]> git.saurik.com Git - wxWidgets.git/blame - wxPython/src/_gdicmn.i
Allow unicode objects in wxPyDrawTextList
[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 115"wx.Size is a useful data structure used to represent the size of
1b8c7ba6
RD
116something. It simply contians integer width and height
117proprtites. In most places in wxPython where a wx.Size is
118expected a (width, height) tuple can be used instead.", "");
dd9f7fea 119
d14a1e28
RD
120class wxSize
121{
122public:
1b8c7ba6
RD
123 %Rename(width, int, x);
124 %Rename(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 134// %extend {
a72f4631
RD
135// bool __eq__(const wxSize* other) { return other ? (*self == *other) : false; }
136// bool __ne__(const wxSize* other) { return other ? (*self != *other) : true; }
22faec7d
RD
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 429 RectPS);
7aada1e0
RD
430
431 DocCtorStrName(
432 wxRect(const wxSize& size),
433 "Create a new Rect from a size only.", "",
434 RectS);
435
d14a1e28
RD
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
3f0ff538
RD
456 wxPoint GetTopLeft() const;
457 void SetTopLeft(const wxPoint &p);
458 wxPoint GetBottomRight() const;
459 void SetBottomRight(const wxPoint &p);
460
461// wxPoint GetLeftTop() const;
462// void SetLeftTop(const wxPoint &p);
463// wxPoint GetRightBottom() const;
464// void SetRightBottom(const wxPoint &p);
465
d14a1e28
RD
466 int GetLeft() const;
467 int GetTop() const;
468 int GetBottom() const;
469 int GetRight() const;
470
471 void SetLeft(int left);
472 void SetRight(int right);
473 void SetTop(int top);
474 void SetBottom(int bottom);
475
dd9f7fea
RD
476 %pythoncode {
477 position = property(GetPosition, SetPosition)
478 size = property(GetSize, SetSize)
479 left = property(GetLeft, SetLeft)
480 right = property(GetRight, SetRight)
481 top = property(GetTop, SetTop)
482 bottom = property(GetBottom, SetBottom)
483 }
484
485 DocDeclStr(
486 wxRect&, Inflate(wxCoord dx, wxCoord dy),
d07d2bc9 487 "Increase the rectangle size by dx in x direction and dy in y
9eefe9f0 488direction. Both (or one of) parameters may be negative to decrease the
d07d2bc9 489rectangle size.", "");
dd9f7fea
RD
490
491 DocDeclStr(
492 wxRect&, Deflate(wxCoord dx, wxCoord dy),
d07d2bc9 493 "Decrease the rectangle size by dx in x direction and dy in y
9eefe9f0 494direction. Both (or one of) parameters may be negative to increase the
d07d2bc9 495rectngle size. This method is the opposite of Inflate.", "");
dd9f7fea
RD
496
497 DocDeclStrName(
498 void, Offset(wxCoord dx, wxCoord dy),
d07d2bc9
RD
499 "Moves the rectangle by the specified offset. If dx is positive, the
500rectangle is moved to the right, if dy is positive, it is moved to the
501bottom, otherwise it is moved to the left or top respectively.", "",
dd9f7fea
RD
502 OffsetXY);
503
504 DocDeclStr(
505 void, Offset(const wxPoint& pt),
d07d2bc9 506 "Same as OffsetXY but uses dx,dy from Point", "");
dd9f7fea
RD
507
508 DocDeclStr(
9eefe9f0
RD
509 wxRect, Intersect(const wxRect& rect),
510 "Returns the intersectsion of this rectangle and rect.", "");
d14a1e28 511
9eefe9f0
RD
512 DocDeclStr(
513 wxRect , Union(const wxRect& rect),
514 "Returns the union of this rectangle and rect.", "");
515
516
dd9f7fea
RD
517 DocDeclStr(
518 wxRect, operator+(const wxRect& rect) const,
d07d2bc9 519 "Add the properties of rect to this rectangle and return the result.", "");
d14a1e28 520
dd9f7fea
RD
521 DocDeclStr(
522 wxRect&, operator+=(const wxRect& rect),
d07d2bc9 523 "Add the properties of rect to this rectangle, updating this rectangle.", "");
d14a1e28 524
dd9f7fea
RD
525 DocDeclStr(
526 bool, operator==(const wxRect& rect) const,
d07d2bc9 527 "Test for equality.", "");
d14a1e28 528
dd9f7fea
RD
529 DocDeclStr(
530 bool, operator!=(const wxRect& rect) const,
d07d2bc9 531 "Test for inequality.", "");
d14a1e28 532
dd9f7fea 533
d07d2bc9 534 DocStr( Inside, "Return True if the point is (not strcitly) inside the rect.", "");
1b8c7ba6 535 %Rename(InsideXY, bool, Inside(int x, int y) const);
d14a1e28
RD
536 bool Inside(const wxPoint& pt) const;
537
dd9f7fea
RD
538 DocDeclStr(
539 bool, Intersects(const wxRect& rect) const,
d07d2bc9 540 "Returns True if the rectangles have a non empty intersection.", "");
d14a1e28 541
dd9f7fea 542
d14a1e28
RD
543 int x, y, width, height;
544
545
546 %extend {
d07d2bc9 547 DocStr(Set, "Set all rectangle properties.", "");
dd9f7fea 548 void Set(int x=0, int y=0, int width=0, int height=0) {
d14a1e28
RD
549 self->x = x;
550 self->y = y;
551 self->width = width;
552 self->height = height;
553 }
554
dd9f7fea
RD
555 DocAStr(Get,
556 "Get() -> (x,y,width,height)",
d07d2bc9 557 "Return the rectangle properties as a tuple.", "");
dd9f7fea 558 PyObject* Get() {
da32eb53 559 bool blocked = wxPyBeginBlockThreads();
d14a1e28
RD
560 PyObject* tup = PyTuple_New(4);
561 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
562 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
563 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
564 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
da32eb53 565 wxPyEndBlockThreads(blocked);
d14a1e28
RD
566 return tup;
567 }
568 }
569
570 %pythoncode {
d07d2bc9 571 asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
dd9f7fea
RD
572 def __str__(self): return str(self.Get())
573 def __repr__(self): return 'wx.Rect'+str(self.Get())
574 def __len__(self): return len(self.Get())
575 def __getitem__(self, index): return self.Get()[index]
d14a1e28
RD
576 def __setitem__(self, index, val):
577 if index == 0: self.x = val
578 elif index == 1: self.y = val
579 elif index == 2: self.width = val
580 elif index == 3: self.height = val
581 else: raise IndexError
dd9f7fea 582 def __nonzero__(self): return self.Get() != (0,0,0,0)
02376d73
RD
583 __safe_for_unpickling__ = True
584 def __reduce__(self): return (wx.Rect, self.Get())
d14a1e28
RD
585 }
586};
587
588
ab1f7d2a
RD
589MustHaveApp(wxIntersectRect);
590
dd9f7fea
RD
591DocAStr(wxIntersectRect,
592 "IntersectRect(Rect r1, Rect r2) -> Rect",
d07d2bc9 593 "Calculate and return the intersection of r1 and r2.", "");
d14a1e28
RD
594%inline %{
595 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
596 wxRegion reg1(*r1);
597 wxRegion reg2(*r2);
598 wxRect dest(0,0,0,0);
599 PyObject* obj;
600
601 reg1.Intersect(reg2);
602 dest = reg1.GetBox();
603
604 if (dest != wxRect(0,0,0,0)) {
da32eb53 605 bool blocked = wxPyBeginBlockThreads();
d14a1e28 606 wxRect* newRect = new wxRect(dest);
a72f4631 607 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
da32eb53 608 wxPyEndBlockThreads(blocked);
d14a1e28
RD
609 return obj;
610 }
611 Py_INCREF(Py_None);
612 return Py_None;
613 }
614%}
615
616//---------------------------------------------------------------------------
617%newgroup
94d33c49 618
d14a1e28 619
dd9f7fea 620DocStr(wxPoint2D,
d07d2bc9
RD
621 "wx.Point2Ds represent a point or a vector in a 2d coordinate system
622with floating point values.", "");
d14a1e28
RD
623
624class wxPoint2D
625{
dd9f7fea 626public:
d07d2bc9 627 DocStr(wxPoint2D, "Create a w.Point2D object.", "");
d14a1e28 628 wxPoint2D( double x=0.0 , double y=0.0 );
1b8c7ba6
RD
629 %RenameCtor(Point2DCopy, wxPoint2D( const wxPoint2D &pt ));
630 %RenameCtor(Point2DFromPoint, wxPoint2D( const wxPoint &pt ));
d14a1e28 631
dd9f7fea
RD
632 DocDeclAStr(
633 void, GetFloor( int *OUTPUT , int *OUTPUT ) const,
634 "GetFloor() -> (x,y)",
d07d2bc9 635 "Convert to integer", "");
dd9f7fea
RD
636
637 DocDeclAStr(
638 void, GetRounded( int *OUTPUT , int *OUTPUT ) const,
639 "GetRounded() -> (x,y)",
d07d2bc9 640 "Convert to integer", "");
d14a1e28
RD
641
642 double GetVectorLength() const;
643 double GetVectorAngle() const ;
644 void SetVectorLength( double length );
645 void SetVectorAngle( double degrees );
dd9f7fea 646
d14a1e28
RD
647 // LinkError: void SetPolarCoordinates( double angle , double length );
648 // LinkError: void Normalize();
649 %pythoncode {
650 def SetPolarCoordinates(self, angle, length):
651 self.SetVectorLength(length)
652 self.SetVectorAngle(angle)
653 def Normalize(self):
654 self.SetVectorLength(1.0)
655 }
656
657 double GetDistance( const wxPoint2D &pt ) const;
658 double GetDistanceSquare( const wxPoint2D &pt ) const;
659 double GetDotProduct( const wxPoint2D &vec ) const;
660 double GetCrossProduct( const wxPoint2D &vec ) const;
661
dd9f7fea
RD
662 DocDeclStr(
663 wxPoint2D, operator-(),
d07d2bc9 664 "the reflection of this point", "");
d14a1e28
RD
665
666 wxPoint2D& operator+=(const wxPoint2D& pt);
667 wxPoint2D& operator-=(const wxPoint2D& pt);
668
669 wxPoint2D& operator*=(const wxPoint2D& pt);
670 wxPoint2D& operator/=(const wxPoint2D& pt);
671
dd9f7fea
RD
672 DocDeclStr(
673 bool, operator==(const wxPoint2D& pt) const,
d07d2bc9 674 "Test for equality", "");
dd9f7fea
RD
675
676 DocDeclStr(
677 bool, operator!=(const wxPoint2D& pt) const,
d07d2bc9 678 "Test for inequality", "");
d14a1e28 679
1b8c7ba6
RD
680 %Rename(x, double, m_x);
681 %Rename(y, double, m_y);
d14a1e28
RD
682
683 %extend {
684 void Set( double x=0 , double y=0 ) {
685 self->m_x = x;
686 self->m_y = y;
687 }
dd9f7fea
RD
688
689 DocAStr(Get,
690 "Get() -> (x,y)",
d07d2bc9 691 "Return x and y properties as a tuple.", "");
dd9f7fea 692 PyObject* Get() {
da32eb53 693 bool blocked = wxPyBeginBlockThreads();
d14a1e28
RD
694 PyObject* tup = PyTuple_New(2);
695 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
696 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
da32eb53 697 wxPyEndBlockThreads(blocked);
d14a1e28
RD
698 return tup;
699 }
700 }
701
702 %pythoncode {
d07d2bc9 703 asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
dd9f7fea
RD
704 def __str__(self): return str(self.Get())
705 def __repr__(self): return 'wx.Point2D'+str(self.Get())
706 def __len__(self): return len(self.Get())
707 def __getitem__(self, index): return self.Get()[index]
d14a1e28 708 def __setitem__(self, index, val):
dd9f7fea
RD
709 if index == 0: self.x = val
710 elif index == 1: self.y = val
d14a1e28 711 else: raise IndexError
dd9f7fea 712 def __nonzero__(self): return self.Get() != (0.0, 0.0)
02376d73
RD
713 __safe_for_unpickling__ = True
714 def __reduce__(self): return (wx.Point2D, self.Get())
d14a1e28
RD
715 }
716};
717
718
719//---------------------------------------------------------------------------
720
721%immutable;
722const wxPoint wxDefaultPosition;
723const wxSize wxDefaultSize;
724%mutable;
725
726//---------------------------------------------------------------------------