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