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