Layer.h

Go to the documentation of this file.

#pragma once
 
#include "Containers/Collection.h"
#include "ConsumableEvent.h"
#include "Geometry/Point.h"
#include "Geometry/Bounds.h"
#include "Geometry/Transform3D.h"
#include "Input/Mouse.h"
 
namespace Gorgon {
    class Layer;
 
    extern Geometry::Transform3D Transform;
 
    extern Geometry::Bounds        Clip;
 
    extern Geometry::Point         Offset;
    
    class MouseHandler {
    public:
        MouseHandler(MouseHandler &&other) {
            layers.Swap(other.layers);
        }
        
        MouseHandler &operator =(MouseHandler &&other) {
            layers.Swap(other.layers);
            
            return *this;
        }
        
        explicit MouseHandler(Layer *layer = nullptr) {
            if(layer) layers.Add(layer);
        }
        
        operator Layer *() const {
            if(layers.GetSize())
                return &layers[0];
            else
                return nullptr;
        }
        
        operator bool() const {
            return layers.GetCount() > 0;
        }
        
        void Clear() {
            layers.Clear();
        }
        
        void Add(Layer *l) {
            layers.Add(l);
        }
        
        void Swap(MouseHandler &other) {
            layers.Swap(other.layers);
        }
        
        Containers::Collection<Layer> layers;
    };
 
    inline void ResetTransform(const Geometry::Size &size) {
        Transform={};
        Transform.Translate({-1.0f, 1.0f, 0});
        Transform.Scale(2.0f / size.Width, -2.0f / size.Height, 1.0f);
    }
 
    class Layer {
    public:
        
        Layer(const Geometry::Bounds &bounds) :
            Children(children),
            bounds(bounds)
        { }
 
        Layer() : Layer(EntireRegion) { }
 
        Layer(const Geometry::Point &location) :
        Layer({location, Geometry::Size::Max()})
        { }
        
        Layer(const Layer&) = delete;
        
        Layer(Layer &&other) : Children(children) {
            Swap(other);
        }
        
        Layer &operator =(const Layer &)=delete;
        
        Layer &operator =(Layer &&other) {
            if(parent)
                parent->Remove(this);
            
            while(children.GetSize())
                Remove(*children.First());
            
            Swap(other);
            
            return *this;
        }
 
        virtual ~Layer();
        
        void Swap(Layer &other) {
            using std::swap;
            
            if(this == &other) return;
            
            swap(bounds, other.bounds);
            swap(isvisible, other.isvisible);
            swap(children, other.children);
            
            for(auto &l : children)
                l.parent = this;
            
            for(auto &l : other.children)
                l.parent = &other;
            
            if(parent==other.parent) return;
            
            auto myparent = parent;
            auto otherparent = other.parent;
            
            int myind = -1;
            int otherind = -1;
            
            if(myparent) {
                myind = myparent->Children.FindLocation(this);
            }
            
            if(otherparent) {
                otherind = otherparent->Children.FindLocation(other);
            }
            
            if(myparent) {
                myparent->Remove(this);
                myparent->Insert(other, myind);
            }
            
            if(otherparent) {
                otherparent->Remove(other);
                otherparent->Insert(this, otherind);
            }
        }
 
        
        void Add(Layer &layer);
 
        void Add(Layer *layer) {
            if(!layer) return;
            
            Add(*layer);
        }
 
        void setname(std::string value) {
#ifndef NDEBUG
            name = value;
#endif
        }
        
        void Insert(Layer &layer, long under);
        
        void Insert(Layer *layer, long under) {
            if(!layer) return;
            
            Insert(*layer, under);
        }
 
        void Remove(Layer &layer) {
            children.Remove(layer);
            
            removed(layer);
            layer.located(nullptr);
            layer.parent = nullptr;
        }
        
        void Remove(Layer *layer) {
            if(!layer) return;
            
            Remove(*layer);
        }
        
        bool HasParent() const {
            return parent!=nullptr;
        }
        
        virtual Layer &GetParent() const {
            if(!parent) throw std::runtime_error("No parent is set");
            
            return *parent;
        }
 
        Layer &GetTopLevel() const {
            if(!parent) 
                return const_cast<Layer &>(*this);
 
            return parent->GetTopLevel();
        }
        
        virtual Geometry::Point TranslateToTopLevel(Geometry::Point location = {0, 0}) const {
            const Layer *cur = this;
            while(cur->HasParent()) {
                location += cur->GetLocation();
                cur = &cur->GetParent();
            }
            
            return location;
        }
 
        Layer &GetTopLevel() {
            if(!parent) return *this;
 
            return parent->GetTopLevel();
        }
        
        
        Containers::Collection<Layer>::ConstIterator begin() const {
            return children.begin();
        }
        
        Containers::Collection<Layer>::ConstIterator end() const {
            return children.end();
        }
        
        Containers::Collection<Layer>::ConstIterator First() const {
            return children.First();
        }
        
        Containers::Collection<Layer>::ConstIterator Last() const {
            return children.Last();
        }
 
        
 
        void PlaceBefore(int before) {
            if(parent) {
                if(before==parent->children.GetCount()) before --;
                
                parent->children.MoveBefore(*this, before++);
            }
        }
 
        void PlaceToTop() {
            if(parent)
                parent->children.MoveBefore(*this, parent->children.GetCount());
        }
 
        void PlaceToBottom() {
            if(parent)
                parent->children.MoveBefore(*this, 0);
        }
 
        int GetOrder() const { 
            if(parent)
                return parent->children.FindLocation(this);
            else
                return -1;
        }
 
 
        virtual void Move(const Geometry::Point &location) {
            bounds.Move(location);
        }
 
        virtual void Move(int x, int y) {
            bounds.Move({x, y});
        }
 
        virtual void Resize(const Geometry::Size &size) {
            bounds.Resize(size);
        }
 
        virtual void Resize(int width, int height) {
            bounds.Resize({width, height});
        }
 
        void SetWidth(int width) {
            bounds.SetWidth(width);
        }
 
        void SetHeight(int height) {
            bounds.SetHeight(height);
        }
 
        void SetBounds(const Geometry::Bounds &bounds) {
            this->bounds=bounds;
        }
        
        Geometry::Size GetSize() const {
            return bounds.GetSize();
        }
        
        Geometry::Size GetCalculatedSize() const {
            if(!parent)
                return bounds.GetSize();
            
            auto ps = parent->GetCalculatedSize();
            auto s = GetSize();
            auto p = GetLocation();
            
            
 
            if(s.Width == 0) {
                s.Width = ps.Width;
                s.Width -= p.X;
            }
 
            if(s.Height == 0) {
                s.Height = ps.Height;
                s.Height -= p.Y;
            }
 
            return s;
        }
        
        int GetWidth() const {
            return bounds.Width();
        }
 
        int GetHeight() const {
            return bounds.Height();
        }
 
        Geometry::Point GetLocation() const {
            return bounds.TopLeft();
        }
 
        int GetLeft() const {
            return bounds.Left;
        }
 
        int GetTop() const {
            return bounds.Top;
        }
        
        Geometry::Bounds GetBounds() const {
            return bounds;
        }
 
        Geometry::Bounds GetEffectiveBounds() const {
            if(!parent)
                return bounds;
 
            auto p = GetLocation();
            auto s = GetSize();
 
            auto pb = parent->GetEffectiveBounds();
 
            if(s == Geometry::Size(0, 0)) {
                s = pb.GetSize();
                s.Width  -= p.X;
                s.Height -= p.Y;
            }
            else {
                auto w = pb.Width() - p.X;
                auto h = pb.Height() - p.Y;
 
                if(s.Width > w)
                    s.Width = w;
                
                if(s.Height > h)
                    s.Height = h;
            }
 
            return {p, s};
        }
 
        virtual void Show() { isvisible=true; }
 
        virtual void Hide() { isvisible=false; }
        
        virtual bool IsVisible() const { 
            if(parent && !parent->isvisible) return false;
            
            return isvisible;
        }
 
        virtual bool propagate_mouseevent(Input::Mouse::EventType evet, Geometry::Point location, Input::Mouse::Button button, float amount, MouseHandler &handlers);
        
        virtual void Render();
        
        const Containers::Collection<Layer> &Children;
        
        static const Geometry::Bounds EntireRegion;
 
    protected:
 
        virtual void added(Layer &layer) { }
        
        virtual void removed(Layer &layer) { }
        
        virtual void located(Layer *parent) { }
 
        void dotransformandclip(bool inverse = false);
 
        void reverttransformandclip();
        
        Containers::Collection<Layer> children;
        
        Layer *parent = nullptr;
 
        Geometry::Bounds bounds;
 
        bool isvisible =true; 
 
#ifndef NDEBUG
        std::string name;
#endif
 
    };
 
}