objects/enhmetafile.c

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