]> git.saurik.com Git - wxWidgets.git/blob - include/wx/geometry.h
Made widgets sample take up less space
[wxWidgets.git] / include / wx / geometry.h
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: wx/geometry.h
3 // Purpose: Common Geometry Classes
4 // Author: Stefan Csomor
5 // Modified by:
6 // Created: 08/05/99
7 // RCS-ID:
8 // Copyright: (c) 1999 Stefan Csomor
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifndef _WX_GEOMETRY_H_
13 #define _WX_GEOMETRY_H_
14
15 #ifdef __GNUG__
16 #pragma interface "geometry.cpp"
17 #endif
18
19 #include "wx/defs.h"
20
21 #ifndef wxUSE_GEOMETRY
22 #define wxUSE_GEOMETRY 0
23 #endif
24
25 #if wxUSE_GEOMETRY
26
27 #include "wx/utils.h"
28 #include "wx/gdicmn.h"
29 #include <math.h>
30
31 #ifdef __WXMSW__
32 #define wxMulDivInt32( a , b , c ) ::MulDiv( a , b , c )
33 #elif defined( __WXMAC__ )
34 #define wxMulDivInt32( a , b , c ) ( (wxInt32) ( ( (wxInt64)(a) * (wxInt64)(b) ) / (wxInt64)(c) ) )
35 #else
36 #define wxMulDivInt32( a , b , c ) ((wxInt32)((a)*(((wxDouble)b)/((wxDouble)c))))
37 #endif
38
39 class wxDataInputStream;
40 class wxDataOutputStream;
41
42 // clipping from Cohen-Sutherland
43
44 enum wxOutCode
45 {
46 wxInside = 0x00 ,
47 wxOutLeft = 0x01 ,
48 wxOutRight = 0x02 ,
49 wxOutTop = 0x08 ,
50 wxOutBottom = 0x04
51 };
52
53 class WXDLLEXPORT wxPoint2DInt
54 {
55 public :
56 inline wxPoint2DInt();
57 inline wxPoint2DInt( wxInt32 x , wxInt32 y );
58 inline wxPoint2DInt( const wxPoint2DInt &pt );
59 inline wxPoint2DInt( const wxPoint &pt );
60
61 // noops for this class, just return the coords
62 inline void GetFloor( wxInt32 *x , wxInt32 *y );
63 inline void GetRounded( wxInt32 *x , wxInt32 *y );
64
65 inline wxDouble GetVectorLength();
66 wxDouble GetVectorAngle();
67 inline void SetVectorLength( wxDouble length );
68 void SetVectorAngle( wxDouble degrees );
69 void SetPolarCoordinates( wxInt32 angle , wxInt32 length );
70 // set the vector length to 1.0, preserving the angle
71 inline void Normalize();
72
73 inline wxDouble GetDistance( const wxPoint2DInt &pt ) const;
74 inline wxDouble GetDistanceSquare( const wxPoint2DInt &pt ) const;
75 inline wxInt32 GetDotProduct( const wxPoint2DInt &vec ) const;
76 inline wxInt32 GetCrossProduct( const wxPoint2DInt &vec ) const;
77
78 // the reflection of this point
79 inline wxPoint2DInt operator-();
80
81 inline wxPoint2DInt& operator=(const wxPoint2DInt& pt);
82 inline wxPoint2DInt& operator+=(const wxPoint2DInt& pt);
83 inline wxPoint2DInt& operator-=(const wxPoint2DInt& pt);
84 inline wxPoint2DInt& operator*=(const wxPoint2DInt& pt);
85 inline wxPoint2DInt& operator*=(wxDouble n);
86 inline wxPoint2DInt& operator*=(wxInt32 n);
87 inline wxPoint2DInt& operator/=(const wxPoint2DInt& pt);
88 inline wxPoint2DInt& operator/=(wxDouble n);
89 inline wxPoint2DInt& operator/=(wxInt32 n);
90 inline operator wxPoint() const;
91 inline bool operator==(const wxPoint2DInt& pt) const;
92 inline bool operator!=(const wxPoint2DInt& pt) const;
93
94 void WriteTo( wxDataOutputStream &stream ) const;
95 void ReadFrom( wxDataInputStream &stream );
96
97 wxInt32 m_x;
98 wxInt32 m_y;
99 };
100
101 inline wxPoint2DInt operator+(const wxPoint2DInt& pt1 , const wxPoint2DInt& pt2);
102 inline wxPoint2DInt operator-(const wxPoint2DInt& pt1 , const wxPoint2DInt& pt2);
103 inline wxPoint2DInt operator*(const wxPoint2DInt& pt1 , const wxPoint2DInt& pt2);
104 inline wxPoint2DInt operator*(wxInt32 n , const wxPoint2DInt& pt);
105 inline wxPoint2DInt operator*(wxInt32 n , const wxPoint2DInt& pt);
106 inline wxPoint2DInt operator*(const wxPoint2DInt& pt , wxInt32 n);
107 inline wxPoint2DInt operator*(const wxPoint2DInt& pt , wxInt32 n);
108 inline wxPoint2DInt operator/(const wxPoint2DInt& pt1 , const wxPoint2DInt& pt2);
109 inline wxPoint2DInt operator/(const wxPoint2DInt& pt , wxInt32 n);
110 inline wxPoint2DInt operator/(const wxPoint2DInt& pt , wxInt32 n);
111
112 inline wxPoint2DInt::wxPoint2DInt()
113 {
114 m_x = 0;
115 m_y = 0;
116 }
117
118 inline wxPoint2DInt::wxPoint2DInt( wxInt32 x , wxInt32 y )
119 {
120 m_x = x;
121 m_y = y;
122 }
123
124 inline wxPoint2DInt::wxPoint2DInt( const wxPoint2DInt &pt )
125 {
126 m_x = pt.m_x;
127 m_y = pt.m_y;
128 }
129
130 inline wxPoint2DInt::wxPoint2DInt( const wxPoint &pt )
131 {
132 m_x = pt.x;
133 m_y = pt.y;
134 }
135
136 inline void wxPoint2DInt::GetFloor( wxInt32 *x , wxInt32 *y )
137 {
138 if ( x )
139 *x = m_x;
140 if ( y )
141 *y = m_y;
142 }
143
144 inline void wxPoint2DInt::GetRounded( wxInt32 *x , wxInt32 *y )
145 {
146 GetFloor(x, y);
147 }
148
149 inline wxDouble wxPoint2DInt::GetVectorLength()
150 {
151 // cast needed MIPSpro compiler under SGI
152 return sqrt( (double)(m_x)*(m_x) + (m_y)*(m_y) );
153 }
154
155 inline void wxPoint2DInt::SetVectorLength( wxDouble length )
156 {
157 wxDouble before = GetVectorLength();
158 m_x = (wxInt32)(m_x * length / before);
159 m_y = (wxInt32)(m_y * length / before);
160 }
161
162 inline void wxPoint2DInt::Normalize()
163 {
164 SetVectorLength( 1 );
165 }
166
167 inline wxDouble wxPoint2DInt::GetDistance( const wxPoint2DInt &pt ) const
168 {
169 return sqrt( GetDistanceSquare( pt ) );
170 }
171
172 inline wxDouble wxPoint2DInt::GetDistanceSquare( const wxPoint2DInt &pt ) const
173 {
174 return ( (pt.m_x-m_x)*(pt.m_x-m_x) + (pt.m_y-m_y)*(pt.m_y-m_y) );
175 }
176
177 inline wxInt32 wxPoint2DInt::GetDotProduct( const wxPoint2DInt &vec ) const
178 {
179 return ( m_x * vec.m_x + m_y * vec.m_y );
180 }
181
182 inline wxInt32 wxPoint2DInt::GetCrossProduct( const wxPoint2DInt &vec ) const
183 {
184 return ( m_x * vec.m_y - vec.m_x * m_y );
185 }
186
187 inline wxPoint2DInt::operator wxPoint() const
188 {
189 return wxPoint( m_x, m_y);
190 }
191
192 inline wxPoint2DInt wxPoint2DInt::operator-()
193 {
194 return wxPoint2DInt( -m_x, -m_y);
195 }
196
197 inline wxPoint2DInt& wxPoint2DInt::operator=(const wxPoint2DInt& pt)
198 {
199 m_x = pt.m_x;
200 m_y = pt.m_y;
201 return *this;
202 }
203
204 inline wxPoint2DInt& wxPoint2DInt::operator+=(const wxPoint2DInt& pt)
205 {
206 m_x = m_x + pt.m_x;
207 m_y = m_y + pt.m_y;
208 return *this;
209 }
210
211 inline wxPoint2DInt& wxPoint2DInt::operator-=(const wxPoint2DInt& pt)
212 {
213 m_x = m_x - pt.m_x;
214 m_y = m_y - pt.m_y;
215 return *this;
216 }
217
218 inline wxPoint2DInt& wxPoint2DInt::operator*=(const wxPoint2DInt& pt)
219 {
220 m_x = m_x + pt.m_x;
221 m_y = m_y + pt.m_y;
222 return *this;
223 }
224
225 inline wxPoint2DInt& wxPoint2DInt::operator/=(const wxPoint2DInt& pt)
226 {
227 m_x = m_x - pt.m_x;
228 m_y = m_y - pt.m_y;
229 return *this;
230 }
231
232 inline bool wxPoint2DInt::operator==(const wxPoint2DInt& pt) const
233 {
234 return m_x == pt.m_x && m_y == pt.m_y;
235 }
236
237 inline bool wxPoint2DInt::operator!=(const wxPoint2DInt& pt) const
238 {
239 return m_x != pt.m_x || m_y != pt.m_y;
240 }
241
242 inline wxPoint2DInt operator+(const wxPoint2DInt& pt1 , const wxPoint2DInt& pt2)
243 {
244 return wxPoint2DInt( pt1.m_x + pt2.m_x , pt1.m_y + pt2.m_y );
245 }
246
247 inline wxPoint2DInt operator-(const wxPoint2DInt& pt1 , const wxPoint2DInt& pt2)
248 {
249 return wxPoint2DInt( pt1.m_x - pt2.m_x , pt1.m_y - pt2.m_y );
250 }
251
252
253 inline wxPoint2DInt operator*(const wxPoint2DInt& pt1 , const wxPoint2DInt& pt2)
254 {
255 return wxPoint2DInt( pt1.m_x * pt2.m_x , pt1.m_y * pt2.m_y );
256 }
257
258 inline wxPoint2DInt operator*(wxInt32 n , const wxPoint2DInt& pt)
259 {
260 return wxPoint2DInt( pt.m_x * n , pt.m_y * n );
261 }
262
263 inline wxPoint2DInt operator*(wxDouble n , const wxPoint2DInt& pt)
264 {
265 return wxPoint2DInt( (int) (pt.m_x * n) , (int) (pt.m_y * n) );
266 }
267
268 inline wxPoint2DInt operator*(const wxPoint2DInt& pt , wxInt32 n)
269 {
270 return wxPoint2DInt( pt.m_x * n , pt.m_y * n );
271 }
272
273 inline wxPoint2DInt operator*(const wxPoint2DInt& pt , wxDouble n)
274 {
275 return wxPoint2DInt( (int) (pt.m_x * n) , (int) (pt.m_y * n) );
276 }
277
278 inline wxPoint2DInt operator/(const wxPoint2DInt& pt1 , const wxPoint2DInt& pt2)
279 {
280 return wxPoint2DInt( pt1.m_x / pt2.m_x , pt1.m_y / pt2.m_y );
281 }
282
283 inline wxPoint2DInt operator/(const wxPoint2DInt& pt , wxInt32 n)
284 {
285 return wxPoint2DInt( pt.m_x / n , pt.m_y / n );
286 }
287
288 inline wxPoint2DInt operator/(const wxPoint2DInt& pt , wxDouble n)
289 {
290 return wxPoint2DInt( (int) (pt.m_x / n) , (int) (pt.m_y / n) );
291 }
292
293 // wxPoint2Ds represent a point or a vector in a 2d coordinate system
294
295 class WXDLLEXPORT wxPoint2DDouble
296 {
297 public :
298 inline wxPoint2DDouble();
299 inline wxPoint2DDouble( wxDouble x , wxDouble y );
300 inline wxPoint2DDouble( const wxPoint2DDouble &pt );
301 wxPoint2DDouble( const wxPoint2DInt &pt )
302 { m_x = (wxDouble) pt.m_x ; m_y = (wxDouble) pt.m_y ; }
303 wxPoint2DDouble( const wxPoint &pt )
304 { m_x = (wxDouble) pt.x ; m_y = (wxDouble) pt.y ; }
305
306 // two different conversions to integers, floor and rounding
307 inline void GetFloor( wxInt32 *x , wxInt32 *y );
308 inline void GetRounded( wxInt32 *x , wxInt32 *y );
309
310 inline wxDouble GetVectorLength() const;
311 wxDouble GetVectorAngle() const ;
312 void SetVectorLength( wxDouble length );
313 void SetVectorAngle( wxDouble degrees );
314 void SetPolarCoordinates( wxDouble angle , wxDouble length );
315 // set the vector length to 1.0, preserving the angle
316 void Normalize();
317
318 inline wxDouble GetDistance( const wxPoint2DDouble &pt );
319 inline wxDouble GetDistanceSquare( const wxPoint2DDouble &pt );
320 inline wxDouble GetDotProduct( const wxPoint2DDouble &vec );
321 inline wxDouble GetCrossProduct( const wxPoint2DDouble &vec );
322
323 // the reflection of this point
324 inline wxPoint2DDouble operator-();
325
326 inline wxPoint2DDouble& operator=(const wxPoint2DDouble& pt);
327 inline wxPoint2DDouble& operator+=(const wxPoint2DDouble& pt);
328 inline wxPoint2DDouble& operator-=(const wxPoint2DDouble& pt);
329 inline wxPoint2DDouble& operator*=(const wxPoint2DDouble& pt);
330 inline wxPoint2DDouble& operator*=(wxDouble n);
331 inline wxPoint2DDouble& operator*=(wxInt32 n);
332 inline wxPoint2DDouble& operator/=(const wxPoint2DDouble& pt);
333 inline wxPoint2DDouble& operator/=(wxDouble n);
334 inline wxPoint2DDouble& operator/=(wxInt32 n);
335
336 inline bool operator==(const wxPoint2DDouble& pt) const;
337 inline bool operator!=(const wxPoint2DDouble& pt) const;
338
339 wxDouble m_x;
340 wxDouble m_y;
341 };
342
343 inline wxPoint2DDouble operator+(const wxPoint2DDouble& pt1 , const wxPoint2DDouble& pt2);
344 inline wxPoint2DDouble operator-(const wxPoint2DDouble& pt1 , const wxPoint2DDouble& pt2);
345 inline wxPoint2DDouble operator*(const wxPoint2DDouble& pt1 , const wxPoint2DDouble& pt2);
346 inline wxPoint2DDouble operator*(wxDouble n , const wxPoint2DDouble& pt);
347 inline wxPoint2DDouble operator*(wxInt32 n , const wxPoint2DDouble& pt);
348 inline wxPoint2DDouble operator*(const wxPoint2DDouble& pt , wxDouble n);
349 inline wxPoint2DDouble operator*(const wxPoint2DDouble& pt , wxInt32 n);
350 inline wxPoint2DDouble operator/(const wxPoint2DDouble& pt1 , const wxPoint2DDouble& pt2);
351 inline wxPoint2DDouble operator/(const wxPoint2DDouble& pt , wxDouble n);
352 inline wxPoint2DDouble operator/(const wxPoint2DDouble& pt , wxInt32 n);
353
354 inline wxPoint2DDouble::wxPoint2DDouble()
355 {
356 m_x = 0.0;
357 m_y = 0.0;
358 }
359
360 inline wxPoint2DDouble::wxPoint2DDouble( wxDouble x , wxDouble y )
361 {
362 m_x = x;
363 m_y = y;
364 }
365
366 inline wxPoint2DDouble::wxPoint2DDouble( const wxPoint2DDouble &pt )
367 {
368 m_x = pt.m_x;
369 m_y = pt.m_y;
370 }
371
372 inline void wxPoint2DDouble::GetFloor( wxInt32 *x , wxInt32 *y )
373 {
374 *x = (wxInt32) floor( m_x );
375 *y = (wxInt32) floor( m_y );
376 }
377
378 inline void wxPoint2DDouble::GetRounded( wxInt32 *x , wxInt32 *y )
379 {
380 *x = (wxInt32) floor( m_x + 0.5 );
381 *y = (wxInt32) floor( m_y + 0.5);
382 }
383
384 inline wxDouble wxPoint2DDouble::GetVectorLength() const
385 {
386 return sqrt( (m_x)*(m_x) + (m_y)*(m_y) ) ;
387 }
388
389 inline void wxPoint2DDouble::SetVectorLength( wxDouble length )
390 {
391 wxDouble before = GetVectorLength() ;
392 m_x = (m_x * length / before) ;
393 m_y = (m_y * length / before) ;
394 }
395
396 inline wxDouble wxPoint2DDouble::GetDistance( const wxPoint2DDouble &pt )
397 {
398 return sqrt( GetDistanceSquare( pt ) );
399 }
400
401 inline wxDouble wxPoint2DDouble::GetDistanceSquare( const wxPoint2DDouble &pt )
402 {
403 return ( (pt.m_x-m_x)*(pt.m_x-m_x) + (pt.m_y-m_y)*(pt.m_y-m_y) );
404 }
405
406 inline wxDouble wxPoint2DDouble::GetDotProduct( const wxPoint2DDouble &vec )
407 {
408 return ( m_x * vec.m_x + m_y * vec.m_y );
409 }
410
411 inline wxDouble wxPoint2DDouble::GetCrossProduct( const wxPoint2DDouble &vec )
412 {
413 return ( m_x * vec.m_y - vec.m_x * m_y );
414 }
415
416 inline wxPoint2DDouble wxPoint2DDouble::operator-()
417 {
418 return wxPoint2DDouble( -m_x, -m_y);
419 }
420
421 inline wxPoint2DDouble& wxPoint2DDouble::operator=(const wxPoint2DDouble& pt)
422 {
423 m_x = pt.m_x;
424 m_y = pt.m_y;
425 return *this;
426 }
427
428 inline wxPoint2DDouble& wxPoint2DDouble::operator+=(const wxPoint2DDouble& pt)
429 {
430 m_x = m_x + pt.m_x;
431 m_y = m_y + pt.m_y;
432 return *this;
433 }
434
435 inline wxPoint2DDouble& wxPoint2DDouble::operator-=(const wxPoint2DDouble& pt)
436 {
437 m_x = m_x - pt.m_x;
438 m_y = m_y - pt.m_y;
439 return *this;
440 }
441
442 inline wxPoint2DDouble& wxPoint2DDouble::operator*=(const wxPoint2DDouble& pt)
443 {
444 m_x = m_x * pt.m_x;
445 m_y = m_y * pt.m_y;
446 return *this;
447 }
448
449 inline wxPoint2DDouble& wxPoint2DDouble::operator/=(const wxPoint2DDouble& pt)
450 {
451 m_x = m_x / pt.m_x;
452 m_y = m_y / pt.m_y;
453 return *this;
454 }
455
456 inline bool wxPoint2DDouble::operator==(const wxPoint2DDouble& pt) const
457 {
458 return m_x == pt.m_x && m_y == pt.m_y;
459 }
460
461 inline bool wxPoint2DDouble::operator!=(const wxPoint2DDouble& pt) const
462 {
463 return m_x != pt.m_x || m_y != pt.m_y;
464 }
465
466 inline wxPoint2DDouble operator+(const wxPoint2DDouble& pt1 , const wxPoint2DDouble& pt2)
467 {
468 return wxPoint2DDouble( pt1.m_x + pt2.m_x , pt1.m_y + pt2.m_y );
469 }
470
471 inline wxPoint2DDouble operator-(const wxPoint2DDouble& pt1 , const wxPoint2DDouble& pt2)
472 {
473 return wxPoint2DDouble( pt1.m_x - pt2.m_x , pt1.m_y - pt2.m_y );
474 }
475
476
477 inline wxPoint2DDouble operator*(const wxPoint2DDouble& pt1 , const wxPoint2DDouble& pt2)
478 {
479 return wxPoint2DDouble( pt1.m_x * pt2.m_x , pt1.m_y * pt2.m_y );
480 }
481
482 inline wxPoint2DDouble operator*(wxDouble n , const wxPoint2DDouble& pt)
483 {
484 return wxPoint2DDouble( pt.m_x * n , pt.m_y * n );
485 }
486
487 inline wxPoint2DDouble operator*(wxInt32 n , const wxPoint2DDouble& pt)
488 {
489 return wxPoint2DDouble( pt.m_x * n , pt.m_y * n );
490 }
491
492 inline wxPoint2DDouble operator*(const wxPoint2DDouble& pt , wxDouble n)
493 {
494 return wxPoint2DDouble( pt.m_x * n , pt.m_y * n );
495 }
496
497 inline wxPoint2DDouble operator*(const wxPoint2DDouble& pt , wxInt32 n)
498 {
499 return wxPoint2DDouble( pt.m_x * n , pt.m_y * n );
500 }
501
502 inline wxPoint2DDouble operator/(const wxPoint2DDouble& pt1 , const wxPoint2DDouble& pt2)
503 {
504 return wxPoint2DDouble( pt1.m_x / pt2.m_x , pt1.m_y / pt2.m_y );
505 }
506
507 inline wxPoint2DDouble operator/(const wxPoint2DDouble& pt , wxDouble n)
508 {
509 return wxPoint2DDouble( pt.m_x / n , pt.m_y / n );
510 }
511
512 inline wxPoint2DDouble operator/(const wxPoint2DDouble& pt , wxInt32 n)
513 {
514 return wxPoint2DDouble( pt.m_x / n , pt.m_y / n );
515 }
516
517 // wxRect2Ds are a axis-aligned rectangles, each side of the rect is parallel to the x- or m_y- axis. The rectangle is either defined by the
518 // top left and bottom right corner, or by the top left corner and size. A point is contained within the rectangle if
519 // left <= x < right and top <= m_y < bottom , thus it is a half open interval.
520
521 class WXDLLEXPORT wxRect2DDouble
522 {
523 public:
524 wxRect2DDouble()
525 { m_x = m_y = m_width = m_height = 0; }
526 wxRect2DDouble(wxDouble x, wxDouble y, wxDouble w, wxDouble h)
527 { m_x = x; m_y = y; m_width = w; m_height = h; }
528 /*
529 wxRect2DDouble(const wxPoint2DDouble& topLeft, const wxPoint2DDouble& bottomRight);
530 wxRect2DDouble(const wxPoint2DDouble& pos, const wxSize& size);
531 wxRect2DDouble(const wxRect2DDouble& rect);
532 */
533 // single attribute accessors
534
535 inline wxPoint2DDouble GetPosition()
536 { return wxPoint2DDouble(m_x, m_y); }
537 inline wxSize GetSize()
538 { return wxSize((int) m_width, (int) m_height); }
539
540 // for the edge and corner accessors there are two setters conterparts, the Set.. functions keep the other corners at their
541 // position whenever sensible, the Move.. functions keep the size of the rect and move the other corners apropriately
542
543 inline wxDouble GetLeft() const { return m_x; }
544 inline void SetLeft( wxDouble n ) { m_width += m_x - n; m_x = n; }
545 inline void MoveLeftTo( wxDouble n ) { m_x = n; }
546 inline wxDouble GetTop() const { return m_y; }
547 inline void SetTop( wxDouble n ) { m_height += m_y - n; m_y = n; }
548 inline void MoveTopTo( wxDouble n ) { m_y = n; }
549 inline wxDouble GetBottom() const { return m_y + m_height; }
550 inline void SetBottom( wxDouble n ) { m_height += n - (m_y+m_height);}
551 inline void MoveBottomTo( wxDouble n ) { m_y = n - m_height; }
552 inline wxDouble GetRight() const { return m_x + m_width; }
553 inline void SetRight( wxDouble n ) { m_width += n - (m_x+m_width) ; }
554 inline void MoveRightTo( wxDouble n ) { m_x = n - m_width; }
555
556 inline wxPoint2DDouble GetLeftTop() const
557 { return wxPoint2DDouble( m_x , m_y ); }
558 inline void SetLeftTop( const wxPoint2DDouble &pt )
559 { m_width += m_x - pt.m_x; m_height += m_y - pt.m_y; m_x = pt.m_x; m_y = pt.m_y; }
560 inline void MoveLeftTopTo( const wxPoint2DDouble &pt )
561 { m_x = pt.m_x; m_y = pt.m_y; }
562 inline wxPoint2DDouble GetLeftBottom() const
563 { return wxPoint2DDouble( m_x , m_y + m_height ); }
564 inline void SetLeftBottom( const wxPoint2DDouble &pt )
565 { m_width += m_x - pt.m_x; m_height += pt.m_y - (m_y+m_height) ; m_x = pt.m_x; }
566 inline void MoveLeftBottomTo( const wxPoint2DDouble &pt )
567 { m_x = pt.m_x; m_y = pt.m_y - m_height; }
568 inline wxPoint2DDouble GetRightTop() const
569 { return wxPoint2DDouble( m_x+m_width , m_y ); }
570 inline void SetRightTop( const wxPoint2DDouble &pt )
571 { m_width += pt.m_x - ( m_x + m_width ); m_height += m_y - pt.m_y; m_y = pt.m_y; }
572 inline void MoveRightTopTo( const wxPoint2DDouble &pt )
573 { m_x = pt.m_x - m_width; m_y = pt.m_y; }
574 inline wxPoint2DDouble GetRightBottom() const
575 { return wxPoint2DDouble( m_x+m_width , m_y + m_height ); }
576 inline void SetRightBottom( const wxPoint2DDouble &pt )
577 { m_width += pt.m_x - ( m_x + m_width ); m_height += pt.m_y - (m_y+m_height);}
578 inline void MoveRightBottomTo( const wxPoint2DDouble &pt )
579 { m_x = pt.m_x - m_width; m_y = pt.m_y - m_height; }
580 inline wxPoint2DDouble GetCentre() const
581 { return wxPoint2DDouble( m_x+m_width/2 , m_y+m_height/2 ); }
582 inline void SetCentre( const wxPoint2DDouble &pt )
583 { MoveCentreTo( pt ); } // since this is impossible without moving...
584 inline void MoveCentreTo( const wxPoint2DDouble &pt )
585 { m_x += pt.m_x - (m_x+m_width/2) , m_y += pt.m_y -(m_y+m_height/2); }
586 inline wxOutCode GetOutcode( const wxPoint2DDouble &pt ) const
587 { return (wxOutCode) (( ( pt.m_x < m_x ) ? wxOutLeft : 0 ) +
588 ( ( pt.m_x >= m_x + m_width ) ? wxOutRight : 0 ) +
589 ( ( pt.m_y < m_y ) ? wxOutTop : 0 ) +
590 ( ( pt.m_y >= m_y + m_height ) ? wxOutBottom : 0 )); }
591 inline bool Contains( const wxPoint2DDouble &pt ) const
592 { return GetOutcode( pt ) == wxInside; }
593 inline bool Contains( const wxRect2DDouble &rect ) const
594 { return ( ( ( m_x <= rect.m_x ) && ( rect.m_x + rect.m_width <= m_x + m_width ) ) &&
595 ( ( m_y <= rect.m_y ) && ( rect.m_y + rect.m_height <= m_y + m_height ) ) ); }
596 inline bool IsEmpty() const
597 { return ( m_width <= 0 || m_height <= 0 ); }
598 inline bool HaveEqualSize( const wxRect2DDouble &rect ) const
599 { return ( rect.m_width == m_width && rect.m_height == m_height ); }
600
601 inline void Inset( wxDouble x , wxDouble y )
602 { m_x += x; m_y += y; m_width -= 2 * x; m_height -= 2 * y; }
603 inline void Inset( wxDouble left , wxDouble top ,wxDouble right , wxDouble bottom )
604 { m_x += left; m_y += top; m_width -= left + right; m_height -= top + bottom;}
605 inline void Offset( const wxPoint2DDouble &pt )
606 { m_x += pt.m_x; m_y += pt.m_y; }
607
608 void ConstrainTo( const wxRect2DDouble &rect );
609
610 inline wxPoint2DDouble Interpolate( wxInt32 widthfactor , wxInt32 heightfactor )
611 { return wxPoint2DDouble( m_x + m_width * widthfactor , m_y + m_height * heightfactor ); }
612
613 static void Intersect( const wxRect2DDouble &src1 , const wxRect2DDouble &src2 , wxRect2DDouble *dest );
614 inline void Intersect( const wxRect2DDouble &otherRect )
615 { Intersect( *this , otherRect , this ); }
616 inline wxRect2DDouble CreateIntersection( const wxRect2DDouble &otherRect ) const
617 { wxRect2DDouble result; Intersect( *this , otherRect , &result); return result; }
618 bool Intersects( const wxRect2DDouble &rect ) const;
619
620 static void Union( const wxRect2DDouble &src1 , const wxRect2DDouble &src2 , wxRect2DDouble *dest );
621 void Union( const wxRect2DDouble &otherRect )
622 { Union( *this , otherRect , this ); }
623 void Union( const wxPoint2DDouble &pt );
624 inline wxRect2DDouble CreateUnion( const wxRect2DDouble &otherRect ) const
625 { wxRect2DDouble result; Union( *this , otherRect , &result); return result; }
626
627 inline void Scale( wxDouble f )
628 { m_x *= f; m_y *= f; m_width *= f; m_height *= f;}
629 inline void Scale( wxInt32 num , wxInt32 denum )
630 { m_x *= ((wxDouble)num)/((wxDouble)denum); m_y *= ((wxDouble)num)/((wxDouble)denum);
631 m_width *= ((wxDouble)num)/((wxDouble)denum); m_height *= ((wxDouble)num)/((wxDouble)denum);}
632
633 /*
634 wxRect2DDouble& operator = (const wxRect2DDouble& rect);
635 bool operator == (const wxRect2DDouble& rect);
636 bool operator != (const wxRect2DDouble& rect);
637 */
638
639 wxDouble m_x;
640 wxDouble m_y;
641 wxDouble m_width;
642 wxDouble m_height;
643 };
644
645
646 // wxRect2Ds are a axis-aligned rectangles, each side of the rect is parallel to the x- or m_y- axis. The rectangle is either defined by the
647 // top left and bottom right corner, or by the top left corner and size. A point is contained within the rectangle if
648 // left <= x < right and top <= m_y < bottom , thus it is a half open interval.
649
650 class WXDLLEXPORT wxRect2DInt
651 {
652 public:
653 wxRect2DInt() { m_x = m_y = m_width = m_height = 0; }
654 wxRect2DInt( const wxRect& r ) { m_x = r.x ; m_y = r.y ; m_width = r.width ; m_height = r.height ; }
655 wxRect2DInt(wxInt32 x, wxInt32 y, wxInt32 w, wxInt32 h) { m_x = x; m_y = y; m_width = w; m_height = h; }
656 wxRect2DInt(const wxPoint2DInt& topLeft, const wxPoint2DInt& bottomRight);
657 inline wxRect2DInt(const wxPoint2DInt& pos, const wxSize& size);
658 inline wxRect2DInt(const wxRect2DInt& rect);
659
660 // single attribute accessors
661
662 inline wxPoint2DInt GetPosition() { return wxPoint2DInt(m_x, m_y); }
663 inline wxSize GetSize() { return wxSize(m_width, m_height); }
664
665 // for the edge and corner accessors there are two setters conterparts, the Set.. functions keep the other corners at their
666 // position whenever sensible, the Move.. functions keep the size of the rect and move the other corners apropriately
667
668 inline wxInt32 GetLeft() const { return m_x; }
669 inline void SetLeft( wxInt32 n ) { m_width += m_x - n; m_x = n; }
670 inline void MoveLeftTo( wxInt32 n ) { m_x = n; }
671 inline wxInt32 GetTop() const { return m_y; }
672 inline void SetTop( wxInt32 n ) { m_height += m_y - n; m_y = n; }
673 inline void MoveTopTo( wxInt32 n ) { m_y = n; }
674 inline wxInt32 GetBottom() const { return m_y + m_height; }
675 inline void SetBottom( wxInt32 n ) { m_height += n - (m_y+m_height);}
676 inline void MoveBottomTo( wxInt32 n ) { m_y = n - m_height; }
677 inline wxInt32 GetRight() const { return m_x + m_width; }
678 inline void SetRight( wxInt32 n ) { m_width += n - (m_x+m_width) ; }
679 inline void MoveRightTo( wxInt32 n ) { m_x = n - m_width; }
680
681 inline wxPoint2DInt GetLeftTop() const { return wxPoint2DInt( m_x , m_y ); }
682 inline void SetLeftTop( const wxPoint2DInt &pt ) { m_width += m_x - pt.m_x; m_height += m_y - pt.m_y; m_x = pt.m_x; m_y = pt.m_y; }
683 inline void MoveLeftTopTo( const wxPoint2DInt &pt ) { m_x = pt.m_x; m_y = pt.m_y; }
684 inline wxPoint2DInt GetLeftBottom() const { return wxPoint2DInt( m_x , m_y + m_height ); }
685 inline void SetLeftBottom( const wxPoint2DInt &pt ) { m_width += m_x - pt.m_x; m_height += pt.m_y - (m_y+m_height) ; m_x = pt.m_x; }
686 inline void MoveLeftBottomTo( const wxPoint2DInt &pt ) { m_x = pt.m_x; m_y = pt.m_y - m_height; }
687 inline wxPoint2DInt GetRightTop() const { return wxPoint2DInt( m_x+m_width , m_y ); }
688 inline void SetRightTop( const wxPoint2DInt &pt ) { m_width += pt.m_x - ( m_x + m_width ); m_height += m_y - pt.m_y; m_y = pt.m_y; }
689 inline void MoveRightTopTo( const wxPoint2DInt &pt ) { m_x = pt.m_x - m_width; m_y = pt.m_y; }
690 inline wxPoint2DInt GetRightBottom() const { return wxPoint2DInt( m_x+m_width , m_y + m_height ); }
691 inline void SetRightBottom( const wxPoint2DInt &pt ) { m_width += pt.m_x - ( m_x + m_width ); m_height += pt.m_y - (m_y+m_height);}
692 inline void MoveRightBottomTo( const wxPoint2DInt &pt ) { m_x = pt.m_x - m_width; m_y = pt.m_y - m_height; }
693 inline wxPoint2DInt GetCentre() const { return wxPoint2DInt( m_x+m_width/2 , m_y+m_height/2 ); }
694 inline void SetCentre( const wxPoint2DInt &pt ) { MoveCentreTo( pt ); } // since this is impossible without moving...
695 inline void MoveCentreTo( const wxPoint2DInt &pt ) { m_x += pt.m_x - (m_x+m_width/2) , m_y += pt.m_y -(m_y+m_height/2); }
696 inline wxOutCode GetOutcode( const wxPoint2DInt &pt ) const
697 { return (wxOutCode) (( ( pt.m_x < m_x ) ? wxOutLeft : 0 ) +
698 ( ( pt.m_x >= m_x + m_width ) ? wxOutRight : 0 ) +
699 ( ( pt.m_y < m_y ) ? wxOutTop : 0 ) +
700 ( ( pt.m_y >= m_y + m_height ) ? wxOutBottom : 0 )); }
701 inline bool Contains( const wxPoint2DInt &pt ) const
702 { return GetOutcode( pt ) == wxInside; }
703 inline bool Contains( const wxRect2DInt &rect ) const
704 { return ( ( ( m_x <= rect.m_x ) && ( rect.m_x + rect.m_width <= m_x + m_width ) ) &&
705 ( ( m_y <= rect.m_y ) && ( rect.m_y + rect.m_height <= m_y + m_height ) ) ); }
706 inline bool IsEmpty() const
707 { return ( m_width <= 0 || m_height <= 0 ); }
708 inline bool HaveEqualSize( const wxRect2DInt &rect ) const
709 { return ( rect.m_width == m_width && rect.m_height == m_height ); }
710
711 inline void Inset( wxInt32 x , wxInt32 y ) { m_x += x; m_y += y; m_width -= 2 * x; m_height -= 2 * y; }
712 inline void Inset( wxInt32 left , wxInt32 top ,wxInt32 right , wxInt32 bottom )
713 { m_x += left; m_y += top; m_width -= left + right; m_height -= top + bottom;}
714 inline void Offset( const wxPoint2DInt &pt ) { m_x += pt.m_x; m_y += pt.m_y; }
715 void ConstrainTo( const wxRect2DInt &rect );
716 inline wxPoint2DInt Interpolate( wxInt32 widthfactor , wxInt32 heightfactor ) { return wxPoint2DInt( m_x + m_width * widthfactor , m_y + m_height * heightfactor ); }
717
718 static void Intersect( const wxRect2DInt &src1 , const wxRect2DInt &src2 , wxRect2DInt *dest );
719 inline void Intersect( const wxRect2DInt &otherRect ) { Intersect( *this , otherRect , this ); }
720 inline wxRect2DInt CreateIntersection( const wxRect2DInt &otherRect ) const { wxRect2DInt result; Intersect( *this , otherRect , &result); return result; }
721 bool Intersects( const wxRect2DInt &rect ) const;
722
723 static void Union( const wxRect2DInt &src1 , const wxRect2DInt &src2 , wxRect2DInt *dest );
724 void Union( const wxRect2DInt &otherRect ) { Union( *this , otherRect , this ); }
725 void Union( const wxPoint2DInt &pt );
726 inline wxRect2DInt CreateUnion( const wxRect2DInt &otherRect ) const { wxRect2DInt result; Union( *this , otherRect , &result); return result; }
727
728 inline void Scale( wxInt32 f ) { m_x *= f; m_y *= f; m_width *= f; m_height *= f;}
729 inline void Scale( wxInt32 num , wxInt32 denum )
730 { m_x *= ((wxInt32)num)/((wxInt32)denum); m_y *= ((wxInt32)num)/((wxInt32)denum);
731 m_width *= ((wxInt32)num)/((wxInt32)denum); m_height *= ((wxInt32)num)/((wxInt32)denum);}
732
733 wxRect2DInt& operator = (const wxRect2DInt& rect);
734 bool operator == (const wxRect2DInt& rect);
735 bool operator != (const wxRect2DInt& rect);
736
737 void WriteTo( wxDataOutputStream &stream ) const;
738 void ReadFrom( wxDataInputStream &stream );
739
740 wxInt32 m_x;
741 wxInt32 m_y;
742 wxInt32 m_width;
743 wxInt32 m_height;
744 };
745
746 inline wxRect2DInt::wxRect2DInt( const wxRect2DInt &r )
747 {
748 m_x = r.m_x;
749 m_y = r.m_y;
750 m_width = r.m_width;
751 m_height = r.m_height;
752 }
753
754 inline wxRect2DInt::wxRect2DInt( const wxPoint2DInt &a , const wxPoint2DInt &b)
755 {
756 m_x = wxMin( a.m_x , b.m_x );
757 m_y = wxMin( a.m_y , b.m_y );
758 m_width = abs( a.m_x - b.m_x );
759 m_height = abs( a.m_y - b.m_y );
760 }
761
762 class wxTransform2D
763 {
764 public :
765 virtual void Transform( wxPoint2DInt* pt )const = 0;
766 virtual void Transform( wxRect2DInt* r ) const;
767 virtual wxPoint2DInt Transform( const wxPoint2DInt &pt ) const;
768 virtual wxRect2DInt Transform( const wxRect2DInt &r ) const ;
769
770 virtual void InverseTransform( wxPoint2DInt* pt ) const = 0;
771 virtual void InverseTransform( wxRect2DInt* r ) const ;
772 virtual wxPoint2DInt InverseTransform( const wxPoint2DInt &pt ) const ;
773 virtual wxRect2DInt InverseTransform( const wxRect2DInt &r ) const ;
774 };
775
776 inline void wxTransform2D::Transform( wxRect2DInt* r ) const
777 { wxPoint2DInt a = r->GetLeftTop() , b = r->GetRightBottom(); Transform( &a ); Transform( &b ); *r = wxRect2DInt( a , b ); }
778
779 inline wxPoint2DInt wxTransform2D::Transform( const wxPoint2DInt &pt ) const
780 { wxPoint2DInt res = pt; Transform( &res ); return res; }
781
782 inline wxRect2DInt wxTransform2D::Transform( const wxRect2DInt &r ) const
783 { wxRect2DInt res = r; Transform( &res ); return res; }
784
785 inline void wxTransform2D::InverseTransform( wxRect2DInt* r ) const
786 { wxPoint2DInt a = r->GetLeftTop() , b = r->GetRightBottom(); InverseTransform( &a ); InverseTransform( &b ); *r = wxRect2DInt( a , b ); }
787
788 inline wxPoint2DInt wxTransform2D::InverseTransform( const wxPoint2DInt &pt ) const
789 { wxPoint2DInt res = pt; InverseTransform( &res ); return res; }
790
791 inline wxRect2DInt wxTransform2D::InverseTransform( const wxRect2DInt &r ) const
792 { wxRect2DInt res = r; InverseTransform( &res ); return res; }
793
794
795 #endif // wxUSE_GEOMETRY
796
797 #endif // _WX_GEOMETRY_H_