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