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

Last change on this file since 4214 was 4214, checked in by phaller, 25 years ago

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