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