DnD.h

Go to the documentation of this file.

#pragma once
 
#include <string>
 
#include "./Layer.h"
#include "../Resource/GID.h"
#include "../Event.h"
#include "../DataExchange.h"
 
namespace Gorgon {
    class Window;
}
 
namespace Gorgon { namespace Input {
    
    class DragInfo;
    
    class DropTarget : public Gorgon::Layer {
        friend void Drop(Geometry::Point location);
        friend void CancelDrag();
        friend class Gorgon::Window;
    public:
        using Gorgon::Layer::Layer;
 
        //BEGIN Event handling
        
 
        void SetHitCheck(std::function<bool(DropTarget &, Geometry::Point)> fn) {
            hitcheck = fn;
        }
        
        void SetHitCheck(std::function<bool(Geometry::Point)> fn) {
            hitcheck = [fn](DropTarget &, Geometry::Point point) { return fn(point); };
        }
 
        template<class C_>
        void SetHitCheck(C_ &c, bool(C_::*fn)(DropTarget &, Geometry::Point)) {
            C_ *my = &c;
            hitcheck = [fn, my](DropTarget &layer, Geometry::Point point) { return my->fn(layer, point); };
        }
        
        template<class C_>
        void SetHitCheck(C_ &c, bool(C_::*fn)(Geometry::Point)) {
            C_ *my = &c;
            hitcheck = [fn, my](DropTarget &, Geometry::Point point) { return my->fn(point); };
        }
 
        template<class C_>
        void SetHitCheck(C_ *my, bool(C_::*fn)(DropTarget &, Geometry::Point)) {
            hitcheck = [fn, my](DropTarget &layer, Geometry::Point point) { return my->fn(layer, point); };
        }
        
        template<class C_>
        void SetHitCheck(C_ *my, bool(C_::*fn)(Geometry::Point)) {
            hitcheck = [fn, my](DropTarget &, Geometry::Point point) { return my->fn(point); };
        }
        
        void ResetHitCheck() {
            hitcheck = {};
        }
 
 
 
        void SetOver(std::function<bool(DropTarget &, DragInfo &)> fn) {
            over = fn;
        }
 
        void SetOver(std::function<bool(DragInfo &)> fn) {
            over = [fn](DropTarget &, DragInfo &data) { return fn(data); };
        }
 
        template<class C_>
        void SetOver(C_ &c, bool(C_::*fn)(DropTarget &, DragInfo &)) {
            C_ *my = &c;
            over = [fn, my](DropTarget &layer, DragInfo &data) { return my->fn(layer, data); };
        }
 
        template<class C_>
        void SetOver(C_ &c, bool(C_::*fn)(DragInfo &)) {
            C_ *my = &c;
            over = [fn, my](DropTarget &, DragInfo &data) { return my->fn(data); };
        }
 
        template<class C_>
        void SetOver(C_ *my, bool(C_::*fn)(DropTarget &, DragInfo &)) {
            over = [fn, my](DropTarget &layer, DragInfo &data) { return my->fn(layer, data); };
        }
 
        template<class C_>
        void SetOver(C_ *my, bool(C_::*fn)(DragInfo &)) {
            over = [fn, my](DropTarget &, DragInfo &data) { return my->fn(data); };
        }
 
        void ResetOver() {
            over = {};
        }
 
 
 
        void SetOut(std::function<void(DropTarget &, DragInfo &)> fn) {
            out = fn;
        }
 
        void SetOut(std::function<void(DragInfo &)> fn) {
            out = [fn](DropTarget &, DragInfo &data) { return fn(data); };
        }
 
        template<class C_>
        void SetOut(C_ &c, void(C_::*fn)(DropTarget &, DragInfo &)) {
            C_ *my = &c;
            out = [fn, my](DropTarget &layer, DragInfo &data) { return my->fn(layer, data); };
        }
 
        template<class C_>
        void SetOut(C_ &c, void(C_::*fn)(DragInfo &)) {
            C_ *my = &c;
            out = [fn, my](DropTarget &, DragInfo &data) { return my->fn(data); };
        }
 
        template<class C_>
        void SetOut(C_ *my, void(C_::*fn)(DropTarget &, DragInfo &)) {
            out = [fn, my](DropTarget &layer, DragInfo &data) { return my->fn(layer, data); };
        }
 
        template<class C_>
        void SetOut(C_ *my, void(C_::*fn)(DragInfo &)) {
            out = [fn, my](DropTarget &, DragInfo &data) { return my->fn(data); };
        }
 
        void ResetOut() {
            out = {};
        }
 
 
 
        void SetMove(std::function<bool(DropTarget &, DragInfo &, Geometry::Point)> fn) {
            move = fn;
        }
 
        void SetMove(std::function<bool(DragInfo &, Geometry::Point)> fn) {
            move = [fn](DropTarget &, DragInfo &data, Geometry::Point p) { return fn(data, p); };
        }
 
        template<class C_>
        void SetMove(C_ &c, bool(C_::*fn)(DropTarget &, DragInfo &, Geometry::Point)) {
            C_ *my = &c;
            move = [fn, my](DropTarget &layer, DragInfo &data, Geometry::Point p) { return my->fn(layer, data, p); };
        }
 
        template<class C_>
        void SetMove(C_ &c, bool(C_::*fn)(DragInfo &, Geometry::Point)) {
            C_ *my = &c;
            move = [fn, my](DropTarget &, DragInfo &data, Geometry::Point p) { return my->fn(data, p); };
        }
 
        template<class C_>
        void SetMove(C_ *my, bool(C_::*fn)(DropTarget &, DragInfo &, Geometry::Point)) {
            move = [fn, my](DropTarget &layer, DragInfo &data, Geometry::Point p) { return my->fn(layer, data, p); };
        }
 
        template<class C_>
        void SetMove(C_ *my, bool(C_::*fn)(DragInfo &, Geometry::Point)) {
            move = [fn, my](DropTarget &, DragInfo &data, Geometry::Point p) { return my->fn(data, p); };
        }
 
        void SetMove(std::function<bool(DropTarget &, DragInfo &)> fn) {
            move = [fn](DropTarget &layer, DragInfo &data, Geometry::Point p) { return fn(layer, data); };
        }
 
        void SetMove(std::function<bool(DragInfo &)> fn) {
            move = [fn](DropTarget &, DragInfo &data, Geometry::Point p) { return fn(data); };
        }
 
        template<class C_>
        void SetMove(C_ &c, bool(C_::*fn)(DropTarget &, DragInfo &)) {
            C_ *my = &c;
            move = [fn, my](DropTarget &layer, DragInfo &data, Geometry::Point p) { return my->fn(layer, data); };
        }
 
        template<class C_>
        void SetMove(C_ &c, bool(C_::*fn)(DragInfo &)) {
            C_ *my = &c;
            move = [fn, my](DropTarget &, DragInfo &data, Geometry::Point p) { return my->fn(data); };
        }
 
        template<class C_>
        void SetMove(C_ *my, bool(C_::*fn)(DropTarget &, DragInfo &)) {
            move = [fn, my](DropTarget &layer, DragInfo &data, Geometry::Point p) { return my->fn(layer, data); };
        }
 
        template<class C_>
        void SetMove(C_ *my, bool(C_::*fn)(DragInfo &)) {
            move = [fn, my](DropTarget &, DragInfo &data, Geometry::Point p) { return my->fn(data); };
        }
 
        void ResetMove() {
            move ={};
        }
 
 
 
        void SetDrop(std::function<bool(DropTarget &, DragInfo &, Geometry::Point)> fn) {
            drop = fn;
        }
 
        void SetDrop(std::function<bool(DragInfo &, Geometry::Point)> fn) {
            drop = [fn](DropTarget &, DragInfo &data, Geometry::Point p) { return fn(data, p); };
        }
 
        template<class C_>
        void SetDrop(C_ &c, bool(C_::*fn)(DropTarget &, DragInfo &, Geometry::Point)) {
            C_ *my = &c;
            drop = [fn, my](DropTarget &layer, DragInfo &data, Geometry::Point p) { return my->fn(layer, data, p); };
        }
 
        template<class C_>
        void SetDrop(C_ &c, bool(C_::*fn)(DragInfo &, Geometry::Point)) {
            C_ *my = &c;
            drop = [fn, my](DropTarget &, DragInfo &data, Geometry::Point p) { return my->fn(data, p); };
        }
 
        template<class C_>
        void SetDrop(C_ *my, bool(C_::*fn)(DropTarget &, DragInfo &, Geometry::Point)) {
            drop = [fn, my](DropTarget &layer, DragInfo &data, Geometry::Point p) { return my->fn(layer, data, p); };
        }
 
        template<class C_>
        void SetDrop(C_ *my, bool(C_::*fn)(DragInfo &, Geometry::Point)) {
            drop = [fn, my](DropTarget &, DragInfo &data, Geometry::Point p) { return my->fn(data, p); };
        }
 
        void SetDrop(std::function<bool(DropTarget &, DragInfo &)> fn) {
            drop = [fn](DropTarget &layer, DragInfo &data, Geometry::Point p) { return fn(layer, data); };
        }
 
        void SetDrop(std::function<bool(DragInfo &)> fn) {
            drop = [fn](DropTarget &, DragInfo &data, Geometry::Point) { return fn(data); };
        }
 
        template<class C_>
        void SetDrop(C_ &c, bool(C_::*fn)(DropTarget &, DragInfo &)) {
            C_ *my = &c;
            drop = [fn, my](DropTarget &layer, DragInfo &data, Geometry::Point) { return my->fn(layer, data); };
        }
 
        template<class C_>
        void SetDrop(C_ &c, bool(C_::*fn)(DragInfo &)) {
            C_ *my = &c;
            drop = [fn, my](DropTarget &, DragInfo &data, Geometry::Point) { return my->fn(data); };
        }
 
        template<class C_>
        void SetDrop(C_ *my, bool(C_::*fn)(DropTarget &, DragInfo &)) {
            drop = [fn, my](DropTarget &layer, DragInfo &data, Geometry::Point) { return my->fn(layer, data); };
        }
 
        template<class C_>
        void SetDrop(C_ *my, bool(C_::*fn)(DragInfo &)) {
            drop = [fn, my](DropTarget &, DragInfo &data, Geometry::Point) { return my->fn(data); };
        }
 
        void ResetDrop() {
            drop = {};
        }
 
 
 
        void SetCancel(std::function<void(DropTarget &, DragInfo &)> fn) {
            cancel = fn;
        }
 
        void SetCancel(std::function<void(DragInfo &)> fn) {
            cancel = [fn](DropTarget &, DragInfo &data) { return fn(data); };
        }
 
        template<class C_>
        void SetCancel(C_ &c, void(C_::*fn)(DropTarget &, DragInfo &)) {
            C_ *my = &c;
            cancel = [fn, my](DropTarget &layer, DragInfo &data) { return my->fn(layer, data); };
        }
 
        template<class C_>
        void SetCancel(C_ &c, void(C_::*fn)(DragInfo &)) {
            C_ *my = &c;
            cancel = [fn, my](DropTarget &, DragInfo &data) { return my->fn(data); };
        }
 
        template<class C_>
        void SetCancel(C_ *my, void(C_::*fn)(DropTarget &, DragInfo &)) {
            cancel = [fn, my](DropTarget &layer, DragInfo &data) { return my->fn(layer, data); };
        }
 
        template<class C_>
        void SetCancel(C_ *my, void(C_::*fn)(DragInfo &)) {
            cancel = [fn, my](DropTarget &, DragInfo &data) { return my->fn(data); };
        }
 
        void ResetCancel() {
            cancel = {};
        }
        
        //END
 
    protected:
        std::function<bool(DropTarget &, Geometry::Point)>              hitcheck;
        std::function<bool(DropTarget &, DragInfo &)>                   over;
        std::function<void(DropTarget &, DragInfo &)>                   out;
        std::function<bool(DropTarget &, DragInfo &, Geometry::Point)>  move;
        std::function<bool(DropTarget &, DragInfo &, Geometry::Point)>  drop;
        std::function<void(DropTarget &, DragInfo &)>                   cancel;
 
        Geometry::Transform3D mytransform;
 
 
        virtual bool propagate_mouseevent(Input::Mouse::EventType event, Geometry::Point location, Input::Mouse::Button button, float amount, MouseHandler &handlers) override;
    };
    
    class DragSource {
        friend class DropTarget;
        friend void Drop(Geometry::Point location);
        friend void CancelDrag();
    public:
 
        void SetOver(std::function<bool(DragSource &, DragInfo &)> fn) {
            over = fn;
        }
 
        void SetOver(std::function<bool(DragInfo &)> fn) {
            over = [fn](DragSource &, DragInfo &data) { return fn(data); };
        }
 
        template<class C_>
        void SetOver(C_ &c, bool(C_::*fn)(DragSource &, DragInfo &)) {
            C_ *my = &c;
            over = [fn, my](DragSource &layer, DragInfo &data) { return my->fn(layer, data); };
        }
 
        template<class C_>
        void SetOver(C_ &c, bool(C_::*fn)(DragInfo &)) {
            C_ *my = &c;
            over = [fn, my](DragSource &, DragInfo &data) { return my->fn(data); };
        }
 
        template<class C_>
        void SetOver(C_ *my, bool(C_::*fn)(DragSource &, DragInfo &)) {
            over = [fn, my](DragSource &layer, DragInfo &data) { return my->fn(layer, data); };
        }
 
        template<class C_>
        void SetOver(C_ *my, bool(C_::*fn)(DragInfo &)) {
            over = [fn, my](DragSource &, DragInfo &data) { return my->fn(data); };
        }
 
        void ResetOver() {
            over ={};
        }
 
 
 
        void SetOut(std::function<void(DragSource &, DragInfo &)> fn) {
            out = fn;
        }
 
        void SetOut(std::function<void(DragInfo &)> fn) {
            out = [fn](DragSource &, DragInfo &data) { return fn(data); };
        }
 
        template<class C_>
        void SetOut(C_ &c, void(C_::*fn)(DragSource &, DragInfo &)) {
            C_ *my = &c;
            out = [fn, my](DragSource &layer, DragInfo &data) { return my->fn(layer, data); };
        }
 
        template<class C_>
        void SetOut(C_ &c, void(C_::*fn)(DragInfo &)) {
            C_ *my = &c;
            out = [fn, my](DragSource &, DragInfo &data) { return my->fn(data); };
        }
 
        template<class C_>
        void SetOut(C_ *my, void(C_::*fn)(DragSource &, DragInfo &)) {
            out = [fn, my](DragSource &layer, DragInfo &data) { return my->fn(layer, data); };
        }
 
        template<class C_>
        void SetOut(C_ *my, void(C_::*fn)(DragInfo &)) {
            out = [fn, my](DragSource &, DragInfo &data) { return my->fn(data); };
        }
 
        void ResetOut() {
            out ={};
        }
 
 
 
        void SetMove(std::function<void(DragSource &, DragInfo &, Geometry::Point)> fn) {
            move = fn;
        }
 
        void SetMove(std::function<void(DragInfo &, Geometry::Point)> fn) {
            move = [fn](DragSource &, DragInfo &data, Geometry::Point p) { return fn(data, p); };
        }
 
        template<class C_>
        void SetMove(C_ &c, void(C_::*fn)(DragSource &, DragInfo &, Geometry::Point)) {
            C_ *my = &c;
            move = [fn, my](DragSource &layer, DragInfo &data, Geometry::Point p) { return my->fn(layer, data, p); };
        }
 
        template<class C_>
        void SetMove(C_ &c, void(C_::*fn)(DragInfo &, Geometry::Point)) {
            C_ *my = &c;
            move = [fn, my](DragSource &, DragInfo &data, Geometry::Point p) { return my->fn(data, p); };
        }
 
        template<class C_>
        void SetMove(C_ *my, void(C_::*fn)(DragSource &, DragInfo &, Geometry::Point)) {
            move = [fn, my](DragSource &layer, DragInfo &data, Geometry::Point p) { return my->fn(layer, data, p); };
        }
 
        template<class C_>
        void SetMove(C_ *my, void(C_::*fn)(DragInfo &, Geometry::Point)) {
            move = [fn, my](DragSource &, DragInfo &data, Geometry::Point p) { return my->fn(data, p); };
        }
 
        void SetMove(std::function<void(DragSource &, DragInfo &)> fn) {
            move = [fn](DragSource &layer, DragInfo &data, Geometry::Point p) { return fn(layer, data); };
        }
 
        void SetMove(std::function<void(DragInfo &)> fn) {
            move = [fn](DragSource &, DragInfo &data, Geometry::Point p) { return fn(data); };
        }
 
        template<class C_>
        void SetMove(C_ &c, void(C_::*fn)(DragSource &, DragInfo &)) {
            C_ *my = &c;
            move = [fn, my](DragSource &layer, DragInfo &data, Geometry::Point p) { return my->fn(layer, data); };
        }
 
        template<class C_>
        void SetMove(C_ &c, void(C_::*fn)(DragInfo &)) {
            C_ *my = &c;
            move = [fn, my](DragSource &, DragInfo &data, Geometry::Point p) { return my->fn(data); };
        }
 
        template<class C_>
        void SetMove(C_ *my, void(C_::*fn)(DragSource &, DragInfo &)) {
            move = [fn, my](DragSource &layer, DragInfo &data, Geometry::Point p) { return my->fn(layer, data); };
        }
 
        template<class C_>
        void SetMove(C_ *my, void(C_::*fn)(DragInfo &)) {
            move = [fn, my](DragSource &, DragInfo &data, Geometry::Point p) { return my->fn(data); };
        }
 
        void ResetMove() {
            move ={};
        }
 
 
 
        void SetAccept(std::function<void(DragSource &, DragInfo &)> fn) {
            accept = fn;
        }
 
        void SetAccept(std::function<void(DragInfo &)> fn) {
            accept = [fn](DragSource &, DragInfo &data) { return fn(data); };
        }
 
        template<class C_>
        void SetAccept(C_ &c, void(C_::*fn)(DragSource &, DragInfo &)) {
            C_ *my = &c;
            accept = [fn, my](DragSource &layer, DragInfo &data) { return my->fn(layer, data); };
        }
 
        template<class C_>
        void SetAccept(C_ &c, void(C_::*fn)(DragInfo &)) {
            C_ *my = &c;
            accept = [fn, my](DragSource &, DragInfo &data) { return my->fn(data); };
        }
 
        template<class C_>
        void SetAccept(C_ *my, void(C_::*fn)(DragSource &, DragInfo &)) {
            accept = [fn, my](DragSource &layer, DragInfo &data) { return my->fn(layer, data); };
        }
 
        template<class C_>
        void SetAccept(C_ *my, void(C_::*fn)(DragInfo &)) {
            accept = [fn, my](DragSource &, DragInfo &data) { return my->fn(data); };
        }
 
        void ResetAccept() {
            accept ={};
        }
 
 
        void SetCancel(std::function<void(DragSource &, DragInfo &)> fn) {
            cancel = fn;
        }
 
        void SetCancel(std::function<void(DragInfo &)> fn) {
            cancel = [fn](DragSource &, DragInfo &data) { return fn(data); };
        }
 
        template<class C_>
        void SetCancel(C_ &c, void(C_::*fn)(DragSource &, DragInfo &)) {
            C_ *my = &c;
            cancel = [fn, my](DragSource &layer, DragInfo &data) { return my->fn(layer, data); };
        }
 
        template<class C_>
        void SetCancel(C_ &c, void(C_::*fn)(DragInfo &)) {
            C_ *my = &c;
            cancel = [fn, my](DragSource &, DragInfo &data) { return my->fn(data); };
        }
 
        template<class C_>
        void SetCancel(C_ *my, void(C_::*fn)(DragSource &, DragInfo &)) {
            cancel = [fn, my](DragSource &layer, DragInfo &data) { return my->fn(layer, data); };
        }
 
        template<class C_>
        void SetCancel(C_ *my, void(C_::*fn)(DragInfo &)) {
            cancel = [fn, my](DragSource &, DragInfo &data) { return my->fn(data); };
        }
 
        void ResetCancel() {
            cancel ={};
        }
 
 
    private:
        std::function<bool(DragSource &, DragInfo &)>                   over;
        std::function<void(DragSource &, DragInfo &)>                   out;
        std::function<void(DragSource &, DragInfo &, Geometry::Point)>  move;
        std::function<void(DragSource &, DragInfo &)>                   accept;
        std::function<void(DragSource &, DragInfo &)>                   cancel;
    };
 
    
    class DragInfo {
    public:
        explicit DragInfo(DragSource &source) : source(&source) {}
 
        DragInfo() { }
        
        void AddTextData(const std::string &text);
        
        void AddFileData(const std::string &text);
 
        void AddData(ExchangeData &data);
 
        void AssumeData(ExchangeData &data);
        
        bool HasData(Resource::GID::Type type) const;
        
        void DataReady() {
            std::cout<<"Ready!"<<std::endl;
            dataready = true;
        }
        
        bool IsDataReady() const {
            return dataready;
        }
        
        Containers::Collection<ExchangeData>::Iterator begin() {
            return data.begin();
        }
        
        Containers::Collection<ExchangeData>::Iterator end() {
            return data.end();
        }
        
        ExchangeData &GetData(Resource::GID::Type type) const;
        
        ExchangeData &operator [](int ind) const { return data[ind]; }
        
        int GetSize() const { return (int)data.GetSize(); }
        
        bool HasTarget() const { return active != nullptr; }
        
        DropTarget &GetTarget() const {
            if(!active) throw std::runtime_error("There is no active target.");
            return *active;
        }
        
        void SetTarget(DropTarget &value) { active = &value; }
        
        void RemoveTarget() { active = nullptr; }
 
        bool HasSource() const { return source != nullptr; }
 
        DragSource &GetSource() const {
            if(!source) throw std::runtime_error("There is no source.");
            return *source;
        }
        
        void MarkAsOS() {
            os = true;
        }
        
        bool IsFromOS() {
            return os;
        }
        
        ~DragInfo() {
            destroylist.Destroy();
        }
    private:
        Containers::Collection<ExchangeData> data;
        Containers::Collection<ExchangeData> destroylist;
        
        DragSource *source = nullptr;
        DropTarget *active = nullptr;
        
        bool os = false;
        bool dataready = false;
    };
 
    extern DragInfo *DragOperation;
 
    extern Event<void, DragInfo &> DragStarted;
    
    extern Event<void, DragInfo &, bool> DragEnded;
 
 
    void begindrag(DragSource &source);
    void begindrag();
 
    template<class D_, class ...A_>
    void begindrag(D_ &&data, A_&& ... rest) {
        begindrag(std::forward<A_>(rest)...);
 
        DragOperation->AddData(std::forward<D_>(data));
    }
 
    template<class ...A_>
    void begindrag(const std::string &data, A_&& ... rest) {
        begindrag(std::forward<A_>(rest)...);
 
        DragOperation->AddTextData(data);
    }
    template<class ...A_>
    void begindrag(const char *data, A_&& ... rest) {
        begindrag(std::forward<A_>(rest)...);
 
        DragOperation->AddTextData(data);
    }
 
    template<class ...A_>
    void begindrag(std::string &data, A_&& ... rest) {
        begindrag(std::forward<A_>(rest)...);
 
        DragOperation->AddTextData(data);
    }
    template<class ...A_>
    void begindrag(char *data, A_&& ... rest) {
        begindrag(std::forward<A_>(rest)...);
 
        DragOperation->AddTextData(data);
    }
 
 
    template<class D_, class ...A_>
    void begindrag(DragSource &source, D_ &&data, A_&& ... rest) {
        begindrag(source, std::forward<A_>(rest)...);
 
        DragOperation->AddData(std::forward<D_>(data));
    }
 
    template<class ...A_>
    void begindrag(DragSource &source, const std::string &data, A_&& ... rest) {
        begindrag(source, std::forward<A_>(rest)...);
 
        DragOperation->AddTextData(data);
    }
 
    template<class ...A_>
    void begindrag(DragSource &source, std::string &data, A_&& ... rest) {
        begindrag(source, std::forward<A_>(rest)...);
 
        DragOperation->AddTextData(data);
    }
 
    template<class ...A_>
    void begindrag(DragSource &source, char *data, A_&& ... rest) {
        begindrag(source, std::forward<A_>(rest)...);
 
        DragOperation->AddTextData(data);
    }
 
    template<class ...A_>
    void begindrag(DragSource &source, const char *data, A_&& ... rest) {
        begindrag(source, std::forward<A_>(rest)...);
 
        DragOperation->AddTextData(data);
    }
 
 
    void startdrag();
 
    template<class ...A_>
    DragInfo &BeginDrag(DragSource &source, A_&& ... data) {
        begindrag(source, std::forward<A_>(data)...);
        
        startdrag();
        
        if(sizeof...(data) > 0)
            DragOperation->DataReady();
        
        return *DragOperation;
    }
 
    template<class ...A_>
    inline DragInfo &BeginDrag(A_&& ... data) {
        begindrag(std::forward<A_&&>(data)...);
        
        startdrag();
        
        if(sizeof...(data) > 0)
            DragOperation->DataReady();
 
        return *DragOperation;
    }
 
    void initdrag();
 
    inline DragInfo &PrepareDrag(DragSource &source) {
        DragOperation = new DragInfo(source);
 
        initdrag();
 
        return *DragOperation;
    }
 
    inline DragInfo &PrepareDrag() {
        DragOperation = new DragInfo();
 
        initdrag();
 
        return *DragOperation;
    }
 
    inline DragInfo &StartDrag() {
        startdrag();
 
        return *DragOperation;
    }
 
    extern bool dragstarted;
 
    inline bool IsDragging() {
        return DragOperation != nullptr && dragstarted;
    }
 
    inline bool IsDragPrepared() {
        return DragOperation != nullptr;
    }
 
    inline DragInfo &GetDragOperation() {
        if(!DragOperation)
            throw std::runtime_error("No current drag operation is in progress");
        
        return *DragOperation;
    }
 
    void CancelDrag();
 
    void Drop(Geometry::Point location = {0, 0});
} }