Changeset 10316 for trunk/src/gdi32/region.cpp

Timestamp:

Nov 12, 2003, 3:13:26 PM (22 years ago)

Author:

sandervl

Message:

Visible & Clip region changes

File:

• trunk/src/gdi32/region.cpp (modified) (34 diffs)

trunk/src/gdi32/region.cpp

@@ -1 @@
-/* $Id: region.cpp,v 1.32 2003-06-03 13:48:13 sandervl Exp $ */
+/* $Id: region.cpp,v 1.33 2003-11-12 14:10:55 sandervl Exp $ */
 
 /*
@@ -6 +6 @@
  * Copyright 1998-2000 Sander van Leeuwen (sandervl@xs4all.nl)
  * Copyright 1998 Patrick Haller
+ * Copyright 2002-2003 Innotek Systemberatung GmbH (sandervl@innotek.de)
  *
  * TODO: Metafile recording
  * TODO: Do we need to translate & set the last error for Gpi operations?
+ *
+ *
+ * NOTE: In windows there is a clip and a visible region (just like in PM)
+ *       We do not map the Win32 visible region to the PM visible region
+ *       as that's rather annoying.
+ *       Instead we use the intersection of the win32 visible and win32 clip 
+ *       region for the PM clip region.
+ *       The original Win32 clip region is saved in pHps->hrgnWin32Clip.
+ *       The Win32 visible region is saved in pHps->hrgnWinVis.
+ * 
+ *
  *
  * Project Odin Software License can be found in LICENSE.TXT
@@ -31 +43 @@
 #include <stats.h>
 #include "dibsect.h"
+#include <wingdi32.h>
 
 #define DBG_LOCALLOG    DBG_region
 #include "dbglocal.h"
+
+//GPI and Windows use the same values
+#define GPI_TO_WIN_COMPLEXITY(a)        a
 
 typedef enum
@@ -42 +58 @@
 
 #define MEM_HPS_MAX 768
+
+int WIN32API OffsetRgn( HRGN  hrgn, int  xOffset, int  yOffset);
 
 static void convertDeviceRect(HWND hwnd, pDCData pHps, PRECTL pRectl, ULONG count);
@@ -107 +125 @@
         LONG y = 0;
 
-        if(pHps == 0 || pHps->isClient) //client area
+        if(pHps && pHps->isClient) //client area
         {
             if(GetClientRect(OS2ToWin32Handle(hwnd), &rect) == TRUE) {
@@ -132 +150 @@
    if(pHps->isPrinter)
    {
-      return pHps->printPageHeight;
+      return GetDeviceCaps(pHps->hps, VERTRES_W);
    }
    else
@@ -152 +170 @@
         LONG x = 0;
 
-        if(pHps == 0 || pHps->isClient) //client area
+        if(pHps && pHps->isClient) //client area
         {
             if(GetClientRect(OS2ToWin32Handle(hwnd), &rect) == TRUE) {
@@ -164 +182 @@
         return x;
    }
+   else
+   if(pHps->bitmapHandle)
+   {
+      return pHps->bitmapWidth;
+   }
+   else
+   if(pHps->isMetaPS)
+   {
+      return 0;
+   }
+   else
+   if(pHps->isPrinter)
+   {
+      return GetDeviceCaps(pHps->hps, HORZRES_W);
+   }
 //   else
 //     DebugInt3();
@@ -211 +244 @@
     if(pHps)
     {
-         wHeight += pHps->HPStoHDCInversionHeight;
+        wHeight += pHps->HPStoHDCInversionHeight;
     }
 
@@ -388 +421 @@
 }
 //******************************************************************************
-//******************************************************************************
-int WIN32API SelectClipRgn(HDC hdc, HRGN hrgn)
-{
- LONG lComplexity = RGN_NULL;
- HRGN hrgnNewClip;
- HRGN hrgnOldClip;
+// GdiSetVisRgn
+//
+// Change the Win32 visible region to the specified region
+//
+// Parameters:
+// 
+// pDCData pHps         - presentation space structure
+// HRGN hrgn            - region handle (GPI)
+//
+//
+// Returns:     - ERROR_W         -> failure
+//              - NULLREGION_W    -> empty region
+//              - SIMPLEREGION_W  -> rectangular region
+//              - COMPLEXREGION_W -> complex region
+//
+// NOTE: In windows there is a clip and a visible region (just like in PM)
+//       We do not map the Win32 visible region to the PM visible region
+//       as that's rather annoying.
+//       Instead we use the intersection of the win32 visible and win32 clip 
+//       region for the PM clip region.
+//       The Win32 clip region is saved in pHps->hrgnWin32Clip.
+//       The Win32 visible region is saved in pHps->hrgnWinVis.
+//
+//******************************************************************************
+INT WIN32API GdiSetVisRgn(pDCData pHps, HRGN hrgn)
+{
+    HRGN hrgnNewClip = NULLHANDLE, hrgnOldClip = NULLHANDLE;
+    LONG lComplexity = RGN_NULL;
+    RECTL rectl = {0, 0, 1, 1};
+
+    if(pHps == NULL) {
+        DebugInt3();
+        return ERROR_W;
+    }
+
+    if(hrgn != NULLHANDLE) 
+    {
+        hrgnNewClip = GpiCreateRegion(pHps->hps, 1, &rectl);
+        if(hrgnNewClip == NULLHANDLE) {
+            dprintf(("ERROR: GdiCombineVisRgn: GpiCreateRegion failed!!"));
+            DebugInt3();
+            goto failure;
+        }
+        //make a copy of the new visible region
+        lComplexity = GpiCombineRegion(pHps->hps, hrgnNewClip, hrgn, NULLHANDLE, CRGN_COPY);
+    }
+    else {
+        hrgnNewClip = NULLHANDLE;
+    }
+
+    //and set that as the GPI clip region
+    lComplexity = GpiSetClipRegion(pHps->hps, hrgnNewClip, &hrgnOldClip);
+    if (lComplexity != RGN_ERROR)
+    {
+        //SvL: Must check if origin changed here. Sometimes happens when
+        //     window looses focus. (don't know why....)
+        checkOrigin(pHps);
+
+        if(hrgnOldClip) GpiDestroyRegion(pHps->hps, hrgnOldClip);
+
+        dprintf(("New visible region %x", hrgn));
+        pHps->hrgnWinVis = hrgn;
+        return GPI_TO_WIN_COMPLEXITY(lComplexity);
+    }
+failure:
+    if(hrgnNewClip) GpiDestroyRegion(pHps->hps, hrgnNewClip);
+
+    return ERROR_W;
+}
+//******************************************************************************
+// GdiCombineVisRgn
+//
+// Combine the specified region with the visible region according to the operation
+//
+// Parameters:
+// 
+// pDCData pHps         - presentation space structure
+// HRGN hrgn            - region handle (Win32)
+// INT operation        - combine operation (RGN_*)
+//
+//
+// Returns:     - ERROR_W         -> failure
+//              - NULLREGION_W    -> empty region
+//              - SIMPLEREGION_W  -> rectangular region
+//              - COMPLEXREGION_W -> complex region
+//
+// NOTE: In windows there is a clip and a visible region (just like in PM)
+//       We do not map the Win32 visible region to the PM visible region
+//       as that's rather annoying.
+//       Instead we use the intersection of the win32 visible and win32 clip 
+//       region for the PM clip region.
+//       The Win32 clip region is saved in pHps->hrgnWin32Clip.
+//       The Win32 visible region is saved in pHps->hrgnWinVis.
+//
+//******************************************************************************
+INT WIN32API GdiCombineVisRgn(pDCData pHps, HRGN hrgn, INT operation)
+{
 #ifdef DEBUG
- HRGN hrgn1 = hrgn;
+    HRGN hrgn1 = hrgn;
 #endif
-
-    pDCData  pHps = (pDCData)OSLibGpiQueryDCData((HPS)hdc);
-    if(!pHps)
-    {
-        dprintf(("WARNING: SelectClipRgn: invalid hdc!", hdc, hrgn));
-        SetLastError(ERROR_INVALID_HANDLE_W);
+    LONG lComplexity = RGN_NULL;
+
+    if(pHps == NULL) {
+        DebugInt3();
         return ERROR_W;
     }
 
-    if(hrgn)
-    {
-        hrgn = ObjQueryHandleData(hrgn, HNDL_REGION);
-        if(hrgn == HANDLE_OBJ_ERROR) {
-            dprintf(("WARNING: SelectClipRgn: invalid region!", hdc, hrgn1));
-            SetLastError(ERROR_INVALID_HANDLE_W);
-            return ERROR_W;
-        }
-    }
-
-    if(hrgn)
-    {
-        RECTL rectl = {0,0,1,1};
-        hrgnNewClip = GpiCreateRegion(pHps->hps, 1, &rectl);
-        if(interpretRegionAs(pHps, hrgnNewClip, hrgn, AS_DEVICE) == 0)
+    hrgn = ObjQueryHandleData(hrgn, HNDL_REGION);
+    if(hrgn == HANDLE_OBJ_ERROR || !pHps) {
+        dprintf(("ERROR: GdiCombineVisRgn %x invalid handle", hrgn1));
+        return ERROR_W;
+    }
+    //interpretRegionAs converts the region and saves it in pHps->hrgnHDC
+    if(!interpretRegionAs(pHps, 0, hrgn, AS_DEVICE) )
+    {
+        dprintf(("ERROR: interpretRegionAs failed!!"));
+        return ERROR_W;
+    }
+
+    //If there is no visible region, then create one that covers the whole DC
+    if(pHps->hrgnWinVis == NULLHANDLE) 
+    {
+         RECTL rectl = {0, 0, hdcWidth(0, pHps), hdcHeight(0, pHps)};
+         dprintf(("No visible region: create one (0,0)(%d,%d)", rectl.xRight, rectl.yTop));
+         pHps->hrgnWinVis = GpiCreateRegion(pHps->hps, 1, &rectl);
+         if(pHps->hrgnWinVis == NULLHANDLE) {
+             dprintf(("ERROR: GdiCombineVisRgn: GpiCreateRegion failed!!"));
+             DebugInt3();
+             goto failure;
+         }
+    }
+
+    LONG lMode;
+    switch (operation)
+    {
+    case  RGN_AND_W  : lMode = CRGN_AND ; break;
+    case  RGN_DIFF_W : lMode = CRGN_DIFF; break;
+    default:
+        dprintf(("ERROR: GdiCombineVisRgn %d invalid parameter", operation));
+        DebugInt3();
+        goto failure;
+    }
+    lComplexity = GpiCombineRegion(pHps->hps, pHps->hrgnWinVis, pHps->hrgnWinVis, pHps->hrgnHDC, lMode);
+    if (lComplexity != RGN_ERROR)
+    {
+        return GdiSetVisRgn(pHps, pHps->hrgnWinVis);
+    }
+    dprintf(("ERROR: GdiCombineVisRgn: GpiCombineRegion failed"));
+    DebugInt3();
+
+failure:
+    return ERROR_W;
+}
+//******************************************************************************
+// GdiCombineVisRgnClipRgn
+//
+// Combine the specified clip region with the visible region according to the operation
+//
+// Parameters:
+// 
+// pDCData pHps         - presentation space structure
+// HRGN hrgn            - region handle (GPI)
+// INT operation        - combine operation (RGN_*)
+//
+//
+// Returns:     - ERROR_W         -> failure
+//              - NULLREGION_W    -> empty region
+//              - SIMPLEREGION_W  -> rectangular region
+//              - COMPLEXREGION_W -> complex region
+//
+// NOTE: In windows there is a clip and a visible region (just like in PM)
+//       We do not map the Win32 visible region to the PM visible region
+//       as that's rather annoying.
+//       Instead we use the intersection of the win32 visible and win32 clip 
+//       region for the PM clip region.
+//       The Win32 clip region is saved in pHps->hrgnWin32Clip.
+//       The Win32 visible region is saved in pHps->hrgnWinVis.
+//
+//******************************************************************************
+INT WIN32API GdiCombineVisRgnClipRgn(pDCData pHps, HRGN hrgn, INT operation)
+{
+    HRGN hrgnClip = NULL, hrgnOldClip, hrgnNewClip;
+    LONG lComplexity = RGN_NULL;
+
+    //Create a region that will be used for the new GPI clip region
+    RECTL rectl = {0, 0, 1, 1};
+    hrgnNewClip = GpiCreateRegion(pHps->hps, 1, &rectl);
+    if(hrgnNewClip == NULLHANDLE) {
+        dprintf(("ERROR: GdiCombineVisRgnClipRgn: GpiCreateRegion failed!!"));
+        DebugInt3();
+        return ERROR_W;
+    }
+
+    if(hrgn == NULLHANDLE) 
+    {
+        if(pHps->hrgnWin32Clip != NULL) 
         {
-            lComplexity = RGN_ERROR;
-        }
-    }
-    else
-        hrgnNewClip = 0;
-
-    if(lComplexity != RGN_ERROR)
-    {
-        if(hrgnNewClip == 0) {
-            GpiSetClipPath(pHps->hps, 0, SCP_RESET);
-        }
-        lComplexity = GpiSetClipRegion(pHps->hps, hrgnNewClip, &hrgnOldClip);
-        if (lComplexity != RGN_ERROR )
-        {
-            if(hrgnOldClip)
-                GpiDestroyRegion(pHps->hps, hrgnOldClip);
-
-            //todo: metafile recording
-            SetLastError(ERROR_SUCCESS_W);
+            //Only reset the path if both the visible and clip regions are zero
+            if(!pHps->hrgnWinVis) {
+                GpiSetClipPath(pHps->hps, 0, SCP_RESET);
+
+                GpiDestroyRegion(pHps->hps, hrgnNewClip);
+                hrgnNewClip = NULLHANDLE;
+            }
+            else 
+            {//set PM clip region to Win32 visible region
+                lComplexity = GpiCombineRegion(pHps->hps, hrgnNewClip, pHps->hrgnWinVis, NULLHANDLE, CRGN_COPY);
+                if(lComplexity == RGN_ERROR) {
+                    dprintf(("ERROR: GdiCombineVisRgnClipRgn: GpiSetClipRegion failed!!"));
+                    DebugInt3();
+                    goto failure;
+                }
+            }
+            dprintfRegion(pHps->hps, hrgnNewClip);
+            lComplexity = GpiSetClipRegion(pHps->hps, hrgnNewClip, &hrgnOldClip);
+            if(lComplexity == RGN_ERROR) {
+                dprintf(("ERROR: GdiCombineVisRgnClipRgn: GpiSetClipRegion failed!!"));
+                DebugInt3();
+            }
 
             //SvL: Must check if origin changed here. Sometimes happens when
             //     window looses focus. (don't know why....)
             checkOrigin(pHps);
-            return lComplexity;
-        }
-    }
-
-    dprintf(("WARNING: SelectClipRgn: RGN_ERROR!", hdc, hrgn1));
-    if(hrgnNewClip)
-        GpiDestroyRegion(pHps->hps, hrgnNewClip);
-
-    SetLastError(ERROR_SUCCESS_W);
-    return lComplexity;
+            if(hrgnOldClip) GpiDestroyRegion(pHps->hps, hrgnOldClip);
+        }
+        //else already NULL, so nothing to do.
+
+        pHps->hrgnWin32Clip = hrgn;
+        return NULLREGION_W;
+    }
+
+    LONG lMode;
+    switch (operation)
+    {
+    case  RGN_AND_W  : lMode = CRGN_AND ; break;  //intersect clip & visible region
+    default:
+        dprintf(("ERROR: GdiCombineVisRgnClipRgn %d invalid parameter", operation));
+        DebugInt3();
+        goto failure;
+    }
+    // If there's no visible region (meaning entire DC is visible), then just set 
+    // the GPI clip region to the win32 clip region
+    if (pHps->hrgnWinVis == NULLHANDLE) 
+    {
+         lComplexity = GpiCombineRegion(pHps->hps, hrgnNewClip, hrgn, NULLHANDLE, CRGN_COPY);
+    }
+    else lComplexity = GpiCombineRegion(pHps->hps, hrgnNewClip, pHps->hrgnWinVis, hrgn, lMode);
+
+    if (lComplexity != RGN_ERROR)
+    {
+        dprintfRegion(pHps->hps, hrgnNewClip);
+        //And activate the new clip region
+        lComplexity = GpiSetClipRegion(pHps->hps, hrgnNewClip, &hrgnOldClip);
+        if (lComplexity == RGN_ERROR )
+        {
+            dprintf(("ERROR: GdiCombineVisRgnClipRgn: GpiSetClipRegion failed"));
+            DebugInt3();
+            goto failure;
+        }
+        //SvL: Must check if origin changed here. Sometimes happens when
+        //     window looses focus. (don't know why....)
+        checkOrigin(pHps);
+
+        if(hrgnOldClip) GpiDestroyRegion(pHps->hps, hrgnOldClip);
+
+        pHps->hrgnWin32Clip = hrgn;
+
+        return GPI_TO_WIN_COMPLEXITY(lComplexity);
+    }
+    dprintf(("ERROR: GdiCombineVisRgnClipRgn: GpiCombineRegion failed"));
+    DebugInt3();
+
+failure:
+    if(hrgnNewClip) GpiDestroyRegion(pHps->hps, hrgnNewClip);
+
+    return ERROR_W;
 }
 //******************************************************************************
@@ -464 +706 @@
 #endif
 
-   pDCData    pHps = (pDCData)OSLibGpiQueryDCData((HPS)hdc);
+   pDCData pHps = (pDCData)OSLibGpiQueryDCData((HPS)hdc);
    if (!pHps)
    {
@@ -473 +715 @@
 
    LONG lComplexity;
-   HRGN hrgnCurrent = NULLHANDLE;
+   HRGN hrgnCurrent = NULLHANDLE, hrgnOld = NULLHANDLE;
 
    if(!hrgn && mode != RGN_COPY_W)
@@ -506 +748 @@
             return 0;
         }
+        dprintfRegion(hdc, hrgn);
    }
 
@@ -511 +754 @@
    if(hrgn)
    {
+        //interpretRegionAs converts the region and saves it in pHps->hrgnHDC
         if(!interpretRegionAs(pHps, 0, hrgn, AS_DEVICE) )
         {
@@ -518 +762 @@
    else
    {
-        //remove clip region
-        GpiSetClipPath(pHps->hps, 0, SCP_RESET);
-        GpiSetClipRegion(pHps->hps, NULLHANDLE, &hrgnCurrent);
-
-        if(hrgnCurrent)
-            GpiDestroyRegion(pHps->hps, hrgnCurrent);
+        //Intersect the Windows clip region with the current visible region
+        lComplexity = GdiCombineVisRgnClipRgn(pHps, NULLHANDLE, RGN_AND_W);
 
         return NULLREGION_W;
    }
 
-   GpiSetClipRegion(pHps->hps, NULLHANDLE, &hrgnCurrent);
+   // get current clipping region
+   hrgnOld     = pHps->hrgnWin32Clip;
+   hrgnCurrent = hrgnOld;
 
    if(hrgnCurrent == NULLHANDLE)
-   {
+   {//if none, then create one
         lMode = CRGN_COPY;
         RECTL rectl = {0, 0, 1, 1};
@@ -554 +796 @@
    {
         HRGN hrgnOld;
-        lComplexity = GpiSetClipRegion(pHps->hps, hrgnCurrent, &hrgnOld);
+
+        //Intersect the Windows clip region with the current visible region
+        lComplexity = GdiCombineVisRgnClipRgn(pHps, hrgnCurrent, RGN_AND_W);
+
         SetLastError(ERROR_SUCCESS_W);
 
-        //SvL: Must check if origin changed here. Sometimes happens when
-        //     window looses focus. (don't know why....)
-        checkOrigin(pHps);
-
-        if (lComplexity != RGN_ERROR)
+        if (lComplexity != RGN_ERROR) {
             return lComplexity;
-   }
-   SetLastError(ERROR_SUCCESS_W);
+        }
+   }
+   GpiDestroyRegion(pHps->hps, hrgnCurrent); //delete newly created region
+
+   SetLastError(ERROR_INVALID_PARAMETER_W); //TODO
    return ERROR_W;
 }
 //******************************************************************************
+//******************************************************************************
+int WIN32API SelectClipRgn(HDC hdc, HRGN hrgn)
+{
+    return ExtSelectClipRgn(hdc, hrgn, RGN_COPY_W);
+}
+//******************************************************************************
+// The GetClipBox function retrieves the dimensions of the tightest bounding 
+// rectangle that can be drawn around the current visible area on the device. 
+// The visible area is defined by the current clipping region or clip path, as well 
+// as any overlapping windows.
+//
+// NOTE: We simply call GpiQueryClipBox as it behaves just like GetClipBox
+//
 //******************************************************************************
 int WIN32API GetClipBox(HDC hdc, PRECT lpRect)
@@ -583 +840 @@
     if(pHps->isPrinter)
     {
+        //Some printers return the wrong clip box. Return the full page instead.
+        //(TODO: which is incorrect!)
         lpRect->left   = 0;
         lpRect->top    = 0;
@@ -608 +867 @@
             //Convert coordinates from PM to win32
             if (pHps->yInvert > 0) {
-             LONG temp     = pHps->yInvert - rectl.yBottom;
-                 rectl.yBottom = pHps->yInvert - rectl.yTop;
-             rectl.yTop    = temp;
+                LONG temp     = pHps->yInvert - rectl.yBottom;
+                rectl.yBottom = pHps->yInvert - rectl.yTop;
+                rectl.yTop    = temp;
             }
 #endif
@@ -628 +887 @@
             }
 
-            rc = (lComplexity == RGN_RECT) ? SIMPLEREGION_W : COMPLEXREGION_W;
+            rc = GPI_TO_WIN_COMPLEXITY(lComplexity);
         }
     }
@@ -655 +914 @@
     }
 
-    if(GpiSetClipRegion(pHps->hps, NULL, &hrgnClip) == RGN_ERROR) {
-        dprintf(("WARNING: GetClipRgn GpiSetClipRegion failed! (%x)", WinGetLastError(0)));
-        SetLastError(ERROR_INVALID_PARAMETER_W); //todo right errror
-        return 0;
-    }
-    if(hrgnClip) {
-        if(!setWinDeviceRegionFromPMDeviceRegion(hrgn, hrgnClip, pHps, NULL)) {
-                dprintf(("WARNING: GetClipRgn setWinDeviceRegionFromPMDeviceRegion failed!"));
-                GpiSetClipRegion(pHps->hps, hrgnClip, &hrgnTemp);
-                SetLastError(ERROR_INVALID_PARAMETER_W); //todo right errror
-                return 0;
-        }
-        if(GpiSetClipRegion(pHps->hps, hrgnClip, &hrgnTemp) == RGN_ERROR )
-        {
-            dprintf(("WARNING: GetClipRgn GpiSetClipRegion failed %x!", WinGetLastError(0)));
+    if(pHps->hrgnWin32Clip) {
+        dprintfRegion(hdc, pHps->hrgnWin32Clip);
+        if(!setWinDeviceRegionFromPMDeviceRegion(hrgn, pHps->hrgnWin32Clip, pHps, NULL)) {
+            dprintf(("WARNING: GetClipRgn setWinDeviceRegionFromPMDeviceRegion failed!"));
+            GpiSetClipRegion(pHps->hps, hrgnClip, &hrgnTemp);
             SetLastError(ERROR_INVALID_PARAMETER_W); //todo right errror
             return 0;
         }
     }
-    else lComplexity = RGN_NULL;
+    else {
+       //no clip region; return NULL
+       lComplexity = RGN_NULL;
+    }
 
     SetLastError(ERROR_SUCCESS_W);
@@ -682 +934 @@
 }
 //******************************************************************************
+// The GetRandomRgn function copies the system clipping region of a specified 
+// device context to a specific region.
+// It returns the visible region of the specified device context in screen
+// coordinates (if it belongs to a window).
+//
+// VALUE = 1: This undocumented value will return the current Clip Region contained in the DC.
+// VALUE = 2: This undocumented value will return the current Meta Region contained in the DC.
+// VALUE = 3: This undocumented value will return the intersection of the Clip Region and Meta Region. 
+// VALUE = 4, SYSRGN: The only value that is documented and defined for this function. 
+//                    This value returns the System Region
+//******************************************************************************
+INT WIN32API GetRandomRgn(HDC hdc, HRGN hrgn, INT iNum)
+{
+    HWND hwnd;
+    INT  ret;
+
+    if(iNum != SYSRGN_W) {
+        dprintf(("WARNING: GetRandomRgn: invalid parameter %x", iNum));
+        SetLastError(ERROR_INVALID_PARAMETER_W);
+        return ERROR_W;
+    }
+    ret = GetClipRgn(hdc, hrgn);
+
+    hwnd = WindowFromDC(hdc);
+    if(hwnd) {
+        POINT pt = {0,0};
+        //map from client to desktop coordinates
+        MapWindowPoints(hwnd, 0, &pt, 1);
+
+        OffsetRgn(hrgn, pt.x, pt.y);
+    }
+    return ret;
+}
+//******************************************************************************
 //******************************************************************************
 int WIN32API ExcludeClipRect(HDC  hdc, int  left, int  top, int  right, int bottom)
@@ -688 +974 @@
     if(!pHps)
     {
-        dprintf(("WARNING: ExcludeClipRgn %x (%d,%d)(%d,%d) invalid hdc", hdc, left, top, right, bottom));
+        dprintf(("ERROR: ExcludeClipRgn %x (%d,%d)(%d,%d) invalid hdc", hdc, left, top, right, bottom));
         SetLastError(ERROR_INVALID_HANDLE_W);
         return ERROR_W;
@@ -712 +998 @@
 
     dprintf(("ExcludeClipRgn %x (%d,%d)(%d,%d)", hdc, left, top, right, bottom));
+
     lComplexity = GpiExcludeClipRectangle(pHps->hps, &rectl);
     if (lComplexity == RGN_ERROR) {
+        dprintf(("ERROR: ExcludeClipRgn: GpiExcludeClipRectangle failed!!"));
         SetLastError(ERROR_INVALID_PARAMETER_W); //TODO: wrong error
         return ERROR_W;
+    }
+
+    //Ok, success. Now update the cached win32 clip region
+    if(pHps->hrgnWin32Clip != NULLHANDLE) 
+    {
+        HRGN hrgnClipRect = GpiCreateRegion(pHps->hps, 1, &rectl);
+        if(hrgnClipRect == NULLHANDLE) {
+            dprintf(("ERROR: ExcludeClipRgn GpiCreateRegion failed!!"));
+            DebugInt3();
+            SetLastError(ERROR_INVALID_PARAMETER_W); //TODO: wrong error
+            return ERROR_W;
+        }
+        //subtract rect region from clip region
+        lComplexity = GpiCombineRegion(pHps->hps, pHps->hrgnWin32Clip, pHps->hrgnWin32Clip, hrgnClipRect, CRGN_DIFF);
+        GpiDestroyRegion(pHps->hps, hrgnClipRect);
+
+        if (lComplexity == RGN_ERROR) {
+            dprintf(("ERROR: ExcludeClipRgn GpiCombineRegion failed!!"));
+            DebugInt3();
+            SetLastError(ERROR_INVALID_PARAMETER_W); //TODO: wrong error
+            return ERROR_W;
+        }
     }
 
@@ -756 +1066 @@
     dprintf(("IntersectClipRect %x (%d,%d)(%d,%d)", hdc, left, top, right, bottom));
     lComplexity = GpiIntersectClipRectangle(pHps->hps, &rectl);
+    if (lComplexity == RGN_ERROR) {
+        dprintf(("ERROR: IntersectClipRect: GpiIntersectClipRectangle failed!!"));
+        SetLastError(ERROR_INVALID_PARAMETER_W); //TODO: wrong error
+        return ERROR_W;
+    }
+
+    //Ok, success. Now update the cached win32 clip region
+    if(pHps->hrgnWin32Clip != NULLHANDLE) 
+    {
+        HRGN hrgnClipRect = GpiCreateRegion(pHps->hps, 1, &rectl);
+        if(hrgnClipRect == NULLHANDLE) {
+            dprintf(("ERROR: IntersectClipRect GpiCreateRegion failed!!"));
+            DebugInt3();
+            SetLastError(ERROR_INVALID_PARAMETER_W); //TODO: wrong error
+            return ERROR_W;
+        }
+        //intersect rect region with clip region
+        lComplexity = GpiCombineRegion(pHps->hps, pHps->hrgnWin32Clip, pHps->hrgnWin32Clip, hrgnClipRect, CRGN_AND);
+        GpiDestroyRegion(pHps->hps, hrgnClipRect);
+
+        if (lComplexity == RGN_ERROR) {
+            dprintf(("ERROR: IntersectClipRect GpiCombineRegion failed!!"));
+            DebugInt3();
+            SetLastError(ERROR_INVALID_PARAMETER_W); //TODO: wrong error
+            return ERROR_W;
+        }
+    }
 
     //todo metafile recording
@@ -784 +1121 @@
 #endif
 
-   lComplexity = GpiOffsetClipRegion(pHps->hps, &pointl);
+   if(pHps->hrgnWin32Clip == NULLHANDLE) {
+       lComplexity = NULLREGION_W;
+   }
+   else {
+       lComplexity = GpiOffsetRegion(pHps->hps, pHps->hrgnWin32Clip, &pointl);
+       if (lComplexity == RGN_ERROR) {
+           dprintf(("ERROR: OffsetClipRgn: GpiOffsetRegion failed!!"));
+           SetLastError(ERROR_INVALID_PARAMETER_W); //TODO: wrong error
+           return ERROR_W;
+       }
+
+       //Intersect the Windows clip region with the current visible region
+       lComplexity = GdiCombineVisRgnClipRgn(pHps, pHps->hrgnWin32Clip, RGN_AND_W);
+
+       lComplexity = GPI_TO_WIN_COMPLEXITY(lComplexity);
+   }
 
    //todo metafile recording
@@ -1038 +1390 @@
     dprintf(("CreateEllipticRgn (%d,%d)(%d,%d)", left, top, right, bottom));
     hrgn = GpiCreateEllipticRegion(hpsRegion, &rectl);
+    if(hrgn == RGN_ERROR) {
+        SetLastError(ERROR_INVALID_PARAMETER_W); //todo: not right
+        dprintf(("WARNING: CreateEllipticRgn: GpiCreateEllipticRegion failed! %x", WinGetLastError(0)));
+        return 0;
+    }
 
     if(ObjAllocateHandle(&hrgn, hrgn, HNDL_REGION) == FALSE) {
@@ -1086 +1443 @@
     polygon.aPointl  = (PPOINTL)(lppt + 1);
 
+#ifdef DEBUG
+    for(int i=0;i<cPoints;i++) {
+        dprintf(("Point %d: (%d,%d)", i, lppt[i].x, lppt[i].y));
+    }
+#endif
     GpiMove(hpsRegion, (PPOINTL)lppt);
     hrgn = GpiCreatePolygonRegion(hpsRegion, 1, &polygon, POLYGON_BOUNDARY | flMode);
+    if(hrgn == RGN_ERROR) {
+        SetLastError(ERROR_INVALID_PARAMETER_W); //todo: not right
+        dprintf(("WARNING: CreatePolygonRgn: GpiCreatePolygonRegion failed! %x", WinGetLastError(0)));
+        return 0;
+    }
 
     if(ObjAllocateHandle(&hrgn, hrgn, HNDL_REGION) == FALSE) {
@@ -1284 +1651 @@
         dprintf(("WARNING: GetRgnBox %x %x invalid region!", hrgn1, pRect));
         SetLastError(ERROR_INVALID_HANDLE_W);
-        return FALSE;
+        return ERROR_W;
     }
 
@@ -1356 +1723 @@
     }
 
+    DIBSECTION_MARK_INVALID(hdc);
     return TRUE;
 }
@@ -1448 +1816 @@
         SelectObject(hdc, hbrushRestore);
 
+    if(lHits != GPI_ERROR) 
+        DIBSECTION_MARK_INVALID(hdc);
+
     //todo metafile recording
     return (lHits != GPI_ERROR);
@@ -1458 +1829 @@
  HBRUSH hbrushRestore = 0;
 #ifdef DEBUG
- HRGN   hrgn1 = hrgn;
+    HRGN   hrgn1 = hrgn;
 #endif
-
 
     pDCData  pHps = (pDCData)OSLibGpiQueryDCData((HPS)hdc);
@@ -1483 +1853 @@
     dprintf(("FillRgn %x %x %x", hdc, hrgn1, hBrush));
 
+    DIBSECTION_CHECK_IF_DIRTY(hdc);
     interpretRegionAs(pHps, NULL, hrgn, AS_WORLD);
 
@@ -1495 +1866 @@
         SelectObject(hdc, hbrushRestore);
 
-    /* PF Sync DIBSection as well */
-    if(DIBSection::getSection() != NULL) 
-    {
-        DIBSection *dsect = DIBSection::findHDC(hdc);
-        if(dsect) 
-        {
-            dsect->sync(hdc, 0, dsect->GetHeight());
-        }
-    }
-
+    if(success)
+        DIBSECTION_MARK_INVALID(hdc);
 
     return(success);
@@ -1512 +1875 @@
 BOOL WIN32API PaintRgn( HDC  hdc, HRGN  hrgn)
 {
-   pDCData  pHps = (pDCData)OSLibGpiQueryDCData((HPS)hdc);
-   if(!pHps)
-   {
-      SetLastError(ERROR_INVALID_HANDLE_W);
-      return FALSE;
-   }
-
-   return FillRgn(hdc, hrgn, (HBRUSH) pHps->lastBrushKey);
+   return FillRgn(hdc, hrgn, (HBRUSH) GetCurrentObject(hdc, OBJ_BRUSH_W));
 }
 //******************************************************************************