wxPython/src/gdi.i

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        gdi.i
   3 // Purpose:     SWIG interface file for wxDC, wxBrush, wxPen, wxFont, etc.
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     7/7/97
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 1998 by Total Control Software
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13
  14 %module gdi
  15
  16 %{
  17 #include "helpers.h"
  18 #include <wx/metafile.h>
  19 #include <wx/imaglist.h>
  20 #ifndef __WXMSW__
  21 #include <wx/dcps.h>
  22 #endif
  23 #include <wx/fontmap.h>
  24 #include <wx/fontenc.h>
  25 #include <wx/fontmap.h>
  26 #include <wx/fontutil.h>
  27 %}
  28
  29 //----------------------------------------------------------------------
  30
  31 %include typemaps.i
  32 %include my_typemaps.i
  33
  34 // Import some definitions of other classes, etc.
  35 %import _defs.i
  36 %import misc.i
  37
  38 %{
  39     static wxString wxPyEmptyStr("");
  40 %}
  41
  42 //---------------------------------------------------------------------------
  43
  44 class wxGDIObject : public wxObject {
  45 public:
  46     wxGDIObject();
  47     ~wxGDIObject();
  48
  49     bool GetVisible();
  50     void SetVisible( bool visible );
  51
  52     bool IsNull();
  53
  54 };
  55
  56 //---------------------------------------------------------------------------
  57
  58 class wxBitmap : public wxGDIObject
  59 {
  60 public:
  61     wxBitmap(const wxString& name, wxBitmapType type);
  62     ~wxBitmap();
  63
  64     wxPalette* GetPalette();
  65     wxMask* GetMask();
  66     bool LoadFile(const wxString& name, long flags);
  67     bool SaveFile(const wxString& name, int type, wxPalette* palette = NULL);
  68     void SetMask(wxMask* mask);
  69 #ifdef __WXMSW__
  70     void SetPalette(wxPalette& palette);
  71 #endif
  72
  73     // wxGDIImage methods
  74 #ifdef __WXMSW__
  75     long GetHandle();
  76     void SetHandle(long handle);
  77 #endif
  78     bool Ok();
  79     int GetWidth();
  80     int GetHeight();
  81     int GetDepth();
  82     void SetWidth(int w);
  83     void SetHeight(int h);
  84     void SetDepth(int d);
  85 #ifdef __WXMSW__
  86     void SetSize(const wxSize& size);
  87 #endif
  88
  89     wxBitmap GetSubBitmap( const wxRect& rect );
  90 #ifdef __WXMSW__
  91     bool CopyFromIcon(const wxIcon& icon);
  92     bool CopyFromCursor(const wxCursor& cursor);
  93     int GetQuality();
  94     void SetQuality(int q);
  95 #endif
  96
  97     %pragma(python) addtoclass = "
  98     def __del__(self,gdic=gdic):
  99         try:
 100             if self.thisown == 1 :
 101                 gdic.delete_wxBitmap(self)
 102         except:
 103             pass
 104 "
 105 };
 106
 107
 108 // Declarations of some alternate "constructors"
 109 %new wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1);
 110 %new wxBitmap* wxBitmapFromXPMData(PyObject* listOfStrings);
 111 %new wxBitmap* wxBitmapFromIcon(const wxIcon& icon);
 112 %new wxBitmap* wxBitmapFromBits(char* bits, int width, int height, int depth = 1 );
 113
 114 //  #ifdef __WXMSW__
 115 //  %new wxBitmap* wxBitmapFromData(PyObject* data, long type,
 116 //                                  int width, int height, int depth = 1);
 117 //  #endif
 118
 119
 120
 121 %{ // Implementations of some alternate "constructors"
 122
 123     wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1) {
 124         return new wxBitmap(width, height, depth);
 125     }
 126
 127     static char** ConvertListOfStrings(PyObject* listOfStrings) {
 128         char**    cArray = NULL;
 129         int       count;
 130
 131         if (!PyList_Check(listOfStrings)) {
 132             PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
 133             return NULL;
 134         }
 135         count = PyList_Size(listOfStrings);
 136         cArray = new char*[count];
 137
 138         for(int x=0; x<count; x++) {
 139             // TODO: Need some validation and error checking here
 140             cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
 141         }
 142         return cArray;
 143     }
 144
 145
 146     wxBitmap* wxBitmapFromXPMData(PyObject* listOfStrings) {
 147         char**    cArray = NULL;
 148         wxBitmap* bmp;
 149
 150         cArray = ConvertListOfStrings(listOfStrings);
 151         if (! cArray)
 152             return NULL;
 153         bmp = new wxBitmap(cArray);
 154         delete [] cArray;
 155         return bmp;
 156     }
 157
 158
 159     wxBitmap* wxBitmapFromIcon(const wxIcon& icon) {
 160         return new wxBitmap(icon);
 161     }
 162
 163
 164     wxBitmap* wxBitmapFromBits(char* bits, int width, int height, int depth = 1 ) {
 165         return new wxBitmap(bits, width, height, depth);
 166     }
 167
 168
 169 //  #ifdef __WXMSW__
 170 //      wxBitmap* wxBitmapFromData(PyObject* data, long type,
 171 //                                 int width, int height, int depth = 1) {
 172 //          if (! PyString_Check(data)) {
 173 //              PyErr_SetString(PyExc_TypeError, "Expected string object");
 174 //              return NULL;
 175 //          }
 176 //          return new wxBitmap((void*)PyString_AsString(data), type, width, height, depth);
 177 //      }
 178 //  #endif
 179 %}
 180
 181 //---------------------------------------------------------------------------
 182
 183 class wxMask : public wxObject {
 184 public:
 185     wxMask(const wxBitmap& bitmap);
 186     //~wxMask();
 187
 188     %addmethods { void Destroy() { delete self; } }
 189 };
 190
 191 %new wxMask* wxMaskColour(const wxBitmap& bitmap, const wxColour& colour);
 192 %{
 193     wxMask* wxMaskColour(const wxBitmap& bitmap, const wxColour& colour) {
 194         return new wxMask(bitmap, colour);
 195     }
 196 %}
 197
 198
 199 //---------------------------------------------------------------------------
 200
 201
 202 class wxIcon : public wxGDIObject
 203 {
 204 public:
 205     wxIcon(const wxString& name, long flags,
 206            int desiredWidth = -1, int desiredHeight = -1);
 207     ~wxIcon();
 208
 209     bool LoadFile(const wxString& name, long flags);
 210
 211     // wxGDIImage methods
 212 #ifdef __WXMSW__
 213     long GetHandle();
 214     void SetHandle(long handle);
 215 #endif
 216     bool Ok();
 217     int GetWidth();
 218     int GetHeight();
 219     int GetDepth();
 220     void SetWidth(int w);
 221     void SetHeight(int h);
 222     void SetDepth(int d);
 223 #ifdef __WXMSW__
 224     void SetSize(const wxSize& size);
 225 #endif
 226     void CopyFromBitmap(const wxBitmap& bmp);
 227
 228     %pragma(python) addtoclass = "
 229     def __del__(self,gdic=gdic):
 230         try:
 231             if self.thisown == 1 :
 232                 gdic.delete_wxIcon(self)
 233         except:
 234             pass
 235 "
 236 };
 237
 238
 239 // Declarations of some alternate "constructors"
 240 %new wxIcon* wxEmptyIcon();
 241 %new wxIcon* wxIconFromXPMData(PyObject* listOfStrings);
 242
 243 %{ // Implementations of some alternate "constructors"
 244     wxIcon* wxEmptyIcon() {
 245         return new wxIcon();
 246     }
 247
 248     wxIcon* wxIconFromXPMData(PyObject* listOfStrings) {
 249         char**  cArray = NULL;
 250         wxIcon* icon;
 251
 252         cArray = ConvertListOfStrings(listOfStrings);
 253         if (! cArray)
 254             return NULL;
 255         icon = new wxIcon(cArray);
 256         delete [] cArray;
 257         return icon;
 258     }
 259 %}
 260
 261 //---------------------------------------------------------------------------
 262
 263 class wxCursor : public wxGDIObject
 264 {
 265 public:
 266 #ifdef __WXMSW__
 267     wxCursor(const wxString& cursorName, long flags, int hotSpotX=0, int hotSpotY=0);
 268 #endif
 269     ~wxCursor();
 270
 271     // wxGDIImage methods
 272 #ifdef __WXMSW__
 273     long GetHandle();
 274     void SetHandle(long handle);
 275 #endif
 276     bool Ok();
 277 #ifdef __WXMSW__
 278     int GetWidth();
 279     int GetHeight();
 280     int GetDepth();
 281     void SetWidth(int w);
 282     void SetHeight(int h);
 283     void SetDepth(int d);
 284     void SetSize(const wxSize& size);
 285 #endif
 286 };
 287
 288 %name(wxStockCursor) %new wxCursor* wxPyStockCursor(int id);
 289 %{                              // Alternate 'constructor'
 290     wxCursor* wxPyStockCursor(int id) {
 291         return new wxCursor(id);
 292     }
 293 %}
 294
 295 //----------------------------------------------------------------------
 296
 297
 298 enum wxFontFamily
 299 {
 300     wxFONTFAMILY_DEFAULT = wxDEFAULT,
 301     wxFONTFAMILY_DECORATIVE = wxDECORATIVE,
 302     wxFONTFAMILY_ROMAN = wxROMAN,
 303     wxFONTFAMILY_SCRIPT = wxSCRIPT,
 304     wxFONTFAMILY_SWISS = wxSWISS,
 305     wxFONTFAMILY_MODERN = wxMODERN,
 306     wxFONTFAMILY_TELETYPE = wxTELETYPE,
 307     wxFONTFAMILY_MAX
 308 };
 309
 310 // font styles
 311 enum wxFontStyle
 312 {
 313     wxFONTSTYLE_NORMAL = wxNORMAL,
 314     wxFONTSTYLE_ITALIC = wxITALIC,
 315     wxFONTSTYLE_SLANT = wxSLANT,
 316     wxFONTSTYLE_MAX
 317 };
 318
 319 // font weights
 320 enum wxFontWeight
 321 {
 322     wxFONTWEIGHT_NORMAL = wxNORMAL,
 323     wxFONTWEIGHT_LIGHT = wxLIGHT,
 324     wxFONTWEIGHT_BOLD = wxBOLD,
 325     wxFONTWEIGHT_MAX
 326 };
 327
 328
 329 // font encodings
 330 enum wxFontEncoding
 331 {
 332     wxFONTENCODING_SYSTEM = -1,     // system default
 333     wxFONTENCODING_DEFAULT,         // current default encoding
 334
 335     // ISO8859 standard defines a number of single-byte charsets
 336     wxFONTENCODING_ISO8859_1,       // West European (Latin1)
 337     wxFONTENCODING_ISO8859_2,       // Central and East European (Latin2)
 338     wxFONTENCODING_ISO8859_3,       // Esperanto (Latin3)
 339     wxFONTENCODING_ISO8859_4,       // Baltic (old) (Latin4)
 340     wxFONTENCODING_ISO8859_5,       // Cyrillic
 341     wxFONTENCODING_ISO8859_6,       // Arabic
 342     wxFONTENCODING_ISO8859_7,       // Greek
 343     wxFONTENCODING_ISO8859_8,       // Hebrew
 344     wxFONTENCODING_ISO8859_9,       // Turkish (Latin5)
 345     wxFONTENCODING_ISO8859_10,      // Variation of Latin4 (Latin6)
 346     wxFONTENCODING_ISO8859_11,      // Thai
 347     wxFONTENCODING_ISO8859_12,      // doesn't exist currently, but put it
 348                                     // here anyhow to make all ISO8859
 349                                     // consecutive numbers
 350     wxFONTENCODING_ISO8859_13,      // Baltic (Latin7)
 351     wxFONTENCODING_ISO8859_14,      // Latin8
 352     wxFONTENCODING_ISO8859_15,      // Latin9 (a.k.a. Latin0, includes euro)
 353     wxFONTENCODING_ISO8859_MAX,
 354
 355     // Cyrillic charset soup (see http://czyborra.com/charsets/cyrillic.html)
 356     wxFONTENCODING_KOI8,            // we don't support any of KOI8 variants
 357     wxFONTENCODING_ALTERNATIVE,     // same as MS-DOS CP866
 358     wxFONTENCODING_BULGARIAN,       // used under Linux in Bulgaria
 359
 360     // what would we do without Microsoft? They have their own encodings
 361         // for DOS
 362     wxFONTENCODING_CP437,           // original MS-DOS codepage
 363     wxFONTENCODING_CP850,           // CP437 merged with Latin1
 364     wxFONTENCODING_CP852,           // CP437 merged with Latin2
 365     wxFONTENCODING_CP855,           // another cyrillic encoding
 366     wxFONTENCODING_CP866,           // and another one
 367         // and for Windows
 368     wxFONTENCODING_CP874,           // WinThai
 369     wxFONTENCODING_CP1250,          // WinLatin2
 370     wxFONTENCODING_CP1251,          // WinCyrillic
 371     wxFONTENCODING_CP1252,          // WinLatin1
 372     wxFONTENCODING_CP1253,          // WinGreek (8859-7)
 373     wxFONTENCODING_CP1254,          // WinTurkish
 374     wxFONTENCODING_CP1255,          // WinHebrew
 375     wxFONTENCODING_CP1256,          // WinArabic
 376     wxFONTENCODING_CP1257,          // WinBaltic (same as Latin 7)
 377     wxFONTENCODING_CP12_MAX,
 378
 379     wxFONTENCODING_UTF7,            // UTF-7 Unicode encoding
 380     wxFONTENCODING_UTF8,            // UTF-8 Unicode encoding
 381
 382     wxFONTENCODING_UNICODE,         // Unicode - currently used only by
 383                                     // wxEncodingConverter class
 384
 385     wxFONTENCODING_MAX
 386 };
 387
 388
 389
 390 // wxNativeFontInfo is platform-specific font representation: this struct
 391 // should be considered as opaque font description only used by the native
 392 // functions, the user code can only get the objects of this type from
 393 // somewhere and pass it somewhere else (possibly save them somewhere using
 394 // ToString() and restore them using FromString())
 395 struct wxNativeFontInfo
 396 {
 397     // it is important to be able to serialize wxNativeFontInfo objects to be
 398     // able to store them (in config file, for example)
 399     bool FromString(const wxString& s);
 400     wxString ToString() const;
 401
 402     %addmethods {
 403         wxString __str__() {
 404             return self->ToString();
 405         }
 406     }
 407 };
 408
 409
 410 // wxFontMapper manages user-definable correspondence between logical font
 411 // names and the fonts present on the machine.
 412 //
 413 // The default implementations of all functions will ask the user if they are
 414 // not capable of finding the answer themselves and store the answer in a
 415 // config file (configurable via SetConfigXXX functions). This behaviour may
 416 // be disabled by giving the value of FALSE to "interactive" parameter.
 417 // However, the functions will always consult the config file to allow the
 418 // user-defined values override the default logic and there is no way to
 419 // disable this - which shouldn't be ever needed because if "interactive" was
 420 // never TRUE, the config file is never created anyhow.
 421 class  wxFontMapper
 422 {
 423 public:
 424     wxFontMapper();
 425     ~wxFontMapper();
 426
 427
 428     // find an alternative for the given encoding (which is supposed to not be
 429     // available on this system). If successful, return TRUE and rwxFontEcoding
 430     // that can be used it wxFont ctor otherwise return FALSE
 431     //bool GetAltForEncoding(wxFontEncoding encoding,
 432     //                       wxFontEncoding *alt_encoding,
 433     //                       const wxString& facename = wxEmptyString,
 434     //                       bool interactive = TRUE);
 435
 436
 437     // Find an alternative for the given encoding (which is supposed to not be
 438     // available on this system). If successful, returns the encoding otherwise
 439     // returns None.
 440     %addmethods {
 441         PyObject* GetAltForEncoding(wxFontEncoding encoding,
 442                                     const wxString& facename = wxEmptyString,
 443                                     bool interactive = TRUE) {
 444             wxFontEncoding alt_enc;
 445             if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
 446                 return PyInt_FromLong(alt_enc);
 447             else {
 448                 Py_INCREF(Py_None);
 449                 return Py_None;
 450             }
 451         }
 452     }
 453
 454
 455     // checks whether given encoding is available in given face or not.
 456     // If no facename is given,
 457     bool IsEncodingAvailable(wxFontEncoding encoding,
 458                              const wxString& facename = wxEmptyString);
 459
 460     // returns the encoding for the given charset (in the form of RFC 2046) or
 461     // wxFONTENCODING_SYSTEM if couldn't decode it
 462     wxFontEncoding CharsetToEncoding(const wxString& charset,
 463                                      bool interactive = TRUE);
 464
 465     // return internal string identifier for the encoding (see also
 466     // GetEncodingDescription())
 467     static wxString GetEncodingName(wxFontEncoding encoding);
 468
 469     // return user-readable string describing the given encoding
 470     //
 471     // NB: hard-coded now, but might change later (read it from config?)
 472     static wxString GetEncodingDescription(wxFontEncoding encoding);
 473
 474     // the parent window for modal dialogs
 475     void SetDialogParent(wxWindow *parent);
 476
 477     // the title for the dialogs (note that default is quite reasonable)
 478     void SetDialogTitle(const wxString& title);
 479
 480     // functions which allow to configure the config object used: by default,
 481     // the global one (from wxConfigBase::Get() will be used) and the default
 482     // root path for the config settings is the string returned by
 483     // GetDefaultConfigPath()
 484
 485
 486     // set the config object to use (may be NULL to use default)
 487     void SetConfig(wxConfigBase *config);
 488
 489     // set the root config path to use (should be an absolute path)
 490     void SetConfigPath(const wxString& prefix);
 491
 492     // return default config path
 493     static const wxChar *GetDefaultConfigPath();
 494 };
 495
 496
 497
 498
 499 class wxFont : public wxGDIObject {
 500 public:
 501     wxFont( int pointSize, int family, int style, int weight,
 502             int underline=FALSE, char* faceName = "",
 503             wxFontEncoding encoding=wxFONTENCODING_DEFAULT);
 504
 505     %name(wxFontFromNativeInfo)wxFont(const wxNativeFontInfo& info);
 506
 507     ~wxFont();
 508
 509     bool Ok() const;
 510     int GetPointSize() const;
 511     int GetFamily() const;
 512     int GetStyle() const;
 513     int GetWeight() const;
 514     bool GetUnderlined() const;
 515     wxString GetFaceName() const;
 516     wxFontEncoding GetEncoding() const;
 517     wxNativeFontInfo* GetNativeFontInfo() const;
 518
 519     void SetPointSize(int pointSize);
 520     void SetFamily(int family);
 521     void SetStyle(int style);
 522     void SetWeight(int weight);
 523     void SetFaceName(const wxString& faceName);
 524     void SetUnderlined(bool underlined);
 525     void SetEncoding(wxFontEncoding encoding);
 526     void SetNativeFontInfo(const wxNativeFontInfo& info);
 527
 528     wxString GetFamilyString() const;
 529     wxString GetStyleString() const;
 530     wxString GetWeightString() const;
 531
 532     static wxFontEncoding GetDefaultEncoding();
 533     static void SetDefaultEncoding(wxFontEncoding encoding);
 534
 535 };
 536
 537
 538 class wxFontList : public wxObject {
 539 public:
 540
 541     void AddFont(wxFont* font);
 542     wxFont * FindOrCreateFont(int point_size, int family, int style, int weight,
 543                               bool underline = FALSE, const char* facename = NULL,
 544                               wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
 545     void RemoveFont(wxFont *font);
 546 };
 547
 548
 549 //----------------------------------------------------------------------
 550
 551 class wxColour : public wxObject {
 552 public:
 553     wxColour(unsigned char red=0, unsigned char green=0, unsigned char blue=0);
 554     ~wxColour();
 555     unsigned char Red();
 556     unsigned char Green();
 557     unsigned char Blue();
 558     bool Ok();
 559     void Set(unsigned char red, unsigned char green, unsigned char blue);
 560     %addmethods {
 561         PyObject* Get() {
 562             PyObject* rv = PyTuple_New(3);
 563             PyTuple_SetItem(rv, 0, PyInt_FromLong(self->Red()));
 564             PyTuple_SetItem(rv, 1, PyInt_FromLong(self->Green()));
 565             PyTuple_SetItem(rv, 2, PyInt_FromLong(self->Blue()));
 566             return rv;
 567         }
 568     }
 569     %pragma(python) addtoclass = "asTuple = Get"
 570     %pragma(python) addtoclass = "def __str__(self): return str(self.asTuple())"
 571     %pragma(python) addtoclass = "def __repr__(self): return str(self.asTuple())"
 572
 573 };
 574
 575 %new wxColour* wxNamedColour(const wxString& colorName);
 576
 577 %{                                      // Alternate 'constructor'
 578     wxColour* wxNamedColour(const wxString& colorName) {
 579         return new wxColour(colorName);
 580     }
 581 %}
 582
 583
 584
 585 class wxColourDatabase : public wxObject {
 586 public:
 587
 588     wxColour *FindColour(const wxString& colour);
 589     wxString FindName(const wxColour& colour) const;
 590
 591     %addmethods {
 592         void Append(const wxString& name, int red, int green, int blue) {
 593             self->Append(name.c_str(), new wxColour(red, green, blue));
 594         }
 595     }
 596 };
 597
 598
 599 //----------------------------------------------------------------------
 600
 601
 602 class wxPen : public wxGDIObject {
 603 public:
 604     wxPen(wxColour& colour, int width=1, int style=wxSOLID);
 605     ~wxPen();
 606
 607     int GetCap();
 608     wxColour GetColour();
 609
 610     int GetJoin();
 611     int GetStyle();
 612     int GetWidth();
 613     bool Ok();
 614     void SetCap(int cap_style);
 615     void SetColour(wxColour& colour);
 616     void SetJoin(int join_style);
 617     void SetStyle(int style);
 618     void SetWidth(int width);
 619
 620             // **** This one needs to return a list of ints (wxDash)
 621     int GetDashes(wxDash **dashes);
 622     void SetDashes(int LCOUNT, wxDash* choices);
 623
 624 #ifdef __WXMSW__
 625     wxBitmap* GetStipple();
 626     void SetStipple(wxBitmap& stipple);
 627 #endif
 628 };
 629
 630
 631 class wxPenList : public wxObject {
 632 public:
 633
 634     void AddPen(wxPen* pen);
 635     wxPen* FindOrCreatePen(const wxColour& colour, int width, int style);
 636     void RemovePen(wxPen* pen);
 637 };
 638
 639
 640
 641 //----------------------------------------------------------------------
 642
 643 class wxBrush : public wxGDIObject {
 644 public:
 645     wxBrush(const wxColour& colour, int style=wxSOLID);
 646     ~wxBrush();
 647
 648     wxColour GetColour();
 649     wxBitmap * GetStipple();
 650     int GetStyle();
 651     bool Ok();
 652     void SetColour(wxColour &colour);
 653     void SetStipple(wxBitmap& bitmap);
 654     void SetStyle(int style);
 655 };
 656
 657
 658 class wxBrushList {
 659 public:
 660
 661     void AddBrush(wxBrush *brush);
 662     wxBrush * FindOrCreateBrush(const wxColour& colour, int style);
 663     void RemoveBrush(wxBrush *brush);
 664 };
 665
 666 //----------------------------------------------------------------------
 667
 668
 669
 670 class wxDC : public wxObject {
 671 public:
 672 //    wxDC(); **** abstract base class, can't instantiate.
 673     ~wxDC();
 674
 675     void BeginDrawing();
 676 //  %name(BlitXY)
 677     bool Blit(long xdest, long ydest,
 678               long width, long height,
 679               wxDC *source, long xsrc, long ysrc,
 680               int logicalFunc = wxCOPY, int useMask = FALSE);
 681 //      bool Blit(const wxPoint& destPt, const wxSize& sz,
 682 //                wxDC *source, const wxPoint& srcPt,
 683 //                int logicalFunc = wxCOPY, int useMask = FALSE);
 684
 685     void Clear();
 686     void CrossHair(long x, long y);
 687     void DestroyClippingRegion();
 688     long DeviceToLogicalX(long x);
 689     long DeviceToLogicalXRel(long x);
 690     long DeviceToLogicalY(long y);
 691     long DeviceToLogicalYRel(long y);
 692     void DrawArc(long x1, long y1, long x2, long y2, long xc, long yc);
 693     void DrawCircle(long x, long y, long radius);
 694     void DrawEllipse(long x, long y, long width, long height);
 695     void DrawEllipticArc(long x, long y, long width, long height, long start, long end);
 696     void DrawIcon(const wxIcon& icon, long x, long y);
 697     void DrawLine(long x1, long y1, long x2, long y2);
 698     void DrawLines(int PCOUNT, wxPoint* points, long xoffset=0, long yoffset=0);
 699     void DrawPolygon(int PCOUNT, wxPoint* points, long xoffset=0, long yoffset=0,
 700                      int fill_style=wxODDEVEN_RULE);
 701     void DrawPoint(long x, long y);
 702     void DrawRectangle(long x, long y, long width, long height);
 703     void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle);
 704     void DrawRoundedRectangle(long x, long y, long width, long height, long radius=20);
 705     void DrawSpline(int PCOUNT, wxPoint* points);
 706     void DrawText(const wxString& text, long x, long y);
 707     void EndDoc();
 708     void EndDrawing();
 709     void EndPage();
 710     void FloodFill(long x, long y, const wxColour& colour, int style=wxFLOOD_SURFACE);
 711     wxBrush&  GetBackground();
 712     wxBrush&  GetBrush();
 713     long GetCharHeight();
 714     long GetCharWidth();
 715     void GetClippingBox(long *OUTPUT, long *OUTPUT,
 716                         long *OUTPUT, long *OUTPUT);
 717     wxFont& GetFont();
 718     int GetLogicalFunction();
 719     void GetLogicalScale(double *OUTPUT, double *OUTPUT);
 720     int GetMapMode();
 721     bool GetOptimization();
 722     wxPen& GetPen();
 723     %addmethods {
 724         %new wxColour* GetPixel(long x, long y) {
 725             wxColour* wc = new wxColour();
 726             self->GetPixel(x, y, wc);
 727             return wc;
 728         }
 729     }
 730     %name(GetSizeTuple)void GetSize(int* OUTPUT, int* OUTPUT);
 731     wxSize GetSize();
 732     wxSize GetSizeMM();
 733     wxColour GetTextBackground();
 734     void GetTextExtent(const wxString& string, long *OUTPUT, long *OUTPUT);
 735     %name(GetFullTextExtent)void GetTextExtent(const wxString& string,
 736                        long *OUTPUT, long *OUTPUT, long *OUTPUT, long* OUTPUT,
 737                        const wxFont* font = NULL);
 738     wxColour GetTextForeground();
 739     void GetUserScale(double *OUTPUT, double *OUTPUT);
 740     long LogicalToDeviceX(long x);
 741     long LogicalToDeviceXRel(long x);
 742     long LogicalToDeviceY(long y);
 743     long LogicalToDeviceYRel(long y);
 744     long MaxX();
 745     long MaxY();
 746     long MinX();
 747     long MinY();
 748     bool Ok();
 749     void SetDeviceOrigin(long x, long y);
 750     void SetBackground(const wxBrush& brush);
 751     void SetBackgroundMode(int mode);
 752     void SetClippingRegion(long x, long y, long width, long height);
 753     %name(SetClippingRegionAsRegion) void SetClippingRegion(const wxRegion& region);
 754     void SetPalette(const wxPalette& colourMap);
 755     void SetBrush(const wxBrush& brush);
 756     void SetFont(const wxFont& font);
 757     void SetLogicalFunction(int function);
 758     void SetLogicalScale(double x, double y);
 759     void SetMapMode(int mode);
 760     void SetOptimization(bool optimize);
 761     void SetPen(const wxPen& pen);
 762     void SetTextBackground(const wxColour& colour);
 763     void SetTextForeground(const wxColour& colour);
 764     void SetUserScale(double x_scale, double y_scale);
 765     bool StartDoc(const wxString& message);
 766     void StartPage();
 767
 768
 769
 770     void DrawBitmap(const wxBitmap& bitmap, long x, long y,
 771                     int useMask = FALSE);
 772
 773     bool CanDrawBitmap();
 774     bool CanGetTextExtent();
 775     int  GetDepth();
 776     wxSize GetPPI();
 777
 778     void GetLogicalOrigin(int *OUTPUT, int *OUTPUT);
 779     void SetLogicalOrigin(int x, int y);
 780     void GetDeviceOrigin(int *OUTPUT, int *OUTPUT);
 781     void SetAxisOrientation(bool xLeftRight, bool yBottomUp);
 782
 783     void CalcBoundingBox(int x, int y);
 784     void ResetBoundingBox();
 785
 786 #ifdef __WXMSW__
 787     long GetHDC();
 788 #endif
 789 };
 790
 791
 792 //----------------------------------------------------------------------
 793
 794 class wxMemoryDC : public wxDC {
 795 public:
 796     wxMemoryDC();
 797
 798     void SelectObject(const wxBitmap& bitmap);
 799 }
 800
 801 %new wxMemoryDC* wxMemoryDCFromDC(wxDC* oldDC);
 802 %{                                      // Alternate 'constructor'
 803     wxMemoryDC* wxMemoryDCFromDC(wxDC* oldDC) {
 804         return new wxMemoryDC(oldDC);
 805     }
 806 %}
 807
 808
 809 //---------------------------------------------------------------------------
 810
 811 class wxScreenDC : public wxDC {
 812 public:
 813     wxScreenDC();
 814
 815     %name(StartDrawingOnTopWin) bool StartDrawingOnTop(wxWindow* window);
 816     bool StartDrawingOnTop(wxRect* rect = NULL);
 817     bool EndDrawingOnTop();
 818 };
 819
 820 //---------------------------------------------------------------------------
 821
 822 class wxClientDC : public wxDC {
 823 public:
 824       wxClientDC(wxWindow* win);
 825 };
 826
 827 //---------------------------------------------------------------------------
 828
 829 class wxPaintDC : public wxDC {
 830 public:
 831       wxPaintDC(wxWindow* win);
 832 };
 833
 834 //---------------------------------------------------------------------------
 835
 836 class wxWindowDC : public wxDC {
 837 public:
 838       wxWindowDC(wxWindow* win);
 839 };
 840
 841 //---------------------------------------------------------------------------
 842
 843 #ifndef __WXMSW__
 844 class wxPostScriptDC : public wxDC {
 845 public:
 846       wxPostScriptDC(const wxString& output, bool interactive = TRUE, wxWindow* win = NULL);
 847 };
 848 #endif
 849
 850 //---------------------------------------------------------------------------
 851
 852
 853 #ifdef __WXMSW__
 854 class wxMetaFileDC : public wxDC {
 855 public:
 856     wxMetaFileDC(const wxString& filename = wxPyEmptyStr);
 857     wxMetaFile* Close();
 858 };
 859 #endif
 860
 861 //---------------------------------------------------------------------------
 862 //---------------------------------------------------------------------------
 863
 864
 865 %readonly
 866 %{
 867 #if 0
 868 %}
 869 extern wxFont *wxNORMAL_FONT;
 870 extern wxFont *wxSMALL_FONT;
 871 extern wxFont *wxITALIC_FONT;
 872 extern wxFont *wxSWISS_FONT;
 873
 874 extern wxPen *wxRED_PEN;
 875 extern wxPen *wxCYAN_PEN;
 876 extern wxPen *wxGREEN_PEN;
 877 extern wxPen *wxBLACK_PEN;
 878 extern wxPen *wxWHITE_PEN;
 879 extern wxPen *wxTRANSPARENT_PEN;
 880 extern wxPen *wxBLACK_DASHED_PEN;
 881 extern wxPen *wxGREY_PEN;
 882 extern wxPen *wxMEDIUM_GREY_PEN;
 883 extern wxPen *wxLIGHT_GREY_PEN;
 884
 885 extern wxBrush *wxBLUE_BRUSH;
 886 extern wxBrush *wxGREEN_BRUSH;
 887 extern wxBrush *wxWHITE_BRUSH;
 888 extern wxBrush *wxBLACK_BRUSH;
 889 extern wxBrush *wxTRANSPARENT_BRUSH;
 890 extern wxBrush *wxCYAN_BRUSH;
 891 extern wxBrush *wxRED_BRUSH;
 892 extern wxBrush *wxGREY_BRUSH;
 893 extern wxBrush *wxMEDIUM_GREY_BRUSH;
 894 extern wxBrush *wxLIGHT_GREY_BRUSH;
 895
 896 extern wxColour *wxBLACK;
 897 extern wxColour *wxWHITE;
 898 extern wxColour *wxRED;
 899 extern wxColour *wxBLUE;
 900 extern wxColour *wxGREEN;
 901 extern wxColour *wxCYAN;
 902 extern wxColour *wxLIGHT_GREY;
 903
 904 extern wxCursor *wxSTANDARD_CURSOR;
 905 extern wxCursor *wxHOURGLASS_CURSOR;
 906 extern wxCursor *wxCROSS_CURSOR;
 907
 908 extern wxBitmap wxNullBitmap;
 909 extern wxIcon   wxNullIcon;
 910 extern wxCursor wxNullCursor;
 911 extern wxPen    wxNullPen;
 912 extern wxBrush  wxNullBrush;
 913 extern wxPalette wxNullPalette;
 914 extern wxFont   wxNullFont;
 915 extern wxColour wxNullColour;
 916
 917
 918 extern wxFontList*       wxTheFontList;
 919 extern wxPenList*        wxThePenList;
 920 extern wxBrushlist*      wxTheBrushList;
 921 extern wxColourDatabase* wxTheColourDatabase;
 922
 923
 924 %readwrite
 925 %{
 926 #endif
 927 %}
 928
 929 //---------------------------------------------------------------------------
 930
 931 class wxPalette : public wxGDIObject {
 932 public:
 933     wxPalette(int LCOUNT, byte* choices, byte* choices, byte* choices);
 934     ~wxPalette();
 935
 936     int GetPixel(byte red, byte green, byte blue);
 937     bool GetRGB(int pixel, byte* OUTPUT, byte* OUTPUT, byte* OUTPUT);
 938     bool Ok();
 939 };
 940
 941 //---------------------------------------------------------------------------
 942
 943 enum {
 944     wxIMAGELIST_DRAW_NORMAL ,
 945     wxIMAGELIST_DRAW_TRANSPARENT,
 946     wxIMAGELIST_DRAW_SELECTED,
 947     wxIMAGELIST_DRAW_FOCUSED,
 948     wxIMAGE_LIST_NORMAL,
 949     wxIMAGE_LIST_SMALL,
 950     wxIMAGE_LIST_STATE
 951 };
 952
 953 class wxImageList : public wxObject {
 954 public:
 955     wxImageList(int width, int height, int mask=TRUE, int initialCount=1);
 956     ~wxImageList();
 957
 958     int Add(const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap);
 959     %name(AddWithColourMask)int Add(const wxBitmap& bitmap, const wxColour& maskColour);
 960     %name(AddIcon)int Add(const wxIcon& icon);
 961 #ifdef __WXMSW__
 962     bool Replace(int index, const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap);
 963 #else
 964 //      %name(ReplaceIcon)bool Replace(int index, const wxIcon& icon);
 965 //      int Add(const wxBitmap& bitmap);
 966     bool Replace(int index, const wxBitmap& bitmap);
 967 #endif
 968
 969     bool Draw(int index, wxDC& dc, int x, int x, int flags = wxIMAGELIST_DRAW_NORMAL,
 970               const bool solidBackground = FALSE);
 971
 972     int GetImageCount();
 973     bool Remove(int index);
 974     bool RemoveAll();
 975     void GetSize(int index, int& OUTPUT, int& OUTPUT);
 976 };
 977
 978
 979 //---------------------------------------------------------------------------
 980 // Regions, etc.
 981
 982 enum wxRegionContain {
 983         wxOutRegion, wxPartRegion, wxInRegion
 984 };
 985
 986
 987 class wxRegion : public wxGDIObject {
 988 public:
 989     wxRegion(long x=0, long y=0, long width=0, long height=0);
 990     ~wxRegion();
 991
 992     void Clear();
 993     wxRegionContain Contains(long x, long y);
 994     %name(ContainsPoint)wxRegionContain Contains(const wxPoint& pt);
 995     %name(ContainsRect)wxRegionContain Contains(const wxRect& rect);
 996     %name(ContainsRectDim)wxRegionContain Contains(long x, long y, long w, long h);
 997
 998     wxRect GetBox();
 999
1000     bool Intersect(long x, long y, long width, long height);
1001     %name(IntersectRect)bool Intersect(const wxRect& rect);
1002     %name(IntersectRegion)bool Intersect(const wxRegion& region);
1003
1004     bool IsEmpty();
1005
1006     bool Union(long x, long y, long width, long height);
1007     %name(UnionRect)bool Union(const wxRect& rect);
1008     %name(UnionRegion)bool Union(const wxRegion& region);
1009
1010     bool Subtract(long x, long y, long width, long height);
1011     %name(SubtractRect)bool Subtract(const wxRect& rect);
1012     %name(SubtractRegion)bool Subtract(const wxRegion& region);
1013
1014     bool Xor(long x, long y, long width, long height);
1015     %name(XorRect)bool Xor(const wxRect& rect);
1016     %name(XorRegion)bool Xor(const wxRegion& region);
1017 };
1018
1019
1020
1021 class wxRegionIterator : public wxObject {
1022 public:
1023     wxRegionIterator(const wxRegion& region);
1024     ~wxRegionIterator();
1025
1026     long GetX();
1027     long GetY();
1028     long GetW();
1029     long GetWidth();
1030     long GetH();
1031     long GetHeight();
1032     wxRect GetRect();
1033     bool HaveRects();
1034     void Reset();
1035
1036     %addmethods {
1037         void Next() {
1038             (*self) ++;
1039         }
1040     };
1041 };
1042
1043
1044 //---------------------------------------------------------------------------
1045