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

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

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