Listbox.h

Go to the documentation of this file.

#pragma once
 
 
#include "Common.h"
#include "../UI/ComponentStackWidget.h"
#include "../Property.h"
#include "../Input/KeyRepeater.h"
#include "Registry.h"
#include "ListItem.h"
#include <vector>
#include "Scrollbar.h"
 
namespace Gorgon { namespace Widgets {
    
    template<class T_, class W_>
    class ListBase {
    public:
        virtual ~ListBase() {
        }
        
        virtual T_ &operator[](long index) = 0;
 
        virtual const T_ &operator[](long index) const = 0;
        
        virtual long GetCount() const = 0;
        
        virtual long getindex(const W_ &widget) = 0;
        
        virtual void Refresh() = 0;
        
    protected:
 
        virtual W_ *getrepresentation(long index) = 0;
        
        virtual W_ *getrepresentation() = 0;
        
    };
    
    namespace internal { 
        template <class T_, class W_, class F_>
        class LBTRF_blank {
        protected:
            LBTRF_blank() { }
            ~LBTRF_blank() { }
            
            void apply(long, W_ &, const T_ &, Geometry::Point p, Geometry::Size) { }
            
            UI::ComponentTemplate::Tag tag(long, const T_ &, Geometry::Point, Geometry::Size) {
                return UI::ComponentTemplate::ItemTag;
            }
            
            void prepare(W_ &) { }
            void insert(long, long) { }
            void move(long, long) { }
            void remove(long, long) { }
        }; 
        
        template <class T_, class W_, class F_>
        class LBTRF_ListItem {
        public:
            
            void SetOddEven(bool value) {
                if(oddeven == value)
                    return;
                
                oddeven = value;
                dynamic_cast<F_*>(this)->Refresh();
            }
            
            bool GetOddEven() const {
                return oddeven;
            }
            
        protected:
            LBTRF_ListItem() { }
            ~LBTRF_ListItem() { }
            
            void apply(long, W_ &w, const T_ &, Geometry::Point p, Geometry::Size) { 
                if(oddeven) {
                    w.SetParity(p.Y%2 ? Parity::Odd : Parity::Even);
                }
                else {
                    w.SetParity(Parity::None);
                }
            }
            
            UI::ComponentTemplate::Tag tag(long, const T_ &, Geometry::Point, Geometry::Size) {
                return UI::ComponentTemplate::ItemTag;
            }
            
            void prepare(W_ &) { }
            void insert(long, long) { }
            void move(long, long) { }
            void remove(long, long) { }
            
            bool oddeven = true;
        };
        
        template<class T_, class W_>
        void SetTextUsingFrom(const T_ &val, W_ &w) {
            w.SetText(String::From(val));
        }
        
        template<class T_, class W_, class F_, F_ f>
        void SetTextUsingFn(const T_ &val, W_ &w) {
            w.SetText(f(val));
        }
        
        template<class T_, class W_>
        void GetTextUsingTo(W_ &w, T_ &val) {
            val = String::To<T_>(w.GetText());
        }
        
        //This class allows single selection. The selected item will
        //follow the focus by default. If desired, this can be changed
        template<class T_, class W_, class F_>
        class LBSELTR_Single {
        public:
            bool HasSelectedItem() const {
                return selectedindex != -1;
            }
            
            const T_ &GetSelectedItem() const {
                if(selectedindex == -1)
                    throw std::runtime_error("Nothing is selected.");
                
                return dynamic_cast<const F_&>(*this)[selectedindex];
            }
            
            T_ &GetSelectedItem() {
                if(selectedindex == -1)
                    throw std::runtime_error("Nothing is selected.");
                
                return dynamic_cast<F_&>(*this)[selectedindex];
            }
            
            long GetSelectedIndex() const {
                return selectedindex;
            }
            
            void SetSelectedIndex(long index) {
                if(index < -1 || index >= dynamic_cast<F_&>(*this).GetCount())
                    throw std::out_of_range("Selected index does not exits");
                
                if(index == selectedindex)
                    return;
                
                if(focusonly) {
                    if(index == -1) {
                        W_ *elm = dynamic_cast<F_&>(*this).getrepresentation();
                        if(elm != nullptr && elm->HasParent()) {
                            elm->GetParent().RemoveFocus();
                        }
                    }
                    else {
                        W_ *elm = dynamic_cast<F_&>(*this).getrepresentation(index);
                        if(elm != nullptr) {
                            elm->Focus();
                        }
                        else {
                            elm = dynamic_cast<F_&>(*this).getrepresentation();
                            
                            if(elm != nullptr && elm->HasParent()) {
                                elm->GetParent().RemoveFocus();
                            }
                        }
                    }
                    
                    focusindex = index;
                }
                
                if(selected)
                    selected->SetSelected(false);
                
                if(index != -1) {
                    W_ *elm = dynamic_cast<F_&>(*this).getrepresentation(index);
                    
                    if(elm)
                        elm->SetSelected(true);
                    
                    selected = elm;
                }
                
                selectedindex = index;
                ChangedEvent(selectedindex);
            }
 
            void SetFocusIndex(long value) {
                if(focusindex == value)
                    return;
                
                if(focusonly) {
                    SetSelectedIndex(value);
                    return;
                }
                
                if(value != -1) {
                    auto w = dynamic_cast<F_*>(this)->getrepresentation(value);
                    if(w)
                        w->Focus();
                }
                else {
                    auto w = dynamic_cast<F_*>(this)->getrepresentation(focusindex);
                    if(w)
                        w->Defocus();
                }
                
                focusindex = value;
            }
            
            long GetFocusIndex() const {
                return focusindex;
            }
            
            void RemoveSelection() {
                SetSelectedIndex(-1);
            }
            
            void SetSelection(T_ item) {
                auto &me = dynamic_cast<F_&>(*this);
                
                for(long i=0; i<me.GetSize(); i++) {
                    if(me[i] == item) {
                        SetSelectedIndex(i);
                        return;
                    }
                }
                
                SetSelectedIndex(-1);
            }
            
            bool IsSelectionFollowingFocus() const {
                return focusonly;
            }
            
            void SetSelectionFollowsFocus(bool value) {
                if(!focusonly && value) {
                    if(focusindex != -1) {
                        if(selectedindex != focusindex) {
                            selectedindex = focusindex;
                            ChangedEvent(selectedindex);
                        }
                    }
                    else {
                        focusindex = selectedindex;
                    }
                }
                
                focusonly = value;
            }
            
            operator T_() {
                return GetSelectedItem();
            }
            
            operator T_() const {
                return GetSelectedItem();
            }
            
            Event<LBSELTR_Single, long> ChangedEvent = Event<LBSELTR_Single, long>{this};
            
        protected:
            LBSELTR_Single() {
            }
            
            virtual ~LBSELTR_Single() { }
            
            void sel_clicked(long index, W_ &w) {
                if(focusonly) {
                    if(selectedindex == index)
                        return;
                    
                    if(selected)
                        selected->SetSelected(false);
                    
                    w.SetSelected(true);
                    
                    if(dynamic_cast<UI::Widget*>(this)->IsFocused())
                        w.Focus();
                    
                    selected = &w;
                    selectedindex = index;
                    focusindex    = index;
                    
                    ChangedEvent(index);
                }
                else {
                    if(focusindex == index)
                        return;
                    
                    if(dynamic_cast<UI::Widget*>(this)->IsFocused())
                        w.Focus();
                    
                    focusindex = index;
                }
                
                dynamic_cast<UI::Widget*>(this)->Focus();
            }
            
            void sel_toggled(long index, W_ &w) {
                if(selectedindex == index || focusonly)
                    return;
                
                if(selected)
                    selected->SetSelected(false);
                
                w.SetSelected(true);
                selectedindex = index;
                selected = &w;
                
                if(focusonly) {
                    if(dynamic_cast<UI::Widget*>(this)->IsFocused())
                        w.Focus();
                    
                    focusindex = index;
                }
                
                ChangedEvent(index);
            }
            
            void sel_apply(long index, W_ &w, const T_ &) {
                if(index == focusindex) {
                    w.Focus();
                }
                else if(w.IsFocused()) {
                    w.Defocus();
                }
                
                if(index == selectedindex) {
                    w.SetSelected(true);
                    selected = &w;
                }
                else {
                    w.SetSelected(false);
                    
                    if(&w == selected)
                        selected = nullptr;
                }
            }
            
            void sel_prepare(W_ &w) {
                w.ClickEvent.Register([&w, this] {
                    sel_clicked(dynamic_cast<F_*>(this)->getindex(w), w);
                });
                w.ToggleEvent.Register([&w, this] {
                    sel_toggled(dynamic_cast<F_*>(this)->getindex(w), w);
                });
            }
            
            void sel_insert(long index, long count) { 
                if(index <= focusindex)
                    focusindex += count;
                
                if(index <= selectedindex)
                    selectedindex += count;
            }
            
            void sel_move(long index, long target) { 
                //move triggers apply to both indexes
                
                if(index == focusindex) {
                    focusindex = target;
                }
                else if(index > focusindex && target <= focusindex) {
                    focusindex++;
                }
                else if(index < focusindex && target > focusindex) {
                    focusindex--;
                }
                
                if(index == selectedindex) {
                    selectedindex = target;
                }
                else if(index > selectedindex && target <= selectedindex) {
                    selectedindex++;
                }
                else if(index < selectedindex && target > selectedindex) {
                    selectedindex--;
                }
            }
            
            void sel_remove(long index, long count) { 
                //removed items will be repurposed using apply,
                if(index <= focusindex) {
                    if(index+count > focusindex) {
                        focusindex = -1;
                        ChangedEvent(-1);
                    }
                    else {
                        focusindex -= count;
                    }
                }
                
                if(index <= selectedindex) {
                    if(index+count > selectedindex) {
                        selectedindex = -1;
                        ChangedEvent(-1);
                    }
                    else {
                        selectedindex -= count;
                    }
                }
            }
            
            void sel_destroy(W_ &w) {
                if(&w == selected) {
                    selected = nullptr;
                }
                if(w.IsFocused()) {
                    focusindex = -1;
                    w.Defocus();
                }
            }
            
            void reapplyfocus() {
                if(focusindex != -1) {
                    auto w = dynamic_cast<F_*>(this)->getrepresentation(focusindex);
                    if(w)
                        w->Focus();
                }
            }
            
            bool focusonly = true;
            
            long focusindex = -1, selectedindex = -1;
            
            W_ *selected = nullptr;
        };
        
        //This class allows single selection. The selected item will
        //follow the focus by default. If desired, this can be changed
        template<class T_, class W_, class F_>
        class LBSELTR_Multi {
            template <class F1_> friend class ItemIterator_;
            friend class SelectionHelper;
 
            class SelectionIndexHelper {
            public:
                SelectionIndexHelper(const std::vector<long> &v) : v(v) {
                }
                
                auto begin() {
                    return v.begin();
                }
                
                auto end() {
                    return v.end();
                }
                
            private:
                const std::vector<long> &v;
            };
 
            class SelectionHelper {
            public:
                SelectionHelper(LBSELTR_Multi &l) : l(l) {
                }
 
                auto begin() {
                    auto &me = dynamic_cast<F_ &>(l);
                    return ItemIterator(me, l.selected, 0);
                }
 
                auto end() {
                    auto &me = dynamic_cast<F_ &>(l);
                    return ItemIterator(me, l.selected, l.selected.size());
                }
 
                auto begin() const {
                    auto &me = dynamic_cast<F_ &>(l);
                    return ConstItemIterator(me, l.selected, 0);
                }
 
                auto end() const {
                    auto &me = dynamic_cast<F_ &>(l);
                    return ConstItemIterator(me, l.selected, l.selected.size());
                }
 
            private:
                LBSELTR_Multi &l;
            };
 
 
            template <class O_, class F1_>
            class ItemIterator_ : public Containers::Iterator<ItemIterator_<O_, F1_>, O_> {
                friend class SelectionHelper;
                friend class ConstItemIterator;
                friend class Containers::Iterator<ItemIterator_<O_, F1_>, O_>;
            public:
                ItemIterator_(): list(NULL), offset(-1) {
                }
                ItemIterator_(const ItemIterator_ &it): list(it.list), offset(it.offset) {
                }
 
            protected:
                ItemIterator_(F1_ &list, const std::vector<long> &inds, long offset = 0): list(&list), offset(offset), inds(&inds) {
                }
 
                O_ &current() const {
                    if(!isvalid())
                        throw std::out_of_range("Iterator is not valid.");
 
                    return (*list)[(*inds)[offset]];
                }
 
                bool isvalid() const {
                    return list && inds && offset>=0 && offset<(inds->size());
                }
 
                bool moveby(long amount) {
                    //sanity check
                    if(amount==0)  return isvalid();
 
                    offset += amount;
 
                    return isvalid();
                }
 
                bool compare(const ItemIterator_ &it) const {
                    if(!it.isvalid() && !isvalid()) return true;
                    return it.offset==offset;
                }
 
                void set(const ItemIterator_ &it) {
                    list = it.list;
                    offset = it.offset;
                }
 
                long distance(const ItemIterator_ &it) const {
                    return it.offset-offset;
                }
 
                bool isbefore(const ItemIterator_ &it) const {
                    return offset<it.offset;
                }
 
                F1_ *list = nullptr;
                long offset = 0;
                const std::vector<long> *inds = nullptr;
            };
        public:
            typedef ItemIterator_<T_, F_> ItemIterator;
 
            class ConstItemIterator : public ItemIterator_<const T_, const F_> {
                friend class SelectionHelper;
                friend class Containers::Iterator<ItemIterator_<const T_, const F_>, T_>;
 
            public:
                ConstItemIterator(const ItemIterator &it) {
                    this->list = it.list;
                    this->offset = it.offset;
                }
 
            private:
                ConstItemIterator(const F_ &c, const std::vector<long> &inds, long offset = 0): ItemIterator_<const T_, const F_>(c, inds, offset) {
                }
            };
 
            enum SelectionMethod {
                Toggle,
 
                UseCtrl,
            };
            
            enum EventMethod {
                Once,
                
                ForEachItem
            };
            
            void SetSelectionMethod(SelectionMethod value) {
                method = value;
            }
            
            SelectionMethod GetSelectionMethod() const {
                return method;
            }
            
            void SetEventMethod(EventMethod value) {
                event = value;
            }
            
            EventMethod GetEventMethod() const {
                return event;
            }
            
            long GetFocusIndex() const {
                return focusindex;
            }
            
            void SetFocusIndex(long value) {
                if(focusindex == value)
                    return;
                
                if(value != -1) {
                    auto w = dynamic_cast<F_*>(this)->getrepresentation(value);
                    if(w)
                        w->Focus();
                }
                else {
                    auto w = dynamic_cast<F_*>(this)->getrepresentation(focusindex);
                    if(w)
                        w->Defocus();
                }
                
                focusindex = value;
            }
            
            void ClearSelection() {
                if(event == Once) {
                    selected.clear();
                    ChangedEvent(-1, false);
                }
                else {
                    std::vector<long> old;
                    std::swap(old, selected);
                    
                    for(auto ind : old) {
                        ChangedEvent(ind, false);
                    }
                }
                
                dynamic_cast<F_*>(this)->Refresh();
            }
            
            void SetSelection(long ind) {
                SetSelection(std::vector<long>{ind});
            };
            
            void SetSelection(std::vector<long> indices) {
                if(event == ForEachItem)
                    ClearSelection();
                
                selected = std::move(indices);
                std::sort(selected.begin(), selected.end());
                
                //ensure nothing is duplicated
                selected.erase(std::unique(selected.begin(), selected.end()), selected.end());
                
                if(event == ForEachItem) {
                    for(auto ind : selected) {
                        ChangedEvent(ind, true);
                    }
                }
                else {
                    ChangedEvent(-1, false);
                }
                
                dynamic_cast<F_*>(this)->Refresh();
            };
            
            template<class ...P_>
            void SetSelection(P_&&... elms) {
                SetSelection({elms...});
            }
            
            void AddToSelection(long ind) {
                AddToSelection(std::vector<long>{ind});
            };
            
            void AddToSelection(std::vector<long> indices) {
                std::sort(indices.begin(), indices.end());
                
                selected.resize(selected.size() + indices.size());
                auto sel = selected.rbegin();
                auto cur = selected.rbegin() + indices.size();
                auto ind = indices.rbegin();
                
                while(ind != indices.rend()) {
                    if(cur == selected.rend() || *cur < *ind) {
                        *sel = *ind;
                        
                        if(event == ForEachItem)
                            ChangedEvent(*ind, true);
                        
                        ++ind;
                    }
                    else {
                        *sel = *cur;
                        ++cur;
                    }
                    ++sel;
                }
                
                //ensure nothing is duplicated
                selected.erase(std::unique(selected.begin(), selected.end()), selected.end());
                
                if(event == Once) {
                    ChangedEvent(-1, false);
                }
                
                dynamic_cast<F_*>(this)->Refresh();
            };
            
            template<class ...P_>
            void AddToSelection(P_&&... elms) {
                AddToSelection({elms...});
            }
            
            bool IsSelected(long index) const {
                return std::binary_search(selected.begin(), selected.end(), index);
            }
            
            long GetSelectionCount() const {
                return long(selected.size());
            }
            
            void RemoveFromSelection(long index) {
                auto item = std::lower_bound(selected.begin(), selected.end(), index);
                
                if(item != selected.end() && *item == index) {
                    selected.erase(item);
                    ChangedEvent(index, false);
                }
                
                dynamic_cast<F_*>(this)->Refresh();
            }
            
            void SelectAll() {
                auto elms = dynamic_cast<F_*>(this)->GetCount();
                
                std::vector<long> old;
                old.reserve(elms);
                
                std::swap(old, selected);
                
                auto sel = old.begin();
                for(int i=0; i<elms; i++) {
                    if(sel != old.end() && *sel == i)
                        ++sel;
                    else if(event == ForEachItem)
                        ChangedEvent(i, true);
                        
                    selected.push_back(i);
                }
                
                if(event == Once)
                    ChangedEvent(-1, false);
                
                
                dynamic_cast<F_*>(this)->Refresh();
            }
            
            void InvertSelection() {
                std::vector<long> old;
                
                auto elms = dynamic_cast<F_*>(this)->GetCount();
                old.reserve(elms-selected.size());
                
                std::swap(selected, old);
                
                auto sel = old.begin();
                for(int i=0; i<elms; i++) {
                    if(sel != old.end() && *sel == i) {
                        ++sel;
                        
                        if(event == ForEachItem)
                            ChangedEvent(i, false);
                    }
                    else {
                        selected.push_back(i);
                        
                        if(event == ForEachItem)
                            ChangedEvent(i, true);
                    }
                }
                
                if(event == Once)
                    ChangedEvent(-1, false);
                
                dynamic_cast<F_*>(this)->Refresh();
            }
            
            SelectionIndexHelper SelectedIndices;
            
            SelectionHelper Selection;
            
            Event<LBSELTR_Multi, long, bool> ChangedEvent = Event<LBSELTR_Multi, long, bool>{this};
            
        protected:
            LBSELTR_Multi() : 
                SelectedIndices(selected),
                Selection(*this)
            {
            }
            
            virtual ~LBSELTR_Multi() { }
            
            void sel_clicked(long index, W_ &w) {
                if(focusindex == index)
                    return;
                
                if(dynamic_cast<UI::Widget*>(this)->IsFocused())
                    w.Focus();
                
                focusindex = index;
                
                dynamic_cast<UI::Widget*>(this)->Focus();
            }
            
            void sel_toggled(long index, W_ &w, bool forcetoggle = true) {
                if(method == Toggle || forcetoggle) {
                    auto item = std::lower_bound(selected.begin(), selected.end(), index);
                    
                    if(item != selected.end() && *item == index) {
                        w.SetSelected(false);
                        selected.erase(item);
                        
                        ChangedEvent(index, false);
                    }
                    else {
                        w.SetSelected(true);
                        selected.insert(item, index);
                        
                        ChangedEvent(index, true);
                    }
                }
                else {
                    if(Input::Keyboard::CurrentModifier == Input::Keyboard::Modifier::Ctrl) {
                        auto item = std::lower_bound(selected.begin(), selected.end(), index);
                        
                        if(item != selected.end() && *item == index) {
                            w.SetSelected(false);
                            selected.erase(item);
                            
                            ChangedEvent(index, false);
                        }
                        else {
                            w.SetSelected(true);
                            selected.insert(item, index);
                            
                            ChangedEvent(index, true);
                        }
                    }
                    else {
                        SetSelection(index);
                    }
                }
            }
            
            void sel_apply(long index, W_ &w, const T_ &) {
                if(index == focusindex) {
                    w.Focus();
                }
                else if(w.IsFocused()) {
                    w.Defocus();
                }
                
                if(std::binary_search(selected.begin(), selected.end(), index)) {
                    w.SetSelected(true);
                }
                else {
                    w.SetSelected(false);
                }
            }
            
            void sel_prepare(W_ &w) {
                w.ClickEvent.Register([&w, this] {
                    sel_clicked(dynamic_cast<F_*>(this)->getindex(w), w);
                });
                w.ToggleEvent.Register([&w, this] {
                    sel_toggled(dynamic_cast<F_*>(this)->getindex(w), w, false);
                });
            }
            
            void sel_insert(long index, long count) { 
                if(index <= focusindex)
                    focusindex += count;
                
                auto item = std::lower_bound(selected.begin(), selected.end(), index);
                for(; item != selected.end(); ++item) {
                    *item += count;
                }
            }
            
            void sel_move(long index, long target) { 
                if(index == target) 
                    return;
                //move triggers apply to both indexes
                
                if(index == focusindex) {
                    focusindex = target;
                }
                else if(index > focusindex && target <= focusindex) {
                    focusindex++;
                }
                else if(index < focusindex && target > focusindex) {
                    focusindex--;
                }
                
                if(index < target) {
                    auto from = std::lower_bound(selected.begin(), selected.end(), index);
                    auto to = std::lower_bound(selected.begin(), selected.end(), target+1);
                
                    auto shifted = from;
                    
                    if(*from == index)
                        ++shifted;
                    
                    while(from < to) {
                        *from = *shifted - 1;
                        
                        ++from;
                        ++shifted;
                    }
                    
                    if(shifted != from) {
                        *shifted = target;
                    }
                }
                else {
                    auto from = std::lower_bound(selected.begin(), selected.end(), index-1);
                    auto to = std::upper_bound(selected.begin(), selected.end(), target);
                
                    auto shifted = from;
                    
                    if(*from == index)
                        --shifted;
                    
                    while(from > to) {
                        *from = *shifted + 1;
                        
                        --from;
                        --shifted;
                    }
                    
                    if(shifted != from) {
                        *shifted = target;
                    }
                }
            }
            
            void sel_remove(long index, long count) { 
                //removed items will be repurposed using apply,
                if(index <= focusindex) {
                    if(index+count > focusindex) {
                        focusindex = -1;
                    }
                    else {
                        focusindex -= count;
                    }
                }
                
                //move and update items that are after the point of removal
                auto item = std::lower_bound(selected.begin(), selected.end(), index);
                auto shifted = item;
                while(shifted != selected.end()) {
                    if(*item < index+count) {
                        shifted++;
                    }
                    
                    *item = *shifted - count;
                    
                    ++shifted;
                    ++item;
                }
                
                //remove the items to be removed, they are already moved to the end
                if(item != selected.end())
                    selected.erase(item, selected.end());
            }
            
            void sel_destroy(W_ &w) {
                if(w.IsFocused()) {
                    focusindex = -1;
                    w.Defocus();
                }
            }
            
            void reapplyfocus() {
                if(focusindex != -1) {
                    auto w = dynamic_cast<F_*>(this)->getrepresentation(focusindex);
                    if(w)
                        w->Focus();
                }
            }
            
            long focusindex = -1;
            std::vector<long> selected; //this list will be kept sorted
            SelectionMethod method = Toggle;
            EventMethod event      = ForEachItem;
        };
        
        template<class T_, class W_, class S_, class F_>
        class LBSTR_STLVector {
        public:
            using Storage = S_;
            
            void Add(T_ val) {
                storage.push_back(val);
                
                dynamic_cast<F_*>(this)->Refresh();
            }
            
            template<class... A_>
            void Add(T_ val, A_&& ...rest) {
                storage.push_back(val);
                
                Add(std::forward<A_>(rest)...);
            }
            
            void Insert(long before, T_ val) {
                if(before == -1) {
                    Add(val);
                    return;
                }
                
                storage.insert(storage.begin()+before, val);
                
                dynamic_cast<F_*>(this)->sel_insert(before, 1);
                dynamic_cast<F_*>(this)->Refresh();
            }
            
            template<class... A_>
            void Insert(long before, T_ val, A_&& ...rest) {
                if(before == -1) {
                    Add(val, rest...);
                    return;
                }
                
                //TODO optimize
                Insert(std::forward<A_>(rest)...);
                
                storage.insert(storage.begin()+before, val);
                dynamic_cast<F_*>(this)->sel_insert(before, 1);
            }
            
            void Remove(long index) {
                storage.erase(storage.begin()+index);
                
                dynamic_cast<F_*>(this)->sel_remove(index, 1);
                dynamic_cast<F_*>(this)->Refresh();
            }
            
            void MoveBefore(long index, long before) {
                if(index==before)
                    return;
 
                if(before >= storage.size() || before == -1) {
                    auto t = storage[index];
 
                    for(unsigned i=index; i<storage.size()-1; i++)
                        storage[i] = storage[i+1];
 
                    storage[storage.size()-1] = t;
                }
                else if(index>before) {
                    auto t = storage[index];
                    for(unsigned i=index; i>before; i--)
                        storage[i] = storage[i-1];
 
                    storage[before]=t;
                }
                else {
                    auto t = storage[index];
                    for(unsigned i=index; i<before; i++)
                        storage[i] = storage[i+1];
 
                    storage[before] = t;
                }
                
                dynamic_cast<F_*>(this)->sel_move(index, before);
                dynamic_cast<F_*>(this)->Refresh();
            }
            
            long Find(const T_ item, long start = 0) {
                auto it = std::find(storage.begin() + start, storage.end(), item);
                if(it == storage.end())
                    return -1;
                else
                    return it-storage.begin();
            }
            
            void Reserve(long amount) {
                storage.reserve(amount);
            }
            
            auto begin() {
                return storage.begin();
            }
            
            auto begin() const {
                return storage.begin();
            }
            
            auto end() {
                return storage.end();
            }
            
            auto end() const {
                return storage.end();
            }
            
        
        protected:
            LBSTR_STLVector() {}
            virtual ~LBSTR_STLVector() {}
            
            long getsize() const {
                return storage.size();
            }
            
            T_ &getelm(long index) {
                return storage[index];
            }
            
            const T_ &getelm(long index) const {
                return storage[index];
            }
            
            Storage storage;
        };
        
        template<class T_, class W_, class F_>
        class LBSTR_Collection {
        public:
            using Storage = Containers::Collection<T_>;
            
            void Add(T_ &val) {
                storage.Push(val);
                
                dynamic_cast<F_*>(this)->Refresh();
            }
            
            template<class... A_>
            T_ &AddNew(A_&& ...args) {
                auto &t = storage.AddNew(args...);
                
                dynamic_cast<F_*>(this)->Refresh();
                
                return t;
            }
            
            template<class... A_>
            void Add(T_ &val, A_& ...rest) {
                storage.Push(val);
                
                Add(std::forward<A_>(rest)...);
            }
            
            void Insert(long before, T_ &val) {
                if(storage.Insert(before, val)) {
                    dynamic_cast<F_*>(this)->sel_insert(before, 1);
                    dynamic_cast<F_*>(this)->Refresh();
                }
            }
            
            void Insert(const T_ &before, T_ &val) {
                Insert(FindLocation(before), val);
            }
            
            template<class... A_>
            T_ &InsertNew(const T_ &before, A_&& ...args) {
                auto &t = storage.InsertNew(FindLocation(before), args...);
                
                dynamic_cast<F_*>(this)->sel_insert(before, 1);
                dynamic_cast<F_*>(this)->Refresh();
                
                return t;
            }
            
            void Remove(long index) {
                storage.Remove(index);
                
                dynamic_cast<F_*>(this)->sel_remove(index, 1);
                dynamic_cast<F_*>(this)->Refresh();
            }
            
            void Remove(const T_ &item) {
                long index = storage.FindLocation(item);
                if(index == -1)
                    return;
                
                storage.Remove(index);
                
                dynamic_cast<F_*>(this)->sel_remove(index, 1);
                dynamic_cast<F_*>(this)->Refresh();
            }
            
            void Delete(const T_ &item) {
                long index = storage.FindLocation(item);
                if(index == -1) {
                    delete &item;
                    
                    return;
                }
                
                storage.Delete(index);
                
                dynamic_cast<F_*>(this)->sel_remove(index, 1);
                dynamic_cast<F_*>(this)->Refresh();
            }
            
            void Delete(long index) {
                storage.Delete(index);
                
                dynamic_cast<F_*>(this)->sel_remove(index, 1);
                dynamic_cast<F_*>(this)->Refresh();
            }
            
            void MoveBefore(long index, long before) {
                if(index==before)
                    return;
                
                storage.MoveBefore(index, before);
                
                dynamic_cast<F_*>(this)->sel_move(index, before);
                dynamic_cast<F_*>(this)->Refresh();
            }
            
            long Find(const T_ &item) {
                return storage.FindLocation(item);
            }
            
            void DeleteAll() {
                auto s = storage.GetSize();
                
                storage.DeleteAll();
                
                dynamic_cast<F_*>(this)->sel_remove(0, s);
                dynamic_cast<F_*>(this)->Refresh();
            }
            
            void Destroy() {
                auto s = storage.GetSize();
                
                storage.Destroy();
                
                dynamic_cast<F_*>(this)->sel_remove(0, s);
                dynamic_cast<F_*>(this)->Refresh();
            }
            
            void Reserve(long amount) {
                storage.Reserve(amount);
            }
            
            auto begin() {
                return storage.begin();
            }
            
            auto begin() const {
                return storage.begin();
            }
            
            auto end() {
                return storage.end();
            }
            
            auto end() const {
                return storage.end();
            }
            
        
        protected:
            LBSTR_Collection() {}
            virtual ~LBSTR_Collection() {}
            
            long getsize() const {
                return storage.GetSize();
            }
            
            T_ &getelm(long index) {
                return storage[index];
            }
            
            const T_ &getelm(long index) const {
                return storage[index];
            }
            
            Storage storage;
        };
    }
    
    template<
        class T_, class W_, class TRF_, 
        class STR_, class SELTR_, 
        bool useisvisible,
        void (*TW_)(const T_ &, W_ &)
    >
    class ListboxBase : 
        public ListBase<T_, W_>, 
        public TRF_, 
        public SELTR_, 
        public STR_ 
    {
    public:
        using SelectionType = SELTR_;
        using TypeTraits    = TRF_;
        using StorageType   = STR_;
        
        virtual T_ &operator[](long index) override {
            return this->getelm(index);
        }
 
        virtual const T_ &operator[](long index) const override {
            return this->getelm(index);
        }
        
        virtual long GetCount() const override {
            return this->STR_::getsize();
        }
        
        
 
    protected:
        ListboxBase()
        { }
    };
    
    template<
        class T_, class W_, class TRF_, 
        class STR_, class SELTR_, 
        bool useisvisible,
        void (*TW_)(const T_ &, W_ &)
    >
    class ListboxWidgetBase : 
        public UI::ComponentStackWidget,
        public ListboxBase<T_, W_, TRF_, STR_, SELTR_, useisvisible, TW_> 
    {
    public:
        using ListBase = ListboxBase<T_, W_, TRF_, STR_, SELTR_, useisvisible, TW_>;
        
        virtual void Refresh() override {
            if(!contents.IsReady())
                return;
 
            auto elms = this->STR_::getsize();
            
            std::map<UI::ComponentTemplate::Tag, int> tagcounts;
            
            //TODO improve performance by rolling
            
            //remove all first
            for(auto &p : widgetlist) {
                p.second->Remove();
            }
            indexes.clear();
            widgetlist.clear();
            
            auto b = stack.TagBounds(UI::ComponentTemplate::ViewPortTag);
            if(b.Width() == 0 || b.Height() == 0)
                b = stack.TagBounds(UI::ComponentTemplate::ContentsTag);
            
            int y = 0;
            long i = int(scrolloffset), c = 0;
            int totalh = 0;
            if(i < 0)
                i = 0;
            while(y < b.Height() && i < elms) {
                auto &v   = this->getelm(i);
                auto  tag = this->tag(i, v, {0, (int)i}, {1, (int)elms});
                
                auto w = getwidget(tag, tagcounts[tag]++);
                
                if(w == nullptr)
                    return;
 
                TW_(v, *w);
                
                contents.Add(*w);
                this->apply(i, *w, v, {0, (int)i}, {1, (int)elms});
                this->sel_apply(i, *w, v);
                
                if(y == 0) {
                    y = -int(std::round(w->GetHeight() * (scrolloffset - int(scrolloffset))));
                }
                
                indexes.insert({w, i});
                widgetlist.insert({i, w});
                
                w->Move(0, y);
                
                //to be moved to resize
                w->SetWidth(b.Width());
                auto advance = w->GetHeight() + stack.GetTemplate().GetSpacing() / 2;
                y += advance;
                totalh += advance;
                i++;
                c++;
            }
                
            if(totalh == 0)
                maxdisplay = 0;
            else
                maxdisplay = b.Height() / (float(totalh) / c);
            
            if(maxdisplay < elms+overscroll && !stack.HasCondition(UI::ComponentCondition::VScroll)) {
                stack.AddCondition(UI::ComponentCondition::VScroll);
                stack.Update(true);
            }
            
            auto scroller = dynamic_cast<VScroller<float>*>(stack.GetWidget(UI::ComponentTemplate::VScrollTag));
            if(scroller) {
                scroller->SetMaximum(elms + overscroll);
                
                scroller->Range = maxdisplay;
                scroller->LargeChange = maxdisplay * 0.8f;
                
                if(scroller->Range >= scroller->Maximum) {
                    stack.RemoveCondition(UI::ComponentCondition::VScroll);
                }
            }
            
            contents.Displaced();
        }
        
        void ScrollTo(float y) { 
            float max = this->STR_::getsize() + overscroll - maxdisplay;
            
            if(y < 0)
                y = 0;
            
            if(y > max)
                y = max;
            
            if(target == y)
                return;
            
            target = y;
            
            if(scrollspeed == 0) {
                scrolloffset = y;
                Refresh();
            }
            else {
                if(!isscrolling) {
                    stack.SetFrameEvent(std::bind(&ListboxWidgetBase::updatescroll, this));
                    isscrolling = true;
                }
            }
            
            auto scroller = dynamic_cast<VScroller<float>*>(stack.GetWidget(UI::ComponentTemplate::VScrollTag));
            if(scroller)
                *scroller = target;
            
            Refresh();
        }
        
        void ScrollBy(float y) {
            ScrollTo(ScrollOffset() + y);
        }
        
        float ScrollOffset() const {
            return scrolloffset;
        }
        
        void SetOverscroll(float value) {
            if(overscroll == value)
                return;
            
            overscroll = value;
            
            auto scroller = dynamic_cast<VScroller<float>*>(stack.GetWidget(UI::ComponentTemplate::VScrollTag));
            if(scroller)
                scroller->SetMaximum(this->STR_::getsize() + overscroll);
        }
        
        float GetOverscroll() const {
            return overscroll;
        }
        
        void SetScrollDistance(int vert) {
            scrolldist = vert;
        }
        
        int GetScrollDistance() const {
            return scrolldist;
        }
        
        void DisableSmoothScroll() {
            SetSmoothScrollSpeed(0);
        }
        
        void SetSmoothScrollSpeed(int value) {
            scrollspeed = value;
            
            auto scroller = dynamic_cast<VScroller<float>*>(stack.GetWidget(UI::ComponentTemplate::VScrollTag));
            if(scroller)
                scroller->SetSmoothChangeSpeed(scrollspeed);
            
            auto elms = this->STR_::getsize();
            
            
            stack.SetValueTransitionSpeed({elms > 0 ? float(value)/elms : 0, 0, 0, 0});
        }
        
        int GetSmoothScrollSpeed() const {
            return scrollspeed;
        }
        
        bool IsSmoothScrollEnabled() const {
            return scrollspeed != 0;
        }
        
        float GetMaximumDisplayedElements() const {
            return maxdisplay;
        }
        
        bool FitHeight(int maxpixels) {
            int curh = GetInteriorSize().Height;
            int overhead = GetHeight() - curh;
            int expected = int( std::ceil( (this->GetCount()+overscroll) * (curh/maxdisplay) ) ) + overhead;
            bool smalldone = false;
            
            //will possibly fit
            if(expected < maxpixels) {
                
                do {
                    SetHeight(expected);
                    stack.Update(true);
                    Refresh();
                    
                    auto diff = maxdisplay - (this->GetCount()+overscroll);
                    
                    //it fits everything, might not be tightest but that's ok. We can also eat up a bit of overscroll
                    if(diff < 1 && diff >= -overscroll/2)
                        return true;
                    
                    curh = GetInteriorSize().Height;
                    overhead = GetHeight() - curh;
                    int curexpected = int( std::ceil( (this->GetCount()+overscroll) * (curh/maxdisplay) ) ) + overhead;
                    
                    if(abs(expected - curexpected) == 0) { //no progress, exit
                        break;
                    }
                    else if(abs(expected - curexpected) < 0.1 && smalldone) { //we will allow one small progress, no more
                        break;
                    }
                    else if(abs(expected - curexpected) < 0.1) {
                        smalldone = true;
                    }
                    expected = curexpected;
                } while(expected < maxpixels);
                
            }
            
            SetHeight(maxpixels);
            return false;
        }
        
        Geometry::Size GetInteriorSize() const {
            auto b = stack.TagBounds(UI::ComponentTemplate::ViewPortTag);
            if(b.Width() == 0 || b.Height() == 0)
                b = stack.TagBounds(UI::ComponentTemplate::ContentsTag);
            
            return b.GetSize();
        }
        
        using UI::Widget::EnsureVisible;
        
        void EnsureVisible(long index) {
            float targetind = float(index);
            
            auto md = maxdisplay;
            
            if(targetind >= target && targetind < floor(target + md)) {
                return; //already visible
            }
            else if(targetind >= floor(target + md)) {
                targetind -= md - 1.5; //show the next item a little bit
            }
            else {
                targetind -= 0.5; //show the next item a little bit
            }
            
            auto elms = this->GetCount();
            
            if(targetind < 0)
                targetind = 0;
            if(targetind > overscroll + elms)
                targetind = overscroll + elms;
            
            ScrollTo(targetind);
            
            //if max display changes, call ensure visible again
            if(md != maxdisplay)
                EnsureVisible(index);
        }
        
        bool KeyEvent(Input::Key key, float state) override {
            namespace Keycodes = Input::Keyboard::Keycodes;
            
            if(repeater.KeyEvent(key, state))
                return true;
            
            if(key == Keycodes::Space) {
                if(contents.HasFocusedWidget() && state != 0) {
                    auto w = dynamic_cast<W_*>(&contents.GetFocus());
                    if(w) {
                        this->sel_toggled(indexes.count(w) ? indexes[w] : -1, *w);
                    }
                }
                
                return true;
            }
 
            return false;
        }
        
    protected:
        ListboxWidgetBase(const UI::Template &temp) : 
            ComponentStackWidget(temp, { 
                { UI::ComponentTemplate::ItemTag   , {}},
                { UI::ComponentTemplate::HeaderTag , {}},
                { UI::ComponentTemplate::SpacerTag , {}},
                { UI::ComponentTemplate::VScrollTag, 
                    std::bind(&ListboxWidgetBase::createvscroll, this, std::placeholders::_1)
                }
            })
        {
            stack.HandleMouse();
            
            stack.SetClickEvent([&](auto, auto, auto) {
                Focus();
            });
            
            stack.SetOtherMouseEvent([this](UI::ComponentTemplate::Tag tag, Input::Mouse::EventType type, Geometry::Point, float amount) {
                if(type == Input::Mouse::EventType::Scroll_Vert && stack.HasCondition(UI::ComponentCondition::VScroll)) {
                    ScrollBy(-amount*scrolldist);
                    
                    return true;
                }
                
                return false;
            });
            
            contents.SetLayer(stack.GetLayerOf(stack.IndexOfTag(UI::ComponentTemplate::ContentsTag)));
            stack.AddCondition(UI::ComponentCondition::VScroll);
            
            repeater.Register(Input::Keyboard::Keycodes::Up);
            repeater.Register(Input::Keyboard::Keycodes::Down);
            repeater.Register(Input::Keyboard::Keycodes::PageUp);
            repeater.Register(Input::Keyboard::Keycodes::PageDown);
            
            
            repeater.Repeat.Register([this](Input::Key key) {
                namespace Keycodes = Input::Keyboard::Keycodes;
                using Input::Keyboard::Modifier;
                
                long org = this->GetFocusIndex();
                long ind = org;
                
                switch(key) {
                case Keycodes::Down:
                    ind++;
                    break;
                    
                case Keycodes::Up:
                    ind--;
                    break;
                    
                case Keycodes::PageDown:
                    ind += long(floor(maxdisplay));
                    break;
                    
                case Keycodes::PageUp:
                    ind -= long(floor(maxdisplay));
                    break;
                }
                
                if(ind < 0)
                    ind = 0;
                if(ind >= this->GetCount())
                    ind = this->GetCount() - 1;
                
                if(ind != org) {
                    this->SetFocusIndex(ind);
                    EnsureVisible(ind);
                }
 
            });            
        }
        
        ~ListboxWidgetBase() {
            for(auto &p : widgets) {
                p.second.Destroy();
            }
        }
        
        //this will return the widget with the tag and the order (not index). If the requested
        //widget does not exists, it will be created
        W_ *getwidget(UI::ComponentTemplate::Tag tag, int order) {
            auto temp = stack.GetTemplate(tag);
            
            if(temp == nullptr)
                return nullptr;
            
            auto &ws = widgets[tag];
            
            while(ws.GetSize() <= order) {
                auto &w = ws.AddNew(*temp);
                this->TRF_::prepare(w);
                this->sel_prepare(w);
            }
            
            return &ws[order];
        }
        
        virtual void focused() override {
            ComponentStackWidget::focused();
            this->reapplyfocus();
        }
 
        virtual void focuslost() override {
            ComponentStackWidget::focuslost();
            contents.RemoveFocus();
        }
        
        UI::Widget *createvscroll(const UI::Template &temp) {
            auto vscroller = new VScroller<float>(temp);
            vscroller->Maximum      = this->STR_::getsize();
            vscroller->Range        = 1;
            *vscroller              = scrolloffset;
            vscroller->SmallChange  = scrolldist;
            vscroller->ValueChanged.Register(*this, &ListboxWidgetBase::ScrollTo);
            
            return vscroller;
        }
        
        void updatescroll() {
            if(!isscrolling)
                Utils::ASSERT_FALSE("This should not happen");
            
            auto cur = scrolloffset;
            
            float dist = (float)scrollspeed/1000 * Time::DeltaTime();
            
            bool done = false;
            
            if(target < cur) {
                if(cur - dist <= target) {
                    cur = target;
                }
                else {
                    cur -= dist;
                }
            }
            else if(target > cur) {
                if(cur + dist >= target) {
                    cur = target;
                }
                else {
                    cur += dist;
                }
            }
            else {
                done = true;
            }                
            
            scrolloffset = cur;
            
            Refresh();
            
            if(done) {
                isscrolling = false;
                stack.RemoveFrameEvent();
            }
        }
        
        virtual W_ *getrepresentation(long index) override {
            return widgetlist.count(index) ? widgetlist[index] : nullptr;
        }
        
        virtual W_ *getrepresentation() override {
            return nullptr;
        }
        
        virtual long getindex(const W_ &widget) override {
            return indexes.count(&widget) ? indexes[&widget] : -1;
        }
        
        virtual void boundschanged() override {
            Refresh();
        }
        
        std::map<UI::ComponentTemplate::Tag, Containers::Collection<W_>> widgets;
        std::map<const W_*, long> indexes;
        std::map<long, W_*> widgetlist;
        UI::LayerAdapter contents;
        float scrolloffset = 0.f;
        float target = 0.f;
        float overscroll = 1;
        int scrollspeed = 20;
        int scrolldist  = 5;
        bool isscrolling = false;
        float maxdisplay = 0; //maximum elements that can be displayed
        
        Input::KeyRepeater repeater;
    };
 
    template<class T_, void (*TW_)(const T_ &, ListItem &) = internal::SetTextUsingFrom<T_, ListItem>>
    class SimpleListbox : 
        public ListboxWidgetBase<T_, ListItem, 
            internal::LBTRF_ListItem<T_, ListItem, SimpleListbox<T_, TW_>>,
            internal::LBSTR_STLVector<T_, ListItem, std::vector<T_>, SimpleListbox<T_, TW_>>,
            internal::LBSELTR_Single<T_, ListItem, SimpleListbox<T_, TW_>>,
            false, TW_
        >
    {
        using Base = ListboxWidgetBase<T_, ListItem, 
            internal::LBTRF_ListItem<T_, ListItem, SimpleListbox<T_, TW_>>,
            internal::LBSTR_STLVector<T_, ListItem, std::vector<T_>, SimpleListbox<T_, TW_>>,
            internal::LBSELTR_Single<T_, ListItem, SimpleListbox<T_, TW_>>,
            false, TW_
        >;
        
        friend internal::LBTRF_ListItem<T_, ListItem, SimpleListbox<T_, TW_>>;
        friend internal::LBSTR_STLVector<T_, ListItem, std::vector<T_>, SimpleListbox<T_, TW_>>;
        friend internal::LBSELTR_Single<T_, ListItem, SimpleListbox<T_, TW_>>;
        
    public:
        explicit SimpleListbox(Registry::TemplateType temp = Registry::Listbox_Regular) : Base(Registry::Active()[temp]) {
        }
        
        explicit SimpleListbox(const UI::Template &temp) : Base(temp) {
        }
        
        virtual bool Activate() {
            return false;
        }
        
        SimpleListbox &operator =(const T_ value) {
            this->SetSelection(value);
            
            return *this;
        }
        
        using Base::ComponentStackWidget::Widget::Remove;
        using internal::LBSTR_STLVector<T_, ListItem, std::vector<T_>, SimpleListbox<T_>>::Remove;
    };
    
    template<class T_, void (*TW_)(const T_ &, ListItem &) = internal::SetTextUsingFrom<T_, ListItem>>
    class MultiListbox : 
        public ListboxWidgetBase<T_, ListItem, 
            internal::LBTRF_ListItem<T_, ListItem, MultiListbox<T_, TW_>>,
            internal::LBSTR_STLVector<T_, ListItem, std::vector<T_>, MultiListbox<T_, TW_>>,
            internal::LBSELTR_Multi<T_, ListItem, MultiListbox<T_, TW_>>,
            false, TW_
        >
    {
        using Base = ListboxWidgetBase<T_, ListItem, 
            internal::LBTRF_ListItem<T_, ListItem, MultiListbox<T_, TW_>>,
            internal::LBSTR_STLVector<T_, ListItem, std::vector<T_>, MultiListbox<T_, TW_>>,
            internal::LBSELTR_Multi<T_, ListItem, MultiListbox<T_, TW_>>,
            false, TW_
        >;
        
        friend internal::LBTRF_ListItem<T_, ListItem, MultiListbox<T_, TW_>>;
        friend internal::LBSTR_STLVector<T_, ListItem, std::vector<T_>, MultiListbox<T_, TW_>>;
        friend internal::LBSELTR_Multi<T_, ListItem, MultiListbox<T_, TW_>>;
        
    public:
        explicit MultiListbox(Registry::TemplateType temp = Registry::Listbox_Regular) : Base(Registry::Active()[temp]) {
        }
        
        explicit MultiListbox(const UI::Template &temp) : Base(temp) {
        }
        
        virtual bool Activate() {
            return false;
        }
        
        MultiListbox &operator =(const T_ value) {
            this->SetSelection(value);
            
            return *this;
        }
        
        using Base::ComponentStackWidget::Widget::Remove;
        using internal::LBSTR_STLVector<T_, ListItem, std::vector<T_>, MultiListbox<T_>>::Remove;
    };
    
    template<class T_, void (*TW_)(const T_ &, ListItem &) = internal::SetTextUsingFrom<T_, ListItem>>
    class SimpleCollectionbox : 
        public ListboxWidgetBase<T_, ListItem, 
            internal::LBTRF_ListItem<T_, ListItem, SimpleCollectionbox<T_, TW_>>,
            internal::LBSTR_Collection<T_, ListItem, SimpleCollectionbox<T_, TW_>>,
            internal::LBSELTR_Single<T_, ListItem, SimpleCollectionbox<T_, TW_>>,
            false, TW_
        >
    {
        using Base = ListboxWidgetBase<T_, ListItem, 
            internal::LBTRF_ListItem<T_, ListItem, SimpleCollectionbox<T_, TW_>>,
            internal::LBSTR_Collection<T_, ListItem, SimpleCollectionbox<T_, TW_>>,
            internal::LBSELTR_Single<T_, ListItem, SimpleCollectionbox<T_, TW_>>,
            false, TW_
        >;
        
        friend internal::LBTRF_ListItem<T_, ListItem, SimpleCollectionbox<T_, TW_>>;
        friend internal::LBSTR_Collection<T_, ListItem, SimpleCollectionbox<T_, TW_>>;
        friend internal::LBSELTR_Single<T_, ListItem, SimpleCollectionbox<T_, TW_>>;
        
    public:
        explicit SimpleCollectionbox(Registry::TemplateType temp = Registry::Listbox_Regular) : Base(Registry::Active()[temp]) {
        }
        
        explicit SimpleCollectionbox(const UI::Template &temp) : Base(temp) {
        }
        
        virtual bool Activate() {
            return false;
        }
        
        SimpleCollectionbox &operator =(const T_ value) {
            this->SetSelection(value);
            
            return *this;
        }
        
        using Base::ComponentStackWidget::Widget::Remove;
        using internal::LBSTR_Collection<T_, ListItem, SimpleCollectionbox<T_>>::Remove;
    };
    
    template<class T_, void (*TW_)(const T_ &, ListItem &) = internal::SetTextUsingFrom<T_, ListItem>>
    class MultiCollectionbox : 
        public ListboxWidgetBase<T_, ListItem, 
            internal::LBTRF_ListItem<T_, ListItem, MultiCollectionbox<T_, TW_>>,
            internal::LBSTR_Collection<T_, ListItem, MultiCollectionbox<T_, TW_>>,
            internal::LBSELTR_Multi<T_, ListItem, MultiCollectionbox<T_, TW_>>,
            false, TW_
        >
    {
        using Base = ListboxWidgetBase<T_, ListItem, 
            internal::LBTRF_ListItem<T_, ListItem, MultiCollectionbox<T_, TW_>>,
            internal::LBSTR_Collection<T_, ListItem, MultiCollectionbox<T_, TW_>>,
            internal::LBSELTR_Multi<T_, ListItem, MultiCollectionbox<T_, TW_>>,
            false, TW_
        >;
        
        friend internal::LBTRF_ListItem<T_, ListItem, MultiCollectionbox<T_, TW_>>;
        friend internal::LBSTR_Collection<T_, ListItem, MultiCollectionbox<T_, TW_>>;
        friend internal::LBSELTR_Multi<T_, ListItem, MultiCollectionbox<T_, TW_>>;
        
    public:
        explicit MultiCollectionbox(Registry::TemplateType temp = Registry::Listbox_Regular) : Base(Registry::Active()[temp]) {
        }
        
        explicit MultiCollectionbox(const UI::Template &temp) : Base(temp) {
        }
        
        virtual bool Activate() {
            return false;
        }
        
        MultiCollectionbox &operator =(const T_ value) {
            this->SetSelection(value);
            
            return *this;
        }
        
        using Base::ComponentStackWidget::Widget::Remove;
        using internal::LBSTR_Collection<T_, ListItem, MultiCollectionbox<T_>>::Remove;
    };
    
} }