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