WidgetContainer.h

Go to the documentation of this file.

#pragma once
 
#include <stdexcept>
 
#include "Widget.h"
#include "../Layer.h"
#include "../Input/Keyboard.h"
#include "Organizers/Base.h"
 
namespace Gorgon { namespace UI {
    
    class WidgetContainer;
    
    struct ExtenderRequestResponse {
        bool Transformed = false;
        
        WidgetContainer *Extender = nullptr;
        
        Geometry::Point CoordinatesInExtender = {0, 0};
        
        Geometry::Size TotalSize = {0, 0};
    };
    
    class WidgetContainer {
        friend class Widget;
    public:
        enum FocusStrategy {
            Inherit,
 
            AllowAll,
 
            Selective,
 
            Strict,
 
            Deny
        };
 
        WidgetContainer() = default;
        
        WidgetContainer(WidgetContainer &&) = default;
        
        virtual ~WidgetContainer();
        
        WidgetContainer &operator=(WidgetContainer&&) = default;
 
        bool Add(Widget &widget);
 
        bool Insert(Widget &widget, int index);
 
        bool Remove(Widget &widget);
 
        void ForceRemove(Widget &widget);
 
        void ChangeFocusOrder(Widget &widget, int order);
 
        int GetFocusOrder(const Widget &widget) const;
 
        void ChangeZorder(Widget &widget, int order);
        
        bool FocusFirst();
 
        bool FocusNext();
 
        bool FocusNext(int after);
 
        bool FocusNext(const Widget &widget) { return FocusNext(GetFocusOrder(widget)); }
 
        bool FocusLast() { return FocusPrevious(widgets.GetSize()); }
 
        bool FocusPrevious() { return FocusPrevious(focusindex); }
 
        bool FocusPrevious(const Widget& widget) { return FocusNext(GetFocusOrder(widget)); }
 
        bool FocusPrevious(int before);
 
        bool SetFocusTo(Widget &widget);
        
        bool RemoveFocus();
        
        void ForceRemoveFocus();
 
        bool HasFocusedWidget() const { return focusindex != -1; }
 
        Widget &GetFocus() const;
        
        virtual bool EnsureVisible(const Widget &widget) = 0;
        
        virtual bool IsVisible() const = 0;
        
        virtual bool IsEnabled() const { return isenabled; }
        
        void Enable() {
            SetEnabled(true);
        }
        
        void Disable() {
            SetEnabled(false);
        }
        
        void ToggleEnabled() { 
            SetEnabled(!IsEnabled());
        }
        
        virtual void SetEnabled(bool value) {
            if(value != isenabled) {
                isenabled = value;
                distributeparentenabled(value);
            }
        }
        
        virtual Geometry::Size GetInteriorSize() const = 0;
        
        virtual bool ResizeInterior(Geometry::Size size) = 0;
        
        virtual bool IsTabSwitchEnabled() const { return tabswitch; }
        
        void EnableTabSwitch() { SetTabSwitchEnabledState(true); }
        
        void DisableTabSwitch() { SetTabSwitchEnabledState(false); }
        
        void ToggleTabSwitchEnabledState() { tabswitch=!tabswitch; }
        
        virtual void SetTabSwitchEnabledState(bool state) { tabswitch = state; }
        
        auto begin() {
            return widgets.begin();
        }
        
        auto begin() const {
            return widgets.begin();
        }
        
        auto end() {
            return widgets.end();
        }
        
        auto end() const {
            return widgets.end();
        }
        
        int GetCount() const {
            return (int)widgets.GetCount();
        }
        
        const Widget &operator [](int ind) const {
            return widgets[ind];
        }
        
        Widget &operator [](int ind) {
            return widgets[ind];
        }
        
        virtual Widget &GetDefault() const {
            if(!def) 
                throw std::runtime_error("Container does not have a default");
            
            return *def; 
        }
        
        virtual bool HasDefault() const { return def!=nullptr; }
        
        virtual void SetDefault(Widget &widget) { def=&widget; }
        
        virtual void RemoveDefault() { def=nullptr; }
        
        virtual Widget &GetCancel() const { 
            if(!def) 
                throw std::runtime_error("Container does not have a default");
            
            return *cancel; 
        }
        
        virtual bool HasCancel() const { return cancel!=nullptr; }
        
        virtual void SetCancel(Widget &widget) { cancel=&widget; }
        
        virtual void RemoveCancel() { cancel=nullptr; }
 
        void SetFocusStrategy(FocusStrategy value) {
            focusmode = value;
        }
 
        FocusStrategy GetFocusStrategy() const {
            return focusmode;
        }
 
        FocusStrategy CurrentFocusStrategy() const {
            if(focusmode == Inherit)
                return getparentfocusstrategy();
            else
                return focusmode;
        }
        
        template <class O_, class ...Args_>
        O_ &CreateOrganizer(Args_ &&... args) {
            auto &org = *new O_(std::forward<Args_>(args)...);
            AttachOrganizer(org);
            
            ownorganizer = true;
            
            return org;
        }
        
        void AttachOrganizer(Organizers::Base &organizer);
        
        void RemoveOrganizer();
        
        bool HasOrganizer() const {
            return organizer != nullptr;
        }
        
        Organizers::Base &GetOrganizer() const {
            if(organizer == nullptr) {
                throw std::runtime_error("The container does not have an organizer");
            }
            
            return *organizer;
        }
        
        void Displaced();
 
        virtual bool KeyEvent(Input::Key key, float state) { return distributekeyevent(key, state, true); }
        
        virtual bool CharacterEvent(Char c) { return distributecharevent(c); }
        
        virtual ExtenderRequestResponse RequestExtender(const Gorgon::Layer &self) = 0;
 
    protected:
        Containers::Collection<Widget> widgets;
 
        virtual bool addingwidget(Widget &) { return true; }
 
        virtual void widgetadded(Widget &) { }
 
        virtual bool removingwidget(Widget &) { return true; }
 
        virtual void widgetremoved(Widget &) { }
 
        virtual FocusStrategy getparentfocusstrategy() const {
            return AllowAll;
        }
 
        virtual Layer &getlayer() = 0;
 
        virtual void focuschanged() { }
        
        bool handlestandardkey(Input::Key key);
 
        bool distributekeyevent(Input::Key key, float state, bool handlestandard);
 
        bool distributecharevent(Char c);
 
        void distributeparentenabled(bool state);
 
        virtual void childboundschanged(Widget *source);
 
    private:
        bool isenabled              = true;
        bool tabswitch              = true;
        Widget *def             = nullptr;
        Widget *cancel          = nullptr;
        Widget *focused         = nullptr;
        int focusindex              = -1;
        Organizers::Base *organizer = nullptr;
        bool ownorganizer           = false;
 
        FocusStrategy focusmode = Inherit;
    };
    
} }