wxPython/src/clip_dnd.i

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