]> git.saurik.com Git - wxWidgets.git/blob - src/motif/region.cpp
Committing in .
[wxWidgets.git] / src / motif / region.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // File: region.cpp
3 // Purpose: Region class
4 // Author: Markus Holzem/Julian Smart
5 // Created: Fri Oct 24 10:46:34 MET 1997
6 // RCS-ID: $Id$
7 // Copyright: (c) 1997 Markus Holzem/Julian Smart
8 // Licence: wxWindows licence
9 /////////////////////////////////////////////////////////////////////////////
10
11 #ifdef __GNUG__
12 #pragma implementation "region.h"
13 #endif
14
15 #include "wx/region.h"
16 #include "wx/gdicmn.h"
17
18 #ifdef __VMS__
19 #pragma message disable nosimpint
20 #endif
21 #include <Xm/Xm.h>
22 #ifdef __VMS__
23 #pragma message enable nosimpint
24 #endif
25 // #include "wx/motif/private.h"
26
27 #if !USE_SHARED_LIBRARY
28 IMPLEMENT_DYNAMIC_CLASS(wxRegion, wxGDIObject)
29 IMPLEMENT_DYNAMIC_CLASS(wxRegionIterator, wxObject)
30 #endif
31
32 // ----------------------------------------------------------------------------
33 // list types
34 // ----------------------------------------------------------------------------
35
36 #include "wx/listimpl.cpp"
37
38 WX_DEFINE_LIST(wxRectList);
39
40 //-----------------------------------------------------------------------------
41 // wxRegionRefData implementation
42 //-----------------------------------------------------------------------------
43
44 class WXDLLEXPORT wxRegionRefData : public wxGDIRefData {
45 public:
46 wxRegionRefData()
47 {
48 m_region = XCreateRegion();
49 m_usingRects = FALSE;
50 m_rects = (wxRect*) NULL;
51 m_rectCount = 0;
52 }
53
54 wxRegionRefData(const wxRegionRefData& data)
55 {
56 m_region = XCreateRegion();
57 m_rects = (wxRect*) NULL;
58 m_rectCount = 0;
59 XUnionRegion(m_region, data.m_region, m_region);
60
61 SetRects(data.m_rectCount, data.m_rects);
62 }
63
64 ~wxRegionRefData()
65 {
66 XDestroyRegion(m_region);
67 DeleteRects();
68 }
69
70 wxRect* GetRects() { return m_rects; };
71 void SetRects(const wxRectList& rectList);
72 void SetRects(int count, const wxRect* rects);
73 bool UsingRects() const { return m_usingRects; }
74 int GetRectCount() const { return m_rectCount; }
75
76 void DeleteRects();
77
78 Region m_region;
79 wxRect* m_rects;
80 int m_rectCount;
81 bool m_usingRects; // TRUE if we're using the above.
82 };
83
84 void wxRegionRefData::SetRects(const wxRectList& rectList)
85 {
86 DeleteRects();
87 m_usingRects = (rectList.Number() > 0);
88 if (m_usingRects)
89 {
90 m_rectCount = rectList.Number();
91 m_rects = new wxRect[m_rectCount];
92 }
93
94 wxRectList::Node* node = rectList.GetFirst();
95 int i = 0;
96 while (node) {
97 wxRect* rect = node->GetData();
98 m_rects[i] = * rect;
99 node = node->GetNext();
100 i ++;
101 }
102 }
103
104 void wxRegionRefData::SetRects(int count, const wxRect* rects)
105 {
106 DeleteRects();
107 m_usingRects = (count > 0);
108 if (m_usingRects)
109 {
110 m_rectCount = count;
111 m_rects = new wxRect[m_rectCount];
112 int i;
113 for (i = 0; i < m_rectCount; i++)
114 m_rects[i] = rects[i];
115 }
116 }
117
118 void wxRegionRefData::DeleteRects()
119 {
120 if (m_rects)
121 {
122 delete[] m_rects;
123 m_rects = (wxRect*) NULL;
124 }
125 m_rectCount = 0;
126 m_usingRects = FALSE;
127 }
128
129 #define M_REGION (((wxRegionRefData*)m_refData)->m_region)
130
131 //-----------------------------------------------------------------------------
132 // wxRegion
133 //-----------------------------------------------------------------------------
134
135 /*!
136 * Create an empty region.
137 */
138 wxRegion::wxRegion()
139 {
140 }
141
142 wxRegion::wxRegion(long x, long y, long w, long h)
143 {
144 m_refData = new wxRegionRefData;
145
146 XRectangle rect;
147 rect.x = x;
148 rect.y = y;
149 rect.width = w;
150 rect.height = h;
151 XUnionRectWithRegion(&rect, M_REGION, M_REGION);
152 }
153
154 wxRegion::wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight)
155 {
156 m_refData = new wxRegionRefData;
157
158 XRectangle rect;
159 rect.x = topLeft.x;
160 rect.y = topLeft.y;
161 rect.width = bottomRight.x - topLeft.x;
162 rect.height = bottomRight.y - topLeft.y;
163 XUnionRectWithRegion(&rect, M_REGION, M_REGION);
164 }
165
166 wxRegion::wxRegion(const wxRect& rect)
167 {
168 m_refData = new wxRegionRefData;
169
170 XRectangle rect1;
171 rect1.x = rect.x;
172 rect1.y = rect.y;
173 rect1.width = rect.width;
174 rect1.height = rect.height;
175 XUnionRectWithRegion(&rect1, M_REGION, M_REGION);
176 }
177
178 /*!
179 * Destroy the region.
180 */
181 wxRegion::~wxRegion()
182 {
183 // m_refData unrefed in ~wxObject
184 }
185
186 // Get the internal region handle
187 WXRegion wxRegion::GetXRegion() const
188 {
189 wxASSERT( m_refData !=NULL );
190
191 return (WXRegion) ((wxRegionRefData*)m_refData)->m_region;
192 }
193
194 //-----------------------------------------------------------------------------
195 //# Modify region
196 //-----------------------------------------------------------------------------
197
198 //! Clear current region
199 void wxRegion::Clear()
200 {
201 UnRef();
202 }
203
204 //! Combine rectangle (x, y, w, h) with this.
205 bool wxRegion::Combine(long x, long y, long width, long height, wxRegionOp op)
206 {
207 // Don't change shared data
208 if (!m_refData) {
209 m_refData = new wxRegionRefData();
210 } else if (m_refData->GetRefCount() > 1) {
211 wxRegionRefData* ref = (wxRegionRefData*)m_refData;
212 UnRef();
213 m_refData = new wxRegionRefData(*ref);
214 }
215 // If ref count is 1, that means it's 'ours' anyway so no action.
216
217 Region rectRegion = XCreateRegion();
218
219 XRectangle rect;
220 rect.x = x;
221 rect.y = y;
222 rect.width = width;
223 rect.height = height;
224 XUnionRectWithRegion(&rect, rectRegion, rectRegion);
225
226 switch (op)
227 {
228 case wxRGN_AND:
229 XIntersectRegion(M_REGION, rectRegion, M_REGION);
230 break ;
231 case wxRGN_OR:
232 XUnionRegion(M_REGION, rectRegion, M_REGION);
233 break ;
234 case wxRGN_XOR:
235 // TODO
236 break ;
237 case wxRGN_DIFF:
238 // TODO
239 break ;
240 case wxRGN_COPY: // Don't have to do this one
241 default:
242 // TODO
243 break ;
244 }
245
246 return FALSE;
247 }
248
249 //! Union /e region with this.
250 bool wxRegion::Combine(const wxRegion& region, wxRegionOp op)
251 {
252 if (region.Empty())
253 return FALSE;
254
255 // Don't change shared data
256 if (!m_refData) {
257 m_refData = new wxRegionRefData();
258 } else if (m_refData->GetRefCount() > 1) {
259 wxRegionRefData* ref = (wxRegionRefData*)m_refData;
260 UnRef();
261 m_refData = new wxRegionRefData(*ref);
262 }
263
264 switch (op)
265 {
266 case wxRGN_AND:
267 XIntersectRegion(M_REGION, ((wxRegionRefData*)region.m_refData)->m_region,
268 M_REGION);
269 break ;
270 case wxRGN_OR:
271 XUnionRegion(M_REGION, ((wxRegionRefData*)region.m_refData)->m_region,
272 M_REGION);
273 break ;
274 case wxRGN_XOR:
275 // TODO
276 break ;
277 case wxRGN_DIFF:
278 // TODO
279 break ;
280 case wxRGN_COPY: // Don't have to do this one
281 default:
282 // TODO
283 break ;
284 }
285
286 return FALSE;
287 }
288
289 bool wxRegion::Combine(const wxRect& rect, wxRegionOp op)
290 {
291 return Combine(rect.GetLeft(), rect.GetTop(), rect.GetWidth(), rect.GetHeight(), op);
292 }
293
294 //-----------------------------------------------------------------------------
295 //# Information on region
296 //-----------------------------------------------------------------------------
297
298 // Outer bounds of region
299 void wxRegion::GetBox(long& x, long& y, long&w, long &h) const
300 {
301 if (m_refData) {
302 XRectangle rect;
303 XClipBox(M_REGION, &rect);
304 x = rect.x;
305 y = rect.y;
306 w = rect.width;
307 h = rect.height;
308 } else {
309 x = y = w = h = 0;
310 }
311 }
312
313 wxRect wxRegion::GetBox() const
314 {
315 long x, y, w, h;
316 GetBox(x, y, w, h);
317 return wxRect(x, y, w, h);
318 }
319
320 // Is region empty?
321 bool wxRegion::Empty() const
322 {
323 return m_refData ? XEmptyRegion(M_REGION) : TRUE;
324 }
325
326 //-----------------------------------------------------------------------------
327 //# Tests
328 //-----------------------------------------------------------------------------
329
330 // Does the region contain the point (x,y)?
331 wxRegionContain wxRegion::Contains(long WXUNUSED(x), long WXUNUSED(y)) const
332 {
333 if (!m_refData)
334 return wxOutRegion;
335
336 // TODO. Return wxInRegion if within region.
337 if (0)
338 return wxInRegion;
339 return wxOutRegion;
340 }
341
342 // Does the region contain the point pt?
343 wxRegionContain wxRegion::Contains(const wxPoint& pt) const
344 {
345 if (!m_refData)
346 return wxOutRegion;
347
348 return XPointInRegion(M_REGION, pt.x, pt.y) ? wxInRegion : wxOutRegion;
349 }
350
351 // Does the region contain the rectangle (x, y, w, h)?
352 wxRegionContain wxRegion::Contains(long x, long y, long w, long h) const
353 {
354 if (!m_refData)
355 return wxOutRegion;
356
357 switch (XRectInRegion(M_REGION, x, y, w, h)) {
358 case RectangleIn: return wxInRegion;
359 case RectanglePart: return wxPartRegion;
360 }
361 return wxOutRegion;
362 }
363
364 // Does the region contain the rectangle rect
365 wxRegionContain wxRegion::Contains(const wxRect& rect) const
366 {
367 if (!m_refData)
368 return wxOutRegion;
369
370 long x, y, w, h;
371 x = rect.x;
372 y = rect.y;
373 w = rect.GetWidth();
374 h = rect.GetHeight();
375 return Contains(x, y, w, h);
376 }
377
378 bool wxRegion::UsingRects() const
379 {
380 return ((wxRegionRefData*)m_refData)->UsingRects();
381 }
382
383 /*
384 wxRectList& wxRegion::GetRectList()
385 {
386 return ((wxRegionRefData*)m_refData)->GetRectList();
387 }
388 */
389
390 wxRect* wxRegion::GetRects()
391 {
392 return ((wxRegionRefData*)m_refData)->GetRects();
393 }
394
395 int wxRegion::GetRectCount() const
396 {
397 return ((wxRegionRefData*)m_refData)->GetRectCount();
398 }
399
400 void wxRegion::SetRects(const wxRectList& rectList)
401 {
402 ((wxRegionRefData*)m_refData)->SetRects(rectList);
403 }
404
405 void wxRegion::SetRects(int count, const wxRect* rects)
406 {
407 ((wxRegionRefData*)m_refData)->SetRects(count, rects);
408 }
409
410 ///////////////////////////////////////////////////////////////////////////////
411 // //
412 // wxRegionIterator //
413 // //
414 ///////////////////////////////////////////////////////////////////////////////
415
416 /*!
417 * Initialize empty iterator
418 */
419 wxRegionIterator::wxRegionIterator() : m_current(0), m_numRects(0), m_rects(NULL)
420 {
421 }
422
423 wxRegionIterator::~wxRegionIterator()
424 {
425 if (m_rects)
426 delete[] m_rects;
427 }
428
429 /*!
430 * Initialize iterator for region
431 */
432 wxRegionIterator::wxRegionIterator(const wxRegion& region)
433 {
434 m_rects = NULL;
435
436 Reset(region);
437 }
438
439 /*!
440 * Reset iterator for a new /e region.
441 */
442 void wxRegionIterator::Reset(const wxRegion& region)
443 {
444 m_current = 0;
445 m_region = region;
446
447 if (m_rects)
448 delete[] m_rects;
449
450 m_rects = NULL;
451
452 if (m_region.Empty())
453 m_numRects = 0;
454 else
455 {
456 // Create m_rects and fill with rectangles for this region.
457 // Since we can't find the rectangles in a region, we cheat
458 // by retrieving the rectangles explicitly set in wxPaintDC::wxPaintDC
459 // (dcclient.cpp).
460 if (m_region.UsingRects())
461 {
462 wxRect* rects = m_region.GetRects();
463 int count = m_region.GetRectCount();
464 m_numRects = count;
465 m_rects = new wxRect[m_numRects];
466
467 int i = 0;
468 for (i = 0; i < m_numRects; i++)
469 m_rects[i] = rects[i];
470
471 /*
472 int i = 0;
473 wxRectList::Node* node = rectList.GetFirst();
474 while (node) {
475 wxRect* rect = node->GetData();
476 m_rects[i] = * rect;
477 node = node->GetNext();
478 i ++;
479 }
480 */
481 }
482 else
483 {
484 // For now, fudge by getting the whole bounding box.
485 m_rects = new wxRect[1];
486 m_numRects = 1;
487 m_rects[0] = m_region.GetBox();
488 }
489 }
490 }
491
492 /*!
493 * Increment iterator. The rectangle returned is the one after the
494 * incrementation.
495 */
496 void wxRegionIterator::operator ++ ()
497 {
498 if (m_current < m_numRects)
499 ++m_current;
500 }
501
502 /*!
503 * Increment iterator. The rectangle returned is the one before the
504 * incrementation.
505 */
506 void wxRegionIterator::operator ++ (int)
507 {
508 if (m_current < m_numRects)
509 ++m_current;
510 }
511
512 long wxRegionIterator::GetX() const
513 {
514 if (m_current < m_numRects)
515 return m_rects[m_current].x;
516 return 0;
517 }
518
519 long wxRegionIterator::GetY() const
520 {
521 if (m_current < m_numRects)
522 return m_rects[m_current].y;
523 return 0;
524 }
525
526 long wxRegionIterator::GetW() const
527 {
528 if (m_current < m_numRects)
529 return m_rects[m_current].width ;
530 return 0;
531 }
532
533 long wxRegionIterator::GetH() const
534 {
535 if (m_current < m_numRects)
536 return m_rects[m_current].height;
537 return 0;
538 }
539