StackedObject.h

Go to the documentation of this file.

#pragma once
 
#include "AnimationStorage.h"
#include "../Graphics/StackedObject.h"
 
 
namespace Gorgon { namespace Resource {
    class File;
    class Reader;
 
    class StackedObject : public Graphics::IStackedObjectProvider, public AnimationStorage {
    public:
        explicit StackedObject(Graphics::StackedBitmapProvider &prov);
 
        explicit StackedObject(Graphics::StackedBitmapAnimationProvider &prov);
 
        explicit StackedObject(Graphics::StackedObjectProvider &prov);
        
        explicit StackedObject(Graphics::StackedBitmapProvider &&prov) : StackedObject(*new Graphics::StackedBitmapProvider(std::move(prov))) {
            own = true;
        }
 
        explicit StackedObject(Graphics::StackedBitmapAnimationProvider &&prov) : StackedObject(*new Graphics::StackedBitmapAnimationProvider(std::move(prov))) {
            own = true;
        }
 
        explicit StackedObject(Graphics::StackedObjectProvider &&prov) : StackedObject(*new Graphics::StackedObjectProvider(std::move(prov))) {
            own = true;
        }
        
        StackedObject() { }
        
        IStackedObjectProvider &MoveOutProvider() override;
 
        GID::Type GetGID() const override {
            return GID::StackedObject;
        }
 
        void SetProvider(Graphics::StackedBitmapProvider &value) {
            RemoveProvider();
            prov = &value;
        }
 
        void SetProvider(Graphics::StackedBitmapAnimationProvider &value) {
            RemoveProvider();
            prov = &value;
        }
 
        void SetProvider(Graphics::StackedObjectProvider &value) {
            RemoveProvider();
            prov = &value;
        }
        
        void AssumeProvider(Graphics::StackedBitmapProvider &value) {
            RemoveProvider();
            prov = &value;
            own = true;
        }
 
        void AssumeProvider(Graphics::StackedBitmapAnimationProvider &value) {
            RemoveProvider();
            prov = &value;
            own = true;
        }
 
        void AssumeProvider(Graphics::StackedObjectProvider &value) {
            RemoveProvider();
            prov = &value;
            own = true;
        }
        
        void RemoveProvider() {
            if(own)
                delete prov;
            
            own = false;
            
            prov = nullptr;
        }
 
        virtual Graphics::RectangularAnimation &CreateTop() const override {
            if(!prov)
                throw std::runtime_error("Provider is not set.");
 
            return prov->CreateTop();
        }
 
        virtual Graphics::RectangularAnimation &CreateBottom() const override {
            if(!prov)
                throw std::runtime_error("Provider is not set.");
 
            return prov->CreateBottom();
        }
        
        virtual Geometry::Point GetOffset() const override {
            if(!prov)
                throw std::runtime_error("Provider is not set.");
 
            return prov->GetOffset();
        }
        
        virtual void SetOffset(const Geometry::Point &value) override {
            if(!prov)
                throw std::runtime_error("Provider is not set.");
 
            return prov->SetOffset(value);
        }
 
        virtual Graphics::StackedObject &CreateAnimation(Gorgon::Animation::ControllerBase &timer) const override {
            if(!prov)
                throw std::runtime_error("Provider is not set.");
 
            return dynamic_cast<Gorgon::Graphics::StackedObject &>(prov->CreateAnimation(timer));
        }
        
        virtual Graphics::StackedObject &CreateAnimation(bool create=true) const override {
            if(!prov)
                throw std::runtime_error("Provider is not set.");
 
            return dynamic_cast<Gorgon::Graphics::StackedObject &>(prov->CreateAnimation(create));
        }
 
        virtual Geometry::Size GetSize() const override {
            if(!prov)
                throw std::runtime_error("Provider is not set.");
 
            return prov->GetSize();
        }
 
        static StackedObject *LoadResource(std::weak_ptr<File> file, std::shared_ptr<Reader> reader, unsigned long size);
        
        static void SaveThis(Writer &writer, const Graphics::IStackedObjectProvider &provider);
 
    protected:
        void save(Writer &writer) const override;
 
        virtual Graphics::RectangularAnimationStorage animmoveout() override;
 
    private:
        virtual ~StackedObject() { 
            if(own) 
                delete prov;
        }
 
        IStackedObjectProvider *prov = nullptr;
        
        bool own = false;
    };
} }