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