4 * Copyright David W. Metcalfe, 1994
5 * Niels de Carpentier, Albrecht Kleine 1996
15 #include "stackframe.h"
19 #define HTINCR 10 /* handle table allocation size increment */
21 static HANDLE hHT
; /* handle of the handle table */
22 static int HTLen
; /* allocated length of handle table */
24 /******************************************************************
25 * GetMetafile GDI.124 By Kenny MacDonald 30 Nov 94
28 HMETAFILE
GetMetaFile(LPSTR lpFilename
)
35 dprintf_metafile(stddeb
,"GetMetaFile: %s\n", lpFilename
);
40 hmf
= GlobalAlloc16(GMEM_MOVEABLE
, MFHEADERSIZE
);
41 mh
= (METAHEADER
*)GlobalLock16(hmf
);
48 if ((hFile
= _lopen(lpFilename
, OF_READ
)) == HFILE_ERROR
) {
53 if (FILE_Read(hFile
, (char *)mh
, MFHEADERSIZE
) == HFILE_ERROR
) {
58 size
= mh
->mtSize
* 2; /* alloc memory for whole metafile */
60 hmf
= GlobalReAlloc16(hmf
,size
,GMEM_MOVEABLE
);
61 mh
= (METAHEADER
*)GlobalLock16(hmf
);
68 if (FILE_Read(hFile
, (char*)mh
+ mh
->mtHeaderSize
* 2,
69 size
- mh
->mtHeaderSize
* 2) == HFILE_ERROR
) {
76 if (mh
->mtType
!= 1) {
86 /******************************************************************
87 * CreateMetafile GDI.125
90 HANDLE
CreateMetaFile(LPCSTR lpFilename
)
97 dprintf_metafile(stddeb
,"CreateMetaFile: %s\n", lpFilename
);
99 handle
= GDI_AllocObject(sizeof(DC
), METAFILE_DC_MAGIC
);
104 dc
= (DC
*)GDI_HEAP_LIN_ADDR(handle
);
106 if (!(dc
->w
.hMetaFile
= GlobalAlloc16(GMEM_MOVEABLE
, sizeof(METAHEADER
)))) {
107 GDI_FreeObject(handle
);
110 dc
->w
.bitsPerPixel
= screenDepth
;
111 mh
= (METAHEADER
*)GlobalLock16(dc
->w
.hMetaFile
);
113 mh
->mtHeaderSize
= MFHEADERSIZE
/ 2;
114 mh
->mtVersion
= MFVERSION
;
115 mh
->mtSize
= MFHEADERSIZE
/ 2;
118 mh
->mtNoParameters
= 0;
120 if (lpFilename
) /* disk based metafile */
122 mh
->mtType
= 1; /* disk */
123 hFile
= _lcreat(lpFilename
, 0);
124 if (_lwrite(hFile
, (char *)mh
, MFHEADERSIZE
) == -1)
126 GlobalFree16(dc
->w
.hMetaFile
);
129 mh
->mtNoParameters
= hFile
; /* store file descriptor here */
130 /* windows probably uses this too*/
132 else /* memory based metafile */
135 /* create the handle table */
137 hHT
= GlobalAlloc16(GMEM_MOVEABLE
| GMEM_ZEROINIT
,
138 sizeof(HANDLETABLE16
) * HTLen
);
140 GlobalUnlock16(dc
->w
.hMetaFile
);
141 dprintf_metafile(stddeb
,"CreateMetaFile: returning %04x\n", handle
);
145 /******************************************************************
146 * CopyMetafile GDI.151 Niels de Carpentier, April 1996
149 HMETAFILE
CopyMetaFile(HMETAFILE hSrcMetaFile
, LPCSTR lpFilename
)
151 HMETAFILE handle
= 0;
156 dprintf_metafile(stddeb
,"CopyMetaFile: %s\n", lpFilename
);
158 mh
= (METAHEADER
*)GlobalLock16(hSrcMetaFile
);
163 if (lpFilename
) /* disk based metafile */
166 hFile
= _lcreat(lpFilename
, 0);
168 mh
->mtType
=1; /* disk file version stores 1 here */
169 i
=_lwrite(hFile
, (char *)mh
, mh
->mtSize
* 2) ;
170 mh
->mtType
=j
; /* restore old value [0 or 1] */
178 else /* memory based metafile */
180 handle
= GlobalAlloc16(GMEM_MOVEABLE
,mh
->mtSize
* 2);
181 mh2
= (METAHEADER
*)GlobalLock16(handle
);
182 memcpy(mh2
,mh
, mh
->mtSize
* 2);
183 GlobalUnlock16(handle
);
190 /******************************************************************
191 * CloseMetafile GDI.126
194 HMETAFILE
CloseMetaFile(HDC hdc
)
201 dprintf_metafile(stddeb
,"CloseMetaFile\n");
203 dc
= (DC
*)GDI_GetObjPtr(hdc
, METAFILE_DC_MAGIC
);
208 mh
= (METAHEADER
*)GlobalLock16(dc
->w
.hMetaFile
);
210 /* Construct the end of metafile record - this is documented
211 * in SDK Knowledgebase Q99334.
214 if (!MF_MetaParam0(dc
, META_EOF
))
216 GlobalFree16(dc
->w
.hMetaFile
);
220 if (mh
->mtType
== 1) /* disk based metafile */
222 hFile
= mh
->mtNoParameters
;
223 mh
->mtNoParameters
= 0;
224 if (_llseek(hFile
, 0L, 0) == -1)
226 GlobalFree16(dc
->w
.hMetaFile
);
229 if (_lwrite(hFile
, (char *)mh
, MFHEADERSIZE
) == -1)
231 GlobalFree16(dc
->w
.hMetaFile
);
237 /* delete the handle table */
240 hmf
= dc
->w
.hMetaFile
;
247 /******************************************************************
248 * DeleteMetafile GDI.127
251 BOOL
DeleteMetaFile(HMETAFILE hmf
)
253 METAHEADER
*mh
= (METAHEADER
*)GlobalLock16(hmf
);
263 /******************************************************************
264 * PlayMetafile GDI.123
267 BOOL
PlayMetaFile(HDC hdc
, HMETAFILE hmf
)
269 METAHEADER
*mh
= (METAHEADER
*)GlobalLock16(hmf
);
275 dprintf_metafile(stddeb
,"PlayMetaFile(%04x %04x)\n",hdc
,hmf
);
277 /* create the handle table */
278 hHT
= GlobalAlloc16(GMEM_MOVEABLE
|GMEM_ZEROINIT
,
279 sizeof(HANDLETABLE16
) * mh
->mtNoObjects
);
280 ht
= (HANDLETABLE16
*)GlobalLock16(hHT
);
282 /* loop through metafile playing records */
283 offset
= mh
->mtHeaderSize
* 2;
284 while (offset
< mh
->mtSize
* 2)
286 mr
= (METARECORD
*)((char *)mh
+ offset
);
287 dprintf_metafile(stddeb
,"offset = %04x size = %08lx function = %04x\n",
288 offset
,mr
->rdSize
,mr
->rdFunction
);
289 offset
+= mr
->rdSize
* 2;
290 PlayMetaFileRecord(hdc
, ht
, mr
, mh
->mtNoObjects
);
293 /* free objects in handle table */
294 for(i
= 0; i
< mh
->mtNoObjects
; i
++)
295 if(*(ht
->objectHandle
+ i
) != 0)
296 DeleteObject(*(ht
->objectHandle
+ i
));
298 /* free handle table */
305 /******************************************************************
306 * EnumMetafile GDI.175
307 * Niels de carpentier, april 1996
310 BOOL
EnumMetaFile(HDC hdc
, HMETAFILE hmf
, MFENUMPROC16 lpEnumFunc
,LPARAM lpData
)
312 METAHEADER
*mh
= (METAHEADER
*)GlobalLock16(hmf
);
317 dprintf_metafile(stddeb
,"EnumMetaFile(%04x, %04x, %08lx, %08lx)\n",
318 hdc
, hmf
, (DWORD
)lpEnumFunc
, lpData
);
320 /* create the handle table */
322 hHT
= GlobalAlloc16(GMEM_MOVEABLE
| GMEM_ZEROINIT
,
323 sizeof(HANDLETABLE16
) * mh
->mtNoObjects
);
324 ht
= WIN16_GlobalLock16(hHT
);
326 offset
= mh
->mtHeaderSize
* 2;
328 /* loop through metafile records */
330 while (offset
< (mh
->mtSize
* 2))
332 mr
= (METARECORD
*)((char *)mh
+ offset
);
333 if (!lpEnumFunc( hdc
, ht
, MAKE_SEGPTR(mr
), /* FIXME!! */
334 mh
->mtNoObjects
, (LONG
)lpData
))
337 offset
+= (mr
->rdSize
* 2);
340 /* free handle table */
346 /*******************************************************************
347 * MF_GetDIBitsPointer [internal helper for e.g. PlayMetaFileRecord]
349 * Returns offset to DIB bits or 0 if error
350 * (perhaps should be moved to (objects/dib.c ?)
352 static LPSTR
MF_GetDIBitsPointer(LPBITMAPINFO info
)
355 if (info
->bmiHeader
.biSize
== sizeof(BITMAPINFOHEADER
))
357 if (info
->bmiHeader
.biClrUsed
)
359 if (info
->bmiHeader
.biClrUsed
< (1 << info
->bmiHeader
.biBitCount
))
360 offset
= info
->bmiHeader
.biClrUsed
* 4;
362 offset
= (1 << info
->bmiHeader
.biBitCount
) * 4;
365 offset
= (1 << info
->bmiHeader
.biBitCount
) * 4;
367 else if (info
->bmiHeader
.biSize
== sizeof(BITMAPCOREHEADER
))
369 if (info
->bmiHeader
.biClrUsed
)
371 if (info
->bmiHeader
.biClrUsed
< (1 << info
->bmiHeader
.biBitCount
))
372 offset
= info
->bmiHeader
.biClrUsed
* 3;
374 offset
= (1 << info
->bmiHeader
.biBitCount
) * 3;
377 offset
= (1 << info
->bmiHeader
.biBitCount
) * 3;
381 fprintf(stderr
,"Unknown size for BITMAPHEADER in MetaFile!\n");
384 return (LPSTR
)info
+ info
->bmiHeader
.biSize
+ offset
;
388 /******************************************************************
389 * PlayMetaFileRecord GDI.176
392 void PlayMetaFileRecord(HDC hdc
, HANDLETABLE16
*ht
, METARECORD
*mr
,
398 BITMAPINFOHEADER
*infohdr
;
400 dprintf_metafile(stddeb
,"PlayMetaFileRecord(%04x %08lx %08lx %04x)\n",
401 hdc
,(LONG
)ht
, (LONG
)mr
, nHandles
);
403 switch (mr
->rdFunction
)
408 case META_DELETEOBJECT
:
409 DeleteObject(*(ht
->objectHandle
+ *(mr
->rdParam
)));
410 *(ht
->objectHandle
+ *(mr
->rdParam
)) = 0;
413 case META_SETBKCOLOR
:
414 SetBkColor(hdc
, *(mr
->rdParam
));
418 SetBkMode(hdc
, *(mr
->rdParam
));
421 case META_SETMAPMODE
:
422 SetMapMode(hdc
, *(mr
->rdParam
));
426 SetROP2(hdc
, *(mr
->rdParam
));
430 SetRelAbs(hdc
, *(mr
->rdParam
));
433 case META_SETPOLYFILLMODE
:
434 SetPolyFillMode(hdc
, *(mr
->rdParam
));
437 case META_SETSTRETCHBLTMODE
:
438 SetStretchBltMode(hdc
, *(mr
->rdParam
));
441 case META_SETTEXTCOLOR
:
442 SetTextColor(hdc
, MAKELONG(*(mr
->rdParam
), *(mr
->rdParam
+ 1)));
445 case META_SETWINDOWORG
:
446 SetWindowOrg(hdc
, *(mr
->rdParam
+ 1), *(mr
->rdParam
));
449 case META_SETWINDOWEXT
:
450 SetWindowExt(hdc
, *(mr
->rdParam
+ 1), *(mr
->rdParam
));
453 case META_SETVIEWPORTORG
:
454 SetViewportOrg(hdc
, *(mr
->rdParam
+ 1), *(mr
->rdParam
));
457 case META_SETVIEWPORTEXT
:
458 SetViewportExt(hdc
, *(mr
->rdParam
+ 1), *(mr
->rdParam
));
461 case META_OFFSETWINDOWORG
:
462 OffsetWindowOrg(hdc
, *(mr
->rdParam
+ 1), *(mr
->rdParam
));
465 case META_SCALEWINDOWEXT
:
466 ScaleWindowExt(hdc
, *(mr
->rdParam
+ 3), *(mr
->rdParam
+ 2),
467 *(mr
->rdParam
+ 1), *(mr
->rdParam
));
470 case META_OFFSETVIEWPORTORG
:
471 OffsetViewportOrg(hdc
, *(mr
->rdParam
+ 1), *(mr
->rdParam
));
474 case META_SCALEVIEWPORTEXT
:
475 ScaleViewportExt(hdc
, *(mr
->rdParam
+ 3), *(mr
->rdParam
+ 2),
476 *(mr
->rdParam
+ 1), *(mr
->rdParam
));
480 LineTo(hdc
, *(mr
->rdParam
+ 1), *(mr
->rdParam
));
484 MoveTo(hdc
, *(mr
->rdParam
+ 1), *(mr
->rdParam
));
487 case META_EXCLUDECLIPRECT
:
488 ExcludeClipRect(hdc
, *(mr
->rdParam
+ 3), *(mr
->rdParam
+ 2),
489 *(mr
->rdParam
+ 1), *(mr
->rdParam
));
492 case META_INTERSECTCLIPRECT
:
493 IntersectClipRect(hdc
, *(mr
->rdParam
+ 3), *(mr
->rdParam
+ 2),
494 *(mr
->rdParam
+ 1), *(mr
->rdParam
));
498 Arc(hdc
, *(mr
->rdParam
+ 7), *(mr
->rdParam
+ 6), *(mr
->rdParam
+ 5),
499 *(mr
->rdParam
+ 4), *(mr
->rdParam
+ 3), *(mr
->rdParam
+ 2),
500 *(mr
->rdParam
+ 1), *(mr
->rdParam
));
504 Ellipse(hdc
, *(mr
->rdParam
+ 3), *(mr
->rdParam
+ 2),
505 *(mr
->rdParam
+ 1), *(mr
->rdParam
));
509 FloodFill(hdc
, *(mr
->rdParam
+ 3), *(mr
->rdParam
+ 2),
510 MAKELONG(*(mr
->rdParam
+ 1), *(mr
->rdParam
)));
514 Pie(hdc
, *(mr
->rdParam
+ 7), *(mr
->rdParam
+ 6), *(mr
->rdParam
+ 5),
515 *(mr
->rdParam
+ 4), *(mr
->rdParam
+ 3), *(mr
->rdParam
+ 2),
516 *(mr
->rdParam
+ 1), *(mr
->rdParam
));
520 Rectangle(hdc
, *(mr
->rdParam
+ 3), *(mr
->rdParam
+ 2),
521 *(mr
->rdParam
+ 1), *(mr
->rdParam
));
525 RoundRect(hdc
, *(mr
->rdParam
+ 5), *(mr
->rdParam
+ 4),
526 *(mr
->rdParam
+ 3), *(mr
->rdParam
+ 2),
527 *(mr
->rdParam
+ 1), *(mr
->rdParam
));
531 PatBlt(hdc
, *(mr
->rdParam
+ 5), *(mr
->rdParam
+ 4),
532 *(mr
->rdParam
+ 3), *(mr
->rdParam
+ 2),
533 MAKELONG(*(mr
->rdParam
), *(mr
->rdParam
+ 1)));
541 SetPixel(hdc
, *(mr
->rdParam
+ 3), *(mr
->rdParam
+ 2),
542 MAKELONG(*(mr
->rdParam
+ 1), *(mr
->rdParam
)));
545 case META_OFFSETCLIPRGN
:
546 OffsetClipRgn(hdc
, *(mr
->rdParam
+ 1), *(mr
->rdParam
));
551 TextOut16(hdc
, *(mr
->rdParam
+ ((s1
+ 1) >> 1) + 2),
552 *(mr
->rdParam
+ ((s1
+ 1) >> 1) + 1),
553 (char *)(mr
->rdParam
+ 1), s1
);
557 Polygon16(hdc
, (LPPOINT16
)(mr
->rdParam
+ 1), *(mr
->rdParam
));
560 case META_POLYPOLYGON
:
561 PolyPolygon16(hdc
, (LPPOINT16
)(mr
->rdParam
+ *(mr
->rdParam
) + 1),
562 (LPINT16
)(mr
->rdParam
+ 1), *(mr
->rdParam
));
566 Polyline16(hdc
, (LPPOINT16
)(mr
->rdParam
+ 1), *(mr
->rdParam
));
570 RestoreDC(hdc
, *(mr
->rdParam
));
573 case META_SELECTOBJECT
:
574 SelectObject(hdc
, *(ht
->objectHandle
+ *(mr
->rdParam
)));
578 Chord(hdc
, *(mr
->rdParam
+ 7), *(mr
->rdParam
+ 6), *(mr
->rdParam
+ 5),
579 *(mr
->rdParam
+ 4), *(mr
->rdParam
+ 3), *(mr
->rdParam
+ 2),
580 *(mr
->rdParam
+ 1), *(mr
->rdParam
));
583 case META_CREATEPATTERNBRUSH
:
584 switch (*(mr
->rdParam
))
587 infohdr
= (BITMAPINFOHEADER
*)(mr
->rdParam
+ 2);
588 MF_AddHandle(ht
, nHandles
,
589 CreatePatternBrush(CreateBitmap(infohdr
->biWidth
,
593 (LPSTR
)(mr
->rdParam
+
594 (sizeof(BITMAPINFOHEADER
) / 2) + 4))));
598 s1
= mr
->rdSize
* 2 - sizeof(METARECORD
) - 2;
599 hndl
= GlobalAlloc16(GMEM_MOVEABLE
, s1
);
600 ptr
= GlobalLock16(hndl
);
601 memcpy(ptr
, mr
->rdParam
+ 2, s1
);
602 GlobalUnlock16(hndl
);
603 MF_AddHandle(ht
, nHandles
,
604 CreateDIBPatternBrush(hndl
, *(mr
->rdParam
+ 1)));
609 case META_CREATEPENINDIRECT
:
610 MF_AddHandle(ht
, nHandles
,
611 CreatePenIndirect((LOGPEN16
*)(&(mr
->rdParam
))));
614 case META_CREATEFONTINDIRECT
:
615 MF_AddHandle(ht
, nHandles
,
616 CreateFontIndirect16((LOGFONT16
*)(&(mr
->rdParam
))));
619 case META_CREATEBRUSHINDIRECT
:
620 MF_AddHandle(ht
, nHandles
,
621 CreateBrushIndirect((LOGBRUSH16
*)(&(mr
->rdParam
))));
624 /* W. Magro: Some new metafile operations. Not all debugged. */
625 case META_CREATEPALETTE
:
626 MF_AddHandle(ht
, nHandles
,
627 CreatePalette((LPLOGPALETTE
)mr
->rdParam
));
630 case META_SETTEXTALIGN
:
631 SetTextAlign(hdc
, *(mr
->rdParam
));
634 case META_SELECTPALETTE
:
635 SelectPalette(hdc
, *(ht
->objectHandle
+ *(mr
->rdParam
+1)),*(mr
->rdParam
));
638 case META_SETMAPPERFLAGS
:
639 SetMapperFlags(hdc
, *(mr
->rdParam
));
642 case META_REALIZEPALETTE
:
647 dprintf_metafile(stddeb
,"PlayMetaFileRecord: META_ESCAPE unimplemented.\n");
650 /* --- Begin of fixed or new metafile operations. July 1996 ----*/
651 case META_EXTTEXTOUT
:
654 s1
=mr
->rdParam
[2]; /* String length */
655 if (mr
->rdSize
-(s1
+1))
656 dxx
=&mr
->rdParam
[8+(s1
+1)/2]; /* start of array */
658 dxx
=NULL
; /* NO array present */
660 ExtTextOut16( hdc
, mr
->rdParam
[1], /* X position */
661 mr
->rdParam
[0], /* Y position */
662 mr
->rdParam
[3], /* options */
663 (LPRECT16
) &mr
->rdParam
[4], /* rectangle */
664 (char *)(mr
->rdParam
+ 8), /* string */
665 s1
, dxx
); /* length, dx array */
667 dprintf_metafile(stddeb
,"EXTTEXTOUT len: %ld (%hd %hd) [%s].\n",
668 mr
->rdSize
,dxx
[0],dxx
[1],(char*) &(mr
->rdParam
[8]) );
672 case META_STRETCHDIB
:
674 LPBITMAPINFO info
= (LPBITMAPINFO
) &(mr
->rdParam
[11]);
675 LPSTR bits
= MF_GetDIBitsPointer(info
);
677 StretchDIBits(hdc
,mr
->rdParam
[10],mr
->rdParam
[9],mr
->rdParam
[8],
678 mr
->rdParam
[7],mr
->rdParam
[6],mr
->rdParam
[5],
679 mr
->rdParam
[4],mr
->rdParam
[3],bits
,info
,
680 mr
->rdParam
[2],MAKELONG(mr
->rdParam
[0],mr
->rdParam
[1]));
684 case META_DIBSTRETCHBLT
:
686 LPBITMAPINFO info
= (LPBITMAPINFO
) &(mr
->rdParam
[10]);
687 LPSTR bits
= MF_GetDIBitsPointer(info
);
689 StretchDIBits(hdc
,mr
->rdParam
[9],mr
->rdParam
[8],mr
->rdParam
[7],
690 mr
->rdParam
[6],mr
->rdParam
[5],mr
->rdParam
[4],
691 mr
->rdParam
[3],mr
->rdParam
[2],bits
,info
,
692 DIB_RGB_COLORS
,MAKELONG(mr
->rdParam
[0],mr
->rdParam
[1]));
696 case META_STRETCHBLT
:
698 HDC hdcSrc
=CreateCompatibleDC(hdc
);
699 HBITMAP16 hbitmap
=CreateBitmap(mr
->rdParam
[10], /*Width */
700 mr
->rdParam
[11], /*Height*/
701 mr
->rdParam
[13], /*Planes*/
702 mr
->rdParam
[14], /*BitsPixel*/
703 (LPSTR
)&mr
->rdParam
[15]); /*bits*/
704 SelectObject(hdcSrc
,hbitmap
);
705 StretchBlt(hdc
,mr
->rdParam
[9],mr
->rdParam
[8],
706 mr
->rdParam
[7],mr
->rdParam
[6],
707 hdcSrc
,mr
->rdParam
[5],mr
->rdParam
[4],
708 mr
->rdParam
[3],mr
->rdParam
[2],
709 MAKELONG(mr
->rdParam
[0],mr
->rdParam
[1]));
714 case META_BITBLT
: /* <-- not yet debugged */
716 HDC hdcSrc
=CreateCompatibleDC(hdc
);
717 HBITMAP16 hbitmap
=CreateBitmap(mr
->rdParam
[7]/*Width */,mr
->rdParam
[8]/*Height*/,
718 mr
->rdParam
[10]/*Planes*/,mr
->rdParam
[11]/*BitsPixel*/,
719 (LPSTR
)&mr
->rdParam
[12]/*bits*/);
720 SelectObject(hdcSrc
,hbitmap
);
721 BitBlt(hdc
,mr
->rdParam
[6],mr
->rdParam
[5],
722 mr
->rdParam
[4],mr
->rdParam
[3],
724 mr
->rdParam
[2],mr
->rdParam
[1],
725 MAKELONG(0,mr
->rdParam
[0]));
731 fprintf(stddeb
,"PlayMetaFileRecord: Unknown record type %x\n",
737 /******************************************************************
738 * GetMetaFileBits by William Magro, 19 Sep 1995
740 * Trade in a meta file object handle for a handle to the meta file memory
743 HANDLE
GetMetaFileBits(HMETAFILE hmf
)
745 dprintf_metafile(stddeb
,"GetMetaFileBits: hMem out: %04x\n", hmf
);
750 /******************************************************************
751 * SetMetaFileBits by William Magro, 19 Sep 1995
753 * Trade in a meta file memory handle for a handle to a meta file object
756 HMETAFILE
SetMetaFileBits(HANDLE hMem
)
758 dprintf_metafile(stddeb
,"SetMetaFileBits: hmf out: %04x\n", hMem
);
763 /******************************************************************
767 HMETAFILE
MF_WriteRecord(HMETAFILE hmf
, METARECORD
*mr
, WORD rlen
)
770 METAHEADER
*mh
= (METAHEADER
*)GlobalLock16(hmf
);
772 if (mh
->mtType
== 0) /* memory based metafile */
774 len
= mh
->mtSize
* 2 + rlen
;
776 hmf
= GlobalReAlloc16(hmf
, len
, GMEM_MOVEABLE
); /* hmf can change */
777 mh
= (METAHEADER
*)GlobalLock16(hmf
);
778 memcpy((WORD
*)mh
+ mh
->mtSize
, mr
, rlen
);
780 else if (mh
->mtType
== 1) /* disk based metafile */
782 dprintf_metafile(stddeb
,"Writing record to disk\n");
783 if (_lwrite(mh
->mtNoParameters
, (char *)mr
, rlen
) == -1)
795 mh
->mtSize
+= rlen
/ 2;
796 mh
->mtMaxRecord
= MAX(mh
->mtMaxRecord
, rlen
/ 2);
802 /******************************************************************
805 * Add a handle to an external handle table and return the index
808 int MF_AddHandle(HANDLETABLE16
*ht
, WORD htlen
, HANDLE hobj
)
812 for (i
= 0; i
< htlen
; i
++)
814 if (*(ht
->objectHandle
+ i
) == 0)
816 *(ht
->objectHandle
+ i
) = hobj
;
824 /******************************************************************
825 * MF_AddHandleInternal
827 * Add a handle to the internal handle table and return the index
830 int MF_AddHandleInternal(HANDLE hobj
)
833 HANDLETABLE16
*ht
= (HANDLETABLE16
*)GlobalLock16(hHT
);
835 for (i
= 0; i
< HTLen
; i
++)
837 if (*(ht
->objectHandle
+ i
) == 0)
839 *(ht
->objectHandle
+ i
) = hobj
;
845 if (!(hHT
= GlobalReAlloc16(hHT
, HTINCR
, GMEM_MOVEABLE
| GMEM_ZEROINIT
)))
848 ht
= (HANDLETABLE16
*)GlobalLock16(hHT
);
849 *(ht
->objectHandle
+ i
) = hobj
;
855 /******************************************************************
859 BOOL
MF_MetaParam0(DC
*dc
, short func
)
862 METARECORD
*mr
= (METARECORD
*)&buffer
;
866 mr
->rdFunction
= func
;
867 handle
= MF_WriteRecord(dc
->w
.hMetaFile
, mr
, mr
->rdSize
* 2);
868 dc
->w
.hMetaFile
= handle
;
874 /******************************************************************
877 BOOL
MF_MetaParam1(DC
*dc
, short func
, short param1
)
880 METARECORD
*mr
= (METARECORD
*)&buffer
;
884 mr
->rdFunction
= func
;
885 *(mr
->rdParam
) = param1
;
886 handle
= MF_WriteRecord(dc
->w
.hMetaFile
, mr
, mr
->rdSize
* 2);
887 dc
->w
.hMetaFile
= handle
;
893 /******************************************************************
896 BOOL
MF_MetaParam2(DC
*dc
, short func
, short param1
, short param2
)
899 METARECORD
*mr
= (METARECORD
*)&buffer
;
903 mr
->rdFunction
= func
;
904 *(mr
->rdParam
) = param2
;
905 *(mr
->rdParam
+ 1) = param1
;
906 handle
= MF_WriteRecord(dc
->w
.hMetaFile
, mr
, mr
->rdSize
* 2);
907 dc
->w
.hMetaFile
= handle
;
913 /******************************************************************
917 BOOL
MF_MetaParam4(DC
*dc
, short func
, short param1
, short param2
,
918 short param3
, short param4
)
921 METARECORD
*mr
= (METARECORD
*)&buffer
;
925 mr
->rdFunction
= func
;
926 *(mr
->rdParam
) = param4
;
927 *(mr
->rdParam
+ 1) = param3
;
928 *(mr
->rdParam
+ 2) = param2
;
929 *(mr
->rdParam
+ 3) = param1
;
930 handle
= MF_WriteRecord(dc
->w
.hMetaFile
, mr
, mr
->rdSize
* 2);
931 dc
->w
.hMetaFile
= handle
;
937 /******************************************************************
941 BOOL
MF_MetaParam6(DC
*dc
, short func
, short param1
, short param2
,
942 short param3
, short param4
, short param5
, short param6
)
945 METARECORD
*mr
= (METARECORD
*)&buffer
;
949 mr
->rdFunction
= func
;
950 *(mr
->rdParam
) = param6
;
951 *(mr
->rdParam
+ 1) = param5
;
952 *(mr
->rdParam
+ 2) = param4
;
953 *(mr
->rdParam
+ 3) = param3
;
954 *(mr
->rdParam
+ 4) = param2
;
955 *(mr
->rdParam
+ 5) = param1
;
956 handle
= MF_WriteRecord(dc
->w
.hMetaFile
, mr
, mr
->rdSize
* 2);
957 dc
->w
.hMetaFile
= handle
;
963 /******************************************************************
966 BOOL
MF_MetaParam8(DC
*dc
, short func
, short param1
, short param2
,
967 short param3
, short param4
, short param5
,
968 short param6
, short param7
, short param8
)
971 METARECORD
*mr
= (METARECORD
*)&buffer
;
975 mr
->rdFunction
= func
;
976 *(mr
->rdParam
) = param8
;
977 *(mr
->rdParam
+ 1) = param7
;
978 *(mr
->rdParam
+ 2) = param6
;
979 *(mr
->rdParam
+ 3) = param5
;
980 *(mr
->rdParam
+ 4) = param4
;
981 *(mr
->rdParam
+ 5) = param3
;
982 *(mr
->rdParam
+ 6) = param2
;
983 *(mr
->rdParam
+ 7) = param1
;
984 handle
= MF_WriteRecord(dc
->w
.hMetaFile
, mr
, mr
->rdSize
* 2);
985 dc
->w
.hMetaFile
= handle
;
991 /******************************************************************
992 * MF_CreateBrushIndirect
995 BOOL
MF_CreateBrushIndirect(DC
*dc
, HBRUSH hBrush
, LOGBRUSH16
*logbrush
)
999 char buffer
[sizeof(METARECORD
) - 2 + sizeof(LOGBRUSH16
)];
1000 METARECORD
*mr
= (METARECORD
*)&buffer
;
1003 mr
->rdSize
= (sizeof(METARECORD
) + sizeof(LOGBRUSH16
) - 2) / 2;
1004 mr
->rdFunction
= META_CREATEBRUSHINDIRECT
;
1005 memcpy(&(mr
->rdParam
), logbrush
, sizeof(LOGBRUSH16
));
1006 if (!(dc
->w
.hMetaFile
= MF_WriteRecord(dc
->w
.hMetaFile
,
1007 mr
, mr
->rdSize
* 2)))
1010 mr
->rdSize
= sizeof(METARECORD
) / 2;
1011 mr
->rdFunction
= META_SELECTOBJECT
;
1013 if ((index
= MF_AddHandleInternal(hBrush
)) == -1)
1016 mh
= (METAHEADER
*)GlobalLock16(dc
->w
.hMetaFile
);
1017 *(mr
->rdParam
) = index
;
1018 if (index
>= mh
->mtNoObjects
)
1021 GlobalUnlock16(dc
->w
.hMetaFile
);
1022 handle
= MF_WriteRecord(dc
->w
.hMetaFile
, mr
, mr
->rdSize
* 2);
1023 dc
->w
.hMetaFile
= handle
;
1029 /******************************************************************
1030 * MF_CreatePatternBrush
1033 BOOL
MF_CreatePatternBrush(DC
*dc
, HBRUSH hBrush
, LOGBRUSH16
*logbrush
)
1035 DWORD len
, bmSize
, biSize
;
1040 BITMAPINFOHEADER
*infohdr
;
1043 char buffer
[sizeof(METARECORD
)];
1046 switch (logbrush
->lbStyle
)
1049 bmp
= (BITMAPOBJ
*)GDI_GetObjPtr((HANDLE
)logbrush
->lbHatch
, BITMAP_MAGIC
);
1050 if (!bmp
) return FALSE
;
1051 len
= sizeof(METARECORD
) + sizeof(BITMAPINFOHEADER
) +
1052 (bmp
->bitmap
.bmHeight
* bmp
->bitmap
.bmWidthBytes
) + 6;
1053 if (!(hmr
= GlobalAlloc16(GMEM_MOVEABLE
, len
)))
1055 mr
= (METARECORD
*)GlobalLock16(hmr
);
1057 mr
->rdFunction
= META_DIBCREATEPATTERNBRUSH
;
1058 mr
->rdSize
= len
/ 2;
1059 *(mr
->rdParam
) = logbrush
->lbStyle
;
1060 *(mr
->rdParam
+ 1) = DIB_RGB_COLORS
;
1061 infohdr
= (BITMAPINFOHEADER
*)(mr
->rdParam
+ 2);
1062 infohdr
->biSize
= sizeof(BITMAPINFOHEADER
);
1063 infohdr
->biWidth
= bmp
->bitmap
.bmWidth
;
1064 infohdr
->biHeight
= bmp
->bitmap
.bmHeight
;
1065 infohdr
->biPlanes
= bmp
->bitmap
.bmPlanes
;
1066 infohdr
->biBitCount
= bmp
->bitmap
.bmBitsPixel
;
1067 memcpy(mr
->rdParam
+ (sizeof(BITMAPINFOHEADER
) / 2) + 4,
1068 PTR_SEG_TO_LIN(bmp
->bitmap
.bmBits
),
1069 bmp
->bitmap
.bmHeight
* bmp
->bitmap
.bmWidthBytes
);
1073 info
= (BITMAPINFO
*)GlobalLock16((HANDLE
)logbrush
->lbHatch
);
1074 if (info
->bmiHeader
.biCompression
)
1075 bmSize
= info
->bmiHeader
.biSizeImage
;
1077 bmSize
= (info
->bmiHeader
.biWidth
* info
->bmiHeader
.biBitCount
1078 + 31) / 32 * 8 * info
->bmiHeader
.biHeight
;
1079 biSize
= DIB_BitmapInfoSize(info
, LOWORD(logbrush
->lbColor
));
1080 len
= sizeof(METARECORD
) + biSize
+ bmSize
+ 2;
1081 if (!(hmr
= GlobalAlloc16(GMEM_MOVEABLE
, len
)))
1083 mr
= (METARECORD
*)GlobalLock16(hmr
);
1085 mr
->rdFunction
= META_DIBCREATEPATTERNBRUSH
;
1086 mr
->rdSize
= len
/ 2;
1087 *(mr
->rdParam
) = logbrush
->lbStyle
;
1088 *(mr
->rdParam
+ 1) = LOWORD(logbrush
->lbColor
);
1089 memcpy(mr
->rdParam
+ 2, info
, biSize
+ bmSize
);
1094 if (!(dc
->w
.hMetaFile
= MF_WriteRecord(dc
->w
.hMetaFile
, mr
, len
)))
1102 mr
= (METARECORD
*)&buffer
;
1103 mr
->rdSize
= sizeof(METARECORD
) / 2;
1104 mr
->rdFunction
= META_SELECTOBJECT
;
1105 if ((index
= MF_AddHandleInternal(hBrush
)) == -1)
1108 mh
= (METAHEADER
*)GlobalLock16(dc
->w
.hMetaFile
);
1109 *(mr
->rdParam
) = index
;
1110 if (index
>= mh
->mtNoObjects
)
1112 GlobalUnlock16(dc
->w
.hMetaFile
);
1113 handle
= MF_WriteRecord(dc
->w
.hMetaFile
, mr
, mr
->rdSize
* 2);
1114 dc
->w
.hMetaFile
= handle
;
1120 /******************************************************************
1121 * MF_CreatePenIndirect
1124 BOOL
MF_CreatePenIndirect(DC
*dc
, HPEN16 hPen
, LOGPEN16
*logpen
)
1128 char buffer
[sizeof(METARECORD
) - 2 + sizeof(LOGPEN16
)];
1129 METARECORD
*mr
= (METARECORD
*)&buffer
;
1132 mr
->rdSize
= (sizeof(METARECORD
) + sizeof(LOGPEN16
) - 2) / 2;
1133 mr
->rdFunction
= META_CREATEPENINDIRECT
;
1134 memcpy(&(mr
->rdParam
), logpen
, sizeof(LOGPEN16
));
1135 if (!(dc
->w
.hMetaFile
= MF_WriteRecord(dc
->w
.hMetaFile
, mr
,
1139 mr
->rdSize
= sizeof(METARECORD
) / 2;
1140 mr
->rdFunction
= META_SELECTOBJECT
;
1142 if ((index
= MF_AddHandleInternal(hPen
)) == -1)
1145 mh
= (METAHEADER
*)GlobalLock16(dc
->w
.hMetaFile
);
1146 *(mr
->rdParam
) = index
;
1147 if (index
>= mh
->mtNoObjects
)
1149 GlobalUnlock16(dc
->w
.hMetaFile
);
1150 handle
= MF_WriteRecord(dc
->w
.hMetaFile
, mr
, mr
->rdSize
* 2);
1151 dc
->w
.hMetaFile
= handle
;
1157 /******************************************************************
1158 * MF_CreateFontIndirect
1161 BOOL
MF_CreateFontIndirect(DC
*dc
, HFONT hFont
, LOGFONT16
*logfont
)
1165 char buffer
[sizeof(METARECORD
) - 2 + sizeof(LOGFONT16
)];
1166 METARECORD
*mr
= (METARECORD
*)&buffer
;
1169 mr
->rdSize
= (sizeof(METARECORD
) + sizeof(LOGFONT16
) - 2) / 2;
1170 mr
->rdFunction
= META_CREATEFONTINDIRECT
;
1171 memcpy(&(mr
->rdParam
), logfont
, sizeof(LOGFONT16
));
1172 if (!(dc
->w
.hMetaFile
= MF_WriteRecord(dc
->w
.hMetaFile
, mr
,
1176 mr
->rdSize
= sizeof(METARECORD
) / 2;
1177 mr
->rdFunction
= META_SELECTOBJECT
;
1179 if ((index
= MF_AddHandleInternal(hFont
)) == -1)
1182 mh
= (METAHEADER
*)GlobalLock16(dc
->w
.hMetaFile
);
1183 *(mr
->rdParam
) = index
;
1184 if (index
>= mh
->mtNoObjects
)
1186 GlobalUnlock16(dc
->w
.hMetaFile
);
1187 handle
= MF_WriteRecord(dc
->w
.hMetaFile
, mr
, mr
->rdSize
* 2);
1188 dc
->w
.hMetaFile
= handle
;
1194 /******************************************************************
1197 BOOL
MF_TextOut(DC
*dc
, short x
, short y
, LPCSTR str
, short count
)
1204 len
= sizeof(METARECORD
) + (((count
+ 1) >> 1) * 2) + 4;
1205 if (!(hmr
= GlobalAlloc16(GMEM_MOVEABLE
, len
)))
1207 mr
= (METARECORD
*)GlobalLock16(hmr
);
1210 mr
->rdSize
= len
/ 2;
1211 mr
->rdFunction
= META_TEXTOUT
;
1212 *(mr
->rdParam
) = count
;
1213 memcpy(mr
->rdParam
+ 1, str
, count
);
1214 *(mr
->rdParam
+ ((count
+ 1) >> 1) + 1) = y
;
1215 *(mr
->rdParam
+ ((count
+ 1) >> 1) + 2) = x
;
1216 handle
= MF_WriteRecord(dc
->w
.hMetaFile
, mr
, mr
->rdSize
* 2);
1217 dc
->w
.hMetaFile
= handle
;
1222 /******************************************************************
1225 BOOL
MF_ExtTextOut(DC
*dc
, short x
, short y
, UINT16 flags
, const RECT16
*rect
,
1226 LPCSTR str
, short count
, const INT16
*lpDx
)
1233 len
= sizeof(METARECORD
) + (((count
+ 1) >> 1) * 2) + 4 + sizeof(RECT16
);
1235 len
+=count
*sizeof(INT16
);
1236 if (!(hmr
= GlobalAlloc16(GMEM_MOVEABLE
, len
)))
1238 mr
= (METARECORD
*)GlobalLock16(hmr
);
1241 mr
->rdSize
= len
/ 2;
1242 mr
->rdFunction
= META_EXTTEXTOUT
;
1244 *(mr
->rdParam
+ 1) = x
;
1245 *(mr
->rdParam
+ 2) = count
;
1246 *(mr
->rdParam
+ 3) = flags
;
1247 memcpy(mr
->rdParam
+ 4, rect
, sizeof(RECT16
));
1248 memcpy(mr
->rdParam
+ 8, str
, count
);
1250 memcpy(mr
->rdParam
+ 8+ ((count
+ 1) >> 1),lpDx
,count
*sizeof(INT16
));
1251 handle
= MF_WriteRecord(dc
->w
.hMetaFile
, mr
, mr
->rdSize
* 2);
1252 dc
->w
.hMetaFile
= handle
;
1257 /******************************************************************
1258 * MF_MetaPoly - implements Polygon and Polyline
1260 BOOL
MF_MetaPoly(DC
*dc
, short func
, LPPOINT16 pt
, short count
)
1267 len
= sizeof(METARECORD
) + (count
* 4);
1268 if (!(hmr
= GlobalAlloc16(GMEM_MOVEABLE
, len
)))
1270 mr
= (METARECORD
*)GlobalLock16(hmr
);
1273 mr
->rdSize
= len
/ 2;
1274 mr
->rdFunction
= func
;
1275 *(mr
->rdParam
) = count
;
1276 memcpy(mr
->rdParam
+ 1, pt
, count
* 4);
1277 handle
= MF_WriteRecord(dc
->w
.hMetaFile
, mr
, mr
->rdSize
* 2);
1278 dc
->w
.hMetaFile
= handle
;
1284 /******************************************************************
1287 BOOL
MF_BitBlt(DC
*dcDest
, short xDest
, short yDest
, short width
,
1288 short height
, HDC hdcSrc
, short xSrc
, short ySrc
, DWORD rop
)
1297 if (!(dcSrc
= (DC
*) GDI_GetObjPtr( hdcSrc
, DC_MAGIC
))) return 0;
1298 GetObject16(dcSrc
->w
.hBitmap
, sizeof(BITMAP16
), &BM
);
1299 len
= sizeof(METARECORD
) + 12 * sizeof(INT16
) + BM
.bmWidthBytes
* BM
.bmHeight
;
1300 if (!(hmr
= GlobalAlloc16(GMEM_MOVEABLE
, len
)))
1302 mr
= (METARECORD
*)GlobalLock16(hmr
);
1303 mr
->rdFunction
= META_BITBLT
;
1304 *(mr
->rdParam
+ 7) = BM
.bmWidth
;
1305 *(mr
->rdParam
+ 8) = BM
.bmHeight
;
1306 *(mr
->rdParam
+ 9) = BM
.bmWidthBytes
;
1307 *(mr
->rdParam
+10) = BM
.bmPlanes
;
1308 *(mr
->rdParam
+11) = BM
.bmBitsPixel
;
1309 dprintf_metafile(stddeb
,"MF_StretchBlt->len = %ld rop=%lx \n",len
,rop
);
1310 if (GetBitmapBits(dcSrc
->w
.hBitmap
,BM
.bmWidthBytes
* BM
.bmHeight
,mr
->rdParam
+12))
1312 mr
->rdSize
= len
/ sizeof(INT16
);
1313 *(mr
->rdParam
) = HIWORD(rop
);
1314 *(mr
->rdParam
+ 1) = ySrc
;
1315 *(mr
->rdParam
+ 2) = xSrc
;
1316 *(mr
->rdParam
+ 3) = height
;
1317 *(mr
->rdParam
+ 4) = width
;
1318 *(mr
->rdParam
+ 5) = yDest
;
1319 *(mr
->rdParam
+ 6) = xDest
;
1320 handle
= MF_WriteRecord(dcDest
->w
.hMetaFile
, mr
, mr
->rdSize
* 2);
1324 dcDest
->w
.hMetaFile
= handle
;
1330 /**********************************************************************
1332 * this function contains TWO ways for procesing StretchBlt in metafiles,
1333 * decide between rdFunction values META_STRETCHBLT or META_DIBSTRETCHBLT
1334 * via #define STRETCH_VIA_DIB
1336 #define STRETCH_VIA_DIB
1337 #undef STRETCH_VIA_DIB
1338 BOOL
MF_StretchBlt(DC
*dcDest
, short xDest
, short yDest
, short widthDest
,
1339 short heightDest
, HDC hdcSrc
, short xSrc
, short ySrc
,
1340 short widthSrc
, short heightSrc
, DWORD rop
)
1348 #ifdef STRETCH_VIA_DIB
1349 LPBITMAPINFOHEADER lpBMI
;
1352 if (!(dcSrc
= (DC
*) GDI_GetObjPtr( hdcSrc
, DC_MAGIC
))) return 0;
1353 GetObject16(dcSrc
->w
.hBitmap
, sizeof(BITMAP16
), &BM
);
1354 #ifdef STRETCH_VIA_DIB
1355 nBPP
= BM
.bmPlanes
* BM
.bmBitsPixel
;
1356 len
= sizeof(METARECORD
) + 10 * sizeof(INT16
)
1357 + sizeof(BITMAPINFOHEADER
) + (nBPP
!= 24 ? 1 << nBPP
: 0) * sizeof(RGBQUAD
)
1358 + ((BM
.bmWidth
* nBPP
+ 31) / 32) * 4 * BM
.bmHeight
;
1359 if (!(hmr
= GlobalAlloc16(GMEM_MOVEABLE
, len
)))
1361 mr
= (METARECORD
*)GlobalLock16(hmr
);
1362 mr
->rdFunction
= META_DIBSTRETCHBLT
;
1363 lpBMI
=(LPBITMAPINFOHEADER
)(mr
->rdParam
+10);
1364 lpBMI
->biSize
= sizeof(BITMAPINFOHEADER
);
1365 lpBMI
->biWidth
= BM
.bmWidth
;
1366 lpBMI
->biHeight
= BM
.bmHeight
;
1367 lpBMI
->biPlanes
= 1;
1368 lpBMI
->biBitCount
= nBPP
; /* 1,4,8 or 24 */
1369 lpBMI
->biClrUsed
= nBPP
!= 24 ? 1 << nBPP
: 0;
1370 lpBMI
->biSizeImage
= ((lpBMI
->biWidth
* nBPP
+ 31) / 32) * 4 * lpBMI
->biHeight
;
1371 lpBMI
->biCompression
= BI_RGB
;
1372 lpBMI
->biXPelsPerMeter
= MulDiv32(GetDeviceCaps(hdcSrc
,LOGPIXELSX
),3937,100);
1373 lpBMI
->biYPelsPerMeter
= MulDiv32(GetDeviceCaps(hdcSrc
,LOGPIXELSY
),3937,100);
1374 lpBMI
->biClrImportant
= 0; /* 1 meter = 39.37 inch */
1376 dprintf_metafile(stddeb
,"MF_StretchBltViaDIB->len = %ld rop=%lx PixYPM=%ld Caps=%d\n",
1377 len
,rop
,lpBMI
->biYPelsPerMeter
,GetDeviceCaps(hdcSrc
,LOGPIXELSY
));
1378 if (GetDIBits(hdcSrc
,dcSrc
->w
.hBitmap
,0,(UINT
)lpBMI
->biHeight
,
1379 MF_GetDIBitsPointer((LPBITMAPINFO
)lpBMI
), /* DIB bits */
1380 (LPBITMAPINFO
)lpBMI
,DIB_RGB_COLORS
)) /* DIB info structure */
1382 len
= sizeof(METARECORD
) + 15 * sizeof(INT16
) + BM
.bmWidthBytes
* BM
.bmHeight
;
1383 if (!(hmr
= GlobalAlloc16(GMEM_MOVEABLE
, len
)))
1385 mr
= (METARECORD
*)GlobalLock16(hmr
);
1386 mr
->rdFunction
= META_STRETCHBLT
;
1387 *(mr
->rdParam
+10) = BM
.bmWidth
;
1388 *(mr
->rdParam
+11) = BM
.bmHeight
;
1389 *(mr
->rdParam
+12) = BM
.bmWidthBytes
;
1390 *(mr
->rdParam
+13) = BM
.bmPlanes
;
1391 *(mr
->rdParam
+14) = BM
.bmBitsPixel
;
1392 dprintf_metafile(stddeb
,"MF_StretchBlt->len = %ld rop=%lx \n",len
,rop
);
1393 if (GetBitmapBits(dcSrc
->w
.hBitmap
,BM
.bmWidthBytes
* BM
.bmHeight
,mr
->rdParam
+15))
1396 mr
->rdSize
= len
/ sizeof(INT16
);
1397 *(mr
->rdParam
) = LOWORD(rop
);
1398 *(mr
->rdParam
+ 1) = HIWORD(rop
);
1399 *(mr
->rdParam
+ 2) = heightSrc
;
1400 *(mr
->rdParam
+ 3) = widthSrc
;
1401 *(mr
->rdParam
+ 4) = ySrc
;
1402 *(mr
->rdParam
+ 5) = xSrc
;
1403 *(mr
->rdParam
+ 6) = heightDest
;
1404 *(mr
->rdParam
+ 7) = widthDest
;
1405 *(mr
->rdParam
+ 8) = yDest
;
1406 *(mr
->rdParam
+ 9) = xDest
;
1407 handle
= MF_WriteRecord(dcDest
->w
.hMetaFile
, mr
, mr
->rdSize
* 2);
1411 dcDest
->w
.hMetaFile
= handle
;