]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/mgl/region.cpp | |
3 | // Purpose: Region handling for wxWidgets/MGL | |
4 | // Author: Vaclav Slavik | |
5 | // RCS-ID: $Id$ | |
6 | // Copyright: (c) 2001-2002 SciTech Software, Inc. (www.scitechsoft.com) | |
7 | // Licence: wxWindows licence | |
8 | ///////////////////////////////////////////////////////////////////////////// | |
9 | ||
10 | // For compilers that support precompilation, includes "wx.h". | |
11 | #include "wx/wxprec.h" | |
12 | ||
13 | #ifdef __BORLANDC__ | |
14 | #pragma hdrstop | |
15 | #endif | |
16 | ||
17 | #include "wx/region.h" | |
18 | #include "wx/gdicmn.h" | |
19 | #include "wx/thread.h" | |
20 | #include "wx/module.h" | |
21 | ||
22 | #include <mgraph.hpp> | |
23 | ||
24 | #include "wx/listimpl.cpp" | |
25 | WX_DEFINE_LIST(wxRegionRectList) | |
26 | ||
27 | IMPLEMENT_DYNAMIC_CLASS(wxRegion, wxGDIObject) | |
28 | IMPLEMENT_DYNAMIC_CLASS(wxRegionIterator, wxObject) | |
29 | ||
30 | //----------------------------------------------------------------------------- | |
31 | // wxRegionRefData implementation | |
32 | //----------------------------------------------------------------------------- | |
33 | ||
34 | class WXDLLEXPORT wxRegionRefData : public wxGDIRefData | |
35 | { | |
36 | public: | |
37 | wxRegionRefData() {} | |
38 | ||
39 | wxRegionRefData(const wxRegionRefData& data) | |
40 | { | |
41 | m_region = data.m_region; | |
42 | } | |
43 | ||
44 | ~wxRegionRefData() {} | |
45 | ||
46 | MGLRegion m_region; | |
47 | }; | |
48 | ||
49 | #define M_REGION (((wxRegionRefData*)m_refData)->m_region) | |
50 | #define M_REGION_OF(r) (((wxRegionRefData*)(r.m_refData))->m_region) | |
51 | ||
52 | //----------------------------------------------------------------------------- | |
53 | // wxRegion | |
54 | //----------------------------------------------------------------------------- | |
55 | ||
56 | wxObjectRefData *wxRegion::CreateRefData() const | |
57 | { | |
58 | return new wxRegionRefData; | |
59 | } | |
60 | ||
61 | wxObjectRefData *wxRegion::CloneRefData(const wxObjectRefData *data) const | |
62 | { | |
63 | return new wxRegionRefData(*(wxRegionRefData *)data); | |
64 | } | |
65 | ||
66 | /* | |
67 | * Create an empty region. | |
68 | */ | |
69 | wxRegion::wxRegion() | |
70 | { | |
71 | m_refData = NULL; | |
72 | } | |
73 | ||
74 | wxRegion::wxRegion(wxCoord x, wxCoord y, wxCoord w, wxCoord h) | |
75 | { | |
76 | m_refData = new wxRegionRefData; | |
77 | MGLRect rect(x, y, x + w, y + h); | |
78 | M_REGION = rect; | |
79 | } | |
80 | ||
81 | wxRegion::wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight) | |
82 | { | |
83 | m_refData = new wxRegionRefData; | |
84 | MGLRect rect(topLeft.x, topLeft.y, bottomRight.x+1, bottomRight.y+1); | |
85 | M_REGION = rect; | |
86 | } | |
87 | ||
88 | wxRegion::wxRegion(const wxRect& r) | |
89 | { | |
90 | m_refData = new wxRegionRefData; | |
91 | MGLRect rect(r.GetLeft(), r.GetTop(), r.GetRight()+1, r.GetBottom()+1); | |
92 | M_REGION = rect; | |
93 | } | |
94 | ||
95 | wxRegion::wxRegion(const MGLRegion& region) | |
96 | { | |
97 | m_refData = new wxRegionRefData; | |
98 | M_REGION = region; | |
99 | } | |
100 | ||
101 | wxRegion::~wxRegion() | |
102 | { | |
103 | // m_refData unrefed in ~wxObject | |
104 | } | |
105 | ||
106 | const MGLRegion& wxRegion::GetMGLRegion() const | |
107 | { | |
108 | return M_REGION; | |
109 | } | |
110 | ||
111 | //----------------------------------------------------------------------------- | |
112 | // Modify region | |
113 | //----------------------------------------------------------------------------- | |
114 | ||
115 | // Clear current region | |
116 | void wxRegion::Clear() | |
117 | { | |
118 | UnRef(); | |
119 | } | |
120 | ||
121 | ||
122 | //----------------------------------------------------------------------------- | |
123 | // Information on region | |
124 | //----------------------------------------------------------------------------- | |
125 | ||
126 | // Outer bounds of region | |
127 | void wxRegion::GetBox(wxCoord& x, wxCoord& y, wxCoord&w, wxCoord &h) const | |
128 | { | |
129 | if (m_refData) | |
130 | { | |
131 | rect_t rect; | |
132 | rect = M_REGION.getBounds(); | |
133 | x = rect.left; | |
134 | y = rect.top; | |
135 | w = rect.right - rect.left; | |
136 | h = rect.bottom - rect.top; | |
137 | } | |
138 | else | |
139 | { | |
140 | x = y = w = h = 0; | |
141 | } | |
142 | } | |
143 | ||
144 | wxRect wxRegion::GetBox() const | |
145 | { | |
146 | wxCoord x, y, w, h; | |
147 | GetBox(x, y, w, h); | |
148 | return wxRect(x, y, w, h); | |
149 | } | |
150 | ||
151 | // Is region empty? | |
152 | bool wxRegion::Empty() const | |
153 | { | |
154 | if (!m_refData) | |
155 | return true; | |
156 | ||
157 | return (bool)(M_REGION.isEmpty()); | |
158 | } | |
159 | ||
160 | //----------------------------------------------------------------------------- | |
161 | // Modifications | |
162 | //----------------------------------------------------------------------------- | |
163 | ||
164 | bool wxRegion::Offset(wxCoord x, wxCoord y) | |
165 | { | |
166 | AllocExclusive(); | |
167 | M_REGION.offset(x, y); | |
168 | return true; | |
169 | } | |
170 | ||
171 | // Union rectangle or region with this. | |
172 | bool wxRegion::Union(wxCoord x, wxCoord y, wxCoord width, wxCoord height) | |
173 | { | |
174 | AllocExclusive(); | |
175 | M_REGION += MGLRect(x, y, x + width, y + height); | |
176 | return true; | |
177 | } | |
178 | ||
179 | bool wxRegion::Union(const wxRegion& region) | |
180 | { | |
181 | AllocExclusive(); | |
182 | M_REGION += M_REGION_OF(region); | |
183 | return true; | |
184 | } | |
185 | ||
186 | // Intersect rectangle or region with this. | |
187 | bool wxRegion::Intersect(wxCoord x, wxCoord y, wxCoord width, wxCoord height) | |
188 | { | |
189 | AllocExclusive(); | |
190 | M_REGION &= MGLRect(x, y, x + width, y + height); | |
191 | return true; | |
192 | } | |
193 | ||
194 | bool wxRegion::Intersect(const wxRegion& region) | |
195 | { | |
196 | AllocExclusive(); | |
197 | M_REGION &= M_REGION_OF(region); | |
198 | return true; | |
199 | } | |
200 | ||
201 | // Subtract rectangle or region from this: | |
202 | // Combines the parts of 'this' that are not part of the second region. | |
203 | bool wxRegion::Subtract(wxCoord x, wxCoord y, wxCoord width, wxCoord height) | |
204 | { | |
205 | AllocExclusive(); | |
206 | M_REGION -= MGLRect(x, y, x + width, y + height); | |
207 | return true; | |
208 | } | |
209 | ||
210 | bool wxRegion::Subtract(const wxRegion& region) | |
211 | { | |
212 | AllocExclusive(); | |
213 | M_REGION -= M_REGION_OF(region); | |
214 | return true; | |
215 | } | |
216 | ||
217 | // XOR: the union of two combined regions except for any overlapping areas. | |
218 | bool wxRegion::Xor(wxCoord x, wxCoord y, wxCoord width, wxCoord height) | |
219 | { | |
220 | AllocExclusive(); | |
221 | MGLRect rect(x, y, x + width, y + height); | |
222 | MGLRegion rg1 = M_REGION + rect, | |
223 | rg2 = M_REGION & rect; | |
224 | M_REGION = rg1 - rg2; | |
225 | return true; | |
226 | } | |
227 | ||
228 | bool wxRegion::Xor(const wxRegion& region) | |
229 | { | |
230 | AllocExclusive(); | |
231 | MGLRegion rg1 = M_REGION + M_REGION_OF(region), | |
232 | rg2 = M_REGION & M_REGION_OF(region); | |
233 | M_REGION = rg1 - rg2; | |
234 | return true; | |
235 | } | |
236 | ||
237 | ||
238 | //----------------------------------------------------------------------------- | |
239 | // Tests | |
240 | //----------------------------------------------------------------------------- | |
241 | ||
242 | // Does the region contain the point (x,y)? | |
243 | wxRegionContain wxRegion::Contains(wxCoord x, wxCoord y) const | |
244 | { | |
245 | if (!m_refData) | |
246 | return wxOutRegion; | |
247 | ||
248 | if (M_REGION.includes((int)x, (int)y)) | |
249 | return wxInRegion; | |
250 | else | |
251 | return wxOutRegion; | |
252 | } | |
253 | ||
254 | // Does the region contain the point pt? | |
255 | wxRegionContain wxRegion::Contains(const wxPoint& pt) const | |
256 | { | |
257 | return Contains(pt.x, pt.y); | |
258 | } | |
259 | ||
260 | // Does the region contain the rectangle (x, y, w, h)? | |
261 | wxRegionContain wxRegion::Contains(wxCoord x, wxCoord y, wxCoord w, wxCoord h) const | |
262 | { | |
263 | if (!m_refData) | |
264 | return wxOutRegion; | |
265 | ||
266 | MGLRect rect(x, y, x + w, y + h); | |
267 | MGLRegion rg; | |
268 | ||
269 | // 1) is the rectangle entirely covered by the region? | |
270 | rg = MGLRegion(rect) - M_REGION; | |
271 | if (rg.isEmpty()) return wxInRegion; | |
272 | ||
273 | // 2) is the rectangle completely outside the region? | |
274 | rg = M_REGION & rect; // intersection | |
275 | if (rg.isEmpty()) return wxOutRegion; | |
276 | ||
277 | // 3) neither case happened => it is partially covered: | |
278 | return wxPartRegion; | |
279 | } | |
280 | ||
281 | // Does the region contain the rectangle rect | |
282 | wxRegionContain wxRegion::Contains(const wxRect& rect) const | |
283 | { | |
284 | return Contains(rect.x, rect.y, rect.width, rect.height); | |
285 | } | |
286 | ||
287 | ||
288 | /////////////////////////////////////////////////////////////////////////////// | |
289 | // wxRegionIterator // | |
290 | /////////////////////////////////////////////////////////////////////////////// | |
291 | ||
292 | #if wxUSE_THREADS | |
293 | static wxMutex *gs_mutexIterator; | |
294 | ||
295 | class wxMglRegionModule : public wxModule | |
296 | { | |
297 | public: | |
298 | virtual bool OnInit() | |
299 | { | |
300 | gs_mutexIterator = new wxMutex(); | |
301 | return true; | |
302 | } | |
303 | virtual void OnExit() | |
304 | { | |
305 | wxDELETE(gs_mutexIterator); | |
306 | } | |
307 | ||
308 | DECLARE_DYNAMIC_CLASS(wxMglRegionModule) | |
309 | }; | |
310 | IMPLEMENT_DYNAMIC_CLASS(wxMglRegionModule, wxModule) | |
311 | #endif | |
312 | ||
313 | /* | |
314 | * Initialize empty iterator | |
315 | */ | |
316 | wxRegionIterator::wxRegionIterator() : m_currentNode(NULL) | |
317 | { | |
318 | m_rects.DeleteContents(true); | |
319 | } | |
320 | ||
321 | wxRegionIterator::~wxRegionIterator() | |
322 | { | |
323 | } | |
324 | ||
325 | /* | |
326 | * Initialize iterator for region | |
327 | */ | |
328 | wxRegionIterator::wxRegionIterator(const wxRegion& region) | |
329 | { | |
330 | m_rects.DeleteContents(true); | |
331 | Reset(region); | |
332 | } | |
333 | ||
334 | /* | |
335 | * Reset iterator for a new /e region. | |
336 | */ | |
337 | ||
338 | ||
339 | static wxRegionRectList *gs_rectList; | |
340 | ||
341 | static void MGLAPI wxMGL_region_callback(const rect_t *r) | |
342 | { | |
343 | gs_rectList->Append(new wxRect(r->left, r->top, | |
344 | r->right - r->left, r->bottom - r->top)); | |
345 | } | |
346 | ||
347 | void wxRegionIterator::Reset(const wxRegion& region) | |
348 | { | |
349 | m_currentNode = NULL; | |
350 | m_rects.Clear(); | |
351 | ||
352 | if (!region.Empty()) | |
353 | { | |
354 | #if wxUSE_THREADS | |
355 | wxMutexLocker lock(*gs_mutexIterator); | |
356 | #endif | |
357 | gs_rectList = &m_rects; | |
358 | M_REGION_OF(region).traverse(wxMGL_region_callback); | |
359 | m_currentNode = m_rects.GetFirst(); | |
360 | } | |
361 | } | |
362 | ||
363 | /* | |
364 | * Increment iterator. The rectangle returned is the one after the | |
365 | * incrementation. | |
366 | */ | |
367 | void wxRegionIterator::operator ++ () | |
368 | { | |
369 | if (m_currentNode) | |
370 | m_currentNode = m_currentNode->GetNext(); | |
371 | } | |
372 | ||
373 | /* | |
374 | * Increment iterator. The rectangle returned is the one before the | |
375 | * incrementation. | |
376 | */ | |
377 | void wxRegionIterator::operator ++ (int) | |
378 | { | |
379 | if (m_currentNode) | |
380 | m_currentNode = m_currentNode->GetNext(); | |
381 | } | |
382 | ||
383 | wxCoord wxRegionIterator::GetX() const | |
384 | { | |
385 | if (m_currentNode) | |
386 | return m_currentNode->GetData()->x; | |
387 | else | |
388 | return 0; | |
389 | } | |
390 | ||
391 | wxCoord wxRegionIterator::GetY() const | |
392 | { | |
393 | if (m_currentNode) | |
394 | return m_currentNode->GetData()->y; | |
395 | else | |
396 | return 0; | |
397 | } | |
398 | ||
399 | wxCoord wxRegionIterator::GetW() const | |
400 | { | |
401 | if (m_currentNode) | |
402 | return m_currentNode->GetData()->width; | |
403 | else | |
404 | return 0; | |
405 | } | |
406 | ||
407 | wxCoord wxRegionIterator::GetH() const | |
408 | { | |
409 | if (m_currentNode) | |
410 | return m_currentNode->GetData()->height; | |
411 | else | |
412 | return 0; | |
413 | } |