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

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

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