objects/enhmetafile.c

   1 /*
   2  * Enhanced metafile functions
   3  * Copyright 1998 Douglas Ridgway
   4  *           1999 Huw D M Davies
   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * NOTES:
  21  *
  22  * The enhanced format consists of the following elements:
  23  *
  24  *    A header
  25  *    A table of handles to GDI objects
  26  *    An array of metafile records
  27  *    A private palette
  28  *
  29  *
  30  *  The standard format consists of a header and an array of metafile records.
  31  *
  32  */
  33
  34 #include "config.h"
  35 #include "wine/port.h"
  36
  37 #include <string.h>
  38 #include <assert.h>
  39 #include "winnls.h"
  40 #include "winbase.h"
  41 #include "wingdi.h"
  42 #include "winerror.h"
  43 #include "gdi.h"
  44 #include "wine/debug.h"
  45
  46 WINE_DEFAULT_DEBUG_CHANNEL(enhmetafile);
  47
  48 typedef struct
  49 {
  50     GDIOBJHDR      header;
  51     ENHMETAHEADER  *emh;
  52     BOOL           on_disk;   /* true if metafile is on disk */
  53 } ENHMETAFILEOBJ;
  54
  55
  56 /****************************************************************************
  57  *          EMF_Create_HENHMETAFILE
  58  */
  59 HENHMETAFILE EMF_Create_HENHMETAFILE(ENHMETAHEADER *emh, BOOL on_disk )
  60 {
  61     HENHMETAFILE hmf = 0;
  62     ENHMETAFILEOBJ *metaObj = GDI_AllocObject( sizeof(ENHMETAFILEOBJ),
  63                                                ENHMETAFILE_MAGIC,
  64                                                (HGDIOBJ *)&hmf, NULL );
  65     if (metaObj)
  66     {
  67         metaObj->emh = emh;
  68         metaObj->on_disk = on_disk;
  69         GDI_ReleaseObj( hmf );
  70     }
  71     return hmf;
  72 }
  73
  74 /****************************************************************************
  75  *          EMF_Delete_HENHMETAFILE
  76  */
  77 static BOOL EMF_Delete_HENHMETAFILE( HENHMETAFILE hmf )
  78 {
  79     ENHMETAFILEOBJ *metaObj = (ENHMETAFILEOBJ *)GDI_GetObjPtr( hmf,
  80                                                            ENHMETAFILE_MAGIC );
  81     if(!metaObj) return FALSE;
  82
  83     if(metaObj->on_disk)
  84         UnmapViewOfFile( metaObj->emh );
  85     else
  86         HeapFree( GetProcessHeap(), 0, metaObj->emh );
  87     return GDI_FreeObject( hmf, metaObj );
  88 }
  89
  90 /******************************************************************
  91  *         EMF_GetEnhMetaHeader
  92  *
  93  * Returns ptr to ENHMETAHEADER associated with HENHMETAFILE
  94  */
  95 static ENHMETAHEADER *EMF_GetEnhMetaHeader( HENHMETAFILE hmf )
  96 {
  97     ENHMETAHEADER *ret = NULL;
  98     ENHMETAFILEOBJ *metaObj = (ENHMETAFILEOBJ *)GDI_GetObjPtr( hmf, ENHMETAFILE_MAGIC );
  99     TRACE("hmf %p -> enhmetaObj %p\n", hmf, metaObj);
 100     if (metaObj)
 101     {
 102         ret = metaObj->emh;
 103         GDI_ReleaseObj( hmf );
 104     }
 105     return ret;
 106 }
 107
 108 /*****************************************************************************
 109  *         EMF_GetEnhMetaFile
 110  *
 111  */
 112 static HENHMETAFILE EMF_GetEnhMetaFile( HANDLE hFile )
 113 {
 114     ENHMETAHEADER *emh;
 115     HANDLE hMapping;
 116
 117     hMapping = CreateFileMappingA( hFile, NULL, PAGE_READONLY, 0, 0, NULL );
 118     emh = MapViewOfFile( hMapping, FILE_MAP_READ, 0, 0, 0 );
 119     CloseHandle( hMapping );
 120
 121     if (!emh) return 0;
 122
 123     if (emh->iType != EMR_HEADER || emh->dSignature != ENHMETA_SIGNATURE) {
 124         WARN("Invalid emf header type 0x%08lx sig 0x%08lx.\n",
 125              emh->iType, emh->dSignature);
 126         goto err;
 127     }
 128
 129     /* refuse to load unaligned EMF as Windows does */
 130     if (emh->nBytes & 3)
 131     {
 132         WARN("Refusing to load unaligned EMF\n");
 133         goto err;
 134     }
 135
 136     return EMF_Create_HENHMETAFILE( emh, TRUE );
 137
 138 err:
 139     UnmapViewOfFile( emh );
 140     return 0;
 141 }
 142
 143
 144 /*****************************************************************************
 145  *          GetEnhMetaFileA (GDI32.@)
 146  *
 147  *
 148  */
 149 HENHMETAFILE WINAPI GetEnhMetaFileA(
 150              LPCSTR lpszMetaFile  /* [in] filename of enhanced metafile */
 151     )
 152 {
 153     HENHMETAFILE hmf;
 154     HANDLE hFile;
 155
 156     hFile = CreateFileA(lpszMetaFile, GENERIC_READ, FILE_SHARE_READ, 0,
 157                         OPEN_EXISTING, 0, 0);
 158     if (hFile == INVALID_HANDLE_VALUE) {
 159         WARN("could not open %s\n", lpszMetaFile);
 160         return 0;
 161     }
 162     hmf = EMF_GetEnhMetaFile( hFile );
 163     CloseHandle( hFile );
 164     return hmf;
 165 }
 166
 167 /*****************************************************************************
 168  *          GetEnhMetaFileW  (GDI32.@)
 169  */
 170 HENHMETAFILE WINAPI GetEnhMetaFileW(
 171              LPCWSTR lpszMetaFile)  /* [in] filename of enhanced metafile */
 172 {
 173     HENHMETAFILE hmf;
 174     HANDLE hFile;
 175
 176     hFile = CreateFileW(lpszMetaFile, GENERIC_READ, FILE_SHARE_READ, 0,
 177                         OPEN_EXISTING, 0, 0);
 178     if (hFile == INVALID_HANDLE_VALUE) {
 179         WARN("could not open %s\n", debugstr_w(lpszMetaFile));
 180         return 0;
 181     }
 182     hmf = EMF_GetEnhMetaFile( hFile );
 183     CloseHandle( hFile );
 184     return hmf;
 185 }
 186
 187 /*****************************************************************************
 188  *        GetEnhMetaFileHeader  (GDI32.@)
 189  *
 190  *  If buf is NULL, returns the size of buffer required.
 191  *  Otherwise, copy up to bufsize bytes of enhanced metafile header into
 192  *  buf.
 193  */
 194 UINT WINAPI GetEnhMetaFileHeader(
 195        HENHMETAFILE hmf,   /* [in] enhanced metafile */
 196        UINT bufsize,       /* [in] size of buffer */
 197        LPENHMETAHEADER buf /* [out] buffer */
 198     )
 199 {
 200     LPENHMETAHEADER emh;
 201     UINT size;
 202
 203     emh = EMF_GetEnhMetaHeader(hmf);
 204     if(!emh) return FALSE;
 205     size = emh->nSize;
 206     if (!buf) return size;
 207     size = min(size, bufsize);
 208     memmove(buf, emh, size);
 209     return size;
 210 }
 211
 212
 213 /*****************************************************************************
 214  *          GetEnhMetaFileDescriptionA  (GDI32.@)
 215  */
 216 UINT WINAPI GetEnhMetaFileDescriptionA(
 217        HENHMETAFILE hmf, /* [in] enhanced metafile */
 218        UINT size,        /* [in] size of buf */
 219        LPSTR buf         /* [out] buffer to receive description */
 220     )
 221 {
 222      LPENHMETAHEADER emh = EMF_GetEnhMetaHeader(hmf);
 223      DWORD len;
 224      WCHAR *descrW;
 225
 226      if(!emh) return FALSE;
 227      if(emh->nDescription == 0 || emh->offDescription == 0) return 0;
 228      descrW = (WCHAR *) ((char *) emh + emh->offDescription);
 229      len = WideCharToMultiByte( CP_ACP, 0, descrW, emh->nDescription, NULL, 0, NULL, NULL );
 230
 231      if (!buf || !size ) return len;
 232
 233      len = min( size, len );
 234      WideCharToMultiByte( CP_ACP, 0, descrW, emh->nDescription, buf, len, NULL, NULL );
 235      return len;
 236 }
 237
 238 /*****************************************************************************
 239  *          GetEnhMetaFileDescriptionW  (GDI32.@)
 240  *
 241  *  Copies the description string of an enhanced metafile into a buffer
 242  *  _buf_.
 243  *
 244  *  If _buf_ is NULL, returns size of _buf_ required. Otherwise, returns
 245  *  number of characters copied.
 246  */
 247 UINT WINAPI GetEnhMetaFileDescriptionW(
 248        HENHMETAFILE hmf, /* [in] enhanced metafile */
 249        UINT size,        /* [in] size of buf */
 250        LPWSTR buf        /* [out] buffer to receive description */
 251     )
 252 {
 253      LPENHMETAHEADER emh = EMF_GetEnhMetaHeader(hmf);
 254
 255      if(!emh) return FALSE;
 256      if(emh->nDescription == 0 || emh->offDescription == 0) return 0;
 257      if (!buf || !size ) return emh->nDescription;
 258
 259      memmove(buf, (char *) emh + emh->offDescription, min(size,emh->nDescription)*sizeof(WCHAR));
 260      return min(size, emh->nDescription);
 261 }
 262
 263 /****************************************************************************
 264  *    SetEnhMetaFileBits (GDI32.@)
 265  *
 266  *  Creates an enhanced metafile by copying _bufsize_ bytes from _buf_.
 267  */
 268 HENHMETAFILE WINAPI SetEnhMetaFileBits(UINT bufsize, const BYTE *buf)
 269 {
 270     ENHMETAHEADER *emh = HeapAlloc( GetProcessHeap(), 0, bufsize );
 271     memmove(emh, buf, bufsize);
 272     return EMF_Create_HENHMETAFILE( emh, FALSE );
 273 }
 274
 275 /*****************************************************************************
 276  *  GetEnhMetaFileBits (GDI32.@)
 277  *
 278  */
 279 UINT WINAPI GetEnhMetaFileBits(
 280     HENHMETAFILE hmf,
 281     UINT bufsize,
 282     LPBYTE buf
 283 )
 284 {
 285     LPENHMETAHEADER emh = EMF_GetEnhMetaHeader( hmf );
 286     UINT size;
 287
 288     if(!emh) return 0;
 289
 290     size = emh->nBytes;
 291     if( buf == NULL ) return size;
 292
 293     size = min( size, bufsize );
 294     memmove(buf, emh, size);
 295     return size;
 296 }
 297
 298 typedef struct enum_emh_data
 299 {
 300     INT   mode;
 301     XFORM init_transform;
 302     XFORM world_transform;
 303     INT   wndOrgX;
 304     INT   wndOrgY;
 305     INT   wndExtX;
 306     INT   wndExtY;
 307     INT   vportOrgX;
 308     INT   vportOrgY;
 309     INT   vportExtX;
 310     INT   vportExtY;
 311 } enum_emh_data;
 312
 313 #define ENUM_GET_PRIVATE_DATA(ht) \
 314     ((enum_emh_data*)(((unsigned char*)(ht))-sizeof (enum_emh_data)))
 315
 316 #define WIDTH(rect) ( (rect).right - (rect).left )
 317 #define HEIGHT(rect) ( (rect).bottom - (rect).top )
 318
 319 #define IS_WIN9X() (GetVersion()&0x80000000)
 320
 321 void EMF_Update_MF_Xform(HDC hdc, enum_emh_data *info)
 322 {
 323     XFORM mapping_mode_trans, final_trans;
 324     FLOAT scaleX, scaleY;
 325
 326     scaleX = (FLOAT)info->vportExtX / (FLOAT)info->wndExtX;
 327     scaleY = (FLOAT)info->vportExtY / (FLOAT)info->wndExtY;
 328     mapping_mode_trans.eM11 = scaleX;
 329     mapping_mode_trans.eM12 = 0.0;
 330     mapping_mode_trans.eM21 = 0.0;
 331     mapping_mode_trans.eM22 = scaleY;
 332     mapping_mode_trans.eDx  = (FLOAT)info->vportOrgX - scaleX * (FLOAT)info->wndOrgX;
 333     mapping_mode_trans.eDy  = (FLOAT)info->vportOrgY - scaleY * (FLOAT)info->wndOrgY;
 334
 335     CombineTransform(&final_trans, &info->world_transform, &mapping_mode_trans);
 336     CombineTransform(&final_trans, &final_trans, &info->init_transform);
 337
 338     if (!SetWorldTransform(hdc, &final_trans))
 339     {
 340         ERR("World transform failed!\n");
 341     }
 342 }
 343
 344 void EMF_SetMapMode(HDC hdc, enum_emh_data *info)
 345 {
 346     INT horzSize = GetDeviceCaps( hdc, HORZSIZE );
 347     INT vertSize = GetDeviceCaps( hdc, VERTSIZE );
 348     INT horzRes  = GetDeviceCaps( hdc, HORZRES );
 349     INT vertRes  = GetDeviceCaps( hdc, VERTRES );
 350
 351     TRACE("%d\n",info->mode);
 352
 353     switch(info->mode)
 354     {
 355     case MM_TEXT:
 356         info->wndExtX   = 1;
 357         info->wndExtY   = 1;
 358         info->vportExtX = 1;
 359         info->vportExtY = 1;
 360         break;
 361     case MM_LOMETRIC:
 362     case MM_ISOTROPIC:
 363         info->wndExtX   = horzSize;
 364         info->wndExtY   = vertSize;
 365         info->vportExtX = horzRes / 10;
 366         info->vportExtY = vertRes / -10;
 367         break;
 368     case MM_HIMETRIC:
 369         info->wndExtX   = horzSize * 10;
 370         info->wndExtY   = vertSize * 10;
 371         info->vportExtX = horzRes / 10;
 372         info->vportExtY = vertRes / -10;
 373         break;
 374     case MM_LOENGLISH:
 375         info->wndExtX   = horzSize;
 376         info->wndExtY   = vertSize;
 377         info->vportExtX = 254L * horzRes / 1000;
 378         info->vportExtY = -254L * vertRes / 1000;
 379         break;
 380     case MM_HIENGLISH:
 381         info->wndExtX   = horzSize * 10;
 382         info->wndExtY   = vertSize * 10;
 383         info->vportExtX = 254L * horzRes / 1000;
 384         info->vportExtY = -254L * vertRes / 1000;
 385         break;
 386     case MM_TWIPS:
 387         info->wndExtX   = 144L * horzSize / 10;
 388         info->wndExtY   = 144L * vertSize / 10;
 389         info->vportExtX = 254L * horzRes / 1000;
 390         info->vportExtY = -254L * vertRes / 1000;
 391         break;
 392     case MM_ANISOTROPIC:
 393         break;
 394     default:
 395         return;
 396     }
 397 }
 398
 399 /*****************************************************************************
 400  *       emr_produces_output
 401  *
 402  * Returns TRUE if the record type writes something to the dc.  Used by
 403  * PlayEnhMetaFileRecord to determine whether it needs to update the
 404  * dc's xform when in win9x mode.
 405  *
 406  * FIXME: need to test which records should be here.
 407  */
 408 static BOOL emr_produces_output(int type)
 409 {
 410     switch(type) {
 411     case EMR_POLYBEZIER:
 412     case EMR_POLYGON:
 413     case EMR_POLYLINE:
 414     case EMR_POLYBEZIERTO:
 415     case EMR_POLYLINETO:
 416     case EMR_POLYPOLYLINE:
 417     case EMR_POLYPOLYGON:
 418     case EMR_SETPIXELV:
 419     case EMR_MOVETOEX:
 420     case EMR_EXCLUDECLIPRECT:
 421     case EMR_INTERSECTCLIPRECT:
 422     case EMR_SELECTOBJECT:
 423     case EMR_ANGLEARC:
 424     case EMR_ELLIPSE:
 425     case EMR_RECTANGLE:
 426     case EMR_ROUNDRECT:
 427     case EMR_ARC:
 428     case EMR_CHORD:
 429     case EMR_PIE:
 430     case EMR_EXTFLOODFILL:
 431     case EMR_LINETO:
 432     case EMR_ARCTO:
 433     case EMR_POLYDRAW:
 434     case EMR_FILLRGN:
 435     case EMR_FRAMERGN:
 436     case EMR_INVERTRGN:
 437     case EMR_PAINTRGN:
 438     case EMR_BITBLT:
 439     case EMR_STRETCHBLT:
 440     case EMR_MASKBLT:
 441     case EMR_PLGBLT:
 442     case EMR_SETDIBITSTODEVICE:
 443     case EMR_STRETCHDIBITS:
 444     case EMR_EXTTEXTOUTA:
 445     case EMR_EXTTEXTOUTW:
 446     case EMR_POLYBEZIER16:
 447     case EMR_POLYGON16:
 448     case EMR_POLYLINE16:
 449     case EMR_POLYBEZIERTO16:
 450     case EMR_POLYLINETO16:
 451     case EMR_POLYPOLYLINE16:
 452     case EMR_POLYPOLYGON16:
 453     case EMR_POLYDRAW16:
 454     case EMR_POLYTEXTOUTA:
 455     case EMR_POLYTEXTOUTW:
 456     case EMR_SMALLTEXTOUT:
 457     case EMR_TRANSPARENTBLT:
 458         return TRUE;
 459     default:
 460         return FALSE;
 461     }
 462 }
 463
 464
 465 /*****************************************************************************
 466  *           PlayEnhMetaFileRecord  (GDI32.@)
 467  *
 468  *  Render a single enhanced metafile record in the device context hdc.
 469  *
 470  *  RETURNS
 471  *    TRUE (non zero) on success, FALSE on error.
 472  *  BUGS
 473  *    Many unimplemented records.
 474  *    No error handling on record play failures (ie checking return codes)
 475  *
 476  * NOTES
 477  *    WinNT actually updates the current world transform in this function
 478  *     whereas Win9x does not.
 479  */
 480 BOOL WINAPI PlayEnhMetaFileRecord(
 481      HDC hdc,                   /* [in] device context in which to render EMF record */
 482      LPHANDLETABLE handletable, /* [in] array of handles to be used in rendering record */
 483      const ENHMETARECORD *mr,   /* [in] EMF record to render */
 484      UINT handles               /* [in] size of handle array */
 485      )
 486 {
 487   int type;
 488   RECT tmprc;
 489   enum_emh_data *info = ENUM_GET_PRIVATE_DATA(handletable);
 490
 491   TRACE("hdc = %p, handletable = %p, record = %p, numHandles = %d\n",
 492         hdc, handletable, mr, handles);
 493   if (!mr) return FALSE;
 494
 495   type = mr->iType;
 496
 497   /* In Win9x mode we update the xform if the record will produce output */
 498   if ( IS_WIN9X() && emr_produces_output(type) )
 499      EMF_Update_MF_Xform(hdc, info);
 500
 501   TRACE(" type=%d\n", type);
 502   switch(type)
 503     {
 504     case EMR_HEADER:
 505       break;
 506     case EMR_EOF:
 507       break;
 508     case EMR_GDICOMMENT:
 509       {
 510         PEMRGDICOMMENT lpGdiComment = (PEMRGDICOMMENT)mr;
 511         /* In an enhanced metafile, there can be both public and private GDI comments */
 512         GdiComment( hdc, lpGdiComment->cbData, lpGdiComment->Data );
 513         break;
 514       }
 515     case EMR_SETMAPMODE:
 516       {
 517         PEMRSETMAPMODE pSetMapMode = (PEMRSETMAPMODE) mr;
 518
 519         if(info->mode == pSetMapMode->iMode)
 520             break;
 521         info->mode = pSetMapMode->iMode;
 522         EMF_SetMapMode(hdc, info);
 523         break;
 524       }
 525     case EMR_SETBKMODE:
 526       {
 527         PEMRSETBKMODE pSetBkMode = (PEMRSETBKMODE) mr;
 528         SetBkMode(hdc, pSetBkMode->iMode);
 529         break;
 530       }
 531     case EMR_SETBKCOLOR:
 532       {
 533         PEMRSETBKCOLOR pSetBkColor = (PEMRSETBKCOLOR) mr;
 534         SetBkColor(hdc, pSetBkColor->crColor);
 535         break;
 536       }
 537     case EMR_SETPOLYFILLMODE:
 538       {
 539         PEMRSETPOLYFILLMODE pSetPolyFillMode = (PEMRSETPOLYFILLMODE) mr;
 540         SetPolyFillMode(hdc, pSetPolyFillMode->iMode);
 541         break;
 542       }
 543     case EMR_SETROP2:
 544       {
 545         PEMRSETROP2 pSetROP2 = (PEMRSETROP2) mr;
 546         SetROP2(hdc, pSetROP2->iMode);
 547         break;
 548       }
 549     case EMR_SETSTRETCHBLTMODE:
 550       {
 551         PEMRSETSTRETCHBLTMODE pSetStretchBltMode = (PEMRSETSTRETCHBLTMODE) mr;
 552         SetStretchBltMode(hdc, pSetStretchBltMode->iMode);
 553         break;
 554       }
 555     case EMR_SETTEXTALIGN:
 556       {
 557         PEMRSETTEXTALIGN pSetTextAlign = (PEMRSETTEXTALIGN) mr;
 558         SetTextAlign(hdc, pSetTextAlign->iMode);
 559         break;
 560       }
 561     case EMR_SETTEXTCOLOR:
 562       {
 563         PEMRSETTEXTCOLOR pSetTextColor = (PEMRSETTEXTCOLOR) mr;
 564         SetTextColor(hdc, pSetTextColor->crColor);
 565         break;
 566       }
 567     case EMR_SAVEDC:
 568       {
 569         SaveDC(hdc);
 570         break;
 571       }
 572     case EMR_RESTOREDC:
 573       {
 574         PEMRRESTOREDC pRestoreDC = (PEMRRESTOREDC) mr;
 575         RestoreDC(hdc, pRestoreDC->iRelative);
 576         break;
 577       }
 578     case EMR_INTERSECTCLIPRECT:
 579       {
 580         PEMRINTERSECTCLIPRECT pClipRect = (PEMRINTERSECTCLIPRECT) mr;
 581         IntersectClipRect(hdc, pClipRect->rclClip.left, pClipRect->rclClip.top,
 582                           pClipRect->rclClip.right, pClipRect->rclClip.bottom);
 583         break;
 584       }
 585     case EMR_SELECTOBJECT:
 586       {
 587         PEMRSELECTOBJECT pSelectObject = (PEMRSELECTOBJECT) mr;
 588         if( pSelectObject->ihObject & 0x80000000 ) {
 589           /* High order bit is set - it's a stock object
 590            * Strip the high bit to get the index.
 591            * See MSDN article Q142319
 592            */
 593           SelectObject( hdc, GetStockObject( pSelectObject->ihObject &
 594                                              0x7fffffff ) );
 595         } else {
 596           /* High order bit wasn't set - not a stock object
 597            */
 598               SelectObject( hdc,
 599                         (handletable->objectHandle)[pSelectObject->ihObject] );
 600         }
 601         break;
 602       }
 603     case EMR_DELETEOBJECT:
 604       {
 605         PEMRDELETEOBJECT pDeleteObject = (PEMRDELETEOBJECT) mr;
 606         DeleteObject( (handletable->objectHandle)[pDeleteObject->ihObject]);
 607         (handletable->objectHandle)[pDeleteObject->ihObject] = 0;
 608         break;
 609       }
 610     case EMR_SETWINDOWORGEX:
 611       {
 612         PEMRSETWINDOWORGEX pSetWindowOrgEx = (PEMRSETWINDOWORGEX) mr;
 613
 614         info->wndOrgX = pSetWindowOrgEx->ptlOrigin.x;
 615         info->wndOrgY = pSetWindowOrgEx->ptlOrigin.y;
 616
 617         TRACE("SetWindowOrgEx: %d,%d\n",info->wndOrgX,info->wndOrgY);
 618         break;
 619       }
 620     case EMR_SETWINDOWEXTEX:
 621       {
 622         PEMRSETWINDOWEXTEX pSetWindowExtEx = (PEMRSETWINDOWEXTEX) mr;
 623
 624         if(info->mode != MM_ISOTROPIC && info->mode != MM_ANISOTROPIC)
 625             break;
 626         info->wndExtX = pSetWindowExtEx->szlExtent.cx;
 627         info->wndExtY = pSetWindowExtEx->szlExtent.cy;
 628
 629         TRACE("SetWindowExtEx: %d,%d\n",info->wndExtX,info->wndExtY);
 630         break;
 631       }
 632     case EMR_SETVIEWPORTORGEX:
 633       {
 634         PEMRSETVIEWPORTORGEX pSetViewportOrgEx = (PEMRSETVIEWPORTORGEX) mr;
 635         enum_emh_data *info = ENUM_GET_PRIVATE_DATA(handletable);
 636
 637         info->vportOrgX = pSetViewportOrgEx->ptlOrigin.x;
 638         info->vportOrgY = pSetViewportOrgEx->ptlOrigin.y;
 639         TRACE("SetViewportOrgEx: %d,%d\n",info->vportOrgX,info->vportOrgY);
 640         break;
 641       }
 642     case EMR_SETVIEWPORTEXTEX:
 643       {
 644         PEMRSETVIEWPORTEXTEX pSetViewportExtEx = (PEMRSETVIEWPORTEXTEX) mr;
 645         enum_emh_data *info = ENUM_GET_PRIVATE_DATA(handletable);
 646
 647         if(info->mode != MM_ISOTROPIC && info->mode != MM_ANISOTROPIC)
 648             break;
 649         info->vportExtX = pSetViewportExtEx->szlExtent.cx;
 650         info->vportExtY = pSetViewportExtEx->szlExtent.cy;
 651         TRACE("SetViewportExtEx: %d,%d\n",info->vportExtX,info->vportExtY);
 652         break;
 653       }
 654     case EMR_CREATEPEN:
 655       {
 656         PEMRCREATEPEN pCreatePen = (PEMRCREATEPEN) mr;
 657         (handletable->objectHandle)[pCreatePen->ihPen] =
 658           CreatePenIndirect(&pCreatePen->lopn);
 659         break;
 660       }
 661     case EMR_EXTCREATEPEN:
 662       {
 663         PEMREXTCREATEPEN pPen = (PEMREXTCREATEPEN) mr;
 664         LOGBRUSH lb;
 665         lb.lbStyle = pPen->elp.elpBrushStyle;
 666         lb.lbColor = pPen->elp.elpColor;
 667         lb.lbHatch = pPen->elp.elpHatch;
 668
 669         if(pPen->offBmi || pPen->offBits)
 670           FIXME("EMR_EXTCREATEPEN: Need to copy brush bitmap\n");
 671
 672         (handletable->objectHandle)[pPen->ihPen] =
 673           ExtCreatePen(pPen->elp.elpPenStyle, pPen->elp.elpWidth, &lb,
 674                        pPen->elp.elpNumEntries, pPen->elp.elpStyleEntry);
 675         break;
 676       }
 677     case EMR_CREATEBRUSHINDIRECT:
 678       {
 679         PEMRCREATEBRUSHINDIRECT pBrush = (PEMRCREATEBRUSHINDIRECT) mr;
 680         (handletable->objectHandle)[pBrush->ihBrush] =
 681           CreateBrushIndirect(&pBrush->lb);
 682         break;
 683       }
 684     case EMR_EXTCREATEFONTINDIRECTW:
 685       {
 686         PEMREXTCREATEFONTINDIRECTW pFont = (PEMREXTCREATEFONTINDIRECTW) mr;
 687         (handletable->objectHandle)[pFont->ihFont] =
 688           CreateFontIndirectW(&pFont->elfw.elfLogFont);
 689         break;
 690       }
 691     case EMR_MOVETOEX:
 692       {
 693         PEMRMOVETOEX pMoveToEx = (PEMRMOVETOEX) mr;
 694         MoveToEx(hdc, pMoveToEx->ptl.x, pMoveToEx->ptl.y, NULL);
 695         break;
 696       }
 697     case EMR_LINETO:
 698       {
 699         PEMRLINETO pLineTo = (PEMRLINETO) mr;
 700         LineTo(hdc, pLineTo->ptl.x, pLineTo->ptl.y);
 701         break;
 702       }
 703     case EMR_RECTANGLE:
 704       {
 705         PEMRRECTANGLE pRect = (PEMRRECTANGLE) mr;
 706         Rectangle(hdc, pRect->rclBox.left, pRect->rclBox.top,
 707                   pRect->rclBox.right, pRect->rclBox.bottom);
 708         break;
 709       }
 710     case EMR_ELLIPSE:
 711       {
 712         PEMRELLIPSE pEllipse = (PEMRELLIPSE) mr;
 713         Ellipse(hdc, pEllipse->rclBox.left, pEllipse->rclBox.top,
 714                 pEllipse->rclBox.right, pEllipse->rclBox.bottom);
 715         break;
 716       }
 717     case EMR_POLYGON16:
 718       {
 719         PEMRPOLYGON16 pPoly = (PEMRPOLYGON16) mr;
 720         /* Shouldn't use Polygon16 since pPoly->cpts is DWORD */
 721         POINT *pts = HeapAlloc( GetProcessHeap(), 0,
 722                                 pPoly->cpts * sizeof(POINT) );
 723         DWORD i;
 724         for(i = 0; i < pPoly->cpts; i++)
 725           CONV_POINT16TO32(pPoly->apts + i, pts + i);
 726         Polygon(hdc, pts, pPoly->cpts);
 727         HeapFree( GetProcessHeap(), 0, pts );
 728         break;
 729       }
 730     case EMR_POLYLINE16:
 731       {
 732         PEMRPOLYLINE16 pPoly = (PEMRPOLYLINE16) mr;
 733         /* Shouldn't use Polyline16 since pPoly->cpts is DWORD */
 734         POINT *pts = HeapAlloc( GetProcessHeap(), 0,
 735                                 pPoly->cpts * sizeof(POINT) );
 736         DWORD i;
 737         for(i = 0; i < pPoly->cpts; i++)
 738           CONV_POINT16TO32(pPoly->apts + i, pts + i);
 739         Polyline(hdc, pts, pPoly->cpts);
 740         HeapFree( GetProcessHeap(), 0, pts );
 741         break;
 742       }
 743     case EMR_POLYLINETO16:
 744       {
 745         PEMRPOLYLINETO16 pPoly = (PEMRPOLYLINETO16) mr;
 746         /* Shouldn't use PolylineTo16 since pPoly->cpts is DWORD */
 747         POINT *pts = HeapAlloc( GetProcessHeap(), 0,
 748                                 pPoly->cpts * sizeof(POINT) );
 749         DWORD i;
 750         for(i = 0; i < pPoly->cpts; i++)
 751           CONV_POINT16TO32(pPoly->apts + i, pts + i);
 752         PolylineTo(hdc, pts, pPoly->cpts);
 753         HeapFree( GetProcessHeap(), 0, pts );
 754         break;
 755       }
 756     case EMR_POLYBEZIER16:
 757       {
 758         PEMRPOLYBEZIER16 pPoly = (PEMRPOLYBEZIER16) mr;
 759         /* Shouldn't use PolyBezier16 since pPoly->cpts is DWORD */
 760         POINT *pts = HeapAlloc( GetProcessHeap(), 0,
 761                                 pPoly->cpts * sizeof(POINT) );
 762         DWORD i;
 763         for(i = 0; i < pPoly->cpts; i++)
 764           CONV_POINT16TO32(pPoly->apts + i, pts + i);
 765         PolyBezier(hdc, pts, pPoly->cpts);
 766         HeapFree( GetProcessHeap(), 0, pts );
 767         break;
 768       }
 769     case EMR_POLYBEZIERTO16:
 770       {
 771         PEMRPOLYBEZIERTO16 pPoly = (PEMRPOLYBEZIERTO16) mr;
 772         /* Shouldn't use PolyBezierTo16 since pPoly->cpts is DWORD */
 773         POINT *pts = HeapAlloc( GetProcessHeap(), 0,
 774                                 pPoly->cpts * sizeof(POINT) );
 775         DWORD i;
 776         for(i = 0; i < pPoly->cpts; i++)
 777           CONV_POINT16TO32(pPoly->apts + i, pts + i);
 778         PolyBezierTo(hdc, pts, pPoly->cpts);
 779         HeapFree( GetProcessHeap(), 0, pts );
 780         break;
 781       }
 782     case EMR_POLYPOLYGON16:
 783       {
 784         PEMRPOLYPOLYGON16 pPolyPoly = (PEMRPOLYPOLYGON16) mr;
 785         /* NB POINTS array doesn't start at pPolyPoly->apts it's actually
 786            pPolyPoly->aPolyCounts + pPolyPoly->nPolys */
 787
 788         POINT *pts = HeapAlloc( GetProcessHeap(), 0,
 789                                 pPolyPoly->cpts * sizeof(POINT) );
 790         DWORD i;
 791         for(i = 0; i < pPolyPoly->cpts; i++)
 792           CONV_POINT16TO32((POINT16*) (pPolyPoly->aPolyCounts +
 793                                       pPolyPoly->nPolys) + i, pts + i);
 794
 795         PolyPolygon(hdc, pts, (INT*)pPolyPoly->aPolyCounts, pPolyPoly->nPolys);
 796         HeapFree( GetProcessHeap(), 0, pts );
 797         break;
 798       }
 799     case EMR_POLYPOLYLINE16:
 800       {
 801         PEMRPOLYPOLYLINE16 pPolyPoly = (PEMRPOLYPOLYLINE16) mr;
 802         /* NB POINTS array doesn't start at pPolyPoly->apts it's actually
 803            pPolyPoly->aPolyCounts + pPolyPoly->nPolys */
 804
 805         POINT *pts = HeapAlloc( GetProcessHeap(), 0,
 806                                 pPolyPoly->cpts * sizeof(POINT) );
 807         DWORD i;
 808         for(i = 0; i < pPolyPoly->cpts; i++)
 809           CONV_POINT16TO32((POINT16*) (pPolyPoly->aPolyCounts +
 810                                       pPolyPoly->nPolys) + i, pts + i);
 811
 812         PolyPolyline(hdc, pts, pPolyPoly->aPolyCounts, pPolyPoly->nPolys);
 813         HeapFree( GetProcessHeap(), 0, pts );
 814         break;
 815       }
 816
 817     case EMR_STRETCHDIBITS:
 818       {
 819         EMRSTRETCHDIBITS *pStretchDIBits = (EMRSTRETCHDIBITS *)mr;
 820
 821         StretchDIBits(hdc,
 822                       pStretchDIBits->xDest,
 823                       pStretchDIBits->yDest,
 824                       pStretchDIBits->cxDest,
 825                       pStretchDIBits->cyDest,
 826                       pStretchDIBits->xSrc,
 827                       pStretchDIBits->ySrc,
 828                       pStretchDIBits->cxSrc,
 829                       pStretchDIBits->cySrc,
 830                       (BYTE *)mr + pStretchDIBits->offBitsSrc,
 831                       (const BITMAPINFO *)((BYTE *)mr + pStretchDIBits->offBmiSrc),
 832                       pStretchDIBits->iUsageSrc,
 833                       pStretchDIBits->dwRop);
 834         break;
 835       }
 836
 837     case EMR_EXTTEXTOUTA:
 838     {
 839         PEMREXTTEXTOUTA pExtTextOutA = (PEMREXTTEXTOUTA)mr;
 840         RECT rc;
 841
 842         rc.left = pExtTextOutA->emrtext.rcl.left;
 843         rc.top = pExtTextOutA->emrtext.rcl.top;
 844         rc.right = pExtTextOutA->emrtext.rcl.right;
 845         rc.bottom = pExtTextOutA->emrtext.rcl.bottom;
 846         ExtTextOutA(hdc, pExtTextOutA->emrtext.ptlReference.x, pExtTextOutA->emrtext.ptlReference.y,
 847             pExtTextOutA->emrtext.fOptions, &rc,
 848             (LPSTR)((BYTE *)mr + pExtTextOutA->emrtext.offString), pExtTextOutA->emrtext.nChars,
 849             (INT *)((BYTE *)mr + pExtTextOutA->emrtext.offDx));
 850         break;
 851     }
 852
 853     case EMR_EXTTEXTOUTW:
 854     {
 855         PEMREXTTEXTOUTW pExtTextOutW = (PEMREXTTEXTOUTW)mr;
 856         RECT rc;
 857
 858         rc.left = pExtTextOutW->emrtext.rcl.left;
 859         rc.top = pExtTextOutW->emrtext.rcl.top;
 860         rc.right = pExtTextOutW->emrtext.rcl.right;
 861         rc.bottom = pExtTextOutW->emrtext.rcl.bottom;
 862         ExtTextOutW(hdc, pExtTextOutW->emrtext.ptlReference.x, pExtTextOutW->emrtext.ptlReference.y,
 863             pExtTextOutW->emrtext.fOptions, &rc,
 864             (LPWSTR)((BYTE *)mr + pExtTextOutW->emrtext.offString), pExtTextOutW->emrtext.nChars,
 865             (INT *)((BYTE *)mr + pExtTextOutW->emrtext.offDx));
 866         break;
 867     }
 868
 869     case EMR_CREATEPALETTE:
 870       {
 871         PEMRCREATEPALETTE lpCreatePal = (PEMRCREATEPALETTE)mr;
 872
 873         (handletable->objectHandle)[ lpCreatePal->ihPal ] =
 874                 CreatePalette( &lpCreatePal->lgpl );
 875
 876         break;
 877       }
 878
 879     case EMR_SELECTPALETTE:
 880       {
 881         PEMRSELECTPALETTE lpSelectPal = (PEMRSELECTPALETTE)mr;
 882
 883         if( lpSelectPal->ihPal & 0x80000000 ) {
 884                 SelectPalette( hdc, GetStockObject(lpSelectPal->ihPal & 0x7fffffff), TRUE);
 885         } else {
 886         (handletable->objectHandle)[ lpSelectPal->ihPal ] =
 887                 SelectPalette( hdc, (handletable->objectHandle)[lpSelectPal->ihPal], TRUE);
 888         }
 889         break;
 890       }
 891
 892     case EMR_REALIZEPALETTE:
 893       {
 894         RealizePalette( hdc );
 895         break;
 896       }
 897
 898     case EMR_EXTSELECTCLIPRGN:
 899       {
 900 #if 0
 901         PEMREXTSELECTCLIPRGN lpRgn = (PEMREXTSELECTCLIPRGN)mr;
 902         HRGN hRgn = ExtCreateRegion(NULL, lpRgn->cbRgnData, (RGNDATA *)lpRgn->RgnData);
 903         ExtSelectClipRgn(hdc, hRgn, (INT)(lpRgn->iMode));
 904         /* ExtSelectClipRgn created a copy of the region */
 905         DeleteObject(hRgn);
 906 #endif
 907         FIXME("ExtSelectClipRgn\n");
 908         break;
 909       }
 910
 911     case EMR_SETMETARGN:
 912       {
 913         SetMetaRgn( hdc );
 914         break;
 915       }
 916
 917     case EMR_SETWORLDTRANSFORM:
 918       {
 919         PEMRSETWORLDTRANSFORM lpXfrm = (PEMRSETWORLDTRANSFORM)mr;
 920         info->world_transform = lpXfrm->xform;
 921         break;
 922       }
 923
 924     case EMR_POLYBEZIER:
 925       {
 926         PEMRPOLYBEZIER lpPolyBez = (PEMRPOLYBEZIER)mr;
 927         PolyBezier(hdc, (const LPPOINT)lpPolyBez->aptl, (UINT)lpPolyBez->cptl);
 928         break;
 929       }
 930
 931     case EMR_POLYGON:
 932       {
 933         PEMRPOLYGON lpPoly = (PEMRPOLYGON)mr;
 934         Polygon( hdc, (const LPPOINT)lpPoly->aptl, (UINT)lpPoly->cptl );
 935         break;
 936       }
 937
 938     case EMR_POLYLINE:
 939       {
 940         PEMRPOLYLINE lpPolyLine = (PEMRPOLYLINE)mr;
 941         Polyline(hdc, (const LPPOINT)lpPolyLine->aptl, (UINT)lpPolyLine->cptl);
 942         break;
 943       }
 944
 945     case EMR_POLYBEZIERTO:
 946       {
 947         PEMRPOLYBEZIERTO lpPolyBezierTo = (PEMRPOLYBEZIERTO)mr;
 948         PolyBezierTo( hdc, (const LPPOINT)lpPolyBezierTo->aptl,
 949                       (UINT)lpPolyBezierTo->cptl );
 950         break;
 951       }
 952
 953     case EMR_POLYLINETO:
 954       {
 955         PEMRPOLYLINETO lpPolyLineTo = (PEMRPOLYLINETO)mr;
 956         PolylineTo( hdc, (const LPPOINT)lpPolyLineTo->aptl,
 957                     (UINT)lpPolyLineTo->cptl );
 958         break;
 959       }
 960
 961     case EMR_POLYPOLYLINE:
 962       {
 963         PEMRPOLYPOLYLINE pPolyPolyline = (PEMRPOLYPOLYLINE) mr;
 964         /* NB Points at pPolyPolyline->aPolyCounts + pPolyPolyline->nPolys */
 965
 966         PolyPolyline(hdc, (LPPOINT)(pPolyPolyline->aPolyCounts +
 967                                     pPolyPolyline->nPolys),
 968                      pPolyPolyline->aPolyCounts,
 969                      pPolyPolyline->nPolys );
 970
 971         break;
 972       }
 973
 974     case EMR_POLYPOLYGON:
 975       {
 976         PEMRPOLYPOLYGON pPolyPolygon = (PEMRPOLYPOLYGON) mr;
 977
 978         /* NB Points at pPolyPolygon->aPolyCounts + pPolyPolygon->nPolys */
 979
 980         PolyPolygon(hdc, (LPPOINT)(pPolyPolygon->aPolyCounts +
 981                                    pPolyPolygon->nPolys),
 982                     (INT*)pPolyPolygon->aPolyCounts, pPolyPolygon->nPolys );
 983         break;
 984       }
 985
 986     case EMR_SETBRUSHORGEX:
 987       {
 988         PEMRSETBRUSHORGEX lpSetBrushOrgEx = (PEMRSETBRUSHORGEX)mr;
 989
 990         SetBrushOrgEx( hdc,
 991                        (INT)lpSetBrushOrgEx->ptlOrigin.x,
 992                        (INT)lpSetBrushOrgEx->ptlOrigin.y,
 993                        NULL );
 994
 995         break;
 996       }
 997
 998     case EMR_SETPIXELV:
 999       {
1000         PEMRSETPIXELV lpSetPixelV = (PEMRSETPIXELV)mr;
1001
1002         SetPixelV( hdc,
1003                    (INT)lpSetPixelV->ptlPixel.x,
1004                    (INT)lpSetPixelV->ptlPixel.y,
1005                    lpSetPixelV->crColor );
1006
1007         break;
1008       }
1009
1010     case EMR_SETMAPPERFLAGS:
1011       {
1012         PEMRSETMAPPERFLAGS lpSetMapperFlags = (PEMRSETMAPPERFLAGS)mr;
1013
1014         SetMapperFlags( hdc, lpSetMapperFlags->dwFlags );
1015
1016         break;
1017       }
1018
1019     case EMR_SETCOLORADJUSTMENT:
1020       {
1021         PEMRSETCOLORADJUSTMENT lpSetColorAdjust = (PEMRSETCOLORADJUSTMENT)mr;
1022
1023         SetColorAdjustment( hdc, &lpSetColorAdjust->ColorAdjustment );
1024
1025         break;
1026       }
1027
1028     case EMR_OFFSETCLIPRGN:
1029       {
1030         PEMROFFSETCLIPRGN lpOffsetClipRgn = (PEMROFFSETCLIPRGN)mr;
1031
1032         OffsetClipRgn( hdc,
1033                        (INT)lpOffsetClipRgn->ptlOffset.x,
1034                        (INT)lpOffsetClipRgn->ptlOffset.y );
1035         FIXME("OffsetClipRgn\n");
1036
1037         break;
1038       }
1039
1040     case EMR_EXCLUDECLIPRECT:
1041       {
1042         PEMREXCLUDECLIPRECT lpExcludeClipRect = (PEMREXCLUDECLIPRECT)mr;
1043
1044         ExcludeClipRect( hdc,
1045                          lpExcludeClipRect->rclClip.left,
1046                          lpExcludeClipRect->rclClip.top,
1047                          lpExcludeClipRect->rclClip.right,
1048                          lpExcludeClipRect->rclClip.bottom  );
1049         FIXME("ExcludeClipRect\n");
1050
1051          break;
1052       }
1053
1054     case EMR_SCALEVIEWPORTEXTEX:
1055       {
1056         PEMRSCALEVIEWPORTEXTEX lpScaleViewportExtEx = (PEMRSCALEVIEWPORTEXTEX)mr;
1057
1058         if ((info->mode != MM_ISOTROPIC) && (info->mode != MM_ANISOTROPIC))
1059             break;
1060         if (!lpScaleViewportExtEx->xNum || !lpScaleViewportExtEx->xDenom ||
1061             !lpScaleViewportExtEx->xNum || !lpScaleViewportExtEx->yDenom)
1062             break;
1063         info->vportExtX = (info->vportExtX * lpScaleViewportExtEx->xNum) /
1064                                   lpScaleViewportExtEx->xDenom;
1065         info->vportExtY = (info->vportExtY * lpScaleViewportExtEx->yNum) /
1066                                   lpScaleViewportExtEx->yDenom;
1067         if (info->vportExtX == 0) info->vportExtX = 1;
1068         if (info->vportExtY == 0) info->vportExtY = 1;
1069         if (info->mode == MM_ISOTROPIC)
1070             FIXME("EMRSCALEVIEWPORTEXTEX MM_ISOTROPIC mapping\n");
1071             /* MAPPING_FixIsotropic( dc ); */
1072
1073         TRACE("EMRSCALEVIEWPORTEXTEX %ld/%ld %ld/%ld\n",
1074              lpScaleViewportExtEx->xNum,lpScaleViewportExtEx->xDenom,
1075              lpScaleViewportExtEx->yNum,lpScaleViewportExtEx->yDenom);
1076
1077         break;
1078       }
1079
1080     case EMR_SCALEWINDOWEXTEX:
1081       {
1082         PEMRSCALEWINDOWEXTEX lpScaleWindowExtEx = (PEMRSCALEWINDOWEXTEX)mr;
1083
1084         if ((info->mode != MM_ISOTROPIC) && (info->mode != MM_ANISOTROPIC))
1085             break;
1086         if (!lpScaleWindowExtEx->xNum || !lpScaleWindowExtEx->xDenom ||
1087             !lpScaleWindowExtEx->xNum || !lpScaleWindowExtEx->yDenom)
1088             break;
1089         info->wndExtX = (info->wndExtX * lpScaleWindowExtEx->xNum) /
1090                                   lpScaleWindowExtEx->xDenom;
1091         info->wndExtY = (info->wndExtY * lpScaleWindowExtEx->yNum) /
1092                                   lpScaleWindowExtEx->yDenom;
1093         if (info->wndExtX == 0) info->wndExtX = 1;
1094         if (info->wndExtY == 0) info->wndExtY = 1;
1095         if (info->mode == MM_ISOTROPIC)
1096             FIXME("EMRSCALEWINDOWEXTEX MM_ISOTROPIC mapping\n");
1097             /* MAPPING_FixIsotropic( dc ); */
1098
1099         TRACE("EMRSCALEWINDOWEXTEX %ld/%ld %ld/%ld\n",
1100              lpScaleWindowExtEx->xNum,lpScaleWindowExtEx->xDenom,
1101              lpScaleWindowExtEx->yNum,lpScaleWindowExtEx->yDenom);
1102
1103         break;
1104       }
1105
1106     case EMR_MODIFYWORLDTRANSFORM:
1107       {
1108         PEMRMODIFYWORLDTRANSFORM lpModifyWorldTrans = (PEMRMODIFYWORLDTRANSFORM)mr;
1109
1110         switch(lpModifyWorldTrans->iMode) {
1111         case MWT_IDENTITY:
1112             info->world_transform.eM11 = info->world_transform.eM22 = 1;
1113             info->world_transform.eM12 = info->world_transform.eM21 = 0;
1114             info->world_transform.eDx  = info->world_transform.eDy  = 0;
1115             break;
1116         case MWT_LEFTMULTIPLY:
1117             CombineTransform(&info->world_transform, &lpModifyWorldTrans->xform,
1118                              &info->world_transform);
1119             break;
1120         case MWT_RIGHTMULTIPLY:
1121             CombineTransform(&info->world_transform, &info->world_transform,
1122                              &lpModifyWorldTrans->xform);
1123             break;
1124         default:
1125             FIXME("Unknown imode %ld\n", lpModifyWorldTrans->iMode);
1126             break;
1127         }
1128         break;
1129       }
1130
1131     case EMR_ANGLEARC:
1132       {
1133         PEMRANGLEARC lpAngleArc = (PEMRANGLEARC)mr;
1134
1135         AngleArc( hdc,
1136                  (INT)lpAngleArc->ptlCenter.x, (INT)lpAngleArc->ptlCenter.y,
1137                  lpAngleArc->nRadius, lpAngleArc->eStartAngle,
1138                  lpAngleArc->eSweepAngle );
1139
1140         break;
1141       }
1142
1143     case EMR_ROUNDRECT:
1144       {
1145         PEMRROUNDRECT lpRoundRect = (PEMRROUNDRECT)mr;
1146
1147         RoundRect( hdc,
1148                    lpRoundRect->rclBox.left,
1149                    lpRoundRect->rclBox.top,
1150                    lpRoundRect->rclBox.right,
1151                    lpRoundRect->rclBox.bottom,
1152                    lpRoundRect->szlCorner.cx,
1153                    lpRoundRect->szlCorner.cy );
1154
1155         break;
1156       }
1157
1158     case EMR_ARC:
1159       {
1160         PEMRARC lpArc = (PEMRARC)mr;
1161
1162         Arc( hdc,
1163              (INT)lpArc->rclBox.left,
1164              (INT)lpArc->rclBox.top,
1165              (INT)lpArc->rclBox.right,
1166              (INT)lpArc->rclBox.bottom,
1167              (INT)lpArc->ptlStart.x,
1168              (INT)lpArc->ptlStart.y,
1169              (INT)lpArc->ptlEnd.x,
1170              (INT)lpArc->ptlEnd.y );
1171
1172         break;
1173       }
1174
1175     case EMR_CHORD:
1176       {
1177         PEMRCHORD lpChord = (PEMRCHORD)mr;
1178
1179         Chord( hdc,
1180              (INT)lpChord->rclBox.left,
1181              (INT)lpChord->rclBox.top,
1182              (INT)lpChord->rclBox.right,
1183              (INT)lpChord->rclBox.bottom,
1184              (INT)lpChord->ptlStart.x,
1185              (INT)lpChord->ptlStart.y,
1186              (INT)lpChord->ptlEnd.x,
1187              (INT)lpChord->ptlEnd.y );
1188
1189         break;
1190       }
1191
1192     case EMR_PIE:
1193       {
1194         PEMRPIE lpPie = (PEMRPIE)mr;
1195
1196         Pie( hdc,
1197              (INT)lpPie->rclBox.left,
1198              (INT)lpPie->rclBox.top,
1199              (INT)lpPie->rclBox.right,
1200              (INT)lpPie->rclBox.bottom,
1201              (INT)lpPie->ptlStart.x,
1202              (INT)lpPie->ptlStart.y,
1203              (INT)lpPie->ptlEnd.x,
1204              (INT)lpPie->ptlEnd.y );
1205
1206        break;
1207       }
1208
1209     case EMR_ARCTO:
1210       {
1211         PEMRARC lpArcTo = (PEMRARC)mr;
1212
1213         ArcTo( hdc,
1214                (INT)lpArcTo->rclBox.left,
1215                (INT)lpArcTo->rclBox.top,
1216                (INT)lpArcTo->rclBox.right,
1217                (INT)lpArcTo->rclBox.bottom,
1218                (INT)lpArcTo->ptlStart.x,
1219                (INT)lpArcTo->ptlStart.y,
1220                (INT)lpArcTo->ptlEnd.x,
1221                (INT)lpArcTo->ptlEnd.y );
1222
1223         break;
1224       }
1225
1226     case EMR_EXTFLOODFILL:
1227       {
1228         PEMREXTFLOODFILL lpExtFloodFill = (PEMREXTFLOODFILL)mr;
1229
1230         ExtFloodFill( hdc,
1231                       (INT)lpExtFloodFill->ptlStart.x,
1232                       (INT)lpExtFloodFill->ptlStart.y,
1233                       lpExtFloodFill->crColor,
1234                       (UINT)lpExtFloodFill->iMode );
1235
1236         break;
1237       }
1238
1239     case EMR_POLYDRAW:
1240       {
1241         PEMRPOLYDRAW lpPolyDraw = (PEMRPOLYDRAW)mr;
1242         PolyDraw( hdc,
1243                   (const LPPOINT)lpPolyDraw->aptl,
1244                   lpPolyDraw->abTypes,
1245                   (INT)lpPolyDraw->cptl );
1246
1247         break;
1248       }
1249
1250     case EMR_SETARCDIRECTION:
1251       {
1252         PEMRSETARCDIRECTION lpSetArcDirection = (PEMRSETARCDIRECTION)mr;
1253         SetArcDirection( hdc, (INT)lpSetArcDirection->iArcDirection );
1254         break;
1255       }
1256
1257     case EMR_SETMITERLIMIT:
1258       {
1259         PEMRSETMITERLIMIT lpSetMiterLimit = (PEMRSETMITERLIMIT)mr;
1260         SetMiterLimit( hdc, lpSetMiterLimit->eMiterLimit, NULL );
1261         break;
1262       }
1263
1264     case EMR_BEGINPATH:
1265       {
1266         BeginPath( hdc );
1267         break;
1268       }
1269
1270     case EMR_ENDPATH:
1271       {
1272         EndPath( hdc );
1273         break;
1274       }
1275
1276     case EMR_CLOSEFIGURE:
1277       {
1278         CloseFigure( hdc );
1279         break;
1280       }
1281
1282     case EMR_FILLPATH:
1283       {
1284         /*PEMRFILLPATH lpFillPath = (PEMRFILLPATH)mr;*/
1285         FillPath( hdc );
1286         break;
1287       }
1288
1289     case EMR_STROKEANDFILLPATH:
1290       {
1291         /*PEMRSTROKEANDFILLPATH lpStrokeAndFillPath = (PEMRSTROKEANDFILLPATH)mr;*/
1292         StrokeAndFillPath( hdc );
1293         break;
1294       }
1295
1296     case EMR_STROKEPATH:
1297       {
1298         /*PEMRSTROKEPATH lpStrokePath = (PEMRSTROKEPATH)mr;*/
1299         StrokePath( hdc );
1300         break;
1301       }
1302
1303     case EMR_FLATTENPATH:
1304       {
1305         FlattenPath( hdc );
1306         break;
1307       }
1308
1309     case EMR_WIDENPATH:
1310       {
1311         WidenPath( hdc );
1312         break;
1313       }
1314
1315     case EMR_SELECTCLIPPATH:
1316       {
1317         PEMRSELECTCLIPPATH lpSelectClipPath = (PEMRSELECTCLIPPATH)mr;
1318         SelectClipPath( hdc, (INT)lpSelectClipPath->iMode );
1319         break;
1320       }
1321
1322     case EMR_ABORTPATH:
1323       {
1324         AbortPath( hdc );
1325         break;
1326       }
1327
1328     case EMR_CREATECOLORSPACE:
1329       {
1330         PEMRCREATECOLORSPACE lpCreateColorSpace = (PEMRCREATECOLORSPACE)mr;
1331         (handletable->objectHandle)[lpCreateColorSpace->ihCS] =
1332            CreateColorSpaceA( &lpCreateColorSpace->lcs );
1333         break;
1334       }
1335
1336     case EMR_SETCOLORSPACE:
1337       {
1338         PEMRSETCOLORSPACE lpSetColorSpace = (PEMRSETCOLORSPACE)mr;
1339         SetColorSpace( hdc,
1340                        (handletable->objectHandle)[lpSetColorSpace->ihCS] );
1341         break;
1342       }
1343
1344     case EMR_DELETECOLORSPACE:
1345       {
1346         PEMRDELETECOLORSPACE lpDeleteColorSpace = (PEMRDELETECOLORSPACE)mr;
1347         DeleteColorSpace( (handletable->objectHandle)[lpDeleteColorSpace->ihCS] );
1348         break;
1349       }
1350
1351     case EMR_SETICMMODE:
1352       {
1353         PEMRSETICMMODE lpSetICMMode = (PEMRSETICMMODE)mr;
1354         SetICMMode( hdc, (INT)lpSetICMMode->iMode );
1355         break;
1356       }
1357
1358     case EMR_PIXELFORMAT:
1359       {
1360         INT iPixelFormat;
1361         PEMRPIXELFORMAT lpPixelFormat = (PEMRPIXELFORMAT)mr;
1362
1363         iPixelFormat = ChoosePixelFormat( hdc, &lpPixelFormat->pfd );
1364         SetPixelFormat( hdc, iPixelFormat, &lpPixelFormat->pfd );
1365
1366         break;
1367       }
1368
1369     case EMR_SETPALETTEENTRIES:
1370       {
1371         PEMRSETPALETTEENTRIES lpSetPaletteEntries = (PEMRSETPALETTEENTRIES)mr;
1372
1373         SetPaletteEntries( (handletable->objectHandle)[lpSetPaletteEntries->ihPal],
1374                            (UINT)lpSetPaletteEntries->iStart,
1375                            (UINT)lpSetPaletteEntries->cEntries,
1376                            lpSetPaletteEntries->aPalEntries );
1377
1378         break;
1379       }
1380
1381     case EMR_RESIZEPALETTE:
1382       {
1383         PEMRRESIZEPALETTE lpResizePalette = (PEMRRESIZEPALETTE)mr;
1384
1385         ResizePalette( (handletable->objectHandle)[lpResizePalette->ihPal],
1386                        (UINT)lpResizePalette->cEntries );
1387
1388         break;
1389       }
1390
1391     case EMR_CREATEDIBPATTERNBRUSHPT:
1392       {
1393         PEMRCREATEDIBPATTERNBRUSHPT lpCreate = (PEMRCREATEDIBPATTERNBRUSHPT)mr;
1394         LPVOID lpPackedStruct;
1395
1396         /* check that offsets and data are contained within the record */
1397         if ( !( (lpCreate->cbBmi>=0) && (lpCreate->cbBits>=0) &&
1398                 (lpCreate->offBmi>=0) && (lpCreate->offBits>=0) &&
1399                 ((lpCreate->offBmi +lpCreate->cbBmi ) <= mr->nSize) &&
1400                 ((lpCreate->offBits+lpCreate->cbBits) <= mr->nSize) ) )
1401         {
1402             ERR("Invalid EMR_CREATEDIBPATTERNBRUSHPT record\n");
1403             break;
1404         }
1405
1406         /* This is a BITMAPINFO struct followed directly by bitmap bits */
1407         lpPackedStruct = HeapAlloc( GetProcessHeap(), 0,
1408                                     lpCreate->cbBmi + lpCreate->cbBits );
1409         if(!lpPackedStruct)
1410         {
1411             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1412             break;
1413         }
1414
1415         /* Now pack this structure */
1416         memcpy( lpPackedStruct,
1417                 ((BYTE*)lpCreate) + lpCreate->offBmi,
1418                 lpCreate->cbBmi );
1419         memcpy( ((BYTE*)lpPackedStruct) + lpCreate->cbBmi,
1420                 ((BYTE*)lpCreate) + lpCreate->offBits,
1421                 lpCreate->cbBits );
1422
1423         (handletable->objectHandle)[lpCreate->ihBrush] =
1424            CreateDIBPatternBrushPt( lpPackedStruct,
1425                                     (UINT)lpCreate->iUsage );
1426
1427         HeapFree(GetProcessHeap(), 0, lpPackedStruct);
1428
1429         break;
1430       }
1431
1432     case EMR_CREATEMONOBRUSH:
1433     {
1434         PEMRCREATEMONOBRUSH pCreateMonoBrush = (PEMRCREATEMONOBRUSH)mr;
1435         BITMAPINFO *pbi = (BITMAPINFO *)((BYTE *)mr + pCreateMonoBrush->offBmi);
1436         HBITMAP hBmp = CreateDIBitmap(0, (BITMAPINFOHEADER *)pbi, CBM_INIT,
1437                 (BYTE *)mr + pCreateMonoBrush->offBits, pbi, pCreateMonoBrush->iUsage);
1438         (handletable->objectHandle)[pCreateMonoBrush->ihBrush] = CreatePatternBrush(hBmp);
1439         /* CreatePatternBrush created a copy of the bitmap */
1440         DeleteObject(hBmp);
1441         break;
1442     }
1443
1444     case EMR_BITBLT:
1445     {
1446         PEMRBITBLT pBitBlt = (PEMRBITBLT)mr;
1447         HDC hdcSrc = CreateCompatibleDC(hdc);
1448         HBRUSH hBrush, hBrushOld;
1449         HBITMAP hBmp = 0, hBmpOld = 0;
1450         BITMAPINFO *pbi = (BITMAPINFO *)((BYTE *)mr + pBitBlt->offBmiSrc);
1451
1452         SetWorldTransform(hdcSrc, &pBitBlt->xformSrc);
1453
1454         hBrush = CreateSolidBrush(pBitBlt->crBkColorSrc);
1455         hBrushOld = SelectObject(hdcSrc, hBrush);
1456         PatBlt(hdcSrc, pBitBlt->rclBounds.left, pBitBlt->rclBounds.top,
1457                pBitBlt->rclBounds.right - pBitBlt->rclBounds.left,
1458                pBitBlt->rclBounds.bottom - pBitBlt->rclBounds.top, PATCOPY);
1459         SelectObject(hdcSrc, hBrushOld);
1460         DeleteObject(hBrush);
1461
1462         if (pBitBlt->offBmiSrc > 0)
1463         {
1464                 hBmp = CreateDIBitmap(0, (BITMAPINFOHEADER *)pbi, CBM_INIT,
1465                                           (BYTE *)mr + pBitBlt->offBitsSrc, pbi, pBitBlt->iUsageSrc);
1466                 hBmpOld = SelectObject(hdcSrc, hBmp);
1467         }
1468
1469         BitBlt(hdc,
1470                pBitBlt->xDest,
1471                pBitBlt->yDest,
1472                pBitBlt->cxDest,
1473                pBitBlt->cyDest,
1474                hdcSrc,
1475                pBitBlt->xSrc,
1476                pBitBlt->ySrc,
1477                pBitBlt->dwRop);
1478
1479         if (pBitBlt->offBmiSrc > 0)
1480         {
1481                 SelectObject(hdcSrc, hBmpOld);
1482                 DeleteObject(hBmp);
1483         }
1484         DeleteDC(hdcSrc);
1485         break;
1486     }
1487
1488     case EMR_STRETCHBLT:
1489     {
1490         PEMRSTRETCHBLT pStretchBlt= (PEMRSTRETCHBLT)mr;
1491         HDC hdcSrc = CreateCompatibleDC(hdc);
1492         HBRUSH hBrush, hBrushOld;
1493         HBITMAP hBmp = 0, hBmpOld = 0;
1494         BITMAPINFO *pbi = (BITMAPINFO *)((BYTE *)mr + pStretchBlt->offBmiSrc);
1495
1496         SetWorldTransform(hdcSrc, &pStretchBlt->xformSrc);
1497
1498         hBrush = CreateSolidBrush(pStretchBlt->crBkColorSrc);
1499         hBrushOld = SelectObject(hdcSrc, hBrush);
1500         PatBlt(hdcSrc, pStretchBlt->rclBounds.left, pStretchBlt->rclBounds.top,
1501                pStretchBlt->rclBounds.right - pStretchBlt->rclBounds.left,
1502                pStretchBlt->rclBounds.bottom - pStretchBlt->rclBounds.top, PATCOPY);
1503         SelectObject(hdcSrc, hBrushOld);
1504         DeleteObject(hBrush);
1505
1506         if (pStretchBlt->offBmiSrc)
1507         {
1508                 hBmp = CreateDIBitmap(0, (BITMAPINFOHEADER *)pbi, CBM_INIT,
1509                                           (BYTE *)mr + pStretchBlt->offBitsSrc, pbi, pStretchBlt->iUsageSrc);
1510                 hBmpOld = SelectObject(hdcSrc, hBmp);
1511         }
1512
1513         StretchBlt(hdc,
1514                pStretchBlt->xDest,
1515                pStretchBlt->yDest,
1516                pStretchBlt->cxDest,
1517                pStretchBlt->cyDest,
1518                hdcSrc,
1519                pStretchBlt->xSrc,
1520                pStretchBlt->ySrc,
1521                pStretchBlt->cxSrc,
1522                pStretchBlt->cySrc,
1523                pStretchBlt->dwRop);
1524
1525
1526         if (pStretchBlt->offBmiSrc)
1527         {
1528                 SelectObject(hdcSrc, hBmpOld);
1529                 DeleteObject(hBmp);
1530         }
1531
1532         DeleteDC(hdcSrc);
1533         break;
1534     }
1535
1536     case EMR_MASKBLT:
1537     {
1538         PEMRMASKBLT pMaskBlt= (PEMRMASKBLT)mr;
1539         HDC hdcSrc = CreateCompatibleDC(hdc);
1540         HBRUSH hBrush, hBrushOld;
1541         HBITMAP hBmp, hBmpOld, hBmpMask;
1542         BITMAPINFO *pbi;
1543
1544         SetWorldTransform(hdcSrc, &pMaskBlt->xformSrc);
1545
1546         hBrush = CreateSolidBrush(pMaskBlt->crBkColorSrc);
1547         hBrushOld = SelectObject(hdcSrc, hBrush);
1548         PatBlt(hdcSrc, pMaskBlt->rclBounds.left, pMaskBlt->rclBounds.top,
1549                pMaskBlt->rclBounds.right - pMaskBlt->rclBounds.left,
1550                pMaskBlt->rclBounds.bottom - pMaskBlt->rclBounds.top, PATCOPY);
1551         SelectObject(hdcSrc, hBrushOld);
1552         DeleteObject(hBrush);
1553
1554         pbi = (BITMAPINFO *)((BYTE *)mr + pMaskBlt->offBmiMask);
1555         hBmpMask = CreateDIBitmap(0, (BITMAPINFOHEADER *)pbi, CBM_INIT,
1556                               (BYTE *)mr + pMaskBlt->offBitsMask, pbi, pMaskBlt->iUsageMask);
1557
1558         pbi = (BITMAPINFO *)((BYTE *)mr + pMaskBlt->offBmiSrc);
1559         hBmp = CreateDIBitmap(0, (BITMAPINFOHEADER *)pbi, CBM_INIT,
1560                               (BYTE *)mr + pMaskBlt->offBitsSrc, pbi, pMaskBlt->iUsageSrc);
1561         hBmpOld = SelectObject(hdcSrc, hBmp);
1562         MaskBlt(hdc,
1563                 pMaskBlt->xDest,
1564                 pMaskBlt->yDest,
1565                 pMaskBlt->cxDest,
1566                 pMaskBlt->cyDest,
1567                 hdcSrc,
1568                 pMaskBlt->xSrc,
1569                 pMaskBlt->ySrc,
1570                 hBmpMask,
1571                 pMaskBlt->xMask,
1572                 pMaskBlt->yMask,
1573                 pMaskBlt->dwRop);
1574         SelectObject(hdcSrc, hBmpOld);
1575         DeleteObject(hBmp);
1576         DeleteObject(hBmpMask);
1577         DeleteDC(hdcSrc);
1578         break;
1579     }
1580
1581     case EMR_PLGBLT:
1582     {
1583         PEMRPLGBLT pPlgBlt= (PEMRPLGBLT)mr;
1584         HDC hdcSrc = CreateCompatibleDC(hdc);
1585         HBRUSH hBrush, hBrushOld;
1586         HBITMAP hBmp, hBmpOld, hBmpMask;
1587         BITMAPINFO *pbi;
1588         POINT pts[3];
1589
1590         SetWorldTransform(hdcSrc, &pPlgBlt->xformSrc);
1591
1592         pts[0].x = pPlgBlt->aptlDest[0].x; pts[0].y = pPlgBlt->aptlDest[0].y;
1593         pts[1].x = pPlgBlt->aptlDest[1].x; pts[1].y = pPlgBlt->aptlDest[1].y;
1594         pts[2].x = pPlgBlt->aptlDest[2].x; pts[2].y = pPlgBlt->aptlDest[2].y;
1595
1596         hBrush = CreateSolidBrush(pPlgBlt->crBkColorSrc);
1597         hBrushOld = SelectObject(hdcSrc, hBrush);
1598         PatBlt(hdcSrc, pPlgBlt->rclBounds.left, pPlgBlt->rclBounds.top,
1599                pPlgBlt->rclBounds.right - pPlgBlt->rclBounds.left,
1600                pPlgBlt->rclBounds.bottom - pPlgBlt->rclBounds.top, PATCOPY);
1601         SelectObject(hdcSrc, hBrushOld);
1602         DeleteObject(hBrush);
1603
1604         pbi = (BITMAPINFO *)((BYTE *)mr + pPlgBlt->offBmiMask);
1605         hBmpMask = CreateDIBitmap(0, (BITMAPINFOHEADER *)pbi, CBM_INIT,
1606                               (BYTE *)mr + pPlgBlt->offBitsMask, pbi, pPlgBlt->iUsageMask);
1607
1608         pbi = (BITMAPINFO *)((BYTE *)mr + pPlgBlt->offBmiSrc);
1609         hBmp = CreateDIBitmap(0, (BITMAPINFOHEADER *)pbi, CBM_INIT,
1610                               (BYTE *)mr + pPlgBlt->offBitsSrc, pbi, pPlgBlt->iUsageSrc);
1611         hBmpOld = SelectObject(hdcSrc, hBmp);
1612         PlgBlt(hdc,
1613                pts,
1614                hdcSrc,
1615                pPlgBlt->xSrc,
1616                pPlgBlt->ySrc,
1617                pPlgBlt->cxSrc,
1618                pPlgBlt->cySrc,
1619                hBmpMask,
1620                pPlgBlt->xMask,
1621                pPlgBlt->yMask);
1622         SelectObject(hdcSrc, hBmpOld);
1623         DeleteObject(hBmp);
1624         DeleteObject(hBmpMask);
1625         DeleteDC(hdcSrc);
1626         break;
1627     }
1628
1629     case EMR_SETDIBITSTODEVICE:
1630     {
1631         PEMRSETDIBITSTODEVICE pSetDIBitsToDevice = (PEMRSETDIBITSTODEVICE)mr;
1632
1633         SetDIBitsToDevice(hdc,
1634                           pSetDIBitsToDevice->xDest,
1635                           pSetDIBitsToDevice->yDest,
1636                           pSetDIBitsToDevice->cxSrc,
1637                           pSetDIBitsToDevice->cySrc,
1638                           pSetDIBitsToDevice->xSrc,
1639                           pSetDIBitsToDevice->ySrc,
1640                           pSetDIBitsToDevice->iStartScan,
1641                           pSetDIBitsToDevice->cScans,
1642                           (BYTE *)mr + pSetDIBitsToDevice->offBitsSrc,
1643                           (BITMAPINFO *)((BYTE *)mr + pSetDIBitsToDevice->offBmiSrc),
1644                           pSetDIBitsToDevice->iUsageSrc);
1645         break;
1646     }
1647
1648     case EMR_POLYTEXTOUTA:
1649     {
1650         PEMRPOLYTEXTOUTA pPolyTextOutA = (PEMRPOLYTEXTOUTA)mr;
1651         POLYTEXTA *polytextA = HeapAlloc(GetProcessHeap(), 0, pPolyTextOutA->cStrings * sizeof(POLYTEXTA));
1652         LONG i;
1653         XFORM xform, xformOld;
1654         int gModeOld;
1655
1656         gModeOld = SetGraphicsMode(hdc, pPolyTextOutA->iGraphicsMode);
1657         GetWorldTransform(hdc, &xformOld);
1658
1659         xform.eM11 = pPolyTextOutA->exScale;
1660         xform.eM12 = 0.0;
1661         xform.eM21 = 0.0;
1662         xform.eM22 = pPolyTextOutA->eyScale;
1663         xform.eDx = 0.0;
1664         xform.eDy = 0.0;
1665         SetWorldTransform(hdc, &xform);
1666
1667         /* Set up POLYTEXTA structures */
1668         for(i = 0; i < pPolyTextOutA->cStrings; i++)
1669         {
1670             polytextA[i].x = pPolyTextOutA->aemrtext[i].ptlReference.x;
1671             polytextA[i].y = pPolyTextOutA->aemrtext[i].ptlReference.y;
1672             polytextA[i].n = pPolyTextOutA->aemrtext[i].nChars;
1673             polytextA[i].lpstr = (LPSTR)((BYTE *)mr + pPolyTextOutA->aemrtext[i].offString);
1674             polytextA[i].uiFlags = pPolyTextOutA->aemrtext[i].fOptions;
1675             polytextA[i].rcl.left = pPolyTextOutA->aemrtext[i].rcl.left;
1676             polytextA[i].rcl.right = pPolyTextOutA->aemrtext[i].rcl.right;
1677             polytextA[i].rcl.top = pPolyTextOutA->aemrtext[i].rcl.top;
1678             polytextA[i].rcl.bottom = pPolyTextOutA->aemrtext[i].rcl.bottom;
1679             polytextA[i].pdx = (int *)((BYTE *)mr + pPolyTextOutA->aemrtext[i].offDx);
1680         }
1681         PolyTextOutA(hdc, polytextA, pPolyTextOutA->cStrings);
1682         HeapFree(GetProcessHeap(), 0, polytextA);
1683
1684         SetWorldTransform(hdc, &xformOld);
1685         SetGraphicsMode(hdc, gModeOld);
1686         break;
1687     }
1688
1689     case EMR_POLYTEXTOUTW:
1690     {
1691         PEMRPOLYTEXTOUTW pPolyTextOutW = (PEMRPOLYTEXTOUTW)mr;
1692         POLYTEXTW *polytextW = HeapAlloc(GetProcessHeap(), 0, pPolyTextOutW->cStrings * sizeof(POLYTEXTW));
1693         LONG i;
1694         XFORM xform, xformOld;
1695         int gModeOld;
1696
1697         gModeOld = SetGraphicsMode(hdc, pPolyTextOutW->iGraphicsMode);
1698         GetWorldTransform(hdc, &xformOld);
1699
1700         xform.eM11 = pPolyTextOutW->exScale;
1701         xform.eM12 = 0.0;
1702         xform.eM21 = 0.0;
1703         xform.eM22 = pPolyTextOutW->eyScale;
1704         xform.eDx = 0.0;
1705         xform.eDy = 0.0;
1706         SetWorldTransform(hdc, &xform);
1707
1708         /* Set up POLYTEXTW structures */
1709         for(i = 0; i < pPolyTextOutW->cStrings; i++)
1710         {
1711             polytextW[i].x = pPolyTextOutW->aemrtext[i].ptlReference.x;
1712             polytextW[i].y = pPolyTextOutW->aemrtext[i].ptlReference.y;
1713             polytextW[i].n = pPolyTextOutW->aemrtext[i].nChars;
1714             polytextW[i].lpstr = (LPWSTR)((BYTE *)mr + pPolyTextOutW->aemrtext[i].offString);
1715             polytextW[i].uiFlags = pPolyTextOutW->aemrtext[i].fOptions;
1716             polytextW[i].rcl.left = pPolyTextOutW->aemrtext[i].rcl.left;
1717             polytextW[i].rcl.right = pPolyTextOutW->aemrtext[i].rcl.right;
1718             polytextW[i].rcl.top = pPolyTextOutW->aemrtext[i].rcl.top;
1719             polytextW[i].rcl.bottom = pPolyTextOutW->aemrtext[i].rcl.bottom;
1720             polytextW[i].pdx = (int *)((BYTE *)mr + pPolyTextOutW->aemrtext[i].offDx);
1721         }
1722         PolyTextOutW(hdc, polytextW, pPolyTextOutW->cStrings);
1723         HeapFree(GetProcessHeap(), 0, polytextW);
1724
1725         SetWorldTransform(hdc, &xformOld);
1726         SetGraphicsMode(hdc, gModeOld);
1727         break;
1728     }
1729
1730     case EMR_FILLRGN:
1731     {
1732         PEMRFILLRGN pFillRgn = (PEMRFILLRGN)mr;
1733         HRGN hRgn = ExtCreateRegion(NULL, pFillRgn->cbRgnData, (RGNDATA *)pFillRgn->RgnData);
1734         FillRgn(hdc,
1735                 hRgn,
1736                 (handletable->objectHandle)[pFillRgn->ihBrush]);
1737         DeleteObject(hRgn);
1738         break;
1739     }
1740
1741     case EMR_FRAMERGN:
1742     {
1743         PEMRFRAMERGN pFrameRgn = (PEMRFRAMERGN)mr;
1744         HRGN hRgn = ExtCreateRegion(NULL, pFrameRgn->cbRgnData, (RGNDATA *)pFrameRgn->RgnData);
1745         FrameRgn(hdc,
1746                  hRgn,
1747                  (handletable->objectHandle)[pFrameRgn->ihBrush],
1748                  pFrameRgn->szlStroke.cx,
1749                  pFrameRgn->szlStroke.cy);
1750         DeleteObject(hRgn);
1751         break;
1752     }
1753
1754     case EMR_INVERTRGN:
1755     {
1756         PEMRINVERTRGN pInvertRgn = (PEMRINVERTRGN)mr;
1757         HRGN hRgn = ExtCreateRegion(NULL, pInvertRgn->cbRgnData, (RGNDATA *)pInvertRgn->RgnData);
1758         InvertRgn(hdc, hRgn);
1759         DeleteObject(hRgn);
1760         break;
1761     }
1762
1763     case EMR_PAINTRGN:
1764     {
1765         PEMRPAINTRGN pPaintRgn = (PEMRPAINTRGN)mr;
1766         HRGN hRgn = ExtCreateRegion(NULL, pPaintRgn->cbRgnData, (RGNDATA *)pPaintRgn->RgnData);
1767         PaintRgn(hdc, hRgn);
1768         DeleteObject(hRgn);
1769         break;
1770     }
1771
1772     case EMR_SETTEXTJUSTIFICATION:
1773     {
1774         PEMRSETTEXTJUSTIFICATION pSetTextJust = (PEMRSETTEXTJUSTIFICATION)mr;
1775         SetTextJustification(hdc, pSetTextJust->nBreakExtra, pSetTextJust->nBreakCount);
1776         break;
1777     }
1778
1779     case EMR_SETLAYOUT:
1780     {
1781         PEMRSETLAYOUT pSetLayout = (PEMRSETLAYOUT)mr;
1782         SetLayout(hdc, pSetLayout->iMode);
1783         break;
1784     }
1785
1786     case EMR_POLYDRAW16:
1787     case EMR_GLSRECORD:
1788     case EMR_GLSBOUNDEDRECORD:
1789         case EMR_DRAWESCAPE :
1790         case EMR_EXTESCAPE:
1791         case EMR_STARTDOC:
1792         case EMR_SMALLTEXTOUT:
1793         case EMR_FORCEUFIMAPPING:
1794         case EMR_NAMEDESCAPE:
1795         case EMR_COLORCORRECTPALETTE:
1796         case EMR_SETICMPROFILEA:
1797         case EMR_SETICMPROFILEW:
1798         case EMR_ALPHABLEND:
1799         case EMR_TRANSPARENTBLT:
1800         case EMR_GRADIENTFILL:
1801         case EMR_SETLINKEDUFI:
1802         case EMR_COLORMATCHTOTARGETW:
1803         case EMR_CREATECOLORSPACEW:
1804
1805     default:
1806       /* From docs: If PlayEnhMetaFileRecord doesn't recognize a
1807                     record then ignore and return TRUE. */
1808       FIXME("type %d is unimplemented\n", type);
1809       break;
1810     }
1811   tmprc.left = tmprc.top = 0;
1812   tmprc.right = tmprc.bottom = 1000;
1813   LPtoDP(hdc, (POINT*)&tmprc, 2);
1814   TRACE("L:0,0 - 1000,1000 -> D:%ld,%ld - %ld,%ld\n", tmprc.left,
1815         tmprc.top, tmprc.right, tmprc.bottom);
1816
1817   if ( !IS_WIN9X() )
1818   {
1819     /* WinNT - update the transform (win9x updates when the next graphics output
1820        record is played). */
1821     EMF_Update_MF_Xform(hdc, info);
1822   }
1823
1824   return TRUE;
1825 }
1826
1827
1828 /*****************************************************************************
1829  *
1830  *        EnumEnhMetaFile  (GDI32.@)
1831  *
1832  *  Walk an enhanced metafile, calling a user-specified function _EnhMetaFunc_
1833  *  for each
1834  *  record. Returns when either every record has been used or
1835  *  when _EnhMetaFunc_ returns FALSE.
1836  *
1837  *
1838  * RETURNS
1839  *  TRUE if every record is used, FALSE if any invocation of _EnhMetaFunc_
1840  *  returns FALSE.
1841  *
1842  * BUGS
1843  *   Ignores rect.
1844  *
1845  * NOTES
1846  *   This function behaves differently in Win9x and WinNT.
1847  *
1848  *   In WinNT, the DC's world transform is updated as the EMF changes
1849  *    the Window/Viewport Extent and Origin or it's world transform.
1850  *    The actual Window/Viewport Extent and Origin are left untouched.
1851  *
1852  *   In Win9x, the DC is left untouched, and PlayEnhMetaFileRecord
1853  *    updates the scaling itself but only just before a record that
1854  *    writes anything to the DC.
1855  *
1856  *   I'm not sure where the data (enum_emh_data) is stored in either
1857  *    version. For this implementation, it is stored before the handle
1858  *    table, but it could be stored in the DC, in the EMF handle or in
1859  *    TLS.
1860  *             MJM  5 Oct 2002
1861  */
1862 BOOL WINAPI EnumEnhMetaFile(
1863      HDC hdc,                /* [in] device context to pass to _EnhMetaFunc_ */
1864      HENHMETAFILE hmf,       /* [in] EMF to walk */
1865      ENHMFENUMPROC callback, /* [in] callback function */
1866      LPVOID data,            /* [in] optional data for callback function */
1867      const RECT *lpRect      /* [in] bounding rectangle for rendered metafile */
1868     )
1869 {
1870     BOOL ret;
1871     ENHMETAHEADER *emh;
1872     ENHMETARECORD *emr;
1873     DWORD offset;
1874     UINT i;
1875     HANDLETABLE *ht;
1876     INT savedMode = 0;
1877     XFORM savedXform;
1878     HPEN hPen = NULL;
1879     HBRUSH hBrush = NULL;
1880     HFONT hFont = NULL;
1881     enum_emh_data *info;
1882     SIZE vp_size, win_size;
1883     POINT vp_org, win_org;
1884     INT mapMode = MM_TEXT;
1885
1886     if(!lpRect)
1887     {
1888         SetLastError(ERROR_INVALID_PARAMETER);
1889         return FALSE;
1890     }
1891
1892     emh = EMF_GetEnhMetaHeader(hmf);
1893     if(!emh) {
1894         SetLastError(ERROR_INVALID_HANDLE);
1895         return FALSE;
1896     }
1897
1898     info = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
1899                     sizeof (enum_emh_data) + sizeof(HANDLETABLE) * emh->nHandles );
1900     if(!info)
1901     {
1902         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1903         return FALSE;
1904     }
1905     info->wndOrgX = 0;
1906     info->wndOrgY = 0;
1907     info->wndExtX = 1;
1908     info->wndExtY = 1;
1909     info->vportOrgX = 0;
1910     info->vportOrgY = 0;
1911     info->vportExtX = 1;
1912     info->vportExtY = 1;
1913     info->world_transform.eM11 = info->world_transform.eM22 = 1;
1914     info->world_transform.eM12 = info->world_transform.eM21 = 0;
1915     info->world_transform.eDx  = info->world_transform.eDy =  0;
1916
1917     ht = (HANDLETABLE*) &info[1];
1918     ht->objectHandle[0] = hmf;
1919
1920     if(hdc)
1921     {
1922         savedMode = SetGraphicsMode(hdc, GM_ADVANCED);
1923         GetWorldTransform(hdc, &savedXform);
1924         GetViewportExtEx(hdc, &vp_size);
1925         GetWindowExtEx(hdc, &win_size);
1926         GetViewportOrgEx(hdc, &vp_org);
1927         GetWindowOrgEx(hdc, &win_org);
1928         mapMode = GetMapMode(hdc);
1929
1930         /* save the current pen, brush and font */
1931         hPen = GetCurrentObject(hdc, OBJ_PEN);
1932         hBrush = GetCurrentObject(hdc, OBJ_BRUSH);
1933         hFont = GetCurrentObject(hdc, OBJ_FONT);
1934     }
1935
1936     info->mode = MM_TEXT;
1937
1938     if ( IS_WIN9X() )
1939     {
1940         /* Win95 leaves the vp/win ext/org info alone */
1941         info->init_transform.eM11 = 1.0;
1942         info->init_transform.eM12 = 0.0;
1943         info->init_transform.eM21 = 0.0;
1944         info->init_transform.eM22 = 1.0;
1945         info->init_transform.eDx  = 0.0;
1946         info->init_transform.eDy  = 0.0;
1947     }
1948     else
1949     {
1950         /* WinNT combines the vp/win ext/org info into a transform */
1951         FLOAT xscale, yscale;
1952         xscale = (FLOAT)vp_size.cx / (FLOAT)win_size.cx;
1953         yscale = (FLOAT)vp_size.cy / (FLOAT)win_size.cy;
1954         info->init_transform.eM11 = xscale;
1955         info->init_transform.eM12 = 0.0;
1956         info->init_transform.eM21 = 0.0;
1957         info->init_transform.eM22 = yscale;
1958         info->init_transform.eDx  = (FLOAT)vp_org.x - xscale * (FLOAT)win_org.x;
1959         info->init_transform.eDy  = (FLOAT)vp_org.y - yscale * (FLOAT)win_org.y;
1960
1961         CombineTransform(&info->init_transform, &savedXform, &info->init_transform);
1962     }
1963
1964     if ( WIDTH(emh->rclFrame) && HEIGHT(emh->rclFrame) )
1965     {
1966         FLOAT xSrcPixSize, ySrcPixSize, xscale, yscale;
1967         XFORM xform;
1968
1969         TRACE("rect: %ld,%ld - %ld,%ld. rclFrame: %ld,%ld - %ld,%ld\n",
1970            lpRect->left, lpRect->top, lpRect->right, lpRect->bottom,
1971            emh->rclFrame.left, emh->rclFrame.top, emh->rclFrame.right,
1972            emh->rclFrame.bottom);
1973
1974         xSrcPixSize = (FLOAT) emh->szlMillimeters.cx / emh->szlDevice.cx;
1975         ySrcPixSize = (FLOAT) emh->szlMillimeters.cy / emh->szlDevice.cy;
1976         xscale = (FLOAT) WIDTH(*lpRect) * 100.0 /
1977                  WIDTH(emh->rclFrame) * xSrcPixSize;
1978         yscale = (FLOAT) HEIGHT(*lpRect) * 100.0 /
1979                  HEIGHT(emh->rclFrame) * ySrcPixSize;
1980
1981         xform.eM11 = xscale;
1982         xform.eM12 = 0;
1983         xform.eM21 = 0;
1984         xform.eM22 = yscale;
1985         xform.eDx = (FLOAT) lpRect->left - (FLOAT) WIDTH(*lpRect) / WIDTH(emh->rclFrame) * emh->rclFrame.left;
1986         xform.eDy = (FLOAT) lpRect->top - (FLOAT) HEIGHT(*lpRect) / HEIGHT(emh->rclFrame) * emh->rclFrame.top;
1987
1988         CombineTransform(&info->init_transform, &xform, &info->init_transform);
1989     }
1990
1991     /* WinNT resets the current vp/win org/ext */
1992     if ( !IS_WIN9X() )
1993     {
1994         SetMapMode(hdc, MM_TEXT);
1995         SetWindowOrgEx(hdc, 0, 0, NULL);
1996         SetViewportOrgEx(hdc, 0, 0, NULL);
1997         EMF_Update_MF_Xform(hdc, info);
1998     }
1999
2000     ret = TRUE;
2001     offset = 0;
2002     while(ret && offset < emh->nBytes)
2003     {
2004         emr = (ENHMETARECORD *)((char *)emh + offset);
2005         TRACE("Calling EnumFunc with record type %ld, size %ld\n", emr->iType, emr->nSize);
2006         ret = (*callback)(hdc, ht, emr, emh->nHandles, (LPARAM)data);
2007         offset += emr->nSize;
2008     }
2009
2010     if (hdc)
2011     {
2012         /* restore pen, brush and font */
2013         SelectObject(hdc, hBrush);
2014         SelectObject(hdc, hPen);
2015         SelectObject(hdc, hFont);
2016
2017         SetWorldTransform(hdc, &savedXform);
2018         if (savedMode)
2019             SetGraphicsMode(hdc, savedMode);
2020         SetMapMode(hdc, mapMode);
2021         SetWindowOrgEx(hdc, win_org.x, win_org.y, NULL);
2022         SetWindowExtEx(hdc, win_size.cx, win_size.cy, NULL);
2023         SetViewportOrgEx(hdc, vp_org.x, vp_org.y, NULL);
2024         SetViewportExtEx(hdc, vp_size.cx, vp_size.cy, NULL);
2025     }
2026
2027     for(i = 1; i < emh->nHandles; i++) /* Don't delete element 0 (hmf) */
2028         if( (ht->objectHandle)[i] )
2029             DeleteObject( (ht->objectHandle)[i] );
2030
2031     HeapFree( GetProcessHeap(), 0, info );
2032     return ret;
2033 }
2034
2035 static INT CALLBACK EMF_PlayEnhMetaFileCallback(HDC hdc, HANDLETABLE *ht,
2036                                                 const ENHMETARECORD *emr,
2037                                                 INT handles, LPARAM data)
2038 {
2039     return PlayEnhMetaFileRecord(hdc, ht, emr, handles);
2040 }
2041
2042 /**************************************************************************
2043  *    PlayEnhMetaFile  (GDI32.@)
2044  *
2045  *    Renders an enhanced metafile into a specified rectangle *lpRect
2046  *    in device context hdc.
2047  *
2048  */
2049 BOOL WINAPI PlayEnhMetaFile(
2050        HDC hdc,           /* [in] DC to render into */
2051        HENHMETAFILE hmf,  /* [in] metafile to render */
2052        const RECT *lpRect /* [in] rectangle to place metafile inside */
2053       )
2054 {
2055     return EnumEnhMetaFile(hdc, hmf, EMF_PlayEnhMetaFileCallback, NULL,
2056                            lpRect);
2057 }
2058
2059 /*****************************************************************************
2060  *  DeleteEnhMetaFile (GDI32.@)
2061  *
2062  *  Deletes an enhanced metafile and frees the associated storage.
2063  */
2064 BOOL WINAPI DeleteEnhMetaFile(HENHMETAFILE hmf)
2065 {
2066     return EMF_Delete_HENHMETAFILE( hmf );
2067 }
2068
2069 /*****************************************************************************
2070  *  CopyEnhMetaFileA (GDI32.@)  Duplicate an enhanced metafile
2071  *
2072  *
2073  */
2074 HENHMETAFILE WINAPI CopyEnhMetaFileA(
2075     HENHMETAFILE hmfSrc,
2076     LPCSTR file)
2077 {
2078     ENHMETAHEADER *emrSrc = EMF_GetEnhMetaHeader( hmfSrc ), *emrDst;
2079     HENHMETAFILE hmfDst;
2080
2081     if(!emrSrc) return FALSE;
2082     if (!file) {
2083         emrDst = HeapAlloc( GetProcessHeap(), 0, emrSrc->nBytes );
2084         memcpy( emrDst, emrSrc, emrSrc->nBytes );
2085         hmfDst = EMF_Create_HENHMETAFILE( emrDst, FALSE );
2086     } else {
2087         HANDLE hFile;
2088         hFile = CreateFileA( file, GENERIC_WRITE | GENERIC_READ, 0,
2089                              NULL, CREATE_ALWAYS, 0, 0);
2090         WriteFile( hFile, emrSrc, emrSrc->nBytes, 0, 0);
2091         CloseHandle( hFile );
2092         /* Reopen file for reading only, so that apps can share
2093            read access to the file while hmf is still valid */
2094         hFile = CreateFileA( file, GENERIC_READ, FILE_SHARE_READ,
2095                              NULL, OPEN_EXISTING, 0, 0);
2096         if(hFile == INVALID_HANDLE_VALUE) {
2097             ERR("Can't reopen emf for reading\n");
2098             return 0;
2099         }
2100         hmfDst = EMF_GetEnhMetaFile( hFile );
2101         CloseHandle( hFile );
2102     }
2103     return hmfDst;
2104 }
2105
2106
2107 /* Struct to be used to be passed in the LPVOID parameter for cbEnhPaletteCopy */
2108 typedef struct tagEMF_PaletteCopy
2109 {
2110    UINT cEntries;
2111    LPPALETTEENTRY lpPe;
2112 } EMF_PaletteCopy;
2113
2114 /***************************************************************
2115  * Find the EMR_EOF record and then use it to find the
2116  * palette entries for this enhanced metafile.
2117  * The lpData is actually a pointer to a EMF_PaletteCopy struct
2118  * which contains the max number of elements to copy and where
2119  * to copy them to.
2120  *
2121  * NOTE: To be used by GetEnhMetaFilePaletteEntries only!
2122  */
2123 INT CALLBACK cbEnhPaletteCopy( HDC a,
2124                                HANDLETABLE *b,
2125                                const ENHMETARECORD *lpEMR,
2126                                INT c,
2127                                LPARAM lpData )
2128 {
2129
2130   if ( lpEMR->iType == EMR_EOF )
2131   {
2132     PEMREOF lpEof = (PEMREOF)lpEMR;
2133     EMF_PaletteCopy* info = (EMF_PaletteCopy*)lpData;
2134     DWORD dwNumPalToCopy = min( lpEof->nPalEntries, info->cEntries );
2135
2136     TRACE( "copying 0x%08lx palettes\n", dwNumPalToCopy );
2137
2138     memcpy( (LPVOID)info->lpPe,
2139             (LPVOID)(((LPSTR)lpEof) + lpEof->offPalEntries),
2140             sizeof( *(info->lpPe) ) * dwNumPalToCopy );
2141
2142     /* Update the passed data as a return code */
2143     info->lpPe     = NULL; /* Palettes were copied! */
2144     info->cEntries = (UINT)dwNumPalToCopy;
2145
2146     return FALSE; /* That's all we need */
2147   }
2148
2149   return TRUE;
2150 }
2151
2152 /*****************************************************************************
2153  *  GetEnhMetaFilePaletteEntries (GDI32.@)
2154  *
2155  *  Copy the palette and report size
2156  *
2157  *  BUGS: Error codes (SetLastError) are not set on failures
2158  */
2159 UINT WINAPI GetEnhMetaFilePaletteEntries( HENHMETAFILE hEmf,
2160                                           UINT cEntries,
2161                                           LPPALETTEENTRY lpPe )
2162 {
2163   ENHMETAHEADER* enhHeader = EMF_GetEnhMetaHeader( hEmf );
2164   EMF_PaletteCopy infoForCallBack;
2165
2166   TRACE( "(%p,%d,%p)\n", hEmf, cEntries, lpPe );
2167
2168   /* First check if there are any palettes associated with
2169      this metafile. */
2170   if ( enhHeader->nPalEntries == 0 ) return 0;
2171
2172   /* Is the user requesting the number of palettes? */
2173   if ( lpPe == NULL ) return (UINT)enhHeader->nPalEntries;
2174
2175   /* Copy cEntries worth of PALETTEENTRY structs into the buffer */
2176   infoForCallBack.cEntries = cEntries;
2177   infoForCallBack.lpPe     = lpPe;
2178
2179   if ( !EnumEnhMetaFile( 0, hEmf, cbEnhPaletteCopy,
2180                          &infoForCallBack, 0 ) )
2181       return GDI_ERROR;
2182
2183   /* Verify that the callback executed correctly */
2184   if ( infoForCallBack.lpPe != NULL )
2185   {
2186      /* Callback proc had error! */
2187      ERR( "cbEnhPaletteCopy didn't execute correctly\n" );
2188      return GDI_ERROR;
2189   }
2190
2191   return infoForCallBack.cEntries;
2192 }
2193
2194 typedef struct gdi_mf_comment
2195 {
2196     DWORD ident;
2197     DWORD iComment;
2198     DWORD nVersion;
2199     DWORD nChecksum;
2200     DWORD fFlags;
2201     DWORD cbWinMetaFile;
2202 } gdi_mf_comment;
2203
2204 /******************************************************************
2205  *         SetWinMetaFileBits   (GDI32.@)
2206  *
2207  *         Translate from old style to new style.
2208  *
2209  */
2210 HENHMETAFILE WINAPI SetWinMetaFileBits(UINT cbBuffer,
2211                                            CONST BYTE *lpbBuffer,
2212                                            HDC hdcRef,
2213                                            CONST METAFILEPICT *lpmfp
2214                                            )
2215 {
2216     HMETAFILE hmf = 0;
2217     HENHMETAFILE ret = 0;
2218     HDC hdc = 0, hdcdisp = 0;
2219     METAFILEPICT mfp;
2220     RECT rc, *prcFrame = NULL;
2221     gdi_mf_comment *mfcomment;
2222     UINT mfcomment_size;
2223     INT horzres, vertres, horzsize, vertsize, xext, yext;
2224
2225     TRACE("(%d, %p, %p, %p)\n", cbBuffer, lpbBuffer, hdcRef, lpmfp);
2226
2227     hmf = SetMetaFileBitsEx(cbBuffer, lpbBuffer);
2228     if(!hmf)
2229     {
2230         WARN("SetMetaFileBitsEx failed\n");
2231         return 0;
2232     }
2233
2234     if(!hdcRef)
2235         hdcRef = hdcdisp = CreateDCA("DISPLAY", NULL, NULL, NULL);
2236
2237     if(!lpmfp) {
2238         lpmfp = &mfp;
2239         mfp.mm = MM_ANISOTROPIC;
2240         mfp.xExt = 100;
2241         mfp.yExt = 100;
2242         FIXME("Correct Exts from dc\n");
2243     }
2244     else
2245     {
2246         TRACE("mm = %ld %ldx%ld\n", lpmfp->mm, lpmfp->xExt, lpmfp->yExt);
2247         if ( ( mfp.xExt < 0 ) || ( mfp.yExt < 0) )
2248             FIXME("Negative coordinates!\n");
2249     }
2250
2251     if(lpmfp->mm == MM_ISOTROPIC || lpmfp->mm == MM_ANISOTROPIC) {
2252         rc.left = rc.top = 0;
2253         rc.right = lpmfp->xExt;
2254         rc.bottom = lpmfp->yExt;
2255         prcFrame = &rc;
2256     }
2257
2258     if(!(hdc = CreateEnhMetaFileW(hdcRef, NULL, prcFrame, NULL))) {
2259         ERR("CreateEnhMetaFile fails?\n");
2260         goto end;
2261     }
2262
2263     horzres = GetDeviceCaps(hdcRef, HORZRES);
2264     vertres = GetDeviceCaps(hdcRef, VERTRES);
2265     horzsize = GetDeviceCaps(hdcRef, HORZSIZE);
2266     vertsize = GetDeviceCaps(hdcRef, VERTSIZE);
2267
2268     if(hdcdisp) {
2269         DeleteDC(hdcdisp);
2270         hdcRef = 0;
2271     }
2272
2273     /*
2274      * Write the original METAFILE into the enhanced metafile.
2275      * It is encapsulated in a GDICOMMENT_WINDOWS_METAFILE record.
2276      */
2277     mfcomment_size = sizeof (gdi_mf_comment) + cbBuffer;
2278     mfcomment = HeapAlloc(GetProcessHeap(), 0, mfcomment_size);
2279     if(mfcomment)
2280     {
2281         mfcomment->ident = GDICOMMENT_IDENTIFIER;
2282         mfcomment->iComment = GDICOMMENT_WINDOWS_METAFILE;
2283         mfcomment->nVersion = 0x00000300;
2284         mfcomment->nChecksum = 0; /* FIXME */
2285         mfcomment->fFlags = 0;
2286         mfcomment->cbWinMetaFile = cbBuffer;
2287         memcpy(&mfcomment[1], lpbBuffer, cbBuffer);
2288         GdiComment(hdc, mfcomment_size, (BYTE*) mfcomment);
2289         HeapFree(GetProcessHeap(), 0, mfcomment);
2290     }
2291
2292     if(lpmfp->mm != MM_TEXT)
2293         SetMapMode(hdc, lpmfp->mm);
2294
2295     /* set the initial viewport:window ratio as 1:1 */
2296     xext = lpmfp->xExt*horzres/(100*horzsize);
2297     yext = lpmfp->yExt*vertres/(100*vertsize);
2298     SetViewportExtEx(hdc, xext, yext, NULL);
2299     SetWindowExtEx(hdc,   xext, yext, NULL);
2300
2301     PlayMetaFile(hdc, hmf);
2302
2303     ret = CloseEnhMetaFile(hdc);
2304 end:
2305     DeleteMetaFile(hmf);
2306     return ret;
2307 }