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 }
1301
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.