[wxWidgets.git] / 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

#ifndef __WXMAC__

%{
#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;
    wxPyBeginBlockThreads();
    if (m_myInst.findCallback("GetDataHere")) {
        PyObject* ro;
        ro = m_myInst.callCallbackObj(Py_BuildValue("()"));
        if (ro) {
            rval = (ro != Py_None && PyString_Check(ro));
            if (rval)
                memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
            Py_DECREF(ro);
        }
    }
    wxPyEndBlockThreads();
    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;
    wxPyBeginBlockThreads();
    if (m_myInst.findCallback("SetData")) {
        PyObject* data = PyString_FromStringAndSize((char*)buf, len);
        rval = m_myInst.callCallback(Py_BuildValue("(O)", data));
        Py_DECREF(data);
    }
    wxPyEndBlockThreads();
    return rval;
}
%}


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

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

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 _setCallbackInfo(PyObject* self, PyObject* _class);
    %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPyTextDataObject)"
};

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

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;
    wxPyBeginBlockThreads();
    if (m_myInst.findCallback("GetBitmap")) {
        PyObject* ro;
        wxBitmap* ptr;
        ro = m_myInst.callCallbackObj(Py_BuildValue("()"));
        if (ro) {
            if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxBitmap_p"))
                rval = ptr;
            Py_DECREF(ro);
        }
    }
    wxPyEndBlockThreads();
    return *rval;
}

void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
    wxPyBeginBlockThreads();
    if (m_myInst.findCallback("SetBitmap")) {
        m_myInst.callCallback(Py_BuildValue("(O)",
                              wxPyConstructObject((void*)&bitmap, "wxBitmap")));
    }
    wxPyEndBlockThreads();
}
%}


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


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

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

    //const wxArrayString& GetFilenames();
    %addmethods {
        PyObject* GetFilenames() {
            const wxArrayString& strings = self->GetFilenames();
            return wxArrayString2PyList_helper(strings);
        }
    }
#ifdef __WXMSW__
    void AddFile(const wxString &filename);
#endif
};


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

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 wxURLDataObject : public wxDataObjectComposite {
public:
    wxURLDataObject();

    wxString GetURL();
    void SetURL(const wxString& url);
};

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

#ifndef __WXGTK__

%{
#include <wx/metafile.h>
%}

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

    void SetMetafile(const wxMetafile& metafile);
    wxMetafile GetMetafile() const;
};

#endif

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

class wxClipboard : public wxObject {
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 );
};

%{
    // See below in the init function...
    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)
    wxDragLink,     // operation is a drag-link
    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() { }

    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 _setCallbackInfo(PyObject* self, PyObject* _class, int incref);
    %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxDropSource, 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 _setCallbackInfo(PyObject* self, PyObject* _class);
    %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPyDropTarget)"

    ~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 _setCallbackInfo(PyObject* self, PyObject* _class);
    %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxTextDropTarget)"

    //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;
    wxPyBeginBlockThreads();
    PyObject* list = wxArrayString2PyList_helper(filenames);
    if (m_myInst.findCallback("OnDropFiles"))
        rval = m_myInst.callCallback(Py_BuildValue("(iiO)",x,y,list));
    Py_DECREF(list);
    wxPyEndBlockThreads();
    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 _setCallbackInfo(PyObject* self, PyObject* _class);
    %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxFileDropTarget)"

//    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;
    wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
    wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
    wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
%}

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