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