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