#include <wx/wx.h>
#include <wx/dnd.h>
 
class MyDataObject : public wxDataObject
{
    public:
        // default constructor
        MyDataObject();
 
        // class accessors
        wxString GetStr() { return m_Str; }
        void SetStr(wxString str) { m_Str = str; }
        int GetInt() { return m_Int; }
        void SetInt(int i) { m_Int = i; }
        double GetDouble() { return m_Double; }
        void SetDouble(double d) { m_Double = d; }
        void* GetPtr() { return m_Ptr; }
        void SetPtr(void* ptr) { m_Ptr = ptr; }
 
        // virtual methods
        wxDataFormat GetPreferredFormat(Direction WXUNUSED(dir)) const;
        size_t GetFormatCount(Direction dir) const;
        void GetAllFormats(wxDataFormat *formats, Direction dir) const;
        size_t GetDataSize(const wxDataFormat& format) const;
        bool GetDataHere(const wxDataFormat& format, void *pBuf) const;
        bool SetData(const wxDataFormat& format, size_t WXUNUSED(len), const void *buf);
 
    private:
        // data
        wxString m_Str;
        int m_Int;
        double m_Double;
        void* m_Ptr;
 
        / format
        wxDataFormat m_Format;
};
 
 
MyDataObject::MyDataObject()
 : wxDataObject()
{
    m_Str = wxT("");
    m_Int = 0;
    m_Double = 0.0;
    m_Ptr = NULL;
 
    m_Format.SetId(wxT("MyDataObject"));
}
 
wxDataFormat MyDataObject::GetPreferredFormat(Direction WXUNUSED(dir)) const
{
    return m_Format;
}
 
size_t MyDataObject::GetFormatCount(Direction dir) const
{
    if(dir == Set)
    // 2 formats pour les cibles (formats interne+texte)
        return 2;
    else 
    // 1 format pour les sources (format interne)
        return 1;
}
 
void MyDataObject::GetAllFormats(wxDataFormat *formats, Direction dir) const
{
    // format interne utilisable comme source ou cible
    formats[0] = m_Format;
 
    // format string utilisable uniquement comme cible
    if(dir == Set)
        formats[1] = wxDataFormat(wxDF_TEXT);
}
 
size_t MyDataObject::GetDataSize(const wxDataFormat& format) const
{
    if (format == m_Format)
    // si format interne, taille = pointeur
        return sizeof(void*);
    else if (format == wxDataFormat(wxDF_TEXT))
    // si format texte, taille = la chaine de caractères
        return ( sizeof(int) + (m_Str.Len()+1) * sizeof(wxChar) );
    else
        return 0;
}
 
bool MyDataObject::GetDataHere(const wxDataFormat& format, void *pBuf) const
{
    if ( format == m_Format )
    {
        // pour le format interne, on revoit un pointeur sur l'objet
        *pBuf = (void*) this;
        return true;
    }
    else if (format == wxDataFormat(wxDF_TEXT))
    {
        // pour le format text, on copie la chaine dans le tampon
        wxStrcpy( (wxChar*)pBuf,  m_Str.c_str() );
        return true;
    }
    else
        return false;
}
 
bool MyDataObject::SetData(const wxDataFormat& format, size_t WXUNUSED(len), const void *buf)
{
    if ( format == m_Format )
    {
        // pour le format interne, on récupère un pointeur sur l'objet
        (MyDataObject*) ptr = *buf;
 
        // puis on récupère les données
        SetStr( ptr->GetStr() );
        SetInt( ptr->GetInt() );
        SetDouble( ptr->GetDouble() );
        SetPtr( ptr->GetPtr() );
 
        return true;
    }
    else if (format == wxDataFormat(wxDF_TEXT))
    {
        // pour le format texte, on copie le tampon dans une chaine
        m_Str = wxString( (const wxChar*) buf );
        return true;
    }
    else
        return false;
}

class MyDlg : public wxDialog
{
    ...
    wxListCtrl* m_ListSource;
    void OnBeginDrag(wxListEvent& event);
    DECLARE_EVENT_TABLE()
};
 
BEGIN_EVENT_TABLE(MyDlg, wxTextCtrl)
    EVT_LIST_BEGIN_DRAG(ID_SOURCE, MyDlg::OnBeginDrag)
    // EVT_LEFT_DOWN(ID_SOURCE, MyDlg::OnBeginDrag)
END_EVENT_TABLE()
 
void MyDlg::OnBeginDrag(wxListEvent& event)
{
    wxListItem item;
    item.SetId(event.GetIndex());
    item.SetColumn(0);                // récupère le text de la 1ère colonne
    item.SetMask(wxLIST_MASK_TEXT);
    m_ListSource->GetItem(item);
    wxString text = item.GetText();
 
    // on crée l'objet contenant les données à transférer
    MyDataObject data();
    data.SetStr(text);
    data.SetInt(event.GetIndex());
    data.SetPtr( (void*) m_ListSource );
    // data.SetDouble(...); non utilisé
 
    // on crée la source
    wxDropSource source(this, wxDROP_ICON(dnd_copy), 
        wxDROP_ICON(dnd_move), wxDROP_ICON(dnd_none));
    source.SetData(data);
 
    // on rend la main au système pour qu'il gère le d&d
    source.DoDragDrop(true);
}

#include <wx/dnd.h>
 
class MyDropTarget : public wxDropTarget
{
    public:
        MyDroptarget(MyDlg* dlg);
        wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def);
        bool OnDrop(wxCoord x, wxCoord y);
 
    private:
        // on garde un pointeur vers le dialog contenant la cible du d&d
        MyDlg* m_Dlg;
};
 
 
PT_MyDropTarget::MyDropTarget(MyDlg* dlg)
 : wxDropTarget(new MyDataObject)
{
    m_Dlg = dlg;
}
 
bool MyDropTarget::OnDrop(wxCoord x, wxCoord y)
{
    return true;
}
 
wxDragResult MyDropTarget::OnData(wxCoord x, wxCoord y, wxDragResult def)
{
    if ( !GetData() )
    {
        wxMessageBox(wxT("Failed to get drag and drop data"));
        return wxDragNone;
    }
    else
        wxMessageBox(_("reussit"), _("reussit"));
 
    MyDataObject* data = (MyDataObject*) GetDataObject();
    // non utilisé
    // data->GetInt()
    // data->GetDouble()
    // data->GetPtr()
    m_Dlg->OnDrop(data->GetStr());
 
    return def;
}
 

class MyDlg : public wxDialog
{
    ...
    wxListCtrl* m_ListTarget;
    void OnDrop(wxString text);
};
 
 
MyDlg::MyDlg()
{
    ...
    m_ListTarget= new wxListCtrl(this, ID_TARGET, wxDefaultPosition,
                wxDefaultSize, wxLC_REPORT|wxLC_VRULES|wxLC_HRULES|wxBORDER_RAISED);
    m_ListTarget->SetDropTarget(new MyDropTarget(this));
}
 
void MyDlg::OnDrop(wxString text)
{
    long item = m_ListTarget->InsertItem(m_ListTarget->GetCount(), text);
}