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

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

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