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