objects/clipping.c

   1 /*
   2  * DC clipping functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  */
   6
   7 #include <stdlib.h>
   8 #include "dc.h"
   9 #include "metafiledrv.h"
  10 #include "region.h"
  11 #include "debug.h"
  12 #include "wine/winuser16.h"
  13
  14 DECLARE_DEBUG_CHANNEL(clipping)
  15 DECLARE_DEBUG_CHANNEL(region)
  16
  17 #define UPDATE_DIRTY_DC(dc) \
  18  do { \
  19    if ((dc)->hookProc && !((dc)->w.flags & (DC_SAVED | DC_MEMORY))) \
  20      (dc)->hookProc( (dc)->hSelf, DCHC_INVALIDVISRGN, (dc)->dwHookData, 0 ); \
  21  } while(0)
  22
  23
  24
  25 /***********************************************************************
  26  *           CLIPPING_UpdateGCRegion
  27  *
  28  * Update the GC clip region when the ClipRgn or VisRgn have changed.
  29  */
  30 void CLIPPING_UpdateGCRegion( DC * dc )
  31 {
  32     if (!dc->w.hGCClipRgn) dc->w.hGCClipRgn = CreateRectRgn( 0, 0, 0, 0 );
  33
  34     if (!dc->w.hVisRgn)
  35     {
  36         ERR(region, "hVisRgn is zero. Please report this.\n" );
  37         exit(1);
  38     }
  39
  40     if (dc->w.flags & DC_DIRTY)
  41     {
  42         UPDATE_DIRTY_DC(dc);
  43         dc->w.flags &= ~DC_DIRTY;
  44     }
  45
  46     if (!dc->w.hClipRgn)
  47         CombineRgn( dc->w.hGCClipRgn, dc->w.hVisRgn, 0, RGN_COPY );
  48     else
  49         CombineRgn(dc->w.hGCClipRgn, dc->w.hClipRgn, dc->w.hVisRgn, RGN_AND);
  50     if (dc->funcs->pSetDeviceClipping) dc->funcs->pSetDeviceClipping( dc );
  51 }
  52
  53
  54 /***********************************************************************
  55  *           SelectClipRgn16    (GDI.44)
  56  */
  57 INT16 WINAPI SelectClipRgn16( HDC16 hdc, HRGN16 hrgn )
  58 {
  59     return (INT16)SelectClipRgn( hdc, hrgn );
  60 }
  61
  62
  63 /***********************************************************************
  64  *           SelectClipRgn32    (GDI32.297)
  65  */
  66 INT WINAPI SelectClipRgn( HDC hdc, HRGN hrgn )
  67 {
  68     return ExtSelectClipRgn( hdc, hrgn, RGN_COPY );
  69 }
  70
  71 /******************************************************************************
  72  *              ExtSelectClipRgn        [GDI32.97]
  73  */
  74 INT WINAPI ExtSelectClipRgn( HDC hdc, HRGN hrgn, INT fnMode )
  75 {
  76     INT retval;
  77     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
  78     if (!dc) return ERROR;
  79
  80     TRACE( clipping, "%04x %04x %d\n", hdc, hrgn, fnMode );
  81
  82     if (!hrgn)
  83     {
  84         if (fnMode == RGN_COPY)
  85         {
  86             if (dc->w.hClipRgn) DeleteObject16( dc->w.hClipRgn );
  87             dc->w.hClipRgn = 0;
  88             retval = SIMPLEREGION; /* Clip region == whole DC */
  89         }
  90         else
  91         {
  92             FIXME(clipping, "Unimplemented: hrgn NULL in mode: %d\n", fnMode);
  93             return ERROR;
  94         }
  95     }
  96     else
  97     {
  98         if (!dc->w.hClipRgn)
  99         {
 100             RECT rect;
 101             GetRgnBox( dc->w.hVisRgn, &rect );
 102             dc->w.hClipRgn = CreateRectRgnIndirect( &rect );
 103         }
 104
 105         OffsetRgn( dc->w.hClipRgn, -dc->w.DCOrgX, -dc->w.DCOrgY );
 106         if(fnMode == RGN_COPY)
 107             retval = CombineRgn( dc->w.hClipRgn, hrgn, 0, fnMode );
 108         else
 109             retval = CombineRgn( dc->w.hClipRgn, dc->w.hClipRgn, hrgn, fnMode);
 110         OffsetRgn( dc->w.hClipRgn, dc->w.DCOrgX, dc->w.DCOrgY );
 111     }
 112
 113
 114     CLIPPING_UpdateGCRegion( dc );
 115     GDI_HEAP_UNLOCK( hdc );
 116     return retval;
 117 }
 118
 119 /***********************************************************************
 120  *           SelectVisRgn    (GDI.105)
 121  */
 122 INT16 WINAPI SelectVisRgn16( HDC16 hdc, HRGN16 hrgn )
 123 {
 124     int retval;
 125     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 126     if (!dc || !hrgn) return ERROR;
 127
 128     TRACE(clipping, "%04x %04x\n", hdc, hrgn );
 129
 130     dc->w.flags &= ~DC_DIRTY;
 131
 132     retval = CombineRgn16( dc->w.hVisRgn, hrgn, 0, RGN_COPY );
 133     CLIPPING_UpdateGCRegion( dc );
 134     GDI_HEAP_UNLOCK( hdc );
 135     return retval;
 136 }
 137
 138
 139 /***********************************************************************
 140  *           OffsetClipRgn16    (GDI.32)
 141  */
 142 INT16 WINAPI OffsetClipRgn16( HDC16 hdc, INT16 x, INT16 y )
 143 {
 144     return (INT16)OffsetClipRgn( hdc, x, y );
 145 }
 146
 147
 148 /***********************************************************************
 149  *           OffsetClipRgn32    (GDI32.255)
 150  */
 151 INT WINAPI OffsetClipRgn( HDC hdc, INT x, INT y )
 152 {
 153     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 154     if (!dc)
 155     {
 156         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 157         if (!dc) return ERROR;
 158         MFDRV_MetaParam2(dc, META_OFFSETCLIPRGN, x, y);
 159         GDI_HEAP_UNLOCK( hdc );
 160         return NULLREGION;   /* ?? */
 161     }
 162
 163     TRACE(clipping, "%04x %d,%d\n", hdc, x, y );
 164
 165     if (dc->w.hClipRgn)
 166     {
 167         INT ret = OffsetRgn( dc->w.hClipRgn, XLPTODP(dc,x), YLPTODP(dc,y));
 168         CLIPPING_UpdateGCRegion( dc );
 169         GDI_HEAP_UNLOCK( hdc );
 170         return ret;
 171     }
 172     GDI_HEAP_UNLOCK( hdc );
 173     return SIMPLEREGION; /* Clip region == client area */
 174 }
 175
 176
 177 /***********************************************************************
 178  *           OffsetVisRgn    (GDI.102)
 179  */
 180 INT16 WINAPI OffsetVisRgn16( HDC16 hdc, INT16 x, INT16 y )
 181 {
 182     INT16 retval;
 183     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 184     if (!dc) return ERROR;
 185     TRACE(clipping, "%04x %d,%d\n", hdc, x, y );
 186     retval = OffsetRgn( dc->w.hVisRgn, x, y );
 187     CLIPPING_UpdateGCRegion( dc );
 188     GDI_HEAP_UNLOCK( hdc );
 189     return retval;
 190 }
 191
 192
 193 /***********************************************************************
 194  *           CLIPPING_IntersectClipRect
 195  *
 196  * Helper function for {Intersect,Exclude}ClipRect, can be called from
 197  * elsewhere (like ExtTextOut()) to skip redundant metafile update and
 198  * coordinate conversion.
 199  */
 200 INT CLIPPING_IntersectClipRect( DC * dc, INT left, INT top,
 201                                   INT right, INT bottom, UINT flags )
 202 {
 203     HRGN newRgn;
 204     INT ret;
 205
 206     left   += dc->w.DCOrgX;
 207     right  += dc->w.DCOrgX;
 208     top    += dc->w.DCOrgY;
 209     bottom += dc->w.DCOrgY;
 210
 211     if (!(newRgn = CreateRectRgn( left, top, right, bottom ))) return ERROR;
 212     if (!dc->w.hClipRgn)
 213     {
 214        if( flags & CLIP_INTERSECT )
 215        {
 216            dc->w.hClipRgn = newRgn;
 217            CLIPPING_UpdateGCRegion( dc );
 218            return SIMPLEREGION;
 219        }
 220        else if( flags & CLIP_EXCLUDE )
 221        {
 222            dc->w.hClipRgn = CreateRectRgn( 0, 0, 0, 0 );
 223            CombineRgn( dc->w.hClipRgn, dc->w.hVisRgn, 0, RGN_COPY );
 224        }
 225        else WARN(clipping,"No hClipRgn and flags are %x\n",flags);
 226     }
 227
 228     ret = CombineRgn( newRgn, dc->w.hClipRgn, newRgn,
 229                         (flags & CLIP_EXCLUDE) ? RGN_DIFF : RGN_AND );
 230     if (ret != ERROR)
 231     {
 232         if (!(flags & CLIP_KEEPRGN)) DeleteObject( dc->w.hClipRgn );
 233         dc->w.hClipRgn = newRgn;
 234         CLIPPING_UpdateGCRegion( dc );
 235     }
 236     else DeleteObject( newRgn );
 237     return ret;
 238 }
 239
 240
 241 /***********************************************************************
 242  *           ExcludeClipRect16    (GDI.21)
 243  */
 244 INT16 WINAPI ExcludeClipRect16( HDC16 hdc, INT16 left, INT16 top,
 245                                 INT16 right, INT16 bottom )
 246 {
 247     return (INT16)ExcludeClipRect( hdc, left, top, right, bottom );
 248 }
 249
 250
 251 /***********************************************************************
 252  *           ExcludeClipRect32    (GDI32.92)
 253  */
 254 INT WINAPI ExcludeClipRect( HDC hdc, INT left, INT top,
 255                                 INT right, INT bottom )
 256 {
 257     INT ret;
 258     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 259     if (!dc)
 260     {
 261         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 262         if (!dc) return ERROR;
 263         MFDRV_MetaParam4(dc, META_EXCLUDECLIPRECT, left, top, right, bottom);
 264         GDI_HEAP_UNLOCK( hdc );
 265         return NULLREGION;   /* ?? */
 266     }
 267
 268     left   = XLPTODP( dc, left );
 269     right  = XLPTODP( dc, right );
 270     top    = YLPTODP( dc, top );
 271     bottom = YLPTODP( dc, bottom );
 272
 273     TRACE(clipping, "%04x %dx%d,%dx%d\n",
 274             hdc, left, top, right, bottom );
 275     ret = CLIPPING_IntersectClipRect( dc, left, top, right, bottom, CLIP_EXCLUDE );
 276     GDI_HEAP_UNLOCK( hdc );
 277     return ret;
 278 }
 279
 280
 281 /***********************************************************************
 282  *           IntersectClipRect16    (GDI.22)
 283  */
 284 INT16 WINAPI IntersectClipRect16( HDC16 hdc, INT16 left, INT16 top,
 285                                   INT16 right, INT16 bottom )
 286 {
 287     return (INT16)IntersectClipRect( hdc, left, top, right, bottom );
 288 }
 289
 290
 291 /***********************************************************************
 292  *           IntersectClipRect32    (GDI32.245)
 293  */
 294 INT WINAPI IntersectClipRect( HDC hdc, INT left, INT top,
 295                                   INT right, INT bottom )
 296 {
 297     INT ret;
 298     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 299     if (!dc)
 300     {
 301         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 302         if (!dc) return ERROR;
 303         MFDRV_MetaParam4(dc, META_INTERSECTCLIPRECT, left, top, right, bottom);
 304         GDI_HEAP_UNLOCK( hdc );
 305         return NULLREGION;   /* ?? */
 306     }
 307
 308     left   = XLPTODP( dc, left );
 309     right  = XLPTODP( dc, right );
 310     top    = YLPTODP( dc, top );
 311     bottom = YLPTODP( dc, bottom );
 312
 313     TRACE(clipping, "%04x %dx%d,%dx%d\n",
 314             hdc, left, top, right, bottom );
 315     ret = CLIPPING_IntersectClipRect( dc, left, top, right, bottom, CLIP_INTERSECT );
 316     GDI_HEAP_UNLOCK( hdc );
 317     return ret;
 318 }
 319
 320
 321 /***********************************************************************
 322  *           CLIPPING_IntersectVisRect
 323  *
 324  * Helper function for {Intersect,Exclude}VisRect, can be called from
 325  * elsewhere (like ExtTextOut()) to skip redundant metafile update and
 326  * coordinate conversion.
 327  */
 328 INT CLIPPING_IntersectVisRect( DC * dc, INT left, INT top,
 329                                  INT right, INT bottom,
 330                                  BOOL exclude )
 331 {
 332     HRGN tempRgn, newRgn;
 333     INT ret;
 334
 335     left   += dc->w.DCOrgX;
 336     right  += dc->w.DCOrgX;
 337     top    += dc->w.DCOrgY;
 338     bottom += dc->w.DCOrgY;
 339
 340     if (!(newRgn = CreateRectRgn( 0, 0, 0, 0 ))) return ERROR;
 341     if (!(tempRgn = CreateRectRgn( left, top, right, bottom )))
 342     {
 343         DeleteObject( newRgn );
 344         return ERROR;
 345     }
 346     ret = CombineRgn( newRgn, dc->w.hVisRgn, tempRgn,
 347                         exclude ? RGN_DIFF : RGN_AND );
 348     DeleteObject( tempRgn );
 349
 350     if (ret != ERROR)
 351     {
 352         RGNOBJ *newObj  = (RGNOBJ*)GDI_GetObjPtr( newRgn, REGION_MAGIC);
 353         RGNOBJ *prevObj = (RGNOBJ*)GDI_GetObjPtr( dc->w.hVisRgn, REGION_MAGIC);
 354         if (newObj && prevObj) newObj->header.hNext = prevObj->header.hNext;
 355         DeleteObject( dc->w.hVisRgn );
 356         dc->w.hVisRgn = newRgn;
 357         CLIPPING_UpdateGCRegion( dc );
 358         GDI_HEAP_UNLOCK( newRgn );
 359     }
 360     else DeleteObject( newRgn );
 361     return ret;
 362 }
 363
 364
 365 /***********************************************************************
 366  *           ExcludeVisRect    (GDI.73)
 367  */
 368 INT16 WINAPI ExcludeVisRect16( HDC16 hdc, INT16 left, INT16 top,
 369                              INT16 right, INT16 bottom )
 370 {
 371     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 372     if (!dc) return ERROR;
 373
 374     left   = XLPTODP( dc, left );
 375     right  = XLPTODP( dc, right );
 376     top    = YLPTODP( dc, top );
 377     bottom = YLPTODP( dc, bottom );
 378
 379     TRACE(clipping, "%04x %dx%d,%dx%d\n",
 380             hdc, left, top, right, bottom );
 381
 382     return CLIPPING_IntersectVisRect( dc, left, top, right, bottom, TRUE );
 383 }
 384
 385
 386 /***********************************************************************
 387  *           IntersectVisRect    (GDI.98)
 388  */
 389 INT16 WINAPI IntersectVisRect16( HDC16 hdc, INT16 left, INT16 top,
 390                                INT16 right, INT16 bottom )
 391 {
 392     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 393     if (!dc) return ERROR;
 394
 395     left   = XLPTODP( dc, left );
 396     right  = XLPTODP( dc, right );
 397     top    = YLPTODP( dc, top );
 398     bottom = YLPTODP( dc, bottom );
 399
 400     TRACE(clipping, "%04x %dx%d,%dx%d\n",
 401             hdc, left, top, right, bottom );
 402
 403     return CLIPPING_IntersectVisRect( dc, left, top, right, bottom, FALSE );
 404 }
 405
 406
 407 /***********************************************************************
 408  *           PtVisible16    (GDI.103)
 409  */
 410 BOOL16 WINAPI PtVisible16( HDC16 hdc, INT16 x, INT16 y )
 411 {
 412     return PtVisible( hdc, x, y );
 413 }
 414
 415
 416 /***********************************************************************
 417  *           PtVisible32    (GDI32.279)
 418  */
 419 BOOL WINAPI PtVisible( HDC hdc, INT x, INT y )
 420 {
 421     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 422     if (!dc) return ERROR;
 423
 424     TRACE(clipping, "%04x %d,%d\n", hdc, x, y );
 425     if (!dc->w.hGCClipRgn) return FALSE;
 426
 427     if( dc->w.flags & DC_DIRTY ) UPDATE_DIRTY_DC(dc);
 428     dc->w.flags &= ~DC_DIRTY;
 429
 430     return PtInRegion( dc->w.hGCClipRgn, XLPTODP(dc,x) + dc->w.DCOrgX,
 431                                            YLPTODP(dc,y) + dc->w.DCOrgY );
 432 }
 433
 434
 435 /***********************************************************************
 436  *           RectVisible16    (GDI.104)
 437  */
 438 BOOL16 WINAPI RectVisible16( HDC16 hdc, const RECT16* rect )
 439 {
 440     RECT16 tmpRect;
 441     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 442     if (!dc) return FALSE;
 443     TRACE(clipping,"%04x %d,%dx%d,%d\n",
 444                      hdc, rect->left, rect->top, rect->right, rect->bottom );
 445     if (!dc->w.hGCClipRgn) return FALSE;
 446     /* copy rectangle to avoid overwriting by LPtoDP */
 447     tmpRect = *rect;
 448     LPtoDP16( hdc, (LPPOINT16)&tmpRect, 2 );
 449     OffsetRect16( &tmpRect, dc->w.DCOrgX, dc->w.DCOrgY );
 450     return RectInRegion16( dc->w.hGCClipRgn, &tmpRect );
 451 }
 452
 453
 454 /***********************************************************************
 455  *           RectVisible32    (GDI32.282)
 456  */
 457 BOOL WINAPI RectVisible( HDC hdc, const RECT* rect )
 458 {
 459     RECT16 rect16;
 460     CONV_RECT32TO16( rect, &rect16 );
 461     return RectVisible16( (HDC16)hdc, &rect16 );
 462 }
 463
 464
 465 /***********************************************************************
 466  *           GetClipBox16    (GDI.77)
 467  */
 468 INT16 WINAPI GetClipBox16( HDC16 hdc, LPRECT16 rect )
 469 {
 470     int ret;
 471     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 472     if (!dc) return ERROR;
 473     ret = GetRgnBox16( dc->w.hGCClipRgn, rect );
 474     OffsetRect16( rect, -dc->w.DCOrgX, -dc->w.DCOrgY );
 475     DPtoLP16( hdc, (LPPOINT16)rect, 2 );
 476     TRACE(clipping, "%d,%d-%d,%d\n",
 477             rect->left,rect->top,rect->right,rect->bottom );
 478     return ret;
 479 }
 480
 481
 482 /***********************************************************************
 483  *           GetClipBox32    (GDI32.162)
 484  */
 485 INT WINAPI GetClipBox( HDC hdc, LPRECT rect )
 486 {
 487     INT ret;
 488     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 489     if (!dc) return ERROR;
 490     ret = GetRgnBox( dc->w.hGCClipRgn, rect );
 491     OffsetRect( rect, -dc->w.DCOrgX, -dc->w.DCOrgY );
 492     DPtoLP( hdc, (LPPOINT)rect, 2 );
 493     return ret;
 494 }
 495
 496
 497 /***********************************************************************
 498  *           GetClipRgn32  (GDI32.163)
 499  */
 500 INT WINAPI GetClipRgn( HDC hdc, HRGN hRgn )
 501 {
 502     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 503     if( dc && hRgn )
 504     {
 505       if( dc->w.hClipRgn )
 506       {
 507         /* this assumes that dc->w.hClipRgn is in coordinates
 508            relative to the device (not DC origin) */
 509
 510         if( CombineRgn(hRgn, dc->w.hClipRgn, 0, RGN_COPY) != ERROR )
 511         {
 512             OffsetRgn( hRgn, -dc->w.DCOrgX, -dc->w.DCOrgY );
 513             return 1;
 514         }
 515       }
 516       else return 0;
 517     }
 518     return -1;
 519 }
 520
 521 /***********************************************************************
 522  *           SaveVisRgn    (GDI.129)
 523  */
 524 HRGN16 WINAPI SaveVisRgn16( HDC16 hdc )
 525 {
 526     HRGN copy;
 527     RGNOBJ *obj, *copyObj;
 528     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 529     if (!dc) return 0;
 530     TRACE(clipping, "%04x\n", hdc );
 531     if (!dc->w.hVisRgn)
 532     {
 533         ERR(region, "hVisRgn is zero. Please report this.\n" );
 534         exit(1);
 535     }
 536     if( dc->w.flags & DC_DIRTY ) UPDATE_DIRTY_DC(dc);
 537     dc->w.flags &= ~DC_DIRTY;
 538
 539     if (!(obj = (RGNOBJ *) GDI_GetObjPtr( dc->w.hVisRgn, REGION_MAGIC )))
 540     {
 541         GDI_HEAP_UNLOCK( hdc );
 542         return 0;
 543     }
 544     if (!(copy = CreateRectRgn( 0, 0, 0, 0 )))
 545     {
 546         GDI_HEAP_UNLOCK( dc->w.hVisRgn );
 547         GDI_HEAP_UNLOCK( hdc );
 548         return 0;
 549     }
 550     CombineRgn( copy, dc->w.hVisRgn, 0, RGN_COPY );
 551     if (!(copyObj = (RGNOBJ *) GDI_GetObjPtr( copy, REGION_MAGIC )))
 552     {
 553         GDI_HEAP_UNLOCK( dc->w.hVisRgn );
 554         GDI_HEAP_UNLOCK( hdc );
 555         return 0;
 556     }
 557     copyObj->header.hNext = obj->header.hNext;
 558     obj->header.hNext = copy;
 559     GDI_HEAP_UNLOCK( dc->w.hVisRgn );
 560     GDI_HEAP_UNLOCK( hdc );
 561     GDI_HEAP_UNLOCK( copy );
 562     return copy;
 563 }
 564
 565
 566 /***********************************************************************
 567  *           RestoreVisRgn    (GDI.130)
 568  */
 569 INT16 WINAPI RestoreVisRgn16( HDC16 hdc )
 570 {
 571     HRGN saved;
 572     RGNOBJ *obj, *savedObj;
 573     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 574     INT16 ret;
 575
 576     if (!dc) return ERROR;
 577     if (!dc->w.hVisRgn)
 578     {
 579         GDI_HEAP_UNLOCK( hdc );
 580         return ERROR;
 581     }
 582     TRACE(clipping, "%04x\n", hdc );
 583     if (!(obj = (RGNOBJ *) GDI_GetObjPtr( dc->w.hVisRgn, REGION_MAGIC )))
 584     {
 585         GDI_HEAP_UNLOCK( hdc );
 586         return ERROR;
 587     }
 588     if (!(saved = obj->header.hNext))
 589     {
 590         GDI_HEAP_UNLOCK( dc->w.hVisRgn );
 591         GDI_HEAP_UNLOCK( hdc );
 592         return ERROR;
 593     }
 594     if (!(savedObj = (RGNOBJ *) GDI_GetObjPtr( saved, REGION_MAGIC )))
 595     {
 596         GDI_HEAP_UNLOCK( dc->w.hVisRgn );
 597         GDI_HEAP_UNLOCK( hdc );
 598         return ERROR;
 599     }
 600     DeleteObject( dc->w.hVisRgn );
 601     dc->w.hVisRgn = saved;
 602     CLIPPING_UpdateGCRegion( dc );
 603     GDI_HEAP_UNLOCK( hdc );
 604     ret = savedObj->rgn->type; /* FIXME */
 605     GDI_HEAP_UNLOCK( saved );
 606     return ret;
 607 }