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     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     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, FIELD_OFFSET(HANDLETABLE, objectHandle[handles] ));
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     FIXME( "%04x %x: not supported\n", hdc, flags );
2021     return 0;
2022 }
2023
2024
2025 /***********************************************************************
2026  *           SetBoundsRect    (GDI.193)
2027  */
2028 UINT16 WINAPI SetBoundsRect16( HDC16 hdc, const RECT16* rect, UINT16 flags )
2029 {
2030     if (rect)
2031     {
2032         RECT rect32;
2033         rect32.left   = rect->left;
2034         rect32.top    = rect->top;
2035         rect32.right  = rect->right;
2036         rect32.bottom = rect->bottom;
2037         return SetBoundsRect( HDC_32( hdc ), &rect32, flags );
2038     }
2039     else return SetBoundsRect( HDC_32( hdc ), NULL, flags );
2040 }
2041
2042
2043 /***********************************************************************
2044  *           GetBoundsRect    (GDI.194)
2045  */
2046 UINT16 WINAPI GetBoundsRect16( HDC16 hdc, LPRECT16 rect, UINT16 flags)
2047 {
2048     RECT rect32;
2049     UINT ret = GetBoundsRect( HDC_32( hdc ), &rect32, flags );
2050     if (rect)
2051     {
2052         rect->left   = rect32.left;
2053         rect->top    = rect32.top;
2054         rect->right  = rect32.right;
2055         rect->bottom = rect32.bottom;
2056     }
2057     return ret;
2058 }
2059
2060
2061 /***********************************************************************
2062  *              EngineEnumerateFont (GDI.300)
2063  */
2064 WORD WINAPI EngineEnumerateFont16(LPSTR fontname, FARPROC16 proc, DWORD data )
2065 {
2066     FIXME("(%s,%p,%x),stub\n",fontname,proc,data);
2067     return 0;
2068 }
2069
2070
2071 /***********************************************************************
2072  *              EngineDeleteFont (GDI.301)
2073  */
2074 WORD WINAPI EngineDeleteFont16(LPFONTINFO16 lpFontInfo)
2075 {
2076     WORD handle;
2077
2078     /*  untested, don't know if it works.
2079         We seem to access some structure that is located after the
2080         FONTINFO. The FONTINFO documentation says that there may
2081         follow some char-width table or font bitmap or vector info.
2082         I think it is some kind of font bitmap that begins at offset 0x52,
2083         as FONTINFO goes up to 0x51.
2084         If this is correct, everything should be implemented correctly.
2085     */
2086     if ( ((lpFontInfo->dfType & (RASTER_FONTTYPE|DEVICE_FONTTYPE)) == (RASTER_FONTTYPE|DEVICE_FONTTYPE))
2087          && (LOWORD(lpFontInfo->dfFace) == LOWORD(lpFontInfo)+0x6e)
2088          && (handle = *(WORD *)(lpFontInfo+0x54)) )
2089     {
2090         *(WORD *)(lpFontInfo+0x54) = 0;
2091         GlobalFree16(handle);
2092     }
2093     return 1;
2094 }
2095
2096
2097 /***********************************************************************
2098  *              EngineRealizeFont (GDI.302)
2099  */
2100 WORD WINAPI EngineRealizeFont16(LPLOGFONT16 lplogFont, LPTEXTXFORM16 lptextxform, LPFONTINFO16 lpfontInfo)
2101 {
2102     FIXME("(%p,%p,%p),stub\n",lplogFont,lptextxform,lpfontInfo);
2103
2104     return 0;
2105 }
2106
2107
2108 /***********************************************************************
2109  *              EngineRealizeFontExt (GDI.315)
2110  */
2111 WORD WINAPI EngineRealizeFontExt16(LONG l1, LONG l2, LONG l3, LONG l4)
2112 {
2113     FIXME("(%08x,%08x,%08x,%08x),stub\n",l1,l2,l3,l4);
2114
2115     return 0;
2116 }
2117
2118
2119 /***********************************************************************
2120  *              EngineGetCharWidth (GDI.303)
2121  */
2122 WORD WINAPI EngineGetCharWidth16(LPFONTINFO16 lpFontInfo, BYTE firstChar, BYTE lastChar, LPINT16 buffer)
2123 {
2124     int i;
2125
2126     for (i = firstChar; i <= lastChar; i++)
2127        FIXME(" returns font's average width for range %d to %d\n", firstChar, lastChar);
2128     *buffer++ = lpFontInfo->dfAvgWidth; /* insert some charwidth functionality here; use average width for now */
2129     return 1;
2130 }
2131
2132
2133 /***********************************************************************
2134  *              EngineSetFontContext (GDI.304)
2135  */
2136 WORD WINAPI EngineSetFontContext16(LPFONTINFO16 lpFontInfo, WORD data)
2137 {
2138    FIXME("stub?\n");
2139    return 0;
2140 }
2141
2142 /***********************************************************************
2143  *              EngineGetGlyphBMP (GDI.305)
2144  */
2145 WORD WINAPI EngineGetGlyphBMP16(WORD word, LPFONTINFO16 lpFontInfo, WORD w1, WORD w2,
2146                               LPSTR string, DWORD dword, /*LPBITMAPMETRICS16*/ LPVOID metrics)
2147 {
2148     FIXME("stub?\n");
2149     return 0;
2150 }
2151
2152
2153 /***********************************************************************
2154  *              EngineMakeFontDir (GDI.306)
2155  */
2156 DWORD WINAPI EngineMakeFontDir16(HDC16 hdc, LPFONTDIR16 fontdir, LPCSTR string)
2157 {
2158     FIXME(" stub! (always fails)\n");
2159     return ~0UL; /* error */
2160 }
2161
2162
2163 /***********************************************************************
2164  *           GetCharABCWidths   (GDI.307)
2165  */
2166 BOOL16 WINAPI GetCharABCWidths16( HDC16 hdc, UINT16 firstChar, UINT16 lastChar, LPABC16 abc )
2167 {
2168     BOOL ret;
2169     UINT i;
2170     LPABC abc32 = HeapAlloc( GetProcessHeap(), 0, sizeof(ABC) * (lastChar - firstChar + 1) );
2171
2172     if ((ret = GetCharABCWidthsA( HDC_32(hdc), firstChar, lastChar, abc32 )))
2173     {
2174         for (i = firstChar; i <= lastChar; i++)
2175         {
2176             abc[i-firstChar].abcA = abc32[i-firstChar].abcA;
2177             abc[i-firstChar].abcB = abc32[i-firstChar].abcB;
2178             abc[i-firstChar].abcC = abc32[i-firstChar].abcC;
2179         }
2180     }
2181     HeapFree( GetProcessHeap(), 0, abc32 );
2182     return ret;
2183 }
2184
2185
2186 /***********************************************************************
2187  *           GetOutlineTextMetrics (GDI.308)
2188  *
2189  * Gets metrics for TrueType fonts.
2190  *
2191  * PARAMS
2192  *    hdc    [In]  Handle of device context
2193  *    cbData [In]  Size of metric data array
2194  *    lpOTM  [Out] Address of metric data array
2195  *
2196  * RETURNS
2197  *    Success: Non-zero or size of required buffer
2198  *    Failure: 0
2199  *
2200  * NOTES
2201  *    lpOTM should be LPOUTLINETEXTMETRIC
2202  */
2203 UINT16 WINAPI GetOutlineTextMetrics16( HDC16 hdc, UINT16 cbData,
2204                                        LPOUTLINETEXTMETRIC16 lpOTM )
2205 {
2206     FIXME("(%04x,%04x,%p): stub\n", hdc,cbData,lpOTM);
2207     return 0;
2208 }
2209
2210
2211 /***********************************************************************
2212  *           GetGlyphOutline    (GDI.309)
2213  */
2214 DWORD WINAPI GetGlyphOutline16( HDC16 hdc, UINT16 uChar, UINT16 fuFormat,
2215                                 LPGLYPHMETRICS16 lpgm, DWORD cbBuffer,
2216                                 LPVOID lpBuffer, const MAT2 *lpmat2 )
2217 {
2218     DWORD ret;
2219     GLYPHMETRICS gm32;
2220
2221     ret = GetGlyphOutlineA( HDC_32(hdc), uChar, fuFormat, &gm32, cbBuffer, lpBuffer, lpmat2);
2222     if (ret && ret != GDI_ERROR)
2223     {
2224         lpgm->gmBlackBoxX = gm32.gmBlackBoxX;
2225         lpgm->gmBlackBoxY = gm32.gmBlackBoxY;
2226         lpgm->gmptGlyphOrigin.x = gm32.gmptGlyphOrigin.x;
2227         lpgm->gmptGlyphOrigin.y = gm32.gmptGlyphOrigin.y;
2228         lpgm->gmCellIncX = gm32.gmCellIncX;
2229         lpgm->gmCellIncY = gm32.gmCellIncY;
2230     }
2231     return ret;
2232 }
2233
2234
2235 /***********************************************************************
2236  *           CreateScalableFontResource   (GDI.310)
2237  */
2238 BOOL16 WINAPI CreateScalableFontResource16( UINT16 fHidden, LPCSTR lpszResourceFile,
2239                                             LPCSTR fontFile, LPCSTR path )
2240 {
2241     return CreateScalableFontResourceA( fHidden, lpszResourceFile, fontFile, path );
2242 }
2243
2244
2245 /*************************************************************************
2246  *             GetFontData    (GDI.311)
2247  *
2248  */
2249 DWORD WINAPI GetFontData16( HDC16 hdc, DWORD table, DWORD offset, LPVOID buffer, DWORD count )
2250 {
2251     return GetFontData( HDC_32(hdc), table, offset, buffer, count );
2252 }
2253
2254
2255 /*************************************************************************
2256  *             GetRasterizerCaps   (GDI.313)
2257  */
2258 BOOL16 WINAPI GetRasterizerCaps16( LPRASTERIZER_STATUS lprs, UINT16 cbNumBytes )
2259 {
2260     return GetRasterizerCaps( lprs, cbNumBytes );
2261 }
2262
2263
2264 /***********************************************************************
2265  *             EnumFontFamilies    (GDI.330)
2266  */
2267 INT16 WINAPI EnumFontFamilies16( HDC16 hDC, LPCSTR lpFamily,
2268                                  FONTENUMPROC16 efproc, LPARAM lpData )
2269 {
2270     LOGFONT16 lf, *plf;
2271
2272     if (lpFamily)
2273     {
2274         if (!*lpFamily) return 1;
2275         lstrcpynA( lf.lfFaceName, lpFamily, LF_FACESIZE );
2276         lf.lfCharSet = DEFAULT_CHARSET;
2277         lf.lfPitchAndFamily = 0;
2278         plf = &lf;
2279     }
2280     else plf = NULL;
2281
2282     return EnumFontFamiliesEx16( hDC, plf, efproc, lpData, 0 );
2283 }
2284
2285
2286 /*************************************************************************
2287  *             GetKerningPairs   (GDI.332)
2288  *
2289  */
2290 INT16 WINAPI GetKerningPairs16( HDC16 hdc, INT16 count, LPKERNINGPAIR16 pairs )
2291 {
2292     KERNINGPAIR *pairs32;
2293     INT i, ret;
2294
2295     if (!count) return 0;
2296
2297     if (!(pairs32 = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*pairs32) ))) return 0;
2298     if ((ret = GetKerningPairsA( HDC_32(hdc), count, pairs32 )))
2299     {
2300         for (i = 0; i < ret; i++)
2301         {
2302             pairs->wFirst      = pairs32->wFirst;
2303             pairs->wSecond     = pairs32->wSecond;
2304             pairs->iKernAmount = pairs32->iKernAmount;
2305         }
2306     }
2307     HeapFree( GetProcessHeap(), 0, pairs32 );
2308     return ret;
2309 }
2310
2311
2312
2313 /***********************************************************************
2314  *              GetTextAlign (GDI.345)
2315  */
2316 UINT16 WINAPI GetTextAlign16( HDC16 hdc )
2317 {
2318     return GetTextAlign( HDC_32(hdc) );
2319 }
2320
2321
2322 /***********************************************************************
2323  *           SetTextAlign    (GDI.346)
2324  */
2325 UINT16 WINAPI SetTextAlign16( HDC16 hdc, UINT16 align )
2326 {
2327     return SetTextAlign( HDC_32(hdc), align );
2328 }
2329
2330
2331 /***********************************************************************
2332  *           Chord    (GDI.348)
2333  */
2334 BOOL16 WINAPI Chord16( HDC16 hdc, INT16 left, INT16 top,
2335                        INT16 right, INT16 bottom, INT16 xstart, INT16 ystart,
2336                        INT16 xend, INT16 yend )
2337 {
2338     return Chord( HDC_32(hdc), left, top, right, bottom, xstart, ystart, xend, yend );
2339 }
2340
2341
2342 /***********************************************************************
2343  *           SetMapperFlags    (GDI.349)
2344  */
2345 DWORD WINAPI SetMapperFlags16( HDC16 hdc, DWORD flags )
2346 {
2347     return SetMapperFlags( HDC_32(hdc), flags );
2348 }
2349
2350
2351 /***********************************************************************
2352  *           GetCharWidth    (GDI.350)
2353  */
2354 BOOL16 WINAPI GetCharWidth16( HDC16 hdc, UINT16 firstChar, UINT16 lastChar, LPINT16 buffer )
2355 {
2356     BOOL retVal = FALSE;
2357
2358     if( firstChar != lastChar )
2359     {
2360         LPINT buf32 = HeapAlloc(GetProcessHeap(), 0, sizeof(INT)*(1 + (lastChar - firstChar)));
2361         if( buf32 )
2362         {
2363             LPINT obuf32 = buf32;
2364             int i;
2365
2366             retVal = GetCharWidth32A( HDC_32(hdc), firstChar, lastChar, buf32);
2367             if (retVal)
2368             {
2369                 for (i = firstChar; i <= lastChar; i++) *buffer++ = *buf32++;
2370             }
2371             HeapFree(GetProcessHeap(), 0, obuf32);
2372         }
2373     }
2374     else /* happens quite often to warrant a special treatment */
2375     {
2376         INT chWidth;
2377         retVal = GetCharWidth32A( HDC_32(hdc), firstChar, lastChar, &chWidth );
2378         *buffer = chWidth;
2379     }
2380     return retVal;
2381 }
2382
2383
2384 /***********************************************************************
2385  *           ExtTextOut   (GDI.351)
2386  */
2387 BOOL16 WINAPI ExtTextOut16( HDC16 hdc, INT16 x, INT16 y, UINT16 flags,
2388                             const RECT16 *lprect, LPCSTR str, UINT16 count,
2389                             const INT16 *lpDx )
2390 {
2391     BOOL        ret;
2392     int         i;
2393     RECT        rect32;
2394     LPINT       lpdx32 = NULL;
2395
2396     if (lpDx) {
2397         lpdx32 = HeapAlloc( GetProcessHeap(),0, sizeof(INT)*count );
2398         if(lpdx32 == NULL) return FALSE;
2399         for (i=count;i--;) lpdx32[i]=lpDx[i];
2400     }
2401     if (lprect)
2402     {
2403         rect32.left   = lprect->left;
2404         rect32.top    = lprect->top;
2405         rect32.right  = lprect->right;
2406         rect32.bottom = lprect->bottom;
2407     }
2408     ret = ExtTextOutA(HDC_32(hdc),x,y,flags,lprect?&rect32:NULL,str,count,lpdx32);
2409     HeapFree( GetProcessHeap(), 0, lpdx32 );
2410     return ret;
2411 }
2412
2413
2414 /***********************************************************************
2415  *           CreatePalette    (GDI.360)
2416  */
2417 HPALETTE16 WINAPI CreatePalette16( const LOGPALETTE* palette )
2418 {
2419     return HPALETTE_16( CreatePalette( palette ) );
2420 }
2421
2422
2423 /***********************************************************************
2424  *           GDISelectPalette   (GDI.361)
2425  */
2426 HPALETTE16 WINAPI GDISelectPalette16( HDC16 hdc, HPALETTE16 hpalette, WORD wBkg )
2427 {
2428     HPALETTE16 ret = HPALETTE_16( SelectPalette( HDC_32(hdc), HPALETTE_32(hpalette), wBkg ));
2429     if (ret && !wBkg) hPrimaryPalette = hpalette;
2430     return ret;
2431 }
2432
2433
2434 /***********************************************************************
2435  *           GDIRealizePalette   (GDI.362)
2436  */
2437 UINT16 WINAPI GDIRealizePalette16( HDC16 hdc )
2438 {
2439     return RealizePalette( HDC_32(hdc) );
2440 }
2441
2442
2443 /***********************************************************************
2444  *           GetPaletteEntries    (GDI.363)
2445  */
2446 UINT16 WINAPI GetPaletteEntries16( HPALETTE16 hpalette, UINT16 start,
2447                                    UINT16 count, LPPALETTEENTRY entries )
2448 {
2449     return GetPaletteEntries( HPALETTE_32(hpalette), start, count, entries );
2450 }
2451
2452
2453 /***********************************************************************
2454  *           SetPaletteEntries    (GDI.364)
2455  */
2456 UINT16 WINAPI SetPaletteEntries16( HPALETTE16 hpalette, UINT16 start,
2457                                    UINT16 count, const PALETTEENTRY *entries )
2458 {
2459     return SetPaletteEntries( HPALETTE_32(hpalette), start, count, entries );
2460 }
2461
2462
2463 /**********************************************************************
2464  *            UpdateColors   (GDI.366)
2465  */
2466 INT16 WINAPI UpdateColors16( HDC16 hdc )
2467 {
2468     UpdateColors( HDC_32(hdc) );
2469     return TRUE;
2470 }
2471
2472
2473 /***********************************************************************
2474  *           AnimatePalette   (GDI.367)
2475  */
2476 void WINAPI AnimatePalette16( HPALETTE16 hpalette, UINT16 StartIndex,
2477                               UINT16 NumEntries, const PALETTEENTRY* PaletteColors)
2478 {
2479     AnimatePalette( HPALETTE_32(hpalette), StartIndex, NumEntries, PaletteColors );
2480 }
2481
2482
2483 /***********************************************************************
2484  *           ResizePalette   (GDI.368)
2485  */
2486 BOOL16 WINAPI ResizePalette16( HPALETTE16 hpalette, UINT16 cEntries )
2487 {
2488     return ResizePalette( HPALETTE_32(hpalette), cEntries );
2489 }
2490
2491
2492 /***********************************************************************
2493  *           GetNearestPaletteIndex   (GDI.370)
2494  */
2495 UINT16 WINAPI GetNearestPaletteIndex16( HPALETTE16 hpalette, COLORREF color )
2496 {
2497     return GetNearestPaletteIndex( HPALETTE_32(hpalette), color );
2498 }
2499
2500
2501 /**********************************************************************
2502  *          ExtFloodFill   (GDI.372)
2503  */
2504 BOOL16 WINAPI ExtFloodFill16( HDC16 hdc, INT16 x, INT16 y, COLORREF color,
2505                               UINT16 fillType )
2506 {
2507     return ExtFloodFill( HDC_32(hdc), x, y, color, fillType );
2508 }
2509
2510
2511 /***********************************************************************
2512  *           SetSystemPaletteUse   (GDI.373)
2513  */
2514 UINT16 WINAPI SetSystemPaletteUse16( HDC16 hdc, UINT16 use )
2515 {
2516     return SetSystemPaletteUse( HDC_32(hdc), use );
2517 }
2518
2519
2520 /***********************************************************************
2521  *           GetSystemPaletteUse   (GDI.374)
2522  */
2523 UINT16 WINAPI GetSystemPaletteUse16( HDC16 hdc )
2524 {
2525     return GetSystemPaletteUse( HDC_32(hdc) );
2526 }
2527
2528
2529 /***********************************************************************
2530  *           GetSystemPaletteEntries   (GDI.375)
2531  */
2532 UINT16 WINAPI GetSystemPaletteEntries16( HDC16 hdc, UINT16 start, UINT16 count,
2533                                          LPPALETTEENTRY entries )
2534 {
2535     return GetSystemPaletteEntries( HDC_32(hdc), start, count, entries );
2536 }
2537
2538
2539 /***********************************************************************
2540  *           ResetDC    (GDI.376)
2541  */
2542 HDC16 WINAPI ResetDC16( HDC16 hdc, const DEVMODEA *devmode )
2543 {
2544     return HDC_16( ResetDCA(HDC_32(hdc), devmode) );
2545 }
2546
2547
2548 /******************************************************************
2549  *           StartDoc   (GDI.377)
2550  */
2551 INT16 WINAPI StartDoc16( HDC16 hdc, const DOCINFO16 *lpdoc )
2552 {
2553     DOCINFOA docA;
2554
2555     docA.cbSize = lpdoc->cbSize;
2556     docA.lpszDocName = MapSL(lpdoc->lpszDocName);
2557     docA.lpszOutput = MapSL(lpdoc->lpszOutput);
2558     if(lpdoc->cbSize > offsetof(DOCINFO16,lpszDatatype))
2559         docA.lpszDatatype = MapSL(lpdoc->lpszDatatype);
2560     else
2561         docA.lpszDatatype = NULL;
2562     if(lpdoc->cbSize > offsetof(DOCINFO16,fwType))
2563         docA.fwType = lpdoc->fwType;
2564     else
2565         docA.fwType = 0;
2566     return StartDocA( HDC_32(hdc), &docA );
2567 }
2568
2569
2570 /******************************************************************
2571  *           EndDoc   (GDI.378)
2572  */
2573 INT16 WINAPI EndDoc16( HDC16 hdc )
2574 {
2575     return EndDoc( HDC_32(hdc) );
2576 }
2577
2578
2579 /******************************************************************
2580  *           StartPage   (GDI.379)
2581  */
2582 INT16 WINAPI StartPage16( HDC16 hdc )
2583 {
2584     return StartPage( HDC_32(hdc) );
2585 }
2586
2587
2588 /******************************************************************
2589  *           EndPage   (GDI.380)
2590  */
2591 INT16 WINAPI EndPage16( HDC16 hdc )
2592 {
2593     return EndPage( HDC_32(hdc) );
2594 }
2595
2596
2597 /******************************************************************************
2598  *           AbortDoc   (GDI.382)
2599  */
2600 INT16 WINAPI AbortDoc16( HDC16 hdc )
2601 {
2602     return AbortDoc( HDC_32(hdc) );
2603 }
2604
2605
2606 /***********************************************************************
2607  *           FastWindowFrame    (GDI.400)
2608  */
2609 BOOL16 WINAPI FastWindowFrame16( HDC16 hdc, const RECT16 *rect,
2610                                INT16 width, INT16 height, DWORD rop )
2611 {
2612     HDC hdc32 = HDC_32(hdc);
2613     HBRUSH hbrush = SelectObject( hdc32, GetStockObject( GRAY_BRUSH ) );
2614     PatBlt( hdc32, rect->left, rect->top,
2615             rect->right - rect->left - width, height, rop );
2616     PatBlt( hdc32, rect->left, rect->top + height, width,
2617             rect->bottom - rect->top - height, rop );
2618     PatBlt( hdc32, rect->left + width, rect->bottom - 1,
2619             rect->right - rect->left - width, -height, rop );
2620     PatBlt( hdc32, rect->right - 1, rect->top, -width,
2621             rect->bottom - rect->top - height, rop );
2622     SelectObject( hdc32, hbrush );
2623     return TRUE;
2624 }
2625
2626
2627 /***********************************************************************
2628  *           GdiInit2     (GDI.403)
2629  *
2630  * See "Undocumented Windows"
2631  *
2632  * PARAMS
2633  *   h1 [I] GDI object
2634  *   h2 [I] global data
2635  */
2636 HANDLE16 WINAPI GdiInit216( HANDLE16 h1, HANDLE16 h2 )
2637 {
2638     FIXME("(%04x, %04x), stub.\n", h1, h2);
2639     if (h2 == 0xffff) return 0xffff; /* undefined return value */
2640     return h1; /* FIXME: should be the memory handle of h1 */
2641 }
2642
2643
2644 /***********************************************************************
2645  *           FinalGdiInit     (GDI.405)
2646  */
2647 void WINAPI FinalGdiInit16( HBRUSH16 hPattern /* [in] fill pattern of desktop */ )
2648 {
2649 }
2650
2651
2652 /***********************************************************************
2653  *           CreateUserBitmap    (GDI.407)
2654  */
2655 HBITMAP16 WINAPI CreateUserBitmap16( INT16 width, INT16 height, UINT16 planes,
2656                                      UINT16 bpp, LPCVOID bits )
2657 {
2658     return CreateBitmap16( width, height, planes, bpp, bits );
2659 }
2660
2661
2662 /***********************************************************************
2663  *           CreateUserDiscardableBitmap    (GDI.409)
2664  */
2665 HBITMAP16 WINAPI CreateUserDiscardableBitmap16( WORD dummy, INT16 width, INT16 height )
2666 {
2667     HDC hdc = CreateDCA( "DISPLAY", NULL, NULL, NULL );
2668     HBITMAP ret = CreateCompatibleBitmap( hdc, width, height );
2669     DeleteDC( hdc );
2670     return HBITMAP_16(ret);
2671 }
2672
2673
2674 /***********************************************************************
2675  *              GetCurLogFont (GDI.411)
2676  */
2677 HFONT16 WINAPI GetCurLogFont16( HDC16 hdc )
2678 {
2679     return HFONT_16( GetCurrentObject( HDC_32(hdc), OBJ_FONT ) );
2680 }
2681
2682
2683 /***********************************************************************
2684  *           StretchDIBits   (GDI.439)
2685  */
2686 INT16 WINAPI StretchDIBits16( HDC16 hdc, INT16 xDst, INT16 yDst, INT16 widthDst,
2687                               INT16 heightDst, INT16 xSrc, INT16 ySrc, INT16 widthSrc,
2688                               INT16 heightSrc, const VOID *bits,
2689                               const BITMAPINFO *info, UINT16 wUsage, DWORD dwRop )
2690 {
2691     return StretchDIBits( HDC_32(hdc), xDst, yDst, widthDst, heightDst,
2692                           xSrc, ySrc, widthSrc, heightSrc, bits,
2693                           info, wUsage, dwRop );
2694 }
2695
2696
2697 /***********************************************************************
2698  *           SetDIBits    (GDI.440)
2699  */
2700 INT16 WINAPI SetDIBits16( HDC16 hdc, HBITMAP16 hbitmap, UINT16 startscan,
2701                           UINT16 lines, LPCVOID bits, const BITMAPINFO *info,
2702                           UINT16 coloruse )
2703 {
2704     return SetDIBits( HDC_32(hdc), HBITMAP_32(hbitmap), startscan, lines, bits, info, coloruse );
2705 }
2706
2707
2708 /***********************************************************************
2709  *           GetDIBits    (GDI.441)
2710  */
2711 INT16 WINAPI GetDIBits16( HDC16 hdc, HBITMAP16 hbitmap, UINT16 startscan,
2712                           UINT16 lines, LPVOID bits, BITMAPINFO * info,
2713                           UINT16 coloruse )
2714 {
2715     return GetDIBits( HDC_32(hdc), HBITMAP_32(hbitmap), startscan, lines, bits, info, coloruse );
2716 }
2717
2718
2719 /***********************************************************************
2720  *           CreateDIBitmap    (GDI.442)
2721  */
2722 HBITMAP16 WINAPI CreateDIBitmap16( HDC16 hdc, const BITMAPINFOHEADER * header,
2723                                    DWORD init, LPCVOID bits, const BITMAPINFO * data,
2724                                    UINT16 coloruse )
2725 {
2726     return HBITMAP_16( CreateDIBitmap( HDC_32(hdc), header, init, bits, data, coloruse ) );
2727 }
2728
2729
2730 /***********************************************************************
2731  *           SetDIBitsToDevice    (GDI.443)
2732  */
2733 INT16 WINAPI SetDIBitsToDevice16( HDC16 hdc, INT16 xDest, INT16 yDest, INT16 cx,
2734                                   INT16 cy, INT16 xSrc, INT16 ySrc, UINT16 startscan,
2735                                   UINT16 lines, LPCVOID bits, const BITMAPINFO *info,
2736                                   UINT16 coloruse )
2737 {
2738     return SetDIBitsToDevice( HDC_32(hdc), xDest, yDest, cx, cy, xSrc, ySrc,
2739                               startscan, lines, bits, info, coloruse );
2740 }
2741
2742
2743 /***********************************************************************
2744  *           CreateRoundRectRgn    (GDI.444)
2745  *
2746  * If either ellipse dimension is zero we call CreateRectRgn16 for its
2747  * `special' behaviour. -ve ellipse dimensions can result in GPFs under win3.1
2748  * we just let CreateRoundRectRgn convert them to +ve values.
2749  */
2750
2751 HRGN16 WINAPI CreateRoundRectRgn16( INT16 left, INT16 top, INT16 right, INT16 bottom,
2752                                     INT16 ellipse_width, INT16 ellipse_height )
2753 {
2754     if( ellipse_width == 0 || ellipse_height == 0 )
2755         return CreateRectRgn16( left, top, right, bottom );
2756     else
2757         return HRGN_16( CreateRoundRectRgn( left, top, right, bottom,
2758                                             ellipse_width, ellipse_height ));
2759 }
2760
2761
2762 /***********************************************************************
2763  *           CreateDIBPatternBrush    (GDI.445)
2764  */
2765 HBRUSH16 WINAPI CreateDIBPatternBrush16( HGLOBAL16 hbitmap, UINT16 coloruse )
2766 {
2767     BITMAPINFO *bmi;
2768     HBRUSH16 ret;
2769
2770     if (!(bmi = GlobalLock16( hbitmap ))) return 0;
2771     ret = HBRUSH_16( CreateDIBPatternBrushPt( bmi, coloruse ));
2772     GlobalUnlock16( hbitmap );
2773     return ret;
2774 }
2775
2776
2777 /**********************************************************************
2778  *          PolyPolygon (GDI.450)
2779  */
2780 BOOL16 WINAPI PolyPolygon16( HDC16 hdc, const POINT16* pt, const INT16* counts,
2781                              UINT16 polygons )
2782 {
2783     int         i,nrpts;
2784     LPPOINT     pt32;
2785     LPINT       counts32;
2786     BOOL16      ret;
2787
2788     nrpts=0;
2789     for (i=polygons;i--;)
2790         nrpts+=counts[i];
2791     pt32 = HeapAlloc( GetProcessHeap(), 0, sizeof(POINT)*nrpts);
2792     if(pt32 == NULL) return FALSE;
2793     for (i=nrpts;i--;)
2794     {
2795         pt32[i].x = pt[i].x;
2796         pt32[i].y = pt[i].y;
2797     }
2798     counts32 = HeapAlloc( GetProcessHeap(), 0, polygons*sizeof(INT) );
2799     if(counts32 == NULL) {
2800         HeapFree( GetProcessHeap(), 0, pt32 );
2801         return FALSE;
2802     }
2803     for (i=polygons;i--;) counts32[i]=counts[i];
2804
2805     ret = PolyPolygon(HDC_32(hdc),pt32,counts32,polygons);
2806     HeapFree( GetProcessHeap(), 0, counts32 );
2807     HeapFree( GetProcessHeap(), 0, pt32 );
2808     return ret;
2809 }
2810
2811
2812 /***********************************************************************
2813  *           CreatePolyPolygonRgn    (GDI.451)
2814  */
2815 HRGN16 WINAPI CreatePolyPolygonRgn16( const POINT16 *points,
2816                                       const INT16 *count, INT16 nbpolygons, INT16 mode )
2817 {
2818     HRGN hrgn;
2819     int i, npts = 0;
2820     INT *count32;
2821     POINT *points32;
2822
2823     for (i = 0; i < nbpolygons; i++) npts += count[i];
2824     points32 = HeapAlloc( GetProcessHeap(), 0, npts * sizeof(POINT) );
2825     for (i = 0; i < npts; i++)
2826     {
2827         points32[i].x = points[i].x;
2828         points32[i].y = points[i].y;
2829     }
2830
2831     count32 = HeapAlloc( GetProcessHeap(), 0, nbpolygons * sizeof(INT) );
2832     for (i = 0; i < nbpolygons; i++) count32[i] = count[i];
2833     hrgn = CreatePolyPolygonRgn( points32, count32, nbpolygons, mode );
2834     HeapFree( GetProcessHeap(), 0, count32 );
2835     HeapFree( GetProcessHeap(), 0, points32 );
2836     return HRGN_16(hrgn);
2837 }
2838
2839
2840 /***********************************************************************
2841  *           GdiSeeGdiDo   (GDI.452)
2842  */
2843 DWORD WINAPI GdiSeeGdiDo16( WORD wReqType, WORD wParam1, WORD wParam2,
2844                           WORD wParam3 )
2845 {
2846     DWORD ret = ~0U;
2847
2848     switch (wReqType)
2849     {
2850     case 0x0001:  /* LocalAlloc */
2851         WARN("LocalAlloc16(%x, %x): ignoring\n", wParam1, wParam3);
2852         ret = 0;
2853         break;
2854     case 0x0002:  /* LocalFree */
2855         WARN("LocalFree16(%x): ignoring\n", wParam1);
2856         ret = 0;
2857         break;
2858     case 0x0003:  /* LocalCompact */
2859         WARN("LocalCompact16(%x): ignoring\n", wParam3);
2860         ret = 65000; /* lie about the amount of free space */
2861         break;
2862     case 0x0103:  /* LocalHeap */
2863         WARN("LocalHeap16(): ignoring\n");
2864         break;
2865     default:
2866         WARN("(wReqType=%04x): Unknown\n", wReqType);
2867         break;
2868     }
2869     return ret;
2870 }
2871
2872
2873 /***********************************************************************
2874  *           SetObjectOwner    (GDI.461)
2875  */
2876 void WINAPI SetObjectOwner16( HGDIOBJ16 handle, HANDLE16 owner )
2877 {
2878     /* Nothing to do */
2879 }
2880
2881
2882 /***********************************************************************
2883  *           IsGDIObject    (GDI.462)
2884  *
2885  * returns type of object if valid (W95 system programming secrets p. 264-5)
2886  */
2887 BOOL16 WINAPI IsGDIObject16( HGDIOBJ16 handle16 )
2888 {
2889     static const BYTE type_map[] =
2890     {
2891         0,  /* bad */
2892         1,  /* OBJ_PEN */
2893         2,  /* OBJ_BRUSH */
2894         7,  /* OBJ_DC */
2895         9,  /* OBJ_METADC */
2896         4,  /* OBJ_PAL */
2897         3,  /* OBJ_FONT */
2898         5,  /* OBJ_BITMAP */
2899         6,  /* OBJ_REGION */
2900         10, /* OBJ_METAFILE */
2901         7,  /* OBJ_MEMDC */
2902         0,  /* OBJ_EXTPEN */
2903         9,  /* OBJ_ENHMETADC */
2904         12, /* OBJ_ENHMETAFILE */
2905         0   /* OBJ_COLORSPACE */
2906     };
2907
2908     UINT type = GetObjectType( HGDIOBJ_32( handle16 ));
2909
2910     if (type >= sizeof(type_map)/sizeof(type_map[0])) return 0;
2911     return type_map[type];
2912 }
2913
2914
2915 /***********************************************************************
2916  *           RectVisible    (GDI.465)
2917  *           RectVisibleOld (GDI.104)
2918  */
2919 BOOL16 WINAPI RectVisible16( HDC16 hdc, const RECT16* rect16 )
2920 {
2921     RECT rect;
2922
2923     rect.left   = rect16->left;
2924     rect.top    = rect16->top;
2925     rect.right  = rect16->right;
2926     rect.bottom = rect16->bottom;
2927     return RectVisible( HDC_32(hdc), &rect );
2928 }
2929
2930
2931 /***********************************************************************
2932  *           RectInRegion    (GDI.466)
2933  *           RectInRegionOld (GDI.181)
2934  */
2935 BOOL16 WINAPI RectInRegion16( HRGN16 hrgn, const RECT16 *rect )
2936 {
2937     RECT r32;
2938
2939     r32.left   = rect->left;
2940     r32.top    = rect->top;
2941     r32.right  = rect->right;
2942     r32.bottom = rect->bottom;
2943     return RectInRegion( HRGN_32(hrgn), &r32 );
2944 }
2945
2946
2947 /***********************************************************************
2948  *           GetBitmapDimensionEx    (GDI.468)
2949  */
2950 BOOL16 WINAPI GetBitmapDimensionEx16( HBITMAP16 hbitmap, LPSIZE16 size )
2951 {
2952     SIZE size32;
2953     BOOL ret = GetBitmapDimensionEx( HBITMAP_32(hbitmap), &size32 );
2954
2955     if (ret)
2956     {
2957         size->cx = size32.cx;
2958         size->cy = size32.cy;
2959     }
2960     return ret;
2961 }
2962
2963
2964 /***********************************************************************
2965  *              GetBrushOrgEx (GDI.469)
2966  */
2967 BOOL16 WINAPI GetBrushOrgEx16( HDC16 hdc, LPPOINT16 pt )
2968 {
2969     POINT pt32;
2970     if (!GetBrushOrgEx( HDC_32(hdc), &pt32 )) return FALSE;
2971     pt->x = pt32.x;
2972     pt->y = pt32.y;
2973     return TRUE;
2974 }
2975
2976
2977 /***********************************************************************
2978  *              GetCurrentPositionEx (GDI.470)
2979  */
2980 BOOL16 WINAPI GetCurrentPositionEx16( HDC16 hdc, LPPOINT16 pt )
2981 {
2982     POINT pt32;
2983     if (!GetCurrentPositionEx( HDC_32(hdc), &pt32 )) return FALSE;
2984     pt->x = pt32.x;
2985     pt->y = pt32.y;
2986     return TRUE;
2987 }
2988
2989
2990 /***********************************************************************
2991  *           GetTextExtentPoint    (GDI.471)
2992  *
2993  * FIXME: Should this have a bug for compatibility?
2994  * Original Windows versions of GetTextExtentPoint{A,W} have documented
2995  * bugs (-> MSDN KB q147647.txt).
2996  */
2997 BOOL16 WINAPI GetTextExtentPoint16( HDC16 hdc, LPCSTR str, INT16 count, LPSIZE16 size )
2998 {
2999     SIZE size32;
3000     BOOL ret = GetTextExtentPoint32A( HDC_32(hdc), str, count, &size32 );
3001
3002     if (ret)
3003     {
3004         size->cx = size32.cx;
3005         size->cy = size32.cy;
3006     }
3007     return ret;
3008 }
3009
3010
3011 /***********************************************************************
3012  *              GetViewportExtEx (GDI.472)
3013  */
3014 BOOL16 WINAPI GetViewportExtEx16( HDC16 hdc, LPSIZE16 size )
3015 {
3016     SIZE size32;
3017     if (!GetViewportExtEx( HDC_32(hdc), &size32 )) return FALSE;
3018     size->cx = size32.cx;
3019     size->cy = size32.cy;
3020     return TRUE;
3021 }
3022
3023
3024 /***********************************************************************
3025  *              GetViewportOrgEx (GDI.473)
3026  */
3027 BOOL16 WINAPI GetViewportOrgEx16( HDC16 hdc, LPPOINT16 pt )
3028 {
3029     POINT pt32;
3030     if (!GetViewportOrgEx( HDC_32(hdc), &pt32 )) return FALSE;
3031     pt->x = pt32.x;
3032     pt->y = pt32.y;
3033     return TRUE;
3034 }
3035
3036
3037 /***********************************************************************
3038  *              GetWindowExtEx (GDI.474)
3039  */
3040 BOOL16 WINAPI GetWindowExtEx16( HDC16 hdc, LPSIZE16 size )
3041 {
3042     SIZE size32;
3043     if (!GetWindowExtEx( HDC_32(hdc), &size32 )) return FALSE;
3044     size->cx = size32.cx;
3045     size->cy = size32.cy;
3046     return TRUE;
3047 }
3048
3049
3050 /***********************************************************************
3051  *              GetWindowOrgEx (GDI.475)
3052  */
3053 BOOL16 WINAPI GetWindowOrgEx16( HDC16 hdc, LPPOINT16 pt )
3054 {
3055     POINT pt32;
3056     if (!GetWindowOrgEx( HDC_32(hdc), &pt32 )) return FALSE;
3057     pt->x = pt32.x;
3058     pt->y = pt32.y;
3059     return TRUE;
3060 }
3061
3062
3063 /***********************************************************************
3064  *           OffsetViewportOrgEx    (GDI.476)
3065  */
3066 BOOL16 WINAPI OffsetViewportOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt)
3067 {
3068     POINT pt32;
3069     BOOL16 ret = OffsetViewportOrgEx( HDC_32(hdc), x, y, &pt32 );
3070     if (pt)
3071     {
3072         pt->x = pt32.x;
3073         pt->y = pt32.y;
3074     }
3075     return ret;
3076 }
3077
3078
3079 /***********************************************************************
3080  *           OffsetWindowOrgEx    (GDI.477)
3081  */
3082 BOOL16 WINAPI OffsetWindowOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
3083 {
3084     POINT pt32;
3085     BOOL16 ret = OffsetWindowOrgEx( HDC_32(hdc), x, y, &pt32 );
3086     if (pt)
3087     {
3088         pt->x = pt32.x;
3089         pt->y = pt32.y;
3090     }
3091     return ret;
3092 }
3093
3094
3095 /***********************************************************************
3096  *           SetBitmapDimensionEx    (GDI.478)
3097  */
3098 BOOL16 WINAPI SetBitmapDimensionEx16( HBITMAP16 hbitmap, INT16 x, INT16 y, LPSIZE16 prevSize )
3099 {
3100     SIZE size32;
3101     BOOL ret = SetBitmapDimensionEx( HBITMAP_32(hbitmap), x, y, &size32 );
3102
3103     if (ret && prevSize)
3104     {
3105         prevSize->cx = size32.cx;
3106         prevSize->cy = size32.cy;
3107     }
3108     return ret;
3109 }
3110
3111
3112 /***********************************************************************
3113  *           SetViewportExtEx    (GDI.479)
3114  */
3115 BOOL16 WINAPI SetViewportExtEx16( HDC16 hdc, INT16 x, INT16 y, LPSIZE16 size )
3116 {
3117     SIZE size32;
3118     BOOL16 ret = SetViewportExtEx( HDC_32(hdc), x, y, &size32 );
3119     if (size) { size->cx = size32.cx; size->cy = size32.cy; }
3120     return ret;
3121 }
3122
3123
3124 /***********************************************************************
3125  *           SetViewportOrgEx    (GDI.480)
3126  */
3127 BOOL16 WINAPI SetViewportOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
3128 {
3129     POINT pt32;
3130     BOOL16 ret = SetViewportOrgEx( HDC_32(hdc), x, y, &pt32 );
3131     if (pt)
3132     {
3133         pt->x = pt32.x;
3134         pt->y = pt32.y;
3135     }
3136     return ret;
3137 }
3138
3139
3140 /***********************************************************************
3141  *           SetWindowExtEx    (GDI.481)
3142  */
3143 BOOL16 WINAPI SetWindowExtEx16( HDC16 hdc, INT16 x, INT16 y, LPSIZE16 size )
3144 {
3145     SIZE size32;
3146     BOOL16 ret = SetWindowExtEx( HDC_32(hdc), x, y, &size32 );
3147     if (size) { size->cx = size32.cx; size->cy = size32.cy; }
3148     return ret;
3149 }
3150
3151
3152 /***********************************************************************
3153  *           SetWindowOrgEx    (GDI.482)
3154  */
3155 BOOL16 WINAPI SetWindowOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
3156 {
3157     POINT pt32;
3158     BOOL16 ret = SetWindowOrgEx( HDC_32(hdc), x, y, &pt32 );
3159     if (pt)
3160     {
3161         pt->x = pt32.x;
3162         pt->y = pt32.y;
3163     }
3164     return ret;
3165 }
3166
3167
3168 /***********************************************************************
3169  *           MoveToEx    (GDI.483)
3170  */
3171 BOOL16 WINAPI MoveToEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
3172 {
3173     POINT pt32;
3174
3175     if (!MoveToEx( HDC_32(hdc), x, y, &pt32 )) return FALSE;
3176     if (pt)
3177     {
3178         pt->x = pt32.x;
3179         pt->y = pt32.y;
3180     }
3181     return TRUE;
3182 }
3183
3184
3185 /***********************************************************************
3186  *           ScaleViewportExtEx    (GDI.484)
3187  */
3188 BOOL16 WINAPI ScaleViewportExtEx16( HDC16 hdc, INT16 xNum, INT16 xDenom,
3189                                     INT16 yNum, INT16 yDenom, LPSIZE16 size )
3190 {
3191     SIZE size32;
3192     BOOL16 ret = ScaleViewportExtEx( HDC_32(hdc), xNum, xDenom, yNum, yDenom,
3193                                        &size32 );
3194     if (size) { size->cx = size32.cx; size->cy = size32.cy; }
3195     return ret;
3196 }
3197
3198
3199 /***********************************************************************
3200  *           ScaleWindowExtEx    (GDI.485)
3201  */
3202 BOOL16 WINAPI ScaleWindowExtEx16( HDC16 hdc, INT16 xNum, INT16 xDenom,
3203                                   INT16 yNum, INT16 yDenom, LPSIZE16 size )
3204 {
3205     SIZE size32;
3206     BOOL16 ret = ScaleWindowExtEx( HDC_32(hdc), xNum, xDenom, yNum, yDenom,
3207                                      &size32 );
3208     if (size) { size->cx = size32.cx; size->cy = size32.cy; }
3209     return ret;
3210 }
3211
3212
3213 /***********************************************************************
3214  *           GetAspectRatioFilterEx  (GDI.486)
3215  */
3216 BOOL16 WINAPI GetAspectRatioFilterEx16( HDC16 hdc, LPSIZE16 pAspectRatio )
3217 {
3218     FIXME("(%04x, %p): -- Empty Stub !\n", hdc, pAspectRatio);
3219     return FALSE;
3220 }
3221
3222
3223 /******************************************************************************
3224  *           PolyBezier  (GDI.502)
3225  */
3226 BOOL16 WINAPI PolyBezier16( HDC16 hdc, const POINT16* lppt, INT16 cPoints )
3227 {
3228     int i;
3229     BOOL16 ret;
3230     LPPOINT pt32 = HeapAlloc( GetProcessHeap(), 0, cPoints*sizeof(POINT) );
3231     if(!pt32) return FALSE;
3232     for (i=cPoints;i--;)
3233     {
3234         pt32[i].x = lppt[i].x;
3235         pt32[i].y = lppt[i].y;
3236     }
3237     ret= PolyBezier(HDC_32(hdc), pt32, cPoints);
3238     HeapFree( GetProcessHeap(), 0, pt32 );
3239     return ret;
3240 }
3241
3242
3243 /******************************************************************************
3244  *           PolyBezierTo  (GDI.503)
3245  */
3246 BOOL16 WINAPI PolyBezierTo16( HDC16 hdc, const POINT16* lppt, INT16 cPoints )
3247 {
3248     int i;
3249     BOOL16 ret;
3250     LPPOINT pt32 = HeapAlloc( GetProcessHeap(), 0,
3251                                            cPoints*sizeof(POINT) );
3252     if(!pt32) return FALSE;
3253     for (i=cPoints;i--;)
3254     {
3255         pt32[i].x = lppt[i].x;
3256         pt32[i].y = lppt[i].y;
3257     }
3258     ret= PolyBezierTo(HDC_32(hdc), pt32, cPoints);
3259     HeapFree( GetProcessHeap(), 0, pt32 );
3260     return ret;
3261 }
3262
3263
3264 /******************************************************************************
3265  *           ExtSelectClipRgn   (GDI.508)
3266  */
3267 INT16 WINAPI ExtSelectClipRgn16( HDC16 hdc, HRGN16 hrgn, INT16 fnMode )
3268 {
3269   return ExtSelectClipRgn( HDC_32(hdc), HRGN_32(hrgn), fnMode);
3270 }
3271
3272
3273 /***********************************************************************
3274  *           AbortPath    (GDI.511)
3275  */
3276 BOOL16 WINAPI AbortPath16(HDC16 hdc)
3277 {
3278     return AbortPath( HDC_32(hdc) );
3279 }
3280
3281
3282 /***********************************************************************
3283  *           BeginPath    (GDI.512)
3284  */
3285 BOOL16 WINAPI BeginPath16(HDC16 hdc)
3286 {
3287     return BeginPath( HDC_32(hdc) );
3288 }
3289
3290
3291 /***********************************************************************
3292  *           CloseFigure    (GDI.513)
3293  */
3294 BOOL16 WINAPI CloseFigure16(HDC16 hdc)
3295 {
3296     return CloseFigure( HDC_32(hdc) );
3297 }
3298
3299
3300 /***********************************************************************
3301  *           EndPath    (GDI.514)
3302  */
3303 BOOL16 WINAPI EndPath16(HDC16 hdc)
3304 {
3305     return EndPath( HDC_32(hdc) );
3306 }
3307
3308
3309 /***********************************************************************
3310  *           FillPath    (GDI.515)
3311  */
3312 BOOL16 WINAPI FillPath16(HDC16 hdc)
3313 {
3314     return FillPath( HDC_32(hdc) );
3315 }
3316
3317
3318 /*******************************************************************
3319  *           FlattenPath    (GDI.516)
3320  */
3321 BOOL16 WINAPI FlattenPath16(HDC16 hdc)
3322 {
3323     return FlattenPath( HDC_32(hdc) );
3324 }
3325
3326
3327 /***********************************************************************
3328  *           GetPath    (GDI.517)
3329  */
3330 INT16 WINAPI GetPath16(HDC16 hdc, LPPOINT16 pPoints, LPBYTE pTypes, INT16 nSize)
3331 {
3332     FIXME("(%d,%p,%p): stub\n",hdc,pPoints,pTypes);
3333     return 0;
3334 }
3335
3336
3337 /***********************************************************************
3338  *           PathToRegion    (GDI.518)
3339  */
3340 HRGN16 WINAPI PathToRegion16(HDC16 hdc)
3341 {
3342     return HRGN_16( PathToRegion( HDC_32(hdc) ));
3343 }
3344
3345
3346 /***********************************************************************
3347  *           SelectClipPath    (GDI.519)
3348  */
3349 BOOL16 WINAPI SelectClipPath16(HDC16 hdc, INT16 iMode)
3350 {
3351     return SelectClipPath( HDC_32(hdc), iMode );
3352 }
3353
3354
3355 /*******************************************************************
3356  *           StrokeAndFillPath    (GDI.520)
3357  */
3358 BOOL16 WINAPI StrokeAndFillPath16(HDC16 hdc)
3359 {
3360     return StrokeAndFillPath( HDC_32(hdc) );
3361 }
3362
3363
3364 /*******************************************************************
3365  *           StrokePath    (GDI.521)
3366  */
3367 BOOL16 WINAPI StrokePath16(HDC16 hdc)
3368 {
3369     return StrokePath( HDC_32(hdc) );
3370 }
3371
3372
3373 /*******************************************************************
3374  *           WidenPath    (GDI.522)
3375  */
3376 BOOL16 WINAPI WidenPath16(HDC16 hdc)
3377 {
3378     return WidenPath( HDC_32(hdc) );
3379 }
3380
3381
3382 /***********************************************************************
3383  *              GetArcDirection (GDI.524)
3384  */
3385 INT16 WINAPI GetArcDirection16( HDC16 hdc )
3386 {
3387     return GetArcDirection( HDC_32(hdc) );
3388 }
3389
3390
3391 /***********************************************************************
3392  *           SetArcDirection    (GDI.525)
3393  */
3394 INT16 WINAPI SetArcDirection16( HDC16 hdc, INT16 nDirection )
3395 {
3396     return SetArcDirection( HDC_32(hdc), (INT)nDirection );
3397 }
3398
3399
3400 /***********************************************************************
3401  *           CreateHalftonePalette (GDI.529)
3402  */
3403 HPALETTE16 WINAPI CreateHalftonePalette16( HDC16 hdc )
3404 {
3405     return HPALETTE_16( CreateHalftonePalette( HDC_32(hdc) ));
3406 }
3407
3408
3409 /***********************************************************************
3410  *           SetDIBColorTable    (GDI.602)
3411  */
3412 UINT16 WINAPI SetDIBColorTable16( HDC16 hdc, UINT16 startpos, UINT16 entries, RGBQUAD *colors )
3413 {
3414     return SetDIBColorTable( HDC_32(hdc), startpos, entries, colors );
3415 }
3416
3417
3418 /***********************************************************************
3419  *           GetDIBColorTable    (GDI.603)
3420  */
3421 UINT16 WINAPI GetDIBColorTable16( HDC16 hdc, UINT16 startpos, UINT16 entries, RGBQUAD *colors )
3422 {
3423     return GetDIBColorTable( HDC_32(hdc), startpos, entries, colors );
3424 }
3425
3426
3427 /***********************************************************************
3428  *           GetRegionData   (GDI.607)
3429  *
3430  * FIXME: is LPRGNDATA the same in Win16 and Win32 ?
3431  */
3432 DWORD WINAPI GetRegionData16( HRGN16 hrgn, DWORD count, LPRGNDATA rgndata )
3433 {
3434     return GetRegionData( HRGN_32(hrgn), count, rgndata );
3435 }
3436
3437
3438 /***********************************************************************
3439  *           GdiFreeResources   (GDI.609)
3440  */
3441 WORD WINAPI GdiFreeResources16( DWORD reserve )
3442 {
3443     return 90; /* lie about it, it shouldn't matter */
3444 }
3445
3446
3447 /***********************************************************************
3448  *           GdiSignalProc32     (GDI.610)
3449  */
3450 WORD WINAPI GdiSignalProc( UINT uCode, DWORD dwThreadOrProcessID,
3451                            DWORD dwFlags, HMODULE16 hModule )
3452 {
3453     return 0;
3454 }
3455
3456
3457 /***********************************************************************
3458  *           GetTextCharset   (GDI.612)
3459  */
3460 UINT16 WINAPI GetTextCharset16( HDC16 hdc )
3461 {
3462     return GetTextCharset( HDC_32(hdc) );
3463 }
3464
3465
3466 /***********************************************************************
3467  *           EnumFontFamiliesEx (GDI.613)
3468  */
3469 INT16 WINAPI EnumFontFamiliesEx16( HDC16 hdc, LPLOGFONT16 plf,
3470                                    FONTENUMPROC16 proc, LPARAM lParam,
3471                                    DWORD dwFlags)
3472 {
3473     struct callback16_info info;
3474     LOGFONTW lfW, *plfW;
3475
3476     info.proc  = (FARPROC16)proc;
3477     info.param = lParam;
3478
3479     if (plf)
3480     {
3481         logfont_16_to_W(plf, &lfW);
3482         plfW = &lfW;
3483     }
3484     else plfW = NULL;
3485
3486     return EnumFontFamiliesExW( HDC_32(hdc), plfW, enum_font_callback,
3487                                 (LPARAM)&info, dwFlags );
3488 }
3489
3490
3491 /*************************************************************************
3492  *             GetFontLanguageInfo   (GDI.616)
3493  */
3494 DWORD WINAPI GetFontLanguageInfo16( HDC16 hdc )
3495 {
3496     return GetFontLanguageInfo( HDC_32(hdc) );
3497 }
3498
3499
3500 /***********************************************************************
3501  *           SetLayout   (GDI.1000)
3502  *
3503  * Sets left->right or right->left text layout flags of a dc.
3504  */
3505 BOOL16 WINAPI SetLayout16( HDC16 hdc, DWORD layout )
3506 {
3507     return SetLayout( HDC_32(hdc), layout );
3508 }
3509
3510
3511 /***********************************************************************
3512  *           SetSolidBrush   (GDI.604)
3513  *
3514  * Change the color of a solid brush.
3515  *
3516  * PARAMS
3517  *  hBrush   [I] Brush to change the color of
3518  *  newColor [I] New color for hBrush
3519  *
3520  * RETURNS
3521  *  Success: TRUE. The color of hBrush is set to newColor.
3522  *  Failure: FALSE.
3523  *
3524  * FIXME
3525  *  This function is undocumented and untested. The implementation may
3526  *  not be correct.
3527  */
3528 BOOL16 WINAPI SetSolidBrush16(HBRUSH16 hBrush, COLORREF newColor )
3529 {
3530     FIXME( "%04x %08x no longer supported\n", hBrush, newColor );
3531     return FALSE;
3532 }
3533
3534
3535 /***********************************************************************
3536  *           Copy   (GDI.250)
3537  */
3538 void WINAPI Copy16( LPVOID src, LPVOID dst, WORD size )
3539 {
3540     memcpy( dst, src, size );
3541 }
3542
3543 /***********************************************************************
3544  *           RealizeDefaultPalette    (GDI.365)
3545  */
3546 UINT16 WINAPI RealizeDefaultPalette16( HDC16 hdc )
3547 {
3548     FIXME( "%04x semi-stub\n", hdc );
3549     return GDIRealizePalette16( hdc );
3550 }
3551
3552 /***********************************************************************
3553  *           IsDCCurrentPalette   (GDI.412)
3554  */
3555 BOOL16 WINAPI IsDCCurrentPalette16(HDC16 hDC)
3556 {
3557     return HPALETTE_16( GetCurrentObject( HDC_32(hDC), OBJ_PAL )) == hPrimaryPalette;
3558 }
3559
3560 /*********************************************************************
3561  *           SetMagicColors   (GDI.606)
3562  */
3563 VOID WINAPI SetMagicColors16(HDC16 hDC, COLORREF color, UINT16 index)
3564 {
3565     FIXME("(hDC %04x, color %04x, index %04x): stub\n", hDC, (int)color, index);
3566
3567 }
3568
3569
3570 /***********************************************************************
3571  *           DPtoLP    (GDI.67)
3572  */
3573 BOOL16 WINAPI DPtoLP16( HDC16 hdc, LPPOINT16 points, INT16 count )
3574 {
3575     POINT points32[8], *pt32 = points32;
3576     int i;
3577     BOOL ret;
3578
3579     if (count > 8)
3580     {
3581         if (!(pt32 = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*pt32) ))) return FALSE;
3582     }
3583     for (i = 0; i < count; i++)
3584     {
3585         pt32[i].x = points[i].x;
3586         pt32[i].y = points[i].y;
3587     }
3588     if ((ret = DPtoLP( HDC_32(hdc), pt32, count )))
3589     {
3590         for (i = 0; i < count; i++)
3591         {
3592             points[i].x = pt32[i].x;
3593             points[i].y = pt32[i].y;
3594         }
3595     }
3596     if (pt32 != points32) HeapFree( GetProcessHeap(), 0, pt32 );
3597     return ret;
3598 }
3599
3600
3601 /***********************************************************************
3602  *           LPtoDP    (GDI.99)
3603  */
3604 BOOL16 WINAPI LPtoDP16( HDC16 hdc, LPPOINT16 points, INT16 count )
3605 {
3606     POINT points32[8], *pt32 = points32;
3607     int i;
3608     BOOL ret;
3609
3610     if (count > 8)
3611     {
3612         if (!(pt32 = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*pt32) ))) return FALSE;
3613     }
3614     for (i = 0; i < count; i++)
3615     {
3616         pt32[i].x = points[i].x;
3617         pt32[i].y = points[i].y;
3618     }
3619     if ((ret = LPtoDP( HDC_32(hdc), pt32, count )))
3620     {
3621         for (i = 0; i < count; i++)
3622         {
3623             points[i].x = pt32[i].x;
3624             points[i].y = pt32[i].y;
3625         }
3626     }
3627     if (pt32 != points32) HeapFree( GetProcessHeap(), 0, pt32 );
3628     return ret;
3629 }
3630
3631
3632 /***********************************************************************
3633  *           GetDCState   (GDI.179)
3634  */
3635 HDC16 WINAPI GetDCState16( HDC16 hdc )
3636 {
3637     ERR( "no longer supported\n" );
3638     return 0;
3639 }
3640
3641
3642 /***********************************************************************
3643  *           SetDCState   (GDI.180)
3644  */
3645 void WINAPI SetDCState16( HDC16 hdc, HDC16 hdcs )
3646 {
3647     ERR( "no longer supported\n" );
3648 }
3649
3650 /***********************************************************************
3651  *           SetDCOrg   (GDI.117)
3652  */
3653 DWORD WINAPI SetDCOrg16( HDC16 hdc16, INT16 x, INT16 y )
3654 {
3655     FIXME( "%04x %d,%d no longer supported\n", hdc16, x, y );
3656     return 0;
3657 }
3658
3659
3660 /***********************************************************************
3661  *              InquireVisRgn   (GDI.131)
3662  */
3663 HRGN16 WINAPI InquireVisRgn16( HDC16 hdc )
3664 {
3665     static HRGN hrgn;
3666
3667     if (!hrgn) hrgn = CreateRectRgn( 0, 0, 0, 0 );
3668     GetRandomRgn( HDC_32(hdc), hrgn, SYSRGN );
3669     return HRGN_16(hrgn);
3670 }
3671
3672
3673 /***********************************************************************
3674  *           OffsetVisRgn    (GDI.102)
3675  */
3676 INT16 WINAPI OffsetVisRgn16( HDC16 hdc16, INT16 x, INT16 y )
3677 {
3678     FIXME( "%04x %d,%d no longer supported\n", hdc16, x, y );
3679     return ERROR;
3680 }
3681
3682
3683 /***********************************************************************
3684  *           ExcludeVisRect   (GDI.73)
3685  */
3686 INT16 WINAPI ExcludeVisRect16( HDC16 hdc16, INT16 left, INT16 top, INT16 right, INT16 bottom )
3687 {
3688     FIXME( "%04x %d,%d-%d,%d no longer supported\n", hdc16, left, top, right, bottom );
3689     return ERROR;
3690 }
3691
3692
3693 /***********************************************************************
3694  *           IntersectVisRect   (GDI.98)
3695  */
3696 INT16 WINAPI IntersectVisRect16( HDC16 hdc16, INT16 left, INT16 top, INT16 right, INT16 bottom )
3697 {
3698     FIXME( "%04x %d,%d-%d,%d no longer supported\n", hdc16, left, top, right, bottom );
3699     return ERROR;
3700 }
3701
3702
3703 /***********************************************************************
3704  *           SaveVisRgn   (GDI.129)
3705  */
3706 HRGN16 WINAPI SaveVisRgn16( HDC16 hdc16 )
3707 {
3708     FIXME( "%04x no longer supported\n", hdc16 );
3709     return 0;
3710 }
3711
3712
3713 /***********************************************************************
3714  *           RestoreVisRgn   (GDI.130)
3715  */
3716 INT16 WINAPI RestoreVisRgn16( HDC16 hdc16 )
3717 {
3718     FIXME( "%04x no longer supported\n", hdc16 );
3719     return ERROR;
3720 }
3721
3722
3723 /***********************************************************************
3724  *              GetClipRgn (GDI.173)
3725  */
3726 HRGN16 WINAPI GetClipRgn16( HDC16 hdc )
3727 {
3728     static HRGN hrgn;
3729
3730     if (!hrgn) hrgn = CreateRectRgn( 0, 0, 0, 0 );
3731     GetClipRgn( HDC_32(hdc), hrgn );
3732     return HRGN_16(hrgn);
3733 }
3734
3735
3736 /***********************************************************************
3737  *           MakeObjectPrivate    (GDI.463)
3738  *
3739  * What does that mean ?
3740  * Some little docu can be found in "Undocumented Windows",
3741  * but this is basically useless.
3742  */
3743 void WINAPI MakeObjectPrivate16( HGDIOBJ16 handle16, BOOL16 private )
3744 {
3745     FIXME( "stub: %x %u\n", handle16, private );
3746 }
3747
3748 /***********************************************************************
3749  *           CreateDIBSection    (GDI.489)
3750  */
3751 HBITMAP16 WINAPI CreateDIBSection16 (HDC16 hdc, const BITMAPINFO *bmi, UINT16 usage,
3752                                      SEGPTR *bits16, HANDLE section, DWORD offset)
3753 {
3754     LPVOID bits32;
3755     HBITMAP hbitmap;
3756
3757     hbitmap = CreateDIBSection( HDC_32(hdc), bmi, usage, &bits32, section, offset );
3758     if (hbitmap && bits32 && bits16) *bits16 = alloc_segptr_bits( hbitmap, bits32 );
3759     return HBITMAP_16(hbitmap);
3760 }