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 // None/NULL is now handled properly by the typemap, so these are not needed.
 134 //     %extend {
 135 //         bool __eq__(const wxSize* other) { return other ? (*self == *other) : false; }
 136 //         bool __ne__(const wxSize* other) { return other ? (*self != *other) : true;  }
 137 //     }
 138
 139     DocDeclStr(
 140         bool, operator==(const wxSize& sz),
 141         "Test for equality of wx.Size objects.", "");
 142
 143     DocDeclStr(
 144         bool, operator!=(const wxSize& sz),
 145         "Test for inequality.", "");
 146
 147     DocDeclStr(
 148         wxSize, operator+(const wxSize& sz),
 149         "Add sz's proprties to this and return the result.", "");
 150
 151     DocDeclStr(
 152         wxSize, operator-(const wxSize& sz),
 153         "Subtract sz's properties from this and return the result.", "");
 154
 155     DocDeclStr(
 156         void, IncTo(const wxSize& sz),
 157         "Increments this object so that both of its dimensions are not less
 158 than the corresponding dimensions of the size.", "");
 159
 160     DocDeclStr(
 161         void, DecTo(const wxSize& sz),
 162         "Decrements this object so that both of its dimensions are not greater
 163 than the corresponding dimensions of the size.", "");
 164
 165     DocDeclStr(
 166         void, Set(int w, int h),
 167         "Set both width and height.", "");
 168
 169     void SetWidth(int w);
 170     void SetHeight(int h);
 171     int GetWidth() const;
 172     int GetHeight() const;
 173
 174
 175     DocDeclStr(
 176         bool , IsFullySpecified() const,
 177         "Returns True if both components of the size are non-default values.", "");
 178
 179
 180     DocDeclStr(
 181         void , SetDefaults(const wxSize& size),
 182         "Combine this size with the other one replacing the default components
 183 of this object (i.e. equal to -1) with those of the other.", "");
 184
 185
 186     //int GetX() const;
 187     //int GetY() const;
 188
 189     %extend {
 190         DocAStr(Get,
 191                "Get() -> (width,height)",
 192                "Returns the width and height properties as a tuple.", "");
 193         PyObject* Get() {
 194             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 195             PyObject* tup = PyTuple_New(2);
 196             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
 197             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
 198             wxPyEndBlockThreads(blocked);
 199             return tup;
 200         }
 201     }
 202     %pythoncode {
 203     asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
 204     def __str__(self):                   return str(self.Get())
 205     def __repr__(self):                  return 'wx.Size'+str(self.Get())
 206     def __len__(self):                   return len(self.Get())
 207     def __getitem__(self, index):        return self.Get()[index]
 208     def __setitem__(self, index, val):
 209         if index == 0: self.width = val
 210         elif index == 1: self.height = val
 211         else: raise IndexError
 212     def __nonzero__(self):               return self.Get() != (0,0)
 213     __safe_for_unpickling__ = True
 214     def __reduce__(self):                return (wx.Size, self.Get())
 215     }
 216
 217 };
 218
 219 //---------------------------------------------------------------------------
 220 %newgroup
 221
 222 DocStr( wxRealPoint,
 223 "A data structure for representing a point or position with floating
 224 point x and y properties.  In wxPython most places that expect a
 225 wx.RealPoint can also accept a (x,y) tuple.", "");
 226 class wxRealPoint
 227 {
 228 public:
 229     double x;
 230     double y;
 231
 232     DocCtorStr(
 233         wxRealPoint(double x=0.0, double y=0.0),
 234         "Create a wx.RealPoint object", "");
 235
 236     ~wxRealPoint();
 237
 238     DocDeclStr(
 239         bool, operator==(const wxRealPoint& pt),
 240         "Test for equality of wx.RealPoint objects.", "");
 241
 242     DocDeclStr(
 243         bool, operator!=(const wxRealPoint& pt),
 244         "Test for inequality of wx.RealPoint objects.", "");
 245
 246
 247     DocDeclStr(
 248         wxRealPoint, operator+(const wxRealPoint& pt),
 249         "Add pt's proprties to this and return the result.", "");
 250
 251     DocDeclStr(
 252         wxRealPoint, operator-(const wxRealPoint& pt),
 253         "Subtract pt's proprties from this and return the result", "");
 254
 255
 256     %extend {
 257         DocStr(Set, "Set both the x and y properties", "");
 258         void Set(double x, double y) {
 259             self->x = x;
 260             self->y = y;
 261         }
 262
 263         DocAStr(Get,
 264                "Get() -> (x,y)",
 265                "Return the x and y properties as a tuple. ", "");
 266         PyObject* Get() {
 267             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 268             PyObject* tup = PyTuple_New(2);
 269             PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
 270             PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
 271             wxPyEndBlockThreads(blocked);
 272             return tup;
 273         }
 274     }
 275
 276     %pythoncode {
 277     asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
 278     def __str__(self):                   return str(self.Get())
 279     def __repr__(self):                  return 'wx.RealPoint'+str(self.Get())
 280     def __len__(self):                   return len(self.Get())
 281     def __getitem__(self, index):        return self.Get()[index]
 282     def __setitem__(self, index, val):
 283         if index == 0: self.x = val
 284         elif index == 1: self.y = val
 285         else: raise IndexError
 286     def __nonzero__(self):               return self.Get() != (0.0, 0.0)
 287     __safe_for_unpickling__ = True
 288     def __reduce__(self):                return (wx.RealPoint, self.Get())
 289     }
 290 };
 291
 292
 293 //---------------------------------------------------------------------------
 294 %newgroup
 295
 296
 297 DocStr(wxPoint,
 298 "A data structure for representing a point or position with integer x
 299 and y properties.  Most places in wxPython that expect a wx.Point can
 300 also accept a (x,y) tuple.", "");
 301
 302 class wxPoint
 303 {
 304 public:
 305     int x, y;
 306
 307     DocCtorStr(
 308         wxPoint(int x=0, int y=0),
 309         "Create a wx.Point object", "");
 310
 311     ~wxPoint();
 312
 313
 314     DocDeclStr(
 315         bool, operator==(const wxPoint& pt),
 316         "Test for equality of wx.Point objects.", "");
 317
 318     DocDeclStr(
 319         bool, operator!=(const wxPoint& pt),
 320         "Test for inequality of wx.Point objects.", "");
 321
 322
 323
 324 //     %nokwargs operator+;
 325 //     %nokwargs operator-;
 326 //     %nokwargs operator+=;
 327 //     %nokwargs operator-=;
 328
 329     DocDeclStr(
 330         wxPoint, operator+(const wxPoint& pt),
 331         "Add pt's proprties to this and return the result.", "");
 332
 333
 334     DocDeclStr(
 335         wxPoint, operator-(const wxPoint& pt),
 336         "Subtract pt's proprties from this and return the result", "");
 337
 338
 339     DocDeclStr(
 340         wxPoint&, operator+=(const wxPoint& pt),
 341         "Add pt to this object.", "");
 342
 343     DocDeclStr(
 344         wxPoint&, operator-=(const wxPoint& pt),
 345         "Subtract pt from this object.", "");
 346
 347
 348
 349 //     DocDeclStr(
 350 //         wxPoint, operator+(const wxSize& sz),
 351 //         "Add sz to this Point and return the result.", "");
 352
 353 //     DocDeclStr(
 354 //         wxPoint, operator-(const wxSize& sz),
 355 //         "Subtract sz from this Point and return the result", "");
 356
 357
 358 //     DocDeclStr(
 359 //         wxPoint&, operator+=(const wxSize& sz),
 360 //         "Add sz to this object.", "");
 361
 362 //     DocDeclStr(
 363 //         wxPoint&, operator-=(const wxSize& sz),
 364 //         "Subtract sz from this object.", "");
 365
 366
 367
 368
 369     %extend {
 370         DocStr(Set, "Set both the x and y properties", "");
 371         void Set(long x, long y) {
 372             self->x = x;
 373             self->y = y;
 374         }
 375
 376         DocAStr(Get,
 377                "Get() -> (x,y)",
 378                "Return the x and y properties as a tuple. ", "");
 379         PyObject* Get() {
 380             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 381             PyObject* tup = PyTuple_New(2);
 382             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
 383             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
 384             wxPyEndBlockThreads(blocked);
 385             return tup;
 386         }
 387     }
 388
 389     %pythoncode {
 390     asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
 391     def __str__(self):                   return str(self.Get())
 392     def __repr__(self):                  return 'wx.Point'+str(self.Get())
 393     def __len__(self):                   return len(self.Get())
 394     def __getitem__(self, index):        return self.Get()[index]
 395     def __setitem__(self, index, val):
 396         if index == 0: self.x = val
 397         elif index == 1: self.y = val
 398         else: raise IndexError
 399     def __nonzero__(self):               return self.Get() != (0,0)
 400     __safe_for_unpickling__ = True
 401     def __reduce__(self):                return (wx.Point, self.Get())
 402     }
 403 };
 404
 405 //---------------------------------------------------------------------------
 406 %newgroup
 407
 408
 409 DocStr(wxRect,
 410 "A class for representing and manipulating rectangles.  It has x, y,
 411 width and height properties.  In wxPython most palces that expect a
 412 wx.Rect can also accept a (x,y,width,height) tuple.", "");
 413
 414 class wxRect
 415 {
 416 public:
 417     DocCtorStr(
 418         wxRect(int x=0, int y=0, int width=0, int height=0),
 419         "Create a new Rect object.", "");
 420
 421     DocCtorStrName(
 422         wxRect(const wxPoint& topLeft, const wxPoint& bottomRight),
 423         "Create a new Rect object from Points representing two corners.", "",
 424         RectPP);
 425
 426     DocCtorStrName(
 427         wxRect(const wxPoint& pos, const wxSize& size),
 428         "Create a new Rect from a position and size.", "",
 429          RectPS);
 430
 431     DocCtorStrName(
 432         wxRect(const wxSize& size),
 433         "Create a new Rect from a size only.", "",
 434          RectS);
 435
 436     ~wxRect();
 437
 438     int GetX() const;
 439     void SetX(int x);
 440
 441     int GetY();
 442     void SetY(int y);
 443
 444     int GetWidth() const;
 445     void SetWidth(int w);
 446
 447     int GetHeight() const;
 448     void SetHeight(int h);
 449
 450     wxPoint GetPosition() const;
 451     void SetPosition( const wxPoint &p );
 452
 453     wxSize GetSize() const;
 454     void SetSize( const wxSize &s );
 455
 456     bool IsEmpty() const;
 457
 458     wxPoint GetTopLeft() const;
 459     void SetTopLeft(const wxPoint &p);
 460     wxPoint GetBottomRight() const;
 461     void SetBottomRight(const wxPoint &p);
 462
 463 //    wxPoint GetLeftTop() const;
 464 //    void SetLeftTop(const wxPoint &p);
 465 //    wxPoint GetRightBottom() const;
 466 //    void SetRightBottom(const wxPoint &p);
 467
 468     int GetLeft()   const;
 469     int GetTop()    const;
 470     int GetBottom() const;
 471     int GetRight()  const;
 472
 473     void SetLeft(int left);
 474     void SetRight(int right);
 475     void SetTop(int top);
 476     void SetBottom(int bottom);
 477
 478     %pythoncode {
 479         position = property(GetPosition, SetPosition)
 480         size = property(GetSize, SetSize)
 481         left = property(GetLeft, SetLeft)
 482         right = property(GetRight, SetRight)
 483         top = property(GetTop, SetTop)
 484         bottom = property(GetBottom, SetBottom)
 485     }
 486
 487     DocDeclStr(
 488         wxRect&, Inflate(wxCoord dx, wxCoord dy),
 489         "Increases the size of the rectangle.
 490
 491 The left border is moved farther left and the right border is moved
 492 farther right by ``dx``. The upper border is moved farther up and the
 493 bottom border is moved farther down by ``dy``. (Note the the width and
 494 height of the rectangle thus change by ``2*dx`` and ``2*dy``,
 495 respectively.) If one or both of ``dx`` and ``dy`` are negative, the
 496 opposite happens: the rectangle size decreases in the respective
 497 direction.
 498
 499 The change is made to the rectangle inplace, if instead you need a
 500 copy that is inflated, preserving the original then make the copy
 501 first::
 502
 503     copy = wx.Rect(*original)
 504     copy.Inflate(10,15)
 505
 506 ", "
 507 Inflating and deflating behaves *naturally*. Defined more precisely,
 508 that means:
 509
 510     * Real inflates (that is, ``dx`` and/or ``dy`` >= 0) are not
 511       constrained. Thus inflating a rectangle can cause its upper left
 512       corner to move into the negative numbers. (The versions prior to
 513       2.5.4 forced the top left coordinate to not fall below (0, 0),
 514       which implied a forced move of the rectangle.)
 515
 516     * Deflates are clamped to not reduce the width or height of the
 517       rectangle below zero. In such cases, the top-left corner is
 518       nonetheless handled properly. For example, a rectangle at (10,
 519       10) with size (20, 40) that is inflated by (-15, -15) will
 520       become located at (20, 25) at size (0, 10). Finally, observe
 521       that the width and height are treated independently. In the
 522       above example, the width is reduced by 20, whereas the height is
 523       reduced by the full 30 (rather than also stopping at 20, when
 524       the width reached zero).
 525
 526 :see: `Deflate`
 527 ");
 528
 529     DocDeclStr(
 530         wxRect&, Deflate(wxCoord dx, wxCoord dy),
 531         "Decrease the rectangle size. This method is the opposite of `Inflate`
 532 in that Deflate(a,b) is equivalent to Inflate(-a,-b).  Please refer to
 533 `Inflate` for a full description.", "");
 534
 535     DocDeclStrName(
 536         void, Offset(wxCoord dx, wxCoord dy),
 537         "Moves the rectangle by the specified offset. If dx is positive, the
 538 rectangle is moved to the right, if dy is positive, it is moved to the
 539 bottom, otherwise it is moved to the left or top respectively.", "",
 540         OffsetXY);
 541
 542     DocDeclStr(
 543         void, Offset(const wxPoint& pt),
 544         "Same as `OffsetXY` but uses dx,dy from Point", "");
 545
 546     DocDeclStr(
 547         wxRect, Intersect(const wxRect& rect),
 548         "Returns the intersectsion of this rectangle and rect.", "");
 549
 550     DocDeclStr(
 551         wxRect , Union(const wxRect& rect),
 552         "Returns the union of this rectangle and rect.", "");
 553
 554
 555     DocDeclStr(
 556         wxRect, operator+(const wxRect& rect) const,
 557         "Add the properties of rect to this rectangle and return the result.", "");
 558
 559     DocDeclStr(
 560         wxRect&, operator+=(const wxRect& rect),
 561         "Add the properties of rect to this rectangle, updating this rectangle.", "");
 562
 563     DocDeclStr(
 564         bool, operator==(const wxRect& rect) const,
 565         "Test for equality.", "");
 566
 567     DocDeclStr(
 568         bool, operator!=(const wxRect& rect) const,
 569         "Test for inequality.", "");
 570
 571
 572     DocStr( Inside, "Return True if the point is (not strcitly) inside the rect.", "");
 573     %Rename(InsideXY, bool, Inside(int x, int y) const);
 574     bool Inside(const wxPoint& pt) const;
 575
 576     DocDeclStr(
 577         bool, Intersects(const wxRect& rect) const,
 578         "Returns True if the rectangles have a non empty intersection.", "");
 579
 580     DocDeclStr(
 581         wxRect, CenterIn(const wxRect& r, int dir = wxBOTH),
 582         "Center this rectangle within the one passed to the method, which is
 583 usually, but not necessarily, the larger one.", "");
 584     %pythoncode { CentreIn = CenterIn }
 585
 586
 587     int x, y, width, height;
 588
 589
 590     %extend {
 591        DocStr(Set, "Set all rectangle properties.", "");
 592         void Set(int x=0, int y=0, int width=0, int height=0) {
 593             self->x = x;
 594             self->y = y;
 595             self->width = width;
 596             self->height = height;
 597         }
 598
 599         DocAStr(Get,
 600                "Get() -> (x,y,width,height)",
 601                "Return the rectangle properties as a tuple.", "");
 602         PyObject* Get() {
 603             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 604             PyObject* tup = PyTuple_New(4);
 605             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
 606             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
 607             PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
 608             PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
 609             wxPyEndBlockThreads(blocked);
 610             return tup;
 611         }
 612     }
 613
 614     %pythoncode {
 615     asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
 616     def __str__(self):                   return str(self.Get())
 617     def __repr__(self):                  return 'wx.Rect'+str(self.Get())
 618     def __len__(self):                   return len(self.Get())
 619     def __getitem__(self, index):        return self.Get()[index]
 620     def __setitem__(self, index, val):
 621         if index == 0: self.x = val
 622         elif index == 1: self.y = val
 623         elif index == 2: self.width = val
 624         elif index == 3: self.height = val
 625         else: raise IndexError
 626     def __nonzero__(self):               return self.Get() != (0,0,0,0)
 627     __safe_for_unpickling__ = True
 628     def __reduce__(self):                return (wx.Rect, self.Get())
 629     }
 630 };
 631
 632
 633 MustHaveApp(wxIntersectRect);
 634
 635 DocAStr(wxIntersectRect,
 636        "IntersectRect(Rect r1, Rect r2) -> Rect",
 637        "Calculate and return the intersection of r1 and r2.", "");
 638 %inline %{
 639     PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
 640         wxRegion  reg1(*r1);
 641         wxRegion  reg2(*r2);
 642         wxRect    dest(0,0,0,0);
 643         PyObject* obj;
 644
 645         reg1.Intersect(reg2);
 646         dest = reg1.GetBox();
 647
 648         if (dest != wxRect(0,0,0,0)) {
 649             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 650             wxRect* newRect = new wxRect(dest);
 651             obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
 652             wxPyEndBlockThreads(blocked);
 653             return obj;
 654         }
 655         Py_INCREF(Py_None);
 656         return Py_None;
 657     }
 658 %}
 659
 660 //---------------------------------------------------------------------------
 661 %newgroup
 662
 663
 664 DocStr(wxPoint2D,
 665       "wx.Point2Ds represent a point or a vector in a 2d coordinate system
 666 with floating point values.", "");
 667
 668 class wxPoint2D
 669 {
 670 public:
 671     DocStr(wxPoint2D, "Create a w.Point2D object.", "");
 672     wxPoint2D( double x=0.0 , double y=0.0 );
 673     %RenameCtor(Point2DCopy, wxPoint2D( const wxPoint2D &pt ));
 674     %RenameCtor(Point2DFromPoint, wxPoint2D( const wxPoint &pt ));
 675
 676     DocDeclAStr(
 677         void, GetFloor( int *OUTPUT , int *OUTPUT ) const,
 678         "GetFloor() -> (x,y)",
 679         "Convert to integer", "");
 680
 681     DocDeclAStr(
 682         void, GetRounded( int *OUTPUT , int *OUTPUT ) const,
 683         "GetRounded() -> (x,y)",
 684         "Convert to integer", "");
 685
 686     double GetVectorLength() const;
 687     double GetVectorAngle() const ;
 688     void SetVectorLength( double length );
 689     void SetVectorAngle( double degrees );
 690
 691     // LinkError: void SetPolarCoordinates( double angle , double length );
 692     // LinkError: void Normalize();
 693     %pythoncode {
 694     def SetPolarCoordinates(self, angle, length):
 695         self.SetVectorLength(length)
 696         self.SetVectorAngle(angle)
 697     def Normalize(self):
 698         self.SetVectorLength(1.0)
 699     }
 700
 701     double GetDistance( const wxPoint2D &pt ) const;
 702     double GetDistanceSquare( const wxPoint2D &pt ) const;
 703     double GetDotProduct( const wxPoint2D &vec ) const;
 704     double GetCrossProduct( const wxPoint2D &vec ) const;
 705
 706     DocDeclStr(
 707         wxPoint2D, operator-(),
 708         "the reflection of this point", "");
 709
 710     wxPoint2D& operator+=(const wxPoint2D& pt);
 711     wxPoint2D& operator-=(const wxPoint2D& pt);
 712
 713     wxPoint2D& operator*=(const wxPoint2D& pt);
 714     wxPoint2D& operator/=(const wxPoint2D& pt);
 715
 716     DocDeclStr(
 717         bool, operator==(const wxPoint2D& pt) const,
 718         "Test for equality", "");
 719
 720     DocDeclStr(
 721         bool, operator!=(const wxPoint2D& pt) const,
 722         "Test for inequality", "");
 723
 724     %Rename(x, double,  m_x);
 725     %Rename(y, double,  m_y);
 726
 727     %extend {
 728         void Set( double x=0 , double y=0 ) {
 729             self->m_x = x;
 730             self->m_y = y;
 731         }
 732
 733         DocAStr(Get,
 734                "Get() -> (x,y)",
 735                "Return x and y properties as a tuple.", "");
 736         PyObject* Get() {
 737             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 738             PyObject* tup = PyTuple_New(2);
 739             PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
 740             PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
 741             wxPyEndBlockThreads(blocked);
 742             return tup;
 743         }
 744     }
 745
 746     %pythoncode {
 747     asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
 748     def __str__(self):                   return str(self.Get())
 749     def __repr__(self):                  return 'wx.Point2D'+str(self.Get())
 750     def __len__(self):                   return len(self.Get())
 751     def __getitem__(self, index):        return self.Get()[index]
 752     def __setitem__(self, index, val):
 753         if index == 0: self.x = val
 754         elif index == 1: self.y = val
 755         else: raise IndexError
 756     def __nonzero__(self):               return self.Get() != (0.0, 0.0)
 757     __safe_for_unpickling__ = True
 758     def __reduce__(self):                return (wx.Point2D, self.Get())
 759     }
 760 };
 761
 762
 763 //---------------------------------------------------------------------------
 764
 765 %immutable;
 766 const wxPoint     wxDefaultPosition;
 767 const wxSize      wxDefaultSize;
 768 %mutable;
 769
 770 //---------------------------------------------------------------------------