wxPython/src/_gdicmn.i

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        _gdicmn.i
   3 // Purpose:     SWIG interface for common GDI stuff and misc classes
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     13-Sept-2003
   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 %newgroup
  18
  19
  20 enum wxBitmapType
  21 {
  22     wxBITMAP_TYPE_INVALID,          // should be == 0 for compatibility!
  23     wxBITMAP_TYPE_BMP,
  24     wxBITMAP_TYPE_BMP_RESOURCE,
  25     wxBITMAP_TYPE_RESOURCE = wxBITMAP_TYPE_BMP_RESOURCE,
  26     wxBITMAP_TYPE_ICO,
  27     wxBITMAP_TYPE_ICO_RESOURCE,
  28     wxBITMAP_TYPE_CUR,
  29     wxBITMAP_TYPE_CUR_RESOURCE,
  30     wxBITMAP_TYPE_XBM,
  31     wxBITMAP_TYPE_XBM_DATA,
  32     wxBITMAP_TYPE_XPM,
  33     wxBITMAP_TYPE_XPM_DATA,
  34     wxBITMAP_TYPE_TIF,
  35     wxBITMAP_TYPE_TIF_RESOURCE,
  36     wxBITMAP_TYPE_GIF,
  37     wxBITMAP_TYPE_GIF_RESOURCE,
  38     wxBITMAP_TYPE_PNG,
  39     wxBITMAP_TYPE_PNG_RESOURCE,
  40     wxBITMAP_TYPE_JPEG,
  41     wxBITMAP_TYPE_JPEG_RESOURCE,
  42     wxBITMAP_TYPE_PNM,
  43     wxBITMAP_TYPE_PNM_RESOURCE,
  44     wxBITMAP_TYPE_PCX,
  45     wxBITMAP_TYPE_PCX_RESOURCE,
  46     wxBITMAP_TYPE_PICT,
  47     wxBITMAP_TYPE_PICT_RESOURCE,
  48     wxBITMAP_TYPE_ICON,
  49     wxBITMAP_TYPE_ICON_RESOURCE,
  50     wxBITMAP_TYPE_ANI,
  51     wxBITMAP_TYPE_IFF,
  52     wxBITMAP_TYPE_MACCURSOR,
  53     wxBITMAP_TYPE_MACCURSOR_RESOURCE,
  54     wxBITMAP_TYPE_ANY = 50
  55 };
  56
  57 // Standard cursors
  58 enum wxStockCursor
  59 {
  60     wxCURSOR_NONE,          // should be 0
  61     wxCURSOR_ARROW,
  62     wxCURSOR_RIGHT_ARROW,
  63     wxCURSOR_BULLSEYE,
  64     wxCURSOR_CHAR,
  65     wxCURSOR_CROSS,
  66     wxCURSOR_HAND,
  67     wxCURSOR_IBEAM,
  68     wxCURSOR_LEFT_BUTTON,
  69     wxCURSOR_MAGNIFIER,
  70     wxCURSOR_MIDDLE_BUTTON,
  71     wxCURSOR_NO_ENTRY,
  72     wxCURSOR_PAINT_BRUSH,
  73     wxCURSOR_PENCIL,
  74     wxCURSOR_POINT_LEFT,
  75     wxCURSOR_POINT_RIGHT,
  76     wxCURSOR_QUESTION_ARROW,
  77     wxCURSOR_RIGHT_BUTTON,
  78     wxCURSOR_SIZENESW,
  79     wxCURSOR_SIZENS,
  80     wxCURSOR_SIZENWSE,
  81     wxCURSOR_SIZEWE,
  82     wxCURSOR_SIZING,
  83     wxCURSOR_SPRAYCAN,
  84     wxCURSOR_WAIT,
  85     wxCURSOR_WATCH,
  86     wxCURSOR_BLANK,
  87     wxCURSOR_DEFAULT, // standard X11 cursor
  88     wxCURSOR_COPY_ARROW , // MacOS Theme Plus arrow
  89
  90 // #ifdef __X__
  91 //     // Not yet implemented for Windows
  92 //     wxCURSOR_CROSS_REVERSE,
  93 //     wxCURSOR_DOUBLE_ARROW,
  94 //     wxCURSOR_BASED_ARROW_UP,
  95 //     wxCURSOR_BASED_ARROW_DOWN,
  96 // #endif // X11
  97
  98     wxCURSOR_ARROWWAIT,
  99
 100     wxCURSOR_MAX
 101 };
 102
 103 %{
 104 #ifndef __WXMAC__
 105 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
 106 #endif
 107 %}
 108
 109 //---------------------------------------------------------------------------
 110 %newgroup
 111
 112 DocStr( wxSize,
 113 "wx.Size is a useful data structure used to represent the size of something.
 114 It simply contians integer width and height proprtites.  In most places in
 115 wxPython where a wx.Size is expected a (width,height) tuple can be used
 116 instead.");
 117
 118 class wxSize
 119 {
 120 public:
 121     %name(width) int x;
 122     %name(height)int y;
 123     %pythoncode { x = width; y = height }
 124
 125     DocCtorStr(
 126         wxSize(int w=0, int h=0),
 127         "Creates a size object.");
 128
 129     ~wxSize();
 130
 131     DocDeclStr(
 132         bool, operator==(const wxSize& sz),
 133         "Test for equality of wx.Size objects.");
 134
 135     DocDeclStr(
 136         bool, operator!=(const wxSize& sz),
 137         "Test for inequality.");
 138
 139     DocDeclStr(
 140         wxSize, operator+(const wxSize& sz),
 141         "Add sz's proprties to this and return the result.");
 142
 143     DocDeclStr(
 144         wxSize, operator-(const wxSize& sz),
 145         "Subtract sz's properties from this and return the result.");
 146
 147     DocDeclStr(
 148         void, IncTo(const wxSize& sz),
 149         "Increments this object so that both of its dimensions are not less\n"
 150         "than the corresponding dimensions of the size.");
 151
 152     DocDeclStr(
 153         void, DecTo(const wxSize& sz),
 154         "Decrements this object so that both of its dimensions are not greater\n"
 155         "than the corresponding dimensions of the size.");
 156
 157     DocDeclStr(
 158         void, Set(int w, int h),
 159         "Set both width and height.");
 160
 161     void SetWidth(int w);
 162     void SetHeight(int h);
 163     int GetWidth() const;
 164     int GetHeight() const;
 165
 166     //int GetX() const;
 167     //int GetY() const;
 168
 169     %extend {
 170         DocAStr(Get,
 171                "Get() -> (width,height)",
 172                "Returns the width and height properties as a tuple.");
 173         PyObject* Get() {
 174             wxPyBeginBlockThreads();
 175             PyObject* tup = PyTuple_New(2);
 176             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
 177             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
 178             wxPyEndBlockThreads();
 179             return tup;
 180         }
 181     }
 182     %pythoncode {
 183     asTuple = Get
 184     def __str__(self):                   return str(self.Get())
 185     def __repr__(self):                  return 'wx.Size'+str(self.Get())
 186     def __len__(self):                   return len(self.Get())
 187     def __getitem__(self, index):        return self.Get()[index]
 188     def __setitem__(self, index, val):
 189         if index == 0: self.width = val
 190         elif index == 1: self.height = val
 191         else: raise IndexError
 192     def __nonzero__(self):               return self.Get() != (0,0)
 193     def __getinitargs__(self):           return ()
 194     def __getstate__(self):              return self.Get()
 195     def __setstate__(self, state):       self.Set(*state)
 196     }
 197
 198 };
 199
 200 //---------------------------------------------------------------------------
 201 %newgroup
 202
 203 DocStr( wxRealPoint,
 204 "A data structure for representing a point or position with floating point x
 205 and y properties.  In wxPython most places that expect a wx.RealPoint can also
 206 accept a (x,y) tuple.");
 207 class wxRealPoint
 208 {
 209 public:
 210     double x;
 211     double y;
 212
 213     DocCtorStr(
 214         wxRealPoint(double x=0.0, double y=0.0),
 215         "Create a wx.RealPoint object");
 216
 217     ~wxRealPoint();
 218
 219     DocDeclStr(
 220         bool, operator==(const wxRealPoint& pt),
 221         "Test for equality of wx.RealPoint objects.");
 222
 223     DocDeclStr(
 224         bool, operator!=(const wxRealPoint& pt),
 225         "Test for inequality of wx.RealPoint objects.");
 226
 227
 228     DocDeclStr(
 229         wxRealPoint, operator+(const wxRealPoint& pt),
 230         "Add pt's proprties to this and return the result.");
 231
 232     DocDeclStr(
 233         wxRealPoint, operator-(const wxRealPoint& pt),
 234         "Subtract pt's proprties from this and return the result");
 235
 236
 237     %extend {
 238         DocStr(Set, "Set both the x and y properties");
 239         void Set(double x, double y) {
 240             self->x = x;
 241             self->y = y;
 242         }
 243
 244         DocAStr(Get,
 245                "Get() -> (x,y)",
 246                "Return the x and y properties as a tuple. ");
 247         PyObject* Get() {
 248             wxPyBeginBlockThreads();
 249             PyObject* tup = PyTuple_New(2);
 250             PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
 251             PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
 252             wxPyEndBlockThreads();
 253             return tup;
 254         }
 255     }
 256
 257     %pythoncode {
 258     asTuple = Get
 259     def __str__(self):                   return str(self.Get())
 260     def __repr__(self):                  return 'wx.RealPoint'+str(self.Get())
 261     def __len__(self):                   return len(self.Get())
 262     def __getitem__(self, index):        return self.Get()[index]
 263     def __setitem__(self, index, val):
 264         if index == 0: self.x = val
 265         elif index == 1: self.y = val
 266         else: raise IndexError
 267     def __nonzero__(self):               return self.Get() != (0.0, 0.0)
 268     def __getinitargs__(self):           return ()
 269     def __getstate__(self):              return self.Get()
 270     def __setstate__(self, state):       self.Set(*state)
 271     }
 272 };
 273
 274
 275 //---------------------------------------------------------------------------
 276 %newgroup
 277
 278
 279 DocStr(wxPoint,
 280 "A data structure for representing a point or position with integer x and y
 281 properties.  Most places in wxPython that expect a wx.Point can also accept a
 282 (x,y) tuple.");
 283
 284 class wxPoint
 285 {
 286 public:
 287     int x, y;
 288
 289     DocCtorStr(
 290         wxPoint(int x=0, int y=0),
 291         "Create a wx.Point object");
 292
 293     ~wxPoint();
 294
 295
 296     DocDeclStr(
 297         bool, operator==(const wxPoint& pt),
 298         "Test for equality of wx.Point objects.");
 299
 300     DocDeclStr(
 301         bool, operator!=(const wxPoint& pt),
 302         "Test for inequality of wx.Point objects.");
 303
 304
 305     DocDeclStr(
 306         wxPoint, operator+(const wxPoint& pt),
 307         "Add pt's proprties to this and return the result.");
 308
 309     DocDeclStr(
 310         wxPoint, operator-(const wxPoint& pt),
 311         "Subtract pt's proprties from this and return the result");
 312
 313
 314     DocDeclStr(
 315         wxPoint&, operator+=(const wxPoint& pt),
 316         "Add pt to this object.");
 317
 318     DocDeclStr(
 319         wxPoint&, operator-=(const wxPoint& pt),
 320         "Subtract pt from this object.");
 321
 322
 323     %extend {
 324         DocStr(Set, "Set both the x and y properties");
 325         void Set(long x, long y) {
 326             self->x = x;
 327             self->y = y;
 328         }
 329
 330         DocAStr(Get,
 331                "Get() -> (x,y)",
 332                "Return the x and y properties as a tuple. ");
 333         PyObject* Get() {
 334             wxPyBeginBlockThreads();
 335             PyObject* tup = PyTuple_New(2);
 336             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
 337             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
 338             wxPyEndBlockThreads();
 339             return tup;
 340         }
 341     }
 342
 343     %pythoncode {
 344     asTuple = Get
 345     def __str__(self):                   return str(self.Get())
 346     def __repr__(self):                  return 'wx.Point'+str(self.Get())
 347     def __len__(self):                   return len(self.Get())
 348     def __getitem__(self, index):        return self.Get()[index]
 349     def __setitem__(self, index, val):
 350         if index == 0: self.x = val
 351         elif index == 1: self.y = val
 352         else: raise IndexError
 353     def __nonzero__(self):               return self.Get() != (0,0)
 354     def __getinitargs__(self):           return ()
 355     def __getstate__(self):              return self.Get()
 356     def __setstate__(self, state):       self.Set(*state)
 357     }
 358 };
 359
 360 //---------------------------------------------------------------------------
 361 %newgroup
 362
 363
 364 DocStr(wxRect,
 365 "A class for representing and manipulating rectangles.  It has x, y, width and
 366 height properties.  In wxPython most palces that expect a wx.Rect can also
 367 accept a (x,y,width,height) tuple.");
 368
 369 class wxRect
 370 {
 371 public:
 372     DocCtorStr(
 373         wxRect(int x=0, int y=0, int width=0, int height=0),
 374         "Create a new Rect object.");
 375
 376     DocCtorStrName(
 377         wxRect(const wxPoint& topLeft, const wxPoint& bottomRight),
 378         "Create a new Rect object from Points representing two corners.",
 379         RectPP);
 380
 381     DocCtorStrName(
 382         wxRect(const wxPoint& pos, const wxSize& size),
 383         "Create a new Rect from a position and size.",
 384          RectPS);
 385
 386     ~wxRect();
 387
 388     int GetX() const;
 389     void SetX(int x);
 390
 391     int GetY();
 392     void SetY(int y);
 393
 394     int GetWidth() const;
 395     void SetWidth(int w);
 396
 397     int GetHeight() const;
 398     void SetHeight(int h);
 399
 400     wxPoint GetPosition() const;
 401     void SetPosition( const wxPoint &p );
 402
 403     wxSize GetSize() const;
 404     void SetSize( const wxSize &s );
 405
 406     wxPoint GetTopLeft() const;
 407     void SetTopLeft(const wxPoint &p);
 408     wxPoint GetBottomRight() const;
 409     void SetBottomRight(const wxPoint &p);
 410
 411 //    wxPoint GetLeftTop() const;
 412 //    void SetLeftTop(const wxPoint &p);
 413 //    wxPoint GetRightBottom() const;
 414 //    void SetRightBottom(const wxPoint &p);
 415
 416     int GetLeft()   const;
 417     int GetTop()    const;
 418     int GetBottom() const;
 419     int GetRight()  const;
 420
 421     void SetLeft(int left);
 422     void SetRight(int right);
 423     void SetTop(int top);
 424     void SetBottom(int bottom);
 425
 426     %pythoncode {
 427         position = property(GetPosition, SetPosition)
 428         size = property(GetSize, SetSize)
 429         left = property(GetLeft, SetLeft)
 430         right = property(GetRight, SetRight)
 431         top = property(GetTop, SetTop)
 432         bottom = property(GetBottom, SetBottom)
 433     }
 434
 435     DocDeclStr(
 436         wxRect&, Inflate(wxCoord dx, wxCoord dy),
 437         "Increase the rectangle size by dx in x direction and dy in y direction. Both\n"
 438         "(or one of) parameters may be negative to decrease the rectangle size.");
 439
 440     DocDeclStr(
 441         wxRect&, Deflate(wxCoord dx, wxCoord dy),
 442         "Decrease the rectangle size by dx in x direction and dy in y direction. Both\n"
 443         "(or one of) parameters may be negative to increase the rectngle size. This\n"
 444         "method is the opposite of Inflate.");
 445
 446     DocDeclStrName(
 447         void, Offset(wxCoord dx, wxCoord dy),
 448         "Moves the rectangle by the specified offset. If dx is positive, the rectangle\n"
 449         "is moved to the right, if dy is positive, it is moved to the bottom, otherwise\n"
 450         "it is moved to the left or top respectively.",
 451         OffsetXY);
 452
 453     DocDeclStr(
 454         void, Offset(const wxPoint& pt),
 455         "Same as OffsetXY but uses dx,dy from Point");
 456
 457     DocDeclStr(
 458         wxRect&, Intersect(const wxRect& rect),
 459         "Return the intersectsion of this rectangle and rect.");
 460
 461     DocDeclStr(
 462         wxRect, operator+(const wxRect& rect) const,
 463         "Add the properties of rect to this rectangle and return the result.");
 464
 465     DocDeclStr(
 466         wxRect&, operator+=(const wxRect& rect),
 467         "Add the properties of rect to this rectangle, updating this rectangle.");
 468
 469     DocDeclStr(
 470         bool, operator==(const wxRect& rect) const,
 471         "Test for equality.");
 472
 473     DocDeclStr(
 474         bool, operator!=(const wxRect& rect) const,
 475         "Test for inequality.");
 476
 477
 478     DocStr( Inside, "Return True if the point is (not strcitly) inside the rect.");
 479     %name(InsideXY)bool Inside(int x, int y) const;
 480     bool Inside(const wxPoint& pt) const;
 481
 482     DocDeclStr(
 483         bool, Intersects(const wxRect& rect) const,
 484         "Returns True if the rectangles have a non empty intersection.");
 485
 486
 487     int x, y, width, height;
 488
 489
 490     %extend {
 491        DocStr(Set, "Set all rectangle properties.");
 492         void Set(int x=0, int y=0, int width=0, int height=0) {
 493             self->x = x;
 494             self->y = y;
 495             self->width = width;
 496             self->height = height;
 497         }
 498
 499         DocAStr(Get,
 500                "Get() -> (x,y,width,height)",
 501                "Return the rectangle properties as a tuple.");
 502         PyObject* Get() {
 503             wxPyBeginBlockThreads();
 504             PyObject* tup = PyTuple_New(4);
 505             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
 506             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
 507             PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
 508             PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
 509             wxPyEndBlockThreads();
 510             return tup;
 511         }
 512     }
 513
 514     %pythoncode {
 515     asTuple = Get
 516     def __str__(self):                   return str(self.Get())
 517     def __repr__(self):                  return 'wx.Rect'+str(self.Get())
 518     def __len__(self):                   return len(self.Get())
 519     def __getitem__(self, index):        return self.Get()[index]
 520     def __setitem__(self, index, val):
 521         if index == 0: self.x = val
 522         elif index == 1: self.y = val
 523         elif index == 2: self.width = val
 524         elif index == 3: self.height = val
 525         else: raise IndexError
 526     def __nonzero__(self):               return self.Get() != (0,0,0,0)
 527     def __getinitargs__(self):           return ()
 528     def __getstate__(self):              return self.Get()
 529     def __setstate__(self, state):       self.Set(*state)
 530     }
 531 };
 532
 533
 534 DocAStr(wxIntersectRect,
 535        "IntersectRect(Rect r1, Rect r2) -> Rect",
 536        "Calculate and return the intersection of r1 and r2.");
 537 %inline %{
 538     PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
 539         wxRegion  reg1(*r1);
 540         wxRegion  reg2(*r2);
 541         wxRect    dest(0,0,0,0);
 542         PyObject* obj;
 543
 544         reg1.Intersect(reg2);
 545         dest = reg1.GetBox();
 546
 547         if (dest != wxRect(0,0,0,0)) {
 548             wxPyBeginBlockThreads();
 549             wxRect* newRect = new wxRect(dest);
 550             obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), True);
 551             wxPyEndBlockThreads();
 552             return obj;
 553         }
 554         Py_INCREF(Py_None);
 555         return Py_None;
 556     }
 557 %}
 558
 559 //---------------------------------------------------------------------------
 560 %newgroup
 561
 562
 563 DocStr(wxPoint2D,
 564       "wx.Point2Ds represent a point or a vector in a 2d coordinate system with floating point values.");
 565
 566 class wxPoint2D
 567 {
 568 public:
 569     DocStr(wxPoint2D, "Create a w.Point2D object.");
 570     wxPoint2D( double x=0.0 , double y=0.0 );
 571     %name(Point2DCopy) wxPoint2D( const wxPoint2D &pt );
 572     %name(Point2DFromPoint) wxPoint2D( const wxPoint &pt );
 573
 574     DocDeclAStr(
 575         void, GetFloor( int *OUTPUT , int *OUTPUT ) const,
 576         "GetFloor() -> (x,y)",
 577         "Convert to integer");
 578
 579     DocDeclAStr(
 580         void, GetRounded( int *OUTPUT , int *OUTPUT ) const,
 581         "GetRounded() -> (x,y)",
 582         "Convert to integer");
 583
 584     double GetVectorLength() const;
 585     double GetVectorAngle() const ;
 586     void SetVectorLength( double length );
 587     void SetVectorAngle( double degrees );
 588
 589     // LinkError: void SetPolarCoordinates( double angle , double length );
 590     // LinkError: void Normalize();
 591     %pythoncode {
 592     def SetPolarCoordinates(self, angle, length):
 593         self.SetVectorLength(length)
 594         self.SetVectorAngle(angle)
 595     def Normalize(self):
 596         self.SetVectorLength(1.0)
 597     }
 598
 599     double GetDistance( const wxPoint2D &pt ) const;
 600     double GetDistanceSquare( const wxPoint2D &pt ) const;
 601     double GetDotProduct( const wxPoint2D &vec ) const;
 602     double GetCrossProduct( const wxPoint2D &vec ) const;
 603
 604     DocDeclStr(
 605         wxPoint2D, operator-(),
 606         "the reflection of this point");
 607
 608     wxPoint2D& operator+=(const wxPoint2D& pt);
 609     wxPoint2D& operator-=(const wxPoint2D& pt);
 610
 611     wxPoint2D& operator*=(const wxPoint2D& pt);
 612     wxPoint2D& operator/=(const wxPoint2D& pt);
 613
 614     DocDeclStr(
 615         bool, operator==(const wxPoint2D& pt) const,
 616         "Test for equality");
 617
 618     DocDeclStr(
 619         bool, operator!=(const wxPoint2D& pt) const,
 620         "Test for inequality");
 621
 622     %name(x)double m_x;
 623     %name(y)double m_y;
 624
 625     %extend {
 626         void Set( double x=0 , double y=0 ) {
 627             self->m_x = x;
 628             self->m_y = y;
 629         }
 630
 631         DocAStr(Get,
 632                "Get() -> (x,y)",
 633                "Return x and y properties as a tuple.");
 634         PyObject* Get() {
 635             wxPyBeginBlockThreads();
 636             PyObject* tup = PyTuple_New(2);
 637             PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
 638             PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
 639             wxPyEndBlockThreads();
 640             return tup;
 641         }
 642     }
 643
 644     %pythoncode {
 645     asTuple = Get
 646     def __str__(self):                   return str(self.Get())
 647     def __repr__(self):                  return 'wx.Point2D'+str(self.Get())
 648     def __len__(self):                   return len(self.Get())
 649     def __getitem__(self, index):        return self.Get()[index]
 650     def __setitem__(self, index, val):
 651         if index == 0: self.x = val
 652         elif index == 1: self.y = val
 653         else: raise IndexError
 654     def __nonzero__(self):               return self.Get() != (0.0, 0.0)
 655     def __getinitargs__(self):           return ()
 656     def __getstate__(self):              return self.Get()
 657     def __setstate__(self, state):       self.Set(*state)
 658
 659     }
 660 };
 661
 662
 663 //---------------------------------------------------------------------------
 664
 665 %immutable;
 666 const wxPoint     wxDefaultPosition;
 667 const wxSize      wxDefaultSize;
 668 %mutable;
 669
 670 //---------------------------------------------------------------------------