Pointer.h

Go to the documentation of this file.

#pragma once
 
#include "Drawables.h"
#include "../Utils/Assert.h"
#include "../Geometry/Point.h"
#include "../Containers/Hashmap.h"
#include "Animations.h"
#include "TextureAnimation.h"
 
 
namespace Gorgon { namespace Graphics {
 
    class Pointer : virtual public Drawable {
    public:
 
        virtual ~Pointer() {
        }
        
    protected:
    };
 
    class DrawablePointer : public Pointer {
    public:
        DrawablePointer() = default;
 
        DrawablePointer(const Drawable &image, int x, int y) : DrawablePointer(image, {x, y}) {}
 
        DrawablePointer(const Drawable &image, Geometry::Point hotspot) :
            image(&image), hotspot(hotspot) {}
 
        DrawablePointer(const AssumeOwnershipTag &tag, const Drawable &image, int x, int y) : DrawablePointer(tag, image, {x, y}) {}
 
        DrawablePointer(const AssumeOwnershipTag &, const Drawable &image, Geometry::Point hotspot) :
            image(&image), hotspot(hotspot) { owner = true; }
 
        DrawablePointer(const DrawablePointer &other) = delete;
 
        DrawablePointer(DrawablePointer &&other) :
            image(other.image), hotspot(other.hotspot), owner(other.owner) {
            other.image = nullptr;
            other.owner = false;
        }
 
        DrawablePointer &operator =(const DrawablePointer &) = delete;
 
        DrawablePointer &operator =(DrawablePointer &&other) {
            RemoveImage();
            image   = other.image;
            owner   = other.owner;
            hotspot = other.hotspot;
 
            other.image = nullptr;
            other.owner = false;
 
            return *this;
        }
 
        //Pointer(Resource::Pointer &pointer);
 
        ~DrawablePointer() {
            RemoveImage();
        }
 
 
        bool HasImage() const {
            return image != nullptr;
        }
 
        const Drawable &GetImage() const {
            ASSERT(image, "Pointer image is not set");
 
            return *image;
        }
 
        void SetImage(const Drawable &value) {
            RemoveImage();
 
            image = &value;
        }
 
        void Assume(const Drawable &value) {
            RemoveImage();
 
            image = &value;
            owner = true;
        }
 
        void Assume(const Drawable &value, Geometry::Point hotspot) {
            RemoveImage();
 
            image = &value;
            owner = true;
            this->hotspot = hotspot;
        }
 
        void Assume(const Drawable &value, int x, int y) {
            RemoveImage();
 
            image = &value;
            owner = true;
            this->hotspot = {x, y};
        }
 
        void RemoveImage() {
            if(owner) {
                delete image;
                owner = false;
            }
 
            image = nullptr;
        }
 
        const Drawable &Release() {
            auto img = image;
 
            owner = false;
            image = nullptr;
 
            return *img;
        }
 
 
    protected:
        void draw(Gorgon::Graphics::TextureTarget &target, const Geometry::Pointf &p, Gorgon::Graphics::RGBAf color) const override {
            if(!image) return;
 
            image->Draw(target, p-hotspot, color);
        }
 
    private:
        const Drawable *image = nullptr;
        Geometry::Point hotspot ={0, 0};
 
        bool owner = false;
    };
 
    template<class A_>
    class basic_PointerProvider;
 
    template<class A_>
    class basic_AnimatedPointer : public virtual Pointer, public virtual A_::AnimationType {
    public:
        basic_AnimatedPointer(const basic_PointerProvider<A_> &parent, typename A_::AnimationType &anim) :
            A_::AnimationType(parent, false), anim(&anim), parent(parent)
        { }
 
        basic_AnimatedPointer(const basic_AnimatedPointer &) = delete;
 
        basic_AnimatedPointer(basic_AnimatedPointer &&other) : A_::AnimationType(other.parent, false), anim(other.anim), parent(other.parent) {
            other.anim = nullptr;
        }
 
        ~basic_AnimatedPointer() {
            if(anim)
                anim->DeleteAnimation();
        }
 
        void SetController(Gorgon::Animation::ControllerBase &controller) override {
            ASSERT(anim, "Trying to use a moved out pointer");
 
            anim->SetController(controller);
        }
        
        bool HasController() const override {
            ASSERT(anim, "Trying to use a moved out pointer");
 
            return anim->HasController();
        }
 
        Gorgon::Animation::ControllerBase &GetController() const {
            ASSERT(anim, "Trying to use a moved out pointer");
 
            return anim->GetController();
        }
 
        void RemoveController() const {
            ASSERT(anim, "Trying to use a moved out pointer");
 
            anim->RemoveController();
        }
 
    protected:
        void draw(Gorgon::Graphics::TextureTarget &target, const Geometry::Pointf &p, Gorgon::Graphics::RGBAf color) const override;
 
        const basic_PointerProvider<A_> &parent;
        typename A_::AnimationType *anim;
    };
    
    template<class A_>
    class basic_PointerProvider : public A_ {
    public:
        using AnimationType = basic_AnimatedPointer<A_>;
 
        explicit basic_PointerProvider(Geometry::Point hotspot = {0,0}) :
        hotspot(hotspot) {
        }
        
        basic_PointerProvider(basic_PointerProvider &&other) :
        hotspot(other.hotspot), owned(other.owned) {
            other.owned = false;
        }
        
        basic_PointerProvider(const basic_PointerProvider &) = delete;
        
        virtual ~basic_PointerProvider() {
        }
 
        AnimationType CreatePointer(Gorgon::Animation::Timer &timer) const {
            return AnimationType(*this, A_::CreateAnimation(timer));
        }
 
        AnimationType CreatePointer(bool create = true) const {
            return AnimationType(*this, A_::CreateAnimation(create));
        }
 
        AnimationType &CreateAnimation(Gorgon::Animation::ControllerBase &timer) const override {
            return *new basic_AnimatedPointer<A_>(*this, A_::CreateAnimation(timer));
        }
 
        AnimationType &CreateAnimation(bool create = true) const override {
            return *new basic_AnimatedPointer<A_>(*this, A_::CreateAnimation(create));
        }
 
        Geometry::Point GetHotspot() const {
            return hotspot;
        }
        
        void SetHotspot(Geometry::Point value) {
            hotspot = value;
        }
        
    protected:        
        Geometry::Point hotspot;
        
        bool owned;
    };
 
    using PointerProvider = basic_PointerProvider<AnimationProvider>;
    using BitmapPointerProvider = basic_PointerProvider<BitmapAnimationProvider>;
    using ConstBitmapPointerProvider = basic_PointerProvider<ConstBitmapAnimationProvider>;
 
    enum class PointerType {
        None=0,
        
        Arrow=1,
        
        Wait=2,
        
        No=3,
        
        Text=4,
        
        Hand=5,
        
        Drag=6
    };
        
 
    class PointerStack {
    public:
        
        class Token {
            friend class PointerStack;
        public:
            Token() { }
            
            Token(Token &&other) {
                parent = other.parent;
                ind = other.ind;
                
                other.parent = nullptr;
                other.ind = 0;
            }
            
            ~Token() {
                if(parent)
                    parent->Reset(*this);
            }
            
            Token &operator =(Token &&tok) {
                if(parent)
                    parent->Reset(*this);
                
                parent = tok.parent;
                ind = tok.ind;
                
                tok.parent = nullptr;
                tok.ind = 0;
                
                return *this;
            }
            
            bool IsNull() const { return parent == nullptr; }
            
            explicit operator bool() const { return !IsNull(); }
            
            bool operator !() const { return IsNull(); }
            
        private:
            Token(PointerStack *parent, int ind) : parent(parent), ind(ind) { }
            
            PointerStack *parent = nullptr;
            int ind = 0;
        };
 
        PointerStack() = default;
 
        PointerStack(const PointerStack &) = delete;
 
        PointerStack(PointerStack &&other) {
            Swap(other);
        }
 
        void Swap(PointerStack &other) {
            using std::swap;
 
            swap(lastind, other.lastind);
            swap(stack, other.stack);
            swap(pointers, other.pointers);
        }
 
        ~PointerStack() {
            for(auto &w : pointers) {
                if(w.owned)
                    delete w.ptr;
            }
        }
 
        void Add(PointerType type, const Pointer &pointer);
 
        void Add(PointerType type, const Pointer &&pointer) {
            Assume(type, pointer);
        }
 
        void Assume(PointerType type, const Pointer &pointer);
        
        void Add(PointerType type, const Drawable &image, Geometry::Point hotspot);
 
        void Add(PointerType type, const Drawable &&image, Geometry::Point hotspot) = delete;
 
        bool Exists(PointerType type) {
            if((int)type <= 0 || (int)type > (int)PointerType::Drag) return false;
            
            return pointers[(int)type].ptr != nullptr;
        }
        
        Token Set(PointerType type);
        
        Token Set(const Pointer &pointer);
        
        void Reset(Token &token);
        
        const Pointer &Current() const;
        
        bool IsValid() const;
        
    private:
        struct Wrapper {
            const Pointer *ptr = nullptr;
            bool owned = false;
        };
        
        int lastind = 0;
        
        Containers::Hashmap<int, const Pointer> stack;
        
        std::array<Wrapper, (int)PointerType::Drag+1> pointers = {};
    };
    
 
    template<class A_>
    void basic_AnimatedPointer<A_>::draw(Gorgon::Graphics::TextureTarget &target, const Geometry::Pointf &p, Gorgon::Graphics::RGBAf color) const {
        ASSERT(anim, "Try to use a moved out pointer");
 
        anim->Draw(target, p-parent.GetHotspot(), color);
    }
 
} }