source: trunk/src/gdi32/gdi32.cpp@ 2592

Last change on this file since 2592 was 2592, checked in by sandervl, 26 years ago

cleaned up + dibsection fixes
File size: 87.9 KB
Line 
1/* $Id: gdi32.cpp,v 1.37 2000-02-01 12:53:30 sandervl Exp $ */
2
3/*
4 * GDI32 apis
5 *
6 * Copyright 1998 Sander van Leeuwen (sandervl@xs4all.nl)
7 * Copyright 1998 Patrick Haller
8 *
9 * Project Odin Software License can be found in LICENSE.TXT
10 *
11 */
12#include <os2win.h>
13#include <stdlib.h>
14#include <stdarg.h>
15#include <string.h>
16#include "misc.h"
17#include "callback.h"
18#include "unicode.h"
19#include "dibsect.h"
20#include <codepage.h>
21#include "oslibgpi.h"
22#include "oslibgdi.h"
23
24//******************************************************************************
25//******************************************************************************
26BOOL WIN32API GetTextExtentPointA(HDC hdc, LPCSTR lpsz, int cbString, LPSIZE lpSize)
27{
28 BOOL rc;
29
30 lpSize->cx = lpSize->cy = 0;
31 rc = O32_GetTextExtentPoint(hdc, lpsz, cbString, lpSize);
32 dprintf(("GDI32: GetTextExtentPointA of %s returned %d\n", lpsz, rc));
33 return(rc);
34}
35//******************************************************************************
36//******************************************************************************
37COLORREF WIN32API SetBkColor(HDC hdc, COLORREF crColor)
38{
39 dprintf(("GDI32: SetBkColor to %X\n", crColor));
40 return(O32_SetBkColor(hdc, crColor));
41}
42//******************************************************************************
43//******************************************************************************
44COLORREF WIN32API SetTextColor(HDC hdc, COLORREF crColor)
45{
46 COLORREF clr;
47
48 clr = O32_SetTextColor(hdc, crColor);
49 dprintf(("GDI32: SetTextColor from %X to %X\n", clr, crColor));
50 return(clr);
51}
52//******************************************************************************
53//******************************************************************************
54
55static hFntDefaultGui = NULL;
56HGDIOBJ WIN32API GetStockObject(int arg1)
57{
58 HGDIOBJ obj;
59
60 switch(arg1)
61 {
62 case DEFAULT_GUI_FONT:
63 if(NULL==hFntDefaultGui)
64 hFntDefaultGui = CreateFontA( 9, 0, 0, 0, FW_MEDIUM, FALSE,
65 FALSE, FALSE, ANSI_CHARSET,
66 OUT_DEFAULT_PRECIS,
67 CLIP_DEFAULT_PRECIS,
68 DEFAULT_QUALITY,
69 FIXED_PITCH|FF_MODERN, "WarpSans");
70 obj = hFntDefaultGui;
71 break;
72 default:
73 obj = O32_GetStockObject(arg1);
74 break;
75 }
76 dprintf(("GDI32: GetStockObject %d returned %X\n", arg1, obj));
77 return(obj);
78}
79//******************************************************************************
80//******************************************************************************
81int WIN32API GetObjectA( HGDIOBJ hObject, int size, void *lpBuffer)
82{
83 int rc;
84
85 if(size == 0 || lpBuffer == NULL) {
86 SetLastError(ERROR_INVALID_PARAMETER);
87 return 0;
88 }
89
90 if(DIBSection::getSection() != NULL)
91 {
92 DIBSection *dsect = DIBSection::find(hObject);
93 if(dsect)
94 {
95 rc = dsect->GetDIBSection(size, lpBuffer);
96 if(rc == 0) {
97 SetLastError(ERROR_INVALID_PARAMETER);
98 return 0;
99 }
100 SetLastError(ERROR_SUCCESS);
101 return rc;
102 }
103 }
104
105 dprintf(("GDI32: GetObject %X %X %X\n", hObject, size, lpBuffer));
106 return O32_GetObject(hObject, size, lpBuffer);
107}
108//******************************************************************************
109//******************************************************************************
110int WIN32API GetObjectW( HGDIOBJ arg1, int arg2, void * arg3)
111{
112 dprintf(("GDI32: GetObjectW %X, %d %X not complete!", arg1, arg2, arg3));
113 return GetObjectA(arg1, arg2, arg3);
114}
115//******************************************************************************
116//******************************************************************************
117DWORD WIN32API GetObjectType( HGDIOBJ arg1)
118{
119 dprintf2(("GDI32: GetObjectType\n"));
120 return O32_GetObjectType(arg1);
121}
122//******************************************************************************
123//******************************************************************************
124BOOL WIN32API DeleteObject(HANDLE hObj)
125{
126 dprintf(("GDI32: DeleteObject %x", hObj));
127 DIBSection::deleteSection((DWORD)hObj);
128 return O32_DeleteObject(hObj);
129}
130//******************************************************************************
131//******************************************************************************
132BOOL WIN32API DeleteDC( HDC hdc)
133{
134 dprintf(("GDI32: DeleteDC %x", hdc));
135 return O32_DeleteDC(hdc);
136}
137//******************************************************************************
138//******************************************************************************
139HBRUSH WIN32API CreatePatternBrush(HBITMAP arg1)
140{
141 HBRUSH brush;
142
143 brush = O32_CreatePatternBrush(arg1);
144 dprintf(("GDI32: CreatePatternBrush from bitmap %X returned %X\n", arg1, brush));
145 return(brush);
146}
147//******************************************************************************
148//******************************************************************************
149HPEN WIN32API CreatePen( int arg1, int arg2, COLORREF arg3)
150{
151 dprintf(("GDI32: CreatePen\n"));
152 return O32_CreatePen(arg1, arg2, arg3);
153}
154//******************************************************************************
155//******************************************************************************
156HPEN WIN32API CreatePenIndirect( const LOGPEN * arg1)
157{
158 dprintf(("GDI32: CreatePenIndirect\n"));
159 return O32_CreatePenIndirect(arg1);
160}
161//******************************************************************************
162//******************************************************************************
163HBRUSH WIN32API CreateDIBPatternBrushPt( const VOID * arg1, UINT arg2)
164{
165 dprintf(("GDI32: CreateDIBPatternBrushPt\n"));
166 return O32_CreateDIBPatternBrushPt(arg1, arg2);
167}
168//******************************************************************************
169//******************************************************************************
170HDC WIN32API CreateCompatibleDC( HDC hdc)
171{
172 HDC newHdc;
173
174 newHdc = O32_CreateCompatibleDC(hdc);
175 ULONG oldcp = OSLibGpiQueryCp(hdc);
176 if (!oldcp) /* If new DC is to be created */
177 oldcp = GetDisplayCodepage();
178
179 OSLibGpiSetCp(newHdc, oldcp);
180 dprintf(("CreateCompatibleDC %X returned %x", hdc, newHdc));
181 return newHdc;
182}
183//******************************************************************************
184//******************************************************************************
185INT WIN32API StretchDIBits(HDC hdc, INT xDst, INT yDst, INT widthDst,
186 INT heightDst, INT xSrc, INT ySrc, INT widthSrc,
187 INT heightSrc, const void *bits,
188 const BITMAPINFO *info, UINT wUsage, DWORD dwRop )
189{
190#if 1
191 dprintf(("GDI32: StretchDIBits %x to (%d,%d) (%d,%d) from (%d,%d) (%d,%d), %x %x %x %x", hdc, xDst, yDst, widthDst, heightDst, xSrc, ySrc, widthSrc, heightSrc, bits, info, wUsage, dwRop));
192
193 if(wUsage == DIB_PAL_COLORS && info->bmiHeader.biSize == sizeof(BITMAPINFOHEADER))
194 {
195 // workaround for open32 bug.
196 // If syscolors > 256 and wUsage == DIB_PAL_COLORS.
197
198 int i;
199 USHORT *pColorIndex = (USHORT *)info->bmiColors;
200 RGBQUAD *pColors = (RGBQUAD *) alloca(info->bmiHeader.biClrUsed *
201 sizeof(RGBQUAD));
202 BITMAPINFO *infoLoc = (BITMAPINFO *) alloca(sizeof(BITMAPINFO) +
203 info->bmiHeader.biClrUsed * sizeof(RGBQUAD));
204
205 memcpy(infoLoc, info, sizeof(BITMAPINFO));
206
207 if(GetDIBColorTable(hdc, 0, info->bmiHeader.biClrUsed, pColors) == 0)
208 return FALSE;
209
210 for(i=0;i<info->bmiHeader.biClrUsed;i++, pColorIndex++)
211 {
212 infoLoc->bmiColors[i] = pColors[*pColorIndex];
213 }
214
215 return O32_StretchDIBits(hdc, xDst, yDst, widthDst, heightDst, xSrc, ySrc,
216 widthSrc, heightSrc, (void *)bits,
217 (PBITMAPINFO)infoLoc, DIB_RGB_COLORS, dwRop);
218 }
219
220 return O32_StretchDIBits(hdc, xDst, yDst, widthDst, heightDst, xSrc, ySrc,
221 widthSrc, heightSrc, (void *)bits,
222 (PBITMAPINFO)info, wUsage, dwRop);
223#else
224 dprintf(("GDI32: StretchDIBits\n"));
225 return O32_StretchDIBits(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, (void *)arg10, (PBITMAPINFO)arg11, arg12, arg13);
226#endif
227}
228//******************************************************************************
229//******************************************************************************
230BOOL WIN32API StrokeAndFillPath( HDC arg1)
231{
232 dprintf(("GDI32: StrokeAndFillPath\n"));
233 return O32_StrokeAndFillPath(arg1);
234}
235//******************************************************************************
236//******************************************************************************
237BOOL WIN32API StrokePath( HDC arg1)
238{
239 dprintf(("GDI32: StrokePath\n"));
240 return O32_StrokePath(arg1);
241}
242//******************************************************************************
243//******************************************************************************
244HGDIOBJ WIN32API SelectObject(HDC hdc, HGDIOBJ hObj)
245{
246 HGDIOBJ rc;
247
248 dprintf2(("GDI32: SelectObject %x %x", hdc, hObj));
249
250 if(DIBSection::getSection() != NULL)
251 {
252 DIBSection *dsect;
253
254 dsect = DIBSection::find(hdc);
255 if(dsect)
256 {
257 //remove previously selected dibsection
258 dsect->UnSelectDIBObject();
259 }
260 dsect = DIBSection::find((DWORD)hObj);
261 if(dsect)
262 {
263 dsect->SelectDIBObject(hdc);
264 }
265 }
266 rc = O32_SelectObject(hdc, hObj);
267 if(rc != 0 && DIBSection::getSection != NULL)
268 {
269 DIBSection *dsect = DIBSection::find((DWORD)rc);
270 if(dsect)
271 {
272 dsect->UnSelectDIBObject();
273 }
274 }
275 return(rc);
276}
277//******************************************************************************
278//******************************************************************************
279int WIN32API SetBkMode( HDC arg1, int arg2)
280{
281 dprintf(("GDI32: SetBkMode\n"));
282 return O32_SetBkMode(arg1, arg2);
283}
284//******************************************************************************
285//******************************************************************************
286COLORREF WIN32API GetPixel( HDC arg1, int arg2, int arg3)
287{
288//// dprintf(("GDI32: GetPixel\n"));
289 return O32_GetPixel(arg1, arg2, arg3);
290}
291//******************************************************************************
292//******************************************************************************
293COLORREF WIN32API SetPixel( HDC arg1, int arg2, int arg3, COLORREF arg4)
294{
295//// dprintf(("GDI32: SetPixel\n"));
296 return O32_SetPixel(arg1, arg2, arg3, arg4);
297}
298//******************************************************************************
299//Faster version of SetPixel (since it doesn't need to return the original color)
300//Just use SetPixel for now
301//******************************************************************************
302BOOL WIN32API SetPixelV(HDC arg1, int arg2, int arg3, COLORREF arg4)
303{
304 COLORREF rc;
305
306//// dprintf(("GDI32: SetPixelV\n"));
307 rc = O32_SetPixel(arg1, arg2, arg3, arg4);
308 if(rc == GDI_ERROR) // || rc == COLOR_INVALID)
309 return(FALSE);
310 return(TRUE);
311}
312//******************************************************************************
313//******************************************************************************
314BOOL WIN32API GetDCOrgEx(HDC arg1, PPOINT arg2)
315{
316 dprintf(("GDI32: GetDCOrgEx\n"));
317 return O32_GetDCOrgEx(arg1, arg2);
318}
319//******************************************************************************
320//******************************************************************************
321BOOL WIN32API GetWindowExtEx(HDC arg1, PSIZE arg2)
322{
323 dprintf(("GDI32: GetWindowExtEx\n"));
324 return O32_GetWindowExtEx(arg1, arg2);
325}
326//******************************************************************************
327//******************************************************************************
328int WIN32API AbortDoc( HDC arg1)
329{
330 dprintf(("GDI32: AbortDoc"));
331 return O32_AbortDoc(arg1);
332}
333//******************************************************************************
334//******************************************************************************
335BOOL WIN32API AbortPath( HDC arg1)
336{
337 dprintf(("GDI32: AbortPath"));
338 return O32_AbortPath(arg1);
339}
340//******************************************************************************
341//******************************************************************************
342BOOL WIN32API AngleArc( HDC arg1, int arg2, int arg3, DWORD arg4, float arg5, float arg6)
343{
344 dprintf(("GDI32: AngleArc"));
345 return O32_AngleArc(arg1, arg2, arg3, arg4, arg5, arg6);
346}
347//******************************************************************************
348//******************************************************************************
349BOOL WIN32API Arc( HDC arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9)
350{
351 dprintf(("GDI32: Arc"));
352 return O32_Arc(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
353}
354//******************************************************************************
355//******************************************************************************
356BOOL WIN32API ArcTo( HDC arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9)
357{
358 dprintf(("GDI32: ArcTo"));
359 return O32_ArcTo(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
360}
361//******************************************************************************
362//******************************************************************************
363BOOL WIN32API BeginPath( HDC arg1)
364{
365 dprintf(("GDI32: BeginPath"));
366 return O32_BeginPath(arg1);
367}
368//******************************************************************************
369//******************************************************************************
370BOOL WIN32API Chord( HDC arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9)
371{
372 dprintf(("GDI32: Chord"));
373 return O32_Chord(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
374}
375//******************************************************************************
376//******************************************************************************
377BOOL WIN32API CloseFigure( HDC arg1)
378{
379 dprintf(("GDI32: CloseFigure"));
380 return O32_CloseFigure(arg1);
381}
382//******************************************************************************
383//******************************************************************************
384HBRUSH WIN32API CreateBrushIndirect( const LOGBRUSH * arg1)
385{
386 dprintf(("GDI32: CreateBrushIndirect"));
387 return O32_CreateBrushIndirect((LPLOGBRUSH)arg1);
388}
389//******************************************************************************
390//******************************************************************************
391HDC WIN32API CreateDCA(LPCSTR lpszDriver, LPCSTR lpszDevice, LPCSTR lpszOutput, const DEVMODEA *lpInitData)
392{
393 HDC hdc;
394
395 hdc = O32_CreateDC(lpszDriver, lpszDevice, lpszOutput, lpInitData);
396 dprintf(("GDI32: CreateDCA %s %s %s %x returned %x", lpszDriver, lpszDevice, lpszOutput, lpInitData, hdc));
397 return hdc;
398}
399//******************************************************************************
400//******************************************************************************
401HDC WIN32API CreateDCW( LPCWSTR arg1, LPCWSTR arg2, LPCWSTR arg3, const DEVMODEW * arg4)
402{
403 char *astring4, *astring5;
404
405 char *astring1 = UnicodeToAsciiString((LPWSTR)arg1);
406 char *astring2 = UnicodeToAsciiString((LPWSTR)arg2);
407 char *astring3 = UnicodeToAsciiString((LPWSTR)arg3);
408
409 if(arg4)
410 {
411 astring4 = UnicodeToAsciiString((LPWSTR)(arg4->dmDeviceName));
412 astring5 = UnicodeToAsciiString((LPWSTR)(arg4->dmFormName));
413 }
414
415 HDC rc;
416 DEVMODEA devmode;
417
418 dprintf(("GDI32: CreateDCW"));
419
420 if(arg4)
421 {
422 strcpy((char*)devmode.dmDeviceName, astring4);
423 strcpy((char*)devmode.dmFormName, astring5);
424
425 devmode.dmSpecVersion = arg4->dmSpecVersion;
426 devmode.dmDriverVersion = arg4->dmDriverVersion;
427 devmode.dmSize = arg4->dmSize;
428 devmode.dmDriverExtra = arg4->dmDriverExtra;
429 devmode.dmFields = arg4->dmFields;
430 devmode.dmOrientation = arg4->dmOrientation;
431 devmode.dmPaperSize = arg4->dmPaperSize;
432 devmode.dmPaperLength = arg4->dmPaperLength;
433 devmode.dmPaperWidth = arg4->dmPaperWidth;
434 devmode.dmScale = arg4->dmScale;
435 devmode.dmCopies = arg4->dmCopies;
436 devmode.dmDefaultSource = arg4->dmDefaultSource;
437 devmode.dmPrintQuality = arg4->dmPrintQuality;
438 devmode.dmColor = arg4->dmColor;
439 devmode.dmDuplex = arg4->dmDuplex;
440 devmode.dmYResolution = arg4->dmYResolution;
441 devmode.dmTTOption = arg4->dmTTOption;
442 devmode.dmCollate = arg4->dmCollate;
443 devmode.dmLogPixels = arg4->dmLogPixels;
444 devmode.dmBitsPerPel = arg4->dmBitsPerPel;
445 devmode.dmPelsWidth = arg4->dmPelsWidth;
446 devmode.dmPelsHeight = arg4->dmPelsHeight;
447 devmode.dmDisplayFlags = arg4->dmDisplayFlags;
448 devmode.dmDisplayFrequency = arg4->dmDisplayFrequency;
449 devmode.dmICMMethod = arg4->dmICMMethod;
450 devmode.dmICMIntent = arg4->dmICMIntent;
451 devmode.dmMediaType = arg4->dmMediaType;
452 devmode.dmDitherType = arg4->dmDitherType;
453 devmode.dmReserved1 = arg4->dmReserved1;
454 devmode.dmReserved2 = arg4->dmReserved2;
455 rc = O32_CreateDC(astring1,astring2,astring3,&devmode);
456 }
457 else
458 rc = O32_CreateDC(astring1,astring2,astring3, NULL);
459
460 FreeAsciiString(astring1);
461 FreeAsciiString(astring2);
462 FreeAsciiString(astring3);
463
464 if(arg4)
465 {
466 FreeAsciiString(astring4);
467 FreeAsciiString(astring5);
468 }
469
470 return rc;
471}
472//******************************************************************************
473//******************************************************************************
474HBRUSH WIN32API CreateHatchBrush( int arg1, COLORREF arg2)
475{
476 dprintf(("GDI32: CreateHatchBrush"));
477 return O32_CreateHatchBrush(arg1, arg2);
478}
479//******************************************************************************
480//******************************************************************************
481HDC WIN32API CreateICA( LPCSTR arg1, LPCSTR arg2, LPCSTR arg3, const DEVMODEA * arg4)
482{
483 dprintf(("GDI32: CreateICA"));
484 return O32_CreateIC(arg1, arg2, arg3, arg4);
485}
486//******************************************************************************
487//******************************************************************************
488HDC WIN32API CreateICW( LPCWSTR arg1, LPCWSTR arg2, LPCWSTR arg3, const DEVMODEW * arg4)
489{
490 char *astring4, *astring5;
491
492 char *astring1 = UnicodeToAsciiString((LPWSTR)arg1);
493 char *astring2 = UnicodeToAsciiString((LPWSTR)arg2);
494 char *astring3 = UnicodeToAsciiString((LPWSTR)arg3);
495 if(arg4)
496 {
497 astring4 = UnicodeToAsciiString((LPWSTR)(arg4->dmDeviceName));
498 astring5 = UnicodeToAsciiString((LPWSTR)(arg4->dmFormName));
499 }
500
501 HDC rc;
502 DEVMODEA devmode;
503
504 dprintf(("GDI32: CreateICW"));
505
506 if(arg4)
507 {
508 strcpy((char*)devmode.dmDeviceName, astring4);
509 strcpy((char*)devmode.dmFormName, astring5);
510
511 devmode.dmSpecVersion = arg4->dmSpecVersion;
512 devmode.dmDriverVersion = arg4->dmDriverVersion;
513 devmode.dmSize = arg4->dmSize;
514 devmode.dmDriverExtra = arg4->dmDriverExtra;
515 devmode.dmFields = arg4->dmFields;
516 devmode.dmOrientation = arg4->dmOrientation;
517 devmode.dmPaperSize = arg4->dmPaperSize;
518 devmode.dmPaperLength = arg4->dmPaperLength;
519 devmode.dmPaperWidth = arg4->dmPaperWidth;
520 devmode.dmScale = arg4->dmScale;
521 devmode.dmCopies = arg4->dmCopies;
522 devmode.dmDefaultSource = arg4->dmDefaultSource;
523 devmode.dmPrintQuality = arg4->dmPrintQuality;
524 devmode.dmColor = arg4->dmColor;
525 devmode.dmDuplex = arg4->dmDuplex;
526 devmode.dmYResolution = arg4->dmYResolution;
527 devmode.dmTTOption = arg4->dmTTOption;
528 devmode.dmCollate = arg4->dmCollate;
529 devmode.dmLogPixels = arg4->dmLogPixels;
530 devmode.dmBitsPerPel = arg4->dmBitsPerPel;
531 devmode.dmPelsWidth = arg4->dmPelsWidth;
532 devmode.dmPelsHeight = arg4->dmPelsHeight;
533 devmode.dmDisplayFlags = arg4->dmDisplayFlags;
534 devmode.dmDisplayFrequency = arg4->dmDisplayFrequency;
535 devmode.dmICMMethod = arg4->dmICMMethod;
536 devmode.dmICMIntent = arg4->dmICMIntent;
537 devmode.dmMediaType = arg4->dmMediaType;
538 devmode.dmDitherType = arg4->dmDitherType;
539 devmode.dmReserved1 = arg4->dmReserved1;
540 devmode.dmReserved2 = arg4->dmReserved2;
541
542 rc = O32_CreateIC(astring1,astring2,astring3,&devmode);
543 }
544 else
545 rc = O32_CreateIC(astring1,astring2,astring3, NULL);
546
547 FreeAsciiString(astring1);
548 FreeAsciiString(astring2);
549 FreeAsciiString(astring3);
550 if(arg4)
551 {
552 FreeAsciiString(astring4);
553 FreeAsciiString(astring5);
554 }
555
556 return rc;
557}
558//******************************************************************************
559//******************************************************************************
560HBRUSH WIN32API CreateSolidBrush( COLORREF arg1)
561{
562 dprintf(("GDI32: CreateSolidBrush\n"));
563 return O32_CreateSolidBrush(arg1);
564}
565//******************************************************************************
566//******************************************************************************
567BOOL WIN32API DPtoLP( HDC arg1, PPOINT arg2, int arg3)
568{
569 dprintf(("GDI32: DPtoLP\n"));
570 return O32_DPtoLP(arg1, arg2, arg3);
571}
572//******************************************************************************
573//******************************************************************************
574BOOL WIN32API Ellipse( HDC arg1, int arg2, int arg3, int arg4, int arg5)
575{
576 dprintf(("GDI32: Ellipse"));
577 return O32_Ellipse(arg1, arg2, arg3, arg4, arg5);
578}
579//******************************************************************************
580//******************************************************************************
581int WIN32API EndDoc( HDC arg1)
582{
583 dprintf(("GDI32: EndDoc"));
584 return O32_EndDoc(arg1);
585}
586//******************************************************************************
587//******************************************************************************
588int WIN32API EndPage( HDC arg1)
589{
590 dprintf(("GDI32: EndPage"));
591 return O32_EndPage(arg1);
592}
593//******************************************************************************
594//******************************************************************************
595BOOL WIN32API EndPath( HDC arg1)
596{
597 dprintf(("GDI32: EndPath"));
598 return O32_EndPath(arg1);
599}
600//******************************************************************************
601//******************************************************************************
602BOOL WIN32API Rectangle( HDC arg1, int arg2, int arg3, int arg4, int arg5)
603{
604 dprintf(("GDI32: Rectangle\n"));
605 return O32_Rectangle(arg1, arg2, arg3, arg4, arg5);
606}
607//******************************************************************************
608//******************************************************************************
609int WIN32API SetROP2( HDC hdc, int rop2)
610{
611 dprintf(("GDI32: SetROP2 %x %x", hdc, rop2));
612 return O32_SetROP2(hdc, rop2);
613}
614//******************************************************************************
615//******************************************************************************
616int WIN32API EnumObjects( HDC arg1, int arg2, GOBJENUMPROC arg3, LPARAM arg4)
617{
618 dprintf(("GDI32: EnumObjects STUB"));
619 //calling convention differences
620// return O32_EnumObjects(arg1, arg2, arg3, arg4);
621 return 0;
622}
623//******************************************************************************
624//******************************************************************************
625int WIN32API Escape( HDC arg1, int arg2, int arg3, LPCSTR arg4, PVOID arg5)
626{
627 dprintf(("GDI32: Escape"));
628 return O32_Escape(arg1, arg2, arg3, arg4, arg5);
629}
630//******************************************************************************
631//******************************************************************************
632int WIN32API ExcludeClipRect( HDC arg1, int arg2, int arg3, int arg4, int arg5)
633{
634 dprintf(("GDI32: ExcludeClipRect"));
635 return O32_ExcludeClipRect(arg1, arg2, arg3, arg4, arg5);
636}
637//******************************************************************************
638//******************************************************************************
639HPEN WIN32API ExtCreatePen( DWORD arg1, DWORD arg2, const LOGBRUSH * arg3, DWORD arg4, const DWORD * arg5)
640{
641 dprintf(("GDI32: ExtCreatePen"));
642 return O32_ExtCreatePen(arg1, arg2, arg3, arg4, arg5);
643}
644//******************************************************************************
645//******************************************************************************
646BOOL WIN32API ExtFloodFill( HDC arg1, int arg2, int arg3, COLORREF arg4, UINT arg5)
647{
648 dprintf(("GDI32: ExtFloodFill"));
649 return O32_ExtFloodFill(arg1, arg2, arg3, arg4, arg5);
650}
651//******************************************************************************
652//******************************************************************************
653BOOL WIN32API FillPath( HDC arg1)
654{
655 dprintf(("GDI32: FillPath"));
656 return O32_FillPath(arg1);
657}
658//******************************************************************************
659//******************************************************************************
660BOOL WIN32API FlattenPath( HDC arg1)
661{
662 dprintf(("GDI32: FlattenPath"));
663 return O32_FlattenPath(arg1);
664}
665//******************************************************************************
666//******************************************************************************
667BOOL WIN32API FloodFill(HDC arg1, int arg2, int arg3, COLORREF arg4)
668{
669 dprintf(("GDI32: FloodFill"));
670 return O32_FloodFill(arg1, arg2, arg3, arg4);
671}
672//******************************************************************************
673//******************************************************************************
674int WIN32API GetArcDirection( HDC arg1)
675{
676 dprintf(("GDI32: GetArcDirection"));
677 return O32_GetArcDirection(arg1);
678}
679//******************************************************************************
680//******************************************************************************
681BOOL WIN32API GetAspectRatioFilterEx( HDC arg1, PSIZE arg2)
682{
683 dprintf(("GDI32: GetAspectRatioFilterEx"));
684 return O32_GetAspectRatioFilterEx(arg1, arg2);
685}
686//******************************************************************************
687//******************************************************************************
688COLORREF WIN32API GetBkColor( HDC arg1)
689{
690 dprintf(("GDI32: GetBkColor"));
691 return O32_GetBkColor(arg1);
692}
693//******************************************************************************
694//******************************************************************************
695int WIN32API GetBkMode( HDC arg1)
696{
697 dprintf(("GDI32: GetBkMode"));
698 return O32_GetBkMode(arg1);
699}
700//******************************************************************************
701//******************************************************************************
702UINT WIN32API GetBoundsRect( HDC arg1, PRECT arg2, UINT arg3)
703{
704 dprintf(("GDI32: GetBoundsRect"));
705 return O32_GetBoundsRect(arg1, arg2, arg3);
706}
707//******************************************************************************
708//******************************************************************************
709BOOL WIN32API GetBrushOrgEx( HDC arg1, PPOINT arg2)
710{
711 dprintf(("GDI32: GetBrushOrgEx"));
712 return O32_GetBrushOrgEx(arg1, arg2);
713}
714//******************************************************************************
715//******************************************************************************
716BOOL WIN32API GetCharABCWidthsA( HDC arg1, UINT arg2, UINT arg3, LPABC arg4)
717{
718 dprintf(("GDI32: GetCharABCWidthsA"));
719 return O32_GetCharABCWidths(arg1, arg2, arg3, arg4);
720}
721//******************************************************************************
722//******************************************************************************
723BOOL WIN32API GetCharABCWidthsW( HDC arg1, UINT arg2, UINT arg3, LPABC arg4)
724{
725 dprintf(("GDI32: GetCharABCWidthsW not properly implemented."));
726 // NOTE: This will not work as is (needs UNICODE support)
727 return O32_GetCharABCWidths(arg1, arg2, arg3, arg4);
728}
729//******************************************************************************
730//******************************************************************************
731BOOL WIN32API GetCharWidthA( HDC arg1, UINT arg2, UINT arg3, PINT arg4)
732{
733 dprintf(("GDI32: GetCharWidthA"));
734 return O32_GetCharWidth(arg1, arg2, arg3, arg4);
735}
736//******************************************************************************
737//TODO: Cut off Unicode chars?
738//******************************************************************************
739BOOL WIN32API GetCharWidthW(HDC arg1, UINT iFirstChar, UINT iLastChar, PINT arg4)
740{
741 dprintf(("GDI32: GetCharWidthW, not properly implemented"));
742 return O32_GetCharWidth(arg1, iFirstChar, iLastChar, arg4);
743}
744//******************************************************************************
745//******************************************************************************
746int WIN32API GetClipBox( HDC arg1, PRECT arg2)
747{
748 int rc;
749
750 rc = O32_GetClipBox(arg1, arg2);
751 dprintf(("GDI32: GetClipBox of %X returned %d\n", arg1, rc));
752 return(rc);
753}
754//******************************************************************************
755//******************************************************************************
756HANDLE WIN32API GetCurrentObject( HDC hdc, UINT arg2)
757{
758 dprintf(("GDI32: GetCurrentObject %x %x", hdc, arg2));
759 return (HANDLE)O32_GetCurrentObject(hdc, arg2);
760}
761//******************************************************************************
762//******************************************************************************
763BOOL WIN32API GetCurrentPositionEx( HDC arg1, PPOINT arg2)
764{
765 dprintf(("GDI32: GetCurrentPositionEx"));
766 return O32_GetCurrentPositionEx(arg1, arg2);
767}
768//******************************************************************************
769//******************************************************************************
770int WIN32API GetDeviceCaps(HDC hdc, int nIndex)
771{
772 int rc;
773
774 rc = O32_GetDeviceCaps(hdc, nIndex);
775 dprintf(("GDI32: GetDeviceCaps %X, %d returned %d\n", hdc, nIndex, rc));
776 //SvL: 13-9-'98: NT returns -1 when using 16 bits colors, NOT 65536!
777 if(nIndex == NUMCOLORS && rc > 256)
778 return -1;
779 return(rc);
780}
781//******************************************************************************
782//******************************************************************************
783int WIN32API GetGraphicsMode(HDC arg1)
784{
785 dprintf(("GDI32: GetGraphicsMode"));
786 return O32_GetGraphicsMode(arg1);
787}
788//******************************************************************************
789//******************************************************************************
790DWORD WIN32API GetKerningPairsA( HDC arg1, DWORD arg2, LPKERNINGPAIR arg3)
791{
792 dprintf(("GDI32: GetKerningPairsA"));
793 return O32_GetKerningPairs(arg1, arg2, arg3);
794}
795//******************************************************************************
796//******************************************************************************
797DWORD WIN32API GetKerningPairsW( HDC arg1, DWORD arg2, LPKERNINGPAIR arg3)
798{
799 dprintf(("GDI32: GetKerningPairsW"));
800 // NOTE: This will not work as is (needs UNICODE support)
801 return O32_GetKerningPairs(arg1, arg2, arg3);
802}
803//******************************************************************************
804//******************************************************************************
805int WIN32API GetMapMode( HDC arg1)
806{
807 dprintf(("GDI32: GetMapMode"));
808 return O32_GetMapMode(arg1);
809}
810//******************************************************************************
811//******************************************************************************
812BOOL WIN32API GetMiterLimit( HDC arg1, float * arg2)
813{
814 dprintf(("GDI32: GetMiterLimit"));
815 return O32_GetMiterLimit(arg1, arg2);
816}
817//******************************************************************************
818//******************************************************************************
819COLORREF WIN32API GetNearestColor( HDC arg1, COLORREF arg2)
820{
821 dprintf(("GDI32: GetNearestColor\n"));
822 return O32_GetNearestColor(arg1, arg2);
823}
824//******************************************************************************
825//******************************************************************************
826UINT WIN32API GetOutlineTextMetricsA( HDC arg1, UINT arg2, LPOUTLINETEXTMETRICA arg3)
827{
828 dprintf(("GDI32: GetOutlineTextMetricsA"));
829 return O32_GetOutlineTextMetrics(arg1, arg2, arg3);
830}
831//******************************************************************************
832//******************************************************************************
833UINT WIN32API GetOutlineTextMetricsW( HDC arg1, UINT arg2, LPOUTLINETEXTMETRICW arg3)
834{
835 dprintf(("GDI32: GetOutlineTextMetricsW STUB"));
836 // NOTE: This will not work as is (needs UNICODE support)
837// return O32_GetOutlineTextMetrics(arg1, arg2, arg3);
838 return 0;
839}
840//******************************************************************************
841//******************************************************************************
842INT WIN32API GetPath( HDC arg1, PPOINT arg2, PBYTE arg3, int arg4)
843{
844 dprintf(("GDI32: GetPath"));
845 return O32_GetPath(arg1, arg2, arg3, arg4);
846}
847//******************************************************************************
848//******************************************************************************
849int WIN32API GetPolyFillMode( HDC arg1)
850{
851 dprintf(("GDI32: GetPolyFillMode"));
852 return O32_GetPolyFillMode(arg1);
853}
854//******************************************************************************
855//******************************************************************************
856int WIN32API GetROP2( HDC arg1)
857{
858 dprintf(("GDI32: GetROP2"));
859 return O32_GetROP2(arg1);
860}
861//******************************************************************************
862//******************************************************************************
863BOOL WIN32API GetRasterizerCaps(LPRASTERIZER_STATUS arg1, UINT arg2)
864{
865 dprintf(("GDI32: GetRasterizerCaps"));
866 return O32_GetRasterizerCaps(arg1, arg2);
867}
868//******************************************************************************
869//******************************************************************************
870UINT WIN32API GetTextAlign( HDC arg1)
871{
872 dprintf(("GDI32: GetTextAlign"));
873 return O32_GetTextAlign(arg1);
874}
875//******************************************************************************
876//******************************************************************************
877int WIN32API GetTextCharacterExtra( HDC arg1)
878{
879 dprintf(("GDI32: GetTextCharacterExtra"));
880 return O32_GetTextCharacterExtra(arg1);
881}
882//******************************************************************************
883//******************************************************************************
884COLORREF WIN32API GetTextColor( HDC arg1)
885{
886 dprintf(("GDI32: GetTextColor"));
887 return O32_GetTextColor(arg1);
888}
889//******************************************************************************
890//******************************************************************************
891BOOL WIN32API GetTextExtentPoint32A( HDC hdc, LPCSTR lpsz, int cbString, PSIZE lpSize)
892{
893 BOOL rc;
894
895 lpSize->cx = lpSize->cy = 0;
896 rc = O32_GetTextExtentPoint32(hdc, lpsz, cbString, lpSize);
897 dprintf(("GDI32: GetTextExtentPoint32A %x %s %d returned %d (%d,%d)", hdc, lpsz, cbString, rc, lpSize->cx, lpSize->cy));
898 return rc;
899}
900//******************************************************************************
901//******************************************************************************
902BOOL WIN32API GetTextExtentPoint32W(HDC arg1, LPCWSTR arg2, int arg3, PSIZE lpSize)
903{
904 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
905 BOOL rc;
906
907 dprintf(("GDI32: GetTextExtentPoint32W %s\n", astring));
908 lpSize->cx = lpSize->cy = 0;
909 rc = O32_GetTextExtentPoint32(arg1, astring, arg3, lpSize);
910 FreeAsciiString(astring);
911 return(rc);
912}
913//******************************************************************************
914//******************************************************************************
915BOOL WIN32API GetTextExtentPointW(HDC hdc,
916 LPCWSTR lpString,
917 int cbString,
918 PSIZE lpSize)
919{
920 char *astring = UnicodeToAsciiString((LPWSTR)lpString);
921 BOOL rc;
922
923 lpSize->cx = lpSize->cy = 0;
924 rc = O32_GetTextExtentPoint(hdc,
925 astring,
926 cbString,
927 lpSize);
928 dprintf(("GDI32: GetTextExtentPointW %X %s (size %08xh) returned %d\n", hdc, astring, cbString, rc));
929 dprintf(("GDI32: GetTextExtentPointW (%d,%d)\n", lpSize->cx, lpSize->cy));
930
931 FreeAsciiString(astring);
932 return(rc);
933}
934//******************************************************************************
935//******************************************************************************
936int WIN32API GetTextFaceA( HDC arg1, int arg2, LPSTR arg3)
937{
938 dprintf(("GDI32: GetTextFaceA"));
939 return O32_GetTextFace(arg1, arg2, arg3);
940}
941//******************************************************************************
942//******************************************************************************
943int WIN32API GetTextFaceW( HDC arg1, int arg2, LPWSTR arg3)
944{
945 char *astring = (char *)malloc(arg2+1);
946 int rc;
947
948 dprintf(("GDI32: GetTextFaceW"));
949 rc = O32_GetTextFace(arg1, arg2, astring);
950 AsciiToUnicode(astring, arg3);
951 free(astring);
952 return rc;
953}
954//******************************************************************************
955//******************************************************************************
956BOOL WIN32API GetTextMetricsA( HDC arg1, LPTEXTMETRICA arg2)
957{
958 BOOL rc;
959
960 rc = O32_GetTextMetrics(arg1, arg2);
961 dprintf(("GDI32: GetTextMetricsA returned %d\n", rc));
962 return(rc);
963}
964//******************************************************************************
965//******************************************************************************
966BOOL WIN32API GetTextMetricsW( HDC arg1, LPTEXTMETRICW pwtm)
967{
968 BOOL rc;
969 TEXTMETRICA atm;
970
971 dprintf(("GDI32: GetTextMetricsW"));
972
973 rc = O32_GetTextMetrics(arg1, &atm);
974 pwtm->tmHeight = atm.tmHeight;
975 pwtm->tmAscent = atm.tmAscent;
976 pwtm->tmDescent = atm.tmDescent;
977 pwtm->tmInternalLeading = atm.tmInternalLeading;
978 pwtm->tmExternalLeading = atm.tmExternalLeading;
979 pwtm->tmAveCharWidth = atm.tmAveCharWidth;
980 pwtm->tmMaxCharWidth = atm.tmMaxCharWidth;
981 pwtm->tmWeight = atm.tmWeight;
982 pwtm->tmOverhang = atm.tmOverhang;
983 pwtm->tmDigitizedAspectX = atm.tmDigitizedAspectX;
984 pwtm->tmDigitizedAspectY = atm.tmDigitizedAspectY;
985 pwtm->tmFirstChar = atm.tmFirstChar;
986 pwtm->tmLastChar = atm.tmLastChar;
987 pwtm->tmDefaultChar = atm.tmDefaultChar;
988 pwtm->tmBreakChar = atm.tmBreakChar;
989 pwtm->tmItalic = atm.tmItalic;
990 pwtm->tmUnderlined = atm.tmUnderlined;
991 pwtm->tmStruckOut = atm.tmStruckOut;
992 pwtm->tmPitchAndFamily = atm.tmPitchAndFamily;
993 pwtm->tmCharSet = atm.tmCharSet;
994 return(rc);
995}
996//******************************************************************************
997//******************************************************************************
998BOOL WIN32API GetViewportExtEx( HDC arg1, PSIZE arg2)
999{
1000 dprintf(("GDI32: GetViewportExtEx"));
1001 return O32_GetViewportExtEx(arg1, arg2);
1002}
1003//******************************************************************************
1004//******************************************************************************
1005BOOL WIN32API GetViewportOrgEx( HDC arg1, PPOINT arg2)
1006{
1007 dprintf(("GDI32: GetViewportOrgEx"));
1008 return O32_GetViewportOrgEx(arg1, arg2);
1009}
1010//******************************************************************************
1011//******************************************************************************
1012BOOL WIN32API GetWindowOrgEx( HDC arg1, PPOINT arg2)
1013{
1014 dprintf(("GDI32: GetWindowOrgEx"));
1015 return O32_GetWindowOrgEx(arg1, arg2);
1016}
1017//******************************************************************************
1018//******************************************************************************
1019BOOL WIN32API GetWorldTransform( HDC arg1, LPXFORM arg2)
1020{
1021 dprintf(("GDI32: GetWorldTransform"));
1022 return O32_GetWorldTransform(arg1, arg2);
1023}
1024//******************************************************************************
1025//******************************************************************************
1026int WIN32API IntersectClipRect(HDC arg1, int arg2, int arg3, int arg4, int arg5)
1027{
1028 int rc;
1029
1030 rc = O32_IntersectClipRect(arg1, arg2, arg3, arg4, arg5);
1031 dprintf(("GDI32: IntersectClipRect returned %d\n", rc));
1032 return(rc);
1033}
1034//******************************************************************************
1035//******************************************************************************
1036BOOL WIN32API LPtoDP( HDC arg1, PPOINT arg2, int arg3)
1037{
1038 dprintf(("GDI32: LPtoDP"));
1039 return O32_LPtoDP(arg1, arg2, arg3);
1040}
1041//******************************************************************************
1042//******************************************************************************
1043BOOL WIN32API ModifyWorldTransform( HDC arg1, const XFORM *arg2, DWORD arg3)
1044{
1045 dprintf(("GDI32: ModifyWorldTransform"));
1046 return O32_ModifyWorldTransform(arg1, (LPXFORM)arg2, arg3);
1047}
1048//******************************************************************************
1049//******************************************************************************
1050BOOL WIN32API OffsetViewportOrgEx( HDC arg1, int arg2, int arg3, PPOINT arg4)
1051{
1052 dprintf(("GDI32: OffsetViewportOrgEx"));
1053 return O32_OffsetViewportOrgEx(arg1, arg2, arg3, arg4);
1054}
1055//******************************************************************************
1056//******************************************************************************
1057BOOL WIN32API OffsetWindowOrgEx( HDC arg1, int arg2, int arg3, PPOINT arg4)
1058{
1059 dprintf(("GDI32: OffsetWindowOrgEx"));
1060 return O32_OffsetWindowOrgEx(arg1, arg2, arg3, arg4);
1061}
1062//******************************************************************************
1063//******************************************************************************
1064BOOL WIN32API Pie(HDC hdc, int nLeftRect, int nTopRect, int nRightRect,
1065 int nBottomRect, int nXRadial1, int nYRadial1, int nXRadial2,
1066 int nYRadial2)
1067{
1068 dprintf(("GDI32: Pie"));
1069 //CB: bug in O32_Pie
1070 if (nXRadial1 == nXRadial2 && nYRadial1 == nYRadial2)
1071 return O32_Ellipse(hdc,nLeftRect,nTopRect,nRightRect,nBottomRect);
1072 else
1073 return O32_Pie(hdc,nLeftRect,nTopRect,nRightRect,nBottomRect,nXRadial1,nYRadial1,nXRadial2,nYRadial2);
1074}
1075//******************************************************************************
1076//******************************************************************************
1077BOOL WIN32API PolyBezier( HDC arg1, const POINT * arg2, DWORD arg3)
1078{
1079 dprintf(("GDI32: PolyBezier"));
1080 return O32_PolyBezier(arg1, arg2, (int)arg3);
1081}
1082//******************************************************************************
1083//******************************************************************************
1084BOOL WIN32API PolyBezierTo( HDC arg1, const POINT * arg2, DWORD arg3)
1085{
1086 dprintf(("GDI32: PolyBezierTo"));
1087 return O32_PolyBezierTo(arg1, arg2, arg3);
1088}
1089//******************************************************************************
1090//******************************************************************************
1091BOOL WIN32API PolyDraw( HDC arg1, const POINT * arg2, const BYTE * arg3, DWORD arg4)
1092{
1093 dprintf(("GDI32: PolyDraw"));
1094 return O32_PolyDraw(arg1, arg2, arg3, arg4);
1095}
1096//******************************************************************************
1097//******************************************************************************
1098BOOL WIN32API PolyPolygon( HDC arg1, const POINT * arg2, const INT * arg3, UINT arg4)
1099{
1100 dprintf(("GDI32: PolyPolygon"));
1101 return O32_PolyPolygon(arg1, arg2, arg3, arg4);
1102}
1103//******************************************************************************
1104//******************************************************************************
1105BOOL WIN32API PolyPolyline( HDC hdc, const POINT * lppt, const DWORD * lpdwPolyPoints, DWORD cCount)
1106{
1107 dprintf(("GDI32: PolyPolyline"));
1108
1109 return O32_PolyPolyline(hdc,lppt,lpdwPolyPoints,cCount);
1110}
1111//******************************************************************************
1112//******************************************************************************
1113BOOL WIN32API Polygon( HDC arg1, const POINT * arg2, int arg3)
1114{
1115 dprintf(("GDI32: Polygon"));
1116 return O32_Polygon(arg1, arg2, arg3);
1117}
1118//******************************************************************************
1119//******************************************************************************
1120BOOL WIN32API PtVisible( HDC arg1, int arg2, int arg3)
1121{
1122 dprintf(("GDI32: PtVisible"));
1123 return O32_PtVisible(arg1, arg2, arg3);
1124}
1125//******************************************************************************
1126//******************************************************************************
1127BOOL WIN32API RectVisible( HDC arg1, const RECT * arg2)
1128{
1129 dprintf(("GDI32: RectVisible\n"));
1130 return O32_RectVisible(arg1, arg2);
1131}
1132//******************************************************************************
1133//******************************************************************************
1134HDC WIN32API ResetDCA( HDC arg1, const DEVMODEA * arg2)
1135{
1136 dprintf(("GDI32: ResetDCA\n"));
1137 return (HDC)O32_ResetDC(arg1, arg2);
1138}
1139//******************************************************************************
1140//******************************************************************************
1141HDC WIN32API ResetDCW( HDC arg1, const DEVMODEW * arg2)
1142{
1143 dprintf(("GDI32: ResetDCW\n"));
1144 // NOTE: This will not work as is (needs UNICODE support)
1145 return (HDC)O32_ResetDC(arg1, (const DEVMODEA *)arg2);
1146}
1147//******************************************************************************
1148//******************************************************************************
1149BOOL WIN32API RestoreDC( HDC arg1, int arg2)
1150{
1151 dprintf(("GDI32: RestoreDC\n"));
1152 return O32_RestoreDC(arg1, arg2);
1153}
1154//******************************************************************************
1155//******************************************************************************
1156BOOL WIN32API RoundRect( HDC arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7)
1157{
1158 dprintf(("GDI32: RoundRect"));
1159 return O32_RoundRect(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1160}
1161//******************************************************************************
1162//******************************************************************************
1163int WIN32API SaveDC( HDC arg1)
1164{
1165 dprintf(("GDI32: SaveDC"));
1166 return O32_SaveDC(arg1);
1167}
1168//******************************************************************************
1169//******************************************************************************
1170BOOL WIN32API ScaleViewportExtEx( HDC arg1, int arg2, int arg3, int arg4, int arg5, PSIZE arg6)
1171{
1172 dprintf(("GDI32: ScaleViewportExtEx"));
1173 return O32_ScaleViewportExtEx(arg1, arg2, arg3, arg4, arg5, arg6);
1174}
1175//******************************************************************************
1176//******************************************************************************
1177BOOL WIN32API ScaleWindowExtEx( HDC arg1, int arg2, int arg3, int arg4, int arg5, PSIZE arg6)
1178{
1179 dprintf(("GDI32: ScaleWindowExtEx"));
1180 return O32_ScaleWindowExtEx(arg1, arg2, arg3, arg4, arg5, arg6);
1181}
1182//******************************************************************************
1183//******************************************************************************
1184int WIN32API SetArcDirection( HDC arg1, int arg2)
1185{
1186 dprintf(("GDI32: SetArcDirection"));
1187 return O32_SetArcDirection(arg1, arg2);
1188}
1189//******************************************************************************
1190//******************************************************************************
1191UINT WIN32API SetBoundsRect( HDC arg1, const RECT * arg2, UINT arg3)
1192{
1193 dprintf(("GDI32: SetBoundsRect"));
1194 return O32_SetBoundsRect(arg1, arg2, arg3);
1195}
1196//******************************************************************************
1197//******************************************************************************
1198BOOL WIN32API SetBrushOrgEx( HDC arg1, int arg2, int arg3, PPOINT arg4)
1199{
1200 BOOL rc;
1201
1202 rc = O32_SetBrushOrgEx(arg1, arg2, arg3, arg4);
1203 dprintf(("GDI32: SetBrushOrgEx returned %d\n", rc));
1204 return(rc);
1205}
1206//******************************************************************************
1207//******************************************************************************
1208int WIN32API SetGraphicsMode(HDC arg1, int arg2)
1209{
1210 dprintf(("GDI32: SetGraphicsMode"));
1211 return O32_SetGraphicsMode(arg1, arg2);
1212}
1213//******************************************************************************
1214//******************************************************************************
1215int WIN32API SetMapMode( HDC arg1, int arg2)
1216{
1217 dprintf(("GDI32: SetMapMode"));
1218 return O32_SetMapMode(arg1, arg2);
1219}
1220//******************************************************************************
1221//******************************************************************************
1222DWORD WIN32API SetMapperFlags( HDC arg1, DWORD arg2)
1223{
1224 dprintf(("GDI32: SetMapperFlags"));
1225 return O32_SetMapperFlags(arg1, arg2);
1226}
1227//******************************************************************************
1228//******************************************************************************
1229BOOL WIN32API SetMiterLimit( HDC arg1, float arg2, float * arg3)
1230{
1231 dprintf(("GDI32: SetMiterLimit"));
1232 return O32_SetMiterLimit(arg1, arg2, arg3);
1233}
1234//******************************************************************************
1235//******************************************************************************
1236int WIN32API SetPolyFillMode( HDC arg1, int arg2)
1237{
1238 dprintf(("GDI32: SetPolyFillMode"));
1239 return O32_SetPolyFillMode(arg1, arg2);
1240}
1241//******************************************************************************
1242//******************************************************************************
1243UINT WIN32API SetTextAlign( HDC arg1, UINT arg2)
1244{
1245 dprintf(("GDI32: SetTextAlign"));
1246 return O32_SetTextAlign(arg1, arg2);
1247}
1248//******************************************************************************
1249//******************************************************************************
1250int WIN32API SetTextCharacterExtra( HDC arg1, int arg2)
1251{
1252 dprintf(("GDI32: SetTextCharacterExtra"));
1253 return O32_SetTextCharacterExtra(arg1, arg2);
1254}
1255//******************************************************************************
1256//******************************************************************************
1257BOOL WIN32API SetTextJustification( HDC arg1, int arg2, int arg3)
1258{
1259 dprintf(("GDI32: SetTextJustification"));
1260 return O32_SetTextJustification(arg1, arg2, arg3);
1261}
1262//******************************************************************************
1263//******************************************************************************
1264BOOL WIN32API SetViewportExtEx( HDC arg1, int arg2, int arg3, PSIZE arg4)
1265{
1266 dprintf(("GDI32: SetViewportExtEx"));
1267 return O32_SetViewportExtEx(arg1, arg2, arg3, arg4);
1268}
1269//******************************************************************************
1270//******************************************************************************
1271BOOL WIN32API SetViewportOrgEx( HDC arg1, int arg2, int arg3, PPOINT arg4)
1272{
1273 dprintf(("GDI32: SetViewportOrgEx"));
1274 return O32_SetViewportOrgEx(arg1, arg2, arg3, arg4);
1275}
1276//******************************************************************************
1277//******************************************************************************
1278BOOL WIN32API SetWindowExtEx( HDC arg1, int arg2, int arg3, PSIZE arg4)
1279{
1280 dprintf(("GDI32: SetWindowExtEx"));
1281 return O32_SetWindowExtEx(arg1, arg2, arg3, arg4);
1282}
1283//******************************************************************************
1284//******************************************************************************
1285BOOL WIN32API SetWindowOrgEx( HDC arg1, int arg2, int arg3, PPOINT arg4)
1286{
1287 dprintf(("GDI32: SetWindowOrgEx"));
1288 return O32_SetWindowOrgEx(arg1, arg2, arg3, arg4);
1289}
1290//******************************************************************************
1291//******************************************************************************
1292BOOL WIN32API SetWorldTransform( HDC arg1, const XFORM *arg2)
1293{
1294 dprintf(("GDI32: SetWorldTransform"));
1295 return O32_SetWorldTransform(arg1, (LPXFORM)arg2);
1296}
1297//******************************************************************************
1298//******************************************************************************
1299INT WIN32API StartDocA( HDC arg1, const DOCINFOA *arg2)
1300{
1301 dprintf(("GDI32: StartDocA"));
1302 return O32_StartDoc(arg1, (LPDOCINFOA)arg2);
1303}
1304//******************************************************************************
1305//******************************************************************************
1306INT WIN32API StartDocW( HDC arg1, const DOCINFOW *arg2)
1307{
1308 dprintf(("GDI32: StartDocW STUB"));
1309 // NOTE: This will not work as is (needs UNICODE support)
1310// return O32_StartDoc(arg1, arg2);
1311 return 0;
1312}
1313//******************************************************************************
1314//******************************************************************************
1315int WIN32API StartPage( HDC arg1)
1316{
1317 dprintf(("GDI32: StartPage"));
1318 return O32_StartPage(arg1);
1319}
1320//******************************************************************************
1321//******************************************************************************
1322BOOL WIN32API UnrealizeObject( HGDIOBJ arg1)
1323{
1324 dprintf(("GDI32: UnrealizeObject"));
1325 return O32_UnrealizeObject(arg1);
1326}
1327//******************************************************************************
1328//******************************************************************************
1329BOOL WIN32API WidenPath( HDC arg1)
1330{
1331 dprintf(("GDI32: WidenPath"));
1332 return O32_WidenPath(arg1);
1333}
1334//******************************************************************************
1335//TODO: Not implemented
1336//******************************************************************************
1337int WIN32API SetAbortProc(HDC hdc, ABORTPROC lpAbortProc)
1338{
1339 dprintf(("GDI32: SetAbortProc - stub (1)w\n"));
1340 return(1);
1341}
1342//******************************************************************************
1343//Selects the current path as a clipping region for a device context, combining
1344//any existing clipping region by using the specified mode
1345//TODO: Can be emulated with SelectClipRegion??
1346//******************************************************************************
1347BOOL WIN32API SelectClipPath(HDC hdc, int iMode)
1348{
1349 dprintf(("GDI32: SelectClipPath, not implemented!(TRUE)\n"));
1350 return(TRUE);
1351}
1352//******************************************************************************
1353//TODO: Sets the color adjustment values for a device context. (used to adjust
1354// the input color of the src bitmap for calls of StretchBlt & StretchDIBits
1355// functions when HALFTONE mode is set
1356//******************************************************************************
1357BOOL WIN32API SetColorAdjustment(HDC hdc, CONST COLORADJUSTMENT *lpca)
1358{
1359 dprintf(("GDI32: SetColorAdjustment, not implemented!(TRUE)\n"));
1360 return(TRUE);
1361}
1362//******************************************************************************
1363//Maps colors to system palette; faster way to update window (instead of redrawing)
1364//We just redraw
1365//******************************************************************************
1366BOOL WIN32API UpdateColors(HDC hdc)
1367{
1368 dprintf(("GDI32: UpdateColors\n"));
1369 return O32_InvalidateRect(O32_WindowFromDC(hdc), NULL, FALSE);
1370}
1371//******************************************************************************
1372//******************************************************************************
1373BOOL WIN32API GdiFlush()
1374{
1375 dprintf(("GDI32: GdiFlush, not implemented (TRUE)\n"));
1376 return(TRUE);
1377}
1378//******************************************************************************
1379//******************************************************************************
1380BOOL WIN32API GdiComment(HDC hdc, UINT cbSize, CONST BYTE *lpData)
1381{
1382 dprintf(("GDI32: GdiComment, not implemented (TRUE)\n"));
1383 return(TRUE);
1384}
1385//******************************************************************************
1386//******************************************************************************
1387BOOL WIN32API GetCharWidthFloatA(HDC hdc, UINT iFirstChar, UINT iLastChar, PFLOAT pxBUffer)
1388{
1389 dprintf(("GDI32: GetCharWidthFloatA, not implemented\n"));
1390 return(FALSE);
1391}
1392//******************************************************************************
1393//******************************************************************************
1394BOOL WIN32API GetCharWidthFloatW(HDC hdc, UINT iFirstChar, UINT iLastChar, PFLOAT pxBUffer)
1395{
1396 dprintf(("GDI32: GetCharWidthFloatW, not implemented\n"));
1397 return(FALSE);
1398}
1399//******************************************************************************
1400//******************************************************************************
1401BOOL WIN32API GetCharABCWidthsFloatA(HDC hdc, UINT iFirstChar, UINT iLastChar, LPABCFLOAT pxBUffer)
1402{
1403 dprintf(("GDI32: GetCharABCWidthsFloatA, not implemented\n"));
1404 return(FALSE);
1405}
1406//******************************************************************************
1407//******************************************************************************
1408BOOL WIN32API GetCharABCWidthsFloatW(HDC hdc,
1409 UINT iFirstChar,
1410 UINT iLastChar,
1411 LPABCFLOAT pxBUffer)
1412{
1413 dprintf(("GDI32: GetCharABCWidthsFloatA, not implemented\n"));
1414 return(FALSE);
1415}
1416//******************************************************************************
1417//******************************************************************************
1418INT WIN32API ExtEscape(HDC hdc, INT nEscape, INT cbInput, LPCSTR lpszInData,
1419 INT cbOutput, LPSTR lpszOutData)
1420{
1421 dprintf(("GDI32: ExtEscape, not implemented\n"));
1422 return(0);
1423}
1424//******************************************************************************
1425//******************************************************************************
1426int WIN32API DrawEscape(HDC hdc, int nEscape, int cbInput, LPCSTR lpszInData)
1427{
1428 dprintf(("GDI32: DrawEscape, not implemented\n"));
1429 return(0);
1430}
1431//******************************************************************************
1432//******************************************************************************
1433BOOL WIN32API GetColorAdjustment(HDC hdc, COLORADJUSTMENT *lpca)
1434{
1435 dprintf(("GDI32: GetColorAdjustment, not implemented\n"));
1436 return(FALSE);
1437}
1438//******************************************************************************
1439//******************************************************************************
1440DWORD WIN32API GetGlyphOutlineA(HDC hdc, UINT uChar, UINT uFormat, LPGLYPHMETRICS lpgm,
1441 DWORD cbBuffer, LPVOID lpvBuffer, CONST MAT2 *lpmat2)
1442{
1443 dprintf(("GDI32: GetGlyphOutLineA, not implemented (GDI_ERROR)\n"));
1444 return(GDI_ERROR);
1445}
1446//******************************************************************************
1447
1448//******************************************************************************
1449/*KSO Thu 21.05.1998*/
1450DWORD WIN32API GetGlyphOutlineW(HDC hdc, UINT uChar, UINT uFormat, LPGLYPHMETRICS lpgm,
1451 DWORD cbBuffer, LPVOID lpvBuffer, CONST MAT2 *lpmat2)
1452{
1453 dprintf(("GDI32: GetGlyphOutLineW, not implemented\n"));
1454 return(GDI_ERROR);
1455}
1456//******************************************************************************
1457
1458//******************************************************************************
1459BOOL WIN32API SetObjectOwner( HGDIOBJ arg1, int arg2 )
1460{
1461 // Here is a guess for a undocumented entry
1462 dprintf(("GDI32: SetObjectOwner - stub (TRUE)\n"));
1463 return TRUE;
1464}
1465//******************************************************************************
1466
1467
1468/* Office 97 stubs - KSO Thu 21.05.1998*/
1469//******************************************************************************
1470BOOL WIN32API GetTextExtentExPointA(/*KSO Thu 21.05.1998*/
1471 HDC hdc,
1472 LPCSTR str,
1473 int count,
1474 int maxExt,
1475 LPINT lpnFit,
1476 LPINT alpDx,
1477 LPSIZE size)
1478{
1479 int index, nFit, extent;
1480 SIZE tSize;
1481
1482 dprintf(("GDI32: GetTextExtendExPointA\n"));
1483
1484 size->cx = size->cy = nFit = extent = 0;
1485 for(index = 0; index < count; index++)
1486 {
1487 if(!O32_GetTextExtentPoint( hdc, str, 1, &tSize )) return FALSE;
1488 if( extent+tSize.cx < maxExt )
1489 {
1490 extent+=tSize.cx;
1491 nFit++;
1492 str++;
1493 if( alpDx )
1494 alpDx[index] = extent;
1495 if( tSize.cy > size->cy ) size->cy = tSize.cy;
1496 }
1497 else break;
1498 }
1499 size->cx = extent;
1500
1501 if (lpnFit != NULL) // check if result is desired
1502 *lpnFit = nFit;
1503
1504 dprintf(("GDI32: GetTextExtendExPointA(%08x '%.*s' %d) returning %d %d %d\n",
1505 hdc,count,str,maxExt,nFit, size->cx,size->cy));
1506 return TRUE;
1507}
1508//******************************************************************************
1509//******************************************************************************
1510BOOL WIN32API GetTextExtentExPointW( /*KSO Thu 21.05.1998*/
1511 HDC arg1,
1512 LPCWSTR arg2,
1513 int arg3,
1514 int arg4,
1515 LPINT arg5,
1516 LPINT arg6,
1517 LPSIZE arg7
1518 )
1519{
1520 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1521 BOOL rc;
1522
1523 dprintf(("GDI32: GetTextExtendExPointW\n"));
1524 rc = GetTextExtentExPointA(arg1, astring, arg3, arg4, arg5, arg6, arg7);
1525 FreeAsciiString(astring);
1526 return rc;
1527}
1528//******************************************************************************
1529//******************************************************************************
1530UINT WIN32API DeleteColorSpace( /*KSO Thu 21.05.1998*/
1531 HCOLORSPACE hColorSpace
1532 )
1533{
1534 dprintf(("GDI32: DeleteColorSpace - stub\n"));
1535 return FALSE;
1536}
1537//******************************************************************************
1538//******************************************************************************
1539BOOL WIN32API SetColorSpace( /*KSO Thu 21.05.1998*/
1540 HDC hdc,
1541 HCOLORSPACE hColorSpace
1542 )
1543{
1544 dprintf(("GDI32: SetColorSpace - stub\n"));
1545 return FALSE;
1546}
1547//******************************************************************************
1548//******************************************************************************
1549 HCOLORSPACE WIN32API CreateColorSpaceA( /*KSO Thu 21.05.1998*/
1550 LPLOGCOLORSPACEA lpLogColorSpace
1551 )
1552{
1553 dprintf(("GDI32: CreateColorSpaceA - stub\n"));
1554 return 0;
1555}
1556//******************************************************************************
1557//******************************************************************************
1558HCOLORSPACE WIN32API CreateColorSpaceW( /*KSO Thu 21.05.1998*/
1559 LPLOGCOLORSPACEW lpwLogColorSpace
1560 )
1561{
1562 dprintf(("GDI32: CreateColorSpaceW - stub\n"));
1563 return 0;
1564}
1565//******************************************************************************
1566//******************************************************************************
1567HANDLE WIN32API GetColorSpace( /*KSO Thu 21.05.1998*/
1568 HDC hdc
1569 )
1570{
1571 dprintf(("GDI32: GetColorSpace - stub\n"));
1572 return 0;
1573}
1574//******************************************************************************
1575//******************************************************************************
1576int WIN32API SetICMMode( /*KSO Thu 21.05.1998*/
1577 HDC hdc,
1578 int mode
1579 )
1580{
1581 dprintf(("GDI32: SetICMMode - stub\n"));
1582 return 0;
1583}
1584//******************************************************************************
1585
1586
1587
1588
1589/*****************************************************************************
1590 * Name : BOOL CancelDC
1591 * Purpose : The CancelDC function cancels any pending operation on the
1592 * specified device context (DC).
1593 * Parameters: HDC hdc handle of device context
1594 * Variables :
1595 * Result : TRUE / FALSE
1596 * Remark :
1597 * Status : UNTESTED STUB
1598 *
1599 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1600 *****************************************************************************/
1601
1602BOOL WIN32API CancelDC(HDC hdc)
1603{
1604 dprintf(("GDI32: CancelDC(%08xh) not implemented.\n",
1605 hdc));
1606
1607 return (FALSE);
1608}
1609
1610
1611/*****************************************************************************
1612 * Name : BOOL CheckColorsInGamut
1613 * Purpose : The CheckColorsInGamut function indicates whether the specified
1614 * color values are within the gamut of the specified device.
1615 * Parameters: HDC hdc handle of device context
1616 * LPVOID lpaRGBQuad
1617 * LPVOID lpResult
1618 * DWORD dwResult
1619 * Variables :
1620 * Result : TRUE / FALSE
1621 * Remark :
1622 * Status : UNTESTED STUB
1623 *
1624 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1625 *****************************************************************************/
1626
1627BOOL WIN32API CheckColorsInGamut(HDC hdc,
1628 LPVOID lpaRGBQuad,
1629 LPVOID lpResult,
1630 DWORD dwResult)
1631{
1632 dprintf(("GDI32: CheckColorsInGamut(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1633 hdc,
1634 lpaRGBQuad,
1635 lpResult,
1636 dwResult));
1637
1638 return (FALSE);
1639}
1640
1641
1642/*****************************************************************************
1643 * Name : BOOL ColorMatchToTarget
1644 * Purpose : The ColorMatchToTarget function enables or disables preview for
1645 * the specified device context. When preview is enabled, colors
1646 * in subsequent output to the specified device context are
1647 * displayed as they would appear on the target device. This is
1648 * useful for checking how well the target maps the specified
1649 * colors in an image. To enable preview, image color matching
1650 * must be enabled for both the target and the preview device context.
1651 * Parameters: HDC hdc handle of device context
1652 * HDC hdcTarget handle of target device context
1653 * DWORD uiAction
1654 * Variables :
1655 * Result : TRUE / FALSE
1656 * Remark :
1657 * Status : UNTESTED STUB
1658 *
1659 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1660 *****************************************************************************/
1661
1662BOOL WIN32API ColorMatchToTarget(HDC hdc,
1663 HDC hdcTarget,
1664 DWORD uiAction)
1665{
1666 dprintf(("GDI32: ColorMatchToTarget(%08xh,%08xh,%08xh) not implemented.\n",
1667 hdc,
1668 hdcTarget,
1669 uiAction));
1670
1671 return (FALSE);
1672}
1673
1674
1675/*****************************************************************************
1676 * Name : BOOL CombineTransform
1677 * Purpose : The CombineTransform function concatenates two world-space to
1678 * page-space transformations.
1679 * Parameters: LLPXFORM lLPXFORMResult address of combined transformation
1680 * XFORM *lLPXFORM1 address of 1st transformation
1681 * XFORM *lLPXFORM2 address of 2nd transformation
1682 * Variables :
1683 * Result : TRUE / FALSE
1684 * Remark :
1685 * Status : UNTESTED
1686 *
1687 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1688 * Markus Montkowski [Wen, 1999/01/12 20:18]
1689 *****************************************************************************/
1690
1691BOOL WIN32API CombineTransform(LPXFORM lLPXFORMResult,
1692 CONST XFORM *lLPXFORM1,
1693 CONST XFORM *lLPXFORM2)
1694{
1695 dprintf(("GDI32: CombineTransform(%08xh,%08xh,%08xh).\n",
1696 lLPXFORMResult,
1697 lLPXFORM1,
1698 lLPXFORM2));
1699
1700 XFORM xfrm;
1701 if( O32_IsBadWritePtr( (void*)lLPXFORMResult, sizeof(XFORM)) ||
1702 O32_IsBadReadPtr( (void*)lLPXFORM1, sizeof(XFORM)) ||
1703 O32_IsBadWritePtr( (void*)lLPXFORM2, sizeof(XFORM)) )
1704 return (FALSE);
1705
1706 // Add the translations
1707 lLPXFORMResult->eDx = lLPXFORM1->eDx + lLPXFORM2->eDx;
1708 lLPXFORMResult->eDy = lLPXFORM1->eDy + lLPXFORM2->eDy;
1709
1710 // Multiply the matrixes
1711 xfrm.eM11 = lLPXFORM1->eM11 * lLPXFORM2->eM11 + lLPXFORM1->eM21 * lLPXFORM1->eM12;
1712 xfrm.eM12 = lLPXFORM1->eM11 * lLPXFORM2->eM12 + lLPXFORM1->eM12 * lLPXFORM1->eM22;
1713 xfrm.eM21 = lLPXFORM1->eM21 * lLPXFORM2->eM11 + lLPXFORM1->eM22 * lLPXFORM1->eM21;
1714 xfrm.eM22 = lLPXFORM1->eM21 * lLPXFORM2->eM12 + lLPXFORM1->eM22 * lLPXFORM1->eM22;
1715
1716 // Now copy to resulting XFROM as the pt must not be distinct
1717 lLPXFORMResult->eM11 = xfrm.eM11;
1718 lLPXFORMResult->eM12 = xfrm.eM12;
1719 lLPXFORMResult->eM21 = xfrm.eM21;
1720 lLPXFORMResult->eM22 = xfrm.eM22;
1721
1722 return (TRUE);
1723}
1724
1725
1726
1727/*****************************************************************************
1728 * Name : HBRUSH CreateDIBPatternBrush
1729 * Purpose : The CreateDIBPatternBrush function creates a logical brush that
1730 * has the pattern specified by the specified device-independent
1731 * bitmap (DIB). The brush can subsequently be selected into any
1732 * device context that is associated with a device that supports
1733 * raster operations.
1734 * This function is provided only for compatibility with applications
1735 * written for versions of Windows earlier than 3.0. For Win32-based
1736 * applications, use the CreateDIBPatternBrushPt function.
1737 * Parameters: HGLOBAL hglbDIBPacked Identifies a global memory object containing
1738 * a packed DIB, which consists of a BITMAPINFO structure immediately
1739 * followed by an array of bytes defining the pixels of the bitmap.
1740 * UINT fuColorSpec color table data
1741 * Variables :
1742 * Result : TRUE / FALSE
1743 * Remark :
1744 * Status : UNTESTED
1745 *
1746 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1747 * Markus Montkowski [Wen, 1999/01/12 20:00]
1748 *****************************************************************************/
1749
1750HBRUSH WIN32API CreateDIBPatternBrush( HGLOBAL hglbDIBPacked,
1751 UINT fuColorSpec)
1752{
1753 LPVOID lpMem;
1754 HBRUSH ret = 0;
1755 dprintf(("GDI32: CreateDIBPatternBrush(%08xh, %08xh) \n",
1756 hglbDIBPacked,
1757 fuColorSpec));
1758
1759 lpMem = GlobalLock(hglbDIBPacked);
1760 if(NULL!=lpMem)
1761 {
1762
1763 ret = CreateDIBPatternBrushPt( lpMem,
1764 fuColorSpec);
1765 GlobalUnlock(hglbDIBPacked);
1766 }
1767
1768 return (ret);
1769}
1770
1771
1772
1773
1774/*****************************************************************************
1775 * Name : int EnumICMProfilesA
1776 * Purpose : The EnumICMProfilesA function enumerates the different color
1777 * profiles that the system supports for the specified device context.
1778 * Parameters: HDC hdc
1779 * ICMENUMPROC lpICMEnumFunc
1780 * LPARAM lParam
1781 * Variables :
1782 * Result : TRUE / FALSE
1783 * Remark :
1784 * Status : UNTESTED STUB
1785 *
1786 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1787 *****************************************************************************/
1788
1789int WIN32API EnumICMProfilesA(HDC hdc,
1790 ICMENUMPROCA lpICMEnumProc,
1791 LPARAM lParam)
1792{
1793 dprintf(("GDI32: EnumICMProfilesA(%08xh, %08xh, %08xh) not implemented(-1).\n",
1794 hdc,
1795 lpICMEnumProc,
1796 lParam));
1797
1798 return (-1);
1799}
1800
1801
1802/*****************************************************************************
1803 * Name : int EnumICMProfilesW
1804 * Purpose : The EnumICMProfilesW function enumerates the different color
1805 * profiles that the system supports for the specified device context.
1806 * Parameters: HDC hdc
1807 * ICMENUMPROC lpICMEnumFunc
1808 * LPARAM lParam
1809 * Variables :
1810 * Result : TRUE / FALSE
1811 * Remark :
1812 * Status : UNTESTED STUB
1813 *
1814 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1815 *****************************************************************************/
1816
1817int WIN32API EnumICMProfilesW(HDC hdc,
1818 ICMENUMPROCW lpICMEnumProc,
1819 LPARAM lParam)
1820{
1821 dprintf(("GDI32: EnumICMProfilesW(%08xh, %08xh, %08xh) not implemented (-1).\n",
1822 hdc,
1823 lpICMEnumProc,
1824 lParam));
1825
1826 return (-1);
1827}
1828
1829
1830/*****************************************************************************
1831 * Name : BOOL FixBrushOrgEx
1832 * Purpose : The FixBrushOrgEx function is not implemented in the Win32 API.
1833 * It is provided for compatibility with Win32s. If called, the
1834 * function does nothing, and returns FALSE.
1835 * Parameters: HDC, int, int, LPPOINT
1836 * Variables :
1837 * Result : TRUE / FALSE
1838 * Remark : not implemented in Win32
1839 * Status : UNTESTED STUB
1840 *
1841 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1842 *****************************************************************************/
1843
1844BOOL WIN32API FixBrushOrgEx(HDC hdc,
1845 int iDummy1,
1846 int iDummy2,
1847 LPPOINT lpPoint)
1848{
1849 dprintf(("GDI32: FixBrushOrgEx(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1850 hdc,
1851 iDummy1,
1852 iDummy2,
1853 lpPoint));
1854
1855 return (FALSE);
1856}
1857
1858
1859/*****************************************************************************
1860 * Name : DWORD GdiGetBatchLimit
1861 * Purpose : The GdiGetBatchLimit function returns the maximum number of
1862 * function calls that can be accumulated in the calling thread's
1863 * current batch. The system flushes the current batch whenever
1864 * this limit is exceeded.
1865 * Parameters:
1866 * Variables :
1867 * Result : 1
1868 * Remark :
1869 * Status : UNTESTED STUB
1870 *
1871 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1872 *****************************************************************************/
1873
1874DWORD WIN32API GdiGetBatchLimit(VOID)
1875{
1876 dprintf(("GDI32: GdiGetBatchLimit() not implemented (1).\n"));
1877
1878 return (1);
1879}
1880
1881
1882/*****************************************************************************
1883 * Name : DWORD GdiSetBatchLimit
1884 * Purpose : The GdiSetBatchLimit function sets the maximum number of
1885 * functions that can be accumulated in the calling thread's current
1886 * batch. The system flushes the current batch whenever this limit
1887 * is exceeded.
1888 * Parameters: DWORD dwLimit
1889 * Variables :
1890 * Result :
1891 * Remark :
1892 * Status : UNTESTED STUB
1893 *
1894 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1895 *****************************************************************************/
1896
1897DWORD WIN32API GdiSetBatchLimit(DWORD dwLimit)
1898{
1899 dprintf(("GDI32: GdiSetBatchLimit(%08xh) not implemented (1).\n",
1900 dwLimit));
1901
1902 return (1);
1903}
1904
1905
1906/*****************************************************************************
1907 * Name : DWORD GetCharacterPlacementA
1908 * Purpose : The GetCharacterPlacementA function retrieves information about
1909 * a character string, such as character widths, caret positioning,
1910 * ordering within the string, and glyph rendering. The type of
1911 * information returned depends on the dwFlags parameter and is
1912 * based on the currently selected font in the given display context.
1913 * The function copies the information to the specified GCP_RESULTSA
1914 * structure or to one or more arrays specified by the structure.
1915 * Parameters: HDC hdc handle to device context
1916 * LPCSTR lpString pointer to string
1917 * int nCount number of characters in string
1918 * int nMaxExtent maximum extent for displayed string
1919 * LPGCP_RESULTSA *lpResults pointer to buffer for placement result
1920 * DWORD dwFlags placement flags
1921 * Variables :
1922 * Result :
1923 * Remark :
1924 * Status : UNTESTED STUB
1925 *
1926 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1927 *****************************************************************************/
1928
1929DWORD WIN32API GetCharacterPlacementA(HDC hdc,
1930 LPCSTR lpString,
1931 int nCount,
1932 int nMaxExtent,
1933 GCP_RESULTSA * lpResults,
1934 DWORD dwFlags)
1935{
1936 dprintf(("GDI32: GetCharacterPlacementA(%08xh,%s,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1937 hdc,
1938 lpString,
1939 nCount,
1940 nMaxExtent,
1941 lpResults,
1942 dwFlags));
1943
1944 return (0);
1945}
1946
1947
1948/*****************************************************************************
1949 * Name : DWORD GetCharacterPlacementW
1950 * Purpose : The GetCharacterPlacementW function retrieves information about
1951 * a character string, such as character widths, caret positioning,
1952 * ordering within the string, and glyph rendering. The type of
1953 * information returned depends on the dwFlags parameter and is
1954 * based on the currently selected font in the given display context.
1955 * The function copies the information to the specified GCP_RESULTSW
1956 * structure or to one or more arrays specified by the structure.
1957 * Parameters: HDC hdc handle to device context
1958 * LPCSTR lpString pointer to string
1959 * int nCount number of characters in string
1960 * int nMaxExtent maximum extent for displayed string
1961 * GCP_RESULTSW *lpResults pointer to buffer for placement result
1962 * DWORD dwFlags placement flags
1963 * Variables :
1964 * Result :
1965 * Remark :
1966 * Status : UNTESTED STUB
1967 *
1968 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1969 *****************************************************************************/
1970
1971DWORD WIN32API GetCharacterPlacementW(HDC hdc,
1972 LPCWSTR lpString,
1973 int nCount,
1974 int nMaxExtent,
1975 GCP_RESULTSW *lpResults,
1976 DWORD dwFlags)
1977{
1978 dprintf(("GDI32: GetCharacterPlacementW(%08xh,%s,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1979 hdc,
1980 lpString,
1981 nCount,
1982 nMaxExtent,
1983 lpResults,
1984 dwFlags));
1985
1986 return (0);
1987}
1988
1989
1990/*****************************************************************************
1991 * Name : DWORD GetDeviceGammaRamp
1992 * Purpose : The GetDeviceGammaRamp function retrieves the gamma ramp on
1993 * direct color display boards.
1994 * Parameters: HDC hdc handle to device context
1995 * LPVOID lpRamp Gamma ramp array
1996 * Variables :
1997 * Result :
1998 * Remark :
1999 * Status : UNTESTED STUB
2000 *
2001 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2002 *****************************************************************************/
2003
2004DWORD WIN32API GetDeviceGammaRamp(HDC hdc,
2005 LPVOID lpRamp)
2006{
2007 dprintf(("GDI32: GetDeviceGammaRamp(%08xh, %08xh) not implemented.\n",
2008 hdc,
2009 lpRamp));
2010
2011 return (FALSE);
2012}
2013
2014
2015
2016
2017/*****************************************************************************
2018 * Name : BOOL GetICMProfileA
2019 * Purpose : The GetICMProfileA function retrieves the name of the color
2020 * profile file for the device associated with the specified device
2021 * context.
2022 * Parameters: HDC hdc handle to device context
2023 * DWORD cbName
2024 * LPTSTR lpszFilename
2025 * Variables :
2026 * Result : TRUE / FALSE
2027 * Remark :
2028 * Status : UNTESTED STUB
2029 *
2030 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2031 *****************************************************************************/
2032
2033BOOL WIN32API GetICMProfileA(HDC hdc,
2034 DWORD cbName,
2035 LPTSTR lpszFilename)
2036{
2037 dprintf(("GDI32: GetICMProfileA(%08xh, %08xh, %08xh) not implemented.\n",
2038 hdc,
2039 cbName,
2040 lpszFilename));
2041
2042 return (FALSE);
2043}
2044
2045
2046/*****************************************************************************
2047 * Name : BOOL GetICMProfileW
2048 * Purpose : The GetICMProfileW function retrieves the name of the color
2049 * profile file for the device associated with the specified device
2050 * context.
2051 * Parameters: HDC hdc handle to device context
2052 * DWORD cbName
2053 * LPWSTR lpszFilename
2054 * Variables :
2055 * Result : TRUE / FALSE
2056 * Remark :
2057 * Status : UNTESTED STUB
2058 *
2059 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2060 *****************************************************************************/
2061
2062BOOL WIN32API GetICMProfileW(HDC hdc,
2063 DWORD cbName,
2064 LPTSTR lpszFilename)
2065{
2066 dprintf(("GDI32: GetICMProfileW(%08xh, %08xh, %08xh) not implemented.\n",
2067 hdc,
2068 cbName,
2069 lpszFilename));
2070
2071 return (FALSE);
2072}
2073
2074
2075/*****************************************************************************
2076 * Name : BOOL GetLogColorSpaceA
2077 * Purpose : The GetLogColorSpace function retrieves information about the
2078 * logical color space identified by the specified handle.
2079 * Parameters: HCOLORSPACE hColorSpace
2080 * LPLOGCOLORSPACE lpbuffer
2081 * DWORD nSize
2082 * Variables :
2083 * Result : TRUE / FALSE
2084 * Remark :
2085 * Status : UNTESTED STUB
2086 *
2087 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2088 *****************************************************************************/
2089
2090#define LPLOGCOLORSPACE LPVOID
2091BOOL WIN32API GetLogColorSpaceA(HCOLORSPACE hColorSpace,
2092 LPLOGCOLORSPACE lpBuffer,
2093 DWORD nSize)
2094{
2095 dprintf(("GDI32: GetLogColorSpaceA(%08xh, %08xh, %08xh) not implemented.\n",
2096 hColorSpace,
2097 lpBuffer,
2098 nSize));
2099
2100 return (FALSE);
2101}
2102
2103
2104/*****************************************************************************
2105 * Name : BOOL GetLogColorSpaceW
2106 * Purpose : The GetLogColorSpace function retrieves information about the
2107 * logical color space identified by the specified handle.
2108 * Parameters: HCOLORSPACE hColorSpace
2109 * LPLOGCOLORSPACE lpbuffer
2110 * DWORD nSize
2111 * Variables :
2112 * Result : TRUE / FALSE
2113 * Remark :
2114 * Status : UNTESTED STUB
2115 *
2116 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2117 *****************************************************************************/
2118
2119BOOL WIN32API GetLogColorSpaceW(HCOLORSPACE hColorSpace,
2120 LPLOGCOLORSPACE lpBuffer,
2121 DWORD nSize)
2122{
2123 dprintf(("GDI32: GetLogColorSpaceW(%08xh, %08xh, %08xh) not implemented.\n",
2124 hColorSpace,
2125 lpBuffer,
2126 nSize));
2127
2128 return (FALSE);
2129}
2130
2131
2132/*****************************************************************************
2133 * Name : BOOL SetDeviceGammaRamp
2134 * Purpose : The SetDeviceGammaRamp function sets the gamma ramp on direct
2135 * color display boards.
2136 * Parameters: HDC hdc handle of device context
2137 * LPVOID lpRamp
2138 * Variables :
2139 * Result : TRUE / FALSE
2140 * Remark :
2141 * Status : UNTESTED STUB
2142 *
2143 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2144 *****************************************************************************/
2145
2146BOOL WIN32API SetDeviceGammaRamp(HDC hdc,
2147 LPVOID lpRamp)
2148{
2149 dprintf(("GDI32: SetDeviceGammaRamp(%08xh, %08xh) not implemented.\n",
2150 hdc,
2151 lpRamp));
2152
2153 return (FALSE);
2154}
2155
2156
2157/*****************************************************************************
2158 * Name : BOOL SetICMProfileA
2159 * Purpose : The SetICMProfileA function sets the color profile for the
2160 * specified device context.
2161 * Parameters: HDC hdc handle of device context
2162 * LPTSTR lpFileName
2163 * Variables :
2164 * Result : TRUE / FALSE
2165 * Remark :
2166 * Status : UNTESTED STUB
2167 *
2168 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2169 *****************************************************************************/
2170
2171BOOL WIN32API SetICMProfileA(HDC hdc,
2172 LPTSTR lpFileName)
2173{
2174 dprintf(("GDI32: SetICMProfileA(%08xh, %s) not implemented.\n",
2175 hdc,
2176 lpFileName));
2177
2178 return (FALSE);
2179}
2180
2181
2182/*****************************************************************************
2183 * Name : BOOL SetICMProfileW
2184 * Purpose : The SetICMProfileW function sets the color profile for the
2185 * specified device context.
2186 * Parameters: HDC hdc handle of device context
2187 * LPTSTR lpFileName
2188 * Variables :
2189 * Result : TRUE / FALSE
2190 * Remark :
2191 * Status : UNTESTED STUB
2192 *
2193 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2194 *****************************************************************************/
2195
2196BOOL WIN32API SetICMProfileW(HDC hdc,
2197 LPWSTR lpFileName)
2198{
2199 dprintf(("GDI32: SetICMProfileW(%08xh, %s) not implemented.\n",
2200 hdc,
2201 lpFileName));
2202
2203 return (FALSE);
2204}
2205
2206
2207
2208/*****************************************************************************
2209 * Name : BOOL UpdateICMRegKeyA
2210 * Purpose : The UpdateICMRegKeyA function installs, removes, or queries
2211 * registry entries that identify ICC color profiles or color-matching
2212 * DLLs. The function carries out the action specified by the nCommand
2213 * parameter.
2214 * Parameters: DWORD dwReserved
2215 * DWORD CMID
2216 * LPTSTR lpszFileName
2217 * UINT nCommand
2218 * Variables :
2219 * Result : TRUE / FALSE
2220 * Remark :
2221 * Status : UNTESTED STUB
2222 *
2223 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2224 *****************************************************************************/
2225
2226BOOL WIN32API UpdateICMRegKeyA(DWORD dwReserved,
2227 DWORD CMID,
2228 LPTSTR lpszFileName,
2229 UINT nCommand)
2230{
2231 dprintf(("GDI32: UpdateICMRegKeyA(%08xh, %08xh, %08xh, %08xh) not implemented.\n",
2232 dwReserved,
2233 CMID,
2234 lpszFileName,
2235 nCommand));
2236
2237 return (FALSE);
2238}
2239
2240
2241/*****************************************************************************
2242 * Name : BOOL UpdateICMRegKeyW
2243 * Purpose : The UpdateICMRegKeyW function installs, removes, or queries
2244 * registry entries that identify ICC color profiles or color-matching
2245 * DLLs. The function carries out the action specified by the nCommand
2246 * parameter.
2247 * Parameters: DWORD dwReserved
2248 * DWORD CMID
2249 * LPWSTR lpszFileName
2250 * UINT nCommand
2251 * Variables :
2252 * Result : TRUE / FALSE
2253 * Remark :
2254 * Status : UNTESTED STUB
2255 *
2256 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2257 *****************************************************************************/
2258
2259BOOL WIN32API UpdateICMRegKeyW(DWORD dwReserved,
2260 DWORD CMID,
2261 LPWSTR lpszFileName,
2262 UINT nCommand)
2263{
2264 dprintf(("GDI32: UpdateICMRegKeyW(%08xh, %08xh, %08xh, %08xh) not implemented.\n",
2265 dwReserved,
2266 CMID,
2267 lpszFileName,
2268 nCommand));
2269
2270 return (FALSE);
2271}
2272
2273
2274
Note: See TracBrowser for help on using the repository browser.