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