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