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 "options.h"
  16 #include "palette.h"
  17 #include "pen.h"
  18 #include "region.h"
  19 #include "stddebug.h"
  20 #include "debug.h"
  21
  22 WORD GDI_HeapSel = 0;
  23
  24 /* Object types for EnumObjects() */
  25 #define OBJ_PEN             1
  26 #define OBJ_BRUSH           2
  27
  28 /***********************************************************************
  29  *          GDI stock objects
  30  */
  31
  32 static BRUSHOBJ WhiteBrush =
  33 {
  34     { 0, BRUSH_MAGIC, 1 },             /* header */
  35     { BS_SOLID, RGB(255,255,255), 0 }  /* logbrush */
  36 };
  37
  38 static BRUSHOBJ LtGrayBrush =
  39 {
  40     { 0, BRUSH_MAGIC, 1 },             /* header */
  41 /* FIXME : this should perhaps be BS_HATCHED, at least for 1 bitperpixel */
  42     { BS_SOLID, RGB(192,192,192), 0 }  /* logbrush */
  43 };
  44
  45 static BRUSHOBJ GrayBrush =
  46 {
  47     { 0, BRUSH_MAGIC, 1 },             /* header */
  48 /* FIXME : this should perhaps be BS_HATCHED, at least for 1 bitperpixel */
  49     { BS_SOLID, RGB(128,128,128), 0 }  /* logbrush */
  50 };
  51
  52 static BRUSHOBJ DkGrayBrush =
  53 {
  54     { 0, BRUSH_MAGIC, 1 },          /* header */
  55 /* This is BS_HATCHED, for 1 bitperpixel. This makes the spray work in pbrush */
  56 /* NB_HATCH_STYLES is an index into HatchBrushes */
  57     { BS_HATCHED, RGB(0,0,0), NB_HATCH_STYLES }  /* logbrush */
  58 };
  59
  60 static BRUSHOBJ BlackBrush =
  61 {
  62     { 0, BRUSH_MAGIC, 1 },       /* header */
  63     { BS_SOLID, RGB(0,0,0), 0 }  /* logbrush */
  64 };
  65
  66 static BRUSHOBJ NullBrush =
  67 {
  68     { 0, BRUSH_MAGIC, 1 },  /* header */
  69     { BS_NULL, 0, 0 }       /* logbrush */
  70 };
  71
  72 static PENOBJ WhitePen =
  73 {
  74     { 0, PEN_MAGIC, 1 },                     /* header */
  75     { PS_SOLID, { 1, 0 }, RGB(255,255,255) } /* logpen */
  76 };
  77
  78 static PENOBJ BlackPen =
  79 {
  80     { 0, PEN_MAGIC, 1 },               /* header */
  81     { PS_SOLID, { 1, 0 }, RGB(0,0,0) } /* logpen */
  82 };
  83
  84 static PENOBJ NullPen =
  85 {
  86     { 0, PEN_MAGIC, 1 },      /* header */
  87     { PS_NULL, { 1, 0 }, 0 }  /* logpen */
  88 };
  89
  90 static FONTOBJ OEMFixedFont =
  91 {
  92     { 0, FONT_MAGIC, 1 },   /* header */
  93     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, OEM_CHARSET,
  94       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
  95 };
  96
  97 static FONTOBJ AnsiFixedFont =
  98 {
  99     { 0, FONT_MAGIC, 1 },   /* header */
 100     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 101       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
 102 };
 103
 104 static FONTOBJ AnsiVarFont =
 105 {
 106     { 0, FONT_MAGIC, 1 },   /* header */
 107     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 108       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "MS Sans Serif" }
 109 };
 110
 111 static FONTOBJ SystemFont =
 112 {
 113     { 0, FONT_MAGIC, 1 },
 114     { 16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ANSI_CHARSET,
 115       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "System" }
 116 };
 117
 118 static FONTOBJ DeviceDefaultFont =
 119 {
 120     { 0, FONT_MAGIC, 1 },   /* header */
 121     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 122       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
 123 };
 124
 125 static FONTOBJ SystemFixedFont =
 126 {
 127     { 0, FONT_MAGIC, 1 },   /* header */
 128     { 12, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ANSI_CHARSET,
 129       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
 130 };
 131
 132
 133 static GDIOBJHDR * StockObjects[NB_STOCK_OBJECTS] =
 134 {
 135     (GDIOBJHDR *) &WhiteBrush,
 136     (GDIOBJHDR *) &LtGrayBrush,
 137     (GDIOBJHDR *) &GrayBrush,
 138     (GDIOBJHDR *) &DkGrayBrush,
 139     (GDIOBJHDR *) &BlackBrush,
 140     (GDIOBJHDR *) &NullBrush,
 141     (GDIOBJHDR *) &WhitePen,
 142     (GDIOBJHDR *) &BlackPen,
 143     (GDIOBJHDR *) &NullPen,
 144     NULL,
 145     (GDIOBJHDR *) &OEMFixedFont,
 146     (GDIOBJHDR *) &AnsiFixedFont,
 147     (GDIOBJHDR *) &AnsiVarFont,
 148     (GDIOBJHDR *) &SystemFont,
 149     (GDIOBJHDR *) &DeviceDefaultFont,
 150     NULL,            /* DEFAULT_PALETTE created by PALETTE_Init */
 151     (GDIOBJHDR *) &SystemFixedFont
 152 };
 153
 154 /******************************************************************************
 155  *
 156  *   void  ReadFontInformation(
 157  *      char const  *fontName,
 158  *      FONTOBJ  *font,
 159  *      int  defHeight,
 160  *      int  defBold,
 161  *      int  defItalic,
 162  *      int  defUnderline,
 163  *      int  defStrikeOut )
 164  *
 165  *   ReadFontInformation() checks the Wine configuration file's Tweak.Fonts
 166  *   section for entries containing fontName.Height, fontName.Bold, etc.,
 167  *   where fontName is the name specified in the call (e.g., "System").  It
 168  *   attempts to be user friendly by accepting 'n', 'N', 'f', 'F', or '0' as
 169  *   the first character in the boolean attributes (bold, italic, and
 170  *   underline).
 171  *****************************************************************************/
 172
 173 static void  ReadFontInformation(
 174     char const *fontName,
 175     FONTOBJ *font,
 176     int  defHeight,
 177     int  defBold,
 178     int  defItalic,
 179     int  defUnderline,
 180     int  defStrikeOut )
 181 {
 182     char  key[256];
 183
 184     sprintf(key, "%s.Height", fontName);
 185     font->logfont.lfHeight =
 186         PROFILE_GetWineIniInt("Tweak.Fonts", key, defHeight);
 187
 188     sprintf(key, "%s.Bold", fontName);
 189     font->logfont.lfWeight =
 190         (PROFILE_GetWineIniBool("Tweak.Fonts", key, defBold)) ?
 191         FW_BOLD : FW_NORMAL;
 192
 193     sprintf(key, "%s.Italic", fontName);
 194     font->logfont.lfItalic =
 195         PROFILE_GetWineIniBool("Tweak.Fonts", key, defItalic);
 196
 197     sprintf(key, "%s.Underline", fontName);
 198     font->logfont.lfUnderline =
 199         PROFILE_GetWineIniBool("Tweak.Fonts", key, defUnderline);
 200
 201     sprintf(key, "%s.StrikeOut", fontName);
 202     font->logfont.lfStrikeOut =
 203         PROFILE_GetWineIniBool("Tweak.Fonts", key, defStrikeOut);
 204
 205     return;
 206 }
 207
 208
 209 /***********************************************************************
 210  *           GDI_Init
 211  *
 212  * GDI initialization.
 213  */
 214 BOOL32 GDI_Init(void)
 215 {
 216     extern BOOL32 X11DRV_Init(void);
 217     extern BOOL32 DIB_Init(void);
 218
 219     /* TWEAK: Initialize font hints */
 220     ReadFontInformation("OEMFixed", &OEMFixedFont, 12, 0, 0, 0, 0);
 221     ReadFontInformation("AnsiFixed", &AnsiFixedFont, 12, 0, 0, 0, 0);
 222     ReadFontInformation("AnsiVar", &AnsiVarFont, 12, 0, 0, 0, 0);
 223     ReadFontInformation("System", &SystemFont, 16, 1, 0, 0, 0);
 224     ReadFontInformation("SystemFixed", &SystemFixedFont, 12, 1, 0, 0, 0);
 225
 226     /* Initialize drivers */
 227
 228     DIB_Init(); /* always before X11DRV_Init() */
 229
 230     if( X11DRV_Init() )
 231     {
 232         /* Create default palette */
 233
 234       /* DR well *this* palette can't be moveable (?) */
 235
 236         HPALETTE16 hpalette = PALETTE_Init();
 237
 238         if( hpalette )
 239         {
 240             StockObjects[DEFAULT_PALETTE] = (GDIOBJHDR *)GDI_HEAP_LOCK( hpalette );
 241             return TRUE;
 242         }
 243     }
 244     return FALSE;
 245 }
 246
 247
 248 /***********************************************************************
 249  *           GDI_AllocObject
 250  */
 251 HGDIOBJ16 GDI_AllocObject( WORD size, WORD magic )
 252 {
 253     static DWORD count = 0;
 254     GDIOBJHDR * obj;
 255     HGDIOBJ16 handle;
 256     if ( magic == DC_MAGIC || magic == METAFILE_DC_MAGIC )
 257       handle = GDI_HEAP_ALLOC( size );
 258     else
 259       handle = GDI_HEAP_ALLOC_MOVEABLE( size );
 260     if (!handle) return 0;
 261     obj = (GDIOBJHDR *) GDI_HEAP_LOCK( handle );
 262     obj->hNext   = 0;
 263     obj->wMagic  = magic;
 264     obj->dwCount = ++count;
 265     GDI_HEAP_UNLOCK( handle );
 266     return handle;
 267 }
 268
 269
 270 /***********************************************************************
 271  *           GDI_FreeObject
 272  */
 273 BOOL32 GDI_FreeObject( HGDIOBJ16 handle )
 274 {
 275     GDIOBJHDR * object;
 276
 277       /* Can't free stock objects */
 278     if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
 279         return TRUE;
 280
 281     object = (GDIOBJHDR *) GDI_HEAP_LOCK( handle );
 282     if (!object) return FALSE;
 283     object->wMagic = 0;  /* Mark it as invalid */
 284
 285       /* Free object */
 286
 287     GDI_HEAP_FREE( handle );
 288     return TRUE;
 289 }
 290
 291 /***********************************************************************
 292  *           GDI_GetObjPtr
 293  *
 294  * Return a pointer to the GDI object associated to the handle.
 295  * Return NULL if the object has the wrong magic number.
 296  * Movable GDI objects are locked in memory: it is up to the caller to unlock
 297  * it after the caller is done with the pointer.
 298  */
 299 GDIOBJHDR * GDI_GetObjPtr( HGDIOBJ16 handle, WORD magic )
 300 {
 301     GDIOBJHDR * ptr = NULL;
 302
 303     if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
 304       ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 305     else
 306       ptr = (GDIOBJHDR *) GDI_HEAP_LOCK( handle );
 307     if (!ptr) return NULL;
 308     if ((magic != MAGIC_DONTCARE) && (ptr->wMagic != magic))
 309     {
 310       GDI_HEAP_UNLOCK( handle );
 311       return NULL;
 312     }
 313     return ptr;
 314 }
 315
 316
 317 /***********************************************************************
 318  *           DeleteObject16    (GDI.69)
 319  */
 320 BOOL16 WINAPI DeleteObject16( HGDIOBJ16 obj )
 321 {
 322     return DeleteObject32( obj );
 323 }
 324
 325
 326 /***********************************************************************
 327  *           DeleteObject32    (GDI32.70)
 328  */
 329 BOOL32 WINAPI DeleteObject32( HGDIOBJ32 obj )
 330 {
 331       /* Check if object is valid */
 332
 333     GDIOBJHDR * header;
 334     if (HIWORD(obj)) return FALSE;
 335     if ((obj >= FIRST_STOCK_HANDLE) && (obj <= LAST_STOCK_HANDLE))
 336         return TRUE;
 337     if (!(header = (GDIOBJHDR *) GDI_HEAP_LOCK( obj ))) return FALSE;
 338
 339     dprintf_gdi(stddeb, "DeleteObject: %04x\n", obj );
 340
 341       /* Delete object */
 342
 343     switch(header->wMagic)
 344     {
 345       case PEN_MAGIC:     return GDI_FreeObject( obj );
 346       case BRUSH_MAGIC:   return BRUSH_DeleteObject( obj, (BRUSHOBJ*)header );
 347       case FONT_MAGIC:    return GDI_FreeObject( obj );
 348       case PALETTE_MAGIC: return PALETTE_DeleteObject(obj,(PALETTEOBJ*)header);
 349       case BITMAP_MAGIC:  return BITMAP_DeleteObject( obj, (BITMAPOBJ*)header);
 350       case REGION_MAGIC:  return REGION_DeleteObject( obj, (RGNOBJ*)header );
 351     }
 352     return FALSE;
 353 }
 354
 355
 356 /***********************************************************************
 357  *           GetStockObject16    (GDI.87)
 358  */
 359 HGDIOBJ16 WINAPI GetStockObject16( INT16 obj )
 360 {
 361     return (HGDIOBJ16)GetStockObject32( obj );
 362 }
 363
 364
 365 /***********************************************************************
 366  *           GetStockObject32    (GDI32.220)
 367  */
 368 HGDIOBJ32 WINAPI GetStockObject32( INT32 obj )
 369 {
 370     if ((obj < 0) || (obj >= NB_STOCK_OBJECTS)) return 0;
 371     if (!StockObjects[obj]) return 0;
 372     dprintf_gdi(stddeb, "GetStockObject: returning %d\n",
 373                 FIRST_STOCK_HANDLE + obj );
 374     return (HGDIOBJ16)(FIRST_STOCK_HANDLE + obj);
 375 }
 376
 377
 378 /***********************************************************************
 379  *           GetObject16    (GDI.82)
 380  */
 381 INT16 WINAPI GetObject16( HANDLE16 handle, INT16 count, LPVOID buffer )
 382 {
 383     GDIOBJHDR * ptr = NULL;
 384     INT16 result = 0;
 385     dprintf_gdi(stddeb, "GetObject16: %04x %d %p\n", handle, count, buffer );
 386     if (!count) return 0;
 387
 388     if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
 389       ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 390     else
 391       ptr = (GDIOBJHDR *) GDI_HEAP_LOCK( handle );
 392     if (!ptr) return 0;
 393
 394     switch(ptr->wMagic)
 395       {
 396       case PEN_MAGIC:
 397         result = PEN_GetObject16( (PENOBJ *)ptr, count, buffer );
 398         break;
 399       case BRUSH_MAGIC:
 400         result = BRUSH_GetObject16( (BRUSHOBJ *)ptr, count, buffer );
 401         break;
 402       case BITMAP_MAGIC:
 403         result = BITMAP_GetObject16( (BITMAPOBJ *)ptr, count, buffer );
 404         break;
 405       case FONT_MAGIC:
 406         result = FONT_GetObject16( (FONTOBJ *)ptr, count, buffer );
 407         break;
 408       case PALETTE_MAGIC:
 409         result = PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
 410         break;
 411       }
 412     GDI_HEAP_UNLOCK( handle );
 413     return result;
 414 }
 415
 416
 417 /***********************************************************************
 418  *           GetObject32A    (GDI32.204)
 419  */
 420 INT32 WINAPI GetObject32A( HANDLE32 handle, INT32 count, LPVOID buffer )
 421 {
 422     GDIOBJHDR * ptr = NULL;
 423     INT32 result = 0;
 424     dprintf_gdi(stddeb, "GetObject32A: %08x %d %p\n", handle, count, buffer );
 425     if (!count) return 0;
 426
 427     if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
 428       ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 429     else
 430       ptr = (GDIOBJHDR *) GDI_HEAP_LOCK( handle );
 431     if (!ptr) return 0;
 432
 433     switch(ptr->wMagic)
 434     {
 435       case PEN_MAGIC:
 436           result = PEN_GetObject32( (PENOBJ *)ptr, count, buffer );
 437           break;
 438       case BRUSH_MAGIC:
 439           result = BRUSH_GetObject32( (BRUSHOBJ *)ptr, count, buffer );
 440           break;
 441       case BITMAP_MAGIC:
 442           result = BITMAP_GetObject32( (BITMAPOBJ *)ptr, count, buffer );
 443           break;
 444       case FONT_MAGIC:
 445           result = FONT_GetObject32A( (FONTOBJ *)ptr, count, buffer );
 446           break;
 447       case PALETTE_MAGIC:
 448           fprintf( stderr, "GetObject32: magic %04x not implemented\n",
 449                    ptr->wMagic );
 450           break;
 451     }
 452     GDI_HEAP_UNLOCK( handle );
 453     return result;
 454 }
 455
 456
 457 /***********************************************************************
 458  *           GetObject32W    (GDI32.206)
 459  */
 460 INT32 WINAPI GetObject32W( HANDLE32 handle, INT32 count, LPVOID buffer )
 461 {
 462     return GetObject32A( handle, count, buffer );
 463 }
 464
 465
 466 /***********************************************************************
 467  *           SelectObject16    (GDI.45)
 468  */
 469 HGDIOBJ16 WINAPI SelectObject16( HDC16 hdc, HGDIOBJ16 handle )
 470 {
 471     return (HGDIOBJ16)SelectObject32( hdc, handle );
 472 }
 473
 474
 475 /***********************************************************************
 476  *           SelectObject32    (GDI32.299)
 477  */
 478 HGDIOBJ32 WINAPI SelectObject32( HDC32 hdc, HGDIOBJ32 handle )
 479 {
 480     DC * dc = DC_GetDCPtr( hdc );
 481     if (!dc || !dc->funcs->pSelectObject) return 0;
 482     dprintf_gdi(stddeb, "SelectObject: hdc=%04x %04x\n", hdc, handle );
 483     return dc->funcs->pSelectObject( dc, handle );
 484 }
 485
 486
 487 /***********************************************************************
 488  *           UnrealizeObject16    (GDI.150)
 489  */
 490 BOOL16 WINAPI UnrealizeObject16( HGDIOBJ16 obj )
 491 {
 492     return UnrealizeObject32( obj );
 493 }
 494
 495
 496 /***********************************************************************
 497  *           UnrealizeObject    (GDI32.358)
 498  */
 499 BOOL32 WINAPI UnrealizeObject32( HGDIOBJ32 obj )
 500 {
 501     BOOL32 result = TRUE;
 502   /* Check if object is valid */
 503
 504     GDIOBJHDR * header = (GDIOBJHDR *) GDI_HEAP_LOCK( obj );
 505     if (!header) return FALSE;
 506
 507     dprintf_gdi( stddeb, "UnrealizeObject: %04x\n", obj );
 508
 509       /* Unrealize object */
 510
 511     switch(header->wMagic)
 512     {
 513     case PALETTE_MAGIC:
 514         result = PALETTE_UnrealizeObject( obj, (PALETTEOBJ *)header );
 515         break;
 516
 517     case BRUSH_MAGIC:
 518         /* Windows resets the brush origin. We don't need to. */
 519         break;
 520     }
 521     GDI_HEAP_UNLOCK( obj );
 522     return result;
 523 }
 524
 525
 526 /***********************************************************************
 527  *           EnumObjects16    (GDI.71)
 528  */
 529 INT16 WINAPI EnumObjects16( HDC16 hdc, INT16 nObjType,
 530                             GOBJENUMPROC16 lpEnumFunc, LPARAM lParam )
 531 {
 532     /* Solid colors to enumerate */
 533     static const COLORREF solid_colors[] =
 534     { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
 535       RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
 536       RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
 537       RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
 538       RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
 539       RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
 540       RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
 541       RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
 542     };
 543
 544     INT16 i, retval = 0;
 545     LOGPEN16 *pen;
 546     LOGBRUSH16 *brush = NULL;
 547
 548     dprintf_gdi( stddeb, "EnumObjects16: %04x %d %08lx %08lx\n",
 549                  hdc, nObjType, (DWORD)lpEnumFunc, lParam );
 550     switch(nObjType)
 551     {
 552     case OBJ_PEN:
 553         /* Enumerate solid pens */
 554         if (!(pen = SEGPTR_NEW(LOGPEN16))) break;
 555         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 556         {
 557             pen->lopnStyle   = PS_SOLID;
 558             pen->lopnWidth.x = 1;
 559             pen->lopnWidth.y = 0;
 560             pen->lopnColor   = solid_colors[i];
 561             retval = lpEnumFunc( SEGPTR_GET(pen), lParam );
 562             dprintf_gdi( stddeb, "EnumObjects16: solid pen %08lx, ret=%d\n",
 563                          solid_colors[i], retval);
 564             if (!retval) break;
 565         }
 566         SEGPTR_FREE(pen);
 567         break;
 568
 569     case OBJ_BRUSH:
 570         /* Enumerate solid brushes */
 571         if (!(brush = SEGPTR_NEW(LOGBRUSH16))) break;
 572         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 573         {
 574             brush->lbStyle = BS_SOLID;
 575             brush->lbColor = solid_colors[i];
 576             brush->lbHatch = 0;
 577             retval = lpEnumFunc( SEGPTR_GET(brush), lParam );
 578             dprintf_gdi( stddeb, "EnumObjects16: solid brush %08lx, ret=%d\n",
 579                          solid_colors[i], retval);
 580             if (!retval) break;
 581         }
 582
 583         /* Now enumerate hatched brushes */
 584         if (retval) for (i = HS_HORIZONTAL; i <= HS_DIAGCROSS; i++)
 585         {
 586             brush->lbStyle = BS_HATCHED;
 587             brush->lbColor = RGB(0,0,0);
 588             brush->lbHatch = i;
 589             retval = lpEnumFunc( SEGPTR_GET(brush), lParam );
 590             dprintf_gdi( stddeb, "EnumObjects16: hatched brush %d, ret=%d\n",
 591                          i, retval);
 592             if (!retval) break;
 593         }
 594         SEGPTR_FREE(brush);
 595         break;
 596
 597     default:
 598         fprintf( stderr, "EnumObjects16: invalid type %d\n", nObjType );
 599         break;
 600     }
 601     return retval;
 602 }
 603
 604
 605 /***********************************************************************
 606  *           EnumObjects32    (GDI32.89)
 607  */
 608 INT32 WINAPI EnumObjects32( HDC32 hdc, INT32 nObjType,
 609                             GOBJENUMPROC32 lpEnumFunc, LPARAM lParam )
 610 {
 611     /* Solid colors to enumerate */
 612     static const COLORREF solid_colors[] =
 613     { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
 614       RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
 615       RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
 616       RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
 617       RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
 618       RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
 619       RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
 620       RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
 621     };
 622
 623     INT32 i, retval = 0;
 624     LOGPEN32 pen;
 625     LOGBRUSH32 brush;
 626
 627     dprintf_gdi( stddeb, "EnumObjects32: %04x %d %08lx %08lx\n",
 628                  hdc, nObjType, (DWORD)lpEnumFunc, lParam );
 629     switch(nObjType)
 630     {
 631     case OBJ_PEN:
 632         /* Enumerate solid pens */
 633         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 634         {
 635             pen.lopnStyle   = PS_SOLID;
 636             pen.lopnWidth.x = 1;
 637             pen.lopnWidth.y = 0;
 638             pen.lopnColor   = solid_colors[i];
 639             retval = lpEnumFunc( &pen, lParam );
 640             dprintf_gdi( stddeb, "EnumObjects32: solid pen %08lx, ret=%d\n",
 641                          solid_colors[i], retval);
 642             if (!retval) break;
 643         }
 644         break;
 645
 646     case OBJ_BRUSH:
 647         /* Enumerate solid brushes */
 648         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 649         {
 650             brush.lbStyle = BS_SOLID;
 651             brush.lbColor = solid_colors[i];
 652             brush.lbHatch = 0;
 653             retval = lpEnumFunc( &brush, lParam );
 654             dprintf_gdi( stddeb, "EnumObjects32: solid brush %08lx, ret=%d\n",
 655                          solid_colors[i], retval);
 656             if (!retval) break;
 657         }
 658
 659         /* Now enumerate hatched brushes */
 660         if (retval) for (i = HS_HORIZONTAL; i <= HS_DIAGCROSS; i++)
 661         {
 662             brush.lbStyle = BS_HATCHED;
 663             brush.lbColor = RGB(0,0,0);
 664             brush.lbHatch = i;
 665             retval = lpEnumFunc( &brush, lParam );
 666             dprintf_gdi( stddeb, "EnumObjects32: hatched brush %d, ret=%d\n",
 667                          i, retval);
 668             if (!retval) break;
 669         }
 670         break;
 671
 672     default:
 673         /* FIXME: implement Win32 types */
 674         fprintf( stderr, "EnumObjects32: invalid type %d\n", nObjType );
 675         break;
 676     }
 677     return retval;
 678 }
 679
 680
 681 /***********************************************************************
 682  *           IsGDIObject    (GDI.462)
 683  *
 684  * returns type of object if valid (W95 system programming secrets p. 264-5)
 685  */
 686 BOOL16 WINAPI IsGDIObject( HGDIOBJ16 handle )
 687 {
 688     GDIOBJHDR *object = (GDIOBJHDR *) GDI_HEAP_LOCK( handle );
 689     if (object)
 690     {
 691         UINT16 magic = object->wMagic;
 692         GDI_HEAP_UNLOCK( handle );
 693         if (magic >= PEN_MAGIC && magic <= METAFILE_DC_MAGIC)
 694             return magic - PEN_MAGIC + 1;
 695     }
 696     return FALSE;
 697 }
 698
 699
 700 /***********************************************************************
 701  *           SetObjectOwner16    (GDI.461)
 702  */
 703 void WINAPI SetObjectOwner16( HGDIOBJ16 handle, HANDLE16 owner )
 704 {
 705     /* Nothing to do */
 706 }
 707
 708
 709 /***********************************************************************
 710  *           SetObjectOwner32    (GDI32.386)
 711  */
 712 void WINAPI SetObjectOwner32( HGDIOBJ32 handle, HANDLE32 owner )
 713 {
 714     /* Nothing to do */
 715 }
 716
 717
 718 /***********************************************************************
 719  *           GdiGetBatchLimit    (GDI32.129)
 720  */
 721 DWORD WINAPI GdiGetBatchLimit(void)
 722 {
 723     return 1;  /* FIXME */
 724 }
 725
 726
 727 /***********************************************************************
 728  *           GdiSetBatchLimit    (GDI32.139)
 729  */
 730 DWORD WINAPI GdiSetBatchLimit( DWORD limit )
 731 {
 732     return 1; /* FIXME */
 733 }
 734
 735
 736 /***********************************************************************
 737  *           MulDiv16   (GDI.128)
 738  */
 739 INT16 WINAPI MulDiv16( INT16 foo, INT16 bar, INT16 baz )
 740 {
 741     INT32 ret;
 742     if (!baz) return -32768;
 743     ret = (foo * bar) / baz;
 744     if ((ret > 32767) || (ret < -32767)) return -32768;
 745     return ret;
 746 }
 747
 748
 749 /***********************************************************************
 750  *           MulDiv32   (KERNEL32.391)
 751  */
 752 INT32 WINAPI MulDiv32( INT32 foo, INT32 bar, INT32 baz )
 753 {
 754 #ifdef __GNUC__
 755     long long ret;
 756     if (!baz) return -1;
 757     ret = ((long long)foo * bar) / baz;
 758     if ((ret > 2147483647) || (ret < -2147483647)) return -1;
 759     return ret;
 760 #else
 761     if (!baz) return -1;
 762     return (foo * bar) / baz;
 763 #endif
 764 }