Sync with trunk 48067
authorJérôme Gardou <jerome.gardou@reactos.org>
Thu, 15 Jul 2010 20:49:51 +0000 (20:49 +0000)
committerJérôme Gardou <jerome.gardou@reactos.org>
Thu, 15 Jul 2010 20:49:51 +0000 (20:49 +0000)
svn path=/branches/reactos-yarotows/; revision=48068

24 files changed:
1  2 
base/applications/network/ping/ping.c
base/applications/regedit/childwnd.c
base/applications/regedit/hexedit.c
config.template.rbuild
dll/3rdparty/libtiff/libtiff.rbuild
dll/3rdparty/libtiff/rosdiff.patch
dll/3rdparty/libtiff/tif_open.c
dll/win32/setupapi/setupcab.c
dll/win32/user32/windows/cursoricon.c
include/psdk/shellapi.h
include/psdk/wingdi.h
include/psdk/ws2ipdef.h
include/psdk/ws2tcpip.h
include/reactos/libs/libtiff/rosdiff.patch
include/reactos/libs/libtiff/tiffio.h
ntoskrnl/ex/rundown.c
ntoskrnl/include/internal/amd64/ke.h
ntoskrnl/include/internal/mm.h
ntoskrnl/include/ntoskrnl.h
ntoskrnl/io/iomgr/adapter.c
ntoskrnl/kd64/kddata.c
ntoskrnl/ke/clock.c
ntoskrnl/mm/ARM3/miarm.h
subsystems/win32/win32k/objects/cliprgn.c

Simple merge
Simple merge
Simple merge
index d8a1304,0000000..077038b
mode 100644,000000..100644
--- /dev/null
@@@ -1,102 -1,0 +1,102 @@@
- <property name="OPTIMIZE" value="1" />
 +<?xml version="1.0"?>
 +<!DOCTYPE group SYSTEM "tools/rbuild/project.dtd">
 +<group>
 +
 +<!--
 +      This file is a template used as a starting point for compile-time
 +      configuration of ReactOS. Make a copy of this file and name it config.rbuild.
 +      Then change the options in config.rbuild. If you don't have a config.rbuild file,
 +      then the defaults in this file, config.template.rbuild, will be used instead.
 +
 +      Boolean options can obtain the values 0 (disabled) or 1 (enabled). String
 +      options can obtain any value specified in the comment before it.
 +-->
 +
 +
 +<!--
 +      Sub-architecture to build for. Specify one of:
 +              xbox
 +-->
 +<property name="SARCH" value="" />
 +
 +
 +<!--
 +      Generate instructions for this CPU type. Specify one of:
 +              native, i386, i486, pentium, pentium-mmx, pentiumpro, i686,
 +              pentium2, pentium3, pentium-m, pentium4, prescott, nocona,
 +              core2, k6, k6-2, athlon, athlon-xp, opteron, opteron-sse3,
 +              barcelona, winchip-c6, winchip2, c3, c3-2, geode
 +
 +      See GCC manual for more CPU names.
 +-->
 +<property name="OARCH" value="pentium" />
 +
 +
 +<!--
 +      Which CPU ReactOS should be optimized for. Specify one of the above
 +      CPUs or generic. When this option is not used, GCC will optimize for
 +      the processor specified by OARCH.
 +-->
 +<property name="TUNE" value="i686" />
 +
 +
 +<!--
 +      What level of optimisation to use.
 +              0 = off
 +              1 = Default option, optimize for size (-Os) with some additional options
 +              2 = -Os
 +              3 = -O1
 +              4 = -O2
 +              5 = -O3
 +-->
++<property name="OPTIMIZE" value="0" />
 +
 +
 +<!--
 +      Whether to compile in the integrated kernel debugger.
 +-->
 +<property name="KDBG" value="1" />
 +
 +
 +<!--
 +      Whether to compile for debugging.
 +-->
 +<property name="DBG" value="1" />
 +
 +
 +<!--
 +      Whether to compile for debugging with GDB. If you don't use GDB, don't
 +      enable this.
 +-->
 +<property name="GDB" value="0" />
 +
 +
 +<!--
 +      Whether to compile apps/libs with features covered software patents or not.
 +      If you live in a country where software patents are valid/apply, don't
 +      enable this (except they/you purchased a license from the patent owner).
 +      This settings is disabled (0) by default.
 +-->
 +<property name="NSWPAT" value="0" />
 +
 +<!--
 +      Whether to compile with the KD protocol. This will disable support for KDBG
 +      as well as rossym and symbol lookups, and allow WinDBG to connect to ReactOS.
 +      This is currently not fully working, and requires kdcom from Windows 2003 or
 +      TinyKRNL. Booting into debug mode with this flag enabled will result in a
 +      failure to enter GUI mode. Do not enable unless you know what you're doing.
 +-->
 +<property name="_WINKD_" value="0" />
 +
 +<!--
 +      Whether to compile support for ELF files. Do not enable unless you know what
 +      you're doing.
 +-->
 +<property name="_ELF_" value="0" />
 +
 +<!--
 +      Whether to compile the multi processor versions for ntoskrnl and hal.
 +-->
 +<property name="BUILD_MP" value="1" />
 +
 +</group>
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index 42f22e4,0000000..1f8fe79
mode 100644,000000..100644
--- /dev/null
@@@ -1,619 -1,0 +1,619 @@@
-    HRGN hRgnVis = NULL;
 +/*
 + *  ReactOS W32 Subsystem
 + *  Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
 + *
 + *  This program is free software; you can redistribute it and/or modify
 + *  it under the terms of the GNU General Public License as published by
 + *  the Free Software Foundation; either version 2 of the License, or
 + *  (at your option) any later version.
 + *
 + *  This program is distributed in the hope that it will be useful,
 + *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 + *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 + *  GNU General Public License for more details.
 + *
 + *  You should have received a copy of the GNU General Public License along
 + *  with this program; if not, write to the Free Software Foundation, Inc.,
 + *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 + */
 +
 +#include <win32k.h>
 +
 +#define NDEBUG
 +#include <debug.h>
 +
 +int FASTCALL
 +CLIPPING_UpdateGCRegion(DC* Dc)
 +{
 +   PROSRGNDATA CombinedRegion;
-       NtGdiCombineRgn(Dc->rosdc.hGCClipRgn, ((PROSRGNDATA)Dc->prgnVis)->BaseObject.hHmgr, 0, RGN_COPY);
++   HRGN hRgnVis = Dc->prgnVis->BaseObject.hHmgr;
 +
 +    // would prefer this, but the rest of the code sucks
 +//    ASSERT(Dc->rosdc.hGCClipRgn);
 +//    ASSERT(Dc->rosdc.hClipRgn);
 +   if (!Dc->prgnVis)
 +   {
 +      DPRINT1("Warning, prgnVis is NULL!\n");
 +   }
 +   else
 +   {
 +       hRgnVis = Dc->prgnVis->BaseObject.hHmgr ;
 +   }
 +
 +
 +   if (Dc->rosdc.hGCClipRgn == NULL)
 +      Dc->rosdc.hGCClipRgn = IntSysCreateRectRgn(0, 0, 0, 0);
 +
 +   if (Dc->rosdc.hClipRgn == NULL)
++      NtGdiCombineRgn(Dc->rosdc.hGCClipRgn, hRgnVis, 0, RGN_COPY);
 +   else
 +      NtGdiCombineRgn(Dc->rosdc.hGCClipRgn, Dc->rosdc.hClipRgn, hRgnVis, RGN_AND);
 +
 +   NtGdiOffsetRgn(Dc->rosdc.hGCClipRgn, Dc->ptlDCOrig.x, Dc->ptlDCOrig.y);
 +
 +   if((CombinedRegion = RGNOBJAPI_Lock(Dc->rosdc.hGCClipRgn, NULL)))
 +   {
 +     CLIPOBJ *CombinedClip;
 +
 +     CombinedClip = IntEngCreateClipRegion(CombinedRegion->rdh.nCount,
 +        CombinedRegion->Buffer,
 +        &CombinedRegion->rdh.rcBound);
 +
 +     RGNOBJAPI_Unlock(CombinedRegion);
 +
 +     if ( !CombinedClip )
 +     {
 +       DPRINT1("IntEngCreateClipRegion() failed\n");
 +       return ERROR;
 +     }
 +
 +     if(Dc->rosdc.CombinedClip != NULL)
 +       IntEngDeleteClipRegion(Dc->rosdc.CombinedClip);
 +
 +      Dc->rosdc.CombinedClip = CombinedClip ;
 +   }
 +
 +   return NtGdiOffsetRgn(Dc->rosdc.hGCClipRgn, -Dc->ptlDCOrig.x, -Dc->ptlDCOrig.y);
 +}
 +
 +INT FASTCALL
 +GdiSelectVisRgn(HDC hdc, HRGN hrgn)
 +{
 +  int retval;
 +  DC *dc;
 +
 +  if (!hrgn)
 +  {
 +      SetLastWin32Error(ERROR_INVALID_PARAMETER);
 +      return ERROR;
 +  }
 +  if (!(dc = DC_LockDc(hdc)))
 +  {
 +      SetLastWin32Error(ERROR_INVALID_HANDLE);
 +      return ERROR;
 +  }
 +
 +  dc->fs &= ~DC_FLAG_DIRTY_RAO;
 +
 +  if (dc->prgnVis == NULL)
 +  {
 +    dc->prgnVis = IntSysCreateRectpRgn(0, 0, 0, 0);
 +    GDIOBJ_CopyOwnership(hdc, ((PROSRGNDATA)dc->prgnVis)->BaseObject.hHmgr);
 +  }
 +
 +  retval = NtGdiCombineRgn(((PROSRGNDATA)dc->prgnVis)->BaseObject.hHmgr, hrgn, 0, RGN_COPY);
 +  if ( retval != ERROR )
 +  {
 +    NtGdiOffsetRgn(((PROSRGNDATA)dc->prgnVis)->BaseObject.hHmgr, -dc->ptlDCOrig.x, -dc->ptlDCOrig.y);
 +    CLIPPING_UpdateGCRegion(dc);
 +  }
 +  DC_UnlockDc(dc);
 +
 +  return retval;
 +}
 +
 +
 +int FASTCALL GdiExtSelectClipRgn(PDC dc,
 +                                 HRGN hrgn,
 +                                 int fnMode)
 +{
 +  //  dc->fs &= ~DC_FLAG_DIRTY_RAO;
 +
 +  if (!hrgn)
 +  {
 +    if (fnMode == RGN_COPY)
 +    {
 +      if (dc->rosdc.hClipRgn != NULL)
 +      {
 +        REGION_FreeRgnByHandle(dc->rosdc.hClipRgn);
 +        dc->rosdc.hClipRgn = NULL;
 +      }
 +    }
 +    else
 +    {
 +      SetLastWin32Error(ERROR_INVALID_PARAMETER);
 +      return ERROR;
 +    }
 +  }
 +  else
 +  {
 +    if (!dc->rosdc.hClipRgn)
 +    {
 +      RECTL rect;
 +      if(dc->prgnVis)
 +      {
 +              REGION_GetRgnBox(dc->prgnVis, &rect);
 +        dc->rosdc.hClipRgn = IntSysCreateRectRgnIndirect(&rect);
 +      }
 +      else
 +      {
 +        dc->rosdc.hClipRgn = IntSysCreateRectRgn(0, 0, 0, 0);
 +      }
 +    }
 +    if(fnMode == RGN_COPY)
 +    {
 +      NtGdiCombineRgn(dc->rosdc.hClipRgn, hrgn, 0, fnMode);
 +    }
 +    else
 +      NtGdiCombineRgn(dc->rosdc.hClipRgn, dc->rosdc.hClipRgn, hrgn, fnMode);
 +  }
 +
 +  return CLIPPING_UpdateGCRegion(dc);
 +}
 +
 +
 +int APIENTRY NtGdiExtSelectClipRgn(HDC  hDC,
 +                                HRGN  hrgn,
 +                               int  fnMode)
 +{
 +  int retval;
 +  DC *dc;
 +
 +  if (!(dc = DC_LockDc(hDC)))
 +  {
 +      SetLastWin32Error(ERROR_INVALID_HANDLE);
 +      return ERROR;
 +  }
 +
 +  retval = GdiExtSelectClipRgn ( dc, hrgn, fnMode );
 +
 +  DC_UnlockDc(dc);
 +  return retval;
 +}
 +
 +INT FASTCALL
 +GdiGetClipBox(HDC hDC, PRECTL rc)
 +{
 +   INT retval;
 +   PDC dc;
 +   PROSRGNDATA pRgnNew, pRgn = NULL;
 +   BOOL Unlock = FALSE; //Small hack
 +
 +   if (!(dc = DC_LockDc(hDC)))
 +   {
 +      return ERROR;
 +   }
 +
 +   /* FIXME! Rao and Vis only! */
 +   if (dc->prgnAPI) // APIRGN
 +   {
 +      pRgn = dc->prgnAPI;
 +   }
 +   else if (dc->dclevel.prgnMeta) // METARGN
 +   {
 +      pRgn = dc->dclevel.prgnMeta;
 +   }
 +   else
 +   {
 +         Unlock = TRUE ;
 +       pRgn = REGION_LockRgn(dc->rosdc.hClipRgn); // CLIPRGN
 +   }
 +
 +   if (pRgn)
 +   {
 +      pRgnNew = IntSysCreateRectpRgn( 0, 0, 0, 0 );
 +
 +        if (!pRgnNew)
 +      {
 +         DC_UnlockDc(dc);
 +               if(Unlock) REGION_UnlockRgn(pRgn);
 +         return ERROR;
 +      }
 +
 +      IntGdiCombineRgn(pRgnNew, dc->prgnVis, pRgn, RGN_AND);
 +
 +      retval = REGION_GetRgnBox(pRgnNew, rc);
 +
 +        REGION_FreeRgnByHandle(pRgnNew->BaseObject.hHmgr);
 +
 +      DC_UnlockDc(dc);
 +        if(Unlock) REGION_UnlockRgn(pRgn);
 +      return retval;
 +   }
 +
 +   retval = REGION_GetRgnBox(dc->prgnVis, rc);
 +   IntDPtoLP(dc, (LPPOINT)rc, 2);
 +   DC_UnlockDc(dc);
 +
 +   return retval;
 +}
 +
 +INT APIENTRY
 +NtGdiGetAppClipBox(HDC hDC, PRECTL rc)
 +{
 +  INT Ret;
 +  NTSTATUS Status = STATUS_SUCCESS;
 +  RECTL Saferect;
 +
 +  Ret = GdiGetClipBox(hDC, &Saferect);
 +
 +  _SEH2_TRY
 +  {
 +    ProbeForWrite(rc,
 +                  sizeof(RECT),
 +                  1);
 +    *rc = Saferect;
 +  }
 +  _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 +  {
 +    Status = _SEH2_GetExceptionCode();
 +  }
 +  _SEH2_END;
 +
 +  if(!NT_SUCCESS(Status))
 +  {
 +    SetLastNtError(Status);
 +    return ERROR;
 +  }
 +
 +  return Ret;
 +}
 +
 +int APIENTRY NtGdiExcludeClipRect(HDC  hDC,
 +                         int  LeftRect,
 +                         int  TopRect,
 +                         int  RightRect,
 +                         int  BottomRect)
 +{
 +   INT Result;
 +   RECTL Rect;
 +   HRGN NewRgn;
 +   PDC dc = DC_LockDc(hDC);
 +
 +   if (!dc)
 +   {
 +      SetLastWin32Error(ERROR_INVALID_HANDLE);
 +      return ERROR;
 +   }
 +
 +   Rect.left = LeftRect;
 +   Rect.top = TopRect;
 +   Rect.right = RightRect;
 +   Rect.bottom = BottomRect;
 +
 +   IntLPtoDP(dc, (LPPOINT)&Rect, 2);
 +
 +   NewRgn = IntSysCreateRectRgnIndirect(&Rect);
 +   if (!NewRgn)
 +   {
 +      Result = ERROR;
 +   }
 +   else
 +   {
 +      if (!dc->rosdc.hClipRgn)
 +      {
 +         dc->rosdc.hClipRgn = IntSysCreateRectRgn(0, 0, 0, 0);
 +         NtGdiCombineRgn(dc->rosdc.hClipRgn, ((PROSRGNDATA)dc->prgnVis)->BaseObject.hHmgr, NewRgn, RGN_DIFF);
 +         Result = SIMPLEREGION;
 +      }
 +      else
 +      {
 +         Result = NtGdiCombineRgn(dc->rosdc.hClipRgn, dc->rosdc.hClipRgn, NewRgn, RGN_DIFF);
 +      }
 +      REGION_FreeRgnByHandle(NewRgn);
 +   }
 +   if (Result != ERROR)
 +      CLIPPING_UpdateGCRegion(dc);
 +
 +   DC_UnlockDc(dc);
 +
 +   return Result;
 +}
 +
 +int APIENTRY NtGdiIntersectClipRect(HDC  hDC,
 +                           int  LeftRect,
 +                           int  TopRect,
 +                           int  RightRect,
 +                           int  BottomRect)
 +{
 +   INT Result;
 +   RECTL Rect;
 +   HRGN NewRgn;
 +   PDC dc = DC_LockDc(hDC);
 +
 +   DPRINT("NtGdiIntersectClipRect(%x, %d,%d-%d,%d)\n",
 +      hDC, LeftRect, TopRect, RightRect, BottomRect);
 +
 +   if (!dc)
 +   {
 +      SetLastWin32Error(ERROR_INVALID_HANDLE);
 +      return ERROR;
 +   }
 +
 +   Rect.left = LeftRect;
 +   Rect.top = TopRect;
 +   Rect.right = RightRect;
 +   Rect.bottom = BottomRect;
 +
 +   IntLPtoDP(dc, (LPPOINT)&Rect, 2);
 +
 +   NewRgn = IntSysCreateRectRgnIndirect(&Rect);
 +   if (!NewRgn)
 +   {
 +      Result = ERROR;
 +   }
 +   else if (!dc->rosdc.hClipRgn)
 +   {
 +      dc->rosdc.hClipRgn = NewRgn;
 +      Result = SIMPLEREGION;
 +   }
 +   else
 +   {
 +      Result = NtGdiCombineRgn(dc->rosdc.hClipRgn, dc->rosdc.hClipRgn, NewRgn, RGN_AND);
 +      REGION_FreeRgnByHandle(NewRgn);
 +   }
 +   if (Result != ERROR)
 +      CLIPPING_UpdateGCRegion(dc);
 +
 +   DC_UnlockDc(dc);
 +
 +   return Result;
 +}
 +
 +int APIENTRY NtGdiOffsetClipRgn(HDC  hDC,
 +                       int  XOffset,
 +                       int  YOffset)
 +{
 +  INT Result;
 +  DC *dc;
 +
 +  if(!(dc = DC_LockDc(hDC)))
 +  {
 +    SetLastWin32Error(ERROR_INVALID_HANDLE);
 +    return ERROR;
 +  }
 +
 +  if(dc->rosdc.hClipRgn != NULL)
 +  {
 +    Result = NtGdiOffsetRgn(dc->rosdc.hClipRgn,
 +                            XOffset,
 +                            YOffset);
 +    CLIPPING_UpdateGCRegion(dc);
 +  }
 +  else
 +  {
 +    Result = NULLREGION;
 +  }
 +
 +  DC_UnlockDc(dc);
 +  return Result;
 +}
 +
 +BOOL APIENTRY NtGdiPtVisible(HDC  hDC,
 +                    int  X,
 +                    int  Y)
 +{
 +  HRGN rgn;
 +  DC *dc;
 +
 +  if(!(dc = DC_LockDc(hDC)))
 +  {
 +    SetLastWin32Error(ERROR_INVALID_HANDLE);
 +    return FALSE;
 +  }
 +
 +  rgn = dc->rosdc.hGCClipRgn;
 +  DC_UnlockDc(dc);
 +
 +  return (rgn ? NtGdiPtInRegion(rgn, X, Y) : FALSE);
 +}
 +
 +BOOL APIENTRY NtGdiRectVisible(HDC  hDC,
 +                      LPRECT UnsafeRect)
 +{
 +   NTSTATUS Status = STATUS_SUCCESS;
 +   PROSRGNDATA Rgn;
 +   PDC dc = DC_LockDc(hDC);
 +   BOOL Result = FALSE;
 +   RECTL Rect;
 +
 +   if (!dc)
 +   {
 +      SetLastWin32Error(ERROR_INVALID_HANDLE);
 +      return FALSE;
 +   }
 +
 +   _SEH2_TRY
 +   {
 +      ProbeForRead(UnsafeRect,
 +                   sizeof(RECT),
 +                   1);
 +      Rect = *UnsafeRect;
 +   }
 +   _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 +   {
 +      Status = _SEH2_GetExceptionCode();
 +   }
 +   _SEH2_END;
 +
 +   if(!NT_SUCCESS(Status))
 +   {
 +      DC_UnlockDc(dc);
 +      SetLastNtError(Status);
 +      return FALSE;
 +   }
 +
 +   if (dc->rosdc.hGCClipRgn)
 +   {
 +      if((Rgn = (PROSRGNDATA)RGNOBJAPI_Lock(dc->rosdc.hGCClipRgn, NULL)))
 +      {
 +         IntLPtoDP(dc, (LPPOINT)&Rect, 2);
 +         Result = REGION_RectInRegion(Rgn, &Rect);
 +         RGNOBJAPI_Unlock(Rgn);
 +      }
 +   }
 +   DC_UnlockDc(dc);
 +
 +   return Result;
 +}
 +
 +int
 +FASTCALL
 +IntGdiSetMetaRgn(PDC pDC)
 +{
 +  INT Ret = ERROR;
 +  PROSRGNDATA TempRgn;
 +
 +  if ( pDC->dclevel.prgnMeta )
 +  {
 +     if ( pDC->dclevel.prgnClip )
 +     {
 +        TempRgn = IntSysCreateRectpRgn(0,0,0,0);
 +        if (TempRgn)
 +        {
 +           Ret = IntGdiCombineRgn( TempRgn,
 +                     pDC->dclevel.prgnMeta,
 +                     pDC->dclevel.prgnClip,
 +                                   RGN_AND);
 +           if ( Ret )
 +           {
 +              GDIOBJ_ShareUnlockObjByPtr(pDC->dclevel.prgnMeta);
 +              if (!((PROSRGNDATA)pDC->dclevel.prgnMeta)->BaseObject.ulShareCount)
 +                 REGION_Delete(pDC->dclevel.prgnMeta);
 +
 +              pDC->dclevel.prgnMeta = TempRgn;
 +
 +              GDIOBJ_ShareUnlockObjByPtr(pDC->dclevel.prgnClip);
 +              if (!((PROSRGNDATA)pDC->dclevel.prgnClip)->BaseObject.ulShareCount)
 +                 REGION_Delete(pDC->dclevel.prgnClip);
 +
 +              pDC->dclevel.prgnClip = NULL;
 +
 +              IntGdiReleaseRaoRgn(pDC);
 +           }
 +           else
 +              REGION_Delete(TempRgn);
 +        }
 +     }
 +     else
 +        Ret = REGION_Complexity(pDC->dclevel.prgnMeta);
 +  }
 +  else
 +  {
 +     if ( pDC->dclevel.prgnClip )
 +     {
 +        Ret = REGION_Complexity(pDC->dclevel.prgnClip);
 +        pDC->dclevel.prgnMeta = pDC->dclevel.prgnClip;
 +        pDC->dclevel.prgnClip = NULL;
 +     }
 +     else
 +       Ret = SIMPLEREGION;
 +  }
 +  return Ret;
 +}
 +
 +
 +int APIENTRY NtGdiSetMetaRgn(HDC  hDC)
 +{
 +  INT Ret;
 +  PDC pDC = DC_LockDc(hDC);
 +
 +  if (!pDC)
 +  {
 +     SetLastWin32Error(ERROR_INVALID_PARAMETER);
 +     return ERROR;
 +  }
 +  Ret = IntGdiSetMetaRgn(pDC);
 +
 +  DC_UnlockDc(pDC);
 +  return Ret;
 +}
 +
 +INT FASTCALL
 +NEW_CLIPPING_UpdateGCRegion(PDC pDC)
 +{
 +  CLIPOBJ * co;
 +
 +  /* Must have VisRgn set to a valid state! */
 +  if (!pDC->prgnVis) return ERROR;
 +
 +  if (pDC->prgnAPI)
 +  {
 +     REGION_Delete(pDC->prgnAPI);
 +     pDC->prgnAPI = IntSysCreateRectpRgn(0,0,0,0);
 +  }
 +
 +  if (pDC->prgnRao)
 +  {
 +     REGION_Delete(pDC->prgnRao);
 +     pDC->prgnRao = IntSysCreateRectpRgn(0,0,0,0);
 +  }
 +
 +  if (pDC->dclevel.prgnMeta && pDC->dclevel.prgnClip)
 +  {
 +     IntGdiCombineRgn( pDC->prgnAPI,
 +                       pDC->dclevel.prgnClip,
 +                       pDC->dclevel.prgnMeta,
 +                       RGN_AND);
 +  }
 +  else
 +  {
 +     if (pDC->dclevel.prgnClip)
 +     {
 +        IntGdiCombineRgn( pDC->prgnAPI,
 +                          pDC->dclevel.prgnClip,
 +                          NULL,
 +                          RGN_COPY);
 +     }
 +     else if (pDC->dclevel.prgnMeta)
 +     {
 +        IntGdiCombineRgn( pDC->prgnAPI,
 +                          pDC->dclevel.prgnMeta,
 +                          NULL,
 +                          RGN_COPY);
 +     }
 +  }
 +
 +  IntGdiCombineRgn( pDC->prgnRao,
 +                    pDC->prgnVis,
 +                    pDC->prgnAPI,
 +                    RGN_AND);
 +
 +  RtlCopyMemory(&pDC->erclClip,
 +                &((PROSRGNDATA)pDC->prgnRao)->rdh.rcBound,
 +                sizeof(RECTL));
 +
 +  pDC->fs &= ~DC_FLAG_DIRTY_RAO;
 +
 +  IntGdiOffsetRgn(pDC->prgnRao, pDC->ptlDCOrig.x, pDC->ptlDCOrig.y);
 +
 +  // pDC->co should be used. Example, CLIPOBJ_cEnumStart uses XCLIPOBJ to build
 +  // the rects from region objects rects in pClipRgn->Buffer.
 +  // With pDC->co.pClipRgn->Buffer,
 +  // pDC->co.pClipRgn = pDC->prgnRao ? pDC->prgnRao : pDC->prgnVis;
 +
 +  co = IntEngCreateClipRegion( ((PROSRGNDATA)pDC->prgnRao)->rdh.nCount,
 +                               ((PROSRGNDATA)pDC->prgnRao)->Buffer,
 +                                 &pDC->erclClip);
 +  if (co)
 +  {
 +    if (pDC->rosdc.CombinedClip != NULL)
 +      IntEngDeleteClipRegion(pDC->rosdc.CombinedClip);
 +
 +    pDC->rosdc.CombinedClip = co;
 +  }
 +
 +  return IntGdiOffsetRgn(pDC->prgnRao, -pDC->ptlDCOrig.x, -pDC->ptlDCOrig.y);
 +}
 +
 +/* EOF */