[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"

//---------------------------------------------------------------------------
%{
    // Put some wx default wxChar* values into wxStrings.
    static const wxString wxPyEmptyString(wxT(""));
%}
//----------------------------------------------------------------------


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 wxString& 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 = wxPyEmptyString);

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