objects/gdiobj.c

   1 /*
   2  * GDI functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  *
   6 static char Copyright[] = "Copyright  Alexandre Julliard, 1993";
   7 */
   8
   9 #include <stdlib.h>
  10 #include <stdio.h>
  11 #include "selectors.h"
  12 #include "gdi.h"
  13 #include "color.h"
  14 #include "bitmap.h"
  15 #include "brush.h"
  16 #include "font.h"
  17 #include "palette.h"
  18 #include "pen.h"
  19 #include "region.h"
  20 #include "stddebug.h"
  21 /* #define DEBUG_GDI */
  22 #include "debug.h"
  23
  24 MDESC *GDI_Heap = NULL;
  25
  26 /* Object types for EnumObjects() */
  27 #define OBJ_PEN             1
  28 #define OBJ_BRUSH           2
  29
  30 #define MAX_OBJ                         1024
  31 HANDLE *lpPenBrushList = NULL;
  32
  33
  34 /***********************************************************************
  35  *          GDI stock objects
  36  */
  37
  38 static BRUSHOBJ WhiteBrush =
  39 {
  40     { 0, BRUSH_MAGIC, 1, 0 },          /* header */
  41     { BS_SOLID, RGB(255,255,255), 0 }  /* logbrush */
  42 };
  43
  44 static BRUSHOBJ LtGrayBrush =
  45 {
  46     { 0, BRUSH_MAGIC, 1, 0 },          /* header */
  47     { BS_SOLID, RGB(192,192,192), 0 }  /* logbrush */
  48 };
  49
  50 static BRUSHOBJ GrayBrush =
  51 {
  52     { 0, BRUSH_MAGIC, 1, 0 },          /* header */
  53     { BS_SOLID, RGB(128,128,128), 0 }  /* logbrush */
  54 };
  55
  56 static BRUSHOBJ DkGrayBrush =
  57 {
  58     { 0, BRUSH_MAGIC, 1, 0 },       /* header */
  59     { BS_SOLID, RGB(64,64,64), 0 }  /* logbrush */
  60 };
  61
  62 static BRUSHOBJ BlackBrush =
  63 {
  64     { 0, BRUSH_MAGIC, 1, 0 },    /* header */
  65     { BS_SOLID, RGB(0,0,0), 0 }  /* logbrush */
  66 };
  67
  68 static BRUSHOBJ NullBrush =
  69 {
  70     { 0, BRUSH_MAGIC, 1, 0 },  /* header */
  71     { BS_NULL, 0, 0 }          /* logbrush */
  72 };
  73
  74 static PENOBJ WhitePen =
  75 {
  76     { 0, PEN_MAGIC, 1, 0 },                  /* header */
  77     { PS_SOLID, { 1, 0 }, RGB(255,255,255) } /* logpen */
  78 };
  79
  80 static PENOBJ BlackPen =
  81 {
  82     { 0, PEN_MAGIC, 1, 0 },            /* header */
  83     { PS_SOLID, { 1, 0 }, RGB(0,0,0) } /* logpen */
  84 };
  85
  86 static PENOBJ NullPen =
  87 {
  88     { 0, PEN_MAGIC, 1, 0 },   /* header */
  89     { PS_NULL, { 1, 0 }, 0 }  /* logpen */
  90 };
  91
  92 static FONTOBJ OEMFixedFont =
  93 {
  94     { 0, FONT_MAGIC, 1, 0 },   /* header */
  95     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, OEM_CHARSET,
  96       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
  97 };
  98
  99 static FONTOBJ AnsiFixedFont =
 100 {
 101     { 0, FONT_MAGIC, 1, 0 },   /* header */
 102     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 103       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
 104 };
 105
 106 static FONTOBJ AnsiVarFont =
 107 {
 108     { 0, FONT_MAGIC, 1, 0 },   /* header */
 109     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 110       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
 111 };
 112
 113 static FONTOBJ SystemFont =
 114 {
 115     { 0, FONT_MAGIC, 1, 0 },   /* header */
 116     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 117       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
 118 };
 119
 120 static FONTOBJ DeviceDefaultFont =
 121 {
 122     { 0, FONT_MAGIC, 1, 0 },   /* header */
 123     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 124       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
 125 };
 126
 127 static FONTOBJ SystemFixedFont =
 128 {
 129     { 0, FONT_MAGIC, 1, 0 },   /* header */
 130     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 131       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
 132 };
 133
 134
 135 static GDIOBJHDR * StockObjects[NB_STOCK_OBJECTS] =
 136 {
 137     (GDIOBJHDR *) &WhiteBrush,
 138     (GDIOBJHDR *) &LtGrayBrush,
 139     (GDIOBJHDR *) &GrayBrush,
 140     (GDIOBJHDR *) &DkGrayBrush,
 141     (GDIOBJHDR *) &BlackBrush,
 142     (GDIOBJHDR *) &NullBrush,
 143     (GDIOBJHDR *) &WhitePen,
 144     (GDIOBJHDR *) &BlackPen,
 145     (GDIOBJHDR *) &NullPen,
 146     NULL,
 147     (GDIOBJHDR *) &OEMFixedFont,
 148     (GDIOBJHDR *) &AnsiFixedFont,
 149     (GDIOBJHDR *) &AnsiVarFont,
 150     (GDIOBJHDR *) &SystemFont,
 151     (GDIOBJHDR *) &DeviceDefaultFont,
 152     NULL,            /* DEFAULT_PALETTE created by COLOR_Init */
 153     (GDIOBJHDR *) &SystemFixedFont
 154 };
 155
 156
 157 /***********************************************************************
 158  *           GDI_Init
 159  *
 160  * GDI initialisation.
 161  */
 162 BOOL GDI_Init(void)
 163 {
 164     HPALETTE hpalette;
 165     struct segment_descriptor_s * s;
 166
 167 #ifndef WINELIB
 168     /* Create GDI heap */
 169
 170     s = (struct segment_descriptor_s *)GetNextSegment( 0, 0x10000 );
 171     if (s == NULL) return FALSE;
 172     HEAP_Init( &GDI_Heap, s->base_addr, GDI_HEAP_SIZE );
 173 #endif
 174
 175       /* Create default palette */
 176
 177     if (!(hpalette = COLOR_Init())) return FALSE;
 178     StockObjects[DEFAULT_PALETTE] = (GDIOBJHDR *) GDI_HEAP_ADDR( hpalette );
 179
 180       /* Create default bitmap */
 181
 182     if (!BITMAP_Init()) return FALSE;
 183
 184       /* Initialise regions */
 185
 186     if (!REGION_Init()) return FALSE;
 187
 188       /* Initialise brush dithering */
 189
 190     if (!BRUSH_Init()) return FALSE;
 191
 192       /* Initialise fonts */
 193
 194     if (!FONT_Init()) return FALSE;
 195
 196     return TRUE;
 197 }
 198
 199
 200 /***********************************************************************
 201  *           GDI_AppendToPenBrushList
 202  */
 203 BOOL GDI_AppendToPenBrushList(HANDLE hNewObj)
 204 {
 205         HANDLE          *lphObj;
 206         int                     i = 1;
 207         if (hNewObj == 0) return FALSE;
 208         if (lpPenBrushList == NULL) {
 209                 lpPenBrushList = malloc(MAX_OBJ * sizeof(HANDLE));
 210                 lpPenBrushList[0] = 0;
 211                 dprintf_gdi(stddeb,"GDI_AppendToPenBrushList() lpPenBrushList allocated !\n");
 212                 }
 213         for (lphObj = lpPenBrushList; i < MAX_OBJ; i++) {
 214                 if (*lphObj == 0) {
 215                         *lphObj = hNewObj;
 216                         *(lphObj + 1) = 0;
 217                         dprintf_gdi(stddeb,"GDI_AppendToPenBrushList(%04X) appended (count=%d)\n", hNewObj, i);
 218                         return TRUE;
 219                         }
 220                 lphObj++;
 221                 }
 222         return FALSE;
 223 }
 224
 225
 226 /***********************************************************************
 227  *           GDI_FindPrevObject
 228  *
 229  * Return the GDI object whose hNext field points to obj.
 230  */
 231 HANDLE GDI_FindPrevObject( HANDLE first, HANDLE obj )
 232 {
 233     HANDLE handle;
 234
 235     for (handle = first; handle && (handle != obj); )
 236     {
 237         GDIOBJHDR * header = (GDIOBJHDR *) GDI_HEAP_ADDR( handle );
 238         handle = header->hNext;
 239     }
 240     return handle;
 241 }
 242
 243
 244 /***********************************************************************
 245  *           GDI_AllocObject
 246  */
 247 HANDLE GDI_AllocObject( WORD size, WORD magic )
 248 {
 249     static DWORD count = 0;
 250     GDIOBJHDR * obj;
 251     HANDLE handle = GDI_HEAP_ALLOC( GMEM_MOVEABLE, size );
 252     if (!handle) return 0;
 253     obj = (GDIOBJHDR *) GDI_HEAP_ADDR( handle );
 254     obj->hNext   = 0;
 255     obj->wMagic  = magic;
 256     obj->dwCount = ++count;
 257         if (magic == PEN_MAGIC || magic == BRUSH_MAGIC) {
 258                 GDI_AppendToPenBrushList(handle);
 259                 }
 260     return handle;
 261 }
 262
 263
 264 /***********************************************************************
 265  *           GDI_FreeObject
 266  */
 267 BOOL GDI_FreeObject( HANDLE handle )
 268 {
 269     GDIOBJHDR * object;
 270
 271       /* Can't free stock objects */
 272     if (handle >= FIRST_STOCK_HANDLE) return TRUE;
 273
 274     object = (GDIOBJHDR *) GDI_HEAP_ADDR( handle );
 275     if (!object) return FALSE;
 276     object->wMagic = 0;  /* Mark it as invalid */
 277
 278       /* Free object */
 279
 280     GDI_HEAP_FREE( handle );
 281     return TRUE;
 282 }
 283
 284 /***********************************************************************
 285  *           GDI_GetObjPtr
 286  *
 287  * Return a pointer to the GDI object associated to the handle.
 288  * Return NULL if the object has the wrong magic number.
 289  */
 290 GDIOBJHDR * GDI_GetObjPtr( HANDLE handle, WORD magic )
 291 {
 292     GDIOBJHDR * ptr = NULL;
 293
 294     if (handle >= FIRST_STOCK_HANDLE)
 295     {
 296         if (handle < FIRST_STOCK_HANDLE + NB_STOCK_OBJECTS)
 297             ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 298     }
 299     else ptr = (GDIOBJHDR *) GDI_HEAP_ADDR( handle );
 300     if (!ptr) return NULL;
 301     if (ptr->wMagic != magic) return NULL;
 302     return ptr;
 303 }
 304
 305
 306 /***********************************************************************
 307  *           DeleteObject    (GDI.69)
 308  */
 309 BOOL DeleteObject( HANDLE obj )
 310 {
 311       /* Check if object is valid */
 312
 313     GDIOBJHDR * header = (GDIOBJHDR *) GDI_HEAP_ADDR( obj );
 314     if (!header) return FALSE;
 315
 316     dprintf_gdi(stddeb, "DeleteObject: %d\n", obj );
 317
 318       /* Delete object */
 319
 320     switch(header->wMagic)
 321     {
 322       case PEN_MAGIC:     return GDI_FreeObject( obj );
 323       case BRUSH_MAGIC:   return BRUSH_DeleteObject( obj, (BRUSHOBJ*)header );
 324       case FONT_MAGIC:    return GDI_FreeObject( obj );
 325       case PALETTE_MAGIC: return GDI_FreeObject( obj );
 326       case BITMAP_MAGIC:  return BITMAP_DeleteObject( obj, (BITMAPOBJ*)header);
 327       case REGION_MAGIC:  return REGION_DeleteObject( obj, (RGNOBJ*)header );
 328     }
 329     return FALSE;
 330 }
 331
 332
 333 /***********************************************************************
 334  *           GetStockObject    (GDI.87)
 335  */
 336 HANDLE GetStockObject( int obj )
 337 {
 338     if ((obj < 0) || (obj >= NB_STOCK_OBJECTS)) return 0;
 339     if (!StockObjects[obj]) return 0;
 340     dprintf_gdi(stddeb, "GetStockObject: returning %04x\n",
 341                 FIRST_STOCK_HANDLE + obj );
 342     return FIRST_STOCK_HANDLE + obj;
 343 }
 344
 345
 346 /***********************************************************************
 347  *           GetObject    (GDI.82)
 348  */
 349 int GetObject( HANDLE handle, int count, LPSTR buffer )
 350 {
 351     GDIOBJHDR * ptr = NULL;
 352     dprintf_gdi(stddeb, "GetObject: %04x %d %p\n", handle, count, buffer );
 353     if (!count) return 0;
 354
 355     if (handle >= FIRST_STOCK_HANDLE)
 356     {
 357         if (handle < FIRST_STOCK_HANDLE + NB_STOCK_OBJECTS)
 358             ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 359     }
 360     else ptr = (GDIOBJHDR *) GDI_HEAP_ADDR( handle );
 361     if (!ptr) return 0;
 362
 363     switch(ptr->wMagic)
 364     {
 365       case PEN_MAGIC:
 366           return PEN_GetObject( (PENOBJ *)ptr, count, buffer );
 367       case BRUSH_MAGIC:
 368           return BRUSH_GetObject( (BRUSHOBJ *)ptr, count, buffer );
 369       case BITMAP_MAGIC:
 370           return BITMAP_GetObject( (BITMAPOBJ *)ptr, count, buffer );
 371       case FONT_MAGIC:
 372           return FONT_GetObject( (FONTOBJ *)ptr, count, buffer );
 373       case PALETTE_MAGIC:
 374           return PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
 375     }
 376     return 0;
 377 }
 378
 379
 380 /***********************************************************************
 381  *           SelectObject    (GDI.45)
 382  */
 383 HANDLE SelectObject( HDC hdc, HANDLE handle )
 384 {
 385     GDIOBJHDR * ptr = NULL;
 386     DC * dc;
 387
 388     dprintf_gdi(stddeb, "SelectObject: %d %04x\n", hdc, handle );
 389     if (handle >= FIRST_STOCK_HANDLE)
 390     {
 391         if (handle < FIRST_STOCK_HANDLE + NB_STOCK_OBJECTS)
 392             ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 393     }
 394     else ptr = (GDIOBJHDR *) GDI_HEAP_ADDR( handle );
 395     if (!ptr) return 0;
 396
 397     dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 398     if (!dc)
 399     {
 400         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 401         if (!dc) return 0;
 402     }
 403
 404     switch(ptr->wMagic)
 405     {
 406       case PEN_MAGIC:
 407           return PEN_SelectObject( dc, handle, (PENOBJ *)ptr );
 408       case BRUSH_MAGIC:
 409           return BRUSH_SelectObject( hdc, dc, handle, (BRUSHOBJ *)ptr );
 410       case BITMAP_MAGIC:
 411           return BITMAP_SelectObject( hdc, dc, handle, (BITMAPOBJ *)ptr );
 412       case FONT_MAGIC:
 413           return FONT_SelectObject( dc, handle, (FONTOBJ *)ptr );
 414       case REGION_MAGIC:
 415           return SelectClipRgn( hdc, handle );
 416     }
 417     return 0;
 418 }
 419
 420
 421 /***********************************************************************
 422  *           UnrealizeObject    (GDI.150)
 423  */
 424 BOOL UnrealizeObject( HANDLE handle )
 425 {
 426     dprintf_gdi(stdnimp, "UnrealizeObject: %04x\n", handle );
 427     return TRUE;
 428 }
 429
 430
 431 /***********************************************************************
 432  *           EnumObjects    (GDI.71)
 433  */
 434 int EnumObjects(HDC hDC, int nObjType, FARPROC lpEnumFunc, LPSTR lpData)
 435 {
 436 /*    HANDLE            handle;
 437     DC                  *dc;*/
 438         HANDLE          *lphObj;
 439         GDIOBJHDR       *header;
 440         WORD            wMagic;
 441         LPSTR           lpLog;          /* Point to a LOGBRUSH or LOGPEN struct */
 442         HANDLE          hLog;
 443         int                     i, nRet;
 444         if (lpEnumFunc == NULL) {
 445                 fprintf(stderr,"EnumObjects // Bad EnumProc callback address !\n");
 446                 return 0;
 447                 }
 448         switch (nObjType) {
 449                 case OBJ_PEN:
 450                         wMagic = PEN_MAGIC;
 451                         dprintf_gdi(stddeb,"EnumObjects(%04X, OBJ_PEN, %p, %p);\n",
 452                                                                         hDC, lpEnumFunc, lpData);
 453                         hLog = GDI_HEAP_ALLOC(GMEM_MOVEABLE, sizeof(LOGPEN));
 454                         lpLog = (LPSTR) GDI_HEAP_ADDR(hLog);
 455                         if (lpLog == NULL) {
 456                                 fprintf(stderr,"EnumObjects // Unable to alloc LOGPEN struct !\n");
 457                                 return 0;
 458                                 }
 459                         break;
 460                 case OBJ_BRUSH:
 461                         wMagic = BRUSH_MAGIC;
 462                         dprintf_gdi(stddeb,"EnumObjects(%04X, OBJ_BRUSH, %p, %p);\n",
 463                                                                         hDC, lpEnumFunc, lpData);
 464                         hLog = GDI_HEAP_ALLOC(GMEM_MOVEABLE, sizeof(LOGBRUSH));
 465                         lpLog = (LPSTR) GDI_HEAP_ADDR(hLog);
 466                         if (lpLog == NULL) {
 467                                 fprintf(stderr,"EnumObjects // Unable to alloc LOGBRUSH struct !\n");
 468                                 return 0;
 469                                 }
 470                         break;
 471                 default:
 472                         fprintf(stderr,"EnumObjects(%04X, %04X, %p, %p); // Unknown OBJ type !\n",
 473                                                 hDC, nObjType, lpEnumFunc, lpData);
 474                         return 0;
 475                 }
 476         dprintf_gdi(stddeb,"EnumObjects // Stock Objects first !\n");
 477         for (i = 0; i < NB_STOCK_OBJECTS; i++) {
 478                 header = StockObjects[i];
 479                 if (header->wMagic == wMagic) {
 480                         PEN_GetObject( (PENOBJ *)header, sizeof(LOGPEN), lpLog);
 481                         BRUSH_GetObject( (BRUSHOBJ *)header, sizeof(LOGBRUSH),lpLog);
 482                         dprintf_gdi(stddeb,"EnumObjects // StockObj lpLog=%p lpData=%p\n", lpLog, lpData);
 483                         if (header->wMagic == BRUSH_MAGIC) {
 484                                 dprintf_gdi(stddeb,"EnumObjects // StockBrush lbStyle=%04X\n", ((LPLOGBRUSH)lpLog)->lbStyle);
 485                                 dprintf_gdi(stddeb,"EnumObjects // StockBrush lbColor=%08lX\n", ((LPLOGBRUSH)lpLog)->lbColor);
 486                                 dprintf_gdi(stddeb,"EnumObjects // StockBrush lbHatch=%04X\n", ((LPLOGBRUSH)lpLog)->lbHatch);
 487                                 }
 488                         if (header->wMagic == PEN_MAGIC) {
 489                                 dprintf_gdi(stddeb,"EnumObjects // StockPen lopnStyle=%04X\n", ((LPLOGPEN)lpLog)->lopnStyle);
 490                                 dprintf_gdi(stddeb,"EnumObjects // StockPen lopnWidth=%d\n", ((LPLOGPEN)lpLog)->lopnWidth.x);
 491                                 dprintf_gdi(stddeb,"EnumObjects // StockPen lopnColor=%08lX\n", ((LPLOGPEN)lpLog)->lopnColor);
 492                                 }
 493                         nRet = 1;
 494 /*
 495 #ifdef WINELIB
 496                         nRet = (*lpEnumFunc)(lpLog, lpData);
 497 #else
 498                         nRet = CallBack16(lpEnumFunc, 4, 2, (int)lpLog, 2, (int)lpData);
 499 #endif
 500 */
 501                         dprintf_gdi(stddeb,"EnumObjects // after CallBack16 !\n");
 502                         if (nRet == 0) {
 503                                 GDI_HEAP_FREE(hLog);
 504                                 dprintf_gdi(stddeb,"EnumObjects // EnumEnd requested by application !\n");
 505                                 return 0;
 506                                 }
 507                         }
 508                 }
 509         if (lpPenBrushList == NULL) return 0;
 510         dprintf_gdi(stddeb,"EnumObjects // Now DC owned objects %p !\n", header);
 511         for (lphObj = lpPenBrushList; *lphObj != 0; ) {
 512                 dprintf_gdi(stddeb,"EnumObjects // *lphObj=%04X\n", *lphObj);
 513                 header = (GDIOBJHDR *) GDI_HEAP_ADDR(*lphObj++);
 514                 if (header->wMagic == wMagic) {
 515                         dprintf_gdi(stddeb,"EnumObjects // DC_Obj lpLog=%p lpData=%p\n", lpLog, lpData);
 516                         if (header->wMagic == BRUSH_MAGIC) {
 517                                 BRUSH_GetObject( (BRUSHOBJ *)header, sizeof(LOGBRUSH), lpLog);
 518                                 dprintf_gdi(stddeb,"EnumObjects // DC_Brush lbStyle=%04X\n", ((LPLOGBRUSH)lpLog)->lbStyle);
 519                                 dprintf_gdi(stddeb,"EnumObjects // DC_Brush lbColor=%08lX\n", ((LPLOGBRUSH)lpLog)->lbColor);
 520                                 dprintf_gdi(stddeb,"EnumObjects // DC_Brush lbHatch=%04X\n", ((LPLOGBRUSH)lpLog)->lbHatch);
 521                                 }
 522                         if (header->wMagic == PEN_MAGIC) {
 523                                 PEN_GetObject( (PENOBJ *)header, sizeof(LOGPEN), lpLog);
 524                                 dprintf_gdi(stddeb,"EnumObjects // DC_Pen lopnStyle=%04X\n", ((LPLOGPEN)lpLog)->lopnStyle);
 525                                 dprintf_gdi(stddeb,"EnumObjects // DC_Pen lopnWidth=%d\n", ((LPLOGPEN)lpLog)->lopnWidth.x);
 526                                 dprintf_gdi(stddeb,"EnumObjects // DC_Pen lopnColor=%08lX\n", ((LPLOGPEN)lpLog)->lopnColor);
 527                                 }
 528 /*
 529 #ifdef WINELIB
 530                         nRet = (*lpEnumFunc)(lpLog, lpData);
 531 #else
 532                         nRet = CallBack16(lpEnumFunc, 4, 2, (int)lpLog, 2, (int)lpData);
 533 #endif
 534 */
 535                         nRet = 1;
 536                         dprintf_gdi(stddeb,"EnumObjects // after CallBack16 !\n");
 537                         if (nRet == 0) {
 538                                 GDI_HEAP_FREE(hLog);
 539                                 dprintf_gdi(stddeb,"EnumObjects // EnumEnd requested by application !\n");
 540                                 return 0;
 541                                 }
 542                         }
 543                 }
 544         GDI_HEAP_FREE(hLog);
 545         dprintf_gdi(stddeb,"EnumObjects // End of enumeration !\n");
 546         return 0;
 547 }
 548
 549 /***********************************************************************
 550  *              IsGDIObject(GDI.462)
 551  */
 552 BOOL IsGDIObject(HANDLE handle)
 553 {
 554         GDIOBJHDR *object;
 555
 556         object = (GDIOBJHDR *) GDI_HEAP_ADDR( handle );
 557         if (object)
 558                 return TRUE;
 559         else
 560                 return FALSE;
 561 }