Widget.hpp

Go to the documentation of this file.

#pragma once

#include <vector>
#include <etk/types.hpp>
#include <etk/math/Vector2D.hpp>

#include <ewol/debug.hpp>
#include <ewol/object/Object.hpp>
#include <gale/Dimension.hpp>
#include <gale/context/cursor.hpp>

namespace ewol {
    class Widget;
    namespace widget {
        class Manager;
        class Windows;
    };
    using WidgetShared = ememory::SharedPtr<ewol::Widget>;
    using WidgetWeak = ememory::WeakPtr<ewol::Widget>;
};
#include <gale/context/clipBoard.hpp>
#include <gale/key/key.hpp>
#include <gale/context/cursor.hpp>
#include <ewol/event/Input.hpp>
#include <ewol/event/Entry.hpp>
#include <ewol/event/Time.hpp>
#include <etranslate/etranslate.hpp>
#include <esignal/Signal.hpp>
#include <ewol/DrawProperty.hpp>
#include <ewol/gravity.hpp>

#define ULTIMATE_MAX_SIZE  (99999999)

#define DECLARE_WIDGET_FACTORY(className, name) \
    DECLARE_FACTORY(className); \
    static void createManagerWidget(ewol::widget::Manager& _widgetManager) { \
        _widgetManager.addWidgetCreator(name,   []() -> ewol::WidgetShared { \
                                                    return className::create(); \
                                                }); \
    }

namespace ewol {
    // TODO: change position of this ...
    class EventShortCut {
        public:
            std::string message; 
            gale::key::Special specialKey; 
            char32_t unicodeValue; 
            enum gale::key::keyboard keyboardMoveValue; 
            EventShortCut() {
                message = "";
                unicodeValue = 0;
                keyboardMoveValue = gale::key::keyboard::unknow;
            };
            virtual ~EventShortCut() { };
    };
    class Widget : public ewol::Object {
        public: // signals:
            
        public: // properties:
            eproperty::Value<gale::Dimension> propertyMinSize; 
            eproperty::Value<gale::Dimension> propertyMaxSize; 
            eproperty::Value<bvec2> propertyExpand; 
            eproperty::Value<bvec2> propertyFill; 
            eproperty::Value<bool> propertyHide; 
            eproperty::List<enum ewol::gravity> propertyGravity; 
            eproperty::Value<bool> propertyCanFocus; 
        protected:
            Widget();
        public:
            virtual ~Widget();
        // ----------------------------------------------------------------------------------------------------------------
        // -- Widget size:
        // ----------------------------------------------------------------------------------------------------------------
        protected:
            vec2 m_size; 
            vec2 m_minSize; 
            vec2 m_maxSize; 
        public:
            virtual vec2 relativePosition(const vec2& _pos);
            virtual void onChangeSize();
            virtual void calculateSize() {};
            virtual vec2 getSize();
            virtual void setSize(const vec2& _value) {
                m_size = _value;
            }
            virtual void calculateMinMaxSize();
            virtual vec2 getCalculateMinSize();
            virtual vec2 getCalculateMaxSize();
        protected:
            vec2 m_offset; 
        public:
            virtual void setOffset(const vec2& _newVal);
            virtual const vec2& getOffset() {
                return m_offset;
            };
        protected:
            // internal element calculated by the system
            float m_zoom; 
        public:
            virtual void setZoom(float _newVal);
            virtual float getZoom();
            virtual void changeZoom(float _range) {};
        protected:
            vec2 m_origin; 
        public:
            virtual void setOrigin(const vec2& _pos);
            virtual vec2 getOrigin();
        public:
            void setNoMinSize(); // TODO : Remove ==> default ... of the property
            virtual void checkMinSize();
        protected:
            
        public:
            void setNoMaxSize(); // TODO : Remove ==> default ... of the property
            virtual void checkMaxSize();
        public:
            virtual bvec2 canExpand();
        public:
            const bvec2& canFill();
        // ----------------------------------------------------------------------------------------------------------------
        // -- focus Area
        // ----------------------------------------------------------------------------------------------------------------
        private:
            bool m_hasFocus; 
            
        public:
            virtual bool getFocus() {
                return m_hasFocus;
            };
            virtual bool setFocus();
            virtual bool rmFocus();
            virtual void keepFocus();
        protected:
            virtual void onGetFocus() {};
            virtual void onLostFocus() {};
        
        // ----------------------------------------------------------------------------------------------------------------
        // -- Mouse event properties Area
        // ----------------------------------------------------------------------------------------------------------------
        private:
            int32_t m_limitMouseEvent; 
        public:
            virtual int32_t getMouseLimit() {
                return m_limitMouseEvent;
            };
            virtual void setMouseLimit(int32_t _numberState) {
                m_limitMouseEvent = _numberState;
            };
        // ----------------------------------------------------------------------------------------------------------------
        // -- keyboard event properties Area
        // ----------------------------------------------------------------------------------------------------------------
        private:
            bool m_allowRepeateKeyboardEvent; 
        public:
            virtual bool getKeyboardRepeate() {
                return m_allowRepeateKeyboardEvent;
            };
        protected:
            virtual void setKeyboardRepeate(bool _state) {
                m_allowRepeateKeyboardEvent = _state;
            };
            virtual void showKeyboard();
            virtual void hideKeyboard();
        public:
            virtual ewol::WidgetShared getWidgetAtPos(const vec2& _pos) {
                if (propertyHide.get() == false) {
                    return ememory::dynamicPointerCast<ewol::Widget>(sharedFromThis());
                }
                return nullptr;
            };
        
        // event section:
        public:
            virtual bool systemEventInput(ewol::event::InputSystem& _event);
        protected:
            virtual bool onEventInput(const ewol::event::Input& _event) {
                return false;
            };
        public:
            virtual bool systemEventEntry(ewol::event::EntrySystem& _event);
        protected:
            virtual bool onEventEntry(const ewol::event::Entry& _event) {
                return false;
            };
        public:
            virtual void onEventClipboard(enum gale::context::clipBoard::clipboardListe _clipboardID) { };
        
        // ----------------------------------------------------------------------------------------------------------------
        // -- Shortcut : management of the shortcut
        // ----------------------------------------------------------------------------------------------------------------
        public:
            esignal::Signal<std::string> signalShortcut; 
        private:
            std::vector<EventShortCut*> m_localShortcut; 
        protected:
            virtual void shortCutAdd(const std::string& _descriptiveString,
                                     const std::string& _message="");
            virtual void shortCutClean();
            virtual void shortCutRemove(const std::string& _message);
        public:
            virtual bool onEventShortCut(const gale::key::Special& _special,
                                         char32_t _unicodeValue,
                                         enum gale::key::keyboard _kbMove,
                                         bool _isDown);
        // ----------------------------------------------------------------------------------------------------------------
        // -- drawing : All drawing must be done in 2 separate buffer 1 for the current display and 1 for the working...
        // ----------------------------------------------------------------------------------------------------------------
        protected:
            bool m_needRegenerateDisplay; 

            virtual void markToRedraw();
            virtual bool needRedraw() {
                bool tmpData = m_needRegenerateDisplay;
                m_needRegenerateDisplay = false;
                return tmpData;
            };
        public:
            virtual void systemDraw(const DrawProperty& _displayProp);
        protected:
            virtual void onDraw() { };
        public:
            virtual void onRegenerateDisplay() { };
        // grab cursor mode
        private:
            bool m_grabCursor;
        public:
            virtual void grabCursor();
            virtual void unGrabCursor();
            virtual bool getGrabStatus();
        private:
            enum gale::context::cursor m_cursorDisplay;
        public:
            virtual void setCursor(enum gale::context::cursor _newCursor);
            virtual enum gale::context::cursor getCursor();
        public:
            virtual bool loadXML(const exml::Element& _node) override;
        public:
            void requestUpdateSize();
            ewol::widget::Manager& getWidgetManager();
            ememory::SharedPtr<ewol::widget::Windows> getWindows();
        /*
         * Annimation section :
         */
        public:
            // event generated :
            esignal::Signal<> signalAnnimationStart; 
            esignal::Signal<float> signalAnnimationRatio; 
            esignal::Signal<> signalAnnimationStop;  
        protected:
            enum annimationMode {
                annimationModeEnableAdd,
                annimationModeEnableRemove,
                annimationModeDisable
            };
            enum annimationMode m_annimationMode; 
            float m_annimationratio; 
        protected:
            eproperty::List<int32_t> propertyAnnimationTypeStart; 
            eproperty::Range<float> propertyAnnimationTimeStart; 
            eproperty::List<int32_t> propertyAnnimationTypeStop; 
            eproperty::Range<float> propertyAnnimationTimeStop; 
        protected:
            void addAnnimationType(enum ewol::Widget::annimationMode _mode, const char* _type);
        public:
            void setAnnimationType(enum ewol::Widget::annimationMode _mode, const std::string& _type);
            void setAnnimationTime(enum ewol::Widget::annimationMode _mode, float _time);
            bool startAnnimation(enum ewol::Widget::annimationMode _mode);
            bool stopAnnimation();
        protected:
            virtual bool onStartAnnimation(enum ewol::Widget::annimationMode _mode) {
                return false;
            };
            virtual void onStopAnnimation() { };
        protected:
            virtual void onChangePropertyCanFocus();
            virtual void onChangePropertyGravity();
            virtual void onChangePropertyHide();
            virtual void onChangePropertyFill();
            virtual void onChangePropertyExpand();
            virtual void onChangePropertyMaxSize();
            virtual void onChangePropertyMinSize();
    };
};

#include <ewol/widget/Manager.hpp>