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

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

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