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 "winerror.h"
33 #include "winternl.h"
34
35 #include "gdi_private.h"
36 #include "wine/debug.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(gdi);
39
40 #define HGDIOBJ_32(h16) ((HGDIOBJ)(ULONG_PTR)(h16))
41
42 #define GDI_HEAP_SIZE 0xffe0
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 static const LOGBRUSH LtGrayBrush = { BS_SOLID, RGB(192,192,192), 0 };
53 static const LOGBRUSH GrayBrush = { BS_SOLID, RGB(128,128,128), 0 };
54 static const LOGBRUSH DkGrayBrush = { BS_SOLID, RGB(64,64,64), 0 };
55
56 static const LOGPEN WhitePen = { PS_SOLID, { 0, 0 }, RGB(255,255,255) };
57 static const LOGPEN BlackPen = { PS_SOLID, { 0, 0 }, RGB(0,0,0) };
58 static const LOGPEN NullPen = { PS_NULL, { 0, 0 }, 0 };
59
60 static const LOGBRUSH DCBrush = { BS_SOLID, RGB(255,255,255), 0 };
61 static const LOGPEN DCPen = { PS_SOLID, { 0, 0 }, RGB(0,0,0) };
62
63 /* reserve one extra entry for the stock default bitmap */
64 /* this is what Windows does too */
65 #define NB_STOCK_OBJECTS (STOCK_LAST+2)
66
67 static HGDIOBJ stock_objects[NB_STOCK_OBJECTS];
68
69 static SYSLEVEL GDI_level;
70 static CRITICAL_SECTION_DEBUG critsect_debug =
71 {
72 0, 0, &GDI_level.crst,
73 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
74 0, 0, { (DWORD_PTR)(__FILE__ ": GDI_level") }
75 };
76 static SYSLEVEL GDI_level = { { &critsect_debug, -1, 0, 0, 0, 0 }, 3 };
77
78
79 /****************************************************************************
80 *
81 * language-independent stock fonts
82 *
83 */
84
85 static const LOGFONTW OEMFixedFont =
86 { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, OEM_CHARSET,
87 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, {'\0'} };
88
89 static const LOGFONTW AnsiFixedFont =
90 { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
91 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, {'\0'} };
92
93 static const LOGFONTW AnsiVarFont =
94 { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
95 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
96 {'M','S',' ','S','a','n','s',' ','S','e','r','i','f','\0'} };
97
98 /******************************************************************************
99 *
100 * language-dependent stock fonts
101 *
102 * 'ANSI' charset and 'DEFAULT' charset is not same.
103 * The chars in CP_ACP should be drawn with 'DEFAULT' charset.
104 * 'ANSI' charset seems to be identical with ISO-8859-1.
105 * 'DEFAULT' charset is a language-dependent charset.
106 *
107 * 'System' font seems to be an alias for language-dependent font.
108 */
109
110 /*
111 * language-dependent stock fonts for all known charsets
112 * please see TranslateCharsetInfo (dlls/gdi/font.c) and
113 * CharsetBindingInfo (dlls/x11drv/xfont.c),
114 * and modify entries for your language if needed.
115 */
116 struct DefaultFontInfo
117 {
118 UINT charset;
119 LOGFONTW SystemFont;
120 LOGFONTW DeviceDefaultFont;
121 LOGFONTW SystemFixedFont;
122 LOGFONTW DefaultGuiFont; /* Note for this font the lfHeight member should be the point size */
123 };
124
125 static const struct DefaultFontInfo default_fonts[] =
126 {
127 { ANSI_CHARSET,
128 { /* System */
129 16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
130 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
131 {'S','y','s','t','e','m','\0'}
132 },
133 { /* Device Default */
134 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
135 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
136 {'\0'}
137 },
138 { /* System Fixed */
139 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
140 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
141 {'\0'}
142 },
143 { /* DefaultGuiFont */
144 8, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
145 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
146 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
147 },
148 },
149 { EASTEUROPE_CHARSET,
150 { /* System */
151 16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, EASTEUROPE_CHARSET,
152 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
153 {'S','y','s','t','e','m','\0'}
154 },
155 { /* Device Default */
156 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, EASTEUROPE_CHARSET,
157 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
158 {'\0'}
159 },
160 { /* System Fixed */
161 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, EASTEUROPE_CHARSET,
162 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
163 {'\0'}
164 },
165 { /* DefaultGuiFont */
166 8, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, EASTEUROPE_CHARSET,
167 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
168 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
169 },
170 },
171 { RUSSIAN_CHARSET,
172 { /* System */
173 16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, RUSSIAN_CHARSET,
174 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
175 {'S','y','s','t','e','m','\0'}
176 },
177 { /* Device Default */
178 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, RUSSIAN_CHARSET,
179 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
180 {'\0'}
181 },
182 { /* System Fixed */
183 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, RUSSIAN_CHARSET,
184 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
185 {'\0'}
186 },
187 { /* DefaultGuiFont */
188 8, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, RUSSIAN_CHARSET,
189 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
190 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
191 },
192 },
193 { GREEK_CHARSET,
194 { /* System */
195 16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GREEK_CHARSET,
196 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
197 {'S','y','s','t','e','m','\0'}
198 },
199 { /* Device Default */
200 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GREEK_CHARSET,
201 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
202 {'\0'}
203 },
204 { /* System Fixed */
205 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GREEK_CHARSET,
206 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
207 {'\0'}
208 },
209 { /* DefaultGuiFont */
210 8, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GREEK_CHARSET,
211 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
212 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
213 },
214 },
215 { TURKISH_CHARSET,
216 { /* System */
217 16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, TURKISH_CHARSET,
218 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
219 {'S','y','s','t','e','m','\0'}
220 },
221 { /* Device Default */
222 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, TURKISH_CHARSET,
223 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
224 {'\0'}
225 },
226 { /* System Fixed */
227 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, TURKISH_CHARSET,
228 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
229 {'\0'}
230 },
231 { /* DefaultGuiFont */
232 8, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, TURKISH_CHARSET,
233 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
234 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
235 },
236 },
237 { HEBREW_CHARSET,
238 { /* System */
239 16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HEBREW_CHARSET,
240 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
241 {'S','y','s','t','e','m','\0'}
242 },
243 { /* Device Default */
244 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HEBREW_CHARSET,
245 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
246 {'\0'}
247 },
248 { /* System Fixed */
249 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HEBREW_CHARSET,
250 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
251 {'\0'}
252 },
253 { /* DefaultGuiFont */
254 8, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HEBREW_CHARSET,
255 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
256 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
257 },
258 },
259 { ARABIC_CHARSET,
260 { /* System */
261 16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ARABIC_CHARSET,
262 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
263 {'S','y','s','t','e','m','\0'}
264 },
265 { /* Device Default */
266 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ARABIC_CHARSET,
267 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
268 {'\0'}
269 },
270 { /* System Fixed */
271 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ARABIC_CHARSET,
272 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
273 {'\0'}
274 },
275 { /* DefaultGuiFont */
276 8, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ARABIC_CHARSET,
277 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
278 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
279 },
280 },
281 { BALTIC_CHARSET,
282 { /* System */
283 16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, BALTIC_CHARSET,
284 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
285 {'S','y','s','t','e','m','\0'}
286 },
287 { /* Device Default */
288 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, BALTIC_CHARSET,
289 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
290 {'\0'}
291 },
292 { /* System Fixed */
293 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, BALTIC_CHARSET,
294 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
295 {'\0'}
296 },
297 { /* DefaultGuiFont */
298 8, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, BALTIC_CHARSET,
299 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
300 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
301 },
302 },
303 { THAI_CHARSET,
304 { /* System */
305 16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, THAI_CHARSET,
306 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
307 {'S','y','s','t','e','m','\0'}
308 },
309 { /* Device Default */
310 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, THAI_CHARSET,
311 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
312 {'\0'}
313 },
314 { /* System Fixed */
315 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, THAI_CHARSET,
316 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
317 {'\0'}
318 },
319 { /* DefaultGuiFont */
320 8, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, THAI_CHARSET,
321 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
322 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
323 },
324 },
325 { SHIFTJIS_CHARSET,
326 { /* System */
327 16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, SHIFTJIS_CHARSET,
328 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
329 {'S','y','s','t','e','m','\0'}
330 },
331 { /* Device Default */
332 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, SHIFTJIS_CHARSET,
333 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
334 {'\0'}
335 },
336 { /* System Fixed */
337 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, SHIFTJIS_CHARSET,
338 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
339 {'\0'}
340 },
341 { /* DefaultGuiFont */
342 9, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, SHIFTJIS_CHARSET,
343 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
344 {'M','S',' ','U','I',' ','G','o','t','h','i','c','\0'}
345 },
346 },
347 { GB2312_CHARSET,
348 { /* System */
349 16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GB2312_CHARSET,
350 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
351 {'S','y','s','t','e','m','\0'}
352 },
353 { /* Device Default */
354 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GB2312_CHARSET,
355 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
356 {'\0'}
357 },
358 { /* System Fixed */
359 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GB2312_CHARSET,
360 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
361 {'\0'}
362 },
363 { /* DefaultGuiFont */
364 9, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GB2312_CHARSET,
365 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
366 {'S','i','m','S','u','n','\0'}
367 },
368 },
369 { HANGEUL_CHARSET,
370 { /* System */
371 16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HANGEUL_CHARSET,
372 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
373 {'S','y','s','t','e','m','\0'}
374 },
375 { /* Device Default */
376 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HANGEUL_CHARSET,
377 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
378 {'\0'}
379 },
380 { /* System Fixed */
381 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HANGEUL_CHARSET,
382 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
383 {'\0'}
384 },
385 { /* DefaultGuiFont */
386 9, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HANGEUL_CHARSET,
387 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
388 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
389 },
390 },
391 { CHINESEBIG5_CHARSET,
392 { /* System */
393 16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, CHINESEBIG5_CHARSET,
394 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
395 {'S','y','s','t','e','m','\0'}
396 },
397 { /* Device Default */
398 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, CHINESEBIG5_CHARSET,
399 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
400 {'\0'}
401 },
402 { /* System Fixed */
403 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, CHINESEBIG5_CHARSET,
404 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
405 {'\0'}
406 },
407 { /* DefaultGuiFont */
408 9, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, CHINESEBIG5_CHARSET,
409 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
410 {'P','M','i','n','g','L','i','U','\0'}
411 },
412 },
413 { JOHAB_CHARSET,
414 { /* System */
415 16, 7, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, JOHAB_CHARSET,
416 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
417 {'S','y','s','t','e','m','\0'}
418 },
419 { /* Device Default */
420 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, JOHAB_CHARSET,
421 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
422 {'\0'}
423 },
424 { /* System Fixed */
425 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, JOHAB_CHARSET,
426 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
427 {'\0'}
428 },
429 { /* DefaultGuiFont */
430 8, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, JOHAB_CHARSET,
431 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
432 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
433 },
434 },
435 };
436
437
438 /*************************************************************************
439 * __wine_make_gdi_object_system (GDI32.@)
440 *
441 * USER has to tell GDI that its system brushes and pens are non-deletable.
442 * For a description of the GDI object magics and their flags,
443 * see "Undocumented Windows" (wrong about the OBJECT_NOSYSTEM flag, though).
444 */
445 void __wine_make_gdi_object_system( HGDIOBJ handle, BOOL set)
446 {
447 GDIOBJHDR *ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE );
448
449 /* touch the "system" bit of the wMagic field of a GDIOBJHDR */
450 if (set)
451 ptr->wMagic &= ~OBJECT_NOSYSTEM;
452 else
453 ptr->wMagic |= OBJECT_NOSYSTEM;
454
455 GDI_ReleaseObj( handle );
456 }
457
458 /******************************************************************************
459 * get_default_fonts
460 */
461 static const struct DefaultFontInfo* get_default_fonts(UINT charset)
462 {
463 unsigned int n;
464
465 for(n=0;n<(sizeof(default_fonts)/sizeof(default_fonts[0]));n++)
466 {
467 if ( default_fonts[n].charset == charset )
468 return &default_fonts[n];
469 }
470
471 FIXME( "unhandled charset 0x%08x - use ANSI_CHARSET for default stock objects\n", charset );
472 return &default_fonts[0];
473 }
474
475
476 /******************************************************************************
477 * get_default_charset (internal)
478 *
479 * get the language-dependent charset that can handle CP_ACP correctly.
480 */
481 static UINT get_default_charset( void )
482 {
483 CHARSETINFO csi;
484 UINT uACP;
485
486 uACP = GetACP();
487 csi.ciCharset = ANSI_CHARSET;
488 if ( !TranslateCharsetInfo( ULongToPtr(uACP), &csi, TCI_SRCCODEPAGE ) )
489 {
490 FIXME( "unhandled codepage %u - use ANSI_CHARSET for default stock objects\n", uACP );
491 return ANSI_CHARSET;
492 }
493
494 return csi.ciCharset;
495 }
496
497 static const WCHAR dpi_key_name[] = {'S','o','f','t','w','a','r','e','\\','F','o','n','t','s','\0'};
498 static const WCHAR dpi_value_name[] = {'L','o','g','P','i','x','e','l','s','\0'};
499
500 /******************************************************************************
501 * get_dpi (internal)
502 *
503 * get the dpi from the registry
504 */
505 static DWORD get_dpi( void )
506 {
507 DWORD dpi = 96;
508 HKEY hkey;
509
510 if (RegOpenKeyW(HKEY_CURRENT_CONFIG, dpi_key_name, &hkey) == ERROR_SUCCESS)
511 {
512 DWORD type, size, new_dpi;
513
514 size = sizeof(new_dpi);
515 if(RegQueryValueExW(hkey, dpi_value_name, NULL, &type, (void *)&new_dpi, &size) == ERROR_SUCCESS)
516 {
517 if(type == REG_DWORD && new_dpi != 0)
518 dpi = new_dpi;
519 }
520 RegCloseKey(hkey);
521 }
522 return dpi;
523 }
524
525
526 /***********************************************************************
527 * GDI_inc_ref_count
528 *
529 * Increment the reference count of a GDI object.
530 */
531 BOOL GDI_inc_ref_count( HGDIOBJ handle )
532 {
533 GDIOBJHDR *header;
534
535 if ((header = GDI_GetObjPtr( handle, MAGIC_DONTCARE )))
536 {
537 header->dwCount++;
538 GDI_ReleaseObj( handle );
539 }
540 return header != NULL;
541 }
542
543
544 /***********************************************************************
545 * GDI_dec_ref_count
546 *
547 * Decrement the reference count of a GDI object.
548 */
549 BOOL GDI_dec_ref_count( HGDIOBJ handle )
550 {
551 GDIOBJHDR *header;
552
553 if ((header = GDI_GetObjPtr( handle, MAGIC_DONTCARE )))
554 {
555 if (header->dwCount) header->dwCount--;
556 if (header->dwCount != 0x80000000) GDI_ReleaseObj( handle );
557 else
558 {
559 /* handle delayed DeleteObject*/
560 header->dwCount = 0;
561 GDI_ReleaseObj( handle );
562 TRACE( "executing delayed DeleteObject for %p\n", handle );
563 DeleteObject( handle );
564 }
565 }
566 return header != NULL;
567 }
568
569
570 /***********************************************************************
571 * GDI_Init
572 *
573 * GDI initialization.
574 */
575 BOOL GDI_Init(void)
576 {
577 LOGFONTW default_gui_font;
578 const struct DefaultFontInfo* deffonts;
579 int i;
580
581 WineEngInit();
582
583 /* create stock objects */
584 stock_objects[WHITE_BRUSH] = CreateBrushIndirect( &WhiteBrush );
585 stock_objects[LTGRAY_BRUSH] = CreateBrushIndirect( &LtGrayBrush );
586 stock_objects[GRAY_BRUSH] = CreateBrushIndirect( &GrayBrush );
587 stock_objects[DKGRAY_BRUSH] = CreateBrushIndirect( &DkGrayBrush );
588 stock_objects[BLACK_BRUSH] = CreateBrushIndirect( &BlackBrush );
589 stock_objects[NULL_BRUSH] = CreateBrushIndirect( &NullBrush );
590
591 stock_objects[WHITE_PEN] = CreatePenIndirect( &WhitePen );
592 stock_objects[BLACK_PEN] = CreatePenIndirect( &BlackPen );
593 stock_objects[NULL_PEN] = CreatePenIndirect( &NullPen );
594
595 stock_objects[DEFAULT_PALETTE] = PALETTE_Init();
596 stock_objects[DEFAULT_BITMAP] = CreateBitmap( 1, 1, 1, 1, NULL );
597
598 /* language-independent stock fonts */
599 stock_objects[OEM_FIXED_FONT] = CreateFontIndirectW( &OEMFixedFont );
600 stock_objects[ANSI_FIXED_FONT] = CreateFontIndirectW( &AnsiFixedFont );
601 stock_objects[ANSI_VAR_FONT] = CreateFontIndirectW( &AnsiVarFont );
602
603 /* language-dependent stock fonts */
604 deffonts = get_default_fonts(get_default_charset());
605 stock_objects[SYSTEM_FONT] = CreateFontIndirectW( &deffonts->SystemFont );
606 stock_objects[DEVICE_DEFAULT_FONT] = CreateFontIndirectW( &deffonts->DeviceDefaultFont );
607 stock_objects[SYSTEM_FIXED_FONT] = CreateFontIndirectW( &deffonts->SystemFixedFont );
608
609 /* For the default gui font, we use the lfHeight member in deffonts as a place-holder
610 for the point size so we must convert this into a true height */
611 default_gui_font = deffonts->DefaultGuiFont;
612 default_gui_font.lfHeight = -MulDiv(default_gui_font.lfHeight, get_dpi(), 72);
613 stock_objects[DEFAULT_GUI_FONT] = CreateFontIndirectW( &default_gui_font );
614
615 stock_objects[DC_BRUSH] = CreateBrushIndirect( &DCBrush );
616 stock_objects[DC_PEN] = CreatePenIndirect( &DCPen );
617
618 /* clear the NOSYSTEM bit on all stock objects*/
619 for (i = 0; i < NB_STOCK_OBJECTS; i++)
620 {
621 if (!stock_objects[i])
622 {
623 if (i == 9) continue; /* there's no stock object 9 */
624 ERR( "could not create stock object %d\n", i );
625 return FALSE;
626 }
627 __wine_make_gdi_object_system( stock_objects[i], TRUE );
628 }
629
630 return TRUE;
631 }
632
633 #define FIRST_LARGE_HANDLE 16
634 #define MAX_LARGE_HANDLES ((GDI_HEAP_SIZE >> 2) - FIRST_LARGE_HANDLE)
635 static GDIOBJHDR *large_handles[MAX_LARGE_HANDLES];
636 static int next_large_handle;
637
638 /***********************************************************************
639 * alloc_large_heap
640 *
641 * Allocate a GDI handle from the large heap. Helper for GDI_AllocObject
642 */
643 static inline GDIOBJHDR *alloc_large_heap( WORD size, HGDIOBJ *handle )
644 {
645 int i;
646 GDIOBJHDR *obj;
647
648 for (i = next_large_handle + 1; i < MAX_LARGE_HANDLES; i++)
649 if (!large_handles[i]) goto found;
650 for (i = 0; i <= next_large_handle; i++)
651 if (!large_handles[i]) goto found;
652 *handle = 0;
653 return NULL;
654
655 found:
656 if ((obj = HeapAlloc( GetProcessHeap(), 0, size )))
657 {
658 large_handles[i] = obj;
659 *handle = (HGDIOBJ)(ULONG_PTR)((i + FIRST_LARGE_HANDLE) << 2);
660 next_large_handle = i;
661 }
662 return obj;
663 }
664
665
666 /***********************************************************************
667 * GDI_AllocObject
668 */
669 void *GDI_AllocObject( WORD size, WORD magic, HGDIOBJ *handle, const struct gdi_obj_funcs *funcs )
670 {
671 GDIOBJHDR *obj = NULL;
672
673 _EnterSysLevel( &GDI_level );
674 if (!(obj = alloc_large_heap( size, handle ))) goto error;
675
676 obj->wMagic = magic|OBJECT_NOSYSTEM;
677 obj->dwCount = 0;
678 obj->funcs = funcs;
679 obj->hdcs = NULL;
680
681 TRACE("(%p): enter %d\n", *handle, GDI_level.crst.RecursionCount);
682 return obj;
683
684 error:
685 _LeaveSysLevel( &GDI_level );
686 *handle = 0;
687 return NULL;
688 }
689
690
691 /***********************************************************************
692 * GDI_ReallocObject
693 *
694 * The object ptr must have been obtained with GDI_GetObjPtr.
695 * The new pointer must be released with GDI_ReleaseObj.
696 */
697 void *GDI_ReallocObject( WORD size, HGDIOBJ handle, void *object )
698 {
699 void *new_ptr = NULL;
700 int i;
701
702 i = ((ULONG_PTR)handle >> 2) - FIRST_LARGE_HANDLE;
703 if (i >= 0 && i < MAX_LARGE_HANDLES && large_handles[i])
704 {
705 new_ptr = HeapReAlloc( GetProcessHeap(), 0, large_handles[i], size );
706 if (new_ptr) large_handles[i] = new_ptr;
707 }
708 else ERR( "Invalid handle %p\n", handle );
709 if (!new_ptr)
710 {
711 TRACE("(%p): leave %d\n", handle, GDI_level.crst.RecursionCount);
712 _LeaveSysLevel( &GDI_level );
713 }
714 return new_ptr;
715 }
716
717
718 /***********************************************************************
719 * GDI_FreeObject
720 */
721 BOOL GDI_FreeObject( HGDIOBJ handle, void *ptr )
722 {
723 GDIOBJHDR *object = ptr;
724 int i;
725
726 object->wMagic = 0; /* Mark it as invalid */
727 object->funcs = NULL;
728 i = ((ULONG_PTR)handle >> 2) - FIRST_LARGE_HANDLE;
729 if (i >= 0 && i < MAX_LARGE_HANDLES)
730 {
731 HeapFree( GetProcessHeap(), 0, large_handles[i] );
732 large_handles[i] = NULL;
733 }
734 else ERR( "Invalid handle %p\n", handle );
735 TRACE("(%p): leave %d\n", handle, GDI_level.crst.RecursionCount);
736 _LeaveSysLevel( &GDI_level );
737 return TRUE;
738 }
739
740
741 /***********************************************************************
742 * GDI_GetObjPtr
743 *
744 * Return a pointer to the GDI object associated to the handle.
745 * Return NULL if the object has the wrong magic number.
746 * The object must be released with GDI_ReleaseObj.
747 */
748 void *GDI_GetObjPtr( HGDIOBJ handle, WORD magic )
749 {
750 GDIOBJHDR *ptr = NULL;
751 int i;
752
753 _EnterSysLevel( &GDI_level );
754
755 i = ((UINT_PTR)handle >> 2) - FIRST_LARGE_HANDLE;
756 if (i >= 0 && i < MAX_LARGE_HANDLES)
757 {
758 ptr = large_handles[i];
759 if (ptr && (magic != MAGIC_DONTCARE) && (GDIMAGIC(ptr->wMagic) != magic)) ptr = NULL;
760 }
761
762 if (!ptr)
763 {
764 _LeaveSysLevel( &GDI_level );
765 WARN( "Invalid handle %p\n", handle );
766 }
767 else TRACE("(%p): enter %d\n", handle, GDI_level.crst.RecursionCount);
768
769 return ptr;
770 }
771
772
773 /***********************************************************************
774 * GDI_ReleaseObj
775 *
776 */
777 void GDI_ReleaseObj( HGDIOBJ handle )
778 {
779 TRACE("(%p): leave %d\n", handle, GDI_level.crst.RecursionCount);
780 _LeaveSysLevel( &GDI_level );
781 }
782
783
784 /***********************************************************************
785 * GDI_CheckNotLock
786 */
787 void GDI_CheckNotLock(void)
788 {
789 _CheckNotSysLevel( &GDI_level );
790 }
791
792
793 /***********************************************************************
794 * DeleteObject (GDI32.@)
795 *
796 * Delete a Gdi object.
797 *
798 * PARAMS
799 * obj [I] Gdi object to delete
800 *
801 * RETURNS
802 * Success: TRUE. If obj was not returned from GetStockObject(), any resources
803 * it consumed are released.
804 * Failure: FALSE, if obj is not a valid Gdi object, or is currently selected
805 * into a DC.
806 */
807 BOOL WINAPI DeleteObject( HGDIOBJ obj )
808 {
809 /* Check if object is valid */
810
811 GDIOBJHDR * header;
812 if (HIWORD(obj)) return FALSE;
813
814 if (!(header = GDI_GetObjPtr( obj, MAGIC_DONTCARE ))) return FALSE;
815
816 if (!(header->wMagic & OBJECT_NOSYSTEM)
817 && (header->wMagic >= FIRST_MAGIC) && (header->wMagic <= LAST_MAGIC))
818 {
819 TRACE("Preserving system object %p\n", obj);
820 GDI_ReleaseObj( obj );
821 return TRUE;
822 }
823
824 while (header->hdcs)
825 {
826 DC *dc = get_dc_ptr(header->hdcs->hdc);
827 struct hdc_list *tmp;
828
829 TRACE("hdc %p has interest in %p\n", header->hdcs->hdc, obj);
830 if(dc)
831 {
832 if(dc->funcs->pDeleteObject)
833 dc->funcs->pDeleteObject( dc->physDev, obj );
834 release_dc_ptr( dc );
835 }
836 tmp = header->hdcs;
837 header->hdcs = header->hdcs->next;
838 HeapFree(GetProcessHeap(), 0, tmp);
839 }
840
841 if (header->dwCount)
842 {
843 TRACE("delayed for %p because object in use, count %d\n", obj, header->dwCount );
844 header->dwCount |= 0x80000000; /* mark for delete */
845 GDI_ReleaseObj( obj );
846 return TRUE;
847 }
848
849 TRACE("%p\n", obj );
850
851 /* Delete object */
852
853 if (header->funcs && header->funcs->pDeleteObject)
854 return header->funcs->pDeleteObject( obj, header );
855
856 GDI_ReleaseObj( obj );
857 return FALSE;
858 }
859
860 /***********************************************************************
861