]> git.saurik.com Git - wxWidgets.git/blame - wxPython/src/_gdicmn.i
test wxString's char<->wchar_t ctors
[wxWidgets.git] / wxPython / src / _gdicmn.i
CommitLineData
d14a1e28
RD
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
20enum wxBitmapType
21{
22 wxBITMAP_TYPE_INVALID, // should be == 0 for compatibility!
23 wxBITMAP_TYPE_BMP,
d14a1e28 24 wxBITMAP_TYPE_ICO,
d14a1e28 25 wxBITMAP_TYPE_CUR,
d14a1e28
RD
26 wxBITMAP_TYPE_XBM,
27 wxBITMAP_TYPE_XBM_DATA,
28 wxBITMAP_TYPE_XPM,
29 wxBITMAP_TYPE_XPM_DATA,
30 wxBITMAP_TYPE_TIF,
d14a1e28 31 wxBITMAP_TYPE_GIF,
d14a1e28 32 wxBITMAP_TYPE_PNG,
d14a1e28 33 wxBITMAP_TYPE_JPEG,
d14a1e28 34 wxBITMAP_TYPE_PNM,
d14a1e28 35 wxBITMAP_TYPE_PCX,
d14a1e28 36 wxBITMAP_TYPE_PICT,
d14a1e28 37 wxBITMAP_TYPE_ICON,
d14a1e28
RD
38 wxBITMAP_TYPE_ANI,
39 wxBITMAP_TYPE_IFF,
40 wxBITMAP_TYPE_MACCURSOR,
64e8a1f0
RD
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
d14a1e28
RD
56 wxBITMAP_TYPE_ANY = 50
57};
58
59// Standard cursors
60enum 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
d14a1e28 113
dd9f7fea 114DocStr( wxSize,
d07d2bc9
RD
115"wx.Size is a useful data structure used to represent the size of
116something. It simply contians integer width and height proprtites.
117In most places in wxPython where a wx.Size is expected a
118(width,height) tuple can be used instead.", "");
dd9f7fea 119
d14a1e28
RD
120class wxSize
121{
122public:
d14a1e28
RD
123 %name(width) int x;
124 %name(height)int y;
61c5a8ac
RD
125 %pythoncode { x = width; y = height }
126
dd9f7fea
RD
127 DocCtorStr(
128 wxSize(int w=0, int h=0),
d07d2bc9 129 "Creates a size object.", "");
dd9f7fea 130
d14a1e28
RD
131 ~wxSize();
132
dce2bd22 133// None/NULL is now handled properly by the typemap, so these are not needed.
22faec7d
RD
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
dd9f7fea
RD
139 DocDeclStr(
140 bool, operator==(const wxSize& sz),
d07d2bc9 141 "Test for equality of wx.Size objects.", "");
dd9f7fea
RD
142
143 DocDeclStr(
144 bool, operator!=(const wxSize& sz),
d07d2bc9 145 "Test for inequality.", "");
d14a1e28 146
dd9f7fea
RD
147 DocDeclStr(
148 wxSize, operator+(const wxSize& sz),
d07d2bc9 149 "Add sz's proprties to this and return the result.", "");
d14a1e28 150
dd9f7fea
RD
151 DocDeclStr(
152 wxSize, operator-(const wxSize& sz),
d07d2bc9 153 "Subtract sz's properties from this and return the result.", "");
d14a1e28 154
dd9f7fea
RD
155 DocDeclStr(
156 void, IncTo(const wxSize& sz),
d07d2bc9
RD
157 "Increments this object so that both of its dimensions are not less
158than the corresponding dimensions of the size.", "");
dd9f7fea
RD
159
160 DocDeclStr(
161 void, DecTo(const wxSize& sz),
d07d2bc9
RD
162 "Decrements this object so that both of its dimensions are not greater
163than the corresponding dimensions of the size.", "");
dd9f7fea
RD
164
165 DocDeclStr(
166 void, Set(int w, int h),
d07d2bc9 167 "Set both width and height.", "");
dd9f7fea 168
d14a1e28
RD
169 void SetWidth(int w);
170 void SetHeight(int h);
171 int GetWidth() const;
172 int GetHeight() const;
173
93a163f6
RD
174
175 DocDeclStr(
176 bool , IsFullySpecified() const,
d07d2bc9 177 "Returns True if both components of the size are non-default values.", "");
93a163f6
RD
178
179
180 DocDeclStr(
181 void , SetDefaults(const wxSize& size),
d07d2bc9
RD
182 "Combine this size with the other one replacing the default components
183of this object (i.e. equal to -1) with those of the other.", "");
93a163f6
RD
184
185
dd9f7fea
RD
186 //int GetX() const;
187 //int GetY() const;
d14a1e28
RD
188
189 %extend {
dd9f7fea
RD
190 DocAStr(Get,
191 "Get() -> (width,height)",
d07d2bc9 192 "Returns the width and height properties as a tuple.", "");
dd9f7fea 193 PyObject* Get() {
da32eb53 194 bool blocked = wxPyBeginBlockThreads();
d14a1e28
RD
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));
da32eb53 198 wxPyEndBlockThreads(blocked);
d14a1e28
RD
199 return tup;
200 }
201 }
202 %pythoncode {
d07d2bc9 203 asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
dd9f7fea
RD
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]
d14a1e28
RD
208 def __setitem__(self, index, val):
209 if index == 0: self.width = val
210 elif index == 1: self.height = val
211 else: raise IndexError
dd9f7fea 212 def __nonzero__(self): return self.Get() != (0,0)
02376d73
RD
213 __safe_for_unpickling__ = True
214 def __reduce__(self): return (wx.Size, self.Get())
d14a1e28
RD
215 }
216
217};
218
219//---------------------------------------------------------------------------
220%newgroup
94d33c49 221
dd9f7fea 222DocStr( wxRealPoint,
d07d2bc9
RD
223"A data structure for representing a point or position with floating
224point x and y properties. In wxPython most places that expect a
225wx.RealPoint can also accept a (x,y) tuple.", "");
d14a1e28
RD
226class wxRealPoint
227{
228public:
229 double x;
230 double y;
231
dd9f7fea
RD
232 DocCtorStr(
233 wxRealPoint(double x=0.0, double y=0.0),
d07d2bc9 234 "Create a wx.RealPoint object", "");
dd9f7fea 235
d14a1e28
RD
236 ~wxRealPoint();
237
dd9f7fea
RD
238 DocDeclStr(
239 bool, operator==(const wxRealPoint& pt),
d07d2bc9 240 "Test for equality of wx.RealPoint objects.", "");
dd9f7fea
RD
241
242 DocDeclStr(
243 bool, operator!=(const wxRealPoint& pt),
d07d2bc9 244 "Test for inequality of wx.RealPoint objects.", "");
dd9f7fea
RD
245
246
247 DocDeclStr(
248 wxRealPoint, operator+(const wxRealPoint& pt),
d07d2bc9 249 "Add pt's proprties to this and return the result.", "");
dd9f7fea
RD
250
251 DocDeclStr(
252 wxRealPoint, operator-(const wxRealPoint& pt),
d07d2bc9 253 "Subtract pt's proprties from this and return the result", "");
d14a1e28 254
d14a1e28
RD
255
256 %extend {
d07d2bc9 257 DocStr(Set, "Set both the x and y properties", "");
d14a1e28
RD
258 void Set(double x, double y) {
259 self->x = x;
260 self->y = y;
261 }
dd9f7fea
RD
262
263 DocAStr(Get,
264 "Get() -> (x,y)",
d07d2bc9 265 "Return the x and y properties as a tuple. ", "");
dd9f7fea 266 PyObject* Get() {
da32eb53 267 bool blocked = wxPyBeginBlockThreads();
d14a1e28
RD
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));
da32eb53 271 wxPyEndBlockThreads(blocked);
d14a1e28
RD
272 return tup;
273 }
274 }
275
276 %pythoncode {
d07d2bc9 277 asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
dd9f7fea
RD
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]
d14a1e28 282 def __setitem__(self, index, val):
dd9f7fea
RD
283 if index == 0: self.x = val
284 elif index == 1: self.y = val
d14a1e28 285 else: raise IndexError
dd9f7fea 286 def __nonzero__(self): return self.Get() != (0.0, 0.0)
02376d73
RD
287 __safe_for_unpickling__ = True
288 def __reduce__(self): return (wx.RealPoint, self.Get())
d14a1e28
RD
289 }
290};
291
dd9f7fea 292
d14a1e28
RD
293//---------------------------------------------------------------------------
294%newgroup
94d33c49 295
d14a1e28 296
dd9f7fea 297DocStr(wxPoint,
d07d2bc9
RD
298"A data structure for representing a point or position with integer x
299and y properties. Most places in wxPython that expect a wx.Point can
300also accept a (x,y) tuple.", "");
dd9f7fea 301
d14a1e28
RD
302class wxPoint
303{
304public:
305 int x, y;
306
dd9f7fea
RD
307 DocCtorStr(
308 wxPoint(int x=0, int y=0),
d07d2bc9 309 "Create a wx.Point object", "");
dd9f7fea 310
d14a1e28
RD
311 ~wxPoint();
312
dd9f7fea
RD
313
314 DocDeclStr(
315 bool, operator==(const wxPoint& pt),
d07d2bc9 316 "Test for equality of wx.Point objects.", "");
d14a1e28 317
dd9f7fea
RD
318 DocDeclStr(
319 bool, operator!=(const wxPoint& pt),
d07d2bc9 320 "Test for inequality of wx.Point objects.", "");
d14a1e28 321
093d613e
RD
322
323
324// %nokwargs operator+;
325// %nokwargs operator-;
326// %nokwargs operator+=;
327// %nokwargs operator-=;
dd9f7fea
RD
328
329 DocDeclStr(
330 wxPoint, operator+(const wxPoint& pt),
d07d2bc9 331 "Add pt's proprties to this and return the result.", "");
d14a1e28 332
093d613e 333
dd9f7fea
RD
334 DocDeclStr(
335 wxPoint, operator-(const wxPoint& pt),
d07d2bc9 336 "Subtract pt's proprties from this and return the result", "");
dd9f7fea
RD
337
338
339 DocDeclStr(
340 wxPoint&, operator+=(const wxPoint& pt),
d07d2bc9 341 "Add pt to this object.", "");
dd9f7fea
RD
342
343 DocDeclStr(
344 wxPoint&, operator-=(const wxPoint& pt),
d07d2bc9 345 "Subtract pt from this object.", "");
dd9f7fea 346
093d613e
RD
347
348
349// DocDeclStr(
350// wxPoint, operator+(const wxSize& sz),
d07d2bc9 351// "Add sz to this Point and return the result.", "");
093d613e
RD
352
353// DocDeclStr(
354// wxPoint, operator-(const wxSize& sz),
d07d2bc9 355// "Subtract sz from this Point and return the result", "");
093d613e
RD
356
357
358// DocDeclStr(
359// wxPoint&, operator+=(const wxSize& sz),
d07d2bc9 360// "Add sz to this object.", "");
093d613e
RD
361
362// DocDeclStr(
363// wxPoint&, operator-=(const wxSize& sz),
d07d2bc9 364// "Subtract sz from this object.", "");
093d613e
RD
365
366
367
dd9f7fea 368
d14a1e28 369 %extend {
d07d2bc9 370 DocStr(Set, "Set both the x and y properties", "");
d14a1e28
RD
371 void Set(long x, long y) {
372 self->x = x;
373 self->y = y;
374 }
dd9f7fea
RD
375
376 DocAStr(Get,
377 "Get() -> (x,y)",
d07d2bc9 378 "Return the x and y properties as a tuple. ", "");
dd9f7fea 379 PyObject* Get() {
da32eb53 380 bool blocked = wxPyBeginBlockThreads();
d14a1e28
RD
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));
da32eb53 384 wxPyEndBlockThreads(blocked);
d14a1e28
RD
385 return tup;
386 }
387 }
388
389 %pythoncode {
d07d2bc9 390 asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
dd9f7fea
RD
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]
d14a1e28
RD
395 def __setitem__(self, index, val):
396 if index == 0: self.x = val
397 elif index == 1: self.y = val
398 else: raise IndexError
dd9f7fea 399 def __nonzero__(self): return self.Get() != (0,0)
02376d73
RD
400 __safe_for_unpickling__ = True
401 def __reduce__(self): return (wx.Point, self.Get())
d14a1e28
RD
402 }
403};
404
405//---------------------------------------------------------------------------
406%newgroup
94d33c49 407
d14a1e28 408
dd9f7fea 409DocStr(wxRect,
d07d2bc9
RD
410"A class for representing and manipulating rectangles. It has x, y,
411width and height properties. In wxPython most palces that expect a
412wx.Rect can also accept a (x,y,width,height) tuple.", "");
dd9f7fea 413
d14a1e28
RD
414class wxRect
415{
416public:
dd9f7fea
RD
417 DocCtorStr(
418 wxRect(int x=0, int y=0, int width=0, int height=0),
d07d2bc9 419 "Create a new Rect object.", "");
dd9f7fea
RD
420
421 DocCtorStrName(
422 wxRect(const wxPoint& topLeft, const wxPoint& bottomRight),
d07d2bc9 423 "Create a new Rect object from Points representing two corners.", "",
dd9f7fea
RD
424 RectPP);
425
426 DocCtorStrName(
427 wxRect(const wxPoint& pos, const wxSize& size),
d07d2bc9 428 "Create a new Rect from a position and size.", "",
dd9f7fea
RD
429 RectPS);
430
d14a1e28
RD
431 ~wxRect();
432
433 int GetX() const;
434 void SetX(int x);
435
436 int GetY();
437 void SetY(int y);
438
439 int GetWidth() const;
440 void SetWidth(int w);
441
442 int GetHeight() const;
443 void SetHeight(int h);
444
445 wxPoint GetPosition() const;
446 void SetPosition( const wxPoint &p );
447
448 wxSize GetSize() const;
449 void SetSize( const wxSize &s );
450
3f0ff538
RD
451 wxPoint GetTopLeft() const;
452 void SetTopLeft(const wxPoint &p);
453 wxPoint GetBottomRight() const;
454 void SetBottomRight(const wxPoint &p);
455
456// wxPoint GetLeftTop() const;
457// void SetLeftTop(const wxPoint &p);
458// wxPoint GetRightBottom() const;
459// void SetRightBottom(const wxPoint &p);
460
d14a1e28
RD
461 int GetLeft() const;
462 int GetTop() const;
463 int GetBottom() const;
464 int GetRight() const;
465
466 void SetLeft(int left);
467 void SetRight(int right);
468 void SetTop(int top);
469 void SetBottom(int bottom);
470
dd9f7fea
RD
471 %pythoncode {
472 position = property(GetPosition, SetPosition)
473 size = property(GetSize, SetSize)
474 left = property(GetLeft, SetLeft)
475 right = property(GetRight, SetRight)
476 top = property(GetTop, SetTop)
477 bottom = property(GetBottom, SetBottom)
478 }
479
480 DocDeclStr(
481 wxRect&, Inflate(wxCoord dx, wxCoord dy),
d07d2bc9
RD
482 "Increase the rectangle size by dx in x direction and dy in y
483direction. Both or one of) parameters may be negative to decrease the
484rectangle size.", "");
dd9f7fea
RD
485
486 DocDeclStr(
487 wxRect&, Deflate(wxCoord dx, wxCoord dy),
d07d2bc9
RD
488 "Decrease the rectangle size by dx in x direction and dy in y
489direction. Both or one of) parameters may be negative to increase the
490rectngle size. This method is the opposite of Inflate.", "");
dd9f7fea
RD
491
492 DocDeclStrName(
493 void, Offset(wxCoord dx, wxCoord dy),
d07d2bc9
RD
494 "Moves the rectangle by the specified offset. If dx is positive, the
495rectangle is moved to the right, if dy is positive, it is moved to the
496bottom, otherwise it is moved to the left or top respectively.", "",
dd9f7fea
RD
497 OffsetXY);
498
499 DocDeclStr(
500 void, Offset(const wxPoint& pt),
d07d2bc9 501 "Same as OffsetXY but uses dx,dy from Point", "");
dd9f7fea
RD
502
503 DocDeclStr(
504 wxRect&, Intersect(const wxRect& rect),
d07d2bc9 505 "Return the intersectsion of this rectangle and rect.", "");
d14a1e28 506
dd9f7fea
RD
507 DocDeclStr(
508 wxRect, operator+(const wxRect& rect) const,
d07d2bc9 509 "Add the properties of rect to this rectangle and return the result.", "");
d14a1e28 510
dd9f7fea
RD
511 DocDeclStr(
512 wxRect&, operator+=(const wxRect& rect),
d07d2bc9 513 "Add the properties of rect to this rectangle, updating this rectangle.", "");
d14a1e28 514
dd9f7fea
RD
515 DocDeclStr(
516 bool, operator==(const wxRect& rect) const,
d07d2bc9 517 "Test for equality.", "");
d14a1e28 518
dd9f7fea
RD
519 DocDeclStr(
520 bool, operator!=(const wxRect& rect) const,
d07d2bc9 521 "Test for inequality.", "");
d14a1e28 522
dd9f7fea 523
d07d2bc9 524 DocStr( Inside, "Return True if the point is (not strcitly) inside the rect.", "");
d14a1e28
RD
525 %name(InsideXY)bool Inside(int x, int y) const;
526 bool Inside(const wxPoint& pt) const;
527
dd9f7fea
RD
528 DocDeclStr(
529 bool, Intersects(const wxRect& rect) const,
d07d2bc9 530 "Returns True if the rectangles have a non empty intersection.", "");
d14a1e28 531
dd9f7fea 532
d14a1e28
RD
533 int x, y, width, height;
534
535
536 %extend {
d07d2bc9 537 DocStr(Set, "Set all rectangle properties.", "");
dd9f7fea 538 void Set(int x=0, int y=0, int width=0, int height=0) {
d14a1e28
RD
539 self->x = x;
540 self->y = y;
541 self->width = width;
542 self->height = height;
543 }
544
dd9f7fea
RD
545 DocAStr(Get,
546 "Get() -> (x,y,width,height)",
d07d2bc9 547 "Return the rectangle properties as a tuple.", "");
dd9f7fea 548 PyObject* Get() {
da32eb53 549 bool blocked = wxPyBeginBlockThreads();
d14a1e28
RD
550 PyObject* tup = PyTuple_New(4);
551 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
552 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
553 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
554 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
da32eb53 555 wxPyEndBlockThreads(blocked);
d14a1e28
RD
556 return tup;
557 }
558 }
559
560 %pythoncode {
d07d2bc9 561 asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
dd9f7fea
RD
562 def __str__(self): return str(self.Get())
563 def __repr__(self): return 'wx.Rect'+str(self.Get())
564 def __len__(self): return len(self.Get())
565 def __getitem__(self, index): return self.Get()[index]
d14a1e28
RD
566 def __setitem__(self, index, val):
567 if index == 0: self.x = val
568 elif index == 1: self.y = val
569 elif index == 2: self.width = val
570 elif index == 3: self.height = val
571 else: raise IndexError
dd9f7fea 572 def __nonzero__(self): return self.Get() != (0,0,0,0)
02376d73
RD
573 __safe_for_unpickling__ = True
574 def __reduce__(self): return (wx.Rect, self.Get())
d14a1e28
RD
575 }
576};
577
578
ab1f7d2a
RD
579MustHaveApp(wxIntersectRect);
580
dd9f7fea
RD
581DocAStr(wxIntersectRect,
582 "IntersectRect(Rect r1, Rect r2) -> Rect",
d07d2bc9 583 "Calculate and return the intersection of r1 and r2.", "");
d14a1e28
RD
584%inline %{
585 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
586 wxRegion reg1(*r1);
587 wxRegion reg2(*r2);
588 wxRect dest(0,0,0,0);
589 PyObject* obj;
590
591 reg1.Intersect(reg2);
592 dest = reg1.GetBox();
593
594 if (dest != wxRect(0,0,0,0)) {
da32eb53 595 bool blocked = wxPyBeginBlockThreads();
d14a1e28 596 wxRect* newRect = new wxRect(dest);
dd9f7fea 597 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), True);
da32eb53 598 wxPyEndBlockThreads(blocked);
d14a1e28
RD
599 return obj;
600 }
601 Py_INCREF(Py_None);
602 return Py_None;
603 }
604%}
605
606//---------------------------------------------------------------------------
607%newgroup
94d33c49 608
d14a1e28 609
dd9f7fea 610DocStr(wxPoint2D,
d07d2bc9
RD
611 "wx.Point2Ds represent a point or a vector in a 2d coordinate system
612with floating point values.", "");
d14a1e28
RD
613
614class wxPoint2D
615{
dd9f7fea 616public:
d07d2bc9 617 DocStr(wxPoint2D, "Create a w.Point2D object.", "");
d14a1e28
RD
618 wxPoint2D( double x=0.0 , double y=0.0 );
619 %name(Point2DCopy) wxPoint2D( const wxPoint2D &pt );
620 %name(Point2DFromPoint) wxPoint2D( const wxPoint &pt );
621
dd9f7fea
RD
622 DocDeclAStr(
623 void, GetFloor( int *OUTPUT , int *OUTPUT ) const,
624 "GetFloor() -> (x,y)",
d07d2bc9 625 "Convert to integer", "");
dd9f7fea
RD
626
627 DocDeclAStr(
628 void, GetRounded( int *OUTPUT , int *OUTPUT ) const,
629 "GetRounded() -> (x,y)",
d07d2bc9 630 "Convert to integer", "");
d14a1e28
RD
631
632 double GetVectorLength() const;
633 double GetVectorAngle() const ;
634 void SetVectorLength( double length );
635 void SetVectorAngle( double degrees );
dd9f7fea 636
d14a1e28
RD
637 // LinkError: void SetPolarCoordinates( double angle , double length );
638 // LinkError: void Normalize();
639 %pythoncode {
640 def SetPolarCoordinates(self, angle, length):
641 self.SetVectorLength(length)
642 self.SetVectorAngle(angle)
643 def Normalize(self):
644 self.SetVectorLength(1.0)
645 }
646
647 double GetDistance( const wxPoint2D &pt ) const;
648 double GetDistanceSquare( const wxPoint2D &pt ) const;
649 double GetDotProduct( const wxPoint2D &vec ) const;
650 double GetCrossProduct( const wxPoint2D &vec ) const;
651
dd9f7fea
RD
652 DocDeclStr(
653 wxPoint2D, operator-(),
d07d2bc9 654 "the reflection of this point", "");
d14a1e28
RD
655
656 wxPoint2D& operator+=(const wxPoint2D& pt);
657 wxPoint2D& operator-=(const wxPoint2D& pt);
658
659 wxPoint2D& operator*=(const wxPoint2D& pt);
660 wxPoint2D& operator/=(const wxPoint2D& pt);
661
dd9f7fea
RD
662 DocDeclStr(
663 bool, operator==(const wxPoint2D& pt) const,
d07d2bc9 664 "Test for equality", "");
dd9f7fea
RD
665
666 DocDeclStr(
667 bool, operator!=(const wxPoint2D& pt) const,
d07d2bc9 668 "Test for inequality", "");
d14a1e28 669
d14a1e28
RD
670 %name(x)double m_x;
671 %name(y)double m_y;
672
673 %extend {
674 void Set( double x=0 , double y=0 ) {
675 self->m_x = x;
676 self->m_y = y;
677 }
dd9f7fea
RD
678
679 DocAStr(Get,
680 "Get() -> (x,y)",
d07d2bc9 681 "Return x and y properties as a tuple.", "");
dd9f7fea 682 PyObject* Get() {
da32eb53 683 bool blocked = wxPyBeginBlockThreads();
d14a1e28
RD
684 PyObject* tup = PyTuple_New(2);
685 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
686 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
da32eb53 687 wxPyEndBlockThreads(blocked);
d14a1e28
RD
688 return tup;
689 }
690 }
691
692 %pythoncode {
d07d2bc9 693 asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
dd9f7fea
RD
694 def __str__(self): return str(self.Get())
695 def __repr__(self): return 'wx.Point2D'+str(self.Get())
696 def __len__(self): return len(self.Get())
697 def __getitem__(self, index): return self.Get()[index]
d14a1e28 698 def __setitem__(self, index, val):
dd9f7fea
RD
699 if index == 0: self.x = val
700 elif index == 1: self.y = val
d14a1e28 701 else: raise IndexError
dd9f7fea 702 def __nonzero__(self): return self.Get() != (0.0, 0.0)
02376d73
RD
703 __safe_for_unpickling__ = True
704 def __reduce__(self): return (wx.Point2D, self.Get())
d14a1e28
RD
705 }
706};
707
708
709//---------------------------------------------------------------------------
710
711%immutable;
712const wxPoint wxDefaultPosition;
713const wxSize wxDefaultSize;
714%mutable;
715
716//---------------------------------------------------------------------------