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