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