#ifndef TDRAGDROP_INCLUDED

#define TDRAGDROP_INCLUDED

//#include "tw/tw.h"

// #include "tdata.h"

#include "tgeometry.h"

#undef DVAPI

#undef DVVAR

#ifdef TWIN_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

class TDataObject;

class TData;

//////////////////

// Exceptions

//////////////////

class DVAPI TOutOfMemory

{

};

class DVAPI TInitFailed

{

};

class DVAPI TDragDropExpt

{

};

//////////////////

//TDropSource/////

//////////////////

class DVAPI TDropSource

{

#if defined(__GNUC__)

public:

#endif

	class Imp;

#if defined(__GNUC__)

private:

#endif

	Imp *m_imp;

private:

	// not implemented

	TDropSource(const TDropSource &);

	TDropSource &operator=(const TDropSource &);

public:

	enum DropEffect {

		None = 0,

		Copy,

		Move,

		Link,

		CopyScroll,

		MoveScroll,

		LinkScroll

	};

	TDropSource();

	virtual ~TDropSource();

	bool isValid() const;

	DropEffect doDragDrop(const TDataObject &data);

	// viene chiamata durante il drag su un target passando come

	// argomento il valore ritornato dalla onOver() del target

	//virtual CursorToUse setCursor(DropEffect dropEffect);

	virtual void setCursor(DropEffect dropEffect);

};

//////////////////

//TDropTarget/////

//////////////////

//! \brief Ascoltatore degli eventi per il Drag&Drop

class DVAPI TDragDropListener

{

public:

	class Event

	{

	public:

		const TData *const m_data;

		TPoint m_pos;

		unsigned int m_buttonMask;

		Event(TData *data) : m_data(data), m_buttonMask(0){};

	};

	TDragDropListener(){};

	virtual ~TDragDropListener(){};

	//! Funzione per il drop di un file - ingresso nel pannello

	virtual TDropSource::DropEffect onEnter(const Event &event) = 0;

	//! Funzione per il drop di un file - interno al pannello

	virtual TDropSource::DropEffect onOver(const Event &event) = 0;

	//! Funzione per il drop di un file - rilascio del file

	virtual TDropSource::DropEffect onDrop(const Event &event) = 0;

	//! Funzione per il drop di un file - uscita dal pannello

	virtual void onLeave() = 0;

};

//////////////////

//TDataObject/////

//////////////////

class DVAPI TDataObject

{

public:

	class Imp;

	Imp *m_imp;

	// not implemented

	TDataObject(const TDataObject &);

	TDataObject &operator=(const TDataObject &);

public:

	enum DataType {

		Text,

		File,

		Bitmap

	};

	TDataObject();

	~TDataObject();

	//Costruttore per Text

	TDataObject(const std::string &str);

	TDataObject(const std::wstring &str);

	//Costruttore per File

	TDataObject(const std::vector<std::string> &vStr);</std::string>

	TDataObject(const std::vector<std::wstring> &vStr);</std::wstring>

	//Costruttore per dt_bitmap o eventualmente un tipo proprietario

	TDataObject(DataType dataType, const unsigned char *data, const unsigned int dataLen);

	bool getDataTypes(std::vector<datatype> &dataType) const;</datatype>

	bool getData(string &str) const;

	bool getData(std::vector<string> &vStr) const;</string>

	bool getData(DataType dataType, unsigned char *&data, unsigned int *dataLen) const;

	//friend class TDropSource::Imp;

	//friend class TDropTarget::Imp;

	friend class TEnumFormatEtc;

};

// void DVAPI uffa(TWidget *w);

//

// Gestione (discutibilissima) del drag&drop "interno" con tipi speciali

//

// nel dropSource:

//   MyType *data = ...

//   TDNDDataHolder<mytype> holder(data);</mytype>

//   holder.doDragDrop();

//

// nel target

//   if(MyType *data = TDNDDataHolder<mytype>::getCurrentValue())</mytype>

//     {

//     }

class DVAPI TDNDGenericDataHolder

{

protected:

	TDNDGenericDataHolder() {}

	static TDNDGenericDataHolder *m_holder;

public:

	virtual ~TDNDGenericDataHolder() {}

	static bool isDraggingCustomData() { return m_holder != 0; }

	TDropSource::DropEffect doDragDrop();

};

template <class t=""></class>

class TDNDDataHolder : public TDNDGenericDataHolder

{

	T *m_value;

	string m_name;

public:

	TDNDDataHolder(T *value, string name = "") : m_value(value), m_name(name) { m_holder = this; }

	~TDNDDataHolder() { m_holder = 0; }

	T *getValue() const { return m_value; }

	string getName() const { return m_name; }

	static T *getCurrentValue()

	{

		TDNDDataHolder<t> *holder = dynamic_cast<tdnddataholder<t> *>(m_holder);</tdnddataholder<t></t>

		return holder ? holder->getValue() : 0;

	}

};

#endif