?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 990226.
[wine/gsoc-2012-control.git] / objects / metafile.c
blobc40d01e34eb6cddcca93715c6f4867b05002fd7a
1 /*
2 * Metafile functions
3 *
4 * Copyright David W. Metcalfe, 1994
5 * Niels de Carpentier, Albrecht Kleine, Huw Davies 1996
6 *
7 */
8
9 #include <string.h>
10 #include <fcntl.h>
11 #include "wine/winbase16.h"
12 #include "metafiledrv.h"
13 #include "metafile.h"
14 #include "bitmap.h"
15 #include "heap.h"
16 #include "toolhelp.h"
17 #include "debug.h"
18
19 /******************************************************************
20 * MF_AddHandle
21 *
22 * Add a handle to an external handle table and return the index
23 */
24
25 static int MF_AddHandle(HANDLETABLE16 *ht, WORD htlen, HGDIOBJ16 hobj)
26 {
27 int i;
28
29 for (i = 0; i < htlen; i++)
30 {
31 if (*(ht->objectHandle + i) == 0)
32 {
33 *(ht->objectHandle + i) = hobj;
34 return i;
35 }
36 }
37 return -1;
38 }
39
40
41 /******************************************************************
42 * MF_AddHandleDC
43 *
44 * Note: this function assumes that we never delete objects.
45 * If we do someday, we'll need to maintain a table to re-use deleted
46 * handles.
47 */
48 static int MF_AddHandleDC( DC *dc )
49 {
50 METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dc->physDev;
51 physDev->mh->mtNoObjects++;
52 return physDev->nextHandle++;
53 }
54
55
56 /******************************************************************
57 * GetMetaFile16 (GDI.124)
58 */
59 HMETAFILE16 WINAPI GetMetaFile16( LPCSTR lpFilename )
60 {
61 return GetMetaFileA( lpFilename );
62 }
63
64
65 /******************************************************************
66 * GetMetaFile32A (GDI32.197)
67 *
68 * Read a metafile from a file. Returns handle to a disk-based metafile.
69 */
70 HMETAFILE WINAPI GetMetaFileA(
71 LPCSTR lpFilename
72 /* pointer to string containing filename to read */
73 )
74 {
75 HMETAFILE16 hmf;
76 METAHEADER *mh;
77 HFILE hFile;
78 DWORD size;
79
80 TRACE(metafile,"%s\n", lpFilename);
81
82 if (!lpFilename)
83 return 0;
84
85 hmf = GlobalAlloc16(GMEM_MOVEABLE, MFHEADERSIZE);
86 mh = (METAHEADER *)GlobalLock16(hmf);
87
88 if (!mh)
89 {
90 GlobalFree16(hmf);
91 return 0;
92 }
93
94 if ((hFile = _lopen(lpFilename, OF_READ)) == HFILE_ERROR)
95 {
96 GlobalFree16(hmf);
97 return 0;
98 }
99
100 if (_lread(hFile, (char *)mh, MFHEADERSIZE) == HFILE_ERROR)
101 {
102 _lclose( hFile );
103 GlobalFree16(hmf);
104 return 0;
105 }
106
107 size = mh->mtSize * 2; /* alloc memory for whole metafile */
108 GlobalUnlock16(hmf);
109 hmf = GlobalReAlloc16(hmf,size,GMEM_MOVEABLE);
110 mh = (METAHEADER *)GlobalLock16(hmf);
111
112 if (!mh)
113 {
114 _lclose( hFile );
115 GlobalFree16(hmf);
116 return 0;
117 }
118
119 if (_lread(hFile, (char*)mh + mh->mtHeaderSize * 2,
120 size - mh->mtHeaderSize * 2) == HFILE_ERROR)
121 {
122 _lclose( hFile );
123 GlobalFree16(hmf);
124 return 0;
125 }
126
127 _lclose(hFile);
128
129 if (mh->mtType != 1)
130 {
131 GlobalFree16(hmf);
132 return 0;
133 }
134
135 GlobalUnlock16(hmf);
136 return hmf;
137
138 }
139
140
141 /******************************************************************
142 * GetMetaFile32W (GDI32.199)
143 */
144 HMETAFILE WINAPI GetMetaFileW( LPCWSTR lpFilename )
145 {
146 LPSTR p = HEAP_strdupWtoA( GetProcessHeap(), 0, lpFilename );
147 HMETAFILE ret = GetMetaFileA( p );
148 HeapFree( GetProcessHeap(), 0, p );
149 return ret;
150 }
151
152
153 /******************************************************************
154 * CopyMetaFile16 (GDI.151)
155 */
156
157 HMETAFILE16 WINAPI CopyMetaFile16( HMETAFILE16 hSrcMetaFile, LPCSTR lpFilename )
158 {
159 return CopyMetaFileA( hSrcMetaFile, lpFilename );
160 }
161
162
163 /******************************************************************
164 * CopyMetaFile32A (GDI32.23)
165 *
166 * Copies the metafile corresponding to hSrcMetaFile to either
167 * a disk file, if a filename is given, or to a new memory based
168 * metafile, if lpFileName is NULL.
169 *
170 * RETURNS
171 *
172 * Handle to metafile copy on success, NULL on failure.
173 *
174 * BUGS
175 *
176 * Copying to disk returns NULL even if successful.
177 */
178 HMETAFILE WINAPI CopyMetaFileA(
179 HMETAFILE hSrcMetaFile, /* handle of metafile to copy */
180 LPCSTR lpFilename /* filename if copying to a file */
181 ) {
182 HMETAFILE16 handle = 0;
183 METAHEADER *mh;
184 METAHEADER *mh2;
185 HFILE hFile;
186
187 TRACE(metafile,"(%08x,%s)\n", hSrcMetaFile, lpFilename);
188
189 mh = (METAHEADER *)GlobalLock16(hSrcMetaFile);
190
191 if (!mh)
192 return 0;
193
194 if (lpFilename) /* disk based metafile */
195 {
196 int i,j;
197 hFile = _lcreat(lpFilename, 0);
198 j=mh->mtType;
199 mh->mtType=1; /* disk file version stores 1 here */
200 i=_lwrite(hFile, (char *)mh, mh->mtSize * 2) ;
201 mh->mtType=j; /* restore old value [0 or 1] */
202 _lclose(hFile);
203 if (i == -1)
204 return 0;
205 /* FIXME: return value */
206 }
207 else /* memory based metafile */
208 {
209 handle = GlobalAlloc16(GMEM_MOVEABLE,mh->mtSize * 2);
210 mh2 = (METAHEADER *)GlobalLock16(handle);
211 memcpy(mh2,mh, mh->mtSize * 2);
212 GlobalUnlock16(handle);
213 }
214
215 GlobalUnlock16(hSrcMetaFile);
216 return handle;
217 }
218
219
220 /******************************************************************
221 * CopyMetaFile32W (GDI32.24)
222 */
223 HMETAFILE WINAPI CopyMetaFileW( HMETAFILE hSrcMetaFile,
224 LPCWSTR lpFilename )
225 {
226 LPSTR p = HEAP_strdupWtoA( GetProcessHeap(), 0, lpFilename );
227 HMETAFILE ret = CopyMetaFileA( hSrcMetaFile, p );
228 HeapFree( GetProcessHeap(), 0, p );
229 return ret;
230 }
231
232
233 /******************************************************************
234 * IsValidMetaFile (GDI.410)
235 *
236 * Attempts to check if a given metafile is correctly formatted.
237 * Currently, the only things verified are several properties of the
238 * header.
239 *
240 * RETURNS
241 * TRUE if hmf passes some tests for being a valid metafile, FALSE otherwise.
242 *
243 * BUGS
244 * This is not exactly what windows does, see _Undocumented_Windows_
245 * for details.
246 */
247
248 BOOL16 WINAPI IsValidMetaFile16(HMETAFILE16 hmf)
249 {
250 BOOL16 resu=FALSE;
251 METAHEADER *mh = (METAHEADER *)GlobalLock16(hmf);
252 if (mh) {
253 if (mh->mtType == 1 || mh->mtType == 0)
254 if (mh->mtHeaderSize == MFHEADERSIZE/sizeof(INT16))
255 if (mh->mtVersion == MFVERSION)
256 resu=TRUE;
257 GlobalUnlock16(hmf);
258 }
259 TRACE(metafile,"IsValidMetaFile %x => %d\n",hmf,resu);
260 return resu;
261 }
262
263
264 /******************************************************************
265 * PlayMetaFile16 (GDI.123)
266 *
267 */
268 BOOL16 WINAPI PlayMetaFile16( HDC16 hdc, HMETAFILE16 hmf )
269 {
270 return PlayMetaFile( hdc, hmf );
271 }
272
273 /******************************************************************
274 * PlayMetaFile32 (GDI32.265)
275 *
276 * Renders the metafile specified by hmf in the DC specified by
277 * hdc. Returns FALSE on failure, TRUE on success.
278 */
279 BOOL WINAPI PlayMetaFile(
280 HDC hdc, /* handle of DC to render in */
281 HMETAFILE hmf /* handle of metafile to render */
282 )
283 {
284 METAHEADER *mh = (METAHEADER *)GlobalLock16(hmf);
285 METARECORD *mr;
286 HANDLETABLE16 *ht;
287 HGLOBAL16 hHT;
288 int offset = 0;
289 WORD i;
290 HPEN hPen;
291 HBRUSH hBrush;
292 HFONT hFont;
293 DC *dc;
294
295 TRACE(metafile,"(%04x %04x)\n",hdc,hmf);
296 if (!mh) return FALSE;
297
298 /* save the current pen, brush and font */
299 if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
300 hPen = dc->w.hPen;
301 hBrush = dc->w.hBrush;
302 hFont = dc->w.hFont;
303 GDI_HEAP_UNLOCK(hdc);
304 /* create the handle table */
305 hHT = GlobalAlloc16(GMEM_MOVEABLE|GMEM_ZEROINIT,
306 sizeof(HANDLETABLE16) * mh->mtNoObjects);
307 ht = (HANDLETABLE16 *)GlobalLock16(hHT);
308
309
310 /* loop through metafile playing records */
311 offset = mh->mtHeaderSize * 2;
312 while (offset < mh->mtSize * 2)
313 {
314 mr = (METARECORD *)((char *)mh + offset);
315 TRACE(metafile,"offset=%04x,size=%08lx\n",
316 offset, mr->rdSize);
317 if (!mr->rdSize) {
318 TRACE(metafile,"Entry got size 0 at offset %d, total mf length is %ld\n",
319 offset,mh->mtSize*2);
320 break; /* would loop endlessly otherwise */
321 }
322 offset += mr->rdSize * 2;
323 PlayMetaFileRecord16( hdc, ht, mr, mh->mtNoObjects );
324 }
325
326 SelectObject(hdc, hBrush);
327 SelectObject(hdc, hPen);
328 SelectObject(hdc, hFont);
329
330 /* free objects in handle table */
331 for(i = 0; i < mh->mtNoObjects; i++)
332 if(*(ht->objectHandle + i) != 0)
333 DeleteObject(*(ht->objectHandle + i));
334
335 /* free handle table */
336 GlobalFree16(hHT);
337
338 return TRUE;
339 }
340
341
342 /******************************************************************
343 * EnumMetaFile16 (GDI.175)
344 *
345 * Loop through the metafile records in hmf, calling the user-specified
346 * function for each one, stopping when the user's function returns FALSE
347 * (which is considered to be failure)
348 * or when no records are left (which is considered to be success).
349 *
350 * RETURNS
351 * TRUE on success, FALSE on failure.
352 *
353 * HISTORY
354 * Niels de carpentier, april 1996
355 */
356 BOOL16 WINAPI EnumMetaFile16(
357 HDC16 hdc,
358 HMETAFILE16 hmf,
359 MFENUMPROC16 lpEnumFunc,
360 LPARAM lpData
361 )
362 {
363 METAHEADER *mh = (METAHEADER *)GlobalLock16(hmf);
364 METARECORD *mr;
365 HANDLETABLE16 *ht;
366 HGLOBAL16 hHT;
367 SEGPTR spht;
368 int offset = 0;
369 WORD i, seg;
370 HPEN hPen;
371 HBRUSH hBrush;
372 HFONT hFont;
373 DC *dc;
374 BOOL16 result = TRUE;
375
376 TRACE(metafile,"(%04x, %04x, %08lx, %08lx)\n",
377 hdc, hmf, (DWORD)lpEnumFunc, lpData);
378
379 if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
380 hPen = dc->w.hPen;
381 hBrush = dc->w.hBrush;
382 hFont = dc->w.hFont;
383 GDI_HEAP_UNLOCK(hdc);
384
385 /* create the handle table */
386
387 hHT = GlobalAlloc16(GMEM_MOVEABLE | GMEM_ZEROINIT,
388 sizeof(HANDLETABLE16) * mh->mtNoObjects);
389 spht = WIN16_GlobalLock16(hHT);
390
391 seg = GlobalHandleToSel16(hmf);
392 offset = mh->mtHeaderSize * 2;
393
394 /* loop through metafile records */
395
396 while (offset < (mh->mtSize * 2))
397 {
398 mr = (METARECORD *)((char *)mh + offset);
399 if (!lpEnumFunc( hdc, (HANDLETABLE16 *)spht,
400 (METARECORD *) PTR_SEG_OFF_TO_HUGEPTR(seg, offset),
401 mh->mtNoObjects, (LONG)lpData ))
402 {
403 result = FALSE;
404 break;
405 }
406
407
408 offset += (mr->rdSize * 2);
409 }
410
411 SelectObject(hdc, hBrush);
412 SelectObject(hdc, hPen);
413 SelectObject(hdc, hFont);
414
415 ht = (HANDLETABLE16 *)GlobalLock16(hHT);
416
417 /* free objects in handle table */
418 for(i = 0; i < mh->mtNoObjects; i++)
419 if(*(ht->objectHandle + i) != 0)
420 DeleteObject(*(ht->objectHandle + i));
421
422 /* free handle table */
423 GlobalFree16(hHT);
424 GlobalUnlock16(hmf);
425 return result;
426 }
427
428 BOOL WINAPI EnumMetaFile(
429 HDC hdc,
430 HMETAFILE hmf,
431 MFENUMPROC lpEnumFunc,
432 LPARAM lpData
433 ) {
434 METAHEADER *mh = (METAHEADER *)GlobalLock16(hmf);
435 METARECORD *mr;
436 HANDLETABLE *ht;
437 BOOL result = TRUE;
438 int i, offset = 0;
439 DC *dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
440 HPEN hPen;
441 HBRUSH hBrush;
442 HFONT hFont;
443
444 TRACE(metafile,"(%08x,%08x,%p,%p)\n",
445 hdc, hmf, lpEnumFunc, (void*)lpData);
446 if (!mh) return 0;
447
448 /* save the current pen, brush and font */
449 if (!dc) return 0;
450 hPen = dc->w.hPen;
451 hBrush = dc->w.hBrush;
452 hFont = dc->w.hFont;
453 GDI_HEAP_UNLOCK(hdc);
454
455
456 ht = (HANDLETABLE *) GlobalAlloc(GPTR,
457 sizeof(HANDLETABLE) * mh->mtNoObjects);
458
459 /* loop through metafile records */
460 offset = mh->mtHeaderSize * 2;
461
462 while (offset < (mh->mtSize * 2))
463 {
464 mr = (METARECORD *)((char *)mh + offset);
465 if (!lpEnumFunc( hdc, ht, mr, mh->mtNoObjects, (LONG)lpData ))
466 {
467 result = FALSE;
468 break;
469 }
470
471 offset += (mr->rdSize * 2);
472 }
473
474 /* restore pen, brush and font */
475 SelectObject(hdc, hBrush);
476 SelectObject(hdc, hPen);
477 SelectObject(hdc, hFont);
478
479 /* free objects in handle table */
480 for(i = 0; i < mh->mtNoObjects; i++)
481 if(*(ht->objectHandle + i) != 0)
482 DeleteObject(*(ht->objectHandle + i));
483
484 /* free handle table */
485 GlobalFree((HGLOBAL)ht);
486 GlobalUnlock16(hmf);
487 return result;
488 }
489
490 static BOOL MF_Meta_CreateRegion( METARECORD *mr, HRGN hrgn );
491
492 /******************************************************************
493 * PlayMetaFileRecord16 (GDI.176)
494 *
495 * Render a single metafile record specified by *mr in the DC hdc, while
496 * using the handle table *ht, of length nHandles,
497 * to store metafile objects.
498 *
499 * BUGS
500 * The following metafile records are unimplemented:
501 *
502 * FRAMEREGION, DRAWTEXT, SETDIBTODEV, ANIMATEPALETTE, SETPALENTRIES,
503 * RESIZEPALETTE, EXTFLOODFILL, RESETDC, STARTDOC, STARTPAGE, ENDPAGE,
504 * ABORTDOC, ENDDOC, CREATEBRUSH, CREATEBITMAPINDIRECT, and CREATEBITMAP.
505 *
506 */
507 void WINAPI PlayMetaFileRecord16(
508 HDC16 hdc, /* DC to render metafile into */
509 HANDLETABLE16 *ht, /* pointer to handle table for metafile objects */
510 METARECORD *mr, /* pointer to metafile record to render */
511 UINT16 nHandles /* size of handle table */
512 ) {
513 short s1;
514 HANDLE16 hndl;
515 char *ptr;
516 BITMAPINFOHEADER *infohdr;
517
518 TRACE(metafile,"(%04x %08lx %08lx %04x) function %04x\n",
519 hdc,(LONG)ht, (LONG)mr, nHandles, mr->rdFunction);
520
521 switch (mr->rdFunction)
522 {
523 case META_EOF:
524 break;
525
526 case META_DELETEOBJECT:
527 DeleteObject(*(ht->objectHandle + *(mr->rdParm)));
528 *(ht->objectHandle + *(mr->rdParm)) = 0;
529 break;
530
531 case META_SETBKCOLOR:
532 SetBkColor16(hdc, MAKELONG(*(mr->rdParm), *(mr->rdParm + 1)));
533 break;
534
535 case META_SETBKMODE:
536 SetBkMode16(hdc, *(mr->rdParm));
537 break;
538
539 case META_SETMAPMODE:
540 SetMapMode16(hdc, *(mr->rdParm));
541 break;
542
543 case META_SETROP2:
544 SetROP216(hdc, *(mr->rdParm));
545 break;
546
547 case META_SETRELABS:
548 SetRelAbs16(hdc, *(mr->rdParm));
549 break;
550
551 case META_SETPOLYFILLMODE:
552 SetPolyFillMode16(hdc, *(mr->rdParm));
553 break;
554
555 case META_SETSTRETCHBLTMODE:
556 SetStretchBltMode16(hdc, *(mr->rdParm));
557 break;
558
559 case META_SETTEXTCOLOR:
560 SetTextColor16(hdc, MAKELONG(*(mr->rdParm), *(mr->rdParm + 1)));
561 break;
562
563 case META_SETWINDOWORG:
564 SetWindowOrg16(hdc, *(mr->rdParm + 1), *(mr->rdParm));
565 break;
566
567 case META_SETWINDOWEXT:
568 SetWindowExt16(hdc, *(mr->rdParm + 1), *(mr->rdParm));
569 break;
570
571 case META_SETVIEWPORTORG:
572 SetViewportOrg16(hdc, *(mr->rdParm + 1), *(mr->rdParm));
573 break;
574
575 case META_SETVIEWPORTEXT:
576 SetViewportExt16(hdc, *(mr->rdParm + 1), *(mr->rdParm));
577 break;
578
579 case META_OFFSETWINDOWORG:
580 OffsetWindowOrg16(hdc, *(mr->rdParm + 1), *(mr->rdParm));
581 break;
582
583 case META_SCALEWINDOWEXT:
584 ScaleWindowExt16(hdc, *(mr->rdParm + 3), *(mr->rdParm + 2),
585 *(mr->rdParm + 1), *(mr->rdParm));
586 break;
587
588 case META_OFFSETVIEWPORTORG:
589 OffsetViewportOrg16(hdc, *(mr->rdParm + 1), *(mr->rdParm));
590 break;
591
592 case META_SCALEVIEWPORTEXT:
593 ScaleViewportExt16(hdc, *(mr->rdParm + 3), *(mr->rdParm + 2),
594 *(mr->rdParm + 1), *(mr->rdParm));
595 break;
596
597 case META_LINETO:
598 LineTo(hdc, (INT16)*(mr->rdParm + 1), (INT16)*(mr->rdParm));
599 break;
600
601 case META_MOVETO:
602 MoveTo16(hdc, *(mr->rdParm + 1), *(mr->rdParm));
603 break;
604
605 case META_EXCLUDECLIPRECT:
606 ExcludeClipRect16( hdc, *(mr->rdParm + 3), *(mr->rdParm + 2),
607 *(mr->rdParm + 1), *(mr->rdParm) );
608 break;
609
610 case META_INTERSECTCLIPRECT:
611 IntersectClipRect16( hdc, *(mr->rdParm + 3), *(mr->rdParm + 2),
612 *(mr->rdParm + 1), *(mr->rdParm) );
613 break;
614
615 case META_ARC:
616 Arc(hdc, (INT16)*(mr->rdParm + 7), (INT16)*(mr->rdParm + 6),
617 (INT16)*(mr->rdParm + 5), (INT16)*(mr->rdParm + 4),
618 (INT16)*(mr->rdParm + 3), (INT16)*(mr->rdParm + 2),
619 (INT16)*(mr->rdParm + 1), (INT16)*(mr->rdParm));
620 break;
621
622 case META_ELLIPSE:
623 Ellipse(hdc, (INT16)*(mr->rdParm + 3), (INT16)*(mr->rdParm + 2),
624 (INT16)*(mr->rdParm + 1), (INT16)*(mr->rdParm));
625 break;
626
627 case META_FLOODFILL:
628 FloodFill(hdc, (INT16)*(mr->rdParm + 3), (INT16)*(mr->rdParm + 2),
629 MAKELONG(*(mr->rdParm), *(mr->rdParm + 1)));
630 break;
631
632 case META_PIE:
633 Pie(hdc, (INT16)*(mr->rdParm + 7), (INT16)*(mr->rdParm + 6),
634 (INT16)*(mr->rdParm + 5), (INT16)*(mr->rdParm + 4),
635 (INT16)*(mr->rdParm + 3), (INT16)*(mr->rdParm + 2),
636 (INT16)*(mr->rdParm + 1), (INT16)*(mr->rdParm));
637 break;
638
639 case META_RECTANGLE:
640 Rectangle(hdc, (INT16)*(mr->rdParm + 3), (INT16)*(mr->rdParm + 2),
641 (INT16)*(mr->rdParm + 1), (INT16)*(mr->rdParm));
642 break;
643
644 case META_ROUNDRECT:
645 RoundRect(hdc, (INT16)*(mr->rdParm + 5), (INT16)*(mr->rdParm + 4),
646 (INT16)*(mr->rdParm + 3), (INT16)*(mr->rdParm + 2),
647 (INT16)*(mr->rdParm + 1), (INT16)*(mr->rdParm));
648 break;
649
650 case META_PATBLT:
651 PatBlt16(hdc, *(mr->rdParm + 5), *(mr->rdParm + 4),
652 *(mr->rdParm + 3), *(mr->rdParm + 2),
653 MAKELONG(*(mr->rdParm), *(mr->rdParm + 1)));
654 break;
655
656 case META_SAVEDC:
657 SaveDC(hdc);
658 break;
659
660 case META_SETPIXEL:
661 SetPixel(hdc, (INT16)*(mr->rdParm + 3), (INT16)*(mr->rdParm + 2),
662 MAKELONG(*(mr->rdParm), *(mr->rdParm + 1)));
663 break;
664
665 case META_OFFSETCLIPRGN:
666 OffsetClipRgn16( hdc, *(mr->rdParm + 1), *(mr->rdParm) );
667 break;
668
669 case META_TEXTOUT:
670 s1 = *(mr->rdParm);
671 TextOut16(hdc, *(mr->rdParm + ((s1 + 1) >> 1) + 2),
672 *(mr->rdParm + ((s1 + 1) >> 1) + 1),
673 (char *)(mr->rdParm + 1), s1);
674 break;
675
676 case META_POLYGON:
677 Polygon16(hdc, (LPPOINT16)(mr->rdParm + 1), *(mr->rdParm));
678 break;
679
680 case META_POLYPOLYGON:
681 PolyPolygon16(hdc, (LPPOINT16)(mr->rdParm + *(mr->rdParm) + 1),
682 (LPINT16)(mr->rdParm + 1), *(mr->rdParm));
683 break;
684
685 case META_POLYLINE:
686 Polyline16(hdc, (LPPOINT16)(mr->rdParm + 1), *(mr->rdParm));
687 break;
688
689 case META_RESTOREDC:
690 RestoreDC(hdc, (INT16)*(mr->rdParm));
691 break;
692
693 case META_SELECTOBJECT:
694 SelectObject(hdc, *(ht->objectHandle + *(mr->rdParm)));
695 break;
696
697 case META_CHORD:
698 Chord(hdc, (INT16)*(mr->rdParm + 7), (INT16)*(mr->rdParm + 6),
699 (INT16)*(mr->rdParm+5), (INT16)*(mr->rdParm + 4),
700 (INT16)*(mr->rdParm + 3), (INT16)*(mr->rdParm + 2),
701 (INT16)*(mr->rdParm + 1), (INT16)*(mr->rdParm));
702 break;
703
704 case META_CREATEPATTERNBRUSH:
705 switch (*(mr->rdParm))
706 {
707 case BS_PATTERN:
708 infohdr = (BITMAPINFOHEADER *)(mr->rdParm + 2);
709 MF_AddHandle(ht, nHandles,
710 CreatePatternBrush(CreateBitmap(infohdr->biWidth,
711 infohdr->biHeight,
712 infohdr->biPlanes,
713 infohdr->biBitCount,
714 (LPSTR)(mr->rdParm +
715 (sizeof(BITMAPINFOHEADER) / 2) + 4))));
716 break;
717
718 case BS_DIBPATTERN:
719 s1 = mr->rdSize * 2 - sizeof(METARECORD) - 2;
720 hndl = GlobalAlloc16(GMEM_MOVEABLE, s1);
721 ptr = GlobalLock16(hndl);
722 memcpy(ptr, mr->rdParm + 2, s1);
723 GlobalUnlock16(hndl);
724 MF_AddHandle(ht, nHandles,
725 CreateDIBPatternBrush(hndl, *(mr->rdParm + 1)));
726 GlobalFree16(hndl);
727 }
728 break;
729
730 case META_CREATEPENINDIRECT:
731 MF_AddHandle(ht, nHandles,
732 CreatePenIndirect16((LOGPEN16 *)(&(mr->rdParm))));
733 break;
734
735 case META_CREATEFONTINDIRECT:
736 MF_AddHandle(ht, nHandles,
737 CreateFontIndirect16((LOGFONT16 *)(&(mr->rdParm))));
738 break;
739
740 case META_CREATEBRUSHINDIRECT:
741 MF_AddHandle(ht, nHandles,
742 CreateBrushIndirect16((LOGBRUSH16 *)(&(mr->rdParm))));
743 break;
744
745 /* W. Magro: Some new metafile operations. Not all debugged. */
746 case META_CREATEPALETTE:
747 MF_AddHandle(ht, nHandles,
748 CreatePalette16((LPLOGPALETTE)mr->rdParm));
749 break;
750
751 case META_SETTEXTALIGN:
752 SetTextAlign16(hdc, *(mr->rdParm));
753 break;
754
755 case META_SELECTPALETTE:
756 SelectPalette16(hdc, *(ht->objectHandle + *(mr->rdParm+1)),*(mr->rdParm));
757 break;
758
759 case META_SETMAPPERFLAGS:
760 SetMapperFlags16(hdc, *(mr->rdParm));
761 break;
762
763 case META_REALIZEPALETTE:
764 RealizePalette16(hdc);
765 break;
766
767 case META_ESCAPE:
768 FIXME(metafile, "META_ESCAPE unimplemented.\n");
769 break;
770
771 /* --- Begin of fixed or new metafile operations. July 1996 ----*/
772 case META_EXTTEXTOUT:
773 {
774 LPINT16 dxx;
775 LPSTR sot;
776 DWORD len;
777
778 s1 = mr->rdParm[2]; /* String length */
779 len = sizeof(METARECORD) + (((s1 + 1) >> 1) * 2) + 2 * sizeof(short)
780 + sizeof(UINT16) + (mr->rdParm[3] ? sizeof(RECT16) : 0); /* rec len without dx array */
781
782 sot= (LPSTR)&mr->rdParm[4]; /* start_of_text */
783 if (mr->rdParm[3])
784 sot+=sizeof(RECT16); /* there is a rectangle, so add offset */
785
786 if (mr->rdSize == len / 2)
787 dxx = NULL; /* determine if array present */
788 else
789 if (mr->rdSize == (len + s1 * sizeof(INT16)) / 2)
790 dxx = (LPINT16)(sot+(((s1+1)>>1)*2));
791 else
792 {
793 TRACE(metafile,"%s len: %ld\n",
794 sot,mr->rdSize);
795 WARN(metafile,
796 "Please report: PlayMetaFile/ExtTextOut len=%ld slen=%d rdSize=%ld opt=%04x\n",
797 len,s1,mr->rdSize,mr->rdParm[3]);
798 dxx = NULL; /* should't happen -- but if, we continue with NULL [for workaround] */
799 }
800 ExtTextOut16( hdc, mr->rdParm[1], /* X position */
801 mr->rdParm[0], /* Y position */
802 mr->rdParm[3], /* options */
803 mr->rdParm[3] ? (LPRECT16) &mr->rdParm[4]:NULL, /* rectangle */
804 sot, /* string */
805 s1, dxx); /* length, dx array */
806 if (dxx)
807 TRACE(metafile,"%s len: %ld dx0: %d\n",
808 sot,mr->rdSize,dxx[0]);
809 }
810 break;
811
812 case META_STRETCHDIB:
813 {
814 LPBITMAPINFO info = (LPBITMAPINFO) &(mr->rdParm[11]);
815 LPSTR bits = (LPSTR)info + DIB_BitmapInfoSize( info, mr->rdParm[2] );
816 StretchDIBits16(hdc,mr->rdParm[10],mr->rdParm[9],mr->rdParm[8],
817 mr->rdParm[7],mr->rdParm[6],mr->rdParm[5],
818 mr->rdParm[4],mr->rdParm[3],bits,info,
819 mr->rdParm[2],MAKELONG(mr->rdParm[0],mr->rdParm[1]));
820 }
821 break;
822
823 case META_DIBSTRETCHBLT:
824 {
825 LPBITMAPINFO info = (LPBITMAPINFO) &(mr->rdParm[10]);
826 LPSTR bits = (LPSTR)info + DIB_BitmapInfoSize( info, mr->rdParm[2] );
827 StretchDIBits16(hdc,mr->rdParm[9],mr->rdParm[8],mr->rdParm[7],
828 mr->rdParm[6],mr->rdParm[5],mr->rdParm[4],
829 mr->rdParm[3],mr->rdParm[2],bits,info,
830 DIB_RGB_COLORS,MAKELONG(mr->rdParm[0],mr->rdParm[1]));
831 }
832 break;
833
834 case META_STRETCHBLT:
835 {
836 HDC16 hdcSrc=CreateCompatibleDC16(hdc);
837 HBITMAP hbitmap=CreateBitmap(mr->rdParm[10], /*Width */
838 mr->rdParm[11], /*Height*/
839 mr->rdParm[13], /*Planes*/
840 mr->rdParm[14], /*BitsPixel*/
841 (LPSTR)&mr->rdParm[15]); /*bits*/
842 SelectObject(hdcSrc,hbitmap);
843 StretchBlt16(hdc,mr->rdParm[9],mr->rdParm[8],
844 mr->rdParm[7],mr->rdParm[6],
845 hdcSrc,mr->rdParm[5],mr->rdParm[4],
846 mr->rdParm[3],mr->rdParm[2],
847 MAKELONG(mr->rdParm[0],mr->rdParm[1]));
848 DeleteDC(hdcSrc);
849 }
850 break;
851
852 case META_BITBLT: /* <-- not yet debugged */
853 {
854 HDC16 hdcSrc=CreateCompatibleDC16(hdc);
855 HBITMAP hbitmap=CreateBitmap(mr->rdParm[7]/*Width */,
856 mr->rdParm[8]/*Height*/,
857 mr->rdParm[10]/*Planes*/,
858 mr->rdParm[11]/*BitsPixel*/,
859 (LPSTR)&mr->rdParm[12]/*bits*/);
860 SelectObject(hdcSrc,hbitmap);
861 BitBlt(hdc,(INT16)mr->rdParm[6],(INT16)mr->rdParm[5],
862 (INT16)mr->rdParm[4],(INT16)mr->rdParm[3],
863 hdcSrc, (INT16)mr->rdParm[2],(INT16)mr->rdParm[1],
864 MAKELONG(0,mr->rdParm[0]));
865 DeleteDC(hdcSrc);
866 }
867 break;
868
869 /* --- Begin of new metafile operations. April, 1997 (ak) ----*/
870 case META_CREATEREGION:
871 {
872 HRGN hrgn = CreateRectRgn(0,0,0,0);
873
874 MF_Meta_CreateRegion(mr, hrgn);
875 MF_AddHandle(ht, nHandles, hrgn);
876 }
877 break;
878
879 case META_FILLREGION:
880 FillRgn16(hdc, *(ht->objectHandle + *(mr->rdParm)),
881 *(ht->objectHandle + *(mr->rdParm+1)));
882 break;
883
884 case META_INVERTREGION:
885 InvertRgn16(hdc, *(ht->objectHandle + *(mr->rdParm)));
886 break;
887
888 case META_PAINTREGION:
889 PaintRgn16(hdc, *(ht->objectHandle + *(mr->rdParm)));
890 break;
891
892 case META_SELECTCLIPREGION:
893 SelectClipRgn(hdc, *(ht->objectHandle + *(mr->rdParm)));
894 break;
895
896 case META_DIBCREATEPATTERNBRUSH:
897 /* *(mr->rdParm) may be BS_PATTERN or BS_DIBPATTERN: but there's no difference */
898 TRACE(metafile,"%d\n",*(mr->rdParm));
899 s1 = mr->rdSize * 2 - sizeof(METARECORD) - 2;
900 hndl = GlobalAlloc16(GMEM_MOVEABLE, s1);
901 ptr = GlobalLock16(hndl);
902 memcpy(ptr, mr->rdParm + 2, s1);
903 GlobalUnlock16(hndl);
904 MF_AddHandle(ht, nHandles,CreateDIBPatternBrush16(hndl, *(mr->rdParm + 1)));
905 GlobalFree16(hndl);
906 break;
907
908 case META_DIBBITBLT:
909 {
910 LPBITMAPINFO info = (LPBITMAPINFO) &(mr->rdParm[8]);
911 LPSTR bits = (LPSTR)info + DIB_BitmapInfoSize( info, mr->rdParm[0] );
912 StretchDIBits16(hdc,mr->rdParm[7],mr->rdParm[6],mr->rdParm[5],
913 mr->rdParm[4],mr->rdParm[3],mr->rdParm[2],
914 mr->rdParm[5],mr->rdParm[4],bits,info,
915 DIB_RGB_COLORS,MAKELONG(mr->rdParm[0],mr->rdParm[1]));
916 }
917 break;
918
919 case META_SETTEXTCHAREXTRA:
920 SetTextCharacterExtra16(hdc, (INT16)*(mr->rdParm));
921 break;
922
923 case META_SETTEXTJUSTIFICATION:
924 SetTextJustification(hdc, *(mr->rdParm + 1), *(mr->rdParm));
925 break;
926
927 #define META_UNIMP(x) case x: FIXME(metafile, "PlayMetaFileRecord:record type "#x" not implemented.\n");break;
928 META_UNIMP(META_FRAMEREGION)
929 META_UNIMP(META_DRAWTEXT)
930 META_UNIMP(META_SETDIBTODEV)
931 META_UNIMP(META_ANIMATEPALETTE)
932 META_UNIMP(META_SETPALENTRIES)
933 META_UNIMP(META_RESIZEPALETTE)
934 META_UNIMP(META_EXTFLOODFILL)
935 META_UNIMP(META_RESETDC)
936 META_UNIMP(META_STARTDOC)
937 META_UNIMP(META_STARTPAGE)
938 META_UNIMP(META_ENDPAGE)
939 META_UNIMP(META_ABORTDOC)
940 META_UNIMP(META_ENDDOC)
941 META_UNIMP(META_CREATEBRUSH)
942 META_UNIMP(META_CREATEBITMAPINDIRECT)
943 META_UNIMP(META_CREATEBITMAP)
944 #undef META_UNIMP
945
946 default:
947 WARN(metafile, "PlayMetaFileRecord: Unknown record type %x\n",
948 mr->rdFunction);
949 }
950 }
951
952
953 BOOL WINAPI PlayMetaFileRecord(
954 HDC hdc,
955 HANDLETABLE *handletable,
956 METARECORD *metarecord,
957 UINT handles
958 )
959 {
960 HANDLETABLE16 * ht = (void *)GlobalAlloc(GPTR,
961 handles*sizeof(HANDLETABLE16));
962 int i = 0;
963 TRACE(metafile, "(%08x,%p,%p,%d)\n", hdc, handletable, metarecord, handles);
964 for (i=0; i<handles; i++)
965 ht->objectHandle[i] = handletable->objectHandle[i];
966 PlayMetaFileRecord16(hdc, ht, metarecord, handles);
967 for (i=0; i<handles; i++)
968 handletable->objectHandle[i] = ht->objectHandle[i];
969 GlobalFree((HGLOBAL)ht);
970 return TRUE;
971 }
972
973 /******************************************************************
974 * GetMetaFileBits (GDI.159)
975 *
976 * Trade in a metafile object handle for a handle to the metafile memory.
977 *
978 */
979
980 HGLOBAL16 WINAPI GetMetaFileBits16(
981 HMETAFILE16 hmf /* metafile handle */
982 )
983 {
984 TRACE(metafile,"hMem out: %04x\n", hmf);
985 return hmf;
986 }
987
988 /******************************************************************
989 * SetMetaFileBits (GDI.160)
990 *
991 * Trade in a metafile memory handle for a handle to a metafile object.
992 * The memory region should hold a proper metafile, otherwise
993 * problems will occur when it is used. Validity of the memory is not
994 * checked. The function is essentially just the identity function.
995 */
996 HMETAFILE16 WINAPI SetMetaFileBits16(
997 HGLOBAL16 hMem
998 /* handle to a memory region holding a metafile */
999 )
1000 {
1001 TRACE(metafile,"hmf out: %04x\n", hMem);
1002
1003 return hMem;
1004 }
1005
1006 /******************************************************************
1007 * SetMetaFileBitsBetter (GDI.196)
1008 *
1009 * Trade in a metafile memory handle for a handle to a metafile object,
1010 * making a cursory check (using IsValidMetaFile()) that the memory
1011 * handle points to a valid metafile.
1012 *
1013 * RETURNS
1014 * Handle to a metafile on success, NULL on failure..
1015 */
1016 HMETAFILE16 WINAPI SetMetaFileBitsBetter16( HMETAFILE16 hMeta )
1017 {
1018 if( IsValidMetaFile16( hMeta ) )
1019 return (HMETAFILE16)GlobalReAlloc16( hMeta, 0,
1020 GMEM_SHARE | GMEM_NODISCARD | GMEM_MODIFY);
1021 return (HMETAFILE16)0;
1022 }
1023
1024 /******************************************************************
1025 * SetMetaFileBitsEx (GDI32.323)
1026 *
1027 * Create a metafile from raw data. No checking of the data is performed.
1028 * Use _GetMetaFileBitsEx_ to get raw data from a metafile.
1029 */
1030 HMETAFILE WINAPI SetMetaFileBitsEx(
1031 UINT size, /* size of metafile, in bytes */
1032 const BYTE *lpData /* pointer to metafile data */
1033 )
1034 {
1035 HMETAFILE hmf = GlobalAlloc16(GHND, size);
1036 BYTE *p = GlobalLock16(hmf) ;
1037 TRACE(metafile, "(%d,%p) returning %08x\n", size, lpData, hmf);
1038 if (!hmf || !p) return 0;
1039 memcpy(p, lpData, size);
1040 GlobalUnlock16(hmf);
1041 return hmf;
1042 }
1043
1044 /*****************************************************************
1045 * GetMetaFileBitsEx (GDI32.198) Get raw metafile data
1046 *
1047 * Copies the data from metafile _hmf_ into the buffer _buf_.
1048 * If _buf_ is zero, returns size of buffer required. Otherwise,
1049 * returns number of bytes copied.
1050 */
1051 UINT WINAPI GetMetaFileBitsEx(
1052 HMETAFILE hmf, /* metafile */
1053 UINT nSize, /* size of buf */
1054 LPVOID buf /* buffer to receive raw metafile data */
1055 ) {
1056 METAHEADER *h = GlobalLock16(hmf);
1057 UINT mfSize;
1058
1059 TRACE(metafile, "(%08x,%d,%p)\n", hmf, nSize, buf);
1060 if (!h) return 0; /* FIXME: error code */
1061 mfSize = h->mtSize * 2;
1062 if (!buf) {
1063 GlobalUnlock16(hmf);
1064 TRACE(metafile,"returning size %d\n", mfSize);
1065 return mfSize;
1066 }
1067 if(mfSize > nSize) mfSize = nSize;
1068 memmove(buf, h, mfSize);
1069 GlobalUnlock16(hmf);
1070 return mfSize;
1071 }
1072
1073 /******************************************************************
1074 * GetWinMetaFileBits [GDI32.241]
1075 */
1076 UINT WINAPI GetWinMetaFileBits(HENHMETAFILE hemf,
1077 UINT cbBuffer, LPBYTE lpbBuffer,
1078 INT fnMapMode, HDC hdcRef)
1079 {
1080 FIXME(metafile, "(%d,%d,%p,%d,%d): stub\n",
1081 hemf, cbBuffer, lpbBuffer, fnMapMode, hdcRef);
1082 return 0;
1083 }
1084
1085 /******************************************************************
1086 * MF_Meta_CreateRegion
1087 *
1088 * Handles META_CREATEREGION for PlayMetaFileRecord().
1089 */
1090
1091 /*
1092 * The layout of the record looks something like this:
1093 *
1094 * rdParm meaning
1095 * 0 Always 0?
1096 * 1 Always 6?
1097 * 2 Looks like a handle? - not constant
1098 * 3 0 or 1 ??
1099 * 4 Total number of bytes
1100 * 5 No. of seperate bands = n [see below]
1101 * 6 Largest number of x co-ords in a band
1102 * 7-10 Bounding box x1 y1 x2 y2
1103 * 11-... n bands
1104 *
1105 * Regions are divided into bands that are uniform in the
1106 * y-direction. Each band consists of pairs of on/off x-coords and is
1107 * written as
1108 * m y0 y1 x1 x2 x3 ... xm m
1109 * into successive rdParm[]s.
1110 *
1111 * This is probably just a dump of the internal RGNOBJ?
1112 *
1113 * HDMD - 18/12/97
1114 *
1115 */
1116
1117 static BOOL MF_Meta_CreateRegion( METARECORD *mr, HRGN hrgn )
1118 {
1119 WORD band, pair;
1120 WORD *start, *end;
1121 INT16 y0, y1;
1122 HRGN hrgn2 = CreateRectRgn( 0, 0, 0, 0 );
1123
1124 for(band = 0, start = &(mr->rdParm[11]); band < mr->rdParm[5];
1125 band++, start = end + 1) {
1126 if(*start / 2 != (*start + 1) / 2) {
1127 WARN(metafile, "Delimiter not even.\n");
1128 DeleteObject( hrgn2 );
1129 return FALSE;
1130 }
1131
1132 end = start + *start + 3;
1133 if(end > (WORD *)mr + mr->rdSize) {
1134 WARN(metafile, "End points outside record.\n");
1135 DeleteObject( hrgn2 );
1136 return FALSE;
1137 }
1138
1139 if(*start != *end) {
1140 WARN(metafile, "Mismatched delimiters.\n");
1141 DeleteObject( hrgn2 );
1142 return FALSE;
1143 }
1144
1145 y0 = *(INT16 *)(start + 1);
1146 y1 = *(INT16 *)(start + 2);
1147 for(pair = 0; pair < *start / 2; pair++) {
1148 SetRectRgn( hrgn2, *(INT16 *)(start + 3 + 2*pair), y0,
1149 *(INT16 *)(start + 4 + 2*pair), y1 );
1150 CombineRgn(hrgn, hrgn, hrgn2, RGN_OR);
1151 }
1152 }
1153 DeleteObject( hrgn2 );
1154 return TRUE;
1155 }
1156
1157
1158 /******************************************************************
1159 * MF_WriteRecord
1160 *
1161 * Warning: this function can change the metafile handle.
1162 */
1163
1164 static BOOL MF_WriteRecord( DC *dc, METARECORD *mr, DWORD rlen)
1165 {
1166 DWORD len;
1167 METAHEADER *mh;
1168 METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dc->physDev;
1169
1170 switch(physDev->mh->mtType)
1171 {
1172 case METAFILE_MEMORY:
1173 len = physDev->mh->mtSize * 2 + rlen;
1174 mh = HeapReAlloc( SystemHeap, 0, physDev->mh, len );
1175 if (!mh) return FALSE;
1176 physDev->mh = mh;
1177 memcpy((WORD *)physDev->mh + physDev->mh->mtSize, mr, rlen);
1178 break;
1179 case METAFILE_DISK:
1180 TRACE(metafile,"Writing record to disk\n");
1181 if (_lwrite(physDev->mh->mtNoParameters, (char *)mr, rlen) == -1)
1182 return FALSE;
1183 break;
1184 default:
1185 ERR(metafile, "Unknown metafile type %d\n", physDev->mh->mtType );
1186 return FALSE;
1187 }
1188
1189 physDev->mh->mtSize += rlen / 2;
1190 physDev->mh->mtMaxRecord = MAX(physDev->mh->mtMaxRecord, rlen / 2);
1191 return TRUE;
1192 }
1193
1194
1195 /******************************************************************
1196 * MF_MetaParam0
1197 */
1198
1199 BOOL MF_MetaParam0(DC *dc, short func)
1200 {
1201 char buffer[8];
1202 METARECORD *mr = (METARECORD *)&buffer;
1203
1204 mr->rdSize = 3;
1205 mr->rdFunction = func;
1206 return MF_WriteRecord( dc, mr, mr->rdSize * 2);
1207 }
1208
1209
1210 /******************************************************************
1211 * MF_MetaParam1
1212 */
1213 BOOL MF_MetaParam1(DC *dc, short func, short param1)
1214 {
1215 char buffer[8];
1216 METARECORD *mr = (METARECORD *)&buffer;
1217
1218 mr->rdSize = 4;
1219 mr->rdFunction = func;
1220 *(mr->rdParm) = param1;
1221 return MF_WriteRecord( dc, mr, mr->rdSize * 2);
1222 }
1223
1224
1225 /******************************************************************
1226 * MF_MetaParam2
1227 */
1228 BOOL MF_MetaParam2(DC *dc, short func, short param1, short param2)
1229 {
1230 char buffer[10];
1231 METARECORD *mr = (METARECORD *)&buffer;
1232
1233 mr->rdSize = 5;
1234 mr->rdFunction = func;
1235 *(mr->rdParm) = param2;
1236 *(mr->rdParm + 1) = param1;
1237 return MF_WriteRecord( dc, mr, mr->rdSize * 2);
1238 }
1239
1240
1241 /******************************************************************
1242 * MF_MetaParam4
1243 */
1244
1245 BOOL MF_MetaParam4(DC *dc, short func, short param1, short param2,
1246 short param3, short param4)
1247 {
1248 char buffer[14];
1249 METARECORD *mr = (METARECORD *)&buffer;
1250
1251 mr->rdSize = 7;
1252 mr->rdFunction = func;
1253 *(mr->rdParm) = param4;
1254 *(mr->rdParm + 1) = param3;
1255 *(mr->rdParm + 2) = param2;
1256 *(mr->rdParm + 3) = param1;
1257 return MF_WriteRecord( dc, mr, mr->rdSize * 2);
1258 }
1259
1260
1261 /******************************************************************
1262 * MF_MetaParam6
1263 */
1264
1265 BOOL MF_MetaParam6(DC *dc, short func, short param1, short param2,
1266 short param3, short param4, short param5, short param6)
1267 {
1268 char buffer[18];
1269 METARECORD *mr = (METARECORD *)&buffer;
1270
1271 mr->rdSize = 9;
1272 mr->rdFunction = func;
1273 *(mr->rdParm) = param6;
1274 *(mr->rdParm + 1) = param5;
1275 *(mr->rdParm + 2) = param4;
1276 *(mr->rdParm + 3) = param3;
1277 *(mr->rdParm + 4) = param2;
1278 *(mr->rdParm + 5) = param1;
1279 return MF_WriteRecord( dc, mr, mr->rdSize * 2);
1280 }
1281
1282
1283 /******************************************************************
1284 * MF_MetaParam8
1285 */
1286 BOOL MF_MetaParam8(DC *dc, short func, short param1, short param2,
1287 short param3, short param4, short param5,
1288 short param6, short param7, short param8)
1289 {
1290 char buffer[22];
1291 METARECORD *mr = (METARECORD *)&buffer;
1292
1293 mr->rdSize = 11;
1294 mr->rdFunction = func;
1295 *(mr->rdParm) = param8;
1296 *(mr->rdParm + 1) = param7;
1297 *(mr->rdParm + 2) = param6;
1298 *(mr->rdParm + 3) = param5;
1299 *(mr->rdParm + 4) = param4;
1300 *(mr->rdParm + 5) = param3;
1301 *(mr->rdParm + 6) = param2;
1302 *(mr->rdParm + 7) = param1;
1303 return MF_WriteRecord( dc, mr, mr->rdSize * 2);
1304 }
1305
1306
1307 /******************************************************************
1308 * MF_CreateBrushIndirect
1309 */
1310
1311 BOOL MF_CreateBrushIndirect(DC *dc, HBRUSH16 hBrush, LOGBRUSH16 *logbrush)
1312 {
1313 int index;
1314 char buffer[sizeof(METARECORD) - 2 + sizeof(*logbrush)];
1315 METARECORD *mr = (METARECORD *)&buffer;
1316
1317 mr->rdSize = (sizeof(METARECORD) + sizeof(*logbrush) - 2) / 2;
1318 mr->rdFunction = META_CREATEBRUSHINDIRECT;
1319 memcpy(&(mr->rdParm), logbrush, sizeof(*logbrush));
1320 if (!(MF_WriteRecord( dc, mr, mr->rdSize * 2))) return FALSE;
1321
1322 mr->rdSize = sizeof(METARECORD) / 2;
1323 mr->rdFunction = META_SELECTOBJECT;
1324
1325 if ((index = MF_AddHandleDC( dc )) == -1) return FALSE;
1326 *(mr->rdParm) = index;
1327 return MF_WriteRecord( dc, mr, mr->rdSize * 2);
1328 }
1329
1330
1331 /******************************************************************
1332 * MF_CreatePatternBrush
1333 */
1334
1335 BOOL MF_CreatePatternBrush(DC *dc, HBRUSH16 hBrush, LOGBRUSH16 *logbrush)
1336 {
1337 DWORD len, bmSize, biSize;
1338 HGLOBAL16 hmr;
1339 METARECORD *mr;
1340 BITMAPOBJ *bmp;
1341 BITMAPINFO *info;
1342 BITMAPINFOHEADER *infohdr;
1343 int index;
1344 char buffer[sizeof(METARECORD)];
1345
1346 switch (logbrush->lbStyle)
1347 {
1348 case BS_PATTERN:
1349 bmp = (BITMAPOBJ *)GDI_GetObjPtr((HGDIOBJ16)logbrush->lbHatch, BITMAP_MAGIC);
1350 if (!bmp) return FALSE;
1351 len = sizeof(METARECORD) + sizeof(BITMAPINFOHEADER) +
1352 (bmp->bitmap.bmHeight * bmp->bitmap.bmWidthBytes) + 6;
1353 if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
1354 {
1355 GDI_HEAP_UNLOCK((HGDIOBJ16)logbrush->lbHatch);
1356 return FALSE;
1357 }
1358 mr = (METARECORD *)GlobalLock16(hmr);
1359 memset(mr, 0, len);
1360 mr->rdFunction = META_DIBCREATEPATTERNBRUSH;
1361 mr->rdSize = len / 2;
1362 *(mr->rdParm) = logbrush->lbStyle;
1363 *(mr->rdParm + 1) = DIB_RGB_COLORS;
1364 infohdr = (BITMAPINFOHEADER *)(mr->rdParm + 2);
1365 infohdr->biSize = sizeof(BITMAPINFOHEADER);
1366 infohdr->biWidth = bmp->bitmap.bmWidth;
1367 infohdr->biHeight = bmp->bitmap.bmHeight;
1368 infohdr->biPlanes = bmp->bitmap.bmPlanes;
1369 infohdr->biBitCount = bmp->bitmap.bmBitsPixel;
1370 memcpy(mr->rdParm + (sizeof(BITMAPINFOHEADER) / 2) + 4,
1371 PTR_SEG_TO_LIN(bmp->bitmap.bmBits),
1372 bmp->bitmap.bmHeight * bmp->bitmap.bmWidthBytes);
1373 GDI_HEAP_UNLOCK(logbrush->lbHatch);
1374 break;
1375
1376 case BS_DIBPATTERN:
1377 info = (BITMAPINFO *)GlobalLock16((HGLOBAL16)logbrush->lbHatch);
1378 if (info->bmiHeader.biCompression)
1379 bmSize = info->bmiHeader.biSizeImage;
1380 else
1381 bmSize = (info->bmiHeader.biWidth * info->bmiHeader.biBitCount
1382 + 31) / 32 * 8 * info->bmiHeader.biHeight;
1383 biSize = DIB_BitmapInfoSize(info, LOWORD(logbrush->lbColor));
1384 len = sizeof(METARECORD) + biSize + bmSize + 2;
1385 if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
1386 return FALSE;
1387 mr = (METARECORD *)GlobalLock16(hmr);
1388 memset(mr, 0, len);
1389 mr->rdFunction = META_DIBCREATEPATTERNBRUSH;
1390 mr->rdSize = len / 2;
1391 *(mr->rdParm) = logbrush->lbStyle;
1392 *(mr->rdParm + 1) = LOWORD(logbrush->lbColor);
1393 memcpy(mr->rdParm + 2, info, biSize + bmSize);
1394 break;
1395 default:
1396 return FALSE;
1397 }
1398 if (!(MF_WriteRecord(dc, mr, len)))
1399 {
1400 GlobalFree16(hmr);
1401 return FALSE;
1402 }
1403
1404 GlobalFree16(hmr);
1405
1406 mr = (METARECORD *)&buffer;
1407 mr->rdSize = sizeof(METARECORD) / 2;
1408 mr->rdFunction = META_SELECTOBJECT;
1409
1410 if ((index = MF_AddHandleDC( dc )) == -1) return FALSE;
1411 *(mr->rdParm) = index;
1412 return MF_WriteRecord( dc, mr, mr->rdSize * 2);
1413 }
1414
1415
1416 /******************************************************************
1417 * MF_CreatePenIndirect
1418 */
1419
1420 BOOL MF_CreatePenIndirect(DC *dc, HPEN16 hPen, LOGPEN16 *logpen)
1421 {
1422 int index;
1423 char buffer[sizeof(METARECORD) - 2 + sizeof(*logpen)];
1424 METARECORD *mr = (METARECORD *)&buffer;
1425
1426 mr->rdSize = (sizeof(METARECORD) + sizeof(*logpen) - 2) / 2;
1427 mr->rdFunction = META_CREATEPENINDIRECT;
1428 memcpy(&(mr->rdParm), logpen, sizeof(*logpen));
1429 if (!(MF_WriteRecord( dc, mr, mr->rdSize * 2))) return FALSE;
1430
1431 mr->rdSize = sizeof(METARECORD) / 2;
1432 mr->rdFunction = META_SELECTOBJECT;
1433
1434 if ((index = MF_AddHandleDC( dc )) == -1) return FALSE;
1435 *(mr->rdParm) = index;
1436 return MF_WriteRecord( dc, mr, mr->rdSize * 2);
1437 }
1438
1439
1440 /******************************************************************
1441 * MF_CreateFontIndirect
1442 */
1443
1444 BOOL MF_CreateFontIndirect(DC *dc, HFONT16 hFont, LOGFONT16 *logfont)
1445 {
1446 int index;
1447 char buffer[sizeof(METARECORD) - 2 + sizeof(LOGFONT16)];
1448 METARECORD *mr = (METARECORD *)&buffer;
1449
1450 mr->rdSize = (sizeof(METARECORD) + sizeof(LOGFONT16) - 2) / 2;
1451 mr->rdFunction = META_CREATEFONTINDIRECT;
1452 memcpy(&(mr->rdParm), logfont, sizeof(LOGFONT16));
1453 if (!(MF_WriteRecord( dc, mr, mr->rdSize * 2))) return FALSE;
1454
1455 mr->rdSize = sizeof(METARECORD) / 2;
1456 mr->rdFunction = META_SELECTOBJECT;
1457
1458 if ((index = MF_AddHandleDC( dc )) == -1) return FALSE;
1459 *(mr->rdParm) = index;
1460 return MF_WriteRecord( dc, mr, mr->rdSize * 2);
1461 }
1462
1463
1464 /******************************************************************
1465 * MF_TextOut
1466 */
1467 BOOL MF_TextOut(DC *dc, short x, short y, LPCSTR str, short count)
1468 {
1469 BOOL ret;
1470 DWORD len;
1471 HGLOBAL16 hmr;
1472 METARECORD *mr;
1473
1474 len = sizeof(METARECORD) + (((count + 1) >> 1) * 2) + 4;
1475 if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
1476 return FALSE;
1477 mr = (METARECORD *)GlobalLock16(hmr);
1478 memset(mr, 0, len);
1479
1480 mr->rdSize = len / 2;
1481 mr->rdFunction = META_TEXTOUT;
1482 *(mr->rdParm) = count;
1483 memcpy(mr->rdParm + 1, str, count);
1484 *(mr->rdParm + ((count + 1) >> 1) + 1) = y;
1485 *(mr->rdParm + ((count + 1) >> 1) + 2) = x;
1486 ret = MF_WriteRecord( dc, mr, mr->rdSize * 2);
1487 GlobalFree16(hmr);
1488 return ret;
1489 }
1490
1491 /******************************************************************
1492 * MF_ExtTextOut
1493 */
1494 BOOL MF_ExtTextOut(DC*dc, short x, short y, UINT16 flags, const RECT16 *rect,
1495 LPCSTR str, short count, const INT16 *lpDx)
1496 {
1497 BOOL ret;
1498 DWORD len;
1499 HGLOBAL16 hmr;
1500 METARECORD *mr;
1501
1502 if((!flags && rect) || (flags && !rect))
1503 WARN(metafile, "Inconsistent flags and rect\n");
1504 len = sizeof(METARECORD) + (((count + 1) >> 1) * 2) + 2 * sizeof(short)
1505 + sizeof(UINT16);
1506 if(rect)
1507 len += sizeof(RECT16);
1508 if (lpDx)
1509 len+=count*sizeof(INT16);
1510 if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
1511 return FALSE;
1512 mr = (METARECORD *)GlobalLock16(hmr);
1513 memset(mr, 0, len);
1514
1515 mr->rdSize = len / 2;
1516 mr->rdFunction = META_EXTTEXTOUT;
1517 *(mr->rdParm) = y;
1518 *(mr->rdParm + 1) = x;
1519 *(mr->rdParm + 2) = count;
1520 *(mr->rdParm + 3) = flags;
1521 if (rect) memcpy(mr->rdParm + 4, rect, sizeof(RECT16));
1522 memcpy(mr->rdParm + (rect ? 8 : 4), str, count);
1523 if (lpDx)
1524 memcpy(mr->rdParm + (rect ? 8 : 4) + ((count + 1) >> 1),lpDx,
1525 count*sizeof(INT16));
1526 ret = MF_WriteRecord( dc, mr, mr->rdSize * 2);
1527 GlobalFree16(hmr);
1528 return ret;
1529 }
1530
1531 /******************************************************************
1532 * MF_MetaPoly - implements Polygon and Polyline
1533 */
1534 BOOL MF_MetaPoly(DC *dc, short func, LPPOINT16 pt, short count)
1535 {
1536 BOOL ret;
1537 DWORD len;
1538 HGLOBAL16 hmr;
1539 METARECORD *mr;
1540
1541 len = sizeof(METARECORD) + (count * 4);
1542 if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
1543 return FALSE;
1544 mr = (METARECORD *)GlobalLock16(hmr);
1545 memset(mr, 0, len);
1546
1547 mr->rdSize = len / 2;
1548 mr->rdFunction = func;
1549 *(mr->rdParm) = count;
1550 memcpy(mr->rdParm + 1, pt, count * 4);
1551 ret = MF_WriteRecord( dc, mr, mr->rdSize * 2);
1552 GlobalFree16(hmr);
1553 return ret;
1554 }
1555
1556
1557 /******************************************************************
1558 * MF_BitBlt
1559 */
1560 BOOL MF_BitBlt(DC *dcDest, short xDest, short yDest, short width,
1561 short height, DC *dcSrc, short xSrc, short ySrc, DWORD rop)
1562 {
1563 BOOL ret;
1564 DWORD len;
1565 HGLOBAL16 hmr;
1566 METARECORD *mr;
1567 BITMAP16 BM;
1568
1569 GetObject16(dcSrc->w.hBitmap, sizeof(BITMAP16), &BM);
1570 len = sizeof(METARECORD) + 12 * sizeof(INT16) + BM.bmWidthBytes * BM.bmHeight;
1571 if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
1572 return FALSE;
1573 mr = (METARECORD *)GlobalLock16(hmr);
1574 mr->rdFunction = META_BITBLT;
1575 *(mr->rdParm + 7) = BM.bmWidth;
1576 *(mr->rdParm + 8) = BM.bmHeight;
1577 *(mr->rdParm + 9) = BM.bmWidthBytes;
1578 *(mr->rdParm +10) = BM.bmPlanes;
1579 *(mr->rdParm +11) = BM.bmBitsPixel;
1580 TRACE(metafile,"MF_StretchBlt->len = %ld rop=%lx \n",len,rop);
1581 if (GetBitmapBits(dcSrc->w.hBitmap,BM.bmWidthBytes * BM.bmHeight,
1582 mr->rdParm +12))
1583 {
1584 mr->rdSize = len / sizeof(INT16);
1585 *(mr->rdParm) = HIWORD(rop);
1586 *(mr->rdParm + 1) = ySrc;
1587 *(mr->rdParm + 2) = xSrc;
1588 *(mr->rdParm + 3) = height;
1589 *(mr->rdParm + 4) = width;
1590 *(mr->rdParm + 5) = yDest;
1591 *(mr->rdParm + 6) = xDest;
1592 ret = MF_WriteRecord( dcDest, mr, mr->rdSize * 2);
1593 }
1594 else
1595 ret = FALSE;
1596 GlobalFree16(hmr);
1597 return ret;
1598 }
1599
1600
1601 /**********************************************************************
1602 * MF_StretchBlt
1603 * this function contains TWO ways for procesing StretchBlt in metafiles,
1604 * decide between rdFunction values META_STRETCHBLT or META_DIBSTRETCHBLT
1605 * via #define STRETCH_VIA_DIB
1606 */
1607 #define STRETCH_VIA_DIB
1608 #undef STRETCH_VIA_DIB
1609 BOOL MF_StretchBlt(DC *dcDest, short xDest, short yDest, short widthDest,
1610 short heightDest, DC *dcSrc, short xSrc, short ySrc,
1611 short widthSrc, short heightSrc, DWORD rop)
1612 {
1613 BOOL ret;
1614 DWORD len;
1615 HGLOBAL16 hmr;
1616 METARECORD *mr;
1617 BITMAP16 BM;
1618 #ifdef STRETCH_VIA_DIB
1619 LPBITMAPINFOHEADER lpBMI;
1620 WORD nBPP;
1621 #endif
1622 GetObject16(dcSrc->w.hBitmap, sizeof(BITMAP16), &BM);
1623 #ifdef STRETCH_VIA_DIB
1624 nBPP = BM.bmPlanes * BM.bmBitsPixel;
1625 len = sizeof(METARECORD) + 10 * sizeof(INT16)
1626 + sizeof(BITMAPINFOHEADER) + (nBPP != 24 ? 1 << nBPP: 0) * sizeof(RGBQUAD)
1627 + ((BM.bmWidth * nBPP + 31) / 32) * 4 * BM.bmHeight;
1628 if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
1629 return FALSE;
1630 mr = (METARECORD *)GlobalLock16(hmr);
1631 mr->rdFunction = META_DIBSTRETCHBLT;
1632 lpBMI=(LPBITMAPINFOHEADER)(mr->rdParm+10);
1633 lpBMI->biSize = sizeof(BITMAPINFOHEADER);
1634 lpBMI->biWidth = BM.bmWidth;
1635 lpBMI->biHeight = BM.bmHeight;
1636 lpBMI->biPlanes = 1;
1637 lpBMI->biBitCount = nBPP; /* 1,4,8 or 24 */
1638 lpBMI->biClrUsed = nBPP != 24 ? 1 << nBPP : 0;
1639 lpBMI->biSizeImage = ((lpBMI->biWidth * nBPP + 31) / 32) * 4 * lpBMI->biHeight;
1640 lpBMI->biCompression = BI_RGB;
1641 lpBMI->biXPelsPerMeter = MulDiv(GetDeviceCaps(dcSrc->hSelf,LOGPIXELSX),3937,100);
1642 lpBMI->biYPelsPerMeter = MulDiv(GetDeviceCaps(dcSrc->hSelf,LOGPIXELSY),3937,100);
1643 lpBMI->biClrImportant = 0; /* 1 meter = 39.37 inch */
1644
1645 TRACE(metafile,"MF_StretchBltViaDIB->len = %ld rop=%lx PixYPM=%ld Caps=%d\n",
1646 len,rop,lpBMI->biYPelsPerMeter,GetDeviceCaps(hdcSrc,LOGPIXELSY));
1647 if (GetDIBits(hdcSrc,dcSrc->w.hBitmap,0,(UINT)lpBMI->biHeight,
1648 (LPSTR)lpBMI + DIB_BitmapInfoSize( (BITMAPINFO *)lpBMI,
1649 DIB_RGB_COLORS ),
1650 (LPBITMAPINFO)lpBMI, DIB_RGB_COLORS))
1651 #else
1652 len = sizeof(METARECORD) + 15 * sizeof(INT16) + BM.bmWidthBytes * BM.bmHeight;
1653 if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
1654 return FALSE;
1655 mr = (METARECORD *)GlobalLock16(hmr);
1656 mr->rdFunction = META_STRETCHBLT;
1657 *(mr->rdParm +10) = BM.bmWidth;
1658 *(mr->rdParm +11) = BM.bmHeight;
1659 *(mr->rdParm +12) = BM.bmWidthBytes;
1660 *(mr->rdParm +13) = BM.bmPlanes;
1661 *(mr->rdParm +14) = BM.bmBitsPixel;
1662 TRACE(metafile,"MF_StretchBlt->len = %ld rop=%lx \n",len,rop);
1663 if (GetBitmapBits( dcSrc->w.hBitmap, BM.bmWidthBytes * BM.bmHeight,
1664 mr->rdParm +15))
1665 #endif
1666 {
1667 mr->rdSize = len / sizeof(INT16);
1668 *(mr->rdParm) = LOWORD(rop);
1669 *(mr->rdParm + 1) = HIWORD(rop);
1670 *(mr->rdParm + 2) = heightSrc;
1671 *(mr->rdParm + 3) = widthSrc;
1672 *(mr->rdParm + 4) = ySrc;
1673 *(mr->rdParm + 5) = xSrc;
1674 *(mr->rdParm + 6) = heightDest;
1675 *(mr->rdParm + 7) = widthDest;
1676 *(mr->rdParm + 8) = yDest;
1677 *(mr->rdParm + 9) = xDest;
1678 ret = MF_WriteRecord( dcDest, mr, mr->rdSize * 2);
1679 }
1680 else
1681 ret = FALSE;
1682 GlobalFree16(hmr);
1683 return ret;
1684 }
1685
1686
1687 /******************************************************************
1688 * MF_CreateRegion
1689 */
1690 INT16 MF_CreateRegion(DC *dc, HRGN hrgn)
1691 {
1692 DWORD len;
1693 METARECORD *mr;
1694 RGNDATA *rgndata;
1695 RECT *pCurRect, *pEndRect;
1696 WORD Bands = 0, MaxBands = 0;
1697 WORD *Param, *StartBand;
1698 BOOL ret;
1699
1700 len = GetRegionData( hrgn, 0, NULL );
1701 if( !(rgndata = HeapAlloc( SystemHeap, 0, len )) ) {
1702 WARN(metafile, "MF_CreateRegion: can't alloc rgndata buffer\n");
1703 return -1;
1704 }
1705 GetRegionData( hrgn, len, rgndata );
1706
1707 /* Overestimate of length:
1708 * Assume every rect is a separate band -> 6 WORDs per rect
1709 */
1710 len = sizeof(METARECORD) + 20 + (rgndata->rdh.nCount * 12);
1711 if( !(mr = HeapAlloc( SystemHeap, 0, len )) ) {
1712 WARN(metafile, "MF_CreateRegion: can't alloc METARECORD buffer\n");
1713 HeapFree( SystemHeap, 0, rgndata );
1714 return -1;
1715 }
1716
1717 memset(mr, 0, len);
1718
1719 Param = mr->rdParm + 11;
1720 StartBand = NULL;
1721
1722 pEndRect = (RECT *)rgndata->Buffer + rgndata->rdh.nCount;
1723 for(pCurRect = (RECT *)rgndata->Buffer; pCurRect < pEndRect; pCurRect++)
1724 {
1725 if( StartBand && pCurRect->top == *(StartBand + 1) )
1726 {
1727 *Param++ = pCurRect->left;
1728 *Param++ = pCurRect->right;
1729 }
1730 else
1731 {
1732 if(StartBand)
1733 {
1734 *StartBand = Param - StartBand - 3;
1735 *Param++ = *StartBand;
1736 if(*StartBand > MaxBands)
1737 MaxBands = *StartBand;
1738 Bands++;
1739 }
1740 StartBand = Param++;
1741 *Param++ = pCurRect->top;
1742 *Param++ = pCurRect->bottom;
1743 *Param++ = pCurRect->left;
1744 *Param++ = pCurRect->right;
1745 }
1746 }
1747 len = Param - (WORD *)mr;
1748
1749 mr->rdParm[0] = 0;
1750 mr->rdParm[1] = 6;
1751 mr->rdParm[2] = 0x1234;
1752 mr->rdParm[3] = 0;
1753 mr->rdParm[4] = len * 2;
1754 mr->rdParm[5] = Bands;
1755 mr->rdParm[6] = MaxBands;
1756 mr->rdParm[7] = rgndata->rdh.rcBound.left;
1757 mr->rdParm[8] = rgndata->rdh.rcBound.top;
1758 mr->rdParm[9] = rgndata->rdh.rcBound.right;
1759 mr->rdParm[10] = rgndata->rdh.rcBound.bottom;
1760 mr->rdFunction = META_CREATEREGION;
1761 mr->rdSize = len / 2;
1762 ret = MF_WriteRecord( dc, mr, mr->rdSize * 2 );
1763 HeapFree( SystemHeap, 0, mr );
1764 HeapFree( SystemHeap, 0, rgndata );
1765 if(!ret)
1766 {
1767 WARN(metafile, "MF_CreateRegion: MF_WriteRecord failed\n");
1768 return -1;
1769 }
1770 return MF_AddHandleDC( dc );
1771 }
GSOC 2012 project to enhance the control panel