Lots of OS/2 fixes mostly to do with painting

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@8940 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

diff --git a/src/os2/brush.cpp b/src/os2/brush.cpp
index e45a28f3b131888f7626941f14b4afb96344931b..ed7e7e1554877427c70537b12948e8ab6f1c99e5 100644 (file)
--- a/src/os2/brush.cpp
+++ b/src/os2/brush.cpp
@@ -204,7 +204,7 @@ bool wxBrush::RealizeResource()
         if (M_BRUSHDATA->m_hBrush==NULL) wxError("Cannot create brush","Internal error") ;
 #endif
         M_BRUSHDATA->m_vBundle.lColor        = vPmColour;
         if (M_BRUSHDATA->m_hBrush==NULL) wxError("Cannot create brush","Internal error") ;
 #endif
         M_BRUSHDATA->m_vBundle.lColor        = vPmColour;

-        M_BRUSHDATA->m_vBundle.lBackColor    = CLR_DEFAULT;
+        M_BRUSHDATA->m_vBundle.lBackColor    = RGB_WHITE;

         M_BRUSHDATA->m_vBundle.usMixMode     = FM_OVERPAINT;
         M_BRUSHDATA->m_vBundle.usBackMixMode = BM_OVERPAINT;
 
         M_BRUSHDATA->m_vBundle.usMixMode     = FM_OVERPAINT;
         M_BRUSHDATA->m_vBundle.usBackMixMode = BM_OVERPAINT;
 

diff --git a/src/os2/dc.cpp b/src/os2/dc.cpp
index 3b886b9446c22615f3edfff4f65c0b79110ff8e7..deb5403652e29d99ae65504ed4ae0d122a7ecb5c 100644 (file)
--- a/src/os2/dc.cpp
+++ b/src/os2/dc.cpp
@@ -147,6 +147,7 @@ wxDC::wxDC(void)
     m_hOldPS       = NULL;
     m_hPS          = NULL;
     m_bIsPaintTime = FALSE; // True at Paint Time
     m_hOldPS       = NULL;
     m_hPS          = NULL;
     m_bIsPaintTime = FALSE; // True at Paint Time

+    m_brush.GetColour().Set("WHITE");

 }
 
 wxDC::~wxDC(void)
 }
 
 wxDC::~wxDC(void)


@@ -226,9 +227,9 @@ void wxDC::DoSetClippingRegion(
 
     m_clipping    = TRUE;
     vRect.xLeft   = XLOG2DEV(x);
 
     m_clipping    = TRUE;
     vRect.xLeft   = XLOG2DEV(x);

-    vRect.yTop    = YLOG2DEV(y + height);
+    vRect.yTop    = YLOG2DEV(m_vRclPaint.yTop - y);

     vRect.xRight  = XLOG2DEV(x + width);
     vRect.xRight  = XLOG2DEV(x + width);

-    vRect.yBottom = YLOG2DEV(y);
+    vRect.yBottom = YLOG2DEV(m_vRclPaint.yTop - (y + height));

     ::GpiIntersectClipRectangle(m_hPS, &vRect);
     DO_SET_CLIPPING_BOX()
 } // end of wxDC::DoSetClippingRegion
     ::GpiIntersectClipRectangle(m_hPS, &vRect);
     DO_SET_CLIPPING_BOX()
 } // end of wxDC::DoSetClippingRegion


@@ -360,9 +361,9 @@ void wxDC::DoDrawLine(
     POINTL                          vPoint[2];
 
     vPoint[0].x = vX1;
     POINTL                          vPoint[2];
 
     vPoint[0].x = vX1;

-    vPoint[0].y = vY1;
+    vPoint[0].y = m_vRclPaint.yTop - vY1;

     vPoint[1].x = vX2;
     vPoint[1].x = vX2;

-    vPoint[1].y = vY2;
+    vPoint[1].y = m_vRclPaint.yTop - vY2;

     ::GpiMove(m_hPS, &vPoint[0]);
     ::GpiLine(m_hPS, &vPoint[1]);
 }
     ::GpiMove(m_hPS, &vPoint[0]);
     ::GpiLine(m_hPS, &vPoint[1]);
 }


@@ -506,7 +507,7 @@ void wxDC::DoDrawPoint(
     POINTL                          vPoint;
 
     vPoint.x = vX;
     POINTL                          vPoint;
 
     vPoint.x = vX;

-    vPoint.y = vY;
+    vPoint.y = m_vRclPaint.yTop - vY;

     ::GpiSetPel(m_hPS, &vPoint);
 }
 
     ::GpiSetPel(m_hPS, &vPoint);
 }
 


@@ -621,9 +622,9 @@ void wxDC::DoDrawRectangle(
     int                             nIsTRANSPARENT = 0;
 
     vPoint[0].x = vX;
     int                             nIsTRANSPARENT = 0;
 
     vPoint[0].x = vX;

-    vPoint[0].y = vY;
+    vPoint[0].y = m_vRclPaint.yTop - (vY + vHeight);

     vPoint[1].x = vX + vWidth;
     vPoint[1].x = vX + vWidth;

-    vPoint[1].y = vY - vHeight;
+    vPoint[1].y = m_vRclPaint.yTop - vY;

     ::GpiMove(m_hPS, &vPoint[0]);
     lColor       = m_brush.GetColour().GetPixel();
     lBorderColor = m_pen.GetColour().GetPixel();
     ::GpiMove(m_hPS, &vPoint[0]);
     lColor       = m_brush.GetColour().GetPixel();
     lBorderColor = m_pen.GetColour().GetPixel();


@@ -635,7 +636,7 @@ void wxDC::DoDrawRectangle(
         if(m_brush.GetStyle() == wxTRANSPARENT)
             lControl = DRO_OUTLINE;
 
         if(m_brush.GetStyle() == wxTRANSPARENT)
             lControl = DRO_OUTLINE;
 

-        ::GpiSetColor(m_hPS, CLR_GREEN);
+        ::GpiSetColor(m_hPS, lColor);

         ::GpiBox( m_hPS       // handle to a presentation space
                  ,lControl   // draw the box outline ? or ?
                  ,&vPoint[1]  // address of the corner
         ::GpiBox( m_hPS       // handle to a presentation space
                  ,lControl   // draw the box outline ? or ?
                  ,&vPoint[1]  // address of the corner


@@ -659,6 +660,11 @@ void wxDC::DoDrawRectangle(
         ::GpiSetColor( m_hPS
                       ,lColor
                      );
         ::GpiSetColor( m_hPS
                       ,lColor
                      );

+        vPoint[0].x = vX + 1;
+        vPoint[0].y = m_vRclPaint.yTop - (vY + vHeight) + 1;
+        vPoint[1].x = vX + vWidth - 2;
+        vPoint[1].y = m_vRclPaint.yTop - (vY + 2);
+        ::GpiMove(m_hPS, &vPoint[0]);

         ::GpiBox( m_hPS
                  ,lControl
                  ,&vPoint[1]
         ::GpiBox( m_hPS
                  ,lControl
                  ,&vPoint[1]


@@ -680,9 +686,9 @@ void wxDC::DoDrawRoundedRectangle(
     LONG                            lControl;
 
     vPoint[0].x = vX;
     LONG                            lControl;
 
     vPoint[0].x = vX;

-    vPoint[0].y = vY;
+    vPoint[0].y = YLOG2DEV(vY) - vHeight;

     vPoint[1].x = vX + vWidth;
     vPoint[1].x = vX + vWidth;

-    vPoint[1].y = vY + vHeight;
+    vPoint[1].y = vY;

     ::GpiMove(m_hPS, &vPoint[0]);
 
     lControl = DRO_OUTLINEFILL; //DRO_FILL;
     ::GpiMove(m_hPS, &vPoint[0]);
 
     lControl = DRO_OUTLINEFILL; //DRO_FILL;


@@ -1241,10 +1247,15 @@ void wxDC::SetLogicalOrigin( wxCoord x, wxCoord y )
     // TODO:
 };
 
     // TODO:
 };
 

-void wxDC::SetDeviceOrigin( wxCoord x, wxCoord y )
+void wxDC::SetDeviceOrigin(
+  wxCoord                           x
+, wxCoord                           y
+)

 {
     RECTL                           vRect;
 
 {
     RECTL                           vRect;
 

+    m_deviceOriginX = x;
+    m_deviceOriginY = y;

     ::GpiQueryPageViewport( m_hPS
                            ,&vRect
                           );
     ::GpiQueryPageViewport( m_hPS
                            ,&vRect
                           );

diff --git a/src/os2/dcclient.cpp b/src/os2/dcclient.cpp
index ebca8b58c92a3b316768deef51a1ba7d9e6fc1e1..a2c49a9655024393e03144fc261b46f3b2999ba8 100644 (file)
--- a/src/os2/dcclient.cpp
+++ b/src/os2/dcclient.cpp
@@ -270,9 +270,7 @@ wxPaintDC::wxPaintDC(
     }
     else // not in cache, create a new one
     {
     }
     else // not in cache, create a new one
     {

-        SIZEL                       vSizl = { 0,0};

         HPS                         hPS;
         HPS                         hPS;

-        HRGN                        hRgn;

 
         hPS = ::WinBeginPaint( GetWinHwnd(m_pCanvas)
                               ,NULLHANDLE
 
         hPS = ::WinBeginPaint( GetWinHwnd(m_pCanvas)
                               ,NULLHANDLE


@@ -280,6 +278,10 @@ wxPaintDC::wxPaintDC(
                              );
         if(hPS)
         {
                              );
         if(hPS)
         {

+            POINTL                          vPoint[2];
+            LONG                            lControl;
+            LONG                            lColor;
+

             m_hOldPS = m_hPS;
             m_hPS = hPS;
             ::GpiCreateLogColorTable( m_hPS
             m_hOldPS = m_hPS;
             m_hPS = hPS;
             ::GpiCreateLogColorTable( m_hPS


@@ -296,6 +298,8 @@ wxPaintDC::wxPaintDC(
                                      ,0L
                                      ,NULL
                                     );
                                      ,0L
                                      ,NULL
                                     );

+
+            ::WinFillRect(hPS, &g_paintStruct,  m_pCanvas->GetBackgroundColour().GetPixel());

         }
 
         m_bIsPaintTime   = TRUE;
         }
 
         m_bIsPaintTime   = TRUE;

diff --git a/src/os2/frame.cpp b/src/os2/frame.cpp
index e02374f85d17d376f76f64e8be9f9b4566728faf..9fd9d2423e360b6a75f441f1615a351d96a4a2b6 100644 (file)
--- a/src/os2/frame.cpp
+++ b/src/os2/frame.cpp
@@ -984,6 +984,22 @@ bool wxFrame::OS2Create(
     wxAssociateWinWithHandle(m_hWnd, this);
     wxAssociateWinWithHandle(m_hFrame, this);
 
     wxAssociateWinWithHandle(m_hWnd, this);
     wxAssociateWinWithHandle(m_hFrame, this);
 

+    m_backgroundColour.Set(wxString("GREY"));
+
+    LONG                            lColor = (LONG)m_backgroundColour.GetPixel();
+
+    if (!::WinSetPresParam( m_hWnd
+                           ,PP_BACKGROUNDCOLOR
+                           ,sizeof(LONG)
+                           ,(PVOID)&lColor
+                          ))
+    {
+        vError = ::WinGetLastError(vHabmain);
+        sError = wxPMErrorToStr(vError);
+        wxLogError("Error creating frame. Error: %s\n", sError);
+        return FALSE;
+    }
+

     //
     // Now need to subclass window.  Instead of calling the SubClassWin in wxWindow
     // we manually subclass here because we don't want to use the main wxWndProc
     //
     // Now need to subclass window.  Instead of calling the SubClassWin in wxWindow
     // we manually subclass here because we don't want to use the main wxWndProc


@@ -1276,8 +1292,7 @@ bool wxFrame::HandlePaint()
         }
         else
         {
         }
         else
         {

-            wxWindow::HandlePaint();
-            return TRUE;
+            return(wxWindow::HandlePaint());

         }
     }
     else
         }
     }
     else


@@ -1585,23 +1600,22 @@ MRESULT wxFrame::OS2WindowProc(
             break;
 
         case WM_PAINT:
             break;
 
         case WM_PAINT:

-            {
-                HPS                             hPS;
-                RECTL                           vRect;
-                wxPaintEvent                    vEvent;
-
-                hPS = WinBeginPaint(m_hWnd, 0L, &vRect);
-                ::WinFillRect(hPS, &vRect,  CLR_BLUE  /* SYSCLR_WINDOW */);
-                ::WinEndPaint(hPS);
+            bProcessed = HandlePaint();
+            mRc = (MRESULT)FALSE;
+            break;

 
 

-                mRc = (MRESULT)FALSE;
-                vEvent.SetEventObject(this);
-                GetEventHandler()->ProcessEvent(vEvent);
-                bProcessed = TRUE;
-            }
+         case WM_ERASEBACKGROUND:
+            //
+            // Returning TRUE to requests PM to paint the window background
+            // in SYSCLR_WINDOW. We capture this here because the PS returned
+            // in Frames is the PS for the whole frame, which we can't really
+            // use at all. If you want to paint a different background, do it
+            // in an OnPaint using a wxPaintDC.
+            //
+            mRc = (MRESULT)(TRUE);

             break;
 
             break;
 

-        case WM_COMMAND:
+      case WM_COMMAND:

             {
                 WORD                wId;
                 WORD                wCmd;
             {
                 WORD                wId;
                 WORD                wCmd;


@@ -1656,15 +1670,6 @@ MRESULT wxFrame::OS2WindowProc(
             mRc = (MRESULT)FALSE;
             break;
 
             mRc = (MRESULT)FALSE;
             break;
 

-        case WM_ERASEBACKGROUND:
-            //
-            // Return TRUE to request PM to paint the window background
-            // in SYSCLR_WINDOW.
-            //
-            bProcessed = TRUE;
-            mRc = (MRESULT)(TRUE);
-            break;
-

         case CM_QUERYDRAGIMAGE:
             {
                 HPOINTER                hIcon;
         case CM_QUERYDRAGIMAGE:
             {
                 HPOINTER                hIcon;

diff --git a/src/os2/pen.cpp b/src/os2/pen.cpp
index 4e47b28cbbf69834c286b8db198b5bcf1c2878e6..58fc0fe2b04ea9e7b404a6988a6d5b91661ab882 100644 (file)
--- a/src/os2/pen.cpp
+++ b/src/os2/pen.cpp
@@ -263,7 +263,7 @@ bool wxPen::RealizeResource()
         }
 
         m_vAreaBundle.lColor        = vPmColour;
         }
 
         m_vAreaBundle.lColor        = vPmColour;

-        m_vAreaBundle.lBackColor    = CLR_DEFAULT;
+        m_vAreaBundle.lBackColor    = RGB_WHITE;

         m_vAreaBundle.usMixMode     = FM_OVERPAINT;
         m_vAreaBundle.usBackMixMode = BM_OVERPAINT;
 
         m_vAreaBundle.usMixMode     = FM_OVERPAINT;
         m_vAreaBundle.usBackMixMode = BM_OVERPAINT;
 

diff --git a/src/os2/region.cpp b/src/os2/region.cpp
index 2ea5f9d6847235629a86c314705ee0eede1a0133..112fccc32f607e170238cf586a8a965a016e301d 100644 (file)
--- a/src/os2/region.cpp
+++ b/src/os2/region.cpp
@@ -29,24 +29,51 @@ class WXDLLEXPORT wxRegionRefData : public wxGDIRefData {
 public:
     wxRegionRefData()
     {
 public:
     wxRegionRefData()
     {

-        m_region = 0;
+        m_hRegion = 0;

     }
 
     }
 

-    wxRegionRefData(const wxRegionRefData& data)
+    wxRegionRefData(const wxRegionRefData& rData)

     {
     {

-        // TODO
+        RGNRECT                     vRgnData;
+        PRECTL                      pRect = NULL;
+
+        if (::GpiQueryRegionRects( rData.m_hPS      // Pres space
+                                  ,rData.m_hRegion  // Handle of region to query
+                                  ,NULL             // Return all RECTs
+                                  ,&vRgnData        // Will contain number or RECTs in region
+                                  ,NULL             // NULL to return number of RECTs
+                                 ))
+        {
+            pRect = new RECTL[vRgnData.crcReturned];
+            vRgnData.crc = vRgnData.crcReturned;
+            vRgnData.ircStart = 1;
+            if (::GpiQueryRegionRects( rData.m_hPS     // Pres space of source
+                                      ,rData.m_hRegion // Handle of source region
+                                      ,NULL            // Return all RECTs
+                                      ,&vRgnData       // Operations set to return rects
+                                      ,pRect           // Will contain the actual RECTS
+                                     ))
+            {
+                m_hRegion = ::GpiCreateRegion( rData.m_hPS
+                                              ,vRgnData.crcReturned
+                                              ,pRect
+                                             );
+                m_hPS = rData.m_hPS;
+            }
+            delete [] pRect;
+        }

     }
 
     ~wxRegionRefData()
     {
     }
 
     ~wxRegionRefData()
     {

-        // TODO
-
+        ::GpiDestroyRegion(m_hPS, m_hRegion);

     }
 
     }
 

-    HRGN m_region;
+    HRGN                            m_hRegion;
+    HPS                             m_hPS;

 };
 
 };
 

-#define M_REGION (((wxRegionRefData*)m_refData)->m_region)
+#define M_REGION (((wxRegionRefData*)m_refData)->m_hRegion)

 
 //-----------------------------------------------------------------------------
 // wxRegion
 
 //-----------------------------------------------------------------------------
 // wxRegion


@@ -58,151 +85,331 @@ public:
 wxRegion::wxRegion()
 {
     m_refData = new wxRegionRefData;
 wxRegion::wxRegion()
 {
     m_refData = new wxRegionRefData;

-    // TODO create empty region
-}
+} // end of wxRegion::wxRegion

 
 

-wxRegion::wxRegion(WXHRGN hRegion)
+wxRegion::wxRegion(
+  WXHRGN                            hRegion
+)

 {
     m_refData = new wxRegionRefData;
     M_REGION = (HRGN) hRegion;
 {
     m_refData = new wxRegionRefData;
     M_REGION = (HRGN) hRegion;

-}
-
-wxRegion::wxRegion(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
+} // end of wxRegion::wxRegion
+
+wxRegion::wxRegion(
+  wxCoord                           x
+, wxCoord                           y
+, wxCoord                           vWidth
+, wxCoord                           vHeight
+)

 {
 {

-    m_refData = new wxRegionRefData;
-    // TODO create rect region
-}
-
-wxRegion::wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight)
+    RECTL                           vRect;
+    SIZEL                           vSize = {0, 0};
+    DEVOPENSTRUC                    vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
+    HDC                             hDC = ::DevOpenDC( vHabmain
+                                                      ,OD_MEMORY
+                                                      ,"*"
+                                                      ,5L
+                                                      ,(PDEVOPENDATA)&vDop
+                                                      ,NULLHANDLE
+                                                     );
+
+
+    vRect.xLeft   = x;
+    vRect.xRight  = x + vWidth;
+    vRect.yBottom = y;
+    vRect.yTop    = y + vHeight;
+
+    m_refData     = new wxRegionRefData;
+
+    //
+    // Need a PS to create a Region
+    //
+    ((wxRegionRefData*)m_refData)->m_hPS = ::GpiCreatePS( vHabmain
+                                                         ,hDC
+                                                         ,&vSize
+                                                         ,PU_PELS | GPIT_MICRO | GPIA_ASSOC
+                                                        );
+    M_REGION      = ::GpiCreateRegion( ((wxRegionRefData*)m_refData)->m_hPS
+                                      ,1
+                                      ,&vRect
+                                     );
+} // end of wxRegion::wxRegion
+
+wxRegion::wxRegion(
+  const wxPoint&                    rTopLeft
+, const wxPoint&                    rBottomRight
+)

 {
 {

-    m_refData = new wxRegionRefData;
-    // TODO create rect region
-}
-
-wxRegion::wxRegion(const wxRect& rect)
+    RECTL                           vRect;
+    SIZEL                           vSize = {0, 0};
+    DEVOPENSTRUC                    vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
+    HDC                             hDC = ::DevOpenDC( vHabmain
+                                                      ,OD_MEMORY
+                                                      ,"*"
+                                                      ,5L
+                                                      ,(PDEVOPENDATA)&vDop
+                                                      ,NULLHANDLE
+                                                     );
+
+    vRect.xLeft   = rTopLeft.x;
+    vRect.xRight  = rBottomRight.x;
+    vRect.yBottom = rBottomRight.y;
+    vRect.yTop    = rTopLeft.y;
+
+    m_refData     = new wxRegionRefData;
+
+    //
+    // Need a PS to create a Region
+    //
+    ((wxRegionRefData*)m_refData)->m_hPS = ::GpiCreatePS( vHabmain
+                                                         ,hDC
+                                                         ,&vSize
+                                                         ,PU_PELS | GPIT_MICRO | GPIA_ASSOC
+                                                        );
+    M_REGION      = ::GpiCreateRegion( ((wxRegionRefData*)m_refData)->m_hPS
+                                      ,1
+                                      ,&vRect
+                                     );
+} // end of wxRegion::wxRegion
+
+wxRegion::wxRegion(
+  const wxRect&                     rRect
+)

 {
 {

-    m_refData = new wxRegionRefData;
-    // TODO create rect region
-}
-
-/*!
- * Destroy the region.
- */
+    RECTL                           vRect;
+    SIZEL                           vSize = {0, 0};
+    DEVOPENSTRUC                    vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
+    HDC                             hDC = ::DevOpenDC( vHabmain
+                                                      ,OD_MEMORY
+                                                      ,"*"
+                                                      ,5L
+                                                      ,(PDEVOPENDATA)&vDop
+                                                      ,NULLHANDLE
+                                                     );
+
+
+    vRect.xLeft   = rRect.x;
+    vRect.xRight  = rRect.x + rRect.width;
+    vRect.yBottom = rRect.y;
+    vRect.yTop    = rRect.y + rRect.height;
+
+    m_refData     = new wxRegionRefData;
+
+    //
+    // Need a PS to create a Region
+    //
+    ((wxRegionRefData*)m_refData)->m_hPS = ::GpiCreatePS( vHabmain
+                                                         ,hDC
+                                                         ,&vSize
+                                                         ,PU_PELS | GPIT_MICRO | GPIA_ASSOC
+                                                        );
+    M_REGION      = ::GpiCreateRegion( ((wxRegionRefData*)m_refData)->m_hPS
+                                      ,1
+                                      ,&vRect
+                                     );
+} // end of wxRegion::wxRegion
+
+//
+// Destroy the region.
+//

 wxRegion::~wxRegion()
 {
 wxRegion::~wxRegion()
 {

-    // m_refData unrefed in ~wxObject
-}
+} // end of wxRegion::~wxRegion

 
 //-----------------------------------------------------------------------------
 //# Modify region
 //-----------------------------------------------------------------------------
 
 
 //-----------------------------------------------------------------------------
 //# Modify region
 //-----------------------------------------------------------------------------
 

-//! Clear current region
+//
+// Clear current region
+//

 void wxRegion::Clear()
 {
     UnRef();
 void wxRegion::Clear()
 {
     UnRef();

-}
-
-//! Combine rectangle (x, y, w, h) with this.
-bool wxRegion::Combine(wxCoord x, wxCoord y, wxCoord width, wxCoord height, wxRegionOp op)
+} // 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
+)

 {
 {

+    //

     // Don't change shared data
     // Don't change shared data

-    if (!m_refData) {
+    //
+    if (!m_refData)
+    {

         m_refData = new wxRegionRefData();
         m_refData = new wxRegionRefData();

-    } else if (m_refData->GetRefCount() > 1) {
-        wxRegionRefData* ref = (wxRegionRefData*)m_refData;
+    }
+    else if (m_refData->GetRefCount() > 1)
+    {
+        wxRegionRefData*            pRef = (wxRegionRefData*)m_refData;
+

         UnRef();
         UnRef();

-        m_refData = new wxRegionRefData(*ref);
+        m_refData = new wxRegionRefData(*pRef);

     }
     }

+
+    //

     // If ref count is 1, that means it's 'ours' anyway so no action.
     // If ref count is 1, that means it's 'ours' anyway so no action.

+    //
+    RECTL                           vRect;
+
+    vRect.xLeft   = x;
+    vRect.xRight  = x + vWidth;
+    vRect.yBottom = y;
+    vRect.yTop    = y + vHeight;

 
 

-    // TODO create rect region
+    HRGN                            hRgn = ::GpiCreateRegion( ((wxRegionRefData*)m_refData)->m_hPS
+                                                             ,1
+                                                             ,&vRect
+                                                            );
+    LONG                            lMode = 0L;

 
 

-    int mode = 0; // TODO platform-specific code
-    switch (op)
+    switch (eOp)

     {
         case wxRGN_AND:
     {
         case wxRGN_AND:

-            // TODO
-            break ;
+            lMode = CRGN_AND;
+            break;
+

         case wxRGN_OR:
         case wxRGN_OR:

-            // TODO
-            break ;
+            lMode = CRGN_OR;
+            break;
+

         case wxRGN_XOR:
         case wxRGN_XOR:

-            // TODO
-            break ;
+            lMode = CRGN_XOR;
+            break;
+

         case wxRGN_DIFF:
         case wxRGN_DIFF:

-            // TODO
-            break ;
+            lMode = CRGN_DIFF;
+            break;
+

         case wxRGN_COPY:
         default:
         case wxRGN_COPY:
         default:

-            // TODO
-            break ;
+            lMode = CRGN_COPY;
+            break;

     }
     }

-
-    // TODO do combine region
-
-    return FALSE;
-}
-
-//! Union /e region with this.
-bool wxRegion::Combine(const wxRegion& region, wxRegionOp op)
+    bool                            bSuccess = ::GpiCombineRegion( ((wxRegionRefData*)m_refData)->m_hPS
+                                                                  ,M_REGION
+                                                                  ,M_REGION
+                                                                  ,hRgn
+                                                                  ,lMode
+                                                                 );
+    ::GpiDestroyRegion ( ((wxRegionRefData*)m_refData)->m_hPS
+                        ,hRgn
+                       );
+
+    return bSuccess;
+} // end of wxRegion::Combine
+
+//
+// Union region with this.
+//
+bool wxRegion::Combine(
+  const wxRegion&                   rRegion
+, wxRegionOp                        eOp
+)

 {
 {

-    if (region.Empty())
+    if (rRegion.Empty())

         return FALSE;
 
         return FALSE;
 

+    //

     // Don't change shared data
     // Don't change shared data

-    if (!m_refData) {
+    //
+    if (!m_refData)
+    {

         m_refData = new wxRegionRefData();
         m_refData = new wxRegionRefData();

-    } else  if (m_refData->GetRefCount() > 1) {
-        wxRegionRefData* ref = (wxRegionRefData*)m_refData;
+    }
+    else  if (m_refData->GetRefCount() > 1)
+    {
+        wxRegionRefData*            pRef = (wxRegionRefData*)m_refData;
+

         UnRef();
         UnRef();

-        m_refData = new wxRegionRefData(*ref);
+        m_refData = new wxRegionRefData(*pRef);

     }
 
     }
 

-    int mode = 0; // TODO platform-specific code
-    switch (op)
+    LONG                            lMode = 0;
+
+    switch (eOp)

     {
         case wxRGN_AND:
     {
         case wxRGN_AND:

-            // TODO
-            break ;
+            lMode = CRGN_AND;
+            break;
+

         case wxRGN_OR:
         case wxRGN_OR:

-            // TODO
-            break ;
+            lMode = CRGN_OR;
+            break;
+

         case wxRGN_XOR:
         case wxRGN_XOR:

-            // TODO
-            break ;
+            lMode = CRGN_XOR;
+            break;
+

         case wxRGN_DIFF:
         case wxRGN_DIFF:

-            // TODO
-            break ;
+            lMode = CRGN_DIFF;
+            break;
+

         case wxRGN_COPY:
         default:
         case wxRGN_COPY:
         default:

-            // TODO
-            break ;
+            lMode = CRGN_COPY;
+            break;

     }
     }

-
-    // TODO combine region
-
-    return FALSE;
-}
-
-bool wxRegion::Combine(const wxRect& rect, wxRegionOp op)
+    return (::GpiCombineRegion( ((wxRegionRefData*)rRegion.m_refData)->m_hPS
+                               ,M_REGION
+                               ,M_REGION
+                               ,((wxRegionRefData*)rRegion.m_refData)->m_hRegion
+                               ,lMode
+                              ) != RGN_ERROR);
+} // end of wxRegion::Combine
+
+bool wxRegion::Combine(
+  const wxRect&                     rRect
+, wxRegionOp                        eOp
+)

 {
 {

-    return Combine(rect.GetLeft(), rect.GetTop(), rect.GetWidth(), rect.GetHeight(), op);
-}
+    return Combine( rRect.GetLeft()
+                   ,rRect.GetTop()
+                   ,rRect.GetWidth()
+                   ,rRect.GetHeight()
+                   ,eOp
+                  );
+} // end of wxRegion::Combine

 
 //-----------------------------------------------------------------------------
 //# Information on region
 //-----------------------------------------------------------------------------
 
 
 //-----------------------------------------------------------------------------
 //# Information on region
 //-----------------------------------------------------------------------------
 

+//

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

-void wxRegion::GetBox(wxCoord& x, wxCoord& y, wxCoord&w, wxCoord &h) const
+//
+void wxRegion::GetBox(
+  wxCoord&                          x
+, wxCoord&                          y
+, wxCoord&                          vWidth
+, wxCoord&                          vHeight
+) const

 {
 {

-    if (m_refData) {
-        // TODO get box
-    } else {
-        x = y = w = h = 0;
+    if (m_refData)
+    {
+        RECTL                       vRect;
+
+        ::GpiQueryRegionBox( ((wxRegionRefData*)m_refData)->m_hPS
+                            ,M_REGION
+                            ,&vRect
+                           );
+        x       = vRect.xLeft;
+        y       = vRect.yTop;
+        vWidth  = vRect.xRight - vRect.xLeft;
+        vHeight = vRect.yTop - vRect.yBottom;

     }
     }

-}
+    else
+    {
+        x = y = vWidth = vHeight = 0L;
+    }
+} // end of wxRegion::GetBox

 
 wxRect wxRegion::GetBox() const
 {
 
 wxRect wxRegion::GetBox() const
 {


@@ -211,73 +418,136 @@ wxRect wxRegion::GetBox() const
     return wxRect(x, y, w, h);
 }
 
     return wxRect(x, y, w, h);
 }
 

+//

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

+//

 bool wxRegion::Empty() const
 {
 bool wxRegion::Empty() const
 {

-    // TODO
-    return FALSE;
-}
+    wxCoord                         x;
+    wxCoord                         y;
+    wxCoord                         vWidth;
+    wxCoord                         vHeight;
+
+    if (M_REGION == 0)
+        return TRUE;
+
+    GetBox( x
+           ,y
+           ,vWidth
+           ,vHeight
+          );
+    return ((vWidth == 0) && (vHeight == 0));
+} // end of wxRegion::Empty

 
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------

-//# Tests
+// Tests

 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 

+//

 // Does the region contain the point (x,y)?
 // Does the region contain the point (x,y)?

-wxRegionContain wxRegion::Contains(wxCoord x, wxCoord y) const
+wxRegionContain wxRegion::Contains(
+  wxCoord                           x
+, wxCoord                           y
+) const

 {
 {

-    bool    bOK = FALSE; // temporary
+    bool                            bOK = FALSE;
+    POINTL                          vPoint;
+
+    vPoint.x = x;
+    vPoint.y = y;
+

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

-    // TODO. Return wxInRegion if within region.
-    if (bOK)
+    LONG                            lInside = ::GpiPtInRegion( ((wxRegionRefData*)m_refData)->m_hPS
+                                                              ,M_REGION
+                                                              ,&vPoint
+                                                             );
+    if (lInside == PRGN_INSIDE)

         return wxInRegion;
     return wxOutRegion;
         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& pt) const
+//
+wxRegionContain wxRegion::Contains(
+  const wxPoint&                    rPoint
+) const

 {
 {

-    bool    bOK = FALSE; // temporary
+    POINTL                          vPoint = { rPoint.x, rPoint.y };
+

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

-    // TODO. Return wxInRegion if within region.
-    if (bOK)
+    LONG                            lInside = ::GpiPtInRegion( ((wxRegionRefData*)m_refData)->m_hPS
+                                                              ,M_REGION
+                                                              ,&vPoint
+                                                             );
+    if (lInside == PRGN_INSIDE)

         return wxInRegion;
     else
         return wxOutRegion;
         return wxInRegion;
     else
         return wxOutRegion;

-}
+} // end of 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 w, wxCoord h) const
+//
+wxRegionContain wxRegion::Contains(
+  wxCoord                           x
+, wxCoord                           y
+, wxCoord                           vWidth
+, wxCoord                           vHeight
+) const

 {
 {

-    bool    bOK = FALSE; // temporary
+    RECTL                           vRect;
+

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

-    // TODO. Return wxInRegion if within region.
-    if (bOK)
+    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;
         return wxInRegion;
     else
         return wxOutRegion;

-}
+} // end of wxRegion::Contains

 
 

+//

 // Does the region contain the rectangle rect
 // Does the region contain the rectangle rect

-wxRegionContain wxRegion::Contains(const wxRect& rect) const
+//
+wxRegionContain wxRegion::Contains(
+  const wxRect&                     rRect
+) const

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

-    wxCoord x, y, w, h;
-    x = rect.x;
-    y = rect.y;
-    w = rect.GetWidth();
-    h = rect.GetHeight();
-    return Contains(x, y, w, h);
-}
-
+    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
+
+//

 // Get internal region handle
 // Get internal region handle

+//

 WXHRGN wxRegion::GetHRGN() const
 {
     if (!m_refData)
 WXHRGN wxRegion::GetHRGN() const
 {
     if (!m_refData)


@@ -291,96 +561,136 @@ WXHRGN wxRegion::GetHRGN() const
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 

-/*!
- * Initialize empty iterator
- */
-wxRegionIterator::wxRegionIterator() : m_current(0), m_numRects(0), m_rects(NULL)
+//
+// Initialize empty iterator
+//
+wxRegionIterator::wxRegionIterator()
+: m_lCurrent(0)
+, m_lNumRects(0)
+, m_pRects(NULL)

 {
 {

-}
+} // end of wxRegionIterator::wxRegionIterator

 
 wxRegionIterator::~wxRegionIterator()
 {
 
 wxRegionIterator::~wxRegionIterator()
 {

-    if (m_rects)
-        delete[] m_rects;
-}
-
-/*!
- * Initialize iterator for region
- */
-wxRegionIterator::wxRegionIterator(const wxRegion& region)
+    if (m_pRects)
+        delete[] m_pRects;
+} // end of wxRegionIterator::~wxRegionIterator
+
+//
+// Initialize iterator for region
+//
+wxRegionIterator::wxRegionIterator(
+  const wxRegion&                   rRegion
+)

 {
 {

-    m_rects = NULL;
-
-    Reset(region);
-}
-
-/*!
- * Reset iterator for a new /e region.
- */
-void wxRegionIterator::Reset(const wxRegion& region)
+    m_pRects = NULL;
+    Reset(rRegion);
+} // end of wxRegionIterator::wxRegionIterator
+
+//
+// Reset iterator for a new /e region.
+//
+void wxRegionIterator::Reset(
+  const wxRegion&                   rRegion
+)

 {
 {

-    m_current = 0;
-    m_region = region;
+    m_lCurrent = 0;
+    m_vRegion  = rRegion;

 
 

-    if (m_rects)
-        delete[] m_rects;
+    if (m_pRects)
+        delete[] m_pRects;

 
 

-    m_rects = NULL;
+    m_pRects = NULL;

 
 

-    if (m_region.Empty())
-        m_numRects = 0;
+    if (m_vRegion.Empty())
+        m_lNumRects = 0;

     else
     {
     else
     {

-        // TODO create m_rects and fill with rectangles for this region
-        m_numRects = 0;
+        RGNRECT                     vRgnData;
+        PRECTL                      pRect;
+
+        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
+                                  ,&vRgnData                                        // Will contain number or RECTs in region
+                                  ,NULL                                             // NULL to return number of RECTs
+                                 ))
+        {
+            pRect = new RECTL[vRgnData.crcReturned];
+            m_pRects = new wxRect[vRgnData.crcReturned];
+            vRgnData.crc = vRgnData.crcReturned;
+            m_lNumRects = vRgnData.crcReturned;
+            vRgnData.ircStart = 1;
+            if (::GpiQueryRegionRects( ((wxRegionRefData*)rRegion.m_refData)->m_hPS     // Pres space of source
+                                      ,((wxRegionRefData*)rRegion.m_refData)->m_hRegion // Handle of source region
+                                      ,NULL                                             // Return all RECTs
+                                      ,&vRgnData                                        // Operations set to return rects
+                                      ,pRect                                            // Will contain the actual RECTS
+                                     ))
+            {
+                M_REGION = ::GpiCreateRegion( ((wxRegionRefData*)rRegion.m_refData)->m_hPS
+                                             ,vRgnData.crcReturned
+                                             ,pRect
+                                            );
+                for( LONG i = 0; i < m_lNumRects; i++)
+                {
+                    m_pRects[i].x      = pRect[i].xLeft;
+                    m_pRects[i].width  = pRect[i].xRight - pRect[i].xLeft;
+                    m_pRects[i].y      = pRect[i].yBottom;
+                    m_pRects[i].height = pRect[i].yTop - pRect[i].yBottom;
+                }
+                ((wxRegionRefData*)m_refData)->m_hPS = ((wxRegionRefData*)rRegion.m_refData)->m_hPS;
+            }
+        }

     }
     }

-}
+} // end of wxRegionIterator::Reset

 
 

-/*!
- * Increment iterator. The rectangle returned is the one after the
- * incrementation.
- */
-void wxRegionIterator::operator ++ ()
+//
+// Increment iterator. The rectangle returned is the one after the
+// incrementation.
+//
+void wxRegionIterator::operator++ ()

 {
 {

-    if (m_current < m_numRects)
-        ++m_current;
-}
-
-/*!
- * Increment iterator. The rectangle returned is the one before the
- * incrementation.
- */
-void wxRegionIterator::operator ++ (int)
+    if (m_lCurrent < m_lNumRects)
+        ++m_lCurrent;
+} // end of wxRegionIterator::operator ++
+
+//
+// Increment iterator. The rectangle returned is the one before the
+// incrementation.
+//
+void wxRegionIterator::operator++ (int)

 {
 {

-    if (m_current < m_numRects)
-        ++m_current;
-}
+    if (m_lCurrent < m_lNumRects)
+        ++m_lCurrent;
+} // end of wxRegionIterator::operator++

 
 wxCoord wxRegionIterator::GetX() const
 {
 
 wxCoord wxRegionIterator::GetX() const
 {

-    if (m_current < m_numRects)
-        return m_rects[m_current].x;
-    return 0;
-}
+    if (m_lCurrent < m_lNumRects)
+        return m_pRects[m_lCurrent].x;
+    return 0L;
+} // end of wxRegionIterator::GetX

 
 wxCoord wxRegionIterator::GetY() const
 {
 
 wxCoord wxRegionIterator::GetY() const
 {

-    if (m_current < m_numRects)
-        return m_rects[m_current].y;
-    return 0;
-}
+    if (m_lCurrent < m_lNumRects)
+        return m_pRects[m_lCurrent].y;
+    return 0L;
+} // end of wxRegionIterator::GetY

 
 wxCoord wxRegionIterator::GetW() const
 {
 
 wxCoord wxRegionIterator::GetW() const
 {

-    if (m_current < m_numRects)
-        return m_rects[m_current].width ;
-    return 0;
-}
+    if (m_lCurrent < m_lNumRects)
+        return m_pRects[m_lCurrent].width ;
+    return 0L;
+} // end of wxRegionIterator::GetW

 
 wxCoord wxRegionIterator::GetH() const
 {
 
 wxCoord wxRegionIterator::GetH() const
 {

-    if (m_current < m_numRects)
-        return m_rects[m_current].height;
-    return 0;
-}
+    if (m_lCurrent < m_lNumRects)
+        return m_pRects[m_lCurrent].height;
+    return 0L;
+} // end of wxRegionIterator::GetH

 
 

diff --git a/src/os2/window.cpp b/src/os2/window.cpp
index c1ea3d70685fcda3826b8eca8647f524e43cfcd3..c43e2576a0e14fdb44d36b9fefb435b14c8f0fb6 100644 (file)
--- a/src/os2/window.cpp
+++ b/src/os2/window.cpp
@@ -2106,6 +2106,15 @@ MRESULT wxWindow::OS2WindowProc(
             }
             break;
 #endif
             }
             break;
 #endif

+        case WM_ERASEBACKGROUND:
+            //
+            // Returning TRUE to requestw PM to paint the window background
+            // in SYSCLR_WINDOW. We don't really want that
+            //
+            bProcessed = HandleEraseBkgnd((WXHDC)(HPS)wParam);
+            mResult = (MRESULT)(FALSE);
+            break;
+

         //
         // Instead of CTLCOLOR messages PM sends QUERYWINDOWPARAMS to
         // things such as colors and fonts and such
         //
         // Instead of CTLCOLOR messages PM sends QUERYWINDOWPARAMS to
         // things such as colors and fonts and such


@@ -2133,17 +2142,6 @@ MRESULT wxWindow::OS2WindowProc(
             bProcessed = HandlePresParamChanged(wParam);
             break;
 
             bProcessed = HandlePresParamChanged(wParam);
             break;
 

-        // move this to wxFrame
-        case WM_ERASEBACKGROUND:
-            bProcessed = HandleEraseBkgnd((WXHDC)(HDC)wParam);
-            if (bProcessed)
-            {
-                //
-                // We processed the message, i.e. erased the background
-                //
-                mResult = (MRESULT)TRUE;
-            }
-            break;

 
         // move all drag and drops to wxDrg
         case WM_ENDDRAG:
 
         // move all drag and drops to wxDrg
         case WM_ENDDRAG:


@@ -2844,47 +2842,36 @@ bool wxWindow::HandlePaint()
          wxLogLastError("CreateRectRgn");
          return FALSE;
     }
          wxLogLastError("CreateRectRgn");
          return FALSE;
     }

-    //
-    // Debug code
-    //
-#ifdef __WXDEBUG__
-    {
-        HWND                        hWnd;
-        HWND                        hWnd0 = NULLHANDLE;
-
-        hWnd = GetHwnd();
-        if(hWnd != hWnd0)
-            printf("HandlePaint hWnd=%x  ",hWnd);
-    }
-#endif

 
     m_updateRegion = wxRegion(hRgn);
     vEvent.SetEventObject(this);
     return (GetEventHandler()->ProcessEvent(vEvent));
 } // end of wxWindow::HandlePaint
 
 
     m_updateRegion = wxRegion(hRgn);
     vEvent.SetEventObject(this);
     return (GetEventHandler()->ProcessEvent(vEvent));
 } // end of wxWindow::HandlePaint
 

-bool wxWindow::HandleEraseBkgnd(WXHDC hdc)
+bool wxWindow::HandleEraseBkgnd(
+  WXHDC                             hDC
+)

 {
 {

-    // TODO:  will have to worry about this later as part of
-    //        the handling of changed presentation parameters
-    /*
-    if ( ::IsIconic(GetHwnd()) )
+    SWP                             vSwp;
+
+    ::WinQueryWindowPos(GetHwnd(), &vSwp);
+    if (vSwp.fl & SWP_MINIMIZE)

         return TRUE;
 
         return TRUE;
 

-    wxDC dc;
+    wxDC                            vDC;
+
+    vDC.m_hPS = (HPS)hDC; // this is really a PS
+    vDC.SetWindow(this);
+    vDC.BeginDrawing();

 
 

-    dc.SetHDC(hdc);
-    dc.SetWindow(this);
-    dc.BeginDrawing();
+    wxEraseEvent                    vEvent(m_windowId, &vDC);
+
+    vEvent.SetEventObject(this);

 
 

-    wxEraseEvent event(m_windowId, &dc);
-    event.SetEventObject(this);
-    bool rc = GetEventHandler()->ProcessEvent(event);
+    bool                            rc = GetEventHandler()->ProcessEvent(vEvent);

 
 

-    dc.EndDrawing();
-    dc.SelectOldObjects(hdc);
-    dc.SetHDC((WXHDC) NULL);
-    */
+    vDC.EndDrawing();
+    vDC.m_hPS = NULLHANDLE;

     return TRUE;
 } // end of wxWindow::HandleEraseBkgnd
 
     return TRUE;
 } // end of wxWindow::HandleEraseBkgnd
 


@@ -2892,7 +2879,11 @@ void wxWindow::OnEraseBackground(
   wxEraseEvent&                     rEvent
 )
 {
   wxEraseEvent&                     rEvent
 )
 {

-    // TODO:
+    RECTL                           vRect;
+    HPS                             hPS = rEvent.m_dc->m_hPS;
+
+    ::WinQueryWindowRect(GetHwnd(), &vRect);
+    ::WinFillRect(hPS, &vRect,  m_backgroundColour.GetPixel());

 }  // end of wxWindow::OnEraseBackground
 
 // ---------------------------------------------------------------------------
 }  // end of wxWindow::OnEraseBackground
 
 // ---------------------------------------------------------------------------