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 /***********************************************************************
 557  *           inc_ref_count
 558  *
 559  * Increment the reference count of a GDI object.
 560  */
 561 inline static void inc_ref_count( HGDIOBJ handle )
 562 {
 563     GDIOBJHDR *header;
 564
 565     if ((header = GDI_GetObjPtr( handle, MAGIC_DONTCARE )))
 566     {
 567         header->dwCount++;
 568         GDI_ReleaseObj( handle );
 569     }
 570 }
 571
 572
 573 /***********************************************************************
 574  *           dec_ref_count
 575  *
 576  * Decrement the reference count of a GDI object.
 577  */
 578 inline static void dec_ref_count( HGDIOBJ handle )
 579 {
 580     GDIOBJHDR *header;
 581
 582     if ((header = GDI_GetObjPtr( handle, MAGIC_DONTCARE )))
 583     {
 584         if (header->dwCount) header->dwCount--;
 585         if (header->dwCount != 0x80000000) GDI_ReleaseObj( handle );
 586         else
 587         {
 588             /* handle delayed DeleteObject*/
 589             header->dwCount = 0;
 590             GDI_ReleaseObj( handle );
 591             TRACE( "executing delayed DeleteObject for %p\n", handle );
 592             DeleteObject( handle );
 593         }
 594     }
 595 }
 596
 597
 598 /***********************************************************************
 599  *           GDI_Init
 600  *
 601  * GDI initialization.
 602  */
 603 BOOL GDI_Init(void)
 604 {
 605     HINSTANCE16 instance;
 606     HKEY hkey;
 607     GDIOBJHDR *ptr;
 608     LOGFONTW default_gui_font;
 609     const struct DefaultFontInfo* deffonts;
 610     int i;
 611
 612     if (RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\Tweak.Fonts", &hkey))
 613         hkey = 0;
 614
 615     /* create GDI heap */
 616     if ((instance = LoadLibrary16( "GDI.EXE" )) >= 32) GDI_HeapSel = instance | 7;
 617
 618     /* create stock objects */
 619     stock_objects[WHITE_BRUSH]  = CreateBrushIndirect( &WhiteBrush );
 620     stock_objects[LTGRAY_BRUSH] = CreateBrushIndirect( &LtGrayBrush );
 621     stock_objects[GRAY_BRUSH]   = CreateBrushIndirect( &GrayBrush );
 622     stock_objects[DKGRAY_BRUSH] = CreateBrushIndirect( &DkGrayBrush );
 623     stock_objects[BLACK_BRUSH]  = CreateBrushIndirect( &BlackBrush );
 624     stock_objects[NULL_BRUSH]   = CreateBrushIndirect( &NullBrush );
 625
 626     stock_objects[WHITE_PEN]    = CreatePenIndirect( &WhitePen );
 627     stock_objects[BLACK_PEN]    = CreatePenIndirect( &BlackPen );
 628     stock_objects[NULL_PEN]     = CreatePenIndirect( &NullPen );
 629
 630     stock_objects[DEFAULT_PALETTE] = PALETTE_Init();
 631     stock_objects[DEFAULT_BITMAP]  = CreateBitmap( 1, 1, 1, 1, NULL );
 632
 633     /* language-independent stock fonts */
 634     stock_objects[OEM_FIXED_FONT]      = create_stock_font( "OEMFixed", &OEMFixedFont, hkey );
 635     stock_objects[ANSI_FIXED_FONT]     = create_stock_font( "AnsiFixed", &AnsiFixedFont, hkey );
 636     stock_objects[ANSI_VAR_FONT]       = create_stock_font( "AnsiVar", &AnsiVarFont, hkey );
 637
 638     /* language-dependent stock fonts */
 639     deffonts = get_default_fonts(get_default_charset());
 640     stock_objects[SYSTEM_FONT]         = create_stock_font( "System", &deffonts->SystemFont, hkey );
 641     stock_objects[DEVICE_DEFAULT_FONT] = create_stock_font( "DeviceDefault", &deffonts->DeviceDefaultFont, hkey );
 642     stock_objects[SYSTEM_FIXED_FONT]   = create_stock_font( "SystemFixed", &deffonts->SystemFixedFont, hkey );
 643
 644     /* For the default gui font, we use the lfHeight member in deffonts as a place-holder
 645        for the point size so we must convert this into a true height */
 646     memcpy(&default_gui_font, &deffonts->DefaultGuiFont, sizeof(default_gui_font));
 647     default_gui_font.lfHeight = -MulDiv(default_gui_font.lfHeight, get_dpi(), 72);
 648     stock_objects[DEFAULT_GUI_FONT]    = create_stock_font( "DefaultGui", &default_gui_font, hkey );
 649
 650     stock_objects[DC_BRUSH]     = CreateBrushIndirect( &DCBrush );
 651     stock_objects[DC_PEN]       = CreatePenIndirect( &DCPen );
 652
 653     /* clear the NOSYSTEM bit on all stock objects*/
 654     for (i = 0; i < NB_STOCK_OBJECTS; i++)
 655     {
 656         if (!stock_objects[i])
 657         {
 658             if (i == 9) continue;  /* there's no stock object 9 */
 659             ERR( "could not create stock object %d\n", i );
 660             return FALSE;
 661         }
 662         ptr = GDI_GetObjPtr( stock_objects[i], MAGIC_DONTCARE );
 663         ptr->wMagic &= ~OBJECT_NOSYSTEM;
 664         GDI_ReleaseObj( stock_objects[i] );
 665     }
 666
 667     if (hkey) RegCloseKey( hkey );
 668
 669     WineEngInit();
 670
 671     return TRUE;
 672 }
 673
 674 #define FIRST_LARGE_HANDLE 16
 675 #define MAX_LARGE_HANDLES ((GDI_HEAP_SIZE >> 2) - FIRST_LARGE_HANDLE)
 676 static GDIOBJHDR *large_handles[MAX_LARGE_HANDLES];
 677 static int next_large_handle;
 678
 679 /***********************************************************************
 680  *           alloc_large_heap
 681  *
 682  * Allocate a GDI handle from the large heap. Helper for GDI_AllocObject
 683  */
 684 inline static GDIOBJHDR *alloc_large_heap( WORD size, HGDIOBJ *handle )
 685 {
 686     int i;
 687     GDIOBJHDR *obj;
 688
 689     for (i = next_large_handle + 1; i < MAX_LARGE_HANDLES; i++)
 690         if (!large_handles[i]) goto found;
 691     for (i = 0; i <= next_large_handle; i++)
 692         if (!large_handles[i]) goto found;
 693     *handle = 0;
 694     return NULL;
 695
 696  found:
 697     if ((obj = HeapAlloc( GetProcessHeap(), 0, size )))
 698     {
 699         large_handles[i] = obj;
 700         *handle = (HGDIOBJ)(ULONG_PTR)((i + FIRST_LARGE_HANDLE) << 2);
 701         next_large_handle = i;
 702     }
 703     return obj;
 704 }
 705
 706
 707 /***********************************************************************
 708  *           GDI_AllocObject
 709  */
 710 void *GDI_AllocObject( WORD size, WORD magic, HGDIOBJ *handle, const struct gdi_obj_funcs *funcs )
 711 {
 712     GDIOBJHDR *obj;
 713     HLOCAL16 hlocal;
 714
 715     _EnterSysLevel( &GDI_level );
 716     switch(magic)
 717     {
 718     case PEN_MAGIC:
 719     case BRUSH_MAGIC:
 720         if (GDI_HeapSel)
 721         {
 722             if (!(hlocal = LOCAL_Alloc( GDI_HeapSel, LMEM_MOVEABLE, size ))) goto error;
 723             assert( hlocal & 2 );
 724             obj = (GDIOBJHDR *)LOCAL_Lock( GDI_HeapSel, hlocal );
 725             *handle = (HGDIOBJ)(ULONG_PTR)hlocal;
 726             break;
 727         }
 728         /* fall through */
 729     default:
 730         if (!(obj = alloc_large_heap( size, handle ))) goto error;
 731         break;
 732     }
 733
 734     obj->wMagic  = magic|OBJECT_NOSYSTEM;
 735     obj->dwCount = 0;
 736     obj->funcs   = funcs;
 737     obj->hdcs    = NULL;
 738
 739     TRACE("(%p): enter %ld\n", *handle, GDI_level.crst.RecursionCount);
 740     return obj;
 741
 742 error:
 743     _LeaveSysLevel( &GDI_level );
 744     *handle = 0;
 745     return NULL;
 746 }
 747
 748
 749 /***********************************************************************
 750  *           GDI_ReallocObject
 751  *
 752  * The object ptr must have been obtained with GDI_GetObjPtr.
 753  * The new pointer must be released with GDI_ReleaseObj.
 754  */
 755 void *GDI_ReallocObject( WORD size, HGDIOBJ handle, void *object )
 756 {
 757     HGDIOBJ new_handle;
 758
 759     if ((UINT_PTR)handle & 2)  /* GDI heap handle */
 760     {
 761         HLOCAL16 h = LOWORD(handle);
 762         LOCAL_Unlock( GDI_HeapSel, h );
 763         if ((new_handle = (HGDIOBJ)(ULONG_PTR)LOCAL_ReAlloc( GDI_HeapSel, h, size, LMEM_MOVEABLE )))
 764         {
 765             assert( new_handle == handle );  /* moveable handle cannot change */
 766             return LOCAL_Lock( GDI_HeapSel, h );
 767         }
 768     }
 769     else
 770     {
 771         int i = ((ULONG_PTR)handle >> 2) - FIRST_LARGE_HANDLE;
 772         if (i >= 0 && i < MAX_LARGE_HANDLES && large_handles[i])
 773         {
 774             void *new_ptr = HeapReAlloc( GetProcessHeap(), 0, large_handles[i], size );
 775             if (new_ptr)
 776             {
 777                 large_handles[i] = new_ptr;
 778                 return new_ptr;
 779             }
 780         }
 781         else ERR( "Invalid handle %p\n", handle );
 782     }
 783     TRACE("(%p): leave %ld\n", handle, GDI_level.crst.RecursionCount);
 784     _LeaveSysLevel( &GDI_level );
 785     return NULL;
 786 }
 787
 788
 789 /***********************************************************************
 790  *           GDI_FreeObject
 791  */
 792 BOOL GDI_FreeObject( HGDIOBJ handle, void *ptr )
 793 {
 794     GDIOBJHDR *object = ptr;
 795
 796     object->wMagic = 0;  /* Mark it as invalid */
 797     object->funcs  = NULL;
 798     if ((UINT_PTR)handle & 2)  /* GDI heap handle */
 799     {
 800         HLOCAL16 h = LOWORD(handle);
 801         LOCAL_Unlock( GDI_HeapSel, h );
 802         LOCAL_Free( GDI_HeapSel, h );
 803     }
 804     else  /* large heap handle */
 805     {
 806         int i = ((ULONG_PTR)handle >> 2) - FIRST_LARGE_HANDLE;
 807         if (i >= 0 && i < MAX_LARGE_HANDLES && large_handles[i])
 808         {
 809             HeapFree( GetProcessHeap(), 0, large_handles[i] );
 810             large_handles[i] = NULL;
 811         }
 812         else ERR( "Invalid handle %p\n", handle );
 813     }
 814     TRACE("(%p): leave %ld\n", handle, GDI_level.crst.RecursionCount);
 815     _LeaveSysLevel( &GDI_level );
 816     return TRUE;
 817 }
 818
 819
 820 /***********************************************************************
 821  *           GDI_GetObjPtr
 822  *
 823  * Return a pointer to the GDI object associated to the handle.
 824  * Return NULL if the object has the wrong magic number.
 825  * The object must be released with GDI_ReleaseObj.
 826  */
 827 void *GDI_GetObjPtr( HGDIOBJ handle, WORD magic )
 828 {
 829     GDIOBJHDR *ptr = NULL;
 830
 831     _EnterSysLevel( &GDI_level );
 832
 833     if ((UINT_PTR)handle & 2)  /* GDI heap handle */
 834     {
 835         HLOCAL16 h = LOWORD(handle);
 836         ptr = (GDIOBJHDR *)LOCAL_Lock( GDI_HeapSel, h );
 837         if (ptr)
 838         {
 839             if (((magic != MAGIC_DONTCARE) && (GDIMAGIC(ptr->wMagic) != magic)) ||
 840                 (GDIMAGIC(ptr->wMagic) < FIRST_MAGIC) ||
 841                 (GDIMAGIC(ptr->wMagic) > LAST_MAGIC))
 842             {
 843                 LOCAL_Unlock( GDI_HeapSel, h );
 844                 ptr = NULL;
 845             }
 846         }
 847     }
 848     else  /* large heap handle */
 849     {
 850         int i = ((UINT_PTR)handle >> 2) - FIRST_LARGE_HANDLE;
 851         if (i >= 0 && i < MAX_LARGE_HANDLES)
 852         {
 853             ptr = large_handles[i];
 854             if (ptr && (magic != MAGIC_DONTCARE) && (GDIMAGIC(ptr->wMagic) != magic)) ptr = NULL;
 855         }
 856     }
 857
 858     if (!ptr)
 859     {
 860         _LeaveSysLevel( &GDI_level );
 861         WARN( "Invalid handle %p\n", handle );
 862     }
 863     else TRACE("(%p): enter %ld\n", handle, GDI_level.crst.RecursionCount);
 864
 865     return ptr;
 866 }
 867
 868
 869 /***********************************************************************
 870  *           GDI_ReleaseObj
 871  *
 872  */
 873 void GDI_ReleaseObj( HGDIOBJ handle )
 874 {
 875     if ((UINT_PTR)handle & 2) LOCAL_Unlock( GDI_HeapSel, LOWORD(handle) );
 876     TRACE("(%p): leave %ld\n", handle, GDI_level.crst.RecursionCount);
 877     _LeaveSysLevel( &GDI_level );
 878 }
 879
 880
 881 /***********************************************************************
 882  *           GDI_CheckNotLock
 883  */
 884 void GDI_CheckNotLock(void)
 885 {
 886     _CheckNotSysLevel( &GDI_level );
 887 }
 888
 889
 890 /***********************************************************************
 891  *           DeleteObject    (GDI32.@)
 892  *
 893  * Delete a Gdi object.
 894  *
 895  * PARAMS
 896  *  obj [I] Gdi object to delete
 897  *
 898  * RETURNS
 899  *  Success: TRUE. If obj was not returned from GetStockObject(), any resources
 900  *           it consumed are released.
 901  *  Failure: FALSE, if obj is not a valid Gdi object, or is currently selected
 902  *           into a DC.
 903  */
 904 BOOL WINAPI DeleteObject( HGDIOBJ obj )
 905 {
 906       /* Check if object is valid */
 907
 908     GDIOBJHDR * header;
 909     if (HIWORD(obj)) return FALSE;
 910
 911     if (!(header = GDI_GetObjPtr( obj, MAGIC_DONTCARE ))) return FALSE;
 912
 913     if (!(header->wMagic & OBJECT_NOSYSTEM)
 914     &&   (header->wMagic >= FIRST_MAGIC) && (header->wMagic <= LAST_MAGIC))
 915     {
 916         TRACE("Preserving system object %p\n", obj);
 917         GDI_ReleaseObj( obj );
 918         return TRUE;
 919     }
 920
 921     while (header->hdcs)
 922     {
 923         DC *dc = DC_GetDCPtr(header->hdcs->hdc);
 924         struct hdc_list *tmp;
 925
 926         TRACE("hdc %p has interest in %p\n", header->hdcs->hdc, obj);
 927         if(dc)
 928         {
 929             if(dc->funcs->pDeleteObject)
 930                 dc->funcs->pDeleteObject( dc->physDev, obj );
 931             GDI_ReleaseObj( header->hdcs->hdc );
 932         }
 933         tmp = header->hdcs;
 934         header->hdcs = header->hdcs->next;
 935         HeapFree(GetProcessHeap(), 0, tmp);
 936     }
 937
 938     if (header->dwCount)
 939     {
 940         TRACE("delayed for %p because object in use, count %ld\n", obj, header->dwCount );
 941         header->dwCount |= 0x80000000; /* mark for delete */
 942         GDI_ReleaseObj( obj );
 943         return TRUE;
 944     }
 945
 946     TRACE("%p\n", obj );
 947
 948       /* Delete object */
 949
 950     if (header->funcs && header->funcs->pDeleteObject)
 951         return header->funcs->pDeleteObject( obj, header );
 952
 953     GDI_ReleaseObj( obj );
 954     return FALSE;
 955 }
 956
 957 /***********************************************************************
 958  *           GDI_hdc_using_object
 959  *
 960  * Call this if the dc requires DeleteObject notification
 961  */
 962 BOOL GDI_hdc_using_object(HGDIOBJ obj, HDC hdc)
 963 {
 964     GDIOBJHDR * header;
 965     struct hdc_list **pphdc;
 966
 967     TRACE("obj %p hdc %p\n", obj, hdc);
 968
 969     if (!(header = GDI_GetObjPtr( obj, MAGIC_DONTCARE ))) return FALSE;
 970
 971     if (!(header->wMagic & OBJECT_NOSYSTEM) &&
 972          (header->wMagic >= FIRST_MAGIC) && (header->wMagic <= LAST_MAGIC))
 973     {
 974         GDI_ReleaseObj(obj);
 975         return FALSE;
 976     }
 977
 978     for(pphdc = &header->hdcs; *pphdc; pphdc = &(*pphdc)->next)
 979         if((*pphdc)->hdc == hdc)
 980             break;
 981
 982     if(!*pphdc) {
 983         *pphdc = HeapAlloc(GetProcessHeap(), 0, sizeof(**pphdc));
 984         (*pphdc)->hdc = hdc;
 985         (*pphdc)->next = NULL;
 986     }
 987
 988     GDI_ReleaseObj(obj);
 989     return TRUE;
 990 }
 991
 992 /***********************************************************************
 993  *           GDI_hdc_not_using_object
 994  *
 995  */
 996 BOOL GDI_hdc_not_using_object(HGDIOBJ obj, HDC hdc)
 997 {
 998     GDIOBJHDR * header;
 999     struct hdc_list *phdc, **prev;
1000
1001     TRACE("obj %p hdc %p\n", obj, hdc);
1002
1003     if (!(header = GDI_GetObjPtr( obj, MAGIC_DONTCARE ))) return FALSE;
1004
1005     if (!(header->wMagic & OBJECT_NOSYSTEM) &&
1006          (header->wMagic >= FIRST_MAGIC) && (header->wMagic <= LAST_MAGIC))
1007     {
1008         GDI_ReleaseObj(obj);
1009         return FALSE;
1010     }
1011
1012     phdc = header->hdcs;
1013     prev = &header->hdcs;
1014
1015     while(phdc) {
1016         if(phdc->hdc == hdc) {
1017             *prev = phdc->next;
1018             HeapFree(GetProcessHeap(), 0, phdc);
1019             phdc = *prev;
1020         } else {
1021             prev = &phdc->next;
1022             phdc = phdc->next;
1023         }
1024     }
1025
1026     GDI_ReleaseObj(obj);
1027     return TRUE;
1028 }
1029
1030 /***********************************************************************
1031  *           GetStockObject    (GDI32.@)
1032  */
1033 HGDIOBJ WINAPI GetStockObject( INT obj )
1034 {
1035     HGDIOBJ ret;
1036     if ((obj < 0) || (obj >= NB_STOCK_OBJECTS)) return 0;
1037     ret = stock_objects[obj];
1038     TRACE("returning %p\n", ret );
1039     return ret;
1040 }
1041
1042
1043 /***********************************************************************
1044  *           GetObject    (GDI.82)
1045  */
1046 INT16 WINAPI GetObject16( HGDIOBJ16 handle16, INT16 count, LPVOID buffer )
1047 {
1048     GDIOBJHDR * ptr;
1049     HGDIOBJ handle = HGDIOBJ_32( handle16 );
1050     INT16 result = 0;
1051
1052     TRACE("%p %d %p\n", handle, count, buffer );
1053     if (!count) return 0;
1054
1055     if (!(ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE ))) return 0;
1056
1057     if (ptr->funcs && ptr->funcs->pGetObject16)
1058         result = ptr->funcs->pGetObject16( handle, ptr, count, buffer );
1059     else
1060         SetLastError( ERROR_INVALID_HANDLE );
1061
1062     GDI_ReleaseObj( handle );
1063     return result;
1064 }
1065
1066
1067 /***********************************************************************
1068  *           GetObjectA    (GDI32.@)
1069  */
1070 INT WINAPI GetObjectA( HGDIOBJ handle, INT count, LPVOID buffer )
1071 {
1072     GDIOBJHDR * ptr;
1073     INT result = 0;
1074     TRACE("%p %d %p\n", handle, count, buffer );
1075
1076     if (!(ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE ))) return 0;
1077
1078     if (ptr->funcs && ptr->funcs->pGetObjectA)
1079         result = ptr->funcs->pGetObjectA( handle, ptr, count, buffer );
1080     else
1081         SetLastError( ERROR_INVALID_HANDLE );
1082
1083     GDI_ReleaseObj( handle );
1084     return result;
1085 }
1086
1087 /***********************************************************************
1088  *           GetObjectW    (GDI32.@)
1089  */
1090 INT WINAPI GetObjectW( HGDIOBJ handle, INT count, LPVOID buffer )
1091 {
1092     GDIOBJHDR * ptr;
1093     INT result = 0;
1094     TRACE("%p %d %p\n", handle, count, buffer );
1095
1096     if (!(ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE ))) return 0;
1097
1098     if (ptr->funcs && ptr->funcs->pGetObjectW)
1099         result = ptr->funcs->pGetObjectW( handle, ptr, count, buffer );
1100     else
1101         SetLastError( ERROR_INVALID_HANDLE );
1102
1103     GDI_ReleaseObj( handle );
1104     return result;
1105 }
1106
1107 /***********************************************************************
1108  *           GetObjectType    (GDI32.@)
1109  */
1110 DWORD WINAPI GetObjectType( HGDIOBJ handle )
1111 {
1112     GDIOBJHDR * ptr;
1113     INT result = 0;
1114     TRACE("%p\n", handle );
1115
1116     if (!(ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE )))
1117     {
1118         SetLastError( ERROR_INVALID_HANDLE );
1119         return 0;
1120     }
1121
1122     switch(GDIMAGIC(ptr->wMagic))
1123     {
1124       case PEN_MAGIC:
1125           result = OBJ_PEN;
1126           break;
1127       case BRUSH_MAGIC:
1128           result = OBJ_BRUSH;
1129           break;
1130       case BITMAP_MAGIC:
1131           result = OBJ_BITMAP;
1132           break;
1133       case FONT_MAGIC:
1134           result = OBJ_FONT;
1135           break;
1136       case PALETTE_MAGIC:
1137           result = OBJ_PAL;
1138           break;
1139       case REGION_MAGIC:
1140           result = OBJ_REGION;
1141           break;
1142       case DC_MAGIC:
1143           result = OBJ_DC;
1144           break;
1145       case META_DC_MAGIC:
1146           result = OBJ_METADC;
1147           break;
1148       case METAFILE_MAGIC:
1149           result = OBJ_METAFILE;
1150           break;
1151       case METAFILE_DC_MAGIC:
1152           result = OBJ_METADC;
1153           break;
1154       case ENHMETAFILE_MAGIC:
1155           result = OBJ_ENHMETAFILE;
1156           break;
1157       case ENHMETAFILE_DC_MAGIC:
1158           result = OBJ_ENHMETADC;
1159           break;
1160       case MEMORY_DC_MAGIC:
1161           result = OBJ_MEMDC;
1162           break;
1163       default:
1164           FIXME("Magic %04x not implemented\n", GDIMAGIC(ptr->wMagic) );
1165           break;
1166     }
1167     GDI_ReleaseObj( handle );
1168     return result;
1169 }
1170
1171 /***********************************************************************
1172  *           GetCurrentObject           (GDI32.@)
1173  *
1174  * Get the currently selected object of a given type in a device context.
1175  *
1176  * PARAMS
1177  *  hdc  [I] Device context to get the current object from
1178  *  type [I] Type of current object to get (OBJ_* defines from "wingdi.h")
1179  *
1180  * RETURNS
1181  *  Success: The current object of the given type selected in hdc.
1182  *  Failure: A NULL handle.
1183  *
1184  * NOTES
1185  * - only the following object types are supported:
1186  *| OBJ_PEN
1187  *| OBJ_BRUSH
1188  *| OBJ_PAL
1189  *| OBJ_FONT
1190  *| OBJ_BITMAP
1191  */
1192 HGDIOBJ WINAPI GetCurrentObject(HDC hdc,UINT type)
1193 {
1194     HGDIOBJ ret = 0;
1195     DC * dc = DC_GetDCPtr( hdc );
1196
1197     if (dc)
1198     {
1199     switch (type) {
1200         case OBJ_PEN:    ret = dc->hPen; break;
1201         case OBJ_BRUSH:  ret = dc->hBrush; break;
1202         case OBJ_PAL:    ret = dc->hPalette; break;
1203         case OBJ_FONT:   ret = dc->hFont; break;
1204         case OBJ_BITMAP: ret = dc->hBitmap; break;
1205     default:
1206         /* the SDK only mentions those above */
1207         FIXME("(%p,%d): unknown type.\n",hdc,type);
1208             break;
1209         }
1210         GDI_ReleaseObj( hdc );
1211     }
1212     return ret;
1213 }
1214
1215
1216 /***********************************************************************
1217  *           SelectObject    (GDI32.@)
1218  *
1219  * Select a Gdi object into a device context.
1220  *
1221  * PARAMS
1222  *  hdc  [I] Device context to associate the object with
1223  *  hObj [I] Gdi object to associate with hdc
1224  *
1225  * RETURNS
1226  *  Success: A non-NULL handle representing the previously selected object of
1227  *           the same type as hObj.
1228  *  Failure: A NULL object. If hdc is invalid, GetLastError() returns ERROR_INVALID_HANDLE.
1229  *           if hObj is not a valid object handle, no last error is set. In either
1230  *           case, hdc is unaffected by the call.
1231  */
1232 HGDIOBJ WINAPI SelectObject( HDC hdc, HGDIOBJ hObj )
1233 {
1234     HGDIOBJ ret = 0;
1235     GDIOBJHDR *header;
1236     DC *dc;
1237
1238     TRACE( "(%p,%p)\n", hdc, hObj );
1239
1240     if (!(dc = DC_GetDCPtr( hdc )))
1241         SetLastError( ERROR_INVALID_HANDLE );
1242     else
1243     {
1244         GDI_ReleaseObj( (GDIOBJHDR *)dc );
1245
1246         header = GDI_GetObjPtr( hObj, MAGIC_DONTCARE );
1247         if (header)
1248         {
1249             if (header->funcs && header->funcs->pSelectObject)
1250             {
1251                 ret = header->funcs->pSelectObject( hObj, header, hdc );
1252                 if (ret && ret != hObj && (INT)ret > COMPLEXREGION)
1253                 {
1254                     inc_ref_count( hObj );
1255                     dec_ref_count( ret );
1256                 }
1257             }
1258             GDI_ReleaseObj( hObj );
1259         }
1260     }
1261     return ret;
1262 }
1263
1264
1265 /***********************************************************************
1266  *           UnrealizeObject    (GDI32.@)
1267  */
1268 BOOL WINAPI UnrealizeObject( HGDIOBJ obj )
1269 {
1270     BOOL result = TRUE;
1271   /* Check if object is valid */
1272
1273     GDIOBJHDR * header = GDI_GetObjPtr( obj, MAGIC_DONTCARE );
1274     if (!header) return FALSE;
1275
1276     TRACE("%p\n", obj );
1277
1278       /* Unrealize object */
1279
1280     if (header->funcs && header->funcs->pUnrealizeObject)
1281         result = header->funcs->pUnrealizeObject( obj, header );
1282
1283     GDI_ReleaseObj( obj );
1284     return result;
1285 }
1286
1287
1288 /* Solid colors to enumerate */
1289 static const COLORREF solid_colors[] =
1290 { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
1291 RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
1292 RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
1293 RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
1294 RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
1295 RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
1296 RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
1297 RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
1298 };
1299
1300
1301 /***********************************************************************
1302  *           EnumObjects    (GDI32.@)
1303  */
1304 INT WINAPI EnumObjects( HDC hdc, INT nObjType,
1305                             GOBJENUMPROC lpEnumFunc, LPARAM lParam )
1306 {
1307     UINT i;
1308     INT retval = 0;
1309     LOGPEN pen;
1310     LOGBRUSH brush;
1311
1312     TRACE("%p %d %p %08lx\n", hdc, nObjType, lpEnumFunc, lParam );
1313     switch(nObjType)
1314     {
1315     case OBJ_PEN:
1316         /* Enumerate solid pens */
1317         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
1318         {
1319             pen.lopnStyle   = PS_SOLID;
1320             pen.lopnWidth.x = 1;
1321             pen.lopnWidth.y = 0;
1322             pen.lopnColor   = solid_colors[i];
1323             retval = lpEnumFunc( &pen, lParam );
1324             TRACE("solid pen %08lx, ret=%d\n",
1325                          solid_colors[i], retval);
1326             if (!retval) break;
1327         }
1328         break;
1329
1330     case OBJ_BRUSH:
1331         /* Enumerate solid brushes */
1332         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
1333         {
1334             brush.lbStyle = BS_SOLID;
1335             brush.lbColor = solid_colors[i];
1336             brush.lbHatch = 0;
1337             retval = lpEnumFunc( &brush, lParam );
1338             TRACE("solid brush %08lx, ret=%d\n",
1339                          solid_colors[i], retval);
1340             if (!retval) break;
1341         }
1342
1343         /* Now enumerate hatched brushes */
1344         if (retval) for (i = HS_HORIZONTAL; i <= HS_DIAGCROSS; i++)
1345         {
1346             brush.lbStyle = BS_HATCHED;
1347             brush.lbColor = RGB(0,0,0);
1348             brush.lbHatch = i;
1349             retval = lpEnumFunc( &brush, lParam );
1350             TRACE("hatched brush %d, ret=%d\n",
1351                          i, retval);
1352             if (!retval) break;
1353         }
1354         break;
1355
1356     default:
1357         /* FIXME: implement Win32 types */
1358         WARN("(%d): Invalid type\n", nObjType );
1359         break;
1360     }
1361     return retval;
1362 }
1363
1364
1365 /***********************************************************************
1366  *           IsGDIObject    (GDI.462)
1367  *
1368  * returns type of object if valid (W95 system programming secrets p. 264-5)
1369  */
1370 BOOL16 WINAPI IsGDIObject16( HGDIOBJ16 handle16 )
1371 {
1372     UINT16 magic = 0;
1373     HGDIOBJ handle = HGDIOBJ_32( handle16 );
1374
1375     GDIOBJHDR *object = GDI_GetObjPtr( handle, MAGIC_DONTCARE );
1376     if (object)
1377     {
1378         magic = GDIMAGIC(object->wMagic) - PEN_MAGIC + 1;
1379         GDI_ReleaseObj( handle );
1380     }
1381     return magic;
1382 }
1383
1384
1385 /***********************************************************************
1386  *           SetObjectOwner    (GDI32.@)
1387  */
1388 void WINAPI SetObjectOwner( HGDIOBJ handle, HANDLE owner )
1389 {
1390     /* Nothing to do */
1391 }
1392
1393
1394 /***********************************************************************
1395  *           MakeObjectPrivate    (GDI.463)
1396  *
1397  * What does that mean ?
1398  * Some little docu can be found in "Undocumented Windows",
1399  * but this is basically useless.
1400  * At least we know that this flags the GDI object's wMagic
1401  * with 0x2000 (OBJECT_PRIVATE), so we just do it.
1402  * But Wine doesn't react on that yet.
1403  */
1404 void WINAPI MakeObjectPrivate16( HGDIOBJ16 handle16, BOOL16 private )
1405 {
1406     HGDIOBJ handle = HGDIOBJ_32( handle16 );
1407     GDIOBJHDR *ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE );
1408     if (!ptr)
1409     {
1410         ERR("invalid GDI object %p !\n", handle);
1411         return;
1412     }
1413     ptr->wMagic |= OBJECT_PRIVATE;
1414     GDI_ReleaseObj( handle );
1415 }
1416
1417
1418 /***********************************************************************
1419  *           GdiFlush    (GDI32.@)
1420  */
1421 BOOL WINAPI GdiFlush(void)
1422 {
1423     return TRUE;  /* FIXME */
1424 }
1425
1426
1427 /***********************************************************************
1428  *           GdiGetBatchLimit    (GDI32.@)
1429  */
1430 DWORD WINAPI GdiGetBatchLimit(void)
1431 {
1432     return 1;  /* FIXME */
1433 }
1434
1435
1436 /***********************************************************************
1437  *           GdiSetBatchLimit    (GDI32.@)
1438  */
1439 DWORD WINAPI GdiSetBatchLimit( DWORD limit )
1440 {
1441     return 1; /* FIXME */
1442 }
1443
1444
1445 /***********************************************************************
1446  *           GdiSeeGdiDo   (GDI.452)
1447  */
1448 DWORD WINAPI GdiSeeGdiDo16( WORD wReqType, WORD wParam1, WORD wParam2,
1449                           WORD wParam3 )
1450 {
1451     switch (wReqType)
1452     {
1453     case 0x0001:  /* LocalAlloc */
1454         return LOCAL_Alloc( GDI_HeapSel, wParam1, wParam3 );
1455     case 0x0002:  /* LocalFree */
1456         return LOCAL_Free( GDI_HeapSel, wParam1 );
1457     case 0x0003:  /* LocalCompact */
1458         return LOCAL_Compact( GDI_HeapSel, wParam3 );
1459     case 0x0103:  /* LocalHeap */
1460         return GDI_HeapSel;
1461     default:
1462         WARN("(wReqType=%04x): Unknown\n", wReqType);
1463         return ~0UL;
1464     }
1465 }
1466
1467 /***********************************************************************
1468  *           GdiSignalProc32     (GDI.610)
1469  */
1470 WORD WINAPI GdiSignalProc( UINT uCode, DWORD dwThreadOrProcessID,
1471                            DWORD dwFlags, HMODULE16 hModule )
1472 {
1473     return 0;
1474 }
1475
1476 /***********************************************************************
1477  *           GdiInit2     (GDI.403)
1478  *
1479  * See "Undocumented Windows"
1480  */
1481 HANDLE16 WINAPI GdiInit216(
1482     HANDLE16 h1, /* [in] GDI object */
1483     HANDLE16 h2  /* [in] global data */
1484 )
1485 {
1486     FIXME("(%04x, %04x), stub.\n", h1, h2);
1487     if (h2 == 0xffff)
1488         return 0xffff; /* undefined return value */
1489     return h1; /* FIXME: should be the memory handle of h1 */
1490 }
1491
1492 /***********************************************************************
1493  *           FinalGdiInit     (GDI.405)
1494  */
1495 void WINAPI FinalGdiInit16( HBRUSH16 hPattern /* [in] fill pattern of desktop */ )
1496 {
1497 }
1498
1499 /***********************************************************************
1500  *           GdiFreeResources   (GDI.609)
1501  */
1502 WORD WINAPI GdiFreeResources16( DWORD reserve )
1503 {
1504    return (WORD)( (int)LOCAL_CountFree( GDI_HeapSel ) * 100 /
1505                   (int)LOCAL_HeapSize( GDI_HeapSel ) );
1506 }
1507
1508
1509 /*******************************************************************
1510  *      GetColorAdjustment [GDI32.@]
1511  *
1512  *
1513  */
1514 BOOL WINAPI GetColorAdjustment(HDC hdc, LPCOLORADJUSTMENT lpca)
1515 {
1516         FIXME("GetColorAdjustment, stub\n");
1517         return 0;
1518 }
1519
1520 /*******************************************************************
1521  *      GdiComment [GDI32.@]
1522  *
1523  *
1524  */
1525 BOOL WINAPI GdiComment(HDC hdc, UINT cbSize, const BYTE *lpData)
1526 {
1527     DC *dc = DC_GetDCPtr(hdc);
1528     BOOL ret = FALSE;
1529     if(dc)
1530     {
1531         if (dc->funcs->pGdiComment)
1532             ret = dc->funcs->pGdiComment( dc->physDev, cbSize, lpData );
1533     }
1534     GDI_ReleaseObj( hdc );
1535     return ret;
1536 }
1537
1538 /*******************************************************************
1539  *      SetColorAdjustment [GDI32.@]
1540  *
1541  *
1542  */
1543 BOOL WINAPI SetColorAdjustment(HDC hdc, const COLORADJUSTMENT* lpca)
1544 {
1545         FIXME("SetColorAdjustment, stub\n");
1546         return 0;
1547 }