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