[wxWidgets.git] / utils / wxPython / src / clip_dnd.i

/////////////////////////////////////////////////////////////////////////////
// Name:        clip_dnd.i
// Purpose:     SWIG definitions for the Clipboard and Drag-n-drop classes
//
// Author:      Robin Dunn
//
// Created:     31-October-1999
// RCS-ID:      $Id$
// Copyright:   (c) 1999 by Total Control Software
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////


%module clip_dnd

%{
#include "helpers.h"
#include <wx/dataobj.h>
#include <wx/clipbrd.h>
#include <wx/dnd.h>
%}

//----------------------------------------------------------------------

%include typemaps.i
%include my_typemaps.i

// Import some definitions of other classes, etc.
%import _defs.i
%import misc.i
%import gdi.i


%pragma(python) code = "import wx"

//----------------------------------------------------------------------


enum wxDataFormatId
{
    wxDF_INVALID =          0,
    wxDF_TEXT =             1,  /* CF_TEXT */
    wxDF_BITMAP =           2,  /* CF_BITMAP */
    wxDF_METAFILE =         3,  /* CF_METAFILEPICT */
    wxDF_SYLK =             4,
    wxDF_DIF =              5,
    wxDF_TIFF =             6,
    wxDF_OEMTEXT =          7,  /* CF_OEMTEXT */
    wxDF_DIB =              8,  /* CF_DIB */
    wxDF_PALETTE =          9,
    wxDF_PENDATA =          10,
    wxDF_RIFF =             11,
    wxDF_WAVE =             12,
    wxDF_UNICODETEXT =      13,
    wxDF_ENHMETAFILE =      14,
    wxDF_FILENAME =         15, /* CF_HDROP */
    wxDF_LOCALE =           16,
    wxDF_PRIVATE =          20,
    wxDF_MAX
};

//----------------------------------------------------------------------

class wxDataFormat {
public:
    wxDataFormat( wxDataFormatId type );
    ~wxDataFormat();

    void SetType(wxDataFormatId format);
    wxDataFormatId GetType() const;

    wxString GetId() const;
    void SetId(const char *format);
};

%new wxDataFormat* wxCustomDataFormat(const wxString &id);
%{  // An alternate constructor...
    wxDataFormat* wxCustomDataFormat(const wxString &id) {
        return new wxDataFormat(id);
    }
%}


%{
wxDataFormat wxPyFormatInvalid;
%}
%readonly
%name(wxFormatInvalid) wxDataFormat wxPyFormatInvalid;
%readwrite


//----------------------------------------------------------------------


class wxDataObject {      //  An abstract base class
public:
    enum Direction {
        Get  = 0x01,    // format is supported by GetDataHere()
        Set  = 0x02,    // format is supported by SetData()
        Both = 0x03     // format is supported by both (unused currently)
    };

    ~wxDataObject();

    wxDataFormat GetPreferredFormat(Direction dir = wxDataObject::Get);
    size_t GetFormatCount(Direction dir = wxDataObject::Get);
    void GetAllFormats(wxDataFormat *formats,
                       Direction dir = wxDataObject::Get);
    size_t GetDataSize(const wxDataFormat& format);
    bool GetDataHere(const wxDataFormat& format, void *buf);
    bool SetData(const wxDataFormat& format,
                 size_t len, const void * buf);
    bool IsSupportedFormat(const wxDataFormat& format);
};

//----------------------------------------------------------------------

class wxDataObjectSimple : public wxDataObject {
public:
    wxDataObjectSimple(const wxDataFormat& format = wxPyFormatInvalid);

    const wxDataFormat& GetFormat();
    void SetFormat(const wxDataFormat& format);

};


%{  // Create a new class for wxPython to use
class wxPyDataObjectSimple : public wxDataObjectSimple {
public:
    wxPyDataObjectSimple(const wxDataFormat& format = wxPyFormatInvalid)
        : wxDataObjectSimple(format) {}

    DEC_PYCALLBACK_SIZET_(GetDataSize);
    bool GetDataHere(void *buf);
    bool SetData(size_t len, const void *buf);
    PYPRIVATE;
};

IMP_PYCALLBACK_SIZET_(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);

bool wxPyDataObjectSimple::GetDataHere(void *buf) {
    // We need to get the data for this object and write it to buf.  I think
    // the best way to do this for wxPython is to have the Python method
    // return either a string or None and then act appropriately with the
    // C++ version.

    bool rval = FALSE;
    bool doSave = wxPyRestoreThread();
    if (m_myInst.findCallback("GetDataHere")) {
        PyObject* ro;
        ro = m_myInst.callCallbackObj(Py_BuildValue("()"));
        rval = (ro != Py_None && PyString_Check(ro));
        if (rval)
            memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
    }
    wxPySaveThread(doSave);
    return rval;
}

bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
    // For this one we simply need to make a string from buf and len
    // and send it to the Python method.
    bool rval = FALSE;
    bool doSave = wxPyRestoreThread();
    if (m_myInst.findCallback("SetData")) {
        PyObject* data = PyString_FromStringAndSize((char*)buf, len);
        rval = m_myInst.callCallback(Py_BuildValue("(O)", data));
        Py_DECREF(data);
    }
    wxPySaveThread(doSave);
    return rval;
}
%}


// Now define it for SWIG
class wxPyDataObjectSimple : public wxDataObjectSimple {
public:
    wxPyDataObjectSimple(const wxDataFormat& format = wxPyFormatInvalid);
    void _setSelf(PyObject* self);
    %pragma(python) addtomethod = "__init__:self._setSelf(self)"
};

//----------------------------------------------------------------------

class wxDataObjectComposite : public wxDataObject {
public:
    wxDataObjectComposite();

    void Add(wxDataObjectSimple *dataObject, int preferred = FALSE);
    %pragma(python) addtomethod = "Add:_args[0].thisown = 0"

};


//----------------------------------------------------------------------

class wxTextDataObject : public wxDataObjectSimple {
public:
    wxTextDataObject(const wxString& text = wxEmptyString);

    size_t GetTextLength();
    wxString GetText();
    void SetText(const wxString& text);
};


%{  // Create a new class for wxPython to use
class wxPyTextDataObject : public wxTextDataObject {
public:
    wxPyTextDataObject(const wxString& text = wxEmptyString)
        : wxTextDataObject(text) {}

    DEC_PYCALLBACK_SIZET_(GetTextLength);
    DEC_PYCALLBACK_STRING_(GetText);
    DEC_PYCALLBACK__STRING(SetText);
    PYPRIVATE;
};

IMP_PYCALLBACK_SIZET_(wxPyTextDataObject, wxTextDataObject, GetTextLength);
IMP_PYCALLBACK_STRING_(wxPyTextDataObject, wxTextDataObject, GetText);
IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);

%}


// Now define it for SWIG
class wxPyTextDataObject : public wxTextDataObject {
public:
    wxPyTextDataObject(const wxString& text = wxEmptyString);
    void _setSelf(PyObject* self);
    %pragma(python) addtomethod = "__init__:self._setSelf(self)"
};

//----------------------------------------------------------------------

class wxBitmapDataObject : public wxDataObjectSimple {
public:
    wxBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap);

    wxBitmap GetBitmap();
    void SetBitmap(const wxBitmap& bitmap);
};


%{  // Create a new class for wxPython to use
class wxPyBitmapDataObject : public wxBitmapDataObject {
public:
    wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
        : wxBitmapDataObject(bitmap) {}

    wxBitmap GetBitmap();
    void SetBitmap(const wxBitmap& bitmap);
    PYPRIVATE;
};

wxBitmap wxPyBitmapDataObject::GetBitmap() {
    wxBitmap* rval = &wxNullBitmap;
    bool doSave = wxPyRestoreThread();
    if (m_myInst.findCallback("GetBitmap")) {
        PyObject* ro;
        wxBitmap* ptr;
        ro = m_myInst.callCallbackObj(Py_BuildValue("()"));
        if (! SWIG_GetPtrObj(ro, (void **)&ptr, "_wxBitmap_p"))
            rval = ptr;
    }
    wxPySaveThread(doSave);
    return *rval;
}

void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
    bool doSave = wxPyRestoreThread();
    if (m_myInst.findCallback("SetBitmap")) {
        m_myInst.callCallback(Py_BuildValue("(O)",
                              wxPyConstructObject((void*)&bitmap, "wxBitmap")));
    }
    wxPySaveThread(doSave);
}
%}


// Now define it for SWIG
class wxPyBitmapDataObject : public wxBitmapDataObject {
public:
    wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap);
    void _setSelf(PyObject* self);
    %pragma(python) addtomethod = "__init__:self._setSelf(self)"
};


//----------------------------------------------------------------------

class wxFileDataObject : public wxDataObjectSimple
{
public:
    wxFileDataObject();

    //const wxArrayString& GetFilenames();
    %addmethods {
        PyObject* GetFilenames() {
            const wxArrayString& strings = self->GetFilenames();
            PyObject* list = PyList_New(0);
            for (size_t x=0; x<strings.GetCount(); x++)
                PyList_Append(list, PyString_FromString(strings[x]));
            return list;
        }
    }

    //void AddFile(const wxString &filename);
};


//----------------------------------------------------------------------

class wxCustomDataObject : public wxDataObjectSimple {
public:
    wxCustomDataObject(const wxDataFormat& format = wxPyFormatInvalid);

    //void TakeData(size_t size, void *data);
    //bool SetData(size_t size, const void *buf);
    %addmethods {
        void TakeData(PyObject* data) {
            if (PyString_Check(data)) {
                self->SetData(PyString_Size(data), PyString_AsString(data));
            }
        }
        bool SetData(PyObject* data) {
            if (PyString_Check(data)) {
                return self->SetData(PyString_Size(data), PyString_AsString(data));
            }
            return FALSE;
        }
    }

    size_t GetSize();
    //void *GetData();
    %addmethods {
        PyObject* GetData() {
            return PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
        }
    }


};


//----------------------------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------

class wxClipboard {
public:
    wxClipboard();

    bool Open();
    void Close();
    bool IsOpened() const;

    bool AddData( wxDataObject *data );
    %pragma(python) addtomethod = "AddData:_args[0].thisown = 0"
    bool SetData( wxDataObject *data );
    %pragma(python) addtomethod = "SetData:_args[0].thisown = 0"

    bool IsSupported( const wxDataFormat& format );
    bool GetData( wxDataObject& data );
    void Clear();
    bool Flush();
    void UsePrimarySelection( int primary = FALSE );
};

%{
    wxClipboard* wxPyTheClipboard;
%}
%readonly
%name(wxTheClipboard) wxClipboard* wxPyTheClipboard;
%readwrite

//----------------------------------------------------------------------
//----------------------------------------------------------------------

enum wxDragResult
{
    wxDragError,    // error prevented the d&d operation from completing
    wxDragNone,     // drag target didn't accept the data
    wxDragCopy,     // the data was successfully copied
    wxDragMove,     // the data was successfully moved (MSW only)
    wxDragCancel    // the operation was cancelled by user (not an error)
};

bool wxIsDragResultOk(wxDragResult res);

//----------------------------------------------------------------------
%{
class wxPyDropSource : public wxDropSource {
public:
#ifdef __WXMSW__
    wxPyDropSource(wxWindow *win = NULL,
                   const wxCursor &cursorCopy = wxNullCursor,
                   const wxCursor &cursorMove = wxNullCursor,
                   const wxCursor &cursorStop = wxNullCursor)
        : wxDropSource(win, cursorCopy, cursorMove, cursorStop) {}
#else
    wxPyDropSource(wxWindow *win = NULL,
                   const wxIcon &go = wxNullIcon)
        : wxDropSource(win, go) {}
#endif
    ~wxPyDropSource() { printf("dtor\n"); }

    DEC_PYCALLBACK_BOOL_DR(GiveFeedback);
    PYPRIVATE;
};

IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);

%}


%name(wxDropSource) class wxPyDropSource {
public:
#ifdef __WXMSW__
    wxPyDropSource(wxWindow *win = NULL,
                 const wxCursor &cursorCopy = wxNullCursor,
                 const wxCursor &cursorMove = wxNullCursor,
                 const wxCursor &cursorStop = wxNullCursor);
#else
    wxPyDropSource(wxWindow *win = NULL,
                   const wxIcon &go = wxNullIcon);
#endif

    void _setSelf(PyObject* self, int incref);
    %pragma(python) addtomethod = "__init__:self._setSelf(self, 0)"
    ~wxPyDropSource();

    void SetData(wxDataObject& data);
    wxDataObject *GetDataObject();
    void SetCursor(wxDragResult res, const wxCursor& cursor);
    wxDragResult DoDragDrop(int bAllowMove = FALSE);

    bool base_GiveFeedback(wxDragResult effect);
};

//----------------------------------------------------------------------

// Just a place holder for the type system.  The real base class for
// wxPython is wxPyDropTarget
class wxDropTarget {
public:
};


%{
class wxPyDropTarget : public wxDropTarget {
public:
    wxPyDropTarget(wxDataObject *dataObject = NULL)
        : wxDropTarget(dataObject) {}

//      DEC_PYCALLBACK_SIZET_(GetFormatCount);
//      DEC_PYCALLBACK_DATAFMT_SIZET(GetFormat);

    DEC_PYCALLBACK__(OnLeave);
    DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
    DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
    DEC_PYCALLBACK_DR_2WXCDR_pure(OnData);
    DEC_PYCALLBACK_BOOL_INTINT(OnDrop);

    PYPRIVATE;
};

//  IMP_PYCALLBACK_SIZET_(wxPyDropTarget, wxDropTarget, GetFormatCount);
//  IMP__PYCALLBACK_DATAFMT_SIZET(wxPyDropTarget, wxDropTarget, GetFormat);

IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);

%}


class wxPyDropTarget : public wxDropTarget {
public:
    wxPyDropTarget(wxDataObject *dataObject = NULL);
    %pragma(python) addtomethod = "__init__:if _args:_args[0].thisown = 0"
    void _setSelf(PyObject* self);
    %pragma(python) addtomethod = "__init__:self._setSelf(self)"

    ~wxPyDropTarget();

    wxDataObject *GetDataObject();
    void SetDataObject(wxDataObject *dataObject);
    %pragma(python) addtomethod = "SetDataObject:if _args:_args[0].thisown = 0"

//      size_t base_GetFormatCount();
//      wxDataFormat base_GetFormat(size_t n);

    wxDragResult base_OnEnter(wxCoord x, wxCoord y, wxDragResult def);
    wxDragResult base_OnDragOver(wxCoord x, wxCoord y, wxDragResult def);
    void base_OnLeave();
    bool base_OnDrop(wxCoord x, wxCoord y);
    //wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def) = 0;

    // **** not sure about this one
    bool GetData();

};


//----------------------------------------------------------------------

%{
class wxPyTextDropTarget : public wxTextDropTarget {
public:
    wxPyTextDropTarget() {}

    DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);

    DEC_PYCALLBACK__(OnLeave);
    DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
    DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
    DEC_PYCALLBACK_DR_2WXCDR(OnData);
    DEC_PYCALLBACK_BOOL_INTINT(OnDrop);

    PYPRIVATE;
};

IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);

%}

%name(wxTextDropTarget) class wxPyTextDropTarget : public wxPyDropTarget {
public:
    wxPyTextDropTarget();
    void _setSelf(PyObject* self);
    %pragma(python) addtomethod = "__init__:self._setSelf(self)"

    //bool OnDropText(wxCoord x, wxCoord y, const wxString& text) = 0;
    wxDragResult base_OnEnter(wxCoord x, wxCoord y, wxDragResult def);
    wxDragResult base_OnDragOver(wxCoord x, wxCoord y, wxDragResult def);
    void base_OnLeave();
    bool base_OnDrop(wxCoord x, wxCoord y);
    wxDragResult base_OnData(wxCoord x, wxCoord y, wxDragResult def);
};

//----------------------------------------------------------------------
%{
class wxPyFileDropTarget : public wxFileDropTarget {
public:
    wxPyFileDropTarget() {}

    virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);

    DEC_PYCALLBACK__(OnLeave);
    DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
    DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
    DEC_PYCALLBACK_DR_2WXCDR(OnData);
    DEC_PYCALLBACK_BOOL_INTINT(OnDrop);

    PYPRIVATE;
};

bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
                                     const wxArrayString& filenames) {
    bool rval = FALSE;
    bool doSave = wxPyRestoreThread();
    PyObject* list = PyList_New(0);
    for (size_t i=0; i<filenames.GetCount(); i++) {
        PyObject* str = PyString_FromString(filenames[i].c_str());
        PyList_Append(list, str);
    }
    if (m_myInst.findCallback("OnDropFiles"))
        rval = m_myInst.callCallback(Py_BuildValue("(iiO)",x,y,list));
    Py_DECREF(list);
    wxPySaveThread(doSave);
    return rval;
}


IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);

%}


%name(wxFileDropTarget) class wxPyFileDropTarget : public wxPyDropTarget
{
public:
    wxPyFileDropTarget();
    void _setSelf(PyObject* self);
    %pragma(python) addtomethod = "__init__:self._setSelf(self)"

//    bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames) = 0;
    wxDragResult base_OnEnter(wxCoord x, wxCoord y, wxDragResult def);
    wxDragResult base_OnDragOver(wxCoord x, wxCoord y, wxDragResult def);
    void base_OnLeave();
    bool base_OnDrop(wxCoord x, wxCoord y);
    wxDragResult base_OnData(wxCoord x, wxCoord y, wxDragResult def);
};

//----------------------------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------

%init %{

    wxPyTheClipboard = wxTheClipboard;

%}

//----------------------------------------------------------------------
Commit	Line	Data
b1462dfa RD	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: clip_dnd.i
	3	// Purpose: SWIG definitions for the Clipboard and Drag-n-drop classes
	4	//
	5	// Author: Robin Dunn
	6	//
	7	// Created: 31-October-1999
	8	// RCS-ID: $Id$
	9	// Copyright: (c) 1999 by Total Control Software
	10	// Licence: wxWindows license
	11	/////////////////////////////////////////////////////////////////////////////
	12
	13
	14	%module clip_dnd
	15
	16	%{
	17	#include "helpers.h"
	18	#include <wx/dataobj.h>
	19	#include <wx/clipbrd.h>
	20	#include <wx/dnd.h>
	21	%}
	22
	23	//----------------------------------------------------------------------
	24
	25	%include typemaps.i
	26	%include my_typemaps.i
	27
	28	// Import some definitions of other classes, etc.
	29	%import _defs.i
	30	%import misc.i
	31	%import gdi.i
	32
	33
	34	%pragma(python) code = "import wx"
	35
	36	//----------------------------------------------------------------------
	37
	38
	39	enum wxDataFormatId
	40	{
	41	wxDF_INVALID = 0,
	42	wxDF_TEXT = 1, /* CF_TEXT */
	43	wxDF_BITMAP = 2, /* CF_BITMAP */
	44	wxDF_METAFILE = 3, /* CF_METAFILEPICT */
	45	wxDF_SYLK = 4,
	46	wxDF_DIF = 5,
	47	wxDF_TIFF = 6,
	48	wxDF_OEMTEXT = 7, /* CF_OEMTEXT */
	49	wxDF_DIB = 8, /* CF_DIB */
	50	wxDF_PALETTE = 9,
	51	wxDF_PENDATA = 10,
	52	wxDF_RIFF = 11,
	53	wxDF_WAVE = 12,
	54	wxDF_UNICODETEXT = 13,
	55	wxDF_ENHMETAFILE = 14,
	56	wxDF_FILENAME = 15, /* CF_HDROP */
	57	wxDF_LOCALE = 16,
	58	wxDF_PRIVATE = 20,
	59	wxDF_MAX
	60	};
	61
	62	//----------------------------------------------------------------------
	63
	64	class wxDataFormat {
65	public:
66	wxDataFormat( wxDataFormatId type );
67	~wxDataFormat();
68
69	void SetType(wxDataFormatId format);
70	wxDataFormatId GetType() const;
71
72	wxString GetId() const;
73	void SetId(const char *format);
74	};
75
76	%new wxDataFormat* wxCustomDataFormat(const wxString &id);
77	%{ // An alternate constructor...
78	wxDataFormat* wxCustomDataFormat(const wxString &id) {
79	return new wxDataFormat(id);
80	}
81	%}
82
83
84	%{
85	wxDataFormat wxPyFormatInvalid;
86	%}
87	%readonly
88	%name(wxFormatInvalid) wxDataFormat wxPyFormatInvalid;
89	%readwrite
90
91
92	//----------------------------------------------------------------------
93
94
95
96	class wxDataObject { // An abstract base class
97	public:
98	enum Direction {
99	Get = 0x01, // format is supported by GetDataHere()
100	Set = 0x02, // format is supported by SetData()
101	Both = 0x03 // format is supported by both (unused currently)
102	};
103
104	~wxDataObject();
105
106	wxDataFormat GetPreferredFormat(Direction dir = wxDataObject::Get);
107	size_t GetFormatCount(Direction dir = wxDataObject::Get);
108	void GetAllFormats(wxDataFormat *formats,
109	Direction dir = wxDataObject::Get);
110	size_t GetDataSize(const wxDataFormat& format);
111	bool GetDataHere(const wxDataFormat& format, void *buf);
112	bool SetData(const wxDataFormat& format,
113	size_t len, const void * buf);
114	bool IsSupportedFormat(const wxDataFormat& format);
115	};
116
117	//----------------------------------------------------------------------
118
119	class wxDataObjectSimple : public wxDataObject {
120	public:
121	wxDataObjectSimple(const wxDataFormat& format = wxPyFormatInvalid);
122
123	const wxDataFormat& GetFormat();
124	void SetFormat(const wxDataFormat& format);
125
126	};
127
128
129	%{ // Create a new class for wxPython to use
130	class wxPyDataObjectSimple : public wxDataObjectSimple {
131	public:
132	wxPyDataObjectSimple(const wxDataFormat& format = wxPyFormatInvalid)
133	: wxDataObjectSimple(format) {}
134
135	DEC_PYCALLBACK_SIZET_(GetDataSize);
136	bool GetDataHere(void *buf);
137	bool SetData(size_t len, const void *buf);
138	PYPRIVATE;
139	};
140
141	IMP_PYCALLBACK_SIZET_(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
142
143	bool wxPyDataObjectSimple::GetDataHere(void *buf) {
144	// We need to get the data for this object and write it to buf. I think
145	// the best way to do this for wxPython is to have the Python method
146	// return either a string or None and then act appropriately with the
147	// C++ version.
148
149	bool rval = FALSE;
150	bool doSave = wxPyRestoreThread();
151	if (m_myInst.findCallback("GetDataHere")) {
152	PyObject* ro;
153	ro = m_myInst.callCallbackObj(Py_BuildValue("()"));
154	rval = (ro != Py_None && PyString_Check(ro));
155	if (rval)
156	memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
157	}
158	wxPySaveThread(doSave);
159	return rval;
160	}
161
162	bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
163	// For this one we simply need to make a string from buf and len
164	// and send it to the Python method.
165	bool rval = FALSE;
166	bool doSave = wxPyRestoreThread();
167	if (m_myInst.findCallback("SetData")) {
168	PyObject* data = PyString_FromStringAndSize((char*)buf, len);
169	rval = m_myInst.callCallback(Py_BuildValue("(O)", data));
170	Py_DECREF(data);
171	}
172	wxPySaveThread(doSave);
173	return rval;
174	}
175	%}
176
177
178
179	// Now define it for SWIG
180	class wxPyDataObjectSimple : public wxDataObjectSimple {
181	public:
182	wxPyDataObjectSimple(const wxDataFormat& format = wxPyFormatInvalid);
183	void _setSelf(PyObject* self);
184	%pragma(python) addtomethod = "__init__:self._setSelf(self)"
185	};
186
187	//----------------------------------------------------------------------
188
189	class wxDataObjectComposite : public wxDataObject {
190	public:
191	wxDataObjectComposite();
192
193	void Add(wxDataObjectSimple *dataObject, int preferred = FALSE);
194	%pragma(python) addtomethod = "Add:_args[0].thisown = 0"
195
196	};
197
198
199	//----------------------------------------------------------------------
200
201	class wxTextDataObject : public wxDataObjectSimple {
202	public:
203	wxTextDataObject(const wxString& text = wxEmptyString);
204
205	size_t GetTextLength();
206	wxString GetText();
207	void SetText(const wxString& text);
208	};
209
210
211
212	%{ // Create a new class for wxPython to use
213	class wxPyTextDataObject : public wxTextDataObject {
214	public:
215	wxPyTextDataObject(const wxString& text = wxEmptyString)
216	: wxTextDataObject(text) {}
217
218	DEC_PYCALLBACK_SIZET_(GetTextLength);
219	DEC_PYCALLBACK_STRING_(GetText);
220	DEC_PYCALLBACK__STRING(SetText);
221	PYPRIVATE;
222	};
223
224	IMP_PYCALLBACK_SIZET_(wxPyTextDataObject, wxTextDataObject, GetTextLength);
225	IMP_PYCALLBACK_STRING_(wxPyTextDataObject, wxTextDataObject, GetText);
226	IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
227
228	%}
229
230
231	// Now define it for SWIG
232	class wxPyTextDataObject : public wxTextDataObject {
233	public:
234	wxPyTextDataObject(const wxString& text = wxEmptyString);
235	void _setSelf(PyObject* self);
236	%pragma(python) addtomethod = "__init__:self._setSelf(self)"
237	};
238
239	//----------------------------------------------------------------------
240
241	class wxBitmapDataObject : public wxDataObjectSimple {
242	public:
243	wxBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap);
244
245	wxBitmap GetBitmap();
246	void SetBitmap(const wxBitmap& bitmap);
247	};
248
249
250
251	%{ // Create a new class for wxPython to use
252	class wxPyBitmapDataObject : public wxBitmapDataObject {
253	public:
254	wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
255	: wxBitmapDataObject(bitmap) {}
256
257	wxBitmap GetBitmap();
258	void SetBitmap(const wxBitmap& bitmap);
259	PYPRIVATE;
260	};
261
262	wxBitmap wxPyBitmapDataObject::GetBitmap() {
263	wxBitmap* rval = &wxNullBitmap;
264	bool doSave = wxPyRestoreThread();
265	if (m_myInst.findCallback("GetBitmap")) {
266	PyObject* ro;
267	wxBitmap* ptr;
268	ro = m_myInst.callCallbackObj(Py_BuildValue("()"));
269	if (! SWIG_GetPtrObj(ro, (void **)&ptr, "_wxBitmap_p"))
270	rval = ptr;
271	}
272	wxPySaveThread(doSave);
273	return *rval;
274	}
275
276	void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
277	bool doSave = wxPyRestoreThread();
278	if (m_myInst.findCallback("SetBitmap")) {
279	m_myInst.callCallback(Py_BuildValue("(O)",
280	wxPyConstructObject((void*)&bitmap, "wxBitmap")));
281	}
282	wxPySaveThread(doSave);
283	}
284	%}
285
286
287
288	// Now define it for SWIG
289	class wxPyBitmapDataObject : public wxBitmapDataObject {
290	public:
291	wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap);
292	void _setSelf(PyObject* self);
293	%pragma(python) addtomethod = "__init__:self._setSelf(self)"
294	};
295
296
297	//----------------------------------------------------------------------
298
299	class wxFileDataObject : public wxDataObjectSimple
300	{
301	public:
302	wxFileDataObject();
303
304	//const wxArrayString& GetFilenames();
305	%addmethods {
306	PyObject* GetFilenames() {
307	const wxArrayString& strings = self->GetFilenames();
308	PyObject* list = PyList_New(0);
309	for (size_t x=0; x<strings.GetCount(); x++)
310	PyList_Append(list, PyString_FromString(strings[x]));
311	return list;
312	}
313	}
314
315	//void AddFile(const wxString &filename);
316	};
317
318
319	//----------------------------------------------------------------------
320
321	class wxCustomDataObject : public wxDataObjectSimple {
322	public:
323	wxCustomDataObject(const wxDataFormat& format = wxPyFormatInvalid);
324
325	//void TakeData(size_t size, void *data);
326	//bool SetData(size_t size, const void *buf);
327	%addmethods {
328	void TakeData(PyObject* data) {
329	if (PyString_Check(data)) {
330	self->SetData(PyString_Size(data), PyString_AsString(data));
331	}
332	}
333	bool SetData(PyObject* data) {
334	if (PyString_Check(data)) {
335	return self->SetData(PyString_Size(data), PyString_AsString(data));
336	}
337	return FALSE;
338	}
339	}
340
341	size_t GetSize();
342	//void *GetData();
343	%addmethods {
344	PyObject* GetData() {
345	return PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
346	}
347	}
348
349
350	};
351
352
353
354	//----------------------------------------------------------------------
355	//----------------------------------------------------------------------
356	//----------------------------------------------------------------------
357
358	class wxClipboard {
359	public:
360	wxClipboard();
361
362	bool Open();
363	void Close();
364	bool IsOpened() const;
365
366	bool AddData( wxDataObject *data );
367	%pragma(python) addtomethod = "AddData:_args[0].thisown = 0"
368	bool SetData( wxDataObject *data );
369	%pragma(python) addtomethod = "SetData:_args[0].thisown = 0"
370
371	bool IsSupported( const wxDataFormat& format );
372	bool GetData( wxDataObject& data );
373	void Clear();
374	bool Flush();
375	void UsePrimarySelection( int primary = FALSE );
376	};
377
378	%{
379	wxClipboard* wxPyTheClipboard;
380	%}
381	%readonly
382	%name(wxTheClipboard) wxClipboard* wxPyTheClipboard;
383	%readwrite
384
385	//----------------------------------------------------------------------
386	//----------------------------------------------------------------------
387
388	enum wxDragResult
389	{
390	wxDragError, // error prevented the d&d operation from completing
391	wxDragNone, // drag target didn't accept the data
392	wxDragCopy, // the data was successfully copied
393	wxDragMove, // the data was successfully moved (MSW only)
394	wxDragCancel // the operation was cancelled by user (not an error)
395	};
396
397	bool wxIsDragResultOk(wxDragResult res);
398
399	//----------------------------------------------------------------------
400	%{
401	class wxPyDropSource : public wxDropSource {
402	public:
4120ef2b	403	#ifdef __WXMSW__
b1462dfa RD	404	wxPyDropSource(wxWindow *win = NULL,
	405	const wxCursor &cursorCopy = wxNullCursor,
	406	const wxCursor &cursorMove = wxNullCursor,
	407	const wxCursor &cursorStop = wxNullCursor)
	408	: wxDropSource(win, cursorCopy, cursorMove, cursorStop) {}
4120ef2b RD	409	#else
	410	wxPyDropSource(wxWindow *win = NULL,
	411	const wxIcon &go = wxNullIcon)
	412	: wxDropSource(win, go) {}
	413	#endif
dafb483b RD	414	~wxPyDropSource() { printf("dtor\n"); }
dafb483b RD	415
b1462dfa RD	416	DEC_PYCALLBACK_BOOL_DR(GiveFeedback);
	417	PYPRIVATE;
	418	};
	419
	420	IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
	421
	422	%}
	423
	424
	425	%name(wxDropSource) class wxPyDropSource {
	426	public:
4120ef2b	427	#ifdef __WXMSW__
b1462dfa RD	428	wxPyDropSource(wxWindow *win = NULL,
	429	const wxCursor &cursorCopy = wxNullCursor,
	430	const wxCursor &cursorMove = wxNullCursor,
	431	const wxCursor &cursorStop = wxNullCursor);
4120ef2b RD	432	#else
	433	wxPyDropSource(wxWindow *win = NULL,
	434	const wxIcon &go = wxNullIcon);
	435	#endif
	436
dafb483b RD	437	void _setSelf(PyObject* self, int incref);
dafb483b RD	438	%pragma(python) addtomethod = "__init__:self._setSelf(self, 0)"
b1462dfa RD	439	~wxPyDropSource();
	440
	441	void SetData(wxDataObject& data);
	442	wxDataObject *GetDataObject();
	443	void SetCursor(wxDragResult res, const wxCursor& cursor);
	444	wxDragResult DoDragDrop(int bAllowMove = FALSE);
	445
	446	bool base_GiveFeedback(wxDragResult effect);
	447	};
	448
	449	//----------------------------------------------------------------------
	450
	451	// Just a place holder for the type system. The real base class for
	452	// wxPython is wxPyDropTarget
	453	class wxDropTarget {
	454	public:
	455	};
	456
	457
	458	%{
	459	class wxPyDropTarget : public wxDropTarget {
	460	public:
	461	wxPyDropTarget(wxDataObject *dataObject = NULL)
	462	: wxDropTarget(dataObject) {}
	463
	464	// DEC_PYCALLBACK_SIZET_(GetFormatCount);
	465	// DEC_PYCALLBACK_DATAFMT_SIZET(GetFormat);
	466
	467	DEC_PYCALLBACK__(OnLeave);
	468	DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
	469	DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
	470	DEC_PYCALLBACK_DR_2WXCDR_pure(OnData);
	471	DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
	472
	473	PYPRIVATE;
	474	};
	475
	476	// IMP_PYCALLBACK_SIZET_(wxPyDropTarget, wxDropTarget, GetFormatCount);
	477	// IMP__PYCALLBACK_DATAFMT_SIZET(wxPyDropTarget, wxDropTarget, GetFormat);
	478
	479	IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
	480	IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
	481	IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
	482	IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
	483	IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
	484
	485	%}
	486
	487
	488	class wxPyDropTarget : public wxDropTarget {
	489	public:
	490	wxPyDropTarget(wxDataObject *dataObject = NULL);
	491	%pragma(python) addtomethod = "__init__:if _args:_args[0].thisown = 0"
	492	void _setSelf(PyObject* self);
	493	%pragma(python) addtomethod = "__init__:self._setSelf(self)"
	494
	495	~wxPyDropTarget();
	496
	497	wxDataObject *GetDataObject();
	498	void SetDataObject(wxDataObject *dataObject);
	499	%pragma(python) addtomethod = "SetDataObject:if _args:_args[0].thisown = 0"
	500
	501	// size_t base_GetFormatCount();
	502	// wxDataFormat base_GetFormat(size_t n);
503
504	wxDragResult base_OnEnter(wxCoord x, wxCoord y, wxDragResult def);
505	wxDragResult base_OnDragOver(wxCoord x, wxCoord y, wxDragResult def);
506	void base_OnLeave();
507	bool base_OnDrop(wxCoord x, wxCoord y);
508	//wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def) = 0;
509
510	// **** not sure about this one
511	bool GetData();
512
513	};
514
515
516	//----------------------------------------------------------------------
517
518	%{
519	class wxPyTextDropTarget : public wxTextDropTarget {
520	public:
521	wxPyTextDropTarget() {}
522
523	DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
524
525	DEC_PYCALLBACK__(OnLeave);
526	DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
527	DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
528	DEC_PYCALLBACK_DR_2WXCDR(OnData);
529	DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
530
531	PYPRIVATE;
532	};
533
534	IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
535	IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
536	IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
537	IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
538	IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
539	IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
540
541	%}
542
543	%name(wxTextDropTarget) class wxPyTextDropTarget : public wxPyDropTarget {
544	public:
545	wxPyTextDropTarget();
546	void _setSelf(PyObject* self);
547	%pragma(python) addtomethod = "__init__:self._setSelf(self)"
548
549	//bool OnDropText(wxCoord x, wxCoord y, const wxString& text) = 0;
550	wxDragResult base_OnEnter(wxCoord x, wxCoord y, wxDragResult def);
551	wxDragResult base_OnDragOver(wxCoord x, wxCoord y, wxDragResult def);
552	void base_OnLeave();
553	bool base_OnDrop(wxCoord x, wxCoord y);
554	wxDragResult base_OnData(wxCoord x, wxCoord y, wxDragResult def);
555	};
556
557	//----------------------------------------------------------------------
558	%{
559	class wxPyFileDropTarget : public wxFileDropTarget {
560	public:
561	wxPyFileDropTarget() {}
562
563	virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
564
565	DEC_PYCALLBACK__(OnLeave);
566	DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
567	DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
568	DEC_PYCALLBACK_DR_2WXCDR(OnData);
569	DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
570
571	PYPRIVATE;
572	};
573
574	bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
575	const wxArrayString& filenames) {
576	bool rval = FALSE;
577	bool doSave = wxPyRestoreThread();
578	PyObject* list = PyList_New(0);
579	for (size_t i=0; i<filenames.GetCount(); i++) {
580	PyObject* str = PyString_FromString(filenames[i].c_str());
581	PyList_Append(list, str);
582	}
583	if (m_myInst.findCallback("OnDropFiles"))
584	rval = m_myInst.callCallback(Py_BuildValue("(iiO)",x,y,list));
585	Py_DECREF(list);
586	wxPySaveThread(doSave);
587	return rval;
588	}
589
590
591
592	IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
593	IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
594	IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
595	IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
596	IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
597
598	%}
599
600
601	%name(wxFileDropTarget) class wxPyFileDropTarget : public wxPyDropTarget
602	{
603	public:
604	wxPyFileDropTarget();
605	void _setSelf(PyObject* self);
606	%pragma(python) addtomethod = "__init__:self._setSelf(self)"
607
608	// bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames) = 0;
609	wxDragResult base_OnEnter(wxCoord x, wxCoord y, wxDragResult def);
610	wxDragResult base_OnDragOver(wxCoord x, wxCoord y, wxDragResult def);
611	void base_OnLeave();
612	bool base_OnDrop(wxCoord x, wxCoord y);
613	wxDragResult base_OnData(wxCoord x, wxCoord y, wxDragResult def);
614	};
615
616	//----------------------------------------------------------------------
617	//----------------------------------------------------------------------
618	//----------------------------------------------------------------------
619
620	%init %{
621
622	wxPyTheClipboard = wxTheClipboard;
623
624	%}
625
626	//----------------------------------------------------------------------
627