gdi32: Take DPI awareness into account for the LOGPIXELSX/Y device caps.
[wine.git] / dlls / gdi32 / gdiobj.c
blobdb03f49b00a5386752c358fd24ac4205d3ebb44f
1 /*
2 * GDI functions
4 * Copyright 1993 Alexandre Julliard
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.
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.
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
21 #include "config.h"
23 #include <assert.h>
24 #include <stdlib.h>
25 #include <stdarg.h>
26 #include <stdio.h>
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"
36 #include "gdi_private.h"
37 #include "wine/debug.h"
39 WINE_DEFAULT_DEBUG_CHANNEL(gdi);
41 #define FIRST_GDI_HANDLE 32
42 #define MAX_GDI_HANDLES 16384
44 struct hdc_list
46 HDC hdc;
47 struct hdc_list *next;
50 struct gdi_handle_entry
52 void *obj; /* pointer to the object-specific data */
53 const struct gdi_obj_funcs *funcs; /* type-specific functions */
54 struct hdc_list *hdcs; /* list of HDCs interested in this object */
55 WORD generation; /* generation count for reusing handle values */
56 WORD type; /* object type (one of the OBJ_* constants) */
57 WORD selcount; /* number of times the object is selected in a DC */
58 WORD system : 1; /* system object flag */
59 WORD deleted : 1; /* whether DeleteObject has been called on this object */
62 static struct gdi_handle_entry gdi_handles[MAX_GDI_HANDLES];
63 static struct gdi_handle_entry *next_free;
64 static struct gdi_handle_entry *next_unused = gdi_handles;
65 static LONG debug_count;
66 HMODULE gdi32_module = 0;
68 static inline HGDIOBJ entry_to_handle( struct gdi_handle_entry *entry )
70 unsigned int idx = entry - gdi_handles + FIRST_GDI_HANDLE;
71 return LongToHandle( idx | (entry->generation << 16) );
74 static inline struct gdi_handle_entry *handle_entry( HGDIOBJ handle )
76 unsigned int idx = LOWORD(handle) - FIRST_GDI_HANDLE;
78 if (idx < MAX_GDI_HANDLES && gdi_handles[idx].type)
80 if (!HIWORD( handle ) || HIWORD( handle ) == gdi_handles[idx].generation)
81 return &gdi_handles[idx];
83 if (handle) WARN( "invalid handle %p\n", handle );
84 return NULL;
87 /***********************************************************************
88 * GDI stock objects
91 static const LOGBRUSH WhiteBrush = { BS_SOLID, RGB(255,255,255), 0 };
92 static const LOGBRUSH BlackBrush = { BS_SOLID, RGB(0,0,0), 0 };
93 static const LOGBRUSH NullBrush = { BS_NULL, 0, 0 };
95 static const LOGBRUSH LtGrayBrush = { BS_SOLID, RGB(192,192,192), 0 };
96 static const LOGBRUSH GrayBrush = { BS_SOLID, RGB(128,128,128), 0 };
97 static const LOGBRUSH DkGrayBrush = { BS_SOLID, RGB(64,64,64), 0 };
99 static const LOGPEN WhitePen = { PS_SOLID, { 0, 0 }, RGB(255,255,255) };
100 static const LOGPEN BlackPen = { PS_SOLID, { 0, 0 }, RGB(0,0,0) };
101 static const LOGPEN NullPen = { PS_NULL, { 0, 0 }, 0 };
103 static const LOGBRUSH DCBrush = { BS_SOLID, RGB(255,255,255), 0 };
104 static const LOGPEN DCPen = { PS_SOLID, { 0, 0 }, RGB(0,0,0) };
106 /* reserve one extra entry for the stock default bitmap */
107 /* this is what Windows does too */
108 #define NB_STOCK_OBJECTS (STOCK_LAST+2)
110 static HGDIOBJ stock_objects[NB_STOCK_OBJECTS];
112 static CRITICAL_SECTION gdi_section;
113 static CRITICAL_SECTION_DEBUG critsect_debug =
115 0, 0, &gdi_section,
116 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
117 0, 0, { (DWORD_PTR)(__FILE__ ": gdi_section") }
119 static CRITICAL_SECTION gdi_section = { &critsect_debug, -1, 0, 0, 0, 0 };
122 /****************************************************************************
124 * language-independent stock fonts
128 static const LOGFONTW OEMFixedFont =
129 { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, OEM_CHARSET,
130 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, {'\0'} };
132 static const LOGFONTW AnsiFixedFont =
133 { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
134 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
135 {'C','o','u','r','i','e','r','\0'} };
137 static const LOGFONTW AnsiVarFont =
138 { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
139 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
140 {'M','S',' ','S','a','n','s',' ','S','e','r','i','f','\0'} };
142 /******************************************************************************
144 * language-dependent stock fonts
146 * 'ANSI' charset and 'DEFAULT' charset is not same.
147 * The chars in CP_ACP should be drawn with 'DEFAULT' charset.
148 * 'ANSI' charset seems to be identical with ISO-8859-1.
149 * 'DEFAULT' charset is a language-dependent charset.
151 * 'System' font seems to be an alias for language-dependent font.
155 * language-dependent stock fonts for all known charsets
156 * please see TranslateCharsetInfo (dlls/gdi/font.c) and
157 * CharsetBindingInfo (dlls/x11drv/xfont.c),
158 * and modify entries for your language if needed.
160 struct DefaultFontInfo
162 UINT charset;
163 LOGFONTW SystemFont;
164 LOGFONTW DeviceDefaultFont;
165 LOGFONTW SystemFixedFont;
166 LOGFONTW DefaultGuiFont;
169 static const struct DefaultFontInfo default_fonts[] =
171 { ANSI_CHARSET,
172 { /* System */
173 16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ANSI_CHARSET,
174 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
175 {'S','y','s','t','e','m','\0'}
177 { /* Device Default */
178 16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ANSI_CHARSET,
179 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
180 {'S','y','s','t','e','m','\0'}
182 { /* System Fixed */
183 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
184 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
185 {'C','o','u','r','i','e','r','\0'}
187 { /* DefaultGuiFont */
188 -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
189 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
190 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
193 { EASTEUROPE_CHARSET,
194 { /* System */
195 16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, EASTEUROPE_CHARSET,
196 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
197 {'S','y','s','t','e','m','\0'}
199 { /* Device Default */
200 16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, EASTEUROPE_CHARSET,
201 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
202 {'S','y','s','t','e','m','\0'}
204 { /* System Fixed */
205 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, EASTEUROPE_CHARSET,
206 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
207 {'C','o','u','r','i','e','r','\0'}
209 { /* DefaultGuiFont */
210 -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, EASTEUROPE_CHARSET,
211 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
212 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
215 { RUSSIAN_CHARSET,
216 { /* System */
217 16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, RUSSIAN_CHARSET,
218 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
219 {'S','y','s','t','e','m','\0'}
221 { /* Device Default */
222 16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, RUSSIAN_CHARSET,
223 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
224 {'S','y','s','t','e','m','\0'}
226 { /* System Fixed */
227 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, RUSSIAN_CHARSET,
228 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
229 {'C','o','u','r','i','e','r','\0'}
231 { /* DefaultGuiFont */
232 -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, RUSSIAN_CHARSET,
233 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
234 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
237 { GREEK_CHARSET,
238 { /* System */
239 16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, GREEK_CHARSET,
240 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
241 {'S','y','s','t','e','m','\0'}
243 { /* Device Default */
244 16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, GREEK_CHARSET,
245 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
246 {'S','y','s','t','e','m','\0'}
248 { /* System Fixed */
249 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GREEK_CHARSET,
250 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
251 {'C','o','u','r','i','e','r','\0'}
253 { /* DefaultGuiFont */
254 -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GREEK_CHARSET,
255 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
256 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
259 { TURKISH_CHARSET,
260 { /* System */
261 16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, TURKISH_CHARSET,
262 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
263 {'S','y','s','t','e','m','\0'}
265 { /* Device Default */
266 16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, TURKISH_CHARSET,
267 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
268 {'S','y','s','t','e','m','\0'}
270 { /* System Fixed */
271 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, TURKISH_CHARSET,
272 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
273 {'C','o','u','r','i','e','r','\0'}
275 { /* DefaultGuiFont */
276 -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, TURKISH_CHARSET,
277 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
278 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
281 { HEBREW_CHARSET,
282 { /* System */
283 16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, HEBREW_CHARSET,
284 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
285 {'S','y','s','t','e','m','\0'}
287 { /* Device Default */
288 16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, HEBREW_CHARSET,
289 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
290 {'S','y','s','t','e','m','\0'}
292 { /* System Fixed */
293 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HEBREW_CHARSET,
294 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
295 {'C','o','u','r','i','e','r','\0'}
297 { /* DefaultGuiFont */
298 -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HEBREW_CHARSET,
299 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
300 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
303 { ARABIC_CHARSET,
304 { /* System */
305 16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ARABIC_CHARSET,
306 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
307 {'S','y','s','t','e','m','\0'}
309 { /* Device Default */
310 16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ARABIC_CHARSET,
311 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
312 {'S','y','s','t','e','m','\0'}
314 { /* System Fixed */
315 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ARABIC_CHARSET,
316 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
317 {'C','o','u','r','i','e','r','\0'}
319 { /* DefaultGuiFont */
320 -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ARABIC_CHARSET,
321 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
322 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
325 { BALTIC_CHARSET,
326 { /* System */
327 16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, BALTIC_CHARSET,
328 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
329 {'S','y','s','t','e','m','\0'}
331 { /* Device Default */
332 16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, BALTIC_CHARSET,
333 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
334 {'S','y','s','t','e','m','\0'}
336 { /* System Fixed */
337 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, BALTIC_CHARSET,
338 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
339 {'C','o','u','r','i','e','r','\0'}
341 { /* DefaultGuiFont */
342 -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, BALTIC_CHARSET,
343 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
344 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
347 { THAI_CHARSET,
348 { /* System */
349 16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, THAI_CHARSET,
350 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
351 {'S','y','s','t','e','m','\0'}
353 { /* Device Default */
354 16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, THAI_CHARSET,
355 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
356 {'S','y','s','t','e','m','\0'}
358 { /* System Fixed */
359 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, THAI_CHARSET,
360 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
361 {'C','o','u','r','i','e','r','\0'}
363 { /* DefaultGuiFont */
364 -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, THAI_CHARSET,
365 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
366 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
369 { SHIFTJIS_CHARSET,
370 { /* System */
371 18, 8, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, SHIFTJIS_CHARSET,
372 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
373 {'S','y','s','t','e','m','\0'}
375 { /* Device Default */
376 18, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, SHIFTJIS_CHARSET,
377 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
378 {'S','y','s','t','e','m','\0'}
380 { /* System Fixed */
381 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, SHIFTJIS_CHARSET,
382 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
383 {'C','o','u','r','i','e','r','\0'}
385 { /* DefaultGuiFont */
386 -12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, SHIFTJIS_CHARSET,
387 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
388 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
391 { GB2312_CHARSET,
392 { /* System */
393 16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, GB2312_CHARSET,
394 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
395 {'S','y','s','t','e','m','\0'}
397 { /* Device Default */
398 16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, GB2312_CHARSET,
399 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
400 {'S','y','s','t','e','m','\0'}
402 { /* System Fixed */
403 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GB2312_CHARSET,
404 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
405 {'C','o','u','r','i','e','r','\0'}
407 { /* DefaultGuiFont */
408 -12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, GB2312_CHARSET,
409 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
410 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
413 { HANGEUL_CHARSET,
414 { /* System */
415 16, 8, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HANGEUL_CHARSET,
416 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
417 {'S','y','s','t','e','m','\0'}
419 { /* Device Default */
420 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HANGEUL_CHARSET,
421 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
422 {'S','y','s','t','e','m','\0'}
424 { /* System Fixed */
425 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HANGEUL_CHARSET,
426 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
427 {'C','o','u','r','i','e','r','\0'}
429 { /* DefaultGuiFont */
430 -12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, HANGEUL_CHARSET,
431 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
432 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
435 { CHINESEBIG5_CHARSET,
436 { /* System */
437 16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, CHINESEBIG5_CHARSET,
438 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
439 {'S','y','s','t','e','m','\0'}
441 { /* Device Default */
442 16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, CHINESEBIG5_CHARSET,
443 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
444 {'S','y','s','t','e','m','\0'}
446 { /* System Fixed */
447 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, CHINESEBIG5_CHARSET,
448 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
449 {'C','o','u','r','i','e','r','\0'}
451 { /* DefaultGuiFont */
452 -12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, CHINESEBIG5_CHARSET,
453 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
454 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
457 { JOHAB_CHARSET,
458 { /* System */
459 16, 7, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, JOHAB_CHARSET,
460 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
461 {'S','y','s','t','e','m','\0'}
463 { /* Device Default */
464 16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, JOHAB_CHARSET,
465 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
466 {'S','y','s','t','e','m','\0'}
468 { /* System Fixed */
469 16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, JOHAB_CHARSET,
470 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN,
471 {'C','o','u','r','i','e','r','\0'}
473 { /* DefaultGuiFont */
474 -12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, JOHAB_CHARSET,
475 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
476 {'M','S',' ','S','h','e','l','l',' ','D','l','g','\0'}
482 /*************************************************************************
483 * __wine_make_gdi_object_system (GDI32.@)
485 * USER has to tell GDI that its system brushes and pens are non-deletable.
486 * For a description of the GDI object magics and their flags,
487 * see "Undocumented Windows" (wrong about the OBJECT_NOSYSTEM flag, though).
489 void CDECL __wine_make_gdi_object_system( HGDIOBJ handle, BOOL set)
491 struct gdi_handle_entry *entry;
493 EnterCriticalSection( &gdi_section );
494 if ((entry = handle_entry( handle ))) entry->system = !!set;
495 LeaveCriticalSection( &gdi_section );
498 /******************************************************************************
499 * get_default_fonts
501 static const struct DefaultFontInfo* get_default_fonts(UINT charset)
503 unsigned int n;
505 for(n=0;n<(sizeof(default_fonts)/sizeof(default_fonts[0]));n++)
507 if ( default_fonts[n].charset == charset )
508 return &default_fonts[n];
511 FIXME( "unhandled charset 0x%08x - use ANSI_CHARSET for default stock objects\n", charset );
512 return &default_fonts[0];
516 /******************************************************************************
517 * get_default_charset (internal)
519 * get the language-dependent charset that can handle CP_ACP correctly.
521 static UINT get_default_charset( void )
523 CHARSETINFO csi;
524 UINT uACP;
526 uACP = GetACP();
527 csi.ciCharset = ANSI_CHARSET;
528 if ( !TranslateCharsetInfo( ULongToPtr(uACP), &csi, TCI_SRCCODEPAGE ) )
530 FIXME( "unhandled codepage %u - use ANSI_CHARSET for default stock objects\n", uACP );
531 return ANSI_CHARSET;
534 return csi.ciCharset;
538 /***********************************************************************
539 * GDI_get_ref_count
541 * Retrieve the reference count of a GDI object.
542 * Note: the object must be locked otherwise the count is meaningless.
544 UINT GDI_get_ref_count( HGDIOBJ handle )
546 struct gdi_handle_entry *entry;
547 UINT ret = 0;
549 EnterCriticalSection( &gdi_section );
550 if ((entry = handle_entry( handle ))) ret = entry->selcount;
551 LeaveCriticalSection( &gdi_section );
552 return ret;
556 /***********************************************************************
557 * GDI_inc_ref_count
559 * Increment the reference count of a GDI object.
561 HGDIOBJ GDI_inc_ref_count( HGDIOBJ handle )
563 struct gdi_handle_entry *entry;
565 EnterCriticalSection( &gdi_section );
566 if ((entry = handle_entry( handle ))) entry->selcount++;
567 else handle = 0;
568 LeaveCriticalSection( &gdi_section );
569 return handle;
573 /***********************************************************************
574 * GDI_dec_ref_count
576 * Decrement the reference count of a GDI object.
578 BOOL GDI_dec_ref_count( HGDIOBJ handle )
580 struct gdi_handle_entry *entry;
582 EnterCriticalSection( &gdi_section );
583 if ((entry = handle_entry( handle )))
585 assert( entry->selcount );
586 if (!--entry->selcount && entry->deleted)
588 /* handle delayed DeleteObject*/
589 entry->deleted = 0;
590 LeaveCriticalSection( &gdi_section );
591 TRACE( "executing delayed DeleteObject for %p\n", handle );
592 DeleteObject( handle );
593 return TRUE;
596 LeaveCriticalSection( &gdi_section );
597 return entry != NULL;
600 static const WCHAR dpi_key_name[] = {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p','\0'};
601 static const WCHAR def_dpi_key_name[] = {'S','o','f','t','w','a','r','e','\\','F','o','n','t','s','\0'};
602 static const WCHAR dpi_value_name[] = {'L','o','g','P','i','x','e','l','s','\0'};
604 /******************************************************************************
605 * get_reg_dword
607 * Read a DWORD value from the registry
609 static BOOL get_reg_dword(HKEY base, const WCHAR *key_name, const WCHAR *value_name, DWORD *value)
611 HKEY key;
612 DWORD type, data, size = sizeof(data);
613 BOOL ret = FALSE;
615 if (RegOpenKeyW(base, key_name, &key) == ERROR_SUCCESS)
617 if (RegQueryValueExW(key, value_name, NULL, &type, (void *)&data, &size) == ERROR_SUCCESS &&
618 type == REG_DWORD)
620 *value = data;
621 ret = TRUE;
623 RegCloseKey(key);
625 return ret;
628 /******************************************************************************
629 * get_dpi
631 * get the dpi from the registry
633 DWORD get_dpi(void)
635 DWORD dpi;
637 if (get_reg_dword(HKEY_CURRENT_USER, dpi_key_name, dpi_value_name, &dpi))
638 return dpi;
639 if (get_reg_dword(HKEY_CURRENT_CONFIG, def_dpi_key_name, dpi_value_name, &dpi))
640 return dpi;
641 return 0;
644 /******************************************************************************
645 * get_system_dpi
647 * Get the system DPI, based on the DPI awareness mode.
649 DWORD get_system_dpi(void)
651 static UINT (WINAPI *pGetDpiForSystem)(void);
653 if (!pGetDpiForSystem)
655 static const WCHAR user32W[] = {'u','s','e','r','3','2','.','d','l','l',0};
656 HMODULE user = GetModuleHandleW( user32W );
657 if (user) pGetDpiForSystem = (void *)GetProcAddress( user, "GetDpiForSystem" );
659 return pGetDpiForSystem ? pGetDpiForSystem() : 96;
662 static HFONT create_scaled_font( const LOGFONTW *deffont )
664 LOGFONTW lf;
665 LONG height;
666 static DWORD dpi;
668 if (!dpi)
670 dpi = get_dpi();
671 if (!dpi) dpi = 96;
674 lf = *deffont;
675 height = abs(lf.lfHeight) * dpi / 96;
676 lf.lfHeight = deffont->lfHeight < 0 ? -height : height;
678 return CreateFontIndirectW( &lf );
681 /***********************************************************************
682 * DllMain
684 * GDI initialization.
686 BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, LPVOID reserved )
688 const struct DefaultFontInfo* deffonts;
689 int i;
691 if (reason != DLL_PROCESS_ATTACH) return TRUE;
693 gdi32_module = inst;
694 DisableThreadLibraryCalls( inst );
695 WineEngInit();
697 /* create stock objects */
698 stock_objects[WHITE_BRUSH] = CreateBrushIndirect( &WhiteBrush );
699 stock_objects[LTGRAY_BRUSH] = CreateBrushIndirect( &LtGrayBrush );
700 stock_objects[GRAY_BRUSH] = CreateBrushIndirect( &GrayBrush );
701 stock_objects[DKGRAY_BRUSH] = CreateBrushIndirect( &DkGrayBrush );
702 stock_objects[BLACK_BRUSH] = CreateBrushIndirect( &BlackBrush );
703 stock_objects[NULL_BRUSH] = CreateBrushIndirect( &NullBrush );
705 stock_objects[WHITE_PEN] = CreatePenIndirect( &WhitePen );
706 stock_objects[BLACK_PEN] = CreatePenIndirect( &BlackPen );
707 stock_objects[NULL_PEN] = CreatePenIndirect( &NullPen );
709 stock_objects[DEFAULT_PALETTE] = PALETTE_Init();
710 stock_objects[DEFAULT_BITMAP] = CreateBitmap( 1, 1, 1, 1, NULL );
712 /* language-independent stock fonts */
713 stock_objects[OEM_FIXED_FONT] = CreateFontIndirectW( &OEMFixedFont );
714 stock_objects[ANSI_FIXED_FONT] = CreateFontIndirectW( &AnsiFixedFont );
715 stock_objects[ANSI_VAR_FONT] = CreateFontIndirectW( &AnsiVarFont );
717 /* language-dependent stock fonts */
718 deffonts = get_default_fonts(get_default_charset());
719 stock_objects[SYSTEM_FONT] = create_scaled_font( &deffonts->SystemFont );
720 stock_objects[DEVICE_DEFAULT_FONT] = create_scaled_font( &deffonts->DeviceDefaultFont );
721 stock_objects[SYSTEM_FIXED_FONT] = CreateFontIndirectW( &deffonts->SystemFixedFont );
722 stock_objects[DEFAULT_GUI_FONT] = create_scaled_font( &deffonts->DefaultGuiFont );
724 stock_objects[DC_BRUSH] = CreateBrushIndirect( &DCBrush );
725 stock_objects[DC_PEN] = CreatePenIndirect( &DCPen );
727 /* clear the NOSYSTEM bit on all stock objects*/
728 for (i = 0; i < NB_STOCK_OBJECTS; i++)
730 if (!stock_objects[i])
732 if (i == 9) continue; /* there's no stock object 9 */
733 ERR( "could not create stock object %d\n", i );
734 return FALSE;
736 __wine_make_gdi_object_system( stock_objects[i], TRUE );
739 return TRUE;
742 static const char *gdi_obj_type( unsigned type )
744 switch ( type )
746 case OBJ_PEN: return "OBJ_PEN";
747 case OBJ_BRUSH: return "OBJ_BRUSH";
748 case OBJ_DC: return "OBJ_DC";
749 case OBJ_METADC: return "OBJ_METADC";
750 case OBJ_PAL: return "OBJ_PAL";
751 case OBJ_FONT: return "OBJ_FONT";
752 case OBJ_BITMAP: return "OBJ_BITMAP";
753 case OBJ_REGION: return "OBJ_REGION";
754 case OBJ_METAFILE: return "OBJ_METAFILE";
755 case OBJ_MEMDC: return "OBJ_MEMDC";
756 case OBJ_EXTPEN: return "OBJ_EXTPEN";
757 case OBJ_ENHMETADC: return "OBJ_ENHMETADC";
758 case OBJ_ENHMETAFILE: return "OBJ_ENHMETAFILE";
759 case OBJ_COLORSPACE: return "OBJ_COLORSPACE";
760 default: return "UNKNOWN";
764 static void dump_gdi_objects( void )
766 struct gdi_handle_entry *entry;
768 TRACE( "%u objects:\n", MAX_GDI_HANDLES );
770 EnterCriticalSection( &gdi_section );
771 for (entry = gdi_handles; entry < next_unused; entry++)
773 if (!entry->type)
774 TRACE( "handle %p FREE\n", entry_to_handle( entry ));
775 else
776 TRACE( "handle %p obj %p type %s selcount %u deleted %u\n",
777 entry_to_handle( entry ), entry->obj, gdi_obj_type( entry->type ),
778 entry->selcount, entry->deleted );
780 LeaveCriticalSection( &gdi_section );
783 /***********************************************************************
784 * alloc_gdi_handle
786 * Allocate a GDI handle for an object, which must have been allocated on the process heap.
788 HGDIOBJ alloc_gdi_handle( void *obj, WORD type, const struct gdi_obj_funcs *funcs )
790 struct gdi_handle_entry *entry;
791 HGDIOBJ ret;
793 assert( type ); /* type 0 is reserved to mark free entries */
795 EnterCriticalSection( &gdi_section );
797 entry = next_free;
798 if (entry)
799 next_free = entry->obj;
800 else if (next_unused < gdi_handles + MAX_GDI_HANDLES)
801 entry = next_unused++;
802 else
804 LeaveCriticalSection( &gdi_section );
805 ERR( "out of GDI object handles, expect a crash\n" );
806 if (TRACE_ON(gdi)) dump_gdi_objects();
807 return 0;
809 entry->obj = obj;
810 entry->funcs = funcs;
811 entry->hdcs = NULL;
812 entry->type = type;
813 entry->selcount = 0;
814 entry->system = 0;
815 entry->deleted = 0;
816 if (++entry->generation == 0xffff) entry->generation = 1;
817 ret = entry_to_handle( entry );
818 LeaveCriticalSection( &gdi_section );
819 TRACE( "allocated %s %p %u/%u\n", gdi_obj_type(type), ret,
820 InterlockedIncrement( &debug_count ), MAX_GDI_HANDLES );
821 return ret;
825 /***********************************************************************
826 * free_gdi_handle
828 * Free a GDI handle and return a pointer to the object.
830 void *free_gdi_handle( HGDIOBJ handle )
832 void *object = NULL;
833 struct gdi_handle_entry *entry;
835 EnterCriticalSection( &gdi_section );
836 if ((entry = handle_entry( handle )))
838 TRACE( "freed %s %p %u/%u\n", gdi_obj_type( entry->type ), handle,
839 InterlockedDecrement( &debug_count ) + 1, MAX_GDI_HANDLES );
840 object = entry->obj;
841 entry->type = 0;
842 entry->obj = next_free;
843 next_free = entry;
845 LeaveCriticalSection( &gdi_section );
846 return object;
850 /***********************************************************************
851 * get_full_gdi_handle
853 * Return the full GDI handle from a possibly truncated value.
855 HGDIOBJ get_full_gdi_handle( HGDIOBJ handle )
857 struct gdi_handle_entry *entry;
859 if (!HIWORD( handle ))
861 EnterCriticalSection( &gdi_section );
862 if ((entry = handle_entry( handle ))) handle = entry_to_handle( entry );
863 LeaveCriticalSection( &gdi_section );
865 return handle;
868 /***********************************************************************
869 * get_any_obj_ptr
871 * Return a pointer to, and the type of, the GDI object
872 * associated with the handle.
873 * The object must be released with GDI_ReleaseObj.
875 void *get_any_obj_ptr( HGDIOBJ handle, WORD *type )
877 void *ptr = NULL;
878 struct gdi_handle_entry *entry;
880 EnterCriticalSection( &gdi_section );
882 if ((entry = handle_entry( handle )))
884 ptr = entry->obj;
885 *type = entry->type;
888 if (!ptr) LeaveCriticalSection( &gdi_section );
889 return ptr;
892 /***********************************************************************
893 * GDI_GetObjPtr
895 * Return a pointer to the GDI object associated with the handle.
896 * Return NULL if the object has the wrong type.
897 * The object must be released with GDI_ReleaseObj.
899 void *GDI_GetObjPtr( HGDIOBJ handle, WORD type )
901 WORD ret_type;
902 void *ptr = get_any_obj_ptr( handle, &ret_type );
903 if (ptr && ret_type != type)
905 GDI_ReleaseObj( handle );
906 ptr = NULL;
908 return ptr;
911 /***********************************************************************
912 * GDI_ReleaseObj
915 void GDI_ReleaseObj( HGDIOBJ handle )
917 LeaveCriticalSection( &gdi_section );
921 /***********************************************************************
922 * GDI_CheckNotLock
924 void GDI_CheckNotLock(void)
926 if (RtlIsCriticalSectionLockedByThread(&gdi_section))
928 ERR( "BUG: holding GDI lock\n" );
929 DebugBreak();
934 /***********************************************************************
935 * DeleteObject (GDI32.@)
937 * Delete a Gdi object.
939 * PARAMS
940 * obj [I] Gdi object to delete
942 * RETURNS
943 * Success: TRUE. If obj was not returned from GetStockObject(), any resources
944 * it consumed are released.
945 * Failure: FALSE, if obj is not a valid Gdi object, or is currently selected
946 * into a DC.
948 BOOL WINAPI DeleteObject( HGDIOBJ obj )
950 struct gdi_handle_entry *entry;
951 struct hdc_list *hdcs_head;
952 const struct gdi_obj_funcs *funcs = NULL;
954 EnterCriticalSection( &gdi_section );
955 if (!(entry = handle_entry( obj )))
957 LeaveCriticalSection( &gdi_section );
958 return FALSE;
961 if (entry->system)
963 TRACE("Preserving system object %p\n", obj);
964 LeaveCriticalSection( &gdi_section );
965 return TRUE;
968 obj = entry_to_handle( entry ); /* make it a full handle */
970 hdcs_head = entry->hdcs;
971 entry->hdcs = NULL;
973 if (entry->selcount)
975 TRACE("delayed for %p because object in use, count %u\n", obj, entry->selcount );
976 entry->deleted = 1; /* mark for delete */
978 else funcs = entry->funcs;
980 LeaveCriticalSection( &gdi_section );
982 while (hdcs_head)
984 struct hdc_list *next = hdcs_head->next;
985 DC *dc = get_dc_ptr(hdcs_head->hdc);
987 TRACE("hdc %p has interest in %p\n", hdcs_head->hdc, obj);
988 if(dc)
990 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pDeleteObject );
991 physdev->funcs->pDeleteObject( physdev, obj );
992 release_dc_ptr( dc );
994 HeapFree(GetProcessHeap(), 0, hdcs_head);
995 hdcs_head = next;
998 TRACE("%p\n", obj );
1000 if (funcs && funcs->pDeleteObject) return funcs->pDeleteObject( obj );
1001 return TRUE;
1004 /***********************************************************************
1005 * GDI_hdc_using_object
1007 * Call this if the dc requires DeleteObject notification
1009 void GDI_hdc_using_object(HGDIOBJ obj, HDC hdc)
1011 struct gdi_handle_entry *entry;
1012 struct hdc_list *phdc;
1014 TRACE("obj %p hdc %p\n", obj, hdc);
1016 EnterCriticalSection( &gdi_section );
1017 if ((entry = handle_entry( obj )) && !entry->system)
1019 for (phdc = entry->hdcs; phdc; phdc = phdc->next)
1020 if (phdc->hdc == hdc) break;
1022 if (!phdc)
1024 phdc = HeapAlloc(GetProcessHeap(), 0, sizeof(*phdc));
1025 phdc->hdc = hdc;
1026 phdc->next = entry->hdcs;
1027 entry->hdcs = phdc;
1030 LeaveCriticalSection( &gdi_section );
1033 /***********************************************************************
1034 * GDI_hdc_not_using_object
1037 void GDI_hdc_not_using_object(HGDIOBJ obj, HDC hdc)
1039 struct gdi_handle_entry *entry;
1040 struct hdc_list **pphdc;
1042 TRACE("obj %p hdc %p\n", obj, hdc);
1044 EnterCriticalSection( &gdi_section );
1045 if ((entry = handle_entry( obj )) && !entry->system)
1047 for (pphdc = &entry->hdcs; *pphdc; pphdc = &(*pphdc)->next)
1048 if ((*pphdc)->hdc == hdc)
1050 struct hdc_list *phdc = *pphdc;
1051 *pphdc = phdc->next;
1052 HeapFree(GetProcessHeap(), 0, phdc);
1053 break;
1056 LeaveCriticalSection( &gdi_section );
1059 /***********************************************************************
1060 * GetStockObject (GDI32.@)
1062 HGDIOBJ WINAPI GetStockObject( INT obj )
1064 HGDIOBJ ret;
1065 if ((obj < 0) || (obj >= NB_STOCK_OBJECTS)) return 0;
1066 ret = stock_objects[obj];
1067 TRACE("returning %p\n", ret );
1068 return ret;
1072 /***********************************************************************
1073 * GetObjectA (GDI32.@)
1075 INT WINAPI GetObjectA( HGDIOBJ handle, INT count, LPVOID buffer )
1077 struct gdi_handle_entry *entry;
1078 const struct gdi_obj_funcs *funcs = NULL;
1079 INT result = 0;
1081 TRACE("%p %d %p\n", handle, count, buffer );
1083 EnterCriticalSection( &gdi_section );
1084 if ((entry = handle_entry( handle )))
1086 funcs = entry->funcs;
1087 handle = entry_to_handle( entry ); /* make it a full handle */
1089 LeaveCriticalSection( &gdi_section );
1091 if (funcs)
1093 if (!funcs->pGetObjectA)
1094 SetLastError( ERROR_INVALID_HANDLE );
1095 else if (buffer && ((ULONG_PTR)buffer >> 16) == 0) /* catch apps getting argument order wrong */
1096 SetLastError( ERROR_NOACCESS );
1097 else
1098 result = funcs->pGetObjectA( handle, count, buffer );
1100 return result;
1103 /***********************************************************************
1104 * GetObjectW (GDI32.@)
1106 INT WINAPI GetObjectW( HGDIOBJ handle, INT count, LPVOID buffer )
1108 struct gdi_handle_entry *entry;
1109 const struct gdi_obj_funcs *funcs = NULL;
1110 INT result = 0;
1112 TRACE("%p %d %p\n", handle, count, buffer );
1114 EnterCriticalSection( &gdi_section );
1115 if ((entry = handle_entry( handle )))
1117 funcs = entry->funcs;
1118 handle = entry_to_handle( entry ); /* make it a full handle */
1120 LeaveCriticalSection( &gdi_section );
1122 if (funcs)
1124 if (!funcs->pGetObjectW)
1125 SetLastError( ERROR_INVALID_HANDLE );
1126 else if (buffer && ((ULONG_PTR)buffer >> 16) == 0) /* catch apps getting argument order wrong */
1127 SetLastError( ERROR_NOACCESS );
1128 else
1129 result = funcs->pGetObjectW( handle, count, buffer );
1131 return result;
1134 /***********************************************************************
1135 * GetObjectType (GDI32.@)
1137 DWORD WINAPI GetObjectType( HGDIOBJ handle )
1139 struct gdi_handle_entry *entry;
1140 DWORD result = 0;
1142 EnterCriticalSection( &gdi_section );
1143 if ((entry = handle_entry( handle ))) result = entry->type;
1144 LeaveCriticalSection( &gdi_section );
1146 TRACE("%p -> %u\n", handle, result );
1147 if (!result) SetLastError( ERROR_INVALID_HANDLE );
1148 return result;
1151 /***********************************************************************
1152 * GetCurrentObject (GDI32.@)
1154 * Get the currently selected object of a given type in a device context.
1156 * PARAMS
1157 * hdc [I] Device context to get the current object from
1158 * type [I] Type of current object to get (OBJ_* defines from "wingdi.h")
1160 * RETURNS
1161 * Success: The current object of the given type selected in hdc.
1162 * Failure: A NULL handle.
1164 * NOTES
1165 * - only the following object types are supported:
1166 *| OBJ_PEN
1167 *| OBJ_BRUSH
1168 *| OBJ_PAL
1169 *| OBJ_FONT
1170 *| OBJ_BITMAP
1172 HGDIOBJ WINAPI GetCurrentObject(HDC hdc,UINT type)
1174 HGDIOBJ ret = 0;
1175 DC * dc = get_dc_ptr( hdc );
1177 if (!dc) return 0;
1179 switch (type) {
1180 case OBJ_EXTPEN: /* fall through */
1181 case OBJ_PEN: ret = dc->hPen; break;
1182 case OBJ_BRUSH: ret = dc->hBrush; break;
1183 case OBJ_PAL: ret = dc->hPalette; break;
1184 case OBJ_FONT: ret = dc->hFont; break;
1185 case OBJ_BITMAP: ret = dc->hBitmap; break;
1187 /* tests show that OBJ_REGION is explicitly ignored */
1188 case OBJ_REGION: break;
1189 default:
1190 /* the SDK only mentions those above */
1191 FIXME("(%p,%d): unknown type.\n",hdc,type);
1192 break;
1194 release_dc_ptr( dc );
1195 return ret;
1199 /***********************************************************************
1200 * SelectObject (GDI32.@)
1202 * Select a Gdi object into a device context.
1204 * PARAMS
1205 * hdc [I] Device context to associate the object with
1206 * hObj [I] Gdi object to associate with hdc
1208 * RETURNS
1209 * Success: A non-NULL handle representing the previously selected object of
1210 * the same type as hObj.
1211 * Failure: A NULL object. If hdc is invalid, GetLastError() returns ERROR_INVALID_HANDLE.
1212 * if hObj is not a valid object handle, no last error is set. In either
1213 * case, hdc is unaffected by the call.
1215 HGDIOBJ WINAPI SelectObject( HDC hdc, HGDIOBJ hObj )
1217 struct gdi_handle_entry *entry;
1218 const struct gdi_obj_funcs *funcs = NULL;
1220 TRACE( "(%p,%p)\n", hdc, hObj );
1222 EnterCriticalSection( &gdi_section );
1223 if ((entry = handle_entry( hObj )))
1225 funcs = entry->funcs;
1226 hObj = entry_to_handle( entry ); /* make it a full handle */
1228 LeaveCriticalSection( &gdi_section );
1230 if (funcs && funcs->pSelectObject) return funcs->pSelectObject( hObj, hdc );
1231 return 0;
1235 /***********************************************************************
1236 * UnrealizeObject (GDI32.@)
1238 BOOL WINAPI UnrealizeObject( HGDIOBJ obj )
1240 const struct gdi_obj_funcs *funcs = NULL;
1241 struct gdi_handle_entry *entry;
1243 EnterCriticalSection( &gdi_section );
1244 if ((entry = handle_entry( obj )))
1246 funcs = entry->funcs;
1247 obj = entry_to_handle( entry ); /* make it a full handle */
1249 LeaveCriticalSection( &gdi_section );
1251 if (funcs && funcs->pUnrealizeObject) return funcs->pUnrealizeObject( obj );
1252 return funcs != NULL;
1256 /* Solid colors to enumerate */
1257 static const COLORREF solid_colors[] =
1258 { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
1259 RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
1260 RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
1261 RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
1262 RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
1263 RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
1264 RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
1265 RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
1269 /***********************************************************************
1270 * EnumObjects (GDI32.@)
1272 INT WINAPI EnumObjects( HDC hdc, INT nObjType,
1273 GOBJENUMPROC lpEnumFunc, LPARAM lParam )
1275 UINT i;
1276 INT retval = 0;
1277 LOGPEN pen;
1278 LOGBRUSH brush;
1280 TRACE("%p %d %p %08lx\n", hdc, nObjType, lpEnumFunc, lParam );
1281 switch(nObjType)
1283 case OBJ_PEN:
1284 /* Enumerate solid pens */
1285 for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
1287 pen.lopnStyle = PS_SOLID;
1288 pen.lopnWidth.x = 1;
1289 pen.lopnWidth.y = 0;
1290 pen.lopnColor = solid_colors[i];
1291 retval = lpEnumFunc( &pen, lParam );
1292 TRACE("solid pen %08x, ret=%d\n",
1293 solid_colors[i], retval);
1294 if (!retval) break;
1296 break;
1298 case OBJ_BRUSH:
1299 /* Enumerate solid brushes */
1300 for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
1302 brush.lbStyle = BS_SOLID;
1303 brush.lbColor = solid_colors[i];
1304 brush.lbHatch = 0;
1305 retval = lpEnumFunc( &brush, lParam );
1306 TRACE("solid brush %08x, ret=%d\n",
1307 solid_colors[i], retval);
1308 if (!retval) break;
1311 /* Now enumerate hatched brushes */
1312 if (retval) for (i = HS_HORIZONTAL; i <= HS_DIAGCROSS; i++)
1314 brush.lbStyle = BS_HATCHED;
1315 brush.lbColor = RGB(0,0,0);
1316 brush.lbHatch = i;
1317 retval = lpEnumFunc( &brush, lParam );
1318 TRACE("hatched brush %d, ret=%d\n",
1319 i, retval);
1320 if (!retval) break;
1322 break;
1324 default:
1325 /* FIXME: implement Win32 types */
1326 WARN("(%d): Invalid type\n", nObjType );
1327 break;
1329 return retval;
1333 /***********************************************************************
1334 * SetObjectOwner (GDI32.@)
1336 void WINAPI SetObjectOwner( HGDIOBJ handle, HANDLE owner )
1338 /* Nothing to do */
1341 /***********************************************************************
1342 * GdiInitializeLanguagePack (GDI32.@)
1344 DWORD WINAPI GdiInitializeLanguagePack( DWORD arg )
1346 FIXME("stub\n");
1347 return 0;
1350 /***********************************************************************
1351 * GdiFlush (GDI32.@)
1353 BOOL WINAPI GdiFlush(void)
1355 return TRUE; /* FIXME */
1359 /***********************************************************************
1360 * GdiGetBatchLimit (GDI32.@)
1362 DWORD WINAPI GdiGetBatchLimit(void)
1364 return 1; /* FIXME */
1368 /***********************************************************************
1369 * GdiSetBatchLimit (GDI32.@)
1371 DWORD WINAPI GdiSetBatchLimit( DWORD limit )
1373 return 1; /* FIXME */
1377 /*******************************************************************
1378 * GetColorAdjustment [GDI32.@]
1382 BOOL WINAPI GetColorAdjustment(HDC hdc, LPCOLORADJUSTMENT lpca)
1384 FIXME("stub\n");
1385 return FALSE;
1388 /*******************************************************************
1389 * GdiComment [GDI32.@]
1393 BOOL WINAPI GdiComment(HDC hdc, UINT cbSize, const BYTE *lpData)
1395 DC *dc = get_dc_ptr(hdc);
1396 BOOL ret = FALSE;
1398 if(dc)
1400 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pGdiComment );
1401 ret = physdev->funcs->pGdiComment( physdev, cbSize, lpData );
1402 release_dc_ptr( dc );
1404 return ret;
1407 /*******************************************************************
1408 * SetColorAdjustment [GDI32.@]
1412 BOOL WINAPI SetColorAdjustment(HDC hdc, const COLORADJUSTMENT* lpca)
1414 FIXME("stub\n");
1415 return FALSE;