Widget.h

Go to the documentation of this file.

#pragma once
 
#include "../Layer.h"
#include "../Geometry/Point.h"
#include "../Input/Keyboard.h"
#include "../Geometry/PointProperty.h"
#include "../Geometry/SizeProperty.h"
 
namespace Gorgon { namespace UI {
 
    class WidgetContainer;
 
    class Widget {
    friend class WidgetContainer;
        //Non-virtual functions for visual studio
 
        void resize(const Geometry::Size &size) {
            Resize(size);
        }
 
        Geometry::Size getsize() const {
            return GetSize();
        }
 
        void move(const Geometry::Point &value) {
            Move(value);
        }
 
        Geometry::Point getlocation() const {
            return GetLocation();
        }
    public:
        
        Widget() : Location(this), Size(this) {
        }
        
        Widget(Widget &&) = default;
        
        virtual ~Widget() { }
        
        void Move(int x, int y) { Move({x, y}); }
        
        virtual void Move(const Geometry::Point &location) = 0;
 
        virtual Geometry::Point GetLocation() const = 0;
 
        virtual void Resize(int w, int h) { Resize({w, h}); };
 
        virtual void Resize(const Geometry::Size &size) = 0;
 
        virtual Geometry::Size GetSize() const = 0;
        
        Geometry::Bounds GetBounds() const { return {GetLocation(), GetSize()}; }
        
        int GetWidth() const { return GetSize().Width; }
        
        int GetHeight() const { return GetSize().Height; }
        
        void SetWidth(int width) { Resize(width, GetHeight()); }
        
        void SetHeight(int height) { Resize(GetWidth(), height); }
        
        virtual bool Activate() = 0;
 
        bool Remove();
        
        bool AllowFocus() const { return allowfocus() && visible; }
        
        bool Focus();
        
        bool Defocus();
        
        bool IsFocused() const { return focus; }
        
        void Show() { SetVisible(true); }
        
        void Hide() { SetVisible(false); }
        
        void ToggleVisible() { SetVisible(!IsVisible()); }
        
        void SetVisible(bool value);
        
        bool IsVisible() const {
            return visible;
        }
        
        bool EnsureVisible() const;
 
        void Enable() { SetEnabled(true); }
 
        void Disable() { SetEnabled(false); }
 
        void ToggleEnabled() { SetEnabled(!IsEnabled()); }
 
        virtual void SetEnabled(bool value) = 0;
 
        virtual bool IsEnabled() const = 0;
 
        bool HasParent() const { return parent != nullptr; }
 
        WidgetContainer &GetParent() const;
        
        virtual void SetIsFloating(bool value) {
            if(floating != value)
                boundschanged();
                
            floating = value;
        }
        
        bool IsFloating() const {
            return floating;
        }
 
        virtual bool KeyEvent(Input::Key, float) { return false; }
 
        virtual bool CharacterEvent(Char) { return false; }
        
        virtual bool Done() { return true; }
 
        Event<Widget> FocusEvent = Event<Widget>{*this};
 
        Event<Widget> BoundsChangedEvent = Event<Widget>{*this};
        
        Geometry::PointProperty<Widget, &Widget::getlocation, &Widget::move> Location;
        Geometry::SizeProperty<Widget, &Widget::getsize, &Widget::resize> Size;
        
        void setname(std::string value) {
#ifndef NDEBUG
            dbgname = value;
#endif
        }
        
#ifndef NDEBUG
    std::string dbgname;
#endif
 
    protected:
        virtual bool addingto(WidgetContainer &) { return true; }
        
        virtual void addto(Layer &layer) = 0;
 
        virtual void addedto(WidgetContainer &container);
 
        virtual void removefrom(Layer &layer) = 0;
 
        virtual bool removingfrom() { return true; }
 
        virtual void removed();
 
        virtual void setlayerorder(Layer &layer, int order) = 0;
 
        virtual bool allowfocus() const { return true; }
        
        virtual void focused();
        
        virtual bool canloosefocus() const { return true; }
        
        virtual void focuslost();
        
        virtual void boundschanged();
        
        virtual void displaced() { }
 
        virtual void parentenabledchanged(bool state) { }
        
    private:
        bool visible = true;
        bool enabled = true;
        bool focus   = false;
        bool floating= false;
        
        virtual void hide() = 0;
        
        virtual void show() = 0;
        
        WidgetContainer *parent = nullptr;
    };
    
    
} }