4 * Copyright 2002 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 #include "wine/wingdi16.h"
29 #include "gdi_private.h"
30 #include "wine/debug.h"
32 WINE_DEFAULT_DEBUG_CHANNEL(gdi
);
34 #define HGDIOBJ_32(handle16) ((HGDIOBJ)(ULONG_PTR)(handle16))
35 #define HGDIOBJ_16(handle32) ((HGDIOBJ16)(ULONG_PTR)(handle32))
37 struct callback16_info
43 /* callback for LineDDA16 */
44 static void CALLBACK
linedda_callback( INT x
, INT y
, LPARAM param
)
46 const struct callback16_info
*info
= (struct callback16_info
*)param
;
51 args
[1] = HIWORD(info
->param
);
52 args
[0] = LOWORD(info
->param
);
53 WOWCallback16Ex( (DWORD
)info
->proc
, WCB16_PASCAL
, sizeof(args
), args
, NULL
);
56 /* callback for EnumObjects16 */
57 static INT CALLBACK
enum_pens_callback( void *ptr
, LPARAM param
)
59 const struct callback16_info
*info
= (struct callback16_info
*)param
;
66 pen16
.lopnStyle
= pen
->lopnStyle
;
67 pen16
.lopnWidth
.x
= pen
->lopnWidth
.x
;
68 pen16
.lopnWidth
.y
= pen
->lopnWidth
.y
;
69 pen16
.lopnColor
= pen
->lopnColor
;
70 segptr
= MapLS( &pen16
);
71 args
[3] = SELECTOROF(segptr
);
72 args
[2] = OFFSETOF(segptr
);
73 args
[1] = HIWORD(info
->param
);
74 args
[0] = LOWORD(info
->param
);
75 WOWCallback16Ex( (DWORD
)info
->proc
, WCB16_PASCAL
, sizeof(args
), args
, &ret
);
80 /* callback for EnumObjects16 */
81 static INT CALLBACK
enum_brushes_callback( void *ptr
, LPARAM param
)
83 const struct callback16_info
*info
= (struct callback16_info
*)param
;
84 LOGBRUSH
*brush
= ptr
;
90 brush16
.lbStyle
= brush
->lbStyle
;
91 brush16
.lbColor
= brush
->lbColor
;
92 brush16
.lbHatch
= brush
->lbHatch
;
93 segptr
= MapLS( &brush16
);
94 args
[3] = SELECTOROF(segptr
);
95 args
[2] = OFFSETOF(segptr
);
96 args
[1] = HIWORD(info
->param
);
97 args
[0] = LOWORD(info
->param
);
98 WOWCallback16Ex( (DWORD
)info
->proc
, WCB16_PASCAL
, sizeof(args
), args
, &ret
);
103 /* convert a LOGFONT16 to a LOGFONTW */
104 static void logfont_16_to_W( const LOGFONT16
*font16
, LPLOGFONTW font32
)
106 font32
->lfHeight
= font16
->lfHeight
;
107 font32
->lfWidth
= font16
->lfWidth
;
108 font32
->lfEscapement
= font16
->lfEscapement
;
109 font32
->lfOrientation
= font16
->lfOrientation
;
110 font32
->lfWeight
= font16
->lfWeight
;
111 font32
->lfItalic
= font16
->lfItalic
;
112 font32
->lfUnderline
= font16
->lfUnderline
;
113 font32
->lfStrikeOut
= font16
->lfStrikeOut
;
114 font32
->lfCharSet
= font16
->lfCharSet
;
115 font32
->lfOutPrecision
= font16
->lfOutPrecision
;
116 font32
->lfClipPrecision
= font16
->lfClipPrecision
;
117 font32
->lfQuality
= font16
->lfQuality
;
118 font32
->lfPitchAndFamily
= font16
->lfPitchAndFamily
;
119 MultiByteToWideChar( CP_ACP
, 0, font16
->lfFaceName
, -1, font32
->lfFaceName
, LF_FACESIZE
);
120 font32
->lfFaceName
[LF_FACESIZE
-1] = 0;
124 /***********************************************************************
127 COLORREF WINAPI
SetBkColor16( HDC16 hdc
, COLORREF color
)
129 return SetBkColor( HDC_32(hdc
), color
);
133 /***********************************************************************
136 INT16 WINAPI
SetBkMode16( HDC16 hdc
, INT16 mode
)
138 return SetBkMode( HDC_32(hdc
), mode
);
142 /***********************************************************************
145 INT16 WINAPI
SetMapMode16( HDC16 hdc
, INT16 mode
)
147 return SetMapMode( HDC_32(hdc
), mode
);
151 /***********************************************************************
154 INT16 WINAPI
SetROP216( HDC16 hdc
, INT16 mode
)
156 return SetROP2( HDC_32(hdc
), mode
);
160 /***********************************************************************
163 INT16 WINAPI
SetRelAbs16( HDC16 hdc
, INT16 mode
)
165 return SetRelAbs( HDC_32(hdc
), mode
);
169 /***********************************************************************
170 * SetPolyFillMode (GDI.6)
172 INT16 WINAPI
SetPolyFillMode16( HDC16 hdc
, INT16 mode
)
174 return SetPolyFillMode( HDC_32(hdc
), mode
);
178 /***********************************************************************
179 * SetStretchBltMode (GDI.7)
181 INT16 WINAPI
SetStretchBltMode16( HDC16 hdc
, INT16 mode
)
183 return SetStretchBltMode( HDC_32(hdc
), mode
);
187 /***********************************************************************
188 * SetTextCharacterExtra (GDI.8)
190 INT16 WINAPI
SetTextCharacterExtra16( HDC16 hdc
, INT16 extra
)
192 return SetTextCharacterExtra( HDC_32(hdc
), extra
);
196 /***********************************************************************
197 * SetTextColor (GDI.9)
199 COLORREF WINAPI
SetTextColor16( HDC16 hdc
, COLORREF color
)
201 return SetTextColor( HDC_32(hdc
), color
);
205 /***********************************************************************
206 * SetTextJustification (GDI.10)
208 INT16 WINAPI
SetTextJustification16( HDC16 hdc
, INT16 extra
, INT16 breaks
)
210 return SetTextJustification( HDC_32(hdc
), extra
, breaks
);
214 /***********************************************************************
215 * SetWindowOrg (GDI.11)
217 DWORD WINAPI
SetWindowOrg16( HDC16 hdc
, INT16 x
, INT16 y
)
220 if (!SetWindowOrgEx( HDC_32(hdc
), x
, y
, &pt
)) return 0;
221 return MAKELONG( pt
.x
, pt
.y
);
225 /***********************************************************************
226 * SetWindowExt (GDI.12)
228 DWORD WINAPI
SetWindowExt16( HDC16 hdc
, INT16 x
, INT16 y
)
231 if (!SetWindowExtEx( HDC_32(hdc
), x
, y
, &size
)) return 0;
232 return MAKELONG( size
.cx
, size
.cy
);
236 /***********************************************************************
237 * SetViewportOrg (GDI.13)
239 DWORD WINAPI
SetViewportOrg16( HDC16 hdc
, INT16 x
, INT16 y
)
242 if (!SetViewportOrgEx( HDC_32(hdc
), x
, y
, &pt
)) return 0;
243 return MAKELONG( pt
.x
, pt
.y
);
247 /***********************************************************************
248 * SetViewportExt (GDI.14)
250 DWORD WINAPI
SetViewportExt16( HDC16 hdc
, INT16 x
, INT16 y
)
253 if (!SetViewportExtEx( HDC_32(hdc
), x
, y
, &size
)) return 0;
254 return MAKELONG( size
.cx
, size
.cy
);
258 /***********************************************************************
259 * OffsetWindowOrg (GDI.15)
261 DWORD WINAPI
OffsetWindowOrg16( HDC16 hdc
, INT16 x
, INT16 y
)
264 if (!OffsetWindowOrgEx( HDC_32(hdc
), x
, y
, &pt
)) return 0;
265 return MAKELONG( pt
.x
, pt
.y
);
269 /***********************************************************************
270 * ScaleWindowExt (GDI.16)
272 DWORD WINAPI
ScaleWindowExt16( HDC16 hdc
, INT16 xNum
, INT16 xDenom
,
273 INT16 yNum
, INT16 yDenom
)
276 if (!ScaleWindowExtEx( HDC_32(hdc
), xNum
, xDenom
, yNum
, yDenom
, &size
))
278 return MAKELONG( size
.cx
, size
.cy
);
282 /***********************************************************************
283 * OffsetViewportOrg (GDI.17)
285 DWORD WINAPI
OffsetViewportOrg16( HDC16 hdc
, INT16 x
, INT16 y
)
288 if (!OffsetViewportOrgEx( HDC_32(hdc
), x
, y
, &pt
)) return 0;
289 return MAKELONG( pt
.x
, pt
.y
);
293 /***********************************************************************
294 * ScaleViewportExt (GDI.18)
296 DWORD WINAPI
ScaleViewportExt16( HDC16 hdc
, INT16 xNum
, INT16 xDenom
,
297 INT16 yNum
, INT16 yDenom
)
300 if (!ScaleViewportExtEx( HDC_32(hdc
), xNum
, xDenom
, yNum
, yDenom
, &size
))
302 return MAKELONG( size
.cx
, size
.cy
);
306 /***********************************************************************
309 BOOL16 WINAPI
LineTo16( HDC16 hdc
, INT16 x
, INT16 y
)
311 return LineTo( HDC_32(hdc
), x
, y
);
315 /***********************************************************************
318 DWORD WINAPI
MoveTo16( HDC16 hdc
, INT16 x
, INT16 y
)
322 if (!MoveToEx( HDC_32(hdc
), x
, y
, &pt
)) return 0;
323 return MAKELONG(pt
.x
,pt
.y
);
327 /***********************************************************************
328 * ExcludeClipRect (GDI.21)
330 INT16 WINAPI
ExcludeClipRect16( HDC16 hdc
, INT16 left
, INT16 top
,
331 INT16 right
, INT16 bottom
)
333 return ExcludeClipRect( HDC_32(hdc
), left
, top
, right
, bottom
);
337 /***********************************************************************
338 * IntersectClipRect (GDI.22)
340 INT16 WINAPI
IntersectClipRect16( HDC16 hdc
, INT16 left
, INT16 top
,
341 INT16 right
, INT16 bottom
)
343 return IntersectClipRect( HDC_32(hdc
), left
, top
, right
, bottom
);
347 /***********************************************************************
350 BOOL16 WINAPI
Arc16( HDC16 hdc
, INT16 left
, INT16 top
, INT16 right
,
351 INT16 bottom
, INT16 xstart
, INT16 ystart
,
352 INT16 xend
, INT16 yend
)
354 return Arc( HDC_32(hdc
), left
, top
, right
, bottom
, xstart
, ystart
, xend
, yend
);
358 /***********************************************************************
361 BOOL16 WINAPI
Ellipse16( HDC16 hdc
, INT16 left
, INT16 top
,
362 INT16 right
, INT16 bottom
)
364 return Ellipse( HDC_32(hdc
), left
, top
, right
, bottom
);
368 /**********************************************************************
371 BOOL16 WINAPI
FloodFill16( HDC16 hdc
, INT16 x
, INT16 y
, COLORREF color
)
373 return ExtFloodFill( HDC_32(hdc
), x
, y
, color
, FLOODFILLBORDER
);
377 /***********************************************************************
380 BOOL16 WINAPI
Pie16( HDC16 hdc
, INT16 left
, INT16 top
,
381 INT16 right
, INT16 bottom
, INT16 xstart
, INT16 ystart
,
382 INT16 xend
, INT16 yend
)
384 return Pie( HDC_32(hdc
), left
, top
, right
, bottom
, xstart
, ystart
, xend
, yend
);
388 /***********************************************************************
391 BOOL16 WINAPI
Rectangle16( HDC16 hdc
, INT16 left
, INT16 top
,
392 INT16 right
, INT16 bottom
)
394 return Rectangle( HDC_32(hdc
), left
, top
, right
, bottom
);
398 /***********************************************************************
401 BOOL16 WINAPI
RoundRect16( HDC16 hdc
, INT16 left
, INT16 top
, INT16 right
,
402 INT16 bottom
, INT16 ell_width
, INT16 ell_height
)
404 return RoundRect( HDC_32(hdc
), left
, top
, right
, bottom
, ell_width
, ell_height
);
408 /***********************************************************************
411 BOOL16 WINAPI
PatBlt16( HDC16 hdc
, INT16 left
, INT16 top
,
412 INT16 width
, INT16 height
, DWORD rop
)
414 return PatBlt( HDC_32(hdc
), left
, top
, width
, height
, rop
);
418 /***********************************************************************
421 INT16 WINAPI
SaveDC16( HDC16 hdc
)
423 return SaveDC( HDC_32(hdc
) );
427 /***********************************************************************
430 COLORREF WINAPI
SetPixel16( HDC16 hdc
, INT16 x
, INT16 y
, COLORREF color
)
432 return SetPixel( HDC_32(hdc
), x
, y
, color
);
436 /***********************************************************************
437 * OffsetClipRgn (GDI.32)
439 INT16 WINAPI
OffsetClipRgn16( HDC16 hdc
, INT16 x
, INT16 y
)
441 return OffsetClipRgn( HDC_32(hdc
), x
, y
);
445 /***********************************************************************
448 BOOL16 WINAPI
TextOut16( HDC16 hdc
, INT16 x
, INT16 y
, LPCSTR str
, INT16 count
)
450 return TextOutA( HDC_32(hdc
), x
, y
, str
, count
);
454 /***********************************************************************
457 BOOL16 WINAPI
BitBlt16( HDC16 hdcDst
, INT16 xDst
, INT16 yDst
, INT16 width
,
458 INT16 height
, HDC16 hdcSrc
, INT16 xSrc
, INT16 ySrc
,
461 return BitBlt( HDC_32(hdcDst
), xDst
, yDst
, width
, height
, HDC_32(hdcSrc
), xSrc
, ySrc
, rop
);
465 /***********************************************************************
466 * StretchBlt (GDI.35)
468 BOOL16 WINAPI
StretchBlt16( HDC16 hdcDst
, INT16 xDst
, INT16 yDst
,
469 INT16 widthDst
, INT16 heightDst
,
470 HDC16 hdcSrc
, INT16 xSrc
, INT16 ySrc
,
471 INT16 widthSrc
, INT16 heightSrc
, DWORD rop
)
473 return StretchBlt( HDC_32(hdcDst
), xDst
, yDst
, widthDst
, heightDst
,
474 HDC_32(hdcSrc
), xSrc
, ySrc
, widthSrc
, heightSrc
, rop
);
478 /**********************************************************************
481 BOOL16 WINAPI
Polygon16( HDC16 hdc
, const POINT16
* pt
, INT16 count
)
485 LPPOINT pt32
= HeapAlloc( GetProcessHeap(), 0, count
*sizeof(POINT
) );
487 if (!pt32
) return FALSE
;
493 ret
= Polygon(HDC_32(hdc
),pt32
,count
);
494 HeapFree( GetProcessHeap(), 0, pt32
);
499 /**********************************************************************
502 BOOL16 WINAPI
Polyline16( HDC16 hdc
, const POINT16
* pt
, INT16 count
)
506 LPPOINT pt32
= HeapAlloc( GetProcessHeap(), 0, count
*sizeof(POINT
) );
508 if (!pt32
) return FALSE
;
514 ret
= Polyline(HDC_32(hdc
),pt32
,count
);
515 HeapFree( GetProcessHeap(), 0, pt32
);
520 /***********************************************************************
523 INT16 WINAPI
Escape16( HDC16 hdc
, INT16 escape
, INT16 in_count
, SEGPTR in_data
, LPVOID out_data
)
529 /* Escape(hdc,CLIP_TO_PATH,LPINT16,NULL) */
530 /* Escape(hdc,DRAFTMODE,LPINT16,NULL) */
531 /* Escape(hdc,ENUMPAPERBINS,LPINT16,LPSTR); */
532 /* Escape(hdc,EPSPRINTING,LPINT16,NULL) */
533 /* Escape(hdc,EXT_DEVICE_CAPS,LPINT16,LPDWORD) */
534 /* Escape(hdc,GETCOLORTABLE,LPINT16,LPDWORD) */
535 /* Escape(hdc,MOUSETRAILS,LPINT16,NULL) */
536 /* Escape(hdc,POSTSCRIPT_IGNORE,LPINT16,NULL) */
537 /* Escape(hdc,QUERYESCSUPPORT,LPINT16,NULL) */
538 /* Escape(hdc,SET_ARC_DIRECTION,LPINT16,NULL) */
539 /* Escape(hdc,SET_POLY_MODE,LPINT16,NULL) */
540 /* Escape(hdc,SET_SCREEN_ANGLE,LPINT16,NULL) */
541 /* Escape(hdc,SET_SPREAD,LPINT16,NULL) */
546 case EXT_DEVICE_CAPS
:
549 case POSTSCRIPT_IGNORE
:
550 case QUERYESCSUPPORT
:
551 case SET_ARC_DIRECTION
:
553 case SET_SCREEN_ANGLE
:
556 INT16
*ptr
= MapSL(in_data
);
558 return Escape( HDC_32(hdc
), escape
, sizeof(data
), (LPCSTR
)&data
, out_data
);
561 /* Escape(hdc,ENABLEDUPLEX,LPUINT16,NULL) */
564 UINT16
*ptr
= MapSL(in_data
);
566 return Escape( HDC_32(hdc
), escape
, sizeof(data
), (LPCSTR
)&data
, NULL
);
569 /* Escape(hdc,GETPHYSPAGESIZE,NULL,LPPOINT16) */
570 /* Escape(hdc,GETPRINTINGOFFSET,NULL,LPPOINT16) */
571 /* Escape(hdc,GETSCALINGFACTOR,NULL,LPPOINT16) */
572 case GETPHYSPAGESIZE
:
573 case GETPRINTINGOFFSET
:
574 case GETSCALINGFACTOR
:
576 POINT16
*ptr
= out_data
;
578 ret
= Escape( HDC_32(hdc
), escape
, 0, NULL
, &pt32
);
584 /* Escape(hdc,ENABLEPAIRKERNING,LPINT16,LPINT16); */
585 /* Escape(hdc,ENABLERELATIVEWIDTHS,LPINT16,LPINT16); */
586 /* Escape(hdc,SETCOPYCOUNT,LPINT16,LPINT16) */
587 /* Escape(hdc,SETKERNTRACK,LPINT16,LPINT16) */
588 /* Escape(hdc,SETLINECAP,LPINT16,LPINT16) */
589 /* Escape(hdc,SETLINEJOIN,LPINT16,LPINT16) */
590 /* Escape(hdc,SETMITERLIMIT,LPINT16,LPINT16) */
591 case ENABLEPAIRKERNING
:
592 case ENABLERELATIVEWIDTHS
:
599 INT16
*new = MapSL(in_data
);
600 INT16
*old
= out_data
;
602 ret
= Escape( HDC_32(hdc
), escape
, sizeof(in
), (LPCSTR
)&in
, &out
);
607 /* Escape(hdc,SETABORTPROC,ABORTPROC,NULL); */
609 return SetAbortProc16( hdc
, (ABORTPROC16
)in_data
);
611 /* Escape(hdc,STARTDOC,LPSTR,LPDOCINFO16);
612 * lpvOutData is actually a pointer to the DocInfo structure and used as
613 * a second input parameter */
617 ret
= StartDoc16( hdc
, out_data
);
618 if (ret
> 0) ret
= StartPage( HDC_32(hdc
) );
621 return Escape( HDC_32(hdc
), escape
, in_count
, MapSL(in_data
), NULL
);
623 /* Escape(hdc,SET_BOUNDS,LPRECT16,NULL); */
624 /* Escape(hdc,SET_CLIP_BOX,LPRECT16,NULL); */
628 RECT16
*rc16
= MapSL(in_data
);
630 rc
.left
= rc16
->left
;
632 rc
.right
= rc16
->right
;
633 rc
.bottom
= rc16
->bottom
;
634 return Escape( HDC_32(hdc
), escape
, sizeof(rc
), (LPCSTR
)&rc
, NULL
);
637 /* Escape(hdc,NEXTBAND,NULL,LPRECT16); */
641 RECT16
*rc16
= out_data
;
642 ret
= Escape( HDC_32(hdc
), escape
, 0, NULL
, &rc
);
643 rc16
->left
= rc
.left
;
645 rc16
->right
= rc
.right
;
646 rc16
->bottom
= rc
.bottom
;
650 /* Escape(hdc,ABORTDOC,NULL,NULL); */
651 /* Escape(hdc,BANDINFO,BANDINFOSTRUCT*,BANDINFOSTRUCT*); */
652 /* Escape(hdc,BEGIN_PATH,NULL,NULL); */
653 /* Escape(hdc,DRAWPATTERNRECT,PRECT_STRUCT*,NULL); */
654 /* Escape(hdc,ENDDOC,NULL,NULL); */
655 /* Escape(hdc,END_PATH,PATHINFO,NULL); */
656 /* Escape(hdc,EXTTEXTOUT,EXTTEXT_STRUCT*,NULL); */
657 /* Escape(hdc,FLUSHOUTPUT,NULL,NULL); */
658 /* Escape(hdc,GETFACENAME,NULL,LPSTR); */
659 /* Escape(hdc,GETPAIRKERNTABLE,NULL,KERNPAIR*); */
660 /* Escape(hdc,GETSETPAPERBINS,BinInfo*,BinInfo*); */
661 /* Escape(hdc,GETSETPRINTORIENT,ORIENT*,NULL); */
662 /* Escape(hdc,GETSETSCREENPARAMS,SCREENPARAMS*,SCREENPARAMS*); */
663 /* Escape(hdc,GETTECHNOLOGY,NULL,LPSTR); */
664 /* Escape(hdc,GETTRACKKERNTABLE,NULL,KERNTRACK*); */
665 /* Escape(hdc,MFCOMMENT,LPSTR,NULL); */
666 /* Escape(hdc,NEWFRAME,NULL,NULL); */
667 /* Escape(hdc,PASSTHROUGH,LPSTR,NULL); */
668 /* Escape(hdc,RESTORE_CTM,NULL,NULL); */
669 /* Escape(hdc,SAVE_CTM,NULL,NULL); */
670 /* Escape(hdc,SETALLJUSTVALUES,EXTTEXTDATA*,NULL); */
671 /* Escape(hdc,SETCOLORTABLE,COLORTABLE_STRUCT*,LPDWORD); */
672 /* Escape(hdc,SET_BACKGROUND_COLOR,LPDWORD,LPDWORD); */
673 /* Escape(hdc,TRANSFORM_CTM,LPSTR,NULL); */
677 case DRAWPATTERNRECT
:
683 case GETPAIRKERNTABLE
:
684 case GETSETPAPERBINS
:
685 case GETSETPRINTORIENT
:
686 case GETSETSCREENPARAMS
:
688 case GETTRACKKERNTABLE
:
694 case SETALLJUSTVALUES
:
696 case SET_BACKGROUND_COLOR
:
698 /* pass it unmodified to the 32-bit function */
699 return Escape( HDC_32(hdc
), escape
, in_count
, MapSL(in_data
), out_data
);
701 /* Escape(hdc,ENUMPAPERMETRICS,LPINT16,LPRECT16); */
702 /* Escape(hdc,GETEXTENDEDTEXTMETRICS,LPUINT16,EXTTEXTMETRIC*); */
703 /* Escape(hdc,GETEXTENTTABLE,LPSTR,LPINT16); */
704 /* Escape(hdc,GETSETPAPERMETRICS,LPRECT16,LPRECT16); */
705 /* Escape(hdc,GETVECTORBRUSHSIZE,LPLOGBRUSH16,LPPOINT16); */
706 /* Escape(hdc,GETVECTORPENSIZE,LPLOGPEN16,LPPOINT16); */
707 case ENUMPAPERMETRICS
:
708 case GETEXTENDEDTEXTMETRICS
:
710 case GETSETPAPERMETRICS
:
711 case GETVECTORBRUSHSIZE
:
712 case GETVECTORPENSIZE
:
714 FIXME("unknown/unsupported 16-bit escape %x (%d,%p,%p\n",
715 escape
, in_count
, MapSL(in_data
), out_data
);
716 return Escape( HDC_32(hdc
), escape
, in_count
, MapSL(in_data
), out_data
);
721 /***********************************************************************
724 BOOL16 WINAPI
RestoreDC16( HDC16 hdc
, INT16 level
)
726 return RestoreDC( HDC_32(hdc
), level
);
730 /***********************************************************************
733 BOOL16 WINAPI
FillRgn16( HDC16 hdc
, HRGN16 hrgn
, HBRUSH16 hbrush
)
735 return FillRgn( HDC_32(hdc
), HRGN_32(hrgn
), HBRUSH_32(hbrush
) );
739 /***********************************************************************
742 BOOL16 WINAPI
FrameRgn16( HDC16 hdc
, HRGN16 hrgn
, HBRUSH16 hbrush
,
743 INT16 nWidth
, INT16 nHeight
)
745 return FrameRgn( HDC_32(hdc
), HRGN_32(hrgn
), HBRUSH_32(hbrush
), nWidth
, nHeight
);
749 /***********************************************************************
752 BOOL16 WINAPI
InvertRgn16( HDC16 hdc
, HRGN16 hrgn
)
754 return InvertRgn( HDC_32(hdc
), HRGN_32(hrgn
) );
758 /***********************************************************************
761 BOOL16 WINAPI
PaintRgn16( HDC16 hdc
, HRGN16 hrgn
)
763 return PaintRgn( HDC_32(hdc
), HRGN_32(hrgn
) );
767 /***********************************************************************
768 * SelectClipRgn (GDI.44)
770 INT16 WINAPI
SelectClipRgn16( HDC16 hdc
, HRGN16 hrgn
)
772 return SelectClipRgn( HDC_32(hdc
), HRGN_32(hrgn
) );
776 /***********************************************************************
777 * SelectObject (GDI.45)
779 HGDIOBJ16 WINAPI
SelectObject16( HDC16 hdc
, HGDIOBJ16 handle
)
781 return HGDIOBJ_16( SelectObject( HDC_32(hdc
), HGDIOBJ_32(handle
) ) );
785 /***********************************************************************
786 * CombineRgn (GDI.47)
788 INT16 WINAPI
CombineRgn16(HRGN16 hDest
, HRGN16 hSrc1
, HRGN16 hSrc2
, INT16 mode
)
790 return CombineRgn( HRGN_32(hDest
), HRGN_32(hSrc1
), HRGN_32(hSrc2
), mode
);
794 /***********************************************************************
795 * CreateBitmap (GDI.48)
797 HBITMAP16 WINAPI
CreateBitmap16( INT16 width
, INT16 height
, UINT16 planes
,
798 UINT16 bpp
, LPCVOID bits
)
800 return HBITMAP_16( CreateBitmap( width
, height
, planes
& 0xff, bpp
& 0xff, bits
) );
804 /***********************************************************************
805 * CreateBitmapIndirect (GDI.49)
807 HBITMAP16 WINAPI
CreateBitmapIndirect16( const BITMAP16
* bmp
)
809 return CreateBitmap16( bmp
->bmWidth
, bmp
->bmHeight
, bmp
->bmPlanes
,
810 bmp
->bmBitsPixel
, MapSL( bmp
->bmBits
) );
814 /***********************************************************************
815 * CreateBrushIndirect (GDI.50)
817 HBRUSH16 WINAPI
CreateBrushIndirect16( const LOGBRUSH16
* brush
)
821 if (brush
->lbStyle
== BS_DIBPATTERN
|| brush
->lbStyle
== BS_DIBPATTERN8X8
)
822 return CreateDIBPatternBrush16( brush
->lbHatch
, brush
->lbColor
);
824 brush32
.lbStyle
= brush
->lbStyle
;
825 brush32
.lbColor
= brush
->lbColor
;
826 brush32
.lbHatch
= brush
->lbHatch
;
827 return HBRUSH_16( CreateBrushIndirect(&brush32
) );
831 /***********************************************************************
832 * CreateCompatibleBitmap (GDI.51)
834 HBITMAP16 WINAPI
CreateCompatibleBitmap16( HDC16 hdc
, INT16 width
, INT16 height
)
836 return HBITMAP_16( CreateCompatibleBitmap( HDC_32(hdc
), width
, height
) );
840 /***********************************************************************
841 * CreateCompatibleDC (GDI.52)
843 HDC16 WINAPI
CreateCompatibleDC16( HDC16 hdc
)
845 return HDC_16( CreateCompatibleDC( HDC_32(hdc
) ) );
849 /***********************************************************************
852 HDC16 WINAPI
CreateDC16( LPCSTR driver
, LPCSTR device
, LPCSTR output
,
853 const DEVMODEA
*initData
)
855 return HDC_16( CreateDCA( driver
, device
, output
, initData
) );
859 /***********************************************************************
860 * CreateEllipticRgn (GDI.54)
862 HRGN16 WINAPI
CreateEllipticRgn16( INT16 left
, INT16 top
, INT16 right
, INT16 bottom
)
864 return HRGN_16( CreateEllipticRgn( left
, top
, right
, bottom
) );
868 /***********************************************************************
869 * CreateEllipticRgnIndirect (GDI.55)
871 HRGN16 WINAPI
CreateEllipticRgnIndirect16( const RECT16
*rect
)
873 return HRGN_16( CreateEllipticRgn( rect
->left
, rect
->top
, rect
->right
, rect
->bottom
) );
877 /***********************************************************************
878 * CreateFont (GDI.56)
880 HFONT16 WINAPI
CreateFont16(INT16 height
, INT16 width
, INT16 esc
, INT16 orient
,
881 INT16 weight
, BYTE italic
, BYTE underline
,
882 BYTE strikeout
, BYTE charset
, BYTE outpres
,
883 BYTE clippres
, BYTE quality
, BYTE pitch
,
886 return HFONT_16( CreateFontA( height
, width
, esc
, orient
, weight
, italic
, underline
,
887 strikeout
, charset
, outpres
, clippres
, quality
, pitch
, name
));
890 /***********************************************************************
891 * CreateFontIndirect (GDI.57)
893 HFONT16 WINAPI
CreateFontIndirect16( const LOGFONT16
*plf16
)
900 logfont_16_to_W( plf16
, &lfW
);
901 ret
= CreateFontIndirectW( &lfW
);
903 else ret
= CreateFontIndirectW( NULL
);
904 return HFONT_16(ret
);
908 /***********************************************************************
909 * CreateHatchBrush (GDI.58)
911 HBRUSH16 WINAPI
CreateHatchBrush16( INT16 style
, COLORREF color
)
913 return HBRUSH_16( CreateHatchBrush( style
, color
) );
917 /***********************************************************************
918 * CreatePatternBrush (GDI.60)
920 HBRUSH16 WINAPI
CreatePatternBrush16( HBITMAP16 hbitmap
)
922 return HBRUSH_16( CreatePatternBrush( HBITMAP_32(hbitmap
) ));
926 /***********************************************************************
929 HPEN16 WINAPI
CreatePen16( INT16 style
, INT16 width
, COLORREF color
)
933 logpen
.lopnStyle
= style
;
934 logpen
.lopnWidth
.x
= width
;
935 logpen
.lopnWidth
.y
= 0;
936 logpen
.lopnColor
= color
;
937 return HPEN_16( CreatePenIndirect( &logpen
) );
941 /***********************************************************************
942 * CreatePenIndirect (GDI.62)
944 HPEN16 WINAPI
CreatePenIndirect16( const LOGPEN16
* pen
)
948 if (pen
->lopnStyle
> PS_INSIDEFRAME
) return 0;
949 logpen
.lopnStyle
= pen
->lopnStyle
;
950 logpen
.lopnWidth
.x
= pen
->lopnWidth
.x
;
951 logpen
.lopnWidth
.y
= pen
->lopnWidth
.y
;
952 logpen
.lopnColor
= pen
->lopnColor
;
953 return HPEN_16( CreatePenIndirect( &logpen
) );
957 /***********************************************************************
958 * CreatePolygonRgn (GDI.63)
960 HRGN16 WINAPI
CreatePolygonRgn16( const POINT16
* points
, INT16 count
, INT16 mode
)
962 return CreatePolyPolygonRgn16( points
, &count
, 1, mode
);
966 /***********************************************************************
967 * CreateRectRgn (GDI.64)
969 * NOTE: cf. SetRectRgn16
971 HRGN16 WINAPI
CreateRectRgn16( INT16 left
, INT16 top
, INT16 right
, INT16 bottom
)
975 if (left
< right
) hrgn
= CreateRectRgn( left
, top
, right
, bottom
);
976 else hrgn
= CreateRectRgn( 0, 0, 0, 0 );
977 return HRGN_16(hrgn
);
981 /***********************************************************************
982 * CreateRectRgnIndirect (GDI.65)
984 HRGN16 WINAPI
CreateRectRgnIndirect16( const RECT16
* rect
)
986 return CreateRectRgn16( rect
->left
, rect
->top
, rect
->right
, rect
->bottom
);
990 /***********************************************************************
991 * CreateSolidBrush (GDI.66)
993 HBRUSH16 WINAPI
CreateSolidBrush16( COLORREF color
)
995 return HBRUSH_16( CreateSolidBrush( color
) );
999 /***********************************************************************
1002 BOOL16 WINAPI
DeleteDC16( HDC16 hdc
)
1004 return DeleteDC( HDC_32(hdc
) );
1008 /***********************************************************************
1009 * DeleteObject (GDI.69)
1010 * SysDeleteObject (GDI.605)
1012 BOOL16 WINAPI
DeleteObject16( HGDIOBJ16 obj
)
1014 return DeleteObject( HGDIOBJ_32(obj
) );
1018 /***********************************************************************
1019 * EnumObjects (GDI.71)
1021 INT16 WINAPI
EnumObjects16( HDC16 hdc
, INT16 obj
, GOBJENUMPROC16 proc
, LPARAM lParam
)
1023 struct callback16_info info
;
1025 info
.proc
= (FARPROC16
)proc
;
1026 info
.param
= lParam
;
1030 return EnumObjects( HDC_32(hdc
), OBJ_PEN
, enum_pens_callback
, (LPARAM
)&info
);
1032 return EnumObjects( HDC_32(hdc
), OBJ_BRUSH
, enum_brushes_callback
, (LPARAM
)&info
);
1038 /***********************************************************************
1041 BOOL16 WINAPI
EqualRgn16( HRGN16 rgn1
, HRGN16 rgn2
)
1043 return EqualRgn( HRGN_32(rgn1
), HRGN_32(rgn2
) );
1047 /***********************************************************************
1048 * GetBitmapBits (GDI.74)
1050 LONG WINAPI
GetBitmapBits16( HBITMAP16 hbitmap
, LONG count
, LPVOID buffer
)
1052 return GetBitmapBits( HBITMAP_32(hbitmap
), count
, buffer
);
1056 /***********************************************************************
1057 * GetBkColor (GDI.75)
1059 COLORREF WINAPI
GetBkColor16( HDC16 hdc
)
1061 return GetBkColor( HDC_32(hdc
) );
1065 /***********************************************************************
1066 * GetBkMode (GDI.76)
1068 INT16 WINAPI
GetBkMode16( HDC16 hdc
)
1070 return GetBkMode( HDC_32(hdc
) );
1074 /***********************************************************************
1075 * GetClipBox (GDI.77)
1077 INT16 WINAPI
GetClipBox16( HDC16 hdc
, LPRECT16 rect
)
1080 INT ret
= GetClipBox( HDC_32(hdc
), &rect32
);
1084 rect
->left
= rect32
.left
;
1085 rect
->top
= rect32
.top
;
1086 rect
->right
= rect32
.right
;
1087 rect
->bottom
= rect32
.bottom
;
1093 /***********************************************************************
1094 * GetCurrentPosition (GDI.78)
1096 DWORD WINAPI
GetCurrentPosition16( HDC16 hdc
)
1099 if (!GetCurrentPositionEx( HDC_32(hdc
), &pt32
)) return 0;
1100 return MAKELONG( pt32
.x
, pt32
.y
);
1104 /***********************************************************************
1107 DWORD WINAPI
GetDCOrg16( HDC16 hdc
)
1110 if (GetDCOrgEx( HDC_32(hdc
), &pt
)) return MAKELONG( pt
.x
, pt
.y
);
1115 /***********************************************************************
1116 * GetDeviceCaps (GDI.80)
1118 INT16 WINAPI
GetDeviceCaps16( HDC16 hdc
, INT16 cap
)
1120 INT16 ret
= GetDeviceCaps( HDC_32(hdc
), cap
);
1121 /* some apps don't expect -1 and think it's a B&W screen */
1122 if ((cap
== NUMCOLORS
) && (ret
== -1)) ret
= 2048;
1127 /***********************************************************************
1128 * GetMapMode (GDI.81)
1130 INT16 WINAPI
GetMapMode16( HDC16 hdc
)
1132 return GetMapMode( HDC_32(hdc
) );
1136 /***********************************************************************
1139 COLORREF WINAPI
GetPixel16( HDC16 hdc
, INT16 x
, INT16 y
)
1141 return GetPixel( HDC_32(hdc
), x
, y
);
1145 /***********************************************************************
1146 * GetPolyFillMode (GDI.84)
1148 INT16 WINAPI
GetPolyFillMode16( HDC16 hdc
)
1150 return GetPolyFillMode( HDC_32(hdc
) );
1154 /***********************************************************************
1157 INT16 WINAPI
GetROP216( HDC16 hdc
)
1159 return GetROP2( HDC_32(hdc
) );
1163 /***********************************************************************
1164 * GetRelAbs (GDI.86)
1166 INT16 WINAPI
GetRelAbs16( HDC16 hdc
)
1168 return GetRelAbs( HDC_32(hdc
), 0 );
1172 /***********************************************************************
1173 * GetStockObject (GDI.87)
1175 HGDIOBJ16 WINAPI
GetStockObject16( INT16 obj
)
1177 return HGDIOBJ_16( GetStockObject( obj
) );
1181 /***********************************************************************
1182 * GetStretchBltMode (GDI.88)
1184 INT16 WINAPI
GetStretchBltMode16( HDC16 hdc
)
1186 return GetStretchBltMode( HDC_32(hdc
) );
1190 /***********************************************************************
1191 * GetTextCharacterExtra (GDI.89)
1193 INT16 WINAPI
GetTextCharacterExtra16( HDC16 hdc
)
1195 return GetTextCharacterExtra( HDC_32(hdc
) );
1199 /***********************************************************************
1200 * GetTextColor (GDI.90)
1202 COLORREF WINAPI
GetTextColor16( HDC16 hdc
)
1204 return GetTextColor( HDC_32(hdc
) );
1208 /***********************************************************************
1209 * GetTextExtent (GDI.91)
1211 DWORD WINAPI
GetTextExtent16( HDC16 hdc
, LPCSTR str
, INT16 count
)
1214 if (!GetTextExtentPoint32A( HDC_32(hdc
), str
, count
, &size
)) return 0;
1215 return MAKELONG( size
.cx
, size
.cy
);
1219 /***********************************************************************
1220 * GetTextFace (GDI.92)
1222 INT16 WINAPI
GetTextFace16( HDC16 hdc
, INT16 count
, LPSTR name
)
1224 return GetTextFaceA( HDC_32(hdc
), count
, name
);
1228 /***********************************************************************
1229 * GetTextMetrics (GDI.93)
1231 BOOL16 WINAPI
GetTextMetrics16( HDC16 hdc
, TEXTMETRIC16
*tm
)
1235 if (!GetTextMetricsW( HDC_32(hdc
), &tm32
)) return FALSE
;
1237 tm
->tmHeight
= tm32
.tmHeight
;
1238 tm
->tmAscent
= tm32
.tmAscent
;
1239 tm
->tmDescent
= tm32
.tmDescent
;
1240 tm
->tmInternalLeading
= tm32
.tmInternalLeading
;
1241 tm
->tmExternalLeading
= tm32
.tmExternalLeading
;
1242 tm
->tmAveCharWidth
= tm32
.tmAveCharWidth
;
1243 tm
->tmMaxCharWidth
= tm32
.tmMaxCharWidth
;
1244 tm
->tmWeight
= tm32
.tmWeight
;
1245 tm
->tmOverhang
= tm32
.tmOverhang
;
1246 tm
->tmDigitizedAspectX
= tm32
.tmDigitizedAspectX
;
1247 tm
->tmDigitizedAspectY
= tm32
.tmDigitizedAspectY
;
1248 tm
->tmFirstChar
= tm32
.tmFirstChar
;
1249 tm
->tmLastChar
= tm32
.tmLastChar
;
1250 tm
->tmDefaultChar
= tm32
.tmDefaultChar
;
1251 tm
->tmBreakChar
= tm32
.tmBreakChar
;
1252 tm
->tmItalic
= tm32
.tmItalic
;
1253 tm
->tmUnderlined
= tm32
.tmUnderlined
;
1254 tm
->tmStruckOut
= tm32
.tmStruckOut
;
1255 tm
->tmPitchAndFamily
= tm32
.tmPitchAndFamily
;
1256 tm
->tmCharSet
= tm32
.tmCharSet
;
1261 /***********************************************************************
1262 * GetViewportExt (GDI.94)
1264 DWORD WINAPI
GetViewportExt16( HDC16 hdc
)
1267 if (!GetViewportExtEx( HDC_32(hdc
), &size
)) return 0;
1268 return MAKELONG( size
.cx
, size
.cy
);
1272 /***********************************************************************
1273 * GetViewportOrg (GDI.95)
1275 DWORD WINAPI
GetViewportOrg16( HDC16 hdc
)
1278 if (!GetViewportOrgEx( HDC_32(hdc
), &pt
)) return 0;
1279 return MAKELONG( pt
.x
, pt
.y
);
1283 /***********************************************************************
1284 * GetWindowExt (GDI.96)
1286 DWORD WINAPI
GetWindowExt16( HDC16 hdc
)
1289 if (!GetWindowExtEx( HDC_32(hdc
), &size
)) return 0;
1290 return MAKELONG( size
.cx
, size
.cy
);
1294 /***********************************************************************
1295 * GetWindowOrg (GDI.97)
1297 DWORD WINAPI
GetWindowOrg16( HDC16 hdc
)
1300 if (!GetWindowOrgEx( HDC_32(hdc
), &pt
)) return 0;
1301 return MAKELONG( pt
.x
, pt
.y
);
1307 /**********************************************************************
1310 void WINAPI
LineDDA16( INT16 nXStart
, INT16 nYStart
, INT16 nXEnd
,
1311 INT16 nYEnd
, LINEDDAPROC16 proc
, LPARAM lParam
)
1313 struct callback16_info info
;
1314 info
.proc
= (FARPROC16
)proc
;
1315 info
.param
= lParam
;
1316 LineDDA( nXStart
, nYStart
, nXEnd
, nYEnd
, linedda_callback
, (LPARAM
)&info
);
1320 /***********************************************************************
1321 * OffsetRgn (GDI.101)
1323 INT16 WINAPI
OffsetRgn16( HRGN16 hrgn
, INT16 x
, INT16 y
)
1325 return OffsetRgn( HRGN_32(hrgn
), x
, y
);
1329 /***********************************************************************
1330 * PtVisible (GDI.103)
1332 BOOL16 WINAPI
PtVisible16( HDC16 hdc
, INT16 x
, INT16 y
)
1334 return PtVisible( HDC_32(hdc
), x
, y
);
1338 /***********************************************************************
1339 * SetBitmapBits (GDI.106)
1341 LONG WINAPI
SetBitmapBits16( HBITMAP16 hbitmap
, LONG count
, LPCVOID buffer
)
1343 return SetBitmapBits( HBITMAP_32(hbitmap
), count
, buffer
);
1347 /***********************************************************************
1348 * AddFontResource (GDI.119)
1350 INT16 WINAPI
AddFontResource16( LPCSTR filename
)
1352 return AddFontResourceA( filename
);
1356 /***********************************************************************
1359 * Disables GDI, switches back to text mode.
1360 * We don't have to do anything here,
1361 * just let console support handle everything
1363 void WINAPI
Death16(HDC16 hdc
)
1365 MESSAGE("Death(%04x) called. Application enters text mode...\n", hdc
);
1369 /***********************************************************************
1370 * Resurrection (GDI.122)
1372 * Restores GDI functionality
1374 void WINAPI
Resurrection16(HDC16 hdc
,
1375 WORD w1
, WORD w2
, WORD w3
, WORD w4
, WORD w5
, WORD w6
)
1377 MESSAGE("Resurrection(%04x, %04x, %04x, %04x, %04x, %04x, %04x) called. Application left text mode.\n",
1378 hdc
, w1
, w2
, w3
, w4
, w5
, w6
);
1382 /**********************************************************************
1383 * CreateMetaFile (GDI.125)
1385 HDC16 WINAPI
CreateMetaFile16( LPCSTR filename
)
1387 return HDC_16( CreateMetaFileA( filename
) );
1391 /***********************************************************************
1394 INT16 WINAPI
MulDiv16( INT16 nMultiplicand
, INT16 nMultiplier
, INT16 nDivisor
)
1397 if (!nDivisor
) return -32768;
1398 /* We want to deal with a positive divisor to simplify the logic. */
1401 nMultiplicand
= - nMultiplicand
;
1402 nDivisor
= -nDivisor
;
1404 /* If the result is positive, we "add" to round. else,
1405 * we subtract to round. */
1406 if ( ( (nMultiplicand
< 0) && (nMultiplier
< 0) ) ||
1407 ( (nMultiplicand
>= 0) && (nMultiplier
>= 0) ) )
1408 ret
= (((int)nMultiplicand
* nMultiplier
) + (nDivisor
/2)) / nDivisor
;
1410 ret
= (((int)nMultiplicand
* nMultiplier
) - (nDivisor
/2)) / nDivisor
;
1411 if ((ret
> 32767) || (ret
< -32767)) return -32768;
1416 /***********************************************************************
1417 * GetRgnBox (GDI.134)
1419 INT16 WINAPI
GetRgnBox16( HRGN16 hrgn
, LPRECT16 rect
)
1422 INT16 ret
= GetRgnBox( HRGN_32(hrgn
), &r
);
1423 rect
->left
= r
.left
;
1425 rect
->right
= r
.right
;
1426 rect
->bottom
= r
.bottom
;
1431 /***********************************************************************
1432 * RemoveFontResource (GDI.136)
1434 BOOL16 WINAPI
RemoveFontResource16( LPCSTR str
)
1436 return RemoveFontResourceA(str
);
1440 /***********************************************************************
1441 * SetBrushOrg (GDI.148)
1443 DWORD WINAPI
SetBrushOrg16( HDC16 hdc
, INT16 x
, INT16 y
)
1447 if (!SetBrushOrgEx( HDC_32(hdc
), x
, y
, &pt
)) return 0;
1448 return MAKELONG( pt
.x
, pt
.y
);
1452 /***********************************************************************
1453 * GetBrushOrg (GDI.149)
1455 DWORD WINAPI
GetBrushOrg16( HDC16 hdc
)
1458 if (!GetBrushOrgEx( HDC_32(hdc
), &pt
)) return 0;
1459 return MAKELONG( pt
.x
, pt
.y
);
1463 /***********************************************************************
1464 * UnrealizeObject (GDI.150)
1466 BOOL16 WINAPI
UnrealizeObject16( HGDIOBJ16 obj
)
1468 return UnrealizeObject( HGDIOBJ_32(obj
) );
1472 /***********************************************************************
1473 * CreateIC (GDI.153)
1475 HDC16 WINAPI
CreateIC16( LPCSTR driver
, LPCSTR device
, LPCSTR output
,
1476 const DEVMODEA
* initData
)
1478 return HDC_16( CreateICA( driver
, device
, output
, initData
) );
1482 /***********************************************************************
1483 * GetNearestColor (GDI.154)
1485 COLORREF WINAPI
GetNearestColor16( HDC16 hdc
, COLORREF color
)
1487 return GetNearestColor( HDC_32(hdc
), color
);
1491 /***********************************************************************
1492 * CreateDiscardableBitmap (GDI.156)
1494 HBITMAP16 WINAPI
CreateDiscardableBitmap16( HDC16 hdc
, INT16 width
, INT16 height
)
1496 return HBITMAP_16( CreateDiscardableBitmap( HDC_32(hdc
), width
, height
) );
1500 /***********************************************************************
1501 * PtInRegion (GDI.161)
1503 BOOL16 WINAPI
PtInRegion16( HRGN16 hrgn
, INT16 x
, INT16 y
)
1505 return PtInRegion( HRGN_32(hrgn
), x
, y
);
1509 /***********************************************************************
1510 * GetBitmapDimension (GDI.162)
1512 DWORD WINAPI
GetBitmapDimension16( HBITMAP16 hbitmap
)
1515 if (!GetBitmapDimensionEx16( hbitmap
, &size
)) return 0;
1516 return MAKELONG( size
.cx
, size
.cy
);
1520 /***********************************************************************
1521 * SetBitmapDimension (GDI.163)
1523 DWORD WINAPI
SetBitmapDimension16( HBITMAP16 hbitmap
, INT16 x
, INT16 y
)
1526 if (!SetBitmapDimensionEx16( hbitmap
, x
, y
, &size
)) return 0;
1527 return MAKELONG( size
.cx
, size
.cy
);
1531 /***********************************************************************
1532 * SetRectRgn (GDI.172)
1534 * NOTE: Win 3.1 sets region to empty if left > right
1536 void WINAPI
SetRectRgn16( HRGN16 hrgn
, INT16 left
, INT16 top
, INT16 right
, INT16 bottom
)
1538 if (left
< right
) SetRectRgn( HRGN_32(hrgn
), left
, top
, right
, bottom
);
1539 else SetRectRgn( HRGN_32(hrgn
), 0, 0, 0, 0 );
1543 /******************************************************************
1544 * PlayMetaFileRecord (GDI.176)
1546 void WINAPI
PlayMetaFileRecord16( HDC16 hdc
, HANDLETABLE16
*ht
, METARECORD
*mr
, UINT16 handles
)
1548 HANDLETABLE
*ht32
= HeapAlloc( GetProcessHeap(), 0, handles
* sizeof(*ht32
) );
1551 for (i
= 0; i
< handles
; i
++) ht32
->objectHandle
[i
] = (HGDIOBJ
)(ULONG_PTR
)ht
->objectHandle
[i
];
1552 PlayMetaFileRecord( HDC_32(hdc
), ht32
, mr
, handles
);
1553 for (i
= 0; i
< handles
; i
++) ht
->objectHandle
[i
] = LOWORD(ht32
->objectHandle
[i
]);
1554 HeapFree( GetProcessHeap(), 0, ht32
);
1558 /***********************************************************************
1559 * SetBoundsRect (GDI.193)
1561 UINT16 WINAPI
SetBoundsRect16( HDC16 hdc
, const RECT16
* rect
, UINT16 flags
)
1566 rect32
.left
= rect
->left
;
1567 rect32
.top
= rect
->top
;
1568 rect32
.right
= rect
->right
;
1569 rect32
.bottom
= rect
->bottom
;
1570 return SetBoundsRect( HDC_32( hdc
), &rect32
, flags
);
1572 else return SetBoundsRect( HDC_32( hdc
), NULL
, flags
);
1576 /***********************************************************************
1577 * GetBoundsRect (GDI.194)
1579 UINT16 WINAPI
GetBoundsRect16( HDC16 hdc
, LPRECT16 rect
, UINT16 flags
)
1582 UINT ret
= GetBoundsRect( HDC_32( hdc
), &rect32
, flags
);
1585 rect
->left
= rect32
.left
;
1586 rect
->top
= rect32
.top
;
1587 rect
->right
= rect32
.right
;
1588 rect
->bottom
= rect32
.bottom
;
1594 /***********************************************************************
1595 * EngineEnumerateFont (GDI.300)
1597 WORD WINAPI
EngineEnumerateFont16(LPSTR fontname
, FARPROC16 proc
, DWORD data
)
1599 FIXME("(%s,%p,%lx),stub\n",fontname
,proc
,data
);
1604 /***********************************************************************
1605 * EngineDeleteFont (GDI.301)
1607 WORD WINAPI
EngineDeleteFont16(LPFONTINFO16 lpFontInfo
)
1611 /* untested, don't know if it works.
1612 We seem to access some structure that is located after the
1613 FONTINFO. The FONTINFO documentation says that there may
1614 follow some char-width table or font bitmap or vector info.
1615 I think it is some kind of font bitmap that begins at offset 0x52,
1616 as FONTINFO goes up to 0x51.
1617 If this is correct, everything should be implemented correctly.
1619 if ( ((lpFontInfo
->dfType
& (RASTER_FONTTYPE
|DEVICE_FONTTYPE
)) == (RASTER_FONTTYPE
|DEVICE_FONTTYPE
))
1620 && (LOWORD(lpFontInfo
->dfFace
) == LOWORD(lpFontInfo
)+0x6e)
1621 && (handle
= *(WORD
*)(lpFontInfo
+0x54)) )
1623 *(WORD
*)(lpFontInfo
+0x54) = 0;
1624 GlobalFree16(handle
);
1630 /***********************************************************************
1631 * EngineRealizeFont (GDI.302)
1633 WORD WINAPI
EngineRealizeFont16(LPLOGFONT16 lplogFont
, LPTEXTXFORM16 lptextxform
, LPFONTINFO16 lpfontInfo
)
1635 FIXME("(%p,%p,%p),stub\n",lplogFont
,lptextxform
,lpfontInfo
);
1641 /***********************************************************************
1642 * EngineRealizeFontExt (GDI.315)
1644 WORD WINAPI
EngineRealizeFontExt16(LONG l1
, LONG l2
, LONG l3
, LONG l4
)
1646 FIXME("(%08lx,%08lx,%08lx,%08lx),stub\n",l1
,l2
,l3
,l4
);
1652 /***********************************************************************
1653 * EngineGetCharWidth (GDI.303)
1655 WORD WINAPI
EngineGetCharWidth16(LPFONTINFO16 lpFontInfo
, BYTE firstChar
, BYTE lastChar
, LPINT16 buffer
)
1659 for (i
= firstChar
; i
<= lastChar
; i
++)
1660 FIXME(" returns font's average width for range %d to %d\n", firstChar
, lastChar
);
1661 *buffer
++ = lpFontInfo
->dfAvgWidth
; /* insert some charwidth functionality here; use average width for now */
1666 /***********************************************************************
1667 * EngineSetFontContext (GDI.304)
1669 WORD WINAPI
EngineSetFontContext(LPFONTINFO16 lpFontInfo
, WORD data
)
1675 /***********************************************************************
1676 * EngineGetGlyphBMP (GDI.305)
1678 WORD WINAPI
EngineGetGlyphBMP(WORD word
, LPFONTINFO16 lpFontInfo
, WORD w1
, WORD w2
,
1679 LPSTR string
, DWORD dword
, /*LPBITMAPMETRICS16*/ LPVOID metrics
)
1686 /***********************************************************************
1687 * EngineMakeFontDir (GDI.306)
1689 DWORD WINAPI
EngineMakeFontDir(HDC16 hdc
, LPFONTDIR16 fontdir
, LPCSTR string
)
1691 FIXME(" stub! (always fails)\n");
1692 return ~0UL; /* error */
1696 /***********************************************************************
1697 * GetCharABCWidths (GDI.307)
1699 BOOL16 WINAPI
GetCharABCWidths16( HDC16 hdc
, UINT16 firstChar
, UINT16 lastChar
, LPABC16 abc
)
1703 LPABC abc32
= HeapAlloc( GetProcessHeap(), 0, sizeof(ABC
) * (lastChar
- firstChar
+ 1) );
1705 if ((ret
= GetCharABCWidthsA( HDC_32(hdc
), firstChar
, lastChar
, abc32
)))
1707 for (i
= firstChar
; i
<= lastChar
; i
++)
1709 abc
[i
-firstChar
].abcA
= abc32
[i
-firstChar
].abcA
;
1710 abc
[i
-firstChar
].abcB
= abc32
[i
-firstChar
].abcB
;
1711 abc
[i
-firstChar
].abcC
= abc32
[i
-firstChar
].abcC
;
1714 HeapFree( GetProcessHeap(), 0, abc32
);
1719 /***********************************************************************
1720 * GetGlyphOutline (GDI.309)
1722 DWORD WINAPI
GetGlyphOutline16( HDC16 hdc
, UINT16 uChar
, UINT16 fuFormat
,
1723 LPGLYPHMETRICS16 lpgm
, DWORD cbBuffer
,
1724 LPVOID lpBuffer
, const MAT2
*lpmat2
)
1729 ret
= GetGlyphOutlineA( HDC_32(hdc
), uChar
, fuFormat
, &gm32
, cbBuffer
, lpBuffer
, lpmat2
);
1730 lpgm
->gmBlackBoxX
= gm32
.gmBlackBoxX
;
1731 lpgm
->gmBlackBoxY
= gm32
.gmBlackBoxY
;
1732 lpgm
->gmptGlyphOrigin
.x
= gm32
.gmptGlyphOrigin
.x
;
1733 lpgm
->gmptGlyphOrigin
.y
= gm32
.gmptGlyphOrigin
.y
;
1734 lpgm
->gmCellIncX
= gm32
.gmCellIncX
;
1735 lpgm
->gmCellIncY
= gm32
.gmCellIncY
;
1740 /***********************************************************************
1741 * CreateScalableFontResource (GDI.310)
1743 BOOL16 WINAPI
CreateScalableFontResource16( UINT16 fHidden
, LPCSTR lpszResourceFile
,
1744 LPCSTR fontFile
, LPCSTR path
)
1746 return CreateScalableFontResourceA( fHidden
, lpszResourceFile
, fontFile
, path
);
1750 /*************************************************************************
1751 * GetFontData (GDI.311)
1754 DWORD WINAPI
GetFontData16( HDC16 hdc
, DWORD table
, DWORD offset
, LPVOID buffer
, DWORD count
)
1756 return GetFontData( HDC_32(hdc
), table
, offset
, buffer
, count
);
1760 /*************************************************************************
1761 * GetRasterizerCaps (GDI.313)
1763 BOOL16 WINAPI
GetRasterizerCaps16( LPRASTERIZER_STATUS lprs
, UINT16 cbNumBytes
)
1765 return GetRasterizerCaps( lprs
, cbNumBytes
);
1769 /*************************************************************************
1770 * GetKerningPairs (GDI.332)
1773 INT16 WINAPI
GetKerningPairs16( HDC16 hdc
, INT16 count
, LPKERNINGPAIR16 pairs
)
1775 KERNINGPAIR
*pairs32
;
1778 if (!count
) return 0;
1780 if (!(pairs32
= HeapAlloc( GetProcessHeap(), 0, count
* sizeof(*pairs32
) ))) return 0;
1781 if ((ret
= GetKerningPairsA( HDC_32(hdc
), count
, pairs32
)))
1783 for (i
= 0; i
< ret
; i
++)
1785 pairs
->wFirst
= pairs32
->wFirst
;
1786 pairs
->wSecond
= pairs32
->wSecond
;
1787 pairs
->iKernAmount
= pairs32
->iKernAmount
;
1790 HeapFree( GetProcessHeap(), 0, pairs32
);
1796 /***********************************************************************
1797 * GetTextAlign (GDI.345)
1799 UINT16 WINAPI
GetTextAlign16( HDC16 hdc
)
1801 return GetTextAlign( HDC_32(hdc
) );
1805 /***********************************************************************
1806 * SetTextAlign (GDI.346)
1808 UINT16 WINAPI
SetTextAlign16( HDC16 hdc
, UINT16 align
)
1810 return SetTextAlign( HDC_32(hdc
), align
);
1814 /***********************************************************************
1817 BOOL16 WINAPI
Chord16( HDC16 hdc
, INT16 left
, INT16 top
,
1818 INT16 right
, INT16 bottom
, INT16 xstart
, INT16 ystart
,
1819 INT16 xend
, INT16 yend
)
1821 return Chord( HDC_32(hdc
), left
, top
, right
, bottom
, xstart
, ystart
, xend
, yend
);
1825 /***********************************************************************
1826 * SetMapperFlags (GDI.349)
1828 DWORD WINAPI
SetMapperFlags16( HDC16 hdc
, DWORD flags
)
1830 return SetMapperFlags( HDC_32(hdc
), flags
);
1834 /***********************************************************************
1835 * GetCharWidth (GDI.350)
1837 BOOL16 WINAPI
GetCharWidth16( HDC16 hdc
, UINT16 firstChar
, UINT16 lastChar
, LPINT16 buffer
)
1839 BOOL retVal
= FALSE
;
1841 if( firstChar
!= lastChar
)
1843 LPINT buf32
= HeapAlloc(GetProcessHeap(), 0, sizeof(INT
)*(1 + (lastChar
- firstChar
)));
1846 LPINT obuf32
= buf32
;
1849 retVal
= GetCharWidth32A( HDC_32(hdc
), firstChar
, lastChar
, buf32
);
1852 for (i
= firstChar
; i
<= lastChar
; i
++) *buffer
++ = *buf32
++;
1854 HeapFree(GetProcessHeap(), 0, obuf32
);
1857 else /* happens quite often to warrant a special treatment */
1860 retVal
= GetCharWidth32A( HDC_32(hdc
), firstChar
, lastChar
, &chWidth
);
1867 /***********************************************************************
1868 * ExtTextOut (GDI.351)
1870 BOOL16 WINAPI
ExtTextOut16( HDC16 hdc
, INT16 x
, INT16 y
, UINT16 flags
,
1871 const RECT16
*lprect
, LPCSTR str
, UINT16 count
,
1877 LPINT lpdx32
= NULL
;
1880 lpdx32
= HeapAlloc( GetProcessHeap(),0, sizeof(INT
)*count
);
1881 if(lpdx32
== NULL
) return FALSE
;
1882 for (i
=count
;i
--;) lpdx32
[i
]=lpDx
[i
];
1886 rect32
.left
= lprect
->left
;
1887 rect32
.top
= lprect
->top
;
1888 rect32
.right
= lprect
->right
;
1889 rect32
.bottom
= lprect
->bottom
;
1891 ret
= ExtTextOutA(HDC_32(hdc
),x
,y
,flags
,lprect
?&rect32
:NULL
,str
,count
,lpdx32
);
1892 HeapFree( GetProcessHeap(), 0, lpdx32
);
1897 /***********************************************************************
1898 * CreatePalette (GDI.360)
1900 HPALETTE16 WINAPI
CreatePalette16( const LOGPALETTE
* palette
)
1902 return HPALETTE_16( CreatePalette( palette
) );
1906 /***********************************************************************
1907 * GDISelectPalette (GDI.361)
1909 HPALETTE16 WINAPI
GDISelectPalette16( HDC16 hdc
, HPALETTE16 hpalette
, WORD wBkg
)
1911 return HPALETTE_16( GDISelectPalette( HDC_32(hdc
), HPALETTE_32(hpalette
), wBkg
));
1915 /***********************************************************************
1916 * GDIRealizePalette (GDI.362)
1918 UINT16 WINAPI
GDIRealizePalette16( HDC16 hdc
)
1920 return GDIRealizePalette( HDC_32(hdc
) );
1924 /***********************************************************************
1925 * GetPaletteEntries (GDI.363)
1927 UINT16 WINAPI
GetPaletteEntries16( HPALETTE16 hpalette
, UINT16 start
,
1928 UINT16 count
, LPPALETTEENTRY entries
)
1930 return GetPaletteEntries( HPALETTE_32(hpalette
), start
, count
, entries
);
1934 /***********************************************************************
1935 * SetPaletteEntries (GDI.364)
1937 UINT16 WINAPI
SetPaletteEntries16( HPALETTE16 hpalette
, UINT16 start
,
1938 UINT16 count
, const PALETTEENTRY
*entries
)
1940 return SetPaletteEntries( HPALETTE_32(hpalette
), start
, count
, entries
);
1944 /**********************************************************************
1945 * UpdateColors (GDI.366)
1947 INT16 WINAPI
UpdateColors16( HDC16 hdc
)
1949 UpdateColors( HDC_32(hdc
) );
1954 /***********************************************************************
1955 * AnimatePalette (GDI.367)
1957 void WINAPI
AnimatePalette16( HPALETTE16 hpalette
, UINT16 StartIndex
,
1958 UINT16 NumEntries
, const PALETTEENTRY
* PaletteColors
)
1960 AnimatePalette( HPALETTE_32(hpalette
), StartIndex
, NumEntries
, PaletteColors
);
1964 /***********************************************************************
1965 * ResizePalette (GDI.368)
1967 BOOL16 WINAPI
ResizePalette16( HPALETTE16 hpalette
, UINT16 cEntries
)
1969 return ResizePalette( HPALETTE_32(hpalette
), cEntries
);
1973 /***********************************************************************
1974 * GetNearestPaletteIndex (GDI.370)
1976 UINT16 WINAPI
GetNearestPaletteIndex16( HPALETTE16 hpalette
, COLORREF color
)
1978 return GetNearestPaletteIndex( HPALETTE_32(hpalette
), color
);
1982 /**********************************************************************
1983 * ExtFloodFill (GDI.372)
1985 BOOL16 WINAPI
ExtFloodFill16( HDC16 hdc
, INT16 x
, INT16 y
, COLORREF color
,
1988 return ExtFloodFill( HDC_32(hdc
), x
, y
, color
, fillType
);
1992 /***********************************************************************
1993 * SetSystemPaletteUse (GDI.373)
1995 UINT16 WINAPI
SetSystemPaletteUse16( HDC16 hdc
, UINT16 use
)
1997 return SetSystemPaletteUse( HDC_32(hdc
), use
);
2001 /***********************************************************************
2002 * GetSystemPaletteUse (GDI.374)
2004 UINT16 WINAPI
GetSystemPaletteUse16( HDC16 hdc
)
2006 return GetSystemPaletteUse( HDC_32(hdc
) );
2010 /***********************************************************************
2011 * GetSystemPaletteEntries (GDI.375)
2013 UINT16 WINAPI
GetSystemPaletteEntries16( HDC16 hdc
, UINT16 start
, UINT16 count
,
2014 LPPALETTEENTRY entries
)
2016 return GetSystemPaletteEntries( HDC_32(hdc
), start
, count
, entries
);
2020 /***********************************************************************
2023 HDC16 WINAPI
ResetDC16( HDC16 hdc
, const DEVMODEA
*devmode
)
2025 return HDC_16( ResetDCA(HDC_32(hdc
), devmode
) );
2029 /******************************************************************
2030 * StartDoc (GDI.377)
2032 INT16 WINAPI
StartDoc16( HDC16 hdc
, const DOCINFO16
*lpdoc
)
2036 docA
.cbSize
= lpdoc
->cbSize
;
2037 docA
.lpszDocName
= MapSL(lpdoc
->lpszDocName
);
2038 docA
.lpszOutput
= MapSL(lpdoc
->lpszOutput
);
2039 if(lpdoc
->cbSize
> offsetof(DOCINFO16
,lpszDatatype
))
2040 docA
.lpszDatatype
= MapSL(lpdoc
->lpszDatatype
);
2042 docA
.lpszDatatype
= NULL
;
2043 if(lpdoc
->cbSize
> offsetof(DOCINFO16
,fwType
))
2044 docA
.fwType
= lpdoc
->fwType
;
2047 return StartDocA( HDC_32(hdc
), &docA
);
2051 /******************************************************************
2054 INT16 WINAPI
EndDoc16( HDC16 hdc
)
2056 return EndDoc( HDC_32(hdc
) );
2060 /******************************************************************
2061 * StartPage (GDI.379)
2063 INT16 WINAPI
StartPage16( HDC16 hdc
)
2065 return StartPage( HDC_32(hdc
) );
2069 /******************************************************************
2072 INT16 WINAPI
EndPage16( HDC16 hdc
)
2074 return EndPage( HDC_32(hdc
) );
2078 /******************************************************************************
2079 * AbortDoc (GDI.382)
2081 INT16 WINAPI
AbortDoc16( HDC16 hdc
)
2083 return AbortDoc( HDC_32(hdc
) );
2087 /***********************************************************************
2088 * FastWindowFrame (GDI.400)
2090 BOOL16 WINAPI
FastWindowFrame16( HDC16 hdc
, const RECT16
*rect
,
2091 INT16 width
, INT16 height
, DWORD rop
)
2093 HDC hdc32
= HDC_32(hdc
);
2094 HBRUSH hbrush
= SelectObject( hdc32
, GetStockObject( GRAY_BRUSH
) );
2095 PatBlt( hdc32
, rect
->left
, rect
->top
,
2096 rect
->right
- rect
->left
- width
, height
, rop
);
2097 PatBlt( hdc32
, rect
->left
, rect
->top
+ height
, width
,
2098 rect
->bottom
- rect
->top
- height
, rop
);
2099 PatBlt( hdc32
, rect
->left
+ width
, rect
->bottom
- 1,
2100 rect
->right
- rect
->left
- width
, -height
, rop
);
2101 PatBlt( hdc32
, rect
->right
- 1, rect
->top
, -width
,
2102 rect
->bottom
- rect
->top
- height
, rop
);
2103 SelectObject( hdc32
, hbrush
);
2108 /***********************************************************************
2109 * CreateUserBitmap (GDI.407)
2111 HBITMAP16 WINAPI
CreateUserBitmap16( INT16 width
, INT16 height
, UINT16 planes
,
2112 UINT16 bpp
, LPCVOID bits
)
2114 return CreateBitmap16( width
, height
, planes
, bpp
, bits
);
2118 /***********************************************************************
2119 * CreateUserDiscardableBitmap (GDI.409)
2121 HBITMAP16 WINAPI
CreateUserDiscardableBitmap16( WORD dummy
, INT16 width
, INT16 height
)
2123 HDC hdc
= CreateDCA( "DISPLAY", NULL
, NULL
, NULL
);
2124 HBITMAP ret
= CreateCompatibleBitmap( hdc
, width
, height
);
2126 return HBITMAP_16(ret
);
2130 /***********************************************************************
2131 * GetCurLogFont (GDI.411)
2133 HFONT16 WINAPI
GetCurLogFont16( HDC16 hdc
)
2135 return HFONT_16( GetCurrentObject( HDC_32(hdc
), OBJ_FONT
) );
2139 /***********************************************************************
2140 * StretchDIBits (GDI.439)
2142 INT16 WINAPI
StretchDIBits16( HDC16 hdc
, INT16 xDst
, INT16 yDst
, INT16 widthDst
,
2143 INT16 heightDst
, INT16 xSrc
, INT16 ySrc
, INT16 widthSrc
,
2144 INT16 heightSrc
, const VOID
*bits
,
2145 const BITMAPINFO
*info
, UINT16 wUsage
, DWORD dwRop
)
2147 return StretchDIBits( HDC_32(hdc
), xDst
, yDst
, widthDst
, heightDst
,
2148 xSrc
, ySrc
, widthSrc
, heightSrc
, bits
,
2149 info
, wUsage
, dwRop
);
2153 /***********************************************************************
2154 * SetDIBits (GDI.440)
2156 INT16 WINAPI
SetDIBits16( HDC16 hdc
, HBITMAP16 hbitmap
, UINT16 startscan
,
2157 UINT16 lines
, LPCVOID bits
, const BITMAPINFO
*info
,
2160 return SetDIBits( HDC_32(hdc
), HBITMAP_32(hbitmap
), startscan
, lines
, bits
, info
, coloruse
);
2164 /***********************************************************************
2165 * GetDIBits (GDI.441)
2167 INT16 WINAPI
GetDIBits16( HDC16 hdc
, HBITMAP16 hbitmap
, UINT16 startscan
,
2168 UINT16 lines
, LPVOID bits
, BITMAPINFO
* info
,
2171 return GetDIBits( HDC_32(hdc
), HBITMAP_32(hbitmap
), startscan
, lines
, bits
, info
, coloruse
);
2175 /***********************************************************************
2176 * CreateDIBitmap (GDI.442)
2178 HBITMAP16 WINAPI
CreateDIBitmap16( HDC16 hdc
, const BITMAPINFOHEADER
* header
,
2179 DWORD init
, LPCVOID bits
, const BITMAPINFO
* data
,
2182 return HBITMAP_16( CreateDIBitmap( HDC_32(hdc
), header
, init
, bits
, data
, coloruse
) );
2186 /***********************************************************************
2187 * SetDIBitsToDevice (GDI.443)
2189 INT16 WINAPI
SetDIBitsToDevice16( HDC16 hdc
, INT16 xDest
, INT16 yDest
, INT16 cx
,
2190 INT16 cy
, INT16 xSrc
, INT16 ySrc
, UINT16 startscan
,
2191 UINT16 lines
, LPCVOID bits
, const BITMAPINFO
*info
,
2194 return SetDIBitsToDevice( HDC_32(hdc
), xDest
, yDest
, cx
, cy
, xSrc
, ySrc
,
2195 startscan
, lines
, bits
, info
, coloruse
);
2199 /***********************************************************************
2200 * CreateRoundRectRgn (GDI.444)
2202 * If either ellipse dimension is zero we call CreateRectRgn16 for its
2203 * `special' behaviour. -ve ellipse dimensions can result in GPFs under win3.1
2204 * we just let CreateRoundRectRgn convert them to +ve values.
2207 HRGN16 WINAPI
CreateRoundRectRgn16( INT16 left
, INT16 top
, INT16 right
, INT16 bottom
,
2208 INT16 ellipse_width
, INT16 ellipse_height
)
2210 if( ellipse_width
== 0 || ellipse_height
== 0 )
2211 return CreateRectRgn16( left
, top
, right
, bottom
);
2213 return HRGN_16( CreateRoundRectRgn( left
, top
, right
, bottom
,
2214 ellipse_width
, ellipse_height
));
2218 /***********************************************************************
2219 * CreateDIBPatternBrush (GDI.445)
2221 HBRUSH16 WINAPI
CreateDIBPatternBrush16( HGLOBAL16 hbitmap
, UINT16 coloruse
)
2226 if (!(bmi
= GlobalLock16( hbitmap
))) return 0;
2227 ret
= HBRUSH_16( CreateDIBPatternBrushPt( bmi
, coloruse
));
2228 GlobalUnlock16( hbitmap
);
2233 /**********************************************************************
2234 * PolyPolygon (GDI.450)
2236 BOOL16 WINAPI
PolyPolygon16( HDC16 hdc
, const POINT16
* pt
, const INT16
* counts
,
2245 for (i
=polygons
;i
--;)
2247 pt32
= HeapAlloc( GetProcessHeap(), 0, sizeof(POINT
)*nrpts
);
2248 if(pt32
== NULL
) return FALSE
;
2251 pt32
[i
].x
= pt
[i
].x
;
2252 pt32
[i
].y
= pt
[i
].y
;
2254 counts32
= HeapAlloc( GetProcessHeap(), 0, polygons
*sizeof(INT
) );
2255 if(counts32
== NULL
) {
2256 HeapFree( GetProcessHeap(), 0, pt32
);
2259 for (i
=polygons
;i
--;) counts32
[i
]=counts
[i
];
2261 ret
= PolyPolygon(HDC_32(hdc
),pt32
,counts32
,polygons
);
2262 HeapFree( GetProcessHeap(), 0, counts32
);
2263 HeapFree( GetProcessHeap(), 0, pt32
);
2268 /***********************************************************************
2269 * CreatePolyPolygonRgn (GDI.451)
2271 HRGN16 WINAPI
CreatePolyPolygonRgn16( const POINT16
*points
,
2272 const INT16
*count
, INT16 nbpolygons
, INT16 mode
)
2279 for (i
= 0; i
< nbpolygons
; i
++) npts
+= count
[i
];
2280 points32
= HeapAlloc( GetProcessHeap(), 0, npts
* sizeof(POINT
) );
2281 for (i
= 0; i
< npts
; i
++)
2283 points32
[i
].x
= points
[i
].x
;
2284 points32
[i
].y
= points
[i
].y
;
2287 count32
= HeapAlloc( GetProcessHeap(), 0, nbpolygons
* sizeof(INT
) );
2288 for (i
= 0; i
< nbpolygons
; i
++) count32
[i
] = count
[i
];
2289 hrgn
= CreatePolyPolygonRgn( points32
, count32
, nbpolygons
, mode
);
2290 HeapFree( GetProcessHeap(), 0, count32
);
2291 HeapFree( GetProcessHeap(), 0, points32
);
2292 return HRGN_16(hrgn
);
2296 /***********************************************************************
2297 * SetObjectOwner (GDI.461)
2299 void WINAPI
SetObjectOwner16( HGDIOBJ16 handle
, HANDLE16 owner
)
2305 /***********************************************************************
2306 * RectVisible (GDI.465)
2307 * RectVisibleOld (GDI.104)
2309 BOOL16 WINAPI
RectVisible16( HDC16 hdc
, const RECT16
* rect16
)
2313 rect
.left
= rect16
->left
;
2314 rect
.top
= rect16
->top
;
2315 rect
.right
= rect16
->right
;
2316 rect
.bottom
= rect16
->bottom
;
2317 return RectVisible( HDC_32(hdc
), &rect
);
2321 /***********************************************************************
2322 * RectInRegion (GDI.466)
2323 * RectInRegionOld (GDI.181)
2325 BOOL16 WINAPI
RectInRegion16( HRGN16 hrgn
, const RECT16
*rect
)
2329 r32
.left
= rect
->left
;
2330 r32
.top
= rect
->top
;
2331 r32
.right
= rect
->right
;
2332 r32
.bottom
= rect
->bottom
;
2333 return RectInRegion( HRGN_32(hrgn
), &r32
);
2337 /***********************************************************************
2338 * GetBitmapDimensionEx (GDI.468)
2340 BOOL16 WINAPI
GetBitmapDimensionEx16( HBITMAP16 hbitmap
, LPSIZE16 size
)
2343 BOOL ret
= GetBitmapDimensionEx( HBITMAP_32(hbitmap
), &size32
);
2347 size
->cx
= size32
.cx
;
2348 size
->cy
= size32
.cy
;
2354 /***********************************************************************
2355 * GetBrushOrgEx (GDI.469)
2357 BOOL16 WINAPI
GetBrushOrgEx16( HDC16 hdc
, LPPOINT16 pt
)
2360 if (!GetBrushOrgEx( HDC_32(hdc
), &pt32
)) return FALSE
;
2367 /***********************************************************************
2368 * GetCurrentPositionEx (GDI.470)
2370 BOOL16 WINAPI
GetCurrentPositionEx16( HDC16 hdc
, LPPOINT16 pt
)
2373 if (!GetCurrentPositionEx( HDC_32(hdc
), &pt32
)) return FALSE
;
2380 /***********************************************************************
2381 * GetTextExtentPoint (GDI.471)
2383 * FIXME: Should this have a bug for compatibility?
2384 * Original Windows versions of GetTextExtentPoint{A,W} have documented
2385 * bugs (-> MSDN KB q147647.txt).
2387 BOOL16 WINAPI
GetTextExtentPoint16( HDC16 hdc
, LPCSTR str
, INT16 count
, LPSIZE16 size
)
2390 BOOL ret
= GetTextExtentPoint32A( HDC_32(hdc
), str
, count
, &size32
);
2394 size
->cx
= size32
.cx
;
2395 size
->cy
= size32
.cy
;
2401 /***********************************************************************
2402 * GetViewportExtEx (GDI.472)
2404 BOOL16 WINAPI
GetViewportExtEx16( HDC16 hdc
, LPSIZE16 size
)
2407 if (!GetViewportExtEx( HDC_32(hdc
), &size32
)) return FALSE
;
2408 size
->cx
= size32
.cx
;
2409 size
->cy
= size32
.cy
;
2414 /***********************************************************************
2415 * GetViewportOrgEx (GDI.473)
2417 BOOL16 WINAPI
GetViewportOrgEx16( HDC16 hdc
, LPPOINT16 pt
)
2420 if (!GetViewportOrgEx( HDC_32(hdc
), &pt32
)) return FALSE
;
2427 /***********************************************************************
2428 * GetWindowExtEx (GDI.474)
2430 BOOL16 WINAPI
GetWindowExtEx16( HDC16 hdc
, LPSIZE16 size
)
2433 if (!GetWindowExtEx( HDC_32(hdc
), &size32
)) return FALSE
;
2434 size
->cx
= size32
.cx
;
2435 size
->cy
= size32
.cy
;
2440 /***********************************************************************
2441 * GetWindowOrgEx (GDI.475)
2443 BOOL16 WINAPI
GetWindowOrgEx16( HDC16 hdc
, LPPOINT16 pt
)
2446 if (!GetWindowOrgEx( HDC_32(hdc
), &pt32
)) return FALSE
;
2453 /***********************************************************************
2454 * OffsetViewportOrgEx (GDI.476)
2456 BOOL16 WINAPI
OffsetViewportOrgEx16( HDC16 hdc
, INT16 x
, INT16 y
, LPPOINT16 pt
)
2459 BOOL16 ret
= OffsetViewportOrgEx( HDC_32(hdc
), x
, y
, &pt32
);
2469 /***********************************************************************
2470 * OffsetWindowOrgEx (GDI.477)
2472 BOOL16 WINAPI
OffsetWindowOrgEx16( HDC16 hdc
, INT16 x
, INT16 y
, LPPOINT16 pt
)
2475 BOOL16 ret
= OffsetWindowOrgEx( HDC_32(hdc
), x
, y
, &pt32
);
2485 /***********************************************************************
2486 * SetBitmapDimensionEx (GDI.478)
2488 BOOL16 WINAPI
SetBitmapDimensionEx16( HBITMAP16 hbitmap
, INT16 x
, INT16 y
, LPSIZE16 prevSize
)
2491 BOOL ret
= SetBitmapDimensionEx( HBITMAP_32(hbitmap
), x
, y
, &size32
);
2493 if (ret
&& prevSize
)
2495 prevSize
->cx
= size32
.cx
;
2496 prevSize
->cy
= size32
.cy
;
2502 /***********************************************************************
2503 * SetViewportExtEx (GDI.479)
2505 BOOL16 WINAPI
SetViewportExtEx16( HDC16 hdc
, INT16 x
, INT16 y
, LPSIZE16 size
)
2508 BOOL16 ret
= SetViewportExtEx( HDC_32(hdc
), x
, y
, &size32
);
2509 if (size
) { size
->cx
= size32
.cx
; size
->cy
= size32
.cy
; }
2514 /***********************************************************************
2515 * SetViewportOrgEx (GDI.480)
2517 BOOL16 WINAPI
SetViewportOrgEx16( HDC16 hdc
, INT16 x
, INT16 y
, LPPOINT16 pt
)
2520 BOOL16 ret
= SetViewportOrgEx( HDC_32(hdc
), x
, y
, &pt32
);
2530 /***********************************************************************
2531 * SetWindowExtEx (GDI.481)
2533 BOOL16 WINAPI
SetWindowExtEx16( HDC16 hdc
, INT16 x
, INT16 y
, LPSIZE16 size
)
2536 BOOL16 ret
= SetWindowExtEx( HDC_32(hdc
), x
, y
, &size32
);
2537 if (size
) { size
->cx
= size32
.cx
; size
->cy
= size32
.cy
; }
2542 /***********************************************************************
2543 * SetWindowOrgEx (GDI.482)
2545 BOOL16 WINAPI
SetWindowOrgEx16( HDC16 hdc
, INT16 x
, INT16 y
, LPPOINT16 pt
)
2548 BOOL16 ret
= SetWindowOrgEx( HDC_32(hdc
), x
, y
, &pt32
);
2558 /***********************************************************************
2559 * MoveToEx (GDI.483)
2561 BOOL16 WINAPI
MoveToEx16( HDC16 hdc
, INT16 x
, INT16 y
, LPPOINT16 pt
)
2565 if (!MoveToEx( HDC_32(hdc
), x
, y
, &pt32
)) return FALSE
;
2575 /***********************************************************************
2576 * ScaleViewportExtEx (GDI.484)
2578 BOOL16 WINAPI
ScaleViewportExtEx16( HDC16 hdc
, INT16 xNum
, INT16 xDenom
,
2579 INT16 yNum
, INT16 yDenom
, LPSIZE16 size
)
2582 BOOL16 ret
= ScaleViewportExtEx( HDC_32(hdc
), xNum
, xDenom
, yNum
, yDenom
,
2584 if (size
) { size
->cx
= size32
.cx
; size
->cy
= size32
.cy
; }
2589 /***********************************************************************
2590 * ScaleWindowExtEx (GDI.485)
2592 BOOL16 WINAPI
ScaleWindowExtEx16( HDC16 hdc
, INT16 xNum
, INT16 xDenom
,
2593 INT16 yNum
, INT16 yDenom
, LPSIZE16 size
)
2596 BOOL16 ret
= ScaleWindowExtEx( HDC_32(hdc
), xNum
, xDenom
, yNum
, yDenom
,
2598 if (size
) { size
->cx
= size32
.cx
; size
->cy
= size32
.cy
; }
2603 /******************************************************************************
2604 * PolyBezier (GDI.502)
2606 BOOL16 WINAPI
PolyBezier16( HDC16 hdc
, const POINT16
* lppt
, INT16 cPoints
)
2610 LPPOINT pt32
= HeapAlloc( GetProcessHeap(), 0, cPoints
*sizeof(POINT
) );
2611 if(!pt32
) return FALSE
;
2612 for (i
=cPoints
;i
--;)
2614 pt32
[i
].x
= lppt
[i
].x
;
2615 pt32
[i
].y
= lppt
[i
].y
;
2617 ret
= PolyBezier(HDC_32(hdc
), pt32
, cPoints
);
2618 HeapFree( GetProcessHeap(), 0, pt32
);
2623 /******************************************************************************
2624 * PolyBezierTo (GDI.503)
2626 BOOL16 WINAPI
PolyBezierTo16( HDC16 hdc
, const POINT16
* lppt
, INT16 cPoints
)
2630 LPPOINT pt32
= HeapAlloc( GetProcessHeap(), 0,
2631 cPoints
*sizeof(POINT
) );
2632 if(!pt32
) return FALSE
;
2633 for (i
=cPoints
;i
--;)
2635 pt32
[i
].x
= lppt
[i
].x
;
2636 pt32
[i
].y
= lppt
[i
].y
;
2638 ret
= PolyBezierTo(HDC_32(hdc
), pt32
, cPoints
);
2639 HeapFree( GetProcessHeap(), 0, pt32
);
2644 /******************************************************************************
2645 * ExtSelectClipRgn (GDI.508)
2647 INT16 WINAPI
ExtSelectClipRgn16( HDC16 hdc
, HRGN16 hrgn
, INT16 fnMode
)
2649 return ExtSelectClipRgn( HDC_32(hdc
), HRGN_32(hrgn
), fnMode
);
2653 /***********************************************************************
2654 * AbortPath (GDI.511)
2656 BOOL16 WINAPI
AbortPath16(HDC16 hdc
)
2658 return AbortPath( HDC_32(hdc
) );
2662 /***********************************************************************
2663 * BeginPath (GDI.512)
2665 BOOL16 WINAPI
BeginPath16(HDC16 hdc
)
2667 return BeginPath( HDC_32(hdc
) );
2671 /***********************************************************************
2672 * CloseFigure (GDI.513)
2674 BOOL16 WINAPI
CloseFigure16(HDC16 hdc
)
2676 return CloseFigure( HDC_32(hdc
) );
2680 /***********************************************************************
2683 BOOL16 WINAPI
EndPath16(HDC16 hdc
)
2685 return EndPath( HDC_32(hdc
) );
2689 /***********************************************************************
2690 * FillPath (GDI.515)
2692 BOOL16 WINAPI
FillPath16(HDC16 hdc
)
2694 return FillPath( HDC_32(hdc
) );
2698 /*******************************************************************
2699 * FlattenPath (GDI.516)
2701 BOOL16 WINAPI
FlattenPath16(HDC16 hdc
)
2703 return FlattenPath( HDC_32(hdc
) );
2707 /***********************************************************************
2710 INT16 WINAPI
GetPath16(HDC16 hdc
, LPPOINT16 pPoints
, LPBYTE pTypes
, INT16 nSize
)
2712 FIXME("(%d,%p,%p): stub\n",hdc
,pPoints
,pTypes
);
2717 /***********************************************************************
2718 * PathToRegion (GDI.518)
2720 HRGN16 WINAPI
PathToRegion16(HDC16 hdc
)
2722 return HRGN_16( PathToRegion( HDC_32(hdc
) ));
2726 /***********************************************************************
2727 * SelectClipPath (GDI.519)
2729 BOOL16 WINAPI
SelectClipPath16(HDC16 hdc
, INT16 iMode
)
2731 return SelectClipPath( HDC_32(hdc
), iMode
);
2735 /*******************************************************************
2736 * StrokeAndFillPath (GDI.520)
2738 BOOL16 WINAPI
StrokeAndFillPath16(HDC16 hdc
)
2740 return StrokeAndFillPath( HDC_32(hdc
) );
2744 /*******************************************************************
2745 * StrokePath (GDI.521)
2747 BOOL16 WINAPI
StrokePath16(HDC16 hdc
)
2749 return StrokePath( HDC_32(hdc
) );
2753 /*******************************************************************
2754 * WidenPath (GDI.522)
2756 BOOL16 WINAPI
WidenPath16(HDC16 hdc
)
2758 return WidenPath( HDC_32(hdc
) );
2762 /***********************************************************************
2763 * GetArcDirection (GDI.524)
2765 INT16 WINAPI
GetArcDirection16( HDC16 hdc
)
2767 return GetArcDirection( HDC_32(hdc
) );
2771 /***********************************************************************
2772 * SetArcDirection (GDI.525)
2774 INT16 WINAPI
SetArcDirection16( HDC16 hdc
, INT16 nDirection
)
2776 return SetArcDirection( HDC_32(hdc
), (INT
)nDirection
);
2780 /***********************************************************************
2781 * CreateHalftonePalette (GDI.529)
2783 HPALETTE16 WINAPI
CreateHalftonePalette16( HDC16 hdc
)
2785 return HPALETTE_16( CreateHalftonePalette( HDC_32(hdc
) ));
2789 /***********************************************************************
2790 * SetDIBColorTable (GDI.602)
2792 UINT16 WINAPI
SetDIBColorTable16( HDC16 hdc
, UINT16 startpos
, UINT16 entries
, RGBQUAD
*colors
)
2794 return SetDIBColorTable( HDC_32(hdc
), startpos
, entries
, colors
);
2798 /***********************************************************************
2799 * GetDIBColorTable (GDI.603)
2801 UINT16 WINAPI
GetDIBColorTable16( HDC16 hdc
, UINT16 startpos
, UINT16 entries
, RGBQUAD
*colors
)
2803 return GetDIBColorTable( HDC_32(hdc
), startpos
, entries
, colors
);
2807 /***********************************************************************
2808 * GetRegionData (GDI.607)
2810 * FIXME: is LPRGNDATA the same in Win16 and Win32 ?
2812 DWORD WINAPI
GetRegionData16( HRGN16 hrgn
, DWORD count
, LPRGNDATA rgndata
)
2814 return GetRegionData( HRGN_32(hrgn
), count
, rgndata
);
2818 /***********************************************************************
2819 * GetTextCharset (GDI.612)
2821 UINT16 WINAPI
GetTextCharset16( HDC16 hdc
)
2823 return GetTextCharset( HDC_32(hdc
) );
2827 /*************************************************************************
2828 * GetFontLanguageInfo (GDI.616)
2830 DWORD WINAPI
GetFontLanguageInfo16( HDC16 hdc
)
2832 return GetFontLanguageInfo( HDC_32(hdc
) );
2836 /***********************************************************************
2837 * SetLayout (GDI.1000)
2839 * Sets left->right or right->left text layout flags of a dc.
2841 BOOL16 WINAPI
SetLayout16( HDC16 hdc
, DWORD layout
)
2843 return SetLayout( HDC_32(hdc
), layout
);