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

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

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