widget.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <promeki/namespace.h>
#include <promeki/objectbase.h>
#include <promeki/rect.h>
#include <promeki/size2d.h>
#include <promeki/point.h>
#include <promeki/event.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class Layout;
class KeyEvent;
class MouseEvent;
 
class PaintEvent : public Event {
        public:
                static const Type Paint;
 
                PaintEvent() : Event(Paint) {}
};
 
class ResizeEvent : public Event {
        public:
                static const Type Resize;
 
                ResizeEvent(const Size2Di32 &size) : Event(Resize), _size(size) {}
 
                const Size2Di32 &size() const { return _size; }
 
        private:
                Size2Di32 _size;
};
 
enum FocusPolicy {
        NoFocus,    
        TabFocus,   
        ClickFocus, 
        StrongFocus 
};
 
enum SizePolicy {
        SizeFixed,           
        SizeMinimum,         
        SizeMaximum,         
        SizePreferred,       
        SizeExpanding,       
        SizeMinimumExpanding 
};
 
class Widget : public ObjectBase {
                PROMEKI_OBJECT(Widget, ObjectBase)
        public:
                Widget(ObjectBase *parent = nullptr);
 
                virtual ~Widget();
 
                const Rect2Di32 &geometry() const { return _geometry; }
 
                void setGeometry(const Rect2Di32 &rect);
 
                int x() const { return _geometry.x(); }
 
                int y() const { return _geometry.y(); }
 
                int width() const { return _geometry.width(); }
 
                int height() const { return _geometry.height(); }
 
                Size2Di32 size() const { return Size2Di32(_geometry.width(), _geometry.height()); }
 
                const Size2Di32 &minimumSize() const { return _minimumSize; }
 
                void setMinimumSize(const Size2Di32 &size) { _minimumSize = size; }
 
                const Size2Di32 &maximumSize() const { return _maximumSize; }
 
                void setMaximumSize(const Size2Di32 &size) { _maximumSize = size; }
 
                SizePolicy sizePolicy() const { return _sizePolicy; }
 
                void setSizePolicy(SizePolicy policy) { _sizePolicy = policy; }
 
                bool isVisible() const { return _visible; }
 
                bool isEffectivelyVisible() const;
 
                void show();
 
                void hide();
 
                void setVisible(bool visible);
 
                bool isEnabled() const { return _enabled; }
 
                void setEnabled(bool enabled) { _enabled = enabled; }
 
                FocusPolicy focusPolicy() const { return _focusPolicy; }
 
                void setFocusPolicy(FocusPolicy policy) { _focusPolicy = policy; }
 
                bool hasFocus() const { return _focused; }
 
                void setFocus();
 
                void setFocused(bool focused) { _focused = focused; }
 
                virtual void update();
 
                bool isDirty() const { return _dirty; }
 
                void clearDirty() { _dirty = false; }
 
                Layout *layout() const { return _layout; }
 
                void setLayout(Layout *layout);
 
                Point2Di32 mapToParent(const Point2Di32 &p) const;
 
                Point2Di32 mapFromParent(const Point2Di32 &p) const;
 
                Point2Di32 mapToGlobal(const Point2Di32 &p) const;
 
                Point2Di32 mapFromGlobal(const Point2Di32 &p) const;
 
                virtual Size2Di32 sizeHint() const;
 
                virtual Size2Di32 minimumSizeHint() const;
 
                void sendEvent(Event *e) { event(e); }
 
                PROMEKI_SIGNAL(resized, Size2Di32)
 
                
                PROMEKI_SIGNAL(visibilityChanged, bool)
 
        protected:
                virtual void paintEvent(PaintEvent *e);
 
                virtual void keyPressEvent(KeyEvent *e);
 
                virtual void keyReleaseEvent(KeyEvent *e);
 
                virtual void mouseEvent(MouseEvent *e);
 
                virtual void resizeEvent(ResizeEvent *e);
 
                virtual void focusInEvent(Event *e);
 
                virtual void focusOutEvent(Event *e);
 
                void event(Event *e) override;
 
        private:
                friend class Layout;
 
                Rect2Di32   _geometry;
                Size2Di32   _minimumSize;
                Size2Di32   _maximumSize = Size2Di32(9999, 9999);
                SizePolicy  _sizePolicy = SizePreferred;
                FocusPolicy _focusPolicy = NoFocus;
                bool        _visible = true;
                bool        _enabled = true;
                bool        _focused = false;
                bool        _dirty = true;
                Layout     *_layout = nullptr;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE