dlls/win32u/gdiobj.c

   1 /*
   2  * GDI functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #if 0
  22 #pragma makedep unix
  23 #endif
  24
  25 #include <assert.h>
  26 #include <stdlib.h>
  27 #include <stdarg.h>
  28 #include <stdio.h>
  29 #include <pthread.h>
  30
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "wingdi.h"
  34 #include "winreg.h"
  35 #include "winnls.h"
  36 #include "winerror.h"
  37 #include "winternl.h"
  38
  39 #include "ntgdi_private.h"
  40 #include "wine/debug.h"
  41 #include "wine/unixlib.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(gdi);
  44
  45 #define FIRST_GDI_HANDLE 32
  46
  47 static GDI_SHARED_MEMORY *gdi_shared;
  48 static GDI_HANDLE_ENTRY *next_free;
  49 static GDI_HANDLE_ENTRY *next_unused;
  50 static LONG debug_count;
  51 SYSTEM_BASIC_INFORMATION system_info;
  52
  53 const struct user_callbacks *user_callbacks = NULL;
  54
  55 static inline HGDIOBJ entry_to_handle( GDI_HANDLE_ENTRY *entry )
  56 {
  57     unsigned int idx = entry - gdi_shared->Handles;
  58     return ULongToHandle( idx | (entry->Unique << NTGDI_HANDLE_TYPE_SHIFT) );
  59 }
  60
  61 static inline GDI_HANDLE_ENTRY *handle_entry( HGDIOBJ handle )
  62 {
  63     unsigned int idx = LOWORD(handle);
  64
  65     if (idx < GDI_MAX_HANDLE_COUNT && gdi_shared->Handles[idx].Type)
  66     {
  67         if (!HIWORD( handle ) || HIWORD( handle ) == gdi_shared->Handles[idx].Unique)
  68             return &gdi_shared->Handles[idx];
  69     }
  70     if (handle) WARN( "invalid handle %p\n", handle );
  71     return NULL;
  72 }
  73
  74 static inline struct gdi_obj_header *entry_obj( GDI_HANDLE_ENTRY *entry )
  75 {
  76     return (struct gdi_obj_header *)(ULONG_PTR)entry->Object;
  77 }
  78
  79 /***********************************************************************
  80  *          GDI stock objects
  81  */
  82
  83 static const LOGBRUSH WhiteBrush = { BS_SOLID, RGB(255,255,255), 0 };
  84 static const LOGBRUSH BlackBrush = { BS_SOLID, RGB(0,0,0), 0 };
  85 static const LOGBRUSH NullBrush  = { BS_NULL, 0, 0 };
  86
  87 static const LOGBRUSH LtGrayBrush = { BS_SOLID, RGB(192,192,192), 0 };
  88 static const LOGBRUSH GrayBrush   = { BS_SOLID, RGB(128,128,128), 0 };
  89 static const LOGBRUSH DkGrayBrush = { BS_SOLID, RGB(64,64,64), 0 };
  90
  91 static const LOGBRUSH DCBrush = { BS_SOLID, RGB(255,255,255), 0 };
  92
  93 static pthread_mutex_t gdi_lock;
  94
  95
  96 /****************************************************************************
  97  *
  98  *      language-independent stock fonts
  99  *
 100  */
 101
 102 static const LOGFONTW OEMFixedFont =
 103 { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, OEM_CHARSET,
 104   0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN };
 105
 106 static const LOGFONTW AnsiFixedFont =
 107 { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 108   0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 109   {'C','o','u','r','i','e','r'} };
 110
 111 static const LOGFONTW AnsiVarFont =
 112 { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 113   0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 114   {'M','S',' ','S','a','n','s',' ','S','e','r','i','f'} };
 115
 116 /******************************************************************************
 117  *
 118  *      language-dependent stock fonts
 119  *
 120  *      'ANSI' charset and 'DEFAULT' charset is not same.
 121  *      The chars in CP_ACP should be drawn with 'DEFAULT' charset.
 122  *      'ANSI' charset seems to be identical with ISO-8859-1.
 123  *      'DEFAULT' charset is a language-dependent charset.
 124  *
 125  *      'System' font seems to be an alias for language-dependent font.
 126  */
 127
 128 /*
 129  * language-dependent stock fonts for all known charsets
 130  * please see TranslateCharsetInfo (dlls/gdi/font.c) and
 131  * CharsetBindingInfo (dlls/x11drv/xfont.c),
 132  * and modify entries for your language if needed.
 133  */
 134 struct DefaultFontInfo
 135 {
 136         UINT            charset;
 137         LOGFONTW        SystemFont;
 138         LOGFONTW        DeviceDefaultFont;
 139         LOGFONTW        SystemFixedFont;
 140         LOGFONTW        DefaultGuiFont;
 141 };
 142
 143 static const struct DefaultFontInfo default_fonts[] =
 144 {
 145     {   ANSI_CHARSET,
 146         { /* System */
 147           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ANSI_CHARSET,
 148            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 149            {'S','y','s','t','e','m'}
 150         },
 151         { /* Device Default */
 152           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ANSI_CHARSET,
 153            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 154            {'S','y','s','t','e','m'}
 155         },
 156         { /* System Fixed */
 157           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 158            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 159            {'C','o','u','r','i','e','r'}
 160         },
 161         { /* DefaultGuiFont */
 162           -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 163            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 164            {'M','S',' ','S','h','e','l','l',' ','D','l','g'}
 165         },
 166     },
 167     {   EASTEUROPE_CHARSET,
 168         { /* System */
 169           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, EASTEUROPE_CHARSET,
 170            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 171            {'S','y','s','t','e','m'}
 172         },
 173         { /* Device Default */
 174           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, EASTEUROPE_CHARSET,
 175            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 176            {'S','y','s','t','e','m'}
 177         },
 178         { /* System Fixed */
 179           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, EASTEUROPE_CHARSET,
 180            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 181            {'C','o','u','r','i','e','r'}
 182         },
 183         { /* DefaultGuiFont */
 184           -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, EASTEUROPE_CHARSET,
 185            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 186            {'M','S',' ','S','h','e','l','l',' ','D','l','g'}
 187         },
 188     },
 189     {   RUSSIAN_CHARSET,
 190         { /* System */
 191           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, RUSSIAN_CHARSET,
 192            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 193            {'S','y','s','t','e','m'}
 194         },
 195         { /* Device Default */
 196           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, RUSSIAN_CHARSET,
 197            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 198            {'S','y','s','t','e','m'}
 199         },
 200         { /* System Fixed */
 201           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, RUSSIAN_CHARSET,
 202            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 203            {'C','o','u','r','i','e','r'}
 204         },
 205         { /* DefaultGuiFont */
 206           -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, RUSSIAN_CHARSET,
 207            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 208            {'M','S',' ','S','h','e','l','l',' ','D','l','g'}
 209         },
 210     },
 211     {   GREEK_CHARSET,
 212         { /* System */
 213           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, GREEK_CHARSET,
 214            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 215            {'S','y','s','t','e','m'}
 216         },
 217         { /* Device Default */
 218           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, GREEK_CHARSET,
 219            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 220            {'S','y','s','t','e','m'}
 221         },
 222         { /* System Fixed */
 223           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GREEK_CHARSET,
 224            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 225            {'C','o','u','r','i','e','r'}
 226         },
 227         { /* DefaultGuiFont */
 228           -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GREEK_CHARSET,
 229            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 230            {'M','S',' ','S','h','e','l','l',' ','D','l','g'}
 231         },
 232     },
 233     {   TURKISH_CHARSET,
 234         { /* System */
 235           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, TURKISH_CHARSET,
 236            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 237            {'S','y','s','t','e','m'}
 238         },
 239         { /* Device Default */
 240           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, TURKISH_CHARSET,
 241            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 242            {'S','y','s','t','e','m'}
 243         },
 244         { /* System Fixed */
 245           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, TURKISH_CHARSET,
 246            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 247            {'C','o','u','r','i','e','r'}
 248         },
 249         { /* DefaultGuiFont */
 250           -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, TURKISH_CHARSET,
 251            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 252            {'M','S',' ','S','h','e','l','l',' ','D','l','g'}
 253         },
 254     },
 255     {   HEBREW_CHARSET,
 256         { /* System */
 257           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, HEBREW_CHARSET,
 258            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 259            {'S','y','s','t','e','m'}
 260         },
 261         { /* Device Default */
 262           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, HEBREW_CHARSET,
 263            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 264            {'S','y','s','t','e','m'}
 265         },
 266         { /* System Fixed */
 267           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HEBREW_CHARSET,
 268            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 269            {'C','o','u','r','i','e','r'}
 270         },
 271         { /* DefaultGuiFont */
 272           -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HEBREW_CHARSET,
 273            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 274            {'M','S',' ','S','h','e','l','l',' ','D','l','g'}
 275         },
 276     },
 277     {   ARABIC_CHARSET,
 278         { /* System */
 279           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ARABIC_CHARSET,
 280            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 281            {'S','y','s','t','e','m'}
 282         },
 283         { /* Device Default */
 284           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ARABIC_CHARSET,
 285            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 286            {'S','y','s','t','e','m'}
 287         },
 288         { /* System Fixed */
 289           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ARABIC_CHARSET,
 290            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 291            {'C','o','u','r','i','e','r'}
 292         },
 293         { /* DefaultGuiFont */
 294           -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ARABIC_CHARSET,
 295            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 296            {'M','S',' ','S','h','e','l','l',' ','D','l','g'}
 297         },
 298     },
 299     {   BALTIC_CHARSET,
 300         { /* System */
 301           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, BALTIC_CHARSET,
 302            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 303            {'S','y','s','t','e','m'}
 304         },
 305         { /* Device Default */
 306           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, BALTIC_CHARSET,
 307            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 308            {'S','y','s','t','e','m'}
 309         },
 310         { /* System Fixed */
 311           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, BALTIC_CHARSET,
 312            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 313            {'C','o','u','r','i','e','r'}
 314         },
 315         { /* DefaultGuiFont */
 316           -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, BALTIC_CHARSET,
 317            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 318            {'M','S',' ','S','h','e','l','l',' ','D','l','g'}
 319         },
 320     },
 321     {   THAI_CHARSET,
 322         { /* System */
 323           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, THAI_CHARSET,
 324            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 325            {'S','y','s','t','e','m'}
 326         },
 327         { /* Device Default */
 328           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, THAI_CHARSET,
 329            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 330            {'S','y','s','t','e','m'}
 331         },
 332         { /* System Fixed */
 333           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, THAI_CHARSET,
 334            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 335            {'C','o','u','r','i','e','r'}
 336         },
 337         { /* DefaultGuiFont */
 338           -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, THAI_CHARSET,
 339            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 340            {'M','S',' ','S','h','e','l','l',' ','D','l','g'}
 341         },
 342     },
 343     {   SHIFTJIS_CHARSET,
 344         { /* System */
 345           18, 8, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, SHIFTJIS_CHARSET,
 346            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 347            {'S','y','s','t','e','m'}
 348         },
 349         { /* Device Default */
 350           18, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, SHIFTJIS_CHARSET,
 351            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 352            {'S','y','s','t','e','m'}
 353         },
 354         { /* System Fixed */
 355           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, SHIFTJIS_CHARSET,
 356            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 357            {'C','o','u','r','i','e','r'}
 358         },
 359         { /* DefaultGuiFont */
 360           -12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, SHIFTJIS_CHARSET,
 361            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 362            {'M','S',' ','S','h','e','l','l',' ','D','l','g'}
 363         },
 364     },
 365     {   GB2312_CHARSET,
 366         { /* System */
 367           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, GB2312_CHARSET,
 368            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 369            {'S','y','s','t','e','m'}
 370         },
 371         { /* Device Default */
 372           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, GB2312_CHARSET,
 373            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 374            {'S','y','s','t','e','m'}
 375         },
 376         { /* System Fixed */
 377           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GB2312_CHARSET,
 378            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 379            {'C','o','u','r','i','e','r'}
 380         },
 381         { /* DefaultGuiFont */
 382           -12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GB2312_CHARSET,
 383            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 384            {'M','S',' ','S','h','e','l','l',' ','D','l','g'}
 385         },
 386     },
 387     {   HANGEUL_CHARSET,
 388         { /* System */
 389           16, 8, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HANGEUL_CHARSET,
 390            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 391            {'S','y','s','t','e','m'}
 392         },
 393         { /* Device Default */
 394           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HANGEUL_CHARSET,
 395            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 396            {'S','y','s','t','e','m'}
 397         },
 398         { /* System Fixed */
 399           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HANGEUL_CHARSET,
 400            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 401            {'C','o','u','r','i','e','r'}
 402         },
 403         { /* DefaultGuiFont */
 404           -12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HANGEUL_CHARSET,
 405            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 406            {'M','S',' ','S','h','e','l','l',' ','D','l','g'}
 407         },
 408     },
 409     {   CHINESEBIG5_CHARSET,
 410         { /* System */
 411           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, CHINESEBIG5_CHARSET,
 412            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 413            {'S','y','s','t','e','m'}
 414         },
 415         { /* Device Default */
 416           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, CHINESEBIG5_CHARSET,
 417            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 418            {'S','y','s','t','e','m'}
 419         },
 420         { /* System Fixed */
 421           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, CHINESEBIG5_CHARSET,
 422            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 423            {'C','o','u','r','i','e','r'}
 424         },
 425         { /* DefaultGuiFont */
 426           -12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, CHINESEBIG5_CHARSET,
 427            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 428            {'M','S',' ','S','h','e','l','l',' ','D','l','g'}
 429         },
 430     },
 431     {   JOHAB_CHARSET,
 432         { /* System */
 433           16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, JOHAB_CHARSET,
 434            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 435            {'S','y','s','t','e','m'}
 436         },
 437         { /* Device Default */
 438           16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, JOHAB_CHARSET,
 439            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 440            {'S','y','s','t','e','m'}
 441         },
 442         { /* System Fixed */
 443           16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, JOHAB_CHARSET,
 444            0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
 445            {'C','o','u','r','i','e','r'}
 446         },
 447         { /* DefaultGuiFont */
 448           -12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, JOHAB_CHARSET,
 449            0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
 450            {'M','S',' ','S','h','e','l','l',' ','D','l','g'}
 451         },
 452     },
 453 };
 454
 455 void make_gdi_object_system( HGDIOBJ handle, BOOL set)
 456 {
 457     GDI_HANDLE_ENTRY *entry;
 458
 459     pthread_mutex_lock( &gdi_lock );
 460     if ((entry = handle_entry( handle ))) entry_obj( entry )->system = !!set;
 461     pthread_mutex_unlock( &gdi_lock );
 462 }
 463
 464 /******************************************************************************
 465  *      get_default_fonts
 466  */
 467 static const struct DefaultFontInfo* get_default_fonts(UINT charset)
 468 {
 469         unsigned int n;
 470
 471         for(n = 0; n < ARRAY_SIZE( default_fonts ); n++)
 472         {
 473                 if ( default_fonts[n].charset == charset )
 474                         return &default_fonts[n];
 475         }
 476
 477         FIXME( "unhandled charset 0x%08x - use ANSI_CHARSET for default stock objects\n", charset );
 478         return &default_fonts[0];
 479 }
 480
 481
 482 /******************************************************************************
 483  *      get_default_charset    (internal)
 484  *
 485  * get the language-dependent charset that can handle CP_ACP correctly.
 486  */
 487 static UINT get_default_charset( void )
 488 {
 489     CHARSETINFO     csi;
 490     UINT    uACP;
 491
 492     uACP = get_acp();
 493     csi.ciCharset = ANSI_CHARSET;
 494     if ( !translate_charset_info( ULongToPtr(uACP), &csi, TCI_SRCCODEPAGE ) )
 495     {
 496         FIXME( "unhandled codepage %u - use ANSI_CHARSET for default stock objects\n", uACP );
 497         return ANSI_CHARSET;
 498     }
 499
 500     return csi.ciCharset;
 501 }
 502
 503
 504 /***********************************************************************
 505  *           GDI_get_ref_count
 506  *
 507  * Retrieve the reference count of a GDI object.
 508  * Note: the object must be locked otherwise the count is meaningless.
 509  */
 510 UINT GDI_get_ref_count( HGDIOBJ handle )
 511 {
 512     GDI_HANDLE_ENTRY *entry;
 513     UINT ret = 0;
 514
 515     pthread_mutex_lock( &gdi_lock );
 516     if ((entry = handle_entry( handle ))) ret = entry_obj( entry )->selcount;
 517     pthread_mutex_unlock( &gdi_lock );
 518     return ret;
 519 }
 520
 521
 522 /***********************************************************************
 523  *           GDI_inc_ref_count
 524  *
 525  * Increment the reference count of a GDI object.
 526  */
 527 HGDIOBJ GDI_inc_ref_count( HGDIOBJ handle )
 528 {
 529     GDI_HANDLE_ENTRY *entry;
 530
 531     pthread_mutex_lock( &gdi_lock );
 532     if ((entry = handle_entry( handle ))) entry_obj( entry )->selcount++;
 533     else handle = 0;
 534     pthread_mutex_unlock( &gdi_lock );
 535     return handle;
 536 }
 537
 538
 539 /***********************************************************************
 540  *           GDI_dec_ref_count
 541  *
 542  * Decrement the reference count of a GDI object.
 543  */
 544 BOOL GDI_dec_ref_count( HGDIOBJ handle )
 545 {
 546     GDI_HANDLE_ENTRY *entry;
 547
 548     pthread_mutex_lock( &gdi_lock );
 549     if ((entry = handle_entry( handle )))
 550     {
 551         assert( entry_obj( entry )->selcount );
 552         if (!--entry_obj( entry )->selcount && entry_obj( entry )->deleted)
 553         {
 554             /* handle delayed DeleteObject*/
 555             entry_obj( entry )->deleted = 0;
 556             pthread_mutex_unlock( &gdi_lock );
 557             TRACE( "executing delayed DeleteObject for %p\n", handle );
 558             NtGdiDeleteObjectApp( handle );
 559             return TRUE;
 560         }
 561     }
 562     pthread_mutex_unlock( &gdi_lock );
 563     return entry != NULL;
 564 }
 565
 566
 567 static HFONT create_font( const LOGFONTW *deffont )
 568 {
 569     ENUMLOGFONTEXDVW lf;
 570
 571     memset( &lf, 0, sizeof(lf) );
 572     lf.elfEnumLogfontEx.elfLogFont = *deffont;
 573     return NtGdiHfontCreate( &lf, sizeof(lf), 0, 0, NULL );
 574 }
 575
 576 static HFONT create_scaled_font( const LOGFONTW *deffont, unsigned int dpi )
 577 {
 578     LOGFONTW lf;
 579
 580     lf = *deffont;
 581     lf.lfHeight = muldiv( lf.lfHeight, dpi, 96 );
 582     return create_font( &lf );
 583 }
 584
 585 static void init_gdi_shared(void)
 586 {
 587     SIZE_T size = sizeof(*gdi_shared);
 588
 589     if (NtAllocateVirtualMemory( GetCurrentProcess(), (void **)&gdi_shared, 0, &size,
 590                                  MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE ))
 591         return;
 592     next_unused = gdi_shared->Handles + FIRST_GDI_HANDLE;
 593
 594 #ifndef _WIN64
 595     if (NtCurrentTeb()->GdiBatchCount)
 596     {
 597         TEB64 *teb64 = (TEB64 *)(UINT_PTR)NtCurrentTeb()->GdiBatchCount;
 598         PEB64 *peb64 = (PEB64 *)(UINT_PTR)teb64->Peb;
 599         peb64->GdiSharedHandleTable = (UINT_PTR)gdi_shared;
 600         return;
 601     }
 602 #endif
 603     /* NOTE: Windows uses 32-bit for 32-bit kernel */
 604     NtCurrentTeb()->Peb->GdiSharedHandleTable = gdi_shared;
 605 }
 606
 607 HGDIOBJ get_stock_object( INT obj )
 608 {
 609     assert( obj >= 0 && obj <= STOCK_LAST + 1 && obj != 9 );
 610
 611     switch (obj)
 612     {
 613     case OEM_FIXED_FONT:
 614         if (get_system_dpi() != 96) obj = 9;
 615         break;
 616     case SYSTEM_FONT:
 617         if (get_system_dpi() != 96) obj = STOCK_LAST + 2;
 618         break;
 619     case SYSTEM_FIXED_FONT:
 620         if (get_system_dpi() != 96) obj = STOCK_LAST + 3;
 621         break;
 622     case DEFAULT_GUI_FONT:
 623         if (get_system_dpi() != 96) obj = STOCK_LAST + 4;
 624         break;
 625     }
 626
 627     return entry_to_handle( handle_entry( ULongToHandle( obj + FIRST_GDI_HANDLE )));
 628 }
 629
 630 static void init_stock_objects( unsigned int dpi )
 631 {
 632     const struct DefaultFontInfo *deffonts;
 633     unsigned int i;
 634     HGDIOBJ obj;
 635
 636     /* Create stock objects in order matching stock object macros,
 637      * so that they use predictable handle slots. Our GetStockObject
 638      * depends on it. */
 639     create_brush( &WhiteBrush );
 640     create_brush( &LtGrayBrush );
 641     create_brush( &GrayBrush );
 642     create_brush( &DkGrayBrush );
 643     create_brush( &BlackBrush );
 644     create_brush( &NullBrush );
 645
 646     create_pen( PS_SOLID, 0, RGB(255,255,255) );
 647     create_pen( PS_SOLID, 0, RGB(0,0,0) );
 648     create_pen( PS_NULL,  0, RGB(0,0,0) );
 649
 650     /* slot 9 is not used for non-scaled stock objects */
 651     create_scaled_font( &OEMFixedFont, dpi );
 652
 653     /* language-independent stock fonts */
 654     create_font( &OEMFixedFont );
 655     create_font( &AnsiFixedFont );
 656     create_font( &AnsiVarFont );
 657
 658     /* language-dependent stock fonts */
 659     deffonts = get_default_fonts(get_default_charset());
 660     create_font( &deffonts->SystemFont );
 661     create_font( &deffonts->DeviceDefaultFont );
 662
 663     PALETTE_Init();
 664
 665     create_font( &deffonts->SystemFixedFont );
 666     create_font( &deffonts->DefaultGuiFont );
 667
 668     create_brush( &DCBrush );
 669     NtGdiCreatePen( PS_SOLID, 0, RGB(0,0,0), NULL );
 670
 671     obj = NtGdiCreateBitmap( 1, 1, 1, 1, NULL );
 672
 673     assert( (HandleToULong( obj ) & 0xffff) == FIRST_GDI_HANDLE + DEFAULT_BITMAP );
 674
 675     create_scaled_font( &deffonts->SystemFont, dpi );
 676     create_scaled_font( &deffonts->SystemFixedFont, dpi );
 677     create_scaled_font( &deffonts->DefaultGuiFont, dpi );
 678
 679     /* clear the NOSYSTEM bit on all stock objects*/
 680     for (i = 0; i < STOCK_LAST + 5; i++)
 681     {
 682         GDI_HANDLE_ENTRY *entry = &gdi_shared->Handles[FIRST_GDI_HANDLE + i];
 683         entry_obj( entry )->system = TRUE;
 684         entry->StockFlag = 1;
 685     }
 686 }
 687
 688
 689 static const char *gdi_obj_type( unsigned type )
 690 {
 691     switch ( type )
 692     {
 693         case NTGDI_OBJ_PEN: return "NTGDI_OBJ_PEN";
 694         case NTGDI_OBJ_BRUSH: return "NTGDI_OBJ_BRUSH";
 695         case NTGDI_OBJ_DC: return "NTGDI_OBJ_DC";
 696         case NTGDI_OBJ_METADC: return "NTGDI_OBJ_METADC";
 697         case NTGDI_OBJ_PAL: return "NTGDI_OBJ_PAL";
 698         case NTGDI_OBJ_FONT: return "NTGDI_OBJ_FONT";
 699         case NTGDI_OBJ_BITMAP: return "NTGDI_OBJ_BITMAP";
 700         case NTGDI_OBJ_REGION: return "NTGDI_OBJ_REGION";
 701         case NTGDI_OBJ_METAFILE: return "NTGDI_OBJ_METAFILE";
 702         case NTGDI_OBJ_MEMDC: return "NTGDI_OBJ_MEMDC";
 703         case NTGDI_OBJ_EXTPEN: return "NTGDI_OBJ_EXTPEN";
 704         case NTGDI_OBJ_ENHMETADC: return "NTGDI_OBJ_ENHMETADC";
 705         case NTGDI_OBJ_ENHMETAFILE: return "NTGDI_OBJ_ENHMETAFILE";
 706         default: return "UNKNOWN";
 707     }
 708 }
 709
 710 static void dump_gdi_objects( void )
 711 {
 712     GDI_HANDLE_ENTRY *entry;
 713
 714     TRACE( "%u objects:\n", GDI_MAX_HANDLE_COUNT );
 715
 716     pthread_mutex_lock( &gdi_lock );
 717     for (entry = gdi_shared->Handles; entry < next_unused; entry++)
 718     {
 719         if (!entry->Type)
 720             TRACE( "handle %p FREE\n", entry_to_handle( entry ));
 721         else
 722             TRACE( "handle %p obj %s type %s selcount %u deleted %u\n",
 723                    entry_to_handle( entry ), wine_dbgstr_longlong( entry->Object ),
 724                    gdi_obj_type( entry->ExtType << NTGDI_HANDLE_TYPE_SHIFT ),
 725                    entry_obj( entry )->selcount, entry_obj( entry )->deleted );
 726     }
 727     pthread_mutex_unlock( &gdi_lock );
 728 }
 729
 730 /***********************************************************************
 731  *           alloc_gdi_handle
 732  *
 733  * Allocate a GDI handle for an object, which must have been allocated on the process heap.
 734  */
 735 HGDIOBJ alloc_gdi_handle( struct gdi_obj_header *obj, DWORD type, const struct gdi_obj_funcs *funcs )
 736 {
 737     GDI_HANDLE_ENTRY *entry;
 738     HGDIOBJ ret;
 739
 740     assert( type );  /* type 0 is reserved to mark free entries */
 741
 742     pthread_mutex_lock( &gdi_lock );
 743
 744     entry = next_free;
 745     if (entry)
 746         next_free = (GDI_HANDLE_ENTRY *)(UINT_PTR)entry->Object;
 747     else if (next_unused < gdi_shared->Handles + GDI_MAX_HANDLE_COUNT)
 748         entry = next_unused++;
 749     else
 750     {
 751         pthread_mutex_unlock( &gdi_lock );
 752         ERR( "out of GDI object handles, expect a crash\n" );
 753         if (TRACE_ON(gdi)) dump_gdi_objects();
 754         return 0;
 755     }
 756     obj->funcs    = funcs;
 757     obj->selcount = 0;
 758     obj->system   = 0;
 759     obj->deleted  = 0;
 760     entry->Object  = (UINT_PTR)obj;
 761     entry->ExtType = type >> NTGDI_HANDLE_TYPE_SHIFT;
 762     entry->Type    = entry->ExtType & 0x1f;
 763     if (++entry->Generation == 0xff) entry->Generation = 1;
 764     ret = entry_to_handle( entry );
 765     pthread_mutex_unlock( &gdi_lock );
 766     TRACE( "allocated %s %p %u/%u\n", gdi_obj_type(type), ret,
 767            InterlockedIncrement( &debug_count ), GDI_MAX_HANDLE_COUNT );
 768     return ret;
 769 }
 770
 771
 772 /***********************************************************************
 773  *           free_gdi_handle
 774  *
 775  * Free a GDI handle and return a pointer to the object.
 776  */
 777 void *free_gdi_handle( HGDIOBJ handle )
 778 {
 779     void *object = NULL;
 780     GDI_HANDLE_ENTRY *entry;
 781
 782     pthread_mutex_lock( &gdi_lock );
 783     if ((entry = handle_entry( handle )))
 784     {
 785         TRACE( "freed %s %p %u/%u\n", gdi_obj_type( entry->ExtType << NTGDI_HANDLE_TYPE_SHIFT ),
 786                handle, InterlockedDecrement( &debug_count ) + 1, GDI_MAX_HANDLE_COUNT );
 787         object = entry_obj( entry );
 788         entry->Type = 0;
 789         entry->Object = (UINT_PTR)next_free;
 790         next_free = entry;
 791     }
 792     pthread_mutex_unlock( &gdi_lock );
 793     return object;
 794 }
 795
 796 DWORD get_gdi_object_type( HGDIOBJ obj )
 797 {
 798     GDI_HANDLE_ENTRY *entry = handle_entry( obj );
 799     return entry ? entry->ExtType << NTGDI_HANDLE_TYPE_SHIFT : 0;
 800 }
 801
 802 void set_gdi_client_ptr( HGDIOBJ obj, void *ptr )
 803 {
 804     GDI_HANDLE_ENTRY *entry = handle_entry( obj );
 805     if (entry) entry->UserPointer = (UINT_PTR)ptr;
 806 }
 807
 808 /***********************************************************************
 809  *           get_any_obj_ptr
 810  *
 811  * Return a pointer to, and the type of, the GDI object
 812  * associated with the handle.
 813  * The object must be released with GDI_ReleaseObj.
 814  */
 815 void *get_any_obj_ptr( HGDIOBJ handle, DWORD *type )
 816 {
 817     void *ptr = NULL;
 818     GDI_HANDLE_ENTRY *entry;
 819
 820     pthread_mutex_lock( &gdi_lock );
 821
 822     if ((entry = handle_entry( handle )))
 823     {
 824         ptr = entry_obj( entry );
 825         *type = entry->ExtType << NTGDI_HANDLE_TYPE_SHIFT;
 826     }
 827
 828     if (!ptr) pthread_mutex_unlock( &gdi_lock );
 829     return ptr;
 830 }
 831
 832 /***********************************************************************
 833  *           GDI_GetObjPtr
 834  *
 835  * Return a pointer to the GDI object associated with the handle.
 836  * Return NULL if the object has the wrong type.
 837  * The object must be released with GDI_ReleaseObj.
 838  */
 839 void *GDI_GetObjPtr( HGDIOBJ handle, DWORD type )
 840 {
 841     DWORD ret_type;
 842     void *ptr = get_any_obj_ptr( handle, &ret_type );
 843     if (ptr && ret_type != type)
 844     {
 845         GDI_ReleaseObj( handle );
 846         ptr = NULL;
 847     }
 848     return ptr;
 849 }
 850
 851 /***********************************************************************
 852  *           GDI_ReleaseObj
 853  *
 854  */
 855 void GDI_ReleaseObj( HGDIOBJ handle )
 856 {
 857     pthread_mutex_unlock( &gdi_lock );
 858 }
 859
 860
 861 /***********************************************************************
 862  *           NtGdiDeleteObjectApp    (win32u.@)
 863  *
 864  * Delete a Gdi object.
 865  *
 866  * PARAMS
 867  *  obj [I] Gdi object to delete
 868  *
 869  * RETURNS
 870  *  Success: TRUE. If obj was not returned from GetStockObject(), any resources
 871  *           it consumed are released.
 872  *  Failure: FALSE, if obj is not a valid Gdi object, or is currently selected
 873  *           into a DC.
 874  */
 875 BOOL WINAPI NtGdiDeleteObjectApp( HGDIOBJ obj )
 876 {
 877     GDI_HANDLE_ENTRY *entry;
 878     const struct gdi_obj_funcs *funcs = NULL;
 879     struct gdi_obj_header *header;
 880
 881     pthread_mutex_lock( &gdi_lock );
 882     if (!(entry = handle_entry( obj )))
 883     {
 884         pthread_mutex_unlock( &gdi_lock );
 885         return FALSE;
 886     }
 887
 888     header = entry_obj( entry );
 889     if (header->system)
 890     {
 891         TRACE("Preserving system object %p\n", obj);
 892         pthread_mutex_unlock( &gdi_lock );
 893         return TRUE;
 894     }
 895
 896     obj = entry_to_handle( entry );  /* make it a full handle */
 897
 898     if (header->selcount)
 899     {
 900         TRACE("delayed for %p because object in use, count %u\n", obj, header->selcount );
 901         header->deleted = 1;  /* mark for delete */
 902     }
 903     else funcs = header->funcs;
 904
 905     pthread_mutex_unlock( &gdi_lock );
 906
 907     TRACE("%p\n", obj );
 908
 909     if (funcs && funcs->pDeleteObject) return funcs->pDeleteObject( obj );
 910     return TRUE;
 911 }
 912
 913 /***********************************************************************
 914  *           NtGdiCreateClientObj    (win32u.@)
 915  */
 916 HANDLE WINAPI NtGdiCreateClientObj( ULONG type )
 917 {
 918     struct gdi_obj_header *obj;
 919     HGDIOBJ handle;
 920
 921     if (!(obj = malloc( sizeof(*obj) )))
 922         return 0;
 923
 924     handle = alloc_gdi_handle( obj, type, NULL );
 925     if (!handle) free( obj );
 926     return handle;
 927 }
 928
 929 /***********************************************************************
 930  *           NtGdiDeleteClientObj    (win32u.@)
 931  */
 932 BOOL WINAPI NtGdiDeleteClientObj( HGDIOBJ handle )
 933 {
 934     void *obj;
 935     if (!(obj = free_gdi_handle( handle ))) return FALSE;
 936     free( obj );
 937     return TRUE;
 938 }
 939
 940
 941 /***********************************************************************
 942  *           NtGdiExtGetObjectW    (win32u.@)
 943  */
 944 INT WINAPI NtGdiExtGetObjectW( HGDIOBJ handle, INT count, void *buffer )
 945 {
 946     GDI_HANDLE_ENTRY *entry;
 947     const struct gdi_obj_funcs *funcs = NULL;
 948     INT result = 0;
 949
 950     TRACE("%p %d %p\n", handle, count, buffer );
 951
 952     pthread_mutex_lock( &gdi_lock );
 953     if ((entry = handle_entry( handle )))
 954     {
 955         funcs = entry_obj( entry )->funcs;
 956         handle = entry_to_handle( entry );  /* make it a full handle */
 957     }
 958     pthread_mutex_unlock( &gdi_lock );
 959
 960     if (funcs && funcs->pGetObjectW)
 961     {
 962         if (buffer && ((ULONG_PTR)buffer >> 16) == 0) /* catch apps getting argument order wrong */
 963             SetLastError( ERROR_NOACCESS );
 964         else
 965             result = funcs->pGetObjectW( handle, count, buffer );
 966     }
 967     return result;
 968 }
 969
 970 /***********************************************************************
 971  *           NtGdiGetDCObject    (win32u.@)
 972  *
 973  * Get the currently selected object of a given type in a device context.
 974  */
 975 HANDLE WINAPI NtGdiGetDCObject( HDC hdc, UINT type )
 976 {
 977     HGDIOBJ ret = 0;
 978     DC *dc;
 979
 980     if (!(dc = get_dc_ptr( hdc ))) return 0;
 981
 982     switch (type)
 983     {
 984     case NTGDI_OBJ_EXTPEN: /* fall through */
 985     case NTGDI_OBJ_PEN:    ret = dc->hPen; break;
 986     case NTGDI_OBJ_BRUSH:  ret = dc->hBrush; break;
 987     case NTGDI_OBJ_PAL:    ret = dc->hPalette; break;
 988     case NTGDI_OBJ_FONT:   ret = dc->hFont; break;
 989     case NTGDI_OBJ_SURF:   ret = dc->hBitmap; break;
 990     default:
 991         FIXME( "(%p, %d): unknown type.\n", hdc, type );
 992         break;
 993     }
 994     release_dc_ptr( dc );
 995     return ret;
 996 }
 997
 998
 999 /***********************************************************************
1000  *           NtGdiUnrealizeObject    (win32u.@)
1001  */
1002 BOOL WINAPI NtGdiUnrealizeObject( HGDIOBJ obj )
1003 {
1004     const struct gdi_obj_funcs *funcs = NULL;
1005     GDI_HANDLE_ENTRY *entry;
1006
1007     pthread_mutex_lock( &gdi_lock );
1008     if ((entry = handle_entry( obj )))
1009     {
1010         funcs = entry_obj( entry )->funcs;
1011         obj = entry_to_handle( entry );  /* make it a full handle */
1012     }
1013     pthread_mutex_unlock( &gdi_lock );
1014
1015     if (funcs && funcs->pUnrealizeObject) return funcs->pUnrealizeObject( obj );
1016     return funcs != NULL;
1017 }
1018
1019
1020 /***********************************************************************
1021  *           NtGdiFlush    (win32u.@)
1022  */
1023 BOOL WINAPI NtGdiFlush(void)
1024 {
1025     return TRUE;  /* FIXME */
1026 }
1027
1028
1029 /*******************************************************************
1030  *           NtGdiGetColorAdjustment    (win32u.@)
1031  */
1032 BOOL WINAPI NtGdiGetColorAdjustment( HDC hdc, COLORADJUSTMENT *ca )
1033 {
1034     FIXME( "stub\n" );
1035     return FALSE;
1036 }
1037
1038 /*******************************************************************
1039  *           NtGdiSetColorAdjustment    (win32u.@)
1040  */
1041 BOOL WINAPI NtGdiSetColorAdjustment( HDC hdc, const COLORADJUSTMENT *ca )
1042 {
1043     FIXME( "stub\n" );
1044     return FALSE;
1045 }
1046
1047
1048 static struct unix_funcs unix_funcs =
1049 {
1050     NtGdiAbortDoc,
1051     NtGdiAbortPath,
1052     NtGdiAlphaBlend,
1053     NtGdiAngleArc,
1054     NtGdiArcInternal,
1055     NtGdiBeginPath,
1056     NtGdiBitBlt,
1057     NtGdiCloseFigure,
1058     NtGdiComputeXformCoefficients,
1059     NtGdiCreateCompatibleBitmap,
1060     NtGdiCreateCompatibleDC,
1061     NtGdiCreateDIBitmapInternal,
1062     NtGdiCreateMetafileDC,
1063     NtGdiDdDDICheckVidPnExclusiveOwnership,
1064     NtGdiDdDDICreateDCFromMemory,
1065     NtGdiDdDDIDestroyDCFromMemory,
1066     NtGdiDdDDIDestroyDevice,
1067     NtGdiDdDDIEscape,
1068     NtGdiDdDDISetVidPnSourceOwner,
1069     NtGdiDeleteObjectApp,
1070     NtGdiDoPalette,
1071     NtGdiEllipse,
1072     NtGdiEndDoc,
1073     NtGdiEndPath,
1074     NtGdiEndPage,
1075     NtGdiEnumFonts,
1076     NtGdiExcludeClipRect,
1077     NtGdiExtEscape,
1078     NtGdiExtFloodFill,
1079     NtGdiExtTextOutW,
1080     NtGdiExtSelectClipRgn,
1081     NtGdiFillPath,
1082     NtGdiFillRgn,
1083     NtGdiFontIsLinked,
1084     NtGdiFrameRgn,
1085     NtGdiGetAndSetDCDword,
1086     NtGdiGetAppClipBox,
1087     NtGdiGetBoundsRect,
1088     NtGdiGetCharABCWidthsW,
1089     NtGdiGetCharWidthW,
1090     NtGdiGetCharWidthInfo,
1091     NtGdiGetDIBitsInternal,
1092     NtGdiGetDeviceCaps,
1093     NtGdiGetDeviceGammaRamp,
1094     NtGdiGetFontData,
1095     NtGdiGetFontUnicodeRanges,
1096     NtGdiGetGlyphIndicesW,
1097     NtGdiGetGlyphOutline,
1098     NtGdiGetKerningPairs,
1099     NtGdiGetNearestColor,
1100     NtGdiGetOutlineTextMetricsInternalW,
1101     NtGdiGetPixel,
1102     NtGdiGetRandomRgn,
1103     NtGdiGetRasterizerCaps,
1104     NtGdiGetRealizationInfo,
1105     NtGdiGetTextCharsetInfo,
1106     NtGdiGetTextExtentExW,
1107     NtGdiGetTextFaceW,
1108     NtGdiGetTextMetricsW,
1109     NtGdiGradientFill,
1110     NtGdiIntersectClipRect,
1111     NtGdiInvertRgn,
1112     NtGdiLineTo,
1113     NtGdiMaskBlt,
1114     NtGdiModifyWorldTransform,
1115     NtGdiMoveTo,
1116     NtGdiOffsetClipRgn,
1117     NtGdiOpenDCW,
1118     NtGdiPatBlt,
1119     NtGdiPlgBlt,
1120     NtGdiPolyDraw,
1121     NtGdiPolyPolyDraw,
1122     NtGdiPtVisible,
1123     NtGdiRectVisible,
1124     NtGdiRectangle,
1125     NtGdiResetDC,
1126     NtGdiResizePalette,
1127     NtGdiRestoreDC,
1128     NtGdiRoundRect,
1129     NtGdiScaleViewportExtEx,
1130     NtGdiScaleWindowExtEx,
1131     NtGdiSelectBitmap,
1132     NtGdiSelectBrush,
1133     NtGdiSelectClipPath,
1134     NtGdiSelectFont,
1135     NtGdiSelectPen,
1136     NtGdiSetBoundsRect,
1137     NtGdiSetDIBitsToDeviceInternal,
1138     NtGdiSetDeviceGammaRamp,
1139     NtGdiSetLayout,
1140     NtGdiSetPixel,
1141     NtGdiSetSystemPaletteUse,
1142     NtGdiStartDoc,
1143     NtGdiStartPage,
1144     NtGdiStretchBlt,
1145     NtGdiStretchDIBitsInternal,
1146     NtGdiStrokeAndFillPath,
1147     NtGdiStrokePath,
1148     NtGdiTransparentBlt,
1149     NtGdiUnrealizeObject,
1150     NtGdiUpdateColors,
1151     NtGdiWidenPath,
1152     NtUserActivateKeyboardLayout,
1153     NtUserCallOneParam,
1154     NtUserCallTwoParam,
1155     NtUserChangeDisplaySettings,
1156     NtUserCountClipboardFormats,
1157     NtUserEnumDisplayDevices,
1158     NtUserEnumDisplayMonitors,
1159     NtUserEnumDisplaySettings,
1160     NtUserGetDisplayConfigBufferSizes,
1161     NtUserGetKeyNameText,
1162     NtUserGetKeyboardLayoutList,
1163     NtUserGetPriorityClipboardFormat,
1164     NtUserGetUpdatedClipboardFormats,
1165     NtUserIsClipboardFormatAvailable,
1166     NtUserMapVirtualKeyEx,
1167     NtUserScrollDC,
1168     NtUserSelectPalette,
1169     NtUserSetSysColors,
1170     NtUserShowCursor,
1171     NtUserSystemParametersInfo,
1172     NtUserSystemParametersInfoForDpi,
1173     NtUserToUnicodeEx,
1174     NtUserUnregisterHotKey,
1175     NtUserVkKeyScanEx,
1176
1177     GetDCHook,
1178     SetDCHook,
1179     SetDIBits,
1180     SetHookFlags,
1181     __wine_get_brush_bitmap_info,
1182     __wine_get_file_outline_text_metric,
1183     __wine_get_icm_profile,
1184     __wine_get_vulkan_driver,
1185     __wine_get_wgl_driver,
1186     __wine_set_display_driver,
1187     __wine_set_visible_region,
1188 };
1189
1190 NTSTATUS gdi_init(void)
1191 {
1192     pthread_mutexattr_t attr;
1193     unsigned int dpi;
1194
1195     pthread_mutexattr_init( &attr );
1196     pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE );
1197     pthread_mutex_init( &gdi_lock, &attr );
1198     pthread_mutexattr_destroy( &attr );
1199
1200     NtQuerySystemInformation( SystemBasicInformation, &system_info, sizeof(system_info), NULL );
1201     init_gdi_shared();
1202     if (!gdi_shared) return STATUS_NO_MEMORY;
1203
1204     dpi = font_init();
1205     init_stock_objects( dpi );
1206     return 0;
1207 }
1208
1209 NTSTATUS callbacks_init( void *args )
1210 {
1211     user_callbacks = *(const struct user_callbacks **)args;
1212     *(const struct unix_funcs **)args = &unix_funcs;
1213     return 0;
1214 }