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

Last change on this file since 3648 was 3648, checked in by sandervl, 25 years ago

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