[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;
    wxPyTState* state = 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(state);
    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;
    wxPyTState* state = 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(state);
    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;
    wxPyTState* state = 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(state);
    return *rval;
}

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


// 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);
};

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

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;
    wxPyTState* state = 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(state);
    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;
19a97bd6	152	wxPyTState* state = 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	}
19a97bd6	163	wxPyEndBlockThreads(state);
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;
19a97bd6	171	wxPyTState* state = 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	}
19a97bd6	177	wxPyEndBlockThreads(state);
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;
19a97bd6	269	wxPyTState* state = 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	}
19a97bd6	280	wxPyEndBlockThreads(state);
b1462dfa RD	281	return *rval;
	282	}
	283
	284	void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
19a97bd6	285	wxPyTState* state = wxPyBeginBlockThreads();
b1462dfa RD	286	if (m_myInst.findCallback("SetBitmap")) {
	287	m_myInst.callCallback(Py_BuildValue("(O)",
	288	wxPyConstructObject((void*)&bitmap, "wxBitmap")));
	289	}
19a97bd6	290	wxPyEndBlockThreads(state);
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 RD	369
	370	//----------------------------------------------------------------------
	371	//----------------------------------------------------------------------
	372	//----------------------------------------------------------------------
	373
9416aa89	374	class wxClipboard : public wxObject {
b1462dfa RD	375	public:
	376	wxClipboard();
	377
	378	bool Open();
	379	void Close();
	380	bool IsOpened() const;
	381
	382	bool AddData( wxDataObject *data );
	383	%pragma(python) addtomethod = "AddData:_args[0].thisown = 0"
	384	bool SetData( wxDataObject *data );
	385	%pragma(python) addtomethod = "SetData:_args[0].thisown = 0"
	386
	387	bool IsSupported( const wxDataFormat& format );
	388	bool GetData( wxDataObject& data );
	389	void Clear();
	390	bool Flush();
	391	void UsePrimarySelection( int primary = FALSE );
	392	};
	393
	394	%{
6999b0d8	395	// See below in the init function...
b1462dfa RD	396	wxClipboard* wxPyTheClipboard;
	397	%}
	398	%readonly
	399	%name(wxTheClipboard) wxClipboard* wxPyTheClipboard;
	400	%readwrite
	401
	402	//----------------------------------------------------------------------
	403	//----------------------------------------------------------------------
	404
	405	enum wxDragResult
	406	{
	407	wxDragError, // error prevented the d&d operation from completing
	408	wxDragNone, // drag target didn't accept the data
	409	wxDragCopy, // the data was successfully copied
	410	wxDragMove, // the data was successfully moved (MSW only)
c9a1416a	411	wxDragLink, // operation is a drag-link
b1462dfa RD	412	wxDragCancel // the operation was cancelled by user (not an error)
	413	};
	414
	415	bool wxIsDragResultOk(wxDragResult res);
	416
	417	//----------------------------------------------------------------------
	418	%{
	419	class wxPyDropSource : public wxDropSource {
	420	public:
4120ef2b	421	#ifdef __WXMSW__
b1462dfa RD	422	wxPyDropSource(wxWindow *win = NULL,
	423	const wxCursor &cursorCopy = wxNullCursor,
	424	const wxCursor &cursorMove = wxNullCursor,
	425	const wxCursor &cursorStop = wxNullCursor)
	426	: wxDropSource(win, cursorCopy, cursorMove, cursorStop) {}
4120ef2b RD	427	#else
	428	wxPyDropSource(wxWindow *win = NULL,
	429	const wxIcon &go = wxNullIcon)
	430	: wxDropSource(win, go) {}
	431	#endif
077def0b	432	~wxPyDropSource() { }
dafb483b	433
b1462dfa RD	434	DEC_PYCALLBACK_BOOL_DR(GiveFeedback);
	435	PYPRIVATE;
	436	};
	437
	438	IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
	439
	440	%}
	441
	442
	443	%name(wxDropSource) class wxPyDropSource {
	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);
4120ef2b RD	450	#else
	451	wxPyDropSource(wxWindow *win = NULL,
	452	const wxIcon &go = wxNullIcon);
	453	#endif
	454
0122b7e3 RD	455	void _setCallbackInfo(PyObject* self, PyObject* _class, int incref);
0122b7e3 RD	456	%pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxDropSource, 0)"
b1462dfa RD	457	~wxPyDropSource();
	458
	459	void SetData(wxDataObject& data);
	460	wxDataObject *GetDataObject();
	461	void SetCursor(wxDragResult res, const wxCursor& cursor);
	462	wxDragResult DoDragDrop(int bAllowMove = FALSE);
	463
	464	bool base_GiveFeedback(wxDragResult effect);
	465	};
	466
	467	//----------------------------------------------------------------------
	468
	469	// Just a place holder for the type system. The real base class for
	470	// wxPython is wxPyDropTarget
	471	class wxDropTarget {
	472	public:
	473	};
	474
	475
	476	%{
	477	class wxPyDropTarget : public wxDropTarget {
	478	public:
	479	wxPyDropTarget(wxDataObject *dataObject = NULL)
	480	: wxDropTarget(dataObject) {}
	481
	482	// DEC_PYCALLBACK_SIZET_(GetFormatCount);
	483	// DEC_PYCALLBACK_DATAFMT_SIZET(GetFormat);
	484
	485	DEC_PYCALLBACK__(OnLeave);
	486	DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
	487	DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
	488	DEC_PYCALLBACK_DR_2WXCDR_pure(OnData);
	489	DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
	490
	491	PYPRIVATE;
	492	};
	493
	494	// IMP_PYCALLBACK_SIZET_(wxPyDropTarget, wxDropTarget, GetFormatCount);
	495	// IMP__PYCALLBACK_DATAFMT_SIZET(wxPyDropTarget, wxDropTarget, GetFormat);
	496
	497	IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
	498	IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
	499	IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
	500	IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
	501	IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
	502
	503	%}
	504
	505
	506	class wxPyDropTarget : public wxDropTarget {
	507	public:
	508	wxPyDropTarget(wxDataObject *dataObject = NULL);
	509	%pragma(python) addtomethod = "__init__:if _args:_args[0].thisown = 0"
0122b7e3 RD	510	void _setCallbackInfo(PyObject* self, PyObject* _class);
0122b7e3 RD	511	%pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPyDropTarget)"
b1462dfa RD	512
	513	~wxPyDropTarget();
	514
	515	wxDataObject *GetDataObject();
	516	void SetDataObject(wxDataObject *dataObject);
	517	%pragma(python) addtomethod = "SetDataObject:if _args:_args[0].thisown = 0"
	518
	519	// size_t base_GetFormatCount();
	520	// wxDataFormat base_GetFormat(size_t n);
	521
	522	wxDragResult base_OnEnter(wxCoord x, wxCoord y, wxDragResult def);
	523	wxDragResult base_OnDragOver(wxCoord x, wxCoord y, wxDragResult def);
	524	void base_OnLeave();
	525	bool base_OnDrop(wxCoord x, wxCoord y);
	526	//wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def) = 0;
	527
	528	// **** not sure about this one
	529	bool GetData();
	530
	531	};
	532
	533
	534	//----------------------------------------------------------------------
	535
	536	%{
	537	class wxPyTextDropTarget : public wxTextDropTarget {
	538	public:
	539	wxPyTextDropTarget() {}
	540
	541	DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
	542
	543	DEC_PYCALLBACK__(OnLeave);
	544	DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
	545	DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
	546	DEC_PYCALLBACK_DR_2WXCDR(OnData);
	547	DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
	548
	549	PYPRIVATE;
	550	};
	551
	552	IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
	553	IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
	554	IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
	555	IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
	556	IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
	557	IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
	558
	559	%}
	560
	561	%name(wxTextDropTarget) class wxPyTextDropTarget : public wxPyDropTarget {
	562	public:
	563	wxPyTextDropTarget();
0122b7e3 RD	564	void _setCallbackInfo(PyObject* self, PyObject* _class);
0122b7e3 RD	565	%pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxTextDropTarget)"
b1462dfa RD	566
	567	//bool OnDropText(wxCoord x, wxCoord y, const wxString& text) = 0;
	568	wxDragResult base_OnEnter(wxCoord x, wxCoord y, wxDragResult def);
	569	wxDragResult base_OnDragOver(wxCoord x, wxCoord y, wxDragResult def);
	570	void base_OnLeave();
	571	bool base_OnDrop(wxCoord x, wxCoord y);
	572	wxDragResult base_OnData(wxCoord x, wxCoord y, wxDragResult def);
	573	};
	574
	575	//----------------------------------------------------------------------
	576	%{
	577	class wxPyFileDropTarget : public wxFileDropTarget {
	578	public:
	579	wxPyFileDropTarget() {}
	580
	581	virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
	582
	583	DEC_PYCALLBACK__(OnLeave);
	584	DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
	585	DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
	586	DEC_PYCALLBACK_DR_2WXCDR(OnData);
	587	DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
	588
	589	PYPRIVATE;
	590	};
	591
	592	bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
	593	const wxArrayString& filenames) {
	594	bool rval = FALSE;
19a97bd6	595	wxPyTState* state = wxPyBeginBlockThreads();
b37c7e1d	596	PyObject* list = wxArrayString2PyList_helper(filenames);
b1462dfa RD	597	if (m_myInst.findCallback("OnDropFiles"))
	598	rval = m_myInst.callCallback(Py_BuildValue("(iiO)",x,y,list));
	599	Py_DECREF(list);
19a97bd6	600	wxPyEndBlockThreads(state);
b1462dfa RD	601	return rval;
	602	}
	603
	604
	605
	606	IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
	607	IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
	608	IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
	609	IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
	610	IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
	611
	612	%}
	613
	614
	615	%name(wxFileDropTarget) class wxPyFileDropTarget : public wxPyDropTarget
	616	{
	617	public:
	618	wxPyFileDropTarget();
0122b7e3 RD	619	void _setCallbackInfo(PyObject* self, PyObject* _class);
0122b7e3 RD	620	%pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxFileDropTarget)"
b1462dfa RD	621
	622	// bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames) = 0;
	623	wxDragResult base_OnEnter(wxCoord x, wxCoord y, wxDragResult def);
	624	wxDragResult base_OnDragOver(wxCoord x, wxCoord y, wxDragResult def);
	625	void base_OnLeave();
	626	bool base_OnDrop(wxCoord x, wxCoord y);
	627	wxDragResult base_OnData(wxCoord x, wxCoord y, wxDragResult def);
	628	};
	629
	630	//----------------------------------------------------------------------
	631	//----------------------------------------------------------------------
	632	//----------------------------------------------------------------------
	633
	634	%init %{
	635
	636	wxPyTheClipboard = wxTheClipboard;
9416aa89 RD	637	wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
	638	wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
	639	wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
b1462dfa RD	640	%}
	641
	642	//----------------------------------------------------------------------
e6056257	643	#endif
b1462dfa	644