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