git.oblomov.eu Git - wine/blob - dlls/gdi/gdi16.c

   1 /*
   2  * GDI 16-bit functions
   3  *
   4  * Copyright 2002 Alexandre Julliard
   5  *
   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.
  10  *
  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.
  15  *
  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
  19  */
  20
  21 #include <stdarg.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "wingdi.h"
  26 #include "wownt32.h"
  27 #include "wine/wingdi16.h"
  28 #include "gdi.h"
  29 #include "gdi_private.h"
  30 #include "wine/debug.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(gdi);
  33
  34 #define HGDIOBJ_32(handle16)    ((HGDIOBJ)(ULONG_PTR)(handle16))
  35 #define HGDIOBJ_16(handle32)    ((HGDIOBJ16)(ULONG_PTR)(handle32))
  36
  37 struct callback16_info
  38 {
  39     FARPROC16 proc;
  40     LPARAM    param;
  41 };
  42
  43 /* callback for LineDDA16 */
  44 static void CALLBACK linedda_callback( INT x, INT y, LPARAM param )
  45 {
  46     const struct callback16_info *info = (struct callback16_info *)param;
  47     WORD args[4];
  48
  49     args[3] = x;
  50     args[2] = y;
  51     args[1] = HIWORD(info->param);
  52     args[0] = LOWORD(info->param);
  53     WOWCallback16Ex( (DWORD)info->proc, WCB16_PASCAL, sizeof(args), args, NULL );
  54 }
  55
  56 /* callback for EnumObjects16 */
  57 static INT CALLBACK enum_pens_callback( void *ptr, LPARAM param )
  58 {
  59     const struct callback16_info *info = (struct callback16_info *)param;
  60     LOGPEN *pen = ptr;
  61     LOGPEN16 pen16;
  62     SEGPTR segptr;
  63     DWORD ret;
  64     WORD args[4];
  65
  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 );
  76     UnMapLS( segptr );
  77     return LOWORD(ret);
  78 }
  79
  80 /* callback for EnumObjects16 */
  81 static INT CALLBACK enum_brushes_callback( void *ptr, LPARAM param )
  82 {
  83     const struct callback16_info *info = (struct callback16_info *)param;
  84     LOGBRUSH *brush = ptr;
  85     LOGBRUSH16 brush16;
  86     SEGPTR segptr;
  87     DWORD ret;
  88     WORD args[4];
  89
  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 );
  99     UnMapLS( segptr );
 100     return ret;
 101 }
 102
 103 /* convert a LOGFONT16 to a LOGFONTW */
 104 static void logfont_16_to_W( const LOGFONT16 *font16, LPLOGFONTW font32 )
 105 {
 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;
 121 }
 122
 123
 124 /***********************************************************************
 125  *           SetBkColor    (GDI.1)
 126  */
 127 COLORREF WINAPI SetBkColor16( HDC16 hdc, COLORREF color )
 128 {
 129     return SetBkColor( HDC_32(hdc), color );
 130 }
 131
 132
 133 /***********************************************************************
 134  *              SetBkMode (GDI.2)
 135  */
 136 INT16 WINAPI SetBkMode16( HDC16 hdc, INT16 mode )
 137 {
 138     return SetBkMode( HDC_32(hdc), mode );
 139 }
 140
 141
 142 /***********************************************************************
 143  *           SetMapMode    (GDI.3)
 144  */
 145 INT16 WINAPI SetMapMode16( HDC16 hdc, INT16 mode )
 146 {
 147     return SetMapMode( HDC_32(hdc), mode );
 148 }
 149
 150
 151 /***********************************************************************
 152  *              SetROP2 (GDI.4)
 153  */
 154 INT16 WINAPI SetROP216( HDC16 hdc, INT16 mode )
 155 {
 156     return SetROP2( HDC_32(hdc), mode );
 157 }
 158
 159
 160 /***********************************************************************
 161  *              SetRelAbs (GDI.5)
 162  */
 163 INT16 WINAPI SetRelAbs16( HDC16 hdc, INT16 mode )
 164 {
 165     return SetRelAbs( HDC_32(hdc), mode );
 166 }
 167
 168
 169 /***********************************************************************
 170  *              SetPolyFillMode (GDI.6)
 171  */
 172 INT16 WINAPI SetPolyFillMode16( HDC16 hdc, INT16 mode )
 173 {
 174     return SetPolyFillMode( HDC_32(hdc), mode );
 175 }
 176
 177
 178 /***********************************************************************
 179  *              SetStretchBltMode (GDI.7)
 180  */
 181 INT16 WINAPI SetStretchBltMode16( HDC16 hdc, INT16 mode )
 182 {
 183     return SetStretchBltMode( HDC_32(hdc), mode );
 184 }
 185
 186
 187 /***********************************************************************
 188  *           SetTextCharacterExtra    (GDI.8)
 189  */
 190 INT16 WINAPI SetTextCharacterExtra16( HDC16 hdc, INT16 extra )
 191 {
 192     return SetTextCharacterExtra( HDC_32(hdc), extra );
 193 }
 194
 195
 196 /***********************************************************************
 197  *           SetTextColor    (GDI.9)
 198  */
 199 COLORREF WINAPI SetTextColor16( HDC16 hdc, COLORREF color )
 200 {
 201     return SetTextColor( HDC_32(hdc), color );
 202 }
 203
 204
 205 /***********************************************************************
 206  *           SetTextJustification    (GDI.10)
 207  */
 208 INT16 WINAPI SetTextJustification16( HDC16 hdc, INT16 extra, INT16 breaks )
 209 {
 210     return SetTextJustification( HDC_32(hdc), extra, breaks );
 211 }
 212
 213
 214 /***********************************************************************
 215  *           SetWindowOrg    (GDI.11)
 216  */
 217 DWORD WINAPI SetWindowOrg16( HDC16 hdc, INT16 x, INT16 y )
 218 {
 219     POINT pt;
 220     if (!SetWindowOrgEx( HDC_32(hdc), x, y, &pt )) return 0;
 221     return MAKELONG( pt.x, pt.y );
 222 }
 223
 224
 225 /***********************************************************************
 226  *           SetWindowExt    (GDI.12)
 227  */
 228 DWORD WINAPI SetWindowExt16( HDC16 hdc, INT16 x, INT16 y )
 229 {
 230     SIZE size;
 231     if (!SetWindowExtEx( HDC_32(hdc), x, y, &size )) return 0;
 232     return MAKELONG( size.cx, size.cy );
 233 }
 234
 235
 236 /***********************************************************************
 237  *           SetViewportOrg    (GDI.13)
 238  */
 239 DWORD WINAPI SetViewportOrg16( HDC16 hdc, INT16 x, INT16 y )
 240 {
 241     POINT pt;
 242     if (!SetViewportOrgEx( HDC_32(hdc), x, y, &pt )) return 0;
 243     return MAKELONG( pt.x, pt.y );
 244 }
 245
 246
 247 /***********************************************************************
 248  *           SetViewportExt    (GDI.14)
 249  */
 250 DWORD WINAPI SetViewportExt16( HDC16 hdc, INT16 x, INT16 y )
 251 {
 252     SIZE size;
 253     if (!SetViewportExtEx( HDC_32(hdc), x, y, &size )) return 0;
 254     return MAKELONG( size.cx, size.cy );
 255 }
 256
 257
 258 /***********************************************************************
 259  *           OffsetWindowOrg    (GDI.15)
 260  */
 261 DWORD WINAPI OffsetWindowOrg16( HDC16 hdc, INT16 x, INT16 y )
 262 {
 263     POINT pt;
 264     if (!OffsetWindowOrgEx( HDC_32(hdc), x, y, &pt )) return 0;
 265     return MAKELONG( pt.x, pt.y );
 266 }
 267
 268
 269 /***********************************************************************
 270  *           ScaleWindowExt    (GDI.16)
 271  */
 272 DWORD WINAPI ScaleWindowExt16( HDC16 hdc, INT16 xNum, INT16 xDenom,
 273                              INT16 yNum, INT16 yDenom )
 274 {
 275     SIZE size;
 276     if (!ScaleWindowExtEx( HDC_32(hdc), xNum, xDenom, yNum, yDenom, &size ))
 277         return FALSE;
 278     return MAKELONG( size.cx,  size.cy );
 279 }
 280
 281
 282 /***********************************************************************
 283  *           OffsetViewportOrg    (GDI.17)
 284  */
 285 DWORD WINAPI OffsetViewportOrg16( HDC16 hdc, INT16 x, INT16 y )
 286 {
 287     POINT pt;
 288     if (!OffsetViewportOrgEx( HDC_32(hdc), x, y, &pt )) return 0;
 289     return MAKELONG( pt.x, pt.y );
 290 }
 291
 292
 293 /***********************************************************************
 294  *           ScaleViewportExt    (GDI.18)
 295  */
 296 DWORD WINAPI ScaleViewportExt16( HDC16 hdc, INT16 xNum, INT16 xDenom,
 297                                INT16 yNum, INT16 yDenom )
 298 {
 299     SIZE size;
 300     if (!ScaleViewportExtEx( HDC_32(hdc), xNum, xDenom, yNum, yDenom, &size ))
 301         return FALSE;
 302     return MAKELONG( size.cx,  size.cy );
 303 }
 304
 305
 306 /***********************************************************************
 307  *           LineTo    (GDI.19)
 308  */
 309 BOOL16 WINAPI LineTo16( HDC16 hdc, INT16 x, INT16 y )
 310 {
 311     return LineTo( HDC_32(hdc), x, y );
 312 }
 313
 314
 315 /***********************************************************************
 316  *           MoveTo    (GDI.20)
 317  */
 318 DWORD WINAPI MoveTo16( HDC16 hdc, INT16 x, INT16 y )
 319 {
 320     POINT pt;
 321
 322     if (!MoveToEx( HDC_32(hdc), x, y, &pt )) return 0;
 323     return MAKELONG(pt.x,pt.y);
 324 }
 325
 326
 327 /***********************************************************************
 328  *           ExcludeClipRect    (GDI.21)
 329  */
 330 INT16 WINAPI ExcludeClipRect16( HDC16 hdc, INT16 left, INT16 top,
 331                                 INT16 right, INT16 bottom )
 332 {
 333     return ExcludeClipRect( HDC_32(hdc), left, top, right, bottom );
 334 }
 335
 336
 337 /***********************************************************************
 338  *           IntersectClipRect    (GDI.22)
 339  */
 340 INT16 WINAPI IntersectClipRect16( HDC16 hdc, INT16 left, INT16 top,
 341                                   INT16 right, INT16 bottom )
 342 {
 343     return IntersectClipRect( HDC_32(hdc), left, top, right, bottom );
 344 }
 345
 346
 347 /***********************************************************************
 348  *           Arc    (GDI.23)
 349  */
 350 BOOL16 WINAPI Arc16( HDC16 hdc, INT16 left, INT16 top, INT16 right,
 351                      INT16 bottom, INT16 xstart, INT16 ystart,
 352                      INT16 xend, INT16 yend )
 353 {
 354     return Arc( HDC_32(hdc), left, top, right, bottom, xstart, ystart, xend, yend );
 355 }
 356
 357
 358 /***********************************************************************
 359  *           Ellipse    (GDI.24)
 360  */
 361 BOOL16 WINAPI Ellipse16( HDC16 hdc, INT16 left, INT16 top,
 362                          INT16 right, INT16 bottom )
 363 {
 364     return Ellipse( HDC_32(hdc), left, top, right, bottom );
 365 }
 366
 367
 368 /**********************************************************************
 369  *          FloodFill   (GDI.25)
 370  */
 371 BOOL16 WINAPI FloodFill16( HDC16 hdc, INT16 x, INT16 y, COLORREF color )
 372 {
 373     return ExtFloodFill( HDC_32(hdc), x, y, color, FLOODFILLBORDER );
 374 }
 375
 376
 377 /***********************************************************************
 378  *           Pie    (GDI.26)
 379  */
 380 BOOL16 WINAPI Pie16( HDC16 hdc, INT16 left, INT16 top,
 381                      INT16 right, INT16 bottom, INT16 xstart, INT16 ystart,
 382                      INT16 xend, INT16 yend )
 383 {
 384     return Pie( HDC_32(hdc), left, top, right, bottom, xstart, ystart, xend, yend );
 385 }
 386
 387
 388 /***********************************************************************
 389  *           Rectangle    (GDI.27)
 390  */
 391 BOOL16 WINAPI Rectangle16( HDC16 hdc, INT16 left, INT16 top,
 392                            INT16 right, INT16 bottom )
 393 {
 394     return Rectangle( HDC_32(hdc), left, top, right, bottom );
 395 }
 396
 397
 398 /***********************************************************************
 399  *           RoundRect    (GDI.28)
 400  */
 401 BOOL16 WINAPI RoundRect16( HDC16 hdc, INT16 left, INT16 top, INT16 right,
 402                            INT16 bottom, INT16 ell_width, INT16 ell_height )
 403 {
 404     return RoundRect( HDC_32(hdc), left, top, right, bottom, ell_width, ell_height );
 405 }
 406
 407
 408 /***********************************************************************
 409  *           PatBlt    (GDI.29)
 410  */
 411 BOOL16 WINAPI PatBlt16( HDC16 hdc, INT16 left, INT16 top,
 412                         INT16 width, INT16 height, DWORD rop)
 413 {
 414     return PatBlt( HDC_32(hdc), left, top, width, height, rop );
 415 }
 416
 417
 418 /***********************************************************************
 419  *           SaveDC    (GDI.30)
 420  */
 421 INT16 WINAPI SaveDC16( HDC16 hdc )
 422 {
 423     return SaveDC( HDC_32(hdc) );
 424 }
 425
 426
 427 /***********************************************************************
 428  *           SetPixel    (GDI.31)
 429  */
 430 COLORREF WINAPI SetPixel16( HDC16 hdc, INT16 x, INT16 y, COLORREF color )
 431 {
 432     return SetPixel( HDC_32(hdc), x, y, color );
 433 }
 434
 435
 436 /***********************************************************************
 437  *           OffsetClipRgn    (GDI.32)
 438  */
 439 INT16 WINAPI OffsetClipRgn16( HDC16 hdc, INT16 x, INT16 y )
 440 {
 441     return OffsetClipRgn( HDC_32(hdc), x, y );
 442 }
 443
 444
 445 /***********************************************************************
 446  *           TextOut    (GDI.33)
 447  */
 448 BOOL16 WINAPI TextOut16( HDC16 hdc, INT16 x, INT16 y, LPCSTR str, INT16 count )
 449 {
 450     return TextOutA( HDC_32(hdc), x, y, str, count );
 451 }
 452
 453
 454 /***********************************************************************
 455  *           BitBlt    (GDI.34)
 456  */
 457 BOOL16 WINAPI BitBlt16( HDC16 hdcDst, INT16 xDst, INT16 yDst, INT16 width,
 458                         INT16 height, HDC16 hdcSrc, INT16 xSrc, INT16 ySrc,
 459                         DWORD rop )
 460 {
 461     return BitBlt( HDC_32(hdcDst), xDst, yDst, width, height, HDC_32(hdcSrc), xSrc, ySrc, rop );
 462 }
 463
 464
 465 /***********************************************************************
 466  *           StretchBlt    (GDI.35)
 467  */
 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 )
 472 {
 473     return StretchBlt( HDC_32(hdcDst), xDst, yDst, widthDst, heightDst,
 474                        HDC_32(hdcSrc), xSrc, ySrc, widthSrc, heightSrc, rop );
 475 }
 476
 477
 478 /**********************************************************************
 479  *          Polygon  (GDI.36)
 480  */
 481 BOOL16 WINAPI Polygon16( HDC16 hdc, const POINT16* pt, INT16 count )
 482 {
 483     register int i;
 484     BOOL ret;
 485     LPPOINT pt32 = (LPPOINT)HeapAlloc( GetProcessHeap(), 0,
 486                                            count*sizeof(POINT) );
 487
 488     if (!pt32) return FALSE;
 489     for (i=count;i--;) CONV_POINT16TO32(&(pt[i]),&(pt32[i]));
 490     ret = Polygon(HDC_32(hdc),pt32,count);
 491     HeapFree( GetProcessHeap(), 0, pt32 );
 492     return ret;
 493 }
 494
 495
 496 /**********************************************************************
 497  *          Polyline  (GDI.37)
 498  */
 499 BOOL16 WINAPI Polyline16( HDC16 hdc, const POINT16* pt, INT16 count )
 500 {
 501     register int i;
 502     BOOL16 ret;
 503     LPPOINT pt32 = (LPPOINT)HeapAlloc( GetProcessHeap(), 0,
 504                                            count*sizeof(POINT) );
 505
 506     if (!pt32) return FALSE;
 507     for (i=count;i--;) CONV_POINT16TO32(&(pt[i]),&(pt32[i]));
 508     ret = Polyline(HDC_32(hdc),pt32,count);
 509     HeapFree( GetProcessHeap(), 0, pt32 );
 510     return ret;
 511 }
 512
 513
 514 /***********************************************************************
 515  *            Escape   (GDI.38)
 516  */
 517 INT16 WINAPI Escape16( HDC16 hdc, INT16 escape, INT16 in_count, SEGPTR in_data, LPVOID out_data )
 518 {
 519     INT ret;
 520
 521     switch(escape)
 522     {
 523     /* Escape(hdc,CLIP_TO_PATH,LPINT16,NULL) */
 524     /* Escape(hdc,DRAFTMODE,LPINT16,NULL) */
 525     /* Escape(hdc,ENUMPAPERBINS,LPINT16,LPSTR); */
 526     /* Escape(hdc,EPSPRINTING,LPINT16,NULL) */
 527     /* Escape(hdc,EXT_DEVICE_CAPS,LPINT16,LPDWORD) */
 528     /* Escape(hdc,GETCOLORTABLE,LPINT16,LPDWORD) */
 529     /* Escape(hdc,MOUSETRAILS,LPINT16,NULL) */
 530     /* Escape(hdc,POSTSCRIPT_IGNORE,LPINT16,NULL) */
 531     /* Escape(hdc,QUERYESCSUPPORT,LPINT16,NULL) */
 532     /* Escape(hdc,SET_ARC_DIRECTION,LPINT16,NULL) */
 533     /* Escape(hdc,SET_POLY_MODE,LPINT16,NULL) */
 534     /* Escape(hdc,SET_SCREEN_ANGLE,LPINT16,NULL) */
 535     /* Escape(hdc,SET_SPREAD,LPINT16,NULL) */
 536     case CLIP_TO_PATH:
 537     case DRAFTMODE:
 538     case ENUMPAPERBINS:
 539     case EPSPRINTING:
 540     case EXT_DEVICE_CAPS:
 541     case GETCOLORTABLE:
 542     case MOUSETRAILS:
 543     case POSTSCRIPT_IGNORE:
 544     case QUERYESCSUPPORT:
 545     case SET_ARC_DIRECTION:
 546     case SET_POLY_MODE:
 547     case SET_SCREEN_ANGLE:
 548     case SET_SPREAD:
 549     {
 550         INT16 *ptr = MapSL(in_data);
 551         INT data = *ptr;
 552         return Escape( HDC_32(hdc), escape, sizeof(data), (LPCSTR)&data, out_data );
 553     }
 554
 555     /* Escape(hdc,ENABLEDUPLEX,LPUINT16,NULL) */
 556     case ENABLEDUPLEX:
 557     {
 558         UINT16 *ptr = MapSL(in_data);
 559         UINT data = *ptr;
 560         return Escape( HDC_32(hdc), escape, sizeof(data), (LPCSTR)&data, NULL );
 561     }
 562
 563     /* Escape(hdc,GETPHYSPAGESIZE,NULL,LPPOINT16) */
 564     /* Escape(hdc,GETPRINTINGOFFSET,NULL,LPPOINT16) */
 565     /* Escape(hdc,GETSCALINGFACTOR,NULL,LPPOINT16) */
 566     case GETPHYSPAGESIZE:
 567     case GETPRINTINGOFFSET:
 568     case GETSCALINGFACTOR:
 569     {
 570         POINT16 *ptr = out_data;
 571         POINT pt32;
 572         ret = Escape( HDC_32(hdc), escape, 0, NULL, &pt32 );
 573         ptr->x = pt32.x;
 574         ptr->y = pt32.y;
 575         return ret;
 576     }
 577
 578     /* Escape(hdc,ENABLEPAIRKERNING,LPINT16,LPINT16); */
 579     /* Escape(hdc,ENABLERELATIVEWIDTHS,LPINT16,LPINT16); */
 580     /* Escape(hdc,SETCOPYCOUNT,LPINT16,LPINT16) */
 581     /* Escape(hdc,SETKERNTRACK,LPINT16,LPINT16) */
 582     /* Escape(hdc,SETLINECAP,LPINT16,LPINT16) */
 583     /* Escape(hdc,SETLINEJOIN,LPINT16,LPINT16) */
 584     /* Escape(hdc,SETMITERLIMIT,LPINT16,LPINT16) */
 585     case ENABLEPAIRKERNING:
 586     case ENABLERELATIVEWIDTHS:
 587     case SETCOPYCOUNT:
 588     case SETKERNTRACK:
 589     case SETLINECAP:
 590     case SETLINEJOIN:
 591     case SETMITERLIMIT:
 592     {
 593         INT16 *new = MapSL(in_data);
 594         INT16 *old = out_data;
 595         INT out, in = *new;
 596         ret = Escape( HDC_32(hdc), escape, sizeof(in), (LPCSTR)&in, &out );
 597         *old = out;
 598         return ret;
 599     }
 600
 601     /* Escape(hdc,SETABORTPROC,ABORTPROC,NULL); */
 602     case SETABORTPROC:
 603         return SetAbortProc16( hdc, (ABORTPROC16)in_data );
 604
 605     /* Escape(hdc,STARTDOC,LPSTR,LPDOCINFO16);
 606      * lpvOutData is actually a pointer to the DocInfo structure and used as
 607      * a second input parameter */
 608     case STARTDOC:
 609         if (out_data)
 610         {
 611             ret = StartDoc16( hdc, out_data );
 612             if (ret > 0) ret = StartPage( HDC_32(hdc) );
 613             return ret;
 614         }
 615         return Escape( HDC_32(hdc), escape, in_count, MapSL(in_data), NULL );
 616
 617     /* Escape(hdc,SET_BOUNDS,LPRECT16,NULL); */
 618     /* Escape(hdc,SET_CLIP_BOX,LPRECT16,NULL); */
 619     case SET_BOUNDS:
 620     case SET_CLIP_BOX:
 621     {
 622         RECT16 *rc16 = MapSL(in_data);
 623         RECT rc;
 624         rc.left   = rc16->left;
 625         rc.top    = rc16->top;
 626         rc.right  = rc16->right;
 627         rc.bottom = rc16->bottom;
 628         return Escape( HDC_32(hdc), escape, sizeof(rc), (LPCSTR)&rc, NULL );
 629     }
 630
 631     /* Escape(hdc,NEXTBAND,NULL,LPRECT16); */
 632     case NEXTBAND:
 633     {
 634         RECT rc;
 635         RECT16 *rc16 = out_data;
 636         ret = Escape( HDC_32(hdc), escape, 0, NULL, &rc );
 637         rc16->left   = rc.left;
 638         rc16->top    = rc.top;
 639         rc16->right  = rc.right;
 640         rc16->bottom = rc.bottom;
 641         return ret;
 642     }
 643
 644     /* Escape(hdc,ABORTDOC,NULL,NULL); */
 645     /* Escape(hdc,BANDINFO,BANDINFOSTRUCT*,BANDINFOSTRUCT*); */
 646     /* Escape(hdc,BEGIN_PATH,NULL,NULL); */
 647     /* Escape(hdc,DRAWPATTERNRECT,PRECT_STRUCT*,NULL); */
 648     /* Escape(hdc,ENDDOC,NULL,NULL); */
 649     /* Escape(hdc,END_PATH,PATHINFO,NULL); */
 650     /* Escape(hdc,EXTTEXTOUT,EXTTEXT_STRUCT*,NULL); */
 651     /* Escape(hdc,FLUSHOUTPUT,NULL,NULL); */
 652     /* Escape(hdc,GETFACENAME,NULL,LPSTR); */
 653     /* Escape(hdc,GETPAIRKERNTABLE,NULL,KERNPAIR*); */
 654     /* Escape(hdc,GETSETPAPERBINS,BinInfo*,BinInfo*); */
 655     /* Escape(hdc,GETSETPRINTORIENT,ORIENT*,NULL); */
 656     /* Escape(hdc,GETSETSCREENPARAMS,SCREENPARAMS*,SCREENPARAMS*); */
 657     /* Escape(hdc,GETTECHNOLOGY,NULL,LPSTR); */
 658     /* Escape(hdc,GETTRACKKERNTABLE,NULL,KERNTRACK*); */
 659     /* Escape(hdc,MFCOMMENT,LPSTR,NULL); */
 660     /* Escape(hdc,NEWFRAME,NULL,NULL); */
 661     /* Escape(hdc,PASSTHROUGH,LPSTR,NULL); */
 662     /* Escape(hdc,RESTORE_CTM,NULL,NULL); */
 663     /* Escape(hdc,SAVE_CTM,NULL,NULL); */
 664     /* Escape(hdc,SETALLJUSTVALUES,EXTTEXTDATA*,NULL); */
 665     /* Escape(hdc,SETCOLORTABLE,COLORTABLE_STRUCT*,LPDWORD); */
 666     /* Escape(hdc,SET_BACKGROUND_COLOR,LPDWORD,LPDWORD); */
 667     /* Escape(hdc,TRANSFORM_CTM,LPSTR,NULL); */
 668     case ABORTDOC:
 669     case BANDINFO:
 670     case BEGIN_PATH:
 671     case DRAWPATTERNRECT:
 672     case ENDDOC:
 673     case END_PATH:
 674     case EXTTEXTOUT:
 675     case FLUSHOUTPUT:
 676     case GETFACENAME:
 677     case GETPAIRKERNTABLE:
 678     case GETSETPAPERBINS:
 679     case GETSETPRINTORIENT:
 680     case GETSETSCREENPARAMS:
 681     case GETTECHNOLOGY:
 682     case GETTRACKKERNTABLE:
 683     case MFCOMMENT:
 684     case NEWFRAME:
 685     case PASSTHROUGH:
 686     case RESTORE_CTM:
 687     case SAVE_CTM:
 688     case SETALLJUSTVALUES:
 689     case SETCOLORTABLE:
 690     case SET_BACKGROUND_COLOR:
 691     case TRANSFORM_CTM:
 692         /* pass it unmodified to the 32-bit function */
 693         return Escape( HDC_32(hdc), escape, in_count, MapSL(in_data), out_data );
 694
 695     /* Escape(hdc,ENUMPAPERMETRICS,LPINT16,LPRECT16); */
 696     /* Escape(hdc,GETEXTENDEDTEXTMETRICS,LPUINT16,EXTTEXTMETRIC*); */
 697     /* Escape(hdc,GETEXTENTTABLE,LPSTR,LPINT16); */
 698     /* Escape(hdc,GETSETPAPERMETRICS,LPRECT16,LPRECT16); */
 699     /* Escape(hdc,GETVECTORBRUSHSIZE,LPLOGBRUSH16,LPPOINT16); */
 700     /* Escape(hdc,GETVECTORPENSIZE,LPLOGPEN16,LPPOINT16); */
 701     case ENUMPAPERMETRICS:
 702     case GETEXTENDEDTEXTMETRICS:
 703     case GETEXTENTTABLE:
 704     case GETSETPAPERMETRICS:
 705     case GETVECTORBRUSHSIZE:
 706     case GETVECTORPENSIZE:
 707     default:
 708         FIXME("unknown/unsupported 16-bit escape %x (%d,%p,%p\n",
 709               escape, in_count, MapSL(in_data), out_data );
 710         return Escape( HDC_32(hdc), escape, in_count, MapSL(in_data), out_data );
 711     }
 712 }
 713
 714
 715 /***********************************************************************
 716  *           RestoreDC    (GDI.39)
 717  */
 718 BOOL16 WINAPI RestoreDC16( HDC16 hdc, INT16 level )
 719 {
 720     return RestoreDC( HDC_32(hdc), level );
 721 }
 722
 723
 724 /***********************************************************************
 725  *           FillRgn    (GDI.40)
 726  */
 727 BOOL16 WINAPI FillRgn16( HDC16 hdc, HRGN16 hrgn, HBRUSH16 hbrush )
 728 {
 729     return FillRgn( HDC_32(hdc), HRGN_32(hrgn), HBRUSH_32(hbrush) );
 730 }
 731
 732
 733 /***********************************************************************
 734  *           FrameRgn     (GDI.41)
 735  */
 736 BOOL16 WINAPI FrameRgn16( HDC16 hdc, HRGN16 hrgn, HBRUSH16 hbrush,
 737                           INT16 nWidth, INT16 nHeight )
 738 {
 739     return FrameRgn( HDC_32(hdc), HRGN_32(hrgn), HBRUSH_32(hbrush), nWidth, nHeight );
 740 }
 741
 742
 743 /***********************************************************************
 744  *           InvertRgn    (GDI.42)
 745  */
 746 BOOL16 WINAPI InvertRgn16( HDC16 hdc, HRGN16 hrgn )
 747 {
 748     return InvertRgn( HDC_32(hdc), HRGN_32(hrgn) );
 749 }
 750
 751
 752 /***********************************************************************
 753  *           PaintRgn    (GDI.43)
 754  */
 755 BOOL16 WINAPI PaintRgn16( HDC16 hdc, HRGN16 hrgn )
 756 {
 757     return PaintRgn( HDC_32(hdc), HRGN_32(hrgn) );
 758 }
 759
 760
 761 /***********************************************************************
 762  *           SelectClipRgn    (GDI.44)
 763  */
 764 INT16 WINAPI SelectClipRgn16( HDC16 hdc, HRGN16 hrgn )
 765 {
 766     return SelectClipRgn( HDC_32(hdc), HRGN_32(hrgn) );
 767 }
 768
 769
 770 /***********************************************************************
 771  *           SelectObject    (GDI.45)
 772  */
 773 HGDIOBJ16 WINAPI SelectObject16( HDC16 hdc, HGDIOBJ16 handle )
 774 {
 775     return HGDIOBJ_16( SelectObject( HDC_32(hdc), HGDIOBJ_32(handle) ) );
 776 }
 777
 778
 779 /***********************************************************************
 780  *           CombineRgn    (GDI.47)
 781  */
 782 INT16 WINAPI CombineRgn16(HRGN16 hDest, HRGN16 hSrc1, HRGN16 hSrc2, INT16 mode)
 783 {
 784     return CombineRgn( HRGN_32(hDest), HRGN_32(hSrc1), HRGN_32(hSrc2), mode );
 785 }
 786
 787
 788 /***********************************************************************
 789  *           CreateBitmap    (GDI.48)
 790  */
 791 HBITMAP16 WINAPI CreateBitmap16( INT16 width, INT16 height, UINT16 planes,
 792                                  UINT16 bpp, LPCVOID bits )
 793 {
 794     return HBITMAP_16( CreateBitmap( width, height, planes, bpp, bits ) );
 795 }
 796
 797
 798 /***********************************************************************
 799  *           CreateBitmapIndirect    (GDI.49)
 800  */
 801 HBITMAP16 WINAPI CreateBitmapIndirect16( const BITMAP16 * bmp )
 802 {
 803     return CreateBitmap16( bmp->bmWidth, bmp->bmHeight, bmp->bmPlanes,
 804                            bmp->bmBitsPixel, MapSL( bmp->bmBits ) );
 805 }
 806
 807
 808 /***********************************************************************
 809  *           CreateBrushIndirect    (GDI.50)
 810  */
 811 HBRUSH16 WINAPI CreateBrushIndirect16( const LOGBRUSH16 * brush )
 812 {
 813     LOGBRUSH brush32;
 814
 815     if (brush->lbStyle == BS_DIBPATTERN || brush->lbStyle == BS_DIBPATTERN8X8)
 816         return CreateDIBPatternBrush16( brush->lbHatch, brush->lbColor );
 817
 818     brush32.lbStyle = brush->lbStyle;
 819     brush32.lbColor = brush->lbColor;
 820     brush32.lbHatch = brush->lbHatch;
 821     return HBRUSH_16( CreateBrushIndirect(&brush32) );
 822 }
 823
 824
 825 /***********************************************************************
 826  *           CreateCompatibleBitmap    (GDI.51)
 827  */
 828 HBITMAP16 WINAPI CreateCompatibleBitmap16( HDC16 hdc, INT16 width, INT16 height )
 829 {
 830     return HBITMAP_16( CreateCompatibleBitmap( HDC_32(hdc), width, height ) );
 831 }
 832
 833
 834 /***********************************************************************
 835  *           CreateCompatibleDC    (GDI.52)
 836  */
 837 HDC16 WINAPI CreateCompatibleDC16( HDC16 hdc )
 838 {
 839     return HDC_16( CreateCompatibleDC( HDC_32(hdc) ) );
 840 }
 841
 842
 843 /***********************************************************************
 844  *           CreateDC    (GDI.53)
 845  */
 846 HDC16 WINAPI CreateDC16( LPCSTR driver, LPCSTR device, LPCSTR output,
 847                          const DEVMODEA *initData )
 848 {
 849     return HDC_16( CreateDCA( driver, device, output, initData ) );
 850 }
 851
 852
 853 /***********************************************************************
 854  *           CreateEllipticRgn    (GDI.54)
 855  */
 856 HRGN16 WINAPI CreateEllipticRgn16( INT16 left, INT16 top, INT16 right, INT16 bottom )
 857 {
 858     return HRGN_16( CreateEllipticRgn( left, top, right, bottom ) );
 859 }
 860
 861
 862 /***********************************************************************
 863  *           CreateEllipticRgnIndirect    (GDI.55)
 864  */
 865 HRGN16 WINAPI CreateEllipticRgnIndirect16( const RECT16 *rect )
 866 {
 867     return HRGN_16( CreateEllipticRgn( rect->left, rect->top, rect->right, rect->bottom ) );
 868 }
 869
 870
 871 /***********************************************************************
 872  *           CreateFont    (GDI.56)
 873  */
 874 HFONT16 WINAPI CreateFont16(INT16 height, INT16 width, INT16 esc, INT16 orient,
 875                             INT16 weight, BYTE italic, BYTE underline,
 876                             BYTE strikeout, BYTE charset, BYTE outpres,
 877                             BYTE clippres, BYTE quality, BYTE pitch,
 878                             LPCSTR name )
 879 {
 880     return HFONT_16( CreateFontA( height, width, esc, orient, weight, italic, underline,
 881                                   strikeout, charset, outpres, clippres, quality, pitch, name ));
 882 }
 883
 884 /***********************************************************************
 885  *           CreateFontIndirect   (GDI.57)
 886  */
 887 HFONT16 WINAPI CreateFontIndirect16( const LOGFONT16 *plf16 )
 888 {
 889     HFONT ret;
 890
 891     if (plf16)
 892     {
 893         LOGFONTW lfW;
 894         logfont_16_to_W( plf16, &lfW );
 895         ret = CreateFontIndirectW( &lfW );
 896     }
 897     else ret = CreateFontIndirectW( NULL );
 898     return HFONT_16(ret);
 899 }
 900
 901
 902 /***********************************************************************
 903  *           CreateHatchBrush    (GDI.58)
 904  */
 905 HBRUSH16 WINAPI CreateHatchBrush16( INT16 style, COLORREF color )
 906 {
 907     return HBRUSH_16( CreateHatchBrush( style, color ) );
 908 }
 909
 910
 911 /***********************************************************************
 912  *           CreatePatternBrush    (GDI.60)
 913  */
 914 HBRUSH16 WINAPI CreatePatternBrush16( HBITMAP16 hbitmap )
 915 {
 916     return HBRUSH_16( CreatePatternBrush( HBITMAP_32(hbitmap) ));
 917 }
 918
 919
 920 /***********************************************************************
 921  *           CreatePen    (GDI.61)
 922  */
 923 HPEN16 WINAPI CreatePen16( INT16 style, INT16 width, COLORREF color )
 924 {
 925     LOGPEN logpen;
 926
 927     logpen.lopnStyle = style;
 928     logpen.lopnWidth.x = width;
 929     logpen.lopnWidth.y = 0;
 930     logpen.lopnColor = color;
 931     return HPEN_16( CreatePenIndirect( &logpen ) );
 932 }
 933
 934
 935 /***********************************************************************
 936  *           CreatePenIndirect    (GDI.62)
 937  */
 938 HPEN16 WINAPI CreatePenIndirect16( const LOGPEN16 * pen )
 939 {
 940     LOGPEN logpen;
 941
 942     if (pen->lopnStyle > PS_INSIDEFRAME) return 0;
 943     logpen.lopnStyle   = pen->lopnStyle;
 944     logpen.lopnWidth.x = pen->lopnWidth.x;
 945     logpen.lopnWidth.y = pen->lopnWidth.y;
 946     logpen.lopnColor   = pen->lopnColor;
 947     return HPEN_16( CreatePenIndirect( &logpen ) );
 948 }
 949
 950
 951 /***********************************************************************
 952  *           CreatePolygonRgn    (GDI.63)
 953  */
 954 HRGN16 WINAPI CreatePolygonRgn16( const POINT16 * points, INT16 count, INT16 mode )
 955 {
 956     return CreatePolyPolygonRgn16( points, &count, 1, mode );
 957 }
 958
 959
 960 /***********************************************************************
 961  *           CreateRectRgn    (GDI.64)
 962  *
 963  * NOTE: cf. SetRectRgn16
 964  */
 965 HRGN16 WINAPI CreateRectRgn16( INT16 left, INT16 top, INT16 right, INT16 bottom )
 966 {
 967     HRGN hrgn;
 968
 969     if (left < right) hrgn = CreateRectRgn( left, top, right, bottom );
 970     else hrgn = CreateRectRgn( 0, 0, 0, 0 );
 971     return HRGN_16(hrgn);
 972 }
 973
 974
 975 /***********************************************************************
 976  *           CreateRectRgnIndirect    (GDI.65)
 977  */
 978 HRGN16 WINAPI CreateRectRgnIndirect16( const RECT16* rect )
 979 {
 980     return CreateRectRgn16( rect->left, rect->top, rect->right, rect->bottom );
 981 }
 982
 983
 984 /***********************************************************************
 985  *           CreateSolidBrush    (GDI.66)
 986  */
 987 HBRUSH16 WINAPI CreateSolidBrush16( COLORREF color )
 988 {
 989     return HBRUSH_16( CreateSolidBrush( color ) );
 990 }
 991
 992
 993 /***********************************************************************
 994  *           DeleteDC    (GDI.68)
 995  */
 996 BOOL16 WINAPI DeleteDC16( HDC16 hdc )
 997 {
 998     return DeleteDC( HDC_32(hdc) );
 999 }
1000
1001
1002 /***********************************************************************
1003  *           DeleteObject    (GDI.69)
1004  *           SysDeleteObject (GDI.605)
1005  */
1006 BOOL16 WINAPI DeleteObject16( HGDIOBJ16 obj )
1007 {
1008     return DeleteObject( HGDIOBJ_32(obj) );
1009 }
1010
1011
1012 /***********************************************************************
1013  *           EnumObjects    (GDI.71)
1014  */
1015 INT16 WINAPI EnumObjects16( HDC16 hdc, INT16 obj, GOBJENUMPROC16 proc, LPARAM lParam )
1016 {
1017     struct callback16_info info;
1018
1019     info.proc  = (FARPROC16)proc;
1020     info.param = lParam;
1021     switch(obj)
1022     {
1023     case OBJ_PEN:
1024         return EnumObjects( HDC_32(hdc), OBJ_PEN, enum_pens_callback, (LPARAM)&info );
1025     case OBJ_BRUSH:
1026         return EnumObjects( HDC_32(hdc), OBJ_BRUSH, enum_brushes_callback, (LPARAM)&info );
1027     }
1028     return 0;
1029 }
1030
1031
1032 /***********************************************************************
1033  *           EqualRgn    (GDI.72)
1034  */
1035 BOOL16 WINAPI EqualRgn16( HRGN16 rgn1, HRGN16 rgn2 )
1036 {
1037     return EqualRgn( HRGN_32(rgn1), HRGN_32(rgn2) );
1038 }
1039
1040
1041 /***********************************************************************
1042  *           GetBitmapBits    (GDI.74)
1043  */
1044 LONG WINAPI GetBitmapBits16( HBITMAP16 hbitmap, LONG count, LPVOID buffer )
1045 {
1046     return GetBitmapBits( HBITMAP_32(hbitmap), count, buffer );
1047 }
1048
1049
1050 /***********************************************************************
1051  *              GetBkColor (GDI.75)
1052  */
1053 COLORREF WINAPI GetBkColor16( HDC16 hdc )
1054 {
1055     return GetBkColor( HDC_32(hdc) );
1056 }
1057
1058
1059 /***********************************************************************
1060  *              GetBkMode (GDI.76)
1061  */
1062 INT16 WINAPI GetBkMode16( HDC16 hdc )
1063 {
1064     return GetBkMode( HDC_32(hdc) );
1065 }
1066
1067
1068 /***********************************************************************
1069  *           GetClipBox    (GDI.77)
1070  */
1071 INT16 WINAPI GetClipBox16( HDC16 hdc, LPRECT16 rect )
1072 {
1073     RECT rect32;
1074     INT ret = GetClipBox( HDC_32(hdc), &rect32 );
1075
1076     if (ret != ERROR)
1077     {
1078         rect->left   = rect32.left;
1079         rect->top    = rect32.top;
1080         rect->right  = rect32.right;
1081         rect->bottom = rect32.bottom;
1082     }
1083     return ret;
1084 }
1085
1086
1087 /***********************************************************************
1088  *              GetCurrentPosition (GDI.78)
1089  */
1090 DWORD WINAPI GetCurrentPosition16( HDC16 hdc )
1091 {
1092     POINT pt32;
1093     if (!GetCurrentPositionEx( HDC_32(hdc), &pt32 )) return 0;
1094     return MAKELONG( pt32.x, pt32.y );
1095 }
1096
1097
1098 /***********************************************************************
1099  *           GetDCOrg    (GDI.79)
1100  */
1101 DWORD WINAPI GetDCOrg16( HDC16 hdc )
1102 {
1103     POINT pt;
1104     if (GetDCOrgEx( HDC_32(hdc), &pt )) return MAKELONG( pt.x, pt.y );
1105     return 0;
1106 }
1107
1108
1109 /***********************************************************************
1110  *           GetDeviceCaps    (GDI.80)
1111  */
1112 INT16 WINAPI GetDeviceCaps16( HDC16 hdc, INT16 cap )
1113 {
1114     INT16 ret = GetDeviceCaps( HDC_32(hdc), cap );
1115     /* some apps don't expect -1 and think it's a B&W screen */
1116     if ((cap == NUMCOLORS) && (ret == -1)) ret = 2048;
1117     return ret;
1118 }
1119
1120
1121 /***********************************************************************
1122  *              GetMapMode (GDI.81)
1123  */
1124 INT16 WINAPI GetMapMode16( HDC16 hdc )
1125 {
1126     return GetMapMode( HDC_32(hdc) );
1127 }
1128
1129
1130 /***********************************************************************
1131  *           GetPixel    (GDI.83)
1132  */
1133 COLORREF WINAPI GetPixel16( HDC16 hdc, INT16 x, INT16 y )
1134 {
1135     return GetPixel( HDC_32(hdc), x, y );
1136 }
1137
1138
1139 /***********************************************************************
1140  *              GetPolyFillMode (GDI.84)
1141  */
1142 INT16 WINAPI GetPolyFillMode16( HDC16 hdc )
1143 {
1144     return GetPolyFillMode( HDC_32(hdc) );
1145 }
1146
1147
1148 /***********************************************************************
1149  *              GetROP2 (GDI.85)
1150  */
1151 INT16 WINAPI GetROP216( HDC16 hdc )
1152 {
1153     return GetROP2( HDC_32(hdc) );
1154 }
1155
1156
1157 /***********************************************************************
1158  *              GetRelAbs (GDI.86)
1159  */
1160 INT16 WINAPI GetRelAbs16( HDC16 hdc )
1161 {
1162     return GetRelAbs( HDC_32(hdc), 0 );
1163 }
1164
1165
1166 /***********************************************************************
1167  *           GetStockObject    (GDI.87)
1168  */
1169 HGDIOBJ16 WINAPI GetStockObject16( INT16 obj )
1170 {
1171     return HGDIOBJ_16( GetStockObject( obj ) );
1172 }
1173
1174
1175 /***********************************************************************
1176  *              GetStretchBltMode (GDI.88)
1177  */
1178 INT16 WINAPI GetStretchBltMode16( HDC16 hdc )
1179 {
1180     return GetStretchBltMode( HDC_32(hdc) );
1181 }
1182
1183
1184 /***********************************************************************
1185  *           GetTextCharacterExtra    (GDI.89)
1186  */
1187 INT16 WINAPI GetTextCharacterExtra16( HDC16 hdc )
1188 {
1189     return GetTextCharacterExtra( HDC_32(hdc) );
1190 }
1191
1192
1193 /***********************************************************************
1194  *              GetTextColor (GDI.90)
1195  */
1196 COLORREF WINAPI GetTextColor16( HDC16 hdc )
1197 {
1198     return GetTextColor( HDC_32(hdc) );
1199 }
1200
1201
1202 /***********************************************************************
1203  *           GetTextExtent    (GDI.91)
1204  */
1205 DWORD WINAPI GetTextExtent16( HDC16 hdc, LPCSTR str, INT16 count )
1206 {
1207     SIZE size;
1208     if (!GetTextExtentPoint32A( HDC_32(hdc), str, count, &size )) return 0;
1209     return MAKELONG( size.cx, size.cy );
1210 }
1211
1212
1213 /***********************************************************************
1214  *           GetTextFace    (GDI.92)
1215  */
1216 INT16 WINAPI GetTextFace16( HDC16 hdc, INT16 count, LPSTR name )
1217 {
1218     return GetTextFaceA( HDC_32(hdc), count, name );
1219 }
1220
1221
1222 /***********************************************************************
1223  *           GetTextMetrics    (GDI.93)
1224  */
1225 BOOL16 WINAPI GetTextMetrics16( HDC16 hdc, TEXTMETRIC16 *tm )
1226 {
1227     TEXTMETRICW tm32;
1228
1229     if (!GetTextMetricsW( HDC_32(hdc), &tm32 )) return FALSE;
1230
1231     tm->tmHeight           = tm32.tmHeight;
1232     tm->tmAscent           = tm32.tmAscent;
1233     tm->tmDescent          = tm32.tmDescent;
1234     tm->tmInternalLeading  = tm32.tmInternalLeading;
1235     tm->tmExternalLeading  = tm32.tmExternalLeading;
1236     tm->tmAveCharWidth     = tm32.tmAveCharWidth;
1237     tm->tmMaxCharWidth     = tm32.tmMaxCharWidth;
1238     tm->tmWeight           = tm32.tmWeight;
1239     tm->tmOverhang         = tm32.tmOverhang;
1240     tm->tmDigitizedAspectX = tm32.tmDigitizedAspectX;
1241     tm->tmDigitizedAspectY = tm32.tmDigitizedAspectY;
1242     tm->tmFirstChar        = tm32.tmFirstChar;
1243     tm->tmLastChar         = tm32.tmLastChar;
1244     tm->tmDefaultChar      = tm32.tmDefaultChar;
1245     tm->tmBreakChar        = tm32.tmBreakChar;
1246     tm->tmItalic           = tm32.tmItalic;
1247     tm->tmUnderlined       = tm32.tmUnderlined;
1248     tm->tmStruckOut        = tm32.tmStruckOut;
1249     tm->tmPitchAndFamily   = tm32.tmPitchAndFamily;
1250     tm->tmCharSet          = tm32.tmCharSet;
1251     return TRUE;
1252 }
1253
1254
1255 /***********************************************************************
1256  *              GetViewportExt (GDI.94)
1257  */
1258 DWORD WINAPI GetViewportExt16( HDC16 hdc )
1259 {
1260     SIZE size;
1261     if (!GetViewportExtEx( HDC_32(hdc), &size )) return 0;
1262     return MAKELONG( size.cx, size.cy );
1263 }
1264
1265
1266 /***********************************************************************
1267  *              GetViewportOrg (GDI.95)
1268  */
1269 DWORD WINAPI GetViewportOrg16( HDC16 hdc )
1270 {
1271     POINT pt;
1272     if (!GetViewportOrgEx( HDC_32(hdc), &pt )) return 0;
1273     return MAKELONG( pt.x, pt.y );
1274 }
1275
1276
1277 /***********************************************************************
1278  *              GetWindowExt (GDI.96)
1279  */
1280 DWORD WINAPI GetWindowExt16( HDC16 hdc )
1281 {
1282     SIZE size;
1283     if (!GetWindowExtEx( HDC_32(hdc), &size )) return 0;
1284     return MAKELONG( size.cx, size.cy );
1285 }
1286
1287
1288 /***********************************************************************
1289  *              GetWindowOrg (GDI.97)
1290  */
1291 DWORD WINAPI GetWindowOrg16( HDC16 hdc )
1292 {
1293     POINT pt;
1294     if (!GetWindowOrgEx( HDC_32(hdc), &pt )) return 0;
1295     return MAKELONG( pt.x, pt.y );
1296 }
1297
1298
1299
1300
1301 /**********************************************************************
1302  *           LineDDA   (GDI.100)
1303  */
1304 void WINAPI LineDDA16( INT16 nXStart, INT16 nYStart, INT16 nXEnd,
1305                        INT16 nYEnd, LINEDDAPROC16 proc, LPARAM lParam )
1306 {
1307     struct callback16_info info;
1308     info.proc  = (FARPROC16)proc;
1309     info.param = lParam;
1310     LineDDA( nXStart, nYStart, nXEnd, nYEnd, linedda_callback, (LPARAM)&info );
1311 }
1312
1313
1314 /***********************************************************************
1315  *           OffsetRgn    (GDI.101)
1316  */
1317 INT16 WINAPI OffsetRgn16( HRGN16 hrgn, INT16 x, INT16 y )
1318 {
1319     return OffsetRgn( HRGN_32(hrgn), x, y );
1320 }
1321
1322
1323 /***********************************************************************
1324  *           PtVisible    (GDI.103)
1325  */
1326 BOOL16 WINAPI PtVisible16( HDC16 hdc, INT16 x, INT16 y )
1327 {
1328     return PtVisible( HDC_32(hdc), x, y );
1329 }
1330
1331
1332 /***********************************************************************
1333  *           SetBitmapBits    (GDI.106)
1334  */
1335 LONG WINAPI SetBitmapBits16( HBITMAP16 hbitmap, LONG count, LPCVOID buffer )
1336 {
1337     return SetBitmapBits( HBITMAP_32(hbitmap), count, buffer );
1338 }
1339
1340
1341 /***********************************************************************
1342  *           AddFontResource    (GDI.119)
1343  */
1344 INT16 WINAPI AddFontResource16( LPCSTR filename )
1345 {
1346     return AddFontResourceA( filename );
1347 }
1348
1349
1350 /***********************************************************************
1351  *           Death    (GDI.121)
1352  *
1353  * Disables GDI, switches back to text mode.
1354  * We don't have to do anything here,
1355  * just let console support handle everything
1356  */
1357 void WINAPI Death16(HDC16 hdc)
1358 {
1359     MESSAGE("Death(%04x) called. Application enters text mode...\n", hdc);
1360 }
1361
1362
1363 /***********************************************************************
1364  *           Resurrection    (GDI.122)
1365  *
1366  * Restores GDI functionality
1367  */
1368 void WINAPI Resurrection16(HDC16 hdc,
1369                            WORD w1, WORD w2, WORD w3, WORD w4, WORD w5, WORD w6)
1370 {
1371     MESSAGE("Resurrection(%04x, %04x, %04x, %04x, %04x, %04x, %04x) called. Application left text mode.\n",
1372             hdc, w1, w2, w3, w4, w5, w6);
1373 }
1374
1375
1376 /**********************************************************************
1377  *           CreateMetaFile     (GDI.125)
1378  */
1379 HDC16 WINAPI CreateMetaFile16( LPCSTR filename )
1380 {
1381     return HDC_16( CreateMetaFileA( filename ) );
1382 }
1383
1384
1385 /***********************************************************************
1386  *           MulDiv   (GDI.128)
1387  */
1388 INT16 WINAPI MulDiv16( INT16 nMultiplicand, INT16 nMultiplier, INT16 nDivisor)
1389 {
1390     INT ret;
1391     if (!nDivisor) return -32768;
1392     /* We want to deal with a positive divisor to simplify the logic. */
1393     if (nDivisor < 0)
1394     {
1395       nMultiplicand = - nMultiplicand;
1396       nDivisor = -nDivisor;
1397     }
1398     /* If the result is positive, we "add" to round. else,
1399      * we subtract to round. */
1400     if ( ( (nMultiplicand <  0) && (nMultiplier <  0) ) ||
1401          ( (nMultiplicand >= 0) && (nMultiplier >= 0) ) )
1402         ret = (((int)nMultiplicand * nMultiplier) + (nDivisor/2)) / nDivisor;
1403     else
1404         ret = (((int)nMultiplicand * nMultiplier) - (nDivisor/2)) / nDivisor;
1405     if ((ret > 32767) || (ret < -32767)) return -32768;
1406     return (INT16) ret;
1407 }
1408
1409
1410 /***********************************************************************
1411  *           GetRgnBox    (GDI.134)
1412  */
1413 INT16 WINAPI GetRgnBox16( HRGN16 hrgn, LPRECT16 rect )
1414 {
1415     RECT r;
1416     INT16 ret = GetRgnBox( HRGN_32(hrgn), &r );
1417     CONV_RECT32TO16( &r, rect );
1418     return ret;
1419 }
1420
1421
1422 /***********************************************************************
1423  *           RemoveFontResource    (GDI.136)
1424  */
1425 BOOL16 WINAPI RemoveFontResource16( LPCSTR str )
1426 {
1427     return RemoveFontResourceA(str);
1428 }
1429
1430
1431 /***********************************************************************
1432  *           SetBrushOrg    (GDI.148)
1433  */
1434 DWORD WINAPI SetBrushOrg16( HDC16 hdc, INT16 x, INT16 y )
1435 {
1436     POINT pt;
1437
1438     if (!SetBrushOrgEx( HDC_32(hdc), x, y, &pt )) return 0;
1439     return MAKELONG( pt.x, pt.y );
1440 }
1441
1442
1443 /***********************************************************************
1444  *              GetBrushOrg (GDI.149)
1445  */
1446 DWORD WINAPI GetBrushOrg16( HDC16 hdc )
1447 {
1448     POINT pt;
1449     if (!GetBrushOrgEx( HDC_32(hdc), &pt )) return 0;
1450     return MAKELONG( pt.x, pt.y );
1451 }
1452
1453
1454 /***********************************************************************
1455  *           UnrealizeObject    (GDI.150)
1456  */
1457 BOOL16 WINAPI UnrealizeObject16( HGDIOBJ16 obj )
1458 {
1459     return UnrealizeObject( HGDIOBJ_32(obj) );
1460 }
1461
1462
1463 /***********************************************************************
1464  *           CreateIC    (GDI.153)
1465  */
1466 HDC16 WINAPI CreateIC16( LPCSTR driver, LPCSTR device, LPCSTR output,
1467                          const DEVMODEA* initData )
1468 {
1469     return HDC_16( CreateICA( driver, device, output, initData ) );
1470 }
1471
1472
1473 /***********************************************************************
1474  *           GetNearestColor   (GDI.154)
1475  */
1476 COLORREF WINAPI GetNearestColor16( HDC16 hdc, COLORREF color )
1477 {
1478     return GetNearestColor( HDC_32(hdc), color );
1479 }
1480
1481
1482 /***********************************************************************
1483  *           CreateDiscardableBitmap    (GDI.156)
1484  */
1485 HBITMAP16 WINAPI CreateDiscardableBitmap16( HDC16 hdc, INT16 width, INT16 height )
1486 {
1487     return HBITMAP_16( CreateDiscardableBitmap( HDC_32(hdc), width, height ) );
1488 }
1489
1490
1491 /***********************************************************************
1492  *           PtInRegion    (GDI.161)
1493  */
1494 BOOL16 WINAPI PtInRegion16( HRGN16 hrgn, INT16 x, INT16 y )
1495 {
1496     return PtInRegion( HRGN_32(hrgn), x, y );
1497 }
1498
1499
1500 /***********************************************************************
1501  *           GetBitmapDimension    (GDI.162)
1502  */
1503 DWORD WINAPI GetBitmapDimension16( HBITMAP16 hbitmap )
1504 {
1505     SIZE16 size;
1506     if (!GetBitmapDimensionEx16( hbitmap, &size )) return 0;
1507     return MAKELONG( size.cx, size.cy );
1508 }
1509
1510
1511 /***********************************************************************
1512  *           SetBitmapDimension    (GDI.163)
1513  */
1514 DWORD WINAPI SetBitmapDimension16( HBITMAP16 hbitmap, INT16 x, INT16 y )
1515 {
1516     SIZE16 size;
1517     if (!SetBitmapDimensionEx16( hbitmap, x, y, &size )) return 0;
1518     return MAKELONG( size.cx, size.cy );
1519 }
1520
1521
1522 /***********************************************************************
1523  *           SetRectRgn    (GDI.172)
1524  *
1525  * NOTE: Win 3.1 sets region to empty if left > right
1526  */
1527 void WINAPI SetRectRgn16( HRGN16 hrgn, INT16 left, INT16 top, INT16 right, INT16 bottom )
1528 {
1529     if (left < right) SetRectRgn( HRGN_32(hrgn), left, top, right, bottom );
1530     else SetRectRgn( HRGN_32(hrgn), 0, 0, 0, 0 );
1531 }
1532
1533
1534 /******************************************************************
1535  *             PlayMetaFileRecord   (GDI.176)
1536  */
1537 void WINAPI PlayMetaFileRecord16( HDC16 hdc, HANDLETABLE16 *ht, METARECORD *mr, UINT16 handles )
1538 {
1539     HANDLETABLE *ht32 = HeapAlloc( GetProcessHeap(), 0, handles * sizeof(*ht32) );
1540     unsigned int i;
1541
1542     for (i = 0; i < handles; i++) ht32->objectHandle[i] = (HGDIOBJ)(ULONG_PTR)ht->objectHandle[i];
1543     PlayMetaFileRecord( HDC_32(hdc), ht32, mr, handles );
1544     for (i = 0; i < handles; i++) ht->objectHandle[i] = LOWORD(ht32->objectHandle[i]);
1545     HeapFree( GetProcessHeap(), 0, ht32 );
1546 }
1547
1548
1549 /***********************************************************************
1550  *              EngineEnumerateFont (GDI.300)
1551  */
1552 WORD WINAPI EngineEnumerateFont16(LPSTR fontname, FARPROC16 proc, DWORD data )
1553 {
1554     FIXME("(%s,%p,%lx),stub\n",fontname,proc,data);
1555     return 0;
1556 }
1557
1558
1559 /***********************************************************************
1560  *              EngineDeleteFont (GDI.301)
1561  */
1562 WORD WINAPI EngineDeleteFont16(LPFONTINFO16 lpFontInfo)
1563 {
1564     WORD handle;
1565
1566     /*  untested, don't know if it works.
1567         We seem to access some structure that is located after the
1568         FONTINFO. The FONTINFO documentation says that there may
1569         follow some char-width table or font bitmap or vector info.
1570         I think it is some kind of font bitmap that begins at offset 0x52,
1571         as FONTINFO goes up to 0x51.
1572         If this is correct, everything should be implemented correctly.
1573     */
1574     if ( ((lpFontInfo->dfType & (RASTER_FONTTYPE|DEVICE_FONTTYPE)) == (RASTER_FONTTYPE|DEVICE_FONTTYPE))
1575          && (LOWORD(lpFontInfo->dfFace) == LOWORD(lpFontInfo)+0x6e)
1576          && (handle = *(WORD *)(lpFontInfo+0x54)) )
1577     {
1578         *(WORD *)(lpFontInfo+0x54) = 0;
1579         GlobalFree16(handle);
1580     }
1581     return 1;
1582 }
1583
1584
1585 /***********************************************************************
1586  *              EngineRealizeFont (GDI.302)
1587  */
1588 WORD WINAPI EngineRealizeFont16(LPLOGFONT16 lplogFont, LPTEXTXFORM16 lptextxform, LPFONTINFO16 lpfontInfo)
1589 {
1590     FIXME("(%p,%p,%p),stub\n",lplogFont,lptextxform,lpfontInfo);
1591
1592     return 0;
1593 }
1594
1595
1596 /***********************************************************************
1597  *              EngineRealizeFontExt (GDI.315)
1598  */
1599 WORD WINAPI EngineRealizeFontExt16(LONG l1, LONG l2, LONG l3, LONG l4)
1600 {
1601     FIXME("(%08lx,%08lx,%08lx,%08lx),stub\n",l1,l2,l3,l4);
1602
1603     return 0;
1604 }
1605
1606
1607 /***********************************************************************
1608  *              EngineGetCharWidth (GDI.303)
1609  */
1610 WORD WINAPI EngineGetCharWidth16(LPFONTINFO16 lpFontInfo, BYTE firstChar, BYTE lastChar, LPINT16 buffer)
1611 {
1612     int i;
1613
1614     for (i = firstChar; i <= lastChar; i++)
1615        FIXME(" returns font's average width for range %d to %d\n", firstChar, lastChar);
1616     *buffer++ = lpFontInfo->dfAvgWidth; /* insert some charwidth functionality here; use average width for now */
1617     return 1;
1618 }
1619
1620
1621 /***********************************************************************
1622  *              EngineSetFontContext (GDI.304)
1623  */
1624 WORD WINAPI EngineSetFontContext(LPFONTINFO16 lpFontInfo, WORD data)
1625 {
1626    FIXME("stub?\n");
1627    return 0;
1628 }
1629
1630 /***********************************************************************
1631  *              EngineGetGlyphBMP (GDI.305)
1632  */
1633 WORD WINAPI EngineGetGlyphBMP(WORD word, LPFONTINFO16 lpFontInfo, WORD w1, WORD w2,
1634                               LPSTR string, DWORD dword, /*LPBITMAPMETRICS16*/ LPVOID metrics)
1635 {
1636     FIXME("stub?\n");
1637     return 0;
1638 }
1639
1640
1641 /***********************************************************************
1642  *              EngineMakeFontDir (GDI.306)
1643  */
1644 DWORD WINAPI EngineMakeFontDir(HDC16 hdc, LPFONTDIR16 fontdir, LPCSTR string)
1645 {
1646     FIXME(" stub! (always fails)\n");
1647     return ~0UL; /* error */
1648 }
1649
1650
1651 /***********************************************************************
1652  *           GetCharABCWidths   (GDI.307)
1653  */
1654 BOOL16 WINAPI GetCharABCWidths16( HDC16 hdc, UINT16 firstChar, UINT16 lastChar, LPABC16 abc )
1655 {
1656     BOOL ret;
1657     UINT i;
1658     LPABC abc32 = HeapAlloc( GetProcessHeap(), 0, sizeof(ABC) * (lastChar - firstChar + 1) );
1659
1660     if ((ret = GetCharABCWidthsA( HDC_32(hdc), firstChar, lastChar, abc32 )))
1661     {
1662         for (i = firstChar; i <= lastChar; i++)
1663         {
1664             abc[i-firstChar].abcA = abc32[i-firstChar].abcA;
1665             abc[i-firstChar].abcB = abc32[i-firstChar].abcB;
1666             abc[i-firstChar].abcC = abc32[i-firstChar].abcC;
1667         }
1668     }
1669     HeapFree( GetProcessHeap(), 0, abc32 );
1670     return ret;
1671 }
1672
1673
1674 /***********************************************************************
1675  *           CreateScalableFontResource   (GDI.310)
1676  */
1677 BOOL16 WINAPI CreateScalableFontResource16( UINT16 fHidden, LPCSTR lpszResourceFile,
1678                                             LPCSTR fontFile, LPCSTR path )
1679 {
1680     return CreateScalableFontResourceA( fHidden, lpszResourceFile, fontFile, path );
1681 }
1682
1683
1684 /*************************************************************************
1685  *             GetFontData    (GDI.311)
1686  *
1687  */
1688 DWORD WINAPI GetFontData16( HDC16 hdc, DWORD table, DWORD offset, LPVOID buffer, DWORD count )
1689 {
1690     return GetFontData( HDC_32(hdc), table, offset, buffer, count );
1691 }
1692
1693
1694 /*************************************************************************
1695  *             GetRasterizerCaps   (GDI.313)
1696  */
1697 BOOL16 WINAPI GetRasterizerCaps16( LPRASTERIZER_STATUS lprs, UINT16 cbNumBytes )
1698 {
1699     return GetRasterizerCaps( lprs, cbNumBytes );
1700 }
1701
1702
1703 /*************************************************************************
1704  *             GetKerningPairs   (GDI.332)
1705  *
1706  */
1707 INT16 WINAPI GetKerningPairs16( HDC16 hdc, INT16 count, LPKERNINGPAIR16 pairs )
1708 {
1709     KERNINGPAIR *pairs32;
1710     INT i, ret;
1711
1712     if (!count) return 0;
1713
1714     if (!(pairs32 = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*pairs32) ))) return 0;
1715     if ((ret = GetKerningPairsA( HDC_32(hdc), count, pairs32 )))
1716     {
1717         for (i = 0; i < ret; i++)
1718         {
1719             pairs->wFirst      = pairs32->wFirst;
1720             pairs->wSecond     = pairs32->wSecond;
1721             pairs->iKernAmount = pairs32->iKernAmount;
1722         }
1723     }
1724     HeapFree( GetProcessHeap(), 0, pairs32 );
1725     return ret;
1726 }
1727
1728
1729
1730 /***********************************************************************
1731  *              GetTextAlign (GDI.345)
1732  */
1733 UINT16 WINAPI GetTextAlign16( HDC16 hdc )
1734 {
1735     return GetTextAlign( HDC_32(hdc) );
1736 }
1737
1738
1739 /***********************************************************************
1740  *           SetTextAlign    (GDI.346)
1741  */
1742 UINT16 WINAPI SetTextAlign16( HDC16 hdc, UINT16 align )
1743 {
1744     return SetTextAlign( HDC_32(hdc), align );
1745 }
1746
1747
1748 /***********************************************************************
1749  *           Chord    (GDI.348)
1750  */
1751 BOOL16 WINAPI Chord16( HDC16 hdc, INT16 left, INT16 top,
1752                        INT16 right, INT16 bottom, INT16 xstart, INT16 ystart,
1753                        INT16 xend, INT16 yend )
1754 {
1755     return Chord( HDC_32(hdc), left, top, right, bottom, xstart, ystart, xend, yend );
1756 }
1757
1758
1759 /***********************************************************************
1760  *           SetMapperFlags    (GDI.349)
1761  */
1762 DWORD WINAPI SetMapperFlags16( HDC16 hdc, DWORD flags )
1763 {
1764     return SetMapperFlags( HDC_32(hdc), flags );
1765 }
1766
1767
1768 /***********************************************************************
1769  *           GetCharWidth    (GDI.350)
1770  */
1771 BOOL16 WINAPI GetCharWidth16( HDC16 hdc, UINT16 firstChar, UINT16 lastChar, LPINT16 buffer )
1772 {
1773     BOOL retVal = FALSE;
1774
1775     if( firstChar != lastChar )
1776     {
1777         LPINT buf32 = HeapAlloc(GetProcessHeap(), 0, sizeof(INT)*(1 + (lastChar - firstChar)));
1778         if( buf32 )
1779         {
1780             LPINT obuf32 = buf32;
1781             int i;
1782
1783             retVal = GetCharWidth32A( HDC_32(hdc), firstChar, lastChar, buf32);
1784             if (retVal)
1785             {
1786                 for (i = firstChar; i <= lastChar; i++) *buffer++ = *buf32++;
1787             }
1788             HeapFree(GetProcessHeap(), 0, obuf32);
1789         }
1790     }
1791     else /* happens quite often to warrant a special treatment */
1792     {
1793         INT chWidth;
1794         retVal = GetCharWidth32A( HDC_32(hdc), firstChar, lastChar, &chWidth );
1795         *buffer = chWidth;
1796     }
1797     return retVal;
1798 }
1799
1800
1801 /***********************************************************************
1802  *           ExtTextOut   (GDI.351)
1803  */
1804 BOOL16 WINAPI ExtTextOut16( HDC16 hdc, INT16 x, INT16 y, UINT16 flags,
1805                             const RECT16 *lprect, LPCSTR str, UINT16 count,
1806                             const INT16 *lpDx )
1807 {
1808     BOOL        ret;
1809     int         i;
1810     RECT        rect32;
1811     LPINT       lpdx32 = NULL;
1812
1813     if (lpDx) {
1814         lpdx32 = (LPINT)HeapAlloc( GetProcessHeap(),0, sizeof(INT)*count );
1815         if(lpdx32 == NULL) return FALSE;
1816         for (i=count;i--;) lpdx32[i]=lpDx[i];
1817     }
1818     if (lprect) CONV_RECT16TO32(lprect,&rect32);
1819     ret = ExtTextOutA(HDC_32(hdc),x,y,flags,lprect?&rect32:NULL,str,count,lpdx32);
1820     if (lpdx32) HeapFree( GetProcessHeap(), 0, lpdx32 );
1821     return ret;
1822 }
1823
1824
1825 /***********************************************************************
1826  *           CreatePalette    (GDI.360)
1827  */
1828 HPALETTE16 WINAPI CreatePalette16( const LOGPALETTE* palette )
1829 {
1830     return HPALETTE_16( CreatePalette( palette ) );
1831 }
1832
1833
1834 /***********************************************************************
1835  *           GDISelectPalette   (GDI.361)
1836  */
1837 HPALETTE16 WINAPI GDISelectPalette16( HDC16 hdc, HPALETTE16 hpalette, WORD wBkg )
1838 {
1839     return HPALETTE_16( GDISelectPalette( HDC_32(hdc), HPALETTE_32(hpalette), wBkg ));
1840 }
1841
1842
1843 /***********************************************************************
1844  *           GDIRealizePalette   (GDI.362)
1845  */
1846 UINT16 WINAPI GDIRealizePalette16( HDC16 hdc )
1847 {
1848     return GDIRealizePalette( HDC_32(hdc) );
1849 }
1850
1851
1852 /***********************************************************************
1853  *           GetPaletteEntries    (GDI.363)
1854  */
1855 UINT16 WINAPI GetPaletteEntries16( HPALETTE16 hpalette, UINT16 start,
1856                                    UINT16 count, LPPALETTEENTRY entries )
1857 {
1858     return GetPaletteEntries( HPALETTE_32(hpalette), start, count, entries );
1859 }
1860
1861
1862 /***********************************************************************
1863  *           SetPaletteEntries    (GDI.364)
1864  */
1865 UINT16 WINAPI SetPaletteEntries16( HPALETTE16 hpalette, UINT16 start,
1866                                    UINT16 count, const PALETTEENTRY *entries )
1867 {
1868     return SetPaletteEntries( HPALETTE_32(hpalette), start, count, entries );
1869 }
1870
1871
1872 /**********************************************************************
1873  *            UpdateColors   (GDI.366)
1874  */
1875 INT16 WINAPI UpdateColors16( HDC16 hdc )
1876 {
1877     UpdateColors( HDC_32(hdc) );
1878     return TRUE;
1879 }
1880
1881
1882 /***********************************************************************
1883  *           AnimatePalette   (GDI.367)
1884  */
1885 void WINAPI AnimatePalette16( HPALETTE16 hpalette, UINT16 StartIndex,
1886                               UINT16 NumEntries, const PALETTEENTRY* PaletteColors)
1887 {
1888     AnimatePalette( HPALETTE_32(hpalette), StartIndex, NumEntries, PaletteColors );
1889 }
1890
1891
1892 /***********************************************************************
1893  *           ResizePalette   (GDI.368)
1894  */
1895 BOOL16 WINAPI ResizePalette16( HPALETTE16 hpalette, UINT16 cEntries )
1896 {
1897     return ResizePalette( HPALETTE_32(hpalette), cEntries );
1898 }
1899
1900
1901 /***********************************************************************
1902  *           GetNearestPaletteIndex   (GDI.370)
1903  */
1904 UINT16 WINAPI GetNearestPaletteIndex16( HPALETTE16 hpalette, COLORREF color )
1905 {
1906     return GetNearestPaletteIndex( HPALETTE_32(hpalette), color );
1907 }
1908
1909
1910 /**********************************************************************
1911  *          ExtFloodFill   (GDI.372)
1912  */
1913 BOOL16 WINAPI ExtFloodFill16( HDC16 hdc, INT16 x, INT16 y, COLORREF color,
1914                               UINT16 fillType )
1915 {
1916     return ExtFloodFill( HDC_32(hdc), x, y, color, fillType );
1917 }
1918
1919
1920 /***********************************************************************
1921  *           SetSystemPaletteUse   (GDI.373)
1922  */
1923 UINT16 WINAPI SetSystemPaletteUse16( HDC16 hdc, UINT16 use )
1924 {
1925     return SetSystemPaletteUse( HDC_32(hdc), use );
1926 }
1927
1928
1929 /***********************************************************************
1930  *           GetSystemPaletteUse   (GDI.374)
1931  */
1932 UINT16 WINAPI GetSystemPaletteUse16( HDC16 hdc )
1933 {
1934     return GetSystemPaletteUse( HDC_32(hdc) );
1935 }
1936
1937
1938 /***********************************************************************
1939  *           GetSystemPaletteEntries   (GDI.375)
1940  */
1941 UINT16 WINAPI GetSystemPaletteEntries16( HDC16 hdc, UINT16 start, UINT16 count,
1942                                          LPPALETTEENTRY entries )
1943 {
1944     return GetSystemPaletteEntries( HDC_32(hdc), start, count, entries );
1945 }
1946
1947
1948 /***********************************************************************
1949  *           ResetDC    (GDI.376)
1950  */
1951 HDC16 WINAPI ResetDC16( HDC16 hdc, const DEVMODEA *devmode )
1952 {
1953     return HDC_16( ResetDCA(HDC_32(hdc), devmode) );
1954 }
1955
1956
1957 /******************************************************************
1958  *           StartDoc   (GDI.377)
1959  */
1960 INT16 WINAPI StartDoc16( HDC16 hdc, const DOCINFO16 *lpdoc )
1961 {
1962     DOCINFOA docA;
1963
1964     docA.cbSize = lpdoc->cbSize;
1965     docA.lpszDocName = MapSL(lpdoc->lpszDocName);
1966     docA.lpszOutput = MapSL(lpdoc->lpszOutput);
1967     if(lpdoc->cbSize > offsetof(DOCINFO16,lpszDatatype))
1968         docA.lpszDatatype = MapSL(lpdoc->lpszDatatype);
1969     else
1970         docA.lpszDatatype = NULL;
1971     if(lpdoc->cbSize > offsetof(DOCINFO16,fwType))
1972         docA.fwType = lpdoc->fwType;
1973     else
1974         docA.fwType = 0;
1975     return StartDocA( HDC_32(hdc), &docA );
1976 }
1977
1978
1979 /******************************************************************
1980  *           EndDoc   (GDI.378)
1981  */
1982 INT16 WINAPI EndDoc16( HDC16 hdc )
1983 {
1984     return EndDoc( HDC_32(hdc) );
1985 }
1986
1987
1988 /******************************************************************
1989  *           StartPage   (GDI.379)
1990  */
1991 INT16 WINAPI StartPage16( HDC16 hdc )
1992 {
1993     return StartPage( HDC_32(hdc) );
1994 }
1995
1996
1997 /******************************************************************
1998  *           EndPage   (GDI.380)
1999  */
2000 INT16 WINAPI EndPage16( HDC16 hdc )
2001 {
2002     return EndPage( HDC_32(hdc) );
2003 }
2004
2005
2006 /******************************************************************************
2007  *           AbortDoc   (GDI.382)
2008  */
2009 INT16 WINAPI AbortDoc16( HDC16 hdc )
2010 {
2011     return AbortDoc( HDC_32(hdc) );
2012 }
2013
2014
2015 /***********************************************************************
2016  *           FastWindowFrame    (GDI.400)
2017  */
2018 BOOL16 WINAPI FastWindowFrame16( HDC16 hdc, const RECT16 *rect,
2019                                INT16 width, INT16 height, DWORD rop )
2020 {
2021     HDC hdc32 = HDC_32(hdc);
2022     HBRUSH hbrush = SelectObject( hdc32, GetStockObject( GRAY_BRUSH ) );
2023     PatBlt( hdc32, rect->left, rect->top,
2024             rect->right - rect->left - width, height, rop );
2025     PatBlt( hdc32, rect->left, rect->top + height, width,
2026             rect->bottom - rect->top - height, rop );
2027     PatBlt( hdc32, rect->left + width, rect->bottom - 1,
2028             rect->right - rect->left - width, -height, rop );
2029     PatBlt( hdc32, rect->right - 1, rect->top, -width,
2030             rect->bottom - rect->top - height, rop );
2031     SelectObject( hdc32, hbrush );
2032     return TRUE;
2033 }
2034
2035
2036 /***********************************************************************
2037  *           CreateUserBitmap    (GDI.407)
2038  */
2039 HBITMAP16 WINAPI CreateUserBitmap16( INT16 width, INT16 height, UINT16 planes,
2040                                      UINT16 bpp, LPCVOID bits )
2041 {
2042     return CreateBitmap16( width, height, planes, bpp, bits );
2043 }
2044
2045
2046 /***********************************************************************
2047  *           CreateUserDiscardableBitmap    (GDI.409)
2048  */
2049 HBITMAP16 WINAPI CreateUserDiscardableBitmap16( WORD dummy, INT16 width, INT16 height )
2050 {
2051     HDC hdc = CreateDCA( "DISPLAY", NULL, NULL, NULL );
2052     HBITMAP ret = CreateCompatibleBitmap( hdc, width, height );
2053     DeleteDC( hdc );
2054     return HBITMAP_16(ret);
2055 }
2056
2057
2058 /***********************************************************************
2059  *              GetCurLogFont (GDI.411)
2060  */
2061 HFONT16 WINAPI GetCurLogFont16( HDC16 hdc )
2062 {
2063     return HFONT_16( GetCurrentObject( HDC_32(hdc), OBJ_FONT ) );
2064 }
2065
2066
2067 /***********************************************************************
2068  *           StretchDIBits   (GDI.439)
2069  */
2070 INT16 WINAPI StretchDIBits16( HDC16 hdc, INT16 xDst, INT16 yDst, INT16 widthDst,
2071                               INT16 heightDst, INT16 xSrc, INT16 ySrc, INT16 widthSrc,
2072                               INT16 heightSrc, const VOID *bits,
2073                               const BITMAPINFO *info, UINT16 wUsage, DWORD dwRop )
2074 {
2075     return StretchDIBits( HDC_32(hdc), xDst, yDst, widthDst, heightDst,
2076                           xSrc, ySrc, widthSrc, heightSrc, bits,
2077                           info, wUsage, dwRop );
2078 }
2079
2080
2081 /***********************************************************************
2082  *           SetDIBits    (GDI.440)
2083  */
2084 INT16 WINAPI SetDIBits16( HDC16 hdc, HBITMAP16 hbitmap, UINT16 startscan,
2085                           UINT16 lines, LPCVOID bits, const BITMAPINFO *info,
2086                           UINT16 coloruse )
2087 {
2088     return SetDIBits( HDC_32(hdc), HBITMAP_32(hbitmap), startscan, lines, bits, info, coloruse );
2089 }
2090
2091
2092 /***********************************************************************
2093  *           GetDIBits    (GDI.441)
2094  */
2095 INT16 WINAPI GetDIBits16( HDC16 hdc, HBITMAP16 hbitmap, UINT16 startscan,
2096                           UINT16 lines, LPVOID bits, BITMAPINFO * info,
2097                           UINT16 coloruse )
2098 {
2099     return GetDIBits( HDC_32(hdc), HBITMAP_32(hbitmap), startscan, lines, bits, info, coloruse );
2100 }
2101
2102
2103 /***********************************************************************
2104  *           CreateDIBitmap    (GDI.442)
2105  */
2106 HBITMAP16 WINAPI CreateDIBitmap16( HDC16 hdc, const BITMAPINFOHEADER * header,
2107                                    DWORD init, LPCVOID bits, const BITMAPINFO * data,
2108                                    UINT16 coloruse )
2109 {
2110     return HBITMAP_16( CreateDIBitmap( HDC_32(hdc), header, init, bits, data, coloruse ) );
2111 }
2112
2113
2114 /***********************************************************************
2115  *           SetDIBitsToDevice    (GDI.443)
2116  */
2117 INT16 WINAPI SetDIBitsToDevice16( HDC16 hdc, INT16 xDest, INT16 yDest, INT16 cx,
2118                                   INT16 cy, INT16 xSrc, INT16 ySrc, UINT16 startscan,
2119                                   UINT16 lines, LPCVOID bits, const BITMAPINFO *info,
2120                                   UINT16 coloruse )
2121 {
2122     return SetDIBitsToDevice( HDC_32(hdc), xDest, yDest, cx, cy, xSrc, ySrc,
2123                               startscan, lines, bits, info, coloruse );
2124 }
2125
2126
2127 /***********************************************************************
2128  *           CreateRoundRectRgn    (GDI.444)
2129  *
2130  * If either ellipse dimension is zero we call CreateRectRgn16 for its
2131  * `special' behaviour. -ve ellipse dimensions can result in GPFs under win3.1
2132  * we just let CreateRoundRectRgn convert them to +ve values.
2133  */
2134
2135 HRGN16 WINAPI CreateRoundRectRgn16( INT16 left, INT16 top, INT16 right, INT16 bottom,
2136                                     INT16 ellipse_width, INT16 ellipse_height )
2137 {
2138     if( ellipse_width == 0 || ellipse_height == 0 )
2139         return CreateRectRgn16( left, top, right, bottom );
2140     else
2141         return HRGN_16( CreateRoundRectRgn( left, top, right, bottom,
2142                                             ellipse_width, ellipse_height ));
2143 }
2144
2145
2146 /***********************************************************************
2147  *           CreateDIBPatternBrush    (GDI.445)
2148  */
2149 HBRUSH16 WINAPI CreateDIBPatternBrush16( HGLOBAL16 hbitmap, UINT16 coloruse )
2150 {
2151     BITMAPINFO *bmi;
2152     HBRUSH16 ret;
2153
2154     if (!(bmi = GlobalLock16( hbitmap ))) return 0;
2155     ret = HBRUSH_16( CreateDIBPatternBrushPt( bmi, coloruse ));
2156     GlobalUnlock16( hbitmap );
2157     return ret;
2158 }
2159
2160
2161 /**********************************************************************
2162  *          PolyPolygon (GDI.450)
2163  */
2164 BOOL16 WINAPI PolyPolygon16( HDC16 hdc, const POINT16* pt, const INT16* counts,
2165                              UINT16 polygons )
2166 {
2167     int         i,nrpts;
2168     LPPOINT     pt32;
2169     LPINT       counts32;
2170     BOOL16      ret;
2171
2172     nrpts=0;
2173     for (i=polygons;i--;)
2174         nrpts+=counts[i];
2175     pt32 = (LPPOINT)HeapAlloc( GetProcessHeap(), 0, sizeof(POINT)*nrpts);
2176     if(pt32 == NULL) return FALSE;
2177     for (i=nrpts;i--;)
2178         CONV_POINT16TO32(&(pt[i]),&(pt32[i]));
2179     counts32 = (LPINT)HeapAlloc( GetProcessHeap(), 0, polygons*sizeof(INT) );
2180     if(counts32 == NULL) {
2181         HeapFree( GetProcessHeap(), 0, pt32 );
2182         return FALSE;
2183     }
2184     for (i=polygons;i--;) counts32[i]=counts[i];
2185
2186     ret = PolyPolygon(HDC_32(hdc),pt32,counts32,polygons);
2187     HeapFree( GetProcessHeap(), 0, counts32 );
2188     HeapFree( GetProcessHeap(), 0, pt32 );
2189     return ret;
2190 }
2191
2192
2193 /***********************************************************************
2194  *           CreatePolyPolygonRgn    (GDI.451)
2195  */
2196 HRGN16 WINAPI CreatePolyPolygonRgn16( const POINT16 *points,
2197                                       const INT16 *count, INT16 nbpolygons, INT16 mode )
2198 {
2199     HRGN hrgn;
2200     int i, npts = 0;
2201     INT *count32;
2202     POINT *points32;
2203
2204     for (i = 0; i < nbpolygons; i++) npts += count[i];
2205     points32 = HeapAlloc( GetProcessHeap(), 0, npts * sizeof(POINT) );
2206     for (i = 0; i < npts; i++) CONV_POINT16TO32( &(points[i]), &(points32[i]) );
2207
2208     count32 = HeapAlloc( GetProcessHeap(), 0, nbpolygons * sizeof(INT) );
2209     for (i = 0; i < nbpolygons; i++) count32[i] = count[i];
2210     hrgn = CreatePolyPolygonRgn( points32, count32, nbpolygons, mode );
2211     HeapFree( GetProcessHeap(), 0, count32 );
2212     HeapFree( GetProcessHeap(), 0, points32 );
2213     return HRGN_16(hrgn);
2214 }
2215
2216
2217 /***********************************************************************
2218  *           SetObjectOwner    (GDI.461)
2219  */
2220 void WINAPI SetObjectOwner16( HGDIOBJ16 handle, HANDLE16 owner )
2221 {
2222     /* Nothing to do */
2223 }
2224
2225
2226 /***********************************************************************
2227  *           RectVisible    (GDI.465)
2228  *           RectVisibleOld (GDI.104)
2229  */
2230 BOOL16 WINAPI RectVisible16( HDC16 hdc, const RECT16* rect16 )
2231 {
2232     RECT rect;
2233     CONV_RECT16TO32( rect16, &rect );
2234     return RectVisible( HDC_32(hdc), &rect );
2235 }
2236
2237
2238 /***********************************************************************
2239  *           RectInRegion    (GDI.466)
2240  *           RectInRegionOld (GDI.181)
2241  */
2242 BOOL16 WINAPI RectInRegion16( HRGN16 hrgn, const RECT16 *rect )
2243 {
2244     RECT r32;
2245
2246     CONV_RECT16TO32(rect, &r32);
2247     return RectInRegion( HRGN_32(hrgn), &r32 );
2248 }
2249
2250
2251 /***********************************************************************
2252  *           GetBitmapDimensionEx    (GDI.468)
2253  */
2254 BOOL16 WINAPI GetBitmapDimensionEx16( HBITMAP16 hbitmap, LPSIZE16 size )
2255 {
2256     SIZE size32;
2257     BOOL ret = GetBitmapDimensionEx( HBITMAP_32(hbitmap), &size32 );
2258
2259     if (ret)
2260     {
2261         size->cx = size32.cx;
2262         size->cy = size32.cy;
2263     }
2264     return ret;
2265 }
2266
2267
2268 /***********************************************************************
2269  *              GetBrushOrgEx (GDI.469)
2270  */
2271 BOOL16 WINAPI GetBrushOrgEx16( HDC16 hdc, LPPOINT16 pt )
2272 {
2273     POINT pt32;
2274     if (!GetBrushOrgEx( HDC_32(hdc), &pt32 )) return FALSE;
2275     pt->x = pt32.x;
2276     pt->y = pt32.y;
2277     return TRUE;
2278 }
2279
2280
2281 /***********************************************************************
2282  *              GetCurrentPositionEx (GDI.470)
2283  */
2284 BOOL16 WINAPI GetCurrentPositionEx16( HDC16 hdc, LPPOINT16 pt )
2285 {
2286     POINT pt32;
2287     if (!GetCurrentPositionEx( HDC_32(hdc), &pt32 )) return FALSE;
2288     pt->x = pt32.x;
2289     pt->y = pt32.y;
2290     return TRUE;
2291 }
2292
2293
2294 /***********************************************************************
2295  *           GetTextExtentPoint    (GDI.471)
2296  *
2297  * FIXME: Should this have a bug for compatibility?
2298  * Original Windows versions of GetTextExtentPoint{A,W} have documented
2299  * bugs (-> MSDN KB q147647.txt).
2300  */
2301 BOOL16 WINAPI GetTextExtentPoint16( HDC16 hdc, LPCSTR str, INT16 count, LPSIZE16 size )
2302 {
2303     SIZE size32;
2304     BOOL ret = GetTextExtentPoint32A( HDC_32(hdc), str, count, &size32 );
2305
2306     if (ret)
2307     {
2308         size->cx = size32.cx;
2309         size->cy = size32.cy;
2310     }
2311     return ret;
2312 }
2313
2314
2315 /***********************************************************************
2316  *              GetViewportExtEx (GDI.472)
2317  */
2318 BOOL16 WINAPI GetViewportExtEx16( HDC16 hdc, LPSIZE16 size )
2319 {
2320     SIZE size32;
2321     if (!GetViewportExtEx( HDC_32(hdc), &size32 )) return FALSE;
2322     size->cx = size32.cx;
2323     size->cy = size32.cy;
2324     return TRUE;
2325 }
2326
2327
2328 /***********************************************************************
2329  *              GetViewportOrgEx (GDI.473)
2330  */
2331 BOOL16 WINAPI GetViewportOrgEx16( HDC16 hdc, LPPOINT16 pt )
2332 {
2333     POINT pt32;
2334     if (!GetViewportOrgEx( HDC_32(hdc), &pt32 )) return FALSE;
2335     pt->x = pt32.x;
2336     pt->y = pt32.y;
2337     return TRUE;
2338 }
2339
2340
2341 /***********************************************************************
2342  *              GetWindowExtEx (GDI.474)
2343  */
2344 BOOL16 WINAPI GetWindowExtEx16( HDC16 hdc, LPSIZE16 size )
2345 {
2346     SIZE size32;
2347     if (!GetWindowExtEx( HDC_32(hdc), &size32 )) return FALSE;
2348     size->cx = size32.cx;
2349     size->cy = size32.cy;
2350     return TRUE;
2351 }
2352
2353
2354 /***********************************************************************
2355  *              GetWindowOrgEx (GDI.475)
2356  */
2357 BOOL16 WINAPI GetWindowOrgEx16( HDC16 hdc, LPPOINT16 pt )
2358 {
2359     POINT pt32;
2360     if (!GetWindowOrgEx( HDC_32(hdc), &pt32 )) return FALSE;
2361     pt->x = pt32.x;
2362     pt->y = pt32.y;
2363     return TRUE;
2364 }
2365
2366
2367 /***********************************************************************
2368  *           OffsetViewportOrgEx    (GDI.476)
2369  */
2370 BOOL16 WINAPI OffsetViewportOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt)
2371 {
2372     POINT pt32;
2373     BOOL16 ret = OffsetViewportOrgEx( HDC_32(hdc), x, y, &pt32 );
2374     if (pt) CONV_POINT32TO16( &pt32, pt );
2375     return ret;
2376 }
2377
2378
2379 /***********************************************************************
2380  *           OffsetWindowOrgEx    (GDI.477)
2381  */
2382 BOOL16 WINAPI OffsetWindowOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
2383 {
2384     POINT pt32;
2385     BOOL16 ret = OffsetWindowOrgEx( HDC_32(hdc), x, y, &pt32 );
2386     if (pt) CONV_POINT32TO16( &pt32, pt );
2387     return ret;
2388 }
2389
2390
2391 /***********************************************************************
2392  *           SetBitmapDimensionEx    (GDI.478)
2393  */
2394 BOOL16 WINAPI SetBitmapDimensionEx16( HBITMAP16 hbitmap, INT16 x, INT16 y, LPSIZE16 prevSize )
2395 {
2396     SIZE size32;
2397     BOOL ret = SetBitmapDimensionEx( HBITMAP_32(hbitmap), x, y, &size32 );
2398
2399     if (ret && prevSize)
2400     {
2401         prevSize->cx = size32.cx;
2402         prevSize->cy = size32.cy;
2403     }
2404     return ret;
2405 }
2406
2407
2408 /***********************************************************************
2409  *           SetViewportExtEx    (GDI.479)
2410  */
2411 BOOL16 WINAPI SetViewportExtEx16( HDC16 hdc, INT16 x, INT16 y, LPSIZE16 size )
2412 {
2413     SIZE size32;
2414     BOOL16 ret = SetViewportExtEx( HDC_32(hdc), x, y, &size32 );
2415     if (size) { size->cx = size32.cx; size->cy = size32.cy; }
2416     return ret;
2417 }
2418
2419
2420 /***********************************************************************
2421  *           SetViewportOrgEx    (GDI.480)
2422  */
2423 BOOL16 WINAPI SetViewportOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
2424 {
2425     POINT pt32;
2426     BOOL16 ret = SetViewportOrgEx( HDC_32(hdc), x, y, &pt32 );
2427     if (pt) CONV_POINT32TO16( &pt32, pt );
2428     return ret;
2429 }
2430
2431
2432 /***********************************************************************
2433  *           SetWindowExtEx    (GDI.481)
2434  */
2435 BOOL16 WINAPI SetWindowExtEx16( HDC16 hdc, INT16 x, INT16 y, LPSIZE16 size )
2436 {
2437     SIZE size32;
2438     BOOL16 ret = SetWindowExtEx( HDC_32(hdc), x, y, &size32 );
2439     if (size) { size->cx = size32.cx; size->cy = size32.cy; }
2440     return ret;
2441 }
2442
2443
2444 /***********************************************************************
2445  *           SetWindowOrgEx    (GDI.482)
2446  */
2447 BOOL16 WINAPI SetWindowOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
2448 {
2449     POINT pt32;
2450     BOOL16 ret = SetWindowOrgEx( HDC_32(hdc), x, y, &pt32 );
2451     if (pt) CONV_POINT32TO16( &pt32, pt );
2452     return ret;
2453 }
2454
2455
2456 /***********************************************************************
2457  *           MoveToEx    (GDI.483)
2458  */
2459 BOOL16 WINAPI MoveToEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
2460 {
2461     POINT pt32;
2462
2463     if (!MoveToEx( HDC_32(hdc), x, y, &pt32 )) return FALSE;
2464     if (pt) CONV_POINT32TO16( &pt32, pt );
2465     return TRUE;
2466 }
2467
2468
2469 /***********************************************************************
2470  *           ScaleViewportExtEx    (GDI.484)
2471  */
2472 BOOL16 WINAPI ScaleViewportExtEx16( HDC16 hdc, INT16 xNum, INT16 xDenom,
2473                                     INT16 yNum, INT16 yDenom, LPSIZE16 size )
2474 {
2475     SIZE size32;
2476     BOOL16 ret = ScaleViewportExtEx( HDC_32(hdc), xNum, xDenom, yNum, yDenom,
2477                                        &size32 );
2478     if (size) { size->cx = size32.cx; size->cy = size32.cy; }
2479     return ret;
2480 }
2481
2482
2483 /***********************************************************************
2484  *           ScaleWindowExtEx    (GDI.485)
2485  */
2486 BOOL16 WINAPI ScaleWindowExtEx16( HDC16 hdc, INT16 xNum, INT16 xDenom,
2487                                   INT16 yNum, INT16 yDenom, LPSIZE16 size )
2488 {
2489     SIZE size32;
2490     BOOL16 ret = ScaleWindowExtEx( HDC_32(hdc), xNum, xDenom, yNum, yDenom,
2491                                      &size32 );
2492     if (size) { size->cx = size32.cx; size->cy = size32.cy; }
2493     return ret;
2494 }
2495
2496
2497 /******************************************************************************
2498  *           PolyBezier  (GDI.502)
2499  */
2500 BOOL16 WINAPI PolyBezier16( HDC16 hdc, const POINT16* lppt, INT16 cPoints )
2501 {
2502     int i;
2503     BOOL16 ret;
2504     LPPOINT pt32 = (LPPOINT)HeapAlloc( GetProcessHeap(), 0,
2505                                            cPoints*sizeof(POINT) );
2506     if(!pt32) return FALSE;
2507     for (i=cPoints;i--;) CONV_POINT16TO32(&(lppt[i]),&(pt32[i]));
2508     ret= PolyBezier(HDC_32(hdc), pt32, cPoints);
2509     HeapFree( GetProcessHeap(), 0, pt32 );
2510     return ret;
2511 }
2512
2513
2514 /******************************************************************************
2515  *           PolyBezierTo  (GDI.503)
2516  */
2517 BOOL16 WINAPI PolyBezierTo16( HDC16 hdc, const POINT16* lppt, INT16 cPoints )
2518 {
2519     int i;
2520     BOOL16 ret;
2521     LPPOINT pt32 = (LPPOINT)HeapAlloc( GetProcessHeap(), 0,
2522                                            cPoints*sizeof(POINT) );
2523     if(!pt32) return FALSE;
2524     for (i=cPoints;i--;) CONV_POINT16TO32(&(lppt[i]),&(pt32[i]));
2525     ret= PolyBezierTo(HDC_32(hdc), pt32, cPoints);
2526     HeapFree( GetProcessHeap(), 0, pt32 );
2527     return ret;
2528 }
2529
2530
2531 /******************************************************************************
2532  *           ExtSelectClipRgn   (GDI.508)
2533  */
2534 INT16 WINAPI ExtSelectClipRgn16( HDC16 hdc, HRGN16 hrgn, INT16 fnMode )
2535 {
2536   return ExtSelectClipRgn( HDC_32(hdc), HRGN_32(hrgn), fnMode);
2537 }
2538
2539
2540 /***********************************************************************
2541  *           AbortPath    (GDI.511)
2542  */
2543 BOOL16 WINAPI AbortPath16(HDC16 hdc)
2544 {
2545     return AbortPath( HDC_32(hdc) );
2546 }
2547
2548
2549 /***********************************************************************
2550  *           BeginPath    (GDI.512)
2551  */
2552 BOOL16 WINAPI BeginPath16(HDC16 hdc)
2553 {
2554     return BeginPath( HDC_32(hdc) );
2555 }
2556
2557
2558 /***********************************************************************
2559  *           CloseFigure    (GDI.513)
2560  */
2561 BOOL16 WINAPI CloseFigure16(HDC16 hdc)
2562 {
2563     return CloseFigure( HDC_32(hdc) );
2564 }
2565
2566
2567 /***********************************************************************
2568  *           EndPath    (GDI.514)
2569  */
2570 BOOL16 WINAPI EndPath16(HDC16 hdc)
2571 {
2572     return EndPath( HDC_32(hdc) );
2573 }
2574
2575
2576 /***********************************************************************
2577  *           FillPath    (GDI.515)
2578  */
2579 BOOL16 WINAPI FillPath16(HDC16 hdc)
2580 {
2581     return FillPath( HDC_32(hdc) );
2582 }
2583
2584
2585 /*******************************************************************
2586  *           FlattenPath    (GDI.516)
2587  */
2588 BOOL16 WINAPI FlattenPath16(HDC16 hdc)
2589 {
2590     return FlattenPath( HDC_32(hdc) );
2591 }
2592
2593
2594 /***********************************************************************
2595  *           GetPath    (GDI.517)
2596  */
2597 INT16 WINAPI GetPath16(HDC16 hdc, LPPOINT16 pPoints, LPBYTE pTypes, INT16 nSize)
2598 {
2599     FIXME("(%d,%p,%p): stub\n",hdc,pPoints,pTypes);
2600     return 0;
2601 }
2602
2603
2604 /***********************************************************************
2605  *           PathToRegion    (GDI.518)
2606  */
2607 HRGN16 WINAPI PathToRegion16(HDC16 hdc)
2608 {
2609     return HRGN_16( PathToRegion( HDC_32(hdc) ));
2610 }
2611
2612
2613 /***********************************************************************
2614  *           SelectClipPath    (GDI.519)
2615  */
2616 BOOL16 WINAPI SelectClipPath16(HDC16 hdc, INT16 iMode)
2617 {
2618     return SelectClipPath( HDC_32(hdc), iMode );
2619 }
2620
2621
2622 /*******************************************************************
2623  *           StrokeAndFillPath    (GDI.520)
2624  */
2625 BOOL16 WINAPI StrokeAndFillPath16(HDC16 hdc)
2626 {
2627     return StrokeAndFillPath( HDC_32(hdc) );
2628 }
2629
2630
2631 /*******************************************************************
2632  *           StrokePath    (GDI.521)
2633  */
2634 BOOL16 WINAPI StrokePath16(HDC16 hdc)
2635 {
2636     return StrokePath( HDC_32(hdc) );
2637 }
2638
2639
2640 /*******************************************************************
2641  *           WidenPath    (GDI.522)
2642  */
2643 BOOL16 WINAPI WidenPath16(HDC16 hdc)
2644 {
2645     return WidenPath( HDC_32(hdc) );
2646 }
2647
2648
2649 /***********************************************************************
2650  *              GetArcDirection (GDI.524)
2651  */
2652 INT16 WINAPI GetArcDirection16( HDC16 hdc )
2653 {
2654     return GetArcDirection( HDC_32(hdc) );
2655 }
2656
2657
2658 /***********************************************************************
2659  *           SetArcDirection    (GDI.525)
2660  */
2661 INT16 WINAPI SetArcDirection16( HDC16 hdc, INT16 nDirection )
2662 {
2663     return SetArcDirection( HDC_32(hdc), (INT)nDirection );
2664 }
2665
2666
2667 /***********************************************************************
2668  *           CreateHalftonePalette (GDI.529)
2669  */
2670 HPALETTE16 WINAPI CreateHalftonePalette16( HDC16 hdc )
2671 {
2672     return HPALETTE_16( CreateHalftonePalette( HDC_32(hdc) ));
2673 }
2674
2675
2676 /***********************************************************************
2677  *           SetDIBColorTable    (GDI.602)
2678  */
2679 UINT16 WINAPI SetDIBColorTable16( HDC16 hdc, UINT16 startpos, UINT16 entries, RGBQUAD *colors )
2680 {
2681     return SetDIBColorTable( HDC_32(hdc), startpos, entries, colors );
2682 }
2683
2684
2685 /***********************************************************************
2686  *           GetDIBColorTable    (GDI.603)
2687  */
2688 UINT16 WINAPI GetDIBColorTable16( HDC16 hdc, UINT16 startpos, UINT16 entries, RGBQUAD *colors )
2689 {
2690     return GetDIBColorTable( HDC_32(hdc), startpos, entries, colors );
2691 }
2692
2693
2694 /***********************************************************************
2695  *           GetRegionData   (GDI.607)
2696  *
2697  * FIXME: is LPRGNDATA the same in Win16 and Win32 ?
2698  */
2699 DWORD WINAPI GetRegionData16( HRGN16 hrgn, DWORD count, LPRGNDATA rgndata )
2700 {
2701     return GetRegionData( HRGN_32(hrgn), count, rgndata );
2702 }
2703
2704
2705 /***********************************************************************
2706  *           GetTextCharset   (GDI.612)
2707  */
2708 UINT16 WINAPI GetTextCharset16( HDC16 hdc )
2709 {
2710     return GetTextCharset( HDC_32(hdc) );
2711 }
2712
2713
2714 /*************************************************************************
2715  *             GetFontLanguageInfo   (GDI.616)
2716  */
2717 DWORD WINAPI GetFontLanguageInfo16( HDC16 hdc )
2718 {
2719     return GetFontLanguageInfo( HDC_32(hdc) );
2720 }
2721
2722
2723 /***********************************************************************
2724  *           SetLayout   (GDI.1000)
2725  *
2726  * Sets left->right or right->left text layout flags of a dc.
2727  */
2728 BOOL16 WINAPI SetLayout16( HDC16 hdc, DWORD layout )
2729 {
2730     return SetLayout( HDC_32(hdc), layout );
2731 }