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 #ifdef __WXMSW__
 321     void AddFile(const wxString &filename);
 322 #endif
 323 };
 324
 325
 326 //----------------------------------------------------------------------
 327
 328 class wxCustomDataObject : public wxDataObjectSimple {
 329 public:
 330     wxCustomDataObject(const wxDataFormat& format = wxPyFormatInvalid);
 331
 332     //void TakeData(size_t size, void *data);
 333     //bool SetData(size_t size, const void *buf);
 334     %addmethods {
 335         void TakeData(PyObject* data) {
 336             if (PyString_Check(data)) {
 337                 self->SetData(PyString_Size(data), PyString_AsString(data));
 338             }
 339         }
 340         bool SetData(PyObject* data) {
 341             if (PyString_Check(data)) {
 342                 return self->SetData(PyString_Size(data), PyString_AsString(data));
 343             }
 344             return FALSE;
 345         }
 346     }
 347
 348     size_t GetSize();
 349     //void *GetData();
 350     %addmethods {
 351         PyObject* GetData() {
 352             return PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
 353         }
 354     }
 355
 356
 357 };
 358
 359
 360
 361 //----------------------------------------------------------------------
 362 //----------------------------------------------------------------------
 363 //----------------------------------------------------------------------
 364
 365 class wxClipboard {
 366 public:
 367     wxClipboard();
 368
 369     bool Open();
 370     void Close();
 371     bool IsOpened() const;
 372
 373     bool AddData( wxDataObject *data );
 374     %pragma(python) addtomethod = "AddData:_args[0].thisown = 0"
 375     bool SetData( wxDataObject *data );
 376     %pragma(python) addtomethod = "SetData:_args[0].thisown = 0"
 377
 378     bool IsSupported( const wxDataFormat& format );
 379     bool GetData( wxDataObject& data );
 380     void Clear();
 381     bool Flush();
 382     void UsePrimarySelection( int primary = FALSE );
 383 };
 384
 385 %{
 386     // See below in the init function...
 387     wxClipboard* wxPyTheClipboard;
 388 %}
 389 %readonly
 390 %name(wxTheClipboard) wxClipboard* wxPyTheClipboard;
 391 %readwrite
 392
 393 //----------------------------------------------------------------------
 394 //----------------------------------------------------------------------
 395
 396 enum wxDragResult
 397 {
 398     wxDragError,    // error prevented the d&d operation from completing
 399     wxDragNone,     // drag target didn't accept the data
 400     wxDragCopy,     // the data was successfully copied
 401     wxDragMove,     // the data was successfully moved (MSW only)
 402     wxDragCancel    // the operation was cancelled by user (not an error)
 403 };
 404
 405 bool wxIsDragResultOk(wxDragResult res);
 406
 407 //----------------------------------------------------------------------
 408 %{
 409 class wxPyDropSource : public wxDropSource {
 410 public:
 411 #ifdef __WXMSW__
 412     wxPyDropSource(wxWindow *win = NULL,
 413                    const wxCursor &cursorCopy = wxNullCursor,
 414                    const wxCursor &cursorMove = wxNullCursor,
 415                    const wxCursor &cursorStop = wxNullCursor)
 416         : wxDropSource(win, cursorCopy, cursorMove, cursorStop) {}
 417 #else
 418     wxPyDropSource(wxWindow *win = NULL,
 419                    const wxIcon &go = wxNullIcon)
 420         : wxDropSource(win, go) {}
 421 #endif
 422     ~wxPyDropSource() { }
 423
 424     DEC_PYCALLBACK_BOOL_DR(GiveFeedback);
 425     PYPRIVATE;
 426 };
 427
 428 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
 429
 430 %}
 431
 432
 433 %name(wxDropSource) class wxPyDropSource {
 434 public:
 435 #ifdef __WXMSW__
 436     wxPyDropSource(wxWindow *win = NULL,
 437                  const wxCursor &cursorCopy = wxNullCursor,
 438                  const wxCursor &cursorMove = wxNullCursor,
 439                  const wxCursor &cursorStop = wxNullCursor);
 440 #else
 441     wxPyDropSource(wxWindow *win = NULL,
 442                    const wxIcon &go = wxNullIcon);
 443 #endif
 444
 445     void _setSelf(PyObject* self, PyObject* _class, int incref);
 446     %pragma(python) addtomethod = "__init__:self._setSelf(self, wxDropSource, 0)"
 447     ~wxPyDropSource();
 448
 449     void SetData(wxDataObject& data);
 450     wxDataObject *GetDataObject();
 451     void SetCursor(wxDragResult res, const wxCursor& cursor);
 452     wxDragResult DoDragDrop(int bAllowMove = FALSE);
 453
 454     bool base_GiveFeedback(wxDragResult effect);
 455 };
 456
 457 //----------------------------------------------------------------------
 458
 459 // Just a place holder for the type system.  The real base class for
 460 // wxPython is wxPyDropTarget
 461 class wxDropTarget {
 462 public:
 463 };
 464
 465
 466 %{
 467 class wxPyDropTarget : public wxDropTarget {
 468 public:
 469     wxPyDropTarget(wxDataObject *dataObject = NULL)
 470         : wxDropTarget(dataObject) {}
 471
 472 //      DEC_PYCALLBACK_SIZET_(GetFormatCount);
 473 //      DEC_PYCALLBACK_DATAFMT_SIZET(GetFormat);
 474
 475     DEC_PYCALLBACK__(OnLeave);
 476     DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
 477     DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
 478     DEC_PYCALLBACK_DR_2WXCDR_pure(OnData);
 479     DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
 480
 481     PYPRIVATE;
 482 };
 483
 484 //  IMP_PYCALLBACK_SIZET_(wxPyDropTarget, wxDropTarget, GetFormatCount);
 485 //  IMP__PYCALLBACK_DATAFMT_SIZET(wxPyDropTarget, wxDropTarget, GetFormat);
 486
 487 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
 488 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
 489 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
 490 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
 491 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
 492
 493 %}
 494
 495
 496 class wxPyDropTarget : public wxDropTarget {
 497 public:
 498     wxPyDropTarget(wxDataObject *dataObject = NULL);
 499     %pragma(python) addtomethod = "__init__:if _args:_args[0].thisown = 0"
 500     void _setSelf(PyObject* self, PyObject* _class);
 501     %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyDropTarget)"
 502
 503     ~wxPyDropTarget();
 504
 505     wxDataObject *GetDataObject();
 506     void SetDataObject(wxDataObject *dataObject);
 507     %pragma(python) addtomethod = "SetDataObject:if _args:_args[0].thisown = 0"
 508
 509 //      size_t base_GetFormatCount();
 510 //      wxDataFormat base_GetFormat(size_t n);
 511
 512     wxDragResult base_OnEnter(wxCoord x, wxCoord y, wxDragResult def);
 513     wxDragResult base_OnDragOver(wxCoord x, wxCoord y, wxDragResult def);
 514     void base_OnLeave();
 515     bool base_OnDrop(wxCoord x, wxCoord y);
 516     //wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def) = 0;
 517
 518     // **** not sure about this one
 519     bool GetData();
 520
 521 };
 522
 523
 524 //----------------------------------------------------------------------
 525
 526 %{
 527 class wxPyTextDropTarget : public wxTextDropTarget {
 528 public:
 529     wxPyTextDropTarget() {}
 530
 531     DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
 532
 533     DEC_PYCALLBACK__(OnLeave);
 534     DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
 535     DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
 536     DEC_PYCALLBACK_DR_2WXCDR(OnData);
 537     DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
 538
 539     PYPRIVATE;
 540 };
 541
 542 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
 543 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
 544 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
 545 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
 546 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
 547 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
 548
 549 %}
 550
 551 %name(wxTextDropTarget) class wxPyTextDropTarget : public wxPyDropTarget {
 552 public:
 553     wxPyTextDropTarget();
 554     void _setSelf(PyObject* self, PyObject* _class);
 555     %pragma(python) addtomethod = "__init__:self._setSelf(self, wxTextDropTarget)"
 556
 557     //bool OnDropText(wxCoord x, wxCoord y, const wxString& text) = 0;
 558     wxDragResult base_OnEnter(wxCoord x, wxCoord y, wxDragResult def);
 559     wxDragResult base_OnDragOver(wxCoord x, wxCoord y, wxDragResult def);
 560     void base_OnLeave();
 561     bool base_OnDrop(wxCoord x, wxCoord y);
 562     wxDragResult base_OnData(wxCoord x, wxCoord y, wxDragResult def);
 563 };
 564
 565 //----------------------------------------------------------------------
 566 %{
 567 class wxPyFileDropTarget : public wxFileDropTarget {
 568 public:
 569     wxPyFileDropTarget() {}
 570
 571     virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
 572
 573     DEC_PYCALLBACK__(OnLeave);
 574     DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
 575     DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
 576     DEC_PYCALLBACK_DR_2WXCDR(OnData);
 577     DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
 578
 579     PYPRIVATE;
 580 };
 581
 582 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
 583                                      const wxArrayString& filenames) {
 584     bool rval = FALSE;
 585     bool doSave = wxPyRestoreThread();
 586     PyObject* list = PyList_New(0);
 587     for (size_t i=0; i<filenames.GetCount(); i++) {
 588         PyObject* str = PyString_FromString(filenames[i].c_str());
 589         PyList_Append(list, str);
 590     }
 591     if (m_myInst.findCallback("OnDropFiles"))
 592         rval = m_myInst.callCallback(Py_BuildValue("(iiO)",x,y,list));
 593     Py_DECREF(list);
 594     wxPySaveThread(doSave);
 595     return rval;
 596 }
 597
 598
 599
 600 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
 601 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
 602 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
 603 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
 604 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
 605
 606 %}
 607
 608
 609 %name(wxFileDropTarget) class wxPyFileDropTarget : public wxPyDropTarget
 610 {
 611 public:
 612     wxPyFileDropTarget();
 613     void _setSelf(PyObject* self, PyObject* _class);
 614     %pragma(python) addtomethod = "__init__:self._setSelf(self, wxFileDropTarget)"
 615
 616 //    bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames) = 0;
 617     wxDragResult base_OnEnter(wxCoord x, wxCoord y, wxDragResult def);
 618     wxDragResult base_OnDragOver(wxCoord x, wxCoord y, wxDragResult def);
 619     void base_OnLeave();
 620     bool base_OnDrop(wxCoord x, wxCoord y);
 621     wxDragResult base_OnData(wxCoord x, wxCoord y, wxDragResult def);
 622 };
 623
 624 //----------------------------------------------------------------------
 625 //----------------------------------------------------------------------
 626 //----------------------------------------------------------------------
 627
 628 %init %{
 629
 630     wxPyTheClipboard = wxTheClipboard;
 631
 632 %}
 633
 634 //----------------------------------------------------------------------
 635