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

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

RGB 555 conversion in SetDIBitsToDevice + quake 2 BitBlt fix
File size: 87.9 KB
Line 
1/* $Id: gdi32.cpp,v 1.38 2000-02-02 23:45:06 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
780 return(rc);
781}
782//******************************************************************************
783//******************************************************************************
784int WIN32API GetGraphicsMode(HDC arg1)
785{
786 dprintf(("GDI32: GetGraphicsMode"));
787 return O32_GetGraphicsMode(arg1);
788}
789//******************************************************************************
790//******************************************************************************
791DWORD WIN32API GetKerningPairsA( HDC arg1, DWORD arg2, LPKERNINGPAIR arg3)
792{
793 dprintf(("GDI32: GetKerningPairsA"));
794 return O32_GetKerningPairs(arg1, arg2, arg3);
795}
796//******************************************************************************
797//******************************************************************************
798DWORD WIN32API GetKerningPairsW( HDC arg1, DWORD arg2, LPKERNINGPAIR arg3)
799{
800 dprintf(("GDI32: GetKerningPairsW"));
801 // NOTE: This will not work as is (needs UNICODE support)
802 return O32_GetKerningPairs(arg1, arg2, arg3);
803}
804//******************************************************************************
805//******************************************************************************
806int WIN32API GetMapMode( HDC arg1)
807{
808 dprintf(("GDI32: GetMapMode"));
809 return O32_GetMapMode(arg1);
810}
811//******************************************************************************
812//******************************************************************************
813BOOL WIN32API GetMiterLimit( HDC arg1, float * arg2)
814{
815 dprintf(("GDI32: GetMiterLimit"));
816 return O32_GetMiterLimit(arg1, arg2);
817}
818//******************************************************************************
819//******************************************************************************
820COLORREF WIN32API GetNearestColor( HDC arg1, COLORREF arg2)
821{
822 dprintf(("GDI32: GetNearestColor\n"));
823 return O32_GetNearestColor(arg1, arg2);
824}
825//******************************************************************************
826//******************************************************************************
827UINT WIN32API GetOutlineTextMetricsA( HDC arg1, UINT arg2, LPOUTLINETEXTMETRICA arg3)
828{
829 dprintf(("GDI32: GetOutlineTextMetricsA"));
830 return O32_GetOutlineTextMetrics(arg1, arg2, arg3);
831}
832//******************************************************************************
833//******************************************************************************
834UINT WIN32API GetOutlineTextMetricsW( HDC arg1, UINT arg2, LPOUTLINETEXTMETRICW arg3)
835{
836 dprintf(("GDI32: GetOutlineTextMetricsW STUB"));
837 // NOTE: This will not work as is (needs UNICODE support)
838// return O32_GetOutlineTextMetrics(arg1, arg2, arg3);
839 return 0;
840}
841//******************************************************************************
842//******************************************************************************
843INT WIN32API GetPath( HDC arg1, PPOINT arg2, PBYTE arg3, int arg4)
844{
845 dprintf(("GDI32: GetPath"));
846 return O32_GetPath(arg1, arg2, arg3, arg4);
847}
848//******************************************************************************
849//******************************************************************************
850int WIN32API GetPolyFillMode( HDC arg1)
851{
852 dprintf(("GDI32: GetPolyFillMode"));
853 return O32_GetPolyFillMode(arg1);
854}
855//******************************************************************************
856//******************************************************************************
857int WIN32API GetROP2( HDC arg1)
858{
859 dprintf(("GDI32: GetROP2"));
860 return O32_GetROP2(arg1);
861}
862//******************************************************************************
863//******************************************************************************
864BOOL WIN32API GetRasterizerCaps(LPRASTERIZER_STATUS arg1, UINT arg2)
865{
866 dprintf(("GDI32: GetRasterizerCaps"));
867 return O32_GetRasterizerCaps(arg1, arg2);
868}
869//******************************************************************************
870//******************************************************************************
871UINT WIN32API GetTextAlign( HDC arg1)
872{
873 dprintf(("GDI32: GetTextAlign"));
874 return O32_GetTextAlign(arg1);
875}
876//******************************************************************************
877//******************************************************************************
878int WIN32API GetTextCharacterExtra( HDC arg1)
879{
880 dprintf(("GDI32: GetTextCharacterExtra"));
881 return O32_GetTextCharacterExtra(arg1);
882}
883//******************************************************************************
884//******************************************************************************
885COLORREF WIN32API GetTextColor( HDC arg1)
886{
887 dprintf(("GDI32: GetTextColor"));
888 return O32_GetTextColor(arg1);
889}
890//******************************************************************************
891//******************************************************************************
892BOOL WIN32API GetTextExtentPoint32A( HDC hdc, LPCSTR lpsz, int cbString, PSIZE lpSize)
893{
894 BOOL rc;
895
896 lpSize->cx = lpSize->cy = 0;
897 rc = O32_GetTextExtentPoint32(hdc, lpsz, cbString, lpSize);
898 dprintf(("GDI32: GetTextExtentPoint32A %x %s %d returned %d (%d,%d)", hdc, lpsz, cbString, rc, lpSize->cx, lpSize->cy));
899 return rc;
900}
901//******************************************************************************
902//******************************************************************************
903BOOL WIN32API GetTextExtentPoint32W(HDC arg1, LPCWSTR arg2, int arg3, PSIZE lpSize)
904{
905 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
906 BOOL rc;
907
908 dprintf(("GDI32: GetTextExtentPoint32W %s\n", astring));
909 lpSize->cx = lpSize->cy = 0;
910 rc = O32_GetTextExtentPoint32(arg1, astring, arg3, lpSize);
911 FreeAsciiString(astring);
912 return(rc);
913}
914//******************************************************************************
915//******************************************************************************
916BOOL WIN32API GetTextExtentPointW(HDC hdc,
917 LPCWSTR lpString,
918 int cbString,
919 PSIZE lpSize)
920{
921 char *astring = UnicodeToAsciiString((LPWSTR)lpString);
922 BOOL rc;
923
924 lpSize->cx = lpSize->cy = 0;
925 rc = O32_GetTextExtentPoint(hdc,
926 astring,
927 cbString,
928 lpSize);
929 dprintf(("GDI32: GetTextExtentPointW %X %s (size %08xh) returned %d\n", hdc, astring, cbString, rc));
930 dprintf(("GDI32: GetTextExtentPointW (%d,%d)\n", lpSize->cx, lpSize->cy));
931
932 FreeAsciiString(astring);
933 return(rc);
934}
935//******************************************************************************
936//******************************************************************************
937int WIN32API GetTextFaceA( HDC arg1, int arg2, LPSTR arg3)
938{
939 dprintf(("GDI32: GetTextFaceA"));
940 return O32_GetTextFace(arg1, arg2, arg3);
941}
942//******************************************************************************
943//******************************************************************************
944int WIN32API GetTextFaceW( HDC arg1, int arg2, LPWSTR arg3)
945{
946 char *astring = (char *)malloc(arg2+1);
947 int rc;
948
949 dprintf(("GDI32: GetTextFaceW"));
950 rc = O32_GetTextFace(arg1, arg2, astring);
951 AsciiToUnicode(astring, arg3);
952 free(astring);
953 return rc;
954}
955//******************************************************************************
956//******************************************************************************
957BOOL WIN32API GetTextMetricsA( HDC arg1, LPTEXTMETRICA arg2)
958{
959 BOOL rc;
960
961 rc = O32_GetTextMetrics(arg1, arg2);
962 dprintf(("GDI32: GetTextMetricsA returned %d\n", rc));
963 return(rc);
964}
965//******************************************************************************
966//******************************************************************************
967BOOL WIN32API GetTextMetricsW( HDC arg1, LPTEXTMETRICW pwtm)
968{
969 BOOL rc;
970 TEXTMETRICA atm;
971
972 dprintf(("GDI32: GetTextMetricsW"));
973
974 rc = O32_GetTextMetrics(arg1, &atm);
975 pwtm->tmHeight = atm.tmHeight;
976 pwtm->tmAscent = atm.tmAscent;
977 pwtm->tmDescent = atm.tmDescent;
978 pwtm->tmInternalLeading = atm.tmInternalLeading;
979 pwtm->tmExternalLeading = atm.tmExternalLeading;
980 pwtm->tmAveCharWidth = atm.tmAveCharWidth;
981 pwtm->tmMaxCharWidth = atm.tmMaxCharWidth;
982 pwtm->tmWeight = atm.tmWeight;
983 pwtm->tmOverhang = atm.tmOverhang;
984 pwtm->tmDigitizedAspectX = atm.tmDigitizedAspectX;
985 pwtm->tmDigitizedAspectY = atm.tmDigitizedAspectY;
986 pwtm->tmFirstChar = atm.tmFirstChar;
987 pwtm->tmLastChar = atm.tmLastChar;
988 pwtm->tmDefaultChar = atm.tmDefaultChar;
989 pwtm->tmBreakChar = atm.tmBreakChar;
990 pwtm->tmItalic = atm.tmItalic;
991 pwtm->tmUnderlined = atm.tmUnderlined;
992 pwtm->tmStruckOut = atm.tmStruckOut;
993 pwtm->tmPitchAndFamily = atm.tmPitchAndFamily;
994 pwtm->tmCharSet = atm.tmCharSet;
995 return(rc);
996}
997//******************************************************************************
998//******************************************************************************
999BOOL WIN32API GetViewportExtEx( HDC arg1, PSIZE arg2)
1000{
1001 dprintf(("GDI32: GetViewportExtEx"));
1002 return O32_GetViewportExtEx(arg1, arg2);
1003}
1004//******************************************************************************
1005//******************************************************************************
1006BOOL WIN32API GetViewportOrgEx( HDC arg1, PPOINT arg2)
1007{
1008 dprintf(("GDI32: GetViewportOrgEx"));
1009 return O32_GetViewportOrgEx(arg1, arg2);
1010}
1011//******************************************************************************
1012//******************************************************************************
1013BOOL WIN32API GetWindowOrgEx( HDC arg1, PPOINT arg2)
1014{
1015 dprintf(("GDI32: GetWindowOrgEx"));
1016 return O32_GetWindowOrgEx(arg1, arg2);
1017}
1018//******************************************************************************
1019//******************************************************************************
1020BOOL WIN32API GetWorldTransform( HDC arg1, LPXFORM arg2)
1021{
1022 dprintf(("GDI32: GetWorldTransform"));
1023 return O32_GetWorldTransform(arg1, arg2);
1024}
1025//******************************************************************************
1026//******************************************************************************
1027int WIN32API IntersectClipRect(HDC arg1, int arg2, int arg3, int arg4, int arg5)
1028{
1029 int rc;
1030
1031 rc = O32_IntersectClipRect(arg1, arg2, arg3, arg4, arg5);
1032 dprintf(("GDI32: IntersectClipRect returned %d\n", rc));
1033 return(rc);
1034}
1035//******************************************************************************
1036//******************************************************************************
1037BOOL WIN32API LPtoDP( HDC arg1, PPOINT arg2, int arg3)
1038{
1039 dprintf(("GDI32: LPtoDP"));
1040 return O32_LPtoDP(arg1, arg2, arg3);
1041}
1042//******************************************************************************
1043//******************************************************************************
1044BOOL WIN32API ModifyWorldTransform( HDC arg1, const XFORM *arg2, DWORD arg3)
1045{
1046 dprintf(("GDI32: ModifyWorldTransform"));
1047 return O32_ModifyWorldTransform(arg1, (LPXFORM)arg2, arg3);
1048}
1049//******************************************************************************
1050//******************************************************************************
1051BOOL WIN32API OffsetViewportOrgEx( HDC arg1, int arg2, int arg3, PPOINT arg4)
1052{
1053 dprintf(("GDI32: OffsetViewportOrgEx"));
1054 return O32_OffsetViewportOrgEx(arg1, arg2, arg3, arg4);
1055}
1056//******************************************************************************
1057//******************************************************************************
1058BOOL WIN32API OffsetWindowOrgEx( HDC arg1, int arg2, int arg3, PPOINT arg4)
1059{
1060 dprintf(("GDI32: OffsetWindowOrgEx"));
1061 return O32_OffsetWindowOrgEx(arg1, arg2, arg3, arg4);
1062}
1063//******************************************************************************
1064//******************************************************************************
1065BOOL WIN32API Pie(HDC hdc, int nLeftRect, int nTopRect, int nRightRect,
1066 int nBottomRect, int nXRadial1, int nYRadial1, int nXRadial2,
1067 int nYRadial2)
1068{
1069 dprintf(("GDI32: Pie"));
1070 //CB: bug in O32_Pie
1071 if (nXRadial1 == nXRadial2 && nYRadial1 == nYRadial2)
1072 return O32_Ellipse(hdc,nLeftRect,nTopRect,nRightRect,nBottomRect);
1073 else
1074 return O32_Pie(hdc,nLeftRect,nTopRect,nRightRect,nBottomRect,nXRadial1,nYRadial1,nXRadial2,nYRadial2);
1075}
1076//******************************************************************************
1077//******************************************************************************
1078BOOL WIN32API PolyBezier( HDC arg1, const POINT * arg2, DWORD arg3)
1079{
1080 dprintf(("GDI32: PolyBezier"));
1081 return O32_PolyBezier(arg1, arg2, (int)arg3);
1082}
1083//******************************************************************************
1084//******************************************************************************
1085BOOL WIN32API PolyBezierTo( HDC arg1, const POINT * arg2, DWORD arg3)
1086{
1087 dprintf(("GDI32: PolyBezierTo"));
1088 return O32_PolyBezierTo(arg1, arg2, arg3);
1089}
1090//******************************************************************************
1091//******************************************************************************
1092BOOL WIN32API PolyDraw( HDC arg1, const POINT * arg2, const BYTE * arg3, DWORD arg4)
1093{
1094 dprintf(("GDI32: PolyDraw"));
1095 return O32_PolyDraw(arg1, arg2, arg3, arg4);
1096}
1097//******************************************************************************
1098//******************************************************************************
1099BOOL WIN32API PolyPolygon( HDC arg1, const POINT * arg2, const INT * arg3, UINT arg4)
1100{
1101 dprintf(("GDI32: PolyPolygon"));
1102 return O32_PolyPolygon(arg1, arg2, arg3, arg4);
1103}
1104//******************************************************************************
1105//******************************************************************************
1106BOOL WIN32API PolyPolyline( HDC hdc, const POINT * lppt, const DWORD * lpdwPolyPoints, DWORD cCount)
1107{
1108 dprintf(("GDI32: PolyPolyline"));
1109
1110 return O32_PolyPolyline(hdc,lppt,lpdwPolyPoints,cCount);
1111}
1112//******************************************************************************
1113//******************************************************************************
1114BOOL WIN32API Polygon( HDC arg1, const POINT * arg2, int arg3)
1115{
1116 dprintf(("GDI32: Polygon"));
1117 return O32_Polygon(arg1, arg2, arg3);
1118}
1119//******************************************************************************
1120//******************************************************************************
1121BOOL WIN32API PtVisible( HDC arg1, int arg2, int arg3)
1122{
1123 dprintf(("GDI32: PtVisible"));
1124 return O32_PtVisible(arg1, arg2, arg3);
1125}
1126//******************************************************************************
1127//******************************************************************************
1128BOOL WIN32API RectVisible( HDC arg1, const RECT * arg2)
1129{
1130 dprintf(("GDI32: RectVisible\n"));
1131 return O32_RectVisible(arg1, arg2);
1132}
1133//******************************************************************************
1134//******************************************************************************
1135HDC WIN32API ResetDCA( HDC arg1, const DEVMODEA * arg2)
1136{
1137 dprintf(("GDI32: ResetDCA\n"));
1138 return (HDC)O32_ResetDC(arg1, arg2);
1139}
1140//******************************************************************************
1141//******************************************************************************
1142HDC WIN32API ResetDCW( HDC arg1, const DEVMODEW * arg2)
1143{
1144 dprintf(("GDI32: ResetDCW\n"));
1145 // NOTE: This will not work as is (needs UNICODE support)
1146 return (HDC)O32_ResetDC(arg1, (const DEVMODEA *)arg2);
1147}
1148//******************************************************************************
1149//******************************************************************************
1150BOOL WIN32API RestoreDC( HDC arg1, int arg2)
1151{
1152 dprintf(("GDI32: RestoreDC\n"));
1153 return O32_RestoreDC(arg1, arg2);
1154}
1155//******************************************************************************
1156//******************************************************************************
1157BOOL WIN32API RoundRect( HDC arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7)
1158{
1159 dprintf(("GDI32: RoundRect"));
1160 return O32_RoundRect(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1161}
1162//******************************************************************************
1163//******************************************************************************
1164int WIN32API SaveDC( HDC arg1)
1165{
1166 dprintf(("GDI32: SaveDC"));
1167 return O32_SaveDC(arg1);
1168}
1169//******************************************************************************
1170//******************************************************************************
1171BOOL WIN32API ScaleViewportExtEx( HDC arg1, int arg2, int arg3, int arg4, int arg5, PSIZE arg6)
1172{
1173 dprintf(("GDI32: ScaleViewportExtEx"));
1174 return O32_ScaleViewportExtEx(arg1, arg2, arg3, arg4, arg5, arg6);
1175}
1176//******************************************************************************
1177//******************************************************************************
1178BOOL WIN32API ScaleWindowExtEx( HDC arg1, int arg2, int arg3, int arg4, int arg5, PSIZE arg6)
1179{
1180 dprintf(("GDI32: ScaleWindowExtEx"));
1181 return O32_ScaleWindowExtEx(arg1, arg2, arg3, arg4, arg5, arg6);
1182}
1183//******************************************************************************
1184//******************************************************************************
1185int WIN32API SetArcDirection( HDC arg1, int arg2)
1186{
1187 dprintf(("GDI32: SetArcDirection"));
1188 return O32_SetArcDirection(arg1, arg2);
1189}
1190//******************************************************************************
1191//******************************************************************************
1192UINT WIN32API SetBoundsRect( HDC arg1, const RECT * arg2, UINT arg3)
1193{
1194 dprintf(("GDI32: SetBoundsRect"));
1195 return O32_SetBoundsRect(arg1, arg2, arg3);
1196}
1197//******************************************************************************
1198//******************************************************************************
1199BOOL WIN32API SetBrushOrgEx( HDC arg1, int arg2, int arg3, PPOINT arg4)
1200{
1201 BOOL rc;
1202
1203 rc = O32_SetBrushOrgEx(arg1, arg2, arg3, arg4);
1204 dprintf(("GDI32: SetBrushOrgEx returned %d\n", rc));
1205 return(rc);
1206}
1207//******************************************************************************
1208//******************************************************************************
1209int WIN32API SetGraphicsMode(HDC arg1, int arg2)
1210{
1211 dprintf(("GDI32: SetGraphicsMode"));
1212 return O32_SetGraphicsMode(arg1, arg2);
1213}
1214//******************************************************************************
1215//******************************************************************************
1216int WIN32API SetMapMode( HDC arg1, int arg2)
1217{
1218 dprintf(("GDI32: SetMapMode"));
1219 return O32_SetMapMode(arg1, arg2);
1220}
1221//******************************************************************************
1222//******************************************************************************
1223DWORD WIN32API SetMapperFlags( HDC arg1, DWORD arg2)
1224{
1225 dprintf(("GDI32: SetMapperFlags"));
1226 return O32_SetMapperFlags(arg1, arg2);
1227}
1228//******************************************************************************
1229//******************************************************************************
1230BOOL WIN32API SetMiterLimit( HDC arg1, float arg2, float * arg3)
1231{
1232 dprintf(("GDI32: SetMiterLimit"));
1233 return O32_SetMiterLimit(arg1, arg2, arg3);
1234}
1235//******************************************************************************
1236//******************************************************************************
1237int WIN32API SetPolyFillMode( HDC arg1, int arg2)
1238{
1239 dprintf(("GDI32: SetPolyFillMode"));
1240 return O32_SetPolyFillMode(arg1, arg2);
1241}
1242//******************************************************************************
1243//******************************************************************************
1244UINT WIN32API SetTextAlign( HDC arg1, UINT arg2)
1245{
1246 dprintf(("GDI32: SetTextAlign"));
1247 return O32_SetTextAlign(arg1, arg2);
1248}
1249//******************************************************************************
1250//******************************************************************************
1251int WIN32API SetTextCharacterExtra( HDC arg1, int arg2)
1252{
1253 dprintf(("GDI32: SetTextCharacterExtra"));
1254 return O32_SetTextCharacterExtra(arg1, arg2);
1255}
1256//******************************************************************************
1257//******************************************************************************
1258BOOL WIN32API SetTextJustification( HDC arg1, int arg2, int arg3)
1259{
1260 dprintf(("GDI32: SetTextJustification"));
1261 return O32_SetTextJustification(arg1, arg2, arg3);
1262}
1263//******************************************************************************
1264//******************************************************************************
1265BOOL WIN32API SetViewportExtEx( HDC arg1, int arg2, int arg3, PSIZE arg4)
1266{
1267 dprintf(("GDI32: SetViewportExtEx"));
1268 return O32_SetViewportExtEx(arg1, arg2, arg3, arg4);
1269}
1270//******************************************************************************
1271//******************************************************************************
1272BOOL WIN32API SetViewportOrgEx( HDC arg1, int arg2, int arg3, PPOINT arg4)
1273{
1274 dprintf(("GDI32: SetViewportOrgEx"));
1275 return O32_SetViewportOrgEx(arg1, arg2, arg3, arg4);
1276}
1277//******************************************************************************
1278//******************************************************************************
1279BOOL WIN32API SetWindowExtEx( HDC arg1, int arg2, int arg3, PSIZE arg4)
1280{
1281 dprintf(("GDI32: SetWindowExtEx"));
1282 return O32_SetWindowExtEx(arg1, arg2, arg3, arg4);
1283}
1284//******************************************************************************
1285//******************************************************************************
1286BOOL WIN32API SetWindowOrgEx( HDC arg1, int arg2, int arg3, PPOINT arg4)
1287{
1288 dprintf(("GDI32: SetWindowOrgEx"));
1289 return O32_SetWindowOrgEx(arg1, arg2, arg3, arg4);
1290}
1291//******************************************************************************
1292//******************************************************************************
1293BOOL WIN32API SetWorldTransform( HDC arg1, const XFORM *arg2)
1294{
1295 dprintf(("GDI32: SetWorldTransform"));
1296 return O32_SetWorldTransform(arg1, (LPXFORM)arg2);
1297}
1298//******************************************************************************
1299//******************************************************************************
1300INT WIN32API StartDocA( HDC arg1, const DOCINFOA *arg2)
1301{
1302 dprintf(("GDI32: StartDocA"));
1303 return O32_StartDoc(arg1, (LPDOCINFOA)arg2);
1304}
1305//******************************************************************************
1306//******************************************************************************
1307INT WIN32API StartDocW( HDC arg1, const DOCINFOW *arg2)
1308{
1309 dprintf(("GDI32: StartDocW STUB"));
1310 // NOTE: This will not work as is (needs UNICODE support)
1311// return O32_StartDoc(arg1, arg2);
1312 return 0;
1313}
1314//******************************************************************************
1315//******************************************************************************
1316int WIN32API StartPage( HDC arg1)
1317{
1318 dprintf(("GDI32: StartPage"));
1319 return O32_StartPage(arg1);
1320}
1321//******************************************************************************
1322//******************************************************************************
1323BOOL WIN32API UnrealizeObject( HGDIOBJ arg1)
1324{
1325 dprintf(("GDI32: UnrealizeObject"));
1326 return O32_UnrealizeObject(arg1);
1327}
1328//******************************************************************************
1329//******************************************************************************
1330BOOL WIN32API WidenPath( HDC arg1)
1331{
1332 dprintf(("GDI32: WidenPath"));
1333 return O32_WidenPath(arg1);
1334}
1335//******************************************************************************
1336//TODO: Not implemented
1337//******************************************************************************
1338int WIN32API SetAbortProc(HDC hdc, ABORTPROC lpAbortProc)
1339{
1340 dprintf(("GDI32: SetAbortProc - stub (1)w\n"));
1341 return(1);
1342}
1343//******************************************************************************
1344//Selects the current path as a clipping region for a device context, combining
1345//any existing clipping region by using the specified mode
1346//TODO: Can be emulated with SelectClipRegion??
1347//******************************************************************************
1348BOOL WIN32API SelectClipPath(HDC hdc, int iMode)
1349{
1350 dprintf(("GDI32: SelectClipPath, not implemented!(TRUE)\n"));
1351 return(TRUE);
1352}
1353//******************************************************************************
1354//TODO: Sets the color adjustment values for a device context. (used to adjust
1355// the input color of the src bitmap for calls of StretchBlt & StretchDIBits
1356// functions when HALFTONE mode is set
1357//******************************************************************************
1358BOOL WIN32API SetColorAdjustment(HDC hdc, CONST COLORADJUSTMENT *lpca)
1359{
1360 dprintf(("GDI32: SetColorAdjustment, not implemented!(TRUE)\n"));
1361 return(TRUE);
1362}
1363//******************************************************************************
1364//Maps colors to system palette; faster way to update window (instead of redrawing)
1365//We just redraw
1366//******************************************************************************
1367BOOL WIN32API UpdateColors(HDC hdc)
1368{
1369 dprintf(("GDI32: UpdateColors\n"));
1370 return O32_InvalidateRect(O32_WindowFromDC(hdc), NULL, FALSE);
1371}
1372//******************************************************************************
1373//******************************************************************************
1374BOOL WIN32API GdiFlush()
1375{
1376 dprintf(("GDI32: GdiFlush, not implemented (TRUE)\n"));
1377 return(TRUE);
1378}
1379//******************************************************************************
1380//******************************************************************************
1381BOOL WIN32API GdiComment(HDC hdc, UINT cbSize, CONST BYTE *lpData)
1382{
1383 dprintf(("GDI32: GdiComment, not implemented (TRUE)\n"));
1384 return(TRUE);
1385}
1386//******************************************************************************
1387//******************************************************************************
1388BOOL WIN32API GetCharWidthFloatA(HDC hdc, UINT iFirstChar, UINT iLastChar, PFLOAT pxBUffer)
1389{
1390 dprintf(("GDI32: GetCharWidthFloatA, not implemented\n"));
1391 return(FALSE);
1392}
1393//******************************************************************************
1394//******************************************************************************
1395BOOL WIN32API GetCharWidthFloatW(HDC hdc, UINT iFirstChar, UINT iLastChar, PFLOAT pxBUffer)
1396{
1397 dprintf(("GDI32: GetCharWidthFloatW, not implemented\n"));
1398 return(FALSE);
1399}
1400//******************************************************************************
1401//******************************************************************************
1402BOOL WIN32API GetCharABCWidthsFloatA(HDC hdc, UINT iFirstChar, UINT iLastChar, LPABCFLOAT pxBUffer)
1403{
1404 dprintf(("GDI32: GetCharABCWidthsFloatA, not implemented\n"));
1405 return(FALSE);
1406}
1407//******************************************************************************
1408//******************************************************************************
1409BOOL WIN32API GetCharABCWidthsFloatW(HDC hdc,
1410 UINT iFirstChar,
1411 UINT iLastChar,
1412 LPABCFLOAT pxBUffer)
1413{
1414 dprintf(("GDI32: GetCharABCWidthsFloatA, not implemented\n"));
1415 return(FALSE);
1416}
1417//******************************************************************************
1418//******************************************************************************
1419INT WIN32API ExtEscape(HDC hdc, INT nEscape, INT cbInput, LPCSTR lpszInData,
1420 INT cbOutput, LPSTR lpszOutData)
1421{
1422 dprintf(("GDI32: ExtEscape, not implemented\n"));
1423 return(0);
1424}
1425//******************************************************************************
1426//******************************************************************************
1427int WIN32API DrawEscape(HDC hdc, int nEscape, int cbInput, LPCSTR lpszInData)
1428{
1429 dprintf(("GDI32: DrawEscape, not implemented\n"));
1430 return(0);
1431}
1432//******************************************************************************
1433//******************************************************************************
1434BOOL WIN32API GetColorAdjustment(HDC hdc, COLORADJUSTMENT *lpca)
1435{
1436 dprintf(("GDI32: GetColorAdjustment, not implemented\n"));
1437 return(FALSE);
1438}
1439//******************************************************************************
1440//******************************************************************************
1441DWORD WIN32API GetGlyphOutlineA(HDC hdc, UINT uChar, UINT uFormat, LPGLYPHMETRICS lpgm,
1442 DWORD cbBuffer, LPVOID lpvBuffer, CONST MAT2 *lpmat2)
1443{
1444 dprintf(("GDI32: GetGlyphOutLineA, not implemented (GDI_ERROR)\n"));
1445 return(GDI_ERROR);
1446}
1447//******************************************************************************
1448
1449//******************************************************************************
1450/*KSO Thu 21.05.1998*/
1451DWORD WIN32API GetGlyphOutlineW(HDC hdc, UINT uChar, UINT uFormat, LPGLYPHMETRICS lpgm,
1452 DWORD cbBuffer, LPVOID lpvBuffer, CONST MAT2 *lpmat2)
1453{
1454 dprintf(("GDI32: GetGlyphOutLineW, not implemented\n"));
1455 return(GDI_ERROR);
1456}
1457//******************************************************************************
1458
1459//******************************************************************************
1460BOOL WIN32API SetObjectOwner( HGDIOBJ arg1, int arg2 )
1461{
1462 // Here is a guess for a undocumented entry
1463 dprintf(("GDI32: SetObjectOwner - stub (TRUE)\n"));
1464 return TRUE;
1465}
1466//******************************************************************************
1467
1468
1469/* Office 97 stubs - KSO Thu 21.05.1998*/
1470//******************************************************************************
1471BOOL WIN32API GetTextExtentExPointA(/*KSO Thu 21.05.1998*/
1472 HDC hdc,
1473 LPCSTR str,
1474 int count,
1475 int maxExt,
1476 LPINT lpnFit,
1477 LPINT alpDx,
1478 LPSIZE size)
1479{
1480 int index, nFit, extent;
1481 SIZE tSize;
1482
1483 dprintf(("GDI32: GetTextExtendExPointA\n"));
1484
1485 size->cx = size->cy = nFit = extent = 0;
1486 for(index = 0; index < count; index++)
1487 {
1488 if(!O32_GetTextExtentPoint( hdc, str, 1, &tSize )) return FALSE;
1489 if( extent+tSize.cx < maxExt )
1490 {
1491 extent+=tSize.cx;
1492 nFit++;
1493 str++;
1494 if( alpDx )
1495 alpDx[index] = extent;
1496 if( tSize.cy > size->cy ) size->cy = tSize.cy;
1497 }
1498 else break;
1499 }
1500 size->cx = extent;
1501
1502 if (lpnFit != NULL) // check if result is desired
1503 *lpnFit = nFit;
1504
1505 dprintf(("GDI32: GetTextExtendExPointA(%08x '%.*s' %d) returning %d %d %d\n",
1506 hdc,count,str,maxExt,nFit, size->cx,size->cy));
1507 return TRUE;
1508}
1509//******************************************************************************
1510//******************************************************************************
1511BOOL WIN32API GetTextExtentExPointW( /*KSO Thu 21.05.1998*/
1512 HDC arg1,
1513 LPCWSTR arg2,
1514 int arg3,
1515 int arg4,
1516 LPINT arg5,
1517 LPINT arg6,
1518 LPSIZE arg7
1519 )
1520{
1521 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1522 BOOL rc;
1523
1524 dprintf(("GDI32: GetTextExtendExPointW\n"));
1525 rc = GetTextExtentExPointA(arg1, astring, arg3, arg4, arg5, arg6, arg7);
1526 FreeAsciiString(astring);
1527 return rc;
1528}
1529//******************************************************************************
1530//******************************************************************************
1531UINT WIN32API DeleteColorSpace( /*KSO Thu 21.05.1998*/
1532 HCOLORSPACE hColorSpace
1533 )
1534{
1535 dprintf(("GDI32: DeleteColorSpace - stub\n"));
1536 return FALSE;
1537}
1538//******************************************************************************
1539//******************************************************************************
1540BOOL WIN32API SetColorSpace( /*KSO Thu 21.05.1998*/
1541 HDC hdc,
1542 HCOLORSPACE hColorSpace
1543 )
1544{
1545 dprintf(("GDI32: SetColorSpace - stub\n"));
1546 return FALSE;
1547}
1548//******************************************************************************
1549//******************************************************************************
1550 HCOLORSPACE WIN32API CreateColorSpaceA( /*KSO Thu 21.05.1998*/
1551 LPLOGCOLORSPACEA lpLogColorSpace
1552 )
1553{
1554 dprintf(("GDI32: CreateColorSpaceA - stub\n"));
1555 return 0;
1556}
1557//******************************************************************************
1558//******************************************************************************
1559HCOLORSPACE WIN32API CreateColorSpaceW( /*KSO Thu 21.05.1998*/
1560 LPLOGCOLORSPACEW lpwLogColorSpace
1561 )
1562{
1563 dprintf(("GDI32: CreateColorSpaceW - stub\n"));
1564 return 0;
1565}
1566//******************************************************************************
1567//******************************************************************************
1568HANDLE WIN32API GetColorSpace( /*KSO Thu 21.05.1998*/
1569 HDC hdc
1570 )
1571{
1572 dprintf(("GDI32: GetColorSpace - stub\n"));
1573 return 0;
1574}
1575//******************************************************************************
1576//******************************************************************************
1577int WIN32API SetICMMode( /*KSO Thu 21.05.1998*/
1578 HDC hdc,
1579 int mode
1580 )
1581{
1582 dprintf(("GDI32: SetICMMode - stub\n"));
1583 return 0;
1584}
1585//******************************************************************************
1586
1587
1588
1589
1590/*****************************************************************************
1591 * Name : BOOL CancelDC
1592 * Purpose : The CancelDC function cancels any pending operation on the
1593 * specified device context (DC).
1594 * Parameters: HDC hdc handle of device context
1595 * Variables :
1596 * Result : TRUE / FALSE
1597 * Remark :
1598 * Status : UNTESTED STUB
1599 *
1600 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1601 *****************************************************************************/
1602
1603BOOL WIN32API CancelDC(HDC hdc)
1604{
1605 dprintf(("GDI32: CancelDC(%08xh) not implemented.\n",
1606 hdc));
1607
1608 return (FALSE);
1609}
1610
1611
1612/*****************************************************************************
1613 * Name : BOOL CheckColorsInGamut
1614 * Purpose : The CheckColorsInGamut function indicates whether the specified
1615 * color values are within the gamut of the specified device.
1616 * Parameters: HDC hdc handle of device context
1617 * LPVOID lpaRGBQuad
1618 * LPVOID lpResult
1619 * DWORD dwResult
1620 * Variables :
1621 * Result : TRUE / FALSE
1622 * Remark :
1623 * Status : UNTESTED STUB
1624 *
1625 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1626 *****************************************************************************/
1627
1628BOOL WIN32API CheckColorsInGamut(HDC hdc,
1629 LPVOID lpaRGBQuad,
1630 LPVOID lpResult,
1631 DWORD dwResult)
1632{
1633 dprintf(("GDI32: CheckColorsInGamut(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1634 hdc,
1635 lpaRGBQuad,
1636 lpResult,
1637 dwResult));
1638
1639 return (FALSE);
1640}
1641
1642
1643/*****************************************************************************
1644 * Name : BOOL ColorMatchToTarget
1645 * Purpose : The ColorMatchToTarget function enables or disables preview for
1646 * the specified device context. When preview is enabled, colors
1647 * in subsequent output to the specified device context are
1648 * displayed as they would appear on the target device. This is
1649 * useful for checking how well the target maps the specified
1650 * colors in an image. To enable preview, image color matching
1651 * must be enabled for both the target and the preview device context.
1652 * Parameters: HDC hdc handle of device context
1653 * HDC hdcTarget handle of target device context
1654 * DWORD uiAction
1655 * Variables :
1656 * Result : TRUE / FALSE
1657 * Remark :
1658 * Status : UNTESTED STUB
1659 *
1660 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1661 *****************************************************************************/
1662
1663BOOL WIN32API ColorMatchToTarget(HDC hdc,
1664 HDC hdcTarget,
1665 DWORD uiAction)
1666{
1667 dprintf(("GDI32: ColorMatchToTarget(%08xh,%08xh,%08xh) not implemented.\n",
1668 hdc,
1669 hdcTarget,
1670 uiAction));
1671
1672 return (FALSE);
1673}
1674
1675
1676/*****************************************************************************
1677 * Name : BOOL CombineTransform
1678 * Purpose : The CombineTransform function concatenates two world-space to
1679 * page-space transformations.
1680 * Parameters: LLPXFORM lLPXFORMResult address of combined transformation
1681 * XFORM *lLPXFORM1 address of 1st transformation
1682 * XFORM *lLPXFORM2 address of 2nd transformation
1683 * Variables :
1684 * Result : TRUE / FALSE
1685 * Remark :
1686 * Status : UNTESTED
1687 *
1688 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1689 * Markus Montkowski [Wen, 1999/01/12 20:18]
1690 *****************************************************************************/
1691
1692BOOL WIN32API CombineTransform(LPXFORM lLPXFORMResult,
1693 CONST XFORM *lLPXFORM1,
1694 CONST XFORM *lLPXFORM2)
1695{
1696 dprintf(("GDI32: CombineTransform(%08xh,%08xh,%08xh).\n",
1697 lLPXFORMResult,
1698 lLPXFORM1,
1699 lLPXFORM2));
1700
1701 XFORM xfrm;
1702 if( O32_IsBadWritePtr( (void*)lLPXFORMResult, sizeof(XFORM)) ||
1703 O32_IsBadReadPtr( (void*)lLPXFORM1, sizeof(XFORM)) ||
1704 O32_IsBadWritePtr( (void*)lLPXFORM2, sizeof(XFORM)) )
1705 return (FALSE);
1706
1707 // Add the translations
1708 lLPXFORMResult->eDx = lLPXFORM1->eDx + lLPXFORM2->eDx;
1709 lLPXFORMResult->eDy = lLPXFORM1->eDy + lLPXFORM2->eDy;
1710
1711 // Multiply the matrixes
1712 xfrm.eM11 = lLPXFORM1->eM11 * lLPXFORM2->eM11 + lLPXFORM1->eM21 * lLPXFORM1->eM12;
1713 xfrm.eM12 = lLPXFORM1->eM11 * lLPXFORM2->eM12 + lLPXFORM1->eM12 * lLPXFORM1->eM22;
1714 xfrm.eM21 = lLPXFORM1->eM21 * lLPXFORM2->eM11 + lLPXFORM1->eM22 * lLPXFORM1->eM21;
1715 xfrm.eM22 = lLPXFORM1->eM21 * lLPXFORM2->eM12 + lLPXFORM1->eM22 * lLPXFORM1->eM22;
1716
1717 // Now copy to resulting XFROM as the pt must not be distinct
1718 lLPXFORMResult->eM11 = xfrm.eM11;
1719 lLPXFORMResult->eM12 = xfrm.eM12;
1720 lLPXFORMResult->eM21 = xfrm.eM21;
1721 lLPXFORMResult->eM22 = xfrm.eM22;
1722
1723 return (TRUE);
1724}
1725
1726
1727
1728/*****************************************************************************
1729 * Name : HBRUSH CreateDIBPatternBrush
1730 * Purpose : The CreateDIBPatternBrush function creates a logical brush that
1731 * has the pattern specified by the specified device-independent
1732 * bitmap (DIB). The brush can subsequently be selected into any
1733 * device context that is associated with a device that supports
1734 * raster operations.
1735 * This function is provided only for compatibility with applications
1736 * written for versions of Windows earlier than 3.0. For Win32-based
1737 * applications, use the CreateDIBPatternBrushPt function.
1738 * Parameters: HGLOBAL hglbDIBPacked Identifies a global memory object containing
1739 * a packed DIB, which consists of a BITMAPINFO structure immediately
1740 * followed by an array of bytes defining the pixels of the bitmap.
1741 * UINT fuColorSpec color table data
1742 * Variables :
1743 * Result : TRUE / FALSE
1744 * Remark :
1745 * Status : UNTESTED
1746 *
1747 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1748 * Markus Montkowski [Wen, 1999/01/12 20:00]
1749 *****************************************************************************/
1750
1751HBRUSH WIN32API CreateDIBPatternBrush( HGLOBAL hglbDIBPacked,
1752 UINT fuColorSpec)
1753{
1754 LPVOID lpMem;
1755 HBRUSH ret = 0;
1756 dprintf(("GDI32: CreateDIBPatternBrush(%08xh, %08xh) \n",
1757 hglbDIBPacked,
1758 fuColorSpec));
1759
1760 lpMem = GlobalLock(hglbDIBPacked);
1761 if(NULL!=lpMem)
1762 {
1763
1764 ret = CreateDIBPatternBrushPt( lpMem,
1765 fuColorSpec);
1766 GlobalUnlock(hglbDIBPacked);
1767 }
1768
1769 return (ret);
1770}
1771
1772
1773
1774
1775/*****************************************************************************
1776 * Name : int EnumICMProfilesA
1777 * Purpose : The EnumICMProfilesA function enumerates the different color
1778 * profiles that the system supports for the specified device context.
1779 * Parameters: HDC hdc
1780 * ICMENUMPROC lpICMEnumFunc
1781 * LPARAM lParam
1782 * Variables :
1783 * Result : TRUE / FALSE
1784 * Remark :
1785 * Status : UNTESTED STUB
1786 *
1787 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1788 *****************************************************************************/
1789
1790int WIN32API EnumICMProfilesA(HDC hdc,
1791 ICMENUMPROCA lpICMEnumProc,
1792 LPARAM lParam)
1793{
1794 dprintf(("GDI32: EnumICMProfilesA(%08xh, %08xh, %08xh) not implemented(-1).\n",
1795 hdc,
1796 lpICMEnumProc,
1797 lParam));
1798
1799 return (-1);
1800}
1801
1802
1803/*****************************************************************************
1804 * Name : int EnumICMProfilesW
1805 * Purpose : The EnumICMProfilesW function enumerates the different color
1806 * profiles that the system supports for the specified device context.
1807 * Parameters: HDC hdc
1808 * ICMENUMPROC lpICMEnumFunc
1809 * LPARAM lParam
1810 * Variables :
1811 * Result : TRUE / FALSE
1812 * Remark :
1813 * Status : UNTESTED STUB
1814 *
1815 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1816 *****************************************************************************/
1817
1818int WIN32API EnumICMProfilesW(HDC hdc,
1819 ICMENUMPROCW lpICMEnumProc,
1820 LPARAM lParam)
1821{
1822 dprintf(("GDI32: EnumICMProfilesW(%08xh, %08xh, %08xh) not implemented (-1).\n",
1823 hdc,
1824 lpICMEnumProc,
1825 lParam));
1826
1827 return (-1);
1828}
1829
1830
1831/*****************************************************************************
1832 * Name : BOOL FixBrushOrgEx
1833 * Purpose : The FixBrushOrgEx function is not implemented in the Win32 API.
1834 * It is provided for compatibility with Win32s. If called, the
1835 * function does nothing, and returns FALSE.
1836 * Parameters: HDC, int, int, LPPOINT
1837 * Variables :
1838 * Result : TRUE / FALSE
1839 * Remark : not implemented in Win32
1840 * Status : UNTESTED STUB
1841 *
1842 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1843 *****************************************************************************/
1844
1845BOOL WIN32API FixBrushOrgEx(HDC hdc,
1846 int iDummy1,
1847 int iDummy2,
1848 LPPOINT lpPoint)
1849{
1850 dprintf(("GDI32: FixBrushOrgEx(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1851 hdc,
1852 iDummy1,
1853 iDummy2,
1854 lpPoint));
1855
1856 return (FALSE);
1857}
1858
1859
1860/*****************************************************************************
1861 * Name : DWORD GdiGetBatchLimit
1862 * Purpose : The GdiGetBatchLimit function returns the maximum number of
1863 * function calls that can be accumulated in the calling thread's
1864 * current batch. The system flushes the current batch whenever
1865 * this limit is exceeded.
1866 * Parameters:
1867 * Variables :
1868 * Result : 1
1869 * Remark :
1870 * Status : UNTESTED STUB
1871 *
1872 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1873 *****************************************************************************/
1874
1875DWORD WIN32API GdiGetBatchLimit(VOID)
1876{
1877 dprintf(("GDI32: GdiGetBatchLimit() not implemented (1).\n"));
1878
1879 return (1);
1880}
1881
1882
1883/*****************************************************************************
1884 * Name : DWORD GdiSetBatchLimit
1885 * Purpose : The GdiSetBatchLimit function sets the maximum number of
1886 * functions that can be accumulated in the calling thread's current
1887 * batch. The system flushes the current batch whenever this limit
1888 * is exceeded.
1889 * Parameters: DWORD dwLimit
1890 * Variables :
1891 * Result :
1892 * Remark :
1893 * Status : UNTESTED STUB
1894 *
1895 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1896 *****************************************************************************/
1897
1898DWORD WIN32API GdiSetBatchLimit(DWORD dwLimit)
1899{
1900 dprintf(("GDI32: GdiSetBatchLimit(%08xh) not implemented (1).\n",
1901 dwLimit));
1902
1903 return (1);
1904}
1905
1906
1907/*****************************************************************************
1908 * Name : DWORD GetCharacterPlacementA
1909 * Purpose : The GetCharacterPlacementA function retrieves information about
1910 * a character string, such as character widths, caret positioning,
1911 * ordering within the string, and glyph rendering. The type of
1912 * information returned depends on the dwFlags parameter and is
1913 * based on the currently selected font in the given display context.
1914 * The function copies the information to the specified GCP_RESULTSA
1915 * structure or to one or more arrays specified by the structure.
1916 * Parameters: HDC hdc handle to device context
1917 * LPCSTR lpString pointer to string
1918 * int nCount number of characters in string
1919 * int nMaxExtent maximum extent for displayed string
1920 * LPGCP_RESULTSA *lpResults pointer to buffer for placement result
1921 * DWORD dwFlags placement flags
1922 * Variables :
1923 * Result :
1924 * Remark :
1925 * Status : UNTESTED STUB
1926 *
1927 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1928 *****************************************************************************/
1929
1930DWORD WIN32API GetCharacterPlacementA(HDC hdc,
1931 LPCSTR lpString,
1932 int nCount,
1933 int nMaxExtent,
1934 GCP_RESULTSA * lpResults,
1935 DWORD dwFlags)
1936{
1937 dprintf(("GDI32: GetCharacterPlacementA(%08xh,%s,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1938 hdc,
1939 lpString,
1940 nCount,
1941 nMaxExtent,
1942 lpResults,
1943 dwFlags));
1944
1945 return (0);
1946}
1947
1948
1949/*****************************************************************************
1950 * Name : DWORD GetCharacterPlacementW
1951 * Purpose : The GetCharacterPlacementW function retrieves information about
1952 * a character string, such as character widths, caret positioning,
1953 * ordering within the string, and glyph rendering. The type of
1954 * information returned depends on the dwFlags parameter and is
1955 * based on the currently selected font in the given display context.
1956 * The function copies the information to the specified GCP_RESULTSW
1957 * structure or to one or more arrays specified by the structure.
1958 * Parameters: HDC hdc handle to device context
1959 * LPCSTR lpString pointer to string
1960 * int nCount number of characters in string
1961 * int nMaxExtent maximum extent for displayed string
1962 * GCP_RESULTSW *lpResults pointer to buffer for placement result
1963 * DWORD dwFlags placement flags
1964 * Variables :
1965 * Result :
1966 * Remark :
1967 * Status : UNTESTED STUB
1968 *
1969 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1970 *****************************************************************************/
1971
1972DWORD WIN32API GetCharacterPlacementW(HDC hdc,
1973 LPCWSTR lpString,
1974 int nCount,
1975 int nMaxExtent,
1976 GCP_RESULTSW *lpResults,
1977 DWORD dwFlags)
1978{
1979 dprintf(("GDI32: GetCharacterPlacementW(%08xh,%s,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1980 hdc,
1981 lpString,
1982 nCount,
1983 nMaxExtent,
1984 lpResults,
1985 dwFlags));
1986
1987 return (0);
1988}
1989
1990
1991/*****************************************************************************
1992 * Name : DWORD GetDeviceGammaRamp
1993 * Purpose : The GetDeviceGammaRamp function retrieves the gamma ramp on
1994 * direct color display boards.
1995 * Parameters: HDC hdc handle to device context
1996 * LPVOID lpRamp Gamma ramp array
1997 * Variables :
1998 * Result :
1999 * Remark :
2000 * Status : UNTESTED STUB
2001 *
2002 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2003 *****************************************************************************/
2004
2005DWORD WIN32API GetDeviceGammaRamp(HDC hdc,
2006 LPVOID lpRamp)
2007{
2008 dprintf(("GDI32: GetDeviceGammaRamp(%08xh, %08xh) not implemented.\n",
2009 hdc,
2010 lpRamp));
2011
2012 return (FALSE);
2013}
2014
2015
2016
2017
2018/*****************************************************************************
2019 * Name : BOOL GetICMProfileA
2020 * Purpose : The GetICMProfileA function retrieves the name of the color
2021 * profile file for the device associated with the specified device
2022 * context.
2023 * Parameters: HDC hdc handle to device context
2024 * DWORD cbName
2025 * LPTSTR lpszFilename
2026 * Variables :
2027 * Result : TRUE / FALSE
2028 * Remark :
2029 * Status : UNTESTED STUB
2030 *
2031 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2032 *****************************************************************************/
2033
2034BOOL WIN32API GetICMProfileA(HDC hdc,
2035 DWORD cbName,
2036 LPTSTR lpszFilename)
2037{
2038 dprintf(("GDI32: GetICMProfileA(%08xh, %08xh, %08xh) not implemented.\n",
2039 hdc,
2040 cbName,
2041 lpszFilename));
2042
2043 return (FALSE);
2044}
2045
2046
2047/*****************************************************************************
2048 * Name : BOOL GetICMProfileW
2049 * Purpose : The GetICMProfileW function retrieves the name of the color
2050 * profile file for the device associated with the specified device
2051 * context.
2052 * Parameters: HDC hdc handle to device context
2053 * DWORD cbName
2054 * LPWSTR lpszFilename
2055 * Variables :
2056 * Result : TRUE / FALSE
2057 * Remark :
2058 * Status : UNTESTED STUB
2059 *
2060 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2061 *****************************************************************************/
2062
2063BOOL WIN32API GetICMProfileW(HDC hdc,
2064 DWORD cbName,
2065 LPTSTR lpszFilename)
2066{
2067 dprintf(("GDI32: GetICMProfileW(%08xh, %08xh, %08xh) not implemented.\n",
2068 hdc,
2069 cbName,
2070 lpszFilename));
2071
2072 return (FALSE);
2073}
2074
2075
2076/*****************************************************************************
2077 * Name : BOOL GetLogColorSpaceA
2078 * Purpose : The GetLogColorSpace function retrieves information about the
2079 * logical color space identified by the specified handle.
2080 * Parameters: HCOLORSPACE hColorSpace
2081 * LPLOGCOLORSPACE lpbuffer
2082 * DWORD nSize
2083 * Variables :
2084 * Result : TRUE / FALSE
2085 * Remark :
2086 * Status : UNTESTED STUB
2087 *
2088 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2089 *****************************************************************************/
2090
2091#define LPLOGCOLORSPACE LPVOID
2092BOOL WIN32API GetLogColorSpaceA(HCOLORSPACE hColorSpace,
2093 LPLOGCOLORSPACE lpBuffer,
2094 DWORD nSize)
2095{
2096 dprintf(("GDI32: GetLogColorSpaceA(%08xh, %08xh, %08xh) not implemented.\n",
2097 hColorSpace,
2098 lpBuffer,
2099 nSize));
2100
2101 return (FALSE);
2102}
2103
2104
2105/*****************************************************************************
2106 * Name : BOOL GetLogColorSpaceW
2107 * Purpose : The GetLogColorSpace function retrieves information about the
2108 * logical color space identified by the specified handle.
2109 * Parameters: HCOLORSPACE hColorSpace
2110 * LPLOGCOLORSPACE lpbuffer
2111 * DWORD nSize
2112 * Variables :
2113 * Result : TRUE / FALSE
2114 * Remark :
2115 * Status : UNTESTED STUB
2116 *
2117 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2118 *****************************************************************************/
2119
2120BOOL WIN32API GetLogColorSpaceW(HCOLORSPACE hColorSpace,
2121 LPLOGCOLORSPACE lpBuffer,
2122 DWORD nSize)
2123{
2124 dprintf(("GDI32: GetLogColorSpaceW(%08xh, %08xh, %08xh) not implemented.\n",
2125 hColorSpace,
2126 lpBuffer,
2127 nSize));
2128
2129 return (FALSE);
2130}
2131
2132
2133/*****************************************************************************
2134 * Name : BOOL SetDeviceGammaRamp
2135 * Purpose : The SetDeviceGammaRamp function sets the gamma ramp on direct
2136 * color display boards.
2137 * Parameters: HDC hdc handle of device context
2138 * LPVOID lpRamp
2139 * Variables :
2140 * Result : TRUE / FALSE
2141 * Remark :
2142 * Status : UNTESTED STUB
2143 *
2144 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2145 *****************************************************************************/
2146
2147BOOL WIN32API SetDeviceGammaRamp(HDC hdc,
2148 LPVOID lpRamp)
2149{
2150 dprintf(("GDI32: SetDeviceGammaRamp(%08xh, %08xh) not implemented.\n",
2151 hdc,
2152 lpRamp));
2153
2154 return (FALSE);
2155}
2156
2157
2158/*****************************************************************************
2159 * Name : BOOL SetICMProfileA
2160 * Purpose : The SetICMProfileA function sets the color profile for the
2161 * specified device context.
2162 * Parameters: HDC hdc handle of device context
2163 * LPTSTR lpFileName
2164 * Variables :
2165 * Result : TRUE / FALSE
2166 * Remark :
2167 * Status : UNTESTED STUB
2168 *
2169 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2170 *****************************************************************************/
2171
2172BOOL WIN32API SetICMProfileA(HDC hdc,
2173 LPTSTR lpFileName)
2174{
2175 dprintf(("GDI32: SetICMProfileA(%08xh, %s) not implemented.\n",
2176 hdc,
2177 lpFileName));
2178
2179 return (FALSE);
2180}
2181
2182
2183/*****************************************************************************
2184 * Name : BOOL SetICMProfileW
2185 * Purpose : The SetICMProfileW function sets the color profile for the
2186 * specified device context.
2187 * Parameters: HDC hdc handle of device context
2188 * LPTSTR lpFileName
2189 * Variables :
2190 * Result : TRUE / FALSE
2191 * Remark :
2192 * Status : UNTESTED STUB
2193 *
2194 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2195 *****************************************************************************/
2196
2197BOOL WIN32API SetICMProfileW(HDC hdc,
2198 LPWSTR lpFileName)
2199{
2200 dprintf(("GDI32: SetICMProfileW(%08xh, %s) not implemented.\n",
2201 hdc,
2202 lpFileName));
2203
2204 return (FALSE);
2205}
2206
2207
2208
2209/*****************************************************************************
2210 * Name : BOOL UpdateICMRegKeyA
2211 * Purpose : The UpdateICMRegKeyA function installs, removes, or queries
2212 * registry entries that identify ICC color profiles or color-matching
2213 * DLLs. The function carries out the action specified by the nCommand
2214 * parameter.
2215 * Parameters: DWORD dwReserved
2216 * DWORD CMID
2217 * LPTSTR lpszFileName
2218 * UINT nCommand
2219 * Variables :
2220 * Result : TRUE / FALSE
2221 * Remark :
2222 * Status : UNTESTED STUB
2223 *
2224 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2225 *****************************************************************************/
2226
2227BOOL WIN32API UpdateICMRegKeyA(DWORD dwReserved,
2228 DWORD CMID,
2229 LPTSTR lpszFileName,
2230 UINT nCommand)
2231{
2232 dprintf(("GDI32: UpdateICMRegKeyA(%08xh, %08xh, %08xh, %08xh) not implemented.\n",
2233 dwReserved,
2234 CMID,
2235 lpszFileName,
2236 nCommand));
2237
2238 return (FALSE);
2239}
2240
2241
2242/*****************************************************************************
2243 * Name : BOOL UpdateICMRegKeyW
2244 * Purpose : The UpdateICMRegKeyW function installs, removes, or queries
2245 * registry entries that identify ICC color profiles or color-matching
2246 * DLLs. The function carries out the action specified by the nCommand
2247 * parameter.
2248 * Parameters: DWORD dwReserved
2249 * DWORD CMID
2250 * LPWSTR lpszFileName
2251 * UINT nCommand
2252 * Variables :
2253 * Result : TRUE / FALSE
2254 * Remark :
2255 * Status : UNTESTED STUB
2256 *
2257 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2258 *****************************************************************************/
2259
2260BOOL WIN32API UpdateICMRegKeyW(DWORD dwReserved,
2261 DWORD CMID,
2262 LPWSTR lpszFileName,
2263 UINT nCommand)
2264{
2265 dprintf(("GDI32: UpdateICMRegKeyW(%08xh, %08xh, %08xh, %08xh) not implemented.\n",
2266 dwReserved,
2267 CMID,
2268 lpszFileName,
2269 nCommand));
2270
2271 return (FALSE);
2272}
2273
2274
2275
Note: See TracBrowser for help on using the repository browser.