Added ability to switch off more components of the size page UI

[wxWidgets.git] / src / os2 / region.cpp

diff --git a/src/os2/region.cpp b/src/os2/region.cpp
index c56301d723e90c333add2942d9572992a2d877d4..90c7306c8da10993e289e0413f653a34683efd5e 100644 (file)
--- a/src/os2/region.cpp
+++ b/src/os2/region.cpp
@@ -1,26 +1,29 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// File:      region.cpp
+// File:      src/os2/region.cpp

 // Purpose:   Region class
 // Author:    David Webster
 // Modified by:
 // Created:   10/15/99
 // RCS-ID:    $Id$
 // Purpose:   Region class
 // Author:    David Webster
 // Modified by:
 // Created:   10/15/99
 // RCS-ID:    $Id$

-// Copyright: (c) Davdi Webster
+// Copyright: (c) David Webster

 // Licence:   wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // Licence:   wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 

-#include "wx/app.h"
+#ifndef WX_PRECOMP
+    #include "wx/app.h"
+    #include "wx/window.h"
+    #include "wx/gdicmn.h"
+#endif
+

 #include "wx/os2/region.h"
 #include "wx/os2/region.h"

-#include "wx/gdicmn.h"

 
 

-#include "wx/window.h"

 #include "wx/os2/private.h"
 
 #include "wx/os2/private.h"
 

-    IMPLEMENT_DYNAMIC_CLASS(wxRegion, wxGDIObject)
-    IMPLEMENT_DYNAMIC_CLASS(wxRegionIterator, wxObject)
+IMPLEMENT_DYNAMIC_CLASS(wxRegion, wxGDIObject)
+IMPLEMENT_DYNAMIC_CLASS(wxRegionIterator, wxObject)

 
 //-----------------------------------------------------------------------------
 // wxRegionRefData implementation
 
 //-----------------------------------------------------------------------------
 // wxRegionRefData implementation


@@ -39,6 +42,7 @@ public:
         RGNRECT                     vRgnData;
         PRECTL                      pRect = NULL;
 
         RGNRECT                     vRgnData;
         PRECTL                      pRect = NULL;
 

+        vRgnData.ulDirection = RECTDIR_LFRT_TOPBOT;

         if (::GpiQueryRegionRects( rData.m_hPS      // Pres space
                                   ,rData.m_hRegion  // Handle of region to query
                                   ,NULL             // Return all RECTs
         if (::GpiQueryRegionRects( rData.m_hPS      // Pres space
                                   ,rData.m_hRegion  // Handle of region to query
                                   ,NULL             // Return all RECTs


@@ -66,7 +70,7 @@ public:
         }
     }
 
         }
     }
 

-    ~wxRegionRefData()
+    virtual ~wxRegionRefData()

     {
         ::GpiDestroyRegion(m_hPS, m_hRegion);
     }
     {
         ::GpiDestroyRegion(m_hPS, m_hRegion);
     }


@@ -82,6 +86,13 @@ public:
 // wxRegion
 //-----------------------------------------------------------------------------
 
 // wxRegion
 //-----------------------------------------------------------------------------
 

+// General remark:
+// wxRegion is always basically stored in wx coordinates. However, since
+// OS/2's internal functions rely on "top > bottom", the values of top and
+// bottom values of a region need to be interchanged, as compared to wx.
+// This needs to be taken into account when feeding any rectangle to wx _or_
+// when accessing the region data via GetBox, wxRegionIterator or otherwise.
+

 /*!
  * Create an empty region.
  */
 /*!
  * Create an empty region.
  */


@@ -140,10 +151,8 @@ wxRegion::wxRegion(
                                      );
 } // end of wxRegion::wxRegion
 
                                      );
 } // end of wxRegion::wxRegion
 

-wxRegion::wxRegion(
-  const wxPoint&                    rTopLeft
-, const wxPoint&                    rBottomRight
-)
+wxRegion::wxRegion(const wxPoint& rTopLeft,
+                   const wxPoint& rBottomRight)

 {
     RECTL                           vRect;
     SIZEL                           vSize = {0, 0};
 {
     RECTL                           vRect;
     SIZEL                           vSize = {0, 0};


@@ -158,8 +167,8 @@ wxRegion::wxRegion(
 
     vRect.xLeft   = rTopLeft.x;
     vRect.xRight  = rBottomRight.x;
 
     vRect.xLeft   = rTopLeft.x;
     vRect.xRight  = rBottomRight.x;

-    vRect.yBottom = rBottomRight.y;
-    vRect.yTop    = rTopLeft.y;
+    vRect.yBottom = rTopLeft.y;
+    vRect.yTop    = rBottomRight.y;

 
     m_refData     = new wxRegionRefData;
 
 
     m_refData     = new wxRegionRefData;
 


@@ -177,9 +186,7 @@ wxRegion::wxRegion(
                                      );
 } // end of wxRegion::wxRegion
 
                                      );
 } // end of wxRegion::wxRegion
 

-wxRegion::wxRegion(
-  const wxRect&                     rRect
-)
+wxRegion::wxRegion(const wxRect& rRect)

 {
     RECTL                           vRect;
     SIZEL                           vSize = {0, 0};
 {
     RECTL                           vRect;
     SIZEL                           vSize = {0, 0};


@@ -214,6 +221,11 @@ wxRegion::wxRegion(
                                      );
 } // end of wxRegion::wxRegion
 
                                      );
 } // end of wxRegion::wxRegion
 

+wxRegion::wxRegion(size_t n, const wxPoint *points, wxPolygonFillMode WXUNUSED(fillStyle))
+{
+    // TO DO
+}
+

 //
 // Destroy the region.
 //
 //
 // Destroy the region.
 //


@@ -221,12 +233,12 @@ wxRegion::~wxRegion()
 {
 } // end of wxRegion::~wxRegion
 
 {
 } // end of wxRegion::~wxRegion
 

-wxObjectRefData *wxRegion::CreateData() const
+wxGDIRefData *wxRegion::CreateGDIRefData() const

 {
     return new wxRegionRefData;
 }
 
 {
     return new wxRegionRefData;
 }
 

-wxObjectRefData *wxRegion::CloneData(const wxObjectRefData *data) const
+wxGDIRefData *wxRegion::CloneGDIRefData(const wxGDIRefData *data) const

 {
     return new wxRegionRefData(*(wxRegionRefData *)data);
 }
 {
     return new wxRegionRefData(*(wxRegionRefData *)data);
 }


@@ -235,15 +247,12 @@ wxObjectRefData *wxRegion::CloneData(const wxObjectRefData *data) const
 //# Modify region
 //-----------------------------------------------------------------------------
 
 //# Modify region
 //-----------------------------------------------------------------------------
 

-bool wxRegion::Offset(
-  wxCoord                           x
-, wxCoord                           y
-)
+bool wxRegion::DoOffset( wxCoord x, wxCoord y )

 {
     if ( !x && !y )
     {
         // nothing to do
 {
     if ( !x && !y )
     {
         // nothing to do

-        return TRUE;
+        return true;

     }
 
     AllocExclusive();
     }
 
     AllocExclusive();


@@ -251,12 +260,12 @@ bool wxRegion::Offset(
 #if 0
     if ( ::OffsetRgn(GetHrgn(), x, y) == ERROR )
     {
 #if 0
     if ( ::OffsetRgn(GetHrgn(), x, y) == ERROR )
     {

-        wxLogLastError(_T("OffsetRgn"));
+        wxLogLastError(wxT("OffsetRgn"));

 
 

-        return FALSE;
+        return false;

     }
 #endif
     }
 #endif

-    return TRUE;
+    return true;

 }
 
 //
 }
 
 //


@@ -267,27 +276,10 @@ void wxRegion::Clear()
     UnRef();
 } // end of wxRegion::Clear
 
     UnRef();
 } // end of wxRegion::Clear
 

-//
-// Combine rectangle (x, y, w, h) with this.
-//
-bool wxRegion::Combine(
-  wxCoord                           x
-, wxCoord                           y
-, wxCoord                           vWidth
-, wxCoord                           vHeight
-, wxRegionOp                        eOp
-)
-{
-    return Combine(wxRegion(x, y, vWidth, vHeight), eOp);
-} // end of wxRegion::Combine
-

 //
 // Union region with this.
 //
 //
 // Union region with this.
 //

-bool wxRegion::Combine(
-  const wxRegion&                   rRegion
-, wxRegionOp                        eOp
-)
+bool wxRegion::DoCombine( const wxRegion& rRegion, wxRegionOp eOp )

 {
     //
     // We can't use the API functions if we don't have a valid region handle
 {
     //
     // We can't use the API functions if we don't have a valid region handle


@@ -305,13 +297,13 @@ bool wxRegion::Combine(
                 break;
 
             default:
                 break;
 
             default:

-                wxFAIL_MSG( _T("unknown region operation") );
+                wxFAIL_MSG( wxT("unknown region operation") );

                 // fall through
 
             case wxRGN_AND:
             case wxRGN_DIFF:
                 // leave empty/invalid
                 // fall through
 
             case wxRGN_AND:
             case wxRGN_DIFF:
                 // leave empty/invalid

-                return FALSE;
+                return false;

         }
     }
     else // we have a valid region
         }
     }
     else // we have a valid region


@@ -349,30 +341,22 @@ bool wxRegion::Combine(
                                    ,lMode
                                   ) != RGN_ERROR);
     }
                                    ,lMode
                                   ) != RGN_ERROR);
     }

-    return TRUE;
-} // end of wxRegion::Combine
-
-bool wxRegion::Combine(
-  const wxRect&                     rRect
-, wxRegionOp                        eOp
-)
-{
-    return Combine( rRect.GetLeft()
-                   ,rRect.GetTop()
-                   ,rRect.GetWidth()
-                   ,rRect.GetHeight()
-                   ,eOp
-                  );
+    return true;

 } // end of wxRegion::Combine
 
 //-----------------------------------------------------------------------------
 //# Information on region
 //-----------------------------------------------------------------------------
 
 } // end of wxRegion::Combine
 
 //-----------------------------------------------------------------------------
 //# Information on region
 //-----------------------------------------------------------------------------
 

+bool wxRegion::DoIsEqual(const wxRegion& WXUNUSED(region)) const
+{
+    return false;
+}
+

 //
 // Outer bounds of region
 //
 //
 // Outer bounds of region
 //

-void wxRegion::GetBox(
+bool wxRegion::DoGetBox(

   wxCoord&                          x
 , wxCoord&                          y
 , wxCoord&                          vWidth
   wxCoord&                          x
 , wxCoord&                          y
 , wxCoord&                          vWidth


@@ -392,32 +376,27 @@ void wxRegion::GetBox(
         y       = vRect.yBottom;
         vWidth  = vRect.xRight - vRect.xLeft;
         vHeight = vRect.yTop - vRect.yBottom;
         y       = vRect.yBottom;
         vWidth  = vRect.xRight - vRect.xLeft;
         vHeight = vRect.yTop - vRect.yBottom;

+        return true;

     }
     else
     {
         x = y = vWidth = vHeight = 0L;
     }
     else
     {
         x = y = vWidth = vHeight = 0L;

+        return false;

     }
 } // end of wxRegion::GetBox
 
     }
 } // end of wxRegion::GetBox
 

-wxRect wxRegion::GetBox() const
-{
-    wxCoord x, y, w, h;
-    GetBox(x, y, w, h);
-    return wxRect(x, y, w, h);
-}
-

 //
 // Is region empty?
 //
 //
 // Is region empty?
 //

-bool wxRegion::Empty() const
+bool wxRegion::IsEmpty() const

 {
 {

-    wxCoord                         x;
-    wxCoord                         y;
-    wxCoord                         vWidth;
-    wxCoord                         vHeight;
+    wxCoord x;
+    wxCoord y;
+    wxCoord vWidth;
+    wxCoord vHeight;

 
     if (M_REGION == 0)
 
     if (M_REGION == 0)

-        return TRUE;
+        return true;

 
     GetBox( x
            ,y
 
     GetBox( x
            ,y


@@ -425,53 +404,25 @@ bool wxRegion::Empty() const
            ,vHeight
           );
     return ((vWidth == 0) && (vHeight == 0));
            ,vHeight
           );
     return ((vWidth == 0) && (vHeight == 0));

-} // end of wxRegion::Empty
+} // end of wxRegion::IsEmpty

 
 //-----------------------------------------------------------------------------
 // Tests
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 // Tests
 //-----------------------------------------------------------------------------

-
-//
-// Does the region contain the point (x,y)?
-wxRegionContain wxRegion::Contains(
-  wxCoord                           x
-, wxCoord                           y
-) const
-{
-    bool                            bOK = FALSE;
-    POINTL                          vPoint;
-
-    vPoint.x = x;
-    vPoint.y = y;
-
-    if (!m_refData)
-        return wxOutRegion;
-
-    LONG                            lInside = ::GpiPtInRegion( ((wxRegionRefData*)m_refData)->m_hPS
-                                                              ,M_REGION
-                                                              ,&vPoint
-                                                             );
-    if (lInside == PRGN_INSIDE)
-        return wxInRegion;
-    return wxOutRegion;
-} // end of wxRegion::Contains
-

 //
 // Does the region contain the point pt?
 //
 //
 // Does the region contain the point pt?
 //

-wxRegionContain wxRegion::Contains(
-  const wxPoint&                    rPoint
-) const
+wxRegionContain wxRegion::DoContainsPoint( wxCoord x, wxCoord y ) const

 {
 {

-    POINTL                          vPoint = { rPoint.x, rPoint.y };
+    POINTL vPoint = { x, y };

 
     if (!m_refData)
         return wxOutRegion;
 
 
     if (!m_refData)
         return wxOutRegion;
 

-    LONG                            lInside = ::GpiPtInRegion( ((wxRegionRefData*)m_refData)->m_hPS
-                                                              ,M_REGION
-                                                              ,&vPoint
-                                                             );
+    LONG lInside = ::GpiPtInRegion( ((wxRegionRefData*)m_refData)->m_hPS,
+                                    M_REGION,
+                                    &vPoint
+                                  );

     if (lInside == PRGN_INSIDE)
         return wxInRegion;
     else
     if (lInside == PRGN_INSIDE)
         return wxInRegion;
     else


@@ -481,56 +432,29 @@ wxRegionContain wxRegion::Contains(
 //
 // Does the region contain the rectangle (x, y, w, h)?
 //
 //
 // Does the region contain the rectangle (x, y, w, h)?
 //

-wxRegionContain wxRegion::Contains(
-  wxCoord                           x
-, wxCoord                           y
-, wxCoord                           vWidth
-, wxCoord                           vHeight
-) const
+wxRegionContain wxRegion::DoContainsRect(const wxRect& rect) const

 {
 {

-    RECTL                           vRect;
-

     if (!m_refData)
         return wxOutRegion;
 
     if (!m_refData)
         return wxOutRegion;
 

-    vRect.xLeft   = x;
-    vRect.yTop    = y;
-    vRect.xRight  = x + vWidth;
-    vRect.yBottom = y + vHeight;
-
-    if (PRGN_INSIDE == ::GpiRectInRegion( ((wxRegionRefData*)m_refData)->m_hPS
-                                         ,M_REGION
-                                         ,&vRect
-                                        ))
-        return wxInRegion;
-    else
-        return wxOutRegion;
-} // end of wxRegion::Contains
-
-//
-// Does the region contain the rectangle rect
-//
-wxRegionContain wxRegion::Contains(
-  const wxRect&                     rRect
-) const
-{
-    if (!m_refData)
-        return wxOutRegion;
+    RECTL   vRect;
+    vRect.xLeft   = rect.x;
+    vRect.xRight  = rect.x + rect.width;
+    vRect.yTop    = rect.y + rect.height;
+    vRect.yBottom = rect.y;
+
+    LONG lInside = ::GpiRectInRegion( ((wxRegionRefData*)m_refData)->m_hPS,
+                                      M_REGION,
+                                      &vRect
+                                    );
+    switch (lInside)
+    {
+        case RRGN_INSIDE    :   return wxInRegion;
+        case RRGN_PARTIAL   :   return wxPartRegion;
+        case RRGN_ERROR     :
+        default             :   return wxOutRegion;
+    }

 
 

-    wxCoord                         x;
-    wxCoord                         y;
-    wxCoord                         vWidth;
-    wxCoord                         vHeight;
-
-    x       = rRect.x;
-    y       = rRect.y;
-    vWidth  = rRect.GetWidth();
-    vHeight = rRect.GetHeight();
-    return Contains( x
-                    ,y
-                    ,vWidth
-                    ,vHeight
-                   );

 } // end of wxRegion::Contains
 
 //
 } // end of wxRegion::Contains
 
 //


@@ -554,6 +478,7 @@ void wxRegion::SetPS(
     RGNRECT                     vRgnData;
     PRECTL                      pRect = NULL;
 
     RGNRECT                     vRgnData;
     PRECTL                      pRect = NULL;
 

+    vRgnData.ulDirection = RECTDIR_LFRT_TOPBOT;

     if (::GpiQueryRegionRects( ((wxRegionRefData*)m_refData)->m_hPS
                               ,((wxRegionRefData*)m_refData)->m_hRegion
                               ,NULL
     if (::GpiQueryRegionRects( ((wxRegionRefData*)m_refData)->m_hPS
                               ,((wxRegionRefData*)m_refData)->m_hRegion
                               ,NULL


@@ -629,6 +554,7 @@ void wxRegionIterator::Reset(
 )
 {
     m_lCurrent = 0;
 )
 {
     m_lCurrent = 0;

+    m_lNumRects = 0;

     m_vRegion  = rRegion;
 
     if (m_pRects)
     m_vRegion  = rRegion;
 
     if (m_pRects)


@@ -643,6 +569,7 @@ void wxRegionIterator::Reset(
         RGNRECT                     vRgnData;
         PRECTL                      pRect;
 
         RGNRECT                     vRgnData;
         PRECTL                      pRect;
 

+        vRgnData.ulDirection = RECTDIR_LFRT_TOPBOT;

         if (::GpiQueryRegionRects( ((wxRegionRefData*)rRegion.m_refData)->m_hPS     // Pres space
                                   ,((wxRegionRefData*)rRegion.m_refData)->m_hRegion // Handle of region to query
                                   ,NULL                                             // Return all RECTs
         if (::GpiQueryRegionRects( ((wxRegionRefData*)rRegion.m_refData)->m_hPS     // Pres space
                                   ,((wxRegionRefData*)rRegion.m_refData)->m_hRegion // Handle of region to query
                                   ,NULL                                             // Return all RECTs


@@ -662,10 +589,12 @@ void wxRegionIterator::Reset(
                                       ,pRect                                            // Will contain the actual RECTS
                                      ))
             {
                                       ,pRect                                            // Will contain the actual RECTS
                                      ))
             {

+#if 0

                 M_REGION = ::GpiCreateRegion( ((wxRegionRefData*)rRegion.m_refData)->m_hPS
                                              ,vRgnData.crcReturned
                                              ,pRect
                                             );
                 M_REGION = ::GpiCreateRegion( ((wxRegionRefData*)rRegion.m_refData)->m_hPS
                                              ,vRgnData.crcReturned
                                              ,pRect
                                             );

+#endif

                 for( LONG i = 0; i < m_lNumRects; i++)
                 {
                     m_pRects[i].x      = pRect[i].xLeft;
                 for( LONG i = 0; i < m_lNumRects; i++)
                 {
                     m_pRects[i].x      = pRect[i].xLeft;


@@ -673,7 +602,9 @@ void wxRegionIterator::Reset(
                     m_pRects[i].y      = pRect[i].yBottom;
                     m_pRects[i].height = pRect[i].yTop - pRect[i].yBottom;
                 }
                     m_pRects[i].y      = pRect[i].yBottom;
                     m_pRects[i].height = pRect[i].yTop - pRect[i].yBottom;
                 }

+#if 0

                 ((wxRegionRefData*)m_refData)->m_hPS = ((wxRegionRefData*)rRegion.m_refData)->m_hPS;
                 ((wxRegionRefData*)m_refData)->m_hPS = ((wxRegionRefData*)rRegion.m_refData)->m_hPS;

+#endif

             }
         }
     }
             }
         }
     }


@@ -726,4 +657,3 @@ wxCoord wxRegionIterator::GetH() const
         return m_pRects[m_lCurrent].height;
     return 0L;
 } // end of wxRegionIterator::GetH
         return m_pRects[m_lCurrent].height;
     return 0L;
 } // end of wxRegionIterator::GetH

-