#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);
  TDataObject(const std::vector<std::wstring> &vStr);
  // 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;
 
  bool getData(string &str) const;
  bool getData(std::vector<string> &vStr) const;
  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);
//   holder.doDragDrop();
//
// nel target
//   if(MyType *data = TDNDDataHolder<MyType>::getCurrentValue())
//     {
//     }
 
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 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);
    return holder ? holder->getValue() : 0;
  }
};
 
#endif