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 && large_handles[i])
 324         {
 325             HeapFree( GetProcessHeap(), 0, large_handles[i] );
 326             large_handles[i] = NULL;
 327         }
 328     }
 329     TRACE_SEC( handle, "leave" );
 330     _LeaveSysLevel( &GDI_level );
 331     return TRUE;
 332 }
 333
 334
 335 /***********************************************************************
 336  *           GDI_GetObjPtr
 337  *
 338  * Return a pointer to the GDI object associated to the handle.
 339  * Return NULL if the object has the wrong magic number.
 340  * The object must be released with GDI_ReleaseObj.
 341  */
 342 void *GDI_GetObjPtr( HGDIOBJ handle, WORD magic )
 343 {
 344     GDIOBJHDR *ptr = NULL;
 345
 346     _EnterSysLevel( &GDI_level );
 347
 348     if (handle & 2)  /* GDI heap handle */
 349     {
 350         ptr = (GDIOBJHDR *)LOCAL_Lock( GDI_HeapSel, handle );
 351         if (ptr && (magic != MAGIC_DONTCARE) && (GDIMAGIC(ptr->wMagic) != magic))
 352         {
 353             LOCAL_Unlock( GDI_HeapSel, handle );
 354             ptr = NULL;
 355         }
 356     }
 357     else  /* large heap handle */
 358     {
 359         int i = (handle >> 2) - FIRST_LARGE_HANDLE;
 360         if (i >= 0)
 361         {
 362             ptr = large_handles[i];
 363             if (ptr && (magic != MAGIC_DONTCARE) && (GDIMAGIC(ptr->wMagic) != magic)) ptr = NULL;
 364         }
 365     }
 366
 367     if (!ptr)
 368     {
 369         _LeaveSysLevel( &GDI_level );
 370         SetLastError( ERROR_INVALID_HANDLE );
 371     }
 372     else TRACE_SEC( handle, "enter" );
 373
 374     return ptr;
 375 }
 376
 377
 378 /***********************************************************************
 379  *           GDI_ReleaseObj
 380  *
 381  */
 382 void GDI_ReleaseObj( HGDIOBJ handle )
 383 {
 384     if (handle & 2) LOCAL_Unlock( GDI_HeapSel, handle );
 385     TRACE_SEC( handle, "leave" );
 386     _LeaveSysLevel( &GDI_level );
 387 }
 388
 389
 390 /***********************************************************************
 391  *           GDI_CheckNotLock
 392  */
 393 void GDI_CheckNotLock(void)
 394 {
 395     _CheckNotSysLevel( &GDI_level );
 396 }
 397
 398
 399 /***********************************************************************
 400  *           DeleteObject    (GDI.69)
 401  *           SysDeleteObject (GDI.605)
 402  */
 403 BOOL16 WINAPI DeleteObject16( HGDIOBJ16 obj )
 404 {
 405     return DeleteObject( obj );
 406 }
 407
 408
 409 /***********************************************************************
 410  *           DeleteObject    (GDI32.@)
 411  */
 412 BOOL WINAPI DeleteObject( HGDIOBJ obj )
 413 {
 414       /* Check if object is valid */
 415
 416     GDIOBJHDR * header;
 417     if (HIWORD(obj)) return FALSE;
 418
 419     if (!(header = GDI_GetObjPtr( obj, MAGIC_DONTCARE ))) return FALSE;
 420
 421     if (!(header->wMagic & OBJECT_NOSYSTEM)
 422     &&   (header->wMagic >= FIRST_MAGIC) && (header->wMagic <= LAST_MAGIC))
 423     {
 424         TRACE("Preserving system object %04x\n", obj);
 425         GDI_ReleaseObj( obj );
 426         return TRUE;
 427     }
 428
 429     TRACE("%04x\n", obj );
 430
 431       /* Delete object */
 432
 433     switch(GDIMAGIC(header->wMagic))
 434     {
 435       case PEN_MAGIC:     return GDI_FreeObject( obj, header );
 436       case BRUSH_MAGIC:   return BRUSH_DeleteObject( obj, (BRUSHOBJ*)header );
 437       case FONT_MAGIC:    return GDI_FreeObject( obj, header );
 438       case PALETTE_MAGIC: return PALETTE_DeleteObject(obj,(PALETTEOBJ*)header);
 439       case BITMAP_MAGIC:  return BITMAP_DeleteObject( obj, (BITMAPOBJ*)header);
 440       case REGION_MAGIC:  return REGION_DeleteObject( obj, (RGNOBJ*)header );
 441       case DC_MAGIC:
 442           GDI_ReleaseObj( obj );
 443           return DeleteDC(obj);
 444       case 0 :
 445         WARN("Already deleted\n");
 446         break;
 447       default:
 448         WARN("Unknown magic number (%d)\n",GDIMAGIC(header->wMagic));
 449     }
 450     GDI_ReleaseObj( obj );
 451     return FALSE;
 452 }
 453
 454 /***********************************************************************
 455  *           GetStockObject    (GDI.87)
 456  */
 457 HGDIOBJ16 WINAPI GetStockObject16( INT16 obj )
 458 {
 459     return (HGDIOBJ16)GetStockObject( obj );
 460 }
 461
 462
 463 /***********************************************************************
 464  *           GetStockObject    (GDI32.@)
 465  */
 466 HGDIOBJ WINAPI GetStockObject( INT obj )
 467 {
 468     HGDIOBJ ret;
 469     if ((obj < 0) || (obj >= NB_STOCK_OBJECTS)) return 0;
 470     ret = stock_objects[obj];
 471     TRACE("returning %4x\n", ret );
 472     return ret;
 473 }
 474
 475
 476 /***********************************************************************
 477  *           GetObject    (GDI.82)
 478  */
 479 INT16 WINAPI GetObject16( HANDLE16 handle, INT16 count, LPVOID buffer )
 480 {
 481     GDIOBJHDR * ptr;
 482     INT16 result = 0;
 483     TRACE("%04x %d %p\n", handle, count, buffer );
 484     if (!count) return 0;
 485
 486     if (!(ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE ))) return 0;
 487
 488     switch(GDIMAGIC(ptr->wMagic))
 489       {
 490       case PEN_MAGIC:
 491         result = PEN_GetObject16( (PENOBJ *)ptr, count, buffer );
 492         break;
 493       case BRUSH_MAGIC:
 494         result = BRUSH_GetObject16( (BRUSHOBJ *)ptr, count, buffer );
 495         break;
 496       case BITMAP_MAGIC:
 497         result = BITMAP_GetObject16( (BITMAPOBJ *)ptr, count, buffer );
 498         break;
 499       case FONT_MAGIC:
 500         result = FONT_GetObject16( (FONTOBJ *)ptr, count, buffer );
 501         break;
 502       case PALETTE_MAGIC:
 503         result = PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
 504         break;
 505       }
 506     GDI_ReleaseObj( handle );
 507     return result;
 508 }
 509
 510
 511 /***********************************************************************
 512  *           GetObjectA    (GDI32.@)
 513  */
 514 INT WINAPI GetObjectA( HANDLE handle, INT count, LPVOID buffer )
 515 {
 516     GDIOBJHDR * ptr;
 517     INT result = 0;
 518     TRACE("%08x %d %p\n", handle, count, buffer );
 519     if (!count) return 0;
 520
 521     if (!(ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE ))) return 0;
 522
 523     switch(GDIMAGIC(ptr->wMagic))
 524     {
 525       case PEN_MAGIC:
 526           result = PEN_GetObject( (PENOBJ *)ptr, count, buffer );
 527           break;
 528       case BRUSH_MAGIC:
 529           result = BRUSH_GetObject( (BRUSHOBJ *)ptr, count, buffer );
 530           break;
 531       case BITMAP_MAGIC:
 532           result = BITMAP_GetObject( (BITMAPOBJ *)ptr, count, buffer );
 533           break;
 534       case FONT_MAGIC:
 535           result = FONT_GetObjectA( (FONTOBJ *)ptr, count, buffer );
 536           break;
 537       case PALETTE_MAGIC:
 538           result = PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
 539           break;
 540
 541       case REGION_MAGIC:
 542       case DC_MAGIC:
 543       case DISABLED_DC_MAGIC:
 544       case META_DC_MAGIC:
 545       case METAFILE_MAGIC:
 546       case METAFILE_DC_MAGIC:
 547       case ENHMETAFILE_MAGIC:
 548       case ENHMETAFILE_DC_MAGIC:
 549           FIXME("Magic %04x not implemented\n", GDIMAGIC(ptr->wMagic) );
 550           break;
 551
 552       default:
 553           ERR("Invalid GDI Magic %04x\n", GDIMAGIC(ptr->wMagic));
 554           break;
 555     }
 556     GDI_ReleaseObj( handle );
 557     return result;
 558 }
 559
 560 /***********************************************************************
 561  *           GetObjectW    (GDI32.@)
 562  */
 563 INT WINAPI GetObjectW( HANDLE handle, INT count, LPVOID buffer )
 564 {
 565     GDIOBJHDR * ptr;
 566     INT result = 0;
 567     TRACE("%08x %d %p\n", handle, count, buffer );
 568     if (!count) return 0;
 569
 570     if (!(ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE ))) return 0;
 571
 572     switch(GDIMAGIC(ptr->wMagic))
 573     {
 574       case PEN_MAGIC:
 575           result = PEN_GetObject( (PENOBJ *)ptr, count, buffer );
 576           break;
 577       case BRUSH_MAGIC:
 578           result = BRUSH_GetObject( (BRUSHOBJ *)ptr, count, buffer );
 579           break;
 580       case BITMAP_MAGIC:
 581           result = BITMAP_GetObject( (BITMAPOBJ *)ptr, count, buffer );
 582           break;
 583       case FONT_MAGIC:
 584           result = FONT_GetObjectW( (FONTOBJ *)ptr, count, buffer );
 585           break;
 586       case PALETTE_MAGIC:
 587           result = PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
 588           break;
 589       default:
 590           FIXME("Magic %04x not implemented\n", GDIMAGIC(ptr->wMagic) );
 591           break;
 592     }
 593     GDI_ReleaseObj( handle );
 594     return result;
 595 }
 596
 597 /***********************************************************************
 598  *           GetObjectType    (GDI32.@)
 599  */
 600 DWORD WINAPI GetObjectType( HANDLE handle )
 601 {
 602     GDIOBJHDR * ptr;
 603     INT result = 0;
 604     TRACE("%08x\n", handle );
 605
 606     if (!(ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE ))) return 0;
 607
 608     switch(GDIMAGIC(ptr->wMagic))
 609     {
 610       case PEN_MAGIC:
 611           result = OBJ_PEN;
 612           break;
 613       case BRUSH_MAGIC:
 614           result = OBJ_BRUSH;
 615           break;
 616       case BITMAP_MAGIC:
 617           result = OBJ_BITMAP;
 618           break;
 619       case FONT_MAGIC:
 620           result = OBJ_FONT;
 621           break;
 622       case PALETTE_MAGIC:
 623           result = OBJ_PAL;
 624           break;
 625       case REGION_MAGIC:
 626           result = OBJ_REGION;
 627           break;
 628       case DC_MAGIC:
 629           result = OBJ_DC;
 630           break;
 631       case META_DC_MAGIC:
 632           result = OBJ_METADC;
 633           break;
 634       case METAFILE_MAGIC:
 635           result = OBJ_METAFILE;
 636           break;
 637       case METAFILE_DC_MAGIC:
 638           result = OBJ_METADC;
 639           break;
 640       case ENHMETAFILE_MAGIC:
 641           result = OBJ_ENHMETAFILE;
 642           break;
 643       case ENHMETAFILE_DC_MAGIC:
 644           result = OBJ_ENHMETADC;
 645           break;
 646       default:
 647           FIXME("Magic %04x not implemented\n", GDIMAGIC(ptr->wMagic) );
 648           break;
 649     }
 650     GDI_ReleaseObj( handle );
 651     return result;
 652 }
 653
 654 /***********************************************************************
 655  *           GetCurrentObject           (GDI32.@)
 656  */
 657 HANDLE WINAPI GetCurrentObject(HDC hdc,UINT type)
 658 {
 659     HANDLE ret = 0;
 660     DC * dc = DC_GetDCPtr( hdc );
 661
 662     if (dc)
 663     {
 664     switch (type) {
 665         case OBJ_PEN:    ret = dc->hPen; break;
 666         case OBJ_BRUSH:  ret = dc->hBrush; break;
 667         case OBJ_PAL:    ret = dc->hPalette; break;
 668         case OBJ_FONT:   ret = dc->hFont; break;
 669         case OBJ_BITMAP: ret = dc->hBitmap; break;
 670     default:
 671         /* the SDK only mentions those above */
 672         FIXME("(%08x,%d): unknown type.\n",hdc,type);
 673             break;
 674         }
 675         GDI_ReleaseObj( hdc );
 676     }
 677     return ret;
 678 }
 679
 680
 681 /***********************************************************************
 682  *           SelectObject    (GDI.45)
 683  */
 684 HGDIOBJ16 WINAPI SelectObject16( HDC16 hdc, HGDIOBJ16 handle )
 685 {
 686     return (HGDIOBJ16)SelectObject( hdc, handle );
 687 }
 688
 689
 690 /***********************************************************************
 691  *           SelectObject    (GDI32.@)
 692  */
 693 HGDIOBJ WINAPI SelectObject( HDC hdc, HGDIOBJ handle )
 694 {
 695     HGDIOBJ ret = 0;
 696     DC * dc = DC_GetDCUpdate( hdc );
 697     if (!dc) return 0;
 698     TRACE("hdc=%04x %04x\n", hdc, handle );
 699     if (dc->funcs->pSelectObject)
 700         ret = dc->funcs->pSelectObject( dc, handle );
 701     GDI_ReleaseObj( hdc );
 702     return ret;
 703 }
 704
 705
 706 /***********************************************************************
 707  *           UnrealizeObject    (GDI.150)
 708  */
 709 BOOL16 WINAPI UnrealizeObject16( HGDIOBJ16 obj )
 710 {
 711     return UnrealizeObject( obj );
 712 }
 713
 714
 715 /***********************************************************************
 716  *           UnrealizeObject    (GDI32.@)
 717  */
 718 BOOL WINAPI UnrealizeObject( HGDIOBJ obj )
 719 {
 720     BOOL result = TRUE;
 721   /* Check if object is valid */
 722
 723     GDIOBJHDR * header = GDI_GetObjPtr( obj, MAGIC_DONTCARE );
 724     if (!header) return FALSE;
 725
 726     TRACE("%04x\n", obj );
 727
 728       /* Unrealize object */
 729
 730     switch(GDIMAGIC(header->wMagic))
 731     {
 732     case PALETTE_MAGIC:
 733         result = PALETTE_UnrealizeObject( obj, (PALETTEOBJ *)header );
 734         break;
 735
 736     case BRUSH_MAGIC:
 737         /* Windows resets the brush origin. We don't need to. */
 738         break;
 739     }
 740     GDI_ReleaseObj( obj );
 741     return result;
 742 }
 743
 744
 745 /***********************************************************************
 746  *           EnumObjects16    (GDI.71)
 747  */
 748 INT16 WINAPI EnumObjects16( HDC16 hdc, INT16 nObjType,
 749                             GOBJENUMPROC16 lpEnumFunc, LPARAM lParam )
 750 {
 751     /* Solid colors to enumerate */
 752     static const COLORREF solid_colors[] =
 753     { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
 754       RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
 755       RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
 756       RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
 757       RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
 758       RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
 759       RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
 760       RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
 761     };
 762
 763     INT16 i, retval = 0;
 764     LOGPEN16 *pen;
 765     LOGBRUSH16 *brush = NULL;
 766
 767     TRACE("%04x %d %08lx %08lx\n",
 768                  hdc, nObjType, (DWORD)lpEnumFunc, lParam );
 769     switch(nObjType)
 770     {
 771     case OBJ_PEN:
 772         /* Enumerate solid pens */
 773         if (!(pen = SEGPTR_NEW(LOGPEN16))) break;
 774         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 775         {
 776             pen->lopnStyle   = PS_SOLID;
 777             pen->lopnWidth.x = 1;
 778             pen->lopnWidth.y = 0;
 779             pen->lopnColor   = solid_colors[i];
 780             retval = lpEnumFunc( SEGPTR_GET(pen), lParam );
 781             TRACE("solid pen %08lx, ret=%d\n",
 782                          solid_colors[i], retval);
 783             if (!retval) break;
 784         }
 785         SEGPTR_FREE(pen);
 786         break;
 787
 788     case OBJ_BRUSH:
 789         /* Enumerate solid brushes */
 790         if (!(brush = SEGPTR_NEW(LOGBRUSH16))) break;
 791         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 792         {
 793             brush->lbStyle = BS_SOLID;
 794             brush->lbColor = solid_colors[i];
 795             brush->lbHatch = 0;
 796             retval = lpEnumFunc( SEGPTR_GET(brush), lParam );
 797             TRACE("solid brush %08lx, ret=%d\n",
 798                          solid_colors[i], retval);
 799             if (!retval) break;
 800         }
 801
 802         /* Now enumerate hatched brushes */
 803         if (retval) for (i = HS_HORIZONTAL; i <= HS_DIAGCROSS; i++)
 804         {
 805             brush->lbStyle = BS_HATCHED;
 806             brush->lbColor = RGB(0,0,0);
 807             brush->lbHatch = i;
 808             retval = lpEnumFunc( SEGPTR_GET(brush), lParam );
 809             TRACE("hatched brush %d, ret=%d\n",
 810                          i, retval);
 811             if (!retval) break;
 812         }
 813         SEGPTR_FREE(brush);
 814         break;
 815
 816     default:
 817         WARN("(%d): Invalid type\n", nObjType );
 818         break;
 819     }
 820     return retval;
 821 }
 822
 823
 824 /***********************************************************************
 825  *           EnumObjects    (GDI32.@)
 826  */
 827 INT WINAPI EnumObjects( HDC hdc, INT nObjType,
 828                             GOBJENUMPROC lpEnumFunc, LPARAM lParam )
 829 {
 830     /* Solid colors to enumerate */
 831     static const COLORREF solid_colors[] =
 832     { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
 833       RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
 834       RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
 835       RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
 836       RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
 837       RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
 838       RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
 839       RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
 840     };
 841
 842     INT i, retval = 0;
 843     LOGPEN pen;
 844     LOGBRUSH brush;
 845
 846     TRACE("%04x %d %08lx %08lx\n",
 847                  hdc, nObjType, (DWORD)lpEnumFunc, lParam );
 848     switch(nObjType)
 849     {
 850     case OBJ_PEN:
 851         /* Enumerate solid pens */
 852         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 853         {
 854             pen.lopnStyle   = PS_SOLID;
 855             pen.lopnWidth.x = 1;
 856             pen.lopnWidth.y = 0;
 857             pen.lopnColor   = solid_colors[i];
 858             retval = lpEnumFunc( &pen, lParam );
 859             TRACE("solid pen %08lx, ret=%d\n",
 860                          solid_colors[i], retval);
 861             if (!retval) break;
 862         }
 863         break;
 864
 865     case OBJ_BRUSH:
 866         /* Enumerate solid brushes */
 867         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 868         {
 869             brush.lbStyle = BS_SOLID;
 870             brush.lbColor = solid_colors[i];
 871             brush.lbHatch = 0;
 872             retval = lpEnumFunc( &brush, lParam );
 873             TRACE("solid brush %08lx, ret=%d\n",
 874                          solid_colors[i], retval);
 875             if (!retval) break;
 876         }
 877
 878         /* Now enumerate hatched brushes */
 879         if (retval) for (i = HS_HORIZONTAL; i <= HS_DIAGCROSS; i++)
 880         {
 881             brush.lbStyle = BS_HATCHED;
 882             brush.lbColor = RGB(0,0,0);
 883             brush.lbHatch = i;
 884             retval = lpEnumFunc( &brush, lParam );
 885             TRACE("hatched brush %d, ret=%d\n",
 886                          i, retval);
 887             if (!retval) break;
 888         }
 889         break;
 890
 891     default:
 892         /* FIXME: implement Win32 types */
 893         WARN("(%d): Invalid type\n", nObjType );
 894         break;
 895     }
 896     return retval;
 897 }
 898
 899
 900 /***********************************************************************
 901  *           IsGDIObject    (GDI.462)
 902  *
 903  * returns type of object if valid (W95 system programming secrets p. 264-5)
 904  */
 905 BOOL16 WINAPI IsGDIObject16( HGDIOBJ16 handle )
 906 {
 907     UINT16 magic = 0;
 908
 909     GDIOBJHDR *object = GDI_GetObjPtr( handle, MAGIC_DONTCARE );
 910     if (object)
 911     {
 912         magic = GDIMAGIC(object->wMagic) - PEN_MAGIC + 1;
 913         GDI_ReleaseObj( handle );
 914     }
 915     return magic;
 916 }
 917
 918
 919 /***********************************************************************
 920  *           SetObjectOwner    (GDI.461)
 921  */
 922 void WINAPI SetObjectOwner16( HGDIOBJ16 handle, HANDLE16 owner )
 923 {
 924     /* Nothing to do */
 925 }
 926
 927
 928 /***********************************************************************
 929  *           SetObjectOwner    (GDI32.@)
 930  */
 931 void WINAPI SetObjectOwner( HGDIOBJ handle, HANDLE owner )
 932 {
 933     /* Nothing to do */
 934 }
 935
 936
 937 /***********************************************************************
 938  *           MakeObjectPrivate    (GDI.463)
 939  *
 940  * What does that mean ?
 941  * Some little docu can be found in "Undocumented Windows",
 942  * but this is basically useless.
 943  * At least we know that this flags the GDI object's wMagic
 944  * with 0x2000 (OBJECT_PRIVATE), so we just do it.
 945  * But Wine doesn't react on that yet.
 946  */
 947 void WINAPI MakeObjectPrivate16( HGDIOBJ16 handle, BOOL16 private )
 948 {
 949     GDIOBJHDR *ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE );
 950     if (!ptr)
 951     {
 952         ERR("invalid GDI object %04x !\n", handle);
 953         return;
 954     }
 955     ptr->wMagic |= OBJECT_PRIVATE;
 956     GDI_ReleaseObj( handle );
 957 }
 958
 959
 960 /***********************************************************************
 961  *           GdiFlush    (GDI32.@)
 962  */
 963 BOOL WINAPI GdiFlush(void)
 964 {
 965     return TRUE;  /* FIXME */
 966 }
 967
 968
 969 /***********************************************************************
 970  *           GdiGetBatchLimit    (GDI32.@)
 971  */
 972 DWORD WINAPI GdiGetBatchLimit(void)
 973 {
 974     return 1;  /* FIXME */
 975 }
 976
 977
 978 /***********************************************************************
 979  *           GdiSetBatchLimit    (GDI32.@)
 980  */
 981 DWORD WINAPI GdiSetBatchLimit( DWORD limit )
 982 {
 983     return 1; /* FIXME */
 984 }
 985
 986
 987 /***********************************************************************
 988  *           GdiSeeGdiDo   (GDI.452)
 989  */
 990 DWORD WINAPI GdiSeeGdiDo16( WORD wReqType, WORD wParam1, WORD wParam2,
 991                           WORD wParam3 )
 992 {
 993     switch (wReqType)
 994     {
 995     case 0x0001:  /* LocalAlloc */
 996         return LOCAL_Alloc( GDI_HeapSel, wParam1, wParam3 );
 997     case 0x0002:  /* LocalFree */
 998         return LOCAL_Free( GDI_HeapSel, wParam1 );
 999     case 0x0003:  /* LocalCompact */
1000         return LOCAL_Compact( GDI_HeapSel, wParam3, 0 );
1001     case 0x0103:  /* LocalHeap */
1002         return GDI_HeapSel;
1003     default:
1004         WARN("(wReqType=%04x): Unknown\n", wReqType);
1005         return (DWORD)-1;
1006     }
1007 }
1008
1009 /***********************************************************************
1010  *           GdiSignalProc32     (GDI.610)
1011  */
1012 WORD WINAPI GdiSignalProc( UINT uCode, DWORD dwThreadOrProcessID,
1013                            DWORD dwFlags, HMODULE16 hModule )
1014 {
1015     return 0;
1016 }
1017
1018 /***********************************************************************
1019  *           FinalGdiInit     (GDI.405)
1020  */
1021 void WINAPI FinalGdiInit16( HANDLE16 unknown )
1022 {
1023 }
1024
1025 /***********************************************************************
1026  *           GdiFreeResources   (GDI.609)
1027  */
1028 WORD WINAPI GdiFreeResources16( DWORD reserve )
1029 {
1030    return (WORD)( (int)LOCAL_CountFree( GDI_HeapSel ) * 100 /
1031                   (int)LOCAL_HeapSize( GDI_HeapSel ) );
1032 }
1033
1034 /***********************************************************************
1035  *           MulDiv   (GDI.128)
1036  */
1037 INT16 WINAPI MulDiv16(
1038              INT16 nMultiplicand,
1039              INT16 nMultiplier,
1040              INT16 nDivisor)
1041 {
1042     INT ret;
1043     if (!nDivisor) return -32768;
1044     /* We want to deal with a positive divisor to simplify the logic. */
1045     if (nDivisor < 0)
1046     {
1047       nMultiplicand = - nMultiplicand;
1048       nDivisor = -nDivisor;
1049     }
1050     /* If the result is positive, we "add" to round. else,
1051      * we subtract to round. */
1052     if ( ( (nMultiplicand <  0) && (nMultiplier <  0) ) ||
1053          ( (nMultiplicand >= 0) && (nMultiplier >= 0) ) )
1054         ret = (((int)nMultiplicand * nMultiplier) + (nDivisor/2)) / nDivisor;
1055     else
1056         ret = (((int)nMultiplicand * nMultiplier) - (nDivisor/2)) / nDivisor;
1057     if ((ret > 32767) || (ret < -32767)) return -32768;
1058     return (INT16) ret;
1059 }
1060
1061
1062 /*******************************************************************
1063  *      GetColorAdjustment [GDI32.@]
1064  *
1065  *
1066  */
1067 BOOL WINAPI GetColorAdjustment(HDC hdc, LPCOLORADJUSTMENT lpca)
1068 {
1069         FIXME("GetColorAdjustment, stub\n");
1070         return 0;
1071 }
1072
1073 /*******************************************************************
1074  *      GetMiterLimit [GDI32.@]
1075  *
1076  *
1077  */
1078 BOOL WINAPI GetMiterLimit(HDC hdc, PFLOAT peLimit)
1079 {
1080         FIXME("GetMiterLimit, stub\n");
1081         return 0;
1082 }
1083
1084 /*******************************************************************
1085  *      SetMiterLimit [GDI32.@]
1086  *
1087  *
1088  */
1089 BOOL WINAPI SetMiterLimit(HDC hdc, FLOAT eNewLimit, PFLOAT peOldLimit)
1090 {
1091         FIXME("SetMiterLimit, stub\n");
1092         return 0;
1093 }
1094
1095 /*******************************************************************
1096  *      GdiComment [GDI32.@]
1097  *
1098  *
1099  */
1100 BOOL WINAPI GdiComment(HDC hdc, UINT cbSize, const BYTE *lpData)
1101 {
1102         FIXME("GdiComment, stub\n");
1103         return 0;
1104 }
1105 /*******************************************************************
1106  *      SetColorAdjustment [GDI32.@]
1107  *
1108  *
1109  */
1110 BOOL WINAPI SetColorAdjustment(HDC hdc, const COLORADJUSTMENT* lpca)
1111 {
1112         FIXME("SetColorAdjustment, stub\n");
1113         return 0;
1114 }
1115