]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/common/geometry.cpp | |
3 | // Purpose: Common Geometry Classes | |
4 | // Author: Stefan Csomor | |
5 | // Modified by: | |
6 | // Created: 08/05/99 | |
7 | // Copyright: (c) 1999 Stefan Csomor | |
8 | // Licence: wxWindows licence | |
9 | ///////////////////////////////////////////////////////////////////////////// | |
10 | ||
11 | // For compilers that support precompilation, includes "wx.h". | |
12 | #include "wx/wxprec.h" | |
13 | ||
14 | #ifdef __BORLANDC__ | |
15 | #pragma hdrstop | |
16 | #endif | |
17 | ||
18 | #if wxUSE_GEOMETRY | |
19 | ||
20 | #include "wx/geometry.h" | |
21 | ||
22 | #ifndef WX_PRECOMP | |
23 | #include "wx/log.h" | |
24 | #endif | |
25 | ||
26 | #include <string.h> | |
27 | ||
28 | #include "wx/datstrm.h" | |
29 | ||
30 | // | |
31 | // wxPoint2D | |
32 | // | |
33 | ||
34 | // | |
35 | // wxRect2D | |
36 | // | |
37 | ||
38 | // wxDouble version | |
39 | ||
40 | // for the following calculations always remember | |
41 | // that the right and bottom edges are not part of a rect | |
42 | ||
43 | bool wxRect2DDouble::Intersects( const wxRect2DDouble &rect ) const | |
44 | { | |
45 | wxDouble left,right,bottom,top; | |
46 | left = wxMax ( m_x , rect.m_x ); | |
47 | right = wxMin ( m_x+m_width, rect.m_x + rect.m_width ); | |
48 | top = wxMax ( m_y , rect.m_y ); | |
49 | bottom = wxMin ( m_y+m_height, rect.m_y + rect.m_height ); | |
50 | ||
51 | if ( left < right && top < bottom ) | |
52 | { | |
53 | return true; | |
54 | } | |
55 | return false; | |
56 | } | |
57 | ||
58 | void wxRect2DDouble::Intersect( const wxRect2DDouble &src1 , const wxRect2DDouble &src2 , wxRect2DDouble *dest ) | |
59 | { | |
60 | wxDouble left,right,bottom,top; | |
61 | left = wxMax ( src1.m_x , src2.m_x ); | |
62 | right = wxMin ( src1.m_x+src1.m_width, src2.m_x + src2.m_width ); | |
63 | top = wxMax ( src1.m_y , src2.m_y ); | |
64 | bottom = wxMin ( src1.m_y+src1.m_height, src2.m_y + src2.m_height ); | |
65 | ||
66 | if ( left < right && top < bottom ) | |
67 | { | |
68 | dest->m_x = left; | |
69 | dest->m_y = top; | |
70 | dest->m_width = right - left; | |
71 | dest->m_height = bottom - top; | |
72 | } | |
73 | else | |
74 | { | |
75 | dest->m_width = dest->m_height = 0; | |
76 | } | |
77 | } | |
78 | ||
79 | void wxRect2DDouble::Union( const wxRect2DDouble &src1 , const wxRect2DDouble &src2 , wxRect2DDouble *dest ) | |
80 | { | |
81 | wxDouble left,right,bottom,top; | |
82 | ||
83 | left = wxMin ( src1.m_x , src2.m_x ); | |
84 | right = wxMax ( src1.m_x+src1.m_width, src2.m_x + src2.m_width ); | |
85 | top = wxMin ( src1.m_y , src2.m_y ); | |
86 | bottom = wxMax ( src1.m_y+src1.m_height, src2.m_y + src2.m_height ); | |
87 | ||
88 | dest->m_x = left; | |
89 | dest->m_y = top; | |
90 | dest->m_width = right - left; | |
91 | dest->m_height = bottom - top; | |
92 | } | |
93 | ||
94 | void wxRect2DDouble::Union( const wxPoint2DDouble &pt ) | |
95 | { | |
96 | wxDouble x = pt.m_x; | |
97 | wxDouble y = pt.m_y; | |
98 | ||
99 | if ( x < m_x ) | |
100 | { | |
101 | SetLeft( x ); | |
102 | } | |
103 | else if ( x < m_x + m_width ) | |
104 | { | |
105 | // contained | |
106 | } | |
107 | else | |
108 | { | |
109 | SetRight( x ); | |
110 | } | |
111 | ||
112 | if ( y < m_y ) | |
113 | { | |
114 | SetTop( y ); | |
115 | } | |
116 | else if ( y < m_y + m_height ) | |
117 | { | |
118 | // contained | |
119 | } | |
120 | else | |
121 | { | |
122 | SetBottom( y ); | |
123 | } | |
124 | } | |
125 | ||
126 | void wxRect2DDouble::ConstrainTo( const wxRect2DDouble &rect ) | |
127 | { | |
128 | if ( GetLeft() < rect.GetLeft() ) | |
129 | SetLeft( rect.GetLeft() ); | |
130 | ||
131 | if ( GetRight() > rect.GetRight() ) | |
132 | SetRight( rect.GetRight() ); | |
133 | ||
134 | if ( GetBottom() > rect.GetBottom() ) | |
135 | SetBottom( rect.GetBottom() ); | |
136 | ||
137 | if ( GetTop() < rect.GetTop() ) | |
138 | SetTop( rect.GetTop() ); | |
139 | } | |
140 | ||
141 | wxRect2DDouble& wxRect2DDouble::operator=( const wxRect2DDouble &r ) | |
142 | { | |
143 | m_x = r.m_x; | |
144 | m_y = r.m_y; | |
145 | m_width = r.m_width; | |
146 | m_height = r.m_height; | |
147 | return *this; | |
148 | } | |
149 | ||
150 | // integer version | |
151 | ||
152 | // for the following calculations always remember | |
153 | // that the right and bottom edges are not part of a rect | |
154 | ||
155 | // wxPoint2D | |
156 | ||
157 | #if wxUSE_STREAMS | |
158 | void wxPoint2DInt::WriteTo( wxDataOutputStream &stream ) const | |
159 | { | |
160 | stream.Write32( m_x ); | |
161 | stream.Write32( m_y ); | |
162 | } | |
163 | ||
164 | void wxPoint2DInt::ReadFrom( wxDataInputStream &stream ) | |
165 | { | |
166 | m_x = stream.Read32(); | |
167 | m_y = stream.Read32(); | |
168 | } | |
169 | #endif // wxUSE_STREAMS | |
170 | ||
171 | wxDouble wxPoint2DInt::GetVectorAngle() const | |
172 | { | |
173 | if ( m_x == 0 ) | |
174 | { | |
175 | if ( m_y >= 0 ) | |
176 | return 90; | |
177 | else | |
178 | return 270; | |
179 | } | |
180 | if ( m_y == 0 ) | |
181 | { | |
182 | if ( m_x >= 0 ) | |
183 | return 0; | |
184 | else | |
185 | return 180; | |
186 | } | |
187 | ||
188 | // casts needed for MIPSpro compiler under SGI | |
189 | wxDouble deg = atan2( (double)m_y , (double)m_x ) * 180 / M_PI; | |
190 | if ( deg < 0 ) | |
191 | { | |
192 | deg += 360; | |
193 | } | |
194 | return deg; | |
195 | } | |
196 | ||
197 | ||
198 | void wxPoint2DInt::SetVectorAngle( wxDouble degrees ) | |
199 | { | |
200 | wxDouble length = GetVectorLength(); | |
201 | m_x = (int)(length * cos( degrees / 180 * M_PI )); | |
202 | m_y = (int)(length * sin( degrees / 180 * M_PI )); | |
203 | } | |
204 | ||
205 | wxDouble wxPoint2DDouble::GetVectorAngle() const | |
206 | { | |
207 | if ( wxIsNullDouble(m_x) ) | |
208 | { | |
209 | if ( m_y >= 0 ) | |
210 | return 90; | |
211 | else | |
212 | return 270; | |
213 | } | |
214 | if ( wxIsNullDouble(m_y) ) | |
215 | { | |
216 | if ( m_x >= 0 ) | |
217 | return 0; | |
218 | else | |
219 | return 180; | |
220 | } | |
221 | wxDouble deg = atan2( m_y , m_x ) * 180 / M_PI; | |
222 | if ( deg < 0 ) | |
223 | { | |
224 | deg += 360; | |
225 | } | |
226 | return deg; | |
227 | } | |
228 | ||
229 | void wxPoint2DDouble::SetVectorAngle( wxDouble degrees ) | |
230 | { | |
231 | wxDouble length = GetVectorLength(); | |
232 | m_x = length * cos( degrees / 180 * M_PI ); | |
233 | m_y = length * sin( degrees / 180 * M_PI ); | |
234 | } | |
235 | ||
236 | // wxRect2D | |
237 | ||
238 | bool wxRect2DInt::Intersects( const wxRect2DInt &rect ) const | |
239 | { | |
240 | wxInt32 left,right,bottom,top; | |
241 | left = wxMax ( m_x , rect.m_x ); | |
242 | right = wxMin ( m_x+m_width, rect.m_x + rect.m_width ); | |
243 | top = wxMax ( m_y , rect.m_y ); | |
244 | bottom = wxMin ( m_y+m_height, rect.m_y + rect.m_height ); | |
245 | ||
246 | if ( left < right && top < bottom ) | |
247 | { | |
248 | return true; | |
249 | } | |
250 | return false; | |
251 | } | |
252 | ||
253 | void wxRect2DInt::Intersect( const wxRect2DInt &src1 , const wxRect2DInt &src2 , wxRect2DInt *dest ) | |
254 | { | |
255 | wxInt32 left,right,bottom,top; | |
256 | left = wxMax ( src1.m_x , src2.m_x ); | |
257 | right = wxMin ( src1.m_x+src1.m_width, src2.m_x + src2.m_width ); | |
258 | top = wxMax ( src1.m_y , src2.m_y ); | |
259 | bottom = wxMin ( src1.m_y+src1.m_height, src2.m_y + src2.m_height ); | |
260 | ||
261 | if ( left < right && top < bottom ) | |
262 | { | |
263 | dest->m_x = left; | |
264 | dest->m_y = top; | |
265 | dest->m_width = right - left; | |
266 | dest->m_height = bottom - top; | |
267 | } | |
268 | else | |
269 | { | |
270 | dest->m_width = dest->m_height = 0; | |
271 | } | |
272 | } | |
273 | ||
274 | void wxRect2DInt::Union( const wxRect2DInt &src1 , const wxRect2DInt &src2 , wxRect2DInt *dest ) | |
275 | { | |
276 | wxInt32 left,right,bottom,top; | |
277 | ||
278 | left = wxMin ( src1.m_x , src2.m_x ); | |
279 | right = wxMax ( src1.m_x+src1.m_width, src2.m_x + src2.m_width ); | |
280 | top = wxMin ( src1.m_y , src2.m_y ); | |
281 | bottom = wxMax ( src1.m_y+src1.m_height, src2.m_y + src2.m_height ); | |
282 | ||
283 | dest->m_x = left; | |
284 | dest->m_y = top; | |
285 | dest->m_width = right - left; | |
286 | dest->m_height = bottom - top; | |
287 | } | |
288 | ||
289 | void wxRect2DInt::Union( const wxPoint2DInt &pt ) | |
290 | { | |
291 | wxInt32 x = pt.m_x; | |
292 | wxInt32 y = pt.m_y; | |
293 | ||
294 | if ( x < m_x ) | |
295 | { | |
296 | SetLeft( x ); | |
297 | } | |
298 | else if ( x < m_x + m_width ) | |
299 | { | |
300 | // contained | |
301 | } | |
302 | else | |
303 | { | |
304 | SetRight( x ); | |
305 | } | |
306 | ||
307 | if ( y < m_y ) | |
308 | { | |
309 | SetTop( y ); | |
310 | } | |
311 | else if ( y < m_y + m_height ) | |
312 | { | |
313 | // contained | |
314 | } | |
315 | else | |
316 | { | |
317 | SetBottom( y ); | |
318 | } | |
319 | } | |
320 | ||
321 | void wxRect2DInt::ConstrainTo( const wxRect2DInt &rect ) | |
322 | { | |
323 | if ( GetLeft() < rect.GetLeft() ) | |
324 | SetLeft( rect.GetLeft() ); | |
325 | ||
326 | if ( GetRight() > rect.GetRight() ) | |
327 | SetRight( rect.GetRight() ); | |
328 | ||
329 | if ( GetBottom() > rect.GetBottom() ) | |
330 | SetBottom( rect.GetBottom() ); | |
331 | ||
332 | if ( GetTop() < rect.GetTop() ) | |
333 | SetTop( rect.GetTop() ); | |
334 | } | |
335 | ||
336 | wxRect2DInt& wxRect2DInt::operator=( const wxRect2DInt &r ) | |
337 | { | |
338 | m_x = r.m_x; | |
339 | m_y = r.m_y; | |
340 | m_width = r.m_width; | |
341 | m_height = r.m_height; | |
342 | return *this; | |
343 | } | |
344 | ||
345 | #if wxUSE_STREAMS | |
346 | void wxRect2DInt::WriteTo( wxDataOutputStream &stream ) const | |
347 | { | |
348 | stream.Write32( m_x ); | |
349 | stream.Write32( m_y ); | |
350 | stream.Write32( m_width ); | |
351 | stream.Write32( m_height ); | |
352 | } | |
353 | ||
354 | void wxRect2DInt::ReadFrom( wxDataInputStream &stream ) | |
355 | { | |
356 | m_x = stream.Read32(); | |
357 | m_y = stream.Read32(); | |
358 | m_width = stream.Read32(); | |
359 | m_height = stream.Read32(); | |
360 | } | |
361 | #endif // wxUSE_STREAMS | |
362 | ||
363 | ||
364 | // wxTransform2D | |
365 | ||
366 | void wxTransform2D::Transform( wxRect2DInt* r ) const | |
367 | { | |
368 | wxPoint2DInt a = r->GetLeftTop(), b = r->GetRightBottom(); | |
369 | Transform( &a ); | |
370 | Transform( &b ); | |
371 | *r = wxRect2DInt( a, b ); | |
372 | } | |
373 | ||
374 | wxPoint2DInt wxTransform2D::Transform( const wxPoint2DInt &pt ) const | |
375 | { | |
376 | wxPoint2DInt res = pt; | |
377 | Transform( &res ); | |
378 | return res; | |
379 | } | |
380 | ||
381 | wxRect2DInt wxTransform2D::Transform( const wxRect2DInt &r ) const | |
382 | { | |
383 | wxRect2DInt res = r; | |
384 | Transform( &res ); | |
385 | return res; | |
386 | } | |
387 | ||
388 | void wxTransform2D::InverseTransform( wxRect2DInt* r ) const | |
389 | { | |
390 | wxPoint2DInt a = r->GetLeftTop(), b = r->GetRightBottom(); | |
391 | InverseTransform( &a ); | |
392 | InverseTransform( &b ); | |
393 | *r = wxRect2DInt( a , b ); | |
394 | } | |
395 | ||
396 | wxPoint2DInt wxTransform2D::InverseTransform( const wxPoint2DInt &pt ) const | |
397 | { | |
398 | wxPoint2DInt res = pt; | |
399 | InverseTransform( &res ); | |
400 | return res; | |
401 | } | |
402 | ||
403 | wxRect2DInt wxTransform2D::InverseTransform( const wxRect2DInt &r ) const | |
404 | { | |
405 | wxRect2DInt res = r; | |
406 | InverseTransform( &res ); | |
407 | return res; | |
408 | } | |
409 | ||
410 | #endif // wxUSE_GEOMETRY |