objects/gdiobj.c

   1 /*
   2  * GDI functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  */
   6
   7 #include "config.h"
   8
   9 #include <assert.h>
  10 #include <stdlib.h>
  11 #include <stdio.h>
  12
  13 #include "windef.h"
  14 #include "wingdi.h"
  15 #include "winreg.h"
  16 #include "winerror.h"
  17 #include "wine/winbase16.h"
  18
  19 #include "bitmap.h"
  20 #include "brush.h"
  21 #include "font.h"
  22 #include "heap.h"
  23 #include "local.h"
  24 #include "palette.h"
  25 #include "pen.h"
  26 #include "region.h"
  27 #include "debugtools.h"
  28 #include "gdi.h"
  29
  30 DEFAULT_DEBUG_CHANNEL(gdi);
  31
  32
  33 /***********************************************************************
  34  *          GDI stock objects
  35  */
  36
  37 static const LOGBRUSH WhiteBrush = { BS_SOLID, RGB(255,255,255), 0 };
  38 static const LOGBRUSH BlackBrush = { BS_SOLID, RGB(0,0,0), 0 };
  39 static const LOGBRUSH NullBrush  = { BS_NULL, 0, 0 };
  40
  41 /* FIXME: these should perhaps be BS_HATCHED, at least for 1 bitperpixel */
  42 static const LOGBRUSH LtGrayBrush = { BS_SOLID, RGB(192,192,192), 0 };
  43 static const LOGBRUSH GrayBrush   = { BS_SOLID, RGB(128,128,128), 0 };
  44
  45 /* This is BS_HATCHED, for 1 bitperpixel. This makes the spray work in pbrush */
  46 /* NB_HATCH_STYLES is an index into HatchBrushes */
  47 static const LOGBRUSH DkGrayBrush = { BS_HATCHED, RGB(0,0,0), NB_HATCH_STYLES };
  48
  49 static const LOGPEN WhitePen = { PS_SOLID, { 0, 0 }, RGB(255,255,255) };
  50 static const LOGPEN BlackPen = { PS_SOLID, { 0, 0 }, RGB(0,0,0) };
  51 static const LOGPEN NullPen  = { PS_NULL,  { 0, 0 }, 0 };
  52
  53 static const LOGFONTW OEMFixedFont =
  54 { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, OEM_CHARSET,
  55   0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, {'\0'} };
  56
  57 static const LOGFONTW AnsiFixedFont =
  58 { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
  59   0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, {'\0'} };
  60
  61 static const LOGFONTW AnsiVarFont =
  62 { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
  63   0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
  64   {'M','S',' ','S','a','n','s',' ','S','e','r','i','f','\0'} };
  65
  66 static const LOGFONTW SystemFont =
  67 { 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
  68   0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
  69   {'S','y','s','t','e','m','\0'} };
  70
  71 static const LOGFONTW DeviceDefaultFont =
  72 { 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
  73   0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, {'\0'} };
  74
  75 static const LOGFONTW SystemFixedFont =
  76 { 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
  77   0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, {'\0'} };
  78
  79 /* FIXME: Is this correct? */
  80 static const LOGFONTW DefaultGuiFont =
  81 { -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
  82   0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
  83   {'M','S',' ','S','a','n','s',' ','S','e','r','i','f','\0'} };
  84
  85 /* reserve one extra entry for the stock default bitmap */
  86 /* this is what Windows does too */
  87 #define NB_STOCK_OBJECTS (STOCK_LAST+2)
  88
  89 static HGDIOBJ stock_objects[NB_STOCK_OBJECTS];
  90
  91 static SYSLEVEL GDI_level = { CRITICAL_SECTION_INIT("GDI_level"), 3 };
  92 static WORD GDI_HeapSel;
  93
  94 inline static BOOL get_bool(char *buffer)
  95 {
  96     return (buffer[0] == 'y' || buffer[0] == 'Y' ||
  97             buffer[0] == 't' || buffer[0] == 'T' ||
  98             buffer[0] == '1');
  99 }
 100
 101
 102 /******************************************************************************
 103  *           create_stock_font
 104  */
 105 static HFONT create_stock_font( char const *fontName, const LOGFONTW *font, HKEY hkey )
 106 {
 107     LOGFONTW lf;
 108     char  key[256];
 109     char buffer[MAX_PATH];
 110     DWORD type, count;
 111
 112     if (!hkey) return CreateFontIndirectW( font );
 113
 114     lf = *font;
 115     sprintf(key, "%s.Height", fontName);
 116     count = sizeof(buffer);
 117     if(!RegQueryValueExA(hkey, key, 0, &type, buffer, &count))
 118         lf.lfHeight = atoi(buffer);
 119
 120     sprintf(key, "%s.Bold", fontName);
 121     count = sizeof(buffer);
 122     if(!RegQueryValueExA(hkey, key, 0, &type, buffer, &count))
 123         lf.lfWeight = get_bool(buffer) ? FW_BOLD : FW_NORMAL;
 124
 125     sprintf(key, "%s.Italic", fontName);
 126     count = sizeof(buffer);
 127     if(!RegQueryValueExA(hkey, key, 0, &type, buffer, &count))
 128         lf.lfItalic = get_bool(buffer);
 129
 130     sprintf(key, "%s.Underline", fontName);
 131     count = sizeof(buffer);
 132     if(!RegQueryValueExA(hkey, key, 0, &type, buffer, &count))
 133         lf.lfUnderline = get_bool(buffer);
 134
 135     sprintf(key, "%s.StrikeOut", fontName);
 136     count = sizeof(buffer);
 137     if(!RegQueryValueExA(hkey, key, 0, &type, buffer, &count))
 138         lf.lfStrikeOut = get_bool(buffer);
 139     return CreateFontIndirectW( &lf );
 140 }
 141
 142
 143 #define TRACE_SEC(handle,text) \
 144    TRACE("(%04x): " text " %ld\n", (handle), GDI_level.crst.RecursionCount)
 145
 146
 147 /***********************************************************************
 148  *           GDI_Init
 149  *
 150  * GDI initialization.
 151  */
 152 BOOL GDI_Init(void)
 153 {
 154     HINSTANCE16 instance;
 155     HKEY hkey;
 156     GDIOBJHDR *ptr;
 157     int i;
 158
 159     if (RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\Tweak.Fonts", &hkey))
 160         hkey = 0;
 161
 162     /* create GDI heap */
 163     if ((instance = LoadLibrary16( "GDI.EXE" )) < 32) return FALSE;
 164     GDI_HeapSel = instance | 7;
 165
 166     /* create stock objects */
 167     stock_objects[WHITE_BRUSH]  = CreateBrushIndirect( &WhiteBrush );
 168     stock_objects[LTGRAY_BRUSH] = CreateBrushIndirect( &LtGrayBrush );
 169     stock_objects[GRAY_BRUSH]   = CreateBrushIndirect( &GrayBrush );
 170     stock_objects[DKGRAY_BRUSH] = CreateBrushIndirect( &DkGrayBrush );
 171     stock_objects[BLACK_BRUSH]  = CreateBrushIndirect( &BlackBrush );
 172     stock_objects[NULL_BRUSH]   = CreateBrushIndirect( &NullBrush );
 173
 174     stock_objects[WHITE_PEN]    = CreatePenIndirect( &WhitePen );
 175     stock_objects[BLACK_PEN]    = CreatePenIndirect( &BlackPen );
 176     stock_objects[NULL_PEN]     = CreatePenIndirect( &NullPen );
 177
 178     stock_objects[DEFAULT_PALETTE] = PALETTE_Init();
 179     stock_objects[DEFAULT_BITMAP]  = CreateBitmap( 1, 1, 1, 1, NULL );
 180
 181     stock_objects[OEM_FIXED_FONT]      = create_stock_font( "OEMFixed", &OEMFixedFont, hkey );
 182     stock_objects[ANSI_FIXED_FONT]     = create_stock_font( "AnsiFixed", &AnsiFixedFont, hkey );
 183     stock_objects[ANSI_VAR_FONT]       = create_stock_font( "AnsiVar", &AnsiVarFont, hkey );
 184     stock_objects[SYSTEM_FONT]         = create_stock_font( "System", &SystemFont, hkey );
 185     stock_objects[DEVICE_DEFAULT_FONT] = create_stock_font( "DeviceDefault", &DeviceDefaultFont, hkey );
 186     stock_objects[SYSTEM_FIXED_FONT]   = create_stock_font( "SystemFixed", &SystemFixedFont, hkey );
 187     stock_objects[DEFAULT_GUI_FONT]    = create_stock_font( "DefaultGui", &DefaultGuiFont, hkey );
 188
 189
 190     /* clear the NOSYSTEM bit on all stock objects*/
 191     for (i = 0; i < NB_STOCK_OBJECTS; i++)
 192     {
 193         if (!stock_objects[i])
 194         {
 195             if (i == 9) continue;  /* there's no stock object 9 */
 196             ERR( "could not create stock object %d\n", i );
 197             return FALSE;
 198         }
 199         ptr = GDI_GetObjPtr( stock_objects[i], MAGIC_DONTCARE );
 200         ptr->wMagic &= ~OBJECT_NOSYSTEM;
 201         GDI_ReleaseObj( stock_objects[i] );
 202     }
 203
 204     if (hkey) RegCloseKey( hkey );
 205     return TRUE;
 206 }
 207
 208 #define FIRST_LARGE_HANDLE 16
 209 #define MAX_LARGE_HANDLES ((GDI_HEAP_SIZE >> 2) - FIRST_LARGE_HANDLE)
 210 static GDIOBJHDR *large_handles[MAX_LARGE_HANDLES];
 211 static int next_large_handle;
 212
 213 /***********************************************************************
 214  *           alloc_large_heap
 215  *
 216  * Allocate a GDI handle from the large heap. Helper for GDI_AllocObject
 217  */
 218 inline static GDIOBJHDR *alloc_large_heap( WORD size, HGDIOBJ *handle )
 219 {
 220     int i;
 221     GDIOBJHDR *obj;
 222
 223     for (i = next_large_handle + 1; i < MAX_LARGE_HANDLES; i++)
 224         if (!large_handles[i]) goto found;
 225     for (i = 0; i <= next_large_handle; i++)
 226         if (!large_handles[i]) goto found;
 227     *handle = 0;
 228     return NULL;
 229
 230  found:
 231     if ((obj = HeapAlloc( GetProcessHeap(), 0, size )))
 232     {
 233         large_handles[i] = obj;
 234         *handle = (i + FIRST_LARGE_HANDLE) << 2;
 235         next_large_handle = i;
 236     }
 237     return obj;
 238 }
 239
 240
 241 /***********************************************************************
 242  *           GDI_AllocObject
 243  */
 244 void *GDI_AllocObject( WORD size, WORD magic, HGDIOBJ *handle )
 245 {
 246     static DWORD count = 0;
 247     GDIOBJHDR *obj;
 248
 249     _EnterSysLevel( &GDI_level );
 250     switch(magic)
 251     {
 252         /* allocate DCs on the larger heap */
 253     case DC_MAGIC:
 254     case DISABLED_DC_MAGIC:
 255     case META_DC_MAGIC:
 256     case METAFILE_MAGIC:
 257     case METAFILE_DC_MAGIC:
 258     case ENHMETAFILE_MAGIC:
 259     case ENHMETAFILE_DC_MAGIC:
 260     case BITMAP_MAGIC:
 261         if (!(obj = alloc_large_heap( size, handle ))) goto error;
 262         break;
 263     default:
 264         if (!(*handle = LOCAL_Alloc( GDI_HeapSel, LMEM_MOVEABLE, size ))) goto error;
 265         assert( *handle & 2 );
 266         obj = (GDIOBJHDR *)LOCAL_Lock( GDI_HeapSel, *handle );
 267         break;
 268     }
 269
 270     obj->hNext   = 0;
 271     obj->wMagic  = magic|OBJECT_NOSYSTEM;
 272     obj->dwCount = ++count;
 273
 274     TRACE_SEC( *handle, "enter" );
 275     return obj;
 276
 277 error:
 278     _LeaveSysLevel( &GDI_level );
 279     *handle = 0;
 280     return NULL;
 281 }
 282
 283
 284 /***********************************************************************
 285  *           GDI_ReallocObject
 286  *
 287  * The object ptr must have been obtained with GDI_GetObjPtr.
 288  * The new pointer must be released with GDI_ReleaseObj.
 289  */
 290 void *GDI_ReallocObject( WORD size, HGDIOBJ handle, void *object )
 291 {
 292     HGDIOBJ new_handle;
 293
 294     assert( handle & 2 );  /* no realloc for large handles */
 295     LOCAL_Unlock( GDI_HeapSel, handle );
 296     if (!(new_handle = LOCAL_ReAlloc( GDI_HeapSel, handle, size, LMEM_MOVEABLE )))
 297     {
 298         TRACE_SEC( handle, "leave" );
 299         _LeaveSysLevel( &GDI_level );
 300         return NULL;
 301     }
 302     assert( new_handle == handle );  /* moveable handle cannot change */
 303     return LOCAL_Lock( GDI_HeapSel, handle );
 304 }
 305
 306
 307 /***********************************************************************
 308  *           GDI_FreeObject
 309  */
 310 BOOL GDI_FreeObject( HGDIOBJ handle, void *ptr )
 311 {
 312     GDIOBJHDR *object = ptr;
 313
 314     object->wMagic = 0;  /* Mark it as invalid */
 315     if (handle & 2)  /* GDI heap handle */
 316     {
 317         LOCAL_Unlock( GDI_HeapSel, handle );
 318         LOCAL_Free( GDI_HeapSel, handle );
 319     }
 320     else  /* large heap handle */
 321     {
 322         int i = (handle >> 2) - FIRST_LARGE_HANDLE;
 323         if (i >= 0 && i < MAX_LARGE_HANDLES && large_handles[i])
 324         {
 325             HeapFree( GetProcessHeap(), 0, large_handles[i] );
 326             large_handles[i] = NULL;
 327         }
 328         else ERR( "Invalid handle %x\n", handle );
 329     }
 330     TRACE_SEC( handle, "leave" );
 331     _LeaveSysLevel( &GDI_level );
 332     return TRUE;
 333 }
 334
 335
 336 /***********************************************************************
 337  *           GDI_GetObjPtr
 338  *
 339  * Return a pointer to the GDI object associated to the handle.
 340  * Return NULL if the object has the wrong magic number.
 341  * The object must be released with GDI_ReleaseObj.
 342  */
 343 void *GDI_GetObjPtr( HGDIOBJ handle, WORD magic )
 344 {
 345     GDIOBJHDR *ptr = NULL;
 346
 347     _EnterSysLevel( &GDI_level );
 348
 349     if (handle & 2)  /* GDI heap handle */
 350     {
 351         ptr = (GDIOBJHDR *)LOCAL_Lock( GDI_HeapSel, handle );
 352         if (ptr && (magic != MAGIC_DONTCARE) && (GDIMAGIC(ptr->wMagic) != magic))
 353         {
 354             LOCAL_Unlock( GDI_HeapSel, handle );
 355             ptr = NULL;
 356         }
 357     }
 358     else  /* large heap handle */
 359     {
 360         int i = (handle >> 2) - FIRST_LARGE_HANDLE;
 361         if (i >= 0 && i < MAX_LARGE_HANDLES)
 362         {
 363             ptr = large_handles[i];
 364             if (ptr && (magic != MAGIC_DONTCARE) && (GDIMAGIC(ptr->wMagic) != magic)) ptr = NULL;
 365         }
 366     }
 367
 368     if (!ptr)
 369     {
 370         _LeaveSysLevel( &GDI_level );
 371         SetLastError( ERROR_INVALID_HANDLE );
 372         WARN( "Invalid handle %x\n", handle );
 373     }
 374     else TRACE_SEC( handle, "enter" );
 375
 376     return ptr;
 377 }
 378
 379
 380 /***********************************************************************
 381  *           GDI_ReleaseObj
 382  *
 383  */
 384 void GDI_ReleaseObj( HGDIOBJ handle )
 385 {
 386     if (handle & 2) LOCAL_Unlock( GDI_HeapSel, handle );
 387     TRACE_SEC( handle, "leave" );
 388     _LeaveSysLevel( &GDI_level );
 389 }
 390
 391
 392 /***********************************************************************
 393  *           GDI_CheckNotLock
 394  */
 395 void GDI_CheckNotLock(void)
 396 {
 397     _CheckNotSysLevel( &GDI_level );
 398 }
 399
 400
 401 /***********************************************************************
 402  *           DeleteObject    (GDI.69)
 403  *           SysDeleteObject (GDI.605)
 404  */
 405 BOOL16 WINAPI DeleteObject16( HGDIOBJ16 obj )
 406 {
 407     return DeleteObject( obj );
 408 }
 409
 410
 411 /***********************************************************************
 412  *           DeleteObject    (GDI32.@)
 413  */
 414 BOOL WINAPI DeleteObject( HGDIOBJ obj )
 415 {
 416       /* Check if object is valid */
 417
 418     GDIOBJHDR * header;
 419     if (HIWORD(obj)) return FALSE;
 420
 421     if (!(header = GDI_GetObjPtr( obj, MAGIC_DONTCARE ))) return FALSE;
 422
 423     if (!(header->wMagic & OBJECT_NOSYSTEM)
 424     &&   (header->wMagic >= FIRST_MAGIC) && (header->wMagic <= LAST_MAGIC))
 425     {
 426         TRACE("Preserving system object %04x\n", obj);
 427         GDI_ReleaseObj( obj );
 428         return TRUE;
 429     }
 430
 431     TRACE("%04x\n", obj );
 432
 433       /* Delete object */
 434
 435     switch(GDIMAGIC(header->wMagic))
 436     {
 437       case PEN_MAGIC:     return GDI_FreeObject( obj, header );
 438       case BRUSH_MAGIC:   return BRUSH_DeleteObject( obj, (BRUSHOBJ*)header );
 439       case FONT_MAGIC:    return GDI_FreeObject( obj, header );
 440       case PALETTE_MAGIC: return PALETTE_DeleteObject(obj,(PALETTEOBJ*)header);
 441       case BITMAP_MAGIC:  return BITMAP_DeleteObject( obj, (BITMAPOBJ*)header);
 442       case REGION_MAGIC:  return REGION_DeleteObject( obj, (RGNOBJ*)header );
 443       case DC_MAGIC:
 444           GDI_ReleaseObj( obj );
 445           return DeleteDC(obj);
 446       case 0 :
 447         WARN("Already deleted\n");
 448         break;
 449       default:
 450         WARN("Unknown magic number (%d)\n",GDIMAGIC(header->wMagic));
 451     }
 452     GDI_ReleaseObj( obj );
 453     return FALSE;
 454 }
 455
 456 /***********************************************************************
 457  *           GetStockObject    (GDI.87)
 458  */
 459 HGDIOBJ16 WINAPI GetStockObject16( INT16 obj )
 460 {
 461     return (HGDIOBJ16)GetStockObject( obj );
 462 }
 463
 464
 465 /***********************************************************************
 466  *           GetStockObject    (GDI32.@)
 467  */
 468 HGDIOBJ WINAPI GetStockObject( INT obj )
 469 {
 470     HGDIOBJ ret;
 471     if ((obj < 0) || (obj >= NB_STOCK_OBJECTS)) return 0;
 472     ret = stock_objects[obj];
 473     TRACE("returning %4x\n", ret );
 474     return ret;
 475 }
 476
 477
 478 /***********************************************************************
 479  *           GetObject    (GDI.82)
 480  */
 481 INT16 WINAPI GetObject16( HANDLE16 handle, INT16 count, LPVOID buffer )
 482 {
 483     GDIOBJHDR * ptr;
 484     INT16 result = 0;
 485     TRACE("%04x %d %p\n", handle, count, buffer );
 486     if (!count) return 0;
 487
 488     if (!(ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE ))) return 0;
 489
 490     switch(GDIMAGIC(ptr->wMagic))
 491       {
 492       case PEN_MAGIC:
 493         result = PEN_GetObject16( (PENOBJ *)ptr, count, buffer );
 494         break;
 495       case BRUSH_MAGIC:
 496         result = BRUSH_GetObject16( (BRUSHOBJ *)ptr, count, buffer );
 497         break;
 498       case BITMAP_MAGIC:
 499         result = BITMAP_GetObject16( (BITMAPOBJ *)ptr, count, buffer );
 500         break;
 501       case FONT_MAGIC:
 502         result = FONT_GetObject16( (FONTOBJ *)ptr, count, buffer );
 503         break;
 504       case PALETTE_MAGIC:
 505         result = PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
 506         break;
 507       }
 508     GDI_ReleaseObj( handle );
 509     return result;
 510 }
 511
 512
 513 /***********************************************************************
 514  *           GetObjectA    (GDI32.@)
 515  */
 516 INT WINAPI GetObjectA( HANDLE handle, INT count, LPVOID buffer )
 517 {
 518     GDIOBJHDR * ptr;
 519     INT result = 0;
 520     TRACE("%08x %d %p\n", handle, count, buffer );
 521     if (!count) return 0;
 522
 523     if (!(ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE ))) return 0;
 524
 525     switch(GDIMAGIC(ptr->wMagic))
 526     {
 527       case PEN_MAGIC:
 528           result = PEN_GetObject( (PENOBJ *)ptr, count, buffer );
 529           break;
 530       case BRUSH_MAGIC:
 531           result = BRUSH_GetObject( (BRUSHOBJ *)ptr, count, buffer );
 532           break;
 533       case BITMAP_MAGIC:
 534           result = BITMAP_GetObject( (BITMAPOBJ *)ptr, count, buffer );
 535           break;
 536       case FONT_MAGIC:
 537           result = FONT_GetObjectA( (FONTOBJ *)ptr, count, buffer );
 538           break;
 539       case PALETTE_MAGIC:
 540           result = PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
 541           break;
 542
 543       case REGION_MAGIC:
 544       case DC_MAGIC:
 545       case DISABLED_DC_MAGIC:
 546       case META_DC_MAGIC:
 547       case METAFILE_MAGIC:
 548       case METAFILE_DC_MAGIC:
 549       case ENHMETAFILE_MAGIC:
 550       case ENHMETAFILE_DC_MAGIC:
 551           FIXME("Magic %04x not implemented\n", GDIMAGIC(ptr->wMagic) );
 552           break;
 553
 554       default:
 555           ERR("Invalid GDI Magic %04x\n", GDIMAGIC(ptr->wMagic));
 556           break;
 557     }
 558     GDI_ReleaseObj( handle );
 559     return result;
 560 }
 561
 562 /***********************************************************************
 563  *           GetObjectW    (GDI32.@)
 564  */
 565 INT WINAPI GetObjectW( HANDLE handle, INT count, LPVOID buffer )
 566 {
 567     GDIOBJHDR * ptr;
 568     INT result = 0;
 569     TRACE("%08x %d %p\n", handle, count, buffer );
 570     if (!count) return 0;
 571
 572     if (!(ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE ))) return 0;
 573
 574     switch(GDIMAGIC(ptr->wMagic))
 575     {
 576       case PEN_MAGIC:
 577           result = PEN_GetObject( (PENOBJ *)ptr, count, buffer );
 578           break;
 579       case BRUSH_MAGIC:
 580           result = BRUSH_GetObject( (BRUSHOBJ *)ptr, count, buffer );
 581           break;
 582       case BITMAP_MAGIC:
 583           result = BITMAP_GetObject( (BITMAPOBJ *)ptr, count, buffer );
 584           break;
 585       case FONT_MAGIC:
 586           result = FONT_GetObjectW( (FONTOBJ *)ptr, count, buffer );
 587           break;
 588       case PALETTE_MAGIC:
 589           result = PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
 590           break;
 591       default:
 592           FIXME("Magic %04x not implemented\n", GDIMAGIC(ptr->wMagic) );
 593           break;
 594     }
 595     GDI_ReleaseObj( handle );
 596     return result;
 597 }
 598
 599 /***********************************************************************
 600  *           GetObjectType    (GDI32.@)
 601  */
 602 DWORD WINAPI GetObjectType( HANDLE handle )
 603 {
 604     GDIOBJHDR * ptr;
 605     INT result = 0;
 606     TRACE("%08x\n", handle );
 607
 608     if (!(ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE ))) return 0;
 609
 610     switch(GDIMAGIC(ptr->wMagic))
 611     {
 612       case PEN_MAGIC:
 613           result = OBJ_PEN;
 614           break;
 615       case BRUSH_MAGIC:
 616           result = OBJ_BRUSH;
 617           break;
 618       case BITMAP_MAGIC:
 619           result = OBJ_BITMAP;
 620           break;
 621       case FONT_MAGIC:
 622           result = OBJ_FONT;
 623           break;
 624       case PALETTE_MAGIC:
 625           result = OBJ_PAL;
 626           break;
 627       case REGION_MAGIC:
 628           result = OBJ_REGION;
 629           break;
 630       case DC_MAGIC:
 631           result = OBJ_DC;
 632           break;
 633       case META_DC_MAGIC:
 634           result = OBJ_METADC;
 635           break;
 636       case METAFILE_MAGIC:
 637           result = OBJ_METAFILE;
 638           break;
 639       case METAFILE_DC_MAGIC:
 640           result = OBJ_METADC;
 641           break;
 642       case ENHMETAFILE_MAGIC:
 643           result = OBJ_ENHMETAFILE;
 644           break;
 645       case ENHMETAFILE_DC_MAGIC:
 646           result = OBJ_ENHMETADC;
 647           break;
 648       default:
 649           FIXME("Magic %04x not implemented\n", GDIMAGIC(ptr->wMagic) );
 650           break;
 651     }
 652     GDI_ReleaseObj( handle );
 653     return result;
 654 }
 655
 656 /***********************************************************************
 657  *           GetCurrentObject           (GDI32.@)
 658  */
 659 HANDLE WINAPI GetCurrentObject(HDC hdc,UINT type)
 660 {
 661     HANDLE ret = 0;
 662     DC * dc = DC_GetDCPtr( hdc );
 663
 664     if (dc)
 665     {
 666     switch (type) {
 667         case OBJ_PEN:    ret = dc->hPen; break;
 668         case OBJ_BRUSH:  ret = dc->hBrush; break;
 669         case OBJ_PAL:    ret = dc->hPalette; break;
 670         case OBJ_FONT:   ret = dc->hFont; break;
 671         case OBJ_BITMAP: ret = dc->hBitmap; break;
 672     default:
 673         /* the SDK only mentions those above */
 674         FIXME("(%08x,%d): unknown type.\n",hdc,type);
 675             break;
 676         }
 677         GDI_ReleaseObj( hdc );
 678     }
 679     return ret;
 680 }
 681
 682
 683 /***********************************************************************
 684  *           SelectObject    (GDI.45)
 685  */
 686 HGDIOBJ16 WINAPI SelectObject16( HDC16 hdc, HGDIOBJ16 handle )
 687 {
 688     return (HGDIOBJ16)SelectObject( hdc, handle );
 689 }
 690
 691
 692 /***********************************************************************
 693  *           SelectObject    (GDI32.@)
 694  */
 695 HGDIOBJ WINAPI SelectObject( HDC hdc, HGDIOBJ handle )
 696 {
 697     HGDIOBJ ret = 0;
 698     DC * dc = DC_GetDCUpdate( hdc );
 699     if (!dc) return 0;
 700     TRACE("hdc=%04x %04x\n", hdc, handle );
 701     if (dc->funcs->pSelectObject)
 702         ret = dc->funcs->pSelectObject( dc, handle );
 703     GDI_ReleaseObj( hdc );
 704     return ret;
 705 }
 706
 707
 708 /***********************************************************************
 709  *           UnrealizeObject    (GDI.150)
 710  */
 711 BOOL16 WINAPI UnrealizeObject16( HGDIOBJ16 obj )
 712 {
 713     return UnrealizeObject( obj );
 714 }
 715
 716
 717 /***********************************************************************
 718  *           UnrealizeObject    (GDI32.@)
 719  */
 720 BOOL WINAPI UnrealizeObject( HGDIOBJ obj )
 721 {
 722     BOOL result = TRUE;
 723   /* Check if object is valid */
 724
 725     GDIOBJHDR * header = GDI_GetObjPtr( obj, MAGIC_DONTCARE );
 726     if (!header) return FALSE;
 727
 728     TRACE("%04x\n", obj );
 729
 730       /* Unrealize object */
 731
 732     switch(GDIMAGIC(header->wMagic))
 733     {
 734     case PALETTE_MAGIC:
 735         result = PALETTE_UnrealizeObject( obj, (PALETTEOBJ *)header );
 736         break;
 737
 738     case BRUSH_MAGIC:
 739         /* Windows resets the brush origin. We don't need to. */
 740         break;
 741     }
 742     GDI_ReleaseObj( obj );
 743     return result;
 744 }
 745
 746
 747 /***********************************************************************
 748  *           EnumObjects16    (GDI.71)
 749  */
 750 INT16 WINAPI EnumObjects16( HDC16 hdc, INT16 nObjType,
 751                             GOBJENUMPROC16 lpEnumFunc, LPARAM lParam )
 752 {
 753     /* Solid colors to enumerate */
 754     static const COLORREF solid_colors[] =
 755     { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
 756       RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
 757       RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
 758       RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
 759       RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
 760       RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
 761       RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
 762       RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
 763     };
 764
 765     INT16 i, retval = 0;
 766     LOGPEN16 *pen;
 767     LOGBRUSH16 *brush = NULL;
 768
 769     TRACE("%04x %d %08lx %08lx\n",
 770                  hdc, nObjType, (DWORD)lpEnumFunc, lParam );
 771     switch(nObjType)
 772     {
 773     case OBJ_PEN:
 774         /* Enumerate solid pens */
 775         if (!(pen = SEGPTR_NEW(LOGPEN16))) break;
 776         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 777         {
 778             pen->lopnStyle   = PS_SOLID;
 779             pen->lopnWidth.x = 1;
 780             pen->lopnWidth.y = 0;
 781             pen->lopnColor   = solid_colors[i];
 782             retval = lpEnumFunc( SEGPTR_GET(pen), lParam );
 783             TRACE("solid pen %08lx, ret=%d\n",
 784                          solid_colors[i], retval);
 785             if (!retval) break;
 786         }
 787         SEGPTR_FREE(pen);
 788         break;
 789
 790     case OBJ_BRUSH:
 791         /* Enumerate solid brushes */
 792         if (!(brush = SEGPTR_NEW(LOGBRUSH16))) break;
 793         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 794         {
 795             brush->lbStyle = BS_SOLID;
 796             brush->lbColor = solid_colors[i];
 797             brush->lbHatch = 0;
 798             retval = lpEnumFunc( SEGPTR_GET(brush), lParam );
 799             TRACE("solid brush %08lx, ret=%d\n",
 800                          solid_colors[i], retval);
 801             if (!retval) break;
 802         }
 803
 804         /* Now enumerate hatched brushes */
 805         if (retval) for (i = HS_HORIZONTAL; i <= HS_DIAGCROSS; i++)
 806         {
 807             brush->lbStyle = BS_HATCHED;
 808             brush->lbColor = RGB(0,0,0);
 809             brush->lbHatch = i;
 810             retval = lpEnumFunc( SEGPTR_GET(brush), lParam );
 811             TRACE("hatched brush %d, ret=%d\n",
 812                          i, retval);
 813             if (!retval) break;
 814         }
 815         SEGPTR_FREE(brush);
 816         break;
 817
 818     default:
 819         WARN("(%d): Invalid type\n", nObjType );
 820         break;
 821     }
 822     return retval;
 823 }
 824
 825
 826 /***********************************************************************
 827  *           EnumObjects    (GDI32.@)
 828  */
 829 INT WINAPI EnumObjects( HDC hdc, INT nObjType,
 830                             GOBJENUMPROC lpEnumFunc, LPARAM lParam )
 831 {
 832     /* Solid colors to enumerate */
 833     static const COLORREF solid_colors[] =
 834     { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
 835       RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
 836       RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
 837       RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
 838       RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
 839       RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
 840       RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
 841       RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
 842     };
 843
 844     INT i, retval = 0;
 845     LOGPEN pen;
 846     LOGBRUSH brush;
 847
 848     TRACE("%04x %d %08lx %08lx\n",
 849                  hdc, nObjType, (DWORD)lpEnumFunc, lParam );
 850     switch(nObjType)
 851     {
 852     case OBJ_PEN:
 853         /* Enumerate solid pens */
 854         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 855         {
 856             pen.lopnStyle   = PS_SOLID;
 857             pen.lopnWidth.x = 1;
 858             pen.lopnWidth.y = 0;
 859             pen.lopnColor   = solid_colors[i];
 860             retval = lpEnumFunc( &pen, lParam );
 861             TRACE("solid pen %08lx, ret=%d\n",
 862                          solid_colors[i], retval);
 863             if (!retval) break;
 864         }
 865         break;
 866
 867     case OBJ_BRUSH:
 868         /* Enumerate solid brushes */
 869         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 870         {
 871             brush.lbStyle = BS_SOLID;
 872             brush.lbColor = solid_colors[i];
 873             brush.lbHatch = 0;
 874             retval = lpEnumFunc( &brush, lParam );
 875             TRACE("solid brush %08lx, ret=%d\n",
 876                          solid_colors[i], retval);
 877             if (!retval) break;
 878         }
 879
 880         /* Now enumerate hatched brushes */
 881         if (retval) for (i = HS_HORIZONTAL; i <= HS_DIAGCROSS; i++)
 882         {
 883             brush.lbStyle = BS_HATCHED;
 884             brush.lbColor = RGB(0,0,0);
 885             brush.lbHatch = i;
 886             retval = lpEnumFunc( &brush, lParam );
 887             TRACE("hatched brush %d, ret=%d\n",
 888                          i, retval);
 889             if (!retval) break;
 890         }
 891         break;
 892
 893     default:
 894         /* FIXME: implement Win32 types */
 895         WARN("(%d): Invalid type\n", nObjType );
 896         break;
 897     }
 898     return retval;
 899 }
 900
 901
 902 /***********************************************************************
 903  *           IsGDIObject    (GDI.462)
 904  *
 905  * returns type of object if valid (W95 system programming secrets p. 264-5)
 906  */
 907 BOOL16 WINAPI IsGDIObject16( HGDIOBJ16 handle )
 908 {
 909     UINT16 magic = 0;
 910
 911     GDIOBJHDR *object = GDI_GetObjPtr( handle, MAGIC_DONTCARE );
 912     if (object)
 913     {
 914         magic = GDIMAGIC(object->wMagic) - PEN_MAGIC + 1;
 915         GDI_ReleaseObj( handle );
 916     }
 917     return magic;
 918 }
 919
 920
 921 /***********************************************************************
 922  *           SetObjectOwner    (GDI.461)
 923  */
 924 void WINAPI SetObjectOwner16( HGDIOBJ16 handle, HANDLE16 owner )
 925 {
 926     /* Nothing to do */
 927 }
 928
 929
 930 /***********************************************************************
 931  *           SetObjectOwner    (GDI32.@)
 932  */
 933 void WINAPI SetObjectOwner( HGDIOBJ handle, HANDLE owner )
 934 {
 935     /* Nothing to do */
 936 }
 937
 938
 939 /***********************************************************************
 940  *           MakeObjectPrivate    (GDI.463)
 941  *
 942  * What does that mean ?
 943  * Some little docu can be found in "Undocumented Windows",
 944  * but this is basically useless.
 945  * At least we know that this flags the GDI object's wMagic
 946  * with 0x2000 (OBJECT_PRIVATE), so we just do it.
 947  * But Wine doesn't react on that yet.
 948  */
 949 void WINAPI MakeObjectPrivate16( HGDIOBJ16 handle, BOOL16 private )
 950 {
 951     GDIOBJHDR *ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE );
 952     if (!ptr)
 953     {
 954         ERR("invalid GDI object %04x !\n", handle);
 955         return;
 956     }
 957     ptr->wMagic |= OBJECT_PRIVATE;
 958     GDI_ReleaseObj( handle );
 959 }
 960
 961
 962 /***********************************************************************
 963  *           GdiFlush    (GDI32.@)
 964  */
 965 BOOL WINAPI GdiFlush(void)
 966 {
 967     return TRUE;  /* FIXME */
 968 }
 969
 970
 971 /***********************************************************************
 972  *           GdiGetBatchLimit    (GDI32.@)
 973  */
 974 DWORD WINAPI GdiGetBatchLimit(void)
 975 {
 976     return 1;  /* FIXME */
 977 }
 978
 979
 980 /***********************************************************************
 981  *           GdiSetBatchLimit    (GDI32.@)
 982  */
 983 DWORD WINAPI GdiSetBatchLimit( DWORD limit )
 984 {
 985     return 1; /* FIXME */
 986 }
 987
 988
 989 /***********************************************************************
 990  *           GdiSeeGdiDo   (GDI.452)
 991  */
 992 DWORD WINAPI GdiSeeGdiDo16( WORD wReqType, WORD wParam1, WORD wParam2,
 993                           WORD wParam3 )
 994 {
 995     switch (wReqType)
 996     {
 997     case 0x0001:  /* LocalAlloc */
 998         return LOCAL_Alloc( GDI_HeapSel, wParam1, wParam3 );
 999     case 0x0002:  /* LocalFree */
1000         return LOCAL_Free( GDI_HeapSel, wParam1 );
1001     case 0x0003:  /* LocalCompact */
1002         return LOCAL_Compact( GDI_HeapSel, wParam3, 0 );
1003     case 0x0103:  /* LocalHeap */
1004         return GDI_HeapSel;
1005     default:
1006         WARN("(wReqType=%04x): Unknown\n", wReqType);
1007         return (DWORD)-1;
1008     }
1009 }
1010
1011 /***********************************************************************
1012  *           GdiSignalProc32     (GDI.610)
1013  */
1014 WORD WINAPI GdiSignalProc( UINT uCode, DWORD dwThreadOrProcessID,
1015                            DWORD dwFlags, HMODULE16 hModule )
1016 {
1017     return 0;
1018 }
1019
1020 /***********************************************************************
1021  *           FinalGdiInit     (GDI.405)
1022  */
1023 void WINAPI FinalGdiInit16( HANDLE16 unknown )
1024 {
1025 }
1026
1027 /***********************************************************************
1028  *           GdiFreeResources   (GDI.609)
1029  */
1030 WORD WINAPI GdiFreeResources16( DWORD reserve )
1031 {
1032    return (WORD)( (int)LOCAL_CountFree( GDI_HeapSel ) * 100 /
1033                   (int)LOCAL_HeapSize( GDI_HeapSel ) );
1034 }
1035
1036 /***********************************************************************
1037  *           MulDiv   (GDI.128)
1038  */
1039 INT16 WINAPI MulDiv16(
1040              INT16 nMultiplicand,
1041              INT16 nMultiplier,
1042              INT16 nDivisor)
1043 {
1044     INT ret;
1045     if (!nDivisor) return -32768;
1046     /* We want to deal with a positive divisor to simplify the logic. */
1047     if (nDivisor < 0)
1048     {
1049       nMultiplicand = - nMultiplicand;
1050       nDivisor = -nDivisor;
1051     }
1052     /* If the result is positive, we "add" to round. else,
1053      * we subtract to round. */
1054     if ( ( (nMultiplicand <  0) && (nMultiplier <  0) ) ||
1055          ( (nMultiplicand >= 0) && (nMultiplier >= 0) ) )
1056         ret = (((int)nMultiplicand * nMultiplier) + (nDivisor/2)) / nDivisor;
1057     else
1058         ret = (((int)nMultiplicand * nMultiplier) - (nDivisor/2)) / nDivisor;
1059     if ((ret > 32767) || (ret < -32767)) return -32768;
1060     return (INT16) ret;
1061 }
1062
1063
1064 /*******************************************************************
1065  *      GetColorAdjustment [GDI32.@]
1066  *
1067  *
1068  */
1069 BOOL WINAPI GetColorAdjustment(HDC hdc, LPCOLORADJUSTMENT lpca)
1070 {
1071         FIXME("GetColorAdjustment, stub\n");
1072         return 0;
1073 }
1074
1075 /*******************************************************************
1076  *      GetMiterLimit [GDI32.@]
1077  *
1078  *
1079  */
1080 BOOL WINAPI GetMiterLimit(HDC hdc, PFLOAT peLimit)
1081 {
1082         FIXME("GetMiterLimit, stub\n");
1083         return 0;
1084 }
1085
1086 /*******************************************************************
1087  *      SetMiterLimit [GDI32.@]
1088  *
1089  *
1090  */
1091 BOOL WINAPI SetMiterLimit(HDC hdc, FLOAT eNewLimit, PFLOAT peOldLimit)
1092 {
1093         FIXME("SetMiterLimit, stub\n");
1094         return 0;
1095 }
1096
1097 /*******************************************************************
1098  *      GdiComment [GDI32.@]
1099  *
1100  *
1101  */
1102 BOOL WINAPI GdiComment(HDC hdc, UINT cbSize, const BYTE *lpData)
1103 {
1104         FIXME("GdiComment, stub\n");
1105         return 0;
1106 }
1107 /*******************************************************************
1108  *      SetColorAdjustment [GDI32.@]
1109  *
1110  *
1111  */
1112 BOOL WINAPI SetColorAdjustment(HDC hdc, const COLORADJUSTMENT* lpca)
1113 {
1114         FIXME("SetColorAdjustment, stub\n");
1115         return 0;
1116 }
1117