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