dlls/gdi32/gdiobj.c

   1 /*
   2  * GDI functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <assert.h>
  22 #include <stdlib.h>
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "wingdi.h"
  29 #include "winreg.h"
  30 #include "winnls.h"
  31 #include "winerror.h"
  32 #include "winternl.h"
  33
  34 #include "gdi_private.h"
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(gdi);
  38
  39 #define FIRST_GDI_HANDLE 32
  40 #define MAX_GDI_HANDLES  16384
  41
  42 struct hdc_list
  43 {
  44     HDC hdc;
  45     struct hdc_list *next;
  46 };
  47
  48 struct gdi_handle_entry
  49 {
  50     void                       *obj;         /* pointer to the object-specific data */
  51     const struct gdi_obj_funcs *funcs;       /* type-specific functions */
  52     struct hdc_list            *hdcs;        /* list of HDCs interested in this object */
  53     WORD                        generation;  /* generation count for reusing handle values */
  54     WORD                        type;        /* object type (one of the OBJ_* constants) */
  55     WORD                        selcount;    /* number of times the object is selected in a DC */
  56     WORD                        system : 1;  /* system object flag */
  57     WORD                        deleted : 1; /* whether DeleteObject has been called on this object */
  58 };
  59
  60 static struct gdi_handle_entry gdi_handles[MAX_GDI_HANDLES];
  61 static struct gdi_handle_entry *next_free;
  62 static struct gdi_handle_entry *next_unused = gdi_handles;
  63 static LONG debug_count;
  64 HMODULE gdi32_module = 0;
  65
  66 static inline HGDIOBJ entry_to_handle( struct gdi_handle_entry *entry )
  67 {
  68     unsigned int idx = entry - gdi_handles + FIRST_GDI_HANDLE;
  69     return LongToHandle( idx | (entry->generation << 16) );
  70 }
  71
  72 static inline struct gdi_handle_entry *handle_entry( HGDIOBJ handle )
  73 {
  74     unsigned int idx = LOWORD(handle) - FIRST_GDI_HANDLE;
  75
  76     if (idx < MAX_GDI_HANDLES && gdi_handles[idx].type)
  77     {
  78         if (!HIWORD( handle ) || HIWORD( handle ) == gdi_handles[idx].generation)
  79             return &gdi_handles[idx];
  80     }
  81     if (handle) WARN( "invalid handle %p\n", handle );
  82     return NULL;
  83 }
  84
  85 /***********************************************************************
  86  *          GDI stock objects
  87  */
  88
  89 static const LOGBRUSH WhiteBrush = { BS_SOLID, RGB(255,255,255), 0 };
  90 static const LOGBRUSH BlackBrush = { BS_SOLID, RGB(0,0,0), 0 };
  91 static const LOGBRUSH NullBrush  = { BS_NULL, 0, 0 };
  92
  93 static const LOGBRUSH LtGrayBrush = { BS_SOLID, RGB(192,192,192), 0 };
  94 static const LOGBRUSH GrayBrush   = { BS_SOLID, RGB(128,128,128), 0 };
  95 static const LOGBRUSH DkGrayBrush = { BS_SOLID, RGB(64,64,64), 0 };
  96
  97 static const LOGPEN WhitePen = { PS_SOLID, { 0, 0 }, RGB(255,255,255) };
  98 static const LOGPEN BlackPen = { PS_SOLID, { 0, 0 }, RGB(0,0,0) };
  99 static const LOGPEN NullPen  = { PS_NULL,  { 0, 0 }, 0 };
 100
 101 static const LOGBRUSH DCBrush = { BS_SOLID, RGB(255,255,255), 0 };
 102 static const LOGPEN DCPen     = { PS_SOLID, { 0, 0 }, RGB(0,0,0) };
 103
 104 /* reserve one extra entry for the stock default bitmap */
 105 /* this is what Windows does too */
 106 #define NB_STOCK_OBJECTS (STOCK_LAST+2)
 107
 108 static HGDIOBJ stock_objects[NB_STOCK_OBJECTS];
 109 static HGDIOBJ scaled_stock_objects[NB_STOCK_OBJECTS];
 110
 111 static CRITICAL_SECTION gdi_section;
 112 static CRITICAL_SECTION_DEBUG critsect_debug =
 113 {
 114     0, 0, &gdi_section,
 115     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
 116       0, 0, { (DWORD_PTR)(__FILE__ ": gdi_section") }
 117 };
 118 static CRITICAL_SECTION gdi_section = { &critsect_debug, -1, 0, 0, 0, 0 };
 119
 120
 121 /****************************************************************************
 122  *
 123  *      language-independent stock fonts
 124  *
 125  */
 126
 127 static const LOGFONTW OEMFixedFont =
 128 { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, OEM_CHARSET,
 129   0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, L"" };
 130
 131 static const LOGFONTW AnsiFixedFont =
 132 { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 133   0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, L"Courier" };
 134
 135 static const LOGFONTW AnsiVarFont =
 136 { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 137   0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"MS Sans Serif" };
 138
 139 /******************************************************************************
 140  *
 141  *      language-dependent stock fonts
 142  *
 143  *      'ANSI' charset and 'DEFAULT' charset is not same.
 144  *      The chars in CP_ACP should be drawn with 'DEFAULT' charset.
 145  *      'ANSI' charset seems to be identical with ISO-8859-1.
 146  *      'DEFAULT' charset is a language-dependent charset.
 147  *
 148  *      'System' font seems to be an alias for language-dependent font.
 149  */
 150
 151 /*
 152  * language-dependent stock fonts for all known charsets
 153  * please see TranslateCharsetInfo (dlls/gdi/font.c) and
 154  * CharsetBindingInfo (dlls/x11drv/xfont.c),
 155  * and modify entries for your language if needed.
 156  */
 157 struct DefaultFontInfo
 158 {
 159         UINT            charset;
 160         LOGFONTW        SystemFont;
 161         LOGFONTW        DeviceDefaultFont;
 162         LOGFONTW        SystemFixedFont;
 163         LOGFONTW        DefaultGuiFont;
 164 };
 165
 166 static const struct DefaultFontInfo default_fonts[] =
 167 {
 168     {   ANSI_CHARSET,
 169         { /* System */
 170           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ANSI_CHARSET,
 171            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 172         },
 173         { /* Device Default */
 174           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ANSI_CHARSET,
 175            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 176         },
 177         { /* System Fixed */
 178           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 179            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, L"Courier"
 180         },
 181         { /* DefaultGuiFont */
 182           -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 183            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"MS Shell Dlg"
 184         },
 185     },
 186     {   EASTEUROPE_CHARSET,
 187         { /* System */
 188           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, EASTEUROPE_CHARSET,
 189            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 190         },
 191         { /* Device Default */
 192           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, EASTEUROPE_CHARSET,
 193            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 194         },
 195         { /* System Fixed */
 196           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, EASTEUROPE_CHARSET,
 197            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, L"Courier"
 198         },
 199         { /* DefaultGuiFont */
 200           -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, EASTEUROPE_CHARSET,
 201            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"MS Shell Dlg"
 202         },
 203     },
 204     {   RUSSIAN_CHARSET,
 205         { /* System */
 206           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, RUSSIAN_CHARSET,
 207            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 208         },
 209         { /* Device Default */
 210           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, RUSSIAN_CHARSET,
 211            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 212         },
 213         { /* System Fixed */
 214           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, RUSSIAN_CHARSET,
 215            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, L"Courier"
 216         },
 217         { /* DefaultGuiFont */
 218           -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, RUSSIAN_CHARSET,
 219            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"MS Shell Dlg"
 220         },
 221     },
 222     {   GREEK_CHARSET,
 223         { /* System */
 224           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, GREEK_CHARSET,
 225            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 226         },
 227         { /* Device Default */
 228           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, GREEK_CHARSET,
 229            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 230         },
 231         { /* System Fixed */
 232           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GREEK_CHARSET,
 233            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, L"Courier"
 234         },
 235         { /* DefaultGuiFont */
 236           -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GREEK_CHARSET,
 237            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"MS Shell Dlg"
 238         },
 239     },
 240     {   TURKISH_CHARSET,
 241         { /* System */
 242           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, TURKISH_CHARSET,
 243            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 244         },
 245         { /* Device Default */
 246           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, TURKISH_CHARSET,
 247            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 248         },
 249         { /* System Fixed */
 250           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, TURKISH_CHARSET,
 251            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, L"Courier"
 252         },
 253         { /* DefaultGuiFont */
 254           -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, TURKISH_CHARSET,
 255            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"MS Shell Dlg"
 256         },
 257     },
 258     {   HEBREW_CHARSET,
 259         { /* System */
 260           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, HEBREW_CHARSET,
 261            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 262         },
 263         { /* Device Default */
 264           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, HEBREW_CHARSET,
 265            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 266         },
 267         { /* System Fixed */
 268           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HEBREW_CHARSET,
 269            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, L"Courier"
 270         },
 271         { /* DefaultGuiFont */
 272           -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HEBREW_CHARSET,
 273            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"MS Shell Dlg"
 274         },
 275     },
 276     {   ARABIC_CHARSET,
 277         { /* System */
 278           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ARABIC_CHARSET,
 279            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 280         },
 281         { /* Device Default */
 282           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ARABIC_CHARSET,
 283            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 284         },
 285         { /* System Fixed */
 286           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ARABIC_CHARSET,
 287            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, L"Courier"
 288         },
 289         { /* DefaultGuiFont */
 290           -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ARABIC_CHARSET,
 291            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"MS Shell Dlg"
 292         },
 293     },
 294     {   BALTIC_CHARSET,
 295         { /* System */
 296           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, BALTIC_CHARSET,
 297            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 298         },
 299         { /* Device Default */
 300           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, BALTIC_CHARSET,
 301            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 302         },
 303         { /* System Fixed */
 304           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, BALTIC_CHARSET,
 305            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, L"Courier"
 306         },
 307         { /* DefaultGuiFont */
 308           -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, BALTIC_CHARSET,
 309            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"MS Shell Dlg"
 310         },
 311     },
 312     {   THAI_CHARSET,
 313         { /* System */
 314           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, THAI_CHARSET,
 315            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 316         },
 317         { /* Device Default */
 318           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, THAI_CHARSET,
 319            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 320         },
 321         { /* System Fixed */
 322           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, THAI_CHARSET,
 323            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, L"Courier"
 324         },
 325         { /* DefaultGuiFont */
 326           -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, THAI_CHARSET,
 327            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"MS Shell Dlg"
 328         },
 329     },
 330     {   SHIFTJIS_CHARSET,
 331         { /* System */
 332           18, 8, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, SHIFTJIS_CHARSET,
 333            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 334         },
 335         { /* Device Default */
 336           18, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, SHIFTJIS_CHARSET,
 337            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 338         },
 339         { /* System Fixed */
 340           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, SHIFTJIS_CHARSET,
 341            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, L"Courier"
 342         },
 343         { /* DefaultGuiFont */
 344           -12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, SHIFTJIS_CHARSET,
 345            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"MS Shell Dlg"
 346         },
 347     },
 348     {   GB2312_CHARSET,
 349         { /* System */
 350           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, GB2312_CHARSET,
 351            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 352         },
 353         { /* Device Default */
 354           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, GB2312_CHARSET,
 355            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 356         },
 357         { /* System Fixed */
 358           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GB2312_CHARSET,
 359            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, L"Courier"
 360         },
 361         { /* DefaultGuiFont */
 362           -12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GB2312_CHARSET,
 363            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"MS Shell Dlg"
 364         },
 365     },
 366     {   HANGEUL_CHARSET,
 367         { /* System */
 368           16, 8, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HANGEUL_CHARSET,
 369            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 370         },
 371         { /* Device Default */
 372           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HANGEUL_CHARSET,
 373            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 374         },
 375         { /* System Fixed */
 376           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HANGEUL_CHARSET,
 377            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, L"Courier"
 378         },
 379         { /* DefaultGuiFont */
 380           -12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HANGEUL_CHARSET,
 381            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"MS Shell Dlg"
 382         },
 383     },
 384     {   CHINESEBIG5_CHARSET,
 385         { /* System */
 386           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, CHINESEBIG5_CHARSET,
 387            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 388         },
 389         { /* Device Default */
 390           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, CHINESEBIG5_CHARSET,
 391            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 392         },
 393         { /* System Fixed */
 394           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, CHINESEBIG5_CHARSET,
 395            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, L"Courier"
 396         },
 397         { /* DefaultGuiFont */
 398           -12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, CHINESEBIG5_CHARSET,
 399            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"MS Shell Dlg"
 400         },
 401     },
 402     {   JOHAB_CHARSET,
 403         { /* System */
 404           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, JOHAB_CHARSET,
 405            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 406         },
 407         { /* Device Default */
 408           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, JOHAB_CHARSET,
 409            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System"
 410         },
 411         { /* System Fixed */
 412           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, JOHAB_CHARSET,
 413            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, L"Courier"
 414         },
 415         { /* DefaultGuiFont */
 416           -12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, JOHAB_CHARSET,
 417            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"MS Shell Dlg"
 418         },
 419     },
 420 };
 421
 422
 423 /*************************************************************************
 424  * __wine_make_gdi_object_system    (GDI32.@)
 425  *
 426  * USER has to tell GDI that its system brushes and pens are non-deletable.
 427  * For a description of the GDI object magics and their flags,
 428  * see "Undocumented Windows" (wrong about the OBJECT_NOSYSTEM flag, though).
 429  */
 430 void CDECL __wine_make_gdi_object_system( HGDIOBJ handle, BOOL set)
 431 {
 432     struct gdi_handle_entry *entry;
 433
 434     EnterCriticalSection( &gdi_section );
 435     if ((entry = handle_entry( handle ))) entry->system = !!set;
 436     LeaveCriticalSection( &gdi_section );
 437 }
 438
 439 /******************************************************************************
 440  *      get_default_fonts
 441  */
 442 static const struct DefaultFontInfo* get_default_fonts(UINT charset)
 443 {
 444         unsigned int n;
 445
 446         for(n = 0; n < ARRAY_SIZE( default_fonts ); n++)
 447         {
 448                 if ( default_fonts[n].charset == charset )
 449                         return &default_fonts[n];
 450         }
 451
 452         FIXME( "unhandled charset 0x%08x - use ANSI_CHARSET for default stock objects\n", charset );
 453         return &default_fonts[0];
 454 }
 455
 456
 457 /******************************************************************************
 458  *      get_default_charset    (internal)
 459  *
 460  * get the language-dependent charset that can handle CP_ACP correctly.
 461  */
 462 static UINT get_default_charset( void )
 463 {
 464     CHARSETINFO     csi;
 465     UINT    uACP;
 466
 467     uACP = GetACP();
 468     csi.ciCharset = ANSI_CHARSET;
 469     if ( !TranslateCharsetInfo( ULongToPtr(uACP), &csi, TCI_SRCCODEPAGE ) )
 470     {
 471         FIXME( "unhandled codepage %u - use ANSI_CHARSET for default stock objects\n", uACP );
 472         return ANSI_CHARSET;
 473     }
 474
 475     return csi.ciCharset;
 476 }
 477
 478
 479 /***********************************************************************
 480  *           GDI_get_ref_count
 481  *
 482  * Retrieve the reference count of a GDI object.
 483  * Note: the object must be locked otherwise the count is meaningless.
 484  */
 485 UINT GDI_get_ref_count( HGDIOBJ handle )
 486 {
 487     struct gdi_handle_entry *entry;
 488     UINT ret = 0;
 489
 490     EnterCriticalSection( &gdi_section );
 491     if ((entry = handle_entry( handle ))) ret = entry->selcount;
 492     LeaveCriticalSection( &gdi_section );
 493     return ret;
 494 }
 495
 496
 497 /***********************************************************************
 498  *           GDI_inc_ref_count
 499  *
 500  * Increment the reference count of a GDI object.
 501  */
 502 HGDIOBJ GDI_inc_ref_count( HGDIOBJ handle )
 503 {
 504     struct gdi_handle_entry *entry;
 505
 506     EnterCriticalSection( &gdi_section );
 507     if ((entry = handle_entry( handle ))) entry->selcount++;
 508     else handle = 0;
 509     LeaveCriticalSection( &gdi_section );
 510     return handle;
 511 }
 512
 513
 514 /***********************************************************************
 515  *           GDI_dec_ref_count
 516  *
 517  * Decrement the reference count of a GDI object.
 518  */
 519 BOOL GDI_dec_ref_count( HGDIOBJ handle )
 520 {
 521     struct gdi_handle_entry *entry;
 522
 523     EnterCriticalSection( &gdi_section );
 524     if ((entry = handle_entry( handle )))
 525     {
 526         assert( entry->selcount );
 527         if (!--entry->selcount && entry->deleted)
 528         {
 529             /* handle delayed DeleteObject*/
 530             entry->deleted = 0;
 531             LeaveCriticalSection( &gdi_section );
 532             TRACE( "executing delayed DeleteObject for %p\n", handle );
 533             DeleteObject( handle );
 534             return TRUE;
 535         }
 536     }
 537     LeaveCriticalSection( &gdi_section );
 538     return entry != NULL;
 539 }
 540
 541
 542 /******************************************************************************
 543  *              get_reg_dword
 544  *
 545  * Read a DWORD value from the registry
 546  */
 547 static BOOL get_reg_dword(HKEY base, const WCHAR *key_name, const WCHAR *value_name, DWORD *value)
 548 {
 549     HKEY key;
 550     DWORD type, data, size = sizeof(data);
 551     BOOL ret = FALSE;
 552
 553     if (RegOpenKeyW(base, key_name, &key) == ERROR_SUCCESS)
 554     {
 555         if (RegQueryValueExW(key, value_name, NULL, &type, (void *)&data, &size) == ERROR_SUCCESS &&
 556             type == REG_DWORD)
 557         {
 558             *value = data;
 559             ret = TRUE;
 560         }
 561         RegCloseKey(key);
 562     }
 563     return ret;
 564 }
 565
 566 /******************************************************************************
 567  *              get_dpi
 568  *
 569  * get the dpi from the registry
 570  */
 571 DWORD get_dpi(void)
 572 {
 573     DWORD dpi;
 574
 575     if (get_reg_dword(HKEY_CURRENT_USER, L"Control Panel\\Desktop", L"LogPixels", &dpi))
 576         return dpi;
 577     if (get_reg_dword(HKEY_CURRENT_CONFIG, L"Software\\Fonts", L"LogPixels", &dpi))
 578         return dpi;
 579     return 0;
 580 }
 581
 582 /******************************************************************************
 583  *              get_system_dpi
 584  *
 585  * Get the system DPI, based on the DPI awareness mode.
 586  */
 587 DWORD get_system_dpi(void)
 588 {
 589     static UINT (WINAPI *pGetDpiForSystem)(void);
 590
 591     if (!pGetDpiForSystem)
 592     {
 593         HMODULE user = GetModuleHandleW( L"user32.dll" );
 594         if (user) pGetDpiForSystem = (void *)GetProcAddress( user, "GetDpiForSystem" );
 595     }
 596     return pGetDpiForSystem ? pGetDpiForSystem() : 96;
 597 }
 598
 599 static HFONT create_scaled_font( const LOGFONTW *deffont )
 600 {
 601     LOGFONTW lf;
 602     static DWORD dpi;
 603
 604     if (!dpi)
 605     {
 606         dpi = get_dpi();
 607         if (!dpi) dpi = 96;
 608     }
 609
 610     lf = *deffont;
 611     lf.lfHeight = MulDiv( lf.lfHeight, dpi, 96 );
 612     return CreateFontIndirectW( &lf );
 613 }
 614
 615 /***********************************************************************
 616  *           DllMain
 617  *
 618  * GDI initialization.
 619  */
 620 BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, LPVOID reserved )
 621 {
 622     const struct DefaultFontInfo* deffonts;
 623     int i;
 624
 625     if (reason != DLL_PROCESS_ATTACH) return TRUE;
 626
 627     gdi32_module = inst;
 628     DisableThreadLibraryCalls( inst );
 629     font_init();
 630
 631     /* create stock objects */
 632     stock_objects[WHITE_BRUSH]  = CreateBrushIndirect( &WhiteBrush );
 633     stock_objects[LTGRAY_BRUSH] = CreateBrushIndirect( &LtGrayBrush );
 634     stock_objects[GRAY_BRUSH]   = CreateBrushIndirect( &GrayBrush );
 635     stock_objects[DKGRAY_BRUSH] = CreateBrushIndirect( &DkGrayBrush );
 636     stock_objects[BLACK_BRUSH]  = CreateBrushIndirect( &BlackBrush );
 637     stock_objects[NULL_BRUSH]   = CreateBrushIndirect( &NullBrush );
 638
 639     stock_objects[WHITE_PEN]    = CreatePenIndirect( &WhitePen );
 640     stock_objects[BLACK_PEN]    = CreatePenIndirect( &BlackPen );
 641     stock_objects[NULL_PEN]     = CreatePenIndirect( &NullPen );
 642
 643     stock_objects[DEFAULT_PALETTE] = PALETTE_Init();
 644     stock_objects[DEFAULT_BITMAP]  = CreateBitmap( 1, 1, 1, 1, NULL );
 645
 646     /* language-independent stock fonts */
 647     stock_objects[OEM_FIXED_FONT]      = CreateFontIndirectW( &OEMFixedFont );
 648     stock_objects[ANSI_FIXED_FONT]     = CreateFontIndirectW( &AnsiFixedFont );
 649     stock_objects[ANSI_VAR_FONT]       = CreateFontIndirectW( &AnsiVarFont );
 650
 651     /* language-dependent stock fonts */
 652     deffonts = get_default_fonts(get_default_charset());
 653     stock_objects[SYSTEM_FONT]         = CreateFontIndirectW( &deffonts->SystemFont );
 654     stock_objects[DEVICE_DEFAULT_FONT] = CreateFontIndirectW( &deffonts->DeviceDefaultFont );
 655     stock_objects[SYSTEM_FIXED_FONT]   = CreateFontIndirectW( &deffonts->SystemFixedFont );
 656     stock_objects[DEFAULT_GUI_FONT]    = CreateFontIndirectW( &deffonts->DefaultGuiFont );
 657
 658     scaled_stock_objects[OEM_FIXED_FONT]    = create_scaled_font( &OEMFixedFont );
 659     scaled_stock_objects[SYSTEM_FONT]       = create_scaled_font( &deffonts->SystemFont );
 660     scaled_stock_objects[SYSTEM_FIXED_FONT] = create_scaled_font( &deffonts->SystemFixedFont );
 661     scaled_stock_objects[DEFAULT_GUI_FONT]  = create_scaled_font( &deffonts->DefaultGuiFont );
 662
 663     stock_objects[DC_BRUSH]     = CreateBrushIndirect( &DCBrush );
 664     stock_objects[DC_PEN]       = CreatePenIndirect( &DCPen );
 665
 666     /* clear the NOSYSTEM bit on all stock objects*/
 667     for (i = 0; i < NB_STOCK_OBJECTS; i++)
 668     {
 669         if (stock_objects[i]) __wine_make_gdi_object_system( stock_objects[i], TRUE );
 670         if (scaled_stock_objects[i]) __wine_make_gdi_object_system( scaled_stock_objects[i], TRUE );
 671     }
 672     return TRUE;
 673 }
 674
 675
 676 /***********************************************************************
 677  *           GdiDllInitialize
 678  *
 679  * Stub entry point, some games (CoD: Black Ops 3) call it directly.
 680  */
 681 BOOL WINAPI GdiDllInitialize( HINSTANCE inst, DWORD reason, LPVOID reserved )
 682 {
 683     FIXME("stub\n");
 684     return TRUE;
 685 }
 686
 687
 688 static const char *gdi_obj_type( unsigned type )
 689 {
 690     switch ( type )
 691     {
 692         case OBJ_PEN: return "OBJ_PEN";
 693         case OBJ_BRUSH: return "OBJ_BRUSH";
 694         case OBJ_DC: return "OBJ_DC";
 695         case OBJ_METADC: return "OBJ_METADC";
 696         case OBJ_PAL: return "OBJ_PAL";
 697         case OBJ_FONT: return "OBJ_FONT";
 698         case OBJ_BITMAP: return "OBJ_BITMAP";
 699         case OBJ_REGION: return "OBJ_REGION";
 700         case OBJ_METAFILE: return "OBJ_METAFILE";
 701         case OBJ_MEMDC: return "OBJ_MEMDC";
 702         case OBJ_EXTPEN: return "OBJ_EXTPEN";
 703         case OBJ_ENHMETADC: return "OBJ_ENHMETADC";
 704         case OBJ_ENHMETAFILE: return "OBJ_ENHMETAFILE";
 705         case OBJ_COLORSPACE: return "OBJ_COLORSPACE";
 706         default: return "UNKNOWN";
 707     }
 708 }
 709
 710 static void dump_gdi_objects( void )
 711 {
 712     struct gdi_handle_entry *entry;
 713
 714     TRACE( "%u objects:\n", MAX_GDI_HANDLES );
 715
 716     EnterCriticalSection( &gdi_section );
 717     for (entry = gdi_handles; entry < next_unused; entry++)
 718     {
 719         if (!entry->type)
 720             TRACE( "handle %p FREE\n", entry_to_handle( entry ));
 721         else
 722             TRACE( "handle %p obj %p type %s selcount %u deleted %u\n",
 723                    entry_to_handle( entry ), entry->obj, gdi_obj_type( entry->type ),
 724                    entry->selcount, entry->deleted );
 725     }
 726     LeaveCriticalSection( &gdi_section );
 727 }
 728
 729 /***********************************************************************
 730  *           alloc_gdi_handle
 731  *
 732  * Allocate a GDI handle for an object, which must have been allocated on the process heap.
 733  */
 734 HGDIOBJ alloc_gdi_handle( void *obj, WORD type, const struct gdi_obj_funcs *funcs )
 735 {
 736     struct gdi_handle_entry *entry;
 737     HGDIOBJ ret;
 738
 739     assert( type );  /* type 0 is reserved to mark free entries */
 740
 741     EnterCriticalSection( &gdi_section );
 742
 743     entry = next_free;
 744     if (entry)
 745         next_free = entry->obj;
 746     else if (next_unused < gdi_handles + MAX_GDI_HANDLES)
 747         entry = next_unused++;
 748     else
 749     {
 750         LeaveCriticalSection( &gdi_section );
 751         ERR( "out of GDI object handles, expect a crash\n" );
 752         if (TRACE_ON(gdi)) dump_gdi_objects();
 753         return 0;
 754     }
 755     entry->obj      = obj;
 756     entry->funcs    = funcs;
 757     entry->hdcs     = NULL;
 758     entry->type     = type;
 759     entry->selcount = 0;
 760     entry->system   = 0;
 761     entry->deleted  = 0;
 762     if (++entry->generation == 0xffff) entry->generation = 1;
 763     ret = entry_to_handle( entry );
 764     LeaveCriticalSection( &gdi_section );
 765     TRACE( "allocated %s %p %u/%u\n", gdi_obj_type(type), ret,
 766            InterlockedIncrement( &debug_count ), MAX_GDI_HANDLES );
 767     return ret;
 768 }
 769
 770
 771 /***********************************************************************
 772  *           free_gdi_handle
 773  *
 774  * Free a GDI handle and return a pointer to the object.
 775  */
 776 void *free_gdi_handle( HGDIOBJ handle )
 777 {
 778     void *object = NULL;
 779     struct gdi_handle_entry *entry;
 780
 781     EnterCriticalSection( &gdi_section );
 782     if ((entry = handle_entry( handle )))
 783     {
 784         TRACE( "freed %s %p %u/%u\n", gdi_obj_type( entry->type ), handle,
 785                InterlockedDecrement( &debug_count ) + 1, MAX_GDI_HANDLES );
 786         object = entry->obj;
 787         entry->type = 0;
 788         entry->obj = next_free;
 789         next_free = entry;
 790     }
 791     LeaveCriticalSection( &gdi_section );
 792     return object;
 793 }
 794
 795
 796 /***********************************************************************
 797  *           get_full_gdi_handle
 798  *
 799  * Return the full GDI handle from a possibly truncated value.
 800  */
 801 HGDIOBJ get_full_gdi_handle( HGDIOBJ handle )
 802 {
 803     struct gdi_handle_entry *entry;
 804
 805     if (!HIWORD( handle ))
 806     {
 807         EnterCriticalSection( &gdi_section );
 808         if ((entry = handle_entry( handle ))) handle = entry_to_handle( entry );
 809         LeaveCriticalSection( &gdi_section );
 810     }
 811     return handle;
 812 }
 813
 814 /***********************************************************************
 815  *           get_any_obj_ptr
 816  *
 817  * Return a pointer to, and the type of, the GDI object
 818  * associated with the handle.
 819  * The object must be released with GDI_ReleaseObj.
 820  */
 821 void *get_any_obj_ptr( HGDIOBJ handle, WORD *type )
 822 {
 823     void *ptr = NULL;
 824     struct gdi_handle_entry *entry;
 825
 826     EnterCriticalSection( &gdi_section );
 827
 828     if ((entry = handle_entry( handle )))
 829     {
 830         ptr = entry->obj;
 831         *type = entry->type;
 832     }
 833
 834     if (!ptr) LeaveCriticalSection( &gdi_section );
 835     return ptr;
 836 }
 837
 838 /***********************************************************************
 839  *           GDI_GetObjPtr
 840  *
 841  * Return a pointer to the GDI object associated with the handle.
 842  * Return NULL if the object has the wrong type.
 843  * The object must be released with GDI_ReleaseObj.
 844  */
 845 void *GDI_GetObjPtr( HGDIOBJ handle, WORD type )
 846 {
 847     WORD ret_type;
 848     void *ptr = get_any_obj_ptr( handle, &ret_type );
 849     if (ptr && ret_type != type)
 850     {
 851         GDI_ReleaseObj( handle );
 852         ptr = NULL;
 853     }
 854     return ptr;
 855 }
 856
 857 /***********************************************************************
 858  *           GDI_ReleaseObj
 859  *
 860  */
 861 void GDI_ReleaseObj( HGDIOBJ handle )
 862 {
 863     LeaveCriticalSection( &gdi_section );
 864 }
 865
 866
 867 /***********************************************************************
 868  *           GDI_CheckNotLock
 869  */
 870 void GDI_CheckNotLock(void)
 871 {
 872     if (RtlIsCriticalSectionLockedByThread(&gdi_section))
 873     {
 874         ERR( "BUG: holding GDI lock\n" );
 875         DebugBreak();
 876     }
 877 }
 878
 879
 880 /***********************************************************************
 881  *           DeleteObject    (GDI32.@)
 882  *
 883  * Delete a Gdi object.
 884  *
 885  * PARAMS
 886  *  obj [I] Gdi object to delete
 887  *
 888  * RETURNS
 889  *  Success: TRUE. If obj was not returned from GetStockObject(), any resources
 890  *           it consumed are released.
 891  *  Failure: FALSE, if obj is not a valid Gdi object, or is currently selected
 892  *           into a DC.
 893  */
 894 BOOL WINAPI DeleteObject( HGDIOBJ obj )
 895 {
 896     struct gdi_handle_entry *entry;
 897     struct hdc_list *hdcs_head;
 898     const struct gdi_obj_funcs *funcs = NULL;
 899
 900     EnterCriticalSection( &gdi_section );
 901     if (!(entry = handle_entry( obj )))
 902     {
 903         LeaveCriticalSection( &gdi_section );
 904         return FALSE;
 905     }
 906
 907     if (entry->system)
 908     {
 909         TRACE("Preserving system object %p\n", obj);
 910         LeaveCriticalSection( &gdi_section );
 911         return TRUE;
 912     }
 913
 914     obj = entry_to_handle( entry );  /* make it a full handle */
 915
 916     hdcs_head = entry->hdcs;
 917     entry->hdcs = NULL;
 918
 919     if (entry->selcount)
 920     {
 921         TRACE("delayed for %p because object in use, count %u\n", obj, entry->selcount );
 922         entry->deleted = 1;  /* mark for delete */
 923     }
 924     else funcs = entry->funcs;
 925
 926     LeaveCriticalSection( &gdi_section );
 927
 928     while (hdcs_head)
 929     {
 930         struct hdc_list *next = hdcs_head->next;
 931         DC *dc = get_dc_ptr(hdcs_head->hdc);
 932
 933         TRACE("hdc %p has interest in %p\n", hdcs_head->hdc, obj);
 934         if(dc)
 935         {
 936             PHYSDEV physdev = GET_DC_PHYSDEV( dc, pDeleteObject );
 937             physdev->funcs->pDeleteObject( physdev, obj );
 938             release_dc_ptr( dc );
 939         }
 940         HeapFree(GetProcessHeap(), 0, hdcs_head);
 941         hdcs_head = next;
 942     }
 943
 944     TRACE("%p\n", obj );
 945
 946     if (funcs && funcs->pDeleteObject) return funcs->pDeleteObject( obj );
 947     return TRUE;
 948 }
 949
 950 /***********************************************************************
 951  *           GDI_hdc_using_object
 952  *
 953  * Call this if the dc requires DeleteObject notification
 954  */
 955 void GDI_hdc_using_object(HGDIOBJ obj, HDC hdc)
 956 {
 957     struct gdi_handle_entry *entry;
 958     struct hdc_list *phdc;
 959
 960     TRACE("obj %p hdc %p\n", obj, hdc);
 961
 962     EnterCriticalSection( &gdi_section );
 963     if ((entry = handle_entry( obj )) && !entry->system)
 964     {
 965         for (phdc = entry->hdcs; phdc; phdc = phdc->next)
 966             if (phdc->hdc == hdc) break;
 967
 968         if (!phdc)
 969         {
 970             phdc = HeapAlloc(GetProcessHeap(), 0, sizeof(*phdc));
 971             phdc->hdc = hdc;
 972             phdc->next = entry->hdcs;
 973             entry->hdcs = phdc;
 974         }
 975     }
 976     LeaveCriticalSection( &gdi_section );
 977 }
 978
 979 /***********************************************************************
 980  *           GDI_hdc_not_using_object
 981  *
 982  */
 983 void GDI_hdc_not_using_object(HGDIOBJ obj, HDC hdc)
 984 {
 985     struct gdi_handle_entry *entry;
 986     struct hdc_list **pphdc;
 987
 988     TRACE("obj %p hdc %p\n", obj, hdc);
 989
 990     EnterCriticalSection( &gdi_section );
 991     if ((entry = handle_entry( obj )) && !entry->system)
 992     {
 993         for (pphdc = &entry->hdcs; *pphdc; pphdc = &(*pphdc)->next)
 994             if ((*pphdc)->hdc == hdc)
 995             {
 996                 struct hdc_list *phdc = *pphdc;
 997                 *pphdc = phdc->next;
 998                 HeapFree(GetProcessHeap(), 0, phdc);
 999                 break;
1000             }
1001     }
1002     LeaveCriticalSection( &gdi_section );
1003 }
1004
1005 /***********************************************************************
1006  *           GetStockObject    (GDI32.@)
1007  */
1008 HGDIOBJ WINAPI GetStockObject( INT obj )
1009 {
1010     if ((obj < 0) || (obj >= NB_STOCK_OBJECTS)) return 0;
1011     switch (obj)
1012     {
1013     case OEM_FIXED_FONT:
1014     case SYSTEM_FONT:
1015     case SYSTEM_FIXED_FONT:
1016     case DEFAULT_GUI_FONT:
1017         if (get_system_dpi() != 96) return scaled_stock_objects[obj];
1018         break;
1019     }
1020     return stock_objects[obj];
1021 }
1022
1023
1024 /***********************************************************************
1025  *           GetObjectA    (GDI32.@)
1026  */
1027 INT WINAPI GetObjectA( HGDIOBJ handle, INT count, LPVOID buffer )
1028 {
1029     struct gdi_handle_entry *entry;
1030     const struct gdi_obj_funcs *funcs = NULL;
1031     INT result = 0;
1032
1033     TRACE("%p %d %p\n", handle, count, buffer );
1034
1035     EnterCriticalSection( &gdi_section );
1036     if ((entry = handle_entry( handle )))
1037     {
1038         funcs = entry->funcs;
1039         handle = entry_to_handle( entry );  /* make it a full handle */
1040     }
1041     LeaveCriticalSection( &gdi_section );
1042
1043     if (funcs)
1044     {
1045         if (!funcs->pGetObjectA)
1046             SetLastError( ERROR_INVALID_HANDLE );
1047         else if (buffer && ((ULONG_PTR)buffer >> 16) == 0) /* catch apps getting argument order wrong */
1048             SetLastError( ERROR_NOACCESS );
1049         else
1050             result = funcs->pGetObjectA( handle, count, buffer );
1051     }
1052     return result;
1053 }
1054
1055 /***********************************************************************
1056  *           GetObjectW    (GDI32.@)
1057  */
1058 INT WINAPI GetObjectW( HGDIOBJ handle, INT count, LPVOID buffer )
1059 {
1060     struct gdi_handle_entry *entry;
1061     const struct gdi_obj_funcs *funcs = NULL;
1062     INT result = 0;
1063
1064     TRACE("%p %d %p\n", handle, count, buffer );
1065
1066     EnterCriticalSection( &gdi_section );
1067     if ((entry = handle_entry( handle )))
1068     {
1069         funcs = entry->funcs;
1070         handle = entry_to_handle( entry );  /* make it a full handle */
1071     }
1072     LeaveCriticalSection( &gdi_section );
1073
1074     if (funcs)
1075     {
1076         if (!funcs->pGetObjectW)
1077             SetLastError( ERROR_INVALID_HANDLE );
1078         else if (buffer && ((ULONG_PTR)buffer >> 16) == 0) /* catch apps getting argument order wrong */
1079             SetLastError( ERROR_NOACCESS );
1080         else
1081             result = funcs->pGetObjectW( handle, count, buffer );
1082     }
1083     return result;
1084 }
1085
1086 /***********************************************************************
1087  *           GetObjectType    (GDI32.@)
1088  */
1089 DWORD WINAPI GetObjectType( HGDIOBJ handle )
1090 {
1091     struct gdi_handle_entry *entry;
1092     DWORD result = 0;
1093
1094     EnterCriticalSection( &gdi_section );
1095     if ((entry = handle_entry( handle ))) result = entry->type;
1096     LeaveCriticalSection( &gdi_section );
1097
1098     TRACE("%p -> %u\n", handle, result );
1099     if (!result) SetLastError( ERROR_INVALID_HANDLE );
1100     return result;
1101 }
1102
1103 /***********************************************************************
1104  *           GetCurrentObject           (GDI32.@)
1105  *
1106  * Get the currently selected object of a given type in a device context.
1107  *
1108  * PARAMS
1109  *  hdc  [I] Device context to get the current object from
1110  *  type [I] Type of current object to get (OBJ_* defines from "wingdi.h")
1111  *
1112  * RETURNS
1113  *  Success: The current object of the given type selected in hdc.
1114  *  Failure: A NULL handle.
1115  *
1116  * NOTES
1117  * - only the following object types are supported:
1118  *| OBJ_PEN
1119  *| OBJ_BRUSH
1120  *| OBJ_PAL
1121  *| OBJ_FONT
1122  *| OBJ_BITMAP
1123  */
1124 HGDIOBJ WINAPI GetCurrentObject(HDC hdc,UINT type)
1125 {
1126     HGDIOBJ ret = 0;
1127     DC * dc = get_dc_ptr( hdc );
1128
1129     if (!dc) return 0;
1130
1131     switch (type) {
1132         case OBJ_EXTPEN: /* fall through */
1133         case OBJ_PEN:    ret = dc->hPen; break;
1134         case OBJ_BRUSH:  ret = dc->hBrush; break;
1135         case OBJ_PAL:    ret = dc->hPalette; break;
1136         case OBJ_FONT:   ret = dc->hFont; break;
1137         case OBJ_BITMAP: ret = dc->hBitmap; break;
1138
1139         /* tests show that OBJ_REGION is explicitly ignored */
1140         case OBJ_REGION: break;
1141         default:
1142             /* the SDK only mentions those above */
1143             FIXME("(%p,%d): unknown type.\n",hdc,type);
1144             break;
1145     }
1146     release_dc_ptr( dc );
1147     return ret;
1148 }
1149
1150
1151 /***********************************************************************
1152  *           SelectObject    (GDI32.@)
1153  *
1154  * Select a Gdi object into a device context.
1155  *
1156  * PARAMS
1157  *  hdc  [I] Device context to associate the object with
1158  *  hObj [I] Gdi object to associate with hdc
1159  *
1160  * RETURNS
1161  *  Success: A non-NULL handle representing the previously selected object of
1162  *           the same type as hObj.
1163  *  Failure: A NULL object. If hdc is invalid, GetLastError() returns ERROR_INVALID_HANDLE.
1164  *           if hObj is not a valid object handle, no last error is set. In either
1165  *           case, hdc is unaffected by the call.
1166  */
1167 HGDIOBJ WINAPI SelectObject( HDC hdc, HGDIOBJ hObj )
1168 {
1169     struct gdi_handle_entry *entry;
1170     const struct gdi_obj_funcs *funcs = NULL;
1171
1172     TRACE( "(%p,%p)\n", hdc, hObj );
1173
1174     EnterCriticalSection( &gdi_section );
1175     if ((entry = handle_entry( hObj )))
1176     {
1177         funcs = entry->funcs;
1178         hObj = entry_to_handle( entry );  /* make it a full handle */
1179     }
1180     LeaveCriticalSection( &gdi_section );
1181
1182     if (funcs && funcs->pSelectObject) return funcs->pSelectObject( hObj, hdc );
1183     return 0;
1184 }
1185
1186
1187 /***********************************************************************
1188  *           UnrealizeObject    (GDI32.@)
1189  */
1190 BOOL WINAPI UnrealizeObject( HGDIOBJ obj )
1191 {
1192     const struct gdi_obj_funcs *funcs = NULL;
1193     struct gdi_handle_entry *entry;
1194
1195     EnterCriticalSection( &gdi_section );
1196     if ((entry = handle_entry( obj )))
1197     {
1198         funcs = entry->funcs;
1199         obj = entry_to_handle( entry );  /* make it a full handle */
1200     }
1201     LeaveCriticalSection( &gdi_section );
1202
1203     if (funcs && funcs->pUnrealizeObject) return funcs->pUnrealizeObject( obj );
1204     return funcs != NULL;
1205 }
1206
1207
1208 /* Solid colors to enumerate */
1209 static const COLORREF solid_colors[] =
1210 { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
1211 RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
1212 RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
1213 RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
1214 RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
1215 RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
1216 RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
1217 RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
1218 };
1219
1220
1221 /***********************************************************************
1222  *           EnumObjects    (GDI32.@)
1223  */
1224 INT WINAPI EnumObjects( HDC hdc, INT nObjType,
1225                             GOBJENUMPROC lpEnumFunc, LPARAM lParam )
1226 {
1227     UINT i;
1228     INT retval = 0;
1229     LOGPEN pen;
1230     LOGBRUSH brush;
1231
1232     TRACE("%p %d %p %08lx\n", hdc, nObjType, lpEnumFunc, lParam );
1233     switch(nObjType)
1234     {
1235     case OBJ_PEN:
1236         /* Enumerate solid pens */
1237         for (i = 0; i < ARRAY_SIZE( solid_colors ); i++)
1238         {
1239             pen.lopnStyle   = PS_SOLID;
1240             pen.lopnWidth.x = 1;
1241             pen.lopnWidth.y = 0;
1242             pen.lopnColor   = solid_colors[i];
1243             retval = lpEnumFunc( &pen, lParam );
1244             TRACE("solid pen %08x, ret=%d\n",
1245                          solid_colors[i], retval);
1246             if (!retval) break;
1247         }
1248         break;
1249
1250     case OBJ_BRUSH:
1251         /* Enumerate solid brushes */
1252         for (i = 0; i < ARRAY_SIZE( solid_colors ); i++)
1253         {
1254             brush.lbStyle = BS_SOLID;
1255             brush.lbColor = solid_colors[i];
1256             brush.lbHatch = 0;
1257             retval = lpEnumFunc( &brush, lParam );
1258             TRACE("solid brush %08x, ret=%d\n",
1259                          solid_colors[i], retval);
1260             if (!retval) break;
1261         }
1262
1263         /* Now enumerate hatched brushes */
1264         if (retval) for (i = HS_HORIZONTAL; i <= HS_DIAGCROSS; i++)
1265         {
1266             brush.lbStyle = BS_HATCHED;
1267             brush.lbColor = RGB(0,0,0);
1268             brush.lbHatch = i;
1269             retval = lpEnumFunc( &brush, lParam );
1270             TRACE("hatched brush %d, ret=%d\n",
1271                          i, retval);
1272             if (!retval) break;
1273         }
1274         break;
1275
1276     default:
1277         /* FIXME: implement Win32 types */
1278         WARN("(%d): Invalid type\n", nObjType );
1279         break;
1280     }
1281     return retval;
1282 }
1283
1284
1285 /***********************************************************************
1286  *           SetObjectOwner    (GDI32.@)
1287  */
1288 void WINAPI SetObjectOwner( HGDIOBJ handle, HANDLE owner )
1289 {
1290     /* Nothing to do */
1291 }
1292
1293 /***********************************************************************
1294  *           GdiInitializeLanguagePack    (GDI32.@)
1295  */
1296 DWORD WINAPI GdiInitializeLanguagePack( DWORD arg )
1297 {
1298     FIXME("stub\n");
1299     return 0;
1300 }
1301
1302 /***********************************************************************
1303  *           GdiFlush    (GDI32.@)
1304  */
1305 BOOL WINAPI GdiFlush(void)
1306 {
1307     return TRUE;  /* FIXME */
1308 }
1309
1310
1311 /***********************************************************************
1312  *           GdiGetBatchLimit    (GDI32.@)
1313  */
1314 DWORD WINAPI GdiGetBatchLimit(void)
1315 {
1316     return 1;  /* FIXME */
1317 }
1318
1319
1320 /***********************************************************************
1321  *           GdiSetBatchLimit    (GDI32.@)
1322  */
1323 DWORD WINAPI GdiSetBatchLimit( DWORD limit )
1324 {
1325     return 1; /* FIXME */
1326 }
1327
1328
1329 /*******************************************************************
1330  *      GetColorAdjustment [GDI32.@]
1331  *
1332  *
1333  */
1334 BOOL WINAPI GetColorAdjustment(HDC hdc, LPCOLORADJUSTMENT lpca)
1335 {
1336     FIXME("stub\n");
1337     return FALSE;
1338 }
1339
1340 /*******************************************************************
1341  *      GdiComment [GDI32.@]
1342  *
1343  *
1344  */
1345 BOOL WINAPI GdiComment(HDC hdc, UINT cbSize, const BYTE *lpData)
1346 {
1347     DC *dc = get_dc_ptr(hdc);
1348     BOOL ret = FALSE;
1349
1350     if(dc)
1351     {
1352         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pGdiComment );
1353         ret = physdev->funcs->pGdiComment( physdev, cbSize, lpData );
1354         release_dc_ptr( dc );
1355     }
1356     return ret;
1357 }
1358
1359 /*******************************************************************
1360  *      SetColorAdjustment [GDI32.@]
1361  *
1362  *
1363  */
1364 BOOL WINAPI SetColorAdjustment(HDC hdc, const COLORADJUSTMENT* lpca)
1365 {
1366     FIXME("stub\n");
1367     return FALSE;
1368 }