4 * Copyright 1993 Alexandre Julliard
16 #include "wine/winbase16.h"
27 #include "debugtools.h"
30 DEFAULT_DEBUG_CHANNEL(gdi
);
33 /***********************************************************************
37 static BRUSHOBJ WhiteBrush
=
39 { 0, BRUSH_MAGIC
, 1 }, /* header */
40 { BS_SOLID
, RGB(255,255,255), 0 } /* logbrush */
43 static BRUSHOBJ LtGrayBrush
=
45 { 0, BRUSH_MAGIC
, 1 }, /* header */
46 /* FIXME : this should perhaps be BS_HATCHED, at least for 1 bitperpixel */
47 { BS_SOLID
, RGB(192,192,192), 0 } /* logbrush */
50 static BRUSHOBJ GrayBrush
=
52 { 0, BRUSH_MAGIC
, 1 }, /* header */
53 /* FIXME : this should perhaps be BS_HATCHED, at least for 1 bitperpixel */
54 { BS_SOLID
, RGB(128,128,128), 0 } /* logbrush */
57 static BRUSHOBJ DkGrayBrush
=
59 { 0, BRUSH_MAGIC
, 1 }, /* header */
60 /* This is BS_HATCHED, for 1 bitperpixel. This makes the spray work in pbrush */
61 /* NB_HATCH_STYLES is an index into HatchBrushes */
62 { BS_HATCHED
, RGB(0,0,0), NB_HATCH_STYLES
} /* logbrush */
65 static BRUSHOBJ BlackBrush
=
67 { 0, BRUSH_MAGIC
, 1 }, /* header */
68 { BS_SOLID
, RGB(0,0,0), 0 } /* logbrush */
71 static BRUSHOBJ NullBrush
=
73 { 0, BRUSH_MAGIC
, 1 }, /* header */
74 { BS_NULL
, 0, 0 } /* logbrush */
77 static PENOBJ WhitePen
=
79 { 0, PEN_MAGIC
, 1 }, /* header */
80 { PS_SOLID
, { 0, 0 }, RGB(255,255,255) } /* logpen */
83 static PENOBJ BlackPen
=
85 { 0, PEN_MAGIC
, 1 }, /* header */
86 { PS_SOLID
, { 0, 0 }, RGB(0,0,0) } /* logpen */
89 static PENOBJ NullPen
=
91 { 0, PEN_MAGIC
, 1 }, /* header */
92 { PS_NULL
, { 0, 0 }, 0 } /* logpen */
95 static FONTOBJ OEMFixedFont
=
97 { 0, FONT_MAGIC
, 1 }, /* header */
98 { 0, 0, 0, 0, FW_NORMAL
, FALSE
, FALSE
, FALSE
, OEM_CHARSET
,
99 0, 0, DEFAULT_QUALITY
, FIXED_PITCH
| FF_MODERN
, {'\0'} }
102 static FONTOBJ AnsiFixedFont
=
104 { 0, FONT_MAGIC
, 1 }, /* header */
105 { 0, 0, 0, 0, FW_NORMAL
, FALSE
, FALSE
, FALSE
, ANSI_CHARSET
,
106 0, 0, DEFAULT_QUALITY
, FIXED_PITCH
| FF_MODERN
, {'\0'} }
109 static FONTOBJ AnsiVarFont
=
111 { 0, FONT_MAGIC
, 1 }, /* header */
112 { 0, 0, 0, 0, FW_NORMAL
, FALSE
, FALSE
, FALSE
, ANSI_CHARSET
,
113 0, 0, DEFAULT_QUALITY
, VARIABLE_PITCH
| FF_SWISS
,
114 {'M','S',' ','S','a','n','s',' ','S','e','r','i','f','\0'} }
117 static FONTOBJ SystemFont
=
119 { 0, FONT_MAGIC
, 1 },
120 { 0, 0, 0, 0, FW_NORMAL
, FALSE
, FALSE
, FALSE
, ANSI_CHARSET
,
121 0, 0, DEFAULT_QUALITY
, VARIABLE_PITCH
| FF_SWISS
,
122 {'S','y','s','t','e','m','\0'} }
125 static FONTOBJ DeviceDefaultFont
=
127 { 0, FONT_MAGIC
, 1 }, /* header */
128 { 0, 0, 0, 0, FW_NORMAL
, FALSE
, FALSE
, FALSE
, ANSI_CHARSET
,
129 0, 0, DEFAULT_QUALITY
, VARIABLE_PITCH
| FF_SWISS
, {'\0'} }
132 static FONTOBJ SystemFixedFont
=
134 { 0, FONT_MAGIC
, 1 }, /* header */
135 { 0, 0, 0, 0, FW_NORMAL
, FALSE
, FALSE
, FALSE
, ANSI_CHARSET
,
136 0, 0, DEFAULT_QUALITY
, FIXED_PITCH
| FF_MODERN
, {'\0'} }
139 /* FIXME: Is this correct? */
140 static FONTOBJ DefaultGuiFont
=
142 { 0, FONT_MAGIC
, 1 }, /* header */
143 { 0, 0, 0, 0, FW_NORMAL
, FALSE
, FALSE
, FALSE
, ANSI_CHARSET
,
144 0, 0, DEFAULT_QUALITY
, VARIABLE_PITCH
| FF_SWISS
,
145 {'M','S',' ','S','a','n','s',' ','S','e','r','i','f','\0'} }
149 static GDIOBJHDR
* StockObjects
[NB_STOCK_OBJECTS
] =
151 (GDIOBJHDR
*) &WhiteBrush
,
152 (GDIOBJHDR
*) &LtGrayBrush
,
153 (GDIOBJHDR
*) &GrayBrush
,
154 (GDIOBJHDR
*) &DkGrayBrush
,
155 (GDIOBJHDR
*) &BlackBrush
,
156 (GDIOBJHDR
*) &NullBrush
,
157 (GDIOBJHDR
*) &WhitePen
,
158 (GDIOBJHDR
*) &BlackPen
,
159 (GDIOBJHDR
*) &NullPen
,
161 (GDIOBJHDR
*) &OEMFixedFont
,
162 (GDIOBJHDR
*) &AnsiFixedFont
,
163 (GDIOBJHDR
*) &AnsiVarFont
,
164 (GDIOBJHDR
*) &SystemFont
,
165 (GDIOBJHDR
*) &DeviceDefaultFont
,
166 NULL
, /* DEFAULT_PALETTE created by PALETTE_Init */
167 (GDIOBJHDR
*) &SystemFixedFont
,
168 (GDIOBJHDR
*) &DefaultGuiFont
171 HBITMAP hPseudoStockBitmap
; /* 1x1 bitmap for memory DCs */
173 static SYSLEVEL GDI_level
= { CRITICAL_SECTION_INIT
, 3 };
174 static WORD GDI_HeapSel
;
177 /******************************************************************************
179 * void ReadFontInformation(
180 * char const *fontName,
188 * ReadFontInformation() checks the Wine configuration file's Tweak.Fonts
189 * section for entries containing fontName.Height, fontName.Bold, etc.,
190 * where fontName is the name specified in the call (e.g., "System"). It
191 * attempts to be user friendly by accepting 'n', 'N', 'f', 'F', or '0' as
192 * the first character in the boolean attributes (bold, italic, and
194 *****************************************************************************/
196 static void ReadFontInformation(
197 char const *fontName
,
207 /* In order for the stock fonts to be independent of
208 * mapping mode, the height (& width) must be 0
210 sprintf(key
, "%s.Height", fontName
);
211 font
->logfont
.lfHeight
=
212 PROFILE_GetWineIniInt("Tweak.Fonts", key
, defHeight
);
214 sprintf(key
, "%s.Bold", fontName
);
215 font
->logfont
.lfWeight
=
216 (PROFILE_GetWineIniBool("Tweak.Fonts", key
, defBold
)) ?
219 sprintf(key
, "%s.Italic", fontName
);
220 font
->logfont
.lfItalic
=
221 PROFILE_GetWineIniBool("Tweak.Fonts", key
, defItalic
);
223 sprintf(key
, "%s.Underline", fontName
);
224 font
->logfont
.lfUnderline
=
225 PROFILE_GetWineIniBool("Tweak.Fonts", key
, defUnderline
);
227 sprintf(key
, "%s.StrikeOut", fontName
);
228 font
->logfont
.lfStrikeOut
=
229 PROFILE_GetWineIniBool("Tweak.Fonts", key
, defStrikeOut
);
234 /***********************************************************************
235 * Because the stock fonts have their structure initialized with
236 * a height of 0 to keep them independent of mapping mode, simply
237 * returning the LOGFONT as is will not work correctly.
238 * These "FixStockFontSizeXXX()" methods will get the correct
239 * size for the fonts.
241 static void GetFontMetrics(HFONT handle
, LPTEXTMETRICA lptm
)
246 hdc
= CreateDCA("DISPLAY", NULL
, NULL
, NULL
);
248 hOldFont
= (HFONT
)SelectObject(hdc
, handle
);
250 GetTextMetricsA(hdc
, lptm
);
252 SelectObject(hdc
, hOldFont
);
257 static inline void FixStockFontSize16(
263 LOGFONT16
* pLogFont
= (LOGFONT16
*)buffer
;
266 * Was the lfHeight field copied (it's the first field)?
267 * If it was and it was null, replace the height.
269 if ( (count
>= 2*sizeof(INT16
)) &&
270 (pLogFont
->lfHeight
== 0) )
272 GetFontMetrics(handle
, &tm
);
274 pLogFont
->lfHeight
= tm
.tmHeight
;
275 pLogFont
->lfWidth
= tm
.tmAveCharWidth
;
279 static inline void FixStockFontSizeA(
285 LOGFONTA
* pLogFont
= (LOGFONTA
*)buffer
;
288 * Was the lfHeight field copied (it's the first field)?
289 * If it was and it was null, replace the height.
291 if ( (count
>= 2*sizeof(INT
)) &&
292 (pLogFont
->lfHeight
== 0) )
294 GetFontMetrics(handle
, &tm
);
296 pLogFont
->lfHeight
= tm
.tmHeight
;
297 pLogFont
->lfWidth
= tm
.tmAveCharWidth
;
302 * Since the LOGFONTA and LOGFONTW structures are identical up to the
303 * lfHeight member (the one of interest in this case) we simply define
304 * the W version as the A version.
306 #define FixStockFontSizeW FixStockFontSizeA
308 #define TRACE_SEC(handle,text) \
309 TRACE("(%04x): " text " %ld\n", (handle), GDI_level.crst.RecursionCount)
311 /***********************************************************************
314 * GDI initialization.
319 HINSTANCE16 instance
;
321 /* create GDI heap */
322 if ((instance
= LoadLibrary16( "GDI.EXE" )) < 32) return FALSE
;
323 GDI_HeapSel
= instance
| 7;
325 /* TWEAK: Initialize font hints */
326 ReadFontInformation("OEMFixed", &OEMFixedFont
, 0, 0, 0, 0, 0);
327 ReadFontInformation("AnsiFixed", &AnsiFixedFont
, 0, 0, 0, 0, 0);
328 ReadFontInformation("AnsiVar", &AnsiVarFont
, 0, 0, 0, 0, 0);
329 ReadFontInformation("System", &SystemFont
, 0, 0, 0, 0, 0);
330 ReadFontInformation("DeviceDefault", &DeviceDefaultFont
, 0, 0, 0, 0, 0);
331 ReadFontInformation("SystemFixed", &SystemFixedFont
, 0, 0, 0, 0, 0);
332 ReadFontInformation("DefaultGui", &DefaultGuiFont
, 0, 0, 0, 0, 0);
334 /* Create default palette */
336 /* DR well *this* palette can't be moveable (?) */
337 hpalette
= PALETTE_Init();
338 if( !hpalette
) return FALSE
;
339 StockObjects
[DEFAULT_PALETTE
] = (GDIOBJHDR
*)LOCAL_Lock( GDI_HeapSel
, hpalette
);
341 hPseudoStockBitmap
= CreateBitmap( 1, 1, 1, 1, NULL
);
345 #define FIRST_LARGE_HANDLE 16
346 #define MAX_LARGE_HANDLES ((GDI_HEAP_SIZE >> 2) - FIRST_LARGE_HANDLE)
347 static GDIOBJHDR
*large_handles
[MAX_LARGE_HANDLES
];
348 static int next_large_handle
;
350 /***********************************************************************
353 * Allocate a GDI handle from the large heap. Helper for GDI_AllocObject
355 inline static GDIOBJHDR
*alloc_large_heap( WORD size
, HGDIOBJ
*handle
)
360 for (i
= next_large_handle
+ 1; i
< MAX_LARGE_HANDLES
; i
++)
361 if (!large_handles
[i
]) goto found
;
362 for (i
= 0; i
<= next_large_handle
; i
++)
363 if (!large_handles
[i
]) goto found
;
368 if ((obj
= HeapAlloc( GetProcessHeap(), 0, size
)))
370 large_handles
[i
] = obj
;
371 *handle
= (i
+ FIRST_LARGE_HANDLE
) << 2;
372 next_large_handle
= i
;
378 /***********************************************************************
381 void *GDI_AllocObject( WORD size
, WORD magic
, HGDIOBJ
*handle
)
383 static DWORD count
= 0;
386 _EnterSysLevel( &GDI_level
);
389 /* allocate DCs on the larger heap */
391 case DISABLED_DC_MAGIC
:
394 case METAFILE_DC_MAGIC
:
395 case ENHMETAFILE_MAGIC
:
396 case ENHMETAFILE_DC_MAGIC
:
398 if (!(obj
= alloc_large_heap( size
, handle
))) goto error
;
401 if (!(*handle
= LOCAL_Alloc( GDI_HeapSel
, LMEM_MOVEABLE
, size
))) goto error
;
402 assert( *handle
& 2 );
403 obj
= (GDIOBJHDR
*)LOCAL_Lock( GDI_HeapSel
, *handle
);
408 obj
->wMagic
= magic
|OBJECT_NOSYSTEM
;
409 obj
->dwCount
= ++count
;
411 TRACE_SEC( *handle
, "enter" );
415 _LeaveSysLevel( &GDI_level
);
421 /***********************************************************************
424 * The object ptr must have been obtained with GDI_GetObjPtr.
425 * The new pointer must be released with GDI_ReleaseObj.
427 void *GDI_ReallocObject( WORD size
, HGDIOBJ handle
, void *object
)
431 assert( handle
& 2 ); /* no realloc for large handles */
432 LOCAL_Unlock( GDI_HeapSel
, handle
);
433 if (!(new_handle
= LOCAL_ReAlloc( GDI_HeapSel
, handle
, size
, LMEM_MOVEABLE
)))
435 TRACE_SEC( handle
, "leave" );
436 _LeaveSysLevel( &GDI_level
);
439 assert( new_handle
== handle
); /* moveable handle cannot change */
440 return LOCAL_Lock( GDI_HeapSel
, handle
);
444 /***********************************************************************
447 BOOL
GDI_FreeObject( HGDIOBJ handle
, void *ptr
)
449 GDIOBJHDR
*object
= ptr
;
451 /* can't free stock objects */
452 if (handle
< FIRST_STOCK_HANDLE
)
454 object
->wMagic
= 0; /* Mark it as invalid */
455 if (handle
& 2) /* GDI heap handle */
457 LOCAL_Unlock( GDI_HeapSel
, handle
);
458 LOCAL_Free( GDI_HeapSel
, handle
);
460 else /* large heap handle */
462 int i
= (handle
>> 2) - FIRST_LARGE_HANDLE
;
463 if (i
>= 0 && large_handles
[i
])
465 HeapFree( GetProcessHeap(), 0, large_handles
[i
] );
466 large_handles
[i
] = NULL
;
470 TRACE_SEC( handle
, "leave" );
471 _LeaveSysLevel( &GDI_level
);
476 /***********************************************************************
479 * Return a pointer to the GDI object associated to the handle.
480 * Return NULL if the object has the wrong magic number.
481 * The object must be released with GDI_ReleaseObj.
483 void *GDI_GetObjPtr( HGDIOBJ handle
, WORD magic
)
485 GDIOBJHDR
*ptr
= NULL
;
487 _EnterSysLevel( &GDI_level
);
489 if (handle
>= FIRST_STOCK_HANDLE
)
491 if (handle
<= LAST_STOCK_HANDLE
) ptr
= StockObjects
[handle
- FIRST_STOCK_HANDLE
];
492 if (ptr
&& (magic
!= MAGIC_DONTCARE
)
493 && (GDIMAGIC(ptr
->wMagic
) != magic
)) ptr
= NULL
;
495 else if (handle
& 2) /* GDI heap handle */
497 ptr
= (GDIOBJHDR
*)LOCAL_Lock( GDI_HeapSel
, handle
);
499 (magic
!= MAGIC_DONTCARE
) && (GDIMAGIC(ptr
->wMagic
) != magic
))
501 LOCAL_Unlock( GDI_HeapSel
, handle
);
505 else /* large heap handle */
507 int i
= (handle
>> 2) - FIRST_LARGE_HANDLE
;
510 ptr
= large_handles
[i
];
511 if (ptr
&& (magic
!= MAGIC_DONTCARE
) && (GDIMAGIC(ptr
->wMagic
) != magic
)) ptr
= NULL
;
517 _LeaveSysLevel( &GDI_level
);
518 SetLastError( ERROR_INVALID_HANDLE
);
520 else TRACE_SEC( handle
, "enter" );
526 /***********************************************************************
530 void GDI_ReleaseObj( HGDIOBJ handle
)
532 if (handle
< FIRST_STOCK_HANDLE
&& (handle
& 2)) LOCAL_Unlock( GDI_HeapSel
, handle
);
533 TRACE_SEC( handle
, "leave" );
534 _LeaveSysLevel( &GDI_level
);
538 /***********************************************************************
539 * DeleteObject16 (GDI.605)
541 BOOL16 WINAPI
DeleteObject16( HGDIOBJ16 obj
)
543 return DeleteObject( obj
);
547 /***********************************************************************
548 * DeleteObject (GDI32.@)
550 BOOL WINAPI
DeleteObject( HGDIOBJ obj
)
552 /* Check if object is valid */
555 if (HIWORD(obj
)) return FALSE
;
556 if ((obj
>= FIRST_STOCK_HANDLE
) && (obj
<= LAST_STOCK_HANDLE
)) {
557 TRACE("Preserving Stock object %04x\n", obj
);
558 /* NOTE: No GDI_Release is necessary */
561 if (obj
== hPseudoStockBitmap
) return TRUE
;
562 if (!(header
= GDI_GetObjPtr( obj
, MAGIC_DONTCARE
))) return FALSE
;
564 if (!(header
->wMagic
& OBJECT_NOSYSTEM
)
565 && (header
->wMagic
>= FIRST_MAGIC
) && (header
->wMagic
<= LAST_MAGIC
))
567 TRACE("Preserving system object %04x\n", obj
);
568 GDI_ReleaseObj( obj
);
572 TRACE("%04x\n", obj
);
576 switch(GDIMAGIC(header
->wMagic
))
578 case PEN_MAGIC
: return GDI_FreeObject( obj
, header
);
579 case BRUSH_MAGIC
: return BRUSH_DeleteObject( obj
, (BRUSHOBJ
*)header
);
580 case FONT_MAGIC
: return GDI_FreeObject( obj
, header
);
581 case PALETTE_MAGIC
: return PALETTE_DeleteObject(obj
,(PALETTEOBJ
*)header
);
582 case BITMAP_MAGIC
: return BITMAP_DeleteObject( obj
, (BITMAPOBJ
*)header
);
583 case REGION_MAGIC
: return REGION_DeleteObject( obj
, (RGNOBJ
*)header
);
585 GDI_ReleaseObj( obj
);
586 return DeleteDC(obj
);
588 WARN("Already deleted\n");
591 WARN("Unknown magic number (%d)\n",GDIMAGIC(header
->wMagic
));
593 GDI_ReleaseObj( obj
);
597 /***********************************************************************
598 * GetStockObject16 (GDI.87)
600 HGDIOBJ16 WINAPI
GetStockObject16( INT16 obj
)
602 return (HGDIOBJ16
)GetStockObject( obj
);
606 /***********************************************************************
607 * GetStockObject (GDI32.@)
609 HGDIOBJ WINAPI
GetStockObject( INT obj
)
612 if ((obj
< 0) || (obj
>= NB_STOCK_OBJECTS
)) return 0;
613 if (!StockObjects
[obj
]) return 0;
614 ret
= (HGDIOBJ16
)(FIRST_STOCK_HANDLE
+ obj
);
615 TRACE("returning %4x\n", ret
);
620 /***********************************************************************
621 * GetObject16 (GDI.82)
623 INT16 WINAPI
GetObject16( HANDLE16 handle
, INT16 count
, LPVOID buffer
)
627 TRACE("%04x %d %p\n", handle
, count
, buffer
);
628 if (!count
) return 0;
630 if (!(ptr
= GDI_GetObjPtr( handle
, MAGIC_DONTCARE
))) return 0;
632 switch(GDIMAGIC(ptr
->wMagic
))
635 result
= PEN_GetObject16( (PENOBJ
*)ptr
, count
, buffer
);
638 result
= BRUSH_GetObject16( (BRUSHOBJ
*)ptr
, count
, buffer
);
641 result
= BITMAP_GetObject16( (BITMAPOBJ
*)ptr
, count
, buffer
);
644 result
= FONT_GetObject16( (FONTOBJ
*)ptr
, count
, buffer
);
647 * Fix the LOGFONT structure for the stock fonts
649 if ( (handle
>= FIRST_STOCK_HANDLE
) &&
650 (handle
<= LAST_STOCK_HANDLE
) )
651 FixStockFontSize16(handle
, count
, buffer
);
654 result
= PALETTE_GetObject( (PALETTEOBJ
*)ptr
, count
, buffer
);
657 GDI_ReleaseObj( handle
);
662 /***********************************************************************
663 * GetObjectA (GDI32.@)
665 INT WINAPI
GetObjectA( HANDLE handle
, INT count
, LPVOID buffer
)
669 TRACE("%08x %d %p\n", handle
, count
, buffer
);
670 if (!count
) return 0;
672 if (!(ptr
= GDI_GetObjPtr( handle
, MAGIC_DONTCARE
))) return 0;
674 switch(GDIMAGIC(ptr
->wMagic
))
677 result
= PEN_GetObject( (PENOBJ
*)ptr
, count
, buffer
);
680 result
= BRUSH_GetObject( (BRUSHOBJ
*)ptr
, count
, buffer
);
683 result
= BITMAP_GetObject( (BITMAPOBJ
*)ptr
, count
, buffer
);
686 result
= FONT_GetObjectA( (FONTOBJ
*)ptr
, count
, buffer
);
689 * Fix the LOGFONT structure for the stock fonts
691 if ( (handle
>= FIRST_STOCK_HANDLE
) &&
692 (handle
<= LAST_STOCK_HANDLE
) )
693 FixStockFontSizeA(handle
, count
, buffer
);
696 result
= PALETTE_GetObject( (PALETTEOBJ
*)ptr
, count
, buffer
);
701 case DISABLED_DC_MAGIC
:
704 case METAFILE_DC_MAGIC
:
705 case ENHMETAFILE_MAGIC
:
706 case ENHMETAFILE_DC_MAGIC
:
707 FIXME("Magic %04x not implemented\n", GDIMAGIC(ptr
->wMagic
) );
711 ERR("Invalid GDI Magic %04x\n", GDIMAGIC(ptr
->wMagic
));
714 GDI_ReleaseObj( handle
);
718 /***********************************************************************
719 * GetObjectW (GDI32.@)
721 INT WINAPI
GetObjectW( HANDLE handle
, INT count
, LPVOID buffer
)
725 TRACE("%08x %d %p\n", handle
, count
, buffer
);
726 if (!count
) return 0;
728 if (!(ptr
= GDI_GetObjPtr( handle
, MAGIC_DONTCARE
))) return 0;
730 switch(GDIMAGIC(ptr
->wMagic
))
733 result
= PEN_GetObject( (PENOBJ
*)ptr
, count
, buffer
);
736 result
= BRUSH_GetObject( (BRUSHOBJ
*)ptr
, count
, buffer
);
739 result
= BITMAP_GetObject( (BITMAPOBJ
*)ptr
, count
, buffer
);
742 result
= FONT_GetObjectW( (FONTOBJ
*)ptr
, count
, buffer
);
745 * Fix the LOGFONT structure for the stock fonts
747 if ( (handle
>= FIRST_STOCK_HANDLE
) &&
748 (handle
<= LAST_STOCK_HANDLE
) )
749 FixStockFontSizeW(handle
, count
, buffer
);
752 result
= PALETTE_GetObject( (PALETTEOBJ
*)ptr
, count
, buffer
);
755 FIXME("Magic %04x not implemented\n", GDIMAGIC(ptr
->wMagic
) );
758 GDI_ReleaseObj( handle
);
762 /***********************************************************************
763 * GetObjectType (GDI32.@)
765 DWORD WINAPI
GetObjectType( HANDLE handle
)
769 TRACE("%08x\n", handle
);
771 if (!(ptr
= GDI_GetObjPtr( handle
, MAGIC_DONTCARE
))) return 0;
773 switch(GDIMAGIC(ptr
->wMagic
))
800 result
= OBJ_METAFILE
;
802 case METAFILE_DC_MAGIC
:
805 case ENHMETAFILE_MAGIC
:
806 result
= OBJ_ENHMETAFILE
;
808 case ENHMETAFILE_DC_MAGIC
:
809 result
= OBJ_ENHMETADC
;
812 FIXME("Magic %04x not implemented\n", GDIMAGIC(ptr
->wMagic
) );
815 GDI_ReleaseObj( handle
);
819 /***********************************************************************
820 * GetCurrentObject (GDI32.@)
822 HANDLE WINAPI
GetCurrentObject(HDC hdc
,UINT type
)
825 DC
* dc
= DC_GetDCPtr( hdc
);
830 case OBJ_PEN
: ret
= dc
->hPen
; break;
831 case OBJ_BRUSH
: ret
= dc
->hBrush
; break;
832 case OBJ_PAL
: ret
= dc
->hPalette
; break;
833 case OBJ_FONT
: ret
= dc
->hFont
; break;
834 case OBJ_BITMAP
: ret
= dc
->hBitmap
; break;
836 /* the SDK only mentions those above */
837 FIXME("(%08x,%d): unknown type.\n",hdc
,type
);
840 GDI_ReleaseObj( hdc
);
846 /***********************************************************************
847 * SelectObject16 (GDI.45)
849 HGDIOBJ16 WINAPI
SelectObject16( HDC16 hdc
, HGDIOBJ16 handle
)
851 return (HGDIOBJ16
)SelectObject( hdc
, handle
);
855 /***********************************************************************
856 * SelectObject (GDI32.@)
858 HGDIOBJ WINAPI
SelectObject( HDC hdc
, HGDIOBJ handle
)
861 DC
* dc
= DC_GetDCUpdate( hdc
);
863 TRACE("hdc=%04x %04x\n", hdc
, handle
);
864 if (dc
->funcs
->pSelectObject
)
865 ret
= dc
->funcs
->pSelectObject( dc
, handle
);
866 GDI_ReleaseObj( hdc
);
871 /***********************************************************************
872 * UnrealizeObject16 (GDI.150)
874 BOOL16 WINAPI
UnrealizeObject16( HGDIOBJ16 obj
)
876 return UnrealizeObject( obj
);
880 /***********************************************************************
881 * UnrealizeObject (GDI32.@)
883 BOOL WINAPI
UnrealizeObject( HGDIOBJ obj
)
886 /* Check if object is valid */
888 GDIOBJHDR
* header
= GDI_GetObjPtr( obj
, MAGIC_DONTCARE
);
889 if (!header
) return FALSE
;
891 TRACE("%04x\n", obj
);
893 /* Unrealize object */
895 switch(GDIMAGIC(header
->wMagic
))
898 result
= PALETTE_UnrealizeObject( obj
, (PALETTEOBJ
*)header
);
902 /* Windows resets the brush origin. We don't need to. */
905 GDI_ReleaseObj( obj
);
910 /***********************************************************************
911 * EnumObjects16 (GDI.71)
913 INT16 WINAPI
EnumObjects16( HDC16 hdc
, INT16 nObjType
,
914 GOBJENUMPROC16 lpEnumFunc
, LPARAM lParam
)
916 /* Solid colors to enumerate */
917 static const COLORREF solid_colors
[] =
918 { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
919 RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
920 RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
921 RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
922 RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
923 RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
924 RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
925 RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
930 LOGBRUSH16
*brush
= NULL
;
932 TRACE("%04x %d %08lx %08lx\n",
933 hdc
, nObjType
, (DWORD
)lpEnumFunc
, lParam
);
937 /* Enumerate solid pens */
938 if (!(pen
= SEGPTR_NEW(LOGPEN16
))) break;
939 for (i
= 0; i
< sizeof(solid_colors
)/sizeof(solid_colors
[0]); i
++)
941 pen
->lopnStyle
= PS_SOLID
;
942 pen
->lopnWidth
.x
= 1;
943 pen
->lopnWidth
.y
= 0;
944 pen
->lopnColor
= solid_colors
[i
];
945 retval
= lpEnumFunc( SEGPTR_GET(pen
), lParam
);
946 TRACE("solid pen %08lx, ret=%d\n",
947 solid_colors
[i
], retval
);
954 /* Enumerate solid brushes */
955 if (!(brush
= SEGPTR_NEW(LOGBRUSH16
))) break;
956 for (i
= 0; i
< sizeof(solid_colors
)/sizeof(solid_colors
[0]); i
++)
958 brush
->lbStyle
= BS_SOLID
;
959 brush
->lbColor
= solid_colors
[i
];
961 retval
= lpEnumFunc( SEGPTR_GET(brush
), lParam
);
962 TRACE("solid brush %08lx, ret=%d\n",
963 solid_colors
[i
], retval
);
967 /* Now enumerate hatched brushes */
968 if (retval
) for (i
= HS_HORIZONTAL
; i
<= HS_DIAGCROSS
; i
++)
970 brush
->lbStyle
= BS_HATCHED
;
971 brush
->lbColor
= RGB(0,0,0);
973 retval
= lpEnumFunc( SEGPTR_GET(brush
), lParam
);
974 TRACE("hatched brush %d, ret=%d\n",
982 WARN("(%d): Invalid type\n", nObjType
);
989 /***********************************************************************
990 * EnumObjects (GDI32.@)
992 INT WINAPI
EnumObjects( HDC hdc
, INT nObjType
,
993 GOBJENUMPROC lpEnumFunc
, LPARAM lParam
)
995 /* Solid colors to enumerate */
996 static const COLORREF solid_colors
[] =
997 { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
998 RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
999 RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
1000 RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
1001 RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
1002 RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
1003 RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
1004 RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
1011 TRACE("%04x %d %08lx %08lx\n",
1012 hdc
, nObjType
, (DWORD
)lpEnumFunc
, lParam
);
1016 /* Enumerate solid pens */
1017 for (i
= 0; i
< sizeof(solid_colors
)/sizeof(solid_colors
[0]); i
++)
1019 pen
.lopnStyle
= PS_SOLID
;
1020 pen
.lopnWidth
.x
= 1;
1021 pen
.lopnWidth
.y
= 0;
1022 pen
.lopnColor
= solid_colors
[i
];
1023 retval
= lpEnumFunc( &pen
, lParam
);
1024 TRACE("solid pen %08lx, ret=%d\n",
1025 solid_colors
[i
], retval
);
1031 /* Enumerate solid brushes */
1032 for (i
= 0; i
< sizeof(solid_colors
)/sizeof(solid_colors
[0]); i
++)
1034 brush
.lbStyle
= BS_SOLID
;
1035 brush
.lbColor
= solid_colors
[i
];
1037 retval
= lpEnumFunc( &brush
, lParam
);
1038 TRACE("solid brush %08lx, ret=%d\n",
1039 solid_colors
[i
], retval
);
1043 /* Now enumerate hatched brushes */
1044 if (retval
) for (i
= HS_HORIZONTAL
; i
<= HS_DIAGCROSS
; i
++)
1046 brush
.lbStyle
= BS_HATCHED
;
1047 brush
.lbColor
= RGB(0,0,0);
1049 retval
= lpEnumFunc( &brush
, lParam
);
1050 TRACE("hatched brush %d, ret=%d\n",
1057 /* FIXME: implement Win32 types */
1058 WARN("(%d): Invalid type\n", nObjType
);
1065 /***********************************************************************
1066 * IsGDIObject (GDI.462)
1068 * returns type of object if valid (W95 system programming secrets p. 264-5)
1070 BOOL16 WINAPI
IsGDIObject16( HGDIOBJ16 handle
)
1074 GDIOBJHDR
*object
= GDI_GetObjPtr( handle
, MAGIC_DONTCARE
);
1077 magic
= GDIMAGIC(object
->wMagic
) - PEN_MAGIC
+ 1;
1078 GDI_ReleaseObj( handle
);
1084 /***********************************************************************
1085 * SetObjectOwner16 (GDI.461)
1087 void WINAPI
SetObjectOwner16( HGDIOBJ16 handle
, HANDLE16 owner
)
1093 /***********************************************************************
1094 * SetObjectOwner (GDI32.@)
1096 void WINAPI
SetObjectOwner( HGDIOBJ handle
, HANDLE owner
)
1102 /***********************************************************************
1103 * MakeObjectPrivate (GDI.463)
1105 * What does that mean ?
1106 * Some little docu can be found in "Undocumented Windows",
1107 * but this is basically useless.
1108 * At least we know that this flags the GDI object's wMagic
1109 * with 0x2000 (OBJECT_PRIVATE), so we just do it.
1110 * But Wine doesn't react on that yet.
1112 void WINAPI
MakeObjectPrivate16( HGDIOBJ16 handle
, BOOL16
private )
1114 GDIOBJHDR
*ptr
= GDI_GetObjPtr( handle
, MAGIC_DONTCARE
);
1117 ERR("invalid GDI object %04x !\n", handle
);
1120 ptr
->wMagic
|= OBJECT_PRIVATE
;
1121 GDI_ReleaseObj( handle
);
1125 /***********************************************************************
1126 * GdiFlush (GDI32.@)
1128 BOOL WINAPI
GdiFlush(void)
1130 return TRUE
; /* FIXME */
1134 /***********************************************************************
1135 * GdiGetBatchLimit (GDI32.@)
1137 DWORD WINAPI
GdiGetBatchLimit(void)
1139 return 1; /* FIXME */
1143 /***********************************************************************
1144 * GdiSetBatchLimit (GDI32.@)
1146 DWORD WINAPI
GdiSetBatchLimit( DWORD limit
)
1148 return 1; /* FIXME */
1152 /***********************************************************************
1153 * GdiSeeGdiDo (GDI.452)
1155 DWORD WINAPI
GdiSeeGdiDo16( WORD wReqType
, WORD wParam1
, WORD wParam2
,
1160 case 0x0001: /* LocalAlloc */
1161 return LOCAL_Alloc( GDI_HeapSel
, wParam1
, wParam3
);
1162 case 0x0002: /* LocalFree */
1163 return LOCAL_Free( GDI_HeapSel
, wParam1
);
1164 case 0x0003: /* LocalCompact */
1165 return LOCAL_Compact( GDI_HeapSel
, wParam3
, 0 );
1166 case 0x0103: /* LocalHeap */
1169 WARN("(wReqType=%04x): Unknown\n", wReqType
);
1174 /***********************************************************************
1175 * GdiSignalProc (GDI.610)
1177 WORD WINAPI
GdiSignalProc( UINT uCode
, DWORD dwThreadOrProcessID
,
1178 DWORD dwFlags
, HMODULE16 hModule
)
1183 /***********************************************************************
1184 * FinalGdiInit16 (GDI.405)
1186 void WINAPI
FinalGdiInit16( HANDLE16 unknown
)
1190 /***********************************************************************
1191 * GdiFreeResources (GDI.609)
1193 WORD WINAPI
GdiFreeResources16( DWORD reserve
)
1195 return (WORD
)( (int)LOCAL_CountFree( GDI_HeapSel
) * 100 /
1196 (int)LOCAL_HeapSize( GDI_HeapSel
) );
1199 /***********************************************************************
1200 * MulDiv16 (GDI.128)
1202 INT16 WINAPI
MulDiv16(
1203 INT16 nMultiplicand
,
1208 if (!nDivisor
) return -32768;
1209 /* We want to deal with a positive divisor to simplify the logic. */
1212 nMultiplicand
= - nMultiplicand
;
1213 nDivisor
= -nDivisor
;
1215 /* If the result is positive, we "add" to round. else,
1216 * we subtract to round. */
1217 if ( ( (nMultiplicand
< 0) && (nMultiplier
< 0) ) ||
1218 ( (nMultiplicand
>= 0) && (nMultiplier
>= 0) ) )
1219 ret
= (((int)nMultiplicand
* nMultiplier
) + (nDivisor
/2)) / nDivisor
;
1221 ret
= (((int)nMultiplicand
* nMultiplier
) - (nDivisor
/2)) / nDivisor
;
1222 if ((ret
> 32767) || (ret
< -32767)) return -32768;
1227 /*******************************************************************
1228 * GetColorAdjustment [GDI32.@]
1232 BOOL WINAPI
GetColorAdjustment(HDC hdc
, LPCOLORADJUSTMENT lpca
)
1234 FIXME("GetColorAdjustment, stub\n");
1238 /*******************************************************************
1239 * GetMiterLimit [GDI32.@]
1243 BOOL WINAPI
GetMiterLimit(HDC hdc
, PFLOAT peLimit
)
1245 FIXME("GetMiterLimit, stub\n");
1249 /*******************************************************************
1250 * SetMiterLimit [GDI32.@]
1254 BOOL WINAPI
SetMiterLimit(HDC hdc
, FLOAT eNewLimit
, PFLOAT peOldLimit
)
1256 FIXME("SetMiterLimit, stub\n");
1260 /*******************************************************************
1261 * GdiComment [GDI32.@]
1265 BOOL WINAPI
GdiComment(HDC hdc
, UINT cbSize
, const BYTE
*lpData
)
1267 FIXME("GdiComment, stub\n");
1270 /*******************************************************************
1271 * SetColorAdjustment [GDI32.@]
1275 BOOL WINAPI
SetColorAdjustment(HDC hdc
, const COLORADJUSTMENT
* lpca
)
1277 FIXME("SetColorAdjustment, stub\n");