dlls/gdi32/metafile.c

   1 /*
   2  * Metafile functions
   3  *
   4  * Copyright  David W. Metcalfe, 1994
   5  * Copyright  Niels de Carpentier, 1996
   6  * Copyright  Albrecht Kleine, 1996
   7  * Copyright  Huw Davies, 1996
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  *
  23  * NOTES
  24  *
  25  * These functions are primarily involved with metafile playback or anything
  26  * that touches a HMETAFILE.
  27  * For recording of metafiles look in graphics/metafiledrv/
  28  *
  29  * Note that (32 bit) HMETAFILEs are GDI objects, while HMETAFILE16s are
  30  * global memory handles so these cannot be interchanged.
  31  *
  32  * Memory-based metafiles are just stored as a continuous block of memory with
  33  * a METAHEADER at the head with METARECORDs appended to it.  mtType is
  34  * METAFILE_MEMORY (1).  Note this is identical to the disk image of a
  35  * disk-based metafile - even mtType is METAFILE_MEMORY.
  36  * 16bit HMETAFILE16s are global handles to this block
  37  * 32bit HMETAFILEs are GDI handles METAFILEOBJs, which contains a ptr to
  38  * the memory.
  39  * Disk-based metafiles are rather different. HMETAFILE16s point to a
  40  * METAHEADER which has mtType equal to METAFILE_DISK (2).  Following the 9
  41  * WORDs of the METAHEADER there are a further 3 WORDs of 0, 1 of 0x117, 1
  42  * more 0, then 2 which may be a time stamp of the file and then the path of
  43  * the file (METAHEADERDISK). I've copied this for 16bit compatibility.
  44  *
  45  * HDMD - 14/4/1999
  46  */
  47
  48 #include "config.h"
  49
  50 #include <stdarg.h>
  51 #include <string.h>
  52 #include <fcntl.h>
  53
  54 #include "windef.h"
  55 #include "winbase.h"
  56 #include "wingdi.h"
  57 #include "winreg.h"
  58 #include "winnls.h"
  59 #include "winternl.h"
  60 #include "gdi_private.h"
  61 #include "wine/debug.h"
  62
  63 WINE_DEFAULT_DEBUG_CHANNEL(metafile);
  64
  65 #include "pshpack1.h"
  66 typedef struct
  67 {
  68     DWORD dw1, dw2, dw3;
  69     WORD w4;
  70     CHAR filename[0x100];
  71 } METAHEADERDISK;
  72 #include "poppack.h"
  73
  74
  75 /******************************************************************
  76  *         MF_AddHandle
  77  *
  78  *    Add a handle to an external handle table and return the index
  79  */
  80 static int MF_AddHandle(HANDLETABLE *ht, UINT htlen, HGDIOBJ hobj)
  81 {
  82     int i;
  83
  84     for (i = 0; i < htlen; i++)
  85     {
  86         if (*(ht->objectHandle + i) == 0)
  87         {
  88             *(ht->objectHandle + i) = hobj;
  89             return i;
  90         }
  91     }
  92     return -1;
  93 }
  94
  95
  96 /******************************************************************
  97  *         MF_Create_HMETATFILE
  98  *
  99  * Creates a (32 bit) HMETAFILE object from a METAHEADER
 100  *
 101  * HMETAFILEs are GDI objects.
 102  */
 103 HMETAFILE MF_Create_HMETAFILE(METAHEADER *mh)
 104 {
 105     return alloc_gdi_handle( mh, OBJ_METAFILE, NULL );
 106 }
 107
 108 /******************************************************************
 109  *         convert_points
 110  *
 111  * Convert an array of POINTS to an array of POINT.
 112  * Result must be freed by caller.
 113  */
 114 static POINT *convert_points( UINT count, const POINTS *pts )
 115 {
 116     UINT i;
 117     POINT *ret = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*ret) );
 118     if (ret)
 119     {
 120         for (i = 0; i < count; i++)
 121         {
 122             ret[i].x = pts[i].x;
 123             ret[i].y = pts[i].y;
 124         }
 125     }
 126     return ret;
 127 }
 128
 129 /******************************************************************
 130  *          DeleteMetaFile  (GDI32.@)
 131  *
 132  *  Delete a memory-based metafile.
 133  */
 134
 135 BOOL WINAPI DeleteMetaFile( HMETAFILE hmf )
 136 {
 137     METAHEADER *mh = free_gdi_handle( hmf );
 138     if (!mh) return FALSE;
 139     return HeapFree( GetProcessHeap(), 0, mh );
 140 }
 141
 142 /******************************************************************
 143  *         MF_ReadMetaFile
 144  *
 145  * Returns a pointer to a memory based METAHEADER read in from file HFILE
 146  *
 147  */
 148 static METAHEADER *MF_ReadMetaFile(HANDLE hfile)
 149 {
 150     METAHEADER *mh;
 151     DWORD BytesRead, size;
 152
 153     size = sizeof(METAHEADER);
 154     mh = HeapAlloc( GetProcessHeap(), 0, size );
 155     if(!mh) return NULL;
 156     if(ReadFile( hfile, mh, size, &BytesRead, NULL) == 0 ||
 157        BytesRead != size) {
 158         HeapFree( GetProcessHeap(), 0, mh );
 159         return NULL;
 160     }
 161     if (mh->mtType != METAFILE_MEMORY || mh->mtVersion != MFVERSION ||
 162         mh->mtHeaderSize != size / 2)
 163     {
 164         HeapFree( GetProcessHeap(), 0, mh );
 165         return NULL;
 166     }
 167     size = mh->mtSize * 2;
 168     mh = HeapReAlloc( GetProcessHeap(), 0, mh, size );
 169     if(!mh) return NULL;
 170     size -= sizeof(METAHEADER);
 171     if(ReadFile( hfile, (char *)mh + sizeof(METAHEADER), size, &BytesRead,
 172                  NULL) == 0 ||
 173        BytesRead != size) {
 174         HeapFree( GetProcessHeap(), 0, mh );
 175         return NULL;
 176     }
 177
 178     if (mh->mtType != METAFILE_MEMORY) {
 179         WARN("Disk metafile had mtType = %04x\n", mh->mtType);
 180         mh->mtType = METAFILE_MEMORY;
 181     }
 182     return mh;
 183 }
 184
 185 /******************************************************************
 186  *         GetMetaFileA   (GDI32.@)
 187  *
 188  *  Read a metafile from a file. Returns handle to a memory-based metafile.
 189  */
 190 HMETAFILE WINAPI GetMetaFileA( LPCSTR lpFilename )
 191 {
 192     METAHEADER *mh;
 193     HANDLE hFile;
 194
 195     TRACE("%s\n", lpFilename);
 196
 197     if(!lpFilename)
 198         return 0;
 199
 200     if((hFile = CreateFileA(lpFilename, GENERIC_READ, FILE_SHARE_READ, NULL,
 201                             OPEN_EXISTING, 0, 0)) == INVALID_HANDLE_VALUE)
 202         return 0;
 203
 204     mh = MF_ReadMetaFile(hFile);
 205     CloseHandle(hFile);
 206     if(!mh) return 0;
 207     return MF_Create_HMETAFILE( mh );
 208 }
 209
 210 /******************************************************************
 211  *         GetMetaFileW   (GDI32.@)
 212  */
 213 HMETAFILE WINAPI GetMetaFileW( LPCWSTR lpFilename )
 214 {
 215     METAHEADER *mh;
 216     HANDLE hFile;
 217
 218     TRACE("%s\n", debugstr_w(lpFilename));
 219
 220     if(!lpFilename)
 221         return 0;
 222
 223     if((hFile = CreateFileW(lpFilename, GENERIC_READ, FILE_SHARE_READ, NULL,
 224                             OPEN_EXISTING, 0, 0)) == INVALID_HANDLE_VALUE)
 225         return 0;
 226
 227     mh = MF_ReadMetaFile(hFile);
 228     CloseHandle(hFile);
 229     if(!mh) return 0;
 230     return MF_Create_HMETAFILE( mh );
 231 }
 232
 233
 234 /******************************************************************
 235  *         MF_LoadDiskBasedMetaFile
 236  *
 237  * Creates a new memory-based metafile from a disk-based one.
 238  */
 239 static METAHEADER *MF_LoadDiskBasedMetaFile(METAHEADER *mh)
 240 {
 241     METAHEADERDISK *mhd;
 242     HANDLE hfile;
 243     METAHEADER *mh2;
 244
 245     if(mh->mtType != METAFILE_DISK) {
 246         ERR("Not a disk based metafile\n");
 247         return NULL;
 248     }
 249     mhd = (METAHEADERDISK *)((char *)mh + sizeof(METAHEADER));
 250
 251     if((hfile = CreateFileA(mhd->filename, GENERIC_READ, FILE_SHARE_READ, NULL,
 252                             OPEN_EXISTING, 0, 0)) == INVALID_HANDLE_VALUE) {
 253         WARN("Can't open file of disk based metafile\n");
 254         return NULL;
 255     }
 256     mh2 = MF_ReadMetaFile(hfile);
 257     CloseHandle(hfile);
 258     return mh2;
 259 }
 260
 261 /******************************************************************
 262  *         MF_CreateMetaHeaderDisk
 263  *
 264  * Take a memory based METAHEADER and change it to a disk based METAHEADER
 265  * associated with filename.  Note: Trashes contents of old one.
 266  */
 267 METAHEADER *MF_CreateMetaHeaderDisk(METAHEADER *mh, LPCVOID filename, BOOL uni )
 268 {
 269     METAHEADERDISK *mhd;
 270
 271     mh = HeapReAlloc( GetProcessHeap(), 0, mh,
 272                       sizeof(METAHEADER) + sizeof(METAHEADERDISK));
 273     mh->mtType = METAFILE_DISK;
 274     mhd = (METAHEADERDISK *)((char *)mh + sizeof(METAHEADER));
 275
 276     if( uni )
 277         WideCharToMultiByte(CP_ACP, 0, filename, -1,
 278                    mhd->filename, sizeof mhd->filename, NULL, NULL);
 279     else
 280         lstrcpynA( mhd->filename, filename, sizeof mhd->filename );
 281     return mh;
 282 }
 283
 284 /* return a copy of the metafile bits, to be freed with HeapFree */
 285 static METAHEADER *get_metafile_bits( HMETAFILE hmf )
 286 {
 287     METAHEADER *ret, *mh = GDI_GetObjPtr( hmf, OBJ_METAFILE );
 288
 289     if (!mh) return NULL;
 290
 291     if (mh->mtType != METAFILE_DISK)
 292     {
 293         ret = HeapAlloc( GetProcessHeap(), 0, mh->mtSize * 2 );
 294         if (ret) memcpy( ret, mh, mh->mtSize * 2 );
 295     }
 296     else ret = MF_LoadDiskBasedMetaFile( mh );
 297
 298     GDI_ReleaseObj( hmf );
 299     return ret;
 300 }
 301
 302 /******************************************************************
 303  *         CopyMetaFileW   (GDI32.@)
 304  *
 305  *  Copies the metafile corresponding to hSrcMetaFile to either
 306  *  a disk file, if a filename is given, or to a new memory based
 307  *  metafile, if lpFileName is NULL.
 308  *
 309  * PARAMS
 310  *  hSrcMetaFile [I] handle of metafile to copy
 311  *  lpFilename   [I] filename if copying to a file
 312  *
 313  * RETURNS
 314  *  Handle to metafile copy on success, NULL on failure.
 315  *
 316  * BUGS
 317  *  Copying to disk returns NULL even if successful.
 318  */
 319 HMETAFILE WINAPI CopyMetaFileW( HMETAFILE hSrcMetaFile, LPCWSTR lpFilename )
 320 {
 321     METAHEADER *mh = get_metafile_bits( hSrcMetaFile );
 322     HANDLE hFile;
 323
 324     TRACE("(%p,%s)\n", hSrcMetaFile, debugstr_w(lpFilename));
 325
 326     if(!mh) return 0;
 327
 328     if(lpFilename) {         /* disk based metafile */
 329         DWORD w;
 330         if((hFile = CreateFileW(lpFilename, GENERIC_WRITE, 0, NULL,
 331                                 CREATE_ALWAYS, 0, 0)) == INVALID_HANDLE_VALUE) {
 332             HeapFree( GetProcessHeap(), 0, mh );
 333             return 0;
 334         }
 335         WriteFile(hFile, mh, mh->mtSize * 2, &w, NULL);
 336         CloseHandle(hFile);
 337     }
 338
 339     return MF_Create_HMETAFILE( mh );
 340 }
 341
 342
 343 /******************************************************************
 344  *         CopyMetaFileA   (GDI32.@)
 345  *
 346  * See CopyMetaFileW.
 347  */
 348 HMETAFILE WINAPI CopyMetaFileA( HMETAFILE hSrcMetaFile, LPCSTR lpFilename )
 349 {
 350     UNICODE_STRING lpFilenameW;
 351     HMETAFILE ret = 0;
 352
 353     if (lpFilename) RtlCreateUnicodeStringFromAsciiz(&lpFilenameW, lpFilename);
 354     else lpFilenameW.Buffer = NULL;
 355
 356     ret = CopyMetaFileW( hSrcMetaFile, lpFilenameW.Buffer );
 357     if (lpFilenameW.Buffer)
 358         RtlFreeUnicodeString(&lpFilenameW);
 359     return ret;
 360 }
 361
 362 /******************************************************************
 363  *         PlayMetaFile   (GDI32.@)
 364  *
 365  *  Renders the metafile specified by hmf in the DC specified by
 366  *  hdc. Returns FALSE on failure, TRUE on success.
 367  *
 368  * PARAMS
 369  *  hdc [I] handle of DC to render in
 370  *  hmf [I] handle of metafile to render
 371  *
 372  * RETURNS
 373  *  Success: TRUE
 374  *  Failure: FALSE
 375  */
 376 BOOL WINAPI PlayMetaFile( HDC hdc, HMETAFILE hmf )
 377 {
 378     METAHEADER *mh = get_metafile_bits( hmf );
 379     METARECORD *mr;
 380     HANDLETABLE *ht;
 381     unsigned int offset = 0;
 382     WORD i;
 383     HPEN hPen;
 384     HBRUSH hBrush;
 385     HPALETTE hPal;
 386     HRGN hRgn;
 387
 388     if (!mh) return FALSE;
 389
 390     /* save DC */
 391     hPen = GetCurrentObject(hdc, OBJ_PEN);
 392     hBrush = GetCurrentObject(hdc, OBJ_BRUSH);
 393     hPal = GetCurrentObject(hdc, OBJ_PAL);
 394
 395     hRgn = CreateRectRgn(0, 0, 0, 0);
 396     if (!GetClipRgn(hdc, hRgn))
 397     {
 398         DeleteObject(hRgn);
 399         hRgn = 0;
 400     }
 401
 402     /* create the handle table */
 403     ht = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 404                     sizeof(HANDLETABLE) * mh->mtNoObjects);
 405     if(!ht)
 406     {
 407         HeapFree( GetProcessHeap(), 0, mh );
 408         return FALSE;
 409     }
 410
 411     /* loop through metafile playing records */
 412     offset = mh->mtHeaderSize * 2;
 413     while (offset < mh->mtSize * 2)
 414     {
 415         mr = (METARECORD *)((char *)mh + offset);
 416         TRACE("offset=%04x,size=%08x\n",
 417             offset, mr->rdSize);
 418         if (mr->rdSize < 3) { /* catch illegal record sizes */
 419             TRACE("Entry got size %d at offset %d, total mf length is %d\n",
 420                   mr->rdSize,offset,mh->mtSize*2);
 421             break;
 422         }
 423
 424         offset += mr->rdSize * 2;
 425         if (mr->rdFunction == META_EOF) {
 426             TRACE("Got META_EOF so stopping\n");
 427             break;
 428         }
 429         PlayMetaFileRecord( hdc, ht, mr, mh->mtNoObjects );
 430     }
 431
 432     /* restore DC */
 433     SelectObject(hdc, hPen);
 434     SelectObject(hdc, hBrush);
 435     SelectPalette(hdc, hPal, FALSE);
 436     ExtSelectClipRgn(hdc, hRgn, RGN_COPY);
 437     DeleteObject(hRgn);
 438
 439     /* free objects in handle table */
 440     for(i = 0; i < mh->mtNoObjects; i++)
 441       if(*(ht->objectHandle + i) != 0)
 442         DeleteObject(*(ht->objectHandle + i));
 443
 444     HeapFree( GetProcessHeap(), 0, ht );
 445     HeapFree( GetProcessHeap(), 0, mh );
 446     return TRUE;
 447 }
 448
 449 /******************************************************************
 450  *            EnumMetaFile   (GDI32.@)
 451  *
 452  *  Loop through the metafile records in hmf, calling the user-specified
 453  *  function for each one, stopping when the user's function returns FALSE
 454  *  (which is considered to be failure)
 455  *  or when no records are left (which is considered to be success).
 456  *
 457  * RETURNS
 458  *  TRUE on success, FALSE on failure.
 459  */
 460 BOOL WINAPI EnumMetaFile(HDC hdc, HMETAFILE hmf, MFENUMPROC lpEnumFunc, LPARAM lpData)
 461 {
 462     METAHEADER *mh = get_metafile_bits( hmf );
 463     METARECORD *mr;
 464     HANDLETABLE *ht;
 465     BOOL result = TRUE;
 466     int i;
 467     unsigned int offset = 0;
 468     HPEN hPen;
 469     HBRUSH hBrush;
 470     HFONT hFont;
 471
 472     TRACE("(%p,%p,%p,%lx)\n", hdc, hmf, lpEnumFunc, lpData);
 473
 474     if (!mh) return FALSE;
 475
 476     /* save the current pen, brush and font */
 477     hPen = GetCurrentObject(hdc, OBJ_PEN);
 478     hBrush = GetCurrentObject(hdc, OBJ_BRUSH);
 479     hFont = GetCurrentObject(hdc, OBJ_FONT);
 480
 481     ht = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 482                             sizeof(HANDLETABLE) * mh->mtNoObjects);
 483
 484     /* loop through metafile records */
 485     offset = mh->mtHeaderSize * 2;
 486
 487     while (offset < (mh->mtSize * 2))
 488     {
 489         mr = (METARECORD *)((char *)mh + offset);
 490         if(mr->rdFunction == META_EOF) {
 491             TRACE("Got META_EOF so stopping\n");
 492             break;
 493         }
 494         TRACE("Calling EnumFunc with record type %x\n",
 495               mr->rdFunction);
 496         if (!lpEnumFunc( hdc, ht, mr, mh->mtNoObjects, lpData ))
 497         {
 498             result = FALSE;
 499             break;
 500         }
 501
 502         offset += (mr->rdSize * 2);
 503     }
 504
 505     /* restore pen, brush and font */
 506     SelectObject(hdc, hBrush);
 507     SelectObject(hdc, hPen);
 508     SelectObject(hdc, hFont);
 509
 510     /* free objects in handle table */
 511     for(i = 0; i < mh->mtNoObjects; i++)
 512       if(*(ht->objectHandle + i) != 0)
 513         DeleteObject(*(ht->objectHandle + i));
 514
 515     HeapFree( GetProcessHeap(), 0, ht);
 516     HeapFree( GetProcessHeap(), 0, mh);
 517     return result;
 518 }
 519
 520 static BOOL MF_Play_MetaCreateRegion( METARECORD *mr, HRGN hrgn );
 521 static BOOL MF_Play_MetaExtTextOut(HDC hdc, METARECORD *mr);
 522 /******************************************************************
 523  *         PlayMetaFileRecord   (GDI32.@)
 524  *
 525  *   Render a single metafile record specified by *mr in the DC hdc, while
 526  *   using the handle table *ht, of length handles,
 527  *   to store metafile objects.
 528  *
 529  * BUGS
 530  *  The following metafile records are unimplemented:
 531  *
 532  *  DRAWTEXT, ANIMATEPALETTE, SETPALENTRIES,
 533  *  RESIZEPALETTE, EXTFLOODFILL, RESETDC, STARTDOC, STARTPAGE, ENDPAGE,
 534  *  ABORTDOC, ENDDOC, CREATEBRUSH, CREATEBITMAPINDIRECT, and CREATEBITMAP.
 535  */
 536 BOOL WINAPI PlayMetaFileRecord( HDC hdc,  HANDLETABLE *ht, METARECORD *mr, UINT handles )
 537 {
 538     short s1;
 539     POINT *pt;
 540     BITMAPINFOHEADER *infohdr;
 541
 542     TRACE("(%p %p %p %u) function %04x\n", hdc, ht, mr, handles, mr->rdFunction);
 543
 544     switch (mr->rdFunction)
 545     {
 546     case META_EOF:
 547         break;
 548
 549     case META_DELETEOBJECT:
 550         DeleteObject(*(ht->objectHandle + mr->rdParm[0]));
 551         *(ht->objectHandle + mr->rdParm[0]) = 0;
 552         break;
 553
 554     case META_SETBKCOLOR:
 555         SetBkColor(hdc, MAKELONG(mr->rdParm[0], mr->rdParm[1]));
 556         break;
 557
 558     case META_SETBKMODE:
 559         SetBkMode(hdc, mr->rdParm[0]);
 560         break;
 561
 562     case META_SETMAPMODE:
 563         SetMapMode(hdc, mr->rdParm[0]);
 564         break;
 565
 566     case META_SETROP2:
 567         SetROP2(hdc, mr->rdParm[0]);
 568         break;
 569
 570     case META_SETRELABS:
 571         SetRelAbs(hdc, mr->rdParm[0]);
 572         break;
 573
 574     case META_SETPOLYFILLMODE:
 575         SetPolyFillMode(hdc, mr->rdParm[0]);
 576         break;
 577
 578     case META_SETSTRETCHBLTMODE:
 579         SetStretchBltMode(hdc, mr->rdParm[0]);
 580         break;
 581
 582     case META_SETTEXTCOLOR:
 583         SetTextColor(hdc, MAKELONG(mr->rdParm[0], mr->rdParm[1]));
 584         break;
 585
 586     case META_SETWINDOWORG:
 587         SetWindowOrgEx(hdc, (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0], NULL);
 588         break;
 589
 590     case META_SETWINDOWEXT:
 591         SetWindowExtEx(hdc, (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0], NULL);
 592         break;
 593
 594     case META_SETVIEWPORTORG:
 595         SetViewportOrgEx(hdc, (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0], NULL);
 596         break;
 597
 598     case META_SETVIEWPORTEXT:
 599         SetViewportExtEx(hdc, (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0], NULL);
 600         break;
 601
 602     case META_OFFSETWINDOWORG:
 603         OffsetWindowOrgEx(hdc, (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0], NULL);
 604         break;
 605
 606     case META_SCALEWINDOWEXT:
 607         ScaleWindowExtEx(hdc, (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
 608                               (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0], NULL);
 609         break;
 610
 611     case META_OFFSETVIEWPORTORG:
 612         OffsetViewportOrgEx(hdc, (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0], NULL);
 613         break;
 614
 615     case META_SCALEVIEWPORTEXT:
 616         ScaleViewportExtEx(hdc, (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
 617                                 (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0], NULL);
 618         break;
 619
 620     case META_LINETO:
 621         LineTo(hdc, (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0]);
 622         break;
 623
 624     case META_MOVETO:
 625         MoveToEx(hdc, (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0], NULL);
 626         break;
 627
 628     case META_EXCLUDECLIPRECT:
 629         ExcludeClipRect( hdc, (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
 630                               (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0] );
 631         break;
 632
 633     case META_INTERSECTCLIPRECT:
 634         IntersectClipRect( hdc, (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
 635                                 (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0] );
 636         break;
 637
 638     case META_ARC:
 639         Arc(hdc, (SHORT)mr->rdParm[7], (SHORT)mr->rdParm[6],
 640                  (SHORT)mr->rdParm[5], (SHORT)mr->rdParm[4],
 641                  (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
 642                  (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0]);
 643         break;
 644
 645     case META_ELLIPSE:
 646         Ellipse(hdc, (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
 647                      (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0]);
 648         break;
 649
 650     case META_FLOODFILL:
 651         FloodFill(hdc, (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
 652                     MAKELONG(mr->rdParm[0], mr->rdParm[1]));
 653         break;
 654
 655     case META_PIE:
 656         Pie(hdc, (SHORT)mr->rdParm[7], (SHORT)mr->rdParm[6],
 657                  (SHORT)mr->rdParm[5], (SHORT)mr->rdParm[4],
 658                  (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
 659                  (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0]);
 660         break;
 661
 662     case META_RECTANGLE:
 663         Rectangle(hdc, (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
 664                        (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0]);
 665         break;
 666
 667     case META_ROUNDRECT:
 668         RoundRect(hdc, (SHORT)mr->rdParm[5], (SHORT)mr->rdParm[4],
 669                        (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
 670                        (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0]);
 671         break;
 672
 673     case META_PATBLT:
 674         PatBlt(hdc, (SHORT)mr->rdParm[5], (SHORT)mr->rdParm[4],
 675                     (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
 676                     MAKELONG(mr->rdParm[0], mr->rdParm[1]));
 677         break;
 678
 679     case META_SAVEDC:
 680         SaveDC(hdc);
 681         break;
 682
 683     case META_SETPIXEL:
 684         SetPixel(hdc, (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
 685                  MAKELONG(mr->rdParm[0], mr->rdParm[1]));
 686         break;
 687
 688     case META_OFFSETCLIPRGN:
 689         OffsetClipRgn( hdc, (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0] );
 690         break;
 691
 692     case META_TEXTOUT:
 693         s1 = mr->rdParm[0];
 694         TextOutA(hdc, (SHORT)mr->rdParm[((s1 + 1) >> 1) + 2],
 695                  (SHORT)mr->rdParm[((s1 + 1) >> 1) + 1],
 696                  (char *)(mr->rdParm + 1), s1);
 697         break;
 698
 699     case META_POLYGON:
 700         if ((pt = convert_points( mr->rdParm[0], (POINTS *)(mr->rdParm + 1))))
 701         {
 702             Polygon(hdc, pt, mr->rdParm[0]);
 703             HeapFree( GetProcessHeap(), 0, pt );
 704         }
 705         break;
 706
 707     case META_POLYPOLYGON:
 708         {
 709             UINT i, total;
 710             SHORT *counts = (SHORT *)(mr->rdParm + 1);
 711
 712             for (i = total = 0; i < mr->rdParm[0]; i++) total += counts[i];
 713             pt = convert_points( total, (POINTS *)(counts + mr->rdParm[0]) );
 714             if (pt)
 715             {
 716                 INT *cnt32 = HeapAlloc( GetProcessHeap(), 0, mr->rdParm[0] * sizeof(*cnt32) );
 717                 if (cnt32)
 718                 {
 719                     for (i = 0; i < mr->rdParm[0]; i++) cnt32[i] = counts[i];
 720                     PolyPolygon( hdc, pt, cnt32, mr->rdParm[0]);
 721                     HeapFree( GetProcessHeap(), 0, cnt32 );
 722                 }
 723             }
 724             HeapFree( GetProcessHeap(), 0, pt );
 725         }
 726         break;
 727
 728     case META_POLYLINE:
 729         if ((pt = convert_points( mr->rdParm[0], (POINTS *)(mr->rdParm + 1))))
 730         {
 731             Polyline( hdc, pt, mr->rdParm[0] );
 732             HeapFree( GetProcessHeap(), 0, pt );
 733         }
 734         break;
 735
 736     case META_RESTOREDC:
 737         RestoreDC(hdc, (SHORT)mr->rdParm[0]);
 738         break;
 739
 740     case META_SELECTOBJECT:
 741         SelectObject(hdc, *(ht->objectHandle + mr->rdParm[0]));
 742         break;
 743
 744     case META_CHORD:
 745         Chord(hdc, (SHORT)mr->rdParm[7], (SHORT)mr->rdParm[6],
 746                    (SHORT)mr->rdParm[5], (SHORT)mr->rdParm[4],
 747                    (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
 748                    (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0]);
 749         break;
 750
 751     case META_CREATEPATTERNBRUSH:
 752         switch (mr->rdParm[0])
 753         {
 754         case BS_PATTERN:
 755             infohdr = (BITMAPINFOHEADER *)(mr->rdParm + 2);
 756             MF_AddHandle(ht, handles,
 757                          CreatePatternBrush(CreateBitmap(infohdr->biWidth,
 758                                       infohdr->biHeight,
 759                                       infohdr->biPlanes,
 760                                       infohdr->biBitCount,
 761                                       mr->rdParm +
 762                                       (sizeof(BITMAPINFOHEADER) / 2) + 4)));
 763             break;
 764
 765         case BS_DIBPATTERN:
 766             infohdr = (BITMAPINFOHEADER *)(mr->rdParm + 2);
 767             MF_AddHandle(ht, handles, CreateDIBPatternBrushPt( infohdr, mr->rdParm[1] ));
 768             break;
 769
 770         default:
 771             ERR("META_CREATEPATTERNBRUSH: Unknown pattern type %d\n",
 772                 mr->rdParm[0]);
 773             break;
 774         }
 775         break;
 776
 777     case META_CREATEPENINDIRECT:
 778         {
 779             LOGPEN pen;
 780             pen.lopnStyle = mr->rdParm[0];
 781             pen.lopnWidth.x = (SHORT)mr->rdParm[1];
 782             pen.lopnWidth.y = (SHORT)mr->rdParm[2];
 783             pen.lopnColor = MAKELONG( mr->rdParm[3], mr->rdParm[4] );
 784             MF_AddHandle(ht, handles, CreatePenIndirect( &pen ));
 785         }
 786         break;
 787
 788     case META_CREATEFONTINDIRECT:
 789         {
 790             LOGFONTA font;
 791             font.lfHeight         = (SHORT)mr->rdParm[0];
 792             font.lfWidth          = (SHORT)mr->rdParm[1];
 793             font.lfEscapement     = (SHORT)mr->rdParm[2];
 794             font.lfOrientation    = (SHORT)mr->rdParm[3];
 795             font.lfWeight         = (SHORT)mr->rdParm[4];
 796             font.lfItalic         = LOBYTE(mr->rdParm[5]);
 797             font.lfUnderline      = HIBYTE(mr->rdParm[5]);
 798             font.lfStrikeOut      = LOBYTE(mr->rdParm[6]);
 799             font.lfCharSet        = HIBYTE(mr->rdParm[6]);
 800             font.lfOutPrecision   = LOBYTE(mr->rdParm[7]);
 801             font.lfClipPrecision  = HIBYTE(mr->rdParm[7]);
 802             font.lfQuality        = LOBYTE(mr->rdParm[8]);
 803             font.lfPitchAndFamily = HIBYTE(mr->rdParm[8]);
 804             memcpy( font.lfFaceName, mr->rdParm + 9, LF_FACESIZE );
 805             MF_AddHandle(ht, handles, CreateFontIndirectA( &font ));
 806         }
 807         break;
 808
 809     case META_CREATEBRUSHINDIRECT:
 810         {
 811             LOGBRUSH brush;
 812             brush.lbStyle = mr->rdParm[0];
 813             brush.lbColor = MAKELONG( mr->rdParm[1], mr->rdParm[2] );
 814             brush.lbHatch = mr->rdParm[3];
 815             MF_AddHandle(ht, handles, CreateBrushIndirect( &brush ));
 816         }
 817         break;
 818
 819     case META_CREATEPALETTE:
 820         MF_AddHandle(ht, handles, CreatePalette((LPLOGPALETTE)mr->rdParm));
 821         break;
 822
 823     case META_SETTEXTALIGN:
 824         SetTextAlign(hdc, mr->rdParm[0]);
 825         break;
 826
 827     case META_SELECTPALETTE:
 828         GDISelectPalette(hdc, *(ht->objectHandle + mr->rdParm[1]), mr->rdParm[0]);
 829         break;
 830
 831     case META_SETMAPPERFLAGS:
 832         SetMapperFlags(hdc, MAKELONG(mr->rdParm[0],mr->rdParm[1]));
 833         break;
 834
 835     case META_REALIZEPALETTE:
 836         GDIRealizePalette(hdc);
 837         break;
 838
 839     case META_ESCAPE:
 840         switch (mr->rdParm[0]) {
 841         case GETSCALINGFACTOR: /* get function ... would just NULL dereference */
 842         case GETPHYSPAGESIZE:
 843         case GETPRINTINGOFFSET:
 844              return FALSE;
 845         case SETABORTPROC:
 846              FIXME("Filtering Escape(SETABORTPROC), possible virus?\n");
 847              return FALSE;
 848         }
 849         Escape(hdc, mr->rdParm[0], mr->rdParm[1], (LPCSTR)&mr->rdParm[2], NULL);
 850         break;
 851
 852     case META_EXTTEXTOUT:
 853         MF_Play_MetaExtTextOut( hdc, mr );
 854         break;
 855
 856     case META_STRETCHDIB:
 857       {
 858         LPBITMAPINFO info = (LPBITMAPINFO) &(mr->rdParm[11]);
 859         LPSTR bits = (LPSTR)info + bitmap_info_size( info, mr->rdParm[2] );
 860         StretchDIBits( hdc, (SHORT)mr->rdParm[10], (SHORT)mr->rdParm[9], (SHORT)mr->rdParm[8],
 861                        (SHORT)mr->rdParm[7], (SHORT)mr->rdParm[6], (SHORT)mr->rdParm[5],
 862                        (SHORT)mr->rdParm[4], (SHORT)mr->rdParm[3], bits, info,
 863                        mr->rdParm[2],MAKELONG(mr->rdParm[0],mr->rdParm[1]));
 864       }
 865       break;
 866
 867     case META_DIBSTRETCHBLT:
 868       {
 869         LPBITMAPINFO info = (LPBITMAPINFO) &(mr->rdParm[10]);
 870         LPSTR bits = (LPSTR)info + bitmap_info_size( info, DIB_RGB_COLORS );
 871         StretchDIBits( hdc, (SHORT)mr->rdParm[9], (SHORT)mr->rdParm[8], (SHORT)mr->rdParm[7],
 872                        (SHORT)mr->rdParm[6], (SHORT)mr->rdParm[5], (SHORT)mr->rdParm[4],
 873                        (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2], bits, info,
 874                        DIB_RGB_COLORS,MAKELONG(mr->rdParm[0],mr->rdParm[1]));
 875       }
 876       break;
 877
 878     case META_STRETCHBLT:
 879       {
 880         HDC hdcSrc = CreateCompatibleDC(hdc);
 881         HBITMAP hbitmap = CreateBitmap(mr->rdParm[10], /*Width */
 882                                        mr->rdParm[11], /*Height*/
 883                                        mr->rdParm[13], /*Planes*/
 884                                        mr->rdParm[14], /*BitsPixel*/
 885                                        &mr->rdParm[15]); /*bits*/
 886         SelectObject(hdcSrc,hbitmap);
 887         StretchBlt(hdc, (SHORT)mr->rdParm[9], (SHORT)mr->rdParm[8],
 888                    (SHORT)mr->rdParm[7], (SHORT)mr->rdParm[6],
 889                    hdcSrc, (SHORT)mr->rdParm[5], (SHORT)mr->rdParm[4],
 890                    (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
 891                    MAKELONG(mr->rdParm[0],mr->rdParm[1]));
 892         DeleteDC(hdcSrc);
 893       }
 894       break;
 895
 896     case META_BITBLT:
 897       {
 898         HDC hdcSrc = CreateCompatibleDC(hdc);
 899         HBITMAP hbitmap = CreateBitmap(mr->rdParm[7]/*Width */,
 900                                         mr->rdParm[8]/*Height*/,
 901                                         mr->rdParm[10]/*Planes*/,
 902                                         mr->rdParm[11]/*BitsPixel*/,
 903                                         &mr->rdParm[12]/*bits*/);
 904         SelectObject(hdcSrc,hbitmap);
 905         BitBlt(hdc,(SHORT)mr->rdParm[6],(SHORT)mr->rdParm[5],
 906                 (SHORT)mr->rdParm[4],(SHORT)mr->rdParm[3],
 907                 hdcSrc, (SHORT)mr->rdParm[2],(SHORT)mr->rdParm[1],
 908                 MAKELONG(0,mr->rdParm[0]));
 909         DeleteDC(hdcSrc);
 910       }
 911       break;
 912
 913     case META_CREATEREGION:
 914       {
 915         HRGN hrgn = CreateRectRgn(0,0,0,0);
 916
 917         MF_Play_MetaCreateRegion(mr, hrgn);
 918         MF_AddHandle(ht, handles, hrgn);
 919       }
 920       break;
 921
 922     case META_FILLREGION:
 923         FillRgn(hdc, *(ht->objectHandle + mr->rdParm[1]),
 924                 *(ht->objectHandle + mr->rdParm[0]));
 925         break;
 926
 927     case META_FRAMEREGION:
 928         FrameRgn(hdc, *(ht->objectHandle + mr->rdParm[3]),
 929                  *(ht->objectHandle + mr->rdParm[2]),
 930                  (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0]);
 931         break;
 932
 933     case META_INVERTREGION:
 934         InvertRgn(hdc, *(ht->objectHandle + mr->rdParm[0]));
 935         break;
 936
 937     case META_PAINTREGION:
 938         PaintRgn(hdc, *(ht->objectHandle + mr->rdParm[0]));
 939         break;
 940
 941     case META_SELECTCLIPREGION:
 942         {
 943             HRGN hrgn = 0;
 944
 945             if (mr->rdParm[0]) hrgn = *(ht->objectHandle + mr->rdParm[0]);
 946             SelectClipRgn(hdc, hrgn);
 947         }
 948         break;
 949
 950     case META_DIBCREATEPATTERNBRUSH:
 951         /*  mr->rdParm[0] may be BS_PATTERN or BS_DIBPATTERN:
 952             but there's no difference */
 953         MF_AddHandle(ht, handles, CreateDIBPatternBrushPt( mr->rdParm + 2, mr->rdParm[1] ));
 954         break;
 955
 956     case META_DIBBITBLT:
 957       /* In practice I've found that there are two layouts for
 958          META_DIBBITBLT, one (the first here) is the usual one when a src
 959          dc is actually passed to it, the second occurs when the src dc is
 960          passed in as NULL to the creating BitBlt. As the second case has
 961          no dib, a size check will suffice to distinguish.
 962
 963          Caolan.McNamara@ul.ie */
 964
 965         if (mr->rdSize > 12) {
 966             LPBITMAPINFO info = (LPBITMAPINFO) &(mr->rdParm[8]);
 967             LPSTR bits = (LPSTR)info + bitmap_info_size(info, mr->rdParm[0]);
 968
 969             StretchDIBits(hdc, (SHORT)mr->rdParm[7], (SHORT)mr->rdParm[6], (SHORT)mr->rdParm[5],
 970                           (SHORT)mr->rdParm[4], (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
 971                           (SHORT)mr->rdParm[5], (SHORT)mr->rdParm[4], bits, info,
 972                           DIB_RGB_COLORS, MAKELONG(mr->rdParm[0], mr->rdParm[1]));
 973         }
 974         else /* equivalent to a PatBlt */
 975             PatBlt(hdc, (SHORT)mr->rdParm[8], (SHORT)mr->rdParm[7],
 976                    (SHORT)mr->rdParm[6], (SHORT)mr->rdParm[5],
 977                    MAKELONG(mr->rdParm[0], mr->rdParm[1]));
 978         break;
 979
 980     case META_SETTEXTCHAREXTRA:
 981         SetTextCharacterExtra(hdc, (SHORT)mr->rdParm[0]);
 982         break;
 983
 984     case META_SETTEXTJUSTIFICATION:
 985         SetTextJustification(hdc, (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0]);
 986         break;
 987
 988     case META_EXTFLOODFILL:
 989         ExtFloodFill(hdc, (SHORT)mr->rdParm[4], (SHORT)mr->rdParm[3],
 990                      MAKELONG(mr->rdParm[1], mr->rdParm[2]),
 991                      mr->rdParm[0]);
 992         break;
 993
 994     case META_SETDIBTODEV:
 995         {
 996             BITMAPINFO *info = (BITMAPINFO *) &(mr->rdParm[9]);
 997             char *bits = (char *)info + bitmap_info_size( info, mr->rdParm[0] );
 998             SetDIBitsToDevice(hdc, (SHORT)mr->rdParm[8], (SHORT)mr->rdParm[7],
 999                               (SHORT)mr->rdParm[6], (SHORT)mr->rdParm[5],
1000                               (SHORT)mr->rdParm[4], (SHORT)mr->rdParm[3],
1001                               mr->rdParm[2], mr->rdParm[1], bits, info,
1002                               mr->rdParm[0]);
1003             break;
1004         }
1005
1006 #define META_UNIMP(x) case x: \
1007 FIXME("PlayMetaFileRecord:record type "#x" not implemented.\n"); \
1008 break;
1009     META_UNIMP(META_DRAWTEXT)
1010     META_UNIMP(META_ANIMATEPALETTE)
1011     META_UNIMP(META_SETPALENTRIES)
1012     META_UNIMP(META_RESIZEPALETTE)
1013     META_UNIMP(META_RESETDC)
1014     META_UNIMP(META_STARTDOC)
1015     META_UNIMP(META_STARTPAGE)
1016     META_UNIMP(META_ENDPAGE)
1017     META_UNIMP(META_ABORTDOC)
1018     META_UNIMP(META_ENDDOC)
1019     META_UNIMP(META_CREATEBRUSH)
1020     META_UNIMP(META_CREATEBITMAPINDIRECT)
1021     META_UNIMP(META_CREATEBITMAP)
1022 #undef META_UNIMP
1023
1024     default:
1025         WARN("PlayMetaFileRecord: Unknown record type %x\n", mr->rdFunction);
1026         return FALSE;
1027     }
1028     return TRUE;
1029 }
1030
1031 /******************************************************************
1032  *         SetMetaFileBitsEx    (GDI32.@)
1033  *
1034  *  Create a metafile from raw data. No checking of the data is performed.
1035  *  Use GetMetaFileBitsEx() to get raw data from a metafile.
1036  *
1037  * PARAMS
1038  *  size   [I] size of metafile, in bytes
1039  *  lpData [I] pointer to metafile data
1040  *
1041  * RETURNS
1042  *  Success: Handle to metafile.
1043  *  Failure: NULL.
1044  */
1045 HMETAFILE WINAPI SetMetaFileBitsEx( UINT size, const BYTE *lpData )
1046 {
1047     const METAHEADER *mh_in = (const METAHEADER *)lpData;
1048     METAHEADER *mh_out;
1049
1050     if (size & 1) return 0;
1051
1052     if (!size || mh_in->mtType != METAFILE_MEMORY || mh_in->mtVersion != MFVERSION ||
1053         mh_in->mtHeaderSize != sizeof(METAHEADER) / 2)
1054     {
1055         SetLastError(ERROR_INVALID_DATA);
1056         return 0;
1057     }
1058
1059     mh_out = HeapAlloc( GetProcessHeap(), 0, size );
1060     if (!mh_out)
1061     {
1062         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1063         return 0;
1064     }
1065
1066     memcpy(mh_out, mh_in, size);
1067     mh_out->mtSize = size / 2;
1068     return MF_Create_HMETAFILE(mh_out);
1069 }
1070
1071 /*****************************************************************
1072  *  GetMetaFileBitsEx     (GDI32.@)
1073  *
1074  * Get raw metafile data.
1075  *
1076  *  Copies the data from metafile _hmf_ into the buffer _buf_.
1077  *
1078  * PARAMS
1079  *  hmf   [I] metafile
1080  *  nSize [I] size of buf
1081  *  buf   [O] buffer to receive raw metafile data
1082  *
1083  * RETURNS
1084  *  If _buf_ is zero, returns size of buffer required. Otherwise,
1085  *  returns number of bytes copied.
1086  */
1087 UINT WINAPI GetMetaFileBitsEx( HMETAFILE hmf, UINT nSize, LPVOID buf )
1088 {
1089     METAHEADER *mh = GDI_GetObjPtr( hmf, OBJ_METAFILE );
1090     UINT mfSize;
1091     BOOL mf_copy = FALSE;
1092
1093     TRACE("(%p,%d,%p)\n", hmf, nSize, buf);
1094     if (!mh) return 0;  /* FIXME: error code */
1095     if(mh->mtType == METAFILE_DISK)
1096     {
1097         mh = MF_LoadDiskBasedMetaFile( mh );
1098         if (!mh)
1099         {
1100             GDI_ReleaseObj( hmf );
1101             return 0;
1102         }
1103         mf_copy = TRUE;
1104     }
1105     mfSize = mh->mtSize * 2;
1106     if (buf)
1107     {
1108         if(mfSize > nSize) mfSize = nSize;
1109         memmove(buf, mh, mfSize);
1110     }
1111     if (mf_copy) HeapFree( GetProcessHeap(), 0, mh );
1112     GDI_ReleaseObj( hmf );
1113     TRACE("returning size %d\n", mfSize);
1114     return mfSize;
1115 }
1116
1117 /******************************************************************
1118  *         add_mf_comment
1119  *
1120  * Helper for GetWinMetaFileBits
1121  *
1122  * Add the MFCOMMENT record[s] which is essentially a copy
1123  * of the original emf.
1124  */
1125 static BOOL add_mf_comment(HDC hdc, HENHMETAFILE emf)
1126 {
1127     DWORD size = GetEnhMetaFileBits(emf, 0, NULL), i;
1128     BYTE *bits, *chunk_data;
1129     emf_in_wmf_comment *chunk = NULL;
1130     BOOL ret = FALSE;
1131     static const DWORD max_chunk_size = 0x2000;
1132
1133     if(!size) return FALSE;
1134     chunk_data = bits = HeapAlloc(GetProcessHeap(), 0, size);
1135     if(!bits) return FALSE;
1136     if(!GetEnhMetaFileBits(emf, size, bits)) goto end;
1137
1138     chunk = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(emf_in_wmf_comment, emf_data[max_chunk_size]));
1139     if(!chunk) goto end;
1140
1141     chunk->magic = WMFC_MAGIC;
1142     chunk->unk04 = 1;
1143     chunk->unk06 = 0;
1144     chunk->unk08 = 0;
1145     chunk->unk0a = 1;
1146     chunk->checksum = 0; /* We fixup the first chunk's checksum before returning from GetWinMetaFileBits */
1147     chunk->unk0e = 0;
1148     chunk->num_chunks = (size + max_chunk_size - 1) / max_chunk_size;
1149     chunk->chunk_size = max_chunk_size;
1150     chunk->remaining_size = size;
1151     chunk->emf_size = size;
1152
1153     for(i = 0; i < chunk->num_chunks; i++)
1154     {
1155         if(i == chunk->num_chunks - 1) /* last chunk */
1156             chunk->chunk_size = chunk->remaining_size;
1157
1158         chunk->remaining_size -= chunk->chunk_size;
1159         memcpy(chunk->emf_data, chunk_data, chunk->chunk_size);
1160         chunk_data += chunk->chunk_size;
1161
1162         if(!Escape(hdc, MFCOMMENT, FIELD_OFFSET(emf_in_wmf_comment, emf_data[chunk->chunk_size]), (char*)chunk, NULL))
1163             goto end;
1164     }
1165     ret = TRUE;
1166 end:
1167     HeapFree(GetProcessHeap(), 0, chunk);
1168     HeapFree(GetProcessHeap(), 0, bits);
1169     return ret;
1170 }
1171
1172 /*******************************************************************
1173  *        muldiv
1174  *
1175  * Behaves somewhat differently to MulDiv when the answer is -ve
1176  * and also rounds n.5 towards zero
1177  */
1178 static INT muldiv(INT m1, INT m2, INT d)
1179 {
1180     LONGLONG ret;
1181
1182     ret = ((LONGLONG)m1 * m2 + d/2) / d; /* Always add d/2 even if ret will be -ve */
1183
1184     if((LONGLONG)m1 * m2 * 2 == (2 * ret - 1) * d) /* If the answer is exactly n.5 round towards zero */
1185     {
1186         if(ret > 0) ret--;
1187         else ret++;
1188     }
1189     return ret;
1190 }
1191
1192 /******************************************************************
1193  *         set_window
1194  *
1195  * Helper for GetWinMetaFileBits
1196  *
1197  * Add the SetWindowOrg and SetWindowExt records
1198  */
1199 static BOOL set_window(HDC hdc, HENHMETAFILE emf, HDC ref_dc, INT map_mode)
1200 {
1201     ENHMETAHEADER header;
1202     INT horz_res, vert_res, horz_size, vert_size;
1203     POINT pt;
1204
1205     if(!GetEnhMetaFileHeader(emf, sizeof(header), &header)) return FALSE;
1206
1207     horz_res = GetDeviceCaps(ref_dc, HORZRES);
1208     vert_res = GetDeviceCaps(ref_dc, VERTRES);
1209     horz_size = GetDeviceCaps(ref_dc, HORZSIZE);
1210     vert_size = GetDeviceCaps(ref_dc, VERTSIZE);
1211
1212     switch(map_mode)
1213     {
1214     case MM_TEXT:
1215     case MM_ISOTROPIC:
1216     case MM_ANISOTROPIC:
1217         pt.y = muldiv(header.rclFrame.top, vert_res, vert_size * 100);
1218         pt.x = muldiv(header.rclFrame.left, horz_res, horz_size * 100);
1219         break;
1220     case MM_LOMETRIC:
1221         pt.y = muldiv(-header.rclFrame.top, 1, 10) + 1;
1222         pt.x = muldiv( header.rclFrame.left, 1, 10);
1223         break;
1224     case MM_HIMETRIC:
1225         pt.y = -header.rclFrame.top + 1;
1226         pt.x = (header.rclFrame.left >= 0) ? header.rclFrame.left : header.rclFrame.left + 1; /* See the tests */
1227         break;
1228     case MM_LOENGLISH:
1229         pt.y = muldiv(-header.rclFrame.top, 10, 254) + 1;
1230         pt.x = muldiv( header.rclFrame.left, 10, 254);
1231         break;
1232     case MM_HIENGLISH:
1233         pt.y = muldiv(-header.rclFrame.top, 100, 254) + 1;
1234         pt.x = muldiv( header.rclFrame.left, 100, 254);
1235         break;
1236     case MM_TWIPS:
1237         pt.y = muldiv(-header.rclFrame.top, 72 * 20, 2540) + 1;
1238         pt.x = muldiv( header.rclFrame.left, 72 * 20, 2540);
1239         break;
1240     default:
1241         WARN("Unknown map mode %d\n", map_mode);
1242         return FALSE;
1243     }
1244     SetWindowOrgEx(hdc, pt.x, pt.y, NULL);
1245
1246     pt.x = muldiv(header.rclFrame.right - header.rclFrame.left, horz_res, horz_size * 100);
1247     pt.y = muldiv(header.rclFrame.bottom - header.rclFrame.top, vert_res, vert_size * 100);
1248     SetWindowExtEx(hdc, pt.x, pt.y, NULL);
1249     return TRUE;
1250 }
1251
1252 /******************************************************************
1253  *         GetWinMetaFileBits [GDI32.@]
1254  */
1255 UINT WINAPI GetWinMetaFileBits(HENHMETAFILE hemf,
1256                                 UINT cbBuffer, LPBYTE lpbBuffer,
1257                                 INT map_mode, HDC hdcRef)
1258 {
1259     HDC hdcmf;
1260     HMETAFILE hmf;
1261     UINT ret, full_size;
1262     RECT rc;
1263
1264     GetClipBox(hdcRef, &rc);
1265
1266     TRACE("(%p,%d,%p,%d,%p) rc=%s\n", hemf, cbBuffer, lpbBuffer,
1267           map_mode, hdcRef, wine_dbgstr_rect(&rc));
1268
1269     hdcmf = CreateMetaFileW(NULL);
1270
1271     add_mf_comment(hdcmf, hemf);
1272     SetMapMode(hdcmf, map_mode);
1273     if(!set_window(hdcmf, hemf, hdcRef, map_mode))
1274         goto error;
1275
1276     PlayEnhMetaFile(hdcmf, hemf, &rc);
1277     hmf = CloseMetaFile(hdcmf);
1278     full_size = GetMetaFileBitsEx(hmf, 0, NULL);
1279     ret = GetMetaFileBitsEx(hmf, cbBuffer, lpbBuffer);
1280     DeleteMetaFile(hmf);
1281
1282     if(ret && ret == full_size && lpbBuffer) /* fixup checksum, but only if retrieving all of the bits */
1283     {
1284         WORD checksum = 0;
1285         METARECORD *comment_rec = (METARECORD*)(lpbBuffer + sizeof(METAHEADER));
1286         UINT i;
1287
1288         for(i = 0; i < full_size / 2; i++)
1289             checksum += ((WORD*)lpbBuffer)[i];
1290         comment_rec->rdParm[8] = ~checksum + 1;
1291     }
1292     return ret;
1293
1294 error:
1295     DeleteMetaFile(CloseMetaFile(hdcmf));
1296     return 0;
1297 }
1298
1299 /******************************************************************
1300  *         MF_Play_MetaCreateRegion
1301  *
1302  *  Handles META_CREATEREGION for PlayMetaFileRecord().
1303  *
1304  *      The layout of the record looks something like this:
1305  *
1306  *       rdParm meaning
1307  *       0              Always 0?
1308  *       1              Always 6?
1309  *       2              Looks like a handle? - not constant
1310  *       3              0 or 1 ??
1311  *       4              Total number of bytes
1312  *       5              No. of separate bands = n [see below]
1313  *       6              Largest number of x co-ords in a band
1314  *       7-10           Bounding box x1 y1 x2 y2
1315  *       11-...         n bands
1316  *
1317  *       Regions are divided into bands that are uniform in the
1318  *       y-direction. Each band consists of pairs of on/off x-coords and is
1319  *       written as
1320  *              m y0 y1 x1 x2 x3 ... xm m
1321  *       into successive rdParm[]s.
1322  *
1323  *       This is probably just a dump of the internal RGNOBJ?
1324  *
1325  *       HDMD - 18/12/97
1326  *
1327  */
1328
1329 static BOOL MF_Play_MetaCreateRegion( METARECORD *mr, HRGN hrgn )
1330 {
1331     WORD band, pair;
1332     WORD *start, *end;
1333     INT16 y0, y1;
1334     HRGN hrgn2 = CreateRectRgn( 0, 0, 0, 0 );
1335
1336     for(band  = 0, start = &(mr->rdParm[11]); band < mr->rdParm[5];
1337                                                 band++, start = end + 1) {
1338         if(*start / 2 != (*start + 1) / 2) {
1339             WARN("Delimiter not even.\n");
1340             DeleteObject( hrgn2 );
1341             return FALSE;
1342         }
1343
1344         end = start + *start + 3;
1345         if(end > (WORD *)mr + mr->rdSize) {
1346             WARN("End points outside record.\n");
1347             DeleteObject( hrgn2 );
1348             return FALSE;
1349         }
1350
1351         if(*start != *end) {
1352             WARN("Mismatched delimiters.\n");
1353             DeleteObject( hrgn2 );
1354             return FALSE;
1355         }
1356
1357         y0 = *(INT16 *)(start + 1);
1358         y1 = *(INT16 *)(start + 2);
1359         for(pair = 0; pair < *start / 2; pair++) {
1360             SetRectRgn( hrgn2, *(INT16 *)(start + 3 + 2*pair), y0,
1361                                  *(INT16 *)(start + 4 + 2*pair), y1 );
1362             CombineRgn(hrgn, hrgn, hrgn2, RGN_OR);
1363         }
1364     }
1365     DeleteObject( hrgn2 );
1366     return TRUE;
1367  }
1368
1369
1370 /******************************************************************
1371  *         MF_Play_MetaExtTextOut
1372  *
1373  *  Handles META_EXTTEXTOUT for PlayMetaFileRecord().
1374  */
1375
1376 static BOOL MF_Play_MetaExtTextOut(HDC hdc, METARECORD *mr)
1377 {
1378     INT *dx = NULL;
1379     int i;
1380     SHORT *dxx;
1381     LPSTR sot;
1382     DWORD len;
1383     WORD s1;
1384     RECT rect;
1385     BOOL isrect = mr->rdParm[3] & (ETO_OPAQUE | ETO_CLIPPED);
1386
1387     s1 = mr->rdParm[2];                              /* String length */
1388     len = sizeof(METARECORD) + (((s1 + 1) >> 1) * 2) + 2 * sizeof(short)
1389         + sizeof(UINT16) + (isrect ? 4 * sizeof(SHORT) : 0);
1390                                            /* rec len without dx array */
1391
1392     sot = (LPSTR)&mr->rdParm[4];                      /* start_of_text */
1393     if (isrect)
1394     {
1395         rect.left   = (SHORT)mr->rdParm[4];
1396         rect.top    = (SHORT)mr->rdParm[5];
1397         rect.right  = (SHORT)mr->rdParm[6];
1398         rect.bottom = (SHORT)mr->rdParm[7];
1399         sot += 4 * sizeof(SHORT);  /* there is a rectangle, so add offset */
1400     }
1401
1402     if (mr->rdSize == len / 2)
1403         dxx = NULL;                      /* determine if array is present */
1404     else
1405         if (mr->rdSize == (len + s1 * sizeof(INT16)) / 2)
1406         {
1407             dxx = (SHORT *)(sot+(((s1+1)>>1)*2));
1408             dx = HeapAlloc( GetProcessHeap(), 0, s1*sizeof(INT));
1409             if (dx) for (i = 0; i < s1; i++) dx[i] = dxx[i];
1410         }
1411         else {
1412             TRACE("%s  len: %d\n",  sot, mr->rdSize);
1413             WARN("Please report: ExtTextOut len=%d slen=%d rdSize=%d opt=%04x\n",
1414                  len, s1, mr->rdSize, mr->rdParm[3]);
1415             dxx = NULL; /* shouldn't happen -- but if, we continue with NULL */
1416         }
1417     ExtTextOutA( hdc,
1418                  (SHORT)mr->rdParm[1],       /* X position */
1419                  (SHORT)mr->rdParm[0],       /* Y position */
1420                  mr->rdParm[3],              /* options */
1421                  &rect,                      /* rectangle */
1422                  sot,                        /* string */
1423                  s1, dx);                    /* length, dx array */
1424     if (dx)
1425     {
1426         TRACE("%s  len: %d  dx0: %d\n", sot, mr->rdSize, dx[0]);
1427         HeapFree( GetProcessHeap(), 0, dx );
1428     }
1429     return TRUE;
1430 }