utils/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         rval = (ro != Py_None && PyString_Check(ro));
 155         if (rval)
 156             memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
 157     }
 158     wxPySaveThread(doSave);
 159     return rval;
 160 }
 161
 162 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
 163     // For this one we simply need to make a string from buf and len
 164     // and send it to the Python method.
 165     bool rval = FALSE;
 166     bool doSave = wxPyRestoreThread();
 167     if (m_myInst.findCallback("SetData")) {
 168         PyObject* data = PyString_FromStringAndSize((char*)buf, len);
 169         rval = m_myInst.callCallback(Py_BuildValue("(O)", data));
 170         Py_DECREF(data);
 171     }
 172     wxPySaveThread(doSave);
 173     return rval;
 174 }
 175 %}
 176
 177
 178
 179 // Now define it for SWIG
 180 class wxPyDataObjectSimple : public wxDataObjectSimple {
 181 public:
 182     wxPyDataObjectSimple(const wxDataFormat& format = wxPyFormatInvalid);
 183     void _setSelf(PyObject* self);
 184     %pragma(python) addtomethod = "__init__:self._setSelf(self)"
 185 };
 186
 187 //----------------------------------------------------------------------
 188
 189 class wxDataObjectComposite : public wxDataObject {
 190 public:
 191     wxDataObjectComposite();
 192
 193     void Add(wxDataObjectSimple *dataObject, int preferred = FALSE);
 194     %pragma(python) addtomethod = "Add:_args[0].thisown = 0"
 195
 196 };
 197
 198
 199 //----------------------------------------------------------------------
 200
 201 class wxTextDataObject : public wxDataObjectSimple {
 202 public:
 203     wxTextDataObject(const wxString& text = wxEmptyString);
 204
 205     size_t GetTextLength();
 206     wxString GetText();
 207     void SetText(const wxString& text);
 208 };
 209
 210
 211
 212 %{  // Create a new class for wxPython to use
 213 class wxPyTextDataObject : public wxTextDataObject {
 214 public:
 215     wxPyTextDataObject(const wxString& text = wxEmptyString)
 216         : wxTextDataObject(text) {}
 217
 218     DEC_PYCALLBACK_SIZET_(GetTextLength);
 219     DEC_PYCALLBACK_STRING_(GetText);
 220     DEC_PYCALLBACK__STRING(SetText);
 221     PYPRIVATE;
 222 };
 223
 224 IMP_PYCALLBACK_SIZET_(wxPyTextDataObject, wxTextDataObject, GetTextLength);
 225 IMP_PYCALLBACK_STRING_(wxPyTextDataObject, wxTextDataObject, GetText);
 226 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
 227
 228 %}
 229
 230
 231 // Now define it for SWIG
 232 class wxPyTextDataObject : public wxTextDataObject {
 233 public:
 234     wxPyTextDataObject(const wxString& text = wxEmptyString);
 235     void _setSelf(PyObject* self);
 236     %pragma(python) addtomethod = "__init__:self._setSelf(self)"
 237 };
 238
 239 //----------------------------------------------------------------------
 240
 241 class wxBitmapDataObject : public wxDataObjectSimple {
 242 public:
 243     wxBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap);
 244
 245     wxBitmap GetBitmap();
 246     void SetBitmap(const wxBitmap& bitmap);
 247 };
 248
 249
 250
 251 %{  // Create a new class for wxPython to use
 252 class wxPyBitmapDataObject : public wxBitmapDataObject {
 253 public:
 254     wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
 255         : wxBitmapDataObject(bitmap) {}
 256
 257     wxBitmap GetBitmap();
 258     void SetBitmap(const wxBitmap& bitmap);
 259     PYPRIVATE;
 260 };
 261
 262 wxBitmap wxPyBitmapDataObject::GetBitmap() {
 263     wxBitmap* rval = &wxNullBitmap;
 264     bool doSave = wxPyRestoreThread();
 265     if (m_myInst.findCallback("GetBitmap")) {
 266         PyObject* ro;
 267         wxBitmap* ptr;
 268         ro = m_myInst.callCallbackObj(Py_BuildValue("()"));
 269         if (! SWIG_GetPtrObj(ro, (void **)&ptr, "_wxBitmap_p"))
 270             rval = ptr;
 271     }
 272     wxPySaveThread(doSave);
 273     return *rval;
 274 }
 275
 276 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
 277     bool doSave = wxPyRestoreThread();
 278     if (m_myInst.findCallback("SetBitmap")) {
 279         m_myInst.callCallback(Py_BuildValue("(O)",
 280                               wxPyConstructObject((void*)&bitmap, "wxBitmap")));
 281     }
 282     wxPySaveThread(doSave);
 283 }
 284 %}
 285
 286
 287
 288 // Now define it for SWIG
 289 class wxPyBitmapDataObject : public wxBitmapDataObject {
 290 public:
 291     wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap);
 292     void _setSelf(PyObject* self);
 293     %pragma(python) addtomethod = "__init__:self._setSelf(self)"
 294 };
 295
 296
 297 //----------------------------------------------------------------------
 298
 299 class wxFileDataObject : public wxDataObjectSimple
 300 {
 301 public:
 302     wxFileDataObject();
 303
 304     //const wxArrayString& GetFilenames();
 305     %addmethods {
 306         PyObject* GetFilenames() {
 307             const wxArrayString& strings = self->GetFilenames();
 308             PyObject* list = PyList_New(0);
 309             for (size_t x=0; x<strings.GetCount(); x++)
 310                 PyList_Append(list, PyString_FromString(strings[x]));
 311             return list;
 312         }
 313     }
 314
 315     //void AddFile(const wxString &filename);
 316 };
 317
 318
 319 //----------------------------------------------------------------------
 320
 321 class wxCustomDataObject : public wxDataObjectSimple {
 322 public:
 323     wxCustomDataObject(const wxDataFormat& format = wxPyFormatInvalid);
 324
 325     //void TakeData(size_t size, void *data);
 326     //bool SetData(size_t size, const void *buf);
 327     %addmethods {
 328         void TakeData(PyObject* data) {
 329             if (PyString_Check(data)) {
 330                 self->SetData(PyString_Size(data), PyString_AsString(data));
 331             }
 332         }
 333         bool SetData(PyObject* data) {
 334             if (PyString_Check(data)) {
 335                 return self->SetData(PyString_Size(data), PyString_AsString(data));
 336             }
 337             return FALSE;
 338         }
 339     }
 340
 341     size_t GetSize();
 342     //void *GetData();
 343     %addmethods {
 344         PyObject* GetData() {
 345             return PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
 346         }
 347     }
 348
 349
 350 };
 351
 352
 353
 354 //----------------------------------------------------------------------
 355 //----------------------------------------------------------------------
 356 //----------------------------------------------------------------------
 357
 358 class wxClipboard {
 359 public:
 360     wxClipboard();
 361
 362     bool Open();
 363     void Close();
 364     bool IsOpened() const;
 365
 366     bool AddData( wxDataObject *data );
 367     %pragma(python) addtomethod = "AddData:_args[0].thisown = 0"
 368     bool SetData( wxDataObject *data );
 369     %pragma(python) addtomethod = "SetData:_args[0].thisown = 0"
 370
 371     bool IsSupported( const wxDataFormat& format );
 372     bool GetData( wxDataObject& data );
 373     void Clear();
 374     bool Flush();
 375     void UsePrimarySelection( int primary = FALSE );
 376 };
 377
 378 %{
 379     wxClipboard* wxPyTheClipboard;
 380 %}
 381 %readonly
 382 %name(wxTheClipboard) wxClipboard* wxPyTheClipboard;
 383 %readwrite
 384
 385 //----------------------------------------------------------------------
 386 //----------------------------------------------------------------------
 387
 388 enum wxDragResult
 389 {
 390     wxDragError,    // error prevented the d&d operation from completing
 391     wxDragNone,     // drag target didn't accept the data
 392     wxDragCopy,     // the data was successfully copied
 393     wxDragMove,     // the data was successfully moved (MSW only)
 394     wxDragCancel    // the operation was cancelled by user (not an error)
 395 };
 396
 397 bool wxIsDragResultOk(wxDragResult res);
 398
 399 //----------------------------------------------------------------------
 400 %{
 401 class wxPyDropSource : public wxDropSource {
 402 public:
 403 #ifdef __WXMSW__
 404     wxPyDropSource(wxWindow *win = NULL,
 405                    const wxCursor &cursorCopy = wxNullCursor,
 406                    const wxCursor &cursorMove = wxNullCursor,
 407                    const wxCursor &cursorStop = wxNullCursor)
 408         : wxDropSource(win, cursorCopy, cursorMove, cursorStop) {}
 409 #else
 410     wxPyDropSource(wxWindow *win = NULL,
 411                    const wxIcon &go = wxNullIcon)
 412         : wxDropSource(win, go) {}
 413 #endif
 414     ~wxPyDropSource() { printf("dtor\n"); }
 415
 416     DEC_PYCALLBACK_BOOL_DR(GiveFeedback);
 417     PYPRIVATE;
 418 };
 419
 420 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
 421
 422 %}
 423
 424
 425 %name(wxDropSource) class wxPyDropSource {
 426 public:
 427 #ifdef __WXMSW__
 428     wxPyDropSource(wxWindow *win = NULL,
 429                  const wxCursor &cursorCopy = wxNullCursor,
 430                  const wxCursor &cursorMove = wxNullCursor,
 431                  const wxCursor &cursorStop = wxNullCursor);
 432 #else
 433     wxPyDropSource(wxWindow *win = NULL,
 434                    const wxIcon &go = wxNullIcon);
 435 #endif
 436
 437     void _setSelf(PyObject* self, int incref);
 438     %pragma(python) addtomethod = "__init__:self._setSelf(self, 0)"
 439     ~wxPyDropSource();
 440
 441     void SetData(wxDataObject& data);
 442     wxDataObject *GetDataObject();
 443     void SetCursor(wxDragResult res, const wxCursor& cursor);
 444     wxDragResult DoDragDrop(int bAllowMove = FALSE);
 445
 446     bool base_GiveFeedback(wxDragResult effect);
 447 };
 448
 449 //----------------------------------------------------------------------
 450
 451 // Just a place holder for the type system.  The real base class for
 452 // wxPython is wxPyDropTarget
 453 class wxDropTarget {
 454 public:
 455 };
 456
 457
 458 %{
 459 class wxPyDropTarget : public wxDropTarget {
 460 public:
 461     wxPyDropTarget(wxDataObject *dataObject = NULL)
 462         : wxDropTarget(dataObject) {}
 463
 464 //      DEC_PYCALLBACK_SIZET_(GetFormatCount);
 465 //      DEC_PYCALLBACK_DATAFMT_SIZET(GetFormat);
 466
 467     DEC_PYCALLBACK__(OnLeave);
 468     DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
 469     DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
 470     DEC_PYCALLBACK_DR_2WXCDR_pure(OnData);
 471     DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
 472
 473     PYPRIVATE;
 474 };
 475
 476 //  IMP_PYCALLBACK_SIZET_(wxPyDropTarget, wxDropTarget, GetFormatCount);
 477 //  IMP__PYCALLBACK_DATAFMT_SIZET(wxPyDropTarget, wxDropTarget, GetFormat);
 478
 479 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
 480 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
 481 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
 482 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
 483 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
 484
 485 %}
 486
 487
 488 class wxPyDropTarget : public wxDropTarget {
 489 public:
 490     wxPyDropTarget(wxDataObject *dataObject = NULL);
 491     %pragma(python) addtomethod = "__init__:if _args:_args[0].thisown = 0"
 492     void _setSelf(PyObject* self);
 493     %pragma(python) addtomethod = "__init__:self._setSelf(self)"
 494
 495     ~wxPyDropTarget();
 496
 497     wxDataObject *GetDataObject();
 498     void SetDataObject(wxDataObject *dataObject);
 499     %pragma(python) addtomethod = "SetDataObject:if _args:_args[0].thisown = 0"
 500
 501 //      size_t base_GetFormatCount();
 502 //      wxDataFormat base_GetFormat(size_t n);
 503
 504     wxDragResult base_OnEnter(wxCoord x, wxCoord y, wxDragResult def);
 505     wxDragResult base_OnDragOver(wxCoord x, wxCoord y, wxDragResult def);
 506     void base_OnLeave();
 507     bool base_OnDrop(wxCoord x, wxCoord y);
 508     //wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def) = 0;
 509
 510     // **** not sure about this one
 511     bool GetData();
 512
 513 };
 514
 515
 516 //----------------------------------------------------------------------
 517
 518 %{
 519 class wxPyTextDropTarget : public wxTextDropTarget {
 520 public:
 521     wxPyTextDropTarget() {}
 522
 523     DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
 524
 525     DEC_PYCALLBACK__(OnLeave);
 526     DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
 527     DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
 528     DEC_PYCALLBACK_DR_2WXCDR(OnData);
 529     DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
 530
 531     PYPRIVATE;
 532 };
 533
 534 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
 535 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
 536 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
 537 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
 538 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
 539 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
 540
 541 %}
 542
 543 %name(wxTextDropTarget) class wxPyTextDropTarget : public wxPyDropTarget {
 544 public:
 545     wxPyTextDropTarget();
 546     void _setSelf(PyObject* self);
 547     %pragma(python) addtomethod = "__init__:self._setSelf(self)"
 548
 549     //bool OnDropText(wxCoord x, wxCoord y, const wxString& text) = 0;
 550     wxDragResult base_OnEnter(wxCoord x, wxCoord y, wxDragResult def);
 551     wxDragResult base_OnDragOver(wxCoord x, wxCoord y, wxDragResult def);
 552     void base_OnLeave();
 553     bool base_OnDrop(wxCoord x, wxCoord y);
 554     wxDragResult base_OnData(wxCoord x, wxCoord y, wxDragResult def);
 555 };
 556
 557 //----------------------------------------------------------------------
 558 %{
 559 class wxPyFileDropTarget : public wxFileDropTarget {
 560 public:
 561     wxPyFileDropTarget() {}
 562
 563     virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
 564
 565     DEC_PYCALLBACK__(OnLeave);
 566     DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
 567     DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
 568     DEC_PYCALLBACK_DR_2WXCDR(OnData);
 569     DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
 570
 571     PYPRIVATE;
 572 };
 573
 574 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
 575                                      const wxArrayString& filenames) {
 576     bool rval = FALSE;
 577     bool doSave = wxPyRestoreThread();
 578     PyObject* list = PyList_New(0);
 579     for (size_t i=0; i<filenames.GetCount(); i++) {
 580         PyObject* str = PyString_FromString(filenames[i].c_str());
 581         PyList_Append(list, str);
 582     }
 583     if (m_myInst.findCallback("OnDropFiles"))
 584         rval = m_myInst.callCallback(Py_BuildValue("(iiO)",x,y,list));
 585     Py_DECREF(list);
 586     wxPySaveThread(doSave);
 587     return rval;
 588 }
 589
 590
 591
 592 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
 593 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
 594 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
 595 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
 596 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
 597
 598 %}
 599
 600
 601 %name(wxFileDropTarget) class wxPyFileDropTarget : public wxPyDropTarget
 602 {
 603 public:
 604     wxPyFileDropTarget();
 605     void _setSelf(PyObject* self);
 606     %pragma(python) addtomethod = "__init__:self._setSelf(self)"
 607
 608 //    bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames) = 0;
 609     wxDragResult base_OnEnter(wxCoord x, wxCoord y, wxDragResult def);
 610     wxDragResult base_OnDragOver(wxCoord x, wxCoord y, wxDragResult def);
 611     void base_OnLeave();
 612     bool base_OnDrop(wxCoord x, wxCoord y);
 613     wxDragResult base_OnData(wxCoord x, wxCoord y, wxDragResult def);
 614 };
 615
 616 //----------------------------------------------------------------------
 617 //----------------------------------------------------------------------
 618 //----------------------------------------------------------------------
 619
 620 %init %{
 621
 622     wxPyTheClipboard = wxTheClipboard;
 623
 624 %}
 625
 626 //----------------------------------------------------------------------
 627