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

Last change on this file since 2400 was 2352, checked in by cbratschi, 26 years ago

fixed PatBlt
File size: 129.5 KB
Line 
1/* $Id: gdi32.cpp,v 1.29 2000-01-07 17:37:53 cbratschi 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 hdc,int nXLeft,int nYLeft,int nWidth,int nHeight,DWORD dwRop)
998{
999 BOOL rc;
1000
1001 //CB: Open32 bug: negative width/height not supported!
1002 if (nWidth < 0)
1003 {
1004 nXLeft += nWidth+1;
1005 nWidth = -nWidth;
1006 }
1007 if (nHeight < 0)
1008 {
1009 nYLeft += nHeight+1;
1010 nHeight = -nHeight;
1011 }
1012 rc = O32_PatBlt(hdc,nXLeft,nYLeft,nWidth,nHeight,dwRop);
1013 dprintf(("GDI32: PatBlt (%d,%d) (%d,%d) returned %d\n",nXLeft,nYLeft,nWidth,nHeight,rc));
1014 return(rc);
1015}
1016//******************************************************************************
1017//******************************************************************************
1018BOOL WIN32API Rectangle( HDC arg1, int arg2, int arg3, int arg4, int arg5)
1019{
1020 dprintf(("GDI32: Rectangle\n"));
1021 return O32_Rectangle(arg1, arg2, arg3, arg4, arg5);
1022}
1023//******************************************************************************
1024//******************************************************************************
1025int WIN32API SetROP2( HDC arg1, int arg2)
1026{
1027 dprintf(("GDI32: SetROP2"));
1028 return O32_SetROP2(arg1, arg2);
1029}
1030//******************************************************************************
1031//TODO: Callback
1032//******************************************************************************
1033BOOL WIN32API EnumMetaFile( HDC arg1, HMETAFILE arg2, MFENUMPROC arg3, LPARAM arg4)
1034{
1035 dprintf(("GDI32: EnumMetaFile STUB"));
1036 //calling convention differences
1037// return O32_EnumMetaFile(arg1, arg2, arg3, arg4);
1038 return 0;
1039}
1040//******************************************************************************
1041//******************************************************************************
1042int WIN32API EnumObjects( HDC arg1, int arg2, GOBJENUMPROC arg3, LPARAM arg4)
1043{
1044 dprintf(("GDI32: EnumObjects STUB"));
1045 //calling convention differences
1046// return O32_EnumObjects(arg1, arg2, arg3, arg4);
1047 return 0;
1048}
1049//******************************************************************************
1050//******************************************************************************
1051BOOL WIN32API EqualRgn( HRGN arg1, HRGN arg2)
1052{
1053 dprintf(("GDI32: EqualRgn"));
1054 return O32_EqualRgn(arg1, arg2);
1055}
1056//******************************************************************************
1057//******************************************************************************
1058int WIN32API Escape( HDC arg1, int arg2, int arg3, LPCSTR arg4, PVOID arg5)
1059{
1060 dprintf(("GDI32: Escape"));
1061 return O32_Escape(arg1, arg2, arg3, arg4, arg5);
1062}
1063//******************************************************************************
1064//******************************************************************************
1065int WIN32API ExcludeClipRect( HDC arg1, int arg2, int arg3, int arg4, int arg5)
1066{
1067 dprintf(("GDI32: ExcludeClipRect"));
1068 return O32_ExcludeClipRect(arg1, arg2, arg3, arg4, arg5);
1069}
1070//******************************************************************************
1071//******************************************************************************
1072HPEN WIN32API ExtCreatePen( DWORD arg1, DWORD arg2, const LOGBRUSH * arg3, DWORD arg4, const DWORD * arg5)
1073{
1074 dprintf(("GDI32: ExtCreatePen"));
1075 return O32_ExtCreatePen(arg1, arg2, arg3, arg4, arg5);
1076}
1077//******************************************************************************
1078//******************************************************************************
1079HRGN WIN32API ExtCreateRegion( const XFORM * arg1, DWORD arg2, const RGNDATA * arg3)
1080{
1081 dprintf(("GDI32: ExtCreateRegion"));
1082 return O32_ExtCreateRegion(arg1, arg2, arg3);
1083}
1084//******************************************************************************
1085//******************************************************************************
1086BOOL WIN32API ExtFloodFill( HDC arg1, int arg2, int arg3, COLORREF arg4, UINT arg5)
1087{
1088 dprintf(("GDI32: ExtFloodFill"));
1089 return O32_ExtFloodFill(arg1, arg2, arg3, arg4, arg5);
1090}
1091//******************************************************************************
1092//******************************************************************************
1093int WIN32API ExtSelectClipRgn( HDC arg1, HRGN arg2, int arg3)
1094{
1095 dprintf(("GDI32: ExtSelectClipRgn"));
1096 return O32_ExtSelectClipRgn(arg1, arg2, arg3);
1097}
1098//******************************************************************************
1099//******************************************************************************
1100BOOL WIN32API FillPath( HDC arg1)
1101{
1102 dprintf(("GDI32: FillPath"));
1103 return O32_FillPath(arg1);
1104}
1105//******************************************************************************
1106//******************************************************************************
1107BOOL WIN32API FillRgn( HDC arg1, HRGN arg2, HBRUSH arg3)
1108{
1109 dprintf(("GDI32: FillRgn"));
1110 return O32_FillRgn(arg1, arg2, arg3);
1111}
1112//******************************************************************************
1113//******************************************************************************
1114BOOL WIN32API FlattenPath( HDC arg1)
1115{
1116 dprintf(("GDI32: FlattenPath"));
1117 return O32_FlattenPath(arg1);
1118}
1119//******************************************************************************
1120//******************************************************************************
1121BOOL WIN32API FloodFill(HDC arg1, int arg2, int arg3, COLORREF arg4)
1122{
1123 dprintf(("GDI32: FloodFill"));
1124 return O32_FloodFill(arg1, arg2, arg3, arg4);
1125}
1126//******************************************************************************
1127//******************************************************************************
1128BOOL WIN32API FrameRgn( HDC arg1, HRGN arg2, HBRUSH arg3, int arg4, int arg5)
1129{
1130 dprintf(("GDI32: FrameRgn"));
1131 return O32_FrameRgn(arg1, arg2, arg3, arg4, arg5);
1132}
1133//******************************************************************************
1134//******************************************************************************
1135int WIN32API GetArcDirection( HDC arg1)
1136{
1137 dprintf(("GDI32: GetArcDirection"));
1138 return O32_GetArcDirection(arg1);
1139}
1140//******************************************************************************
1141//******************************************************************************
1142BOOL WIN32API GetAspectRatioFilterEx( HDC arg1, PSIZE arg2)
1143{
1144 dprintf(("GDI32: GetAspectRatioFilterEx"));
1145 return O32_GetAspectRatioFilterEx(arg1, arg2);
1146}
1147//******************************************************************************
1148//******************************************************************************
1149LONG WIN32API GetBitmapBits( HBITMAP arg1, LONG arg2, PVOID arg3)
1150{
1151 dprintf(("GDI32: GetBitmapBits"));
1152 return O32_GetBitmapBits(arg1, arg2, arg3);
1153}
1154//******************************************************************************
1155//******************************************************************************
1156BOOL WIN32API GetBitmapDimensionEx( HBITMAP arg1, PSIZE arg2)
1157{
1158 dprintf(("GDI32: GetBitmapDimensionEx"));
1159 return O32_GetBitmapDimensionEx(arg1, arg2);
1160}
1161//******************************************************************************
1162//******************************************************************************
1163COLORREF WIN32API GetBkColor( HDC arg1)
1164{
1165 dprintf(("GDI32: GetBkColor"));
1166 return O32_GetBkColor(arg1);
1167}
1168//******************************************************************************
1169//******************************************************************************
1170int WIN32API GetBkMode( HDC arg1)
1171{
1172 dprintf(("GDI32: GetBkMode"));
1173 return O32_GetBkMode(arg1);
1174}
1175//******************************************************************************
1176//******************************************************************************
1177UINT WIN32API GetBoundsRect( HDC arg1, PRECT arg2, UINT arg3)
1178{
1179 dprintf(("GDI32: GetBoundsRect"));
1180 return O32_GetBoundsRect(arg1, arg2, arg3);
1181}
1182//******************************************************************************
1183//******************************************************************************
1184BOOL WIN32API GetBrushOrgEx( HDC arg1, PPOINT arg2)
1185{
1186 dprintf(("GDI32: GetBrushOrgEx"));
1187 return O32_GetBrushOrgEx(arg1, arg2);
1188}
1189//******************************************************************************
1190//******************************************************************************
1191BOOL WIN32API GetCharABCWidthsA( HDC arg1, UINT arg2, UINT arg3, LPABC arg4)
1192{
1193 dprintf(("GDI32: GetCharABCWidthsA"));
1194 return O32_GetCharABCWidths(arg1, arg2, arg3, arg4);
1195}
1196//******************************************************************************
1197//******************************************************************************
1198BOOL WIN32API GetCharABCWidthsW( HDC arg1, UINT arg2, UINT arg3, LPABC arg4)
1199{
1200 dprintf(("GDI32: GetCharABCWidthsW not properly implemented."));
1201 // NOTE: This will not work as is (needs UNICODE support)
1202 return O32_GetCharABCWidths(arg1, arg2, arg3, arg4);
1203}
1204//******************************************************************************
1205//******************************************************************************
1206BOOL WIN32API GetCharWidthA( HDC arg1, UINT arg2, UINT arg3, PINT arg4)
1207{
1208 dprintf(("GDI32: GetCharWidthA"));
1209 return O32_GetCharWidth(arg1, arg2, arg3, arg4);
1210}
1211//******************************************************************************
1212//TODO: Cut off Unicode chars?
1213//******************************************************************************
1214BOOL WIN32API GetCharWidthW(HDC arg1, UINT iFirstChar, UINT iLastChar, PINT arg4)
1215{
1216 dprintf(("GDI32: GetCharWidthW, not properly implemented"));
1217 return O32_GetCharWidth(arg1, iFirstChar, iLastChar, arg4);
1218}
1219//******************************************************************************
1220//******************************************************************************
1221int WIN32API GetClipBox( HDC arg1, PRECT arg2)
1222{
1223 int rc;
1224
1225 rc = O32_GetClipBox(arg1, arg2);
1226 dprintf(("GDI32: GetClipBox of %X returned %d\n", arg1, rc));
1227 return(rc);
1228}
1229//******************************************************************************
1230//******************************************************************************
1231int WIN32API GetClipRgn( HDC arg1, HRGN arg2)
1232{
1233 dprintf(("GDI32: GetClipRgn"));
1234 return O32_GetClipRgn(arg1, arg2);
1235}
1236//******************************************************************************
1237//******************************************************************************
1238HANDLE WIN32API GetCurrentObject( HDC arg1, UINT arg2)
1239{
1240 dprintf(("GDI32: GetCurrentObject"));
1241 return (HANDLE)O32_GetCurrentObject(arg1, arg2);
1242}
1243//******************************************************************************
1244//******************************************************************************
1245BOOL WIN32API GetCurrentPositionEx( HDC arg1, PPOINT arg2)
1246{
1247 dprintf(("GDI32: GetCurrentPositionEx"));
1248 return O32_GetCurrentPositionEx(arg1, arg2);
1249}
1250//******************************************************************************
1251//******************************************************************************
1252int WIN32API GetDIBits( HDC arg1, HBITMAP arg2, UINT arg3, UINT arg4, void * arg5, PBITMAPINFO arg6, UINT arg7)
1253{
1254 dprintf(("GDI32: GetDIBits"));
1255 return O32_GetDIBits(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1256}
1257//******************************************************************************
1258//******************************************************************************
1259int WIN32API GetDeviceCaps(HDC hdc, int nIndex)
1260{
1261 int rc;
1262
1263 rc = O32_GetDeviceCaps(hdc, nIndex);
1264 dprintf(("GDI32: GetDeviceCaps %X, %d returned %d\n", hdc, nIndex, rc));
1265 //SvL: 13-9-'98: NT returns -1 when using 16 bits colors, NOT 65536!
1266 if(nIndex == NUMCOLORS && rc > 256)
1267 return -1;
1268 return(rc);
1269}
1270//******************************************************************************
1271//******************************************************************************
1272HENHMETAFILE WIN32API GetEnhMetaFileA( LPCSTR arg1)
1273{
1274 dprintf(("GDI32: GetEnhMetaFileA"));
1275 return O32_GetEnhMetaFile(arg1);
1276}
1277//******************************************************************************
1278//******************************************************************************
1279UINT WIN32API GetEnhMetaFileBits( HENHMETAFILE arg1, UINT arg2, PBYTE arg3)
1280{
1281 dprintf(("GDI32: GetEnhMetaFileBits"));
1282 return O32_GetEnhMetaFileBits(arg1, arg2, arg3);
1283}
1284//******************************************************************************
1285//******************************************************************************
1286UINT WIN32API GetEnhMetaFileHeader( HENHMETAFILE arg1, UINT arg2, LPENHMETAHEADER arg3)
1287{
1288 dprintf(("GDI32: GetEnhMetaFileHeader"));
1289 return O32_GetEnhMetaFileHeader(arg1, arg2, arg3);
1290}
1291//******************************************************************************
1292//******************************************************************************
1293UINT WIN32API GetEnhMetaFilePaletteEntries( HENHMETAFILE arg1, UINT arg2, PPALETTEENTRY arg3)
1294{
1295 dprintf(("GDI32: GetEnhMetaFilePaletteEntries"));
1296 return O32_GetEnhMetaFilePaletteEntries(arg1, arg2, arg3);
1297}
1298//******************************************************************************
1299//******************************************************************************
1300HENHMETAFILE WIN32API GetEnhMetaFileW( LPCWSTR arg1)
1301{
1302 char *astring = UnicodeToAsciiString((LPWSTR)arg1);
1303 HENHMETAFILE rc;
1304
1305 dprintf(("GDI32: GetEnhMetaFileW"));
1306 // NOTE: This will not work as is (needs UNICODE support)
1307 rc = O32_GetEnhMetaFile(astring);
1308 FreeAsciiString(astring);
1309 return rc;
1310}
1311//******************************************************************************
1312//******************************************************************************
1313int WIN32API GetGraphicsMode(HDC arg1)
1314{
1315 dprintf(("GDI32: GetGraphicsMode"));
1316 return O32_GetGraphicsMode(arg1);
1317}
1318//******************************************************************************
1319//******************************************************************************
1320DWORD WIN32API GetKerningPairsA( HDC arg1, DWORD arg2, LPKERNINGPAIR arg3)
1321{
1322 dprintf(("GDI32: GetKerningPairsA"));
1323 return O32_GetKerningPairs(arg1, arg2, arg3);
1324}
1325//******************************************************************************
1326//******************************************************************************
1327DWORD WIN32API GetKerningPairsW( HDC arg1, DWORD arg2, LPKERNINGPAIR arg3)
1328{
1329 dprintf(("GDI32: GetKerningPairsW"));
1330 // NOTE: This will not work as is (needs UNICODE support)
1331 return O32_GetKerningPairs(arg1, arg2, arg3);
1332}
1333//******************************************************************************
1334//******************************************************************************
1335int WIN32API GetMapMode( HDC arg1)
1336{
1337 dprintf(("GDI32: GetMapMode"));
1338 return O32_GetMapMode(arg1);
1339}
1340//******************************************************************************
1341//******************************************************************************
1342HMETAFILE WIN32API GetMetaFileA( LPCSTR arg1)
1343{
1344 dprintf(("GDI32: GetMetaFileA"));
1345 return O32_GetMetaFile(arg1);
1346}
1347//******************************************************************************
1348//******************************************************************************
1349UINT WIN32API GetMetaFileBitsEx( HMETAFILE arg1, UINT arg2, LPVOID arg3)
1350{
1351 dprintf(("GDI32: GetMetaFileBitsEx"));
1352 return O32_GetMetaFileBitsEx(arg1, arg2, arg3);
1353}
1354//******************************************************************************
1355//******************************************************************************
1356HMETAFILE WIN32API GetMetaFileW( LPCWSTR arg1)
1357{
1358 char *astring = UnicodeToAsciiString((LPWSTR)arg1);
1359 HENHMETAFILE rc;
1360
1361 dprintf(("GDI32: GetMetaFileW"));
1362 rc = O32_GetMetaFile(astring);
1363 FreeAsciiString(astring);
1364 return rc;
1365
1366}
1367//******************************************************************************
1368//******************************************************************************
1369BOOL WIN32API GetMiterLimit( HDC arg1, float * arg2)
1370{
1371 dprintf(("GDI32: GetMiterLimit"));
1372 return O32_GetMiterLimit(arg1, arg2);
1373}
1374//******************************************************************************
1375//******************************************************************************
1376COLORREF WIN32API GetNearestColor( HDC arg1, COLORREF arg2)
1377{
1378 dprintf(("GDI32: GetNearestColor\n"));
1379 return O32_GetNearestColor(arg1, arg2);
1380}
1381//******************************************************************************
1382//******************************************************************************
1383UINT WIN32API GetNearestPaletteIndex( HPALETTE arg1, COLORREF arg2)
1384{
1385 UINT rc;
1386 dprintf(("GDI32: GetNearestPaletteIndex (0x%08X ,0x%08X) ",arg1,arg2));
1387 rc = O32_GetNearestPaletteIndex(arg1, arg2);
1388 dprintf(("Returns %d\n",rc));
1389 return rc;
1390}
1391//******************************************************************************
1392//******************************************************************************
1393UINT WIN32API GetOutlineTextMetricsA( HDC arg1, UINT arg2, LPOUTLINETEXTMETRICA arg3)
1394{
1395 dprintf(("GDI32: GetOutlineTextMetricsA"));
1396 return O32_GetOutlineTextMetrics(arg1, arg2, arg3);
1397}
1398//******************************************************************************
1399//******************************************************************************
1400UINT WIN32API GetOutlineTextMetricsW( HDC arg1, UINT arg2, LPOUTLINETEXTMETRICW arg3)
1401{
1402 dprintf(("GDI32: GetOutlineTextMetricsW STUB"));
1403 // NOTE: This will not work as is (needs UNICODE support)
1404// return O32_GetOutlineTextMetrics(arg1, arg2, arg3);
1405 return 0;
1406}
1407//******************************************************************************
1408//******************************************************************************
1409UINT WIN32API GetPaletteEntries( HPALETTE arg1, UINT arg2, UINT arg3, PPALETTEENTRY arg4)
1410{
1411 dprintf(("GDI32: GetPaletteEntries"));
1412 return O32_GetPaletteEntries(arg1, arg2, arg3, arg4);
1413}
1414//******************************************************************************
1415//******************************************************************************
1416INT WIN32API GetPath( HDC arg1, PPOINT arg2, PBYTE arg3, int arg4)
1417{
1418 dprintf(("GDI32: GetPath"));
1419 return O32_GetPath(arg1, arg2, arg3, arg4);
1420}
1421//******************************************************************************
1422//******************************************************************************
1423int WIN32API GetPolyFillMode( HDC arg1)
1424{
1425 dprintf(("GDI32: GetPolyFillMode"));
1426 return O32_GetPolyFillMode(arg1);
1427}
1428//******************************************************************************
1429//******************************************************************************
1430int WIN32API GetROP2( HDC arg1)
1431{
1432 dprintf(("GDI32: GetROP2"));
1433 return O32_GetROP2(arg1);
1434}
1435//******************************************************************************
1436//******************************************************************************
1437BOOL WIN32API GetRasterizerCaps(LPRASTERIZER_STATUS arg1, UINT arg2)
1438{
1439 dprintf(("GDI32: GetRasterizerCaps"));
1440 return O32_GetRasterizerCaps(arg1, arg2);
1441}
1442//******************************************************************************
1443//******************************************************************************
1444DWORD WIN32API GetRegionData( HRGN arg1, DWORD arg2, PRGNDATA arg3)
1445{
1446 dprintf(("GDI32: GetRegionData"));
1447 return O32_GetRegionData(arg1, arg2, arg3);
1448}
1449//******************************************************************************
1450//******************************************************************************
1451int WIN32API GetRgnBox( HRGN arg1, PRECT arg2)
1452{
1453 dprintf(("GDI32: GetRgnBox"));
1454 return O32_GetRgnBox(arg1, arg2);
1455}
1456//******************************************************************************
1457//******************************************************************************
1458int WIN32API GetStretchBltMode( HDC arg1)
1459{
1460 dprintf(("GDI32: GetStretchBltMode"));
1461 return O32_GetStretchBltMode(arg1);
1462}
1463//******************************************************************************
1464//******************************************************************************
1465UINT WIN32API GetSystemPaletteEntries( HDC arg1, UINT arg2, UINT arg3, PPALETTEENTRY arg4)
1466{
1467 UINT rc;
1468
1469 dprintf(("GDI32: GetSystemPaletteEntries start %d nr %d pal ptr %X", arg2, arg3, arg4));
1470 rc = O32_GetSystemPaletteEntries(arg1, arg2, arg3, arg4);
1471 dprintf((" GetSystemPaletteEntries returned %d", rc));
1472 return(rc);
1473}
1474//******************************************************************************
1475//******************************************************************************
1476UINT WIN32API GetTextAlign( HDC arg1)
1477{
1478 dprintf(("GDI32: GetTextAlign"));
1479 return O32_GetTextAlign(arg1);
1480}
1481//******************************************************************************
1482//******************************************************************************
1483int WIN32API GetTextCharacterExtra( HDC arg1)
1484{
1485 dprintf(("GDI32: GetTextCharacterExtra"));
1486 return O32_GetTextCharacterExtra(arg1);
1487}
1488//******************************************************************************
1489//******************************************************************************
1490COLORREF WIN32API GetTextColor( HDC arg1)
1491{
1492 dprintf(("GDI32: GetTextColor"));
1493 return O32_GetTextColor(arg1);
1494}
1495//******************************************************************************
1496//******************************************************************************
1497BOOL WIN32API GetTextExtentPoint32A( HDC arg1, LPCSTR arg2, int arg3, PSIZE lpSize)
1498{
1499 dprintf(("GDI32: GetTextExtentPoint32A"));
1500 lpSize->cx = lpSize->cy = 0;
1501 return O32_GetTextExtentPoint32(arg1, arg2, arg3, lpSize);
1502}
1503//******************************************************************************
1504//******************************************************************************
1505BOOL WIN32API GetTextExtentPoint32W(HDC arg1, LPCWSTR arg2, int arg3, PSIZE lpSize)
1506{
1507 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1508 BOOL rc;
1509
1510 dprintf(("GDI32: GetTextExtentPoint32W %s\n", astring));
1511 lpSize->cx = lpSize->cy = 0;
1512 rc = O32_GetTextExtentPoint32(arg1, astring, arg3, lpSize);
1513 FreeAsciiString(astring);
1514 return(rc);
1515}
1516//******************************************************************************
1517//******************************************************************************
1518BOOL WIN32API GetTextExtentPointW(HDC hdc,
1519 LPCWSTR lpString,
1520 int cbString,
1521 PSIZE lpSize)
1522{
1523 char *astring = UnicodeToAsciiString((LPWSTR)lpString);
1524 BOOL rc;
1525
1526 lpSize->cx = lpSize->cy = 0;
1527 rc = O32_GetTextExtentPoint(hdc,
1528 astring,
1529 cbString,
1530 lpSize);
1531 dprintf(("GDI32: GetTextExtentPointW %X %s (size %08xh) returned %d\n", hdc, astring, cbString, rc));
1532 dprintf(("GDI32: GetTextExtentPointW (%d,%d)\n", lpSize->cx, lpSize->cy));
1533
1534 FreeAsciiString(astring);
1535 return(rc);
1536}
1537//******************************************************************************
1538//******************************************************************************
1539int WIN32API GetTextFaceA( HDC arg1, int arg2, LPSTR arg3)
1540{
1541 dprintf(("GDI32: GetTextFaceA"));
1542 return O32_GetTextFace(arg1, arg2, arg3);
1543}
1544//******************************************************************************
1545//******************************************************************************
1546int WIN32API GetTextFaceW( HDC arg1, int arg2, LPWSTR arg3)
1547{
1548 char *astring = (char *)malloc(arg2+1);
1549 int rc;
1550
1551 dprintf(("GDI32: GetTextFaceW"));
1552 rc = O32_GetTextFace(arg1, arg2, astring);
1553 AsciiToUnicode(astring, arg3);
1554 free(astring);
1555 return rc;
1556}
1557//******************************************************************************
1558//******************************************************************************
1559BOOL WIN32API GetTextMetricsA( HDC arg1, LPTEXTMETRICA arg2)
1560{
1561 BOOL rc;
1562
1563 rc = O32_GetTextMetrics(arg1, arg2);
1564 dprintf(("GDI32: GetTextMetricsA returned %d\n", rc));
1565 return(rc);
1566}
1567//******************************************************************************
1568//******************************************************************************
1569BOOL WIN32API GetTextMetricsW( HDC arg1, LPTEXTMETRICW pwtm)
1570{
1571 BOOL rc;
1572 TEXTMETRICA atm;
1573
1574 dprintf(("GDI32: GetTextMetricsW"));
1575
1576 rc = O32_GetTextMetrics(arg1, &atm);
1577 pwtm->tmHeight = atm.tmHeight;
1578 pwtm->tmAscent = atm.tmAscent;
1579 pwtm->tmDescent = atm.tmDescent;
1580 pwtm->tmInternalLeading = atm.tmInternalLeading;
1581 pwtm->tmExternalLeading = atm.tmExternalLeading;
1582 pwtm->tmAveCharWidth = atm.tmAveCharWidth;
1583 pwtm->tmMaxCharWidth = atm.tmMaxCharWidth;
1584 pwtm->tmWeight = atm.tmWeight;
1585 pwtm->tmOverhang = atm.tmOverhang;
1586 pwtm->tmDigitizedAspectX = atm.tmDigitizedAspectX;
1587 pwtm->tmDigitizedAspectY = atm.tmDigitizedAspectY;
1588 pwtm->tmFirstChar = atm.tmFirstChar;
1589 pwtm->tmLastChar = atm.tmLastChar;
1590 pwtm->tmDefaultChar = atm.tmDefaultChar;
1591 pwtm->tmBreakChar = atm.tmBreakChar;
1592 pwtm->tmItalic = atm.tmItalic;
1593 pwtm->tmUnderlined = atm.tmUnderlined;
1594 pwtm->tmStruckOut = atm.tmStruckOut;
1595 pwtm->tmPitchAndFamily = atm.tmPitchAndFamily;
1596 pwtm->tmCharSet = atm.tmCharSet;
1597 return(rc);
1598}
1599//******************************************************************************
1600//******************************************************************************
1601BOOL WIN32API GetViewportExtEx( HDC arg1, PSIZE arg2)
1602{
1603 dprintf(("GDI32: GetViewportExtEx"));
1604 return O32_GetViewportExtEx(arg1, arg2);
1605}
1606//******************************************************************************
1607//******************************************************************************
1608BOOL WIN32API GetViewportOrgEx( HDC arg1, PPOINT arg2)
1609{
1610 dprintf(("GDI32: GetViewportOrgEx"));
1611 return O32_GetViewportOrgEx(arg1, arg2);
1612}
1613//******************************************************************************
1614//******************************************************************************
1615UINT WIN32API GetWinMetaFileBits( HENHMETAFILE arg1, UINT arg2, PBYTE arg3, int arg4, HDC arg5)
1616{
1617 dprintf(("GDI32: GetWinMetaFileBits"));
1618 return O32_GetWinMetaFileBits(arg1, arg2, arg3, arg4, arg5);
1619}
1620//******************************************************************************
1621//******************************************************************************
1622BOOL WIN32API GetWindowOrgEx( HDC arg1, PPOINT arg2)
1623{
1624 dprintf(("GDI32: GetWindowOrgEx"));
1625 return O32_GetWindowOrgEx(arg1, arg2);
1626}
1627//******************************************************************************
1628//******************************************************************************
1629BOOL WIN32API GetWorldTransform( HDC arg1, LPXFORM arg2)
1630{
1631 dprintf(("GDI32: GetWorldTransform"));
1632 return O32_GetWorldTransform(arg1, arg2);
1633}
1634//******************************************************************************
1635//******************************************************************************
1636int WIN32API IntersectClipRect(HDC arg1, int arg2, int arg3, int arg4, int arg5)
1637{
1638 int rc;
1639
1640 rc = O32_IntersectClipRect(arg1, arg2, arg3, arg4, arg5);
1641 dprintf(("GDI32: IntersectClipRect returned %d\n", rc));
1642 return(rc);
1643}
1644//******************************************************************************
1645//******************************************************************************
1646BOOL WIN32API InvertRgn( HDC arg1, HRGN arg2)
1647{
1648 dprintf(("GDI32: InvertRgn"));
1649 return O32_InvertRgn(arg1, arg2);
1650}
1651//******************************************************************************
1652//******************************************************************************
1653BOOL WIN32API LPtoDP( HDC arg1, PPOINT arg2, int arg3)
1654{
1655 dprintf(("GDI32: LPtoDP"));
1656 return O32_LPtoDP(arg1, arg2, arg3);
1657}
1658//******************************************************************************
1659//******************************************************************************
1660BOOL 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)
1661{
1662 dprintf(("GDI32: MaskBlt"));
1663 return O32_MaskBlt(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
1664}
1665//******************************************************************************
1666//******************************************************************************
1667BOOL WIN32API ModifyWorldTransform( HDC arg1, const XFORM *arg2, DWORD arg3)
1668{
1669 dprintf(("GDI32: ModifyWorldTransform"));
1670 return O32_ModifyWorldTransform(arg1, (LPXFORM)arg2, arg3);
1671}
1672//******************************************************************************
1673//******************************************************************************
1674int WIN32API OffsetClipRgn( HDC arg1, int arg2, int arg3)
1675{
1676 dprintf(("GDI32: OffsetClipRgn"));
1677 return O32_OffsetClipRgn(arg1, arg2, arg3);
1678}
1679//******************************************************************************
1680//******************************************************************************
1681int WIN32API OffsetRgn( HRGN arg1, int arg2, int arg3)
1682{
1683 dprintf(("GDI32: OffsetRgn"));
1684 return O32_OffsetRgn(arg1, arg2, arg3);
1685}
1686//******************************************************************************
1687//******************************************************************************
1688BOOL WIN32API OffsetViewportOrgEx( HDC arg1, int arg2, int arg3, PPOINT arg4)
1689{
1690 dprintf(("GDI32: OffsetViewportOrgEx"));
1691 return O32_OffsetViewportOrgEx(arg1, arg2, arg3, arg4);
1692}
1693//******************************************************************************
1694//******************************************************************************
1695BOOL WIN32API OffsetWindowOrgEx( HDC arg1, int arg2, int arg3, PPOINT arg4)
1696{
1697 dprintf(("GDI32: OffsetWindowOrgEx"));
1698 return O32_OffsetWindowOrgEx(arg1, arg2, arg3, arg4);
1699}
1700//******************************************************************************
1701//******************************************************************************
1702BOOL WIN32API PaintRgn( HDC arg1, HRGN arg2)
1703{
1704 dprintf(("GDI32: PaintRgn"));
1705 return O32_PaintRgn(arg1, arg2);
1706}
1707//******************************************************************************
1708//******************************************************************************
1709HRGN WIN32API PathToRegion( HDC arg1)
1710{
1711 dprintf(("GDI32: PathToRegion"));
1712 return O32_PathToRegion(arg1);
1713}
1714//******************************************************************************
1715//******************************************************************************
1716BOOL WIN32API Pie(HDC hdc, int nLeftRect, int nTopRect, int nRightRect,
1717 int nBottomRect, int nXRadial1, int nYRadial1, int nXRadial2,
1718 int nYRadial2)
1719{
1720 dprintf(("GDI32: Pie"));
1721 //CB: bug in O32_Pie
1722 if (nXRadial1 == nXRadial2 && nYRadial1 == nYRadial2)
1723 return O32_Ellipse(hdc,nLeftRect,nTopRect,nRightRect,nBottomRect);
1724 else
1725 return O32_Pie(hdc,nLeftRect,nTopRect,nRightRect,nBottomRect,nXRadial1,nYRadial1,nXRadial2,nYRadial2);
1726}
1727//******************************************************************************
1728//******************************************************************************
1729BOOL WIN32API PlayEnhMetaFile( HDC arg1, HENHMETAFILE arg2, const RECT * arg3)
1730{
1731 dprintf(("GDI32: PlayEnhMetaFile"));
1732 return O32_PlayEnhMetaFile(arg1, arg2, arg3);
1733}
1734//******************************************************************************
1735//******************************************************************************
1736BOOL WIN32API PlayMetaFile( HDC arg1, HMETAFILE arg2)
1737{
1738 dprintf(("GDI32: PlayMetaFile"));
1739 return O32_PlayMetaFile(arg1, arg2);
1740}
1741//******************************************************************************
1742//******************************************************************************
1743BOOL WIN32API PlayMetaFileRecord( HDC arg1, LPHANDLETABLE arg2, LPMETARECORD arg3, UINT arg4)
1744{
1745 dprintf(("GDI32: PlayMetaFileRecord"));
1746 return O32_PlayMetaFileRecord(arg1, arg2, arg3, (int)arg4);
1747}
1748//******************************************************************************
1749//******************************************************************************
1750BOOL WIN32API PolyBezier( HDC arg1, const POINT * arg2, DWORD arg3)
1751{
1752 dprintf(("GDI32: PolyBezier"));
1753 return O32_PolyBezier(arg1, arg2, (int)arg3);
1754}
1755//******************************************************************************
1756//******************************************************************************
1757BOOL WIN32API PolyBezierTo( HDC arg1, const POINT * arg2, DWORD arg3)
1758{
1759 dprintf(("GDI32: PolyBezierTo"));
1760 return O32_PolyBezierTo(arg1, arg2, arg3);
1761}
1762//******************************************************************************
1763//******************************************************************************
1764BOOL WIN32API PolyDraw( HDC arg1, const POINT * arg2, const BYTE * arg3, DWORD arg4)
1765{
1766 dprintf(("GDI32: PolyDraw"));
1767 return O32_PolyDraw(arg1, arg2, arg3, arg4);
1768}
1769//******************************************************************************
1770//******************************************************************************
1771BOOL WIN32API PolyPolygon( HDC arg1, const POINT * arg2, const INT * arg3, UINT arg4)
1772{
1773 dprintf(("GDI32: PolyPolygon"));
1774 return O32_PolyPolygon(arg1, arg2, arg3, arg4);
1775}
1776//******************************************************************************
1777//******************************************************************************
1778BOOL WIN32API PolyPolyline( HDC hdc, const POINT * lppt, const DWORD * lpdwPolyPoints, DWORD cCount)
1779{
1780 dprintf(("GDI32: PolyPolyline"));
1781
1782 return O32_PolyPolyline(hdc,lppt,lpdwPolyPoints,cCount);
1783}
1784//******************************************************************************
1785//******************************************************************************
1786BOOL WIN32API Polygon( HDC arg1, const POINT * arg2, int arg3)
1787{
1788 dprintf(("GDI32: Polygon"));
1789 return O32_Polygon(arg1, arg2, arg3);
1790}
1791//******************************************************************************
1792//******************************************************************************
1793BOOL WIN32API PtInRegion( HRGN arg1, int arg2, int arg3)
1794{
1795 dprintf(("GDI32: PtInRegion"));
1796 return O32_PtInRegion(arg1, arg2, arg3);
1797}
1798//******************************************************************************
1799//******************************************************************************
1800BOOL WIN32API PtVisible( HDC arg1, int arg2, int arg3)
1801{
1802 dprintf(("GDI32: PtVisible"));
1803 return O32_PtVisible(arg1, arg2, arg3);
1804}
1805//******************************************************************************
1806//******************************************************************************
1807BOOL WIN32API RectInRegion( HRGN arg1, const RECT * arg2)
1808{
1809 dprintf(("GDI32: RectInRegion"));
1810 return O32_RectInRegion(arg1, arg2);
1811}
1812//******************************************************************************
1813//******************************************************************************
1814BOOL WIN32API RectVisible( HDC arg1, const RECT * arg2)
1815{
1816 dprintf(("GDI32: RectVisible\n"));
1817 return O32_RectVisible(arg1, arg2);
1818}
1819//******************************************************************************
1820//******************************************************************************
1821HDC WIN32API ResetDCA( HDC arg1, const DEVMODEA * arg2)
1822{
1823 dprintf(("GDI32: ResetDCA\n"));
1824 return (HDC)O32_ResetDC(arg1, arg2);
1825}
1826//******************************************************************************
1827//******************************************************************************
1828HDC WIN32API ResetDCW( HDC arg1, const DEVMODEW * arg2)
1829{
1830 dprintf(("GDI32: ResetDCW\n"));
1831 // NOTE: This will not work as is (needs UNICODE support)
1832 return (HDC)O32_ResetDC(arg1, (const DEVMODEA *)arg2);
1833}
1834//******************************************************************************
1835//******************************************************************************
1836BOOL WIN32API ResizePalette( HPALETTE arg1, UINT arg2)
1837{
1838 dprintf(("GDI32: ResizePalette\n"));
1839 return O32_ResizePalette(arg1, arg2);
1840}
1841//******************************************************************************
1842//******************************************************************************
1843BOOL WIN32API RestoreDC( HDC arg1, int arg2)
1844{
1845 dprintf(("GDI32: RestoreDC\n"));
1846 return O32_RestoreDC(arg1, arg2);
1847}
1848//******************************************************************************
1849//******************************************************************************
1850BOOL WIN32API RoundRect( HDC arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7)
1851{
1852 dprintf(("GDI32: RoundRect"));
1853 return O32_RoundRect(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1854}
1855//******************************************************************************
1856//******************************************************************************
1857int WIN32API SaveDC( HDC arg1)
1858{
1859 dprintf(("GDI32: SaveDC"));
1860 return O32_SaveDC(arg1);
1861}
1862//******************************************************************************
1863//******************************************************************************
1864BOOL WIN32API ScaleViewportExtEx( HDC arg1, int arg2, int arg3, int arg4, int arg5, PSIZE arg6)
1865{
1866 dprintf(("GDI32: ScaleViewportExtEx"));
1867 return O32_ScaleViewportExtEx(arg1, arg2, arg3, arg4, arg5, arg6);
1868}
1869//******************************************************************************
1870//******************************************************************************
1871BOOL WIN32API ScaleWindowExtEx( HDC arg1, int arg2, int arg3, int arg4, int arg5, PSIZE arg6)
1872{
1873 dprintf(("GDI32: ScaleWindowExtEx"));
1874 return O32_ScaleWindowExtEx(arg1, arg2, arg3, arg4, arg5, arg6);
1875}
1876//******************************************************************************
1877//******************************************************************************
1878int WIN32API SelectClipRgn( HDC arg1, HRGN arg2)
1879{
1880 dprintf(("GDI32: SelectClipRgn"));
1881 return O32_SelectClipRgn(arg1, arg2);
1882}
1883//******************************************************************************
1884//******************************************************************************
1885int WIN32API SetArcDirection( HDC arg1, int arg2)
1886{
1887 dprintf(("GDI32: SetArcDirection"));
1888 return O32_SetArcDirection(arg1, arg2);
1889}
1890//******************************************************************************
1891//******************************************************************************
1892LONG WIN32API SetBitmapBits( HBITMAP arg1, LONG arg2, const VOID * arg3)
1893{
1894 dprintf(("GDI32: SetBitmapBits"));
1895 return O32_SetBitmapBits(arg1, (DWORD)arg2, arg3);
1896}
1897//******************************************************************************
1898//******************************************************************************
1899BOOL WIN32API SetBitmapDimensionEx( HBITMAP arg1, int arg2, int arg3, PSIZE arg4)
1900{
1901 dprintf(("GDI32: SetBitmapDimensionEx"));
1902 return O32_SetBitmapDimensionEx(arg1, arg2, arg3, arg4);
1903}
1904//******************************************************************************
1905//******************************************************************************
1906UINT WIN32API SetBoundsRect( HDC arg1, const RECT * arg2, UINT arg3)
1907{
1908 dprintf(("GDI32: SetBoundsRect"));
1909 return O32_SetBoundsRect(arg1, arg2, arg3);
1910}
1911//******************************************************************************
1912//******************************************************************************
1913BOOL WIN32API SetBrushOrgEx( HDC arg1, int arg2, int arg3, PPOINT arg4)
1914{
1915 BOOL rc;
1916
1917 rc = O32_SetBrushOrgEx(arg1, arg2, arg3, arg4);
1918 dprintf(("GDI32: SetBrushOrgEx returned %d\n", rc));
1919 return(rc);
1920}
1921//******************************************************************************
1922//******************************************************************************
1923int WIN32API SetDIBits( HDC arg1, HBITMAP arg2, UINT arg3, UINT arg4, const VOID * arg5, const BITMAPINFO * arg6, UINT arg7)
1924{
1925 dprintf(("GDI32: SetDIBits %x %x %x %x %x %x %x\n", arg1, arg2, arg3, arg4, arg5, arg6, arg7));
1926
1927 if(DIBSection::getSection() != NULL) {
1928 DIBSection *dsect;
1929
1930 dsect = DIBSection::find((DWORD)arg2);
1931 if(dsect) {
1932 return dsect->SetDIBits(arg1, arg2, arg3, arg4, arg5, (WINBITMAPINFOHEADER *)&arg6->bmiHeader, arg7);
1933 }
1934 }
1935 return O32_SetDIBits(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1936}
1937//******************************************************************************
1938//******************************************************************************
1939INT 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)
1940{
1941 INT result, imgsize, palsize;
1942 char *ptr;
1943
1944 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",
1945 hdc, xDest, yDest, cx, cy, xSrc, ySrc, startscan, lines, (LPVOID) bits, (PBITMAPINFO)info, coloruse));
1946
1947 // EB: ->>> Crazy. Nobody seen this Open32 bug ?
1948 // Dont't like dirty pointers, but Open32 needs a bit help.
1949 // Only tested with winmine.
1950 palsize = QueryPaletteSize((BITMAPINFOHEADER*)&info->bmiHeader);
1951 imgsize = CalcBitmapSize(info->bmiHeader.biBitCount,
1952 info->bmiHeader.biWidth, info->bmiHeader.biHeight);
1953 ptr = ((char *)info) + palsize + sizeof(BITMAPINFOHEADER);
1954 if(bits >= ptr && bits < ptr + imgsize)
1955 {
1956 bits = (char *)bits - imgsize +
1957 CalcBitmapSize(info->bmiHeader.biBitCount,
1958 info->bmiHeader.biWidth, lines);
1959 }
1960 // EB: <<<-
1961
1962 result = O32_SetDIBitsToDevice(hdc, xDest, yDest, cx, cy, xSrc, ySrc, startscan, lines, (PVOID) bits, (PBITMAPINFO)info, coloruse);
1963 return result;
1964}
1965//******************************************************************************
1966//******************************************************************************
1967HENHMETAFILE WIN32API SetEnhMetaFileBits( UINT arg1, const BYTE * arg2)
1968{
1969 dprintf(("GDI32: SetEnhMetaFileBits"));
1970 return O32_SetEnhMetaFileBits(arg1, arg2);
1971}
1972//******************************************************************************
1973//******************************************************************************
1974int WIN32API SetGraphicsMode(HDC arg1, int arg2)
1975{
1976 dprintf(("GDI32: SetGraphicsMode"));
1977 return O32_SetGraphicsMode(arg1, arg2);
1978}
1979//******************************************************************************
1980//******************************************************************************
1981int WIN32API SetMapMode( HDC arg1, int arg2)
1982{
1983 dprintf(("GDI32: SetMapMode"));
1984 return O32_SetMapMode(arg1, arg2);
1985}
1986//******************************************************************************
1987//******************************************************************************
1988DWORD WIN32API SetMapperFlags( HDC arg1, DWORD arg2)
1989{
1990 dprintf(("GDI32: SetMapperFlags"));
1991 return O32_SetMapperFlags(arg1, arg2);
1992}
1993//******************************************************************************
1994//******************************************************************************
1995HMETAFILE WIN32API SetMetaFileBitsEx( UINT arg1, const BYTE * arg2)
1996{
1997 dprintf(("GDI32: SetMetaFileBitsEx"));
1998 return O32_SetMetaFileBitsEx(arg1, (PBYTE)arg2);
1999}
2000//******************************************************************************
2001//******************************************************************************
2002BOOL WIN32API SetMiterLimit( HDC arg1, float arg2, float * arg3)
2003{
2004 dprintf(("GDI32: SetMiterLimit"));
2005 return O32_SetMiterLimit(arg1, arg2, arg3);
2006}
2007//******************************************************************************
2008//******************************************************************************
2009UINT WIN32API SetPaletteEntries( HPALETTE arg1, UINT arg2, UINT arg3, PALETTEENTRY * arg4)
2010{
2011 dprintf(("GDI32: SetPaletteEntries"));
2012 return O32_SetPaletteEntries(arg1, arg2, arg3, (const PALETTEENTRY *)arg4);
2013}
2014//******************************************************************************
2015//******************************************************************************
2016int WIN32API SetPolyFillMode( HDC arg1, int arg2)
2017{
2018 dprintf(("GDI32: SetPolyFillMode"));
2019 return O32_SetPolyFillMode(arg1, arg2);
2020}
2021//******************************************************************************
2022//******************************************************************************
2023BOOL WIN32API SetRectRgn( HRGN arg1, int arg2, int arg3, int arg4, int arg5)
2024{
2025 dprintf(("GDI32: SetRectRgn"));
2026 return O32_SetRectRgn(arg1, arg2, arg3, arg4, arg5);
2027}
2028//******************************************************************************
2029//******************************************************************************
2030UINT WIN32API SetTextAlign( HDC arg1, UINT arg2)
2031{
2032 dprintf(("GDI32: SetTextAlign"));
2033 return O32_SetTextAlign(arg1, arg2);
2034}
2035//******************************************************************************
2036//******************************************************************************
2037int WIN32API SetTextCharacterExtra( HDC arg1, int arg2)
2038{
2039 dprintf(("GDI32: SetTextCharacterExtra"));
2040 return O32_SetTextCharacterExtra(arg1, arg2);
2041}
2042//******************************************************************************
2043//******************************************************************************
2044BOOL WIN32API SetTextJustification( HDC arg1, int arg2, int arg3)
2045{
2046 dprintf(("GDI32: SetTextJustification"));
2047 return O32_SetTextJustification(arg1, arg2, arg3);
2048}
2049//******************************************************************************
2050//******************************************************************************
2051BOOL WIN32API SetViewportExtEx( HDC arg1, int arg2, int arg3, PSIZE arg4)
2052{
2053 dprintf(("GDI32: SetViewportExtEx"));
2054 return O32_SetViewportExtEx(arg1, arg2, arg3, arg4);
2055}
2056//******************************************************************************
2057//******************************************************************************
2058BOOL WIN32API SetViewportOrgEx( HDC arg1, int arg2, int arg3, PPOINT arg4)
2059{
2060 dprintf(("GDI32: SetViewportOrgEx"));
2061 return O32_SetViewportOrgEx(arg1, arg2, arg3, arg4);
2062}
2063//******************************************************************************
2064//******************************************************************************
2065HENHMETAFILE WIN32API SetWinMetaFileBits( UINT arg1, const BYTE * arg2, HDC arg3, const METAFILEPICT * arg4)
2066{
2067 dprintf(("GDI32: SetWinMetaFileBits"));
2068 return O32_SetWinMetaFileBits(arg1, arg2, arg3, arg4);
2069}
2070//******************************************************************************
2071//******************************************************************************
2072BOOL WIN32API SetWindowExtEx( HDC arg1, int arg2, int arg3, PSIZE arg4)
2073{
2074 dprintf(("GDI32: SetWindowExtEx"));
2075 return O32_SetWindowExtEx(arg1, arg2, arg3, arg4);
2076}
2077//******************************************************************************
2078//******************************************************************************
2079BOOL WIN32API SetWindowOrgEx( HDC arg1, int arg2, int arg3, PPOINT arg4)
2080{
2081 dprintf(("GDI32: SetWindowOrgEx"));
2082 return O32_SetWindowOrgEx(arg1, arg2, arg3, arg4);
2083}
2084//******************************************************************************
2085//******************************************************************************
2086BOOL WIN32API SetWorldTransform( HDC arg1, const XFORM *arg2)
2087{
2088 dprintf(("GDI32: SetWorldTransform"));
2089 return O32_SetWorldTransform(arg1, (LPXFORM)arg2);
2090}
2091//******************************************************************************
2092//******************************************************************************
2093INT WIN32API StartDocA( HDC arg1, const DOCINFOA *arg2)
2094{
2095 dprintf(("GDI32: StartDocA"));
2096 return O32_StartDoc(arg1, (LPDOCINFOA)arg2);
2097}
2098//******************************************************************************
2099//******************************************************************************
2100INT WIN32API StartDocW( HDC arg1, const DOCINFOW *arg2)
2101{
2102 dprintf(("GDI32: StartDocW STUB"));
2103 // NOTE: This will not work as is (needs UNICODE support)
2104// return O32_StartDoc(arg1, arg2);
2105 return 0;
2106}
2107//******************************************************************************
2108//******************************************************************************
2109int WIN32API StartPage( HDC arg1)
2110{
2111 dprintf(("GDI32: StartPage"));
2112 return O32_StartPage(arg1);
2113}
2114//******************************************************************************
2115//******************************************************************************
2116BOOL WIN32API UnrealizeObject( HGDIOBJ arg1)
2117{
2118 dprintf(("GDI32: UnrealizeObject"));
2119 return O32_UnrealizeObject(arg1);
2120}
2121//******************************************************************************
2122//******************************************************************************
2123BOOL WIN32API WidenPath( HDC arg1)
2124{
2125 dprintf(("GDI32: WidenPath"));
2126 return O32_WidenPath(arg1);
2127}
2128//******************************************************************************
2129//CreateDisardableBitmap is obsolete and can be replaced by CreateCompatibleBitmap
2130//******************************************************************************
2131HBITMAP WIN32API CreateDiscardableBitmap(HDC hDC, int nWidth, int nHeight)
2132{
2133 dprintf(("GDI32: CreateDisardableBitmap\n"));
2134 return O32_CreateCompatibleBitmap(hDC, nWidth, nHeight);
2135}
2136//******************************************************************************
2137//TODO: Not implemented
2138//******************************************************************************
2139int WIN32API SetAbortProc(HDC hdc, ABORTPROC lpAbortProc)
2140{
2141 dprintf(("GDI32: SetAbortProc - stub (1)w\n"));
2142 return(1);
2143}
2144//******************************************************************************
2145//Selects the current path as a clipping region for a device context, combining
2146//any existing clipping region by using the specified mode
2147//TODO: Can be emulated with SelectClipRegion??
2148//******************************************************************************
2149BOOL WIN32API SelectClipPath(HDC hdc, int iMode)
2150{
2151 dprintf(("GDI32: SelectClipPath, not implemented!(TRUE)\n"));
2152 return(TRUE);
2153}
2154//******************************************************************************
2155//TODO: Sets the color adjustment values for a device context. (used to adjust
2156// the input color of the src bitmap for calls of StretchBlt & StretchDIBits
2157// functions when HALFTONE mode is set
2158//******************************************************************************
2159BOOL WIN32API SetColorAdjustment(HDC hdc, CONST COLORADJUSTMENT *lpca)
2160{
2161 dprintf(("GDI32: SetColorAdjustment, not implemented!(TRUE)\n"));
2162 return(TRUE);
2163}
2164//******************************************************************************
2165//WINE: OBJECTS\DIB.C
2166//*********************************************************************************
2167HBITMAP WIN32API CreateDIBSection( HDC hdc, BITMAPINFO *pbmi, UINT iUsage,
2168 VOID **ppvBits, HANDLE hSection, DWORD dwOffset)
2169{
2170 HBITMAP res = 0;
2171 BOOL fFlip = 0;
2172 int iHeight, iWidth;
2173
2174 dprintf(("GDI32: CreateDIBSection %x %x %x %d", hdc, iUsage, hSection, dwOffset));
2175 if(hSection)
2176 {
2177 dprintf(("GDI32: CreateDIBSection, hSection != NULL, not supported!\n"));
2178 return NULL;
2179 }
2180
2181 //SvL: 13-9-98: StarCraft uses bitmap with negative height
2182 iWidth = pbmi->bmiHeader.biWidth;
2183 if(pbmi->bmiHeader.biWidth < 0)
2184 {
2185 pbmi->bmiHeader.biWidth = -pbmi->bmiHeader.biWidth;
2186 fFlip = FLIP_HOR;
2187 }
2188 iHeight = pbmi->bmiHeader.biHeight;
2189 if(pbmi->bmiHeader.biHeight < 0)
2190 {
2191 pbmi->bmiHeader.biHeight = -pbmi->bmiHeader.biHeight;
2192 fFlip |= FLIP_VERT;
2193 }
2194
2195 res = O32_CreateDIBitmap(hdc, &pbmi->bmiHeader, 0, NULL, pbmi, 0);
2196 if (res)
2197 {
2198 ULONG Pal[256];
2199 char PalSize;
2200 LOGPALETTE tmpPal = { 0x300,1,{0,0,0,0}};
2201 HPALETTE hpalCur, hpalTmp;
2202 DIBSection *dsect = new DIBSection((WINBITMAPINFOHEADER *)&pbmi->bmiHeader, (DWORD)res, fFlip);
2203
2204 if(NULL!=dsect)
2205 {
2206 PalSize = dsect->GetBitCount();
2207 if(PalSize<=8)
2208 {
2209 // Now get the current Palette from the DC
2210 hpalTmp = CreatePalette(&tmpPal);
2211 hpalCur = SelectPalette(hdc, hpalTmp, FALSE);
2212
2213 // and use it to set the DIBColorTable
2214 GetPaletteEntries( hpalCur, 0, 1<<PalSize, (LPPALETTEENTRY)&Pal);
2215 dsect->SetDIBColorTable(0, 1<< PalSize, (RGBQUAD*)&Pal);
2216
2217 // Restore the DC Palette
2218 SelectPalette(hdc,hpalCur,FALSE);
2219 DeleteObject(hpalTmp);
2220 }
2221 // Set the hdc in the DIBSection so we can update the palete if a new
2222 // Paletet etc. gets selected into the DC.
2223
2224 dsect->SelectDIBObject(hdc);
2225
2226 if(ppvBits!=NULL)
2227 *ppvBits = dsect->GetDIBObject();
2228
2229 pbmi->bmiHeader.biWidth = iWidth;
2230 pbmi->bmiHeader.biHeight = iHeight;
2231
2232 dprintf(("GDI32: return %08X\n",res));
2233 return(res);
2234 }
2235 }
2236
2237 /* Error. */
2238 if (res)
2239 DeleteObject(res);
2240 *ppvBits = NULL;
2241#ifdef DEBUG
2242 dprintf(("GDI32: CreateDIBSection, error!\n"));
2243 dprintf(("pbmi->biWidth %d", pbmi->bmiHeader.biWidth));
2244 dprintf(("pbmi->biHeight %d", pbmi->bmiHeader.biHeight));
2245 dprintf(("pbmi->biBitCount %d", pbmi->bmiHeader.biBitCount));
2246#endif
2247
2248 return 0;
2249}
2250//******************************************************************************
2251//******************************************************************************
2252UINT WIN32API GetDIBColorTable( HDC hdc, UINT uStartIndex, UINT cEntries,
2253 RGBQUAD *pColors)
2254{
2255 HPALETTE hpal = O32_GetCurrentObject(hdc, OBJ_PAL);
2256 UINT rc;
2257 int i;
2258
2259 rc = O32_GetPaletteEntries(hpal,
2260 uStartIndex,
2261 cEntries,
2262 (PALETTEENTRY *)pColors);
2263 for(i=0;
2264 i<cEntries;
2265 i++)
2266 {
2267 BYTE tmp;
2268 tmp = pColors[i].rgbBlue;
2269 pColors[i].rgbBlue = pColors[i].rgbRed;
2270 pColors[i].rgbRed = tmp;
2271 pColors[i].rgbReserved = 0;
2272 }
2273 dprintf(("GDI32: GetDIBColorTable returns %d\n", rc));
2274 return(rc);
2275}
2276//******************************************************************************
2277//******************************************************************************
2278UINT WIN32API SetDIBColorTable(HDC hdc, UINT uStartIndex, UINT cEntries,
2279 RGBQUAD *pColors)
2280{
2281 DIBSection *dsect = DIBSection::findHDC(hdc);
2282
2283 dprintf(("GDI32: SetDIBColorTable\n"));
2284 if(dsect)
2285 {
2286 return(dsect->SetDIBColorTable(uStartIndex, cEntries, pColors));
2287 }
2288 else
2289 return(0);
2290}
2291//******************************************************************************
2292//******************************************************************************
2293HPALETTE WIN32API CreateHalftonePalette(HDC hdc)
2294{
2295 dprintf(("GDI32: CreateHalftonePalette, not implemented\n"));
2296 return(NULL);
2297}
2298//******************************************************************************
2299//Maps colors to system palette; faster way to update window (instead of redrawing)
2300//We just redraw
2301//******************************************************************************
2302BOOL WIN32API UpdateColors(HDC hdc)
2303{
2304 dprintf(("GDI32: UpdateColors\n"));
2305 return O32_InvalidateRect(O32_WindowFromDC(hdc), NULL, FALSE);
2306}
2307//******************************************************************************
2308//******************************************************************************
2309BOOL WIN32API GdiFlush()
2310{
2311 dprintf(("GDI32: GdiFlush, not implemented (TRUE)\n"));
2312 return(TRUE);
2313}
2314//******************************************************************************
2315//******************************************************************************
2316BOOL WIN32API GdiComment(HDC hdc, UINT cbSize, CONST BYTE *lpData)
2317{
2318 dprintf(("GDI32: GdiComment, not implemented (TRUE)\n"));
2319 return(TRUE);
2320}
2321//******************************************************************************
2322//******************************************************************************
2323BOOL WIN32API GetCharWidthFloatA(HDC hdc, UINT iFirstChar, UINT iLastChar, PFLOAT pxBUffer)
2324{
2325 dprintf(("GDI32: GetCharWidthFloatA, not implemented\n"));
2326 return(FALSE);
2327}
2328//******************************************************************************
2329//******************************************************************************
2330BOOL WIN32API GetCharWidthFloatW(HDC hdc, UINT iFirstChar, UINT iLastChar, PFLOAT pxBUffer)
2331{
2332 dprintf(("GDI32: GetCharWidthFloatW, not implemented\n"));
2333 return(FALSE);
2334}
2335//******************************************************************************
2336//******************************************************************************
2337BOOL WIN32API GetCharABCWidthsFloatA(HDC hdc, UINT iFirstChar, UINT iLastChar, LPABCFLOAT pxBUffer)
2338{
2339 dprintf(("GDI32: GetCharABCWidthsFloatA, not implemented\n"));
2340 return(FALSE);
2341}
2342//******************************************************************************
2343//******************************************************************************
2344BOOL WIN32API GetCharABCWidthsFloatW(HDC hdc,
2345 UINT iFirstChar,
2346 UINT iLastChar,
2347 LPABCFLOAT pxBUffer)
2348{
2349 dprintf(("GDI32: GetCharABCWidthsFloatA, not implemented\n"));
2350 return(FALSE);
2351}
2352//******************************************************************************
2353//******************************************************************************
2354INT WIN32API ExtEscape(HDC hdc, INT nEscape, INT cbInput, LPCSTR lpszInData,
2355 INT cbOutput, LPSTR lpszOutData)
2356{
2357 dprintf(("GDI32: ExtEscape, not implemented\n"));
2358 return(0);
2359}
2360//******************************************************************************
2361//******************************************************************************
2362int WIN32API DrawEscape(HDC hdc, int nEscape, int cbInput, LPCSTR lpszInData)
2363{
2364 dprintf(("GDI32: DrawEscape, not implemented\n"));
2365 return(0);
2366}
2367//******************************************************************************
2368//******************************************************************************
2369BOOL WIN32API GetColorAdjustment(HDC hdc, COLORADJUSTMENT *lpca)
2370{
2371 dprintf(("GDI32: GetColorAdjustment, not implemented\n"));
2372 return(FALSE);
2373}
2374//******************************************************************************
2375//******************************************************************************
2376BOOL WIN32API PlgBlt(HDC hdcDest, CONST POINT *lpPoint, HDC hdcSrc, int nXSrc,
2377 int nYSrc, int nWidth, int nHeight, HBITMAP hbmMask,
2378 int xMast, int yMask)
2379{
2380 dprintf(("GDI32: PlgBlt, not implemented\n"));
2381 return(FALSE);
2382}
2383//******************************************************************************
2384//******************************************************************************
2385DWORD WIN32API GetGlyphOutlineA(HDC hdc, UINT uChar, UINT uFormat, LPGLYPHMETRICS lpgm,
2386 DWORD cbBuffer, LPVOID lpvBuffer, CONST MAT2 *lpmat2)
2387{
2388 dprintf(("GDI32: GetGlyphOutLineA, not implemented (GDI_ERROR)\n"));
2389 return(GDI_ERROR);
2390}
2391//******************************************************************************
2392
2393//******************************************************************************
2394/*KSO Thu 21.05.1998*/
2395DWORD WIN32API GetGlyphOutlineW(HDC hdc, UINT uChar, UINT uFormat, LPGLYPHMETRICS lpgm,
2396 DWORD cbBuffer, LPVOID lpvBuffer, CONST MAT2 *lpmat2)
2397{
2398 dprintf(("GDI32: GetGlyphOutLineW, not implemented\n"));
2399 return(GDI_ERROR);
2400}
2401//******************************************************************************
2402
2403//******************************************************************************
2404int WIN32API DescribePixelFormat(HDC, int, UINT, LPPIXELFORMATDESCRIPTOR)
2405{
2406 dprintf(("GDI32: DescribePixelFormat, not implemented (GDI_ERROR)\n"));
2407 return(GDI_ERROR);
2408}
2409//******************************************************************************
2410//******************************************************************************
2411BOOL WIN32API SetObjectOwner( HGDIOBJ arg1, int arg2 )
2412{
2413 // Here is a guess for a undocumented entry
2414 dprintf(("GDI32: SetObjectOwner - stub (TRUE)\n"));
2415 return TRUE;
2416}
2417//******************************************************************************
2418
2419
2420/* Office 97 stubs - KSO Thu 21.05.1998*/
2421//******************************************************************************
2422BOOL WIN32API GetTextExtentExPointA(/*KSO Thu 21.05.1998*/
2423 HDC hdc,
2424 LPCSTR str,
2425 int count,
2426 int maxExt,
2427 LPINT lpnFit,
2428 LPINT alpDx,
2429 LPSIZE size)
2430{
2431 int index, nFit, extent;
2432 SIZE tSize;
2433
2434 dprintf(("GDI32: GetTextExtendExPointA\n"));
2435
2436 size->cx = size->cy = nFit = extent = 0;
2437 for(index = 0; index < count; index++)
2438 {
2439 if(!O32_GetTextExtentPoint( hdc, str, 1, &tSize )) return FALSE;
2440 if( extent+tSize.cx < maxExt )
2441 {
2442 extent+=tSize.cx;
2443 nFit++;
2444 str++;
2445 if( alpDx )
2446 alpDx[index] = extent;
2447 if( tSize.cy > size->cy ) size->cy = tSize.cy;
2448 }
2449 else break;
2450 }
2451 size->cx = extent;
2452
2453 if (lpnFit != NULL) // check if result is desired
2454 *lpnFit = nFit;
2455
2456 dprintf(("GDI32: GetTextExtendExPointA(%08x '%.*s' %d) returning %d %d %d\n",
2457 hdc,count,str,maxExt,nFit, size->cx,size->cy));
2458 return TRUE;
2459}
2460//******************************************************************************
2461//******************************************************************************
2462BOOL WIN32API GetTextExtentExPointW( /*KSO Thu 21.05.1998*/
2463 HDC arg1,
2464 LPCWSTR arg2,
2465 int arg3,
2466 int arg4,
2467 LPINT arg5,
2468 LPINT arg6,
2469 LPSIZE arg7
2470 )
2471{
2472 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2473 BOOL rc;
2474
2475 dprintf(("GDI32: GetTextExtendExPointW\n"));
2476 rc = GetTextExtentExPointA(arg1, astring, arg3, arg4, arg5, arg6, arg7);
2477 FreeAsciiString(astring);
2478 return rc;
2479}
2480//******************************************************************************
2481//******************************************************************************
2482BOOL WIN32API PlayEnhMetaFileRecord( /*KSO Thu 21.05.1998*/
2483 HDC arg1,
2484 LPHANDLETABLE arg2,
2485 CONST ENHMETARECORD *arg3,
2486 UINT arg4
2487 )
2488{
2489 dprintf(("GDI32: PlayEnhMetaFileRecord - stub\n"));
2490 return FALSE;
2491}
2492//******************************************************************************
2493UINT WIN32API GetEnhMetaFileDescriptionA( /*KSO Thu 21.05.1998*/
2494 HENHMETAFILE arg1,
2495 UINT arg2,
2496 LPSTR arg3
2497 )
2498{
2499 dprintf(("GDI32: GetEnhMetaFileDescriptionA - stub\n"));
2500 return FALSE;
2501}
2502//******************************************************************************
2503//******************************************************************************
2504UINT WIN32API GetEnhMetaFileDescriptionW( /*KSO Thu 21.05.1998*/
2505 HENHMETAFILE arg1,
2506 UINT arg2,
2507 LPWSTR arg3
2508 )
2509{
2510 dprintf(("GDI32: GetEnhMetaFileDescriptionW - stub\n"));
2511 return FALSE;
2512}
2513//******************************************************************************
2514//******************************************************************************
2515UINT WIN32API DeleteColorSpace( /*KSO Thu 21.05.1998*/
2516 HCOLORSPACE hColorSpace
2517 )
2518{
2519 dprintf(("GDI32: DeleteColorSpace - stub\n"));
2520 return FALSE;
2521}
2522//******************************************************************************
2523//******************************************************************************
2524BOOL WIN32API SetColorSpace( /*KSO Thu 21.05.1998*/
2525 HDC hdc,
2526 HCOLORSPACE hColorSpace
2527 )
2528{
2529 dprintf(("GDI32: SetColorSpace - stub\n"));
2530 return FALSE;
2531}
2532//******************************************************************************
2533//******************************************************************************
2534 HCOLORSPACE WIN32API CreateColorSpaceA( /*KSO Thu 21.05.1998*/
2535 LPLOGCOLORSPACEA lpLogColorSpace
2536 )
2537{
2538 dprintf(("GDI32: CreateColorSpaceA - stub\n"));
2539 return 0;
2540}
2541//******************************************************************************
2542//******************************************************************************
2543HCOLORSPACE WIN32API CreateColorSpaceW( /*KSO Thu 21.05.1998*/
2544 LPLOGCOLORSPACEW lpwLogColorSpace
2545 )
2546{
2547 dprintf(("GDI32: CreateColorSpaceW - stub\n"));
2548 return 0;
2549}
2550//******************************************************************************
2551//******************************************************************************
2552HANDLE WIN32API GetColorSpace( /*KSO Thu 21.05.1998*/
2553 HDC hdc
2554 )
2555{
2556 dprintf(("GDI32: GetColorSpace - stub\n"));
2557 return 0;
2558}
2559//******************************************************************************
2560//******************************************************************************
2561int WIN32API SetICMMode( /*KSO Thu 21.05.1998*/
2562 HDC hdc,
2563 int mode
2564 )
2565{
2566 dprintf(("GDI32: SetICMMode - stub\n"));
2567 return 0;
2568}
2569//******************************************************************************
2570
2571
2572
2573
2574/*****************************************************************************
2575 * Name : BOOL CancelDC
2576 * Purpose : The CancelDC function cancels any pending operation on the
2577 * specified device context (DC).
2578 * Parameters: HDC hdc handle of device context
2579 * Variables :
2580 * Result : TRUE / FALSE
2581 * Remark :
2582 * Status : UNTESTED STUB
2583 *
2584 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2585 *****************************************************************************/
2586
2587BOOL WIN32API CancelDC(HDC hdc)
2588{
2589 dprintf(("GDI32: CancelDC(%08xh) not implemented.\n",
2590 hdc));
2591
2592 return (FALSE);
2593}
2594
2595
2596/*****************************************************************************
2597 * Name : BOOL CheckColorsInGamut
2598 * Purpose : The CheckColorsInGamut function indicates whether the specified
2599 * color values are within the gamut of the specified device.
2600 * Parameters: HDC hdc handle of device context
2601 * LPVOID lpaRGBQuad
2602 * LPVOID lpResult
2603 * DWORD dwResult
2604 * Variables :
2605 * Result : TRUE / FALSE
2606 * Remark :
2607 * Status : UNTESTED STUB
2608 *
2609 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2610 *****************************************************************************/
2611
2612BOOL WIN32API CheckColorsInGamut(HDC hdc,
2613 LPVOID lpaRGBQuad,
2614 LPVOID lpResult,
2615 DWORD dwResult)
2616{
2617 dprintf(("GDI32: CheckColorsInGamut(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2618 hdc,
2619 lpaRGBQuad,
2620 lpResult,
2621 dwResult));
2622
2623 return (FALSE);
2624}
2625
2626
2627/*****************************************************************************
2628 * Name : BOOL ColorMatchToTarget
2629 * Purpose : The ColorMatchToTarget function enables or disables preview for
2630 * the specified device context. When preview is enabled, colors
2631 * in subsequent output to the specified device context are
2632 * displayed as they would appear on the target device. This is
2633 * useful for checking how well the target maps the specified
2634 * colors in an image. To enable preview, image color matching
2635 * must be enabled for both the target and the preview device context.
2636 * Parameters: HDC hdc handle of device context
2637 * HDC hdcTarget handle of target device context
2638 * DWORD uiAction
2639 * Variables :
2640 * Result : TRUE / FALSE
2641 * Remark :
2642 * Status : UNTESTED STUB
2643 *
2644 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2645 *****************************************************************************/
2646
2647BOOL WIN32API ColorMatchToTarget(HDC hdc,
2648 HDC hdcTarget,
2649 DWORD uiAction)
2650{
2651 dprintf(("GDI32: ColorMatchToTarget(%08xh,%08xh,%08xh) not implemented.\n",
2652 hdc,
2653 hdcTarget,
2654 uiAction));
2655
2656 return (FALSE);
2657}
2658
2659
2660/*****************************************************************************
2661 * Name : BOOL CombineTransform
2662 * Purpose : The CombineTransform function concatenates two world-space to
2663 * page-space transformations.
2664 * Parameters: LLPXFORM lLPXFORMResult address of combined transformation
2665 * XFORM *lLPXFORM1 address of 1st transformation
2666 * XFORM *lLPXFORM2 address of 2nd transformation
2667 * Variables :
2668 * Result : TRUE / FALSE
2669 * Remark :
2670 * Status : UNTESTED
2671 *
2672 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2673 * Markus Montkowski [Wen, 1999/01/12 20:18]
2674 *****************************************************************************/
2675
2676BOOL WIN32API CombineTransform(LPXFORM lLPXFORMResult,
2677 CONST XFORM *lLPXFORM1,
2678 CONST XFORM *lLPXFORM2)
2679{
2680 dprintf(("GDI32: CombineTransform(%08xh,%08xh,%08xh).\n",
2681 lLPXFORMResult,
2682 lLPXFORM1,
2683 lLPXFORM2));
2684
2685 XFORM xfrm;
2686 if( O32_IsBadWritePtr( (void*)lLPXFORMResult, sizeof(XFORM)) ||
2687 O32_IsBadReadPtr( (void*)lLPXFORM1, sizeof(XFORM)) ||
2688 O32_IsBadWritePtr( (void*)lLPXFORM2, sizeof(XFORM)) )
2689 return (FALSE);
2690
2691 // Add the translations
2692 lLPXFORMResult->eDx = lLPXFORM1->eDx + lLPXFORM2->eDx;
2693 lLPXFORMResult->eDy = lLPXFORM1->eDy + lLPXFORM2->eDy;
2694
2695 // Multiply the matrixes
2696 xfrm.eM11 = lLPXFORM1->eM11 * lLPXFORM2->eM11 + lLPXFORM1->eM21 * lLPXFORM1->eM12;
2697 xfrm.eM12 = lLPXFORM1->eM11 * lLPXFORM2->eM12 + lLPXFORM1->eM12 * lLPXFORM1->eM22;
2698 xfrm.eM21 = lLPXFORM1->eM21 * lLPXFORM2->eM11 + lLPXFORM1->eM22 * lLPXFORM1->eM21;
2699 xfrm.eM22 = lLPXFORM1->eM21 * lLPXFORM2->eM12 + lLPXFORM1->eM22 * lLPXFORM1->eM22;
2700
2701 // Now copy to resulting XFROM as the pt must not be distinct
2702 lLPXFORMResult->eM11 = xfrm.eM11;
2703 lLPXFORMResult->eM12 = xfrm.eM12;
2704 lLPXFORMResult->eM21 = xfrm.eM21;
2705 lLPXFORMResult->eM22 = xfrm.eM22;
2706
2707 return (TRUE);
2708}
2709
2710
2711
2712/*****************************************************************************
2713 * Name : HBRUSH CreateDIBPatternBrush
2714 * Purpose : The CreateDIBPatternBrush function creates a logical brush that
2715 * has the pattern specified by the specified device-independent
2716 * bitmap (DIB). The brush can subsequently be selected into any
2717 * device context that is associated with a device that supports
2718 * raster operations.
2719 * This function is provided only for compatibility with applications
2720 * written for versions of Windows earlier than 3.0. For Win32-based
2721 * applications, use the CreateDIBPatternBrushPt function.
2722 * Parameters: HGLOBAL hglbDIBPacked Identifies a global memory object containing
2723 * a packed DIB, which consists of a BITMAPINFO structure immediately
2724 * followed by an array of bytes defining the pixels of the bitmap.
2725 * UINT fuColorSpec color table data
2726 * Variables :
2727 * Result : TRUE / FALSE
2728 * Remark :
2729 * Status : UNTESTED
2730 *
2731 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2732 * Markus Montkowski [Wen, 1999/01/12 20:00]
2733 *****************************************************************************/
2734
2735HBRUSH WIN32API CreateDIBPatternBrush( HGLOBAL hglbDIBPacked,
2736 UINT fuColorSpec)
2737{
2738 LPVOID lpMem;
2739 HBRUSH ret = 0;
2740 dprintf(("GDI32: CreateDIBPatternBrush(%08xh, %08xh) \n",
2741 hglbDIBPacked,
2742 fuColorSpec));
2743
2744 lpMem = GlobalLock(hglbDIBPacked);
2745 if(NULL!=lpMem)
2746 {
2747
2748 ret = CreateDIBPatternBrushPt( lpMem,
2749 fuColorSpec);
2750 GlobalUnlock(hglbDIBPacked);
2751 }
2752
2753 return (ret);
2754}
2755
2756
2757
2758
2759/*****************************************************************************
2760 * Name : int EnumICMProfilesA
2761 * Purpose : The EnumICMProfilesA function enumerates the different color
2762 * profiles that the system supports for the specified device context.
2763 * Parameters: HDC hdc
2764 * ICMENUMPROC lpICMEnumFunc
2765 * LPARAM lParam
2766 * Variables :
2767 * Result : TRUE / FALSE
2768 * Remark :
2769 * Status : UNTESTED STUB
2770 *
2771 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2772 *****************************************************************************/
2773
2774int WIN32API EnumICMProfilesA(HDC hdc,
2775 ICMENUMPROCA lpICMEnumProc,
2776 LPARAM lParam)
2777{
2778 dprintf(("GDI32: EnumICMProfilesA(%08xh, %08xh, %08xh) not implemented(-1).\n",
2779 hdc,
2780 lpICMEnumProc,
2781 lParam));
2782
2783 return (-1);
2784}
2785
2786
2787/*****************************************************************************
2788 * Name : int EnumICMProfilesW
2789 * Purpose : The EnumICMProfilesW function enumerates the different color
2790 * profiles that the system supports for the specified device context.
2791 * Parameters: HDC hdc
2792 * ICMENUMPROC lpICMEnumFunc
2793 * LPARAM lParam
2794 * Variables :
2795 * Result : TRUE / FALSE
2796 * Remark :
2797 * Status : UNTESTED STUB
2798 *
2799 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2800 *****************************************************************************/
2801
2802int WIN32API EnumICMProfilesW(HDC hdc,
2803 ICMENUMPROCW lpICMEnumProc,
2804 LPARAM lParam)
2805{
2806 dprintf(("GDI32: EnumICMProfilesW(%08xh, %08xh, %08xh) not implemented (-1).\n",
2807 hdc,
2808 lpICMEnumProc,
2809 lParam));
2810
2811 return (-1);
2812}
2813
2814
2815/*****************************************************************************
2816 * Name : BOOL FixBrushOrgEx
2817 * Purpose : The FixBrushOrgEx function is not implemented in the Win32 API.
2818 * It is provided for compatibility with Win32s. If called, the
2819 * function does nothing, and returns FALSE.
2820 * Parameters: HDC, int, int, LPPOINT
2821 * Variables :
2822 * Result : TRUE / FALSE
2823 * Remark : not implemented in Win32
2824 * Status : UNTESTED STUB
2825 *
2826 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2827 *****************************************************************************/
2828
2829BOOL WIN32API FixBrushOrgEx(HDC hdc,
2830 int iDummy1,
2831 int iDummy2,
2832 LPPOINT lpPoint)
2833{
2834 dprintf(("GDI32: FixBrushOrgEx(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2835 hdc,
2836 iDummy1,
2837 iDummy2,
2838 lpPoint));
2839
2840 return (FALSE);
2841}
2842
2843
2844/*****************************************************************************
2845 * Name : DWORD GdiGetBatchLimit
2846 * Purpose : The GdiGetBatchLimit function returns the maximum number of
2847 * function calls that can be accumulated in the calling thread's
2848 * current batch. The system flushes the current batch whenever
2849 * this limit is exceeded.
2850 * Parameters:
2851 * Variables :
2852 * Result : 1
2853 * Remark :
2854 * Status : UNTESTED STUB
2855 *
2856 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2857 *****************************************************************************/
2858
2859DWORD WIN32API GdiGetBatchLimit(VOID)
2860{
2861 dprintf(("GDI32: GdiGetBatchLimit() not implemented (1).\n"));
2862
2863 return (1);
2864}
2865
2866
2867/*****************************************************************************
2868 * Name : DWORD GdiSetBatchLimit
2869 * Purpose : The GdiSetBatchLimit function sets the maximum number of
2870 * functions that can be accumulated in the calling thread's current
2871 * batch. The system flushes the current batch whenever this limit
2872 * is exceeded.
2873 * Parameters: DWORD dwLimit
2874 * Variables :
2875 * Result :
2876 * Remark :
2877 * Status : UNTESTED STUB
2878 *
2879 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2880 *****************************************************************************/
2881
2882DWORD WIN32API GdiSetBatchLimit(DWORD dwLimit)
2883{
2884 dprintf(("GDI32: GdiSetBatchLimit(%08xh) not implemented (1).\n",
2885 dwLimit));
2886
2887 return (1);
2888}
2889
2890
2891/*****************************************************************************
2892 * Name : DWORD GetCharacterPlacementA
2893 * Purpose : The GetCharacterPlacementA function retrieves information about
2894 * a character string, such as character widths, caret positioning,
2895 * ordering within the string, and glyph rendering. The type of
2896 * information returned depends on the dwFlags parameter and is
2897 * based on the currently selected font in the given display context.
2898 * The function copies the information to the specified GCP_RESULTSA
2899 * structure or to one or more arrays specified by the structure.
2900 * Parameters: HDC hdc handle to device context
2901 * LPCSTR lpString pointer to string
2902 * int nCount number of characters in string
2903 * int nMaxExtent maximum extent for displayed string
2904 * LPGCP_RESULTSA *lpResults pointer to buffer for placement result
2905 * DWORD dwFlags placement flags
2906 * Variables :
2907 * Result :
2908 * Remark :
2909 * Status : UNTESTED STUB
2910 *
2911 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2912 *****************************************************************************/
2913
2914DWORD WIN32API GetCharacterPlacementA(HDC hdc,
2915 LPCSTR lpString,
2916 int nCount,
2917 int nMaxExtent,
2918 GCP_RESULTSA * lpResults,
2919 DWORD dwFlags)
2920{
2921 dprintf(("GDI32: GetCharacterPlacementA(%08xh,%s,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2922 hdc,
2923 lpString,
2924 nCount,
2925 nMaxExtent,
2926 lpResults,
2927 dwFlags));
2928
2929 return (0);
2930}
2931
2932
2933/*****************************************************************************
2934 * Name : DWORD GetCharacterPlacementW
2935 * Purpose : The GetCharacterPlacementW function retrieves information about
2936 * a character string, such as character widths, caret positioning,
2937 * ordering within the string, and glyph rendering. The type of
2938 * information returned depends on the dwFlags parameter and is
2939 * based on the currently selected font in the given display context.
2940 * The function copies the information to the specified GCP_RESULTSW
2941 * structure or to one or more arrays specified by the structure.
2942 * Parameters: HDC hdc handle to device context
2943 * LPCSTR lpString pointer to string
2944 * int nCount number of characters in string
2945 * int nMaxExtent maximum extent for displayed string
2946 * GCP_RESULTSW *lpResults pointer to buffer for placement result
2947 * DWORD dwFlags placement flags
2948 * Variables :
2949 * Result :
2950 * Remark :
2951 * Status : UNTESTED STUB
2952 *
2953 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2954 *****************************************************************************/
2955
2956DWORD WIN32API GetCharacterPlacementW(HDC hdc,
2957 LPCWSTR lpString,
2958 int nCount,
2959 int nMaxExtent,
2960 GCP_RESULTSW *lpResults,
2961 DWORD dwFlags)
2962{
2963 dprintf(("GDI32: GetCharacterPlacementW(%08xh,%s,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2964 hdc,
2965 lpString,
2966 nCount,
2967 nMaxExtent,
2968 lpResults,
2969 dwFlags));
2970
2971 return (0);
2972}
2973
2974
2975/*****************************************************************************
2976 * Name : DWORD GetDeviceGammaRamp
2977 * Purpose : The GetDeviceGammaRamp function retrieves the gamma ramp on
2978 * direct color display boards.
2979 * Parameters: HDC hdc handle to device context
2980 * LPVOID lpRamp Gamma ramp array
2981 * Variables :
2982 * Result :
2983 * Remark :
2984 * Status : UNTESTED STUB
2985 *
2986 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2987 *****************************************************************************/
2988
2989DWORD WIN32API GetDeviceGammaRamp(HDC hdc,
2990 LPVOID lpRamp)
2991{
2992 dprintf(("GDI32: GetDeviceGammaRamp(%08xh, %08xh) not implemented.\n",
2993 hdc,
2994 lpRamp));
2995
2996 return (FALSE);
2997}
2998
2999
3000
3001
3002/*****************************************************************************
3003 * Name : BOOL GetICMProfileA
3004 * Purpose : The GetICMProfileA function retrieves the name of the color
3005 * profile file for the device associated with the specified device
3006 * context.
3007 * Parameters: HDC hdc handle to device context
3008 * DWORD cbName
3009 * LPTSTR lpszFilename
3010 * Variables :
3011 * Result : TRUE / FALSE
3012 * Remark :
3013 * Status : UNTESTED STUB
3014 *
3015 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3016 *****************************************************************************/
3017
3018BOOL WIN32API GetICMProfileA(HDC hdc,
3019 DWORD cbName,
3020 LPTSTR lpszFilename)
3021{
3022 dprintf(("GDI32: GetICMProfileA(%08xh, %08xh, %08xh) not implemented.\n",
3023 hdc,
3024 cbName,
3025 lpszFilename));
3026
3027 return (FALSE);
3028}
3029
3030
3031/*****************************************************************************
3032 * Name : BOOL GetICMProfileW
3033 * Purpose : The GetICMProfileW function retrieves the name of the color
3034 * profile file for the device associated with the specified device
3035 * context.
3036 * Parameters: HDC hdc handle to device context
3037 * DWORD cbName
3038 * LPWSTR lpszFilename
3039 * Variables :
3040 * Result : TRUE / FALSE
3041 * Remark :
3042 * Status : UNTESTED STUB
3043 *
3044 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3045 *****************************************************************************/
3046
3047BOOL WIN32API GetICMProfileW(HDC hdc,
3048 DWORD cbName,
3049 LPTSTR lpszFilename)
3050{
3051 dprintf(("GDI32: GetICMProfileW(%08xh, %08xh, %08xh) not implemented.\n",
3052 hdc,
3053 cbName,
3054 lpszFilename));
3055
3056 return (FALSE);
3057}
3058
3059
3060/*****************************************************************************
3061 * Name : BOOL GetLogColorSpaceA
3062 * Purpose : The GetLogColorSpace function retrieves information about the
3063 * logical color space identified by the specified handle.
3064 * Parameters: HCOLORSPACE hColorSpace
3065 * LPLOGCOLORSPACE lpbuffer
3066 * DWORD nSize
3067 * Variables :
3068 * Result : TRUE / FALSE
3069 * Remark :
3070 * Status : UNTESTED STUB
3071 *
3072 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3073 *****************************************************************************/
3074
3075#define LPLOGCOLORSPACE LPVOID
3076BOOL WIN32API GetLogColorSpaceA(HCOLORSPACE hColorSpace,
3077 LPLOGCOLORSPACE lpBuffer,
3078 DWORD nSize)
3079{
3080 dprintf(("GDI32: GetLogColorSpaceA(%08xh, %08xh, %08xh) not implemented.\n",
3081 hColorSpace,
3082 lpBuffer,
3083 nSize));
3084
3085 return (FALSE);
3086}
3087
3088
3089/*****************************************************************************
3090 * Name : BOOL GetLogColorSpaceW
3091 * Purpose : The GetLogColorSpace function retrieves information about the
3092 * logical color space identified by the specified handle.
3093 * Parameters: HCOLORSPACE hColorSpace
3094 * LPLOGCOLORSPACE lpbuffer
3095 * DWORD nSize
3096 * Variables :
3097 * Result : TRUE / FALSE
3098 * Remark :
3099 * Status : UNTESTED STUB
3100 *
3101 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3102 *****************************************************************************/
3103
3104BOOL WIN32API GetLogColorSpaceW(HCOLORSPACE hColorSpace,
3105 LPLOGCOLORSPACE lpBuffer,
3106 DWORD nSize)
3107{
3108 dprintf(("GDI32: GetLogColorSpaceW(%08xh, %08xh, %08xh) not implemented.\n",
3109 hColorSpace,
3110 lpBuffer,
3111 nSize));
3112
3113 return (FALSE);
3114}
3115
3116
3117/*****************************************************************************
3118 * Name : int GetMetaRgn
3119 * Purpose : The GetMetaRgn function retrieves the current metaregion for
3120 * the specified device context.
3121 * Parameters: HDC hdc handle of device context
3122 * HRGN hrgn handle of region
3123 * Variables :
3124 * Result : 0 / 1
3125 * Remark :
3126 * Status : UNTESTED STUB
3127 *
3128 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3129 *****************************************************************************/
3130
3131int WIN32API GetMetaRgn(HDC hdc,
3132 HRGN hrgn)
3133{
3134 dprintf(("GDI32: GetMetaRgn(%08xh, %08xh) not implemented.\n",
3135 hdc,
3136 hrgn));
3137
3138 return (0);
3139}
3140
3141
3142/*****************************************************************************
3143 * Name : int GetPixelFormat
3144 * Purpose : The GetPixelFormat function obtains the index of the specified
3145 * device context's currently selected pixel format.
3146 * Parameters: HDC hdc handle of device context
3147 * Variables :
3148 * Result : 0 / 1
3149 * Remark :
3150 * Status : UNTESTED STUB
3151 *
3152 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3153 *****************************************************************************/
3154
3155int WIN32API GetPixelFormat(HDC hdc)
3156{
3157 dprintf(("GDI32: GetPixelFormat(%08xh) not implemented.\n",
3158 hdc));
3159
3160 return (0);
3161}
3162
3163
3164/*****************************************************************************
3165 * Name : BOOL SetDeviceGammaRamp
3166 * Purpose : The SetDeviceGammaRamp function sets the gamma ramp on direct
3167 * color display boards.
3168 * Parameters: HDC hdc handle of device context
3169 * LPVOID lpRamp
3170 * Variables :
3171 * Result : TRUE / FALSE
3172 * Remark :
3173 * Status : UNTESTED STUB
3174 *
3175 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3176 *****************************************************************************/
3177
3178BOOL WIN32API SetDeviceGammaRamp(HDC hdc,
3179 LPVOID lpRamp)
3180{
3181 dprintf(("GDI32: SetDeviceGammaRamp(%08xh, %08xh) not implemented.\n",
3182 hdc,
3183 lpRamp));
3184
3185 return (FALSE);
3186}
3187
3188
3189/*****************************************************************************
3190 * Name : BOOL SetICMProfileA
3191 * Purpose : The SetICMProfileA function sets the color profile for the
3192 * specified device context.
3193 * Parameters: HDC hdc handle of device context
3194 * LPTSTR lpFileName
3195 * Variables :
3196 * Result : TRUE / FALSE
3197 * Remark :
3198 * Status : UNTESTED STUB
3199 *
3200 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3201 *****************************************************************************/
3202
3203BOOL WIN32API SetICMProfileA(HDC hdc,
3204 LPTSTR lpFileName)
3205{
3206 dprintf(("GDI32: SetICMProfileA(%08xh, %s) not implemented.\n",
3207 hdc,
3208 lpFileName));
3209
3210 return (FALSE);
3211}
3212
3213
3214/*****************************************************************************
3215 * Name : BOOL SetICMProfileW
3216 * Purpose : The SetICMProfileW function sets the color profile for the
3217 * specified device context.
3218 * Parameters: HDC hdc handle of device context
3219 * LPTSTR lpFileName
3220 * Variables :
3221 * Result : TRUE / FALSE
3222 * Remark :
3223 * Status : UNTESTED STUB
3224 *
3225 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3226 *****************************************************************************/
3227
3228BOOL WIN32API SetICMProfileW(HDC hdc,
3229 LPWSTR lpFileName)
3230{
3231 dprintf(("GDI32: SetICMProfileW(%08xh, %s) not implemented.\n",
3232 hdc,
3233 lpFileName));
3234
3235 return (FALSE);
3236}
3237
3238
3239/*****************************************************************************
3240 * Name : int SetMetaRgn
3241 * Purpose : The SetMetaRgn function intersects the current clipping region
3242 * for the specified device context with the current metaregion
3243 * and saves the combined region as the new metaregion for the
3244 * specified device context. The clipping region is reset to a null region.
3245 * Parameters: HDC hdc handle of device context
3246 * Variables :
3247 * Result : TRUE / FALSE
3248 * Remark :
3249 * Status : UNTESTED STUB
3250 *
3251 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3252 *****************************************************************************/
3253
3254BOOL WIN32API SetMetaRgn(HDC hdc)
3255{
3256 dprintf(("GDI32: SetMetaRgn(%08xh) not implemented.\n",
3257 hdc));
3258
3259 return (NULLREGION);
3260}
3261
3262
3263/*****************************************************************************
3264 * Name : BOOL UpdateICMRegKeyA
3265 * Purpose : The UpdateICMRegKeyA function installs, removes, or queries
3266 * registry entries that identify ICC color profiles or color-matching
3267 * DLLs. The function carries out the action specified by the nCommand
3268 * parameter.
3269 * Parameters: DWORD dwReserved
3270 * DWORD CMID
3271 * LPTSTR lpszFileName
3272 * UINT nCommand
3273 * Variables :
3274 * Result : TRUE / FALSE
3275 * Remark :
3276 * Status : UNTESTED STUB
3277 *
3278 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3279 *****************************************************************************/
3280
3281BOOL WIN32API UpdateICMRegKeyA(DWORD dwReserved,
3282 DWORD CMID,
3283 LPTSTR lpszFileName,
3284 UINT nCommand)
3285{
3286 dprintf(("GDI32: UpdateICMRegKeyA(%08xh, %08xh, %08xh, %08xh) not implemented.\n",
3287 dwReserved,
3288 CMID,
3289 lpszFileName,
3290 nCommand));
3291
3292 return (FALSE);
3293}
3294
3295
3296/*****************************************************************************
3297 * Name : BOOL UpdateICMRegKeyW
3298 * Purpose : The UpdateICMRegKeyW function installs, removes, or queries
3299 * registry entries that identify ICC color profiles or color-matching
3300 * DLLs. The function carries out the action specified by the nCommand
3301 * parameter.
3302 * Parameters: DWORD dwReserved
3303 * DWORD CMID
3304 * LPWSTR lpszFileName
3305 * UINT nCommand
3306 * Variables :
3307 * Result : TRUE / FALSE
3308 * Remark :
3309 * Status : UNTESTED STUB
3310 *
3311 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
3312 *****************************************************************************/
3313
3314BOOL WIN32API UpdateICMRegKeyW(DWORD dwReserved,
3315 DWORD CMID,
3316 LPWSTR lpszFileName,
3317 UINT nCommand)
3318{
3319 dprintf(("GDI32: UpdateICMRegKeyW(%08xh, %08xh, %08xh, %08xh) not implemented.\n",
3320 dwReserved,
3321 CMID,
3322 lpszFileName,
3323 nCommand));
3324
3325 return (FALSE);
3326}
3327
3328
3329
Note: See TracBrowser for help on using the repository browser.