?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 970112
[wine.git] / objects / metafile.c
blobc7ee25d0ca6326274fcd09e8adf9e9e7ab2513c2
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 "gdi.h"
12 #include "bitmap.h"
13 #include "file.h"
14 #include "heap.h"
15 #include "metafile.h"
16 #include "metafiledrv.h"
17 #include "stddebug.h"
18 #include "debug.h"
19
20 /******************************************************************
21 * MF_AddHandle
22 *
23 * Add a handle to an external handle table and return the index
24 */
25
26 static int MF_AddHandle(HANDLETABLE16 *ht, WORD htlen, HGDIOBJ16 hobj)
27 {
28 int i;
29
30 for (i = 0; i < htlen; i++)
31 {
32 if (*(ht->objectHandle + i) == 0)
33 {
34 *(ht->objectHandle + i) = hobj;
35 return i;
36 }
37 }
38 return -1;
39 }
40
41
42 /******************************************************************
43 * MF_AddHandleDC
44 *
45 * Note: this function assumes that we never delete objects.
46 * If we do someday, we'll need to maintain a table to re-use deleted
47 * handles.
48 */
49 static int MF_AddHandleDC( DC *dc )
50 {
51 METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dc->physDev;
52 physDev->mh->mtNoObjects++;
53 return physDev->nextHandle++;
54 }
55
56
57 /******************************************************************
58 * GetMetafile GDI.124 By Kenny MacDonald 30 Nov 94
59 */
60
61 HMETAFILE16 GetMetaFile(LPSTR lpFilename)
62 {
63 HMETAFILE16 hmf;
64 METAHEADER *mh;
65 HFILE32 hFile;
66 DWORD size;
67
68 dprintf_metafile(stddeb,"GetMetaFile: %s\n", lpFilename);
69
70 if (!lpFilename)
71 return 0;
72
73 hmf = GlobalAlloc16(GMEM_MOVEABLE, MFHEADERSIZE);
74 mh = (METAHEADER *)GlobalLock16(hmf);
75
76 if (!mh) {
77 GlobalFree16(hmf);
78 return 0;
79 }
80
81 if ((hFile = _lopen32(lpFilename, OF_READ)) == HFILE_ERROR32) {
82 GlobalFree16(hmf);
83 return 0;
84 }
85
86 if (_lread32(hFile, (char *)mh, MFHEADERSIZE) == HFILE_ERROR32) {
87 GlobalFree16(hmf);
88 return 0;
89 }
90
91 size = mh->mtSize * 2; /* alloc memory for whole metafile */
92 GlobalUnlock16(hmf);
93 hmf = GlobalReAlloc16(hmf,size,GMEM_MOVEABLE);
94 mh = (METAHEADER *)GlobalLock16(hmf);
95
96 if (!mh) {
97 GlobalFree16(hmf);
98 return 0;
99 }
100
101 if (_lread32(hFile, (char*)mh + mh->mtHeaderSize * 2,
102 size - mh->mtHeaderSize * 2) == HFILE_ERROR32) {
103 GlobalFree16(hmf);
104 return 0;
105 }
106
107 _lclose32(hFile);
108
109 if (mh->mtType != 1) {
110 GlobalFree16(hmf);
111 return 0;
112 }
113
114 GlobalUnlock16(hmf);
115 return hmf;
116
117 }
118
119
120 /******************************************************************
121 * CopyMetafile GDI.151 Niels de Carpentier, April 1996
122 */
123
124 HMETAFILE16 CopyMetaFile(HMETAFILE16 hSrcMetaFile, LPCSTR lpFilename)
125 {
126 HMETAFILE16 handle = 0;
127 METAHEADER *mh;
128 METAHEADER *mh2;
129 HFILE32 hFile;
130
131 dprintf_metafile(stddeb,"CopyMetaFile: %s\n", lpFilename);
132
133 mh = (METAHEADER *)GlobalLock16(hSrcMetaFile);
134
135 if (!mh)
136 return 0;
137
138 if (lpFilename) /* disk based metafile */
139 {
140 int i,j;
141 hFile = _lcreat32(lpFilename, 0);
142 j=mh->mtType;
143 mh->mtType=1; /* disk file version stores 1 here */
144 i=_lwrite32(hFile, (char *)mh, mh->mtSize * 2) ;
145 mh->mtType=j; /* restore old value [0 or 1] */
146 _lclose32(hFile);
147 if (i == -1)
148 return 0;
149 }
150 else /* memory based metafile */
151 {
152 handle = GlobalAlloc16(GMEM_MOVEABLE,mh->mtSize * 2);
153 mh2 = (METAHEADER *)GlobalLock16(handle);
154 memcpy(mh2,mh, mh->mtSize * 2);
155 GlobalUnlock16(handle);
156 }
157
158 return handle;
159 }
160
161 /******************************************************************
162 * IsValidMetaFile (GDI.410)
163 * (This is not exactly what windows does, see "Undoc Win")
164 */
165
166 BOOL IsValidMetaFile(HMETAFILE16 hmf)
167 {
168 BOOL resu=FALSE;
169 METAHEADER *mh = (METAHEADER *)GlobalLock16(hmf);
170 if (mh) {
171 if (mh->mtType == 1 || mh->mtType == 0)
172 if (mh->mtHeaderSize == MFHEADERSIZE/sizeof(INT16))
173 if (mh->mtVersion == MFVERSION)
174 resu=TRUE;
175 GlobalUnlock16(hmf);
176 }
177 dprintf_metafile(stddeb,"IsValidMetaFile %x => %d\n",hmf,resu);
178 return resu;
179 }
180
181
182 #if 0
183 /******************************************************************
184 * CloseMetafile GDI.126
185 */
186
187 HMETAFILE16 CloseMetaFile(HDC16 hdc)
188 {
189 DC *dc;
190 METAHEADER *mh;
191 HMETAFILE16 hmf;
192 HFILE hFile;
193 METAFILEDRV_PDEVICE *physDev;
194
195 dprintf_metafile(stddeb,"CloseMetaFile\n");
196
197 if (!(dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC))) return 0;
198
199 physDev = (METAFILEDRV_PDEVICE *)dc->physDev;
200 mh = (METAHEADER *)GlobalLock16( physDev->hMetafile );
201
202 /* Construct the end of metafile record - this is documented
203 * in SDK Knowledgebase Q99334.
204 */
205
206 if (!MF_MetaParam0(dc, META_EOF))
207 {
208 DeleteDC32( hdc );
209 return 0;
210 }
211
212 if (mh->mtType == 1) /* disk based metafile */
213 {
214 hFile = mh->mtNoParameters;
215 mh->mtNoParameters = 0;
216 if (_llseek(hFile, 0L, 0) == -1)
217 {
218 DeleteDC32( hdc );
219 return 0;
220 }
221 if (_lwrite32(hFile, (char *)mh, MFHEADERSIZE) == -1)
222 {
223 DeleteDC32( hdc );
224 return 0;
225 }
226 _lclose(hFile);
227 }
228
229 hmf = physDev->hMetafile;
230 GlobalUnlock16( hmf );
231 physDev->hMetafile = 0; /* So it won't be deleted */
232 DeleteDC32( hdc );
233 return hmf;
234 }
235
236
237 /******************************************************************
238 * DeleteMetafile GDI.127
239 */
240
241 BOOL DeleteMetaFile(HMETAFILE16 hmf)
242 {
243 METAHEADER *mh = (METAHEADER *)GlobalLock16(hmf);
244
245 if (!mh)
246 return FALSE;
247
248 GlobalFree16(hmf);
249 return TRUE;
250 }
251 #endif
252
253 /******************************************************************
254 * PlayMetafile GDI.123
255 */
256
257 BOOL PlayMetaFile(HDC16 hdc, HMETAFILE16 hmf)
258 {
259 METAHEADER *mh = (METAHEADER *)GlobalLock16(hmf);
260 METARECORD *mr;
261 HANDLETABLE16 *ht;
262 HGLOBAL16 hHT;
263 int offset = 0;
264 WORD i;
265
266 dprintf_metafile(stddeb,"PlayMetaFile(%04x %04x)\n",hdc,hmf);
267
268 /* create the handle table */
269 hHT = GlobalAlloc16(GMEM_MOVEABLE|GMEM_ZEROINIT,
270 sizeof(HANDLETABLE16) * mh->mtNoObjects);
271 ht = (HANDLETABLE16 *)GlobalLock16(hHT);
272
273 /* loop through metafile playing records */
274 offset = mh->mtHeaderSize * 2;
275 while (offset < mh->mtSize * 2)
276 {
277 mr = (METARECORD *)((char *)mh + offset);
278 dprintf_metafile(stddeb,"offset = %04x size = %08lx function = %04x\n",
279 offset,mr->rdSize,mr->rdFunction);
280 offset += mr->rdSize * 2;
281 PlayMetaFileRecord(hdc, ht, mr, mh->mtNoObjects);
282 }
283
284 /* free objects in handle table */
285 for(i = 0; i < mh->mtNoObjects; i++)
286 if(*(ht->objectHandle + i) != 0)
287 DeleteObject32(*(ht->objectHandle + i));
288
289 /* free handle table */
290 GlobalFree16(hHT);
291
292 return TRUE;
293 }
294
295
296 /******************************************************************
297 * EnumMetafile GDI.175
298 * Niels de carpentier, april 1996
299 */
300
301 BOOL EnumMetaFile(HDC16 hdc, HMETAFILE16 hmf, MFENUMPROC16 lpEnumFunc,LPARAM lpData)
302 {
303 METAHEADER *mh = (METAHEADER *)GlobalLock16(hmf);
304 METARECORD *mr;
305 HGLOBAL16 hHT;
306 SEGPTR ht, spRecord;
307 int offset = 0;
308
309 dprintf_metafile(stddeb,"EnumMetaFile(%04x, %04x, %08lx, %08lx)\n",
310 hdc, hmf, (DWORD)lpEnumFunc, lpData);
311
312 /* create the handle table */
313
314 hHT = GlobalAlloc16(GMEM_MOVEABLE | GMEM_ZEROINIT,
315 sizeof(HANDLETABLE16) * mh->mtNoObjects);
316 ht = WIN16_GlobalLock16(hHT);
317
318 offset = mh->mtHeaderSize * 2;
319
320 /* loop through metafile records */
321
322 spRecord = WIN16_GlobalLock16(hmf);
323 while (offset < (mh->mtSize * 2))
324 {
325 mr = (METARECORD *)((char *)mh + offset);
326 if (!lpEnumFunc( hdc, (HANDLETABLE16 *)ht,
327 (METARECORD *)((UINT32)spRecord + offset),
328 mh->mtNoObjects, (LONG)lpData))
329 break;
330
331 offset += (mr->rdSize * 2);
332 }
333
334 /* free handle table */
335 GlobalFree16(hHT);
336
337 return TRUE;
338 }
339
340
341 /******************************************************************
342 * PlayMetaFileRecord GDI.176
343 */
344
345 void PlayMetaFileRecord(HDC16 hdc, HANDLETABLE16 *ht, METARECORD *mr,
346 WORD nHandles)
347 {
348 short s1;
349 HANDLE16 hndl;
350 char *ptr;
351 BITMAPINFOHEADER *infohdr;
352
353 dprintf_metafile(stddeb,"PlayMetaFileRecord(%04x %08lx %08lx %04x)\n",
354 hdc,(LONG)ht, (LONG)mr, nHandles);
355
356 switch (mr->rdFunction)
357 {
358 case META_EOF:
359 break;
360
361 case META_DELETEOBJECT:
362 DeleteObject32(*(ht->objectHandle + *(mr->rdParam)));
363 *(ht->objectHandle + *(mr->rdParam)) = 0;
364 break;
365
366 case META_SETBKCOLOR:
367 SetBkColor(hdc, *(mr->rdParam));
368 break;
369
370 case META_SETBKMODE:
371 SetBkMode16(hdc, *(mr->rdParam));
372 break;
373
374 case META_SETMAPMODE:
375 SetMapMode16(hdc, *(mr->rdParam));
376 break;
377
378 case META_SETROP2:
379 SetROP216(hdc, *(mr->rdParam));
380 break;
381
382 case META_SETRELABS:
383 SetRelAbs16(hdc, *(mr->rdParam));
384 break;
385
386 case META_SETPOLYFILLMODE:
387 SetPolyFillMode16(hdc, *(mr->rdParam));
388 break;
389
390 case META_SETSTRETCHBLTMODE:
391 SetStretchBltMode16(hdc, *(mr->rdParam));
392 break;
393 case META_SETTEXTCOLOR:
394 SetTextColor(hdc, MAKELONG(*(mr->rdParam), *(mr->rdParam + 1)));
395 break;
396
397 case META_SETWINDOWORG:
398 SetWindowOrg(hdc, *(mr->rdParam + 1), *(mr->rdParam));
399 break;
400
401 case META_SETWINDOWEXT:
402 SetWindowExt(hdc, *(mr->rdParam + 1), *(mr->rdParam));
403 break;
404
405 case META_SETVIEWPORTORG:
406 SetViewportOrg(hdc, *(mr->rdParam + 1), *(mr->rdParam));
407 break;
408
409 case META_SETVIEWPORTEXT:
410 SetViewportExt(hdc, *(mr->rdParam + 1), *(mr->rdParam));
411 break;
412
413 case META_OFFSETWINDOWORG:
414 OffsetWindowOrg(hdc, *(mr->rdParam + 1), *(mr->rdParam));
415 break;
416
417 case META_SCALEWINDOWEXT:
418 ScaleWindowExt(hdc, *(mr->rdParam + 3), *(mr->rdParam + 2),
419 *(mr->rdParam + 1), *(mr->rdParam));
420 break;
421
422 case META_OFFSETVIEWPORTORG:
423 OffsetViewportOrg(hdc, *(mr->rdParam + 1), *(mr->rdParam));
424 break;
425
426 case META_SCALEVIEWPORTEXT:
427 ScaleViewportExt(hdc, *(mr->rdParam + 3), *(mr->rdParam + 2),
428 *(mr->rdParam + 1), *(mr->rdParam));
429 break;
430
431 case META_LINETO:
432 LineTo32(hdc, *(mr->rdParam + 1), *(mr->rdParam));
433 break;
434
435 case META_MOVETO:
436 MoveTo(hdc, *(mr->rdParam + 1), *(mr->rdParam));
437 break;
438
439 case META_EXCLUDECLIPRECT:
440 ExcludeClipRect16( hdc, *(mr->rdParam + 3), *(mr->rdParam + 2),
441 *(mr->rdParam + 1), *(mr->rdParam) );
442 break;
443
444 case META_INTERSECTCLIPRECT:
445 IntersectClipRect16( hdc, *(mr->rdParam + 3), *(mr->rdParam + 2),
446 *(mr->rdParam + 1), *(mr->rdParam) );
447 break;
448
449 case META_ARC:
450 Arc32(hdc, *(mr->rdParam + 7), *(mr->rdParam + 6), *(mr->rdParam + 5),
451 *(mr->rdParam + 4), *(mr->rdParam + 3), *(mr->rdParam + 2),
452 *(mr->rdParam + 1), *(mr->rdParam));
453 break;
454
455 case META_ELLIPSE:
456 Ellipse32(hdc, *(mr->rdParam + 3), *(mr->rdParam + 2),
457 *(mr->rdParam + 1), *(mr->rdParam));
458 break;
459
460 case META_FLOODFILL:
461 FloodFill32(hdc, *(mr->rdParam + 3), *(mr->rdParam + 2),
462 MAKELONG(*(mr->rdParam + 1), *(mr->rdParam)));
463 break;
464
465 case META_PIE:
466 Pie32(hdc, *(mr->rdParam + 7), *(mr->rdParam + 6), *(mr->rdParam + 5),
467 *(mr->rdParam + 4), *(mr->rdParam + 3), *(mr->rdParam + 2),
468 *(mr->rdParam + 1), *(mr->rdParam));
469 break;
470
471 case META_RECTANGLE:
472 Rectangle32(hdc, *(mr->rdParam + 3), *(mr->rdParam + 2),
473 *(mr->rdParam + 1), *(mr->rdParam));
474 break;
475
476 case META_ROUNDRECT:
477 RoundRect32(hdc, *(mr->rdParam + 5), *(mr->rdParam + 4),
478 *(mr->rdParam + 3), *(mr->rdParam + 2),
479 *(mr->rdParam + 1), *(mr->rdParam));
480 break;
481
482 case META_PATBLT:
483 PatBlt16(hdc, *(mr->rdParam + 5), *(mr->rdParam + 4),
484 *(mr->rdParam + 3), *(mr->rdParam + 2),
485 MAKELONG(*(mr->rdParam), *(mr->rdParam + 1)));
486 break;
487
488 case META_SAVEDC:
489 SaveDC32(hdc);
490 break;
491
492 case META_SETPIXEL:
493 SetPixel32(hdc, *(mr->rdParam + 3), *(mr->rdParam + 2),
494 MAKELONG(*(mr->rdParam + 1), *(mr->rdParam)));
495 break;
496
497 case META_OFFSETCLIPRGN:
498 OffsetClipRgn16( hdc, *(mr->rdParam + 1), *(mr->rdParam) );
499 break;
500
501 case META_TEXTOUT:
502 s1 = *(mr->rdParam);
503 TextOut16(hdc, *(mr->rdParam + ((s1 + 1) >> 1) + 2),
504 *(mr->rdParam + ((s1 + 1) >> 1) + 1),
505 (char *)(mr->rdParam + 1), s1);
506 break;
507
508 case META_POLYGON:
509 Polygon16(hdc, (LPPOINT16)(mr->rdParam + 1), *(mr->rdParam));
510 break;
511
512 case META_POLYPOLYGON:
513 PolyPolygon16(hdc, (LPPOINT16)(mr->rdParam + *(mr->rdParam) + 1),
514 (LPINT16)(mr->rdParam + 1), *(mr->rdParam));
515 break;
516
517 case META_POLYLINE:
518 Polyline16(hdc, (LPPOINT16)(mr->rdParam + 1), *(mr->rdParam));
519 break;
520
521 case META_RESTOREDC:
522 RestoreDC32(hdc, *(mr->rdParam));
523 break;
524
525 case META_SELECTOBJECT:
526 SelectObject32(hdc, *(ht->objectHandle + *(mr->rdParam)));
527 break;
528
529 case META_CHORD:
530 Chord32(hdc, *(mr->rdParam + 7), *(mr->rdParam + 6), *(mr->rdParam+5),
531 *(mr->rdParam + 4), *(mr->rdParam + 3), *(mr->rdParam + 2),
532 *(mr->rdParam + 1), *(mr->rdParam));
533 break;
534
535 case META_CREATEPATTERNBRUSH:
536 switch (*(mr->rdParam))
537 {
538 case BS_PATTERN:
539 infohdr = (BITMAPINFOHEADER *)(mr->rdParam + 2);
540 MF_AddHandle(ht, nHandles,
541 CreatePatternBrush32(CreateBitmap(infohdr->biWidth,
542 infohdr->biHeight,
543 infohdr->biPlanes,
544 infohdr->biBitCount,
545 (LPSTR)(mr->rdParam +
546 (sizeof(BITMAPINFOHEADER) / 2) + 4))));
547 break;
548
549 case BS_DIBPATTERN:
550 s1 = mr->rdSize * 2 - sizeof(METARECORD) - 2;
551 hndl = GlobalAlloc16(GMEM_MOVEABLE, s1);
552 ptr = GlobalLock16(hndl);
553 memcpy(ptr, mr->rdParam + 2, s1);
554 GlobalUnlock16(hndl);
555 MF_AddHandle(ht, nHandles,
556 CreateDIBPatternBrush32(hndl, *(mr->rdParam + 1)));
557 GlobalFree16(hndl);
558 }
559 break;
560
561 case META_CREATEPENINDIRECT:
562 MF_AddHandle(ht, nHandles,
563 CreatePenIndirect16((LOGPEN16 *)(&(mr->rdParam))));
564 break;
565
566 case META_CREATEFONTINDIRECT:
567 MF_AddHandle(ht, nHandles,
568 CreateFontIndirect16((LOGFONT16 *)(&(mr->rdParam))));
569 break;
570
571 case META_CREATEBRUSHINDIRECT:
572 MF_AddHandle(ht, nHandles,
573 CreateBrushIndirect16((LOGBRUSH16 *)(&(mr->rdParam))));
574 break;
575
576 /* W. Magro: Some new metafile operations. Not all debugged. */
577 case META_CREATEPALETTE:
578 MF_AddHandle(ht, nHandles,
579 CreatePalette((LPLOGPALETTE)mr->rdParam));
580 break;
581
582 case META_SETTEXTALIGN:
583 SetTextAlign16(hdc, *(mr->rdParam));
584 break;
585
586 case META_SELECTPALETTE:
587 SelectPalette(hdc, *(ht->objectHandle + *(mr->rdParam+1)),*(mr->rdParam));
588 break;
589
590 case META_SETMAPPERFLAGS:
591 SetMapperFlags(hdc, *(mr->rdParam));
592 break;
593
594 case META_REALIZEPALETTE:
595 RealizePalette(hdc);
596 break;
597
598 case META_ESCAPE:
599 dprintf_metafile(stddeb,"PlayMetaFileRecord: META_ESCAPE unimplemented.\n");
600 break;
601
602 /* --- Begin of fixed or new metafile operations. July 1996 ----*/
603 case META_EXTTEXTOUT:
604 {
605 LPINT16 dxx;
606 DWORD len;
607
608 s1 = mr->rdParam[2]; /* String length */
609 len = sizeof(METARECORD) + (((s1 + 1) >> 1) * 2) + 2 * sizeof(short)
610 + sizeof(UINT16) + sizeof(RECT16);
611 if (mr->rdSize == len / 2)
612 dxx = NULL; /* No array present */
613 else if (mr->rdSize == (len + s1 * sizeof(INT16)) / 2)
614 dxx = &mr->rdParam[8+(s1+1)/2]; /* start of array */
615 else {
616 fprintf(stderr,
617 "PlayMetaFileRecord ExtTextOut mr->rdSize = %08lx, count = %x\n",
618 mr->rdSize, s1);
619 dxx = NULL;
620 }
621 ExtTextOut16( hdc, mr->rdParam[1], /* X position */
622 mr->rdParam[0], /* Y position */
623 mr->rdParam[3], /* options */
624 (LPRECT16) &mr->rdParam[4], /* rectangle */
625 (char *)(mr->rdParam + 8), /* string */
626 s1, dxx); /* length, dx array */
627 if (dxx)
628 dprintf_metafile(stddeb,"EXTTEXTOUT len: %ld (%hd %hd) [%s].\n",
629 mr->rdSize,dxx[0],dxx[1],(char*) &(mr->rdParam[8]) );
630 }
631 break;
632
633 case META_STRETCHDIB:
634 {
635 LPBITMAPINFO info = (LPBITMAPINFO) &(mr->rdParam[11]);
636 LPSTR bits = (LPSTR)info + DIB_BitmapInfoSize( info, mr->rdParam[2] );
637 StretchDIBits16(hdc,mr->rdParam[10],mr->rdParam[9],mr->rdParam[8],
638 mr->rdParam[7],mr->rdParam[6],mr->rdParam[5],
639 mr->rdParam[4],mr->rdParam[3],bits,info,
640 mr->rdParam[2],MAKELONG(mr->rdParam[0],mr->rdParam[1]));
641 }
642 break;
643
644 case META_DIBSTRETCHBLT:
645 {
646 LPBITMAPINFO info = (LPBITMAPINFO) &(mr->rdParam[10]);
647 LPSTR bits = (LPSTR)info + DIB_BitmapInfoSize( info, mr->rdParam[2] );
648 StretchDIBits16(hdc,mr->rdParam[9],mr->rdParam[8],mr->rdParam[7],
649 mr->rdParam[6],mr->rdParam[5],mr->rdParam[4],
650 mr->rdParam[3],mr->rdParam[2],bits,info,
651 DIB_RGB_COLORS,MAKELONG(mr->rdParam[0],mr->rdParam[1]));
652 }
653 break;
654
655 case META_STRETCHBLT:
656 {
657 HDC16 hdcSrc=CreateCompatibleDC16(hdc);
658 HBITMAP16 hbitmap=CreateBitmap(mr->rdParam[10], /*Width */
659 mr->rdParam[11], /*Height*/
660 mr->rdParam[13], /*Planes*/
661 mr->rdParam[14], /*BitsPixel*/
662 (LPSTR)&mr->rdParam[15]); /*bits*/
663 SelectObject32(hdcSrc,hbitmap);
664 StretchBlt16(hdc,mr->rdParam[9],mr->rdParam[8],
665 mr->rdParam[7],mr->rdParam[6],
666 hdcSrc,mr->rdParam[5],mr->rdParam[4],
667 mr->rdParam[3],mr->rdParam[2],
668 MAKELONG(mr->rdParam[0],mr->rdParam[1]));
669 DeleteDC32(hdcSrc);
670 }
671 break;
672
673 case META_BITBLT: /* <-- not yet debugged */
674 {
675 HDC16 hdcSrc=CreateCompatibleDC16(hdc);
676 HBITMAP16 hbitmap=CreateBitmap(mr->rdParam[7]/*Width */,mr->rdParam[8]/*Height*/,
677 mr->rdParam[10]/*Planes*/,mr->rdParam[11]/*BitsPixel*/,
678 (LPSTR)&mr->rdParam[12]/*bits*/);
679 SelectObject32(hdcSrc,hbitmap);
680 BitBlt32(hdc,mr->rdParam[6],mr->rdParam[5],
681 mr->rdParam[4],mr->rdParam[3],
682 hdcSrc, mr->rdParam[2],mr->rdParam[1],
683 MAKELONG(0,mr->rdParam[0]));
684 DeleteDC32(hdcSrc);
685 }
686 break;
687 #define META_UNIMP(x) case x: fprintf(stderr,"PlayMetaFileRecord:record type "#x" not implemented.\n");break;
688 META_UNIMP(META_SETTEXTCHAREXTRA)
689 META_UNIMP(META_SETTEXTJUSTIFICATION)
690 META_UNIMP(META_FILLREGION)
691 META_UNIMP(META_FRAMEREGION)
692 META_UNIMP(META_INVERTREGION)
693 META_UNIMP(META_PAINTREGION)
694 META_UNIMP(META_SELECTCLIPREGION)
695 META_UNIMP(META_DRAWTEXT)
696 META_UNIMP(META_SETDIBTODEV)
697 META_UNIMP(META_ANIMATEPALETTE)
698 META_UNIMP(META_SETPALENTRIES)
699 META_UNIMP(META_RESIZEPALETTE)
700 META_UNIMP(META_DIBBITBLT)
701 META_UNIMP(META_DIBCREATEPATTERNBRUSH)
702 META_UNIMP(META_EXTFLOODFILL)
703 META_UNIMP(META_RESETDC)
704 META_UNIMP(META_STARTDOC)
705 META_UNIMP(META_STARTPAGE)
706 META_UNIMP(META_ENDPAGE)
707 META_UNIMP(META_ABORTDOC)
708 META_UNIMP(META_ENDDOC)
709 META_UNIMP(META_CREATEBRUSH)
710 META_UNIMP(META_CREATEBITMAPINDIRECT)
711 META_UNIMP(META_CREATEBITMAP)
712 #undef META_UNIMP
713
714 default:
715 fprintf(stddeb,"PlayMetaFileRecord: Unknown record type %x\n",
716 mr->rdFunction);
717 }
718 }
719
720
721 /******************************************************************
722 * GetMetaFileBits by William Magro, 19 Sep 1995
723 *
724 * Trade in a meta file object handle for a handle to the meta file memory
725 */
726
727 HGLOBAL16 GetMetaFileBits(HMETAFILE16 hmf)
728 {
729 dprintf_metafile(stddeb,"GetMetaFileBits: hMem out: %04x\n", hmf);
730
731 return hmf;
732 }
733
734 /******************************************************************
735 * SetMetaFileBits by William Magro, 19 Sep 1995
736 *
737 * Trade in a meta file memory handle for a handle to a meta file object
738 */
739
740 HMETAFILE16 SetMetaFileBits( HGLOBAL16 hMem )
741 {
742 dprintf_metafile(stddeb,"SetMetaFileBits: hmf out: %04x\n", hMem);
743
744 return hMem;
745 }
746
747 /******************************************************************
748 * MF_WriteRecord
749 *
750 * Warning: this function can change the metafile handle.
751 */
752
753 static BOOL32 MF_WriteRecord( DC *dc, METARECORD *mr, WORD rlen)
754 {
755 DWORD len;
756 METAHEADER *mh;
757 METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dc->physDev;
758
759 switch(physDev->mh->mtType)
760 {
761 case METAFILE_MEMORY:
762 len = physDev->mh->mtSize * 2 + rlen;
763 mh = HeapReAlloc( SystemHeap, 0, physDev->mh, len );
764 if (!mh) return FALSE;
765 physDev->mh = mh;
766 memcpy((WORD *)physDev->mh + physDev->mh->mtSize, mr, rlen);
767 break;
768 case METAFILE_DISK:
769 dprintf_metafile(stddeb,"Writing record to disk\n");
770 if (_lwrite32(physDev->mh->mtNoParameters, (char *)mr, rlen) == -1)
771 return FALSE;
772 break;
773 default:
774 fprintf( stderr, "Uknown metafile type %d\n", physDev->mh->mtType );
775 return FALSE;
776 }
777
778 physDev->mh->mtSize += rlen / 2;
779 physDev->mh->mtMaxRecord = MAX(physDev->mh->mtMaxRecord, rlen / 2);
780 return TRUE;
781 }
782
783
784 /******************************************************************
785 * MF_MetaParam0
786 */
787
788 BOOL32 MF_MetaParam0(DC *dc, short func)
789 {
790 char buffer[8];
791 METARECORD *mr = (METARECORD *)&buffer;
792
793 mr->rdSize = 3;
794 mr->rdFunction = func;
795 return MF_WriteRecord( dc, mr, mr->rdSize * 2);
796 }
797
798
799 /******************************************************************
800 * MF_MetaParam1
801 */
802 BOOL32 MF_MetaParam1(DC *dc, short func, short param1)
803 {
804 char buffer[8];
805 METARECORD *mr = (METARECORD *)&buffer;
806
807 mr->rdSize = 4;
808 mr->rdFunction = func;
809 *(mr->rdParam) = param1;
810 return MF_WriteRecord( dc, mr, mr->rdSize * 2);
811 }
812
813
814 /******************************************************************
815 * MF_MetaParam2
816 */
817 BOOL32 MF_MetaParam2(DC *dc, short func, short param1, short param2)
818 {
819 char buffer[10];
820 METARECORD *mr = (METARECORD *)&buffer;
821
822 mr->rdSize = 5;
823 mr->rdFunction = func;
824 *(mr->rdParam) = param2;
825 *(mr->rdParam + 1) = param1;
826 return MF_WriteRecord( dc, mr, mr->rdSize * 2);
827 }
828
829
830 /******************************************************************
831 * MF_MetaParam4
832 */
833
834 BOOL32 MF_MetaParam4(DC *dc, short func, short param1, short param2,
835 short param3, short param4)
836 {
837 char buffer[14];
838 METARECORD *mr = (METARECORD *)&buffer;
839
840 mr->rdSize = 7;
841 mr->rdFunction = func;
842 *(mr->rdParam) = param4;
843 *(mr->rdParam + 1) = param3;
844 *(mr->rdParam + 2) = param2;
845 *(mr->rdParam + 3) = param1;
846 return MF_WriteRecord( dc, mr, mr->rdSize * 2);
847 }
848
849
850 /******************************************************************
851 * MF_MetaParam6
852 */
853
854 BOOL32 MF_MetaParam6(DC *dc, short func, short param1, short param2,
855 short param3, short param4, short param5, short param6)
856 {
857 char buffer[18];
858 METARECORD *mr = (METARECORD *)&buffer;
859
860 mr->rdSize = 9;
861 mr->rdFunction = func;
862 *(mr->rdParam) = param6;
863 *(mr->rdParam + 1) = param5;
864 *(mr->rdParam + 2) = param4;
865 *(mr->rdParam + 3) = param3;
866 *(mr->rdParam + 4) = param2;
867 *(mr->rdParam + 5) = param1;
868 return MF_WriteRecord( dc, mr, mr->rdSize * 2);
869 }
870
871
872 /******************************************************************
873 * MF_MetaParam8
874 */
875 BOOL32 MF_MetaParam8(DC *dc, short func, short param1, short param2,
876 short param3, short param4, short param5,
877 short param6, short param7, short param8)
878 {
879 char buffer[22];
880 METARECORD *mr = (METARECORD *)&buffer;
881
882 mr->rdSize = 11;
883 mr->rdFunction = func;
884 *(mr->rdParam) = param8;
885 *(mr->rdParam + 1) = param7;
886 *(mr->rdParam + 2) = param6;
887 *(mr->rdParam + 3) = param5;
888 *(mr->rdParam + 4) = param4;
889 *(mr->rdParam + 5) = param3;
890 *(mr->rdParam + 6) = param2;
891 *(mr->rdParam + 7) = param1;
892 return MF_WriteRecord( dc, mr, mr->rdSize * 2);
893 }
894
895
896 /******************************************************************
897 * MF_CreateBrushIndirect
898 */
899
900 BOOL32 MF_CreateBrushIndirect(DC *dc, HBRUSH16 hBrush, LOGBRUSH16 *logbrush)
901 {
902 int index;
903 char buffer[sizeof(METARECORD) - 2 + sizeof(*logbrush)];
904 METARECORD *mr = (METARECORD *)&buffer;
905
906 mr->rdSize = (sizeof(METARECORD) + sizeof(*logbrush) - 2) / 2;
907 mr->rdFunction = META_CREATEBRUSHINDIRECT;
908 memcpy(&(mr->rdParam), logbrush, sizeof(*logbrush));
909 if (!(MF_WriteRecord( dc, mr, mr->rdSize * 2))) return FALSE;
910
911 mr->rdSize = sizeof(METARECORD) / 2;
912 mr->rdFunction = META_SELECTOBJECT;
913
914 if ((index = MF_AddHandleDC( dc )) == -1) return FALSE;
915 *(mr->rdParam) = index;
916 return MF_WriteRecord( dc, mr, mr->rdSize * 2);
917 }
918
919
920 /******************************************************************
921 * MF_CreatePatternBrush
922 */
923
924 BOOL32 MF_CreatePatternBrush(DC *dc, HBRUSH16 hBrush, LOGBRUSH16 *logbrush)
925 {
926 DWORD len, bmSize, biSize;
927 HGLOBAL16 hmr;
928 METARECORD *mr;
929 BITMAPOBJ *bmp;
930 BITMAPINFO *info;
931 BITMAPINFOHEADER *infohdr;
932 int index;
933 char buffer[sizeof(METARECORD)];
934
935 switch (logbrush->lbStyle)
936 {
937 case BS_PATTERN:
938 bmp = (BITMAPOBJ *)GDI_GetObjPtr((HGDIOBJ16)logbrush->lbHatch, BITMAP_MAGIC);
939 if (!bmp) return FALSE;
940 len = sizeof(METARECORD) + sizeof(BITMAPINFOHEADER) +
941 (bmp->bitmap.bmHeight * bmp->bitmap.bmWidthBytes) + 6;
942 if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
943 return FALSE;
944 mr = (METARECORD *)GlobalLock16(hmr);
945 memset(mr, 0, len);
946 mr->rdFunction = META_DIBCREATEPATTERNBRUSH;
947 mr->rdSize = len / 2;
948 *(mr->rdParam) = logbrush->lbStyle;
949 *(mr->rdParam + 1) = DIB_RGB_COLORS;
950 infohdr = (BITMAPINFOHEADER *)(mr->rdParam + 2);
951 infohdr->biSize = sizeof(BITMAPINFOHEADER);
952 infohdr->biWidth = bmp->bitmap.bmWidth;
953 infohdr->biHeight = bmp->bitmap.bmHeight;
954 infohdr->biPlanes = bmp->bitmap.bmPlanes;
955 infohdr->biBitCount = bmp->bitmap.bmBitsPixel;
956 memcpy(mr->rdParam + (sizeof(BITMAPINFOHEADER) / 2) + 4,
957 PTR_SEG_TO_LIN(bmp->bitmap.bmBits),
958 bmp->bitmap.bmHeight * bmp->bitmap.bmWidthBytes);
959 break;
960
961 case BS_DIBPATTERN:
962 info = (BITMAPINFO *)GlobalLock16((HGLOBAL16)logbrush->lbHatch);
963 if (info->bmiHeader.biCompression)
964 bmSize = info->bmiHeader.biSizeImage;
965 else
966 bmSize = (info->bmiHeader.biWidth * info->bmiHeader.biBitCount
967 + 31) / 32 * 8 * info->bmiHeader.biHeight;
968 biSize = DIB_BitmapInfoSize(info, LOWORD(logbrush->lbColor));
969 len = sizeof(METARECORD) + biSize + bmSize + 2;
970 if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
971 return FALSE;
972 mr = (METARECORD *)GlobalLock16(hmr);
973 memset(mr, 0, len);
974 mr->rdFunction = META_DIBCREATEPATTERNBRUSH;
975 mr->rdSize = len / 2;
976 *(mr->rdParam) = logbrush->lbStyle;
977 *(mr->rdParam + 1) = LOWORD(logbrush->lbColor);
978 memcpy(mr->rdParam + 2, info, biSize + bmSize);
979 break;
980 default:
981 return FALSE;
982 }
983 if (!(MF_WriteRecord(dc, mr, len)))
984 {
985 GlobalFree16(hmr);
986 return FALSE;
987 }
988
989 GlobalFree16(hmr);
990
991 mr = (METARECORD *)&buffer;
992 mr->rdSize = sizeof(METARECORD) / 2;
993 mr->rdFunction = META_SELECTOBJECT;
994
995 if ((index = MF_AddHandleDC( dc )) == -1) return FALSE;
996 *(mr->rdParam) = index;
997 return MF_WriteRecord( dc, mr, mr->rdSize * 2);
998 }
999
1000
1001 /******************************************************************
1002 * MF_CreatePenIndirect
1003 */
1004
1005 BOOL32 MF_CreatePenIndirect(DC *dc, HPEN16 hPen, LOGPEN16 *logpen)
1006 {
1007 int index;
1008 char buffer[sizeof(METARECORD) - 2 + sizeof(*logpen)];
1009 METARECORD *mr = (METARECORD *)&buffer;
1010
1011 mr->rdSize = (sizeof(METARECORD) + sizeof(*logpen) - 2) / 2;
1012 mr->rdFunction = META_CREATEPENINDIRECT;
1013 memcpy(&(mr->rdParam), logpen, sizeof(*logpen));
1014 if (!(MF_WriteRecord( dc, mr, mr->rdSize * 2))) return FALSE;
1015
1016 mr->rdSize = sizeof(METARECORD) / 2;
1017 mr->rdFunction = META_SELECTOBJECT;
1018
1019 if ((index = MF_AddHandleDC( dc )) == -1) return FALSE;
1020 *(mr->rdParam) = index;
1021 return MF_WriteRecord( dc, mr, mr->rdSize * 2);
1022 }
1023
1024
1025 /******************************************************************
1026 * MF_CreateFontIndirect
1027 */
1028
1029 BOOL32 MF_CreateFontIndirect(DC *dc, HFONT16 hFont, LOGFONT16 *logfont)
1030 {
1031 int index;
1032 char buffer[sizeof(METARECORD) - 2 + sizeof(LOGFONT16)];
1033 METARECORD *mr = (METARECORD *)&buffer;
1034
1035 mr->rdSize = (sizeof(METARECORD) + sizeof(LOGFONT16) - 2) / 2;
1036 mr->rdFunction = META_CREATEFONTINDIRECT;
1037 memcpy(&(mr->rdParam), logfont, sizeof(LOGFONT16));
1038 if (!(MF_WriteRecord( dc, mr, mr->rdSize * 2))) return FALSE;
1039
1040 mr->rdSize = sizeof(METARECORD) / 2;
1041 mr->rdFunction = META_SELECTOBJECT;
1042
1043 if ((index = MF_AddHandleDC( dc )) == -1) return FALSE;
1044 *(mr->rdParam) = index;
1045 return MF_WriteRecord( dc, mr, mr->rdSize * 2);
1046 }
1047
1048
1049 /******************************************************************
1050 * MF_TextOut
1051 */
1052 BOOL32 MF_TextOut(DC *dc, short x, short y, LPCSTR str, short count)
1053 {
1054 BOOL32 ret;
1055 DWORD len;
1056 HGLOBAL16 hmr;
1057 METARECORD *mr;
1058
1059 len = sizeof(METARECORD) + (((count + 1) >> 1) * 2) + 4;
1060 if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
1061 return FALSE;
1062 mr = (METARECORD *)GlobalLock16(hmr);
1063 memset(mr, 0, len);
1064
1065 mr->rdSize = len / 2;
1066 mr->rdFunction = META_TEXTOUT;
1067 *(mr->rdParam) = count;
1068 memcpy(mr->rdParam + 1, str, count);
1069 *(mr->rdParam + ((count + 1) >> 1) + 1) = y;
1070 *(mr->rdParam + ((count + 1) >> 1) + 2) = x;
1071 ret = MF_WriteRecord( dc, mr, mr->rdSize * 2);
1072 GlobalFree16(hmr);
1073 return ret;
1074 }
1075
1076 /******************************************************************
1077 * MF_ExtTextOut
1078 */
1079 BOOL32 MF_ExtTextOut(DC*dc, short x, short y, UINT16 flags, const RECT16 *rect,
1080 LPCSTR str, short count, const INT16 *lpDx)
1081 {
1082 BOOL32 ret;
1083 DWORD len;
1084 HGLOBAL16 hmr;
1085 METARECORD *mr;
1086
1087 len = sizeof(METARECORD) + (((count + 1) >> 1) * 2) + 2 * sizeof(short)
1088 + sizeof(UINT16) + sizeof(RECT16);
1089 if (lpDx)
1090 len+=count*sizeof(INT16);
1091 if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
1092 return FALSE;
1093 mr = (METARECORD *)GlobalLock16(hmr);
1094 memset(mr, 0, len);
1095
1096 mr->rdSize = len / 2;
1097 mr->rdFunction = META_EXTTEXTOUT;
1098 *(mr->rdParam) = y;
1099 *(mr->rdParam + 1) = x;
1100 *(mr->rdParam + 2) = count;
1101 *(mr->rdParam + 3) = flags;
1102 if (rect) memcpy(mr->rdParam + 4, rect, sizeof(RECT16));
1103 memcpy(mr->rdParam + 8, str, count);
1104 if (lpDx)
1105 memcpy(mr->rdParam + 8+ ((count + 1) >> 1),lpDx,count*sizeof(INT16));
1106 ret = MF_WriteRecord( dc, mr, mr->rdSize * 2);
1107 GlobalFree16(hmr);
1108 return ret;
1109 }
1110
1111 /******************************************************************
1112 * MF_MetaPoly - implements Polygon and Polyline
1113 */
1114 BOOL32 MF_MetaPoly(DC *dc, short func, LPPOINT16 pt, short count)
1115 {
1116 BOOL32 ret;
1117 DWORD len;
1118 HGLOBAL16 hmr;
1119 METARECORD *mr;
1120
1121 len = sizeof(METARECORD) + (count * 4);
1122 if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
1123 return FALSE;
1124 mr = (METARECORD *)GlobalLock16(hmr);
1125 memset(mr, 0, len);
1126
1127 mr->rdSize = len / 2;
1128 mr->rdFunction = func;
1129 *(mr->rdParam) = count;
1130 memcpy(mr->rdParam + 1, pt, count * 4);
1131 ret = MF_WriteRecord( dc, mr, mr->rdSize * 2);
1132 GlobalFree16(hmr);
1133 return ret;
1134 }
1135
1136
1137 /******************************************************************
1138 * MF_BitBlt
1139 */
1140 BOOL32 MF_BitBlt(DC *dcDest, short xDest, short yDest, short width,
1141 short height, DC *dcSrc, short xSrc, short ySrc, DWORD rop)
1142 {
1143 BOOL32 ret;
1144 DWORD len;
1145 HGLOBAL16 hmr;
1146 METARECORD *mr;
1147 BITMAP16 BM;
1148
1149 GetObject16(dcSrc->w.hBitmap, sizeof(BITMAP16), &BM);
1150 len = sizeof(METARECORD) + 12 * sizeof(INT16) + BM.bmWidthBytes * BM.bmHeight;
1151 if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
1152 return FALSE;
1153 mr = (METARECORD *)GlobalLock16(hmr);
1154 mr->rdFunction = META_BITBLT;
1155 *(mr->rdParam + 7) = BM.bmWidth;
1156 *(mr->rdParam + 8) = BM.bmHeight;
1157 *(mr->rdParam + 9) = BM.bmWidthBytes;
1158 *(mr->rdParam +10) = BM.bmPlanes;
1159 *(mr->rdParam +11) = BM.bmBitsPixel;
1160 dprintf_metafile(stddeb,"MF_StretchBlt->len = %ld rop=%lx \n",len,rop);
1161 if (GetBitmapBits(dcSrc->w.hBitmap,BM.bmWidthBytes * BM.bmHeight,mr->rdParam +12))
1162 {
1163 mr->rdSize = len / sizeof(INT16);
1164 *(mr->rdParam) = HIWORD(rop);
1165 *(mr->rdParam + 1) = ySrc;
1166 *(mr->rdParam + 2) = xSrc;
1167 *(mr->rdParam + 3) = height;
1168 *(mr->rdParam + 4) = width;
1169 *(mr->rdParam + 5) = yDest;
1170 *(mr->rdParam + 6) = xDest;
1171 ret = MF_WriteRecord( dcDest, mr, mr->rdSize * 2);
1172 }
1173 else
1174 ret = FALSE;
1175 GlobalFree16(hmr);
1176 return ret;
1177 }
1178
1179
1180 /**********************************************************************
1181 * MF_StretchBlt
1182 * this function contains TWO ways for procesing StretchBlt in metafiles,
1183 * decide between rdFunction values META_STRETCHBLT or META_DIBSTRETCHBLT
1184 * via #define STRETCH_VIA_DIB
1185 */
1186 #define STRETCH_VIA_DIB
1187 #undef STRETCH_VIA_DIB
1188 BOOL32 MF_StretchBlt(DC *dcDest, short xDest, short yDest, short widthDest,
1189 short heightDest, DC *dcSrc, short xSrc, short ySrc,
1190 short widthSrc, short heightSrc, DWORD rop)
1191 {
1192 BOOL32 ret;
1193 DWORD len;
1194 HGLOBAL16 hmr;
1195 METARECORD *mr;
1196 BITMAP16 BM;
1197 #ifdef STRETCH_VIA_DIB
1198 LPBITMAPINFOHEADER lpBMI;
1199 WORD nBPP;
1200 #endif
1201 GetObject16(dcSrc->w.hBitmap, sizeof(BITMAP16), &BM);
1202 #ifdef STRETCH_VIA_DIB
1203 nBPP = BM.bmPlanes * BM.bmBitsPixel;
1204 len = sizeof(METARECORD) + 10 * sizeof(INT16)
1205 + sizeof(BITMAPINFOHEADER) + (nBPP != 24 ? 1 << nBPP: 0) * sizeof(RGBQUAD)
1206 + ((BM.bmWidth * nBPP + 31) / 32) * 4 * BM.bmHeight;
1207 if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
1208 return FALSE;
1209 mr = (METARECORD *)GlobalLock16(hmr);
1210 mr->rdFunction = META_DIBSTRETCHBLT;
1211 lpBMI=(LPBITMAPINFOHEADER)(mr->rdParam+10);
1212 lpBMI->biSize = sizeof(BITMAPINFOHEADER);
1213 lpBMI->biWidth = BM.bmWidth;
1214 lpBMI->biHeight = BM.bmHeight;
1215 lpBMI->biPlanes = 1;
1216 lpBMI->biBitCount = nBPP; /* 1,4,8 or 24 */
1217 lpBMI->biClrUsed = nBPP != 24 ? 1 << nBPP : 0;
1218 lpBMI->biSizeImage = ((lpBMI->biWidth * nBPP + 31) / 32) * 4 * lpBMI->biHeight;
1219 lpBMI->biCompression = BI_RGB;
1220 lpBMI->biXPelsPerMeter = MulDiv32(GetDeviceCaps(dcSrc->hSelf,LOGPIXELSX),3937,100);
1221 lpBMI->biYPelsPerMeter = MulDiv32(GetDeviceCaps(dcSrc->hSelf,LOGPIXELSY),3937,100);
1222 lpBMI->biClrImportant = 0; /* 1 meter = 39.37 inch */
1223
1224 dprintf_metafile(stddeb,"MF_StretchBltViaDIB->len = %ld rop=%lx PixYPM=%ld Caps=%d\n",
1225 len,rop,lpBMI->biYPelsPerMeter,GetDeviceCaps(hdcSrc,LOGPIXELSY));
1226 if (GetDIBits(hdcSrc,dcSrc->w.hBitmap,0,(UINT)lpBMI->biHeight,
1227 (LPSTR)lpBMI + DIB_BitmapInfoSize( (BITMAPINFO *)lpBMI,
1228 DIB_RGB_COLORS ),
1229 (LPBITMAPINFO)lpBMI, DIB_RGB_COLORS))
1230 #else
1231 len = sizeof(METARECORD) + 15 * sizeof(INT16) + BM.bmWidthBytes * BM.bmHeight;
1232 if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
1233 return FALSE;
1234 mr = (METARECORD *)GlobalLock16(hmr);
1235 mr->rdFunction = META_STRETCHBLT;
1236 *(mr->rdParam +10) = BM.bmWidth;
1237 *(mr->rdParam +11) = BM.bmHeight;
1238 *(mr->rdParam +12) = BM.bmWidthBytes;
1239 *(mr->rdParam +13) = BM.bmPlanes;
1240 *(mr->rdParam +14) = BM.bmBitsPixel;
1241 dprintf_metafile(stddeb,"MF_StretchBlt->len = %ld rop=%lx \n",len,rop);
1242 if (GetBitmapBits(dcSrc->w.hBitmap,BM.bmWidthBytes * BM.bmHeight,mr->rdParam +15))
1243 #endif
1244 {
1245 mr->rdSize = len / sizeof(INT16);
1246 *(mr->rdParam) = LOWORD(rop);
1247 *(mr->rdParam + 1) = HIWORD(rop);
1248 *(mr->rdParam + 2) = heightSrc;
1249 *(mr->rdParam + 3) = widthSrc;
1250 *(mr->rdParam + 4) = ySrc;
1251 *(mr->rdParam + 5) = xSrc;
1252 *(mr->rdParam + 6) = heightDest;
1253 *(mr->rdParam + 7) = widthDest;
1254 *(mr->rdParam + 8) = yDest;
1255 *(mr->rdParam + 9) = xDest;
1256 ret = MF_WriteRecord( dcDest, mr, mr->rdSize * 2);
1257 }
1258 else
1259 ret = FALSE;
1260 GlobalFree16(hmr);
1261 return ret;
1262 }
1263
1264
Windows API implementation