diff --git a/win32ss/gdi/ntgdi/cliprgn.c b/win32ss/gdi/ntgdi/cliprgn.c
index 2f4f53c525..d5a744e201 100644
--- a/win32ss/gdi/ntgdi/cliprgn.c
+++ b/win32ss/gdi/ntgdi/cliprgn.c
@@ -18,25 +18,41 @@ IntGdiReleaseRaoRgn(PDC pDC)
     INT Index = GDI_HANDLE_GET_INDEX(pDC->BaseObject.hHmgr);
     PGDI_TABLE_ENTRY Entry = &GdiHandleTable->Entries[Index];
     pDC->fs |= DC_FLAG_DIRTY_RAO;
-    Entry->Flags |= GDI_ENTRY_VALIDATE_VIS;
+    Entry->Flags |= GDI_ENTRY_VALIDATE_VIS; // Need to validate Vis.
     RECTL_vSetEmptyRect(&pDC->erclClip);
-    REGION_Delete(pDC->prgnRao);
-    pDC->prgnRao = NULL;
 }
 
 VOID
 FASTCALL
 IntGdiReleaseVisRgn(PDC pDC)
 {
-    INT Index = GDI_HANDLE_GET_INDEX(pDC->BaseObject.hHmgr);
-    PGDI_TABLE_ENTRY Entry = &GdiHandleTable->Entries[Index];
-    pDC->fs |= DC_FLAG_DIRTY_RAO;
-    Entry->Flags |= GDI_ENTRY_VALIDATE_VIS;
-    RECTL_vSetEmptyRect(&pDC->erclClip);
+    IntGdiReleaseRaoRgn(pDC);
     REGION_Delete(pDC->prgnVis);
-    pDC->prgnVis = prgnDefault;
+    pDC->prgnVis = prgnDefault; // Vis can not be NULL!!!
+}
+
+//
+// Updating Vis Region Attribute the for DC Attributes.
+// This system region has an user attribute for it.
+//
+VOID
+FASTCALL
+UpdateVisRgn(
+    PDC pdc)
+{
+    INT Index = GDI_HANDLE_GET_INDEX(pdc->BaseObject.hHmgr);
+    PGDI_TABLE_ENTRY pEntry = &GdiHandleTable->Entries[Index];
+
+    /* Setup Vis Region Attribute information to User side */
+    pEntry->Flags |= GDI_ENTRY_VALIDATE_VIS;
+    pdc->pdcattr->VisRectRegion.iComplexity = REGION_GetRgnBox(pdc->prgnVis, &pdc->pdcattr->VisRectRegion.Rect);
+    pdc->pdcattr->VisRectRegion.AttrFlags = ATTR_RGN_VALID;
+    pEntry->Flags &= ~GDI_ENTRY_VALIDATE_VIS;
 }
 
+//
+//  Selecting Vis Region.
+//
 VOID
 FASTCALL
 GdiSelectVisRgn(
@@ -51,61 +67,233 @@ GdiSelectVisRgn(
         return;
     }
 
+    if (!prgn)
+    {
+       DPRINT1("SVR: Setting NULL Region\n");
+       IntGdiReleaseVisRgn(dc);
+       IntSetDefaultRegion(dc);
+       DC_UnlockDc(dc);
+       return;
+    }
+
     dc->fs |= DC_FLAG_DIRTY_RAO;
 
     ASSERT(dc->prgnVis != NULL);
     ASSERT(prgn != NULL);
 
-    IntGdiCombineRgn(dc->prgnVis, prgn, NULL, RGN_COPY);
+    REGION_bCopy(dc->prgnVis, prgn);
     REGION_bOffsetRgn(dc->prgnVis, -dc->ptlDCOrig.x, -dc->ptlDCOrig.y);
 
     DC_UnlockDc(dc);
 }
 
-
+_Success_(return!=ERROR)
 int
 FASTCALL
-IntGdiExtSelectClipRgn(
-    PDC dc,
-    PREGION prgn,
-    int fnMode)
+IntSelectClipRgn(
+    _In_ PDC dc,
+    _In_ PREGION prgn,
+    _In_ int fnMode)
 {
-    if (fnMode == RGN_COPY)
+    int Ret = ERROR;
+    PREGION prgnNClip, prgnOrigClip = dc->dclevel.prgnClip;
+
+    //
+    // No Coping Regions and no intersecting Regions or an User calling w NULL Region or have the Original Clip Region.
+    //
+    if (fnMode != RGN_COPY && (fnMode != RGN_AND || !prgn || prgnOrigClip))
     {
-        if (!prgn)
+        prgnNClip = IntSysCreateRectpRgn(0, 0, 0, 0);
+
+        // Have Original Clip Region.
+        if (prgnOrigClip)
         {
-            if (dc->dclevel.prgnClip != NULL)
+           // This will fail on NULL prgn.
+           Ret = IntGdiCombineRgn(prgnNClip, prgnOrigClip, prgn, fnMode);
+
+           if (Ret)
+           {
+              REGION_Delete(prgnOrigClip);
+              dc->dclevel.prgnClip = prgnNClip;
+              IntGdiReleaseRaoRgn(dc);
+           }
+           else
+              REGION_Delete(prgnNClip);
+        }
+        else // NULL Original Clip Region, setup a new one and process mode.
+        {
+            PREGION prgnClip;
+            RECTL rcl;
+            PSURFACE pSurface;
+
+            // See IntSetDefaultRegion.
+
+            rcl.left   = 0;
+            rcl.top    = 0;
+            rcl.right  = dc->dclevel.sizl.cx;
+            rcl.bottom = dc->dclevel.sizl.cy;
+
+            //EngAcquireSemaphoreShared(pdc->ppdev->hsemDevLock);
+            if (dc->ppdev->flFlags & PDEV_META_DEVICE)
+            {
+                pSurface = dc->dclevel.pSurface;
+                if (pSurface && pSurface->flags & PDEV_SURFACE)
+                {
+                   rcl.left   += dc->ppdev->ptlOrigion.x;
+                   rcl.top    += dc->ppdev->ptlOrigion.y;
+                   rcl.right  += dc->ppdev->ptlOrigion.x;
+                   rcl.bottom += dc->ppdev->ptlOrigion.y;
+                }
+            }
+            //EngReleaseSemaphore(pdc->ppdev->hsemDevLock);
+
+            rcl.left   += dc->ptlDCOrig.x;
+            rcl.top    += dc->ptlDCOrig.y;
+            rcl.right  += dc->ptlDCOrig.x;
+            rcl.bottom += dc->ptlDCOrig.y;
+
+            prgnClip = IntSysCreateRectpRgnIndirect(&rcl);
+
+            Ret = IntGdiCombineRgn(prgnNClip, prgnClip, prgn, fnMode);
+
+            if (Ret)
             {
-                REGION_Delete(dc->dclevel.prgnClip);
-                dc->dclevel.prgnClip = NULL;
-                dc->fs |= DC_FLAG_DIRTY_RAO;
+                dc->dclevel.prgnClip = prgnNClip;
+                IntGdiReleaseRaoRgn(dc);
             }
-            return SIMPLEREGION;
+            else
+                REGION_Delete(prgnNClip);
+
+            REGION_Delete(prgnClip);
         }
+        return Ret;
+    }
 
-        if (!dc->dclevel.prgnClip)
-            dc->dclevel.prgnClip = IntSysCreateRectpRgn(0, 0, 0, 0);
+    // Fall through to normal RectOS mode.
 
-        dc->fs |= DC_FLAG_DIRTY_RAO;
+    //
+    // Handle NULL Region and Original Clip Region.
+    //
+    if (!prgn)
+    {
+        if (prgnOrigClip)
+        {
+            REGION_Delete(dc->dclevel.prgnClip);
+            dc->dclevel.prgnClip = NULL;
+            IntGdiReleaseRaoRgn(dc);
+        }
+        return SIMPLEREGION;
+    }
 
-        return IntGdiCombineRgn(dc->dclevel.prgnClip, prgn, NULL, RGN_COPY);
+    //
+    // Combine the new Clip region with original Clip and caller Region.
+    //
+    if ( prgnOrigClip &&
+        (Ret = IntGdiCombineRgn(prgnOrigClip, prgn, NULL, RGN_COPY)) ) // Clip could fail.
+    {
+        IntGdiReleaseRaoRgn(dc);
     }
+    else // NULL original Clip, just copy caller region to new.
+    {
+       prgnNClip = IntSysCreateRectpRgn(0, 0, 0, 0);
+       REGION_bCopy(prgnNClip, prgn);
+       Ret = REGION_Complexity(prgnNClip);
+       dc->dclevel.prgnClip = prgnNClip;
+       IntGdiReleaseRaoRgn(dc);
+    }
+    return Ret;
+}
 
-    ASSERT(prgn != NULL);
+//
+// Call from Gdi Batch Subsystem.
+//
+// Was setup to just handle RGN_COPY only and return VOID, since this was called from Gdi32.
+// Tested in place of the other, complexity aside.
+//
 
-    if (!dc->dclevel.prgnClip)
+_Success_(return!=ERROR)
+int
+FASTCALL
+IntGdiExtSelectClipRect(
+    _In_ PDC dc,
+    _In_ PRECTL prcl,
+    _In_ int fnMode)
+{
+    int Ret = ERROR;
+    PREGION prgn;
+    RECTL rect;
+    BOOL NoRegion = fnMode & GDIBS_NORECT;
+
+    fnMode &= ~GDIBS_NORECT;
+
+    if (NoRegion) // NULL Region.
     {
-        RECTL rect;
+        if (fnMode == RGN_COPY)
+        {
+           Ret = IntSelectClipRgn( dc, NULL, RGN_COPY);
 
-        REGION_GetRgnBox(dc->prgnVis, &rect);
-        dc->dclevel.prgnClip = IntSysCreateRectpRgnIndirect(&rect);
+           if (dc->fs & DC_FLAG_DIRTY_RAO)
+               CLIPPING_UpdateGCRegion(dc);
+
+           if (Ret) // Copy? Return Vis complexity.
+               Ret = REGION_Complexity(dc->prgnVis);
+        }
     }
+    else // Have a box to build a region with.
+    {
+        if (dc->dclevel.prgnClip)
+        {
+            REGION_GetRgnBox(dc->dclevel.prgnClip, &rect);
 
-    dc->fs |= DC_FLAG_DIRTY_RAO;
+            if (prcl->left   == rect.left  &&
+                prcl->top    == rect.top   &&
+                prcl->right  == rect.right &&
+                prcl->bottom == rect.bottom)
+            {
+                return REGION_Complexity( dc->prgnRao ? dc->prgnRao : dc->prgnVis );
+            }
+        }
+
+        prgn = IntSysCreateRectpRgnIndirect(prcl);
 
-    return IntGdiCombineRgn(dc->dclevel.prgnClip, dc->dclevel.prgnClip, prgn, fnMode);
+        Ret = IntSelectClipRgn( dc, prgn, fnMode);
+
+        if (dc->fs & DC_FLAG_DIRTY_RAO)
+            CLIPPING_UpdateGCRegion(dc);
+
+        if (Ret)
+            Ret = REGION_Complexity( dc->prgnRao ? dc->prgnRao : dc->prgnVis );
+
+        REGION_Delete(prgn);
+    }
+    return Ret;
 }
 
+_Success_(return!=ERROR)
+int
+FASTCALL
+IntGdiExtSelectClipRgn(
+    _In_ PDC dc,
+    _In_ PREGION prgn,
+    _In_ int fnMode)
+{
+    int Ret = ERROR;
+
+    if (!prgn)
+    {
+        if (fnMode == RGN_COPY)
+        {
+           if ((Ret = IntSelectClipRgn( dc, NULL, RGN_COPY)))
+               Ret = REGION_Complexity(dc->prgnVis);
+        }
+    }
+    else
+    {
+        if ((Ret = IntSelectClipRgn( dc, prgn, fnMode)))
+            Ret = REGION_Complexity( dc->prgnRao ? dc->prgnRao : dc->prgnVis );
+    }
+    return Ret;
+}
 
 int
 APIENTRY
@@ -367,6 +555,7 @@ NtGdiOffsetClipRgn(
     pdc = DC_LockDc(hdc);
     if (pdc == NULL)
     {
+        if (!hdc) EngSetLastError(ERROR_INVALID_HANDLE);
         return ERROR;
     }
 
@@ -390,6 +579,8 @@ NtGdiOffsetClipRgn(
         }
         else
         {
+            IntGdiReleaseRaoRgn(pdc);
+            UpdateVisRgn(pdc);
             iComplexity = REGION_Complexity(pdc->dclevel.prgnClip);
         }
 
@@ -413,6 +604,7 @@ BOOL APIENTRY NtGdiPtVisible(HDC  hDC,
 {
     BOOL ret = FALSE;
     PDC dc;
+    PREGION prgn;
 
     if(!(dc = DC_LockDc(hDC)))
     {
@@ -420,11 +612,13 @@ BOOL APIENTRY NtGdiPtVisible(HDC  hDC,
         return FALSE;
     }
 
-    if (dc->prgnRao)
+    prgn = dc->prgnRao ? dc->prgnRao : dc->prgnVis;
+
+    if (prgn)
     {
         POINT pt = {X, Y};
         IntLPtoDP(dc, &pt, 1);
-        ret = REGION_PtInRegion(dc->prgnRao, pt.x, pt.y);
+        ret = REGION_PtInRegion(prgn, pt.x, pt.y);
     }
 
     DC_UnlockDc(dc);
@@ -442,6 +636,7 @@ NtGdiRectVisible(
     PDC dc = DC_LockDc(hDC);
     BOOL Result = FALSE;
     RECTL Rect;
+    PREGION prgn;
 
     if (!dc)
     {
@@ -472,10 +667,11 @@ NtGdiRectVisible(
     if (dc->fs & DC_FLAG_DIRTY_RAO)
         CLIPPING_UpdateGCRegion(dc);
 
-    if (dc->prgnRao)
+    prgn = dc->prgnRao ? dc->prgnRao : dc->prgnVis;
+    if (prgn)
     {
          IntLPtoDP(dc, (LPPOINT)&Rect, 2);
-         Result = REGION_RectInRegion(dc->prgnRao, &Rect);
+         Result = REGION_RectInRegion(prgn, &Rect);
     }
     DC_UnlockDc(dc);
 
@@ -492,13 +688,23 @@ IntGdiSetMetaRgn(PDC pDC)
     {
         if ( pDC->dclevel.prgnClip )
         {
-            // preferably REGION_IntersectRegion
-            Ret = IntGdiCombineRgn(pDC->dclevel.prgnMeta, pDC->dclevel.prgnMeta, pDC->dclevel.prgnClip, RGN_AND);
-            if (Ret != ERROR)
+            PREGION prgn = IntSysCreateRectpRgn(0,0,0,0);
+            if ( prgn )
             {
-                REGION_Delete(pDC->dclevel.prgnClip);
-                pDC->dclevel.prgnClip = NULL;
-                IntGdiReleaseRaoRgn(pDC);
+                if (REGION_bIntersectRegion(prgn, pDC->dclevel.prgnMeta, pDC->dclevel.prgnClip))
+                {
+                    // See Restore/SaveDC
+                    REGION_Delete(pDC->dclevel.prgnMeta);
+                    pDC->dclevel.prgnMeta = prgn;
+
+                    REGION_Delete(pDC->dclevel.prgnClip);
+                    pDC->dclevel.prgnClip = NULL;
+                    IntGdiReleaseRaoRgn(pDC);
+
+                    Ret = REGION_Complexity(pDC->dclevel.prgnMeta);
+                }
+                else
+                    REGION_Delete(prgn);
             }
         }
         else
@@ -516,9 +722,6 @@ IntGdiSetMetaRgn(PDC pDC)
             Ret = SIMPLEREGION;
     }
 
-    if (Ret != ERROR)
-        pDC->fs |= DC_FLAG_DIRTY_RAO;
-
     return Ret;
 }
 
@@ -545,7 +748,33 @@ CLIPPING_UpdateGCRegion(PDC pDC)
 {
     /* Must have VisRgn set to a valid state! */
     ASSERT (pDC->prgnVis);
+#if 0 // This works with limitations. ReactOS relies on Rao.
+    if ( !pDC->dclevel.prgnClip &&
+         !pDC->dclevel.prgnMeta &&
+         !pDC->prgnAPI)
+    {
+        if (pDC->prgnRao)
+            REGION_Delete(pDC->prgnRao);
+        pDC->prgnRao = NULL;
+
+        REGION_bOffsetRgn(pDC->prgnVis, pDC->ptlDCOrig.x, pDC->ptlDCOrig.y);
 
+        RtlCopyMemory(&pDC->erclClip,
+                      &pDC->prgnVis->rdh.rcBound,
+                       sizeof(RECTL));
+
+        IntEngUpdateClipRegion(&pDC->co,
+                                pDC->prgnVis->rdh.nCount,
+                                pDC->prgnVis->Buffer,
+                               &pDC->erclClip);
+
+        REGION_bOffsetRgn(pDC->prgnVis, -pDC->ptlDCOrig.x, -pDC->ptlDCOrig.y);
+
+        pDC->fs &= ~DC_FLAG_DIRTY_RAO;
+        UpdateVisRgn(pDC);
+        return;
+    }
+#endif
     if (pDC->prgnAPI)
     {
         REGION_Delete(pDC->prgnAPI);
@@ -564,50 +793,43 @@ CLIPPING_UpdateGCRegion(PDC pDC)
         pDC->prgnAPI = IntSysCreateRectpRgn(0,0,0,0);
         if (!pDC->dclevel.prgnMeta)
         {
-            IntGdiCombineRgn(pDC->prgnAPI,
-                             pDC->dclevel.prgnClip,
-                             NULL,
-                             RGN_COPY);
+            REGION_bCopy(pDC->prgnAPI,
+                         pDC->dclevel.prgnClip);
         }
         else if (!pDC->dclevel.prgnClip)
         {
-            IntGdiCombineRgn(pDC->prgnAPI,
-                             pDC->dclevel.prgnMeta,
-                             NULL,
-                             RGN_COPY);
+            REGION_bCopy(pDC->prgnAPI,
+                         pDC->dclevel.prgnMeta);
         }
         else
         {
-            IntGdiCombineRgn(pDC->prgnAPI,
-                             pDC->dclevel.prgnClip,
-                             pDC->dclevel.prgnMeta,
-                             RGN_AND);
+            REGION_bIntersectRegion(pDC->prgnAPI,
+                                    pDC->dclevel.prgnClip,
+                                    pDC->dclevel.prgnMeta);
         }
     }
 
     if (pDC->prgnAPI)
     {
-        IntGdiCombineRgn(pDC->prgnRao,
-                         pDC->prgnVis,
-                         pDC->prgnAPI,
-                         RGN_AND);
+        REGION_bIntersectRegion(pDC->prgnRao,
+                                pDC->prgnVis,
+                                pDC->prgnAPI);
     }
     else
     {
-        IntGdiCombineRgn(pDC->prgnRao,
-                         pDC->prgnVis,
-                         NULL,
-                         RGN_COPY);
+        REGION_bCopy(pDC->prgnRao,
+                     pDC->prgnVis);
     }
 
 
     REGION_bOffsetRgn(pDC->prgnRao, pDC->ptlDCOrig.x, pDC->ptlDCOrig.y);
 
     RtlCopyMemory(&pDC->erclClip,
-                &pDC->prgnRao->rdh.rcBound,
-                sizeof(RECTL));
+                  &pDC->prgnRao->rdh.rcBound,
+                  sizeof(RECTL));
 
     pDC->fs &= ~DC_FLAG_DIRTY_RAO;
+    UpdateVisRgn(pDC);
 
     // pDC->co should be used. Example, CLIPOBJ_cEnumStart uses XCLIPOBJ to build
     // the rects from region objects rects in pClipRgn->Buffer.
diff --git a/win32ss/gdi/ntgdi/cliprgn.h b/win32ss/gdi/ntgdi/cliprgn.h
index af7933b901..0568eea1af 100644
--- a/win32ss/gdi/ntgdi/cliprgn.h
+++ b/win32ss/gdi/ntgdi/cliprgn.h
@@ -12,3 +12,6 @@ INT FASTCALL IntGdiExtSelectClipRgn (PDC dc, PREGION prgn, int fnMode);
 VOID FASTCALL CLIPPING_UpdateGCRegion(DC* Dc);
 VOID FASTCALL IntGdiReleaseRaoRgn(PDC);
 VOID FASTCALL IntGdiReleaseVisRgn(PDC);
+VOID FASTCALL UpdateVisRgn(PDC);
+BOOL FASTCALL REGION_bCopy(PREGION,PREGION);
+BOOL FASTCALL REGION_bIntersectRegion(PREGION,PREGION,PREGION);
diff --git a/win32ss/gdi/ntgdi/dclife.c b/win32ss/gdi/ntgdi/dclife.c
index d27481c03f..691dc2cd0d 100644
--- a/win32ss/gdi/ntgdi/dclife.c
+++ b/win32ss/gdi/ntgdi/dclife.c
@@ -112,6 +112,11 @@ DC_InitHack(PDC pdc)
         DC_vCopyState(pdc, defaultDCstate, TRUE);
     }
 
+    if (prgnDefault == NULL)
+    {
+        prgnDefault = IntSysCreateRectpRgn(0, 0, 0, 0);
+    }
+
     TextIntRealizeFont(pdc->pdcattr->hlfntNew,NULL);
     pdc->pdcattr->iCS_CP = ftGdiGetTextCharsetInfo(pdc,NULL,0);
 
@@ -247,6 +252,9 @@ DC_vInitDc(
     pdc->prgnVis = IntSysCreateRectpRgn(0, 0, pdc->dclevel.sizl.cx, pdc->dclevel.sizl.cy);
 	ASSERT(pdc->prgnVis);
 
+    /* Setup Vis Region Attribute information */
+    UpdateVisRgn(pdc);
+
 	/* Initialize Clip object */
 	IntEngInitClipObj(&pdc->co);
 
@@ -939,7 +947,7 @@ APIENTRY
 NtGdiDeleteObjectApp(HANDLE hobj)
 {
     /* Complete all pending operations */
-    NtGdiFlushUserBatch(); // FIXME: We shouldn't need this
+    //NtGdiFlushUserBatch(); // FIXME: We shouldn't need this
 
     if (GDI_HANDLE_IS_STOCKOBJ(hobj)) return TRUE;
 
diff --git a/win32ss/gdi/ntgdi/dcstate.c b/win32ss/gdi/ntgdi/dcstate.c
index 8902d9572c..ccf7c134e7 100644
--- a/win32ss/gdi/ntgdi/dcstate.c
+++ b/win32ss/gdi/ntgdi/dcstate.c
@@ -57,6 +57,7 @@ DC_vCopyState(PDC pdcSrc, PDC pdcDst, BOOL To)
             REGION_Delete(pdcDst->dclevel.prgnMeta);
             pdcDst->dclevel.prgnMeta = NULL;
         }
+        /* The only way to reset the Meta Region to its original state is to return to a previously saved version of the DC with SaveDC. */
         if (pdcSrc->dclevel.prgnMeta)
         {
             pdcDst->dclevel.prgnMeta = IntSysCreateRectpRgn(0, 0, 0, 0);
diff --git a/win32ss/gdi/ntgdi/dcutil.c b/win32ss/gdi/ntgdi/dcutil.c
index aa130f02d7..0ac907f019 100644
--- a/win32ss/gdi/ntgdi/dcutil.c
+++ b/win32ss/gdi/ntgdi/dcutil.c
@@ -401,11 +401,10 @@ IntSetDefaultRegion(PDC pdc)
         pdc->erclWindow = rclWnd;
         pdc->erclClip = rclClip;
         /* Might be an InitDC or DCE... */
-        pdc->ptlFillOrigin.x = pdc->dcattr.ptlBrushOrigin.x;
-        pdc->ptlFillOrigin.y = pdc->dcattr.ptlBrushOrigin.y;
+        pdc->ptlFillOrigin = pdc->dcattr.ptlBrushOrigin;
         return TRUE;
     }
-
+    // No Vis use the Default System Region.
     pdc->prgnVis = prgnDefault;
     return FALSE;
 }
diff --git a/win32ss/gdi/ntgdi/fillshap.c b/win32ss/gdi/ntgdi/fillshap.c
index a42a341423..c18ff0093c 100644
--- a/win32ss/gdi/ntgdi/fillshap.c
+++ b/win32ss/gdi/ntgdi/fillshap.c
@@ -1081,6 +1081,7 @@ NtGdiExtFloodFill(
     RECTL      DestRect;
     POINTL     Pt;
     ULONG      ConvColor;
+    PREGION    prgn;
 
     dc = DC_LockDc(hDC);
     if (!dc)
@@ -1105,13 +1106,14 @@ NtGdiExtFloodFill(
 
     DC_vPrepareDCsForBlit(dc, &DestRect, NULL, NULL);
 
-    /// FIXME: what about prgnVIS? And what about REAL clipping?
     psurf = dc->dclevel.pSurface;
-    if (dc->prgnRao)
+
+    prgn = dc->prgnRao ? dc->prgnRao : dc->prgnVis;
+    if (prgn)
     {
-        Ret = REGION_PtInRegion(dc->prgnRao, Pt.x, Pt.y);
+        Ret = REGION_PtInRegion(prgn, Pt.x, Pt.y);
         if (Ret)
-            REGION_GetRgnBox(dc->prgnRao, (LPRECT)&DestRect);
+            REGION_GetRgnBox(prgn, (LPRECT)&DestRect);
         else
         {
             DC_vFinishBlit(dc, NULL);
diff --git a/win32ss/gdi/ntgdi/line.c b/win32ss/gdi/ntgdi/line.c
index 5e53b0b24b..3b6eaecd66 100644
--- a/win32ss/gdi/ntgdi/line.c
+++ b/win32ss/gdi/ntgdi/line.c
@@ -63,14 +63,12 @@ AddPenLinesBounds(PDC dc, int count, POINT *points)
     DPRINT("                 r %d b %d\n",rect.right,rect.bottom);
 
     {
-       RECTL rcRgn;
-       if (dc->fs & DC_FLAG_DIRTY_RAO) CLIPPING_UpdateGCRegion(dc);
-       if (REGION_GetRgnBox(dc->prgnRao, &rcRgn))
-       {
-          if (RECTL_bIntersectRect( &rcRgn, &rcRgn, &bounds )) IntUpdateBoundsRect(dc, &rcRgn);
-       }
+       RECTL rcRgn = dc->erclClip;
+
+       if (RECTL_bIntersectRect( &rcRgn, &rcRgn, &bounds ))
+           IntUpdateBoundsRect(dc, &rcRgn);
        else
-          IntUpdateBoundsRect(dc, &bounds);
+           IntUpdateBoundsRect(dc, &bounds);
     }
 }
 
