ComponentStack.h

Go to the documentation of this file.

#pragma once
 
#include "Template.h"
#include "Component.h"
#include "LayerAdapter.h"
#include "../Containers/Hashmap.h"
#include "../Input/Layer.h"
#include "../Geometry/Point3D.h"
 
#include <set>
#include <vector>
 
namespace Gorgon { namespace UI {
    
    class Widget;
 
    class ComponentStack : public Layer, public Updatable {
    public:
        
        ComponentStack(const Template &temp, Geometry::Size size, std::map<ComponentTemplate::Tag, std::function<Widget *(const Template &)>> generators = {});
        
        explicit ComponentStack(const Template &temp) : ComponentStack(temp, temp.GetSize()) 
        { }
        
        virtual ~ComponentStack();
 
        void AddToStack(const ComponentTemplate &temp, bool reversed);
        
        void ReplaceCondition(ComponentCondition from, ComponentCondition to, bool transition = true);
        
        void AddCondition(ComponentCondition condition, bool transition = true) { 
            //redirect to replace condition
            ReplaceCondition(ComponentCondition::Always, condition, transition); 
        }
        
        void RemoveCondition(ComponentCondition condition, bool transition = true)  { 
            //redirect to replace condition
            ReplaceCondition(condition, ComponentCondition::Always, transition); 
        }
 
        bool HasCondition(ComponentCondition condition) { 
            return conditions.count(condition);
        }
        
        void FinalizeTransitions();
 
        void SetData(ComponentTemplate::DataEffect effect, const std::string &text);
        
        void SetData(ComponentTemplate::DataEffect effect, const Graphics::Drawable &image);
        
        std::string GetTextData(ComponentTemplate::DataEffect effect) {
            return stringdata.count(effect) ? stringdata[effect] : "";
        }
        
        const Graphics::Drawable *GetImageData(ComponentTemplate::DataEffect effect) {
            return imagedata.Exists(effect) ? &imagedata[effect] : nullptr;
        }
 
        void RemoveData(ComponentTemplate::DataEffect effect);
 
        void SetValue(float first) { SetValue(first, value[1], value[2], value[3]); }
 
        void SetValue(float first, float second) { SetValue(first, second, value[2], value[3]); }
 
        void SetValue(float first, float second, float third) { SetValue(first, second, third, value[3]); }
 
        void SetValue(float first, float second, float third, float fourth, bool instant = false);
 
        void SetValue(Geometry::Pointf pos) { SetValue(pos.X, pos.Y); }
 
        void SetValue(Geometry::Point3D pos) { SetValue(pos.X, pos.Y, pos.Z); }
 
        void SetValue(Graphics::RGBAf color) { SetValue(color.R, color.G, color.B, color.A); }
 
        void SetValue(Graphics::RGBA color) { SetValue((Graphics::RGBAf)color); }
        
        std::array<float, 4> GetValue() const { return returntarget ? targetvalue : value; }
 
        std::array<float, 4> GetTargetValue() const { return targetvalue; }
 
        void SetValueTransitionSpeed(std::array<float, 4> val) {
            valuespeed = val;
        }
 
        void ReturnTransitionalValue() {
            returntarget = false;
        }
 
        void ReturnTargetValue() {
            returntarget = true;
        }
 
        void SetValueEvent(std::function<void()> handler) {
            value_fn = handler;
        }
 
 
        void SetValueToText(std::function<std::string(int, ComponentTemplate::DataEffect, const std::array<float, 4> &)> handler) {
            valuetotext = handler;
        }
 
        void SetRepeat(ComponentTemplate::RepeatMode mode, std::vector<std::array<float, 4>> data) {
            repeats[mode] = std::move(data);
            checkrepeatupdate(mode);
        }
        
        void AddRepeat(ComponentTemplate::RepeatMode mode, float first) {
            AddRepeat(mode, first, 0, 0, 0);
        }
        
        void AddRepeat(ComponentTemplate::RepeatMode mode, float first, float second) {
            AddRepeat(mode, first, second, 0, 0);
        }
        
        void AddRepeat(ComponentTemplate::RepeatMode mode, float first, float second, float third) {
            AddRepeat(mode, first, second, third, 0);
        }
        
        void AddRepeat(ComponentTemplate::RepeatMode mode, float first, float second, float third, float fourth) {
            repeats[mode].push_back({{first, second, third, fourth}});
            checkrepeatupdate(mode);
        }
        
        void AddRepeat(ComponentTemplate::RepeatMode mode, Geometry::Pointf pos) {
            AddRepeat(mode, pos.X, pos.Y, 0, 0);
        }
        
        void AddRepeat(ComponentTemplate::RepeatMode mode, Geometry::Point3D pos) {
            AddRepeat(mode, pos.X, pos.Y, pos.Z, 0);
        }
        
        void AddRepeat(ComponentTemplate::RepeatMode mode, Graphics::RGBAf color) {
            AddRepeat(mode, color.R, color.G, color.B, color.A);
        }
        
        void AddRepeat(ComponentTemplate::RepeatMode mode, Graphics::RGBA color) {
            AddRepeat(mode, (Graphics::RGBAf)color);
        }
 
        void RemoveRepeats(ComponentTemplate::RepeatMode mode) {
            repeats.erase(mode);
            checkrepeatupdate(mode);
        }
 
        void SetConditionOf(ComponentTemplate::RepeatMode mode, int index, ComponentCondition condition) {
            if(repeatconditions[mode][index] != condition) {
                repeatconditions[mode][index] = condition;
                checkrepeatupdate(mode);
            }
        }
 
        void RemoveAllConditionsOf(ComponentTemplate::RepeatMode mode) {
            repeatconditions[mode].clear();
            checkrepeatupdate(mode);
        }
 
 
        using Layer::Resize;
        
        virtual void Resize(const Geometry::Size &value) override {
            Layer::Resize(value);
            mouse.Resize(value);
            
            if(size != value) {
                size = value;
                Update();
            }
        }
        
        const Template &GetTemplate() const {
            return temp;
        }
        
        const Template *GetTemplate(ComponentTemplate::Tag tag);
        
        Widget *GetWidget(ComponentTemplate::Tag tag);
 
        virtual void Update() override { Update(false); }
        
        void Update(bool immediate);
 
        void Render() override;
 
        void ResetAnimation() {
            controller.Reset();
        }
        
        bool IsDisabled() const {
            return conditions.count(ComponentCondition::Disabled) || 
                transitions.count({ComponentCondition::Always, ComponentCondition::Disabled}) || 
                transitions.count({ComponentCondition::Disabled, ComponentCondition::Always});
        }
        
        void SetEMSize(int value) {
            emsize = value;
        }
        
        void HandleMouse(Input::Mouse::Button accepted = Input::Mouse::Button::All);
        
        bool TagHasSubStack(ComponentTemplate::Tag tag) const;
        
        std::array<float, 4> CoordinateToValue(ComponentTemplate::Tag tag, Geometry::Point location, bool relative = false);
        
        Geometry::Point TranslateCoordinates(ComponentTemplate::Tag tag, Geometry::Point location);
        
        Geometry::Point TranslateCoordinates(int ind, Geometry::Point location);
        
        Geometry::Pointf TransformCoordinates(ComponentTemplate::Tag tag, Geometry::Point location);
        
        Geometry::Pointf TransformCoordinates(int ind, Geometry::Point location);
        
        int IndexOfTag(ComponentTemplate::Tag tag);
 
        Geometry::Bounds TagBounds(ComponentTemplate::Tag tag);
 
        bool HasLayer(int ind) const;
 
        Layer &GetLayerOf(int ind);
        
        Geometry::Bounds BoundsOf(int ind);
 
        int ComponentAt(Geometry::Point location) {
            Geometry::Bounds b;
 
            return ComponentAt(location, b);
        }
 
        int ComponentAt(Geometry::Point location, Geometry::Bounds &bounds);
 
        bool ComponentExists(int ind) const {
            return Between(ind, 0, indices) && stacksizes[ind];
        }
 
        const ComponentTemplate &GetTemplate(int ind) const {
            return get(ind).GetTemplate();
        }
 
        void SetTagLocation(ComponentTemplate::Tag tag, Geometry::Point location) {
            taglocations[tag] = location;
            Update();
        }
        
        Geometry::Point GetTagLocation(ComponentTemplate::Tag tag) const {
            auto f = taglocations.find(tag);
            
            if(f == taglocations.end())
                return {0, 0};
            else
                return f->second;
        }
 
        void RemoveTagLocation(ComponentTemplate::Tag tag) {
            taglocations.erase(tag);
        }
 
        void SetTagSize(ComponentTemplate::Tag tag, Geometry::Size size) {
            tagsizes[tag] = size;
            Update();
        }
 
        Geometry::Size GetTagSize(ComponentTemplate::Tag tag) const {
            auto f = tagsizes.find(tag);
            
            if(f == tagsizes.end())
                return {0, 0};
            else
                return f->second;
        }
 
        void RemoveTagSize(ComponentTemplate::Tag tag) {
            tagsizes.erase(tag);
        }
        
        void EnableTagWrap(ComponentTemplate::Tag tag) {
            tagnowrap.erase(tag);
        }
        
        void DisableTagWrap(ComponentTemplate::Tag tag) {
            tagnowrap.insert(tag);
        }
 
 
        void SetFrameEvent(std::function<void()> handler) {
            frame_fn = handler;
        }
        
        void SetBeforeUpdateEvent(std::function<void()> handler) {
            beforeupdate_fn = handler;
        }
        
        void SetUpdateEvent(std::function<void()> handler) {
            update_fn = handler;
        }
        
        void SetRenderEvent(std::function<void()> handler) {
            render_fn = handler;
        }
        
        void RemoveFrameEvent() {
            frame_fn = std::function<void()>();
        }
        
        void RemoveBeforeUpdateEvent() {
            beforeupdate_fn = std::function<void()>();
        }
        
        void RemoveUpdateEvent() {
            update_fn = std::function<void()>();
        }
        
        void RemoveRenderEvent() {
            render_fn = std::function<void()>();
        }
        
        void SetMouseDownEvent(std::function<void(ComponentTemplate::Tag, Geometry::Point, Input::Mouse::Button)> handler) {
            down_fn = handler;
            
            for(auto stack : substacks) {
                stack.second.SetMouseDownEvent([stack, this](ComponentTemplate::Tag tag, Geometry::Point point, Input::Mouse::Button btn) {
                    down_fn(stack.first->GetTag() == ComponentTemplate::NoTag ? ComponentTemplate::UnknownTag : stack.first->GetTag(), point, btn);
                });
            }
        }
        
        void SetMouseUpEvent(std::function<void(ComponentTemplate::Tag, Geometry::Point, Input::Mouse::Button)> handler) {
            up_fn = handler;
            
            for(auto stack : substacks) {
                stack.second.SetMouseUpEvent([stack, this](ComponentTemplate::Tag tag, Geometry::Point point, Input::Mouse::Button btn) {
                    up_fn(stack.first->GetTag() == ComponentTemplate::NoTag ? ComponentTemplate::UnknownTag : stack.first->GetTag(), point, btn);
                });
            }
        }
        
        void SetClickEvent(std::function<void(ComponentTemplate::Tag, Geometry::Point, Input::Mouse::Button)> handler) {
            click_fn = handler;
            
            for(auto stack : substacks) {
                stack.second.SetClickEvent([stack, this](ComponentTemplate::Tag tag, Geometry::Point point, Input::Mouse::Button btn) {
                    click_fn(stack.first->GetTag() == ComponentTemplate::NoTag ? ComponentTemplate::UnknownTag : stack.first->GetTag(), point, btn);
                });
            }
        }
        
        void SetMouseMoveEvent(std::function<void(ComponentTemplate::Tag, Geometry::Point)> handler) {
            move_fn = handler;
            
            mouse.SetMove([this] (Geometry::Point location){
                if(move_fn)
                    move_fn(ComponentTemplate::NoTag, location);
            });
            
            for(auto stack : substacks) {
                stack.second.SetMouseMoveEvent([stack, this](ComponentTemplate::Tag tag, Geometry::Point point) {
                    move_fn(stack.first->GetTag() == ComponentTemplate::NoTag ? ComponentTemplate::UnknownTag : stack.first->GetTag(), point);
                });
            }
        }
        
        void SetMouseOverEvent(std::function<void(ComponentTemplate::Tag)> handler) {
            over_fn = handler;
            
            for(auto stack : substacks) {
                stack.second.SetMouseOverEvent([stack, this](ComponentTemplate::Tag tag) {
                    over_fn(stack.first->GetTag() == ComponentTemplate::NoTag ? ComponentTemplate::UnknownTag : stack.first->GetTag());
                });
            }
        }
        
        void SetMouseOutEvent(std::function<void(ComponentTemplate::Tag)> handler) {
            out_fn = handler;
            
            for(auto stack : substacks) {
                stack.second.SetMouseOutEvent([stack, this](ComponentTemplate::Tag tag) {
                    out_fn(stack.first->GetTag() == ComponentTemplate::NoTag ? ComponentTemplate::UnknownTag : stack.first->GetTag());
                });
            }
        }
        
        void SetOtherMouseEvent(std::function<bool(ComponentTemplate::Tag, Input::Mouse::EventType, Geometry::Point, float)> handler);
 
        
 
        Event<ComponentStack> ConditionChanged;
        
        
    private:
        Component &get(int ind, int stack = -1) const {
            ASSERT(stacksizes[ind], String::Concat("Stack for index ", ind, " is empty"));
 
            if(stack == -1) {
                stack = stacksizes[ind]-1;
            }
 
            return data[ind + stack * indices];
        }
 
        Component &get(int ind, ComponentCondition condition) const;
        
        void anchortoparent(Component &parent, Component &comp, const ComponentTemplate &temp, 
                                Geometry::Point offset, Geometry::Margin margin, Geometry::Size maxsize);
        
        
        void anchortoother(Component &comp, const ComponentTemplate &temp, 
                        Geometry::Point offset, Geometry::Margin margin, Component &other, Graphics::Orientation orientation);
        
        void update();
 
        void update(Component &parent, const std::array<float, 4> &value, int ind, int textwidth = -1);
 
        void render(Component &component, Graphics::Layer &parentlayer, Geometry::Point offset, const std::array<float, 4> &value, Graphics::RGBAf color = 1.f, int ind = -1);
 
        void grow();
        
        int getemsize(const Component &comp);
        
        int getbaseline(const Component &comp);
        
        int gettextheight(const Component &comp);
 
        float calculatevalue(int channel, const Component &comp) const { return calculatevalue(value, channel, comp); }
 
        float calculatevalue(const std::array<float, 4> &data, int channel, const Component &comp) const;
 
        void checkrepeatupdate(ComponentTemplate::RepeatMode mode);
        
        bool addcondition(ComponentCondition from, ComponentCondition to, ComponentCondition hint = ComponentCondition::None);
 
        bool removecondition(ComponentCondition from, ComponentCondition to);
        
        Component *gettag(ComponentTemplate::Tag tag) const;
 
        int emsize = 0;
        
        int baseline = 0;
        
        int textheight = 0;
        
        Component *data = nullptr;
        
        std::vector<int> stacksizes;
        
        std::set<ComponentCondition> disabled;
        
        std::set<ComponentCondition> conditions;
        
        std::map<ComponentCondition, ComponentCondition> future_transitions;
        
        std::map<std::pair<ComponentCondition, ComponentCondition>, unsigned long> transitions;
        
        std::map<ComponentTemplate::DataEffect, std::string> stringdata;
        
        Containers::Hashmap<ComponentTemplate::DataEffect, const Graphics::Drawable> imagedata;
        
        std::map<ComponentTemplate::RepeatMode, std::vector<std::array<float, 4>>> repeats;
        
        std::map<ComponentTemplate::RepeatMode, std::map<int, ComponentCondition>> repeatconditions; 
        
        std::array<float, 4> value ={{0.f, 0.f, 0.f, 0.f}};
 
        std::array<float, 4> targetvalue = {{0.f, 0.f, 0.f, 0.f}};
        
        std::array<float, 4> valuespeed = {{0.f, 0.f, 0.f, 0.f}};
        
        bool returntarget = false;
 
        int stackcapacity = 3;
        
        int indices = 0;
 
        bool updaterequired = false;
        
        bool handlingmouse = false;
 
        Geometry::Size size;
        
        const Template &temp;
 
        Containers::Hashmap<const ComponentTemplate *, ComponentStack> substacks;
 
        std::map<const ComponentTemplate*, ComponentStorage*> storage;
        std::map<const ComponentTemplate*, std::vector<Component>> repeated;
        std::map<ComponentTemplate::Tag, Geometry::Size> tagsizes;
        std::map<ComponentTemplate::Tag, Geometry::Point> taglocations;
        std::set<ComponentTemplate::Tag> tagnowrap;
 
        Animation::Timer controller;
        
        Graphics::Layer base;
        Input::Layer mouse;
        Input::Mouse::Button mousebuttonaccepted;
        Geometry::Point downlocation;
        
        std::function<void(ComponentTemplate::Tag, Geometry::Point, Input::Mouse::Button)> down_fn;
        std::function<void(ComponentTemplate::Tag, Geometry::Point, Input::Mouse::Button)> click_fn;
        std::function<void(ComponentTemplate::Tag, Geometry::Point, Input::Mouse::Button)> up_fn;
        std::function<void(ComponentTemplate::Tag, Geometry::Point)> move_fn;
        std::function<void(ComponentTemplate::Tag)> over_fn;
        std::function<void(ComponentTemplate::Tag)> out_fn;
        std::function<bool(ComponentTemplate::Tag, Input::Mouse::EventType, Geometry::Point, float)> other_fn; //scroll, zoom, rotate
        std::function<void()> value_fn;
        std::function<void()> frame_fn;
        std::function<void()> beforeupdate_fn;
        std::function<void()> update_fn;
        std::function<void()> render_fn;
        
        std::map<ComponentTemplate::Tag, std::function<Widget *(const Template &)>> widgetgenerators;
        Containers::Hashmap<const ComponentTemplate *, Widget> widgets;
        
        std::function<std::string(int ind, ComponentTemplate::DataEffect, const std::array<float, 4> &value)> valuetotext;
        
        LayerAdapter adapter;
    };
 
}}