Registry.h

Go to the documentation of this file.

#pragma once
 
#include "../UI/Template.h"
 
namespace Gorgon { namespace Widgets {
 
    
    class Registry {
    public:
        
        enum TemplateType {
            Button_Regular,
            Button_Icon,
            
            Label_Regular,
            Label_Error,
            
            Checkbox_Regular,
            Checkbox_Button,
            
            Radio_Regular,
            
            Inputbox_Regular,
            
            Panel_Regular,
            Panel_Blank,
            Panel_Top,
            Panel_Left,
            Panel_Bottom,
            Panel_Right,
            
            Progress_Regular,
            
            Layerbox_Regular,
            Layerbox_Blank,
            
            Scrollbar_Horizontal,
            Scrollbar_Vertical,
            
            Listbox_Regular,
            
            Dropdown_Regular,
            
            Max 
        };
        
        explicit Registry(bool activate = false) : templates({}) {
            if(activate)
                Activate();
        }
        
        virtual ~Registry() {
            for(auto t : templates) {
                delete t;
            }
        }
        
        void Activate() {
            active = this;
        }
        
        static Registry &Active() {
            ASSERT(active, "UI is not initialized.");
            
            return *active;
        }
        
        const UI::Template &operator[](TemplateType type) {
            if(templates[type] == nullptr) {
                templates[type] = &generate(type);
            }
            
            return *templates[type];
        }
    
        virtual int GetSpacing()const = 0;
 
        virtual int GetEmSize()const = 0;
 
    protected:
 
 
        virtual UI::Template &generate(TemplateType type) = 0;
        
        mutable std::array<UI::Template*, Max> templates;
        
 
    private:
        static Registry *active; //initialized in UI.cpp
    };
    
    
    class PresetRegistry : public Registry {
    public:
        
        void Add(TemplateType type, UI::Template &temp) {
            delete templates[type];
            
            templates[type] = &temp;
        }
        
        void SetSpacing(const int tspacing) {
            spacing = tspacing;
        }
 
        void SetEmSize(const int size) {
            emsize = size;
 
        }
 
        virtual int GetSpacing()const override {
            return spacing;
        }
 
        virtual int GetEmSize()const override {
            return emsize;
        }
 
    protected:
        virtual UI::Template &generate(Gorgon::Widgets::Registry::TemplateType) override {
            return *new UI::Template();
        }
        
        int spacing = 5;
 
        int emsize = 14;
 
    };
    
    
} }