#pragma once

#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