widget.h

Go to the documentation of this file.

 
#pragma once
 
#include <promeki/core/namespace.h>
#include <promeki/core/objectbase.h>
#include <promeki/core/rect.h>
#include <promeki/core/size2d.h>
#include <promeki/core/color.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class TuiLayout;
class TuiPainter;
class KeyEvent;
class MouseEvent;
 
class TuiPaintEvent : public Event {
        public:
                static const Type Paint;
                TuiPaintEvent() : Event(Paint) {}
};
 
class TuiResizeEvent : public Event {
        public:
                static const Type Resize;
                TuiResizeEvent(const Size2Di32 &size)
                        : Event(Resize), _size(size) {}
                const Size2Di32 &size() const { return _size; }
        private:
                Size2Di32 _size;
};
 
enum TuiFocusPolicy {
        NoFocus,        
        TabFocus,       
        ClickFocus,     
        StrongFocus     
};
 
enum TuiSizePolicy {
        SizeFixed,              
        SizeMinimum,            
        SizeMaximum,            
        SizePreferred,          
        SizeExpanding,          
        SizeMinimumExpanding    
};
 
class TuiWidget : public ObjectBase {
        PROMEKI_OBJECT(TuiWidget, ObjectBase)
        public:
                TuiWidget(ObjectBase *parent = nullptr);
 
                virtual ~TuiWidget();
 
                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; }
 
                TuiSizePolicy sizePolicy() const { return _sizePolicy; }
 
                void setSizePolicy(TuiSizePolicy 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; }
 
                TuiFocusPolicy focusPolicy() const { return _focusPolicy; }
 
                void setFocusPolicy(TuiFocusPolicy policy) { _focusPolicy = policy; }
 
                bool hasFocus() const { return _focused; }
 
                void setFocus();
 
                void update();
 
                bool isDirty() const { return _dirty; }
 
                void clearDirty() { _dirty = false; }
 
                TuiLayout *layout() const { return _layout; }
 
                void setLayout(TuiLayout *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;
 
                // Signals
                PROMEKI_SIGNAL(resized, Size2Di32)
                PROMEKI_SIGNAL(visibilityChanged, bool)
 
        protected:
                virtual void paintEvent(TuiPaintEvent *e);
 
                virtual void keyEvent(KeyEvent *e);
 
                virtual void mouseEvent(MouseEvent *e);
 
                virtual void resizeEvent(TuiResizeEvent *e);
 
                virtual void focusInEvent(Event *e);
 
                virtual void focusOutEvent(Event *e);
 
                void event(Event *e) override;
 
        private:
                friend class TuiApplication;
 
                Rect2Di32                  _geometry;
                Size2Di32     _minimumSize;
                Size2Di32     _maximumSize = Size2Di32(9999, 9999);
                TuiSizePolicy           _sizePolicy = SizePreferred;
                TuiFocusPolicy          _focusPolicy = NoFocus;
                bool                    _visible = true;
                bool                    _enabled = true;
                bool                    _focused = false;
                bool                    _dirty = true;
                TuiLayout               *_layout = nullptr;
};
 
PROMEKI_NAMESPACE_END