event.hpp

#if !defined(_BTK_EVENT_HPP_)
#define _BTK_EVENT_HPP_
#include <cstdint>
#include <string_view>
#include "locals.hpp"
#include "defs.hpp"
#include "rect.hpp"
union  SDL_Event;
struct SDL_MouseButtonEvent;
namespace Btk{
    class Window;
    class Widget;
    class BTKAPI Event{
        public:
            enum Type:Uint32{
                SetRect = 0,//Update widget's rect
                KeyBoard = 1,//Key pressed or released

                //MotionEvent
                Enter = 2,//Mouse enter Widget 
                Leave = 3,//Mouse leave Widget
                Motion = 4,//Mouse motion in Widget
                //MouseEvent
                Click = 5,//Mouse Click

                DragBegin = 6,//The drag is begin
                Drag = 7,//Is draging now
                DragEnd = 8,//The drag is end
                
                TextInput = 9,//Text the Input


                TakeFocus = 10,//The widget take focus
                               //accept the event to task focus

                LostFocus = 11,//<The widget lost focus
                               //Of course you can refuse it

                Enable = 12,//The widget was enabled
                Disable = 13,//The widget was disabled
                
                Wheel = 14,//The mouse Wheel

                User = 1000,
                UserMax = UINT32_MAX - 1,
                Error = UINT32_MAX
            };
            static Type Register();
            Type type() const noexcept{
                return _type;
            };
        public:
            Event(Type t):
                _type(t),
                _accepted(false){};
            Event(const Event &ev):
                _type(ev._type),
                _accepted(false){};
            virtual ~Event();
            bool is_accepted() const noexcept{
                return _accepted;
            };
            void accept() noexcept{
                _accepted = true;
            };
            void reject() noexcept{
                _accepted = false;
            };
            void set_type(Type t) noexcept{
                _type = t;
            };
        private:
            //Event type
            Type _type;
            bool _accepted;
        friend class Window;
    };
    class ResizeEvent:public Event{
        
    };    
    struct BTKAPI MouseEvent:public Event{
        MouseEvent():Event(Event::Type::Click){};
        MouseEvent(const MouseEvent &) = default;
        ~MouseEvent();

        bool is_pressed() const noexcept{
            return state == Pressed;
        };
        bool is_released() const noexcept{
            return state == Released;
        };
        bool is_up() const noexcept{
            return state == Pressed;
        };
        bool is_down() const noexcept{
            return state == Released;
        };
        Vec2 position() const noexcept{
            return {x,y};
        };
        enum{
            Pressed,//< Button UP
            Released//< Button Down
        }state;
        struct{
            Uint8 value;
            bool is_right() const noexcept{
                return value == SDL_BUTTON_RIGHT;
            }
            bool is_left() const noexcept{
                return value == SDL_BUTTON_LEFT;
            }
            bool is_middle() const noexcept{
                return value == SDL_BUTTON_MIDDLE;
            }
        }button;
        Uint8 clicks;
        int x;
        int y;
    };
    struct BTKAPI KeyEvent:public Event{
        KeyEvent():Event(Event::Type::KeyBoard){};
        KeyEvent(const KeyEvent &ev) = default;
        ~KeyEvent();
        //Keycode and scancode
        Scancode scancode;
        Keycode  keycode;
        Keymode  keymode;
        enum{
            Pressed,
            Released
        }state;
        bool repeat;//is repeat
        //Check kmode
        bool has_kmod(Keymode mode) const noexcept{
            return static_cast<bool>(keymode & mode);
        }
    };
    struct SetRectEvent:public Event{
        SetRectEvent(const Rect n):
            Event(Type::SetRect),
            rect(n){};
        SetRectEvent(const SetRectEvent &ev) = default;
        ~SetRectEvent();

        Vec2 position() const noexcept{
            return {rect.x,rect.y};
        };

        Rect rect;
    };
    struct BTKAPI MotionEvent:public Event{
        MotionEvent(Event::Type type = Event::Type::Motion):
            Event(type){};
        MotionEvent(const MotionEvent &) = default;
        ~MotionEvent();

        //datas
        int x;
        int y;

        int xrel;
        int yrel;
        //methods
        Vec2 position() const noexcept{
            return {x,y};
        };
    };
    struct BTKAPI TextInputEvent:Event{
        TextInputEvent():Event(TextInput){};
        std::string_view text;//<Text input buffer(utf-8 encoded)
        size_t length() const noexcept;
    };
    struct BTKAPI DragEvent:public Event{
        DragEvent(Event::Type type,int x,int y,int xrel,int yrel):
            Event(type),
            x(x),
            y(y),
            xrel(xrel),
            yrel(yrel){};
        DragEvent(Event::Type type,const MotionEvent &motion):Event(type){
            x = motion.x;
            y = motion.y;
            xrel = motion.xrel;
            yrel = motion.yrel;
        };
        DragEvent(const DragEvent &) = default;
        ~DragEvent();

        int x;
        int y;
        int xrel;//< Note It cannot be used at DragEnd
        int yrel;//< Note It cannot be used at DragEnd
    };
    struct BTKAPI WheelEvent:public Event{
        WheelEvent(Uint32 which,Sint64 x,Sint64 y):Event(Type::Wheel){
            this->which = which;
            this->x = x;
            this->y = y;
        }
        WheelEvent(const WheelEvent &) = default;
        ~WheelEvent();
        Uint32 which;//< Which mouse
        Sint64 x;//< Vertical scroll,postive for scroll right
        Sint64 y;//< Horizontal scroll,postive for scroll up
    };
    typedef MouseEvent ClickEvent;
    void PushEvent(Event *event,Window &receiver);
    void PushEvent(Event *event,Widget &receiver);
    bool SendEvent(Event &event,Window &receiver);
    bool SendEvent(Event &event,Widget &receiver);
    void DispatchEvent(const SDL_Event &ev,void *);
};


#endif // _BTK_EVENT_HPP_