git.oblomov.eu Git - wine/blob - dlls/gdi/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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 "winerror.h"
  33
  34 #include "local.h"
  35 #include "gdi.h"
  36 #include "gdi_private.h"
  37 #include "wine/debug.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(gdi);
  40
  41 #define HGDIOBJ_32(h16)   ((HGDIOBJ)(ULONG_PTR)(h16))
  42
  43 #define GDI_HEAP_SIZE 0xffe0
  44
  45 /***********************************************************************
  46  *          GDI stock objects
  47  */
  48
  49 static const LOGBRUSH WhiteBrush = { BS_SOLID, RGB(255,255,255), 0 };
  50 static const LOGBRUSH BlackBrush = { BS_SOLID, RGB(0,0,0), 0 };
  51 static const LOGBRUSH NullBrush  = { BS_NULL, 0, 0 };
  52
  53 static const LOGBRUSH LtGrayBrush = { BS_SOLID, RGB(192,192,192), 0 };
  54 static const LOGBRUSH GrayBrush   = { BS_SOLID, RGB(128,128,128), 0 };
  55 static const LOGBRUSH DkGrayBrush = { BS_SOLID, RGB(64,64,64), 0 };
  56
  57 static const LOGPEN WhitePen = { PS_SOLID, { 0, 0 }, RGB(255,255,255) };
  58 static const LOGPEN BlackPen = { PS_SOLID, { 0, 0 }, RGB(0,0,0) };
  59 static const LOGPEN NullPen  = { PS_NULL,  { 0, 0 }, 0 };
  60
  61 static const LOGBRUSH DCBrush = { BS_SOLID, RGB(255,255,255), 0 };
  62 static const LOGPEN DCPen     = { PS_SOLID, { 0, 0 }, RGB(0,0,0) };
  63
  64 /* reserve one extra entry for the stock default bitmap */
  65 /* this is what Windows does too */
  66 #define NB_STOCK_OBJECTS (STOCK_LAST+2)
  67
  68 static HGDIOBJ stock_objects[NB_STOCK_OBJECTS];
  69
  70 static SYSLEVEL GDI_level;
  71 static CRITICAL_SECTION_DEBUG critsect_debug =
  72 {
  73     0, 0, &GDI_level.crst,
  74     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  75       0, 0, { 0, (DWORD)(__FILE__ ": GDI_level") }
  76 };
  77 static SYSLEVEL GDI_level = { { &critsect_debug, -1, 0, 0, 0, 0 }, 3 };
  78
  79 static WORD GDI_HeapSel;
  80
  81 inline static BOOL get_bool(char *buffer)
  82 {
  83     return (buffer[0] == 'y' || buffer[0] == 'Y' ||
  84             buffer[0] == 't' || buffer[0] == 'T' ||
  85             buffer[0] == '1');
  86 }
  87
  88
  89 /****************************************************************************
  90  *
  91  *      language-independent stock fonts
  92  *
  93  */
  94
  95 static const LOGFONTW OEMFixedFont =
  96 { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, OEM_CHARSET,
  97   0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, {'\0'} };
  98
  99 static const LOGFONTW AnsiFixedFont =
 100 { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 101   0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, {'\0'} };
 102
 103 static const LOGFONTW AnsiVarFont =
 104 { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 105   0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 106   {'M','S',' ','S','a','n','s',' ','S','e','r','i','f','\0'} };
 107
 108 /******************************************************************************
 109  *
 110  *      language-dependent stock fonts
 111  *
 112  *      'ANSI' charset and 'DEFAULT' charset is not same.
 113  *      The chars in CP_ACP should be drawn with 'DEFAULT' charset.
 114  *      'ANSI' charset seems to be identical with ISO-8859-1.
 115  *      'DEFAULT' charset is a language-dependent charset.
 116  *
 117  *      'System' font seems to be an alias for language-dependent font.
 118  */
 119
 120 /*
 121  * language-dependent stock fonts for all known charsets
 122  * please see TranslateCharsetInfo (dlls/gdi/font.c) and
 123  * CharsetBindingInfo (dlls/x11drv/xfont.c),
 124  * and modify entries for your language if needed.
 125  */
 126 struct DefaultFontInfo
 127 {
 128         UINT            charset;
 129         LOGFONTW        SystemFont;
 130         LOGFONTW        DeviceDefaultFont;
 131         LOGFONTW        SystemFixedFont;
 132         LOGFONTW        DefaultGuiFont; /* Note for this font the lfHeight member should be the point size */
 133 };
 134
 135 static const struct DefaultFontInfo default_fonts[] =
 136 {
 137     {   ANSI_CHARSET,
 138         { /* System */
 139           16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 140            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 141            {'S','y','s','t','e','m','\0'}
 142         },
 143         { /* Device Default */
 144           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 145            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 146            {'\0'}
 147         },
 148         { /* System Fixed */
 149           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 150            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 151            {'\0'}
 152         },
 153         { /* DefaultGuiFont */
 154            8, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 155            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 156            {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
 157         },
 158     },
 159     {   EASTEUROPE_CHARSET,
 160         { /* System */
 161           16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, EASTEUROPE_CHARSET,
 162            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 163            {'S','y','s','t','e','m','\0'}
 164         },
 165         { /* Device Default */
 166           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, EASTEUROPE_CHARSET,
 167            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 168            {'\0'}
 169         },
 170         { /* System Fixed */
 171           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, EASTEUROPE_CHARSET,
 172            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 173            {'\0'}
 174         },
 175         { /* DefaultGuiFont */
 176            8, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, EASTEUROPE_CHARSET,
 177            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 178            {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
 179         },
 180     },
 181     {   RUSSIAN_CHARSET,
 182         { /* System */
 183           16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, RUSSIAN_CHARSET,
 184            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 185            {'S','y','s','t','e','m','\0'}
 186         },
 187         { /* Device Default */
 188           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, RUSSIAN_CHARSET,
 189            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 190            {'\0'}
 191         },
 192         { /* System Fixed */
 193           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, RUSSIAN_CHARSET,
 194            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 195            {'\0'}
 196         },
 197         { /* DefaultGuiFont */
 198            8, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, RUSSIAN_CHARSET,
 199            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 200            {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
 201         },
 202     },
 203     {   GREEK_CHARSET,
 204         { /* System */
 205           16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GREEK_CHARSET,
 206            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 207            {'S','y','s','t','e','m','\0'}
 208         },
 209         { /* Device Default */
 210           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GREEK_CHARSET,
 211            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 212            {'\0'}
 213         },
 214         { /* System Fixed */
 215           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GREEK_CHARSET,
 216            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 217            {'\0'}
 218         },
 219         { /* DefaultGuiFont */
 220            8, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GREEK_CHARSET,
 221            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 222            {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
 223         },
 224     },
 225     {   TURKISH_CHARSET,
 226         { /* System */
 227           16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, TURKISH_CHARSET,
 228            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 229            {'S','y','s','t','e','m','\0'}
 230         },
 231         { /* Device Default */
 232           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, TURKISH_CHARSET,
 233            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 234            {'\0'}
 235         },
 236         { /* System Fixed */
 237           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, TURKISH_CHARSET,
 238            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 239            {'\0'}
 240         },
 241         { /* DefaultGuiFont */
 242            8, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, TURKISH_CHARSET,
 243            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 244            {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
 245         },
 246     },
 247     {   HEBREW_CHARSET,
 248         { /* System */
 249           16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HEBREW_CHARSET,
 250            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 251            {'S','y','s','t','e','m','\0'}
 252         },
 253         { /* Device Default */
 254           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HEBREW_CHARSET,
 255            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 256            {'\0'}
 257         },
 258         { /* System Fixed */
 259           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HEBREW_CHARSET,
 260            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 261            {'\0'}
 262         },
 263         { /* DefaultGuiFont */
 264            8, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HEBREW_CHARSET,
 265            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 266            {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
 267         },
 268     },
 269     {   ARABIC_CHARSET,
 270         { /* System */
 271           16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ARABIC_CHARSET,
 272            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 273            {'S','y','s','t','e','m','\0'}
 274         },
 275         { /* Device Default */
 276           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ARABIC_CHARSET,
 277            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 278            {'\0'}
 279         },
 280         { /* System Fixed */
 281           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ARABIC_CHARSET,
 282            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 283            {'\0'}
 284         },
 285         { /* DefaultGuiFont */
 286            8, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ARABIC_CHARSET,
 287            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 288            {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
 289         },
 290     },
 291     {   BALTIC_CHARSET,
 292         { /* System */
 293           16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, BALTIC_CHARSET,
 294            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 295            {'S','y','s','t','e','m','\0'}
 296         },
 297         { /* Device Default */
 298           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, BALTIC_CHARSET,
 299            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 300            {'\0'}
 301         },
 302         { /* System Fixed */
 303           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, BALTIC_CHARSET,
 304            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 305            {'\0'}
 306         },
 307         { /* DefaultGuiFont */
 308            8, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, BALTIC_CHARSET,
 309            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 310            {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
 311         },
 312     },
 313     {   THAI_CHARSET,
 314         { /* System */
 315           16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, THAI_CHARSET,
 316            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 317            {'S','y','s','t','e','m','\0'}
 318         },
 319         { /* Device Default */
 320           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, THAI_CHARSET,
 321            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 322            {'\0'}
 323         },
 324         { /* System Fixed */
 325           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, THAI_CHARSET,
 326            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 327            {'\0'}
 328         },
 329         { /* DefaultGuiFont */
 330            8, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, THAI_CHARSET,
 331            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 332            {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
 333         },
 334     },
 335     {   SHIFTJIS_CHARSET,
 336         { /* System */
 337           16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, SHIFTJIS_CHARSET,
 338            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 339            {'S','y','s','t','e','m','\0'}
 340         },
 341         { /* Device Default */
 342           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, SHIFTJIS_CHARSET,
 343            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 344            {'\0'}
 345         },
 346         { /* System Fixed */
 347           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, SHIFTJIS_CHARSET,
 348            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 349            {'\0'}
 350         },
 351         { /* DefaultGuiFont */
 352            9, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, SHIFTJIS_CHARSET,
 353            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 354            {'M','S',' ','U','I',' ','G','o','t','h','i','c','\0'}
 355         },
 356     },
 357     {   GB2312_CHARSET,
 358         { /* System */
 359           16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GB2312_CHARSET,
 360            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 361            {'S','y','s','t','e','m','\0'}
 362         },
 363         { /* Device Default */
 364           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GB2312_CHARSET,
 365            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 366            {'\0'}
 367         },
 368         { /* System Fixed */
 369           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GB2312_CHARSET,
 370            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 371            {'\0'}
 372         },
 373         { /* DefaultGuiFont */
 374            9, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GB2312_CHARSET,
 375            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 376            {'M','S',' ','S','o','n','g','\0'}   /* FIXME: Is this correct? */
 377         },
 378     },
 379     {   HANGEUL_CHARSET,
 380         { /* System */
 381           16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HANGEUL_CHARSET,
 382            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 383            {'S','y','s','t','e','m','\0'}
 384         },
 385         { /* Device Default */
 386           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HANGEUL_CHARSET,
 387            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 388            {'\0'}
 389         },
 390         { /* System Fixed */
 391           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HANGEUL_CHARSET,
 392            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 393            {'\0'}
 394         },
 395         { /* DefaultGuiFont */
 396            9, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HANGEUL_CHARSET,
 397            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 398            {'G','u','l','i','m','\0'},
 399         },
 400     },
 401     {   CHINESEBIG5_CHARSET,
 402         { /* System */
 403           16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, CHINESEBIG5_CHARSET,
 404            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 405            {'S','y','s','t','e','m','\0'}
 406         },
 407         { /* Device Default */
 408           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, CHINESEBIG5_CHARSET,
 409            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 410            {'\0'}
 411         },
 412         { /* System Fixed */
 413           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, CHINESEBIG5_CHARSET,
 414            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 415            {'\0'}
 416         },
 417         { /* DefaultGuiFont */
 418            8, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, CHINESEBIG5_CHARSET,
 419            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 420            {'\0'}       /* FIXME - what is the native font??? */
 421         },
 422     },
 423     {   JOHAB_CHARSET,
 424         { /* System */
 425           16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, JOHAB_CHARSET,
 426            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 427            {'S','y','s','t','e','m','\0'}
 428         },
 429         { /* Device Default */
 430           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, JOHAB_CHARSET,
 431            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 432            {'\0'}
 433         },
 434         { /* System Fixed */
 435           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, JOHAB_CHARSET,
 436            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 437            {'\0'}
 438         },
 439         { /* DefaultGuiFont */
 440            8, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, JOHAB_CHARSET,
 441            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 442            {'M','S',' ','M','i','n','g','l','i','u','\0'} /* FIXME: Is this correct? */
 443         },
 444     },
 445 };
 446
 447
 448 /******************************************************************************
 449  *      get_default_fonts
 450  */
 451 static const struct DefaultFontInfo* get_default_fonts(UINT charset)
 452 {
 453         unsigned int n;
 454
 455         for(n=0;n<(sizeof(default_fonts)/sizeof(default_fonts[0]));n++)
 456         {
 457                 if ( default_fonts[n].charset == charset )
 458                         return &default_fonts[n];
 459         }
 460
 461         FIXME( "unhandled charset 0x%08x - use ANSI_CHARSET for default stock objects\n", charset );
 462         return &default_fonts[0];
 463 }
 464
 465
 466 /******************************************************************************
 467  *      get_default_charset    (internal)
 468  *
 469  * get the language-dependent charset that can handle CP_ACP correctly.
 470  */
 471 static UINT get_default_charset( void )
 472 {
 473     CHARSETINFO     csi;
 474     UINT    uACP;
 475
 476     uACP = GetACP();
 477     csi.ciCharset = ANSI_CHARSET;
 478     if ( ! TranslateCharsetInfo( (LPDWORD)uACP, &csi, TCI_SRCCODEPAGE ) )
 479     {
 480         FIXME( "unhandled codepage %u - use ANSI_CHARSET for default stock objects\n", uACP );
 481         return ANSI_CHARSET;
 482     }
 483
 484     return csi.ciCharset;
 485 }
 486
 487 static const WCHAR dpi_key_name[] = {'S','o','f','t','w','a','r','e','\\','F','o','n','t','s','\0'};
 488 static const WCHAR dpi_value_name[] = {'L','o','g','P','i','x','e','l','s','\0'};
 489
 490 /******************************************************************************
 491  *      get_dpi   (internal)
 492  *
 493  * get the dpi from the registry
 494  */
 495 static DWORD get_dpi( void )
 496 {
 497     DWORD dpi = 96;
 498     HKEY hkey;
 499
 500     if (RegOpenKeyW(HKEY_CURRENT_CONFIG, dpi_key_name, &hkey) == ERROR_SUCCESS)
 501     {
 502         DWORD type, size, new_dpi;
 503
 504         size = sizeof(new_dpi);
 505         if(RegQueryValueExW(hkey, dpi_value_name, NULL, &type, (void *)&new_dpi, &size) == ERROR_SUCCESS)
 506         {
 507             if(type == REG_DWORD && new_dpi != 0)
 508                 dpi = new_dpi;
 509         }
 510         RegCloseKey(hkey);
 511     }
 512     return dpi;
 513 }
 514
 515 /******************************************************************************
 516  *           create_stock_font
 517  */
 518 static HFONT create_stock_font( char const *fontName, const LOGFONTW *font, HKEY hkey )
 519 {
 520     LOGFONTW lf;
 521     char  key[256];
 522     char buffer[MAX_PATH];
 523     DWORD type, count;
 524
 525     if (!hkey) return CreateFontIndirectW( font );
 526
 527     lf = *font;
 528     sprintf(key, "%s.Height", fontName);
 529     count = sizeof(buffer);
 530     if(!RegQueryValueExA(hkey, key, 0, &type, buffer, &count))
 531         lf.lfHeight = atoi(buffer);
 532
 533     sprintf(key, "%s.Bold", fontName);
 534     count = sizeof(buffer);
 535     if(!RegQueryValueExA(hkey, key, 0, &type, buffer, &count))
 536         lf.lfWeight = get_bool(buffer) ? FW_BOLD : FW_NORMAL;
 537
 538     sprintf(key, "%s.Italic", fontName);
 539     count = sizeof(buffer);
 540     if(!RegQueryValueExA(hkey, key, 0, &type, buffer, &count))
 541         lf.lfItalic = get_bool(buffer);
 542
 543     sprintf(key, "%s.Underline", fontName);
 544     count = sizeof(buffer);
 545     if(!RegQueryValueExA(hkey, key, 0, &type, buffer, &count))
 546         lf.lfUnderline = get_bool(buffer);
 547
 548     sprintf(key, "%s.StrikeOut", fontName);
 549     count = sizeof(buffer);
 550     if(!RegQueryValueExA(hkey, key, 0, &type, buffer, &count))
 551         lf.lfStrikeOut = get_bool(buffer);
 552     return CreateFontIndirectW( &lf );
 553 }
 554
 555
 556 #define TRACE_SEC(handle,text) \
 557    TRACE("(%p): " text " %ld\n", (handle), GDI_level.crst.RecursionCount)
 558
 559
 560 /***********************************************************************
 561  *           inc_ref_count
 562  *
 563  * Increment the reference count of a GDI object.
 564  */
 565 inline static void inc_ref_count( HGDIOBJ handle )
 566 {
 567     GDIOBJHDR *header;
 568
 569     if ((header = GDI_GetObjPtr( handle, MAGIC_DONTCARE )))
 570     {
 571         header->dwCount++;
 572         GDI_ReleaseObj( handle );
 573     }
 574 }
 575
 576
 577 /***********************************************************************
 578  *           dec_ref_count
 579  *
 580  * Decrement the reference count of a GDI object.
 581  */
 582 inline static void dec_ref_count( HGDIOBJ handle )
 583 {
 584     GDIOBJHDR *header;
 585
 586     if ((header = GDI_GetObjPtr( handle, MAGIC_DONTCARE )))
 587     {
 588         if (header->dwCount) header->dwCount--;
 589         if (header->dwCount != 0x80000000) GDI_ReleaseObj( handle );
 590         else
 591         {
 592             /* handle delayed DeleteObject*/
 593             header->dwCount = 0;
 594             GDI_ReleaseObj( handle );
 595             TRACE( "executing delayed DeleteObject for %p\n", handle );
 596             DeleteObject( handle );
 597         }
 598     }
 599 }
 600
 601
 602 /***********************************************************************
 603  *           GDI_Init
 604  *
 605  * GDI initialization.
 606  */
 607 BOOL GDI_Init(void)
 608 {
 609     HINSTANCE16 instance;
 610     HKEY hkey;
 611     GDIOBJHDR *ptr;
 612     LOGFONTW default_gui_font;
 613     const struct DefaultFontInfo* deffonts;
 614     int i;
 615
 616     if (RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\Tweak.Fonts", &hkey))
 617         hkey = 0;
 618
 619     /* create GDI heap */
 620     if ((instance = LoadLibrary16( "GDI.EXE" )) >= 32) GDI_HeapSel = instance | 7;
 621
 622     /* create stock objects */
 623     stock_objects[WHITE_BRUSH]  = CreateBrushIndirect( &WhiteBrush );
 624     stock_objects[LTGRAY_BRUSH] = CreateBrushIndirect( &LtGrayBrush );
 625     stock_objects[GRAY_BRUSH]   = CreateBrushIndirect( &GrayBrush );
 626     stock_objects[DKGRAY_BRUSH] = CreateBrushIndirect( &DkGrayBrush );
 627     stock_objects[BLACK_BRUSH]  = CreateBrushIndirect( &BlackBrush );
 628     stock_objects[NULL_BRUSH]   = CreateBrushIndirect( &NullBrush );
 629
 630     stock_objects[WHITE_PEN]    = CreatePenIndirect( &WhitePen );
 631     stock_objects[BLACK_PEN]    = CreatePenIndirect( &BlackPen );
 632     stock_objects[NULL_PEN]     = CreatePenIndirect( &NullPen );
 633
 634     stock_objects[DEFAULT_PALETTE] = PALETTE_Init();
 635     stock_objects[DEFAULT_BITMAP]  = CreateBitmap( 1, 1, 1, 1, NULL );
 636
 637     /* language-independent stock fonts */
 638     stock_objects[OEM_FIXED_FONT]      = create_stock_font( "OEMFixed", &OEMFixedFont, hkey );
 639     stock_objects[ANSI_FIXED_FONT]     = create_stock_font( "AnsiFixed", &AnsiFixedFont, hkey );
 640     stock_objects[ANSI_VAR_FONT]       = create_stock_font( "AnsiVar", &AnsiVarFont, hkey );
 641
 642     /* language-dependent stock fonts */
 643     deffonts = get_default_fonts(get_default_charset());
 644     stock_objects[SYSTEM_FONT]         = create_stock_font( "System", &deffonts->SystemFont, hkey );
 645     stock_objects[DEVICE_DEFAULT_FONT] = create_stock_font( "DeviceDefault", &deffonts->DeviceDefaultFont, hkey );
 646     stock_objects[SYSTEM_FIXED_FONT]   = create_stock_font( "SystemFixed", &deffonts->SystemFixedFont, hkey );
 647
 648     /* For the default gui font, we use the lfHeight member in deffonts as a place-holder
 649        for the point size so we must convert this into a true height */
 650     memcpy(&default_gui_font, &deffonts->DefaultGuiFont, sizeof(default_gui_font));
 651     default_gui_font.lfHeight = -MulDiv(default_gui_font.lfHeight, get_dpi(), 72);
 652     stock_objects[DEFAULT_GUI_FONT]    = create_stock_font( "DefaultGui", &default_gui_font, hkey );
 653
 654     stock_objects[DC_BRUSH]     = CreateBrushIndirect( &DCBrush );
 655     stock_objects[DC_PEN]       = CreatePenIndirect( &DCPen );
 656
 657     /* clear the NOSYSTEM bit on all stock objects*/
 658     for (i = 0; i < NB_STOCK_OBJECTS; i++)
 659     {
 660         if (!stock_objects[i])
 661         {
 662             if (i == 9) continue;  /* there's no stock object 9 */
 663             ERR( "could not create stock object %d\n", i );
 664             return FALSE;
 665         }
 666         ptr = GDI_GetObjPtr( stock_objects[i], MAGIC_DONTCARE );
 667         ptr->wMagic &= ~OBJECT_NOSYSTEM;
 668         GDI_ReleaseObj( stock_objects[i] );
 669     }
 670
 671     if (hkey) RegCloseKey( hkey );
 672
 673     WineEngInit();
 674
 675     return TRUE;
 676 }
 677
 678 #define FIRST_LARGE_HANDLE 16
 679 #define MAX_LARGE_HANDLES ((GDI_HEAP_SIZE >> 2) - FIRST_LARGE_HANDLE)
 680 static GDIOBJHDR *large_handles[MAX_LARGE_HANDLES];
 681 static int next_large_handle;
 682
 683 /***********************************************************************
 684  *           alloc_large_heap
 685  *
 686  * Allocate a GDI handle from the large heap. Helper for GDI_AllocObject
 687  */
 688 inline static GDIOBJHDR *alloc_large_heap( WORD size, HGDIOBJ *handle )
 689 {
 690     int i;
 691     GDIOBJHDR *obj;
 692
 693     for (i = next_large_handle + 1; i < MAX_LARGE_HANDLES; i++)
 694         if (!large_handles[i]) goto found;
 695     for (i = 0; i <= next_large_handle; i++)
 696         if (!large_handles[i]) goto found;
 697     *handle = 0;
 698     return NULL;
 699
 700  found:
 701     if ((obj = HeapAlloc( GetProcessHeap(), 0, size )))
 702     {
 703         large_handles[i] = obj;
 704         *handle = (HGDIOBJ)(ULONG_PTR)((i + FIRST_LARGE_HANDLE) << 2);
 705         next_large_handle = i;
 706     }
 707     return obj;
 708 }
 709
 710
 711 /***********************************************************************
 712  *           GDI_AllocObject
 713  */
 714 void *GDI_AllocObject( WORD size, WORD magic, HGDIOBJ *handle, const struct gdi_obj_funcs *funcs )
 715 {
 716     GDIOBJHDR *obj;
 717     HLOCAL16 hlocal;
 718
 719     _EnterSysLevel( &GDI_level );
 720     switch(magic)
 721     {
 722     case PEN_MAGIC:
 723     case BRUSH_MAGIC:
 724         if (GDI_HeapSel)
 725         {
 726             if (!(hlocal = LOCAL_Alloc( GDI_HeapSel, LMEM_MOVEABLE, size ))) goto error;
 727             assert( hlocal & 2 );
 728             obj = (GDIOBJHDR *)LOCAL_Lock( GDI_HeapSel, hlocal );
 729             *handle = (HGDIOBJ)(ULONG_PTR)hlocal;
 730             break;
 731         }
 732         /* fall through */
 733     default:
 734         if (!(obj = alloc_large_heap( size, handle ))) goto error;
 735         break;
 736     }
 737
 738     obj->wMagic  = magic|OBJECT_NOSYSTEM;
 739     obj->dwCount = 0;
 740     obj->funcs   = funcs;
 741     obj->hdcs    = NULL;
 742
 743     TRACE_SEC( *handle, "enter" );
 744     return obj;
 745
 746 error:
 747     _LeaveSysLevel( &GDI_level );
 748     *handle = 0;
 749     return NULL;
 750 }
 751
 752
 753 /***********************************************************************
 754  *           GDI_ReallocObject
 755  *
 756  * The object ptr must have been obtained with GDI_GetObjPtr.
 757  * The new pointer must be released with GDI_ReleaseObj.
 758  */
 759 void *GDI_ReallocObject( WORD size, HGDIOBJ handle, void *object )
 760 {
 761     HGDIOBJ new_handle;
 762
 763     if ((UINT_PTR)handle & 2)  /* GDI heap handle */
 764     {
 765         HLOCAL16 h = LOWORD(handle);
 766         LOCAL_Unlock( GDI_HeapSel, h );
 767         if ((new_handle = (HGDIOBJ)(ULONG_PTR)LOCAL_ReAlloc( GDI_HeapSel, h, size, LMEM_MOVEABLE )))
 768         {
 769             assert( new_handle == handle );  /* moveable handle cannot change */
 770             return LOCAL_Lock( GDI_HeapSel, h );
 771         }
 772     }
 773     else
 774     {
 775         int i = ((ULONG_PTR)handle >> 2) - FIRST_LARGE_HANDLE;
 776         if (i >= 0 && i < MAX_LARGE_HANDLES && large_handles[i])
 777         {
 778             void *new_ptr = HeapReAlloc( GetProcessHeap(), 0, large_handles[i], size );
 779             if (new_ptr)
 780             {
 781                 large_handles[i] = new_ptr;
 782                 return new_ptr;
 783             }
 784         }
 785         else ERR( "Invalid handle %p\n", handle );
 786     }
 787     TRACE_SEC( handle, "leave" );
 788     _LeaveSysLevel( &GDI_level );
 789     return NULL;
 790 }
 791
 792
 793 /***********************************************************************
 794  *           GDI_FreeObject
 795  */
 796 BOOL GDI_FreeObject( HGDIOBJ handle, void *ptr )
 797 {
 798     GDIOBJHDR *object = ptr;
 799
 800     object->wMagic = 0;  /* Mark it as invalid */
 801     object->funcs  = NULL;
 802     if ((UINT_PTR)handle & 2)  /* GDI heap handle */
 803     {
 804         HLOCAL16 h = LOWORD(handle);
 805         LOCAL_Unlock( GDI_HeapSel, h );
 806         LOCAL_Free( GDI_HeapSel, h );
 807     }
 808     else  /* large heap handle */
 809     {
 810         int i = ((ULONG_PTR)handle >> 2) - FIRST_LARGE_HANDLE;
 811         if (i >= 0 && i < MAX_LARGE_HANDLES && large_handles[i])
 812         {
 813             HeapFree( GetProcessHeap(), 0, large_handles[i] );
 814             large_handles[i] = NULL;
 815         }
 816         else ERR( "Invalid handle %p\n", handle );
 817     }
 818     TRACE_SEC( handle, "leave" );
 819     _LeaveSysLevel( &GDI_level );
 820     return TRUE;
 821 }
 822
 823
 824 /***********************************************************************
 825  *           GDI_GetObjPtr
 826  *
 827  * Return a pointer to the GDI object associated to the handle.
 828  * Return NULL if the object has the wrong magic number.
 829  * The object must be released with GDI_ReleaseObj.
 830  */
 831 void *GDI_GetObjPtr( HGDIOBJ handle, WORD magic )
 832 {
 833     GDIOBJHDR *ptr = NULL;
 834
 835     _EnterSysLevel( &GDI_level );
 836
 837     if ((UINT_PTR)handle & 2)  /* GDI heap handle */
 838     {
 839         HLOCAL16 h = LOWORD(handle);
 840         ptr = (GDIOBJHDR *)LOCAL_Lock( GDI_HeapSel, h );
 841         if (ptr)
 842         {
 843             if (((magic != MAGIC_DONTCARE) && (GDIMAGIC(ptr->wMagic) != magic)) ||
 844                 (GDIMAGIC(ptr->wMagic) < FIRST_MAGIC) ||
 845                 (GDIMAGIC(ptr->wMagic) > LAST_MAGIC))
 846             {
 847                 LOCAL_Unlock( GDI_HeapSel, h );
 848                 ptr = NULL;
 849             }
 850         }
 851     }
 852     else  /* large heap handle */
 853     {
 854         int i = ((UINT_PTR)handle >> 2) - FIRST_LARGE_HANDLE;
 855         if (i >= 0 && i < MAX_LARGE_HANDLES)
 856         {
 857             ptr = large_handles[i];
 858             if (ptr && (magic != MAGIC_DONTCARE) && (GDIMAGIC(ptr->wMagic) != magic)) ptr = NULL;
 859         }
 860     }
 861
 862     if (!ptr)
 863     {
 864         _LeaveSysLevel( &GDI_level );
 865         WARN( "Invalid handle %p\n", handle );
 866     }
 867     else TRACE_SEC( handle, "enter" );
 868
 869     return ptr;
 870 }
 871
 872
 873 /***********************************************************************
 874  *           GDI_ReleaseObj
 875  *
 876  */
 877 void GDI_ReleaseObj( HGDIOBJ handle )
 878 {
 879     if ((UINT_PTR)handle & 2) LOCAL_Unlock( GDI_HeapSel, LOWORD(handle) );
 880     TRACE_SEC( handle, "leave" );
 881     _LeaveSysLevel( &GDI_level );
 882 }
 883
 884
 885 /***********************************************************************
 886  *           GDI_CheckNotLock
 887  */
 888 void GDI_CheckNotLock(void)
 889 {
 890     _CheckNotSysLevel( &GDI_level );
 891 }
 892
 893
 894 /***********************************************************************
 895  *           DeleteObject    (GDI32.@)
 896  *
 897  * Delete a Gdi object.
 898  *
 899  * PARAMS
 900  *  obj [I] Gdi object to delete
 901  *
 902  * RETURNS
 903  *  Success: TRUE. If obj was not returned from GetStockObject(), any resources
 904  *           it consumed are released.
 905  *  Failure: FALSE, if obj is not a valid Gdi object, or is currently selected
 906  *           into a DC.
 907  */
 908 BOOL WINAPI DeleteObject( HGDIOBJ obj )
 909 {
 910       /* Check if object is valid */
 911
 912     GDIOBJHDR * header;
 913     if (HIWORD(obj)) return FALSE;
 914
 915     if (!(header = GDI_GetObjPtr( obj, MAGIC_DONTCARE ))) return FALSE;
 916
 917     if (!(header->wMagic & OBJECT_NOSYSTEM)
 918     &&   (header->wMagic >= FIRST_MAGIC) && (header->wMagic <= LAST_MAGIC))
 919     {
 920         TRACE("Preserving system object %p\n", obj);
 921         GDI_ReleaseObj( obj );
 922         return TRUE;
 923     }
 924
 925     while (header->hdcs)
 926     {
 927         DC *dc = DC_GetDCPtr(header->hdcs->hdc);
 928         struct hdc_list *tmp;
 929
 930         TRACE("hdc %p has interest in %p\n", header->hdcs->hdc, obj);
 931         if(dc)
 932         {
 933             if(dc->funcs->pDeleteObject)
 934                 dc->funcs->pDeleteObject( dc->physDev, obj );
 935             GDI_ReleaseObj( header->hdcs->hdc );
 936         }
 937         tmp = header->hdcs;
 938         header->hdcs = header->hdcs->next;
 939         HeapFree(GetProcessHeap(), 0, tmp);
 940     }
 941
 942     if (header->dwCount)
 943     {
 944         TRACE("delayed for %p because object in use, count %ld\n", obj, header->dwCount );
 945         header->dwCount |= 0x80000000; /* mark for delete */
 946         GDI_ReleaseObj( obj );
 947         return TRUE;
 948     }
 949
 950     TRACE("%p\n", obj );
 951
 952       /* Delete object */
 953
 954     if (header->funcs && header->funcs->pDeleteObject)
 955         return header->funcs->pDeleteObject( obj, header );
 956
 957     GDI_ReleaseObj( obj );
 958     return FALSE;
 959 }
 960
 961 /***********************************************************************
 962  *           GDI_hdc_using_object
 963  *
 964  * Call this if the dc requires DeleteObject notification
 965  */
 966 BOOL GDI_hdc_using_object(HGDIOBJ obj, HDC hdc)
 967 {
 968     GDIOBJHDR * header;
 969     struct hdc_list **pphdc;
 970
 971     TRACE("obj %p hdc %p\n", obj, hdc);
 972
 973     if (!(header = GDI_GetObjPtr( obj, MAGIC_DONTCARE ))) return FALSE;
 974
 975     if (!(header->wMagic & OBJECT_NOSYSTEM) &&
 976          (header->wMagic >= FIRST_MAGIC) && (header->wMagic <= LAST_MAGIC))
 977     {
 978         GDI_ReleaseObj(obj);
 979         return FALSE;
 980     }
 981
 982     for(pphdc = &header->hdcs; *pphdc; pphdc = &(*pphdc)->next)
 983         if((*pphdc)->hdc == hdc)
 984             break;
 985
 986     if(!*pphdc) {
 987         *pphdc = HeapAlloc(GetProcessHeap(), 0, sizeof(**pphdc));
 988         (*pphdc)->hdc = hdc;
 989         (*pphdc)->next = NULL;
 990     }
 991
 992     GDI_ReleaseObj(obj);
 993     return TRUE;
 994 }
 995
 996 /***********************************************************************
 997  *           GDI_hdc_not_using_object
 998  *
 999  */
1000 BOOL GDI_hdc_not_using_object(HGDIOBJ obj, HDC hdc)
1001 {
1002     GDIOBJHDR * header;
1003     struct hdc_list *phdc, **prev;
1004
1005     TRACE("obj %p hdc %p\n", obj, hdc);
1006
1007     if (!(header = GDI_GetObjPtr( obj, MAGIC_DONTCARE ))) return FALSE;
1008
1009     if (!(header->wMagic & OBJECT_NOSYSTEM) &&
1010          (header->wMagic >= FIRST_MAGIC) && (header->wMagic <= LAST_MAGIC))
1011     {
1012         GDI_ReleaseObj(obj);
1013         return FALSE;
1014     }
1015
1016     phdc = header->hdcs;
1017     prev = &header->hdcs;
1018
1019     while(phdc) {
1020         if(phdc->hdc == hdc) {
1021             *prev = phdc->next;
1022             HeapFree(GetProcessHeap(), 0, phdc);
1023             phdc = *prev;
1024         } else {
1025             prev = &phdc->next;
1026             phdc = phdc->next;
1027         }
1028     }
1029
1030     GDI_ReleaseObj(obj);
1031     return TRUE;
1032 }
1033
1034 /***********************************************************************
1035  *           GetStockObject    (GDI32.@)
1036  */
1037 HGDIOBJ WINAPI GetStockObject( INT obj )
1038 {
1039     HGDIOBJ ret;
1040     if ((obj < 0) || (obj >= NB_STOCK_OBJECTS)) return 0;
1041     ret = stock_objects[obj];
1042     TRACE("returning %p\n", ret );
1043     return ret;
1044 }
1045
1046
1047 /***********************************************************************
1048  *           GetObject    (GDI.82)
1049  */
1050 INT16 WINAPI GetObject16( HGDIOBJ16 handle16, INT16 count, LPVOID buffer )
1051 {
1052     GDIOBJHDR * ptr;
1053     HGDIOBJ handle = HGDIOBJ_32( handle16 );
1054     INT16 result = 0;
1055
1056     TRACE("%p %d %p\n", handle, count, buffer );
1057     if (!count) return 0;
1058
1059     if (!(ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE ))) return 0;
1060
1061     if (ptr->funcs && ptr->funcs->pGetObject16)
1062         result = ptr->funcs->pGetObject16( handle, ptr, count, buffer );
1063     else
1064         SetLastError( ERROR_INVALID_HANDLE );
1065
1066     GDI_ReleaseObj( handle );
1067     return result;
1068 }
1069
1070
1071 /***********************************************************************
1072  *           GetObjectA    (GDI32.@)
1073  */
1074 INT WINAPI GetObjectA( HGDIOBJ handle, INT count, LPVOID buffer )
1075 {
1076     GDIOBJHDR * ptr;
1077     INT result = 0;
1078     TRACE("%p %d %p\n", handle, count, buffer );
1079
1080     if (!(ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE ))) return 0;
1081
1082     if (ptr->funcs && ptr->funcs->pGetObjectA)
1083         result = ptr->funcs->pGetObjectA( handle, ptr, count, buffer );
1084     else
1085         SetLastError( ERROR_INVALID_HANDLE );
1086
1087     GDI_ReleaseObj( handle );
1088     return result;
1089 }
1090
1091 /***********************************************************************
1092  *           GetObjectW    (GDI32.@)
1093  */
1094 INT WINAPI GetObjectW( HGDIOBJ handle, INT count, LPVOID buffer )
1095 {
1096     GDIOBJHDR * ptr;
1097     INT result = 0;
1098     TRACE("%p %d %p\n", handle, count, buffer );
1099
1100     if (!(ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE ))) return 0;
1101
1102     if (ptr->funcs && ptr->funcs->pGetObjectW)
1103         result = ptr->funcs->pGetObjectW( handle, ptr, count, buffer );
1104     else
1105         SetLastError( ERROR_INVALID_HANDLE );
1106
1107     GDI_ReleaseObj( handle );
1108     return result;
1109 }
1110
1111 /***********************************************************************
1112  *           GetObjectType    (GDI32.@)
1113  */
1114 DWORD WINAPI GetObjectType( HGDIOBJ handle )
1115 {
1116     GDIOBJHDR * ptr;
1117     INT result = 0;
1118     TRACE("%p\n", handle );
1119
1120     if (!(ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE )))
1121     {
1122         SetLastError( ERROR_INVALID_HANDLE );
1123         return 0;
1124     }
1125
1126     switch(GDIMAGIC(ptr->wMagic))
1127     {
1128       case PEN_MAGIC:
1129           result = OBJ_PEN;
1130           break;
1131       case BRUSH_MAGIC:
1132           result = OBJ_BRUSH;
1133           break;
1134       case BITMAP_MAGIC:
1135           result = OBJ_BITMAP;
1136           break;
1137       case FONT_MAGIC:
1138           result = OBJ_FONT;
1139           break;
1140       case PALETTE_MAGIC:
1141           result = OBJ_PAL;
1142           break;
1143       case REGION_MAGIC:
1144           result = OBJ_REGION;
1145           break;
1146       case DC_MAGIC:
1147           result = OBJ_DC;
1148           break;
1149       case META_DC_MAGIC:
1150           result = OBJ_METADC;
1151           break;
1152       case METAFILE_MAGIC:
1153           result = OBJ_METAFILE;
1154           break;
1155       case METAFILE_DC_MAGIC:
1156           result = OBJ_METADC;
1157           break;
1158       case ENHMETAFILE_MAGIC:
1159           result = OBJ_ENHMETAFILE;
1160           break;
1161       case ENHMETAFILE_DC_MAGIC:
1162           result = OBJ_ENHMETADC;
1163           break;
1164       case MEMORY_DC_MAGIC:
1165           result = OBJ_MEMDC;
1166           break;
1167       default:
1168           FIXME("Magic %04x not implemented\n", GDIMAGIC(ptr->wMagic) );
1169           break;
1170     }
1171     GDI_ReleaseObj( handle );
1172     return result;
1173 }
1174
1175 /***********************************************************************
1176  *           GetCurrentObject           (GDI32.@)
1177  *
1178  * Get the currently selected object of a given type in a device context.
1179  *
1180  * PARAMS
1181  *  hdc  [I] Device context to get the current object from
1182  *  type [I] Type of current object to get (OBJ_* defines from "wingdi.h")
1183  *
1184  * RETURNS
1185  *  Success: The current object of the given type selected in hdc.
1186  *  Failure: A NULL handle.
1187  *
1188  * NOTES
1189  * - only the following object types are supported:
1190  *| OBJ_PEN
1191  *| OBJ_BRUSH
1192  *| OBJ_PAL
1193  *| OBJ_FONT
1194  *| OBJ_BITMAP
1195  */
1196 HGDIOBJ WINAPI GetCurrentObject(HDC hdc,UINT type)
1197 {
1198     HGDIOBJ ret = 0;
1199     DC * dc = DC_GetDCPtr( hdc );
1200
1201     if (dc)
1202     {
1203     switch (type) {
1204         case OBJ_PEN:    ret = dc->hPen; break;
1205         case OBJ_BRUSH:  ret = dc->hBrush; break;
1206         case OBJ_PAL:    ret = dc->hPalette; break;
1207         case OBJ_FONT:   ret = dc->hFont; break;
1208         case OBJ_BITMAP: ret = dc->hBitmap; break;
1209     default:
1210         /* the SDK only mentions those above */
1211         FIXME("(%p,%d): unknown type.\n",hdc,type);
1212             break;
1213         }
1214         GDI_ReleaseObj( hdc );
1215     }
1216     return ret;
1217 }
1218
1219
1220 /***********************************************************************
1221  *           SelectObject    (GDI32.@)
1222  *
1223  * Select a Gdi object into a device context.
1224  *
1225  * PARAMS
1226  *  hdc  [I] Device context to associate the object with
1227  *  hObj [I] Gdi object to associate with hdc
1228  *
1229  * RETURNS
1230  *  Success: A non-NULL handle representing the previously selected object of
1231  *           the same type as hObj.
1232  *  Failure: A NULL object. If hdc is invalid, GetLastError() returns ERROR_INVALID_HANDLE.
1233  *           if hObj is not a valid object handle, no last error is set. In either
1234  *           case, hdc is unaffected by the call.
1235  */
1236 HGDIOBJ WINAPI SelectObject( HDC hdc, HGDIOBJ hObj )
1237 {
1238     HGDIOBJ ret = 0;
1239     GDIOBJHDR *header;
1240     DC *dc;
1241
1242     TRACE( "(%p,%p)\n", hdc, hObj );
1243
1244     if (!(dc = DC_GetDCPtr( hdc )))
1245         SetLastError( ERROR_INVALID_HANDLE );
1246     else
1247     {
1248         GDI_ReleaseObj( (GDIOBJHDR *)dc );
1249
1250         header = GDI_GetObjPtr( hObj, MAGIC_DONTCARE );
1251         if (header)
1252         {
1253             if (header->funcs && header->funcs->pSelectObject)
1254             {
1255                 ret = header->funcs->pSelectObject( hObj, header, hdc );
1256                 if (ret && ret != hObj && (INT)ret > COMPLEXREGION)
1257                 {
1258                     inc_ref_count( hObj );
1259                     dec_ref_count( ret );
1260                 }
1261             }
1262             GDI_ReleaseObj( hObj );
1263         }
1264     }
1265     return ret;
1266 }
1267
1268
1269 /***********************************************************************
1270  *           UnrealizeObject    (GDI32.@)
1271  */
1272 BOOL WINAPI UnrealizeObject( HGDIOBJ obj )
1273 {
1274     BOOL result = TRUE;
1275   /* Check if object is valid */
1276
1277     GDIOBJHDR * header = GDI_GetObjPtr( obj, MAGIC_DONTCARE );
1278     if (!header) return FALSE;
1279
1280     TRACE("%p\n", obj );
1281
1282       /* Unrealize object */
1283
1284     if (header->funcs && header->funcs->pUnrealizeObject)
1285         result = header->funcs->pUnrealizeObject( obj, header );
1286
1287     GDI_ReleaseObj( obj );
1288     return result;
1289 }
1290
1291
1292 /* Solid colors to enumerate */
1293 static const COLORREF solid_colors[] =
1294 { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
1295 RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
1296 RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
1297 RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
1298 RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
1299 RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
1300 RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
1301 RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
1302 };
1303
1304
1305 /***********************************************************************
1306  *           EnumObjects    (GDI32.@)
1307  */
1308 INT WINAPI EnumObjects( HDC hdc, INT nObjType,
1309                             GOBJENUMPROC lpEnumFunc, LPARAM lParam )
1310 {
1311     UINT i;
1312     INT retval = 0;
1313     LOGPEN pen;
1314     LOGBRUSH brush;
1315
1316     TRACE("%p %d %p %08lx\n", hdc, nObjType, lpEnumFunc, lParam );
1317     switch(nObjType)
1318     {
1319     case OBJ_PEN:
1320         /* Enumerate solid pens */
1321         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
1322         {
1323             pen.lopnStyle   = PS_SOLID;
1324             pen.lopnWidth.x = 1;
1325             pen.lopnWidth.y = 0;
1326             pen.lopnColor   = solid_colors[i];
1327             retval = lpEnumFunc( &pen, lParam );
1328             TRACE("solid pen %08lx, ret=%d\n",
1329                          solid_colors[i], retval);
1330             if (!retval) break;
1331         }
1332         break;
1333
1334     case OBJ_BRUSH:
1335         /* Enumerate solid brushes */
1336         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
1337         {
1338             brush.lbStyle = BS_SOLID;
1339             brush.lbColor = solid_colors[i];
1340             brush.lbHatch = 0;
1341             retval = lpEnumFunc( &brush, lParam );
1342             TRACE("solid brush %08lx, ret=%d\n",
1343                          solid_colors[i], retval);
1344             if (!retval) break;
1345         }
1346
1347         /* Now enumerate hatched brushes */
1348         if (retval) for (i = HS_HORIZONTAL; i <= HS_DIAGCROSS; i++)
1349         {
1350             brush.lbStyle = BS_HATCHED;
1351             brush.lbColor = RGB(0,0,0);
1352             brush.lbHatch = i;
1353             retval = lpEnumFunc( &brush, lParam );
1354             TRACE("hatched brush %d, ret=%d\n",
1355                          i, retval);
1356             if (!retval) break;
1357         }
1358         break;
1359
1360     default:
1361         /* FIXME: implement Win32 types */
1362         WARN("(%d): Invalid type\n", nObjType );
1363         break;
1364     }
1365     return retval;
1366 }
1367
1368
1369 /***********************************************************************
1370  *           IsGDIObject    (GDI.462)
1371  *
1372  * returns type of object if valid (W95 system programming secrets p. 264-5)
1373  */
1374 BOOL16 WINAPI IsGDIObject16( HGDIOBJ16 handle16 )
1375 {
1376     UINT16 magic = 0;
1377     HGDIOBJ handle = HGDIOBJ_32( handle16 );
1378
1379     GDIOBJHDR *object = GDI_GetObjPtr( handle, MAGIC_DONTCARE );
1380     if (object)
1381     {
1382         magic = GDIMAGIC(object->wMagic) - PEN_MAGIC + 1;
1383         GDI_ReleaseObj( handle );
1384     }
1385     return magic;
1386 }
1387
1388
1389 /***********************************************************************
1390  *           SetObjectOwner    (GDI32.@)
1391  */
1392 void WINAPI SetObjectOwner( HGDIOBJ handle, HANDLE owner )
1393 {
1394     /* Nothing to do */
1395 }
1396
1397
1398 /***********************************************************************
1399  *           MakeObjectPrivate    (GDI.463)
1400  *
1401  * What does that mean ?
1402  * Some little docu can be found in "Undocumented Windows",
1403  * but this is basically useless.
1404  * At least we know that this flags the GDI object's wMagic
1405  * with 0x2000 (OBJECT_PRIVATE), so we just do it.
1406  * But Wine doesn't react on that yet.
1407  */
1408 void WINAPI MakeObjectPrivate16( HGDIOBJ16 handle16, BOOL16 private )
1409 {
1410     HGDIOBJ handle = HGDIOBJ_32( handle16 );
1411     GDIOBJHDR *ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE );
1412     if (!ptr)
1413     {
1414         ERR("invalid GDI object %p !\n", handle);
1415         return;
1416     }
1417     ptr->wMagic |= OBJECT_PRIVATE;
1418     GDI_ReleaseObj( handle );
1419 }
1420
1421
1422 /***********************************************************************
1423  *           GdiFlush    (GDI32.@)
1424  */
1425 BOOL WINAPI GdiFlush(void)
1426 {
1427     return TRUE;  /* FIXME */
1428 }
1429
1430
1431 /***********************************************************************
1432  *           GdiGetBatchLimit    (GDI32.@)
1433  */
1434 DWORD WINAPI GdiGetBatchLimit(void)
1435 {
1436     return 1;  /* FIXME */
1437 }
1438
1439
1440 /***********************************************************************
1441  *           GdiSetBatchLimit    (GDI32.@)
1442  */
1443 DWORD WINAPI GdiSetBatchLimit( DWORD limit )
1444 {
1445     return 1; /* FIXME */
1446 }
1447
1448
1449 /***********************************************************************
1450  *           GdiSeeGdiDo   (GDI.452)
1451  */
1452 DWORD WINAPI GdiSeeGdiDo16( WORD wReqType, WORD wParam1, WORD wParam2,
1453                           WORD wParam3 )
1454 {
1455     switch (wReqType)
1456     {
1457     case 0x0001:  /* LocalAlloc */
1458         return LOCAL_Alloc( GDI_HeapSel, wParam1, wParam3 );
1459     case 0x0002:  /* LocalFree */
1460         return LOCAL_Free( GDI_HeapSel, wParam1 );
1461     case 0x0003:  /* LocalCompact */
1462         return LOCAL_Compact( GDI_HeapSel, wParam3, 0 );
1463     case 0x0103:  /* LocalHeap */
1464         return GDI_HeapSel;
1465     default:
1466         WARN("(wReqType=%04x): Unknown\n", wReqType);
1467         return ~0UL;
1468     }
1469 }
1470
1471 /***********************************************************************
1472  *           GdiSignalProc32     (GDI.610)
1473  */
1474 WORD WINAPI GdiSignalProc( UINT uCode, DWORD dwThreadOrProcessID,
1475                            DWORD dwFlags, HMODULE16 hModule )
1476 {
1477     return 0;
1478 }
1479
1480 /***********************************************************************
1481  *           GdiInit2     (GDI.403)
1482  *
1483  * See "Undocumented Windows"
1484  */
1485 HANDLE16 WINAPI GdiInit216(
1486     HANDLE16 h1, /* [in] GDI object */
1487     HANDLE16 h2  /* [in] global data */
1488 )
1489 {
1490     FIXME("(%04x, %04x), stub.\n", h1, h2);
1491     if (h2 == 0xffff)
1492         return 0xffff; /* undefined return value */
1493     return h1; /* FIXME: should be the memory handle of h1 */
1494 }
1495
1496 /***********************************************************************
1497  *           FinalGdiInit     (GDI.405)
1498  */
1499 void WINAPI FinalGdiInit16( HBRUSH16 hPattern /* [in] fill pattern of desktop */ )
1500 {
1501 }
1502
1503 /***********************************************************************
1504  *           GdiFreeResources   (GDI.609)
1505  */
1506 WORD WINAPI GdiFreeResources16( DWORD reserve )
1507 {
1508    return (WORD)( (int)LOCAL_CountFree( GDI_HeapSel ) * 100 /
1509                   (int)LOCAL_HeapSize( GDI_HeapSel ) );
1510 }
1511
1512
1513 /*******************************************************************
1514  *      GetColorAdjustment [GDI32.@]
1515  *
1516  *
1517  */
1518 BOOL WINAPI GetColorAdjustment(HDC hdc, LPCOLORADJUSTMENT lpca)
1519 {
1520         FIXME("GetColorAdjustment, stub\n");
1521         return 0;
1522 }
1523
1524 /*******************************************************************
1525  *      GdiComment [GDI32.@]
1526  *
1527  *
1528  */
1529 BOOL WINAPI GdiComment(HDC hdc, UINT cbSize, const BYTE *lpData)
1530 {
1531     DC *dc = DC_GetDCPtr(hdc);
1532     BOOL ret = FALSE;
1533     if(dc)
1534     {
1535         if (dc->funcs->pGdiComment)
1536             ret = dc->funcs->pGdiComment( dc->physDev, cbSize, lpData );
1537     }
1538     GDI_ReleaseObj( hdc );
1539     return ret;
1540 }
1541
1542 /*******************************************************************
1543  *      SetColorAdjustment [GDI32.@]
1544  *
1545  *
1546  */
1547 BOOL WINAPI SetColorAdjustment(HDC hdc, const COLORADJUSTMENT* lpca)
1548 {
1549         FIXME("SetColorAdjustment, stub\n");
1550         return 0;
1551 }