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_ICO,
  25     wxBITMAP_TYPE_CUR,
  26     wxBITMAP_TYPE_XBM,
  27     wxBITMAP_TYPE_XBM_DATA,
  28     wxBITMAP_TYPE_XPM,
  29     wxBITMAP_TYPE_XPM_DATA,
  30     wxBITMAP_TYPE_TIF,
  31     wxBITMAP_TYPE_GIF,
  32     wxBITMAP_TYPE_PNG,
  33     wxBITMAP_TYPE_JPEG,
  34     wxBITMAP_TYPE_PNM,
  35     wxBITMAP_TYPE_PCX,
  36     wxBITMAP_TYPE_PICT,
  37     wxBITMAP_TYPE_ICON,
  38     wxBITMAP_TYPE_ANI,
  39     wxBITMAP_TYPE_IFF,
  40     wxBITMAP_TYPE_MACCURSOR,
  41
  42 //    wxBITMAP_TYPE_BMP_RESOURCE,
  43 //    wxBITMAP_TYPE_RESOURCE = wxBITMAP_TYPE_BMP_RESOURCE,
  44 //    wxBITMAP_TYPE_ICO_RESOURCE,
  45 //    wxBITMAP_TYPE_CUR_RESOURCE,
  46 //    wxBITMAP_TYPE_TIF_RESOURCE,
  47 //    wxBITMAP_TYPE_GIF_RESOURCE,
  48 //    wxBITMAP_TYPE_PNG_RESOURCE,
  49 //    wxBITMAP_TYPE_JPEG_RESOURCE,
  50 //    wxBITMAP_TYPE_PNM_RESOURCE,
  51 //    wxBITMAP_TYPE_PCX_RESOURCE,
  52 //    wxBITMAP_TYPE_PICT_RESOURCE,
  53 //    wxBITMAP_TYPE_ICON_RESOURCE,
  54 //    wxBITMAP_TYPE_MACCURSOR_RESOURCE,
  55
  56     wxBITMAP_TYPE_ANY = 50
  57 };
  58
  59 // Standard cursors
  60 enum wxStockCursor
  61 {
  62     wxCURSOR_NONE,          // should be 0
  63     wxCURSOR_ARROW,
  64     wxCURSOR_RIGHT_ARROW,
  65     wxCURSOR_BULLSEYE,
  66     wxCURSOR_CHAR,
  67     wxCURSOR_CROSS,
  68     wxCURSOR_HAND,
  69     wxCURSOR_IBEAM,
  70     wxCURSOR_LEFT_BUTTON,
  71     wxCURSOR_MAGNIFIER,
  72     wxCURSOR_MIDDLE_BUTTON,
  73     wxCURSOR_NO_ENTRY,
  74     wxCURSOR_PAINT_BRUSH,
  75     wxCURSOR_PENCIL,
  76     wxCURSOR_POINT_LEFT,
  77     wxCURSOR_POINT_RIGHT,
  78     wxCURSOR_QUESTION_ARROW,
  79     wxCURSOR_RIGHT_BUTTON,
  80     wxCURSOR_SIZENESW,
  81     wxCURSOR_SIZENS,
  82     wxCURSOR_SIZENWSE,
  83     wxCURSOR_SIZEWE,
  84     wxCURSOR_SIZING,
  85     wxCURSOR_SPRAYCAN,
  86     wxCURSOR_WAIT,
  87     wxCURSOR_WATCH,
  88     wxCURSOR_BLANK,
  89     wxCURSOR_DEFAULT, // standard X11 cursor
  90     wxCURSOR_COPY_ARROW , // MacOS Theme Plus arrow
  91
  92 // #ifdef __X__
  93 //     // Not yet implemented for Windows
  94 //     wxCURSOR_CROSS_REVERSE,
  95 //     wxCURSOR_DOUBLE_ARROW,
  96 //     wxCURSOR_BASED_ARROW_UP,
  97 //     wxCURSOR_BASED_ARROW_DOWN,
  98 // #endif // X11
  99
 100     wxCURSOR_ARROWWAIT,
 101
 102     wxCURSOR_MAX
 103 };
 104
 105 %{
 106 #ifndef __WXMAC__
 107 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
 108 #endif
 109 %}
 110
 111 //---------------------------------------------------------------------------
 112 %newgroup
 113
 114 DocStr( wxSize,
 115 "wx.Size is a useful data structure used to represent the size of
 116 something.  It simply contains integer width and height
 117 properties.  In most places in wxPython where a wx.Size is
 118 expected a (width, height) tuple can be used instead.", "");
 119
 120 class wxSize
 121 {
 122 public:
 123     %Rename(width, int,  x);
 124     %Rename(height,int,  y);
 125     %pythoncode { x = width; y = height }
 126
 127     DocCtorStr(
 128         wxSize(int w=0, int h=0),
 129         "Creates a size object.", "");
 130
 131     ~wxSize();
 132
 133
 134     %extend {
 135         KeepGIL(__eq__);
 136         DocStr(__eq__, "Test for equality of wx.Size objects.", "");
 137         bool __eq__(PyObject* other) {
 138             wxSize  temp, *obj = &temp;
 139             if ( other == Py_None ) return false;
 140             if ( ! wxSize_helper(other, &obj) ) {
 141                 PyErr_Clear();
 142                 return false;
 143             }
 144             return self->operator==(*obj);
 145         }
 146
 147
 148         KeepGIL(__ne__);
 149         DocStr(__ne__, "Test for inequality of wx.Size objects.", "");
 150         bool __ne__(PyObject* other) {
 151             wxSize  temp, *obj = &temp;
 152             if ( other == Py_None ) return true;
 153             if ( ! wxSize_helper(other, &obj)) {
 154                 PyErr_Clear();
 155                 return true;
 156             }
 157             return self->operator!=(*obj);
 158         }
 159     }
 160
 161     DocDeclStr(
 162         wxSize, operator+(const wxSize& sz),
 163         "Add sz's proprties to this and return the result.", "");
 164
 165     DocDeclStr(
 166         wxSize, operator-(const wxSize& sz),
 167         "Subtract sz's properties from this and return the result.", "");
 168
 169     DocDeclStr(
 170         void, IncTo(const wxSize& sz),
 171         "Increments this object so that both of its dimensions are not less
 172 than the corresponding dimensions of the size.", "");
 173
 174     DocDeclStr(
 175         void, DecTo(const wxSize& sz),
 176         "Decrements this object so that both of its dimensions are not greater
 177 than the corresponding dimensions of the size.", "");
 178
 179
 180     DocDeclStr(
 181         void , Scale(float xscale, float yscale),
 182         "Scales the dimensions of this object by the given factors.", "");
 183
 184     DocDeclStr(
 185         void, Set(int w, int h),
 186         "Set both width and height.", "");
 187
 188     void SetWidth(int w);
 189     void SetHeight(int h);
 190     int GetWidth() const;
 191     int GetHeight() const;
 192
 193
 194     DocDeclStr(
 195         bool , IsFullySpecified() const,
 196         "Returns True if both components of the size are non-default values.", "");
 197
 198
 199     DocDeclStr(
 200         void , SetDefaults(const wxSize& size),
 201         "Combine this size with the other one replacing the default components
 202 of this object (i.e. equal to -1) with those of the other.", "");
 203
 204
 205     //int GetX() const;
 206     //int GetY() const;
 207
 208     %extend {
 209         DocAStr(Get,
 210                "Get() -> (width,height)",
 211                "Returns the width and height properties as a tuple.", "");
 212         PyObject* Get() {
 213             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 214             PyObject* tup = PyTuple_New(2);
 215             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
 216             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
 217             wxPyEndBlockThreads(blocked);
 218             return tup;
 219         }
 220     }
 221     %pythoncode {
 222     asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
 223     def __str__(self):                   return str(self.Get())
 224     def __repr__(self):                  return 'wx.Size'+str(self.Get())
 225     def __len__(self):                   return len(self.Get())
 226     def __getitem__(self, index):        return self.Get()[index]
 227     def __setitem__(self, index, val):
 228         if index == 0: self.width = val
 229         elif index == 1: self.height = val
 230         else: raise IndexError
 231     def __nonzero__(self):               return self.Get() != (0,0)
 232     __safe_for_unpickling__ = True
 233     def __reduce__(self):                return (wx.Size, self.Get())
 234     }
 235
 236 };
 237
 238 //---------------------------------------------------------------------------
 239 %newgroup
 240
 241 DocStr( wxRealPoint,
 242 "A data structure for representing a point or position with floating
 243 point x and y properties.  In wxPython most places that expect a
 244 wx.RealPoint can also accept a (x,y) tuple.", "");
 245 class wxRealPoint
 246 {
 247 public:
 248     double x;
 249     double y;
 250
 251     DocCtorStr(
 252         wxRealPoint(double x=0.0, double y=0.0),
 253         "Create a wx.RealPoint object", "");
 254
 255     ~wxRealPoint();
 256
 257     %extend {
 258         KeepGIL(__eq__);
 259         DocStr(__eq__, "Test for equality of wx.RealPoint objects.", "");
 260         bool __eq__(PyObject* other) {
 261             wxRealPoint  temp, *obj = &temp;
 262             if ( other == Py_None ) return false;
 263             if ( ! wxRealPoint_helper(other, &obj) ) {
 264                 PyErr_Clear();
 265                 return false;
 266             }
 267             return self->operator==(*obj);
 268         }
 269
 270
 271         KeepGIL(__ne__);
 272         DocStr(__ne__, "Test for inequality of wx.RealPoint objects.", "");
 273         bool __ne__(PyObject* other) {
 274             wxRealPoint  temp, *obj = &temp;
 275             if ( other == Py_None ) return true;
 276             if ( ! wxRealPoint_helper(other, &obj)) {
 277                 PyErr_Clear();
 278                 return true;
 279             }
 280             return self->operator!=(*obj);
 281         }
 282     }
 283
 284
 285     DocDeclStr(
 286         wxRealPoint, operator+(const wxRealPoint& pt),
 287         "Add pt's proprties to this and return the result.", "");
 288
 289     DocDeclStr(
 290         wxRealPoint, operator-(const wxRealPoint& pt),
 291         "Subtract pt's proprties from this and return the result", "");
 292
 293
 294     %extend {
 295         DocStr(Set, "Set both the x and y properties", "");
 296         void Set(double x, double y) {
 297             self->x = x;
 298             self->y = y;
 299         }
 300
 301         DocAStr(Get,
 302                "Get() -> (x,y)",
 303                "Return the x and y properties as a tuple. ", "");
 304         PyObject* Get() {
 305             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 306             PyObject* tup = PyTuple_New(2);
 307             PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
 308             PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
 309             wxPyEndBlockThreads(blocked);
 310             return tup;
 311         }
 312     }
 313
 314     %pythoncode {
 315     asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
 316     def __str__(self):                   return str(self.Get())
 317     def __repr__(self):                  return 'wx.RealPoint'+str(self.Get())
 318     def __len__(self):                   return len(self.Get())
 319     def __getitem__(self, index):        return self.Get()[index]
 320     def __setitem__(self, index, val):
 321         if index == 0: self.x = val
 322         elif index == 1: self.y = val
 323         else: raise IndexError
 324     def __nonzero__(self):               return self.Get() != (0.0, 0.0)
 325     __safe_for_unpickling__ = True
 326     def __reduce__(self):                return (wx.RealPoint, self.Get())
 327     }
 328 };
 329
 330
 331 //---------------------------------------------------------------------------
 332 %newgroup
 333
 334
 335 DocStr(wxPoint,
 336 "A data structure for representing a point or position with integer x
 337 and y properties.  Most places in wxPython that expect a wx.Point can
 338 also accept a (x,y) tuple.", "");
 339
 340 class wxPoint
 341 {
 342 public:
 343     int x, y;
 344
 345     DocCtorStr(
 346         wxPoint(int x=0, int y=0),
 347         "Create a wx.Point object", "");
 348
 349     ~wxPoint();
 350
 351
 352     %extend {
 353         KeepGIL(__eq__);
 354         DocStr(__eq__, "Test for equality of wx.Point objects.", "");
 355         bool __eq__(PyObject* other) {
 356             wxPoint  temp, *obj = &temp;
 357             if ( other == Py_None ) return false;
 358             if ( ! wxPoint_helper(other, &obj) ) {
 359                 PyErr_Clear();
 360                 return false;
 361             }
 362             return self->operator==(*obj);
 363         }
 364
 365
 366         KeepGIL(__ne__);
 367         DocStr(__ne__, "Test for inequality of wx.Point objects.", "");
 368         bool __ne__(PyObject* other) {
 369             wxPoint  temp, *obj = &temp;
 370             if ( other == Py_None ) return true;
 371             if ( ! wxPoint_helper(other, &obj)) {
 372                 PyErr_Clear();
 373                 return true;
 374             }
 375             return self->operator!=(*obj);
 376         }
 377     }
 378
 379
 380 //     %nokwargs operator+;
 381 //     %nokwargs operator-;
 382 //     %nokwargs operator+=;
 383 //     %nokwargs operator-=;
 384
 385     DocDeclStr(
 386         wxPoint, operator+(const wxPoint& pt),
 387         "Add pt's proprties to this and return the result.", "");
 388
 389
 390     DocDeclStr(
 391         wxPoint, operator-(const wxPoint& pt),
 392         "Subtract pt's proprties from this and return the result", "");
 393
 394
 395     DocDeclStr(
 396         wxPoint&, operator+=(const wxPoint& pt),
 397         "Add pt to this object.", "");
 398
 399     DocDeclStr(
 400         wxPoint&, operator-=(const wxPoint& pt),
 401         "Subtract pt from this object.", "");
 402
 403
 404
 405 //     DocDeclStr(
 406 //         wxPoint, operator+(const wxSize& sz),
 407 //         "Add sz to this Point and return the result.", "");
 408
 409 //     DocDeclStr(
 410 //         wxPoint, operator-(const wxSize& sz),
 411 //         "Subtract sz from this Point and return the result", "");
 412
 413
 414 //     DocDeclStr(
 415 //         wxPoint&, operator+=(const wxSize& sz),
 416 //         "Add sz to this object.", "");
 417
 418 //     DocDeclStr(
 419 //         wxPoint&, operator-=(const wxSize& sz),
 420 //         "Subtract sz from this object.", "");
 421
 422
 423
 424
 425     %extend {
 426         DocStr(Set, "Set both the x and y properties", "");
 427         void Set(long x, long y) {
 428             self->x = x;
 429             self->y = y;
 430         }
 431
 432         DocAStr(Get,
 433                "Get() -> (x,y)",
 434                "Return the x and y properties as a tuple. ", "");
 435         PyObject* Get() {
 436             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 437             PyObject* tup = PyTuple_New(2);
 438             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
 439             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
 440             wxPyEndBlockThreads(blocked);
 441             return tup;
 442         }
 443     }
 444
 445     %pythoncode {
 446     asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
 447     def __str__(self):                   return str(self.Get())
 448     def __repr__(self):                  return 'wx.Point'+str(self.Get())
 449     def __len__(self):                   return len(self.Get())
 450     def __getitem__(self, index):        return self.Get()[index]
 451     def __setitem__(self, index, val):
 452         if index == 0: self.x = val
 453         elif index == 1: self.y = val
 454         else: raise IndexError
 455     def __nonzero__(self):               return self.Get() != (0,0)
 456     __safe_for_unpickling__ = True
 457     def __reduce__(self):                return (wx.Point, self.Get())
 458     }
 459 };
 460
 461 //---------------------------------------------------------------------------
 462 %newgroup
 463
 464
 465 DocStr(wxRect,
 466 "A class for representing and manipulating rectangles.  It has x, y,
 467 width and height properties.  In wxPython most palces that expect a
 468 wx.Rect can also accept a (x,y,width,height) tuple.", "");
 469
 470 class wxRect
 471 {
 472 public:
 473     DocCtorStr(
 474         wxRect(int x=0, int y=0, int width=0, int height=0),
 475         "Create a new Rect object.", "");
 476
 477     DocCtorStrName(
 478         wxRect(const wxPoint& topLeft, const wxPoint& bottomRight),
 479         "Create a new Rect object from Points representing two corners.", "",
 480         RectPP);
 481
 482     DocCtorStrName(
 483         wxRect(const wxPoint& pos, const wxSize& size),
 484         "Create a new Rect from a position and size.", "",
 485          RectPS);
 486
 487     DocCtorStrName(
 488         wxRect(const wxSize& size),
 489         "Create a new Rect from a size only.", "",
 490          RectS);
 491
 492     ~wxRect();
 493
 494     int GetX() const;
 495     void SetX(int x);
 496
 497     int GetY();
 498     void SetY(int y);
 499
 500     int GetWidth() const;
 501     void SetWidth(int w);
 502
 503     int GetHeight() const;
 504     void SetHeight(int h);
 505
 506     wxPoint GetPosition() const;
 507     void SetPosition( const wxPoint &p );
 508
 509     wxSize GetSize() const;
 510     void SetSize( const wxSize &s );
 511
 512     bool IsEmpty() const;
 513
 514     wxPoint GetTopLeft() const;
 515     void SetTopLeft(const wxPoint &p);
 516     wxPoint GetBottomRight() const;
 517     void SetBottomRight(const wxPoint &p);
 518
 519     wxPoint GetTopRight() const;
 520     void SetTopRight(const wxPoint &p);
 521     wxPoint GetBottomLeft() const;
 522     void SetBottomLeft(const wxPoint &p);
 523
 524 //    wxPoint GetLeftTop() const;
 525 //    void SetLeftTop(const wxPoint &p);
 526 //    wxPoint GetRightBottom() const;
 527 //    void SetRightBottom(const wxPoint &p);
 528 //    wxPoint GetRightTop() const;
 529 //    void SetRightTop(const wxPoint &p);
 530 //    wxPoint GetLeftBottom() const;
 531 //    void SetLeftBottom(const wxPoint &p);
 532
 533     int GetLeft()   const;
 534     int GetTop()    const;
 535     int GetBottom() const;
 536     int GetRight()  const;
 537
 538     void SetLeft(int left);
 539     void SetRight(int right);
 540     void SetTop(int top);
 541     void SetBottom(int bottom);
 542
 543     %pythoncode {
 544         position = property(GetPosition, SetPosition)
 545         size = property(GetSize, SetSize)
 546         left = property(GetLeft, SetLeft)
 547         right = property(GetRight, SetRight)
 548         top = property(GetTop, SetTop)
 549         bottom = property(GetBottom, SetBottom)
 550     }
 551
 552     DocDeclStr(
 553         wxRect&, Inflate(wxCoord dx, wxCoord dy),
 554         "Increases the size of the rectangle.
 555
 556 The left border is moved farther left and the right border is moved
 557 farther right by ``dx``. The upper border is moved farther up and the
 558 bottom border is moved farther down by ``dy``. (Note the the width and
 559 height of the rectangle thus change by ``2*dx`` and ``2*dy``,
 560 respectively.) If one or both of ``dx`` and ``dy`` are negative, the
 561 opposite happens: the rectangle size decreases in the respective
 562 direction.
 563
 564 The change is made to the rectangle inplace, if instead you need a
 565 copy that is inflated, preserving the original then make the copy
 566 first::
 567
 568     copy = wx.Rect(*original)
 569     copy.Inflate(10,15)
 570
 571 ", "
 572 Inflating and deflating behaves *naturally*. Defined more precisely,
 573 that means:
 574
 575     * Real inflates (that is, ``dx`` and/or ``dy`` >= 0) are not
 576       constrained. Thus inflating a rectangle can cause its upper left
 577       corner to move into the negative numbers. (The versions prior to
 578       2.5.4 forced the top left coordinate to not fall below (0, 0),
 579       which implied a forced move of the rectangle.)
 580
 581     * Deflates are clamped to not reduce the width or height of the
 582       rectangle below zero. In such cases, the top-left corner is
 583       nonetheless handled properly. For example, a rectangle at (10,
 584       10) with size (20, 40) that is inflated by (-15, -15) will
 585       become located at (20, 25) at size (0, 10). Finally, observe
 586       that the width and height are treated independently. In the
 587       above example, the width is reduced by 20, whereas the height is
 588       reduced by the full 30 (rather than also stopping at 20, when
 589       the width reached zero).
 590
 591 :see: `Deflate`
 592 ");
 593
 594     DocDeclStr(
 595         wxRect&, Deflate(wxCoord dx, wxCoord dy),
 596         "Decrease the rectangle size. This method is the opposite of `Inflate`
 597 in that Deflate(a,b) is equivalent to Inflate(-a,-b).  Please refer to
 598 `Inflate` for a full description.", "");
 599
 600     DocDeclStrName(
 601         void, Offset(wxCoord dx, wxCoord dy),
 602         "Moves the rectangle by the specified offset. If dx is positive, the
 603 rectangle is moved to the right, if dy is positive, it is moved to the
 604 bottom, otherwise it is moved to the left or top respectively.", "",
 605         OffsetXY);
 606
 607     DocDeclStr(
 608         void, Offset(const wxPoint& pt),
 609         "Same as `OffsetXY` but uses dx,dy from Point", "");
 610
 611     DocDeclStr(
 612         wxRect, Intersect(const wxRect& rect),
 613         "Returns the intersectsion of this rectangle and rect.", "");
 614
 615     DocDeclStr(
 616         wxRect , Union(const wxRect& rect),
 617         "Returns the union of this rectangle and rect.", "");
 618
 619
 620     DocDeclStr(
 621         wxRect, operator+(const wxRect& rect) const,
 622         "Add the properties of rect to this rectangle and return the result.", "");
 623
 624     DocDeclStr(
 625         wxRect&, operator+=(const wxRect& rect),
 626         "Add the properties of rect to this rectangle, updating this rectangle.", "");
 627
 628     %extend {
 629         KeepGIL(__eq__);
 630         DocStr(__eq__, "Test for equality of wx.Rect objects.", "");
 631         bool __eq__(PyObject* other) {
 632             wxRect  temp, *obj = &temp;
 633             if ( other == Py_None ) return false;
 634             if ( ! wxRect_helper(other, &obj) ) {
 635                 PyErr_Clear();
 636                 return false;
 637             }
 638             return self->operator==(*obj);
 639         }
 640
 641
 642         KeepGIL(__ne__);
 643         DocStr(__ne__, "Test for inequality of wx.Rect objects.", "");
 644         bool __ne__(PyObject* other) {
 645             wxRect  temp, *obj = &temp;
 646             if ( other == Py_None ) return true;
 647             if ( ! wxRect_helper(other, &obj)) {
 648                 PyErr_Clear();
 649                 return true;
 650             }
 651             return self->operator!=(*obj);
 652         }
 653     }
 654
 655
 656     DocStr( Contains, "Return True if the point is inside the rect.", "");
 657     %Rename(ContainsXY, bool, Contains(int x, int y) const);
 658     bool Contains(const wxPoint& pt) const;
 659
 660     DocDeclStrName(
 661         bool, Contains(const wxRect& rect) const,
 662         "Returns ``True`` if the given rectangle is completely inside this
 663 rectangle or touches its boundary.", "",
 664         ContainsRect);
 665     %pythoncode {
 666         Inside = wx._deprecated(Contains, "Use `Contains` instead.")
 667         InsideXY = wx._deprecated(ContainsXY, "Use `ContainsXY` instead.")
 668         InsideRect = wx._deprecated(ContainsRect, "Use `ContainsRect` instead.")
 669     }
 670
 671     DocDeclStr(
 672         bool, Intersects(const wxRect& rect) const,
 673         "Returns True if the rectangles have a non empty intersection.", "");
 674
 675     DocDeclStr(
 676         wxRect, CenterIn(const wxRect& r, int dir = wxBOTH),
 677         "Center this rectangle within the one passed to the method, which is
 678 usually, but not necessarily, the larger one.", "");
 679     %pythoncode { CentreIn = CenterIn }
 680
 681
 682     int x, y, width, height;
 683
 684
 685     %extend {
 686        DocStr(Set, "Set all rectangle properties.", "");
 687         void Set(int x=0, int y=0, int width=0, int height=0) {
 688             self->x = x;
 689             self->y = y;
 690             self->width = width;
 691             self->height = height;
 692         }
 693
 694         DocAStr(Get,
 695                "Get() -> (x,y,width,height)",
 696                "Return the rectangle properties as a tuple.", "");
 697         PyObject* Get() {
 698             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 699             PyObject* tup = PyTuple_New(4);
 700             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
 701             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
 702             PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
 703             PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
 704             wxPyEndBlockThreads(blocked);
 705             return tup;
 706         }
 707     }
 708
 709     %pythoncode {
 710     asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
 711     def __str__(self):                   return str(self.Get())
 712     def __repr__(self):                  return 'wx.Rect'+str(self.Get())
 713     def __len__(self):                   return len(self.Get())
 714     def __getitem__(self, index):        return self.Get()[index]
 715     def __setitem__(self, index, val):
 716         if index == 0: self.x = val
 717         elif index == 1: self.y = val
 718         elif index == 2: self.width = val
 719         elif index == 3: self.height = val
 720         else: raise IndexError
 721     def __nonzero__(self):               return self.Get() != (0,0,0,0)
 722     __safe_for_unpickling__ = True
 723     def __reduce__(self):                return (wx.Rect, self.Get())
 724     }
 725
 726
 727     %property(Bottom, GetBottom, SetBottom, doc="See `GetBottom` and `SetBottom`");
 728     %property(BottomRight, GetBottomRight, SetBottomRight, doc="See `GetBottomRight` and `SetBottomRight`");
 729     %property(BottomLeft, GetBottomLeft, SetBottomLeft, doc="See `GetBottomLeft` and `SetBottomLeft`");
 730     %property(Height, GetHeight, SetHeight, doc="See `GetHeight` and `SetHeight`");
 731     %property(Left, GetLeft, SetLeft, doc="See `GetLeft` and `SetLeft`");
 732     %property(Position, GetPosition, SetPosition, doc="See `GetPosition` and `SetPosition`");
 733     %property(Right, GetRight, SetRight, doc="See `GetRight` and `SetRight`");
 734     %property(Size, GetSize, SetSize, doc="See `GetSize` and `SetSize`");
 735     %property(Top, GetTop, SetTop, doc="See `GetTop` and `SetTop`");
 736     %property(TopLeft, GetTopLeft, SetTopLeft, doc="See `GetTopLeft` and `SetTopLeft`");
 737     %property(TopRight, GetTopRight, SetTopRight, doc="See `GetTopRight` and `SetTopRight`");
 738     %property(Width, GetWidth, SetWidth, doc="See `GetWidth` and `SetWidth`");
 739     %property(X, GetX, SetX, doc="See `GetX` and `SetX`");
 740     %property(Y, GetY, SetY, doc="See `GetY` and `SetY`");
 741
 742     %property(Empty, IsEmpty, doc="See `IsEmpty`");
 743 };
 744
 745
 746 MustHaveApp(wxIntersectRect);
 747
 748 DocAStr(wxIntersectRect,
 749        "IntersectRect(Rect r1, Rect r2) -> Rect",
 750        "Calculate and return the intersection of r1 and r2.", "");
 751 %inline %{
 752     PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
 753         wxRegion  reg1(*r1);
 754         wxRegion  reg2(*r2);
 755         wxRect    dest(0,0,0,0);
 756         PyObject* obj;
 757
 758         reg1.Intersect(reg2);
 759         dest = reg1.GetBox();
 760
 761         if (dest != wxRect(0,0,0,0)) {
 762             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 763             wxRect* newRect = new wxRect(dest);
 764             obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
 765             wxPyEndBlockThreads(blocked);
 766             return obj;
 767         }
 768         Py_INCREF(Py_None);
 769         return Py_None;
 770     }
 771 %}
 772
 773 //---------------------------------------------------------------------------
 774 %newgroup
 775
 776
 777 DocStr(wxPoint2D,
 778       "wx.Point2Ds represent a point or a vector in a 2d coordinate system
 779 with floating point values.", "");
 780
 781 class wxPoint2D
 782 {
 783 public:
 784     DocStr(wxPoint2D, "Create a w.Point2D object.", "");
 785     wxPoint2D( double x=0.0 , double y=0.0 );
 786     %RenameCtor(Point2DCopy, wxPoint2D( const wxPoint2D &pt ));
 787     %RenameCtor(Point2DFromPoint, wxPoint2D( const wxPoint &pt ));
 788
 789     DocDeclAStr(
 790         void, GetFloor( int *OUTPUT , int *OUTPUT ) const,
 791         "GetFloor() -> (x,y)",
 792         "Convert to integer", "");
 793
 794     DocDeclAStr(
 795         void, GetRounded( int *OUTPUT , int *OUTPUT ) const,
 796         "GetRounded() -> (x,y)",
 797         "Convert to integer", "");
 798
 799     double GetVectorLength() const;
 800     double GetVectorAngle() const ;
 801     void SetVectorLength( double length );
 802     void SetVectorAngle( double degrees );
 803
 804     // LinkError: void SetPolarCoordinates( double angle , double length );
 805     // LinkError: void Normalize();
 806     %pythoncode {
 807     def SetPolarCoordinates(self, angle, length):
 808         self.SetVectorLength(length)
 809         self.SetVectorAngle(angle)
 810     def Normalize(self):
 811         self.SetVectorLength(1.0)
 812     }
 813
 814     double GetDistance( const wxPoint2D &pt ) const;
 815     double GetDistanceSquare( const wxPoint2D &pt ) const;
 816     double GetDotProduct( const wxPoint2D &vec ) const;
 817     double GetCrossProduct( const wxPoint2D &vec ) const;
 818
 819     DocDeclStr(
 820         wxPoint2D, operator-(),
 821         "the reflection of this point", "");
 822
 823     wxPoint2D& operator+=(const wxPoint2D& pt);
 824     wxPoint2D& operator-=(const wxPoint2D& pt);
 825
 826     wxPoint2D& operator*=(const wxPoint2D& pt);
 827     wxPoint2D& operator/=(const wxPoint2D& pt);
 828
 829     %extend {
 830         KeepGIL(__eq__);
 831         DocStr(__eq__, "Test for equality of wx.Point2D objects.", "");
 832         bool __eq__(PyObject* other) {
 833             wxPoint2D  temp, *obj = &temp;
 834             if ( other == Py_None ) return false;
 835             if ( ! wxPoint2D_helper(other, &obj) ) {
 836                 PyErr_Clear();
 837                 return false;
 838             }
 839             return self->operator==(*obj);
 840         }
 841
 842
 843         KeepGIL(__ne__);
 844         DocStr(__ne__, "Test for inequality of wx.Point2D objects.", "");
 845         bool __ne__(PyObject* other) {
 846             wxPoint2D  temp, *obj = &temp;
 847             if ( other == Py_None ) return true;
 848             if ( ! wxPoint2D_helper(other, &obj)) {
 849                 PyErr_Clear();
 850                 return true;
 851             }
 852             return self->operator!=(*obj);
 853         }
 854     }
 855
 856     %Rename(x, double,  m_x);
 857     %Rename(y, double,  m_y);
 858
 859     %extend {
 860         void Set( double x=0 , double y=0 ) {
 861             self->m_x = x;
 862             self->m_y = y;
 863         }
 864
 865         DocAStr(Get,
 866                "Get() -> (x,y)",
 867                "Return x and y properties as a tuple.", "");
 868         PyObject* Get() {
 869             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 870             PyObject* tup = PyTuple_New(2);
 871             PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
 872             PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
 873             wxPyEndBlockThreads(blocked);
 874             return tup;
 875         }
 876     }
 877
 878     %pythoncode {
 879     asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
 880     def __str__(self):                   return str(self.Get())
 881     def __repr__(self):                  return 'wx.Point2D'+str(self.Get())
 882     def __len__(self):                   return len(self.Get())
 883     def __getitem__(self, index):        return self.Get()[index]
 884     def __setitem__(self, index, val):
 885         if index == 0: self.x = val
 886         elif index == 1: self.y = val
 887         else: raise IndexError
 888     def __nonzero__(self):               return self.Get() != (0.0, 0.0)
 889     __safe_for_unpickling__ = True
 890     def __reduce__(self):                return (wx.Point2D, self.Get())
 891     }
 892
 893     %property(Floor, GetFloor, doc="See `GetFloor`");
 894     %property(Rounded, GetRounded, doc="See `GetRounded`");
 895     %property(VectorAngle, GetVectorAngle, SetVectorAngle, doc="See `GetVectorAngle` and `SetVectorAngle`");
 896     %property(VectorLength, GetVectorLength, SetVectorLength, doc="See `GetVectorLength` and `SetVectorLength`");
 897
 898 };
 899
 900
 901 //---------------------------------------------------------------------------
 902
 903 %immutable;
 904 const wxPoint     wxDefaultPosition;
 905 const wxSize      wxDefaultSize;
 906 %mutable;
 907
 908 //---------------------------------------------------------------------------