Dropdown.h

Go to the documentation of this file.

#pragma once
 
#include "Common.h"
#include "../UI/ComponentStackWidget.h"
#include "../Property.h"
#include "Registry.h"
#include "Listbox.h"
 
namespace Gorgon { namespace Widgets {
    
    template <class T_, void (*TW_)(const T_ &, ListItem &), class L_>
    class DropdownBase : public virtual UI::ComponentStackWidget, protected ListItem
    {
    public:
        using ListType = L_;
        
        template <class ...A_>
        DropdownBase(A_&& ... elms, Registry::TemplateType type = Registry::Dropdown_Regular) :
            DropdownBase(Registry::Active()[type])
        {
            List.Add(std::forward<A_>(elms)...);
        }
        
        explicit DropdownBase(Registry::TemplateType type = Registry::Dropdown_Regular) :
            DropdownBase(Registry::Active()[type])
        { }
        
        explicit DropdownBase(const UI::Template &temp) :
            ComponentStackWidget(temp, {
                {UI::ComponentTemplate::ListTag, {}}
            }),
            ListItem(temp),
            list(this->stack.GetTemplate(UI::ComponentTemplate::ListTag)  ? 
                 *this->stack.GetTemplate(UI::ComponentTemplate::ListTag) :
                 Registry::Active()[Registry::Listbox_Regular]
            ),
            List(list)
        { 
            stack.SetClickEvent([this](auto, auto, auto) {
                Focus();
                Toggle();
            });
            list.SetOverscroll(0.5);
        }
        
        template <class ...A_>
        explicit DropdownBase(const UI::Template &temp, A_&& ... elms) : DropdownBase(temp)
        {
            List.Add(std::forward<A_>(elms)...);
        }
        
    protected:
        ListType list;
        bool opened = false;
        bool refresh = false;
        
    public:
        typename ListType::ListBase &List;
        
        virtual void Refresh() {
            if(opened)
                list.Refresh();
            else
                refresh = true;
        }
        
        void Open() {
            if(!HasParent())
                return;
            if(opened)
                return;
            
            auto res = GetParent().RequestExtender(stack);
            
            if(!res.Extender)
                return;
            
            opened = true;
            
            list.Move(res.CoordinatesInExtender.X, res.CoordinatesInExtender.Y + GetHeight());
            list.SetWidth(GetWidth());
            list.FitHeight(res.TotalSize.Height-list.GetLocation().Y); 
            res.Extender->Add(list);
            
            stack.AddCondition(UI::ComponentCondition::Opened);
            stack.SetFrameEvent(std::bind(&DropdownBase::checkfocus, this));
            
            if(refresh) {
                refresh = false;
                list.Refresh();
            }
        }
        
        void Close() {
            if(!opened)
                return;
            
            opened = false;
            stack.RemoveCondition(UI::ComponentCondition::Opened);
            stack.RemoveFrameEvent();
            list.Remove();
        }
        
        void Toggle() {
            if(opened)
                Close();
            else
                Open();
        }
        
        bool IsOpened() const {
            return opened;
        }
        
        bool IsReversed() const {
            Utils::NotImplemented();
        }
        
    protected:
        virtual void boundschanged() override {
            Close();
        }
        
        virtual void displaced() override {
            Close();
        }
        
        void checkfocus() {
            if(!this->IsFocused())
                Close();
        }
    };
    
    template <class T_, void (*TW_)(const T_ &, ListItem &), class L_>
    class SingleSelectionDropdown : 
        public virtual UI::ComponentStackWidget, 
        public DropdownBase<T_, TW_, L_>
    {
        using Base = DropdownBase<T_, TW_, L_>;
    public:
        
        template <class ...A_>
        SingleSelectionDropdown(A_&& ... elms, Registry::TemplateType type = Registry::Dropdown_Regular) :
            SingleSelectionDropdown(Registry::Active()[type])
        {
            this->list.Add(std::forward<A_>(elms)...);
        }
        
        explicit SingleSelectionDropdown(Registry::TemplateType type = Registry::Dropdown_Regular) :
            SingleSelectionDropdown(Registry::Active()[type])
        { }
        
        explicit SingleSelectionDropdown(const UI::Template &temp) :
            ComponentStackWidget(temp, {
                {UI::ComponentTemplate::ListTag, {}}
            }),
            Base(temp)
        {
            this->list.ChangedEvent.Register([this]() {
                if(this->list.HasSelectedItem()) {
                    TW_(this->list.GetSelectedItem(), *this);
                    this->Close();
                    SelectionChanged(this->list.GetSelectedIndex());
                }
                else {
                    this->SetText("");
                    this->RemoveIcon();
                    SelectionChanged(-1);
                }
            });
        }
        
        template <class ...A_>
        explicit SingleSelectionDropdown(const UI::Template &temp, A_&& ... elms) : SingleSelectionDropdown(temp)
        {
            this->list.Add(std::forward<A_>(elms)...);
        }
        
        virtual void Refresh() override {
            Base::Refresh();
            
            if(this->list.HasSelectedItem()) {
                TW_(this->list.GetSelectedItem(), *this);
            }
            else {
                this->SetText("");
                this->RemoveIcon();
            }
        }
        
        SingleSelectionDropdown &operator =(const T_ &value) {
            this->list.SetSelectedItem(value);
            
            return *this;
        }
        
        void SetSelectedIndex(long index) {
            this->list.SetSelectedIndex(index);
        }
        
        operator const T_ &() const {
            return this->list.GetSelectedItem();
        }
        
        operator T_ &() {
            return this->list.GetSelectedItem();
        }
        
        Event<SingleSelectionDropdown, long> SelectionChanged = Event<SingleSelectionDropdown, long>{this};
    };
    
    
    template <class T_, void (*TW_)(const T_ &, ListItem &) = internal::SetTextUsingFrom<T_, ListItem>>
    using DropdownList = SingleSelectionDropdown<T_, TW_, SimpleListbox<T_, TW_>>;
    
    template <class T_, void (*TW_)(const T_ &, ListItem &) = internal::SetTextUsingFrom<T_, ListItem>>
    using DropdownCollection = SingleSelectionDropdown<T_, TW_, SimpleCollectionbox<T_, TW_>>;
    
} }