]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/_gdicmn.i
Tweaks for demos on MacOSX
[wxWidgets.git] / 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 //---------------------------------------------------------------------------