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 "gdi.h"
  12 #include "color.h"
  13 #include "bitmap.h"
  14 #include "brush.h"
  15 #include "font.h"
  16 #include "palette.h"
  17 #include "pen.h"
  18 #include "region.h"
  19 #include "stddebug.h"
  20 /* #define DEBUG_GDI */
  21 #include "debug.h"
  22
  23 LPSTR GDI_Heap = NULL;
  24 WORD GDI_HeapSel = 0;
  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
 166 #ifndef WINELIB
 167       /* Create GDI heap */
 168
 169     if (!(GDI_HeapSel = GlobalAlloc(GMEM_FIXED, GDI_HEAP_SIZE))) return FALSE;
 170     GDI_Heap = GlobalLock( GDI_HeapSel );
 171     LocalInit( GDI_HeapSel, 0, GDI_HEAP_SIZE-1 );
 172 #endif
 173
 174       /* Create default palette */
 175
 176     if (!(hpalette = COLOR_Init())) return FALSE;
 177     StockObjects[DEFAULT_PALETTE] = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( hpalette );
 178
 179       /* Create default bitmap */
 180
 181     if (!BITMAP_Init()) return FALSE;
 182
 183       /* Initialise brush dithering */
 184
 185     if (!BRUSH_Init()) return FALSE;
 186
 187       /* Initialise fonts */
 188
 189     if (!FONT_Init()) return FALSE;
 190
 191     return TRUE;
 192 }
 193
 194
 195 /***********************************************************************
 196  *           GDI_AppendToPenBrushList
 197  */
 198 BOOL GDI_AppendToPenBrushList(HANDLE hNewObj)
 199 {
 200         HANDLE          *lphObj;
 201         int                     i = 1;
 202         if (hNewObj == 0) return FALSE;
 203         if (lpPenBrushList == NULL) {
 204                 lpPenBrushList = malloc(MAX_OBJ * sizeof(HANDLE));
 205                 lpPenBrushList[0] = 0;
 206                 dprintf_gdi(stddeb,"GDI_AppendToPenBrushList() lpPenBrushList allocated !\n");
 207                 }
 208         for (lphObj = lpPenBrushList; i < MAX_OBJ; i++) {
 209                 if (*lphObj == 0) {
 210                         *lphObj = hNewObj;
 211                         *(lphObj + 1) = 0;
 212                         dprintf_gdi(stddeb,"GDI_AppendToPenBrushList(%04X) appended (count=%d)\n", hNewObj, i);
 213                         return TRUE;
 214                         }
 215                 lphObj++;
 216                 }
 217         return FALSE;
 218 }
 219
 220
 221 /***********************************************************************
 222  *           GDI_FindPrevObject
 223  *
 224  * Return the GDI object whose hNext field points to obj.
 225  */
 226 HANDLE GDI_FindPrevObject( HANDLE first, HANDLE obj )
 227 {
 228     HANDLE handle;
 229
 230     for (handle = first; handle && (handle != obj); )
 231     {
 232         GDIOBJHDR * header = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 233         handle = header->hNext;
 234     }
 235     return handle;
 236 }
 237
 238
 239 /***********************************************************************
 240  *           GDI_AllocObject
 241  */
 242 HANDLE GDI_AllocObject( WORD size, WORD magic )
 243 {
 244     static DWORD count = 0;
 245     GDIOBJHDR * obj;
 246     HANDLE handle = GDI_HEAP_ALLOC( size );
 247     if (!handle) return 0;
 248     obj = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 249     obj->hNext   = 0;
 250     obj->wMagic  = magic;
 251     obj->dwCount = ++count;
 252         if (magic == PEN_MAGIC || magic == BRUSH_MAGIC) {
 253                 GDI_AppendToPenBrushList(handle);
 254                 }
 255     return handle;
 256 }
 257
 258
 259 /***********************************************************************
 260  *           GDI_FreeObject
 261  */
 262 BOOL GDI_FreeObject( HANDLE handle )
 263 {
 264     GDIOBJHDR * object;
 265
 266       /* Can't free stock objects */
 267     if (handle >= FIRST_STOCK_HANDLE) return TRUE;
 268
 269     object = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 270     if (!object) return FALSE;
 271     object->wMagic = 0;  /* Mark it as invalid */
 272
 273       /* Free object */
 274
 275     GDI_HEAP_FREE( handle );
 276     return TRUE;
 277 }
 278
 279 /***********************************************************************
 280  *           GDI_GetObjPtr
 281  *
 282  * Return a pointer to the GDI object associated to the handle.
 283  * Return NULL if the object has the wrong magic number.
 284  */
 285 GDIOBJHDR * GDI_GetObjPtr( HANDLE handle, WORD magic )
 286 {
 287     GDIOBJHDR * ptr = NULL;
 288
 289     if (handle >= FIRST_STOCK_HANDLE)
 290     {
 291         if (handle < FIRST_STOCK_HANDLE + NB_STOCK_OBJECTS)
 292             ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 293     }
 294     else ptr = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 295     if (!ptr) return NULL;
 296     if (ptr->wMagic != magic) return NULL;
 297     return ptr;
 298 }
 299
 300
 301 /***********************************************************************
 302  *           DeleteObject    (GDI.69)
 303  */
 304 BOOL DeleteObject( HANDLE obj )
 305 {
 306       /* Check if object is valid */
 307
 308     GDIOBJHDR * header = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( obj );
 309     if (!header) return FALSE;
 310
 311     dprintf_gdi(stddeb, "DeleteObject: %d\n", obj );
 312
 313       /* Delete object */
 314
 315     switch(header->wMagic)
 316     {
 317       case PEN_MAGIC:     return GDI_FreeObject( obj );
 318       case BRUSH_MAGIC:   return BRUSH_DeleteObject( obj, (BRUSHOBJ*)header );
 319       case FONT_MAGIC:    return GDI_FreeObject( obj );
 320       case PALETTE_MAGIC: return GDI_FreeObject( obj );
 321       case BITMAP_MAGIC:  return BITMAP_DeleteObject( obj, (BITMAPOBJ*)header);
 322       case REGION_MAGIC:  return REGION_DeleteObject( obj, (RGNOBJ*)header );
 323     }
 324     return FALSE;
 325 }
 326
 327
 328 /***********************************************************************
 329  *           GetStockObject    (GDI.87)
 330  */
 331 HANDLE GetStockObject( int obj )
 332 {
 333     if ((obj < 0) || (obj >= NB_STOCK_OBJECTS)) return 0;
 334     if (!StockObjects[obj]) return 0;
 335     dprintf_gdi(stddeb, "GetStockObject: returning %04x\n",
 336                 FIRST_STOCK_HANDLE + obj );
 337     return FIRST_STOCK_HANDLE + obj;
 338 }
 339
 340
 341 /***********************************************************************
 342  *           GetObject    (GDI.82)
 343  */
 344 int GetObject( HANDLE handle, int count, LPSTR buffer )
 345 {
 346     GDIOBJHDR * ptr = NULL;
 347     dprintf_gdi(stddeb, "GetObject: %04x %d %p\n", handle, count, buffer );
 348     if (!count) return 0;
 349
 350     if (handle >= FIRST_STOCK_HANDLE)
 351     {
 352         if (handle < FIRST_STOCK_HANDLE + NB_STOCK_OBJECTS)
 353             ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 354     }
 355     else ptr = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 356     if (!ptr) return 0;
 357
 358     switch(ptr->wMagic)
 359     {
 360       case PEN_MAGIC:
 361           return PEN_GetObject( (PENOBJ *)ptr, count, buffer );
 362       case BRUSH_MAGIC:
 363           return BRUSH_GetObject( (BRUSHOBJ *)ptr, count, buffer );
 364       case BITMAP_MAGIC:
 365           return BITMAP_GetObject( (BITMAPOBJ *)ptr, count, buffer );
 366       case FONT_MAGIC:
 367           return FONT_GetObject( (FONTOBJ *)ptr, count, buffer );
 368       case PALETTE_MAGIC:
 369           return PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
 370     }
 371     return 0;
 372 }
 373
 374
 375 /***********************************************************************
 376  *           SelectObject    (GDI.45)
 377  */
 378 HANDLE SelectObject( HDC hdc, HANDLE handle )
 379 {
 380     GDIOBJHDR * ptr = NULL;
 381     DC * dc;
 382
 383     dprintf_gdi(stddeb, "SelectObject: %d %04x\n", hdc, handle );
 384     if (handle >= FIRST_STOCK_HANDLE)
 385     {
 386         if (handle < FIRST_STOCK_HANDLE + NB_STOCK_OBJECTS)
 387             ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 388     }
 389     else ptr = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 390     if (!ptr) return 0;
 391
 392     dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 393     if (!dc)
 394     {
 395         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 396         if (!dc) return 0;
 397     }
 398
 399     switch(ptr->wMagic)
 400     {
 401       case PEN_MAGIC:
 402           return PEN_SelectObject( dc, handle, (PENOBJ *)ptr );
 403       case BRUSH_MAGIC:
 404           return BRUSH_SelectObject( hdc, dc, handle, (BRUSHOBJ *)ptr );
 405       case BITMAP_MAGIC:
 406           return BITMAP_SelectObject( hdc, dc, handle, (BITMAPOBJ *)ptr );
 407       case FONT_MAGIC:
 408           return FONT_SelectObject( dc, handle, (FONTOBJ *)ptr );
 409       case REGION_MAGIC:
 410           return SelectClipRgn( hdc, handle );
 411     }
 412     return 0;
 413 }
 414
 415
 416 /***********************************************************************
 417  *           UnrealizeObject    (GDI.150)
 418  */
 419 BOOL UnrealizeObject( HANDLE handle )
 420 {
 421     dprintf_gdi(stdnimp, "UnrealizeObject: %04x\n", handle );
 422     return TRUE;
 423 }
 424
 425
 426 /***********************************************************************
 427  *           EnumObjects    (GDI.71)
 428  */
 429 int EnumObjects(HDC hDC, int nObjType, FARPROC lpEnumFunc, LPSTR lpData)
 430 {
 431 /*    HANDLE            handle;
 432     DC                  *dc;*/
 433         HANDLE          *lphObj;
 434         GDIOBJHDR       *header;
 435         WORD            wMagic;
 436         LPSTR           lpLog;          /* Point to a LOGBRUSH or LOGPEN struct */
 437         HANDLE          hLog;
 438         int                     i, nRet;
 439         if (lpEnumFunc == NULL) {
 440                 fprintf(stderr,"EnumObjects // Bad EnumProc callback address !\n");
 441                 return 0;
 442                 }
 443         switch (nObjType) {
 444                 case OBJ_PEN:
 445                         wMagic = PEN_MAGIC;
 446                         dprintf_gdi(stddeb,"EnumObjects(%04X, OBJ_PEN, %p, %p);\n",
 447                                                                         hDC, lpEnumFunc, lpData);
 448                         hLog = GDI_HEAP_ALLOC( sizeof(LOGPEN) );
 449                         lpLog = (LPSTR) GDI_HEAP_LIN_ADDR(hLog);
 450                         if (lpLog == NULL) {
 451                                 fprintf(stderr,"EnumObjects // Unable to alloc LOGPEN struct !\n");
 452                                 return 0;
 453                                 }
 454                         break;
 455                 case OBJ_BRUSH:
 456                         wMagic = BRUSH_MAGIC;
 457                         dprintf_gdi(stddeb,"EnumObjects(%04X, OBJ_BRUSH, %p, %p);\n",
 458                                                                         hDC, lpEnumFunc, lpData);
 459                         hLog = GDI_HEAP_ALLOC( sizeof(LOGBRUSH) );
 460                         lpLog = (LPSTR) GDI_HEAP_LIN_ADDR(hLog);
 461                         if (lpLog == NULL) {
 462                                 fprintf(stderr,"EnumObjects // Unable to alloc LOGBRUSH struct !\n");
 463                                 return 0;
 464                                 }
 465                         break;
 466                 default:
 467                         fprintf(stderr,"EnumObjects(%04X, %04X, %p, %p); // Unknown OBJ type !\n",
 468                                                 hDC, nObjType, lpEnumFunc, lpData);
 469                         return 0;
 470                 }
 471 #ifdef notdef  /* FIXME: stock object ptr won't work in callback */
 472         dprintf_gdi(stddeb,"EnumObjects // Stock Objects first !\n");
 473         for (i = 0; i < NB_STOCK_OBJECTS; i++) {
 474                 header = StockObjects[i];
 475                 if (header->wMagic == wMagic) {
 476                         PEN_GetObject( (PENOBJ *)header, sizeof(LOGPEN), lpLog);
 477                         BRUSH_GetObject( (BRUSHOBJ *)header, sizeof(LOGBRUSH),lpLog);
 478                         dprintf_gdi(stddeb,"EnumObjects // StockObj lpLog=%p lpData=%p\n", lpLog, lpData);
 479                         if (header->wMagic == BRUSH_MAGIC) {
 480                                 dprintf_gdi(stddeb,"EnumObjects // StockBrush lbStyle=%04X\n", ((LPLOGBRUSH)lpLog)->lbStyle);
 481                                 dprintf_gdi(stddeb,"EnumObjects // StockBrush lbColor=%08lX\n", ((LPLOGBRUSH)lpLog)->lbColor);
 482                                 dprintf_gdi(stddeb,"EnumObjects // StockBrush lbHatch=%04X\n", ((LPLOGBRUSH)lpLog)->lbHatch);
 483                                 }
 484                         if (header->wMagic == PEN_MAGIC) {
 485                                 dprintf_gdi(stddeb,"EnumObjects // StockPen lopnStyle=%04X\n", ((LPLOGPEN)lpLog)->lopnStyle);
 486                                 dprintf_gdi(stddeb,"EnumObjects // StockPen lopnWidth=%d\n", ((LPLOGPEN)lpLog)->lopnWidth.x);
 487                                 dprintf_gdi(stddeb,"EnumObjects // StockPen lopnColor=%08lX\n", ((LPLOGPEN)lpLog)->lopnColor);
 488                                 }
 489                         nRet = 1;
 490 /*
 491 #ifdef WINELIB
 492                         nRet = (*lpEnumFunc)(lpLog, lpData);
 493 #else
 494                         nRet = CallBack16(lpEnumFunc, 4, 2,
 495                                       GDI_HEAP_SEG_ADDR(hLog), 2, (int)lpData);
 496 #endif
 497 */
 498                         dprintf_gdi(stddeb,"EnumObjects // after CallBack16 !\n");
 499                         if (nRet == 0) {
 500                                 GDI_HEAP_FREE(hLog);
 501                                 dprintf_gdi(stddeb,"EnumObjects // EnumEnd requested by application !\n");
 502                                 return 0;
 503                                 }
 504                         }
 505                 }
 506 #endif  /* notdef */
 507
 508         if (lpPenBrushList == NULL) return 0;
 509         dprintf_gdi(stddeb,"EnumObjects // Now DC owned objects %p !\n", header);
 510         for (lphObj = lpPenBrushList; *lphObj != 0; ) {
 511                 dprintf_gdi(stddeb,"EnumObjects // *lphObj=%04X\n", *lphObj);
 512                 header = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR(*lphObj++);
 513                 if (header->wMagic == wMagic) {
 514                         dprintf_gdi(stddeb,"EnumObjects // DC_Obj lpLog=%p lpData=%p\n", lpLog, lpData);
 515                         if (header->wMagic == BRUSH_MAGIC) {
 516                                 BRUSH_GetObject( (BRUSHOBJ *)header, sizeof(LOGBRUSH), lpLog);
 517                                 dprintf_gdi(stddeb,"EnumObjects // DC_Brush lbStyle=%04X\n", ((LPLOGBRUSH)lpLog)->lbStyle);
 518                                 dprintf_gdi(stddeb,"EnumObjects // DC_Brush lbColor=%08lX\n", ((LPLOGBRUSH)lpLog)->lbColor);
 519                                 dprintf_gdi(stddeb,"EnumObjects // DC_Brush lbHatch=%04X\n", ((LPLOGBRUSH)lpLog)->lbHatch);
 520                                 }
 521                         if (header->wMagic == PEN_MAGIC) {
 522                                 PEN_GetObject( (PENOBJ *)header, sizeof(LOGPEN), lpLog);
 523                                 dprintf_gdi(stddeb,"EnumObjects // DC_Pen lopnStyle=%04X\n", ((LPLOGPEN)lpLog)->lopnStyle);
 524                                 dprintf_gdi(stddeb,"EnumObjects // DC_Pen lopnWidth=%d\n", ((LPLOGPEN)lpLog)->lopnWidth.x);
 525                                 dprintf_gdi(stddeb,"EnumObjects // DC_Pen lopnColor=%08lX\n", ((LPLOGPEN)lpLog)->lopnColor);
 526                                 }
 527 /*
 528 #ifdef WINELIB
 529                         nRet = (*lpEnumFunc)(lpLog, lpData);
 530 #else
 531                         nRet = CallBack16(lpEnumFunc, 4, 2,
 532                                       GDI_HEAP_SEG_ADDR(hLog), 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_LIN_ADDR( handle );
 557         if (object)
 558                 return TRUE;
 559         else
 560                 return FALSE;
 561 }