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