RadioControl.h

Go to the documentation of this file.

#pragma once
 
#include "TwoStateControl.h"
#include "../Containers/Hashmap.h"
 
namespace Gorgon { namespace UI {
    
    template<class T_ = int, class CT_ = TwoStateControl>
    class RadioControl {
    public:
        RadioControl() : ChangedEvent(this) { }
        
        RadioControl(const RadioControl &) = delete;
        
        explicit RadioControl(std::initializer_list<std::pair<const T_, CT_&>> elm, T_ current = T_()) : 
        ChangedEvent(this),
        elements(elm), 
        current(current) 
        {
            for(auto p : elements) {
                p.second.SetState(false, true);
                reverse.insert({&p.second, p.first});
            }
            
            if(elements.Exists(current)) {
                elements[current].SetState(true, true);
            }
            
            for(auto p : elements) {
                p.second.StateChangingEvent.Register(*this, &RadioControl::changing);
            }
        }
        
        explicit RadioControl(std::initializer_list<std::pair<const T_, CT_*>> elm, T_ current = T_()) : 
        ChangedEvent(this),
        elements(elm), 
        current(current) 
        {
            for(auto p : elements) {
                p.second.SetState(false, true);
                reverse.insert({&p.second, p.first});
            }
            
            if(elements.Exists(current)) {
                elements[current].SetState(true, true);
            }
            
            for(auto p : elements) {
                p.second.StateChangingEvent.Register(*this, &RadioControl::changing);
            }
            
            own = true;
        }
        
        virtual ~RadioControl() {
            if(own)
                elements.DeleteAll();
        }
        
        RadioControl &operator =(const T_ value) {
            Set(value);
        }
        
        operator T_() const {
            return current;
        }
        
        bool Set(const T_ value) {
            if(value == current)
                return true;
            
            clearall();
            
            current = value;
            
            if(elements.Exists(current)) {
                bool state = elements[current].SetState(true, true);
                
                if(state)
                    ChangedEvent(current);
                
                return state;
            }
            
            return false;
        }
        
        T_ Get() const {
            return current;
        }
        
        bool Exists(const T_ value) const {
            return elements.Exists(value);
        }
        
        void Add(const T_ value, CT_ &control) {
            if(Exists(value) && own) {
                elements.Delete(value);
            }
            
            elements.Add(value, control);
            reverse.insert({&control, value});
            control.StateChangingEvent.Register(*this, &RadioControl::changing);
        }        
        
        void ChangeValue(const T_ &before, const T_ &after) {
            if(before == after)
                return;
           
            if(!Exists(before))
                throw std::runtime_error("Element does not exist");
            
            if(Exists(after) && own) {
                elements.Delete(after);
            }
 
            auto &elm = this->elements[before];
 
            if(before == this->Get())
                elm.Clear();
 
            this->elements.Remove(before);
            this->elements.Add(after, elm);
            this->reverse.erase(&elm);
            this->reverse.insert({&elm, after});
            
            if(after == this->Get())
                elm.Check();
        }
 
        
        template<class C_>
        void PlaceIn(C_ &container, Geometry::Point start, int spacing) {
            auto loc = start;
            
            int col = 0;
            for(auto p : elements) {
                auto w = dynamic_cast<Widget*>(&p.second);
                
                if(!w)
                    continue;
                
                container.Add(*w);
                
                w->Move(loc);
                
                col++;
                if(col%columns == 0) {
                    loc.X = start.X;
                    loc.Y += w->GetSize().Height + spacing;
                    col = 0;
                }
                else {
                    loc.X += w->GetSize().Width + spacing;
                }
            }
        }
        
        auto begin() {
            return elements.begin();
        }
        
        auto end() {
            return elements.begin();
        }
        
        auto begin() const {
            return elements.begin();
        }
        
        auto end() const {
            return elements.begin();
        }
        
        void SetColumns(int value) {
            columns = value;
        }
        
        int GetColumns() const {
            return columns;
        }
        
        Event<RadioControl, T_> ChangedEvent;
        
    protected:
        void changing(TwoStateControl &control, bool state, bool &allow) {
            if(!state) {
                allow = false;
            }
            else {
                if(reverse[dynamic_cast<CT_*>(&control)] == current)
                    return;
                
                clearall();
                current = reverse[dynamic_cast<CT_*>(&control)];
                
                ChangedEvent(current);
            }
        }
        
        void clearall() {
            for(auto p : elements) {
                p.second.SetState(false, true);
            }
        }
 
        virtual void elementadded(const T_ &index) { }
        
        Containers::Hashmap<T_, CT_> elements;
        std::map<CT_ *, T_> reverse;
        
        bool own = false;
        
        T_ current = T_{};
        
        int columns = 1;
    };
    
} }