]> git.saurik.com Git - wxWidgets.git/blob - src/os2/region.cpp
Use wxMarkupParser in wxStaticText for dealing with markup.
[wxWidgets.git] / src / os2 / region.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // File: src/os2/region.cpp
3 // Purpose: Region class
4 // Author: David Webster
5 // Modified by:
6 // Created: 10/15/99
7 // RCS-ID: $Id$
8 // Copyright: (c) David Webster
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // For compilers that support precompilation, includes "wx.h".
13 #include "wx/wxprec.h"
14
15 #ifndef WX_PRECOMP
16 #include "wx/app.h"
17 #include "wx/window.h"
18 #include "wx/gdicmn.h"
19 #endif
20
21 #include "wx/os2/region.h"
22
23 #include "wx/os2/private.h"
24
25 IMPLEMENT_DYNAMIC_CLASS(wxRegion, wxGDIObject)
26 IMPLEMENT_DYNAMIC_CLASS(wxRegionIterator, wxObject)
27
28 //-----------------------------------------------------------------------------
29 // wxRegionRefData implementation
30 //-----------------------------------------------------------------------------
31
32 class WXDLLEXPORT wxRegionRefData : public wxGDIRefData {
33 public:
34 wxRegionRefData()
35 {
36 m_hRegion = 0;
37 m_hPS = 0;
38 }
39
40 wxRegionRefData(const wxRegionRefData& rData)
41 {
42 RGNRECT vRgnData;
43 PRECTL pRect = NULL;
44
45 vRgnData.ulDirection = RECTDIR_LFRT_TOPBOT;
46 if (::GpiQueryRegionRects( rData.m_hPS // Pres space
47 ,rData.m_hRegion // Handle of region to query
48 ,NULL // Return all RECTs
49 ,&vRgnData // Will contain number or RECTs in region
50 ,NULL // NULL to return number of RECTs
51 ))
52 {
53 pRect = new RECTL[vRgnData.crcReturned];
54 vRgnData.crc = vRgnData.crcReturned;
55 vRgnData.ircStart = 1;
56 if (::GpiQueryRegionRects( rData.m_hPS // Pres space of source
57 ,rData.m_hRegion // Handle of source region
58 ,NULL // Return all RECTs
59 ,&vRgnData // Operations set to return rects
60 ,pRect // Will contain the actual RECTS
61 ))
62 {
63 m_hRegion = ::GpiCreateRegion( rData.m_hPS
64 ,vRgnData.crcReturned
65 ,pRect
66 );
67 m_hPS = rData.m_hPS;
68 }
69 delete [] pRect;
70 }
71 }
72
73 virtual ~wxRegionRefData()
74 {
75 ::GpiDestroyRegion(m_hPS, m_hRegion);
76 }
77
78 HRGN m_hRegion;
79 HPS m_hPS;
80 };
81
82 #define M_REGION (((wxRegionRefData*)m_refData)->m_hRegion)
83 #define M_REGION_OF(rgn) (((wxRegionRefData*)(rgn.m_refData))->m_hRegion)
84
85 //-----------------------------------------------------------------------------
86 // wxRegion
87 //-----------------------------------------------------------------------------
88
89 // General remark:
90 // wxRegion is always basically stored in wx coordinates. However, since
91 // OS/2's internal functions rely on "top > bottom", the values of top and
92 // bottom values of a region need to be interchanged, as compared to wx.
93 // This needs to be taken into account when feeding any rectangle to wx _or_
94 // when accessing the region data via GetBox, wxRegionIterator or otherwise.
95
96 /*!
97 * Create an empty region.
98 */
99 wxRegion::wxRegion()
100 {
101 m_refData = new wxRegionRefData;
102 } // end of wxRegion::wxRegion
103
104 wxRegion::wxRegion(
105 WXHRGN hRegion,
106 WXHDC hPS
107 )
108 {
109 m_refData = new wxRegionRefData;
110 M_REGION = (HRGN) hRegion;
111 (((wxRegionRefData*)m_refData)->m_hPS) = hPS;
112 } // end of wxRegion::wxRegion
113
114 wxRegion::wxRegion(
115 wxCoord x
116 , wxCoord y
117 , wxCoord vWidth
118 , wxCoord vHeight
119 )
120 {
121 RECTL vRect;
122 SIZEL vSize = {0, 0};
123 DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
124 HDC hDC = ::DevOpenDC( vHabmain
125 ,OD_MEMORY
126 ,"*"
127 ,5L
128 ,(PDEVOPENDATA)&vDop
129 ,NULLHANDLE
130 );
131
132
133 vRect.xLeft = x;
134 vRect.xRight = x + vWidth;
135 vRect.yBottom = y;
136 vRect.yTop = y + vHeight;
137
138 m_refData = new wxRegionRefData;
139
140 //
141 // Need a PS to create a Region
142 //
143 ((wxRegionRefData*)m_refData)->m_hPS = ::GpiCreatePS( vHabmain
144 ,hDC
145 ,&vSize
146 ,PU_PELS | GPIT_MICRO | GPIA_ASSOC
147 );
148 M_REGION = ::GpiCreateRegion( ((wxRegionRefData*)m_refData)->m_hPS
149 ,1
150 ,&vRect
151 );
152 } // end of wxRegion::wxRegion
153
154 wxRegion::wxRegion(const wxPoint& rTopLeft,
155 const wxPoint& rBottomRight)
156 {
157 RECTL vRect;
158 SIZEL vSize = {0, 0};
159 DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
160 HDC hDC = ::DevOpenDC( vHabmain
161 ,OD_MEMORY
162 ,"*"
163 ,5L
164 ,(PDEVOPENDATA)&vDop
165 ,NULLHANDLE
166 );
167
168 vRect.xLeft = rTopLeft.x;
169 vRect.xRight = rBottomRight.x;
170 vRect.yBottom = rTopLeft.y;
171 vRect.yTop = rBottomRight.y;
172
173 m_refData = new wxRegionRefData;
174
175 //
176 // Need a PS to create a Region
177 //
178 ((wxRegionRefData*)m_refData)->m_hPS = ::GpiCreatePS( vHabmain
179 ,hDC
180 ,&vSize
181 ,PU_PELS | GPIT_MICRO | GPIA_ASSOC
182 );
183 M_REGION = ::GpiCreateRegion( ((wxRegionRefData*)m_refData)->m_hPS
184 ,1
185 ,&vRect
186 );
187 } // end of wxRegion::wxRegion
188
189 wxRegion::wxRegion(const wxRect& rRect)
190 {
191 RECTL vRect;
192 SIZEL vSize = {0, 0};
193 DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
194 HDC hDC = ::DevOpenDC( vHabmain
195 ,OD_MEMORY
196 ,"*"
197 ,5L
198 ,(PDEVOPENDATA)&vDop
199 ,NULLHANDLE
200 );
201
202
203 vRect.xLeft = rRect.x;
204 vRect.xRight = rRect.x + rRect.width;
205 vRect.yBottom = rRect.y;
206 vRect.yTop = rRect.y + rRect.height;
207
208 m_refData = new wxRegionRefData;
209
210 //
211 // Need a PS to create a Region
212 //
213 ((wxRegionRefData*)m_refData)->m_hPS = ::GpiCreatePS( vHabmain
214 ,hDC
215 ,&vSize
216 ,PU_PELS | GPIT_MICRO | GPIA_ASSOC
217 );
218 M_REGION = ::GpiCreateRegion( ((wxRegionRefData*)m_refData)->m_hPS
219 ,1
220 ,&vRect
221 );
222 } // end of wxRegion::wxRegion
223
224 wxRegion::wxRegion(size_t n, const wxPoint *points, wxPolygonFillMode WXUNUSED(fillStyle))
225 {
226 // TO DO
227 }
228
229 //
230 // Destroy the region.
231 //
232 wxRegion::~wxRegion()
233 {
234 } // end of wxRegion::~wxRegion
235
236 wxGDIRefData *wxRegion::CreateGDIRefData() const
237 {
238 return new wxRegionRefData;
239 }
240
241 wxGDIRefData *wxRegion::CloneGDIRefData(const wxGDIRefData *data) const
242 {
243 return new wxRegionRefData(*(wxRegionRefData *)data);
244 }
245
246 //-----------------------------------------------------------------------------
247 //# Modify region
248 //-----------------------------------------------------------------------------
249
250 bool wxRegion::DoOffset( wxCoord x, wxCoord y )
251 {
252 if ( !x && !y )
253 {
254 // nothing to do
255 return true;
256 }
257
258 AllocExclusive();
259
260 #if 0
261 if ( ::OffsetRgn(GetHrgn(), x, y) == ERROR )
262 {
263 wxLogLastError(wxT("OffsetRgn"));
264
265 return false;
266 }
267 #endif
268 return true;
269 }
270
271 //
272 // Clear current region
273 //
274 void wxRegion::Clear()
275 {
276 UnRef();
277 } // end of wxRegion::Clear
278
279 //
280 // Union region with this.
281 //
282 bool wxRegion::DoCombine( const wxRegion& rRegion, wxRegionOp eOp )
283 {
284 //
285 // We can't use the API functions if we don't have a valid region handle
286 //
287 if (!m_refData)
288 {
289 // combining with an empty/invalid region works differently depending
290 // on the operation
291 switch (eOp)
292 {
293 case wxRGN_COPY:
294 case wxRGN_OR:
295 case wxRGN_XOR:
296 *this = rRegion;
297 break;
298
299 default:
300 wxFAIL_MSG( wxT("unknown region operation") );
301 // fall through
302
303 case wxRGN_AND:
304 case wxRGN_DIFF:
305 // leave empty/invalid
306 return false;
307 }
308 }
309 else // we have a valid region
310 {
311
312 LONG lMode = 0;
313
314 switch (eOp)
315 {
316 case wxRGN_AND:
317 lMode = CRGN_AND;
318 break;
319
320 case wxRGN_OR:
321 lMode = CRGN_OR;
322 break;
323
324 case wxRGN_XOR:
325 lMode = CRGN_XOR;
326 break;
327
328 case wxRGN_DIFF:
329 lMode = CRGN_DIFF;
330 break;
331
332 case wxRGN_COPY:
333 default:
334 lMode = CRGN_COPY;
335 break;
336 }
337 return (::GpiCombineRegion( ((wxRegionRefData*)rRegion.m_refData)->m_hPS
338 ,M_REGION
339 ,M_REGION
340 ,((wxRegionRefData*)rRegion.m_refData)->m_hRegion
341 ,lMode
342 ) != RGN_ERROR);
343 }
344 return true;
345 } // end of wxRegion::Combine
346
347 //-----------------------------------------------------------------------------
348 //# Information on region
349 //-----------------------------------------------------------------------------
350
351 bool wxRegion::DoIsEqual(const wxRegion& WXUNUSED(region)) const
352 {
353 return false;
354 }
355
356 //
357 // Outer bounds of region
358 //
359 bool wxRegion::DoGetBox(
360 wxCoord& x
361 , wxCoord& y
362 , wxCoord& vWidth
363 , wxCoord& vHeight
364 ) const
365 {
366 if (m_refData)
367 {
368 RECTL vRect;
369 APIRET rc;
370
371 rc = ::GpiQueryRegionBox( ((wxRegionRefData*)m_refData)->m_hPS
372 ,M_REGION
373 ,&vRect
374 );
375 x = vRect.xLeft;
376 y = vRect.yBottom;
377 vWidth = vRect.xRight - vRect.xLeft;
378 vHeight = vRect.yTop - vRect.yBottom;
379 return true;
380 }
381 else
382 {
383 x = y = vWidth = vHeight = 0L;
384 return false;
385 }
386 } // end of wxRegion::GetBox
387
388 //
389 // Is region empty?
390 //
391 bool wxRegion::IsEmpty() const
392 {
393 wxCoord x;
394 wxCoord y;
395 wxCoord vWidth;
396 wxCoord vHeight;
397
398 if (M_REGION == 0)
399 return true;
400
401 GetBox( x
402 ,y
403 ,vWidth
404 ,vHeight
405 );
406 return ((vWidth == 0) && (vHeight == 0));
407 } // end of wxRegion::IsEmpty
408
409 //-----------------------------------------------------------------------------
410 // Tests
411 //-----------------------------------------------------------------------------
412 //
413 // Does the region contain the point pt?
414 //
415 wxRegionContain wxRegion::DoContainsPoint( wxCoord x, wxCoord y ) const
416 {
417 POINTL vPoint = { x, y };
418
419 if (!m_refData)
420 return wxOutRegion;
421
422 LONG lInside = ::GpiPtInRegion( ((wxRegionRefData*)m_refData)->m_hPS,
423 M_REGION,
424 &vPoint
425 );
426 if (lInside == PRGN_INSIDE)
427 return wxInRegion;
428 else
429 return wxOutRegion;
430 } // end of wxRegion::Contains
431
432 //
433 // Does the region contain the rectangle (x, y, w, h)?
434 //
435 wxRegionContain wxRegion::DoContainsRect(const wxRect& rect) const
436 {
437 if (!m_refData)
438 return wxOutRegion;
439
440 RECTL vRect;
441 vRect.xLeft = rect.x;
442 vRect.xRight = rect.x + rect.width;
443 vRect.yTop = rect.y + rect.height;
444 vRect.yBottom = rect.y;
445
446 LONG lInside = ::GpiRectInRegion( ((wxRegionRefData*)m_refData)->m_hPS,
447 M_REGION,
448 &vRect
449 );
450 switch (lInside)
451 {
452 case RRGN_INSIDE : return wxInRegion;
453 case RRGN_PARTIAL : return wxPartRegion;
454 case RRGN_ERROR :
455 default : return wxOutRegion;
456 }
457
458 } // end of wxRegion::Contains
459
460 //
461 // Get internal region handle
462 //
463 WXHRGN wxRegion::GetHRGN() const
464 {
465 if (!m_refData)
466 return (WXHRGN) 0;
467 return (WXHRGN) M_REGION;
468 }
469
470 //
471 // Set a new PS, this means we have to recreate the old region in the new
472 // PS
473 //
474 void wxRegion::SetPS(
475 HPS hPS
476 )
477 {
478 RGNRECT vRgnData;
479 PRECTL pRect = NULL;
480
481 vRgnData.ulDirection = RECTDIR_LFRT_TOPBOT;
482 if (::GpiQueryRegionRects( ((wxRegionRefData*)m_refData)->m_hPS
483 ,((wxRegionRefData*)m_refData)->m_hRegion
484 ,NULL
485 ,&vRgnData
486 ,NULL
487 ))
488 {
489 pRect = new RECTL[vRgnData.crcReturned];
490 vRgnData.crc = vRgnData.crcReturned;
491 vRgnData.ircStart = 1;
492 if (::GpiQueryRegionRects( ((wxRegionRefData*)m_refData)->m_hPS
493 ,((wxRegionRefData*)m_refData)->m_hRegion
494 ,NULL
495 ,&vRgnData
496 ,pRect
497 ))
498 {
499 //
500 // First destroy the region out of the old PS
501 // and then create it in the new and set the new to current
502 //
503 ::GpiDestroyRegion( ((wxRegionRefData*)m_refData)->m_hPS
504 ,M_REGION
505 );
506 ((wxRegionRefData*)m_refData)->m_hRegion = ::GpiCreateRegion( hPS
507 ,vRgnData.crcReturned
508 ,pRect
509 );
510 ((wxRegionRefData*)m_refData)->m_hPS = hPS;
511 }
512 delete [] pRect;
513 }
514 } // end of wxRegion::SetPS
515
516 ///////////////////////////////////////////////////////////////////////////////
517 // //
518 // wxRegionIterator //
519 // //
520 ///////////////////////////////////////////////////////////////////////////////
521
522 //
523 // Initialize empty iterator
524 //
525 wxRegionIterator::wxRegionIterator()
526 : m_lCurrent(0)
527 , m_lNumRects(0)
528 , m_pRects(NULL)
529 {
530 } // end of wxRegionIterator::wxRegionIterator
531
532 wxRegionIterator::~wxRegionIterator()
533 {
534 if (m_pRects)
535 delete[] m_pRects;
536 } // end of wxRegionIterator::~wxRegionIterator
537
538 //
539 // Initialize iterator for region
540 //
541 wxRegionIterator::wxRegionIterator(
542 const wxRegion& rRegion
543 )
544 {
545 m_pRects = NULL;
546 Reset(rRegion);
547 } // end of wxRegionIterator::wxRegionIterator
548
549 //
550 // Reset iterator for a new /e region.
551 //
552 void wxRegionIterator::Reset(
553 const wxRegion& rRegion
554 )
555 {
556 m_lCurrent = 0;
557 m_lNumRects = 0;
558 m_vRegion = rRegion;
559
560 if (m_pRects)
561 delete[] m_pRects;
562
563 m_pRects = NULL;
564
565 if (m_vRegion.Empty())
566 m_lNumRects = 0;
567 else
568 {
569 RGNRECT vRgnData;
570 PRECTL pRect;
571
572 vRgnData.ulDirection = RECTDIR_LFRT_TOPBOT;
573 if (::GpiQueryRegionRects( ((wxRegionRefData*)rRegion.m_refData)->m_hPS // Pres space
574 ,((wxRegionRefData*)rRegion.m_refData)->m_hRegion // Handle of region to query
575 ,NULL // Return all RECTs
576 ,&vRgnData // Will contain number or RECTs in region
577 ,NULL // NULL to return number of RECTs
578 ))
579 {
580 pRect = new RECTL[vRgnData.crcReturned];
581 m_pRects = new wxRect[vRgnData.crcReturned];
582 vRgnData.crc = vRgnData.crcReturned;
583 m_lNumRects = vRgnData.crcReturned;
584 vRgnData.ircStart = 1;
585 if (::GpiQueryRegionRects( ((wxRegionRefData*)rRegion.m_refData)->m_hPS // Pres space of source
586 ,((wxRegionRefData*)rRegion.m_refData)->m_hRegion // Handle of source region
587 ,NULL // Return all RECTs
588 ,&vRgnData // Operations set to return rects
589 ,pRect // Will contain the actual RECTS
590 ))
591 {
592 #if 0
593 M_REGION = ::GpiCreateRegion( ((wxRegionRefData*)rRegion.m_refData)->m_hPS
594 ,vRgnData.crcReturned
595 ,pRect
596 );
597 #endif
598 for( LONG i = 0; i < m_lNumRects; i++)
599 {
600 m_pRects[i].x = pRect[i].xLeft;
601 m_pRects[i].width = pRect[i].xRight - pRect[i].xLeft;
602 m_pRects[i].y = pRect[i].yBottom;
603 m_pRects[i].height = pRect[i].yTop - pRect[i].yBottom;
604 }
605 #if 0
606 ((wxRegionRefData*)m_refData)->m_hPS = ((wxRegionRefData*)rRegion.m_refData)->m_hPS;
607 #endif
608 }
609 }
610 }
611 } // end of wxRegionIterator::Reset
612
613 //
614 // Increment iterator. The rectangle returned is the one after the
615 // incrementation.
616 //
617 void wxRegionIterator::operator++ ()
618 {
619 if (m_lCurrent < m_lNumRects)
620 ++m_lCurrent;
621 } // end of wxRegionIterator::operator ++
622
623 //
624 // Increment iterator. The rectangle returned is the one before the
625 // incrementation.
626 //
627 void wxRegionIterator::operator++ (int)
628 {
629 if (m_lCurrent < m_lNumRects)
630 ++m_lCurrent;
631 } // end of wxRegionIterator::operator++
632
633 wxCoord wxRegionIterator::GetX() const
634 {
635 if (m_lCurrent < m_lNumRects)
636 return m_pRects[m_lCurrent].x;
637 return 0L;
638 } // end of wxRegionIterator::GetX
639
640 wxCoord wxRegionIterator::GetY() const
641 {
642 if (m_lCurrent < m_lNumRects)
643 return m_pRects[m_lCurrent].y;
644 return 0L;
645 } // end of wxRegionIterator::GetY
646
647 wxCoord wxRegionIterator::GetW() const
648 {
649 if (m_lCurrent < m_lNumRects)
650 return m_pRects[m_lCurrent].width ;
651 return 0L;
652 } // end of wxRegionIterator::GetW
653
654 wxCoord wxRegionIterator::GetH() const
655 {
656 if (m_lCurrent < m_lNumRects)
657 return m_pRects[m_lCurrent].height;
658 return 0L;
659 } // end of wxRegionIterator::GetH