]>
Commit | Line | Data |
---|---|---|
72e7876b | 1 | ///////////////////////////////////////////////////////////////////////////// |
11e82c1b | 2 | // Name: wx/geometry.h |
72e7876b SC |
3 | // Purpose: Common Geometry Classes |
4 | // Author: Stefan Csomor | |
5 | // Modified by: | |
6 | // Created: 08/05/99 | |
f91de7da | 7 | // RCS-ID: |
11e82c1b | 8 | // Copyright: (c) 1999 Stefan Csomor |
c3a4297c | 9 | // Licence: wxWindows licence |
72e7876b SC |
10 | ///////////////////////////////////////////////////////////////////////////// |
11 | ||
c3a4297c VZ |
12 | #ifndef _WX_GEOMETRY_H_ |
13 | #define _WX_GEOMETRY_H_ | |
72e7876b | 14 | |
af49c4b8 | 15 | #if defined(__GNUG__) && !defined(__APPLE__) |
6c7873e1 | 16 | #pragma interface "geometry.cpp" |
72e7876b SC |
17 | #endif |
18 | ||
510fc784 | 19 | #include "wx/defs.h" |
c3a4297c | 20 | |
5b781a67 SC |
21 | #ifndef wxUSE_GEOMETRY |
22 | #define wxUSE_GEOMETRY 0 | |
23 | #endif | |
24 | ||
c3a4297c VZ |
25 | #if wxUSE_GEOMETRY |
26 | ||
510fc784 RR |
27 | #include "wx/utils.h" |
28 | #include "wx/gdicmn.h" | |
29 | #include <math.h> | |
30 | ||
72e7876b | 31 | #ifdef __WXMSW__ |
c3a4297c | 32 | #define wxMulDivInt32( a , b , c ) ::MulDiv( a , b , c ) |
72e7876b | 33 | #elif defined( __WXMAC__ ) |
d60f1012 | 34 | #define wxMulDivInt32( a , b , c ) ( (wxInt32) ( ( (wxInt64)(a) * (wxInt64)(b) ) / (wxInt64)(c) ) ) |
72e7876b | 35 | #else |
c3a4297c | 36 | #define wxMulDivInt32( a , b , c ) ((wxInt32)((a)*(((wxDouble)b)/((wxDouble)c)))) |
72e7876b SC |
37 | #endif |
38 | ||
11e82c1b VZ |
39 | class wxDataInputStream; |
40 | class wxDataOutputStream; | |
72e7876b SC |
41 | |
42 | // clipping from Cohen-Sutherland | |
43 | ||
44 | enum wxOutCode | |
45 | { | |
c3a4297c VZ |
46 | wxInside = 0x00 , |
47 | wxOutLeft = 0x01 , | |
48 | wxOutRight = 0x02 , | |
49 | wxOutTop = 0x08 , | |
f91de7da | 50 | wxOutBottom = 0x04 |
11e82c1b | 51 | }; |
72e7876b | 52 | |
e2aa719c SC |
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 | |
2b5f62a0 VZ |
62 | inline void GetFloor( wxInt32 *x , wxInt32 *y ) const; |
63 | inline void GetRounded( wxInt32 *x , wxInt32 *y ) const; | |
e2aa719c | 64 | |
2b5f62a0 VZ |
65 | inline wxDouble GetVectorLength() const; |
66 | wxDouble GetVectorAngle() const; | |
e2aa719c SC |
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 | ||
295272bd VZ |
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); | |
e2aa719c SC |
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 | ||
2b5f62a0 | 136 | inline void wxPoint2DInt::GetFloor( wxInt32 *x , wxInt32 *y ) const |
e2aa719c SC |
137 | { |
138 | if ( x ) | |
139 | *x = m_x; | |
140 | if ( y ) | |
141 | *y = m_y; | |
142 | } | |
143 | ||
2b5f62a0 | 144 | inline void wxPoint2DInt::GetRounded( wxInt32 *x , wxInt32 *y ) const |
e2aa719c SC |
145 | { |
146 | GetFloor(x, y); | |
147 | } | |
148 | ||
2b5f62a0 | 149 | inline wxDouble wxPoint2DInt::GetVectorLength() const |
e2aa719c SC |
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 | ||
f91de7da | 293 | // wxPoint2Ds represent a point or a vector in a 2d coordinate system |
72e7876b SC |
294 | |
295 | class WXDLLEXPORT wxPoint2DDouble | |
296 | { | |
297 | public : | |
11e82c1b VZ |
298 | inline wxPoint2DDouble(); |
299 | inline wxPoint2DDouble( wxDouble x , wxDouble y ); | |
300 | inline wxPoint2DDouble( const wxPoint2DDouble &pt ); | |
e2aa719c SC |
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 ; } | |
11e82c1b VZ |
305 | |
306 | // two different conversions to integers, floor and rounding | |
2b5f62a0 VZ |
307 | inline void GetFloor( wxInt32 *x , wxInt32 *y ) const; |
308 | inline void GetRounded( wxInt32 *x , wxInt32 *y ) const; | |
11e82c1b | 309 | |
e2aa719c SC |
310 | inline wxDouble GetVectorLength() const; |
311 | wxDouble GetVectorAngle() const ; | |
11e82c1b VZ |
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 | ||
2b5f62a0 VZ |
318 | inline wxDouble GetDistance( const wxPoint2DDouble &pt ) const; |
319 | inline wxDouble GetDistanceSquare( const wxPoint2DDouble &pt ) const; | |
320 | inline wxDouble GetDotProduct( const wxPoint2DDouble &vec ) const; | |
321 | inline wxDouble GetCrossProduct( const wxPoint2DDouble &vec ) const; | |
11e82c1b VZ |
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 | }; | |
c3a4297c | 342 | |
90350682 VZ |
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); | |
72e7876b | 353 | |
f91de7da DW |
354 | inline wxPoint2DDouble::wxPoint2DDouble() |
355 | { | |
11e82c1b VZ |
356 | m_x = 0.0; |
357 | m_y = 0.0; | |
72e7876b SC |
358 | } |
359 | ||
f91de7da DW |
360 | inline wxPoint2DDouble::wxPoint2DDouble( wxDouble x , wxDouble y ) |
361 | { | |
11e82c1b VZ |
362 | m_x = x; |
363 | m_y = y; | |
f91de7da | 364 | } |
72e7876b | 365 | |
f91de7da DW |
366 | inline wxPoint2DDouble::wxPoint2DDouble( const wxPoint2DDouble &pt ) |
367 | { | |
11e82c1b VZ |
368 | m_x = pt.m_x; |
369 | m_y = pt.m_y; | |
72e7876b SC |
370 | } |
371 | ||
2b5f62a0 | 372 | inline void wxPoint2DDouble::GetFloor( wxInt32 *x , wxInt32 *y ) const |
f91de7da | 373 | { |
11e82c1b VZ |
374 | *x = (wxInt32) floor( m_x ); |
375 | *y = (wxInt32) floor( m_y ); | |
72e7876b SC |
376 | } |
377 | ||
2b5f62a0 | 378 | inline void wxPoint2DDouble::GetRounded( wxInt32 *x , wxInt32 *y ) const |
f91de7da | 379 | { |
11e82c1b VZ |
380 | *x = (wxInt32) floor( m_x + 0.5 ); |
381 | *y = (wxInt32) floor( m_y + 0.5); | |
f91de7da DW |
382 | } |
383 | ||
e2aa719c SC |
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 | ||
2b5f62a0 | 396 | inline wxDouble wxPoint2DDouble::GetDistance( const wxPoint2DDouble &pt ) const |
f91de7da DW |
397 | { |
398 | return sqrt( GetDistanceSquare( pt ) ); | |
72e7876b SC |
399 | } |
400 | ||
2b5f62a0 | 401 | inline wxDouble wxPoint2DDouble::GetDistanceSquare( const wxPoint2DDouble &pt ) const |
f91de7da | 402 | { |
11e82c1b | 403 | return ( (pt.m_x-m_x)*(pt.m_x-m_x) + (pt.m_y-m_y)*(pt.m_y-m_y) ); |
f91de7da | 404 | } |
72e7876b | 405 | |
2b5f62a0 | 406 | inline wxDouble wxPoint2DDouble::GetDotProduct( const wxPoint2DDouble &vec ) const |
f91de7da | 407 | { |
11e82c1b | 408 | return ( m_x * vec.m_x + m_y * vec.m_y ); |
72e7876b SC |
409 | } |
410 | ||
2b5f62a0 | 411 | inline wxDouble wxPoint2DDouble::GetCrossProduct( const wxPoint2DDouble &vec ) const |
f91de7da | 412 | { |
11e82c1b | 413 | return ( m_x * vec.m_y - vec.m_x * m_y ); |
f91de7da | 414 | } |
72e7876b | 415 | |
f91de7da DW |
416 | inline wxPoint2DDouble wxPoint2DDouble::operator-() |
417 | { | |
c3a4297c | 418 | return wxPoint2DDouble( -m_x, -m_y); |
72e7876b SC |
419 | } |
420 | ||
421 | inline wxPoint2DDouble& wxPoint2DDouble::operator=(const wxPoint2DDouble& pt) | |
f91de7da | 422 | { |
11e82c1b | 423 | m_x = pt.m_x; |
f91de7da | 424 | m_y = pt.m_y; |
11e82c1b | 425 | return *this; |
72e7876b SC |
426 | } |
427 | ||
f91de7da | 428 | inline wxPoint2DDouble& wxPoint2DDouble::operator+=(const wxPoint2DDouble& pt) |
72e7876b | 429 | { |
11e82c1b | 430 | m_x = m_x + pt.m_x; |
f91de7da | 431 | m_y = m_y + pt.m_y; |
11e82c1b | 432 | return *this; |
72e7876b SC |
433 | } |
434 | ||
f91de7da DW |
435 | inline wxPoint2DDouble& wxPoint2DDouble::operator-=(const wxPoint2DDouble& pt) |
436 | { | |
11e82c1b | 437 | m_x = m_x - pt.m_x; |
f91de7da | 438 | m_y = m_y - pt.m_y; |
11e82c1b | 439 | return *this; |
72e7876b SC |
440 | } |
441 | ||
f91de7da DW |
442 | inline wxPoint2DDouble& wxPoint2DDouble::operator*=(const wxPoint2DDouble& pt) |
443 | { | |
11e82c1b | 444 | m_x = m_x * pt.m_x; |
f91de7da | 445 | m_y = m_y * pt.m_y; |
11e82c1b | 446 | return *this; |
72e7876b SC |
447 | } |
448 | ||
f91de7da DW |
449 | inline wxPoint2DDouble& wxPoint2DDouble::operator/=(const wxPoint2DDouble& pt) |
450 | { | |
11e82c1b | 451 | m_x = m_x / pt.m_x; |
da052901 | 452 | m_y = m_y / pt.m_y; |
11e82c1b | 453 | return *this; |
72e7876b SC |
454 | } |
455 | ||
f91de7da DW |
456 | inline bool wxPoint2DDouble::operator==(const wxPoint2DDouble& pt) const |
457 | { | |
458 | return m_x == pt.m_x && m_y == pt.m_y; | |
72e7876b SC |
459 | } |
460 | ||
f91de7da DW |
461 | inline bool wxPoint2DDouble::operator!=(const wxPoint2DDouble& pt) const |
462 | { | |
463 | return m_x != pt.m_x || m_y != pt.m_y; | |
72e7876b SC |
464 | } |
465 | ||
f91de7da | 466 | inline wxPoint2DDouble operator+(const wxPoint2DDouble& pt1 , const wxPoint2DDouble& pt2) |
72e7876b | 467 | { |
11e82c1b | 468 | return wxPoint2DDouble( pt1.m_x + pt2.m_x , pt1.m_y + pt2.m_y ); |
72e7876b SC |
469 | } |
470 | ||
f91de7da | 471 | inline wxPoint2DDouble operator-(const wxPoint2DDouble& pt1 , const wxPoint2DDouble& pt2) |
72e7876b | 472 | { |
11e82c1b | 473 | return wxPoint2DDouble( pt1.m_x - pt2.m_x , pt1.m_y - pt2.m_y ); |
72e7876b SC |
474 | } |
475 | ||
476 | ||
f91de7da | 477 | inline wxPoint2DDouble operator*(const wxPoint2DDouble& pt1 , const wxPoint2DDouble& pt2) |
72e7876b | 478 | { |
11e82c1b | 479 | return wxPoint2DDouble( pt1.m_x * pt2.m_x , pt1.m_y * pt2.m_y ); |
72e7876b SC |
480 | } |
481 | ||
f91de7da | 482 | inline wxPoint2DDouble operator*(wxDouble n , const wxPoint2DDouble& pt) |
72e7876b | 483 | { |
11e82c1b | 484 | return wxPoint2DDouble( pt.m_x * n , pt.m_y * n ); |
72e7876b SC |
485 | } |
486 | ||
f91de7da | 487 | inline wxPoint2DDouble operator*(wxInt32 n , const wxPoint2DDouble& pt) |
72e7876b | 488 | { |
11e82c1b | 489 | return wxPoint2DDouble( pt.m_x * n , pt.m_y * n ); |
72e7876b SC |
490 | } |
491 | ||
f91de7da | 492 | inline wxPoint2DDouble operator*(const wxPoint2DDouble& pt , wxDouble n) |
72e7876b | 493 | { |
11e82c1b | 494 | return wxPoint2DDouble( pt.m_x * n , pt.m_y * n ); |
72e7876b SC |
495 | } |
496 | ||
f91de7da | 497 | inline wxPoint2DDouble operator*(const wxPoint2DDouble& pt , wxInt32 n) |
72e7876b | 498 | { |
11e82c1b | 499 | return wxPoint2DDouble( pt.m_x * n , pt.m_y * n ); |
72e7876b SC |
500 | } |
501 | ||
f91de7da | 502 | inline wxPoint2DDouble operator/(const wxPoint2DDouble& pt1 , const wxPoint2DDouble& pt2) |
72e7876b | 503 | { |
11e82c1b | 504 | return wxPoint2DDouble( pt1.m_x / pt2.m_x , pt1.m_y / pt2.m_y ); |
72e7876b SC |
505 | } |
506 | ||
f91de7da | 507 | inline wxPoint2DDouble operator/(const wxPoint2DDouble& pt , wxDouble n) |
72e7876b | 508 | { |
11e82c1b | 509 | return wxPoint2DDouble( pt.m_x / n , pt.m_y / n ); |
72e7876b SC |
510 | } |
511 | ||
f91de7da | 512 | inline wxPoint2DDouble operator/(const wxPoint2DDouble& pt , wxInt32 n) |
72e7876b | 513 | { |
11e82c1b | 514 | return wxPoint2DDouble( pt.m_x / n , pt.m_y / n ); |
72e7876b SC |
515 | } |
516 | ||
f91de7da | 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 |
72e7876b | 518 | // top left and bottom right corner, or by the top left corner and size. A point is contained within the rectangle if |
f91de7da | 519 | // left <= x < right and top <= m_y < bottom , thus it is a half open interval. |
72e7876b SC |
520 | |
521 | class WXDLLEXPORT wxRect2DDouble | |
522 | { | |
523 | public: | |
f91de7da | 524 | wxRect2DDouble() |
11e82c1b | 525 | { m_x = m_y = m_width = m_height = 0; } |
6c7873e1 | 526 | wxRect2DDouble(wxDouble x, wxDouble y, wxDouble w, wxDouble h) |
11e82c1b | 527 | { m_x = x; m_y = y; m_width = w; m_height = h; } |
6c7873e1 RR |
528 | /* |
529 | wxRect2DDouble(const wxPoint2DDouble& topLeft, const wxPoint2DDouble& bottomRight); | |
530 | wxRect2DDouble(const wxPoint2DDouble& pos, const wxSize& size); | |
531 | wxRect2DDouble(const wxRect2DDouble& rect); | |
532 | */ | |
c3a4297c VZ |
533 | // single attribute accessors |
534 | ||
f91de7da | 535 | inline wxPoint2DDouble GetPosition() |
6c7873e1 RR |
536 | { return wxPoint2DDouble(m_x, m_y); } |
537 | inline wxSize GetSize() | |
7a5e6267 | 538 | { return wxSize((int) m_width, (int) m_height); } |
c3a4297c | 539 | |
6c7873e1 | 540 | // for the edge and corner accessors there are two setters conterparts, the Set.. functions keep the other corners at their |
c3a4297c VZ |
541 | // position whenever sensible, the Move.. functions keep the size of the rect and move the other corners apropriately |
542 | ||
6c7873e1 | 543 | inline wxDouble GetLeft() const { return m_x; } |
11e82c1b VZ |
544 | inline void SetLeft( wxDouble n ) { m_width += m_x - n; m_x = n; } |
545 | inline void MoveLeftTo( wxDouble n ) { m_x = n; } | |
6c7873e1 | 546 | inline wxDouble GetTop() const { return m_y; } |
11e82c1b VZ |
547 | inline void SetTop( wxDouble n ) { m_height += m_y - n; m_y = n; } |
548 | inline void MoveTopTo( wxDouble n ) { m_y = n; } | |
6c7873e1 | 549 | inline wxDouble GetBottom() const { return m_y + m_height; } |
11e82c1b VZ |
550 | inline void SetBottom( wxDouble n ) { m_height += n - (m_y+m_height);} |
551 | inline void MoveBottomTo( wxDouble n ) { m_y = n - m_height; } | |
6c7873e1 | 552 | inline wxDouble GetRight() const { return m_x + m_width; } |
11e82c1b VZ |
553 | inline void SetRight( wxDouble n ) { m_width += n - (m_x+m_width) ; } |
554 | inline void MoveRightTo( wxDouble n ) { m_x = n - m_width; } | |
6c7873e1 RR |
555 | |
556 | inline wxPoint2DDouble GetLeftTop() const | |
11e82c1b | 557 | { return wxPoint2DDouble( m_x , m_y ); } |
6c7873e1 | 558 | inline void SetLeftTop( const wxPoint2DDouble &pt ) |
11e82c1b | 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; } |
6c7873e1 | 560 | inline void MoveLeftTopTo( const wxPoint2DDouble &pt ) |
11e82c1b | 561 | { m_x = pt.m_x; m_y = pt.m_y; } |
6c7873e1 | 562 | inline wxPoint2DDouble GetLeftBottom() const |
11e82c1b | 563 | { return wxPoint2DDouble( m_x , m_y + m_height ); } |
6c7873e1 | 564 | inline void SetLeftBottom( const wxPoint2DDouble &pt ) |
11e82c1b | 565 | { m_width += m_x - pt.m_x; m_height += pt.m_y - (m_y+m_height) ; m_x = pt.m_x; } |
6c7873e1 | 566 | inline void MoveLeftBottomTo( const wxPoint2DDouble &pt ) |
11e82c1b | 567 | { m_x = pt.m_x; m_y = pt.m_y - m_height; } |
6c7873e1 | 568 | inline wxPoint2DDouble GetRightTop() const |
11e82c1b | 569 | { return wxPoint2DDouble( m_x+m_width , m_y ); } |
6c7873e1 | 570 | inline void SetRightTop( const wxPoint2DDouble &pt ) |
11e82c1b | 571 | { m_width += pt.m_x - ( m_x + m_width ); m_height += m_y - pt.m_y; m_y = pt.m_y; } |
6c7873e1 | 572 | inline void MoveRightTopTo( const wxPoint2DDouble &pt ) |
11e82c1b | 573 | { m_x = pt.m_x - m_width; m_y = pt.m_y; } |
6c7873e1 | 574 | inline wxPoint2DDouble GetRightBottom() const |
11e82c1b | 575 | { return wxPoint2DDouble( m_x+m_width , m_y + m_height ); } |
6c7873e1 | 576 | inline void SetRightBottom( const wxPoint2DDouble &pt ) |
11e82c1b | 577 | { m_width += pt.m_x - ( m_x + m_width ); m_height += pt.m_y - (m_y+m_height);} |
6c7873e1 | 578 | inline void MoveRightBottomTo( const wxPoint2DDouble &pt ) |
11e82c1b | 579 | { m_x = pt.m_x - m_width; m_y = pt.m_y - m_height; } |
6c7873e1 | 580 | inline wxPoint2DDouble GetCentre() const |
11e82c1b | 581 | { return wxPoint2DDouble( m_x+m_width/2 , m_y+m_height/2 ); } |
6c7873e1 | 582 | inline void SetCentre( const wxPoint2DDouble &pt ) |
11e82c1b | 583 | { MoveCentreTo( pt ); } // since this is impossible without moving... |
6c7873e1 | 584 | inline void MoveCentreTo( const wxPoint2DDouble &pt ) |
11e82c1b | 585 | { m_x += pt.m_x - (m_x+m_width/2) , m_y += pt.m_y -(m_y+m_height/2); } |
0624ce56 | 586 | inline wxOutCode GetOutCode( const wxPoint2DDouble &pt ) const |
6c7873e1 | 587 | { return (wxOutCode) (( ( pt.m_x < m_x ) ? wxOutLeft : 0 ) + |
1b2a04da | 588 | ( ( pt.m_x > m_x + m_width ) ? wxOutRight : 0 ) + |
c3a4297c | 589 | ( ( pt.m_y < m_y ) ? wxOutTop : 0 ) + |
1b2a04da | 590 | ( ( pt.m_y > m_y + m_height ) ? wxOutBottom : 0 )); } |
0624ce56 SC |
591 | inline wxOutCode GetOutcode(const wxPoint2DDouble &pt) const |
592 | { return GetOutCode(pt) ; } | |
f91de7da | 593 | inline bool Contains( const wxPoint2DDouble &pt ) const |
0624ce56 | 594 | { return GetOutCode( pt ) == wxInside; } |
f91de7da DW |
595 | inline bool Contains( const wxRect2DDouble &rect ) const |
596 | { return ( ( ( m_x <= rect.m_x ) && ( rect.m_x + rect.m_width <= m_x + m_width ) ) && | |
11e82c1b | 597 | ( ( m_y <= rect.m_y ) && ( rect.m_y + rect.m_height <= m_y + m_height ) ) ); } |
f91de7da | 598 | inline bool IsEmpty() const |
11e82c1b | 599 | { return ( m_width <= 0 || m_height <= 0 ); } |
f91de7da | 600 | inline bool HaveEqualSize( const wxRect2DDouble &rect ) const |
11e82c1b | 601 | { return ( rect.m_width == m_width && rect.m_height == m_height ); } |
f91de7da | 602 | |
6c7873e1 | 603 | inline void Inset( wxDouble x , wxDouble y ) |
11e82c1b | 604 | { m_x += x; m_y += y; m_width -= 2 * x; m_height -= 2 * y; } |
f91de7da | 605 | inline void Inset( wxDouble left , wxDouble top ,wxDouble right , wxDouble bottom ) |
11e82c1b | 606 | { m_x += left; m_y += top; m_width -= left + right; m_height -= top + bottom;} |
6c7873e1 | 607 | inline void Offset( const wxPoint2DDouble &pt ) |
11e82c1b | 608 | { m_x += pt.m_x; m_y += pt.m_y; } |
f91de7da | 609 | |
6c7873e1 | 610 | void ConstrainTo( const wxRect2DDouble &rect ); |
f91de7da | 611 | |
6c7873e1 | 612 | inline wxPoint2DDouble Interpolate( wxInt32 widthfactor , wxInt32 heightfactor ) |
11e82c1b | 613 | { return wxPoint2DDouble( m_x + m_width * widthfactor , m_y + m_height * heightfactor ); } |
6c7873e1 | 614 | |
11e82c1b | 615 | static void Intersect( const wxRect2DDouble &src1 , const wxRect2DDouble &src2 , wxRect2DDouble *dest ); |
6c7873e1 | 616 | inline void Intersect( const wxRect2DDouble &otherRect ) |
11e82c1b | 617 | { Intersect( *this , otherRect , this ); } |
6c7873e1 | 618 | inline wxRect2DDouble CreateIntersection( const wxRect2DDouble &otherRect ) const |
11e82c1b VZ |
619 | { wxRect2DDouble result; Intersect( *this , otherRect , &result); return result; } |
620 | bool Intersects( const wxRect2DDouble &rect ) const; | |
6c7873e1 | 621 | |
11e82c1b | 622 | static void Union( const wxRect2DDouble &src1 , const wxRect2DDouble &src2 , wxRect2DDouble *dest ); |
6c7873e1 | 623 | void Union( const wxRect2DDouble &otherRect ) |
11e82c1b VZ |
624 | { Union( *this , otherRect , this ); } |
625 | void Union( const wxPoint2DDouble &pt ); | |
6c7873e1 | 626 | inline wxRect2DDouble CreateUnion( const wxRect2DDouble &otherRect ) const |
11e82c1b | 627 | { wxRect2DDouble result; Union( *this , otherRect , &result); return result; } |
6c7873e1 RR |
628 | |
629 | inline void Scale( wxDouble f ) | |
11e82c1b | 630 | { m_x *= f; m_y *= f; m_width *= f; m_height *= f;} |
f91de7da | 631 | inline void Scale( wxInt32 num , wxInt32 denum ) |
11e82c1b VZ |
632 | { m_x *= ((wxDouble)num)/((wxDouble)denum); m_y *= ((wxDouble)num)/((wxDouble)denum); |
633 | m_width *= ((wxDouble)num)/((wxDouble)denum); m_height *= ((wxDouble)num)/((wxDouble)denum);} | |
c3a4297c | 634 | |
6c7873e1 RR |
635 | /* |
636 | wxRect2DDouble& operator = (const wxRect2DDouble& rect); | |
637 | bool operator == (const wxRect2DDouble& rect); | |
638 | bool operator != (const wxRect2DDouble& rect); | |
639 | */ | |
c3a4297c | 640 | |
6c7873e1 | 641 | wxDouble m_x; |
11e82c1b | 642 | wxDouble m_y; |
6c7873e1 RR |
643 | wxDouble m_width; |
644 | wxDouble m_height; | |
72e7876b SC |
645 | }; |
646 | ||
72e7876b | 647 | |
f91de7da | 648 | // 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 |
72e7876b | 649 | // top left and bottom right corner, or by the top left corner and size. A point is contained within the rectangle if |
f91de7da | 650 | // left <= x < right and top <= m_y < bottom , thus it is a half open interval. |
72e7876b SC |
651 | |
652 | class WXDLLEXPORT wxRect2DInt | |
653 | { | |
654 | public: | |
11e82c1b | 655 | wxRect2DInt() { m_x = m_y = m_width = m_height = 0; } |
e2aa719c | 656 | wxRect2DInt( const wxRect& r ) { m_x = r.x ; m_y = r.y ; m_width = r.width ; m_height = r.height ; } |
11e82c1b | 657 | wxRect2DInt(wxInt32 x, wxInt32 y, wxInt32 w, wxInt32 h) { m_x = x; m_y = y; m_width = w; m_height = h; } |
c3a4297c | 658 | wxRect2DInt(const wxPoint2DInt& topLeft, const wxPoint2DInt& bottomRight); |
f91de7da DW |
659 | inline wxRect2DInt(const wxPoint2DInt& pos, const wxSize& size); |
660 | inline wxRect2DInt(const wxRect2DInt& rect); | |
c3a4297c VZ |
661 | |
662 | // single attribute accessors | |
663 | ||
664 | inline wxPoint2DInt GetPosition() { return wxPoint2DInt(m_x, m_y); } | |
665 | inline wxSize GetSize() { return wxSize(m_width, m_height); } | |
666 | ||
667 | // for the edge and corner accessors there are two setters conterparts, the Set.. functions keep the other corners at their | |
668 | // position whenever sensible, the Move.. functions keep the size of the rect and move the other corners apropriately | |
669 | ||
670 | inline wxInt32 GetLeft() const { return m_x; } | |
11e82c1b VZ |
671 | inline void SetLeft( wxInt32 n ) { m_width += m_x - n; m_x = n; } |
672 | inline void MoveLeftTo( wxInt32 n ) { m_x = n; } | |
c3a4297c | 673 | inline wxInt32 GetTop() const { return m_y; } |
11e82c1b VZ |
674 | inline void SetTop( wxInt32 n ) { m_height += m_y - n; m_y = n; } |
675 | inline void MoveTopTo( wxInt32 n ) { m_y = n; } | |
c3a4297c | 676 | inline wxInt32 GetBottom() const { return m_y + m_height; } |
11e82c1b VZ |
677 | inline void SetBottom( wxInt32 n ) { m_height += n - (m_y+m_height);} |
678 | inline void MoveBottomTo( wxInt32 n ) { m_y = n - m_height; } | |
c3a4297c | 679 | inline wxInt32 GetRight() const { return m_x + m_width; } |
11e82c1b VZ |
680 | inline void SetRight( wxInt32 n ) { m_width += n - (m_x+m_width) ; } |
681 | inline void MoveRightTo( wxInt32 n ) { m_x = n - m_width; } | |
682 | ||
683 | inline wxPoint2DInt GetLeftTop() const { return wxPoint2DInt( m_x , m_y ); } | |
684 | 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; } | |
685 | inline void MoveLeftTopTo( const wxPoint2DInt &pt ) { m_x = pt.m_x; m_y = pt.m_y; } | |
686 | inline wxPoint2DInt GetLeftBottom() const { return wxPoint2DInt( m_x , m_y + m_height ); } | |
687 | 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; } | |
688 | inline void MoveLeftBottomTo( const wxPoint2DInt &pt ) { m_x = pt.m_x; m_y = pt.m_y - m_height; } | |
689 | inline wxPoint2DInt GetRightTop() const { return wxPoint2DInt( m_x+m_width , m_y ); } | |
690 | 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; } | |
691 | inline void MoveRightTopTo( const wxPoint2DInt &pt ) { m_x = pt.m_x - m_width; m_y = pt.m_y; } | |
692 | inline wxPoint2DInt GetRightBottom() const { return wxPoint2DInt( m_x+m_width , m_y + m_height ); } | |
693 | inline void SetRightBottom( const wxPoint2DInt &pt ) { m_width += pt.m_x - ( m_x + m_width ); m_height += pt.m_y - (m_y+m_height);} | |
694 | inline void MoveRightBottomTo( const wxPoint2DInt &pt ) { m_x = pt.m_x - m_width; m_y = pt.m_y - m_height; } | |
695 | inline wxPoint2DInt GetCentre() const { return wxPoint2DInt( m_x+m_width/2 , m_y+m_height/2 ); } | |
696 | inline void SetCentre( const wxPoint2DInt &pt ) { MoveCentreTo( pt ); } // since this is impossible without moving... | |
697 | 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); } | |
0624ce56 | 698 | inline wxOutCode GetOutCode( const wxPoint2DInt &pt ) const |
c3a4297c VZ |
699 | { return (wxOutCode) (( ( pt.m_x < m_x ) ? wxOutLeft : 0 ) + |
700 | ( ( pt.m_x >= m_x + m_width ) ? wxOutRight : 0 ) + | |
701 | ( ( pt.m_y < m_y ) ? wxOutTop : 0 ) + | |
11e82c1b | 702 | ( ( pt.m_y >= m_y + m_height ) ? wxOutBottom : 0 )); } |
0624ce56 SC |
703 | inline wxOutCode GetOutcode( const wxPoint2DInt &pt ) const |
704 | { return GetOutCode( pt ) ; } | |
f91de7da | 705 | inline bool Contains( const wxPoint2DInt &pt ) const |
0624ce56 | 706 | { return GetOutCode( pt ) == wxInside; } |
f91de7da DW |
707 | inline bool Contains( const wxRect2DInt &rect ) const |
708 | { return ( ( ( m_x <= rect.m_x ) && ( rect.m_x + rect.m_width <= m_x + m_width ) ) && | |
11e82c1b | 709 | ( ( m_y <= rect.m_y ) && ( rect.m_y + rect.m_height <= m_y + m_height ) ) ); } |
f91de7da | 710 | inline bool IsEmpty() const |
11e82c1b | 711 | { return ( m_width <= 0 || m_height <= 0 ); } |
f91de7da | 712 | inline bool HaveEqualSize( const wxRect2DInt &rect ) const |
11e82c1b | 713 | { return ( rect.m_width == m_width && rect.m_height == m_height ); } |
f91de7da | 714 | |
11e82c1b | 715 | inline void Inset( wxInt32 x , wxInt32 y ) { m_x += x; m_y += y; m_width -= 2 * x; m_height -= 2 * y; } |
f91de7da | 716 | inline void Inset( wxInt32 left , wxInt32 top ,wxInt32 right , wxInt32 bottom ) |
11e82c1b VZ |
717 | { m_x += left; m_y += top; m_width -= left + right; m_height -= top + bottom;} |
718 | inline void Offset( const wxPoint2DInt &pt ) { m_x += pt.m_x; m_y += pt.m_y; } | |
719 | void ConstrainTo( const wxRect2DInt &rect ); | |
720 | inline wxPoint2DInt Interpolate( wxInt32 widthfactor , wxInt32 heightfactor ) { return wxPoint2DInt( m_x + m_width * widthfactor , m_y + m_height * heightfactor ); } | |
721 | ||
722 | static void Intersect( const wxRect2DInt &src1 , const wxRect2DInt &src2 , wxRect2DInt *dest ); | |
723 | inline void Intersect( const wxRect2DInt &otherRect ) { Intersect( *this , otherRect , this ); } | |
724 | inline wxRect2DInt CreateIntersection( const wxRect2DInt &otherRect ) const { wxRect2DInt result; Intersect( *this , otherRect , &result); return result; } | |
725 | bool Intersects( const wxRect2DInt &rect ) const; | |
726 | ||
727 | static void Union( const wxRect2DInt &src1 , const wxRect2DInt &src2 , wxRect2DInt *dest ); | |
728 | void Union( const wxRect2DInt &otherRect ) { Union( *this , otherRect , this ); } | |
729 | void Union( const wxPoint2DInt &pt ); | |
730 | inline wxRect2DInt CreateUnion( const wxRect2DInt &otherRect ) const { wxRect2DInt result; Union( *this , otherRect , &result); return result; } | |
731 | ||
732 | inline void Scale( wxInt32 f ) { m_x *= f; m_y *= f; m_width *= f; m_height *= f;} | |
f91de7da | 733 | inline void Scale( wxInt32 num , wxInt32 denum ) |
11e82c1b VZ |
734 | { m_x *= ((wxInt32)num)/((wxInt32)denum); m_y *= ((wxInt32)num)/((wxInt32)denum); |
735 | m_width *= ((wxInt32)num)/((wxInt32)denum); m_height *= ((wxInt32)num)/((wxInt32)denum);} | |
c3a4297c VZ |
736 | |
737 | wxRect2DInt& operator = (const wxRect2DInt& rect); | |
cd501207 JS |
738 | bool operator == (const wxRect2DInt& rect) const; |
739 | bool operator != (const wxRect2DInt& rect) const; | |
c3a4297c | 740 | |
cd501207 JS |
741 | void WriteTo( wxDataOutputStream &stream ) const; |
742 | void ReadFrom( wxDataInputStream &stream ); | |
c3a4297c | 743 | |
11e82c1b | 744 | wxInt32 m_x; |
cd501207 JS |
745 | wxInt32 m_y; |
746 | wxInt32 m_width; | |
747 | wxInt32 m_height; | |
72e7876b SC |
748 | }; |
749 | ||
f91de7da DW |
750 | inline wxRect2DInt::wxRect2DInt( const wxRect2DInt &r ) |
751 | { | |
11e82c1b VZ |
752 | m_x = r.m_x; |
753 | m_y = r.m_y; | |
754 | m_width = r.m_width; | |
755 | m_height = r.m_height; | |
f91de7da DW |
756 | } |
757 | ||
758 | inline wxRect2DInt::wxRect2DInt( const wxPoint2DInt &a , const wxPoint2DInt &b) | |
759 | { | |
11e82c1b VZ |
760 | m_x = wxMin( a.m_x , b.m_x ); |
761 | m_y = wxMin( a.m_y , b.m_y ); | |
762 | m_width = abs( a.m_x - b.m_x ); | |
763 | m_height = abs( a.m_y - b.m_y ); | |
f91de7da | 764 | } |
72e7876b | 765 | |
cd501207 JS |
766 | inline bool wxRect2DInt::operator == (const wxRect2DInt& rect) const |
767 | { | |
768 | return (m_x==rect.m_x && m_y==rect.m_y && | |
769 | m_width==rect.m_width && m_height==rect.m_height); | |
770 | } | |
771 | ||
772 | inline bool wxRect2DInt::operator != (const wxRect2DInt& rect) const | |
773 | { | |
774 | return !(*this == rect); | |
775 | } | |
776 | ||
72e7876b SC |
777 | class wxTransform2D |
778 | { | |
779 | public : | |
11e82c1b VZ |
780 | virtual void Transform( wxPoint2DInt* pt )const = 0; |
781 | virtual void Transform( wxRect2DInt* r ) const; | |
782 | virtual wxPoint2DInt Transform( const wxPoint2DInt &pt ) const; | |
783 | virtual wxRect2DInt Transform( const wxRect2DInt &r ) const ; | |
c3a4297c VZ |
784 | |
785 | virtual void InverseTransform( wxPoint2DInt* pt ) const = 0; | |
11e82c1b VZ |
786 | virtual void InverseTransform( wxRect2DInt* r ) const ; |
787 | virtual wxPoint2DInt InverseTransform( const wxPoint2DInt &pt ) const ; | |
788 | virtual wxRect2DInt InverseTransform( const wxRect2DInt &r ) const ; | |
789 | }; | |
72e7876b | 790 | |
f91de7da | 791 | inline void wxTransform2D::Transform( wxRect2DInt* r ) const |
11e82c1b | 792 | { wxPoint2DInt a = r->GetLeftTop() , b = r->GetRightBottom(); Transform( &a ); Transform( &b ); *r = wxRect2DInt( a , b ); } |
72e7876b | 793 | |
f91de7da | 794 | inline wxPoint2DInt wxTransform2D::Transform( const wxPoint2DInt &pt ) const |
11e82c1b | 795 | { wxPoint2DInt res = pt; Transform( &res ); return res; } |
72e7876b | 796 | |
f91de7da | 797 | inline wxRect2DInt wxTransform2D::Transform( const wxRect2DInt &r ) const |
11e82c1b | 798 | { wxRect2DInt res = r; Transform( &res ); return res; } |
72e7876b | 799 | |
f91de7da | 800 | inline void wxTransform2D::InverseTransform( wxRect2DInt* r ) const |
11e82c1b | 801 | { wxPoint2DInt a = r->GetLeftTop() , b = r->GetRightBottom(); InverseTransform( &a ); InverseTransform( &b ); *r = wxRect2DInt( a , b ); } |
72e7876b | 802 | |
f91de7da | 803 | inline wxPoint2DInt wxTransform2D::InverseTransform( const wxPoint2DInt &pt ) const |
11e82c1b | 804 | { wxPoint2DInt res = pt; InverseTransform( &res ); return res; } |
72e7876b | 805 | |
f91de7da | 806 | inline wxRect2DInt wxTransform2D::InverseTransform( const wxRect2DInt &r ) const |
11e82c1b | 807 | { wxRect2DInt res = r; InverseTransform( &res ); return res; } |
72e7876b | 808 | |
c3a4297c VZ |
809 | |
810 | #endif // wxUSE_GEOMETRY | |
811 | ||
812 | #endif // _WX_GEOMETRY_H_ |