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