?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dplayx: Tests for GroupOwner.
[wine.git] / dlls / gdi32 / metafile.c
blob68ec2039a5db4c66ff5182d52d7eb33539187d8b
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 = 0;
111 METAFILEOBJ *metaObj = GDI_AllocObject( sizeof(METAFILEOBJ), METAFILE_MAGIC,
112 (HGDIOBJ *)&hmf, NULL );
113 if (metaObj)
114 {
115 metaObj->mh = mh;
116 GDI_ReleaseObj( hmf );
117 }
118 return hmf;
119 }
120
121 /******************************************************************
122 * MF_GetMetaHeader
123 *
124 * Returns ptr to METAHEADER associated with HMETAFILE
125 */
126 static METAHEADER *MF_GetMetaHeader( HMETAFILE hmf )
127 {
128 METAHEADER *ret = NULL;
129 METAFILEOBJ * metaObj = (METAFILEOBJ *)GDI_GetObjPtr( hmf, METAFILE_MAGIC );
130 if (metaObj)
131 {
132 ret = metaObj->mh;
133 GDI_ReleaseObj( hmf );
134 }
135 return ret;
136 }
137
138 /******************************************************************
139 * convert_points
140 *
141 * Convert an array of POINT16 to an array of POINT.
142 * Result must be freed by caller.
143 */
144 static POINT *convert_points( UINT count, POINT16 *pt16 )
145 {
146 UINT i;
147 POINT *ret = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*ret) );
148 if (ret)
149 {
150 for (i = 0; i < count; i++)
151 {
152 ret[i].x = pt16[i].x;
153 ret[i].y = pt16[i].y;
154 }
155 }
156 return ret;
157 }
158
159 /******************************************************************
160 * DeleteMetaFile (GDI32.@)
161 *
162 * Delete a memory-based metafile.
163 */
164
165 BOOL WINAPI DeleteMetaFile( HMETAFILE hmf )
166 {
167 METAFILEOBJ * metaObj = (METAFILEOBJ *)GDI_GetObjPtr( hmf, METAFILE_MAGIC );
168 if (!metaObj) return FALSE;
169 HeapFree( GetProcessHeap(), 0, metaObj->mh );
170 GDI_FreeObject( hmf, metaObj );
171 return TRUE;
172 }
173
174 /******************************************************************
175 * MF_ReadMetaFile
176 *
177 * Returns a pointer to a memory based METAHEADER read in from file HFILE
178 *
179 */
180 METAHEADER *MF_ReadMetaFile(HANDLE hfile)
181 {
182 METAHEADER *mh;
183 DWORD BytesRead, size;
184
185 size = sizeof(METAHEADER);
186 mh = HeapAlloc( GetProcessHeap(), 0, size );
187 if(!mh) return NULL;
188 if(ReadFile( hfile, mh, size, &BytesRead, NULL) == 0 ||
189 BytesRead != size) {
190 HeapFree( GetProcessHeap(), 0, mh );
191 return NULL;
192 }
193 if (mh->mtType != METAFILE_MEMORY || mh->mtVersion != MFVERSION ||
194 mh->mtHeaderSize != size / 2)
195 {
196 HeapFree( GetProcessHeap(), 0, mh );
197 return NULL;
198 }
199 size = mh->mtSize * 2;
200 mh = HeapReAlloc( GetProcessHeap(), 0, mh, size );
201 if(!mh) return NULL;
202 size -= sizeof(METAHEADER);
203 if(ReadFile( hfile, (char *)mh + sizeof(METAHEADER), size, &BytesRead,
204 NULL) == 0 ||
205 BytesRead != size) {
206 HeapFree( GetProcessHeap(), 0, mh );
207 return NULL;
208 }
209
210 if (mh->mtType != METAFILE_MEMORY) {
211 WARN("Disk metafile had mtType = %04x\n", mh->mtType);
212 mh->mtType = METAFILE_MEMORY;
213 }
214 return mh;
215 }
216
217 /******************************************************************
218 * GetMetaFileA (GDI32.@)
219 *
220 * Read a metafile from a file. Returns handle to a memory-based metafile.
221 */
222 HMETAFILE WINAPI GetMetaFileA( LPCSTR lpFilename )
223 {
224 METAHEADER *mh;
225 HANDLE hFile;
226
227 TRACE("%s\n", lpFilename);
228
229 if(!lpFilename)
230 return 0;
231
232 if((hFile = CreateFileA(lpFilename, GENERIC_READ, FILE_SHARE_READ, NULL,
233 OPEN_EXISTING, 0, 0)) == INVALID_HANDLE_VALUE)
234 return 0;
235
236 mh = MF_ReadMetaFile(hFile);
237 CloseHandle(hFile);
238 if(!mh) return 0;
239 return MF_Create_HMETAFILE( mh );
240 }
241
242 /******************************************************************
243 * GetMetaFileW (GDI32.@)
244 */
245 HMETAFILE WINAPI GetMetaFileW( LPCWSTR lpFilename )
246 {
247 METAHEADER *mh;
248 HANDLE hFile;
249
250 TRACE("%s\n", debugstr_w(lpFilename));
251
252 if(!lpFilename)
253 return 0;
254
255 if((hFile = CreateFileW(lpFilename, GENERIC_READ, FILE_SHARE_READ, NULL,
256 OPEN_EXISTING, 0, 0)) == INVALID_HANDLE_VALUE)
257 return 0;
258
259 mh = MF_ReadMetaFile(hFile);
260 CloseHandle(hFile);
261 if(!mh) return 0;
262 return MF_Create_HMETAFILE( mh );
263 }
264
265
266 /******************************************************************
267 * MF_LoadDiskBasedMetaFile
268 *
269 * Creates a new memory-based metafile from a disk-based one.
270 */
271 METAHEADER *MF_LoadDiskBasedMetaFile(METAHEADER *mh)
272 {
273 METAHEADERDISK *mhd;
274 HANDLE hfile;
275 METAHEADER *mh2;
276
277 if(mh->mtType != METAFILE_DISK) {
278 ERR("Not a disk based metafile\n");
279 return NULL;
280 }
281 mhd = (METAHEADERDISK *)((char *)mh + sizeof(METAHEADER));
282
283 if((hfile = CreateFileA(mhd->filename, GENERIC_READ, FILE_SHARE_READ, NULL,
284 OPEN_EXISTING, 0, 0)) == INVALID_HANDLE_VALUE) {
285 WARN("Can't open file of disk based metafile\n");
286 return NULL;
287 }
288 mh2 = MF_ReadMetaFile(hfile);
289 CloseHandle(hfile);
290 return mh2;
291 }
292
293 /******************************************************************
294 * MF_CreateMetaHeaderDisk
295 *
296 * Take a memory based METAHEADER and change it to a disk based METAHEADER
297 * associated with filename. Note: Trashes contents of old one.
298 */
299 METAHEADER *MF_CreateMetaHeaderDisk(METAHEADER *mh, LPCVOID filename, BOOL uni )
300 {
301 METAHEADERDISK *mhd;
302
303 mh = HeapReAlloc( GetProcessHeap(), 0, mh,
304 sizeof(METAHEADER) + sizeof(METAHEADERDISK));
305 mh->mtType = METAFILE_DISK;
306 mhd = (METAHEADERDISK *)((char *)mh + sizeof(METAHEADER));
307
308 if( uni )
309 WideCharToMultiByte(CP_ACP, 0, filename, -1,
310 mhd->filename, sizeof mhd->filename, NULL, NULL);
311 else
312 lstrcpynA( mhd->filename, filename, sizeof mhd->filename );
313 return mh;
314 }
315
316 /******************************************************************
317 * CopyMetaFileW (GDI32.@)
318 *
319 * Copies the metafile corresponding to hSrcMetaFile to either
320 * a disk file, if a filename is given, or to a new memory based
321 * metafile, if lpFileName is NULL.
322 *
323 * PARAMS
324 * hSrcMetaFile [I] handle of metafile to copy
325 * lpFilename [I] filename if copying to a file
326 *
327 * RETURNS
328 * Handle to metafile copy on success, NULL on failure.
329 *
330 * BUGS
331 * Copying to disk returns NULL even if successful.
332 */
333 HMETAFILE WINAPI CopyMetaFileW( HMETAFILE hSrcMetaFile, LPCWSTR lpFilename )
334 {
335 METAHEADER *mh = MF_GetMetaHeader( hSrcMetaFile );
336 METAHEADER *mh2 = NULL;
337 HANDLE hFile;
338
339 TRACE("(%p,%s)\n", hSrcMetaFile, debugstr_w(lpFilename));
340
341 if(!mh) return 0;
342
343 if(mh->mtType == METAFILE_DISK)
344 mh2 = MF_LoadDiskBasedMetaFile(mh);
345 else {
346 mh2 = HeapAlloc( GetProcessHeap(), 0, mh->mtSize * 2 );
347 memcpy( mh2, mh, mh->mtSize * 2 );
348 }
349
350 if(lpFilename) { /* disk based metafile */
351 DWORD w;
352 if((hFile = CreateFileW(lpFilename, GENERIC_WRITE, 0, NULL,
353 CREATE_ALWAYS, 0, 0)) == INVALID_HANDLE_VALUE) {
354 HeapFree( GetProcessHeap(), 0, mh2 );
355 return 0;
356 }
357 WriteFile(hFile, mh2, mh2->mtSize * 2, &w, NULL);
358 CloseHandle(hFile);
359 }
360
361 return MF_Create_HMETAFILE( mh2 );
362 }
363
364
365 /******************************************************************
366 * CopyMetaFileA (GDI32.@)
367 *
368 * See CopyMetaFileW.
369 */
370 HMETAFILE WINAPI CopyMetaFileA( HMETAFILE hSrcMetaFile, LPCSTR lpFilename )
371 {
372 UNICODE_STRING lpFilenameW;
373 HMETAFILE ret = 0;
374
375 if (lpFilename) RtlCreateUnicodeStringFromAsciiz(&lpFilenameW, lpFilename);
376 else lpFilenameW.Buffer = NULL;
377
378 ret = CopyMetaFileW( hSrcMetaFile, lpFilenameW.Buffer );
379 if (lpFilenameW.Buffer)
380 RtlFreeUnicodeString(&lpFilenameW);
381 return ret;
382 }
383
384 /*******************************************************************
385 * MF_PlayMetaFile
386 *
387 * Helper for PlayMetaFile
388 */
389 BOOL MF_PlayMetaFile( HDC hdc, METAHEADER *mh)
390 {
391
392 METARECORD *mr;
393 HANDLETABLE *ht;
394 unsigned int offset = 0;
395 WORD i;
396 HPEN hPen;
397 HBRUSH hBrush;
398 HFONT hFont;
399 HPALETTE hPal;
400 HRGN hRgn;
401 BOOL loaded = FALSE;
402
403 if (!mh) return FALSE;
404 if(mh->mtType == METAFILE_DISK) { /* Create a memory-based copy */
405 mh = MF_LoadDiskBasedMetaFile(mh);
406 if(!mh) return FALSE;
407 loaded = TRUE;
408 }
409
410 /* save DC */
411 hPen = GetCurrentObject(hdc, OBJ_PEN);
412 hBrush = GetCurrentObject(hdc, OBJ_BRUSH);
413 hFont = GetCurrentObject(hdc, OBJ_FONT);
414 hPal = GetCurrentObject(hdc, OBJ_PAL);
415
416 hRgn = CreateRectRgn(0, 0, 0, 0);
417 if (!GetClipRgn(hdc, hRgn))
418 {
419 DeleteObject(hRgn);
420 hRgn = 0;
421 }
422
423 /* create the handle table */
424 ht = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
425 sizeof(HANDLETABLE) * mh->mtNoObjects);
426 if(!ht) return FALSE;
427
428 /* loop through metafile playing records */
429 offset = mh->mtHeaderSize * 2;
430 while (offset < mh->mtSize * 2)
431 {
432 mr = (METARECORD *)((char *)mh + offset);
433 TRACE("offset=%04x,size=%08x\n",
434 offset, mr->rdSize);
435 if (mr->rdSize < 3) { /* catch illegal record sizes */
436 TRACE("Entry got size %d at offset %d, total mf length is %d\n",
437 mr->rdSize,offset,mh->mtSize*2);
438 break;
439 }
440
441 offset += mr->rdSize * 2;
442 if (mr->rdFunction == META_EOF) {
443 TRACE("Got META_EOF so stopping\n");
444 break;
445 }
446 PlayMetaFileRecord( hdc, ht, mr, mh->mtNoObjects );
447 }
448
449 /* restore DC */
450 SelectObject(hdc, hPen);
451 SelectObject(hdc, hBrush);
452 SelectPalette(hdc, hPal, FALSE);
453 ExtSelectClipRgn(hdc, hRgn, RGN_COPY);
454 DeleteObject(hRgn);
455
456 /* free objects in handle table */
457 for(i = 0; i < mh->mtNoObjects; i++)
458 if(*(ht->objectHandle + i) != 0)
459 DeleteObject(*(ht->objectHandle + i));
460
461 /* free handle table */
462 HeapFree( GetProcessHeap(), 0, ht );
463 if(loaded)
464 HeapFree( GetProcessHeap(), 0, mh );
465 return TRUE;
466 }
467
468 /******************************************************************
469 * PlayMetaFile (GDI32.@)
470 *
471 * Renders the metafile specified by hmf in the DC specified by
472 * hdc. Returns FALSE on failure, TRUE on success.
473 *
474 * PARAMS
475 * hdc [I] handle of DC to render in
476 * hmf [I] handle of metafile to render
477 *
478 * RETURNS
479 * Success: TRUE
480 * Failure: FALSE
481 */
482 BOOL WINAPI PlayMetaFile( HDC hdc, HMETAFILE hmf )
483 {
484 METAHEADER *mh = MF_GetMetaHeader( hmf );
485 return MF_PlayMetaFile( hdc, mh );
486 }
487
488 /******************************************************************
489 * EnumMetaFile (GDI32.@)
490 *
491 * Loop through the metafile records in hmf, calling the user-specified
492 * function for each one, stopping when the user's function returns FALSE
493 * (which is considered to be failure)
494 * or when no records are left (which is considered to be success).
495 *
496 * RETURNS
497 * TRUE on success, FALSE on failure.
498 */
499 BOOL WINAPI EnumMetaFile(HDC hdc, HMETAFILE hmf, MFENUMPROC lpEnumFunc, LPARAM lpData)
500 {
501 METAHEADER *mhTemp = NULL, *mh = MF_GetMetaHeader(hmf);
502 METARECORD *mr;
503 HANDLETABLE *ht;
504 BOOL result = TRUE;
505 int i;
506 unsigned int offset = 0;
507 HPEN hPen;
508 HBRUSH hBrush;
509 HFONT hFont;
510
511 TRACE("(%p,%p,%p,%p)\n", hdc, hmf, lpEnumFunc, (void*)lpData);
512 if (!mh) return 0;
513 if(mh->mtType == METAFILE_DISK)
514 {
515 /* Create a memory-based copy */
516 if (!(mhTemp = MF_LoadDiskBasedMetaFile(mh))) return FALSE;
517 mh = mhTemp;
518 }
519
520 /* save the current pen, brush and font */
521 hPen = GetCurrentObject(hdc, OBJ_PEN);
522 hBrush = GetCurrentObject(hdc, OBJ_BRUSH);
523 hFont = GetCurrentObject(hdc, OBJ_FONT);
524
525 ht = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
526 sizeof(HANDLETABLE) * mh->mtNoObjects);
527
528 /* loop through metafile records */
529 offset = mh->mtHeaderSize * 2;
530
531 while (offset < (mh->mtSize * 2))
532 {
533 mr = (METARECORD *)((char *)mh + offset);
534 if(mr->rdFunction == META_EOF) {
535 TRACE("Got META_EOF so stopping\n");
536 break;
537 }
538 TRACE("Calling EnumFunc with record type %x\n",
539 mr->rdFunction);
540 if (!lpEnumFunc( hdc, ht, mr, mh->mtNoObjects, (LONG)lpData ))
541 {
542 result = FALSE;
543 break;
544 }
545
546 offset += (mr->rdSize * 2);
547 }
548
549 /* restore pen, brush and font */
550 SelectObject(hdc, hBrush);
551 SelectObject(hdc, hPen);
552 SelectObject(hdc, hFont);
553
554 /* free objects in handle table */
555 for(i = 0; i < mh->mtNoObjects; i++)
556 if(*(ht->objectHandle + i) != 0)
557 DeleteObject(*(ht->objectHandle + i));
558
559 /* free handle table */
560 HeapFree( GetProcessHeap(), 0, ht);
561 /* free a copy of metafile */
562 HeapFree( GetProcessHeap(), 0, mhTemp );
563 return result;
564 }
565
566 static BOOL MF_Play_MetaCreateRegion( METARECORD *mr, HRGN hrgn );
567 static BOOL MF_Play_MetaExtTextOut(HDC hdc, METARECORD *mr);
568 /******************************************************************
569 * PlayMetaFileRecord (GDI32.@)
570 *
571 * Render a single metafile record specified by *mr in the DC hdc, while
572 * using the handle table *ht, of length handles,
573 * to store metafile objects.
574 *
575 * BUGS
576 * The following metafile records are unimplemented:
577 *
578 * DRAWTEXT, ANIMATEPALETTE, SETPALENTRIES,
579 * RESIZEPALETTE, EXTFLOODFILL, RESETDC, STARTDOC, STARTPAGE, ENDPAGE,
580 * ABORTDOC, ENDDOC, CREATEBRUSH, CREATEBITMAPINDIRECT, and CREATEBITMAP.
581 */
582 BOOL WINAPI PlayMetaFileRecord( HDC hdc, HANDLETABLE *ht, METARECORD *mr, UINT handles )
583 {
584 short s1;
585 POINT *pt;
586 BITMAPINFOHEADER *infohdr;
587
588 TRACE("(%p %p %p %u) function %04x\n", hdc, ht, mr, handles, mr->rdFunction);
589
590 switch (mr->rdFunction)
591 {
592 case META_EOF:
593 break;
594
595 case META_DELETEOBJECT:
596 DeleteObject(*(ht->objectHandle + mr->rdParm[0]));
597 *(ht->objectHandle + mr->rdParm[0]) = 0;
598 break;
599
600 case META_SETBKCOLOR:
601 SetBkColor(hdc, MAKELONG(mr->rdParm[0], mr->rdParm[1]));
602 break;
603
604 case META_SETBKMODE:
605 SetBkMode(hdc, mr->rdParm[0]);
606 break;
607
608 case META_SETMAPMODE:
609 SetMapMode(hdc, mr->rdParm[0]);
610 break;
611
612 case META_SETROP2:
613 SetROP2(hdc, mr->rdParm[0]);
614 break;
615
616 case META_SETRELABS:
617 SetRelAbs(hdc, mr->rdParm[0]);
618 break;
619
620 case META_SETPOLYFILLMODE:
621 SetPolyFillMode(hdc, mr->rdParm[0]);
622 break;
623
624 case META_SETSTRETCHBLTMODE:
625 SetStretchBltMode(hdc, mr->rdParm[0]);
626 break;
627
628 case META_SETTEXTCOLOR:
629 SetTextColor(hdc, MAKELONG(mr->rdParm[0], mr->rdParm[1]));
630 break;
631
632 case META_SETWINDOWORG:
633 SetWindowOrgEx(hdc, (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0], NULL);
634 break;
635
636 case META_SETWINDOWEXT:
637 SetWindowExtEx(hdc, (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0], NULL);
638 break;
639
640 case META_SETVIEWPORTORG:
641 SetViewportOrgEx(hdc, (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0], NULL);
642 break;
643
644 case META_SETVIEWPORTEXT:
645 SetViewportExtEx(hdc, (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0], NULL);
646 break;
647
648 case META_OFFSETWINDOWORG:
649 OffsetWindowOrgEx(hdc, (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0], NULL);
650 break;
651
652 case META_SCALEWINDOWEXT:
653 ScaleWindowExtEx(hdc, (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
654 (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0], NULL);
655 break;
656
657 case META_OFFSETVIEWPORTORG:
658 OffsetViewportOrgEx(hdc, (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0], NULL);
659 break;
660
661 case META_SCALEVIEWPORTEXT:
662 ScaleViewportExtEx(hdc, (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
663 (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0], NULL);
664 break;
665
666 case META_LINETO:
667 LineTo(hdc, (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0]);
668 break;
669
670 case META_MOVETO:
671 MoveToEx(hdc, (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0], NULL);
672 break;
673
674 case META_EXCLUDECLIPRECT:
675 ExcludeClipRect( hdc, (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
676 (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0] );
677 break;
678
679 case META_INTERSECTCLIPRECT:
680 IntersectClipRect( hdc, (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
681 (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0] );
682 break;
683
684 case META_ARC:
685 Arc(hdc, (SHORT)mr->rdParm[7], (SHORT)mr->rdParm[6],
686 (SHORT)mr->rdParm[5], (SHORT)mr->rdParm[4],
687 (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
688 (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0]);
689 break;
690
691 case META_ELLIPSE:
692 Ellipse(hdc, (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
693 (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0]);
694 break;
695
696 case META_FLOODFILL:
697 FloodFill(hdc, (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
698 MAKELONG(mr->rdParm[0], mr->rdParm[1]));
699 break;
700
701 case META_PIE:
702 Pie(hdc, (SHORT)mr->rdParm[7], (SHORT)mr->rdParm[6],
703 (SHORT)mr->rdParm[5], (SHORT)mr->rdParm[4],
704 (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
705 (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0]);
706 break;
707
708 case META_RECTANGLE:
709 Rectangle(hdc, (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
710 (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0]);
711 break;
712
713 case META_ROUNDRECT:
714 RoundRect(hdc, (SHORT)mr->rdParm[5], (SHORT)mr->rdParm[4],
715 (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
716 (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0]);
717 break;
718
719 case META_PATBLT:
720 PatBlt(hdc, (SHORT)mr->rdParm[5], (SHORT)mr->rdParm[4],
721 (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
722 MAKELONG(mr->rdParm[0], mr->rdParm[1]));
723 break;
724
725 case META_SAVEDC:
726 SaveDC(hdc);
727 break;
728
729 case META_SETPIXEL:
730 SetPixel(hdc, (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
731 MAKELONG(mr->rdParm[0], mr->rdParm[1]));
732 break;
733
734 case META_OFFSETCLIPRGN:
735 OffsetClipRgn( hdc, (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0] );
736 break;
737
738 case META_TEXTOUT:
739 s1 = mr->rdParm[0];
740 TextOutA(hdc, (SHORT)mr->rdParm[((s1 + 1) >> 1) + 2],
741 (SHORT)mr->rdParm[((s1 + 1) >> 1) + 1],
742 (char *)(mr->rdParm + 1), s1);
743 break;
744
745 case META_POLYGON:
746 if ((pt = convert_points( mr->rdParm[0], (LPPOINT16)(mr->rdParm + 1))))
747 {
748 Polygon(hdc, pt, mr->rdParm[0]);
749 HeapFree( GetProcessHeap(), 0, pt );
750 }
751 break;
752
753 case META_POLYPOLYGON:
754 {
755 UINT i, total;
756 SHORT *counts = (SHORT *)(mr->rdParm + 1);
757
758 for (i = total = 0; i < mr->rdParm[0]; i++) total += counts[i];
759 pt = convert_points( total, (LPPOINT16)(counts + mr->rdParm[0]) );
760 if (pt)
761 {
762 INT *cnt32 = HeapAlloc( GetProcessHeap(), 0, mr->rdParm[0] * sizeof(*cnt32) );
763 if (cnt32)
764 {
765 for (i = 0; i < mr->rdParm[0]; i++) cnt32[i] = counts[i];
766 PolyPolygon( hdc, pt, cnt32, mr->rdParm[0]);
767 HeapFree( GetProcessHeap(), 0, cnt32 );
768 }
769 }
770 HeapFree( GetProcessHeap(), 0, pt );
771 }
772 break;
773
774 case META_POLYLINE:
775 if ((pt = convert_points( mr->rdParm[0], (LPPOINT16)(mr->rdParm + 1))))
776 {
777 Polyline( hdc, pt, mr->rdParm[0] );
778 HeapFree( GetProcessHeap(), 0, pt );
779 }
780 break;
781
782 case META_RESTOREDC:
783 RestoreDC(hdc, (SHORT)mr->rdParm[0]);
784 break;
785
786 case META_SELECTOBJECT:
787 SelectObject(hdc, *(ht->objectHandle + mr->rdParm[0]));
788 break;
789
790 case META_CHORD:
791 Chord(hdc, (SHORT)mr->rdParm[7], (SHORT)mr->rdParm[6],
792 (SHORT)mr->rdParm[5], (SHORT)mr->rdParm[4],
793 (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
794 (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0]);
795 break;
796
797 case META_CREATEPATTERNBRUSH:
798 switch (mr->rdParm[0])
799 {
800 case BS_PATTERN:
801 infohdr = (BITMAPINFOHEADER *)(mr->rdParm + 2);
802 MF_AddHandle(ht, handles,
803 CreatePatternBrush(CreateBitmap(infohdr->biWidth,
804 infohdr->biHeight,
805 infohdr->biPlanes,
806 infohdr->biBitCount,
807 (LPSTR)(mr->rdParm +
808 (sizeof(BITMAPINFOHEADER) / 2) + 4))));
809 break;
810
811 case BS_DIBPATTERN:
812 infohdr = (BITMAPINFOHEADER *)(mr->rdParm + 2);
813 MF_AddHandle(ht, handles, CreateDIBPatternBrushPt( infohdr, mr->rdParm[1] ));
814 break;
815
816 default:
817 ERR("META_CREATEPATTERNBRUSH: Unknown pattern type %d\n",
818 mr->rdParm[0]);
819 break;
820 }
821 break;
822
823 case META_CREATEPENINDIRECT:
824 {
825 LOGPEN pen;
826 pen.lopnStyle = mr->rdParm[0];
827 pen.lopnWidth.x = (SHORT)mr->rdParm[1];
828 pen.lopnWidth.y = (SHORT)mr->rdParm[2];
829 pen.lopnColor = MAKELONG( mr->rdParm[3], mr->rdParm[4] );
830 MF_AddHandle(ht, handles, CreatePenIndirect( &pen ));
831 }
832 break;
833
834 case META_CREATEFONTINDIRECT:
835 {
836 LOGFONTA font;
837 font.lfHeight = (SHORT)mr->rdParm[0];
838 font.lfWidth = (SHORT)mr->rdParm[1];
839 font.lfEscapement = (SHORT)mr->rdParm[2];
840 font.lfOrientation = (SHORT)mr->rdParm[3];
841 font.lfWeight = (SHORT)mr->rdParm[4];
842 font.lfItalic = LOBYTE(mr->rdParm[5]);
843 font.lfUnderline = HIBYTE(mr->rdParm[5]);
844 font.lfStrikeOut = LOBYTE(mr->rdParm[6]);
845 font.lfCharSet = HIBYTE(mr->rdParm[6]);
846 font.lfOutPrecision = LOBYTE(mr->rdParm[7]);
847 font.lfClipPrecision = HIBYTE(mr->rdParm[7]);
848 font.lfQuality = LOBYTE(mr->rdParm[8]);
849 font.lfPitchAndFamily = HIBYTE(mr->rdParm[8]);
850 memcpy( font.lfFaceName, mr->rdParm + 9, LF_FACESIZE );
851 MF_AddHandle(ht, handles, CreateFontIndirectA( &font ));
852 }
853 break;
854
855 case META_CREATEBRUSHINDIRECT:
856 {
857 LOGBRUSH brush;
858 brush.lbStyle = mr->rdParm[0];
859 brush.lbColor = MAKELONG( mr->rdParm[1], mr->rdParm[2] );
860 brush.lbHatch = mr->rdParm[3];
861 MF_AddHandle(ht, handles, CreateBrushIndirect( &brush ));
862 }
863 break;
864
865 case META_CREATEPALETTE:
866 MF_AddHandle(ht, handles, CreatePalette((LPLOGPALETTE)mr->rdParm));
867 break;
868
869 case META_SETTEXTALIGN:
870 SetTextAlign(hdc, mr->rdParm[0]);
871 break;
872
873 case META_SELECTPALETTE:
874 GDISelectPalette(hdc, *(ht->objectHandle + mr->rdParm[1]), mr->rdParm[0]);
875 break;
876
877 case META_SETMAPPERFLAGS:
878 SetMapperFlags(hdc, MAKELONG(mr->rdParm[0],mr->rdParm[1]));
879 break;
880
881 case META_REALIZEPALETTE:
882 GDIRealizePalette(hdc);
883 break;
884
885 case META_ESCAPE:
886 switch (mr->rdParm[0]) {
887 case GETSCALINGFACTOR: /* get function ... would just NULL dereference */
888 case GETPHYSPAGESIZE:
889 case GETPRINTINGOFFSET:
890 return FALSE;
891 case SETABORTPROC:
892 FIXME("Filtering Escape(SETABORTPROC), possible virus?\n");
893 return FALSE;
894 }
895 Escape(hdc, mr->rdParm[0], mr->rdParm[1], (LPCSTR)&mr->rdParm[2], NULL);
896 break;
897
898 case META_EXTTEXTOUT:
899 MF_Play_MetaExtTextOut( hdc, mr );
900 break;
901
902 case META_STRETCHDIB:
903 {
904 LPBITMAPINFO info = (LPBITMAPINFO) &(mr->rdParm[11]);
905 LPSTR bits = (LPSTR)info + bitmap_info_size( info, mr->rdParm[2] );
906 StretchDIBits( hdc, (SHORT)mr->rdParm[10], (SHORT)mr->rdParm[9], (SHORT)mr->rdParm[8],
907 (SHORT)mr->rdParm[7], (SHORT)mr->rdParm[6], (SHORT)mr->rdParm[5],
908 (SHORT)mr->rdParm[4], (SHORT)mr->rdParm[3], bits, info,
909 mr->rdParm[2],MAKELONG(mr->rdParm[0],mr->rdParm[1]));
910 }
911 break;
912
913 case META_DIBSTRETCHBLT:
914 {
915 LPBITMAPINFO info = (LPBITMAPINFO) &(mr->rdParm[10]);
916 LPSTR bits = (LPSTR)info + bitmap_info_size( info, mr->rdParm[2] );
917 StretchDIBits( hdc, (SHORT)mr->rdParm[9], (SHORT)mr->rdParm[8], (SHORT)mr->rdParm[7],
918 (SHORT)mr->rdParm[6], (SHORT)mr->rdParm[5], (SHORT)mr->rdParm[4],
919 (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2], bits, info,
920 DIB_RGB_COLORS,MAKELONG(mr->rdParm[0],mr->rdParm[1]));
921 }
922 break;
923
924 case META_STRETCHBLT:
925 {
926 HDC hdcSrc = CreateCompatibleDC(hdc);
927 HBITMAP hbitmap = CreateBitmap(mr->rdParm[10], /*Width */
928 mr->rdParm[11], /*Height*/
929 mr->rdParm[13], /*Planes*/
930 mr->rdParm[14], /*BitsPixel*/
931 (LPSTR)&mr->rdParm[15]); /*bits*/
932 SelectObject(hdcSrc,hbitmap);
933 StretchBlt(hdc, (SHORT)mr->rdParm[9], (SHORT)mr->rdParm[8],
934 (SHORT)mr->rdParm[7], (SHORT)mr->rdParm[6],
935 hdcSrc, (SHORT)mr->rdParm[5], (SHORT)mr->rdParm[4],
936 (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
937 MAKELONG(mr->rdParm[0],mr->rdParm[1]));
938 DeleteDC(hdcSrc);
939 }
940 break;
941
942 case META_BITBLT:
943 {
944 HDC hdcSrc = CreateCompatibleDC(hdc);
945 HBITMAP hbitmap = CreateBitmap(mr->rdParm[7]/*Width */,
946 mr->rdParm[8]/*Height*/,
947 mr->rdParm[10]/*Planes*/,
948 mr->rdParm[11]/*BitsPixel*/,
949 (LPSTR)&mr->rdParm[12]/*bits*/);
950 SelectObject(hdcSrc,hbitmap);
951 BitBlt(hdc,(SHORT)mr->rdParm[6],(SHORT)mr->rdParm[5],
952 (SHORT)mr->rdParm[4],(SHORT)mr->rdParm[3],
953 hdcSrc, (SHORT)mr->rdParm[2],(SHORT)mr->rdParm[1],
954 MAKELONG(0,mr->rdParm[0]));
955 DeleteDC(hdcSrc);
956 }
957 break;
958
959 case META_CREATEREGION:
960 {
961 HRGN hrgn = CreateRectRgn(0,0,0,0);
962
963 MF_Play_MetaCreateRegion(mr, hrgn);
964 MF_AddHandle(ht, handles, hrgn);
965 }
966 break;
967
968 case META_FILLREGION:
969 FillRgn(hdc, *(ht->objectHandle + mr->rdParm[1]),
970 *(ht->objectHandle + mr->rdParm[0]));
971 break;
972
973 case META_FRAMEREGION:
974 FrameRgn(hdc, *(ht->objectHandle + mr->rdParm[3]),
975 *(ht->objectHandle + mr->rdParm[2]),
976 (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0]);
977 break;
978
979 case META_INVERTREGION:
980 InvertRgn(hdc, *(ht->objectHandle + mr->rdParm[0]));
981 break;
982
983 case META_PAINTREGION:
984 PaintRgn(hdc, *(ht->objectHandle + mr->rdParm[0]));
985 break;
986
987 case META_SELECTCLIPREGION:
988 {
989 HRGN hrgn = 0;
990
991 if (mr->rdParm[0]) hrgn = *(ht->objectHandle + mr->rdParm[0]);
992 SelectClipRgn(hdc, hrgn);
993 }
994 break;
995
996 case META_DIBCREATEPATTERNBRUSH:
997 /* mr->rdParm[0] may be BS_PATTERN or BS_DIBPATTERN:
998 but there's no difference */
999 MF_AddHandle(ht, handles, CreateDIBPatternBrushPt( mr->rdParm + 2, mr->rdParm[1] ));
1000 break;
1001
1002 case META_DIBBITBLT:
1003 /* In practice I've found that there are two layouts for
1004 META_DIBBITBLT, one (the first here) is the usual one when a src
1005 dc is actually passed to it, the second occurs when the src dc is
1006 passed in as NULL to the creating BitBlt. As the second case has
1007 no dib, a size check will suffice to distinguish.
1008
1009 Caolan.McNamara@ul.ie */
1010
1011 if (mr->rdSize > 12) {
1012 LPBITMAPINFO info = (LPBITMAPINFO) &(mr->rdParm[8]);
1013 LPSTR bits = (LPSTR)info + bitmap_info_size(info, mr->rdParm[0]);
1014
1015 StretchDIBits(hdc, (SHORT)mr->rdParm[7], (SHORT)mr->rdParm[6], (SHORT)mr->rdParm[5],
1016 (SHORT)mr->rdParm[4], (SHORT)mr->rdParm[3], (SHORT)mr->rdParm[2],
1017 (SHORT)mr->rdParm[5], (SHORT)mr->rdParm[4], bits, info,
1018 DIB_RGB_COLORS, MAKELONG(mr->rdParm[0], mr->rdParm[1]));
1019 }
1020 else /* equivalent to a PatBlt */
1021 PatBlt(hdc, (SHORT)mr->rdParm[8], (SHORT)mr->rdParm[7],
1022 (SHORT)mr->rdParm[6], (SHORT)mr->rdParm[5],
1023 MAKELONG(mr->rdParm[0], mr->rdParm[1]));
1024 break;
1025
1026 case META_SETTEXTCHAREXTRA:
1027 SetTextCharacterExtra(hdc, (SHORT)mr->rdParm[0]);
1028 break;
1029
1030 case META_SETTEXTJUSTIFICATION:
1031 SetTextJustification(hdc, (SHORT)mr->rdParm[1], (SHORT)mr->rdParm[0]);
1032 break;
1033
1034 case META_EXTFLOODFILL:
1035 ExtFloodFill(hdc, (SHORT)mr->rdParm[4], (SHORT)mr->rdParm[3],
1036 MAKELONG(mr->rdParm[1], mr->rdParm[2]),
1037 mr->rdParm[0]);
1038 break;
1039
1040 case META_SETDIBTODEV:
1041 {
1042 BITMAPINFO *info = (BITMAPINFO *) &(mr->rdParm[9]);
1043 char *bits = (char *)info + bitmap_info_size( info, mr->rdParm[0] );
1044 SetDIBitsToDevice(hdc, (SHORT)mr->rdParm[8], (SHORT)mr->rdParm[7],
1045 (SHORT)mr->rdParm[6], (SHORT)mr->rdParm[5],
1046 (SHORT)mr->rdParm[4], (SHORT)mr->rdParm[3],
1047 mr->rdParm[2], mr->rdParm[1], bits, info,
1048 mr->rdParm[0]);
1049 break;
1050 }
1051
1052 #define META_UNIMP(x) case x: \
1053 FIXME("PlayMetaFileRecord:record type "#x" not implemented.\n"); \
1054 break;
1055 META_UNIMP(META_DRAWTEXT)
1056 META_UNIMP(META_ANIMATEPALETTE)
1057 META_UNIMP(META_SETPALENTRIES)
1058 META_UNIMP(META_RESIZEPALETTE)
1059 META_UNIMP(META_RESETDC)
1060 META_UNIMP(META_STARTDOC)
1061 META_UNIMP(META_STARTPAGE)
1062 META_UNIMP(META_ENDPAGE)
1063 META_UNIMP(META_ABORTDOC)
1064 META_UNIMP(META_ENDDOC)
1065 META_UNIMP(META_CREATEBRUSH)
1066 META_UNIMP(META_CREATEBITMAPINDIRECT)
1067 META_UNIMP(META_CREATEBITMAP)
1068 #undef META_UNIMP
1069
1070 default:
1071 WARN("PlayMetaFileRecord: Unknown record type %x\n", mr->rdFunction);
1072 return FALSE;
1073 }
1074 return TRUE;
1075 }
1076
1077 /******************************************************************
1078 * SetMetaFileBitsEx (GDI32.@)
1079 *
1080 * Create a metafile from raw data. No checking of the data is performed.
1081 * Use GetMetaFileBitsEx() to get raw data from a metafile.
1082 *
1083 * PARAMS
1084 * size [I] size of metafile, in bytes
1085 * lpData [I] pointer to metafile data
1086 *
1087 * RETURNS
1088 * Success: Handle to metafile.
1089 * Failure: NULL.
1090 */
1091 HMETAFILE WINAPI SetMetaFileBitsEx( UINT size, const BYTE *lpData )
1092 {
1093 const METAHEADER *mh_in = (const METAHEADER *)lpData;
1094 METAHEADER *mh_out;
1095
1096 if (size & 1) return 0;
1097
1098 if (!size || mh_in->mtType != METAFILE_MEMORY || mh_in->mtVersion != MFVERSION ||
1099 mh_in->mtHeaderSize != sizeof(METAHEADER) / 2)
1100 {
1101 SetLastError(ERROR_INVALID_DATA);
1102 return 0;
1103 }
1104
1105 mh_out = HeapAlloc( GetProcessHeap(), 0, size );
1106 if (!mh_out)
1107 {
1108 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1109 return 0;
1110 }
1111
1112 memcpy(mh_out, mh_in, size);
1113 mh_out->mtSize = size / 2;
1114 return MF_Create_HMETAFILE(mh_out);
1115 }
1116
1117 /*****************************************************************
1118 * GetMetaFileBitsEx (GDI32.@)
1119 *
1120 * Get raw metafile data.
1121 *
1122 * Copies the data from metafile _hmf_ into the buffer _buf_.
1123 *
1124 * PARAMS
1125 * hmf [I] metafile
1126 * nSize [I] size of buf
1127 * buf [O] buffer to receive raw metafile data
1128 *
1129 * RETURNS
1130 * If _buf_ is zero, returns size of buffer required. Otherwise,
1131 * returns number of bytes copied.
1132 */
1133 UINT WINAPI GetMetaFileBitsEx( HMETAFILE hmf, UINT nSize, LPVOID buf )
1134 {
1135 METAHEADER *mh = MF_GetMetaHeader(hmf);
1136 UINT mfSize;
1137
1138 TRACE("(%p,%d,%p)\n", hmf, nSize, buf);
1139 if (!mh) return 0; /* FIXME: error code */
1140 if(mh->mtType == METAFILE_DISK)
1141 FIXME("Disk-based metafile?\n");
1142 mfSize = mh->mtSize * 2;
1143 if (!buf) {
1144 TRACE("returning size %d\n", mfSize);
1145 return mfSize;
1146 }
1147 if(mfSize > nSize) mfSize = nSize;
1148 memmove(buf, mh, mfSize);
1149 return mfSize;
1150 }
1151
1152 /******************************************************************
1153 * GetWinMetaFileBits [GDI32.@]
1154 */
1155 UINT WINAPI GetWinMetaFileBits(HENHMETAFILE hemf,
1156 UINT cbBuffer, LPBYTE lpbBuffer,
1157 INT fnMapMode, HDC hdcRef)
1158 {
1159 HDC hdcmf;
1160 HMETAFILE hmf;
1161 UINT ret;
1162 RECT rc;
1163 INT oldMapMode;
1164
1165 GetClipBox(hdcRef, &rc);
1166 oldMapMode = SetMapMode(hdcRef, fnMapMode);
1167
1168 TRACE("(%p,%d,%p,%d,%p) rc=%s\n", hemf, cbBuffer, lpbBuffer,
1169 fnMapMode, hdcRef, wine_dbgstr_rect(&rc));
1170
1171 hdcmf = CreateMetaFileA(NULL);
1172 PlayEnhMetaFile(hdcmf, hemf, &rc);
1173 hmf = CloseMetaFile(hdcmf);
1174 ret = GetMetaFileBitsEx(hmf, cbBuffer, lpbBuffer);
1175 DeleteMetaFile(hmf);
1176
1177 SetMapMode(hdcRef, oldMapMode);
1178
1179 return ret;
1180 }
1181
1182 /******************************************************************
1183 * MF_Play_MetaCreateRegion
1184 *
1185 * Handles META_CREATEREGION for PlayMetaFileRecord().
1186 *
1187 * The layout of the record looks something like this:
1188 *
1189 * rdParm meaning
1190 * 0 Always 0?
1191 * 1 Always 6?
1192 * 2 Looks like a handle? - not constant
1193 * 3 0 or 1 ??
1194 * 4 Total number of bytes
1195 * 5 No. of separate bands = n [see below]
1196 * 6 Largest number of x co-ords in a band
1197 * 7-10 Bounding box x1 y1 x2 y2
1198 * 11-... n bands
1199 *
1200 * Regions are divided into bands that are uniform in the
1201 * y-direction. Each band consists of pairs of on/off x-coords and is
1202 * written as
1203 * m y0 y1 x1 x2 x3 ... xm m
1204 * into successive rdParm[]s.
1205 *
1206 * This is probably just a dump of the internal RGNOBJ?
1207 *
1208 * HDMD - 18/12/97
1209 *
1210 */
1211
1212 static BOOL MF_Play_MetaCreateRegion( METARECORD *mr, HRGN hrgn )
1213 {
1214 WORD band, pair;
1215 WORD *start, *end;
1216 INT16 y0, y1;
1217 HRGN hrgn2 = CreateRectRgn( 0, 0, 0, 0 );
1218
1219 for(band = 0, start = &(mr->rdParm[11]); band < mr->rdParm[5];
1220 band++, start = end + 1) {
1221 if(*start / 2 != (*start + 1) / 2) {
1222 WARN("Delimiter not even.\n");
1223 DeleteObject( hrgn2 );
1224 return FALSE;
1225 }
1226
1227 end = start + *start + 3;
1228 if(end > (WORD *)mr + mr->rdSize) {
1229 WARN("End points outside record.\n");
1230 DeleteObject( hrgn2 );
1231 return FALSE;
1232 }
1233
1234 if(*start != *end) {
1235 WARN("Mismatched delimiters.\n");
1236 DeleteObject( hrgn2 );
1237 return FALSE;
1238 }
1239
1240 y0 = *(INT16 *)(start + 1);
1241 y1 = *(INT16 *)(start + 2);
1242 for(pair = 0; pair < *start / 2; pair++) {
1243 SetRectRgn( hrgn2, *(INT16 *)(start + 3 + 2*pair), y0,
1244 *(INT16 *)(start + 4 + 2*pair), y1 );
1245 CombineRgn(hrgn, hrgn, hrgn2, RGN_OR);
1246 }
1247 }
1248 DeleteObject( hrgn2 );
1249 return TRUE;
1250 }
1251
1252
1253 /******************************************************************
1254 * MF_Play_MetaExtTextOut
1255 *
1256 * Handles META_EXTTEXTOUT for PlayMetaFileRecord().
1257 */
1258
1259 static BOOL MF_Play_MetaExtTextOut(HDC hdc, METARECORD *mr)
1260 {
1261 INT *dx = NULL;
1262 int i;
1263 LPINT16 dxx;
1264 LPSTR sot;
1265 DWORD len;
1266 WORD s1;
1267 RECT rect;
1268 BOOL isrect = mr->rdParm[3] & (ETO_OPAQUE | ETO_CLIPPED);
1269
1270 s1 = mr->rdParm[2]; /* String length */
1271 len = sizeof(METARECORD) + (((s1 + 1) >> 1) * 2) + 2 * sizeof(short)
1272 + sizeof(UINT16) + (isrect ? sizeof(RECT16) : 0);
1273 /* rec len without dx array */
1274
1275 sot = (LPSTR)&mr->rdParm[4]; /* start_of_text */
1276 if (isrect)
1277 {
1278 rect.left = (SHORT)mr->rdParm[4];
1279 rect.top = (SHORT)mr->rdParm[5];
1280 rect.right = (SHORT)mr->rdParm[6];
1281 rect.bottom = (SHORT)mr->rdParm[7];
1282 sot += sizeof(RECT16); /* there is a rectangle, so add offset */
1283 }
1284
1285 if (mr->rdSize == len / 2)
1286 dxx = NULL; /* determine if array is present */
1287 else
1288 if (mr->rdSize == (len + s1 * sizeof(INT16)) / 2)
1289 {
1290 dxx = (LPINT16)(sot+(((s1+1)>>1)*2));
1291 dx = HeapAlloc( GetProcessHeap(), 0, s1*sizeof(INT));
1292 if (dx) for (i = 0; i < s1; i++) dx[i] = dxx[i];
1293 }
1294 else {
1295 TRACE("%s len: %d\n", sot, mr->rdSize);
1296 WARN("Please report: ExtTextOut len=%d slen=%d rdSize=%d opt=%04x\n",
1297 len, s1, mr->rdSize, mr->rdParm[3]);
1298 dxx = NULL; /* shouldn't happen -- but if, we continue with NULL */
1299 }
1300 ExtTextOutA( hdc,
1301 (SHORT)mr->rdParm[1], /* X position */
1302 (SHORT)mr->rdParm[0], /* Y position */
1303 mr->rdParm[3], /* options */
1304 &rect, /* rectangle */
1305 sot, /* string */
1306 s1, dx); /* length, dx array */
1307 if (dx)
1308 {
1309 TRACE("%s len: %d dx0: %d\n", sot, mr->rdSize, dx[0]);
1310 HeapFree( GetProcessHeap(), 0, dx );
1311 }
1312 return TRUE;
1313 }
Windows API implementation