objects/gdiobj.c

   1 /*
   2  * GDI functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  */
   6
   7 #include <stdlib.h>
   8 #include <stdio.h>
   9 #include "color.h"
  10 #include "bitmap.h"
  11 #include "brush.h"
  12 #include "dc.h"
  13 #include "font.h"
  14 #include "heap.h"
  15 #include "palette.h"
  16 #include "pen.h"
  17 #include "region.h"
  18 #include "stddebug.h"
  19 #include "debug.h"
  20
  21 WORD GDI_HeapSel = 0;
  22
  23 /* Object types for EnumObjects() */
  24 #define OBJ_PEN             1
  25 #define OBJ_BRUSH           2
  26
  27 /***********************************************************************
  28  *          GDI stock objects
  29  */
  30
  31 static BRUSHOBJ WhiteBrush =
  32 {
  33     { 0, BRUSH_MAGIC, 1 },             /* header */
  34     { BS_SOLID, RGB(255,255,255), 0 }  /* logbrush */
  35 };
  36
  37 static BRUSHOBJ LtGrayBrush =
  38 {
  39     { 0, BRUSH_MAGIC, 1 },             /* header */
  40 /* FIXME : this should perhaps be BS_HATCHED, at least for 1 bitperpixel */
  41     { BS_SOLID, RGB(192,192,192), 0 }  /* logbrush */
  42 };
  43
  44 static BRUSHOBJ GrayBrush =
  45 {
  46     { 0, BRUSH_MAGIC, 1 },             /* header */
  47 /* FIXME : this should perhaps be BS_HATCHED, at least for 1 bitperpixel */
  48     { BS_SOLID, RGB(128,128,128), 0 }  /* logbrush */
  49 };
  50
  51 static BRUSHOBJ DkGrayBrush =
  52 {
  53     { 0, BRUSH_MAGIC, 1 },          /* header */
  54 /* This is BS_HATCHED, for 1 bitperpixel. This makes the spray work in pbrush */
  55 /* NB_HATCH_STYLES is an index into HatchBrushes */
  56     { BS_HATCHED, RGB(0,0,0), NB_HATCH_STYLES }  /* logbrush */
  57 };
  58
  59 static BRUSHOBJ BlackBrush =
  60 {
  61     { 0, BRUSH_MAGIC, 1 },       /* header */
  62     { BS_SOLID, RGB(0,0,0), 0 }  /* logbrush */
  63 };
  64
  65 static BRUSHOBJ NullBrush =
  66 {
  67     { 0, BRUSH_MAGIC, 1 },  /* header */
  68     { BS_NULL, 0, 0 }       /* logbrush */
  69 };
  70
  71 static PENOBJ WhitePen =
  72 {
  73     { 0, PEN_MAGIC, 1 },                     /* header */
  74     { PS_SOLID, { 1, 0 }, RGB(255,255,255) } /* logpen */
  75 };
  76
  77 static PENOBJ BlackPen =
  78 {
  79     { 0, PEN_MAGIC, 1 },               /* header */
  80     { PS_SOLID, { 1, 0 }, RGB(0,0,0) } /* logpen */
  81 };
  82
  83 static PENOBJ NullPen =
  84 {
  85     { 0, PEN_MAGIC, 1 },      /* header */
  86     { PS_NULL, { 1, 0 }, 0 }  /* logpen */
  87 };
  88
  89 static FONTOBJ OEMFixedFont =
  90 {
  91     { 0, FONT_MAGIC, 1 },   /* header */
  92     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, OEM_CHARSET,
  93       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
  94 };
  95
  96 static FONTOBJ AnsiFixedFont =
  97 {
  98     { 0, FONT_MAGIC, 1 },   /* header */
  99     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 100       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
 101 };
 102
 103 static FONTOBJ AnsiVarFont =
 104 {
 105     { 0, FONT_MAGIC, 1 },   /* header */
 106     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 107       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "MS Sans Serif" }
 108 };
 109
 110 static FONTOBJ SystemFont =
 111 {
 112     { 0, FONT_MAGIC, 1 },
 113     { 16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ANSI_CHARSET,
 114       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "System" }
 115 };
 116
 117 static FONTOBJ DeviceDefaultFont =
 118 {
 119     { 0, FONT_MAGIC, 1 },   /* header */
 120     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 121       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
 122 };
 123
 124 static FONTOBJ SystemFixedFont =
 125 {
 126     { 0, FONT_MAGIC, 1 },   /* header */
 127     { 12, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ANSI_CHARSET,
 128       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
 129 };
 130
 131
 132 static GDIOBJHDR * StockObjects[NB_STOCK_OBJECTS] =
 133 {
 134     (GDIOBJHDR *) &WhiteBrush,
 135     (GDIOBJHDR *) &LtGrayBrush,
 136     (GDIOBJHDR *) &GrayBrush,
 137     (GDIOBJHDR *) &DkGrayBrush,
 138     (GDIOBJHDR *) &BlackBrush,
 139     (GDIOBJHDR *) &NullBrush,
 140     (GDIOBJHDR *) &WhitePen,
 141     (GDIOBJHDR *) &BlackPen,
 142     (GDIOBJHDR *) &NullPen,
 143     NULL,
 144     (GDIOBJHDR *) &OEMFixedFont,
 145     (GDIOBJHDR *) &AnsiFixedFont,
 146     (GDIOBJHDR *) &AnsiVarFont,
 147     (GDIOBJHDR *) &SystemFont,
 148     (GDIOBJHDR *) &DeviceDefaultFont,
 149     NULL,            /* DEFAULT_PALETTE created by PALETTE_Init */
 150     (GDIOBJHDR *) &SystemFixedFont
 151 };
 152
 153
 154 /***********************************************************************
 155  *           GDI_Init
 156  *
 157  * GDI initialization.
 158  */
 159 BOOL32 GDI_Init(void)
 160 {
 161     extern BOOL32 X11DRV_Init(void);
 162     extern BOOL32 DIB_Init(void);
 163
 164     /* Initialize drivers */
 165
 166     DIB_Init(); /* always before X11DRV_Init() */
 167
 168     if( X11DRV_Init() )
 169     {
 170         /* Create default palette */
 171
 172         HPALETTE16 hpalette = PALETTE_Init();
 173
 174         if( hpalette )
 175         {
 176             StockObjects[DEFAULT_PALETTE] = (GDIOBJHDR *)GDI_HEAP_LIN_ADDR( hpalette );
 177             return TRUE;
 178         }
 179     }
 180     return FALSE;
 181 }
 182
 183
 184 /***********************************************************************
 185  *           GDI_AllocObject
 186  */
 187 HGDIOBJ16 GDI_AllocObject( WORD size, WORD magic )
 188 {
 189     static DWORD count = 0;
 190     GDIOBJHDR * obj;
 191     HGDIOBJ16 handle = GDI_HEAP_ALLOC( size );
 192     if (!handle) return 0;
 193     obj = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 194     obj->hNext   = 0;
 195     obj->wMagic  = magic;
 196     obj->dwCount = ++count;
 197     return handle;
 198 }
 199
 200
 201 /***********************************************************************
 202  *           GDI_FreeObject
 203  */
 204 BOOL32 GDI_FreeObject( HGDIOBJ16 handle )
 205 {
 206     GDIOBJHDR * object;
 207
 208       /* Can't free stock objects */
 209     if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
 210         return TRUE;
 211
 212     object = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 213     if (!object) return FALSE;
 214     object->wMagic = 0;  /* Mark it as invalid */
 215
 216       /* Free object */
 217
 218     GDI_HEAP_FREE( handle );
 219     return TRUE;
 220 }
 221
 222 /***********************************************************************
 223  *           GDI_GetObjPtr
 224  *
 225  * Return a pointer to the GDI object associated to the handle.
 226  * Return NULL if the object has the wrong magic number.
 227  */
 228 GDIOBJHDR * GDI_GetObjPtr( HGDIOBJ16 handle, WORD magic )
 229 {
 230     GDIOBJHDR * ptr = NULL;
 231
 232     if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
 233       ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 234     else
 235       ptr = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 236     if (!ptr) return NULL;
 237     if ((magic != MAGIC_DONTCARE) && (ptr->wMagic != magic)) return NULL;
 238     return ptr;
 239 }
 240
 241
 242 /***********************************************************************
 243  *           DeleteObject16    (GDI.69)
 244  */
 245 BOOL16 DeleteObject16( HGDIOBJ16 obj )
 246 {
 247     return DeleteObject32( obj );
 248 }
 249
 250
 251 /***********************************************************************
 252  *           DeleteObject32    (GDI32.70)
 253  */
 254 BOOL32 DeleteObject32( HGDIOBJ32 obj )
 255 {
 256       /* Check if object is valid */
 257
 258     GDIOBJHDR * header = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( obj );
 259     if (!header || HIWORD(obj)) return FALSE;
 260
 261     dprintf_gdi(stddeb, "DeleteObject: %04x\n", obj );
 262
 263       /* Delete object */
 264
 265     switch(header->wMagic)
 266     {
 267       case PEN_MAGIC:     return GDI_FreeObject( obj );
 268       case BRUSH_MAGIC:   return BRUSH_DeleteObject( obj, (BRUSHOBJ*)header );
 269       case FONT_MAGIC:    return GDI_FreeObject( obj );
 270       case PALETTE_MAGIC: return PALETTE_DeleteObject(obj,(PALETTEOBJ*)header);
 271       case BITMAP_MAGIC:  return BITMAP_DeleteObject( obj, (BITMAPOBJ*)header);
 272       case REGION_MAGIC:  return REGION_DeleteObject( obj, (RGNOBJ*)header );
 273     }
 274     return FALSE;
 275 }
 276
 277
 278 /***********************************************************************
 279  *           GetStockObject16    (GDI.87)
 280  */
 281 HGDIOBJ16 GetStockObject16( INT16 obj )
 282 {
 283     return (HGDIOBJ16)GetStockObject32( obj );
 284 }
 285
 286
 287 /***********************************************************************
 288  *           GetStockObject32    (GDI32.220)
 289  */
 290 HGDIOBJ32 GetStockObject32( INT32 obj )
 291 {
 292     if ((obj < 0) || (obj >= NB_STOCK_OBJECTS)) return 0;
 293     if (!StockObjects[obj]) return 0;
 294     dprintf_gdi(stddeb, "GetStockObject: returning %d\n",
 295                 FIRST_STOCK_HANDLE + obj );
 296     return (HGDIOBJ16)(FIRST_STOCK_HANDLE + obj);
 297 }
 298
 299
 300 /***********************************************************************
 301  *           GetObject16    (GDI.82)
 302  */
 303 INT16 GetObject16( HANDLE16 handle, INT16 count, LPVOID buffer )
 304 {
 305     GDIOBJHDR * ptr = NULL;
 306     dprintf_gdi(stddeb, "GetObject16: %04x %d %p\n", handle, count, buffer );
 307     if (!count) return 0;
 308
 309     if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
 310       ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 311     else
 312       ptr = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 313     if (!ptr) return 0;
 314
 315     switch(ptr->wMagic)
 316     {
 317       case PEN_MAGIC:
 318           return PEN_GetObject16( (PENOBJ *)ptr, count, buffer );
 319       case BRUSH_MAGIC:
 320           return BRUSH_GetObject16( (BRUSHOBJ *)ptr, count, buffer );
 321       case BITMAP_MAGIC:
 322           return BITMAP_GetObject16( (BITMAPOBJ *)ptr, count, buffer );
 323       case FONT_MAGIC:
 324           return FONT_GetObject16( (FONTOBJ *)ptr, count, buffer );
 325       case PALETTE_MAGIC:
 326           return PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
 327     }
 328     return 0;
 329 }
 330
 331
 332 /***********************************************************************
 333  *           GetObject32A    (GDI32.204)
 334  */
 335 INT32 GetObject32A( HANDLE32 handle, INT32 count, LPVOID buffer )
 336 {
 337     GDIOBJHDR * ptr = NULL;
 338     dprintf_gdi(stddeb, "GetObject32A: %08x %d %p\n", handle, count, buffer );
 339     if (!count) return 0;
 340
 341     if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
 342       ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 343     else
 344       ptr = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 345     if (!ptr) return 0;
 346
 347     switch(ptr->wMagic)
 348     {
 349       case PEN_MAGIC:
 350           return PEN_GetObject32( (PENOBJ *)ptr, count, buffer );
 351       case BRUSH_MAGIC:
 352           return BRUSH_GetObject32( (BRUSHOBJ *)ptr, count, buffer );
 353       case BITMAP_MAGIC:
 354           return BITMAP_GetObject32( (BITMAPOBJ *)ptr, count, buffer );
 355       case FONT_MAGIC:
 356           return FONT_GetObject32A( (FONTOBJ *)ptr, count, buffer );
 357       case PALETTE_MAGIC:
 358           fprintf( stderr, "GetObject32: magic %04x not implemented\n",
 359                    ptr->wMagic );
 360           break;
 361     }
 362     return 0;
 363 }
 364
 365
 366 /***********************************************************************
 367  *           GetObject32W    (GDI32.206)
 368  */
 369 INT32 GetObject32W( HANDLE32 handle, INT32 count, LPVOID buffer )
 370 {
 371     return GetObject32A( handle, count, buffer );
 372 }
 373
 374
 375 /***********************************************************************
 376  *           SelectObject16    (GDI.45)
 377  */
 378 HGDIOBJ16 SelectObject16( HDC16 hdc, HGDIOBJ16 handle )
 379 {
 380     return (HGDIOBJ16)SelectObject32( hdc, handle );
 381 }
 382
 383
 384 /***********************************************************************
 385  *           SelectObject32    (GDI32.299)
 386  */
 387 HGDIOBJ32 SelectObject32( HDC32 hdc, HGDIOBJ32 handle )
 388 {
 389     DC * dc = DC_GetDCPtr( hdc );
 390     if (!dc || !dc->funcs->pSelectObject) return 0;
 391     dprintf_gdi(stddeb, "SelectObject: hdc=%04x %04x\n", hdc, handle );
 392     return dc->funcs->pSelectObject( dc, handle );
 393 }
 394
 395
 396 /***********************************************************************
 397  *           UnrealizeObject16    (GDI.150)
 398  */
 399 BOOL16 UnrealizeObject16( HGDIOBJ16 obj )
 400 {
 401     return UnrealizeObject32( obj );
 402 }
 403
 404
 405 /***********************************************************************
 406  *           UnrealizeObject    (GDI32.358)
 407  */
 408 BOOL32 UnrealizeObject32( HGDIOBJ32 obj )
 409 {
 410       /* Check if object is valid */
 411
 412     GDIOBJHDR * header = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( obj );
 413     if (!header) return FALSE;
 414
 415     dprintf_gdi( stddeb, "UnrealizeObject: %04x\n", obj );
 416
 417       /* Unrealize object */
 418
 419     switch(header->wMagic)
 420     {
 421     case PALETTE_MAGIC:
 422         return PALETTE_UnrealizeObject( obj, (PALETTEOBJ *)header );
 423
 424     case BRUSH_MAGIC:
 425         /* Windows resets the brush origin. We don't need to. */
 426         break;
 427     }
 428     return TRUE;
 429 }
 430
 431
 432 /***********************************************************************
 433  *           EnumObjects16    (GDI.71)
 434  */
 435 INT16 EnumObjects16( HDC16 hdc, INT16 nObjType, GOBJENUMPROC16 lpEnumFunc,
 436                      LPARAM lParam )
 437 {
 438     /* Solid colors to enumerate */
 439     static const COLORREF solid_colors[] =
 440     { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
 441       RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
 442       RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
 443       RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
 444       RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
 445       RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
 446       RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
 447       RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
 448     };
 449
 450     INT16 i, retval = 0;
 451     LOGPEN16 *pen;
 452     LOGBRUSH16 *brush = NULL;
 453
 454     dprintf_gdi( stddeb, "EnumObjects16: %04x %d %08lx %08lx\n",
 455                  hdc, nObjType, (DWORD)lpEnumFunc, lParam );
 456     switch(nObjType)
 457     {
 458     case OBJ_PEN:
 459         /* Enumerate solid pens */
 460         if (!(pen = SEGPTR_NEW(LOGPEN16))) break;
 461         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 462         {
 463             pen->lopnStyle   = PS_SOLID;
 464             pen->lopnWidth.x = 1;
 465             pen->lopnWidth.y = 0;
 466             pen->lopnColor   = solid_colors[i];
 467             retval = lpEnumFunc( SEGPTR_GET(pen), lParam );
 468             dprintf_gdi( stddeb, "EnumObjects16: solid pen %08lx, ret=%d\n",
 469                          solid_colors[i], retval);
 470             if (!retval) break;
 471         }
 472         SEGPTR_FREE(pen);
 473         break;
 474
 475     case OBJ_BRUSH:
 476         /* Enumerate solid brushes */
 477         if (!(brush = SEGPTR_NEW(LOGBRUSH16))) break;
 478         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 479         {
 480             brush->lbStyle = BS_SOLID;
 481             brush->lbColor = solid_colors[i];
 482             brush->lbHatch = 0;
 483             retval = lpEnumFunc( SEGPTR_GET(brush), lParam );
 484             dprintf_gdi( stddeb, "EnumObjects16: solid brush %08lx, ret=%d\n",
 485                          solid_colors[i], retval);
 486             if (!retval) break;
 487         }
 488
 489         /* Now enumerate hatched brushes */
 490         if (retval) for (i = HS_HORIZONTAL; i <= HS_DIAGCROSS; i++)
 491         {
 492             brush->lbStyle = BS_HATCHED;
 493             brush->lbColor = RGB(0,0,0);
 494             brush->lbHatch = i;
 495             retval = lpEnumFunc( SEGPTR_GET(brush), lParam );
 496             dprintf_gdi( stddeb, "EnumObjects16: hatched brush %d, ret=%d\n",
 497                          i, retval);
 498             if (!retval) break;
 499         }
 500         SEGPTR_FREE(brush);
 501         break;
 502
 503     default:
 504         fprintf( stderr, "EnumObjects16: invalid type %d\n", nObjType );
 505         break;
 506     }
 507     return retval;
 508 }
 509
 510
 511 /***********************************************************************
 512  *           EnumObjects32    (GDI32.89)
 513  */
 514 INT32 EnumObjects32( HDC32 hdc, INT32 nObjType, GOBJENUMPROC32 lpEnumFunc,
 515                      LPARAM lParam )
 516 {
 517     /* Solid colors to enumerate */
 518     static const COLORREF solid_colors[] =
 519     { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
 520       RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
 521       RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
 522       RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
 523       RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
 524       RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
 525       RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
 526       RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
 527     };
 528
 529     INT32 i, retval = 0;
 530     LOGPEN32 pen;
 531     LOGBRUSH32 brush;
 532
 533     dprintf_gdi( stddeb, "EnumObjects32: %04x %d %08lx %08lx\n",
 534                  hdc, nObjType, (DWORD)lpEnumFunc, lParam );
 535     switch(nObjType)
 536     {
 537     case OBJ_PEN:
 538         /* Enumerate solid pens */
 539         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 540         {
 541             pen.lopnStyle   = PS_SOLID;
 542             pen.lopnWidth.x = 1;
 543             pen.lopnWidth.y = 0;
 544             pen.lopnColor   = solid_colors[i];
 545             retval = lpEnumFunc( &pen, lParam );
 546             dprintf_gdi( stddeb, "EnumObjects32: solid pen %08lx, ret=%d\n",
 547                          solid_colors[i], retval);
 548             if (!retval) break;
 549         }
 550         break;
 551
 552     case OBJ_BRUSH:
 553         /* Enumerate solid brushes */
 554         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 555         {
 556             brush.lbStyle = BS_SOLID;
 557             brush.lbColor = solid_colors[i];
 558             brush.lbHatch = 0;
 559             retval = lpEnumFunc( &brush, lParam );
 560             dprintf_gdi( stddeb, "EnumObjects32: solid brush %08lx, ret=%d\n",
 561                          solid_colors[i], retval);
 562             if (!retval) break;
 563         }
 564
 565         /* Now enumerate hatched brushes */
 566         if (retval) for (i = HS_HORIZONTAL; i <= HS_DIAGCROSS; i++)
 567         {
 568             brush.lbStyle = BS_HATCHED;
 569             brush.lbColor = RGB(0,0,0);
 570             brush.lbHatch = i;
 571             retval = lpEnumFunc( &brush, lParam );
 572             dprintf_gdi( stddeb, "EnumObjects32: hatched brush %d, ret=%d\n",
 573                          i, retval);
 574             if (!retval) break;
 575         }
 576         break;
 577
 578     default:
 579         /* FIXME: implement Win32 types */
 580         fprintf( stderr, "EnumObjects32: invalid type %d\n", nObjType );
 581         break;
 582     }
 583     return retval;
 584 }
 585
 586
 587 /***********************************************************************
 588  *           IsGDIObject    (GDI.462)
 589  */
 590 BOOL16 IsGDIObject( HGDIOBJ16 handle )
 591 {
 592     GDIOBJHDR *object = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 593     if (object)
 594       return (object->wMagic>=PEN_MAGIC && object->wMagic<= METAFILE_DC_MAGIC);
 595     return FALSE;
 596 }
 597
 598
 599 /***********************************************************************
 600  *           MulDiv16   (GDI.128)
 601  */
 602 INT16 MulDiv16( INT16 foo, INT16 bar, INT16 baz )
 603 {
 604     INT32 ret;
 605     if (!baz) return -32768;
 606     ret = (foo * bar) / baz;
 607     if ((ret > 32767) || (ret < -32767)) return -32768;
 608     return ret;
 609 }
 610
 611
 612 /***********************************************************************
 613  *           MulDiv32   (KERNEL32.391)
 614  */
 615 INT32 MulDiv32( INT32 foo, INT32 bar, INT32 baz )
 616 {
 617 #ifdef __GNUC__
 618     long long ret;
 619     if (!baz) return -1;
 620     ret = ((long long)foo * bar) / baz;
 621     if ((ret > 2147483647) || (ret < -2147483647)) return -1;
 622     return ret;
 623 #else
 624     if (!baz) return -1;
 625     return (foo * bar) / baz;
 626 #endif
 627 }