wxPython/src/_dataobj.i

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        _dataobj.i
   3 // Purpose:     SWIG definitions for the Data Object classes
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     31-October-1999
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 2003 by Total Control Software
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 // Not a %module
  14
  15
  16 //---------------------------------------------------------------------------
  17
  18 %{
  19 #include <wx/dataobj.h>
  20 %}
  21
  22 //---------------------------------------------------------------------------
  23 %newgroup
  24
  25
  26 enum wxDataFormatId
  27 {
  28     wxDF_INVALID,
  29     wxDF_TEXT,
  30     wxDF_BITMAP,
  31     wxDF_METAFILE,
  32     wxDF_SYLK,
  33     wxDF_DIF,
  34     wxDF_TIFF,
  35     wxDF_OEMTEXT,
  36     wxDF_DIB,
  37     wxDF_PALETTE,
  38     wxDF_PENDATA,
  39     wxDF_RIFF,
  40     wxDF_WAVE,
  41     wxDF_UNICODETEXT,
  42     wxDF_ENHMETAFILE,
  43     wxDF_FILENAME,
  44     wxDF_LOCALE,
  45     wxDF_PRIVATE,
  46     wxDF_HTML,
  47     wxDF_MAX,
  48 };
  49
  50
  51 DocStr(wxDataFormat,
  52 "A wx.DataFormat is an encapsulation of a platform-specific format
  53 handle which is used by the system for the clipboard and drag and drop
  54 operations. The applications are usually only interested in, for
  55 example, pasting data from the clipboard only if the data is in a
  56 format the program understands.  A data format is is used to uniquely
  57 identify this format.",
  58 "
  59 On the system level, a data format is usually just a number, (which
  60 may be the CLIPFORMAT under Windows or Atom under X11, for example.)
  61
  62 The standard format IDs are:
  63
  64     ================    =====================================
  65     wx.DF_INVALID       An invalid format
  66     wx.DF_TEXT          Text format
  67     wx.DF_BITMAP        A bitmap (wx.Bitmap)
  68     wx.DF_METAFILE      A metafile (wx.Metafile, Windows only)
  69     wx.DF_FILENAME      A list of filenames
  70     wx.DF_HTML          An HTML string. This is only valid on
  71                         Windows and non-unicode builds
  72     ================    =====================================
  73
  74 Besies the standard formats, the application may also use custom
  75 formats which are identified by their names (strings) and not numeric
  76 identifiers. Although internally custom format must be created (or
  77 registered) first, you shouldn\'t care about it because it is done
  78 automatically the first time the wxDataFormat object corresponding to
  79 a given format name is created.
  80
  81 ");
  82
  83 class wxDataFormat {
  84 public:
  85     DocCtorStr(
  86         wxDataFormat( wxDataFormatId type ),
  87         "Constructs a data format object for one of the standard data formats
  88 or an empty data object (use SetType or SetId later in this case)", "");
  89
  90     DocCtorStrName(
  91         wxDataFormat(const wxString& format),
  92         "Constructs a data format object for a custom format identified by its
  93 name.", "",
  94         CustomDataFormat);
  95
  96     ~wxDataFormat();
  97
  98
  99     %nokwargs operator==;
 100     %nokwargs operator!=;
 101     bool operator==(wxDataFormatId format) const;
 102     bool operator!=(wxDataFormatId format) const;
 103     bool operator==(const wxDataFormat& format) const;
 104     bool operator!=(const wxDataFormat& format) const;
 105
 106
 107     DocDeclStr(
 108         void , SetType(wxDataFormatId format),
 109         "Sets the format to the given value, which should be one of wx.DF_XXX
 110 constants.", "");
 111
 112     DocDeclStr(
 113         wxDataFormatId , GetType() const,
 114         "Returns the platform-specific number identifying the format.", "");
 115
 116
 117     DocDeclStr(
 118         wxString , GetId() const,
 119         "Returns the name of a custom format (this function will fail for a
 120 standard format).", "");
 121
 122     DocDeclStr(
 123         void , SetId(const wxString& format),
 124         "Sets the format to be the custom format identified by the given name.", "");
 125 };
 126
 127
 128 %immutable;
 129 const wxDataFormat wxFormatInvalid;
 130 %mutable;
 131
 132 //---------------------------------------------------------------------------
 133
 134
 135 DocStr(wxDataObject,
 136 "A wx.DataObject represents data that can be copied to or from the
 137 clipboard, or dragged and dropped. The important thing about
 138 wx.DataObject is that this is a 'smart' piece of data unlike usual
 139 'dumb' data containers such as memory buffers or files. Being 'smart'
 140 here means that the data object itself should know what data formats
 141 it supports and how to render itself in each of supported formats.
 142
 143 **NOTE**: This class is an abstract base class and can not be used
 144 directly from Python.  If you need a custom type of data object then
 145 you should instead derive from `wx.PyDataObjectSimple` or use
 146 `wx.CustomDataObject`.
 147 ", "
 148 Not surprisingly, being 'smart' comes at a price of added
 149 complexity. This is reasonable for the situations when you really need
 150 to support multiple formats, but may be annoying if you only want to
 151 do something simple like cut and paste text.
 152
 153 To provide a solution for both cases, wxWidgets has two predefined
 154 classes which derive from wx.DataObject: `wx.DataObjectSimple` and
 155 `wx.DataObjectComposite`.  `wx.DataObjectSimple` is the simplest
 156 wx.DataObject possible and only holds data in a single format (such as
 157 text or bitmap) and `wx.DataObjectComposite` is the simplest way to
 158 implement a wx.DataObject which supports multiple simultaneous formats
 159 because it achievs this by simply holding several
 160 `wx.DataObjectSimple` objects.
 161
 162 Please note that the easiest way to use drag and drop and the
 163 clipboard with multiple formats is by using `wx.DataObjectComposite`,
 164 but it is not the most efficient one as each `wx.DataObjectSimple`
 165 would contain the whole data in its respective formats. Now imagine
 166 that you want to paste 200 pages of text in your proprietary format,
 167 as well as Word, RTF, HTML, Unicode and plain text to the clipboard
 168 and even today's computers are in trouble. For this case, you will
 169 have to derive from wx.DataObject directly and make it enumerate its
 170 formats and provide the data in the requested format on
 171 demand. (**TODO**: This is currently not possible from Python.  Make
 172 it so.)
 173
 174 Note that the platform transfer mechanisms for the clipboard and drag
 175 and drop, do not copy any data out of the source application until
 176 another application actually requests the data. This is in contrast to
 177 the 'feel' offered to the user of a program who would normally think
 178 that the data resides in the clipboard after having pressed 'Copy' -
 179 in reality it is only declared to be available.
 180 ");
 181
 182 // [other docs...]
 183 // There are several predefined data object classes derived from
 184 // wxDataObjectSimple: wxFileDataObject, wxTextDataObject and
 185 // wxBitmapDataObject which can be used without change.
 186
 187 // You may also derive your own data object classes from
 188 // wxCustomDataObject for user-defined types. The format of user-defined
 189 // data is given as mime-type string literal, such as 'application/word'
 190 // or 'image/png'. These strings are used as they are under Unix (so far
 191 // only GTK) to identify a format and are translated into their Windows
 192 // equivalent under Win32 (using the OLE IDataObject for data exchange to
 193 // and from the clipboard and for drag and drop). Note that the format
 194 // string translation under Windows is not yet finished.
 195
 196
 197
 198 class wxDataObject {
 199 public:
 200     enum Direction {
 201         Get  = 0x01,    // format is supported by GetDataHere()
 202         Set  = 0x02,    // format is supported by SetData()
 203         Both = 0x03     // format is supported by both (unused currently)
 204     };
 205
 206     // wxDataObject();  // ***  It's an ABC.
 207     ~wxDataObject();
 208
 209     DocDeclStr(
 210         virtual wxDataFormat , GetPreferredFormat(Direction dir = Get) const,
 211         "Returns the preferred format for either rendering the data (if dir is
 212 Get, its default value) or for setting it. Usually this will be the
 213 native format of the wx.DataObject.", "");
 214
 215
 216     DocDeclStr(
 217         virtual size_t , GetFormatCount(Direction dir = Get) const,
 218         "Returns the number of available formats for rendering or setting the
 219 data.", "");
 220
 221
 222     DocDeclStr(
 223         bool , IsSupported(const wxDataFormat& format, Direction dir = Get) const,
 224         "Returns True if this format is supported.", "");
 225
 226
 227     DocDeclStr(
 228         virtual size_t , GetDataSize(const wxDataFormat& format) const,
 229         "Get the (total) size of data for the given format", "");
 230
 231
 232
 233     %extend {
 234         DocAStr(GetAllFormats,
 235                 "GetAllFormats(self, int dir=Get) -> [formats]",
 236                 "Returns a list of all the wx.DataFormats that this dataobject supports
 237 in the given direction.", "");
 238         PyObject* GetAllFormats(Direction dir = Get) {
 239             size_t count = self->GetFormatCount(dir);
 240             wxDataFormat* formats = new wxDataFormat[count];
 241             self->GetAllFormats(formats, dir);
 242
 243             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 244             PyObject* list = PyList_New(count);
 245             for (size_t i=0; i<count; i++) {
 246                 wxDataFormat* format = new wxDataFormat(formats[i]);
 247                 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
 248                 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
 249             }
 250             wxPyEndBlockThreads(blocked);
 251             delete [] formats;
 252             return list;
 253         }
 254     }
 255
 256
 257
 258     // copy raw data (in the specified format) to the provided buffer, return
 259     // True if data copied successfully, False otherwise
 260     // virtual bool GetDataHere(const wxDataFormat& format, void *buf) const;
 261
 262     %extend {
 263         DocAStr(GetDataHere,
 264                 "GetDataHere(self, DataFormat format) -> String",
 265                 "Get the data bytes in the specified format, returns None on failure.", "
 266 :todo: This should use the python buffer interface isntead...");
 267         PyObject* GetDataHere(const wxDataFormat& format) {
 268             PyObject* rval = NULL;
 269             size_t size = self->GetDataSize(format);
 270             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 271             if (size) {
 272                 char* buf = new char[size];
 273                 if (self->GetDataHere(format, buf))
 274                     rval = PyString_FromStringAndSize(buf, size);
 275                 delete [] buf;
 276             }
 277             if (! rval) {
 278                 rval = Py_None;
 279                 Py_INCREF(rval);
 280             }
 281             wxPyEndBlockThreads(blocked);
 282             return rval;
 283         }
 284     }
 285
 286
 287     // get data from the buffer of specified length (in the given format),
 288     // return True if the data was read successfully, False otherwise
 289     //virtual bool SetData(const wxDataFormat& format,
 290     //                     size_t len, const void * buf);
 291     DocAStr(SetData,
 292             "SetData(self, DataFormat format, String data) -> bool",
 293             "Set the data in the specified format from the bytes in the the data string.
 294 ", "
 295 :todo: This should use the python buffer interface isntead...");
 296     %extend {
 297         bool SetData(const wxDataFormat& format, PyObject* data) {
 298             bool rval;
 299             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 300             if (PyString_Check(data)) {
 301                 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
 302             }
 303             else {
 304                 // raise a TypeError if not a string
 305                 PyErr_SetString(PyExc_TypeError, "String expected.");
 306                 rval = false;
 307             }
 308             wxPyEndBlockThreads(blocked);
 309             return rval;
 310         }
 311     }
 312
 313
 314 };
 315
 316
 317 //---------------------------------------------------------------------------
 318
 319
 320 DocStr(wxDataObjectSimple,
 321 "wx.DataObjectSimple is a `wx.DataObject` which only supports one
 322 format.  This is the simplest possible `wx.DataObject` implementation.
 323
 324 This is still an \"abstract base class\" meaning that you can't use it
 325 directly.  You either need to use one of the predefined base classes,
 326 or derive your own class from `wx.PyDataObjectSimple`.
 327 ", "");
 328
 329 class wxDataObjectSimple : public wxDataObject {
 330 public:
 331     DocCtorStr(
 332         wxDataObjectSimple(const wxDataFormat& format = wxFormatInvalid),
 333         "Constructor accepts the supported format (none by default) which may
 334 also be set later with `SetFormat`.","");
 335
 336
 337     DocDeclStr(
 338         const wxDataFormat& , GetFormat(),
 339         "Returns the (one and only one) format supported by this object. It is
 340 assumed that the format is supported in both directions.", "");
 341
 342     DocDeclStr(
 343         void , SetFormat(const wxDataFormat& format),
 344         "Sets the supported format.", "");
 345
 346     DocDeclStr(
 347         virtual size_t , GetDataSize() const,
 348         "Get the size of our data.", "");
 349
 350
 351
 352     %extend {
 353         DocAStr(GetDataHere,
 354                 "GetDataHere(self) -> String",
 355                 "Returns the data bytes from the data object as a string, returns None
 356 on failure.  Must be implemented in the derived class if the object
 357 supports rendering its data.", "");
 358         PyObject* GetDataHere() {
 359             PyObject* rval = NULL;
 360             size_t size = self->GetDataSize();
 361             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 362             if (size) {
 363                 char* buf = new char[size];
 364                 if (self->GetDataHere(buf))
 365                     rval = PyString_FromStringAndSize(buf, size);
 366                 delete [] buf;
 367             }
 368             if (! rval) {
 369                 rval = Py_None;
 370                 Py_INCREF(rval);
 371             }
 372             wxPyEndBlockThreads(blocked);
 373             return rval;
 374         }
 375     }
 376
 377
 378     %extend {
 379         DocAStr(SetData,
 380                 "SetData(self, String data) -> bool",
 381                 "Copy the data value to the data object.  Must be implemented in the
 382 derived class if the object supports setting its data.
 383 ", "");
 384         bool SetData(PyObject* data) {
 385             bool rval;
 386             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 387             if (PyString_Check(data)) {
 388                 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
 389             }
 390             else {
 391                 // raise a TypeError if not a string
 392                 PyErr_SetString(PyExc_TypeError, "String expected.");
 393                 rval = false;
 394             }
 395             wxPyEndBlockThreads(blocked);
 396             return rval;
 397         }
 398     }
 399
 400 };
 401
 402
 403
 404
 405 %{  // Create a new class for wxPython to use
 406 class wxPyDataObjectSimple : public wxDataObjectSimple {
 407 public:
 408     wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
 409         : wxDataObjectSimple(format) {}
 410
 411     DEC_PYCALLBACK_SIZET__const(GetDataSize);
 412     bool GetDataHere(void *buf) const;
 413     bool SetData(size_t len, const void *buf) const;
 414     PYPRIVATE;
 415 };
 416
 417 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
 418
 419 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
 420     // We need to get the data for this object and write it to buf.  I think
 421     // the best way to do this for wxPython is to have the Python method
 422     // return either a string or None and then act appropriately with the
 423     // C++ version.
 424
 425     bool rval = false;
 426     wxPyBlock_t blocked = wxPyBeginBlockThreads();
 427     if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
 428         PyObject* ro;
 429         ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
 430         if (ro) {
 431             rval = (ro != Py_None && PyString_Check(ro));
 432             if (rval)
 433                 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
 434             Py_DECREF(ro);
 435         }
 436     }
 437     wxPyEndBlockThreads(blocked);
 438     return rval;
 439 }
 440
 441 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
 442     // For this one we simply need to make a string from buf and len
 443     // and send it to the Python method.
 444     bool rval = false;
 445     wxPyBlock_t blocked = wxPyBeginBlockThreads();
 446     if (wxPyCBH_findCallback(m_myInst, "SetData")) {
 447         PyObject* data = PyString_FromStringAndSize((char*)buf, len);
 448         rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
 449         Py_DECREF(data);
 450     }
 451     wxPyEndBlockThreads(blocked);
 452     return rval;
 453 }
 454 %}
 455
 456
 457
 458 // Now define it for SWIG
 459 DocStr(wxPyDataObjectSimple,
 460 "wx.PyDataObjectSimple is a version of `wx.DataObjectSimple` that is
 461 Python-aware and knows how to reflect calls to its C++ virtual methods
 462 to methods in the Python derived class.  You should derive from this
 463 class and overload `GetDataSize`, `GetDataHere` and `SetData` when you
 464 need to create your own simple single-format type of `wx.DataObject`.
 465 ", "
 466 Here is a simple example::
 467
 468     class MyDataObject(wx.PyDataObjectSimple):
 469         def __init__(self):
 470             wx.PyDataObjectSimple.__init__(
 471                 self, wx.CustomDataFormat('MyDOFormat'))
 472             self.data = ''
 473
 474         def GetDataSize(self):
 475             return len(self.data)
 476         def GetDataHere(self):
 477             return self.data  # returns a string
 478         def SetData(self, data):
 479             self.data = data
 480             return True
 481
 482 Note that there is already a `wx.CustomDataObject` class that behaves
 483 very similarly to this example.  The value of creating your own
 484 derived class like this is to be able to do additional things when the
 485 data is requested or given via the clipboard or drag and drop
 486 operation, such as generate the data value or decode it into needed
 487 data structures.
 488 ");
 489 class wxPyDataObjectSimple : public wxDataObjectSimple {
 490 public:
 491     %pythonAppend wxPyDataObjectSimple   "self._setCallbackInfo(self, PyDataObjectSimple)"
 492
 493     wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid);
 494     void _setCallbackInfo(PyObject* self, PyObject* _class);
 495 };
 496
 497
 498 //---------------------------------------------------------------------------
 499
 500
 501 DocStr(wxDataObjectComposite,
 502 "wx.DataObjectComposite is the simplest `wx.DataObject` derivation
 503 which may be sued to support multiple formats. It contains several
 504 'wx.DataObjectSimple` objects and supports any format supported by at
 505 least one of them. Only one of these data objects is *preferred* (the
 506 first one if not explicitly changed by using the second parameter of
 507 `Add`) and its format determines the preferred format of the composite
 508 data object as well.
 509
 510 See `wx.DataObject` documentation for the reasons why you might prefer
 511 to use wx.DataObject directly instead of wx.DataObjectComposite for
 512 efficiency reasons.
 513 ", "");
 514
 515 class wxDataObjectComposite : public wxDataObject {
 516 public:
 517     wxDataObjectComposite();
 518
 519     %disownarg( wxDataObjectSimple *dataObject );
 520
 521     DocDeclStr(
 522         void , Add(wxDataObjectSimple *dataObject, bool preferred = false),
 523         "Adds the dataObject to the list of supported objects and it becomes
 524 the preferred object if preferred is True.", "");
 525
 526     %cleardisown( wxDataObjectSimple *dataObject );
 527 };
 528
 529 //---------------------------------------------------------------------------
 530
 531 DocStr(wxTextDataObject,
 532 "wx.TextDataObject is a specialization of `wx.DataObject` for text
 533 data. It can be used without change to paste data into the `wx.Clipboard`
 534 or a `wx.DropSource`.
 535
 536 Alternativly, you may wish to derive a new class from the
 537 `wx.PyTextDataObject` class for providing text on-demand in order to
 538 minimize memory consumption when offering data in several formats,
 539 such as plain text and RTF, because by default the text is stored in a
 540 string in this class, but it might as well be generated on demand when
 541 requested. For this, `GetTextLength` and `GetText` will have to be
 542 overridden.", "");
 543 class wxTextDataObject : public wxDataObjectSimple {
 544 public:
 545     DocCtorStr(
 546         wxTextDataObject(const wxString& text = wxPyEmptyString),
 547         "Constructor, may be used to initialise the text (otherwise `SetText`
 548 should be used later).", "");
 549
 550     DocDeclStr(
 551         size_t , GetTextLength(),
 552         "Returns the data size.  By default, returns the size of the text data
 553 set in the constructor or using `SetText`.  This can be overridden (via
 554 `wx.PyTextDataObject`) to provide text size data on-demand. It is
 555 recommended to return the text length plus 1 for a trailing zero, but
 556 this is not strictly required.", "");
 557
 558     DocDeclStr(
 559         wxString , GetText(),
 560         "Returns the text associated with the data object.", "");
 561
 562     DocDeclStr(
 563         void , SetText(const wxString& text),
 564         "Sets the text associated with the data object. This method is called
 565 when the data object receives the data and, by default, copies the
 566 text into the member variable. If you want to process the text on the
 567 fly you may wish to override this function (via
 568 `wx.PyTextDataObject`.)", "");
 569
 570 };
 571
 572
 573
 574
 575
 576
 577 %{  // Create a new class for wxPython to use
 578 class wxPyTextDataObject : public wxTextDataObject {
 579 public:
 580     wxPyTextDataObject(const wxString& text = wxPyEmptyString)
 581         : wxTextDataObject(text) {}
 582
 583     DEC_PYCALLBACK_SIZET__const(GetTextLength);
 584     DEC_PYCALLBACK_STRING__const(GetText);
 585     DEC_PYCALLBACK__STRING(SetText);
 586     PYPRIVATE;
 587 };
 588
 589 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
 590 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
 591 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
 592
 593 %}
 594
 595
 596 // Now define it for SWIG
 597
 598 DocStr(wxPyTextDataObject,
 599 "wx.PyTextDataObject is a version of `wx.TextDataObject` that is
 600 Python-aware and knows how to reflect calls to its C++ virtual methods
 601 to methods in the Python derived class.  You should derive from this
 602 class and overload `GetTextLength`, `GetText`, and `SetText` when you
 603 want to be able to provide text on demand instead of preloading it
 604 into the data object.", "");
 605
 606 class wxPyTextDataObject : public wxTextDataObject {
 607 public:
 608     %pythonAppend wxPyTextDataObject   "self._setCallbackInfo(self, PyTextDataObject)"
 609
 610     wxPyTextDataObject(const wxString& text = wxPyEmptyString);
 611     void _setCallbackInfo(PyObject* self, PyObject* _class);
 612 };
 613
 614 //---------------------------------------------------------------------------
 615
 616 DocStr(wxBitmapDataObject,
 617 "wx.BitmapDataObject is a specialization of wxDataObject for bitmap
 618 data. It can be used without change to paste data into the `wx.Clipboard`
 619 or a `wx.DropSource`.
 620 ", "
 621 :see: `wx.PyBitmapDataObject` if you wish to override `GetBitmap` to increase efficiency.");
 622
 623 class wxBitmapDataObject : public wxDataObjectSimple {
 624 public:
 625     DocCtorStr(
 626         wxBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap),
 627         "Constructor, optionally passing a bitmap (otherwise use `SetBitmap`
 628 later).", "");
 629
 630     DocDeclStr(
 631         wxBitmap , GetBitmap() const,
 632         "Returns the bitmap associated with the data object.  You may wish to
 633 override this method (by deriving from `wx.PyBitmapDataObject`) when
 634 offering data on-demand, but this is not required by wxWidgets'
 635 internals. Use this method to get data in bitmap form from the
 636 `wx.Clipboard`.", "");
 637
 638     DocDeclStr(
 639         void , SetBitmap(const wxBitmap& bitmap),
 640         "Sets the bitmap associated with the data object. This method is called
 641 when the data object receives data. Usually there will be no reason to
 642 override this function.", "");
 643
 644 };
 645
 646
 647
 648
 649
 650 %{  // Create a new class for wxPython to use
 651 class wxPyBitmapDataObject : public wxBitmapDataObject {
 652 public:
 653     wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
 654         : wxBitmapDataObject(bitmap) {}
 655
 656     wxBitmap GetBitmap() const;
 657     void SetBitmap(const wxBitmap& bitmap);
 658     PYPRIVATE;
 659 };
 660
 661 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
 662     wxBitmap* rval = &wxNullBitmap;
 663     wxPyBlock_t blocked = wxPyBeginBlockThreads();
 664     if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
 665         PyObject* ro;
 666         wxBitmap* ptr;
 667         ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
 668         if (ro) {
 669             if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
 670                 rval = ptr;
 671             Py_DECREF(ro);
 672         }
 673     }
 674     wxPyEndBlockThreads(blocked);
 675     return *rval;
 676 }
 677
 678 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
 679     wxPyBlock_t blocked = wxPyBeginBlockThreads();
 680     if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
 681         PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
 682         wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
 683         Py_DECREF(bo);
 684     }
 685     wxPyEndBlockThreads(blocked);
 686 }
 687 %}
 688
 689
 690
 691
 692 DocStr(wxPyBitmapDataObject,
 693 "wx.PyBitmapDataObject is a version of `wx.BitmapDataObject` that is
 694 Python-aware and knows how to reflect calls to its C++ virtual methods
 695 to methods in the Python derived class. To be able to provide bitmap
 696 data on demand derive from this class and overload `GetBitmap`.", "");
 697
 698 class wxPyBitmapDataObject : public wxBitmapDataObject {
 699 public:
 700     %pythonAppend wxPyBitmapDataObject   "self._setCallbackInfo(self, PyBitmapDataObject)"
 701
 702     wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap);
 703     void _setCallbackInfo(PyObject* self, PyObject* _class);
 704 };
 705
 706 //---------------------------------------------------------------------------
 707
 708
 709 DocStr(wxFileDataObject,
 710 "wx.FileDataObject is a specialization of `wx.DataObjectSimple` for
 711 file names. The program works with it just as if it were a list of
 712 absolute file names, but internally it uses the same format as
 713 Explorer and other compatible programs under Windows or GNOME/KDE
 714 filemanager under Unix which makes it possible to receive files from
 715 them using this class.", "");
 716
 717 class wxFileDataObject : public wxDataObjectSimple
 718 {
 719 public:
 720     DocCtorStr(
 721         wxFileDataObject(),
 722         "", "");
 723
 724     DocDeclAStr(
 725         const wxArrayString& , GetFilenames(),
 726         "GetFilenames(self) -> [names]",
 727         "Returns a list of file names.", "");
 728
 729     DocDeclStr(
 730         void , AddFile(const wxString &filename),
 731         "Adds a file to the list of files represented by this data object.", "");
 732
 733 };
 734
 735 //---------------------------------------------------------------------------
 736
 737 DocStr(wxCustomDataObject,
 738 "wx.CustomDataObject is a specialization of `wx.DataObjectSimple` for
 739 some application-specific data in arbitrary format.  Python strings
 740 are used for getting and setting data, but any picklable object can
 741 easily be transfered via strings.  A copy of the data is stored in the
 742 data object.", "");
 743
 744 class wxCustomDataObject : public wxDataObjectSimple {
 745 public:
 746     %nokwargs wxCustomDataObject;
 747     wxCustomDataObject(const wxDataFormat& format);
 748     %extend {
 749         wxCustomDataObject(const wxString& formatName) {
 750             return new wxCustomDataObject(wxDataFormat(formatName));
 751         }
 752     }
 753     wxCustomDataObject();
 754
 755
 756     %extend {
 757         DocAStr(SetData,
 758                 "SetData(self, String data) -> bool",
 759                 "Copy the data value to the data object.", "");
 760         bool SetData(PyObject* data) {
 761             bool rval;
 762             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 763             if (PyString_Check(data)) {
 764                 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
 765             }
 766             else {
 767                 // raise a TypeError if not a string
 768                 PyErr_SetString(PyExc_TypeError, "String expected.");
 769                 rval = false;
 770             }
 771             wxPyEndBlockThreads(blocked);
 772             return rval;
 773         }
 774     }
 775     %pythoncode { TakeData = SetData }
 776
 777     DocDeclStr(
 778         size_t , GetSize(),
 779         "Get the size of the data.", "");
 780
 781
 782     %extend {
 783         DocAStr(GetData,
 784                 "GetData(self) -> String",
 785                 "Returns the data bytes from the data object as a string.", "");
 786         PyObject* GetData() {
 787             PyObject* obj;
 788             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 789             obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
 790             wxPyEndBlockThreads(blocked);
 791             return obj;
 792         }
 793     }
 794 };
 795
 796
 797 //---------------------------------------------------------------------------
 798
 799 DocStr(wxURLDataObject,
 800 "This data object holds a URL in a format that is compatible with some
 801 browsers such that it is able to be dragged to or from them.", "");
 802 class wxURLDataObject : public wxDataObject/*Composite*/ {
 803 public:
 804     wxURLDataObject();
 805
 806     DocDeclStr(
 807         wxString , GetURL(),
 808         "Returns a string containing the current URL.", "");
 809
 810     DocDeclStr(
 811         void , SetURL(const wxString& url),
 812         "Set the URL.", "");
 813
 814 };
 815
 816 //---------------------------------------------------------------------------
 817
 818 #if defined(__WXMSW__) || defined(__WXMAC__)
 819
 820 %{
 821 #include <wx/metafile.h>
 822 %}
 823
 824 class wxMetafileDataObject : public wxDataObjectSimple
 825 {
 826 public:
 827     wxMetafileDataObject();
 828
 829     void SetMetafile(const wxMetafile& metafile);
 830     wxMetafile GetMetafile() const;
 831 };
 832
 833
 834 #else
 835 %{
 836 class wxMetafileDataObject : public wxDataObjectSimple
 837 {
 838 public:
 839     wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
 840 };
 841 %}
 842
 843 class wxMetafileDataObject : public wxDataObjectSimple
 844 {
 845 public:
 846     wxMetafileDataObject();
 847 };
 848
 849 #endif
 850
 851 //---------------------------------------------------------------------------
 852 //---------------------------------------------------------------------------
 853