Template.h

Go to the documentation of this file.

 
#pragma once
 
#include "../Types.h"
#include "../Geometry/Margin.h"
#include "../Geometry/Size.h"
#include "../Event.h"
#include "../Containers/Collection.h"
#include "../Graphics/Drawables.h"
#include "../Graphics/Animations.h"
#include "Dimension.h"
 
//TODO: Add baseline for all components
 
namespace Gorgon { 
    namespace Graphics {
        class TextRenderer;
    }
    
    namespace UI {
 
    // TextPlaceholder
    // TextPlaceholder should have its own layer (same for others?)
    // Obtained size, position
    // 
 
    ENUMCLASS Anchor {
        None = 0,
        
        TopLeft = 1,
        TopCenter,
        TopRight,
 
        MiddleLeft = 4,
        MiddleCenter,
        MiddleRight,
        
        BottomLeft = 7,
        BottomCenter,
        BottomRight,
        
        FirstBaselineLeft,
        FirstBaselineRight,
        
        LastBaselineLeft,
        
        LastBaselineRight,
    };
 
    inline bool IsLeft(Anchor a) {
        switch(a) {
            case Anchor::TopLeft:
            case Anchor::BottomLeft:
            case Anchor::MiddleLeft:
            case Anchor::FirstBaselineLeft:
            case Anchor::LastBaselineLeft:
                return true;
            default:
                return false;
        }
    }
 
    inline bool IsRight(Anchor a) {
        switch(a) {
            case Anchor::TopRight:
            case Anchor::BottomRight:
            case Anchor::MiddleRight:
            case Anchor::FirstBaselineRight:
            case Anchor::LastBaselineRight:
                return true;
            default:
                return false;
        }
    }
 
    inline bool IsCenter(Anchor a) {
        switch(a) {
            case Anchor::TopCenter:
            case Anchor::BottomCenter:
            case Anchor::MiddleCenter:
                return true;
            default:
                return false;
        }
    }
 
    inline bool IsTop(Anchor a) {
        switch(a) {
            case Anchor::TopRight:
            case Anchor::TopLeft:
            case Anchor::TopCenter:
            case Anchor::FirstBaselineLeft:
            case Anchor::FirstBaselineRight:
                return true;
            default:
                return false;
        }
    }
 
    inline bool IsBottom(Anchor a) {
        switch(a) {
            case Anchor::BottomLeft:
            case Anchor::BottomRight:
            case Anchor::BottomCenter:
            case Anchor::LastBaselineLeft:
            case Anchor::LastBaselineRight:
                return true;
            default:
                return false;
        }
    }
 
    inline bool IsMiddle(Anchor a) {
        switch(a) {
            case Anchor::MiddleLeft:
            case Anchor::MiddleRight:
            case Anchor::MiddleCenter:
                return true;
            default:
                return false;
        }
    }
    
    ENUMCLASS ComponentType{
        Placeholder,
        Textholder,
        Graphics,
        Container,
        Ignored,
    };
 
    ENUMCLASS ComponentCondition {
        Always,
        
        Never, 
        
        None = Never,
 
        Disabled,
 
        Readonly,
 
        Focused,
 
        Hover,
        
        Down,
        
 
        State2,
 
        State3,
 
        State4,
 
        Opened,
 
        Closed,
        
        Reversed,
        
        Odd,
        
        Even,
        
        First,
 
        Middle,
        
        Last,
 
        Alone,
        
        Active,
        
        HScroll,
        
        VScroll,
        
        HVScroll,
 
        Ch1V0,
 
        Ch1V05,
 
        Ch1V1,
 
        Ch2V0,
 
        Ch2V05,
 
        Ch2V1,
 
        Ch3V0,
 
        Ch3V05,
 
        Ch3V1,
 
        Ch4V0,
 
        Ch4V05,
 
        Ch4V1,
        
        Default,
        
        Cancel,
        
        
        
        DataEffectStart = Cancel,
        
        TextIsSet,
        
        TitleIsSet,
        
        LabelIsSet,
        
        ValueText1IsSet,
        
        ValueText2IsSet,
        
        ValueText3IsSet,
        
        ValueText4IsSet,
        
        State1TextIsSet,
        
        State2TextIsSet,
        
        State3TextIsSet,
        
        State4TextIsSet,
        
        Icon1IsSet,
        
        Icon2IsSet,
        
        StateIcon1IsSet,
        
        StateIcon2IsSet,
        
        StateIcon3IsSet,
        
        StateIcon4IsSet,
        
        Max,
    };
    
    inline bool IsMouseRelated(ComponentCondition condition) {
        switch(condition) {
            case ComponentCondition::Hover:
            case ComponentCondition::Down:
                return true;
            default:
                return false;
        }
    }
    
    
    class ComponentTemplate;
    class PlaceholderTemplate;
    class TextholderTemplate;
    class GraphicsTemplate;
    class ContainerTemplate;
    class IgnoredTemplate;
 
    class Template {
    public:
 
        enum SizeMode {
            Free,
 
            Fixed,
 
            Multiples
        };
        
        Template() {
        }
 
        Template(Template &&) = default;
        
        Template &operator =(Template &&) = default;
 
        ~Template() {
            components.Destroy();
        }
 
        PlaceholderTemplate &AddPlaceholder(int index, ComponentCondition cond) { return AddPlaceholder(index, cond, ComponentCondition::None); }
 
        PlaceholderTemplate &AddPlaceholder(int index, ComponentCondition from, ComponentCondition to);
 
        TextholderTemplate &AddTextholder(int index, ComponentCondition cond) { return AddTextholder(index, cond, ComponentCondition::None); }
        
        IgnoredTemplate &AddIgnored(int index, ComponentCondition cond) { return AddIgnored(index, cond, ComponentCondition::None); }
 
        TextholderTemplate &AddTextholder(int index, ComponentCondition from, ComponentCondition to);
 
        GraphicsTemplate &AddGraphics(int index, ComponentCondition cond) { return AddGraphics(index, cond, ComponentCondition::None); }
 
        GraphicsTemplate &AddGraphics(int index, ComponentCondition from, ComponentCondition to);
 
        ContainerTemplate &AddContainer(int index, ComponentCondition cond) { return AddContainer(index, cond, ComponentCondition::None); }
 
        ContainerTemplate &AddContainer(int index, ComponentCondition from, ComponentCondition to);
        
        IgnoredTemplate &AddIgnored(int index, ComponentCondition from, ComponentCondition to);
        
        void Remove(int index) {
            components.Delete(index);
            ChangedEvent();
        }
        
        ComponentTemplate &Release(int index);
        
        void Assume(ComponentTemplate &component);
        
        int GetCount() const {
            return components.GetCount();
        }
        
        ComponentTemplate &Get(int index) const {
            return components[index];
        }
        
        ComponentTemplate &operator[](int index) const {
            return components[index];
        }
 
        void SetSizing(SizeMode x, SizeMode y) {
            xsizing = x;
            ysizing = y;
            ChangedEvent();
        }
 
        SizeMode GetXSizing() const {
            return xsizing;
        }
 
        SizeMode GetYSizing() const {
            return ysizing;
        }
 
        void SetSize(int w, int h) {
            size = {w, h};
            ChangedEvent();
        }
 
        void SetSize(Geometry::Size value) {
            size = value;
            ChangedEvent();
        }
 
        Geometry::Size GetSize() const {
            return size;
        }
 
        int GetWidth() const {
            return size.Width;
        }
 
        int GetHeight() const {
            return size.Height;
        }
 
        void SetAdditionalSize(int w, int h) {
            additional = {w, h};
            ChangedEvent();
        }
 
        void SetAdditionalSize(Geometry::Size value) {
            additional = value;
            ChangedEvent();
        }
 
        Geometry::Size GetAdditionalSize() const {
            return additional;
        }
        
        void SetConditionDuration(ComponentCondition from, ComponentCondition to, int duration) {
            durations[{from, to}] = duration;
            ChangedEvent();
        }
        
        int GetConditionDuration(ComponentCondition from, ComponentCondition to) const {
            if(durations.count({from, to}))
                return durations.at({from, to});
            else
                return 0;
        }
        
        void SetSpacing(int value) {
            spacing = value;
            ChangedEvent();
        }
        
        int GetSpacing() const {
            return spacing;
        }
 
 
        Event<Template> ChangedEvent = Event<Template>{*this};
        
        std::string Name;
        
    private:
        Containers::Collection<ComponentTemplate> components;
        std::vector<Event<ComponentTemplate>::Token> tokens;
        std::map<std::pair<ComponentCondition, ComponentCondition>, int> durations;
 
        SizeMode xsizing = Free, ysizing = Free;
        Geometry::Size size;
        Geometry::Size additional = {0, 0};
        int spacing = 4;
    };
 
    class ComponentTemplate {
    public:
        
        virtual ~ComponentTemplate() { }
 
        enum PositionType {
 
            Relative,
 
            AbsoluteSliding,
            
            Absolute,
            
            PolarAbsolute,
        };
 
        enum SizingMode {
            Fixed,
 
            Automatic,
 
            GrowOnly,
 
            ShrinkOnly
        };
 
        enum DataEffect {
            None,
 
            Text,
            
            Title,
            
            Label,
 
            //Value texts can automatically be calculated depending on the widget
            ValueText1,
 
            //Value texts can automatically be calculated depending on the widget
            ValueText2,
 
            //Value texts can automatically be calculated depending on the widget
            ValueText3,
 
            //Value texts can automatically be calculated depending on the widget
            ValueText4,
            
            State1Text,
            State2Text,
            State3Text,
            State4Text,
            
            AutoStart = ValueText1,
            AutoEnd   = State4Text,
 
            Icon,
            Icon1 = Icon,
            Icon2, 
            State1Icon,
            State2Icon,
            State3Icon,
            State4Icon,
        };
        
        enum ValueModification {
            NoModification,
            
            ModifyPosition,
            
            ModifyX,
            
            ModifyY,
            
            ModifyAlpha,
            
            ModifyColor, 
 
            BlendColor,
            
            ModifyRotation,
 
            ModifyAnimation,
 
            ModifySize,
 
            ModifyWidth,
 
            ModifyHeight,
            
            
            ModifyPositionAndSize,
            
            ModifyXAndWidth,
            
            ModifyXAndHeight,
            
            ModifyYAndWidth,
            
            ModifyYAndHeight,
            
        };
        
        enum ValueSource {
            UseFirst = 1,
            UseX = UseFirst,
            UseWidth = UseFirst,
            UseR = UseFirst,
            
            UseSecond = 2,
            UseY = UseSecond,
            UseHeight = UseSecond,
            UseG = UseSecond,
            UseT = UseSecond,
            
            UseThird = 4,
            UseZ = UseThird,
            UseB = UseThird,
            
            UseFourth = 8,
            UseA = UseFourth,
            UseW = UseFourth,
 
            UseGray = 16,
 
            UseL = 32,
            
            UseH = 64, 
            
            UseC = 128,
            
            UseTransition = 0x10000,
 
            ValueSourceMaxPower = 7,
            
            UseXY   = UseFirst | UseSecond,
            UseSize = UseFirst | UseSecond,
            UseRG   = UseFirst | UseSecond,
            
            UseYZ = UseSecond | UseThird,
            UseGB = UseSecond | UseThird,
            
            UseXZ = UseFirst | UseThird,
            UseRB = UseFirst | UseThird,
            
            UseXW = UseFirst | UseFourth,
            UseRA = UseFirst  | UseFourth,
            UseBA = UseSecond | UseFourth,
            UseGA = UseThird  | UseFourth,
            
            UseXYZ = UseFirst | UseSecond | UseThird,
            UseRGB = UseFirst | UseSecond | UseThird,
 
            UseRGA = UseFirst  | UseSecond | UseFourth,
            UseRBA = UseFirst  | UseThird  | UseFourth,
            UseGBA = UseSecond | UseThird  | UseFourth,
            
            UseLH = UseL | UseH,
            UseLC = UseL | UseC,
            UseCH = UseC | UseH,
 
            UseGrayAlpha = UseGray | UseA,
 
            UseLCH  = UseL | UseH | UseC,
            UseLCHA = UseL | UseH | UseC | UseA,
            
            UseRGBA = UseFirst | UseSecond | UseThird | UseFourth,
        };
        
        enum Tag {
            NoTag,
            
            UnknownTag,
            TickTag,
            HScrollTag,
            VScrollTag,
            DragTag,
            SecondDragTag,
            DragBarTag,
            XDragTag,
            YDragTag,
            MinimapTag,
            IncrementTag,
            DecrementTag,
            LeftTag,
            RightTag,
            TopTag,
            BottomTag,
            ExpandTag,
            ToggleTag,
            ContentsTag,
            ViewPortTag,
            SelectionTag,
            CaretTag,
            ItemTag,
            HeaderTag,
            SpacerTag,
            ListTag
        };
        
        enum RepeatMode {
            NoRepeat       = 0,
 
            Minor           = 1,
            Major           = 2,
 
            XGrid           = 4,
            YGrid           = 8,
 
            XTick           = 16,
            YTick           = 20,
            
            XMinorGrid      = 5,
            YMinorGrid      = 9,
            XMajorGrid      = 6,
            YMajorGrid      = 10,
            
            XMinorTick      = 17,
            YMinorTick      = 21,
            XMajorTick      = 18,
            YMajorTick      = 22,
        };
 
        virtual ComponentType GetType() const noexcept = 0;
        
        void SetPosition(int x, int y, Dimension::Unit unit = Dimension::Pixel) { position = {{x, unit}, {y, unit}}; ChangedEvent(); }
 
        void SetPosition(Geometry::Point pos, Dimension::Unit unit = Dimension::Pixel) { position = {{pos.X, unit}, {pos.Y, unit}}; ChangedEvent(); }
 
        void SetPosition(Dimension x, Dimension y) { position = {x, y}; ChangedEvent(); }
 
        void SetPosition(Point value) { position = value; ChangedEvent(); }
 
        void SetPositioning(PositionType value) { positioning = value; ChangedEvent(); }
 
        Point GetPosition() const { return position; }
 
        PositionType GetPositioning() const { return positioning; }
        
        void SetCenter(int x, int y, Dimension::Unit unit = Dimension::Pixel) { center = {{x, unit}, {y, unit}}; ChangedEvent(); }
 
        void SetCenter(Geometry::Point pos, Dimension::Unit unit = Dimension::Pixel) { center = {{pos.X, unit}, {pos.Y, unit}}; ChangedEvent(); }
 
        void SetCenter(Dimension x, Dimension y) { center = {x, y}; ChangedEvent(); }
 
        void SetCenter(Point value) { center = value; ChangedEvent(); }
        
        Point GetCenter() const { return center; }
 
 
 
        void SetSize(int w, int h, Dimension::Unit unit = Dimension::Pixel) { SetSize({{w, unit}, {h, unit}}); }
 
        void SetSize(Geometry::Size size, Dimension::Unit unit = Dimension::Pixel) { SetSize({{size.Width, unit}, {size.Height, unit}}); }
 
        void SetSize(Dimension w, Dimension h) { SetSize({w, h}); }
 
        void SetSize(Size size) { 
            this->size = size;
 
            if(sizingw == Automatic && size.Width.GetValue() != 0)
                sizingw = Fixed;
 
            if(sizingh == Automatic && size.Height.GetValue() != 0)
                sizingh = Fixed;
 
            ChangedEvent(); 
        }
 
        void SetSizing(SizingMode value) { sizingw = sizingh = value; ChangedEvent(); }
 
        void SetSizing(SizingMode hor, SizingMode vert) { sizingw = hor; sizingh = vert; ChangedEvent(); }
 
        Size GetSize() const { return size; }
 
        SizingMode GetHorizontalSizing() const { return sizingw; }
 
        SizingMode GetVerticalSizing() const { return sizingh; }
 
 
        void SetMargin(int value, Dimension::Unit unit = Dimension::Pixel) { margin = {{value, unit}}; ChangedEvent(); }
 
        void SetMargin(int hor, int ver, Dimension::Unit unit = Dimension::Pixel) { margin = {{hor, unit}, {ver, unit}}; ChangedEvent(); }
 
        void SetMargin(int left, int top, int right, int bottom, Dimension::Unit unit = Dimension::Pixel) { 
            margin = {{left, unit}, {top, unit}, {right, unit}, {bottom, unit}}; 
            ChangedEvent(); 
        }
 
        void SetMargin(Geometry::Margin value, Dimension::Unit unit = Dimension::Pixel) { 
            margin = {{value.Left, unit}, {value.Top, unit}, {value.Right, unit}, {value.Bottom, unit}}; 
            ChangedEvent(); 
        }
 
        void SetMargin(Dimension value) { margin = {value}; ChangedEvent(); }
 
        void SetMargin(Dimension hor, Dimension ver) { margin = {hor, ver}; ChangedEvent(); }
 
        void SetMargin(Dimension left, Dimension top, Dimension right, Dimension bottom) { margin = {left, top, right, bottom}; ChangedEvent(); }
 
        void SetMargin(Margin value) { margin = value; ChangedEvent(); }
 
        Margin GetMargin() const { return margin; }
 
 
        void SetIndent(int value, Dimension::Unit unit = Dimension::Pixel) { indent = {{value, unit}}; ChangedEvent(); }
 
        void SetIndent(int hor, int ver, Dimension::Unit unit = Dimension::Pixel) { indent = {{hor, unit}, {ver, unit}}; ChangedEvent(); }
 
        void SetIndent(int left, int top, int right, int bottom, Dimension::Unit unit = Dimension::Pixel) { 
            indent = {{left, unit}, {top, unit}, {right, unit}, {bottom, unit}}; 
            ChangedEvent(); 
        }
 
        void SetIndent(Geometry::Margin value, Dimension::Unit unit = Dimension::Pixel) { 
            indent = {{value.Left, unit}, {value.Top, unit}, {value.Right, unit}, {value.Bottom, unit}}; 
            ChangedEvent(); 
        }
 
        void SetIndent(Dimension value) { indent = {value}; ChangedEvent(); }
 
        void SetIndent(Dimension hor, Dimension ver) { indent = {hor, ver}; ChangedEvent(); }
 
        void SetIndent(Dimension left, Dimension top, Dimension right, Dimension bottom) { indent = {left, top, right, bottom}; ChangedEvent(); }
 
        void SetIndent(Margin value) { indent = value; ChangedEvent(); }
 
        Margin GetIndent() const { return indent; }
 
 
 
        void SetDataEffect(DataEffect effect) {
            dataeffect = effect;
            
            ChangedEvent(); 
        }
 
        DataEffect GetDataEffect() const { return dataeffect; }
        
        void SetValueOrdering(int first, int second, int third, int fourth) {
            valueordering = {{first, second, third, fourth}};
            
            ChangedEvent();
        }
        
        std::array<int, 4> GetValueOrdering() const {
            return valueordering;
        }
        
        void SetValueModification(ValueModification mod, ValueSource source = UseFirst, std::array<float, 4> min = {{0, 0, 0, 0}}, std::array<float, 4> max = {{1, 1, 1, 1}}) {
            valuemod = mod;
            valuemin = min;
            valuemax = max;
            this->source = source;
            
            ChangedEvent(); 
        }
 
        void SetValueRange(std::array<float, 4> min, std::array<float, 4> max) {
            valuemin = min;
            valuemax = max;
 
            ChangedEvent();
        }
 
        void SetValueRange(int channel, float min, float max) {
            ASSERT(channel>=0 && channel<4, "Channel index out of bounds");
 
            valuemin[channel] = min;
            valuemax[channel] = max;
 
            ChangedEvent();
        }
 
        ValueModification GetValueModification() const { return valuemod; }
        
        void SetValueSource(ValueSource value) {
            source = value;
            
            ChangedEvent(); 
        }
        
        ValueSource GetValueSource() const {
            return source;
        }
        
        void SetTag(Tag value) {
            tag = value;
            
            ChangedEvent(); 
        }
        
        Tag GetTag() const {
            return tag;
        }
        
        void SetRepeatMode(RepeatMode value) {
            repeat = value;
            
            ChangedEvent();
        }
        
        RepeatMode GetRepeatMode() const {
            return repeat;
        }
        
 
        std::array<float, 4> GetValueMin() const { return valuemin; }
 
        std::array<float, 4> GetValueRange() const { return {{valuemax[0]-valuemin[0], valuemax[1]-valuemin[1], valuemax[2]-valuemin[2], valuemax[3]-valuemin[3]}}; }
 
        std::array<float, 4> GetValueMax() const { return valuemax; }
 
        float GetValueMin(int channel) const {
            ASSERT(channel>=0 && channel<4, "Channel index out of bounds");
 
            return valuemin[channel];
        }
        
        float GetValueRange(int channel) const {
            ASSERT(channel>=0 && channel<4, "Channel index out of bounds");
 
            return valuemax[channel]-valuemin[channel];
        }
 
        float GetValueMax(int channel) const {
            ASSERT(channel>=0 && channel<4, "Channel index out of bounds");
 
            return valuemax[channel];
        }
 
 
        void SetAnchor(Anchor previous, Anchor container, Anchor my) { 
            this->previous = previous; 
            this->container = container;
            this->my = my; 
            
            ChangedEvent(); 
        }
 
        Anchor GetPreviousAnchor() const { return previous; }
        
        Anchor GetContainerAnchor() const { return container; }
 
        Anchor GetMyAnchor() const { return my; }
 
 
 
        void SetBaseline(int value) { baseline = value; ChangedEvent(); } 
 
        int GetBaseline() const { return baseline; }
 
 
 
        void SetIndex(int value) { index = value; ChangedEvent(); } 
 
        int GetIndex() const { return index; }
 
 
 
        void SetCondition(ComponentCondition value) { condition = value; condition_to = ComponentCondition::None; ChangedEvent(); }
 
        void SetCondition(ComponentCondition from, ComponentCondition to) { condition = from; condition_to = to; ChangedEvent(); }
 
        ComponentCondition GetCondition() const { return condition; }
        
        ComponentCondition GetTargetCondition() const { return condition_to; }
        
        bool IsTransition() const { return condition_to != ComponentCondition::None; }
        
        void SetReversible(bool value) { reversible = value; ChangedEvent(); }
        
        bool IsReversible() const { return reversible; }
        
        
        void SetClip(bool value) {
            clip = value;
        }
        
        bool GetClip() const {
            return clip;
        }
 
 
        Event<ComponentTemplate> ChangedEvent = Event<ComponentTemplate>{*this};
 
    protected:
        
        bool clip = false;
        
        bool reversible = false;
        
        
        ComponentCondition condition = ComponentCondition::Always;
        
        ComponentCondition condition_to = ComponentCondition::None;
 
        DataEffect dataeffect = None;
        
        ValueModification valuemod = NoModification;
        
        ValueSource source = UseFirst;
        
        std::array<int, 4>   valueordering{0,1,2,3};
 
        std::array<float, 4> valuemin = {{0, 0, 0, 0}}, valuemax = {{1, 1, 1, 1}};
        
        Tag tag = NoTag;
        
        RepeatMode repeat = NoRepeat;
        
        PositionType positioning = Relative;
 
        Point position = {0, 0};
 
        SizingMode sizingw = Fixed, sizingh = Fixed;
 
        Size size = {{100, Dimension::Percent}, {100, Dimension::Percent}};
 
        Margin margin = {0};
 
        Margin indent = {0};
        
        Point center = {{50, Dimension::Percent}, {50, Dimension::Percent}};
 
        Anchor previous = Anchor::TopRight;
        
        Anchor container = Anchor::TopLeft;
 
        Anchor my = Anchor::TopLeft;
        
        int baseline = 0;
 
        int index = 0;
    };
 
    inline ComponentTemplate::ValueSource operator | (ComponentTemplate::ValueSource l, ComponentTemplate::ValueSource r) {
        return ComponentTemplate::ValueSource((int)l | (int)r);
    }
 
    class PlaceholderTemplate : public ComponentTemplate {
    public:
        
        PlaceholderTemplate() {
            sizingw = Automatic;
            sizingh = Automatic;
        }
 
        virtual ComponentType GetType() const noexcept override {
            return ComponentType::Placeholder;
        }
        
        void SetTemplate(const Template &value) {
            temp = &value;
            ChangedEvent();
        }
        
        bool HasTemplate() const {
            return temp != nullptr;
        }
        
        const Template &GetTemplate() const {
            ASSERT(temp, "Template is empty.");
            return *temp;
        }
        
    private:
        const Template *temp = nullptr;
    };
    
    class IgnoredTemplate : public ComponentTemplate {
    public:
        
        virtual ComponentType GetType() const noexcept override {
            return ComponentType::Ignored;
        }
        
    };
 
    class TextholderTemplate : public ComponentTemplate {
    public:
        TextholderTemplate() {
            my = Anchor::FirstBaselineLeft;
            previous = Anchor::FirstBaselineRight;
            container = Anchor::FirstBaselineLeft;
            SetSizing(Automatic);
        }
 
        virtual ComponentType GetType() const noexcept override {
            return ComponentType::Textholder;
        }
        
        bool IsReady() const;
        
        void SetRenderer(const Graphics::TextRenderer &value) {
            renderer = &value;
        }
        
        const Graphics::TextRenderer &GetRenderer() const {
            ASSERT(renderer, "Renderer is not set.");
            
            return *renderer;
        }
 
        void SetColor(Graphics::RGBAf value) {
            color = value;
 
            ChangedEvent();
        }
 
        Graphics::RGBAf GetColor() const {
            return color;
        }
 
 
        void SetTargetColor(Graphics::RGBAf value) {
            targetcolor = value;
 
            ChangedEvent();
        }
 
        Graphics::RGBAf GetTargetColor() const {
            return targetcolor;
        }
        
        void SetText(const std::string &value) {
            text = value;
            
            ChangedEvent();
        }
        
        std::string GetText() const {
            return text;
        }
    
    private:
        const Graphics::TextRenderer *renderer = nullptr;
        Graphics::RGBAf color = 1.0f;
        Graphics::RGBAf targetcolor = 0.f;
        std::string text;
    };
 
    class VisualProvider {
    public:
        VisualProvider(Event<ComponentTemplate> &changed) : changed(&changed) { }
 
        VisualProvider(Event<ComponentTemplate> &changed, const Graphics::AnimationProvider &content) :
            changed(&changed), provider(&content) 
        { }
 
        VisualProvider(Event<ComponentTemplate> &changed, const Graphics::Drawable &content) : 
            changed(&changed), drawable(&content) 
        { }
 
        bool HasContent() const {
            return drawable != nullptr || provider != nullptr;
        }
 
        bool IsAnimation() const {
            return provider != nullptr;
        }
 
        bool IsDrawable() const {
            return drawable != nullptr;
        }
 
        const Graphics::AnimationProvider &GetAnimation() const {
            if(provider == nullptr) {
                throw std::runtime_error("Animation not set.");
            }
 
            return *provider;
        }
 
        const Graphics::Drawable &GetDrawable() const {
            if(drawable == nullptr) {
                throw std::runtime_error("Drawable not set.");
            }
 
            return *drawable;
        }
 
        const Graphics::Drawable &Instantiate(Animation::ControllerBase &controller) const {
            if(drawable)
                return *drawable;
            else if(provider) {
                return provider->CreateAnimation(controller);
            }
            else {
                throw std::runtime_error("Visual provider is empty.");
            }
        }
 
        void SetDrawable(const Graphics::Drawable &value) {
            drawable = &value;
            provider = nullptr;
 
            (*changed)();
        }
 
        void SetAnimation(const Graphics::AnimationProvider &value) {
            drawable = nullptr;
            provider = &value;
 
            (*changed)();
        }
 
    private:
        Event<ComponentTemplate> *changed;
        
        const Graphics::Drawable *drawable = nullptr;
        const Graphics::AnimationProvider *provider = nullptr;
    };
 
    class GraphicsTemplate : public ComponentTemplate {
    public:
 
        GraphicsTemplate() {
            sizingw = Automatic;
            sizingh = Automatic;
        }
        
        GraphicsTemplate(const Graphics::Drawable &content) : Content(ChangedEvent, content) {
        }
 
        GraphicsTemplate(const Graphics::AnimationProvider &content) : Content(ChangedEvent, content) {
        }
 
        virtual ComponentType GetType() const noexcept override {
            return ComponentType::Graphics;
        }
        
        
        void SetFillArea(bool value) {
            fill = value;
            
            ChangedEvent();
        }
        
        bool GetFillArea() const {
            return fill;
        }
 
        void SetColor(Graphics::RGBAf value) {
            color = value;
 
            ChangedEvent();
        }
 
        Graphics::RGBAf GetColor() const {
            return color;
        }
 
        void SetTargetColor(Graphics::RGBAf value) {
            targetcolor = value;
 
            ChangedEvent();
        }
 
        Graphics::RGBAf GetTargetColor() const {
            return targetcolor;
        }
 
        VisualProvider Content = {ChangedEvent};
 
    private:
        bool fill = true;
        Geometry::Margin padding = {0, 0, 0, 0};
        Graphics::RGBAf color = 1.0f;
        Graphics::RGBAf targetcolor = 0.f;
    };
    
    class ContainerTemplate : public ComponentTemplate {
    public:
        void SetPadding(int value, Dimension::Unit unit = Dimension::Pixel) { padding ={{value, unit}}; ChangedEvent(); }
 
        void SetPadding(int hor, int ver, Dimension::Unit unit = Dimension::Pixel) { padding ={{hor, unit},{ver, unit}}; ChangedEvent(); }
 
        void SetPadding(int left, int top, int right, int bottom, Dimension::Unit unit = Dimension::Pixel) {
            padding ={{left, unit},{top, unit},{right, unit},{bottom, unit}};
            ChangedEvent();
        }
 
        void SetPadding(Geometry::Margin value, Dimension::Unit unit = Dimension::Pixel) {
            padding ={{value.Left, unit},{value.Top, unit},{value.Right, unit},{value.Bottom, unit}};
            ChangedEvent();
        }
 
        void SetPadding(Dimension value) { padding ={value}; ChangedEvent(); }
 
        void SetPadding(Dimension hor, Dimension ver) { padding ={hor, ver}; ChangedEvent(); }
 
        void SetPadding(Dimension left, Dimension top, Dimension right, Dimension bottom) { padding = {left, top, right, bottom}; ChangedEvent(); }
 
        void SetPadding(Margin value) { padding = value; ChangedEvent(); }
 
        Margin GetPadding() const { return padding; }
 
 
 
        void SetBorderSize(int value) { bordersize ={value}; ChangedEvent(); }
 
        void SetBorderSize(int hor, int ver) { bordersize ={hor, ver}; ChangedEvent(); }
 
        void SetBorderSize(int left, int top, int right, int bottom) { bordersize = {left, top, right, bottom}; ChangedEvent(); }
 
        void SetBorderSize(Geometry::Margin value) { bordersize = value; ChangedEvent(); }
 
        Geometry::Margin GetBorderSize() const { return bordersize; }
 
 
        void SetShadowExtent(int value) { padding ={value}; ChangedEvent(); }
 
        void SetShadowExtent(int hor, int ver) { shadowextent ={hor, ver}; ChangedEvent(); }
 
        void SetShadowExtent(int left, int top, int right, int bottom) { shadowextent = {left, top, right, bottom}; ChangedEvent(); }
 
        void SetShadowExtent(Geometry::Margin value) { shadowextent = value; ChangedEvent(); }
 
        Geometry::Margin GetShadowExtent() const { return shadowextent; }
 
 
 
        void SetOverlayExtent(int value) { overlayextent ={value}; ChangedEvent(); }
 
        void SetOverlayExtent(int hor, int ver) { overlayextent ={hor, ver}; ChangedEvent(); }
 
        void SetOverlayExtent(int left, int top, int right, int bottom) { overlayextent = {left, top, right, bottom}; ChangedEvent(); }
 
        void SetOverlayExtent(Geometry::Margin value) { overlayextent = value; ChangedEvent(); }
 
        Geometry::Margin GetOverlayExtent() const { return overlayextent; }
        
        void SetOrientation(Graphics::Orientation value) { orientation = value; ChangedEvent(); }
        
        Graphics::Orientation GetOrientation() const { return orientation; }
 
        ContainerTemplate &AddIndex(int componentindex) {
            indices.push_back(componentindex);
            ChangedEvent();
            
            return *this;
        }
 
        void InsertIndex(int before, int componentindex) {
            indices.insert(indices.begin() + before, componentindex);
            ChangedEvent();
        }
 
        void RemoveIndexAt(int index) {
            indices.erase(indices.begin() + index);
            ChangedEvent();
        }
 
        int GetCount() const {
            return (int)indices.size();
        }
 
        int operator[] (int index) const {
            return indices[index];
        }
 
        int &operator[] (int index) {
            return indices[index];
        }
 
        virtual ComponentType GetType() const noexcept override {
            return ComponentType::Container;
        }
        
        void SetReportMouse(bool value);
        
        bool GetReportMouse() const;
        
 
        VisualProvider Background = {ChangedEvent};
 
        VisualProvider Overlay    = {ChangedEvent};
 
    private:
        Margin padding;
        Geometry::Margin bordersize, shadowextent, overlayextent;
        std::vector<int> indices;
        Graphics::Orientation orientation = Graphics::Orientation::Horizontal;
        bool reportmouse = false;
    };
 
} }