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 /* Solid colors to enumerate */
 864 static const COLORREF solid_colors[] =
 865 { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
 866 RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
 867 RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
 868 RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
 869 RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
 870 RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
 871 RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
 872 RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
 873 };
 874
 875 /***********************************************************************
 876  *           EnumObjects    (GDI.71)
 877  */
 878 INT16 WINAPI EnumObjects16( HDC16 hdc, INT16 nObjType,
 879                             GOBJENUMPROC16 lpEnumFunc, LPARAM lParam )
 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     INT i, retval = 0;
 947     LOGPEN pen;
 948     LOGBRUSH brush;
 949
 950     TRACE("%04x %d %08lx %08lx\n",
 951                  hdc, nObjType, (DWORD)lpEnumFunc, lParam );
 952     switch(nObjType)
 953     {
 954     case OBJ_PEN:
 955         /* Enumerate solid pens */
 956         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 957         {
 958             pen.lopnStyle   = PS_SOLID;
 959             pen.lopnWidth.x = 1;
 960             pen.lopnWidth.y = 0;
 961             pen.lopnColor   = solid_colors[i];
 962             retval = lpEnumFunc( &pen, lParam );
 963             TRACE("solid pen %08lx, ret=%d\n",
 964                          solid_colors[i], retval);
 965             if (!retval) break;
 966         }
 967         break;
 968
 969     case OBJ_BRUSH:
 970         /* Enumerate solid brushes */
 971         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 972         {
 973             brush.lbStyle = BS_SOLID;
 974             brush.lbColor = solid_colors[i];
 975             brush.lbHatch = 0;
 976             retval = lpEnumFunc( &brush, lParam );
 977             TRACE("solid brush %08lx, ret=%d\n",
 978                          solid_colors[i], retval);
 979             if (!retval) break;
 980         }
 981
 982         /* Now enumerate hatched brushes */
 983         if (retval) for (i = HS_HORIZONTAL; i <= HS_DIAGCROSS; i++)
 984         {
 985             brush.lbStyle = BS_HATCHED;
 986             brush.lbColor = RGB(0,0,0);
 987             brush.lbHatch = i;
 988             retval = lpEnumFunc( &brush, lParam );
 989             TRACE("hatched brush %d, ret=%d\n",
 990                          i, retval);
 991             if (!retval) break;
 992         }
 993         break;
 994
 995     default:
 996         /* FIXME: implement Win32 types */
 997         WARN("(%d): Invalid type\n", nObjType );
 998         break;
 999     }
1000     return retval;
1001 }
1002
1003
1004 /***********************************************************************
1005  *           IsGDIObject    (GDI.462)
1006  *
1007  * returns type of object if valid (W95 system programming secrets p. 264-5)
1008  */
1009 BOOL16 WINAPI IsGDIObject16( HGDIOBJ16 handle )
1010 {
1011     UINT16 magic = 0;
1012
1013     GDIOBJHDR *object = GDI_GetObjPtr( handle, MAGIC_DONTCARE );
1014     if (object)
1015     {
1016         magic = GDIMAGIC(object->wMagic) - PEN_MAGIC + 1;
1017         GDI_ReleaseObj( handle );
1018     }
1019     return magic;
1020 }
1021
1022
1023 /***********************************************************************
1024  *           SetObjectOwner    (GDI.461)
1025  */
1026 void WINAPI SetObjectOwner16( HGDIOBJ16 handle, HANDLE16 owner )
1027 {
1028     /* Nothing to do */
1029 }
1030
1031
1032 /***********************************************************************
1033  *           SetObjectOwner    (GDI32.@)
1034  */
1035 void WINAPI SetObjectOwner( HGDIOBJ handle, HANDLE owner )
1036 {
1037     /* Nothing to do */
1038 }
1039
1040
1041 /***********************************************************************
1042  *           MakeObjectPrivate    (GDI.463)
1043  *
1044  * What does that mean ?
1045  * Some little docu can be found in "Undocumented Windows",
1046  * but this is basically useless.
1047  * At least we know that this flags the GDI object's wMagic
1048  * with 0x2000 (OBJECT_PRIVATE), so we just do it.
1049  * But Wine doesn't react on that yet.
1050  */
1051 void WINAPI MakeObjectPrivate16( HGDIOBJ16 handle, BOOL16 private )
1052 {
1053     GDIOBJHDR *ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE );
1054     if (!ptr)
1055     {
1056         ERR("invalid GDI object %04x !\n", handle);
1057         return;
1058     }
1059     ptr->wMagic |= OBJECT_PRIVATE;
1060     GDI_ReleaseObj( handle );
1061 }
1062
1063
1064 /***********************************************************************
1065  *           GdiFlush    (GDI32.@)
1066  */
1067 BOOL WINAPI GdiFlush(void)
1068 {
1069     return TRUE;  /* FIXME */
1070 }
1071
1072
1073 /***********************************************************************
1074  *           GdiGetBatchLimit    (GDI32.@)
1075  */
1076 DWORD WINAPI GdiGetBatchLimit(void)
1077 {
1078     return 1;  /* FIXME */
1079 }
1080
1081
1082 /***********************************************************************
1083  *           GdiSetBatchLimit    (GDI32.@)
1084  */
1085 DWORD WINAPI GdiSetBatchLimit( DWORD limit )
1086 {
1087     return 1; /* FIXME */
1088 }
1089
1090
1091 /***********************************************************************
1092  *           GdiSeeGdiDo   (GDI.452)
1093  */
1094 DWORD WINAPI GdiSeeGdiDo16( WORD wReqType, WORD wParam1, WORD wParam2,
1095                           WORD wParam3 )
1096 {
1097     switch (wReqType)
1098     {
1099     case 0x0001:  /* LocalAlloc */
1100         return LOCAL_Alloc( GDI_HeapSel, wParam1, wParam3 );
1101     case 0x0002:  /* LocalFree */
1102         return LOCAL_Free( GDI_HeapSel, wParam1 );
1103     case 0x0003:  /* LocalCompact */
1104         return LOCAL_Compact( GDI_HeapSel, wParam3, 0 );
1105     case 0x0103:  /* LocalHeap */
1106         return GDI_HeapSel;
1107     default:
1108         WARN("(wReqType=%04x): Unknown\n", wReqType);
1109         return (DWORD)-1;
1110     }
1111 }
1112
1113 /***********************************************************************
1114  *           GdiSignalProc32     (GDI.610)
1115  */
1116 WORD WINAPI GdiSignalProc( UINT uCode, DWORD dwThreadOrProcessID,
1117                            DWORD dwFlags, HMODULE16 hModule )
1118 {
1119     return 0;
1120 }
1121
1122 /***********************************************************************
1123  *           GdiInit2     (GDI.403)
1124  *
1125  * See "Undocumented Windows"
1126  */
1127 HANDLE16 WINAPI GdiInit216(
1128     HANDLE16 h1, /* [in] GDI object */
1129     HANDLE16 h2  /* [in] global data */
1130 )
1131 {
1132     FIXME("(%04x, %04x), stub.\n", h1, h2);
1133     if (h2 == 0xffff)
1134         return 0xffff; /* undefined return value */
1135     return h1; /* FIXME: should be the memory handle of h1 */
1136 }
1137
1138 /***********************************************************************
1139  *           FinalGdiInit     (GDI.405)
1140  */
1141 void WINAPI FinalGdiInit16( HBRUSH16 hPattern /* [in] fill pattern of desktop */ )
1142 {
1143 }
1144
1145 /***********************************************************************
1146  *           GdiFreeResources   (GDI.609)
1147  */
1148 WORD WINAPI GdiFreeResources16( DWORD reserve )
1149 {
1150    return (WORD)( (int)LOCAL_CountFree( GDI_HeapSel ) * 100 /
1151                   (int)LOCAL_HeapSize( GDI_HeapSel ) );
1152 }
1153
1154 /***********************************************************************
1155  *           MulDiv   (GDI.128)
1156  */
1157 INT16 WINAPI MulDiv16(
1158              INT16 nMultiplicand,
1159              INT16 nMultiplier,
1160              INT16 nDivisor)
1161 {
1162     INT ret;
1163     if (!nDivisor) return -32768;
1164     /* We want to deal with a positive divisor to simplify the logic. */
1165     if (nDivisor < 0)
1166     {
1167       nMultiplicand = - nMultiplicand;
1168       nDivisor = -nDivisor;
1169     }
1170     /* If the result is positive, we "add" to round. else,
1171      * we subtract to round. */
1172     if ( ( (nMultiplicand <  0) && (nMultiplier <  0) ) ||
1173          ( (nMultiplicand >= 0) && (nMultiplier >= 0) ) )
1174         ret = (((int)nMultiplicand * nMultiplier) + (nDivisor/2)) / nDivisor;
1175     else
1176         ret = (((int)nMultiplicand * nMultiplier) - (nDivisor/2)) / nDivisor;
1177     if ((ret > 32767) || (ret < -32767)) return -32768;
1178     return (INT16) ret;
1179 }
1180
1181
1182 /*******************************************************************
1183  *      GetColorAdjustment [GDI32.@]
1184  *
1185  *
1186  */
1187 BOOL WINAPI GetColorAdjustment(HDC hdc, LPCOLORADJUSTMENT lpca)
1188 {
1189         FIXME("GetColorAdjustment, stub\n");
1190         return 0;
1191 }
1192
1193 /*******************************************************************
1194  *      GetMiterLimit [GDI32.@]
1195  *
1196  *
1197  */
1198 BOOL WINAPI GetMiterLimit(HDC hdc, PFLOAT peLimit)
1199 {
1200         FIXME("GetMiterLimit, stub\n");
1201         return 0;
1202 }
1203
1204 /*******************************************************************
1205  *      SetMiterLimit [GDI32.@]
1206  *
1207  *
1208  */
1209 BOOL WINAPI SetMiterLimit(HDC hdc, FLOAT eNewLimit, PFLOAT peOldLimit)
1210 {
1211         FIXME("SetMiterLimit, stub\n");
1212         return 0;
1213 }
1214
1215 /*******************************************************************
1216  *      GdiComment [GDI32.@]
1217  *
1218  *
1219  */
1220 BOOL WINAPI GdiComment(HDC hdc, UINT cbSize, const BYTE *lpData)
1221 {
1222         FIXME("GdiComment, stub\n");
1223         return 0;
1224 }
1225 /*******************************************************************
1226  *      SetColorAdjustment [GDI32.@]
1227  *
1228  *
1229  */
1230 BOOL WINAPI SetColorAdjustment(HDC hdc, const COLORADJUSTMENT* lpca)
1231 {
1232         FIXME("SetColorAdjustment, stub\n");
1233         return 0;
1234 }
1235