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

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

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