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

Last change on this file since 2273 was 2273, checked in by sandervl, 26 years ago

GetObjectType logging with dprintf2
File size: 129.1 KB
Line 
1/* $Id: gdi32.cpp,v 1.28 1999-12-30 18:51:48 sandervl Exp $ */
2
3/*
4 * GDI32 apis
5 *
6 * Copyright 1998 Sander van Leeuwen (sandervl@xs4all.nl)
7 * Copyright 1998 Patrick Haller
8 *
9 * Project Odin Software License can be found in LICENSE.TXT
10 *
11 */
12#include <os2win.h>
13#include <stdlib.h>
14#include <stdarg.h>
15#include <string.h>
16#include "misc.h"
17#include "callback.h"
18#include "unicode.h"
19#include "dibsect.h"
20
21static ULONG QueryPaletteSize(BITMAPINFOHEADER *pBHdr)
22{
23 ULONG cbPalette;
24
25 switch (pBHdr->biBitCount)
26 {
27 case 1:
28 case 4:
29 case 8:
30 cbPalette = (1 << pBHdr->biBitCount) * sizeof(RGBQUAD);
31 break;
32
33 case 16:
34 case 24:
35 case 32:
36 cbPalette = 0;
37 break;
38
39 default:
40 dprintf(("QueryPaletteSize: error pBHdr->biBitCount = %d", pBHdr->biBitCount));
41 cbPalette = -1;
42 }
43
44 return cbPalette;
45}
46
47static ULONG CalcBitmapSize(ULONG cBits, LONG cx, LONG cy)
48{
49 ULONG alignment;
50 ULONG factor;
51 BOOL flag = TRUE; //true: '*' false: '/'
52
53 cy = cy < 0 ? -cy : cy;
54
55 switch(cBits)
56 {
57 case 1:
58 factor = 8;
59 flag = FALSE;
60 break;
61
62 case 4:
63 factor = 2;
64 flag = FALSE;
65 break;
66
67 case 8:
68 factor = 1;
69 break;
70
71 case 16:
72 factor = 2;
73 break;
74
75 case 24:
76 factor = 3;
77 break;
78
79 case 32:
80 return cx*cy;
81
82 default:
83 return 0;
84 }
85
86 if (flag)
87 alignment = (cx = (cx*factor)) % 4;
88 else
89 alignment = (cx = ((cx+factor-1)/factor)) % 4;
90
91 if (alignment != 0)
92 cx += 4 - alignment;
93
94 return cx*cy;
95}
96
97//******************************************************************************
98//******************************************************************************
99BOOL WIN32API GetTextExtentPointA(HDC hdc, LPCSTR lpsz, int cbString, LPSIZE lpSize)
100{
101 BOOL rc;
102
103 lpSize->cx = lpSize->cy = 0;
104 rc = O32_GetTextExtentPoint(hdc, lpsz, cbString, lpSize);
105 dprintf(("GDI32: GetTextExtentPointA of %s returned %d\n", lpsz, rc));
106 return(rc);
107}
108//******************************************************************************
109//******************************************************************************
110COLORREF WIN32API SetBkColor(HDC hdc, COLORREF crColor)
111{
112 dprintf(("GDI32: SetBkColor to %X\n", crColor));
113 return(O32_SetBkColor(hdc, crColor));
114}
115//******************************************************************************
116//******************************************************************************
117COLORREF WIN32API SetTextColor(HDC hdc, COLORREF crColor)
118{
119 COLORREF clr;
120
121 clr = O32_SetTextColor(hdc, crColor);
122 dprintf(("GDI32: SetTextColor from %X to %X\n", clr, crColor));
123 return(clr);
124}
125//******************************************************************************
126//******************************************************************************
127
128static hFntDefaultGui = NULL;
129HGDIOBJ WIN32API GetStockObject(int arg1)
130{
131 HGDIOBJ obj;
132
133 switch(arg1)
134 {
135 case DEFAULT_GUI_FONT:
136 if(NULL==hFntDefaultGui)
137 hFntDefaultGui = CreateFontA( 9, 0, 0, 0, FW_MEDIUM, FALSE,
138 FALSE, FALSE, ANSI_CHARSET,
139 OUT_DEFAULT_PRECIS,
140 CLIP_DEFAULT_PRECIS,
141 DEFAULT_QUALITY,
142 FIXED_PITCH|FF_MODERN, "WarpSans");
143 obj = hFntDefaultGui;
144 break;
145 default:
146 obj = O32_GetStockObject(arg1);
147 break;
148 }
149 dprintf(("GDI32: GetStockObject %d returned %X\n", arg1, obj));
150 return(obj);
151}
152//******************************************************************************
153//******************************************************************************
154UINT WIN32API RealizePalette( HDC arg1)
155{
156 dprintf(("GDI32: RealizePalette(0x%08X)\n",arg1));
157 return O32_RealizePalette(arg1);
158}
159//******************************************************************************
160//******************************************************************************
161int WIN32API GetObjectA( HGDIOBJ hObject, int size, void *lpBuffer)
162{
163 int rc;
164
165 if(size == 0 || lpBuffer == NULL) {
166 SetLastError(ERROR_INVALID_PARAMETER);
167 return 0;
168 }
169
170 if(DIBSection::getSection() != NULL)
171 {
172 DIBSection *dsect = DIBSection::find(hObject);
173 if(dsect)
174 {
175 rc = dsect->GetDIBSection(size, lpBuffer);
176 if(rc == 0) {
177 SetLastError(ERROR_INVALID_PARAMETER);
178 return 0;
179 }
180 SetLastError(ERROR_SUCCESS);
181 return rc;
182 }
183 }
184
185 dprintf(("GDI32: GetObject %X %X %X\n", hObject, size, lpBuffer));
186 return O32_GetObject(hObject, size, lpBuffer);
187}
188//******************************************************************************
189//******************************************************************************
190int WIN32API GetObjectW( HGDIOBJ arg1, int arg2, void * arg3)
191{
192 dprintf(("GDI32: GetObjectW %X, %d %X not complete!", arg1, arg2, arg3));
193 return GetObjectA(arg1, arg2, arg3);
194}
195//******************************************************************************
196//******************************************************************************
197DWORD WIN32API GetObjectType( HGDIOBJ arg1)
198{
199 dprintf2(("GDI32: GetObjectType\n"));
200 return O32_GetObjectType(arg1);
201}
202//******************************************************************************
203//******************************************************************************
204BOOL WIN32API DeleteObject(HANDLE hObj)
205{
206 dprintf(("GDI32: DeleteObject %x", hObj));
207 DIBSection::deleteSection((DWORD)hObj);
208 return O32_DeleteObject(hObj);
209}
210//******************************************************************************
211//******************************************************************************
212BOOL WIN32API DeleteDC( HDC hdc)
213{
214 dprintf(("GDI32: DeleteDC %x", hdc));
215 return O32_DeleteDC(hdc);
216}
217//******************************************************************************
218//******************************************************************************
219HPALETTE WIN32API CreatePalette( const LOGPALETTE * arg1)
220{
221 HPALETTE rc;
222 dprintf(("GDI32: CreatePalette\n"));
223 for(int i=0; i<arg1->palNumEntries;i++)
224 {
225 dprintf2(("Index %d : 0x%08X\n",i, *((DWORD*)(&arg1->palPalEntry[i])) ));
226 }
227 rc = O32_CreatePalette(arg1);
228 dprintf((" returns 0x%08X\n",rc));
229
230 return rc;
231}
232//******************************************************************************
233//******************************************************************************
234HBRUSH WIN32API CreatePatternBrush(HBITMAP arg1)
235{
236 HBRUSH brush;
237
238 brush = O32_CreatePatternBrush(arg1);
239 dprintf(("GDI32: CreatePatternBrush from bitmap %X returned %X\n", arg1, brush));
240 return(brush);
241}
242//******************************************************************************
243//******************************************************************************
244HPEN WIN32API CreatePen( int arg1, int arg2, COLORREF arg3)
245{
246 dprintf(("GDI32: CreatePen\n"));
247 return O32_CreatePen(arg1, arg2, arg3);
248}
249//******************************************************************************
250//******************************************************************************
251HPEN WIN32API CreatePenIndirect( const LOGPEN * arg1)
252{
253 dprintf(("GDI32: CreatePenIndirect\n"));
254 return O32_CreatePenIndirect(arg1);
255}
256//******************************************************************************
257//******************************************************************************
258HRGN WIN32API CreatePolyPolygonRgn( const POINT * arg1, const INT * arg2, int arg3, int arg4)
259{
260 dprintf(("GDI32: CreatePolyPolygonRgn\n"));
261 return O32_CreatePolyPolygonRgn(arg1, arg2, arg3, arg4);
262}
263//******************************************************************************
264//******************************************************************************
265HRGN WIN32API CreatePolygonRgn(const POINT * arg1, int arg2, int arg3)
266{
267 dprintf(("GDI32: CreatePolygonRgn"));
268 return O32_CreatePolygonRgn(arg1, arg2, arg3);
269}
270//******************************************************************************
271//******************************************************************************
272HBRUSH WIN32API CreateDIBPatternBrushPt( const VOID * arg1, UINT arg2)
273{
274 dprintf(("GDI32: CreateDIBPatternBrushPt\n"));
275 return O32_CreateDIBPatternBrushPt(arg1, arg2);
276}
277//******************************************************************************
278//******************************************************************************
279HBITMAP WIN32API CreateDIBitmap(HDC arg1, const BITMAPINFOHEADER * arg2, DWORD arg3, const void * arg4, const BITMAPINFO * arg5, UINT arg6)
280{
281 int iHeight;
282 HBITMAP rc;
283 dprintf(("GDI32: CreateDIBitmap\n"));
284
285 //TEMPORARY HACK TO PREVENT CRASH IN OPEN32 (WSeB GA)
286
287 iHeight = arg2->biHeight;
288 if(arg2->biHeight < 0)
289 {
290 ((BITMAPINFOHEADER *)arg2)->biHeight = -arg2->biHeight;
291 }
292
293 rc = O32_CreateDIBitmap(arg1, arg2, arg3, arg4, arg5, arg6);
294
295 ((BITMAPINFOHEADER *)arg2)->biHeight = iHeight;
296
297 return rc;
298}
299//******************************************************************************
300//******************************************************************************
301HBITMAP WIN32API CreateCompatibleBitmap( HDC arg1, int arg2, int arg3)
302{
303 dprintf(("GDI32: CreateCompatibleBitmap\n"));
304 return O32_CreateCompatibleBitmap(arg1, arg2, arg3);
305}
306//******************************************************************************
307//******************************************************************************
308HDC WIN32API CreateCompatibleDC( HDC arg1)
309{
310 HDC rc;
311
312 rc = O32_CreateCompatibleDC(arg1);
313 dprintf(("GDI32: CreateCompatibleDC %X returned %x", arg1, rc));
314 return rc;
315}
316//******************************************************************************
317//******************************************************************************
318INT WIN32API StretchDIBits(HDC hdc, INT xDst, INT yDst, INT widthDst,
319 INT heightDst, INT xSrc, INT ySrc, INT widthSrc,
320 INT heightSrc, const void *bits,
321 const BITMAPINFO *info, UINT wUsage, DWORD dwRop )
322{
323#if 1
324 dprintf(("GDI32: StretchDIBits"));
325
326 if(wUsage == DIB_PAL_COLORS && info->bmiHeader.biSize == sizeof(BITMAPINFOHEADER))
327 {
328 // workaround for open32 bug.
329 // If syscolors > 256 and wUsage == DIB_PAL_COLORS.
330
331 int i;
332 USHORT *pColorIndex = (USHORT *)info->bmiColors;
333 RGBQUAD *pColors = (RGBQUAD *) alloca(info->bmiHeader.biClrUsed *
334 sizeof(RGBQUAD));
335 BITMAPINFO *infoLoc = (BITMAPINFO *) alloca(sizeof(BITMAPINFO) +
336 info->bmiHeader.biClrUsed * sizeof(RGBQUAD));
337
338 memcpy(infoLoc, info, sizeof(BITMAPINFO));
339
340 if(GetDIBColorTable(hdc, 0, info->bmiHeader.biClrUsed, pColors) == 0)
341 return FALSE;
342
343 for(i=0;i<info->bmiHeader.biClrUsed;i++, pColorIndex++)
344 {
345 infoLoc->bmiColors[i] = pColors[*pColorIndex];
346 }
347
348 return O32_StretchDIBits(hdc, xDst, yDst, widthDst, heightDst, xSrc, ySrc,
349 widthSrc, heightSrc, (void *)bits,
350 (PBITMAPINFO)infoLoc, DIB_RGB_COLORS, dwRop);
351 }
352
353 return O32_StretchDIBits(hdc, xDst, yDst, widthDst, heightDst, xSrc, ySrc,
354 widthSrc, heightSrc, (void *)bits,
355 (PBITMAPINFO)info, wUsage, dwRop);
356#else
357 dprintf(("GDI32: StretchDIBits\n"));
358 return O32_StretchDIBits(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, (void *)arg10, (PBITMAPINFO)arg11, arg12, arg13);
359#endif
360}
361//******************************************************************************
362//******************************************************************************
363BOOL WIN32API StretchBlt(HDC hdcDest, int nXOriginDest, int nYOriginDest,
364 int nWidthDest, int nHeightDest,
365 HDC hdcSrc, int nXOriginSrc, int nYOriginSrc,
366 int nWidthSrc, int nHeightSrc, DWORD dwRop)
367{
368 dprintf(("GDI32: StretchBlt Dest: (%d, %d) size (%d, %d)\n",
369 nXOriginDest, nYOriginDest, nWidthDest, nHeightDest));
370 dprintf(("GDI32: StretchBlt Src : (%d, %d) size (%d, %d)\n",
371 nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc));
372 if(DIBSection::getSection() != NULL)
373 {
374 DIBSection *dsect = DIBSection::findHDC(hdcSrc);
375 if(dsect)
376 {
377 dprintf((" Do stretched DIB Blt\n"));
378 return(dsect->BitBlt( hdcDest,
379 nXOriginDest, nYOriginDest, nWidthDest, nHeightDest,
380 nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc,
381 dwRop));
382 }
383 }
384 return O32_StretchBlt(hdcDest, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, hdcSrc, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc, dwRop);
385}
386//******************************************************************************
387//******************************************************************************
388BOOL WIN32API StrokeAndFillPath( HDC arg1)
389{
390 dprintf(("GDI32: StrokeAndFillPath\n"));
391 return O32_StrokeAndFillPath(arg1);
392}
393//******************************************************************************
394//******************************************************************************
395BOOL WIN32API StrokePath( HDC arg1)
396{
397 dprintf(("GDI32: StrokePath\n"));
398 return O32_StrokePath(arg1);
399}
400//******************************************************************************
401//******************************************************************************
402int WIN32API SetStretchBltMode( HDC arg1, int arg2)
403{
404 dprintf(("GDI32: SetStretchBltMode 0x%08X, 0x%08X\n",arg1, arg2));
405
406 if(DIBSection::getSection() != NULL)
407 {
408 DIBSection *dsect = DIBSection::findHDC(arg1);
409 if(dsect)
410 {
411 dprintf((" - DC is DIBSection\n"));
412 }
413 }
414 return O32_SetStretchBltMode(arg1, arg2);
415}
416//******************************************************************************
417//******************************************************************************
418HGDIOBJ WIN32API SelectObject(HDC hdc, HGDIOBJ hObj)
419{
420 HGDIOBJ rc;
421
422//// dprintf(("GDI32: SelectObject\n"));
423
424 if(DIBSection::getSection() != NULL)
425 {
426 DIBSection *dsect;
427
428 dsect = DIBSection::find(hdc);
429 if(dsect)
430 {
431 //remove previously selected dibsection
432 dsect->UnSelectDIBObject();
433 }
434 dsect = DIBSection::find((DWORD)hObj);
435 if(dsect)
436 {
437 dsect->SelectDIBObject(hdc);
438 }
439 }
440 rc = O32_SelectObject(hdc, hObj);
441 if(rc != 0 && DIBSection::getSection != NULL)
442 {
443 DIBSection *dsect = DIBSection::find((DWORD)rc);
444 if(dsect)
445 {
446 dsect->UnSelectDIBObject();
447 }
448 }
449 return(rc);
450}
451//******************************************************************************
452//******************************************************************************
453HPALETTE WIN32API SelectPalette(HDC arg1, HPALETTE arg2, BOOL arg3)
454{
455 dprintf(("GDI32: SelectPalette (0x%08X, 0x%08X, 0x%08X)\n", arg1, arg2, arg3));
456 if(DIBSection::getSection() != NULL)
457 {
458 DIBSection *dsect = DIBSection::findHDC(arg1);
459 if(dsect)
460 {
461 PALETTEENTRY Pal[256];
462 char PalSize = dsect->GetBitCount();
463 dprintf((" - Set Palette Values in DIBSection\n"));
464 if(PalSize<=8)
465 {
466 GetPaletteEntries( arg2, 0, 1<<PalSize, (LPPALETTEENTRY)&Pal);
467 dsect->SetDIBColorTable(0, 1<< PalSize, (RGBQUAD*)&Pal);
468 }
469
470 }
471 }
472 return O32_SelectPalette(arg1, arg2, arg3);
473}
474//******************************************************************************
475//******************************************************************************
476int WIN32API SetBkMode( HDC arg1, int arg2)
477{
478 dprintf(("GDI32: SetBkMode\n"));
479 return O32_SetBkMode(arg1, arg2);
480}
481//******************************************************************************
482//******************************************************************************
483COLORREF WIN32API GetPixel( HDC arg1, int arg2, int arg3)
484{
485//// dprintf(("GDI32: GetPixel\n"));
486 return O32_GetPixel(arg1, arg2, arg3);
487}
488//******************************************************************************
489//******************************************************************************
490COLORREF WIN32API SetPixel( HDC arg1, int arg2, int arg3, COLORREF arg4)
491{
492//// dprintf(("GDI32: SetPixel\n"));
493 return O32_SetPixel(arg1, arg2, arg3, arg4);
494}
495//******************************************************************************
496//Faster version of SetPixel (since it doesn't need to return the original color)
497//Just use SetPixel for now
498//******************************************************************************
499BOOL WIN32API SetPixelV(HDC arg1, int arg2, int arg3, COLORREF arg4)
500{
501 COLORREF rc;
502
503//// dprintf(("GDI32: SetPixelV\n"));
504 rc = O32_SetPixel(arg1, arg2, arg3, arg4);
505 if(rc == GDI_ERROR) // || rc == COLOR_INVALID)
506 return(FALSE);
507 return(TRUE);
508}
509//******************************************************************************
510//******************************************************************************
511BOOL WIN32API GetDCOrgEx(HDC arg1, PPOINT arg2)
512{
513 dprintf(("GDI32: GetDCOrgEx\n"));
514 return O32_GetDCOrgEx(arg1, arg2);
515}
516//******************************************************************************
517//******************************************************************************
518BOOL WIN32API GetWindowExtEx(HDC arg1, PSIZE arg2)
519{
520 dprintf(("GDI32: GetWindowExtEx\n"));
521 return O32_GetWindowExtEx(arg1, arg2);
522}
523//******************************************************************************
524//******************************************************************************
525int WIN32API AbortDoc( HDC arg1)
526{
527 dprintf(("GDI32: AbortDoc"));
528 return O32_AbortDoc(arg1);
529}
530//******************************************************************************
531//******************************************************************************
532BOOL WIN32API AbortPath( HDC arg1)
533{
534 dprintf(("GDI32: AbortPath"));
535 return O32_AbortPath(arg1);
536}
537//******************************************************************************
538//******************************************************************************
539BOOL WIN32API AngleArc( HDC arg1, int arg2, int arg3, DWORD arg4, float arg5, float arg6)
540{
541 dprintf(("GDI32: AngleArc"));
542 return O32_AngleArc(arg1, arg2, arg3, arg4, arg5, arg6);
543}
544//******************************************************************************
545//******************************************************************************
546BOOL WIN32API AnimatePalette( HPALETTE arg1, UINT arg2, UINT arg3, const PALETTEENTRY * arg4)
547{
548 dprintf(("GDI32: AnimatePalette"));
549 return O32_AnimatePalette(arg1, arg2, arg3, arg4);
550}
551//******************************************************************************
552//******************************************************************************
553BOOL WIN32API Arc( HDC arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9)
554{
555 dprintf(("GDI32: Arc"));
556 return O32_Arc(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
557}
558//******************************************************************************
559//******************************************************************************
560BOOL WIN32API ArcTo( HDC arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9)
561{
562 dprintf(("GDI32: ArcTo"));
563 return O32_ArcTo(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
564}
565//******************************************************************************
566//******************************************************************************
567BOOL WIN32API BeginPath( HDC arg1)
568{
569 dprintf(("GDI32: BeginPath"));
570 return O32_BeginPath(arg1);
571}
572//******************************************************************************
573//******************************************************************************
574BOOL WIN32API BitBlt(HDC hdcDest, int arg2, int arg3, int arg4, int arg5, HDC hdcSrc, int arg7, int arg8, DWORD arg9)
575{
576 if(DIBSection::getSection() != NULL) {
577 DIBSection *dsect = DIBSection::findHDC(hdcSrc);
578 if(dsect) {
579 return(dsect->BitBlt(hdcDest, arg2, arg3, arg4, arg5, arg7, arg8, arg4, arg5, arg9));
580 }
581 }
582 dprintf(("GDI32: BitBlt to hdc %X from (%d,%d) to (%d,%d), (%d,%d) rop %X\n", hdcDest, arg7, arg8, arg2, arg3, arg4, arg5, arg9));
583 return O32_BitBlt(hdcDest, arg2, arg3, arg4, arg5, hdcSrc, arg7, arg8, arg9);
584}
585//******************************************************************************
586//******************************************************************************
587BOOL WIN32API Chord( HDC arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9)
588{
589 dprintf(("GDI32: Chord"));
590 return O32_Chord(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
591}
592//******************************************************************************
593//******************************************************************************
594HENHMETAFILE WIN32API CloseEnhMetaFile( HDC arg1)
595{
596 dprintf(("GDI32: CloseEnhMetaFile"));
597 return O32_CloseEnhMetaFile(arg1);
598}
599//******************************************************************************
600//******************************************************************************
601BOOL WIN32API CloseFigure( HDC arg1)
602{
603 dprintf(("GDI32: CloseFigure"));
604 return O32_CloseFigure(arg1);
605}
606//******************************************************************************
607//******************************************************************************
608HMETAFILE WIN32API CloseMetaFile( HDC arg1)
609{
610 dprintf(("GDI32: CloseMetaFile"));
611 return O32_CloseMetaFile(arg1);
612}
613//******************************************************************************
614//******************************************************************************
615int WIN32API CombineRgn( HRGN arg1, HRGN arg2, HRGN arg3, int arg4)
616{
617 dprintf(("GDI32: CombineRgn"));
618 return O32_CombineRgn(arg1, arg2, arg3, arg4);
619}
620//******************************************************************************
621//******************************************************************************
622HENHMETAFILE WIN32API CopyEnhMetaFileA( HENHMETAFILE arg1, LPCSTR arg2)
623{
624 dprintf(("GDI32: CopyEnhMetaFileA"));
625 return O32_CopyEnhMetaFile(arg1, arg2);
626}
627//******************************************************************************
628//******************************************************************************
629HENHMETAFILE WIN32API CopyEnhMetaFileW( HENHMETAFILE arg1, LPCWSTR arg2)
630{
631 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
632 HENHMETAFILE rc;
633
634 dprintf(("GDI32: CopyEnhMetaFileW"));
635 rc = O32_CopyEnhMetaFile(arg1, astring);
636 FreeAsciiString(astring);
637 return rc;
638}
639//******************************************************************************
640//******************************************************************************
641HMETAFILE WIN32API CopyMetaFileA( HMETAFILE arg1, LPCSTR arg2)
642{
643 dprintf(("GDI32: CopyMetaFileA"));
644 return O32_CopyMetaFile(arg1, arg2);
645}
646//******************************************************************************
647//******************************************************************************
648HMETAFILE WIN32API CopyMetaFileW( HMETAFILE arg1, LPCWSTR arg2)
649{
650 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
651 HMETAFILE rc;
652
653 dprintf(("GDI32: CopyMetaFileW"));
654 rc = O32_CopyMetaFile(arg1, astring);
655 FreeAsciiString(astring);
656 return rc;
657}
658//******************************************************************************
659//******************************************************************************
660HBITMAP WIN32API CreateBitmap(int nWidth, int nHeight, UINT cPlanes,
661 UINT cBitsPerPel, const void *lpvBits)
662{
663 HBITMAP rc;
664
665 rc = O32_CreateBitmap(nWidth, nHeight, cPlanes, cBitsPerPel, lpvBits);
666 dprintf(("GDI32: CreateBitmap (%d,%d) bps %d returned %d\n", nWidth, nHeight, cBitsPerPel, rc));
667 return(rc);
668}
669//******************************************************************************
670//******************************************************************************
671HBITMAP WIN32API CreateBitmapIndirect( const BITMAP * arg1)
672{
673 dprintf(("GDI32: CreateBitmapIndirect"));
674 return O32_CreateBitmapIndirect(arg1);
675}
676//******************************************************************************
677//******************************************************************************
678HBRUSH WIN32API CreateBrushIndirect( const LOGBRUSH * arg1)
679{
680 dprintf(("GDI32: CreateBrushIndirect"));
681 return O32_CreateBrushIndirect((LPLOGBRUSH)arg1);
682}
683//******************************************************************************
684//******************************************************************************
685HDC WIN32API CreateDCA( LPCSTR arg1, LPCSTR arg2, LPCSTR arg3, const DEVMODEA * arg4)
686{
687 dprintf(("GDI32: CreateDCA"));
688 return O32_CreateDC(arg1, arg2, arg3, arg4);
689}
690//******************************************************************************
691//******************************************************************************
692HDC WIN32API CreateDCW( LPCWSTR arg1, LPCWSTR arg2, LPCWSTR arg3, const DEVMODEW * arg4)
693{
694 char *astring4, *astring5;
695
696 char *astring1 = UnicodeToAsciiString((LPWSTR)arg1);
697 char *astring2 = UnicodeToAsciiString((LPWSTR)arg2);
698 char *astring3 = UnicodeToAsciiString((LPWSTR)arg3);
699
700 if(arg4)
701 {
702 astring4 = UnicodeToAsciiString((LPWSTR)(arg4->dmDeviceName));
703 astring5 = UnicodeToAsciiString((LPWSTR)(arg4->dmFormName));
704 }
705
706 HDC rc;
707 DEVMODEA devmode;
708
709 dprintf(("GDI32: CreateDCW"));
710
711 if(arg4)
712 {
713 strcpy((char*)devmode.dmDeviceName, astring4);
714 strcpy((char*)devmode.dmFormName, astring5);
715
716 devmode.dmSpecVersion = arg4->dmSpecVersion;
717 devmode.dmDriverVersion = arg4->dmDriverVersion;
718 devmode.dmSize = arg4->dmSize;
719 devmode.dmDriverExtra = arg4->dmDriverExtra;
720 devmode.dmFields = arg4->dmFields;
721 devmode.dmOrientation = arg4->dmOrientation;
722 devmode.dmPaperSize = arg4->dmPaperSize;
723 devmode.dmPaperLength = arg4->dmPaperLength;
724 devmode.dmPaperWidth = arg4->dmPaperWidth;
725 devmode.dmScale = arg4->dmScale;
726 devmode.dmCopies = arg4->dmCopies;
727 devmode.dmDefaultSource = arg4->dmDefaultSource;
728 devmode.dmPrintQuality = arg4->dmPrintQuality;
729 devmode.dmColor = arg4->dmColor;
730 devmode.dmDuplex = arg4->dmDuplex;
731 devmode.dmYResolution = arg4->dmYResolution;
732 devmode.dmTTOption = arg4->dmTTOption;
733 devmode.dmCollate = arg4->dmCollate;
734 devmode.dmLogPixels = arg4->dmLogPixels;
735 devmode.dmBitsPerPel = arg4->dmBitsPerPel;
736 devmode.dmPelsWidth = arg4->dmPelsWidth;
737 devmode.dmPelsHeight = arg4->dmPelsHeight;
738 devmode.dmDisplayFlags = arg4->dmDisplayFlags;
739 devmode.dmDisplayFrequency = arg4->dmDisplayFrequency;
740 devmode.dmICMMethod = arg4->dmICMMethod;
741 devmode.dmICMIntent = arg4->dmICMIntent;
742 devmode.dmMediaType = arg4->dmMediaType;
743 devmode.dmDitherType = arg4->dmDitherType;
744 devmode.dmReserved1 = arg4->dmReserved1;
745 devmode.dmReserved2 = arg4->dmReserved2;
746 rc = O32_CreateDC(astring1,astring2,astring3,&devmode);
747 }
748 else
749 rc = O32_CreateDC(astring1,astring2,astring3, NULL);
750
751 FreeAsciiString(astring1);
752 FreeAsciiString(astring2);
753 FreeAsciiString(astring3);
754
755 if(arg4)
756 {
757 FreeAsciiString(astring4);
758 FreeAsciiString(astring5);
759 }
760
761 return rc;
762}
763//******************************************************************************
764//******************************************************************************
765HRGN WIN32API CreateEllipticRgn( int arg1, int arg2, int arg3, int arg4)
766{
767 dprintf(("GDI32: CreateEllipticRgn"));
768 return O32_CreateEllipticRgn(arg1, arg2, arg3, arg4);
769}
770//******************************************************************************
771//******************************************************************************
772HRGN WIN32API CreateEllipticRgnIndirect( const RECT * arg1)
773{
774 dprintf(("GDI32: CreateEllipticRgnIndirect"));
775 return O32_CreateEllipticRgnIndirect(arg1);
776}
777//******************************************************************************
778//******************************************************************************
779HENHMETAFILE WIN32API CreateEnhMetaFileA( HDC arg1, LPCSTR arg2, const RECT * arg3, LPCSTR arg4)
780{
781 dprintf(("GDI32: CreateEnhMetaFileA"));
782 return O32_CreateEnhMetaFile(arg1, arg2, arg3, arg4);
783}
784//******************************************************************************
785//******************************************************************************
786HENHMETAFILE WIN32API CreateEnhMetaFileW( HDC arg1, LPCWSTR arg2, const RECT * arg3, LPCWSTR arg4)
787{
788 char *astring1 = UnicodeToAsciiString((LPWSTR)arg2);
789 char *astring2 = UnicodeToAsciiString((LPWSTR)arg4);
790 HENHMETAFILE rc;
791
792 dprintf(("GDI32: CreateMetaFileW"));
793 rc = O32_CreateEnhMetaFile(arg1,astring1,arg3,astring2);
794 FreeAsciiString(astring1);
795 FreeAsciiString(astring2);
796 return rc;
797}
798//******************************************************************************
799//******************************************************************************
800//******************************************************************************
801//******************************************************************************
802HBRUSH WIN32API CreateHatchBrush( int arg1, COLORREF arg2)
803{
804 dprintf(("GDI32: CreateHatchBrush"));
805 return O32_CreateHatchBrush(arg1, arg2);
806}
807//******************************************************************************
808//******************************************************************************
809HDC WIN32API CreateICA( LPCSTR arg1, LPCSTR arg2, LPCSTR arg3, const DEVMODEA * arg4)
810{
811 dprintf(("GDI32: CreateICA"));
812 return O32_CreateIC(arg1, arg2, arg3, arg4);
813}
814//******************************************************************************
815//******************************************************************************
816HDC WIN32API CreateICW( LPCWSTR arg1, LPCWSTR arg2, LPCWSTR arg3, const DEVMODEW * arg4)
817{
818 char *astring4, *astring5;
819
820 char *astring1 = UnicodeToAsciiString((LPWSTR)arg1);
821 char *astring2 = UnicodeToAsciiString((LPWSTR)arg2);
822 char *astring3 = UnicodeToAsciiString((LPWSTR)arg3);
823 if(arg4)
824 {
825 astring4 = UnicodeToAsciiString((LPWSTR)(arg4->dmDeviceName));
826 astring5 = UnicodeToAsciiString((LPWSTR)(arg4->dmFormName));
827 }
828
829 HDC rc;
830 DEVMODEA devmode;
831
832 dprintf(("GDI32: CreateICW"));
833
834 if(arg4)
835 {
836 strcpy((char*)devmode.dmDeviceName, astring4);
837 strcpy((char*)devmode.dmFormName, astring5);
838
839 devmode.dmSpecVersion = arg4->dmSpecVersion;
840 devmode.dmDriverVersion = arg4->dmDriverVersion;
841 devmode.dmSize = arg4->dmSize;
842 devmode.dmDriverExtra = arg4->dmDriverExtra;
843 devmode.dmFields = arg4->dmFields;
844 devmode.dmOrientation = arg4->dmOrientation;
845 devmode.dmPaperSize = arg4->dmPaperSize;
846 devmode.dmPaperLength = arg4->dmPaperLength;
847 devmode.dmPaperWidth = arg4->dmPaperWidth;
848 devmode.dmScale = arg4->dmScale;
849 devmode.dmCopies = arg4->dmCopies;
850 devmode.dmDefaultSource = arg4->dmDefaultSource;
851 devmode.dmPrintQuality = arg4->dmPrintQuality;
852 devmode.dmColor = arg4->dmColor;
853 devmode.dmDuplex = arg4->dmDuplex;
854 devmode.dmYResolution = arg4->dmYResolution;
855 devmode.dmTTOption = arg4->dmTTOption;
856 devmode.dmCollate = arg4->dmCollate;
857 devmode.dmLogPixels = arg4->dmLogPixels;
858 devmode.dmBitsPerPel = arg4->dmBitsPerPel;
859 devmode.dmPelsWidth = arg4->dmPelsWidth;
860 devmode.dmPelsHeight = arg4->dmPelsHeight;
861 devmode.dmDisplayFlags = arg4->dmDisplayFlags;
862 devmode.dmDisplayFrequency = arg4->dmDisplayFrequency;
863 devmode.dmICMMethod = arg4->dmICMMethod;
864 devmode.dmICMIntent = arg4->dmICMIntent;
865 devmode.dmMediaType = arg4->dmMediaType;
866 devmode.dmDitherType = arg4->dmDitherType;
867 devmode.dmReserved1 = arg4->dmReserved1;
868 devmode.dmReserved2 = arg4->dmReserved2;
869
870 rc = O32_CreateIC(astring1,astring2,astring3,&devmode);
871 }
872 else
873 rc = O32_CreateIC(astring1,astring2,astring3, NULL);
874
875 FreeAsciiString(astring1);
876 FreeAsciiString(astring2);
877 FreeAsciiString(astring3);
878 if(arg4)
879 {
880 FreeAsciiString(astring4);
881 FreeAsciiString(astring5);
882 }
883
884 return rc;
885}
886//******************************************************************************
887//******************************************************************************
888HDC WIN32API CreateMetaFileA( LPCSTR arg1)
889{
890 dprintf(("GDI32: CreateMetaFileA"));
891 return O32_CreateMetaFile(arg1);
892}
893//******************************************************************************
894//******************************************************************************
895HDC WIN32API CreateMetaFileW( LPCWSTR arg1)
896{
897 char *astring = UnicodeToAsciiString((LPWSTR)arg1);
898 HDC rc;
899
900 dprintf(("GDI32: CreateMetaFileW"));
901 rc = O32_CreateMetaFile(astring);
902 FreeAsciiString(astring);
903 return rc;
904}
905//******************************************************************************
906//******************************************************************************
907HRGN WIN32API CreateRectRgn( int nLeftRect, int nTopRect, int nRightRect, int nBottomRect)
908{
909 dprintf(("GDI32: CreateRectRgn (%d,%d)(%d,%d)", nLeftRect, nTopRect, nRightRect, nBottomRect));
910 return O32_CreateRectRgn(nLeftRect, nTopRect, nRightRect, nBottomRect);
911}
912//******************************************************************************
913//******************************************************************************
914HRGN WIN32API CreateRectRgnIndirect( const RECT * lpRect)
915{
916 if(lpRect == NULL) {
917 SetLastError(ERROR_INVALID_PARAMETER);
918 return 0;
919 }
920 dprintf(("GDI32: CreateRectRgnIndirect (%d,%d)(%d,%d)", lpRect->left, lpRect->top, lpRect->right, lpRect->bottom));
921 return O32_CreateRectRgnIndirect(lpRect);
922}
923//******************************************************************************
924//******************************************************************************
925HRGN WIN32API CreateRoundRectRgn(int nLeftRect, int nTopRect, int nRightRect, int nBottomRect,
926 int nWidthEllipse, int nHeightEllipse)
927{
928 dprintf(("GDI32: CreateRoundRectRgn (%d,%d)(%d,%d) (%d,%d)", nLeftRect, nTopRect, nRightRect, nBottomRect, nWidthEllipse, nHeightEllipse));
929 return O32_CreateRoundRectRgn(nLeftRect, nTopRect, nRightRect, nBottomRect, nWidthEllipse, nHeightEllipse);
930}
931//******************************************************************************
932//******************************************************************************
933HBRUSH WIN32API CreateSolidBrush( COLORREF arg1)
934{
935 dprintf(("GDI32: CreateSolidBrush\n"));
936 return O32_CreateSolidBrush(arg1);
937}
938//******************************************************************************
939//******************************************************************************
940BOOL WIN32API DPtoLP( HDC arg1, PPOINT arg2, int arg3)
941{
942 dprintf(("GDI32: DPtoLP\n"));
943 return O32_DPtoLP(arg1, arg2, arg3);
944}
945//******************************************************************************
946//******************************************************************************
947BOOL WIN32API DeleteEnhMetaFile( HENHMETAFILE arg1)
948{
949 dprintf(("GDI32: DeleteEnhMetaFile\n"));
950 return O32_DeleteEnhMetaFile(arg1);
951}
952//******************************************************************************
953//******************************************************************************
954BOOL WIN32API DeleteMetaFile( HMETAFILE arg1)
955{
956 dprintf(("GDI32: DeleteMetaFile"));
957 return O32_DeleteMetaFile(arg1);
958}
959//******************************************************************************
960//******************************************************************************
961BOOL WIN32API Ellipse( HDC arg1, int arg2, int arg3, int arg4, int arg5)
962{
963 dprintf(("GDI32: Ellipse"));
964 return O32_Ellipse(arg1, arg2, arg3, arg4, arg5);
965}
966//******************************************************************************
967//******************************************************************************
968int WIN32API EndDoc( HDC arg1)
969{
970 dprintf(("GDI32: EndDoc"));
971 return O32_EndDoc(arg1);
972}
973//******************************************************************************
974//******************************************************************************
975int WIN32API EndPage( HDC arg1)
976{
977 dprintf(("GDI32: EndPage"));
978 return O32_EndPage(arg1);
979}
980//******************************************************************************
981//******************************************************************************
982BOOL WIN32API EndPath( HDC arg1)
983{
984 dprintf(("GDI32: EndPath"));
985 return O32_EndPath(arg1);
986}
987//******************************************************************************
988//******************************************************************************
989BOOL WIN32API EnumEnhMetaFile( HDC arg1, HENHMETAFILE arg2, ENHMFENUMPROC arg3, PVOID arg4, const RECT * arg5)
990{
991 dprintf(("GDI32: EnumEnhMetaFile DOESN'T WORK!"));
992// return O32_EnumEnhMetaFile(arg1, arg2, arg3, arg4, arg5);
993 return 0;
994}
995//******************************************************************************
996//******************************************************************************
997BOOL WIN32API PatBlt( HDC arg1, int arg2, int arg3, int arg4, int arg5, DWORD arg6)
998{
999 BOOL rc;
1000
1001 rc = O32_PatBlt(arg1, arg2, arg3, arg4, arg5, arg6);
1002 dprintf(("GDI32: PatBlt (%d,%d) (%d,%d) returned %d\n", arg2, arg3, arg4, arg5, rc));
1003 return(rc);
1004}
1005//******************************************************************************
1006//******************************************************************************
1007BOOL WIN32API Rectangle( HDC arg1, int arg2, int arg3, int arg4, int arg5)
1008{
1009 dprintf(("GDI32: Rectangle\n"));
1010 return O32_Rectangle(arg1, arg2, arg3, arg4, arg5);
1011}
1012//******************************************************************************
1013//******************************************************************************
1014int WIN32API SetROP2( HDC arg1, int arg2)
1015{
1016 dprintf(("GDI32: SetROP2"));
1017 return O32_SetROP2(arg1, arg2);
1018}
1019//******************************************************************************
1020//TODO: Callback
1021//******************************************************************************
1022BOOL WIN32API EnumMetaFile( HDC arg1, HMETAFILE arg2, MFENUMPROC arg3, LPARAM arg4)
1023{
1024 dprintf(("GDI32: EnumMetaFile STUB"));
1025 //calling convention differences
1026// return O32_EnumMetaFile(arg1, arg2, arg3, arg4);
1027 return 0;
1028}
1029//******************************************************************************
1030//******************************************************************************
1031int WIN32API EnumObjects( HDC arg1, int arg2, GOBJENUMPROC arg3, LPARAM arg4)
1032{
1033 dprintf(("GDI32: EnumObjects STUB"));
1034 //calling convention differences
1035// return O32_EnumObjects(arg1, arg2, arg3, arg4);
1036 return 0;
1037}
1038//******************************************************************************
1039//******************************************************************************
1040BOOL WIN32API EqualRgn( HRGN arg1, HRGN arg2)
1041{
1042 dprintf(("GDI32: EqualRgn"));
1043 return O32_EqualRgn(arg1, arg2);
1044}
1045//******************************************************************************
1046//******************************************************************************
1047int WIN32API Escape( HDC arg1, int arg2, int arg3, LPCSTR arg4, PVOID arg5)
1048{
1049 dprintf(("GDI32: Escape"));
1050 return O32_Escape(arg1, arg2, arg3, arg4, arg5);
1051}
1052//******************************************************************************
1053//******************************************************************************
1054int WIN32API ExcludeClipRect( HDC arg1, int arg2, int arg3, int arg4, int arg5)
1055{
1056 dprintf(("GDI32: ExcludeClipRect"));
1057 return O32_ExcludeClipRect(arg1, arg2, arg3, arg4, arg5);
1058}
1059//******************************************************************************
1060//******************************************************************************
1061HPEN WIN32API ExtCreatePen( DWORD arg1, DWORD arg2, const LOGBRUSH * arg3, DWORD arg4, const DWORD * arg5)
1062{
1063 dprintf(("GDI32: ExtCreatePen"));
1064 return O32_ExtCreatePen(arg1, arg2, arg3, arg4, arg5);
1065}
1066//******************************************************************************
1067//******************************************************************************
1068HRGN WIN32API ExtCreateRegion( const XFORM * arg1, DWORD arg2, const RGNDATA * arg3)
1069{
1070 dprintf(("GDI32: ExtCreateRegion"));
1071 return O32_ExtCreateRegion(arg1, arg2, arg3);
1072}
1073//******************************************************************************
1074//******************************************************************************
1075BOOL WIN32API ExtFloodFill( HDC arg1, int arg2, int arg3, COLORREF arg4, UINT arg5)
1076{
1077 dprintf(("GDI32: ExtFloodFill"));
1078 return O32_ExtFloodFill(arg1, arg2, arg3, arg4, arg5);
1079}
1080//******************************************************************************
1081//******************************************************************************
1082int WIN32API ExtSelectClipRgn( HDC arg1, HRGN arg2, int arg3)
1083{
1084 dprintf(("GDI32: ExtSelectClipRgn"));
1085 return O32_ExtSelectClipRgn(arg1, arg2, arg3);
1086}
1087//******************************************************************************
1088//******************************************************************************
1089BOOL WIN32API FillPath( HDC arg1)
1090{
1091 dprintf(("GDI32: FillPath"));
1092 return O32_FillPath(arg1);
1093}
1094//******************************************************************************
1095//******************************************************************************
1096BOOL WIN32API FillRgn( HDC arg1, HRGN arg2, HBRUSH arg3)
1097{
1098 dprintf(("GDI32: FillRgn"));
1099 return O32_FillRgn(arg1, arg2, arg3);
1100}
1101//******************************************************************************
1102//******************************************************************************
1103BOOL WIN32API FlattenPath( HDC arg1)
1104{
1105 dprintf(("GDI32: FlattenPath"));
1106 return O32_FlattenPath(arg1);
1107}
1108//******************************************************************************
1109//******************************************************************************
1110BOOL WIN32API FloodFill(HDC arg1, int arg2, int arg3, COLORREF arg4)
1111{
1112 dprintf(("GDI32: FloodFill"));
1113 return O32_FloodFill(arg1, arg2, arg3, arg4);
1114}
1115//******************************************************************************
1116//******************************************************************************
1117BOOL WIN32API FrameRgn( HDC arg1, HRGN arg2, HBRUSH arg3, int arg4, int arg5)
1118{
1119 dprintf(("GDI32: FrameRgn"));
1120 return O32_FrameRgn(arg1, arg2, arg3, arg4, arg5);
1121}
1122//******************************************************************************
1123//******************************************************************************
1124int WIN32API GetArcDirection( HDC arg1)
1125{
1126 dprintf(("GDI32: GetArcDirection"));
1127 return O32_GetArcDirection(arg1);
1128}
1129//******************************************************************************
1130//******************************************************************************
1131BOOL WIN32API GetAspectRatioFilterEx( HDC arg1, PSIZE arg2)
1132{
1133 dprintf(("GDI32: GetAspectRatioFilterEx"));
1134 return O32_GetAspectRatioFilterEx(arg1, arg2);
1135}
1136//******************************************************************************
1137//******************************************************************************
1138LONG WIN32API GetBitmapBits( HBITMAP arg1, LONG arg2, PVOID arg3)
1139{
1140 dprintf(("GDI32: GetBitmapBits"));
1141 return O32_GetBitmapBits(arg1, arg2, arg3);
1142}
1143//******************************************************************************
1144//******************************************************************************
1145BOOL WIN32API GetBitmapDimensionEx( HBITMAP arg1, PSIZE arg2)
1146{
1147 dprintf(("GDI32: GetBitmapDimensionEx"));
1148 return O32_GetBitmapDimensionEx(arg1, arg2);
1149}
1150//******************************************************************************
1151//******************************************************************************
1152COLORREF WIN32API GetBkColor( HDC arg1)
1153{
1154 dprintf(("GDI32: GetBkColor"));
1155 return O32_GetBkColor(arg1);
1156}
1157//******************************************************************************
1158//******************************************************************************
1159int WIN32API GetBkMode( HDC arg1)
1160{
1161 dprintf(("GDI32: GetBkMode"));
1162 return O32_GetBkMode(arg1);
1163}
1164//******************************************************************************
1165//******************************************************************************
1166UINT WIN32API GetBoundsRect( HDC arg1, PRECT arg2, UINT arg3)
1167{
1168 dprintf(("GDI32: GetBoundsRect"));
1169 return O32_GetBoundsRect(arg1, arg2, arg3);
1170}
1171//******************************************************************************
1172//******************************************************************************
1173BOOL WIN32API GetBrushOrgEx( HDC arg1, PPOINT arg2)
1174{
1175 dprintf(("GDI32: GetBrushOrgEx"));
1176 return O32_GetBrushOrgEx(arg1, arg2);
1177}
1178//******************************************************************************
1179//******************************************************************************
1180BOOL WIN32API GetCharABCWidthsA( HDC arg1, UINT arg2, UINT arg3, LPABC arg4)
1181{
1182 dprintf(("GDI32: GetCharABCWidthsA"));
1183 return O32_GetCharABCWidths(arg1, arg2, arg3, arg4);
1184}
1185//******************************************************************************
1186//******************************************************************************
1187BOOL WIN32API GetCharABCWidthsW( HDC arg1, UINT arg2, UINT arg3, LPABC arg4)
1188{
1189 dprintf(("GDI32: GetCharABCWidthsW not properly implemented."));
1190 // NOTE: This will not work as is (needs UNICODE support)
1191 return O32_GetCharABCWidths(arg1, arg2, arg3, arg4);
1192}
1193//******************************************************************************
1194//******************************************************************************
1195BOOL WIN32API GetCharWidthA( HDC arg1, UINT arg2, UINT arg3, PINT arg4)
1196{
1197 dprintf(("GDI32: GetCharWidthA"));
1198 return O32_GetCharWidth(arg1, arg2, arg3, arg4);
1199}
1200//******************************************************************************
1201//TODO: Cut off Unicode chars?
1202//******************************************************************************
1203BOOL WIN32API GetCharWidthW(HDC arg1, UINT iFirstChar, UINT iLastChar, PINT arg4)
1204{
1205 dprintf(("GDI32: GetCharWidthW, not properly implemented"));
1206 return O32_GetCharWidth(arg1, iFirstChar, iLastChar, arg4);
1207}
1208//******************************************************************************
1209//******************************************************************************
1210int WIN32API GetClipBox( HDC arg1, PRECT arg2)
1211{
1212 int rc;
1213
1214 rc = O32_GetClipBox(arg1, arg2);
1215 dprintf(("GDI32: GetClipBox of %X returned %d\n", arg1, rc));
1216 return(rc);
1217}
1218//******************************************************************************
1219//******************************************************************************
1220int WIN32API GetClipRgn( HDC arg1, HRGN arg2)
1221{
1222 dprintf(("GDI32: GetClipRgn"));
1223 return O32_GetClipRgn(arg1, arg2);
1224}
1225//******************************************************************************
1226//******************************************************************************
1227HANDLE WIN32API GetCurrentObject( HDC arg1, UINT arg2)
1228{
1229 dprintf(("GDI32: GetCurrentObject"));
1230 return (HANDLE)O32_GetCurrentObject(arg1, arg2);
1231}
1232//******************************************************************************
1233//******************************************************************************
1234BOOL WIN32API GetCurrentPositionEx( HDC arg1, PPOINT arg2)
1235{
1236 dprintf(("GDI32: GetCurrentPositionEx"));
1237 return O32_GetCurrentPositionEx(arg1, arg2);
1238}
1239//******************************************************************************
1240//******************************************************************************
1241int WIN32API GetDIBits( HDC arg1, HBITMAP arg2, UINT arg3, UINT arg4, void * arg5, PBITMAPINFO arg6, UINT arg7)
1242{
1243 dprintf(("GDI32: GetDIBits"));
1244 return O32_GetDIBits(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1245}
1246//******************************************************************************
1247//******************************************************************************
1248int WIN32API GetDeviceCaps(HDC hdc, int nIndex)
1249{
1250 int rc;
1251
1252 rc = O32_GetDeviceCaps(hdc, nIndex);
1253 dprintf(("GDI32: GetDeviceCaps %X, %d returned %d\n", hdc, nIndex, rc));
1254 //SvL: 13-9-'98: NT returns -1 when using 16 bits colors, NOT 65536!
1255 if(nIndex == NUMCOLORS && rc > 256)
1256 return -1;
1257 return(rc);
1258}
1259//******************************************************************************
1260//******************************************************************************
1261HENHMETAFILE WIN32API GetEnhMetaFileA( LPCSTR arg1)
1262{
1263 dprintf(("GDI32: GetEnhMetaFileA"));
1264 return O32_GetEnhMetaFile(arg1);
1265}
1266//******************************************************************************
1267//******************************************************************************
1268UINT WIN32API GetEnhMetaFileBits( HENHMETAFILE arg1, UINT arg2, PBYTE arg3)
1269{
1270 dprintf(("GDI32: GetEnhMetaFileBits"));
1271 return O32_GetEnhMetaFileBits(arg1, arg2, arg3);
1272}
1273//******************************************************************************
1274//******************************************************************************
1275UINT WIN32API GetEnhMetaFileHeader( HENHMETAFILE arg1, UINT arg2, LPENHMETAHEADER arg3)
1276{
1277 dprintf(("GDI32: GetEnhMetaFileHeader"));
1278 return O32_GetEnhMetaFileHeader(arg1, arg2, arg3);
1279}
1280//******************************************************************************
1281//******************************************************************************
1282UINT WIN32API GetEnhMetaFilePaletteEntries( HENHMETAFILE arg1, UINT arg2, PPALETTEENTRY arg3)
1283{
1284 dprintf(("GDI32: GetEnhMetaFilePaletteEntries"));
1285 return O32_GetEnhMetaFilePaletteEntries(arg1, arg2, arg3);
1286}
1287//******************************************************************************
1288//******************************************************************************
1289HENHMETAFILE WIN32API GetEnhMetaFileW( LPCWSTR arg1)
1290{
1291 char *astring = UnicodeToAsciiString((LPWSTR)arg1);
1292 HENHMETAFILE rc;
1293
1294 dprintf(("GDI32: GetEnhMetaFileW"));
1295 // NOTE: This will not work as is (needs UNICODE support)
1296 rc = O32_GetEnhMetaFile(astring);
1297 FreeAsciiString(astring);
1298 return rc;
1299}
1300//******************************************************************************
1301//******************************************************************************
1302int WIN32API GetGraphicsMode(HDC arg1)
1303{
1304 dprintf(("GDI32: GetGraphicsMode"));
1305 return O32_GetGraphicsMode(arg1);
1306}
1307//******************************************************************************
1308//******************************************************************************
1309DWORD WIN32API GetKerningPairsA( HDC arg1, DWORD arg2, LPKERNINGPAIR arg3)
1310{
1311 dprintf(("GDI32: GetKerningPairsA"));
1312 return O32_GetKerningPairs(arg1, arg2, arg3);
1313}
1314//******************************************************************************
1315//******************************************************************************
1316DWORD WIN32API GetKerningPairsW( HDC arg1, DWORD arg2, LPKERNINGPAIR arg3)
1317{
1318 dprintf(("GDI32: GetKerningPairsW"));
1319 // NOTE: This will not work as is (needs UNICODE support)
1320 return O32_GetKerningPairs(arg1, arg2, arg3);
1321}
1322//******************************************************************************
1323//******************************************************************************
1324int WIN32API GetMapMode( HDC arg1)
1325{
1326 dprintf(("GDI32: GetMapMode"));
1327 return O32_GetMapMode(arg1);
1328}
1329//******************************************************************************
1330//******************************************************************************
1331HMETAFILE WIN32API GetMetaFileA( LPCSTR arg1)
1332{
1333 dprintf(("GDI32: GetMetaFileA"));
1334 return O32_GetMetaFile(arg1);
1335}
1336//******************************************************************************
1337//******************************************************************************
1338UINT WIN32API GetMetaFileBitsEx( HMETAFILE arg1, UINT arg2, LPVOID arg3)
1339{
1340 dprintf(("GDI32: GetMetaFileBitsEx"));
1341 return O32_GetMetaFileBitsEx(arg1, arg2, arg3);
1342}
1343//******************************************************************************
1344//******************************************************************************
1345HMETAFILE WIN32API GetMetaFileW( LPCWSTR arg1)
1346{
1347 char *astring = UnicodeToAsciiString((LPWSTR)arg1);
1348 HENHMETAFILE rc;
1349
1350 dprintf(("GDI32: GetMetaFileW"));
1351 rc = O32_GetMetaFile(astring);
1352 FreeAsciiString(astring);
1353 return rc;
1354
1355}
1356//******************************************************************************
1357//******************************************************************************
1358BOOL WIN32API GetMiterLimit( HDC arg1, float * arg2)
1359{
1360 dprintf(("GDI32: GetMiterLimit"));
1361 return O32_GetMiterLimit(arg1, arg2);
1362}
1363//******************************************************************************
1364//******************************************************************************
1365COLORREF WIN32API GetNearestColor( HDC arg1, COLORREF arg2)
1366{
1367 dprintf(("GDI32: GetNearestColor\n"));
1368 return O32_GetNearestColor(arg1, arg2);
1369}
1370//******************************************************************************
1371//******************************************************************************
1372UINT WIN32API GetNearestPaletteIndex( HPALETTE arg1, COLORREF arg2)
1373{
1374 UINT rc;
1375 dprintf(("GDI32: GetNearestPaletteIndex (0x%08X ,0x%08X) ",arg1,arg2));
1376 rc = O32_GetNearestPaletteIndex(arg1, arg2);
1377 dprintf(("Returns %d\n",rc));
1378 return rc;
1379}
1380//******************************************************************************
1381//******************************************************************************
1382UINT WIN32API GetOutlineTextMetricsA( HDC arg1, UINT arg2, LPOUTLINETEXTMETRICA arg3)
1383{
1384 dprintf(("GDI32: GetOutlineTextMetricsA"));
1385 return O32_GetOutlineTextMetrics(arg1, arg2, arg3);
1386}
1387//******************************************************************************
1388//******************************************************************************
1389UINT WIN32API GetOutlineTextMetricsW( HDC arg1, UINT arg2, LPOUTLINETEXTMETRICW arg3)
1390{
1391 dprintf(("GDI32: GetOutlineTextMetricsW STUB"));
1392 // NOTE: This will not work as is (needs UNICODE support)
1393// return O32_GetOutlineTextMetrics(arg1, arg2, arg3);
1394 return 0;
1395}
1396//******************************************************************************
1397//******************************************************************************
1398UINT WIN32API GetPaletteEntries( HPALETTE arg1, UINT arg2, UINT arg3, PPALETTEENTRY arg4)
1399{
1400 dprintf(("GDI32: GetPaletteEntries"));
1401 return O32_GetPaletteEntries(arg1, arg2, arg3, arg4);
1402}
1403//******************************************************************************
1404//******************************************************************************
1405INT WIN32API GetPath( HDC arg1, PPOINT arg2, PBYTE arg3, int arg4)
1406{
1407 dprintf(("GDI32: GetPath"));
1408 return O32_GetPath(arg1, arg2, arg3, arg4);
1409}
1410//******************************************************************************
1411//******************************************************************************
1412int WIN32API GetPolyFillMode( HDC arg1)
1413{
1414 dprintf(("GDI32: GetPolyFillMode"));
1415 return O32_GetPolyFillMode(arg1);
1416}
1417//******************************************************************************
1418//******************************************************************************
1419int WIN32API GetROP2( HDC arg1)
1420{
1421 dprintf(("GDI32: GetROP2"));
1422 return O32_GetROP2(arg1);
1423}
1424//******************************************************************************
1425//******************************************************************************
1426BOOL WIN32API GetRasterizerCaps(LPRASTERIZER_STATUS arg1, UINT arg2)
1427{
1428 dprintf(("GDI32: GetRasterizerCaps"));
1429 return O32_GetRasterizerCaps(arg1, arg2);
1430}
1431//******************************************************************************
1432//******************************************************************************
1433DWORD WIN32API GetRegionData( HRGN arg1, DWORD arg2, PRGNDATA arg3)
1434{
1435 dprintf(("GDI32: GetRegionData"));
1436 return O32_GetRegionData(arg1, arg2, arg3);
1437}
1438//******************************************************************************
1439//******************************************************************************
1440int WIN32API GetRgnBox( HRGN arg1, PRECT arg2)
1441{
1442 dprintf(("GDI32: GetRgnBox"));
1443 return O32_GetRgnBox(arg1, arg2);
1444}
1445//******************************************************************************
1446//******************************************************************************
1447int WIN32API GetStretchBltMode( HDC arg1)
1448{
1449 dprintf(("GDI32: GetStretchBltMode"));
1450 return O32_GetStretchBltMode(arg1);
1451}
1452//******************************************************************************
1453//******************************************************************************
1454UINT WIN32API GetSystemPaletteEntries( HDC arg1, UINT arg2, UINT arg3, PPALETTEENTRY arg4)
1455{
1456 UINT rc;
1457
1458 dprintf(("GDI32: GetSystemPaletteEntries start %d nr %d pal ptr %X", arg2, arg3, arg4));
1459 rc = O32_GetSystemPaletteEntries(arg1, arg2, arg3, arg4);
1460 dprintf((" GetSystemPaletteEntries returned %d", rc));
1461 return(rc);
1462}
1463//******************************************************************************
1464//******************************************************************************
1465UINT WIN32API GetTextAlign( HDC arg1)
1466{
1467 dprintf(("GDI32: GetTextAlign"));
1468 return O32_GetTextAlign(arg1);
1469}
1470//******************************************************************************
1471//******************************************************************************
1472int WIN32API GetTextCharacterExtra( HDC arg1)
1473{
1474 dprintf(("GDI32: GetTextCharacterExtra"));
1475 return O32_GetTextCharacterExtra(arg1);
1476}
1477//******************************************************************************
1478//******************************************************************************
1479COLORREF WIN32API GetTextColor( HDC arg1)
1480{
1481 dprintf(("GDI32: GetTextColor"));
1482 return O32_GetTextColor(arg1);
1483}
1484//******************************************************************************
1485//******************************************************************************
1486BOOL WIN32API GetTextExtentPoint32A( HDC arg1, LPCSTR arg2, int arg3, PSIZE lpSize)
1487{
1488 dprintf(("GDI32: GetTextExtentPoint32A"));
1489 lpSize->cx = lpSize->cy = 0;
1490 return O32_GetTextExtentPoint32(arg1, arg2, arg3, lpSize);
1491}
1492//******************************************************************************
1493//******************************************************************************
1494BOOL WIN32API GetTextExtentPoint32W(HDC arg1, LPCWSTR arg2, int arg3, PSIZE lpSize)
1495{
1496 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1497 BOOL rc;
1498
1499 dprintf(("GDI32: GetTextExtentPoint32W %s\n", astring));
1500 lpSize->cx = lpSize->cy = 0;
1501 rc = O32_GetTextExtentPoint32(arg1, astring, arg3, lpSize);
1502 FreeAsciiString(astring);
1503 return(rc);
1504}
1505//******************************************************************************
1506//******************************************************************************
1507BOOL WIN32API GetTextExtentPointW(HDC hdc,
1508 LPCWSTR lpString,
1509 int cbString,
1510 PSIZE lpSize)
1511{
1512 char *astring = UnicodeToAsciiString((LPWSTR)lpString);
1513 BOOL rc;
1514
1515 lpSize->cx = lpSize->cy = 0;
1516 rc = O32_GetTextExtentPoint(hdc,
1517 astring,
1518 cbString,
1519 lpSize);
1520 dprintf(("GDI32: GetTextExtentPointW %X %s (size %08xh) returned %d\n", hdc, astring, cbString, rc));
1521 dprintf(("GDI32: GetTextExtentPointW (%d,%d)\n", lpSize->cx, lpSize->cy));
1522
1523 FreeAsciiString(astring);
1524 return(rc);
1525}
1526//******************************************************************************
1527//******************************************************************************
1528int WIN32API GetTextFaceA( HDC arg1, int arg2, LPSTR arg3)
1529{
1530 dprintf(("GDI32: GetTextFaceA"));
1531 return O32_GetTextFace(arg1, arg2, arg3);
1532}
1533//******************************************************************************
1534//******************************************************************************
1535int WIN32API GetTextFaceW( HDC arg1, int arg2, LPWSTR arg3)
1536{
1537 char *astring = (char *)malloc(arg2+1);
1538 int rc;
1539
1540 dprintf(("GDI32: GetTextFaceW"));
1541 rc = O32_GetTextFace(arg1, arg2, astring);
1542 AsciiToUnicode(astring, arg3);
1543 free(astring);
1544 return rc;
1545}
1546//******************************************************************************
1547//******************************************************************************
1548BOOL WIN32API GetTextMetricsA( HDC arg1, LPTEXTMETRICA arg2)
1549{
1550 BOOL rc;
1551
1552 rc = O32_GetTextMetrics(arg1, arg2);
1553 dprintf(("GDI32: GetTextMetricsA returned %d\n", rc));
1554 return(rc);
1555}
1556//******************************************************************************
1557//******************************************************************************
1558BOOL WIN32API GetTextMetricsW( HDC arg1, LPTEXTMETRICW pwtm)
1559{
1560 BOOL rc;
1561 TEXTMETRICA atm;
1562
1563 dprintf(("GDI32: GetTextMetricsW"));
1564
1565 rc = O32_GetTextMetrics(arg1, &atm);
1566 pwtm->tmHeight = atm.tmHeight;
1567 pwtm->tmAscent = atm.tmAscent;
1568 pwtm->tmDescent = atm.tmDescent;
1569 pwtm->tmInternalLeading = atm.tmInternalLeading;
1570 pwtm->tmExternalLeading = atm.tmExternalLeading;
1571 pwtm->tmAveCharWidth = atm.tmAveCharWidth;
1572 pwtm->tmMaxCharWidth = atm.tmMaxCharWidth;
1573 pwtm->tmWeight = atm.tmWeight;
1574 pwtm->tmOverhang = atm.tmOverhang;
1575 pwtm->tmDigitizedAspectX = atm.tmDigitizedAspectX;
1576 pwtm->tmDigitizedAspectY = atm.tmDigitizedAspectY;
1577 pwtm->tmFirstChar = atm.tmFirstChar;
1578 pwtm->tmLastChar = atm.tmLastChar;
1579 pwtm->tmDefaultChar = atm.tmDefaultChar;
1580 pwtm->tmBreakChar = atm.tmBreakChar;
1581 pwtm->tmItalic = atm.tmItalic;
1582 pwtm->tmUnderlined = atm.tmUnderlined;
1583 pwtm->tmStruckOut = atm.tmStruckOut;
1584 pwtm->tmPitchAndFamily = atm.tmPitchAndFamily;
1585 pwtm->tmCharSet = atm.tmCharSet;
1586 return(rc);
1587}
1588//******************************************************************************
1589//******************************************************************************
1590BOOL WIN32API GetViewportExtEx( HDC arg1, PSIZE arg2)
1591{
1592 dprintf(("GDI32: GetViewportExtEx"));
1593 return O32_GetViewportExtEx(arg1, arg2);
1594}
1595//******************************************************************************
1596//******************************************************************************
1597BOOL WIN32API GetViewportOrgEx( HDC arg1, PPOINT arg2)
1598{
1599 dprintf(("GDI32: GetViewportOrgEx"));
1600 return O32_GetViewportOrgEx(arg1, arg2);
1601}
1602//******************************************************************************
1603//******************************************************************************
1604UINT WIN32API GetWinMetaFileBits( HENHMETAFILE arg1, UINT arg2, PBYTE arg3, int arg4, HDC arg5)
1605{
1606 dprintf(("GDI32: GetWinMetaFileBits"));
1607 return O32_GetWinMetaFileBits(arg1, arg2, arg3, arg4, arg5);
1608}
1609//******************************************************************************
1610//******************************************************************************
1611BOOL WIN32API GetWindowOrgEx( HDC arg1, PPOINT arg2)
1612{
1613 dprintf(("GDI32: GetWindowOrgEx"));
1614 return O32_GetWindowOrgEx(arg1, arg2);
1615}
1616//******************************************************************************
1617//******************************************************************************
1618BOOL WIN32API GetWorldTransform( HDC arg1, LPXFORM arg2)
1619{
1620 dprintf(("GDI32: GetWorldTransform"));
1621 return O32_GetWorldTransform(arg1, arg2);
1622}
1623//******************************************************************************
1624//******************************************************************************
1625int WIN32API IntersectClipRect(HDC arg1, int arg2, int arg3, int arg4, int arg5)
1626{
1627 int rc;
1628
1629 rc = O32_IntersectClipRect(arg1, arg2, arg3, arg4, arg5);
1630 dprintf(("GDI32: IntersectClipRect returned %d\n", rc));
1631 return(rc);
1632}
1633//******************************************************************************
1634//******************************************************************************
1635BOOL WIN32API InvertRgn( HDC arg1, HRGN arg2)
1636{
1637 dprintf(("GDI32: InvertRgn"));
1638 return O32_InvertRgn(arg1, arg2);
1639}
1640//******************************************************************************
1641//******************************************************************************
1642BOOL WIN32API LPtoDP( HDC arg1, PPOINT arg2, int arg3)
1643{
1644 dprintf(("GDI32: LPtoDP"));
1645 return O32_LPtoDP(arg1, arg2, arg3);
1646}
1647//******************************************************************************
1648//******************************************************************************
1649BOOL WIN32API MaskBlt( HDC arg1, int arg2, int arg3, int arg4, int arg5, HDC arg6, int arg7, int arg8, HBITMAP arg9, int arg10, int arg11, DWORD arg12)
1650{
1651 dprintf(("GDI32: MaskBlt"));
1652 return O32_MaskBlt(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
1653}
1654//******************************************************************************
1655//******************************************************************************
1656BOOL WIN32API ModifyWorldTransform( HDC arg1, const XFORM *arg2, DWORD arg3)
1657{
1658 dprintf(("GDI32: ModifyWorldTransform"));
1659 return O32_ModifyWorldTransform(arg1, (LPXFORM)arg2, arg3);
1660}
1661//******************************************************************************
1662//******************************************************************************
1663int WIN32API OffsetClipRgn( HDC arg1, int arg2, int arg3)
1664{
1665 dprintf(("GDI32: OffsetClipRgn"));
1666 return O32_OffsetClipRgn(arg1, arg2, arg3);
1667}
1668//******************************************************************************
1669//******************************************************************************
1670int WIN32API OffsetRgn( HRGN arg1, int arg2, int arg3)
1671{
1672 dprintf(("GDI32: OffsetRgn"));
1673 return O32_OffsetRgn(arg1, arg2, arg3);
1674}
1675//******************************************************************************
1676//******************************************************************************
1677BOOL WIN32API OffsetViewportOrgEx( HDC arg1, int arg2, int arg3, PPOINT arg4)
1678{
1679 dprintf(("GDI32: OffsetViewportOrgEx"));
1680 return O32_OffsetViewportOrgEx(arg1, arg2, arg3, arg4);
1681}
1682//******************************************************************************
1683//******************************************************************************
1684BOOL WIN32API OffsetWindowOrgEx( HDC arg1, int arg2, int arg3, PPOINT arg4)
1685{
1686 dprintf(("GDI32: OffsetWindowOrgEx"));
1687 return O32_OffsetWindowOrgEx(arg1, arg2, arg3, arg4);
1688}
1689//******************************************************************************
1690//******************************************************************************
1691BOOL WIN32API PaintRgn( HDC arg1, HRGN arg2)
1692{
1693 dprintf(("GDI32: PaintRgn"));
1694 return O32_PaintRgn(arg1, arg2);
1695}
1696//******************************************************************************
1697//******************************************************************************
1698HRGN WIN32API PathToRegion( HDC arg1)
1699{
1700 dprintf(("GDI32: PathToRegion"));
1701 return O32_PathToRegion(arg1);
1702}
1703//******************************************************************************
1704//******************************************************************************
1705BOOL WIN32API Pie(HDC hdc, int nLeftRect, int nTopRect, int nRightRect,
1706 int nBottomRect, int nXRadial1, int nYRadial1, int nXRadial2,
1707 int nYRadial2)
1708{
1709 dprintf(("GDI32: Pie"));
1710 //CB: bug in O32_Pie
1711 if (nXRadial1 == nXRadial2 && nYRadial1 == nYRadial2)
1712 return O32_Ellipse(hdc,nLeftRect,nTopRect,nRightRect,nBottomRect);
1713 else
1714 return O32_Pie(hdc,nLeftRect,nTopRect,nRightRect,nBottomRect,nXRadial1,nYRadial1,nXRadial2,nYRadial2);
1715}
1716//******************************************************************************
1717//******************************************************************************
1718BOOL WIN32API PlayEnhMetaFile( HDC arg1, HENHMETAFILE arg2, const RECT * arg3)
1719{
1720 dprintf(("GDI32: PlayEnhMetaFile"));
1721 return O32_PlayEnhMetaFile(arg1, arg2, arg3);
1722}
1723//******************************************************************************
1724//******************************************************************************
1725BOOL WIN32API PlayMetaFile( HDC arg1, HMETAFILE arg2)
1726{
1727 dprintf(("GDI32: PlayMetaFile"));
1728 return O32_PlayMetaFile(arg1, arg2);
1729}
1730//******************************************************************************
1731//******************************************************************************
1732BOOL WIN32API PlayMetaFileRecord( HDC arg1, LPHANDLETABLE arg2, LPMETARECORD arg3, UINT arg4)
1733{
1734 dprintf(("GDI32: PlayMetaFileRecord"));
1735 return O32_PlayMetaFileRecord(arg1, arg2, arg3, (int)arg4);
1736}
1737//******************************************************************************
1738//******************************************************************************
1739BOOL WIN32API PolyBezier( HDC arg1, const POINT * arg2, DWORD arg3)
1740{
1741 dprintf(("GDI32: PolyBezier"));
1742 return O32_PolyBezier(arg1, arg2, (int)arg3);
1743}
1744//******************************************************************************
1745//******************************************************************************
1746BOOL WIN32API PolyBezierTo( HDC arg1, const POINT * arg2, DWORD arg3)
1747{
1748 dprintf(("GDI32: PolyBezierTo"));
1749 return O32_PolyBezierTo(arg1, arg2, arg3);
1750}
1751//******************************************************************************
1752//******************************************************************************
1753BOOL WIN32API PolyDraw( HDC arg1, const POINT * arg2, const BYTE * arg3, DWORD arg4)
1754{
1755 dprintf(("GDI32: PolyDraw"));
1756 return O32_PolyDraw(arg1, arg2, arg3, arg4);
1757}
1758//******************************************************************************
1759//******************************************************************************
1760BOOL WIN32API PolyPolygon( HDC arg1, const POINT * arg2, const INT * arg3, UINT arg4)
1761{
1762 dprintf(("GDI32: PolyPolygon"));
1763 return O32_PolyPolygon(arg1, arg2, arg3, arg4);
1764}
1765//******************************************************************************
1766//******************************************************************************
1767BOOL WIN32API PolyPolyline( HDC hdc, const POINT * lppt, const DWORD * lpdwPolyPoints, DWORD cCount)
1768{
1769 dprintf(("GDI32: PolyPolyline"));
1770
1771 return O32_PolyPolyline(hdc,lppt,lpdwPolyPoints,cCount);
1772}
1773//******************************************************************************
1774//******************************************************************************
1775BOOL WIN32API Polygon( HDC arg1, const POINT * arg2, int arg3)
1776{
1777 dprintf(("GDI32: Polygon"));
1778 return O32_Polygon(arg1, arg2, arg3);
1779}
1780//******************************************************************************
1781//******************************************************************************
1782BOOL WIN32API PtInRegion( HRGN arg1, int arg2, int arg3)
1783{
1784 dprintf(("GDI32: PtInRegion"));
1785 return O32_PtInRegion(arg1, arg2, arg3);
1786}
1787//******************************************************************************
1788//******************************************************************************
1789BOOL WIN32API PtVisible( HDC arg1, int arg2, int arg3)
1790{
1791 dprintf(("GDI32: PtVisible"));
1792 return O32_PtVisible(arg1, arg2, arg3);
1793}
1794//******************************************************************************
1795//******************************************************************************
1796BOOL WIN32API RectInRegion( HRGN arg1, const RECT * arg2)
1797{
1798 dprintf(("GDI32: RectInRegion"));
1799 return O32_RectInRegion(arg1, arg2);
1800}
1801//******************************************************************************
1802//******************************************************************************
1803BOOL WIN32API RectVisible( HDC arg1, const RECT * arg2)
1804{
1805 dprintf(("GDI32: RectVisible\n"));
1806 return O32_RectVisible(arg1, arg2);
1807}
1808//******************************************************************************
1809//******************************************************************************
1810HDC WIN32API ResetDCA( HDC arg1, const DEVMODEA * arg2)
1811{
1812 dprintf(("GDI32: ResetDCA\n"));
1813 return (HDC)O32_ResetDC(arg1, arg2);
1814}
1815//******************************************************************************
1816//******************************************************************************
1817HDC WIN32API ResetDCW( HDC arg1, const DEVMODEW * arg2)
1818{
1819 dprintf(("GDI32: ResetDCW\n"));
1820 // NOTE: This will not work as is (needs UNICODE support)
1821 return (HDC)O32_ResetDC(arg1, (const DEVMODEA *)arg2);
1822}
1823//******************************************************************************
1824//******************************************************************************
1825BOOL WIN32API ResizePalette( HPALETTE arg1, UINT arg2)
1826{
1827 dprintf(("GDI32: ResizePalette\n"));
1828 return O32_ResizePalette(arg1, arg2);
1829}
1830//******************************************************************************
1831//******************************************************************************
1832BOOL WIN32API RestoreDC( HDC arg1, int arg2)
1833{
1834 dprintf(("GDI32: RestoreDC\n"));
1835 return O32_RestoreDC(arg1, arg2);
1836}
1837//******************************************************************************
1838//******************************************************************************
1839BOOL WIN32API RoundRect( HDC arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7)
1840{
1841 dprintf(("GDI32: RoundRect"));
1842 return O32_RoundRect(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1843}
1844//******************************************************************************
1845//******************************************************************************
1846int WIN32API SaveDC( HDC arg1)
1847{
1848 dprintf(("GDI32: SaveDC"));
1849 return O32_SaveDC(arg1);
1850}
1851//******************************************************************************
1852//******************************************************************************
1853BOOL WIN32API ScaleViewportExtEx( HDC arg1, int arg2, int arg3, int arg4, int arg5, PSIZE arg6)
1854{
1855 dprintf(("GDI32: ScaleViewportExtEx"));
1856 return O32_ScaleViewportExtEx(arg1, arg2, arg3, arg4, arg5, arg6);
1857}
1858//******************************************************************************
1859//******************************************************************************
1860BOOL WIN32API ScaleWindowExtEx( HDC arg1, int arg2, int arg3, int arg4, int arg5, PSIZE arg6)
1861{
1862 dprintf(("GDI32: ScaleWindowExtEx"));
1863 return O32_ScaleWindowExtEx(arg1, arg2, arg3, arg4, arg5, arg6);
1864}
1865//******************************************************************************
1866//******************************************************************************
1867int WIN32API SelectClipRgn( HDC arg1, HRGN arg2)
1868{
1869 dprintf(("GDI32: SelectClipRgn"));
1870 return O32_SelectClipRgn(arg1, arg2);
1871}
1872//******************************************************************************
1873//******************************************************************************
1874int WIN32API SetArcDirection( HDC arg1, int arg2)
1875{
1876 dprintf(("GDI32: SetArcDirection"));
1877 return O32_SetArcDirection(arg1, arg2);
1878}
1879//******************************************************************************
1880//******************************************************************************
1881LONG WIN32API SetBitmapBits( HBITMAP arg1, LONG arg2, const VOID * arg3)
1882{
1883 dprintf(("GDI32: SetBitmapBits"));
1884 return O32_SetBitmapBits(arg1, (DWORD)arg2, arg3);
1885}
1886//******************************************************************************
1887//******************************************************************************
1888BOOL WIN32API SetBitmapDimensionEx( HBITMAP arg1, int arg2, int arg3, PSIZE arg4)
1889{
1890 dprintf(("GDI32: SetBitmapDimensionEx"));
1891 return O32_SetBitmapDimensionEx(arg1, arg2, arg3, arg4);
1892}
1893//******************************************************************************
1894//******************************************************************************
1895UINT WIN32API SetBoundsRect( HDC arg1, const RECT * arg2, UINT arg3)
1896{
1897 dprintf(("GDI32: SetBoundsRect"));
1898 return O32_SetBoundsRect(arg1, arg2, arg3);
1899}
1900//******************************************************************************
1901//******************************************************************************
1902BOOL WIN32API SetBrushOrgEx( HDC arg1, int arg2, int arg3, PPOINT arg4)
1903{
1904 BOOL rc;
1905
1906 rc = O32_SetBrushOrgEx(arg1, arg2, arg3, arg4);
1907 dprintf(("GDI32: SetBrushOrgEx returned %d\n", rc));
1908 return(rc);
1909}
1910//******************************************************************************
1911//******************************************************************************
1912int WIN32API SetDIBits( HDC arg1, HBITMAP arg2, UINT arg3, UINT arg4, const VOID * arg5, const BITMAPINFO * arg6, UINT arg7)
1913{
1914 dprintf(("GDI32: SetDIBits %x %x %x %x %x %x %x\n", arg1, arg2, arg3, arg4, arg5, arg6, arg7));
1915
1916 if(DIBSection::getSection() != NULL) {
1917 DIBSection *dsect;
1918
1919 dsect = DIBSection::find((DWORD)arg2);
1920 if(dsect) {
1921 return dsect->SetDIBits(arg1, arg2, arg3, arg4, arg5, (WINBITMAPINFOHEADER *)&arg6->bmiHeader, arg7);
1922 }
1923 }
1924 return O32_SetDIBits(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1925}
1926//******************************************************************************
1927//******************************************************************************
1928INT WIN32API SetDIBitsToDevice(HDC hdc, INT xDest, INT yDest, DWORD cx, DWORD cy, INT xSrc, INT ySrc, UINT startscan, UINT lines, LPCVOID bits, const BITMAPINFO *info, UINT coloruse)
1929{
1930 INT result, imgsize, palsize;
1931 char *ptr;
1932
1933 dprintf(("GDI32: SetDIBitsToDevice hdc:%X xDest:%d yDest:%d, cx:%d, cy:%d, xSrc:%d, ySrc:%d, startscan:%d, lines:%d, bits:%X, info%X, coloruse:%d",
1934 hdc, xDest, yDest, cx, cy, xSrc, ySrc, startscan, lines, (LPVOID) bits, (PBITMAPINFO)info, coloruse));
1935
1936 // EB: ->>> Crazy. Nobody seen this Open32 bug ?
1937 // Dont't like dirty pointers, but Open32 needs a bit help.
1938 // Only tested with winmine.
1939 palsize = QueryPaletteSize((BITMAPINFOHEADER*)&info->bmiHeader);
1940 imgsize = CalcBitmapSize(info->bmiHeader.biBitCount,
1941 info->bmiHeader.biWidth, info->bmiHeader.biHeight);
1942 ptr = ((char *)info) + palsize + sizeof(BITMAPINFOHEADER);
1943 if(bits >= ptr && bits < ptr + imgsize)
1944 {
1945 bits = (char *)bits - imgsize +
1946 CalcBitmapSize(info->bmiHeader.biBitCount,
1947 info->bmiHeader.biWidth, lines);
1948 }
1949 // EB: <<<-
1950
1951 result = O32_SetDIBitsToDevice(hdc, xDest, yDest, cx, cy, xSrc, ySrc, startscan, lines, (PVOID) bits, (PBITMAPINFO)info, coloruse);
1952 return result;
1953}
1954//******************************************************************************
1955//******************************************************************************
1956HENHMETAFILE WIN32API SetEnhMetaFileBits( UINT arg1, const BYTE * arg2)
1957{
1958 dprintf(("GDI32: SetEnhMetaFileBits"));
1959 return O32_SetEnhMetaFileBits(arg1, arg2);
1960}
1961//******************************************************************************
1962//******************************************************************************
1963int WIN32API SetGraphicsMode(HDC arg1, int arg2)
1964{
1965 dprintf(("GDI32: SetGraphicsMode"));
1966 return O32_SetGraphicsMode(arg1, arg2);
1967}
1968//******************************************************************************
1969//******************************************************************************
1970int WIN32API SetMapMode( HDC arg1, int arg2)
1971{
1972 dprintf(("GDI32: SetMapMode"));
1973 return O32_SetMapMode(arg1, arg2);
1974}
1975//******************************************************************************
1976//******************************************************************************
1977DWORD WIN32API SetMapperFlags( HDC arg1, DWORD arg2)
1978{
1979 dprintf(("GDI32: SetMapperFlags"));
1980 return O32_SetMapperFlags(arg1, arg2);
1981}
1982//******************************************************************************
1983//******************************************************************************
1984HMETAFILE WIN32API SetMetaFileBitsEx( UINT arg1, const BYTE * arg2)
1985{
1986 dprintf(("GDI32: SetMetaFileBitsEx"));
1987 return O32_SetMetaFileBitsEx(arg1, (PBYTE)arg2);
1988}
1989//******************************************************************************
1990//******************************************************************************
1991BOOL WIN32API SetMiterLimit( HDC arg1, float arg2, float * arg3)
1992{
1993 dprintf(("GDI32: SetMiterLimit"));
1994 return O32_SetMiterLimit(arg1, arg2, arg3);
1995}
1996//******************************************************************************
1997//******************************************************************************
1998UINT WIN32API SetPaletteEntries( HPALETTE arg1, UINT arg2, UINT arg3, PALETTEENTRY * arg4)
1999{
2000 dprintf(("GDI32: SetPaletteEntries"));
2001 return O32_SetPaletteEntries(arg1, arg2, arg3, (const PALETTEENTRY *)arg4);
2002}
2003//******************************************************************************
2004//******************************************************************************
2005int WIN32API SetPolyFillMode( HDC arg1, int arg2)
2006{
2007 dprintf(("GDI32: SetPolyFillMode"));
2008 return O32_SetPolyFillMode(arg1, arg2);
2009}
2010//******************************************************************************
2011//******************************************************************************
2012BOOL WIN32API SetRectRgn( HRGN arg1, int arg2, int arg3, int arg4, int arg5)
2013{
2014 dprintf(("GDI32: SetRectRgn"));
2015 return O32_SetRectRgn(arg1, arg2, arg3, arg4, arg5);
2016}
2017//******************************************************************************
2018//******************************************************************************
2019UINT WIN32API SetTextAlign( HDC arg1, UINT arg2)
2020{
2021 dprintf(("GDI32: SetTextAlign"));
2022 return O32_SetTextAlign(arg1, arg2);
2023}
2024//******************************************************************************
2025//******************************************************************************
2026int WIN32API SetTextCharacterExtra( HDC arg1, int arg2)
2027{
2028 dprintf(("GDI32: SetTextCharacterExtra"));
2029 return O32_SetTextCharacterExtra(arg1, arg2);
2030}
2031//******************************************************************************
2032//******************************************************************************
2033BOOL WIN32API SetTextJustification( HDC arg1, int arg2, int arg3)
2034{
2035 dprintf(("GDI32: SetTextJustification"));
2036 return O32_SetTextJustification(arg1, arg2, arg3);
2037}
2038//******************************************************************************
2039//******************************************************************************
2040BOOL WIN32API SetViewportExtEx( HDC arg1, int arg2, int arg3, PSIZE arg4)
2041{
2042 dprintf(("GDI32: SetViewportExtEx"));
2043 return O32_SetViewportExtEx(arg1, arg2, arg3, arg4);
2044}
2045//******************************************************************************
2046//******************************************************************************
2047BOOL WIN32API SetViewportOrgEx( HDC arg1, int arg2, int arg3, PPOINT arg4)
2048{
2049 dprintf(("GDI32: SetViewportOrgEx"));
2050 return O32_SetViewportOrgEx(arg1, arg2, arg3, arg4);
2051}
2052//******************************************************************************
2053//******************************************************************************
2054HENHMETAFILE WIN32API SetWinMetaFileBits( UINT arg1, const BYTE * arg2, HDC arg3, const METAFILEPICT * arg4)
2055{
2056 dprintf(("GDI32: SetWinMetaFileBits"));
2057 return O32_SetWinMetaFileBits(arg1, arg2, arg3, arg4);
2058}
2059//******************************************************************************
2060//******************************************************************************
2061BOOL WIN32API SetWindowExtEx( HDC arg1, int arg2, int arg3, PSIZE arg4)
2062{
2063 dprintf(("GDI32: SetWindowExtEx"));
2064 return O32_SetWindowExtEx(arg1, arg2, arg3, arg4);
2065}
2066//******************************************************************************
2067//******************************************************************************
2068BOOL WIN32API SetWindowOrgEx( HDC arg1, int arg2, int arg3, PPOINT arg4)
2069{
2070 dprintf(("GDI32: SetWindowOrgEx"));
2071 return O32_SetWindowOrgEx(arg1, arg2, arg3, arg4);
2072}
2073//******************************************************************************
2074//******************************************************************************
2075BOOL WIN32API SetWorldTransform( HDC arg1, const XFORM *arg2)
2076{
2077 dprintf(("GDI32: SetWorldTransform"));
2078 return O32_SetWorldTransform(arg1, (LPXFORM)arg2);
2079}
2080//******************************************************************************
2081//******************************************************************************
2082INT WIN32API StartDocA( HDC arg1, const DOCINFOA *arg2)
2083{
2084 dprintf(("GDI32: StartDocA"));
2085 return O32_StartDoc(arg1, (LPDOCINFOA)arg2);
2086}
2087//******************************************************************************
2088//******************************************************************************
2089INT WIN32API StartDocW( HDC arg1, const DOCINFOW *arg2)
2090{
2091 dprintf(("GDI32: StartDocW STUB"));
2092 // NOTE: This will not work as is (needs UNICODE support)
2093// return O32_StartDoc(arg1, arg2);
2094 return 0;
2095}
2096//******************************************************************************
2097//******************************************************************************
2098int WIN32API StartPage( HDC arg1)
2099{
2100 dprintf(("GDI32: StartPage"));
2101 return O32_StartPage(arg1);
2102}
2103//******************************************************************************
2104//******************************************************************************
2105BOOL WIN32API UnrealizeObject( HGDIOBJ arg1)
2106{
2107 dprintf(("GDI32: UnrealizeObject"));
2108 return O32_UnrealizeObject(arg1);
2109}
2110//******************************************************************************
2111//******************************************************************************
2112BOOL WIN32API WidenPath( HDC arg1)
2113{
2114 dprintf(("GDI32: WidenPath"));
2115 return O32_WidenPath(arg1);
2116}
2117//******************************************************************************
2118//CreateDisardableBitmap is obsolete and can be replaced by CreateCompatibleBitmap
2119//******************************************************************************
2120HBITMAP WIN32API CreateDiscardableBitmap(HDC hDC, int nWidth, int nHeight)
2121{
2122 dprintf(("GDI32: CreateDisardableBitmap\n"));
2123 return O32_CreateCompatibleBitmap(hDC, nWidth, nHeight);
2124}
2125//******************************************************************************
2126//TODO: Not implemented
2127//******************************************************************************
2128int WIN32API SetAbortProc(HDC hdc, ABORTPROC lpAbortProc)
2129{
2130 dprintf(("GDI32: SetAbortProc - stub (1)w\n"));
2131 return(1);
2132}
2133//******************************************************************************
2134//Selects the current path as a clipping region for a device context, combining
2135//any existing clipping region by using the specified mode
2136//TODO: Can be emulated with SelectClipRegion??
2137//******************************************************************************
2138BOOL WIN32API SelectClipPath(HDC hdc, int iMode)
2139{
2140 dprintf(("GDI32: SelectClipPath, not implemented!(TRUE)\n"));
2141 return(TRUE);
2142}
2143//******************************************************************************
2144//TODO: Sets the color adjustment values for a device context. (used to adjust
2145// the input color of the src bitmap for calls of StretchBlt & StretchDIBits
2146// functions when HALFTONE mode is set
2147//******************************************************************************
2148BOOL WIN32API SetColorAdjustment(HDC hdc, CONST COLORADJUSTMENT *lpca)
2149{
2150 dprintf(("GDI32: SetColorAdjustment, not implemented!(TRUE)\n"));
2151 return(TRUE);
2152}
2153//******************************************************************************
2154//WINE: OBJECTS\DIB.C
2155//*********************************************************************************
2156HBITMAP WIN32API CreateDIBSection( HDC hdc, BITMAPINFO *pbmi, UINT iUsage,
2157 VOID **ppvBits, HANDLE hSection, DWORD dwOffset)
2158{
2159 HBITMAP res = 0;
2160 BOOL fFlip = 0;
2161 int iHeight, iWidth;
2162
2163 dprintf(("GDI32: CreateDIBSection %x %x %x %d", hdc, iUsage, hSection, dwOffset));
2164 if(hSection)
2165 {
2166 dprintf(("GDI32: CreateDIBSection, hSection != NULL, not supported!\n"));
2167 return NULL;
2168 }
2169
2170 //SvL: 13-9-98: StarCraft uses bitmap with negative height
2171 iWidth = pbmi->bmiHeader.biWidth;
2172 if(pbmi->bmiHeader.biWidth < 0)
2173 {
2174 pbmi->bmiHeader.biWidth = -pbmi->bmiHeader.biWidth;
2175 fFlip = FLIP_HOR;
2176 }
2177 iHeight = pbmi->bmiHeader.biHeight;
2178 if(pbmi->bmiHeader.biHeight < 0)
2179 {
2180 pbmi->bmiHeader.biHeight = -pbmi->bmiHeader.biHeight;
2181 fFlip |= FLIP_VERT;
2182 }
2183
2184 res = O32_CreateDIBitmap(hdc, &pbmi->bmiHeader, 0, NULL, pbmi, 0);
2185 if (res)
2186 {
2187 ULONG Pal[256];
2188 char PalSize;
2189 LOGPALETTE tmpPal = { 0x300,1,{0,0,0,0}};
2190 HPALETTE hpalCur, hpalTmp;
2191 DIBSection *dsect = new DIBSection((WINBITMAPINFOHEADER *)&pbmi->bmiHeader, (DWORD)res, fFlip);
2192
2193 if(NULL!=dsect)
2194 {
2195 PalSize = dsect->GetBitCount();
2196 if(PalSize<=8)
2197 {
2198 // Now get the current Palette from the DC
2199 hpalTmp = CreatePalette(&tmpPal);
2200 hpalCur = SelectPalette(hdc, hpalTmp, FALSE);
2201
2202 // and use it to set the DIBColorTable
2203 GetPaletteEntries( hpalCur, 0, 1<<PalSize, (LPPALETTEENTRY)&Pal);
2204 dsect->SetDIBColorTable(0, 1<< PalSize, (RGBQUAD*)&Pal);
2205
2206 // Restore the DC Palette
2207 SelectPalette(hdc,hpalCur,FALSE);
2208 DeleteObject(hpalTmp);
2209 }
2210 // Set the hdc in the DIBSection so we can update the palete if a new
2211 // Paletet etc. gets selected into the DC.
2212
2213 dsect->SelectDIBObject(hdc);
2214
2215 if(ppvBits!=NULL)
2216 *ppvBits = dsect->GetDIBObject();
2217
2218 pbmi->bmiHeader.biWidth = iWidth;
2219 pbmi->bmiHeader.biHeight = iHeight;
2220
2221 dprintf(("GDI32: return %08X\n",res));
2222 return(res);
2223 }
2224 }
2225
2226 /* Error. */
2227 if (res)
2228 DeleteObject(res);
2229 *ppvBits = NULL;
2230#ifdef DEBUG
2231 dprintf(("GDI32: CreateDIBSection, error!\n"));
2232 dprintf(("pbmi->biWidth %d", pbmi->bmiHeader.biWidth));
2233 dprintf(("pbmi->biHeight %d", pbmi->bmiHeader.biHeight));
2234 dprintf(("pbmi->biBitCount %d", pbmi->bmiHeader.biBitCount));
2235#endif
2236
2237 return 0;
2238}
2239//******************************************************************************
2240//******************************************************************************
2241UINT WIN32API GetDIBColorTable( HDC hdc, UINT uStartIndex, UINT cEntries,
2242 RGBQUAD *pColors)
2243{
2244 HPALETTE hpal = O32_GetCurrentObject(hdc, OBJ_PAL);
2245 UINT rc;
2246 int i;
2247
2248 rc = O32_GetPaletteEntries(hpal,
2249 uStartIndex,
2250 cEntries,
2251 (PALETTEENTRY *)pColors);
2252 for(i=0;
2253 i<cEntries;
2254 i++)
2255 {
2256 BYTE tmp;
2257 tmp = pColors[i].rgbBlue;
2258 pColors[i].rgbBlue = pColors[i].rgbRed;
2259 pColors[i].rgbRed = tmp;
2260 pColors[i].rgbReserved = 0;
2261 }
2262 dprintf(("GDI32: GetDIBColorTable returns %d\n", rc));
2263 return(rc);
2264}
2265//******************************************************************************
2266//******************************************************************************
2267UINT WIN32API SetDIBColorTable(HDC hdc, UINT uStartIndex, UINT cEntries,
2268 RGBQUAD *pColors)
2269{
2270 DIBSection *dsect = DIBSection::findHDC(hdc);
2271
2272 dprintf(("GDI32: SetDIBColorTable\n"));
2273 if(dsect)
2274 {
2275 return(dsect->SetDIBColorTable(uStartIndex, cEntries, pColors));
2276 }
2277 else
2278 return(0);
2279}
2280//******************************************************************************
2281//******************************************************************************
2282HPALETTE WIN32API CreateHalftonePalette(HDC hdc)
2283{
2284 dprintf(("GDI32: CreateHalftonePalette, not implemented\n"));
2285 return(NULL);
2286}
2287//******************************************************************************
2288//Maps colors to system palette; faster way to update window (instead of redrawing)
2289//We just redraw
2290//******************************************************************************
2291BOOL WIN32API UpdateColors(HDC hdc)
2292{
2293 dprintf(("GDI32: UpdateColors\n"));
2294 return O32_InvalidateRect(O32_WindowFromDC(hdc), NULL, FALSE);
2295}
2296//******************************************************************************
2297//******************************************************************************
2298BOOL WIN32API GdiFlush()
2299{
2300 dprintf(("GDI32: GdiFlush, not implemented (TRUE)\n"));
2301 return(TRUE);
2302}
2303//******************************************************************************
2304//******************************************************************************
2305BOOL WIN32API GdiComment(HDC hdc, UINT cbSize, CONST BYTE *lpData)
2306{
2307 dprintf(("GDI32: GdiComment, not implemented (TRUE)\n"));
2308 return(TRUE);
2309}
2310//******************************************************************************
2311//******************************************************************************
2312BOOL WIN32API GetCharWidthFloatA(HDC hdc, UINT iFirstChar, UINT iLastChar, PFLOAT pxBUffer)
2313{
2314 dprintf(("GDI32: GetCharWidthFloatA, not implemented\n"));
2315 return(FALSE);
2316}
2317//******************************************************************************
2318//******************************************************************************
2319BOOL WIN32API GetCharWidthFloatW(HDC hdc, UINT iFirstChar, UINT iLastChar, PFLOAT pxBUffer)
2320{
2321 dprintf(("GDI32: GetCharWidthFloatW, not implemented\n"));
2322 return(FALSE);
2323}
2324//******************************************************************************
2325//******************************************************************************
2326BOOL WIN32API GetCharABCWidthsFloatA(HDC hdc, UINT iFirstChar, UINT iLastChar, LPABCFLOAT pxBUffer)
2327{
2328 dprintf(("GDI32: GetCharABCWidthsFloatA, not implemented\n"));
2329 return(FALSE);
2330}
2331//******************************************************************************
2332//******************************************************************************
2333BOOL WIN32API GetCharABCWidthsFloatW(HDC hdc,
2334 UINT iFirstChar,
2335 UINT iLastChar,
2336 LPABCFLOAT pxBUffer)
2337{
2338 dprintf(("GDI32: GetCharABCWidthsFloatA, not implemented\n"));
2339 return(FALSE);
2340}
2341//******************************************************************************
2342//******************************************************************************
2343INT WIN32API ExtEscape(HDC hdc, INT nEscape, INT cbInput, LPCSTR lpszInData,
2344 INT cbOutput, LPSTR lpszOutData)
2345{
2346 dprintf(("GDI32: ExtEscape, not implemented\n"));
2347 return(0);
2348}
2349//******************************************************************************
2350//******************************************************************************
2351int WIN32API DrawEscape(HDC hdc, int nEscape, int cbInput, LPCSTR lpszInData)
2352{
2353 dprintf(("GDI32: DrawEscape, not implemented\n"));
2354 return(0);
2355}
2356//******************************************************************************
2357//******************************************************************************
2358BOOL WIN32API GetColorAdjustment(HDC hdc, COLORADJUSTMENT *lpca)
2359{
2360 dprintf(("GDI32: GetColorAdjustment, not implemented\n"));
2361 return(FALSE);
2362}
2363//******************************************************************************
2364//******************************************************************************
2365BOOL WIN32API PlgBlt(HDC hdcDest, CONST POINT *lpPoint, HDC hdcSrc, int nXSrc,
2366 int nYSrc, int nWidth, int nHeight, HBITMAP hbmMask,
2367 int xMast, int yMask)
2368{
2369 dprintf(("GDI32: PlgBlt, not implemented\n"));
2370 return(FALSE);
2371}
2372//******************************************************************************
2373//******************************************************************************
2374DWORD WIN32API GetGlyphOutlineA(HDC hdc, UINT uChar, UINT uFormat, LPGLYPHMETRICS lpgm,
2375 DWORD cbBuffer, LPVOID lpvBuffer, CONST MAT2 *lpmat2)
2376{
2377 dprintf(("GDI32: GetGlyphOutLineA, not implemented (GDI_ERROR)\n"));
2378 return(GDI_ERROR);
2379}
2380//******************************************************************************
2381
2382//******************************************************************************
2383/*KSO Thu 21.05.1998*/
2384DWORD WIN32API GetGlyphOutlineW(HDC hdc, UINT uChar, UINT uFormat, LPGLYPHMETRICS lpgm,
2385 DWORD cbBuffer, LPVOID lpvBuffer, CONST MAT2 *lpmat2)
2386{
2387 dprintf(("GDI32: GetGlyphOutLineW, not implemented\n"));
2388 return(GDI_ERROR);
2389}
2390//******************************************************************************
2391
2392//******************************************************************************
2393int WIN32API DescribePixelFormat(HDC, int, UINT, LPPIXELFORMATDESCRIPTOR)
2394{
2395 dprintf(("GDI32: DescribePixelFormat, not implemented (GDI_ERROR)\n"));
2396 return(GDI_ERROR);
2397}
2398//******************************************************************************
2399//******************************************************************************
2400BOOL WIN32API SetObjectOwner( HGDIOBJ arg1, int arg2 )
2401{
2402 // Here is a guess for a undocumented entry
2403 dprintf(("GDI32: SetObjectOwner - stub (TRUE)\n"));
2404 return TRUE;
2405}
2406//******************************************************************************
2407
2408
2409/* Office 97 stubs - KSO Thu 21.05.1998*/
2410//******************************************************************************
2411BOOL WIN32API GetTextExtentExPointA(/*KSO Thu 21.05.1998*/
2412 HDC hdc,
2413 LPCSTR str,
2414 int count,
2415 int maxExt,
2416 LPINT lpnFit,
2417 LPINT alpDx,
2418 LPSIZE size)
2419{
2420 int index, nFit, extent;
2421 SIZE tSize;
2422
2423 dprintf(("GDI32: GetTextExtendExPointA\n"));
2424
2425 size->cx = size->cy = nFit = extent = 0;
2426 for(index = 0; index < count; index++)
2427 {
2428 if(!O32_GetTextExtentPoint( hdc, str, 1, &tSize )) return FALSE;
2429 if( extent+tSize.cx < maxExt )
2430 {
2431 extent+=tSize.cx;
2432 nFit++;
2433 str++;
2434 if( alpDx )
2435 alpDx[index] = extent;
2436 if( tSize.cy > size->cy ) size->cy = tSize.cy;
2437 }
2438 else break;
2439 }
2440 size->cx = extent;
2441
2442 if (lpnFit != NULL) // check if result is desired
2443 *lpnFit = nFit;
2444
2445 dprintf(("GDI32: GetTextExtendExPointA(%08x '%.*s' %d) returning %d %d %d\n",
2446 hdc,count,str,maxExt,nFit, size->cx,size->cy));
2447 return TRUE;
2448}
2449//******************************************************************************
2450//******************************************************************************
2451BOOL WIN32API GetTextExtentExPointW( /*KSO Thu 21.05.1998*/
2452 HDC arg1,
2453 LPCWSTR arg2,
2454 int arg3,
2455 int arg4,
2456 LPINT arg5,
2457 LPINT arg6,
2458 LPSIZE arg7
2459 )
2460{
2461 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2462 BOOL rc;
2463
2464 dprintf(("GDI32: GetTextExtendExPointW\n"));
2465 rc = GetTextExtentExPointA(arg1, astring, arg3, arg4, arg5, arg6, arg7);
2466 FreeAsciiString(astring);
2467 return rc;
2468}
2469//******************************************************************************
2470//******************************************************************************
2471BOOL WIN32API PlayEnhMetaFileRecord( /*KSO Thu 21.05.1998*/
2472 HDC arg1,
2473 LPHANDLETABLE arg2,
2474 CONST ENHMETARECORD *arg3,
2475 UINT arg4
2476 )
2477{
2478 dprintf(("GDI32: PlayEnhMetaFileRecord - stub\n"));
2479 return FALSE;
2480}
2481//******************************************************************************
2482UINT WIN32API GetEnhMetaFileDescriptionA( /*KSO Thu 21.05.1998*/
2483 HENHMETAFILE arg1,
2484 UINT arg2,
2485 LPSTR arg3
2486 )
2487{
2488 dprintf(("GDI32: GetEnhMetaFileDescriptionA - stub\n"));
2489 return FALSE;
2490}
2491//******************************************************************************
2492//******************************************************************************
2493UINT WIN32API GetEnhMetaFileDescriptionW( /*KSO Thu 21.05.1998*/
2494 HENHMETAFILE arg1,
2495 UINT arg2,
2496 LPWSTR arg3
2497 )
2498{
2499 dprintf(("GDI32: GetEnhMetaFileDescriptionW - stub\n"));
2500 return FALSE;
2501}
2502//******************************************************************************
2503//******************************************************************************
2504UINT WIN32API DeleteColorSpace( /*KSO Thu 21.05.1998*/
2505 HCOLORSPACE hColorSpace
2506 )
2507{
2508 dprintf(("GDI32: DeleteColorSpace - stub\n"));
2509 return FALSE;
2510}
2511//******************************************************************************
2512//******************************************************************************
2513BOOL WIN32API SetColorSpace( /*KSO Thu 21.05.1998*/
2514 HDC hdc,
2515 HCOLORSPACE hColorSpace
2516 )
2517{
2518 dprintf(("GDI32: SetColorSpace - stub\n"));
2519 return FALSE;
2520}
2521//******************************************************************************
2522//******************************************************************************
2523 HCOLORSPACE WIN32API CreateColorSpaceA( /*KSO Thu 21.05.1998*/
2524 LPLOGCOLORSPACEA lpLogColorSpace
2525 )
2526{
2527 dprintf(("GDI32: CreateColorSpaceA - stub\n"));
2528 return 0;
2529}
2530//******************************************************************************
2531//******************************************************************************
2532HCOLORSPACE WIN32API CreateColorSpaceW( /*KSO Thu 21.05.1998*/
2533 LPLOGCOLORSPACEW lpwLogColorSpace
2534 )
2535{
2536 dprintf(("GDI32: CreateColorSpaceW - stub\n"));
2537 return 0;
2538}
2539//******************************************************************************
2540//******************************************************************************
2541HANDLE WIN32API GetColorSpace( /*KSO Thu 21.05.1998*/
2542 HDC hdc
2543 )
2544{
2545 dprintf(("GDI32: GetColorSpace - stub\n"));
2546 return 0;
2547}
2548//******************************************************************************
2549//******************************************************************************
2550int WIN32API SetICMMode( /*KSO Thu 21.05.1998*/
2551 HDC hdc,
2552 int mode
2553 )
2554{
2555 dprintf(("GDI32: SetICMMode - stub\n"));
2556 return 0;
2557}
2558//******************************************************************************
2559
2560
2561
2562
2563/*****************************************************************************
2564 * Name : BOOL CancelDC
2565 * Purpose : The CancelDC function cancels any pending operation on the
2566 * specified device context (DC).
2567 * Parameters: HDC hdc handle of device context
2568 * Variables :
2569 * Result : TRUE / FALSE
2570 * Remark :
2571 * Status : UNTESTED STUB
2572 *
2573 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2574 *****************************************************************************/
2575
2576BOOL WIN32API CancelDC(HDC hdc)
2577{
2578 dprintf(("GDI32: CancelDC(%08xh) not implemented.\n",
2579 hdc));
2580
2581 return (FALSE);
2582}
2583
2584
2585/*****************************************************************************
2586 * Name : BOOL CheckColorsInGamut
2587 * Purpose : The CheckColorsInGamut function indicates whether the specified
2588 * color values are within the gamut of the specified device.
2589 * Parameters: HDC hdc handle of device context
2590 * LPVOID lpaRGBQuad
2591 * LPVOID lpResult
2592 * DWORD dwResult
2593 * Variables :
2594 * Result : TRUE / FALSE
2595 * Remark :
2596 * Status : UNTESTED STUB
2597 *
2598 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2599 *****************************************************************************/
2600
2601BOOL WIN32API CheckColorsInGamut(HDC hdc,
2602 LPVOID lpaRGBQuad,
2603 LPVOID lpResult,
2604 DWORD dwResult)
2605{
2606 dprintf(("GDI32: CheckColorsInGamut(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2607 hdc,
2608 lpaRGBQuad,
2609 lpResult,
2610 dwResult));
2611
2612 return (FALSE);
2613}
2614
2615
2616/*****************************************************************************
2617 * Name : BOOL ColorMatchToTarget
2618 * Purpose : The ColorMatchToTarget function enables or disables preview for
2619 * the specified device context. When preview is enabled, colors
2620 * in subsequent output to the specified device context are
2621 * displayed as they would appear on the target device. This is
2622 * useful for checking how well the target maps the specified
2623 * colors in an image. To enable preview, image color matching
2624 * must be enabled for both the target and the preview device context.
2625 * Parameters: HDC hdc handle of device context
2626 * HDC hdcTarget handle of target device context
2627 * DWORD uiAction
2628 * Variables :
2629 * Result : TRUE / FALSE
2630 * Remark :
2631 * Status : UNTESTED STUB
2632 *
2633 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2634 *****************************************************************************/
2635
2636BOOL WIN32API ColorMatchToTarget(HDC hdc,
2637 HDC hdcTarget,
2638 DWORD uiAction)
2639{
2640 dprintf(("GDI32: ColorMatchToTarget(%08xh,%08xh,%08xh) not implemented.\n",
2641 hdc,
2642 hdcTarget,
2643 uiAction));
2644
2645 return (FALSE);
2646}
2647
2648
2649/*****************************************************************************
2650 * Name : BOOL CombineTransform
2651 * Purpose : The CombineTransform function concatenates two world-space to
2652 * page-space transformations.
2653 * Parameters: LLPXFORM lLPXFORMResult address of combined transformation
2654 * XFORM *lLPXFORM1 address of 1st transformation
2655 * XFORM *lLPXFORM2 address of 2nd transformation
2656 * Variables :
2657 * Result : TRUE / FALSE
2658 * Remark :
2659 * Status : UNTESTED
2660 *
2661 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2662 * Markus Montkowski [Wen, 1999/01/12 20:18]
2663 *****************************************************************************/
2664
2665BOOL WIN32API CombineTransform(LPXFORM lLPXFORMResult,
2666 CONST XFORM *lLPXFORM1,
2667 CONST XFORM *lLPXFORM2)
2668{
2669 dprintf(("GDI32: CombineTransform(%08xh,%08xh,%08xh).\n",
2670 lLPXFORMResult,
2671 lLPXFORM1,
2672 lLPXFORM2));
2673
2674 XFORM xfrm;
2675 if( O32_IsBadWritePtr( (void*)lLPXFORMResult, sizeof(XFORM)) ||
2676 O32_IsBadReadPtr( (void*)lLPXFORM1, sizeof(XFORM)) ||
2677 O32_IsBadWritePtr( (void*)lLPXFORM2, sizeof(XFORM)) )
2678 return (FALSE);
2679
2680 // Add the translations
2681 lLPXFORMResult->eDx = lLPXFORM1->eDx + lLPXFORM2->eDx;
2682 lLPXFORMResult->eDy = lLPXFORM1->eDy + lLPXFORM2->eDy;
2683
2684 // Multiply the matrixes
2685 xfrm.eM11 = lLPXFORM1->eM11 * lLPXFORM2->eM11 + lLPXFORM1->eM21 * lLPXFORM1->eM12;
2686 xfrm.eM12 = lLPXFORM1->eM11 * lLPXFORM2->eM12 + lLPXFORM1->eM12 * lLPXFORM1->eM22;
2687 xfrm.eM21 = lLPXFORM1->eM21 * lLPXFORM2->eM11 + lLPXFORM1->eM22 * lLPXFORM1->eM21;
2688 xfrm.eM22 = lLPXFORM1->eM21 * lLPXFORM2->eM12 + lLPXFORM1->eM22 * lLPXFORM1->eM22;
2689
2690 // Now copy to resulting XFROM as the pt must not be distinct
2691 lLPXFORMResult->eM11 = xfrm.eM11;
2692 lLPXFORMResult->eM12 = xfrm.eM12;
2693 lLPXFORMResult->eM21 = xfrm.eM21;
2694 lLPXFORMResult->eM22 = xfrm.eM22;
2695
2696 return (TRUE);
2697}
2698
2699
2700
2701/*****************************************************************************
2702 * Name : HBRUSH CreateDIBPatternBrush
2703 * Purpose : The CreateDIBPatternBrush function creates a logical brush that
2704 * has the pattern specified by the specified device-independent
2705 * bitmap (DIB). The brush can subsequently be selected into any
2706 * device context that is associated with a device that supports
2707 * raster operations.
2708 * This function is provided only for compatibility with applications
2709 * written for versions of Windows earlier than 3.0. For Win32-based
2710 * applications, use the CreateDIBPatternBrushPt function.
2711 * Parameters: HGLOBAL hglbDIBPacked Identifies a global memory object containing
2712 * a packed DIB, which consists of a BITMAPINFO structure immediately
2713 * followed by an array of bytes defining the pixels of the bitmap.
2714 * UINT fuColorSpec color table data
2715 * Variables :
2716 * Result : TRUE / FALSE
2717 * Remark :
2718 * Status : UNTESTED
2719 *
2720 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2721 * Markus Montkowski [Wen, 1999/01/12 20:00]
2722 *****************************************************************************/
2723
2724HBRUSH WIN32API CreateDIBPatternBrush( HGLOBAL hglbDIBPacked,
2725 UINT fuColorSpec)
2726{
2727 LPVOID lpMem;
2728 HBRUSH ret = 0;
2729 dprintf(("GDI32: CreateDIBPatternBrush(%08xh, %08xh) \n",
2730 hglbDIBPacked,
2731 fuColorSpec));
2732
2733 lpMem = GlobalLock(hglbDIBPacked);
2734 if(NULL!=lpMem)
2735 {
2736
2737 ret = CreateDIBPatternBrushPt( lpMem,
2738 fuColorSpec);
2739 GlobalUnlock(hglbDIBPacked);
2740 }
2741
2742 return (ret);
2743}
2744
2745
2746
2747
2748/*****************************************************************************
2749 * Name : int EnumICMProfilesA
2750 * Purpose : The EnumICMProfilesA function enumerates the different color
2751 * profiles that the system supports for the specified device context.
2752 * Parameters: HDC hdc
2753 * ICMENUMPROC lpICMEnumFunc
2754 * LPARAM lParam
2755 * Variables :
2756 * Result : TRUE / FALSE
2757 * Remark :
2758 * Status : UNTESTED STUB
2759 *
2760 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2761 *****************************************************************************/
2762
2763int WIN32API EnumICMProfilesA(HDC hdc,
2764 ICMENUMPROCA lpICMEnumProc,
2765 LPARAM lParam)
2766{
2767 dprintf(("GDI32: EnumICMProfilesA(%08xh, %08xh, %08xh) not implemented(-1).\n",
2768 hdc,
2769 lpICMEnumProc,
2770 lParam));
2771
2772 return (-1);
2773}
2774
2775
2776/*****************************************************************************
2777 * Name : int EnumICMProfilesW
2778 * Purpose : The EnumICMProfilesW function enumerates the different color
2779 * profiles that the system supports for the specified device context.
2780 * Parameters: HDC hdc
2781 * ICMENUMPROC lpICMEnumFunc
2782 * LPARAM lParam
2783 * Variables :
2784 * Result : TRUE / FALSE
2785 * Remark :
2786 * Status : UNTESTED STUB
2787 *
2788 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2789 *****************************************************************************/
2790
2791int WIN32API EnumICMProfilesW(HDC hdc,
2792 ICMENUMPROCW lpICMEnumProc,
2793 LPARAM lParam)
2794{
2795 dprintf(("GDI32: EnumICMProfilesW(%08xh, %08xh, %08xh) not implemented (-1).\n",
2796 hdc,
2797 lpICMEnumProc,
2798 lParam));
2799
2800 return (-1);
2801}
2802
2803
2804/*****************************************************************************
2805 * Name : BOOL FixBrushOrgEx
2806 * Purpose : The FixBrushOrgEx function is not implemented in the Win32 API.
2807 * It is provided for compatibility with Win32s. If called, the
2808 * function does nothing, and returns FALSE.
2809 * Parameters: HDC, int, int, LPPOINT
2810 * Variables :
2811 * Result : TRUE / FALSE
2812 * Remark : not implemented in Win32
2813 * Status : UNTESTED STUB
2814 *
2815 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2816 *****************************************************************************/
2817
2818BOOL WIN32API FixBrushOrgEx(HDC hdc,
2819 int iDummy1,
2820 int iDummy2,
2821 LPPOINT lpPoint)
2822{
2823 dprintf(("GDI32: FixBrushOrgEx(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2824 hdc,
2825 iDummy1,
2826 iDummy2,
2827 lpPoint));
2828
2829 return (FALSE);
2830}
2831
2832
2833/*****************************************************************************
2834 * Name : DWORD GdiGetBatchLimit
2835 * Purpose : The GdiGetBatchLimit function returns the maximum number of
2836 * function calls that can be accumulated in the calling thread's
2837 * current batch. The system flushes the current batch whenever
2838 * this limit is exceeded.
2839 * Parameters:
2840 * Variables :
2841 * Result : 1
2842 * Remark :
2843 * Status : UNTESTED STUB
2844 *
2845 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2846 *****************************************************************************/
2847
2848DWORD WIN32API GdiGetBatchLimit(VOID)
2849{
2850 dprintf(("GDI32: GdiGetBatchLimit() not implemented (1).\n"));
2851
2852 return (1);
2853}
2854
2855
2856/*****************************************************************************
2857 * Name : DWORD GdiSetBatchLimit
2858 * Purpose : The GdiSetBatchLimit function sets the maximum number of
2859 * functions that can be accumulated in the calling thread's current
2860 * batch. The system flushes the current batch whenever this limit
2861 * is exceeded.
2862 * Parameters: DWORD dwLimit
2863 * Variables :
2864 * Result :
2865 * Remark :
2866 * Status : UNTESTED STUB
2867 *
2868 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2869 *****************************************************************************/
2870
2871DWORD WIN32API GdiSetBatchLimit(DWORD dwLimit)
2872{
2873 dprintf(("GDI32: GdiSetBatchLimit(%08xh) not implemented (1).\n",
2874 dwLimit));
2875
2876 return (1);
2877}
2878
2879
2880/*****************************************************************************
2881 * Name : DWORD GetCharacterPlacementA
2882 * Purpose : The GetCharacterPlacementA function retrieves information about
2883 * a character string, such as character widths, caret positioning,
2884 * ordering within the string, and glyph rendering. The type of
2885 * information returned depends on the dwFlags parameter and is
2886 * based on the currently selected font in the given display context.
2887 * The function copies the information to the specified GCP_RESULTSA
2888 * structure or to one or more arrays specified by the structure.
2889 * Parameters: HDC hdc handle to device context
2890 * LPCSTR lpString pointer to string
2891 * int nCount number of characters in string
2892 * int nMaxExtent maximum extent for displayed string
2893 * LPGCP_RESULTSA *lpResults pointer to buffer for placement result
2894 * DWORD dwFlags placement flags
2895 * Variables :
2896 * Result :
2897 * Remark :
2898 * Status : UNTESTED STUB
2899 *
2900 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2901 *****************************************************************************/
2902
2903DWORD WIN32API GetCharacterPlacementA(HDC hdc,
2904 LPCSTR lpString,
2905 int nCount,
2906 int nMaxExtent,
2907 GCP_RESULTSA * lpResults,
2908 DWORD dwFlags)
2909{
2910 dprintf(("GDI32: GetCharacterPlacementA(%08xh,%s,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2911 hdc,
2912 lpString,
2913 nCount,
2914 nMaxExtent,
2915 lpResults,
2916 dwFlags));
2917
2918 return (0);
2919}
2920
2921
2922/*****************************************************************************
2923 * Name : DWORD GetCharacterPlacementW
2924 * Purpose : The GetCharacterPlacementW function retrieves information about
2925 * a character string, such as character widths, caret positioning,
2926 * ordering within the string, and glyph rendering. The type of
2927 * information returned depends on the dwFlags parameter and is
2928 * based on the currently selected font in the given display context.
2929 * The function copies the information to the specified GCP_RESULTSW
2930 * structure or to one or more arrays specified by the structure.
2931 * Parameters: HDC hdc handle to device context
2932 * LPCSTR lpString pointer to string
2933 * int nCount number of characters in string
2934 * int nMaxExtent maximum extent for displayed string
2935 * GCP_RESULTSW *lpResults pointer to buffer for placement result
2936 * DWORD dwFlags placement flags
2937 * Variables :
2938 * Result :
2939 * Remark :
2940 * Status : UNTESTED STUB
2941 *
2942 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2943 *****************************************************************************/
2944
2945DWORD WIN32API GetCharacterPlacementW(HDC hdc,
2946 LPCWSTR lpString,
2947 int nCount,
2948 int nMaxExtent,
2949 GCP_RESULTSW *lpResults,
2950 DWORD dwFlags)
2951{
2952 dprintf(("GDI32: GetCharacterPlacementW(%08xh,%s,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2953 hdc,
2954 lpString,
2955 nCount,
2956 nMaxExtent,
2957 lpResults,
2958 dwFlags));
2959
2960 return (0);
2961}
2962
2963
2964/*****************************************************************************
2965 * Name : DWORD GetDeviceGammaRamp
2966 * Purpose : The GetDeviceGammaRamp function retrieves the gamma ramp on
2967 * direct color display boards.
2968 * Parameters: HDC hdc handle to device context
2969 * LPVOID lpRamp Gamma ramp array
2970 * Variables :
2971 * Result :
2972 * Remark :
2973 * Status : UNTESTED STUB
2974 *
2975 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2976 *****************************************************************************/
2977
2978DWORD WIN32API GetDeviceGammaRamp(HDC hdc,
2979 LPVOID lpRamp)
2980{
2981 dprintf(("GDI32: GetDeviceGammaRamp(%08xh, %08xh) not implemented.\n",
2982 hdc,
2983 lpRamp));
2984
2985 return (FALSE);
2986}
2987
2988
2989
2990
2991/*****************************************************************************
2992 * Name : BOOL GetICMProfileA
2993 * Purpose : The GetICMProfileA function retrieves the name of the color
2994 * profile file for the device associated with the specified device
2995 * context.
2996 * Parameters: HDC hdc handle to device context
2997 * DWORD cbName
2998 * LPTSTR lpszFilename
2999 * Variables :
3000 * Result : TRUE / FALSE
3001 * Remark :
3002 * Status : UNTESTED STUB
3003 *
3004 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3005 *****************************************************************************/
3006
3007BOOL WIN32API GetICMProfileA(HDC hdc,
3008 DWORD cbName,
3009 LPTSTR lpszFilename)
3010{
3011 dprintf(("GDI32: GetICMProfileA(%08xh, %08xh, %08xh) not implemented.\n",
3012 hdc,
3013 cbName,
3014 lpszFilename));
3015
3016 return (FALSE);
3017}
3018
3019
3020/*****************************************************************************
3021 * Name : BOOL GetICMProfileW
3022 * Purpose : The GetICMProfileW function retrieves the name of the color
3023 * profile file for the device associated with the specified device
3024 * context.
3025 * Parameters: HDC hdc handle to device context
3026 * DWORD cbName
3027 * LPWSTR lpszFilename
3028 * Variables :
3029 * Result : TRUE / FALSE
3030 * Remark :
3031 * Status : UNTESTED STUB
3032 *
3033 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3034 *****************************************************************************/
3035
3036BOOL WIN32API GetICMProfileW(HDC hdc,
3037 DWORD cbName,
3038 LPTSTR lpszFilename)
3039{
3040 dprintf(("GDI32: GetICMProfileW(%08xh, %08xh, %08xh) not implemented.\n",
3041 hdc,
3042 cbName,
3043 lpszFilename));
3044
3045 return (FALSE);
3046}
3047
3048
3049/*****************************************************************************
3050 * Name : BOOL GetLogColorSpaceA
3051 * Purpose : The GetLogColorSpace function retrieves information about the
3052 * logical color space identified by the specified handle.
3053 * Parameters: HCOLORSPACE hColorSpace
3054 * LPLOGCOLORSPACE lpbuffer
3055 * DWORD nSize
3056 * Variables :
3057 * Result : TRUE / FALSE
3058 * Remark :
3059 * Status : UNTESTED STUB
3060 *
3061 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3062 *****************************************************************************/
3063
3064#define LPLOGCOLORSPACE LPVOID
3065BOOL WIN32API GetLogColorSpaceA(HCOLORSPACE hColorSpace,
3066 LPLOGCOLORSPACE lpBuffer,
3067 DWORD nSize)
3068{
3069 dprintf(("GDI32: GetLogColorSpaceA(%08xh, %08xh, %08xh) not implemented.\n",
3070 hColorSpace,
3071 lpBuffer,
3072 nSize));
3073
3074 return (FALSE);
3075}
3076
3077
3078/*****************************************************************************
3079 * Name : BOOL GetLogColorSpaceW
3080 * Purpose : The GetLogColorSpace function retrieves information about the
3081 * logical color space identified by the specified handle.
3082 * Parameters: HCOLORSPACE hColorSpace
3083 * LPLOGCOLORSPACE lpbuffer
3084 * DWORD nSize
3085 * Variables :
3086 * Result : TRUE / FALSE
3087 * Remark :
3088 * Status : UNTESTED STUB
3089 *
3090 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3091 *****************************************************************************/
3092
3093BOOL WIN32API GetLogColorSpaceW(HCOLORSPACE hColorSpace,
3094 LPLOGCOLORSPACE lpBuffer,
3095 DWORD nSize)
3096{
3097 dprintf(("GDI32: GetLogColorSpaceW(%08xh, %08xh, %08xh) not implemented.\n",
3098 hColorSpace,
3099 lpBuffer,
3100 nSize));
3101
3102 return (FALSE);
3103}
3104
3105
3106/*****************************************************************************
3107 * Name : int GetMetaRgn
3108 * Purpose : The GetMetaRgn function retrieves the current metaregion for
3109 * the specified device context.
3110 * Parameters: HDC hdc handle of device context
3111 * HRGN hrgn handle of region
3112 * Variables :
3113 * Result : 0 / 1
3114 * Remark :
3115 * Status : UNTESTED STUB
3116 *
3117 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3118 *****************************************************************************/
3119
3120int WIN32API GetMetaRgn(HDC hdc,
3121 HRGN hrgn)
3122{
3123 dprintf(("GDI32: GetMetaRgn(%08xh, %08xh) not implemented.\n",
3124 hdc,
3125 hrgn));
3126
3127 return (0);
3128}
3129
3130
3131/*****************************************************************************
3132 * Name : int GetPixelFormat
3133 * Purpose : The GetPixelFormat function obtains the index of the specified
3134 * device context's currently selected pixel format.
3135 * Parameters: HDC hdc handle of device context
3136 * Variables :
3137 * Result : 0 / 1
3138 * Remark :
3139 * Status : UNTESTED STUB
3140 *
3141 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3142 *****************************************************************************/
3143
3144int WIN32API GetPixelFormat(HDC hdc)
3145{
3146 dprintf(("GDI32: GetPixelFormat(%08xh) not implemented.\n",
3147 hdc));
3148
3149 return (0);
3150}
3151
3152
3153/*****************************************************************************
3154 * Name : BOOL SetDeviceGammaRamp
3155 * Purpose : The SetDeviceGammaRamp function sets the gamma ramp on direct
3156 * color display boards.
3157 * Parameters: HDC hdc handle of device context
3158 * LPVOID lpRamp
3159 * Variables :
3160 * Result : TRUE / FALSE
3161 * Remark :
3162 * Status : UNTESTED STUB
3163 *
3164 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3165 *****************************************************************************/
3166
3167BOOL WIN32API SetDeviceGammaRamp(HDC hdc,
3168 LPVOID lpRamp)
3169{
3170 dprintf(("GDI32: SetDeviceGammaRamp(%08xh, %08xh) not implemented.\n",
3171 hdc,
3172 lpRamp));
3173
3174 return (FALSE);
3175}
3176
3177
3178/*****************************************************************************
3179 * Name : BOOL SetICMProfileA
3180 * Purpose : The SetICMProfileA function sets the color profile for the
3181 * specified device context.
3182 * Parameters: HDC hdc handle of device context
3183 * LPTSTR lpFileName
3184 * Variables :
3185 * Result : TRUE / FALSE
3186 * Remark :
3187 * Status : UNTESTED STUB
3188 *
3189 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3190 *****************************************************************************/
3191
3192BOOL WIN32API SetICMProfileA(HDC hdc,
3193 LPTSTR lpFileName)
3194{
3195 dprintf(("GDI32: SetICMProfileA(%08xh, %s) not implemented.\n",
3196 hdc,
3197 lpFileName));
3198
3199 return (FALSE);
3200}
3201
3202
3203/*****************************************************************************
3204 * Name : BOOL SetICMProfileW
3205 * Purpose : The SetICMProfileW function sets the color profile for the
3206 * specified device context.
3207 * Parameters: HDC hdc handle of device context
3208 * LPTSTR lpFileName
3209 * Variables :
3210 * Result : TRUE / FALSE
3211 * Remark :
3212 * Status : UNTESTED STUB
3213 *
3214 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3215 *****************************************************************************/
3216
3217BOOL WIN32API SetICMProfileW(HDC hdc,
3218 LPWSTR lpFileName)
3219{
3220 dprintf(("GDI32: SetICMProfileW(%08xh, %s) not implemented.\n",
3221 hdc,
3222 lpFileName));
3223
3224 return (FALSE);
3225}
3226
3227
3228/*****************************************************************************
3229 * Name : int SetMetaRgn
3230 * Purpose : The SetMetaRgn function intersects the current clipping region
3231 * for the specified device context with the current metaregion
3232 * and saves the combined region as the new metaregion for the
3233 * specified device context. The clipping region is reset to a null region.
3234 * Parameters: HDC hdc handle of device context
3235 * Variables :
3236 * Result : TRUE / FALSE
3237 * Remark :
3238 * Status : UNTESTED STUB
3239 *
3240 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3241 *****************************************************************************/
3242
3243BOOL WIN32API SetMetaRgn(HDC hdc)
3244{
3245 dprintf(("GDI32: SetMetaRgn(%08xh) not implemented.\n",
3246 hdc));
3247
3248 return (NULLREGION);
3249}
3250
3251
3252/*****************************************************************************
3253 * Name : BOOL UpdateICMRegKeyA
3254 * Purpose : The UpdateICMRegKeyA function installs, removes, or queries
3255 * registry entries that identify ICC color profiles or color-matching
3256 * DLLs. The function carries out the action specified by the nCommand
3257 * parameter.
3258 * Parameters: DWORD dwReserved
3259 * DWORD CMID
3260 * LPTSTR lpszFileName
3261 * UINT nCommand
3262 * Variables :
3263 * Result : TRUE / FALSE
3264 * Remark :
3265 * Status : UNTESTED STUB
3266 *
3267 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3268 *****************************************************************************/
3269
3270BOOL WIN32API UpdateICMRegKeyA(DWORD dwReserved,
3271 DWORD CMID,
3272 LPTSTR lpszFileName,
3273 UINT nCommand)
3274{
3275 dprintf(("GDI32: UpdateICMRegKeyA(%08xh, %08xh, %08xh, %08xh) not implemented.\n",
3276 dwReserved,
3277 CMID,
3278 lpszFileName,
3279 nCommand));
3280
3281 return (FALSE);
3282}
3283
3284
3285/*****************************************************************************
3286 * Name : BOOL UpdateICMRegKeyW
3287 * Purpose : The UpdateICMRegKeyW function installs, removes, or queries
3288 * registry entries that identify ICC color profiles or color-matching
3289 * DLLs. The function carries out the action specified by the nCommand
3290 * parameter.
3291 * Parameters: DWORD dwReserved
3292 * DWORD CMID
3293 * LPWSTR lpszFileName
3294 * UINT nCommand
3295 * Variables :
3296 * Result : TRUE / FALSE
3297 * Remark :
3298 * Status : UNTESTED STUB
3299 *
3300 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3301 *****************************************************************************/
3302
3303BOOL WIN32API UpdateICMRegKeyW(DWORD dwReserved,
3304 DWORD CMID,
3305 LPWSTR lpszFileName,
3306 UINT nCommand)
3307{
3308 dprintf(("GDI32: UpdateICMRegKeyW(%08xh, %08xh, %08xh, %08xh) not implemented.\n",
3309 dwReserved,
3310 CMID,
3311 lpszFileName,
3312 nCommand));
3313
3314 return (FALSE);
3315}
3316
3317
3318
Note: See TracBrowser for help on using the repository browser.