?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msdasql: Support IRowsetInfo in IRowset interface.
[wine.git] / dlls / gdi32 / emfdc.c
blob981849a9e86b429aa884eeab1c4cafc1e25006cd
1 /*
2 * Enhanced MetaFile recording functions
3 *
4 * Copyright 1999 Huw D M Davies
5 * Copyright 2016 Alexandre Julliard
6 * Copyright 2021 Jacek Caban for CodeWeavers
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include <assert.h>
24 #include <stdlib.h>
25
26 #include "gdi_private.h"
27 #include "winnls.h"
28
29 #include "wine/debug.h"
30
31 WINE_DEFAULT_DEBUG_CHANNEL(enhmetafile);
32
33
34 struct emf
35 {
36 ENHMETAHEADER *emh;
37 DC_ATTR *dc_attr;
38 UINT handles_size, cur_handles;
39 HGDIOBJ *handles;
40 HANDLE file;
41 HBRUSH dc_brush;
42 HPEN dc_pen;
43 BOOL path;
44 };
45
46 #define HANDLE_LIST_INC 20
47 static const RECTL empty_bounds = { 0, 0, -1, -1 };
48
49 static BOOL emfdc_record( struct emf *emf, EMR *emr )
50 {
51 DWORD len, size;
52 ENHMETAHEADER *emh;
53
54 TRACE( "record %d, size %d\n", emr->iType, emr->nSize );
55
56 assert( !(emr->nSize & 3) );
57
58 emf->emh->nBytes += emr->nSize;
59 emf->emh->nRecords++;
60
61 size = HeapSize( GetProcessHeap(), 0, emf->emh );
62 len = emf->emh->nBytes;
63 if (len > size)
64 {
65 size += (size / 2) + emr->nSize;
66 emh = HeapReAlloc( GetProcessHeap(), 0, emf->emh, size );
67 if (!emh) return FALSE;
68 emf->emh = emh;
69 }
70 memcpy( (char *)emf->emh + emf->emh->nBytes - emr->nSize, emr, emr->nSize );
71 return TRUE;
72 }
73
74 static void emfdc_update_bounds( struct emf *emf, RECTL *rect )
75 {
76 RECTL *bounds = &emf->dc_attr->emf_bounds;
77 RECTL vport_rect = *rect;
78
79 LPtoDP( emf->dc_attr->hdc, (POINT *)&vport_rect, 2 );
80
81 /* The coordinate systems may be mirrored
82 (LPtoDP handles points, not rectangles) */
83 if (vport_rect.left > vport_rect.right)
84 {
85 LONG temp = vport_rect.right;
86 vport_rect.right = vport_rect.left;
87 vport_rect.left = temp;
88 }
89 if (vport_rect.top > vport_rect.bottom)
90 {
91 LONG temp = vport_rect.bottom;
92 vport_rect.bottom = vport_rect.top;
93 vport_rect.top = temp;
94 }
95
96 if (bounds->left > bounds->right)
97 {
98 /* first bounding rectangle */
99 *bounds = vport_rect;
100 }
101 else
102 {
103 bounds->left = min(bounds->left, vport_rect.left);
104 bounds->top = min(bounds->top, vport_rect.top);
105 bounds->right = max(bounds->right, vport_rect.right);
106 bounds->bottom = max(bounds->bottom, vport_rect.bottom);
107 }
108 }
109
110 static UINT get_bitmap_info( HDC *hdc, HBITMAP *bitmap, BITMAPINFO *info )
111 {
112 HBITMAP blit_bitmap;
113 HDC blit_dc;
114 UINT info_size, bpp;
115 DIBSECTION dib;
116
117 if (!(info_size = GetObjectW( *bitmap, sizeof(dib), &dib ))) return 0;
118
119 if (info_size == sizeof(dib))
120 {
121 blit_dc = *hdc;
122 blit_bitmap = *bitmap;
123 }
124 else
125 {
126 unsigned char dib_info_buffer[FIELD_OFFSET(BITMAPINFO, bmiColors[256])];
127 BITMAPINFO *dib_info = (BITMAPINFO *)dib_info_buffer;
128 BITMAP bmp = dib.dsBm;
129 HPALETTE palette;
130 void *bits;
131
132 assert( info_size == sizeof(BITMAP) );
133
134 dib_info->bmiHeader.biSize = sizeof(dib_info->bmiHeader);
135 dib_info->bmiHeader.biWidth = bmp.bmWidth;
136 dib_info->bmiHeader.biHeight = bmp.bmHeight;
137 dib_info->bmiHeader.biPlanes = 1;
138 dib_info->bmiHeader.biBitCount = bmp.bmBitsPixel;
139 dib_info->bmiHeader.biCompression = BI_RGB;
140 dib_info->bmiHeader.biSizeImage = 0;
141 dib_info->bmiHeader.biXPelsPerMeter = 0;
142 dib_info->bmiHeader.biYPelsPerMeter = 0;
143 dib_info->bmiHeader.biClrUsed = 0;
144 dib_info->bmiHeader.biClrImportant = 0;
145 switch (dib_info->bmiHeader.biBitCount)
146 {
147 case 16:
148 ((DWORD *)dib_info->bmiColors)[0] = 0xf800;
149 ((DWORD *)dib_info->bmiColors)[1] = 0x07e0;
150 ((DWORD *)dib_info->bmiColors)[2] = 0x001f;
151 break;
152 case 32:
153 ((DWORD *)dib_info->bmiColors)[0] = 0xff0000;
154 ((DWORD *)dib_info->bmiColors)[1] = 0x00ff00;
155 ((DWORD *)dib_info->bmiColors)[2] = 0x0000ff;
156 break;
157 default:
158 if (dib_info->bmiHeader.biBitCount > 8) break;
159 if (!(palette = GetCurrentObject( *hdc, OBJ_PAL ))) return FALSE;
160 if (!GetPaletteEntries( palette, 0, 256, (PALETTEENTRY *)dib_info->bmiColors ))
161 return FALSE;
162 }
163
164 if (!(blit_dc = NtGdiCreateCompatibleDC( *hdc ))) return FALSE;
165 if (!(blit_bitmap = CreateDIBSection( blit_dc, dib_info, DIB_RGB_COLORS, &bits, NULL, 0 )))
166 goto err;
167 if (!SelectObject( blit_dc, blit_bitmap )) goto err;
168 if (!BitBlt( blit_dc, 0, 0, bmp.bmWidth, bmp.bmHeight, *hdc, 0, 0, SRCCOPY ))
169 goto err;
170 }
171 if (!GetDIBits( blit_dc, blit_bitmap, 0, INT_MAX, NULL, info, DIB_RGB_COLORS ))
172 goto err;
173
174 bpp = info->bmiHeader.biBitCount;
175 if (bpp <= 8)
176 return sizeof(BITMAPINFOHEADER) + (1 << bpp) * sizeof(RGBQUAD);
177 else if (bpp == 16 || bpp == 32)
178 return sizeof(BITMAPINFOHEADER) + 3 * sizeof(RGBQUAD);
179
180 return sizeof(BITMAPINFOHEADER);
181
182 err:
183 if (blit_dc && blit_dc != *hdc) DeleteDC( blit_dc );
184 if (blit_bitmap && blit_bitmap != *bitmap) DeleteObject( blit_bitmap );
185 return 0;
186 }
187
188 static UINT emfdc_add_handle( struct emf *emf, HGDIOBJ obj )
189 {
190 UINT index;
191
192 for (index = 0; index < emf->handles_size; index++)
193 if (emf->handles[index] == 0) break;
194
195 if (index == emf->handles_size)
196 {
197 emf->handles_size += HANDLE_LIST_INC;
198 emf->handles = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
199 emf->handles,
200 emf->handles_size * sizeof(emf->handles[0]) );
201 }
202 emf->handles[index] = obj;
203
204 emf->cur_handles++;
205 if (emf->cur_handles > emf->emh->nHandles)
206 emf->emh->nHandles++;
207
208 return index + 1; /* index 0 is reserved for the hmf, so we increment everything by 1 */
209 }
210
211 static UINT emfdc_find_object( struct emf *emf, HGDIOBJ obj )
212 {
213 UINT index;
214
215 for (index = 0; index < emf->handles_size; index++)
216 if (emf->handles[index] == obj) return index + 1;
217
218 return 0;
219 }
220
221 static void emfdc_delete_object( HDC hdc, HGDIOBJ obj )
222 {
223 DC_ATTR *dc_attr = get_dc_attr( hdc );
224 struct emf *emf = dc_attr->emf;
225 EMRDELETEOBJECT emr;
226 UINT index;
227
228 if(!(index = emfdc_find_object( emf, obj ))) return;
229
230 emr.emr.iType = EMR_DELETEOBJECT;
231 emr.emr.nSize = sizeof(emr);
232 emr.ihObject = index;
233
234 emfdc_record( emf, &emr.emr );
235
236 emf->handles[index - 1] = 0;
237 emf->cur_handles--;
238 }
239
240 static DWORD emfdc_create_brush( struct emf *emf, HBRUSH brush )
241 {
242 DWORD index = 0;
243 LOGBRUSH logbrush;
244
245 if (!GetObjectA( brush, sizeof(logbrush), &logbrush )) return 0;
246
247 switch (logbrush.lbStyle) {
248 case BS_SOLID:
249 case BS_HATCHED:
250 case BS_NULL:
251 {
252 EMRCREATEBRUSHINDIRECT emr;
253 emr.emr.iType = EMR_CREATEBRUSHINDIRECT;
254 emr.emr.nSize = sizeof(emr);
255 emr.ihBrush = index = emfdc_add_handle( emf, brush );
256 emr.lb.lbStyle = logbrush.lbStyle;
257 emr.lb.lbColor = logbrush.lbColor;
258 emr.lb.lbHatch = logbrush.lbHatch;
259
260 if(!emfdc_record( emf, &emr.emr ))
261 index = 0;
262 }
263 break;
264 case BS_PATTERN:
265 case BS_DIBPATTERN:
266 {
267 EMRCREATEDIBPATTERNBRUSHPT *emr;
268 char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
269 BITMAPINFO *info = (BITMAPINFO *)buffer;
270 DWORD info_size;
271 UINT usage;
272
273 if (!__wine_get_brush_bitmap_info( brush, info, NULL, &usage )) break;
274 info_size = get_dib_info_size( info, usage );
275
276 emr = HeapAlloc( GetProcessHeap(), 0,
277 sizeof(EMRCREATEDIBPATTERNBRUSHPT) + sizeof(DWORD) +
278 info_size+info->bmiHeader.biSizeImage );
279 if(!emr) break;
280
281 /* FIXME: There is an extra DWORD written by native before the BMI.
282 * Not sure what it's meant to contain.
283 */
284 emr->offBmi = sizeof( EMRCREATEDIBPATTERNBRUSHPT ) + sizeof(DWORD);
285 *(DWORD *)(emr + 1) = 0x20000000;
286
287 if (logbrush.lbStyle == BS_PATTERN && info->bmiHeader.biBitCount == 1)
288 {
289 /* Presumably to reduce the size of the written EMF, MS supports an
290 * undocumented iUsage value of 2, indicating a mono bitmap without the
291 * 8 byte 2 entry black/white palette. Stupidly, they could have saved
292 * over 20 bytes more by also ignoring the BITMAPINFO fields that are
293 * irrelevant/constant for monochrome bitmaps.
294 * FIXME: It may be that the DIB functions themselves accept this value.
295 */
296 emr->emr.iType = EMR_CREATEMONOBRUSH;
297 usage = DIB_PAL_MONO;
298 emr->cbBmi = sizeof( BITMAPINFOHEADER );
299 }
300 else
301 {
302 emr->emr.iType = EMR_CREATEDIBPATTERNBRUSHPT;
303 emr->cbBmi = info_size;
304 }
305 emr->ihBrush = index = emfdc_add_handle( emf, brush );
306 emr->iUsage = usage;
307 emr->offBits = emr->offBmi + emr->cbBmi;
308 emr->cbBits = info->bmiHeader.biSizeImage;
309 emr->emr.nSize = emr->offBits + emr->cbBits;
310
311 if (info->bmiHeader.biClrUsed == 1 << info->bmiHeader.biBitCount)
312 info->bmiHeader.biClrUsed = 0;
313 memcpy( (BYTE *)emr + emr->offBmi, info, emr->cbBmi );
314 __wine_get_brush_bitmap_info( brush, NULL, (char *)emr + emr->offBits, NULL );
315
316 if (!emfdc_record( emf, &emr->emr )) index = 0;
317 HeapFree( GetProcessHeap(), 0, emr );
318 }
319 break;
320
321 default:
322 FIXME("Unknown style %x\n", logbrush.lbStyle);
323 break;
324 }
325
326 return index;
327 }
328
329 static BOOL emfdc_select_brush( DC_ATTR *dc_attr, HBRUSH brush )
330 {
331 struct emf *emf = dc_attr->emf;
332 EMRSELECTOBJECT emr;
333 DWORD index = 0;
334 int i;
335
336 /* If the object is a stock brush object, do not need to create it.
337 * See definitions in wingdi.h for range of stock brushes.
338 * We do however have to handle setting the higher order bit to
339 * designate that this is a stock object.
340 */
341 for (i = WHITE_BRUSH; i <= DC_BRUSH; i++)
342 {
343 if (brush == GetStockObject(i))
344 {
345 index = i | 0x80000000;
346 break;
347 }
348 }
349
350 if (!index && !(index = emfdc_find_object( emf, brush )))
351 {
352 if (!(index = emfdc_create_brush( emf, brush ))) return 0;
353 GDI_hdc_using_object( brush, dc_attr->hdc, emfdc_delete_object );
354 }
355
356 emr.emr.iType = EMR_SELECTOBJECT;
357 emr.emr.nSize = sizeof(emr);
358 emr.ihObject = index;
359 return emfdc_record( emf, &emr.emr );
360 }
361
362 static BOOL emfdc_create_font( struct emf *emf, HFONT font )
363 {
364 DWORD index = 0;
365 EMREXTCREATEFONTINDIRECTW emr;
366 int i;
367
368 if (!GetObjectW( font, sizeof(emr.elfw.elfLogFont), &emr.elfw.elfLogFont )) return FALSE;
369
370 emr.emr.iType = EMR_EXTCREATEFONTINDIRECTW;
371 emr.emr.nSize = (sizeof(emr) + 3) / 4 * 4;
372 emr.ihFont = index = emfdc_add_handle( emf, font );
373 emr.elfw.elfFullName[0] = '\0';
374 emr.elfw.elfStyle[0] = '\0';
375 emr.elfw.elfVersion = 0;
376 emr.elfw.elfStyleSize = 0;
377 emr.elfw.elfMatch = 0;
378 emr.elfw.elfReserved = 0;
379 for (i = 0; i < ELF_VENDOR_SIZE; i++)
380 emr.elfw.elfVendorId[i] = 0;
381 emr.elfw.elfCulture = PAN_CULTURE_LATIN;
382 emr.elfw.elfPanose.bFamilyType = PAN_NO_FIT;
383 emr.elfw.elfPanose.bSerifStyle = PAN_NO_FIT;
384 emr.elfw.elfPanose.bWeight = PAN_NO_FIT;
385 emr.elfw.elfPanose.bProportion = PAN_NO_FIT;
386 emr.elfw.elfPanose.bContrast = PAN_NO_FIT;
387 emr.elfw.elfPanose.bStrokeVariation = PAN_NO_FIT;
388 emr.elfw.elfPanose.bArmStyle = PAN_NO_FIT;
389 emr.elfw.elfPanose.bLetterform = PAN_NO_FIT;
390 emr.elfw.elfPanose.bMidline = PAN_NO_FIT;
391 emr.elfw.elfPanose.bXHeight = PAN_NO_FIT;
392
393 return emfdc_record( emf, &emr.emr ) ? index : 0;
394 }
395
396 static BOOL emfdc_select_font( DC_ATTR *dc_attr, HFONT font )
397 {
398 struct emf *emf = dc_attr->emf;
399 EMRSELECTOBJECT emr;
400 DWORD index;
401 int i;
402
403 /* If the object is a stock font object, do not need to create it.
404 * See definitions in wingdi.h for range of stock fonts.
405 * We do however have to handle setting the higher order bit to
406 * designate that this is a stock object.
407 */
408
409 for (i = OEM_FIXED_FONT; i <= DEFAULT_GUI_FONT; i++)
410 {
411 if (i != DEFAULT_PALETTE && font == GetStockObject(i))
412 {
413 index = i | 0x80000000;
414 goto found;
415 }
416 }
417
418 if (!(index = emfdc_find_object( emf, font )))
419 {
420 if (!(index = emfdc_create_font( emf, font ))) return FALSE;
421 GDI_hdc_using_object( font, dc_attr->hdc, emfdc_delete_object );
422 }
423
424 found:
425 emr.emr.iType = EMR_SELECTOBJECT;
426 emr.emr.nSize = sizeof(emr);
427 emr.ihObject = index;
428 return emfdc_record( emf, &emr.emr );
429 }
430
431 static DWORD emfdc_create_pen( struct emf *emf, HPEN hPen )
432 {
433 EMRCREATEPEN emr;
434 DWORD index = 0;
435
436 if (!GetObjectW( hPen, sizeof(emr.lopn), &emr.lopn ))
437 {
438 /* must be an extended pen */
439 EXTLOGPEN *elp;
440 INT size = GetObjectW( hPen, 0, NULL );
441
442 if (!size) return 0;
443
444 elp = HeapAlloc( GetProcessHeap(), 0, size );
445
446 GetObjectW( hPen, size, elp );
447 /* FIXME: add support for user style pens */
448 emr.lopn.lopnStyle = elp->elpPenStyle;
449 emr.lopn.lopnWidth.x = elp->elpWidth;
450 emr.lopn.lopnWidth.y = 0;
451 emr.lopn.lopnColor = elp->elpColor;
452
453 HeapFree( GetProcessHeap(), 0, elp );
454 }
455
456 emr.emr.iType = EMR_CREATEPEN;
457 emr.emr.nSize = sizeof(emr);
458 emr.ihPen = index = emfdc_add_handle( emf, hPen );
459 return emfdc_record( emf, &emr.emr ) ? index : 0;
460 }
461
462 static BOOL emfdc_select_pen( DC_ATTR *dc_attr, HPEN pen )
463 {
464 struct emf *emf = dc_attr->emf;
465 EMRSELECTOBJECT emr;
466 DWORD index = 0;
467 int i;
468
469 /* If the object is a stock pen object, do not need to create it.
470 * See definitions in wingdi.h for range of stock pens.
471 * We do however have to handle setting the higher order bit to
472 * designate that this is a stock object.
473 */
474
475 for (i = WHITE_PEN; i <= DC_PEN; i++)
476 {
477 if (pen == GetStockObject(i))
478 {
479 index = i | 0x80000000;
480 break;
481 }
482 }
483 if (!index && !(index = emfdc_find_object( emf, pen )))
484 {
485 if (!(index = emfdc_create_pen( emf, pen ))) return FALSE;
486 GDI_hdc_using_object( pen, dc_attr->hdc, emfdc_delete_object );
487 }
488
489 emr.emr.iType = EMR_SELECTOBJECT;
490 emr.emr.nSize = sizeof(emr);
491 emr.ihObject = index;
492 return emfdc_record( emf, &emr.emr );
493 }
494
495 static DWORD emfdc_create_palette( struct emf *emf, HPALETTE hPal )
496 {
497 WORD i;
498 struct {
499 EMRCREATEPALETTE hdr;
500 PALETTEENTRY entry[255];
501 } pal;
502
503 memset( &pal, 0, sizeof(pal) );
504
505 if (!GetObjectW( hPal, sizeof(pal.hdr.lgpl) + sizeof(pal.entry), &pal.hdr.lgpl ))
506 return 0;
507
508 for (i = 0; i < pal.hdr.lgpl.palNumEntries; i++)
509 pal.hdr.lgpl.palPalEntry[i].peFlags = 0;
510
511 pal.hdr.emr.iType = EMR_CREATEPALETTE;
512 pal.hdr.emr.nSize = sizeof(pal.hdr) + pal.hdr.lgpl.palNumEntries * sizeof(PALETTEENTRY);
513 pal.hdr.ihPal = emfdc_add_handle( emf, hPal );
514
515 if (!emfdc_record( emf, &pal.hdr.emr ))
516 pal.hdr.ihPal = 0;
517 return pal.hdr.ihPal;
518 }
519
520 BOOL EMFDC_SelectPalette( DC_ATTR *dc_attr, HPALETTE palette )
521 {
522 struct emf *emf = dc_attr->emf;
523 EMRSELECTPALETTE emr;
524 DWORD index = 0;
525
526 if (palette == GetStockObject( DEFAULT_PALETTE ))
527 {
528 index = DEFAULT_PALETTE | 0x80000000;
529 }
530 else if (!(index = emfdc_find_object( emf, palette )))
531 {
532 if (!(index = emfdc_create_palette( emf, palette ))) return 0;
533 GDI_hdc_using_object( palette, dc_attr->hdc, emfdc_delete_object );
534 }
535
536 emr.emr.iType = EMR_SELECTPALETTE;
537 emr.emr.nSize = sizeof(emr);
538 emr.ihPal = index;
539 return emfdc_record( emf, &emr.emr );
540 }
541
542 BOOL EMFDC_SelectObject( DC_ATTR *dc_attr, HGDIOBJ obj )
543 {
544 switch (gdi_handle_type( obj ))
545 {
546 case NTGDI_OBJ_BRUSH:
547 return emfdc_select_brush( dc_attr, obj );
548 case NTGDI_OBJ_FONT:
549 return emfdc_select_font( dc_attr, obj );
550 case NTGDI_OBJ_PEN:
551 case NTGDI_OBJ_EXTPEN:
552 return emfdc_select_pen( dc_attr, obj );
553 default:
554 return TRUE;
555 }
556 }
557
558 /* determine if we can use 16-bit points to store all the input points */
559 static BOOL can_use_short_points( const POINT *pts, UINT count )
560 {
561 UINT i;
562
563 for (i = 0; i < count; i++)
564 if (((pts[i].x + 0x8000) & ~0xffff) || ((pts[i].y + 0x8000) & ~0xffff))
565 return FALSE;
566 return TRUE;
567 }
568
569 /* store points in either long or short format; return a pointer to the end of the stored data */
570 static void *store_points( POINTL *dest, const POINT *pts, UINT count, BOOL short_points )
571 {
572 if (short_points)
573 {
574 UINT i;
575 POINTS *dest_short = (POINTS *)dest;
576
577 for (i = 0; i < count; i++)
578 {
579 dest_short[i].x = pts[i].x;
580 dest_short[i].y = pts[i].y;
581 }
582 return dest_short + count;
583 }
584 else
585 {
586 memcpy( dest, pts, count * sizeof(*dest) );
587 return dest + count;
588 }
589 }
590
591 /* compute the bounds of an array of points, optionally including the current position */
592 static void get_points_bounds( RECTL *bounds, const POINT *pts, UINT count, DC_ATTR *dc_attr )
593 {
594 UINT i;
595
596 if (dc_attr)
597 {
598 bounds->left = bounds->right = dc_attr->cur_pos.x;
599 bounds->top = bounds->bottom = dc_attr->cur_pos.y;
600 }
601 else if (count)
602 {
603 bounds->left = bounds->right = pts[0].x;
604 bounds->top = bounds->bottom = pts[0].y;
605 }
606 else *bounds = empty_bounds;
607
608 for (i = 0; i < count; i++)
609 {
610 bounds->left = min( bounds->left, pts[i].x );
611 bounds->right = max( bounds->right, pts[i].x );
612 bounds->top = min( bounds->top, pts[i].y );
613 bounds->bottom = max( bounds->bottom, pts[i].y );
614 }
615 }
616
617 /* helper for path stroke and fill functions */
618 static BOOL emfdrv_stroke_and_fill_path( struct emf *emf, INT type )
619 {
620 EMRSTROKEANDFILLPATH emr;
621 HRGN region;
622
623 emr.emr.iType = type;
624 emr.emr.nSize = sizeof(emr);
625 emr.rclBounds = empty_bounds;
626
627 if ((region = NtGdiPathToRegion( emf->dc_attr->hdc )))
628 {
629 NtGdiGetRgnBox( region, (RECT *)&emr.rclBounds );
630 DeleteObject( region );
631 }
632
633 if (!emfdc_record( emf, &emr.emr )) return FALSE;
634 if (!region) return FALSE;
635 emfdc_update_bounds( emf, &emr.rclBounds );
636 return TRUE;
637 }
638
639 BOOL EMFDC_MoveTo( DC_ATTR *dc_attr, INT x, INT y )
640 {
641 struct emf *emf = dc_attr->emf;
642 EMRMOVETOEX emr;
643
644 emr.emr.iType = EMR_MOVETOEX;
645 emr.emr.nSize = sizeof(emr);
646 emr.ptl.x = x;
647 emr.ptl.y = y;
648 return emfdc_record( emf, &emr.emr );
649 }
650
651 BOOL EMFDC_LineTo( DC_ATTR *dc_attr, INT x, INT y )
652 {
653 EMRLINETO emr;
654
655 emr.emr.iType = EMR_LINETO;
656 emr.emr.nSize = sizeof(emr);
657 emr.ptl.x = x;
658 emr.ptl.y = y;
659 return emfdc_record( dc_attr->emf, &emr.emr );
660 }
661
662 BOOL EMFDC_ArcChordPie( DC_ATTR *dc_attr, INT left, INT top, INT right, INT bottom,
663 INT xstart, INT ystart, INT xend, INT yend, DWORD type )
664 {
665 struct emf *emf = dc_attr->emf;
666 EMRARC emr;
667 INT temp;
668
669 if (left == right || top == bottom) return FALSE;
670
671 if (left > right) { temp = left; left = right; right = temp; }
672 if (top > bottom) { temp = top; top = bottom; bottom = temp; }
673
674 if (dc_attr->graphics_mode == GM_COMPATIBLE)
675 {
676 right--;
677 bottom--;
678 }
679
680 emr.emr.iType = type;
681 emr.emr.nSize = sizeof(emr);
682 emr.rclBox.left = left;
683 emr.rclBox.top = top;
684 emr.rclBox.right = right;
685 emr.rclBox.bottom = bottom;
686 emr.ptlStart.x = xstart;
687 emr.ptlStart.y = ystart;
688 emr.ptlEnd.x = xend;
689 emr.ptlEnd.y = yend;
690 return emfdc_record( emf, &emr.emr );
691 }
692
693 BOOL EMFDC_AngleArc( DC_ATTR *dc_attr, INT x, INT y, DWORD radius, FLOAT start, FLOAT sweep )
694 {
695 EMRANGLEARC emr;
696
697 emr.emr.iType = EMR_ANGLEARC;
698 emr.emr.nSize = sizeof( emr );
699 emr.ptlCenter.x = x;
700 emr.ptlCenter.y = y;
701 emr.nRadius = radius;
702 emr.eStartAngle = start;
703 emr.eSweepAngle = sweep;
704 return emfdc_record( dc_attr->emf, &emr.emr );
705 }
706
707 BOOL EMFDC_Ellipse( DC_ATTR *dc_attr, INT left, INT top, INT right, INT bottom )
708 {
709 struct emf *emf = dc_attr->emf;
710 EMRELLIPSE emr;
711
712 if (left == right || top == bottom) return FALSE;
713
714 emr.emr.iType = EMR_ELLIPSE;
715 emr.emr.nSize = sizeof(emr);
716 emr.rclBox.left = min( left, right );
717 emr.rclBox.top = min( top, bottom );
718 emr.rclBox.right = max( left, right );
719 emr.rclBox.bottom = max( top, bottom );
720 if (dc_attr->graphics_mode == GM_COMPATIBLE)
721 {
722 emr.rclBox.right--;
723 emr.rclBox.bottom--;
724 }
725 return emfdc_record( emf, &emr.emr );
726 }
727
728 BOOL EMFDC_Rectangle( DC_ATTR *dc_attr, INT left, INT top, INT right, INT bottom )
729 {
730 struct emf *emf = dc_attr->emf;
731 EMRRECTANGLE emr;
732
733 if(left == right || top == bottom) return FALSE;
734
735 emr.emr.iType = EMR_RECTANGLE;
736 emr.emr.nSize = sizeof(emr);
737 emr.rclBox.left = min( left, right );
738 emr.rclBox.top = min( top, bottom );
739 emr.rclBox.right = max( left, right );
740 emr.rclBox.bottom = max( top, bottom );
741 if (dc_attr->graphics_mode == GM_COMPATIBLE)
742 {
743 emr.rclBox.right--;
744 emr.rclBox.bottom--;
745 }
746 return emfdc_record( emf, &emr.emr );
747 }
748
749 BOOL EMFDC_RoundRect( DC_ATTR *dc_attr, INT left, INT top, INT right,
750 INT bottom, INT ell_width, INT ell_height )
751 {
752 struct emf *emf = dc_attr->emf;
753 EMRROUNDRECT emr;
754
755 if (left == right || top == bottom) return FALSE;
756
757 emr.emr.iType = EMR_ROUNDRECT;
758 emr.emr.nSize = sizeof(emr);
759 emr.rclBox.left = min( left, right );
760 emr.rclBox.top = min( top, bottom );
761 emr.rclBox.right = max( left, right );
762 emr.rclBox.bottom = max( top, bottom );
763 emr.szlCorner.cx = ell_width;
764 emr.szlCorner.cy = ell_height;
765 if (dc_attr->graphics_mode == GM_COMPATIBLE)
766 {
767 emr.rclBox.right--;
768 emr.rclBox.bottom--;
769 }
770 return emfdc_record( emf, &emr.emr );
771 }
772
773 BOOL EMFDC_SetPixel( DC_ATTR *dc_attr, INT x, INT y, COLORREF color )
774 {
775 EMRSETPIXELV emr;
776
777 emr.emr.iType = EMR_SETPIXELV;
778 emr.emr.nSize = sizeof(emr);
779 emr.ptlPixel.x = x;
780 emr.ptlPixel.y = y;
781 emr.crColor = color;
782 return emfdc_record( dc_attr->emf, &emr.emr );
783 }
784
785 static BOOL emfdc_polylinegon( DC_ATTR *dc_attr, const POINT *points, INT count, DWORD type )
786 {
787 struct emf *emf = dc_attr->emf;
788 EMRPOLYLINE *emr;
789 DWORD size;
790 BOOL ret, use_small_emr = can_use_short_points( points, count );
791
792 size = use_small_emr ? offsetof( EMRPOLYLINE16, apts[count] ) : offsetof( EMRPOLYLINE, aptl[count] );
793
794 emr = HeapAlloc( GetProcessHeap(), 0, size );
795 emr->emr.iType = use_small_emr ? type + EMR_POLYLINE16 - EMR_POLYLINE : type;
796 emr->emr.nSize = size;
797 emr->cptl = count;
798
799 store_points( emr->aptl, points, count, use_small_emr );
800
801 if (!emf->path)
802 get_points_bounds( &emr->rclBounds, points, count,
803 (type == EMR_POLYBEZIERTO || type == EMR_POLYLINETO) ? dc_attr : 0 );
804 else
805 emr->rclBounds = empty_bounds;
806
807 ret = emfdc_record( emf, &emr->emr );
808 if (ret && !emf->path) emfdc_update_bounds( emf, &emr->rclBounds );
809 HeapFree( GetProcessHeap(), 0, emr );
810 return ret;
811 }
812
813 BOOL EMFDC_Polyline( DC_ATTR *dc_attr, const POINT *points, INT count )
814 {
815 return emfdc_polylinegon( dc_attr, points, count, EMR_POLYLINE );
816 }
817
818 BOOL EMFDC_PolylineTo( DC_ATTR *dc_attr, const POINT *points, INT count )
819 {
820 return emfdc_polylinegon( dc_attr, points, count, EMR_POLYLINETO );
821 }
822
823 BOOL EMFDC_Polygon( DC_ATTR *dc_attr, const POINT *pt, INT count )
824 {
825 if(count < 2) return FALSE;
826 return emfdc_polylinegon( dc_attr, pt, count, EMR_POLYGON );
827 }
828
829 BOOL EMFDC_PolyBezier( DC_ATTR *dc_attr, const POINT *pts, DWORD count )
830 {
831 return emfdc_polylinegon( dc_attr, pts, count, EMR_POLYBEZIER );
832 }
833
834 BOOL EMFDC_PolyBezierTo( DC_ATTR *dc_attr, const POINT *pts, DWORD count )
835 {
836 return emfdc_polylinegon( dc_attr, pts, count, EMR_POLYBEZIERTO );
837 }
838
839 static BOOL emfdc_poly_polylinegon( struct emf *emf, const POINT *pt, const INT *counts,
840 UINT polys, DWORD type)
841 {
842 EMRPOLYPOLYLINE *emr;
843 DWORD cptl = 0, poly, size;
844 BOOL ret, use_small_emr, bounds_valid = TRUE;
845
846 for(poly = 0; poly < polys; poly++) {
847 cptl += counts[poly];
848 if(counts[poly] < 2) bounds_valid = FALSE;
849 }
850 if(!cptl) bounds_valid = FALSE;
851 use_small_emr = can_use_short_points( pt, cptl );
852
853 size = FIELD_OFFSET(EMRPOLYPOLYLINE, aPolyCounts[polys]);
854 if(use_small_emr)
855 size += cptl * sizeof(POINTS);
856 else
857 size += cptl * sizeof(POINTL);
858
859 emr = HeapAlloc( GetProcessHeap(), 0, size );
860
861 emr->emr.iType = type;
862 if(use_small_emr) emr->emr.iType += EMR_POLYPOLYLINE16 - EMR_POLYPOLYLINE;
863
864 emr->emr.nSize = size;
865 if(bounds_valid && !emf->path)
866 get_points_bounds( &emr->rclBounds, pt, cptl, 0 );
867 else
868 emr->rclBounds = empty_bounds;
869 emr->nPolys = polys;
870 emr->cptl = cptl;
871
872 if(polys)
873 {
874 memcpy( emr->aPolyCounts, counts, polys * sizeof(DWORD) );
875 store_points( (POINTL *)(emr->aPolyCounts + polys), pt, cptl, use_small_emr );
876 }
877
878 ret = emfdc_record( emf, &emr->emr );
879 if(ret && !bounds_valid)
880 {
881 ret = FALSE;
882 SetLastError( ERROR_INVALID_PARAMETER );
883 }
884 if(ret && !emf->path)
885 emfdc_update_bounds( emf, &emr->rclBounds );
886 HeapFree( GetProcessHeap(), 0, emr );
887 return ret;
888 }
889
890 BOOL EMFDC_PolyPolyline( DC_ATTR *dc_attr, const POINT *pt, const DWORD *counts, DWORD polys)
891 {
892 return emfdc_poly_polylinegon( dc_attr->emf, pt, (const INT *)counts, polys, EMR_POLYPOLYLINE );
893 }
894
895 BOOL EMFDC_PolyPolygon( DC_ATTR *dc_attr, const POINT *pt, const INT *counts, UINT polys )
896 {
897 return emfdc_poly_polylinegon( dc_attr->emf, pt, counts, polys, EMR_POLYPOLYGON );
898 }
899
900 BOOL EMFDC_PolyDraw( DC_ATTR *dc_attr, const POINT *pts, const BYTE *types, DWORD count )
901 {
902 struct emf *emf = dc_attr->emf;
903 EMRPOLYDRAW *emr;
904 BOOL ret;
905 BYTE *types_dest;
906 BOOL use_small_emr = can_use_short_points( pts, count );
907 DWORD size;
908
909 size = use_small_emr ? offsetof( EMRPOLYDRAW16, apts[count] )
910 : offsetof( EMRPOLYDRAW, aptl[count] );
911 size += (count + 3) & ~3;
912
913 if (!(emr = HeapAlloc( GetProcessHeap(), 0, size ))) return FALSE;
914
915 emr->emr.iType = use_small_emr ? EMR_POLYDRAW16 : EMR_POLYDRAW;
916 emr->emr.nSize = size;
917 emr->cptl = count;
918
919 types_dest = store_points( emr->aptl, pts, count, use_small_emr );
920 memcpy( types_dest, types, count );
921 if (count & 3) memset( types_dest + count, 0, 4 - (count & 3) );
922
923 if (!emf->path)
924 get_points_bounds( &emr->rclBounds, pts, count, 0 );
925 else
926 emr->rclBounds = empty_bounds;
927
928 ret = emfdc_record( emf, &emr->emr );
929 if (ret && !emf->path) emfdc_update_bounds( emf, &emr->rclBounds );
930 HeapFree( GetProcessHeap(), 0, emr );
931 return ret;
932 }
933
934 BOOL EMFDC_ExtFloodFill( DC_ATTR *dc_attr, INT x, INT y, COLORREF color, UINT fill_type )
935 {
936 EMREXTFLOODFILL emr;
937
938 emr.emr.iType = EMR_EXTFLOODFILL;
939 emr.emr.nSize = sizeof(emr);
940 emr.ptlStart.x = x;
941 emr.ptlStart.y = y;
942 emr.crColor = color;
943 emr.iMode = fill_type;
944 return emfdc_record( dc_attr->emf, &emr.emr );
945 }
946
947 BOOL EMFDC_FillRgn( DC_ATTR *dc_attr, HRGN hrgn, HBRUSH hbrush )
948 {
949 struct emf *emf = dc_attr->emf;
950 EMRFILLRGN *emr;
951 DWORD size, rgnsize, index;
952 BOOL ret;
953
954 if (!(index = emfdc_create_brush( emf, hbrush ))) return FALSE;
955
956 rgnsize = NtGdiGetRegionData( hrgn, 0, NULL );
957 size = rgnsize + offsetof(EMRFILLRGN,RgnData);
958 emr = HeapAlloc( GetProcessHeap(), 0, size );
959
960 NtGdiGetRegionData( hrgn, rgnsize, (RGNDATA *)&emr->RgnData );
961
962 emr->emr.iType = EMR_FILLRGN;
963 emr->emr.nSize = size;
964 emr->rclBounds.left = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.left;
965 emr->rclBounds.top = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.top;
966 emr->rclBounds.right = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.right - 1;
967 emr->rclBounds.bottom = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.bottom - 1;
968 emr->cbRgnData = rgnsize;
969 emr->ihBrush = index;
970
971 ret = emfdc_record( emf, &emr->emr );
972 if (ret) emfdc_update_bounds( emf, &emr->rclBounds );
973 HeapFree( GetProcessHeap(), 0, emr );
974 return ret;
975 }
976
977 BOOL EMFDC_FrameRgn( DC_ATTR *dc_attr, HRGN hrgn, HBRUSH hbrush, INT width, INT height )
978 {
979 struct emf *emf = dc_attr->emf;
980 EMRFRAMERGN *emr;
981 DWORD size, rgnsize, index;
982 BOOL ret;
983
984 index = emfdc_create_brush( emf, hbrush );
985 if(!index) return FALSE;
986
987 rgnsize = NtGdiGetRegionData( hrgn, 0, NULL );
988 size = rgnsize + offsetof(EMRFRAMERGN,RgnData);
989 emr = HeapAlloc( GetProcessHeap(), 0, size );
990
991 NtGdiGetRegionData( hrgn, rgnsize, (RGNDATA *)&emr->RgnData );
992
993 emr->emr.iType = EMR_FRAMERGN;
994 emr->emr.nSize = size;
995 emr->rclBounds.left = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.left;
996 emr->rclBounds.top = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.top;
997 emr->rclBounds.right = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.right - 1;
998 emr->rclBounds.bottom = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.bottom - 1;
999 emr->cbRgnData = rgnsize;
1000 emr->ihBrush = index;
1001 emr->szlStroke.cx = width;
1002 emr->szlStroke.cy = height;
1003
1004 ret = emfdc_record( emf, &emr->emr );
1005 if (ret) emfdc_update_bounds( emf, &emr->rclBounds );
1006 HeapFree( GetProcessHeap(), 0, emr );
1007 return ret;
1008 }
1009
1010 static BOOL emfdc_paint_invert_region( struct emf *emf, HRGN hrgn, DWORD iType )
1011 {
1012 EMRINVERTRGN *emr;
1013 DWORD size, rgnsize;
1014 BOOL ret;
1015
1016 rgnsize = NtGdiGetRegionData( hrgn, 0, NULL );
1017 size = rgnsize + offsetof(EMRINVERTRGN,RgnData);
1018 emr = HeapAlloc( GetProcessHeap(), 0, size );
1019
1020 NtGdiGetRegionData( hrgn, rgnsize, (RGNDATA *)&emr->RgnData );
1021
1022 emr->emr.iType = iType;
1023 emr->emr.nSize = size;
1024 emr->rclBounds.left = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.left;
1025 emr->rclBounds.top = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.top;
1026 emr->rclBounds.right = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.right - 1;
1027 emr->rclBounds.bottom = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.bottom - 1;
1028 emr->cbRgnData = rgnsize;
1029
1030 ret = emfdc_record( emf, &emr->emr );
1031 if (ret) emfdc_update_bounds( emf, &emr->rclBounds );
1032 HeapFree( GetProcessHeap(), 0, emr );
1033 return ret;
1034 }
1035
1036 BOOL EMFDC_PaintRgn( DC_ATTR *dc_attr, HRGN hrgn )
1037 {
1038 return emfdc_paint_invert_region( dc_attr->emf, hrgn, EMR_PAINTRGN );
1039 }
1040
1041 BOOL EMFDC_InvertRgn( DC_ATTR *dc_attr, HRGN hrgn )
1042 {
1043 return emfdc_paint_invert_region( dc_attr->emf, hrgn, EMR_INVERTRGN );
1044 }
1045
1046 BOOL EMFDC_ExtTextOut( DC_ATTR *dc_attr, INT x, INT y, UINT flags, const RECT *rect,
1047 const WCHAR *str, UINT count, const INT *dx )
1048 {
1049 struct emf *emf = dc_attr->emf;
1050 FLOAT ex_scale, ey_scale;
1051 EMREXTTEXTOUTW *emr;
1052 int text_height = 0;
1053 int text_width = 0;
1054 TEXTMETRICW tm;
1055 DWORD size;
1056 BOOL ret;
1057
1058 size = sizeof(*emr) + ((count+1) & ~1) * sizeof(WCHAR) + count * sizeof(INT);
1059
1060 TRACE( "%s %s count %d size = %d\n", debugstr_wn(str, count),
1061 wine_dbgstr_rect(rect), count, size );
1062 emr = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size );
1063
1064 if (dc_attr->graphics_mode == GM_COMPATIBLE)
1065 {
1066 const INT horzSize = GetDeviceCaps( dc_attr->hdc, HORZSIZE );
1067 const INT horzRes = GetDeviceCaps( dc_attr->hdc, HORZRES );
1068 const INT vertSize = GetDeviceCaps( dc_attr->hdc, VERTSIZE );
1069 const INT vertRes = GetDeviceCaps( dc_attr->hdc, VERTRES );
1070 SIZE wndext, vportext;
1071
1072 GetViewportExtEx( dc_attr->hdc, &vportext );
1073 GetWindowExtEx( dc_attr->hdc, &wndext );
1074 ex_scale = 100.0 * ((FLOAT)horzSize / (FLOAT)horzRes) /
1075 ((FLOAT)wndext.cx / (FLOAT)vportext.cx);
1076 ey_scale = 100.0 * ((FLOAT)vertSize / (FLOAT)vertRes) /
1077 ((FLOAT)wndext.cy / (FLOAT)vportext.cy);
1078 }
1079 else
1080 {
1081 ex_scale = 0.0;
1082 ey_scale = 0.0;
1083 }
1084
1085 emr->emr.iType = EMR_EXTTEXTOUTW;
1086 emr->emr.nSize = size;
1087 emr->iGraphicsMode = dc_attr->graphics_mode;
1088 emr->exScale = ex_scale;
1089 emr->eyScale = ey_scale;
1090 emr->emrtext.ptlReference.x = x;
1091 emr->emrtext.ptlReference.y = y;
1092 emr->emrtext.nChars = count;
1093 emr->emrtext.offString = sizeof(*emr);
1094 memcpy( (char*)emr + emr->emrtext.offString, str, count * sizeof(WCHAR) );
1095 emr->emrtext.fOptions = flags;
1096 if (!rect)
1097 {
1098 emr->emrtext.rcl.left = emr->emrtext.rcl.top = 0;
1099 emr->emrtext.rcl.right = emr->emrtext.rcl.bottom = -1;
1100 }
1101 else
1102 {
1103 emr->emrtext.rcl.left = rect->left;
1104 emr->emrtext.rcl.top = rect->top;
1105 emr->emrtext.rcl.right = rect->right;
1106 emr->emrtext.rcl.bottom = rect->bottom;
1107 }
1108
1109 emr->emrtext.offDx = emr->emrtext.offString + ((count+1) & ~1) * sizeof(WCHAR);
1110 if (dx)
1111 {
1112 UINT i;
1113 SIZE str_size;
1114 memcpy( (char*)emr + emr->emrtext.offDx, dx, count * sizeof(INT) );
1115 for (i = 0; i < count; i++) text_width += dx[i];
1116 if (GetTextExtentPoint32W( dc_attr->hdc, str, count, &str_size ))
1117 text_height = str_size.cy;
1118 }
1119 else
1120 {
1121 UINT i;
1122 INT *emf_dx = (INT *)((char*)emr + emr->emrtext.offDx);
1123 SIZE charSize;
1124 for (i = 0; i < count; i++)
1125 {
1126 if (GetTextExtentPoint32W( dc_attr->hdc, str + i, 1, &charSize ))
1127 {
1128 emf_dx[i] = charSize.cx;
1129 text_width += charSize.cx;
1130 text_height = max( text_height, charSize.cy );
1131 }
1132 }
1133 }
1134
1135 if (emf->path)
1136 {
1137 emr->rclBounds.left = emr->rclBounds.top = 0;
1138 emr->rclBounds.right = emr->rclBounds.bottom = -1;
1139 goto no_bounds;
1140 }
1141
1142 /* FIXME: handle font escapement */
1143 switch (dc_attr->text_align & (TA_LEFT | TA_RIGHT | TA_CENTER))
1144 {
1145 case TA_CENTER:
1146 emr->rclBounds.left = x - (text_width / 2) - 1;
1147 emr->rclBounds.right = x + (text_width / 2) + 1;
1148 break;
1149
1150 case TA_RIGHT:
1151 emr->rclBounds.left = x - text_width - 1;
1152 emr->rclBounds.right = x;
1153 break;
1154
1155 default: /* TA_LEFT */
1156 emr->rclBounds.left = x;
1157 emr->rclBounds.right = x + text_width + 1;
1158 }
1159
1160 switch (dc_attr->text_align & (TA_TOP | TA_BOTTOM | TA_BASELINE))
1161 {
1162 case TA_BASELINE:
1163 if (!GetTextMetricsW( dc_attr->hdc, &tm )) tm.tmDescent = 0;
1164 /* Play safe here... it's better to have a bounding box */
1165 /* that is too big than too small. */
1166 emr->rclBounds.top = y - text_height - 1;
1167 emr->rclBounds.bottom = y + tm.tmDescent + 1;
1168 break;
1169
1170 case TA_BOTTOM:
1171 emr->rclBounds.top = y - text_height - 1;
1172 emr->rclBounds.bottom = y;
1173 break;
1174
1175 default: /* TA_TOP */
1176 emr->rclBounds.top = y;
1177 emr->rclBounds.bottom = y + text_height + 1;
1178 }
1179 emfdc_update_bounds( emf, &emr->rclBounds );
1180
1181 no_bounds:
1182 ret = emfdc_record( emf, &emr->emr );
1183 HeapFree( GetProcessHeap(), 0, emr );
1184 return ret;
1185 }
1186
1187 BOOL EMFDC_GradientFill( DC_ATTR *dc_attr, TRIVERTEX *vert_array, ULONG nvert,
1188 void *grad_array, ULONG ngrad, ULONG mode )
1189 {
1190 EMRGRADIENTFILL *emr;
1191 ULONG i, pt, size, num_pts = ngrad * (mode == GRADIENT_FILL_TRIANGLE ? 3 : 2);
1192 const ULONG *pts = (const ULONG *)grad_array;
1193 BOOL ret;
1194
1195 size = FIELD_OFFSET(EMRGRADIENTFILL, Ver[nvert]) + num_pts * sizeof(pts[0]);
1196
1197 emr = HeapAlloc( GetProcessHeap(), 0, size );
1198 if (!emr) return FALSE;
1199
1200 for (i = 0; i < num_pts; i++)
1201 {
1202 pt = pts[i];
1203
1204 if (i == 0)
1205 {
1206 emr->rclBounds.left = emr->rclBounds.right = vert_array[pt].x;
1207 emr->rclBounds.top = emr->rclBounds.bottom = vert_array[pt].y;
1208 }
1209 else
1210 {
1211 if (vert_array[pt].x < emr->rclBounds.left)
1212 emr->rclBounds.left = vert_array[pt].x;
1213 else if (vert_array[pt].x > emr->rclBounds.right)
1214 emr->rclBounds.right = vert_array[pt].x;
1215 if (vert_array[pt].y < emr->rclBounds.top)
1216 emr->rclBounds.top = vert_array[pt].y;
1217 else if (vert_array[pt].y > emr->rclBounds.bottom)
1218 emr->rclBounds.bottom = vert_array[pt].y;
1219 }
1220 }
1221 emr->rclBounds.right--;
1222 emr->rclBounds.bottom--;
1223
1224 emr->emr.iType = EMR_GRADIENTFILL;
1225 emr->emr.nSize = size;
1226 emr->nVer = nvert;
1227 emr->nTri = ngrad;
1228 emr->ulMode = mode;
1229 memcpy( emr->Ver, vert_array, nvert * sizeof(vert_array[0]) );
1230 memcpy( emr->Ver + nvert, pts, num_pts * sizeof(pts[0]) );
1231
1232 emfdc_update_bounds( dc_attr->emf, &emr->rclBounds );
1233 ret = emfdc_record( dc_attr->emf, &emr->emr );
1234 HeapFree( GetProcessHeap(), 0, emr );
1235 return ret;
1236 }
1237
1238 BOOL EMFDC_FillPath( DC_ATTR *dc_attr )
1239 {
1240 return emfdrv_stroke_and_fill_path( dc_attr->emf, EMR_FILLPATH );
1241 }
1242
1243 BOOL EMFDC_StrokeAndFillPath( DC_ATTR *dc_attr )
1244 {
1245 return emfdrv_stroke_and_fill_path( dc_attr->emf, EMR_STROKEANDFILLPATH );
1246 }
1247
1248 BOOL EMFDC_StrokePath( DC_ATTR *dc_attr )
1249 {
1250 return emfdrv_stroke_and_fill_path( dc_attr->emf, EMR_STROKEPATH );
1251 }
1252
1253 /* Generate an EMRBITBLT, EMRSTRETCHBLT or EMRALPHABLEND record depending on the type parameter */
1254 static BOOL emfdrv_stretchblt( struct emf *emf, INT x_dst, INT y_dst, INT width_dst, INT height_dst,
1255 HDC hdc_src, INT x_src, INT y_src, INT width_src, INT height_src,
1256 DWORD rop, DWORD type )
1257 {
1258 BITMAPINFO src_info = {{ sizeof( src_info.bmiHeader ) }};
1259 UINT bmi_size, emr_size, size;
1260 HBITMAP bitmap, blit_bitmap = NULL;
1261 EMRBITBLT *emr = NULL;
1262 BITMAPINFO *bmi;
1263 HDC blit_dc;
1264 BOOL ret = FALSE;
1265
1266 if (!(bitmap = GetCurrentObject( hdc_src, OBJ_BITMAP ))) return FALSE;
1267
1268 blit_dc = hdc_src;
1269 blit_bitmap = bitmap;
1270 if (!(bmi_size = get_bitmap_info( &blit_dc, &blit_bitmap, &src_info ))) return FALSE;
1271
1272 /* EMRSTRETCHBLT and EMRALPHABLEND have the same structure */
1273 emr_size = type == EMR_BITBLT ? sizeof(EMRBITBLT) : sizeof(EMRSTRETCHBLT);
1274 size = emr_size + bmi_size + src_info.bmiHeader.biSizeImage;
1275
1276 if (!(emr = HeapAlloc(GetProcessHeap(), 0, size))) goto err;
1277
1278 emr->emr.iType = type;
1279 emr->emr.nSize = size;
1280 emr->rclBounds.left = x_dst;
1281 emr->rclBounds.top = y_dst;
1282 emr->rclBounds.right = x_dst + width_dst - 1;
1283 emr->rclBounds.bottom = y_dst + height_dst - 1;
1284 emr->xDest = x_dst;
1285 emr->yDest = y_dst;
1286 emr->cxDest = width_dst;
1287 emr->cyDest = height_dst;
1288 emr->xSrc = x_src;
1289 emr->ySrc = y_src;
1290 if (type != EMR_BITBLT)
1291 {
1292 EMRSTRETCHBLT *emr_stretchblt = (EMRSTRETCHBLT *)emr;
1293 emr_stretchblt->cxSrc = width_src;
1294 emr_stretchblt->cySrc = height_src;
1295 }
1296 emr->dwRop = rop;
1297 NtGdiGetTransform( hdc_src, 0x204, &emr->xformSrc );
1298 emr->crBkColorSrc = GetBkColor( hdc_src );
1299 emr->iUsageSrc = DIB_RGB_COLORS;
1300 emr->offBmiSrc = emr_size;
1301 emr->cbBmiSrc = bmi_size;
1302 emr->offBitsSrc = emr_size + bmi_size;
1303 emr->cbBitsSrc = src_info.bmiHeader.biSizeImage;
1304
1305 bmi = (BITMAPINFO *)((BYTE *)emr + emr->offBmiSrc);
1306 bmi->bmiHeader = src_info.bmiHeader;
1307 ret = GetDIBits( blit_dc, blit_bitmap, 0, src_info.bmiHeader.biHeight,
1308 (BYTE *)emr + emr->offBitsSrc, bmi, DIB_RGB_COLORS );
1309 if (ret)
1310 {
1311 ret = emfdc_record( emf, (EMR *)emr );
1312 if (ret) emfdc_update_bounds( emf, &emr->rclBounds );
1313 }
1314
1315 err:
1316 HeapFree( GetProcessHeap(), 0, emr );
1317 if (blit_bitmap != bitmap) DeleteObject( blit_bitmap );
1318 if (blit_dc != hdc_src) DeleteDC( blit_dc );
1319 return ret;
1320 }
1321
1322 BOOL EMFDC_AlphaBlend( DC_ATTR *dc_attr, INT x_dst, INT y_dst, INT width_dst, INT height_dst,
1323 HDC hdc_src, INT x_src, INT y_src, INT width_src, INT height_src,
1324 BLENDFUNCTION blend_function )
1325 {
1326 return emfdrv_stretchblt( dc_attr->emf, x_dst, y_dst, width_dst, height_dst, hdc_src,
1327 x_src, y_src, width_src, height_src, *(DWORD *)&blend_function,
1328 EMR_ALPHABLEND );
1329 }
1330
1331 BOOL EMFDC_PatBlt( DC_ATTR *dc_attr, INT left, INT top, INT width, INT height, DWORD rop )
1332 {
1333 struct emf *emf = dc_attr->emf;
1334 EMRBITBLT emr;
1335 BOOL ret;
1336
1337 emr.emr.iType = EMR_BITBLT;
1338 emr.emr.nSize = sizeof(emr);
1339 emr.rclBounds.left = left;
1340 emr.rclBounds.top = top;
1341 emr.rclBounds.right = left + width - 1;
1342 emr.rclBounds.bottom = top + height - 1;
1343 emr.xDest = left;
1344 emr.yDest = top;
1345 emr.cxDest = width;
1346 emr.cyDest = height;
1347 emr.dwRop = rop;
1348 emr.xSrc = 0;
1349 emr.ySrc = 0;
1350 emr.xformSrc.eM11 = 1.0;
1351 emr.xformSrc.eM12 = 0.0;
1352 emr.xformSrc.eM21 = 0.0;
1353 emr.xformSrc.eM22 = 1.0;
1354 emr.xformSrc.eDx = 0.0;
1355 emr.xformSrc.eDy = 0.0;
1356 emr.crBkColorSrc = 0;
1357 emr.iUsageSrc = 0;
1358 emr.offBmiSrc = 0;
1359 emr.cbBmiSrc = 0;
1360 emr.offBitsSrc = 0;
1361 emr.cbBitsSrc = 0;
1362
1363 ret = emfdc_record( emf, &emr.emr );
1364 if (ret) emfdc_update_bounds( emf, &emr.rclBounds );
1365 return ret;
1366 }
1367
1368 static inline BOOL rop_uses_src( DWORD rop )
1369 {
1370 return ((rop >> 2) & 0x330000) != (rop & 0x330000);
1371 }
1372
1373 BOOL EMFDC_BitBlt( DC_ATTR *dc_attr, INT x_dst, INT y_dst, INT width, INT height,
1374 HDC hdc_src, INT x_src, INT y_src, DWORD rop )
1375 {
1376 if (!rop_uses_src( rop )) return EMFDC_PatBlt( dc_attr, x_dst, y_dst, width, height, rop );
1377 return emfdrv_stretchblt( dc_attr->emf, x_dst, y_dst, width, height,
1378 hdc_src, x_src, y_src, width, height, rop, EMR_BITBLT );
1379 }
1380
1381 BOOL EMFDC_StretchBlt( DC_ATTR *dc_attr, INT x_dst, INT y_dst, INT width_dst, INT height_dst,
1382 HDC hdc_src, INT x_src, INT y_src, INT width_src, INT height_src,
1383 DWORD rop )
1384 {
1385 if (!rop_uses_src( rop )) return EMFDC_PatBlt( dc_attr, x_dst, y_dst, width_dst, height_dst, rop );
1386 return emfdrv_stretchblt( dc_attr->emf, x_dst, y_dst, width_dst, height_dst,
1387 hdc_src, x_src, y_src, width_src,
1388 height_src, rop, EMR_STRETCHBLT );
1389 }
1390
1391 BOOL EMFDC_TransparentBlt( DC_ATTR *dc_attr, int x_dst, int y_dst, int width_dst, int height_dst,
1392 HDC hdc_src, int x_src, int y_src, int width_src, int height_src,
1393 UINT color )
1394 {
1395 return emfdrv_stretchblt( dc_attr->emf, x_dst, y_dst, width_dst, height_dst,
1396 hdc_src, x_src, y_src, width_src,
1397 height_src, color, EMR_TRANSPARENTBLT );
1398 }
1399
1400 BOOL EMFDC_MaskBlt( DC_ATTR *dc_attr, INT x_dst, INT y_dst, INT width_dst, INT height_dst,
1401 HDC hdc_src, INT x_src, INT y_src, HBITMAP mask,
1402 INT x_mask, INT y_mask, DWORD rop )
1403 {
1404 unsigned char mask_info_buffer[FIELD_OFFSET(BITMAPINFO, bmiColors[256])];
1405 BITMAPINFO *mask_bits_info = (BITMAPINFO *)mask_info_buffer;
1406 struct emf *emf = dc_attr->emf;
1407 BITMAPINFO mask_info = {{ sizeof( mask_info.bmiHeader ) }};
1408 BITMAPINFO src_info = {{ sizeof( src_info.bmiHeader ) }};
1409 HBITMAP bitmap, blit_bitmap = NULL, mask_bitmap = NULL;
1410 UINT bmi_size, size, mask_info_size = 0;
1411 EMRMASKBLT *emr = NULL;
1412 BITMAPINFO *bmi;
1413 HDC blit_dc, mask_dc = NULL;
1414 BOOL ret = FALSE;
1415
1416 if (!rop_uses_src( rop ))
1417 return EMFDC_PatBlt( dc_attr, x_dst, y_dst, width_dst, height_dst, rop );
1418
1419 if (!(bitmap = GetCurrentObject( hdc_src, OBJ_BITMAP ))) return FALSE;
1420 blit_dc = hdc_src;
1421 blit_bitmap = bitmap;
1422 if (!(bmi_size = get_bitmap_info( &blit_dc, &blit_bitmap, &src_info ))) return FALSE;
1423
1424 if (mask)
1425 {
1426 mask_dc = hdc_src;
1427 mask_bitmap = mask;
1428 if (!(mask_info_size = get_bitmap_info( &mask_dc, &mask_bitmap, &mask_info ))) goto err;
1429 if (mask_info.bmiHeader.biBitCount == 1)
1430 mask_info_size = sizeof(BITMAPINFOHEADER); /* don't include colors */
1431 }
1432 else mask_info.bmiHeader.biSizeImage = 0;
1433
1434 size = sizeof(*emr) + bmi_size + src_info.bmiHeader.biSizeImage +
1435 mask_info_size + mask_info.bmiHeader.biSizeImage;
1436
1437 if (!(emr = HeapAlloc(GetProcessHeap(), 0, size))) goto err;
1438
1439 emr->emr.iType = EMR_MASKBLT;
1440 emr->emr.nSize = size;
1441 emr->rclBounds.left = x_dst;
1442 emr->rclBounds.top = y_dst;
1443 emr->rclBounds.right = x_dst + width_dst - 1;
1444 emr->rclBounds.bottom = y_dst + height_dst - 1;
1445 emr->xDest = x_dst;
1446 emr->yDest = y_dst;
1447 emr->cxDest = width_dst;
1448 emr->cyDest = height_dst;
1449 emr->dwRop = rop;
1450 emr->xSrc = x_src;
1451 emr->ySrc = y_src;
1452 NtGdiGetTransform( hdc_src, 0x204, &emr->xformSrc );
1453 emr->crBkColorSrc = GetBkColor( hdc_src );
1454 emr->iUsageSrc = DIB_RGB_COLORS;
1455 emr->offBmiSrc = sizeof(*emr);
1456 emr->cbBmiSrc = bmi_size;
1457 emr->offBitsSrc = emr->offBmiSrc + bmi_size;
1458 emr->cbBitsSrc = src_info.bmiHeader.biSizeImage;
1459 emr->xMask = x_mask;
1460 emr->yMask = y_mask;
1461 emr->iUsageMask = DIB_PAL_MONO;
1462 emr->offBmiMask = mask_info_size ? emr->offBitsSrc + emr->cbBitsSrc : 0;
1463 emr->cbBmiMask = mask_info_size;
1464 emr->offBitsMask = emr->offBmiMask + emr->cbBmiMask;
1465 emr->cbBitsMask = mask_info.bmiHeader.biSizeImage;
1466
1467 bmi = (BITMAPINFO *)((char *)emr + emr->offBmiSrc);
1468 bmi->bmiHeader = src_info.bmiHeader;
1469 ret = GetDIBits( blit_dc, blit_bitmap, 0, src_info.bmiHeader.biHeight,
1470 (char *)emr + emr->offBitsSrc, bmi, DIB_RGB_COLORS );
1471 if (!ret) goto err;
1472
1473 if (mask_info_size)
1474 {
1475 mask_bits_info->bmiHeader = mask_info.bmiHeader;
1476 ret = GetDIBits( blit_dc, mask_bitmap, 0, mask_info.bmiHeader.biHeight,
1477 (char *)emr + emr->offBitsMask, mask_bits_info, DIB_RGB_COLORS );
1478 if (ret) memcpy( (char *)emr + emr->offBmiMask, mask_bits_info, mask_info_size );
1479 }
1480
1481 if (ret)
1482 {
1483 ret = emfdc_record( emf, (EMR *)emr );
1484 if (ret) emfdc_update_bounds( emf, &emr->rclBounds );
1485 }
1486
1487 err:
1488 HeapFree( GetProcessHeap(), 0, emr );
1489 if (mask_bitmap != mask) DeleteObject( mask_bitmap );
1490 if (mask_dc != hdc_src) DeleteObject( mask_dc );
1491 if (blit_bitmap != bitmap) DeleteObject( blit_bitmap );
1492 if (blit_dc != hdc_src) DeleteDC( blit_dc );
1493 return ret;
1494 }
1495
1496 BOOL EMFDC_PlgBlt( DC_ATTR *dc_attr, const POINT *points, HDC hdc_src, INT x_src, INT y_src,
1497 INT width, INT height, HBITMAP mask, INT x_mask, INT y_mask )
1498 {
1499 unsigned char mask_info_buffer[FIELD_OFFSET(BITMAPINFO, bmiColors[256])];
1500 BITMAPINFO *mask_bits_info = (BITMAPINFO *)mask_info_buffer;
1501 struct emf *emf = dc_attr->emf;
1502 BITMAPINFO mask_info = {{ sizeof( mask_info.bmiHeader ) }};
1503 BITMAPINFO src_info = {{ sizeof( src_info.bmiHeader ) }};
1504 HBITMAP bitmap, blit_bitmap = NULL, mask_bitmap = NULL;
1505 UINT bmi_size, size, mask_info_size = 0;
1506 EMRPLGBLT *emr = NULL;
1507 BITMAPINFO *bmi;
1508 HDC blit_dc, mask_dc = NULL;
1509 int x_min, y_min, x_max, y_max, i;
1510 BOOL ret = FALSE;
1511
1512 if (!(bitmap = GetCurrentObject( hdc_src, OBJ_BITMAP ))) return FALSE;
1513
1514 blit_dc = hdc_src;
1515 blit_bitmap = bitmap;
1516 if (!(bmi_size = get_bitmap_info( &blit_dc, &blit_bitmap, &src_info ))) return FALSE;
1517
1518 if (mask)
1519 {
1520 mask_dc = hdc_src;
1521 mask_bitmap = mask;
1522 if (!(mask_info_size = get_bitmap_info( &mask_dc, &mask_bitmap, &mask_info ))) goto err;
1523 if (mask_info.bmiHeader.biBitCount == 1)
1524 mask_info_size = sizeof(BITMAPINFOHEADER); /* don't include colors */
1525 }
1526 else mask_info.bmiHeader.biSizeImage = 0;
1527
1528 size = sizeof(*emr) + bmi_size + src_info.bmiHeader.biSizeImage +
1529 mask_info_size + mask_info.bmiHeader.biSizeImage;
1530
1531 if (!(emr = HeapAlloc(GetProcessHeap(), 0, size))) goto err;
1532
1533 emr->emr.iType = EMR_PLGBLT;
1534 emr->emr.nSize = size;
1535
1536 /* FIXME: not exactly what native does */
1537 x_min = x_max = points[1].x + points[2].x - points[0].x;
1538 y_min = y_max = points[1].y + points[2].y - points[0].y;
1539 for (i = 0; i < ARRAYSIZE(emr->aptlDest); i++)
1540 {
1541 x_min = min( x_min, points[i].x );
1542 y_min = min( y_min, points[i].y );
1543 x_max = max( x_max, points[i].x );
1544 y_max = max( y_min, points[i].y );
1545 }
1546 emr->rclBounds.left = x_min;
1547 emr->rclBounds.top = y_min;
1548 emr->rclBounds.right = x_max;
1549 emr->rclBounds.bottom = y_max;
1550 memcpy( emr->aptlDest, points, sizeof(emr->aptlDest) );
1551 emr->xSrc = x_src;
1552 emr->ySrc = y_src;
1553 emr->cxSrc = width;
1554 emr->cySrc = height;
1555 NtGdiGetTransform( hdc_src, 0x204, &emr->xformSrc );
1556 emr->crBkColorSrc = GetBkColor( hdc_src );
1557 emr->iUsageSrc = DIB_RGB_COLORS;
1558 emr->offBmiSrc = sizeof(*emr);
1559 emr->cbBmiSrc = bmi_size;
1560 emr->offBitsSrc = emr->offBmiSrc + bmi_size;
1561 emr->cbBitsSrc = src_info.bmiHeader.biSizeImage;
1562 emr->xMask = x_mask;
1563 emr->yMask = y_mask;
1564 emr->iUsageMask = DIB_PAL_MONO;
1565 emr->offBmiMask = mask_info_size ? emr->offBitsSrc + emr->cbBitsSrc : 0;
1566 emr->cbBmiMask = mask_info_size;
1567 emr->offBitsMask = emr->offBmiMask + emr->cbBmiMask;
1568 emr->cbBitsMask = mask_info.bmiHeader.biSizeImage;
1569
1570 bmi = (BITMAPINFO *)((char *)emr + emr->offBmiSrc);
1571 bmi->bmiHeader = src_info.bmiHeader;
1572 ret = GetDIBits( blit_dc, blit_bitmap, 0, src_info.bmiHeader.biHeight,
1573 (char *)emr + emr->offBitsSrc, bmi, DIB_RGB_COLORS );
1574 if (!ret) goto err;
1575
1576 if (mask_info_size)
1577 {
1578 mask_bits_info->bmiHeader = mask_info.bmiHeader;
1579 ret = GetDIBits( blit_dc, mask_bitmap, 0, mask_info.bmiHeader.biHeight,
1580 (char *)emr + emr->offBitsMask, mask_bits_info, DIB_RGB_COLORS );
1581 if (ret) memcpy( (char *)emr + emr->offBmiMask, mask_bits_info, mask_info_size );
1582 }
1583
1584 if (ret)
1585 {
1586 ret = emfdc_record( emf, (EMR *)emr );
1587 if (ret) emfdc_update_bounds( emf, &emr->rclBounds );
1588 }
1589
1590 err:
1591 HeapFree( GetProcessHeap(), 0, emr );
1592 if (mask_bitmap != mask) DeleteObject( mask_bitmap );
1593 if (mask_dc != hdc_src) DeleteObject( mask_dc );
1594 if (blit_bitmap != bitmap) DeleteObject( blit_bitmap );
1595 if (blit_dc != hdc_src) DeleteDC( blit_dc );
1596 return ret;
1597 }
1598
1599 BOOL EMFDC_StretchDIBits( DC_ATTR *dc_attr, INT x_dst, INT y_dst, INT width_dst, INT height_dst,
1600 INT x_src, INT y_src, INT width_src, INT height_src, const void *bits,
1601 const BITMAPINFO *info, UINT usage, DWORD rop )
1602 {
1603 EMRSTRETCHDIBITS *emr;
1604 BOOL ret;
1605 UINT bmi_size, emr_size;
1606
1607 /* calculate the size of the colour table */
1608 bmi_size = get_dib_info_size( info, usage );
1609
1610 emr_size = sizeof (EMRSTRETCHDIBITS) + bmi_size + info->bmiHeader.biSizeImage;
1611 if (!(emr = HeapAlloc(GetProcessHeap(), 0, emr_size ))) return 0;
1612
1613 /* write a bitmap info header (with colours) to the record */
1614 memcpy( &emr[1], info, bmi_size);
1615
1616 /* write bitmap bits to the record */
1617 memcpy ( (BYTE *)&emr[1] + bmi_size, bits, info->bmiHeader.biSizeImage );
1618
1619 /* fill in the EMR header at the front of our piece of memory */
1620 emr->emr.iType = EMR_STRETCHDIBITS;
1621 emr->emr.nSize = emr_size;
1622
1623 emr->xDest = x_dst;
1624 emr->yDest = y_dst;
1625 emr->cxDest = width_dst;
1626 emr->cyDest = height_dst;
1627 emr->dwRop = rop;
1628 emr->xSrc = x_src;
1629 emr->ySrc = y_src;
1630
1631 emr->iUsageSrc = usage;
1632 emr->offBmiSrc = sizeof (EMRSTRETCHDIBITS);
1633 emr->cbBmiSrc = bmi_size;
1634 emr->offBitsSrc = emr->offBmiSrc + bmi_size;
1635 emr->cbBitsSrc = info->bmiHeader.biSizeImage;
1636
1637 emr->cxSrc = width_src;
1638 emr->cySrc = height_src;
1639
1640 emr->rclBounds.left = x_dst;
1641 emr->rclBounds.top = y_dst;
1642 emr->rclBounds.right = x_dst + width_dst;
1643 emr->rclBounds.bottom = y_dst + height_dst;
1644
1645 /* save the record we just created */
1646 ret = emfdc_record( dc_attr->emf, &emr->emr );
1647 if (ret) emfdc_update_bounds( dc_attr->emf, &emr->rclBounds );
1648 HeapFree( GetProcessHeap(), 0, emr );
1649 return ret;
1650 }
1651
1652 BOOL EMFDC_SetDIBitsToDevice( DC_ATTR *dc_attr, INT x_dst, INT y_dst, DWORD width, DWORD height,
1653 INT x_src, INT y_src, UINT startscan, UINT lines,
1654 const void *bits, const BITMAPINFO *info, UINT usage )
1655 {
1656 EMRSETDIBITSTODEVICE *emr;
1657 DWORD bmiSize = get_dib_info_size( info, usage );
1658 DWORD size = sizeof(EMRSETDIBITSTODEVICE) + bmiSize + info->bmiHeader.biSizeImage;
1659 BOOL ret;
1660
1661 if (!(emr = HeapAlloc( GetProcessHeap(), 0, size ))) return FALSE;
1662
1663 emr->emr.iType = EMR_SETDIBITSTODEVICE;
1664 emr->emr.nSize = size;
1665 emr->rclBounds.left = x_dst;
1666 emr->rclBounds.top = y_dst;
1667 emr->rclBounds.right = x_dst + width - 1;
1668 emr->rclBounds.bottom = y_dst + height - 1;
1669 emr->xDest = x_dst;
1670 emr->yDest = y_dst;
1671 emr->xSrc = x_src;
1672 emr->ySrc = y_src;
1673 emr->cxSrc = width;
1674 emr->cySrc = height;
1675 emr->offBmiSrc = sizeof(EMRSETDIBITSTODEVICE);
1676 emr->cbBmiSrc = bmiSize;
1677 emr->offBitsSrc = sizeof(EMRSETDIBITSTODEVICE) + bmiSize;
1678 emr->cbBitsSrc = info->bmiHeader.biSizeImage;
1679 emr->iUsageSrc = usage;
1680 emr->iStartScan = startscan;
1681 emr->cScans = lines;
1682 memcpy( (BYTE*)emr + emr->offBmiSrc, info, bmiSize );
1683 memcpy( (BYTE*)emr + emr->offBitsSrc, bits, info->bmiHeader.biSizeImage );
1684
1685 if ((ret = emfdc_record( dc_attr->emf, (EMR*)emr )))
1686 emfdc_update_bounds( dc_attr->emf, &emr->rclBounds );
1687
1688 HeapFree( GetProcessHeap(), 0, emr );
1689 return ret;
1690 }
1691
1692 BOOL EMFDC_SetDCBrushColor( DC_ATTR *dc_attr, COLORREF color )
1693 {
1694 struct emf *emf = dc_attr->emf;
1695 EMRSELECTOBJECT emr;
1696 DWORD index;
1697
1698 if (GetCurrentObject( dc_attr->hdc, OBJ_BRUSH ) != GetStockObject( DC_BRUSH )) return TRUE;
1699
1700 if (emf->dc_brush) DeleteObject( emf->dc_brush );
1701 if (!(emf->dc_brush = CreateSolidBrush( color ))) return FALSE;
1702 if (!(index = emfdc_create_brush( emf, emf->dc_brush ))) return FALSE;
1703 GDI_hdc_using_object( emf->dc_brush, dc_attr->hdc, emfdc_delete_object );
1704 emr.emr.iType = EMR_SELECTOBJECT;
1705 emr.emr.nSize = sizeof(emr);
1706 emr.ihObject = index;
1707 return emfdc_record( emf, &emr.emr );
1708 }
1709
1710 BOOL EMFDC_SetDCPenColor( DC_ATTR *dc_attr, COLORREF color )
1711 {
1712 struct emf *emf = dc_attr->emf;
1713 EMRSELECTOBJECT emr;
1714 DWORD index;
1715 LOGPEN logpen = { PS_SOLID, { 0, 0 }, color };
1716
1717 if (GetCurrentObject( dc_attr->hdc, OBJ_PEN ) != GetStockObject( DC_PEN )) return TRUE;
1718
1719 if (emf->dc_pen) DeleteObject( emf->dc_pen );
1720 if (!(emf->dc_pen = CreatePenIndirect( &logpen ))) return FALSE;
1721 if (!(index = emfdc_create_pen( emf, emf->dc_pen ))) return FALSE;
1722 GDI_hdc_using_object( emf->dc_pen, dc_attr->hdc, emfdc_delete_object );
1723 emr.emr.iType = EMR_SELECTOBJECT;
1724 emr.emr.nSize = sizeof(emr);
1725 emr.ihObject = index;
1726 return emfdc_record( emf, &emr.emr );
1727 }
1728
1729 BOOL EMFDC_SaveDC( DC_ATTR *dc_attr )
1730 {
1731 EMRSAVEDC emr;
1732
1733 emr.emr.iType = EMR_SAVEDC;
1734 emr.emr.nSize = sizeof(emr);
1735 return emfdc_record( dc_attr->emf, &emr.emr );
1736 }
1737
1738 BOOL EMFDC_RestoreDC( DC_ATTR *dc_attr, INT level )
1739 {
1740 EMRRESTOREDC emr;
1741
1742 if (abs(level) > dc_attr->save_level || level == 0) return FALSE;
1743
1744 emr.emr.iType = EMR_RESTOREDC;
1745 emr.emr.nSize = sizeof(emr);
1746 if (level < 0)
1747 emr.iRelative = level;
1748 else
1749 emr.iRelative = level - dc_attr->save_level - 1;
1750 return emfdc_record( dc_attr->emf, &emr.emr );
1751 }
1752
1753 BOOL EMFDC_SetTextAlign( DC_ATTR *dc_attr, UINT align )
1754 {
1755 EMRSETTEXTALIGN emr;
1756
1757 emr.emr.iType = EMR_SETTEXTALIGN;
1758 emr.emr.nSize = sizeof(emr);
1759 emr.iMode = align;
1760 return emfdc_record( dc_attr->emf, &emr.emr );
1761 }
1762
1763 BOOL EMFDC_SetTextJustification( DC_ATTR *dc_attr, INT extra, INT breaks )
1764 {
1765 EMRSETTEXTJUSTIFICATION emr;
1766
1767 emr.emr.iType = EMR_SETTEXTJUSTIFICATION;
1768 emr.emr.nSize = sizeof(emr);
1769 emr.nBreakExtra = extra;
1770 emr.nBreakCount = breaks;
1771 return emfdc_record( dc_attr->emf, &emr.emr );
1772 }
1773
1774 BOOL EMFDC_SetBkMode( DC_ATTR *dc_attr, INT mode )
1775 {
1776 EMRSETBKMODE emr;
1777
1778 emr.emr.iType = EMR_SETBKMODE;
1779 emr.emr.nSize = sizeof(emr);
1780 emr.iMode = mode;
1781 return emfdc_record( dc_attr->emf, &emr.emr );
1782 }
1783
1784 BOOL EMFDC_SetBkColor( DC_ATTR *dc_attr, COLORREF color )
1785 {
1786 EMRSETBKCOLOR emr;
1787
1788 emr.emr.iType = EMR_SETBKCOLOR;
1789 emr.emr.nSize = sizeof(emr);
1790 emr.crColor = color;
1791 return emfdc_record( dc_attr->emf, &emr.emr );
1792 }
1793
1794
1795 BOOL EMFDC_SetTextColor( DC_ATTR *dc_attr, COLORREF color )
1796 {
1797 EMRSETTEXTCOLOR emr;
1798
1799 emr.emr.iType = EMR_SETTEXTCOLOR;
1800 emr.emr.nSize = sizeof(emr);
1801 emr.crColor = color;
1802 return emfdc_record( dc_attr->emf, &emr.emr );
1803 }
1804
1805 BOOL EMFDC_SetROP2( DC_ATTR *dc_attr, INT rop )
1806 {
1807 EMRSETROP2 emr;
1808
1809 emr.emr.iType = EMR_SETROP2;
1810 emr.emr.nSize = sizeof(emr);
1811 emr.iMode = rop;
1812 return emfdc_record( dc_attr->emf, &emr.emr );
1813 }
1814
1815 BOOL EMFDC_SetPolyFillMode( DC_ATTR *dc_attr, INT mode )
1816 {
1817 EMRSETPOLYFILLMODE emr;
1818
1819 emr.emr.iType = EMR_SETPOLYFILLMODE;
1820 emr.emr.nSize = sizeof(emr);
1821 emr.iMode = mode;
1822 return emfdc_record( dc_attr->emf, &emr.emr );
1823 }
1824
1825 BOOL EMFDC_SetStretchBltMode( DC_ATTR *dc_attr, INT mode )
1826 {
1827 EMRSETSTRETCHBLTMODE emr;
1828
1829 emr.emr.iType = EMR_SETSTRETCHBLTMODE;
1830 emr.emr.nSize = sizeof(emr);
1831 emr.iMode = mode;
1832 return emfdc_record( dc_attr->emf, &emr.emr );
1833 }
1834
1835 BOOL EMFDC_SetArcDirection( DC_ATTR *dc_attr, INT dir )
1836 {
1837 EMRSETARCDIRECTION emr;
1838
1839 emr.emr.iType = EMR_SETARCDIRECTION;
1840 emr.emr.nSize = sizeof(emr);
1841 emr.iArcDirection = dir;
1842 return emfdc_record( dc_attr->emf, &emr.emr );
1843 }
1844
1845 INT EMFDC_ExcludeClipRect( DC_ATTR *dc_attr, INT left, INT top, INT right, INT bottom )
1846 {
1847 EMREXCLUDECLIPRECT emr;
1848
1849 emr.emr.iType = EMR_EXCLUDECLIPRECT;
1850 emr.emr.nSize = sizeof(emr);
1851 emr.rclClip.left = left;
1852 emr.rclClip.top = top;
1853 emr.rclClip.right = right;
1854 emr.rclClip.bottom = bottom;
1855 return emfdc_record( dc_attr->emf, &emr.emr );
1856 }
1857
1858 BOOL EMFDC_IntersectClipRect( DC_ATTR *dc_attr, INT left, INT top, INT right, INT bottom)
1859 {
1860 EMRINTERSECTCLIPRECT emr;
1861
1862 emr.emr.iType = EMR_INTERSECTCLIPRECT;
1863 emr.emr.nSize = sizeof(emr);
1864 emr.rclClip.left = left;
1865 emr.rclClip.top = top;
1866 emr.rclClip.right = right;
1867 emr.rclClip.bottom = bottom;
1868 return emfdc_record( dc_attr->emf, &emr.emr );
1869 }
1870
1871 BOOL EMFDC_OffsetClipRgn( DC_ATTR *dc_attr, INT x, INT y )
1872 {
1873 EMROFFSETCLIPRGN emr;
1874
1875 emr.emr.iType = EMR_OFFSETCLIPRGN;
1876 emr.emr.nSize = sizeof(emr);
1877 emr.ptlOffset.x = x;
1878 emr.ptlOffset.y = y;
1879 return emfdc_record( dc_attr->emf, &emr.emr );
1880 }
1881
1882 BOOL EMFDC_ExtSelectClipRgn( DC_ATTR *dc_attr, HRGN hrgn, INT mode )
1883 {
1884 EMREXTSELECTCLIPRGN *emr;
1885 DWORD size, rgnsize;
1886 BOOL ret;
1887
1888 if (!hrgn)
1889 {
1890 if (mode != RGN_COPY) return ERROR;
1891 rgnsize = 0;
1892 }
1893 else rgnsize = NtGdiGetRegionData( hrgn, 0, NULL );
1894
1895 size = rgnsize + offsetof(EMREXTSELECTCLIPRGN,RgnData);
1896 emr = HeapAlloc( GetProcessHeap(), 0, size );
1897 if (rgnsize) NtGdiGetRegionData( hrgn, rgnsize, (RGNDATA *)&emr->RgnData );
1898
1899 emr->emr.iType = EMR_EXTSELECTCLIPRGN;
1900 emr->emr.nSize = size;
1901 emr->cbRgnData = rgnsize;
1902 emr->iMode = mode;
1903
1904 ret = emfdc_record( dc_attr->emf, &emr->emr );
1905 HeapFree( GetProcessHeap(), 0, emr );
1906 return ret;
1907 }
1908
1909 BOOL EMFDC_SetMapMode( DC_ATTR *dc_attr, INT mode )
1910 {
1911 EMRSETMAPMODE emr;
1912
1913 emr.emr.iType = EMR_SETMAPMODE;
1914 emr.emr.nSize = sizeof(emr);
1915 emr.iMode = mode;
1916 return emfdc_record( dc_attr->emf, &emr.emr );
1917 }
1918
1919 BOOL EMFDC_SetViewportExtEx( DC_ATTR *dc_attr, INT cx, INT cy )
1920 {
1921 EMRSETVIEWPORTEXTEX emr;
1922
1923 emr.emr.iType = EMR_SETVIEWPORTEXTEX;
1924 emr.emr.nSize = sizeof(emr);
1925 emr.szlExtent.cx = cx;
1926 emr.szlExtent.cy = cy;
1927 return emfdc_record( dc_attr->emf, &emr.emr );
1928 }
1929
1930 BOOL EMFDC_SetWindowExtEx( DC_ATTR *dc_attr, INT cx, INT cy )
1931 {
1932 EMRSETWINDOWEXTEX emr;
1933
1934 emr.emr.iType = EMR_SETWINDOWEXTEX;
1935 emr.emr.nSize = sizeof(emr);
1936 emr.szlExtent.cx = cx;
1937 emr.szlExtent.cy = cy;
1938 return emfdc_record( dc_attr->emf, &emr.emr );
1939 }
1940
1941 BOOL EMFDC_SetViewportOrgEx( DC_ATTR *dc_attr, INT x, INT y )
1942 {
1943 EMRSETVIEWPORTORGEX emr;
1944
1945 emr.emr.iType = EMR_SETVIEWPORTORGEX;
1946 emr.emr.nSize = sizeof(emr);
1947 emr.ptlOrigin.x = x;
1948 emr.ptlOrigin.y = y;
1949 return emfdc_record( dc_attr->emf, &emr.emr );
1950 }
1951
1952 BOOL EMFDC_SetWindowOrgEx( DC_ATTR *dc_attr, INT x, INT y )
1953 {
1954 EMRSETWINDOWORGEX emr;
1955
1956 emr.emr.iType = EMR_SETWINDOWORGEX;
1957 emr.emr.nSize = sizeof(emr);
1958 emr.ptlOrigin.x = x;
1959 emr.ptlOrigin.y = y;
1960 return emfdc_record( dc_attr->emf, &emr.emr );
1961 }
1962
1963 BOOL EMFDC_ScaleViewportExtEx( DC_ATTR *dc_attr, INT x_num, INT x_denom, INT y_num, INT y_denom )
1964 {
1965 EMRSCALEVIEWPORTEXTEX emr;
1966
1967 emr.emr.iType = EMR_SCALEVIEWPORTEXTEX;
1968 emr.emr.nSize = sizeof(emr);
1969 emr.xNum = x_num;
1970 emr.xDenom = x_denom;
1971 emr.yNum = y_num;
1972 emr.yDenom = y_denom;
1973 return emfdc_record( dc_attr->emf, &emr.emr );
1974 }
1975
1976 BOOL EMFDC_ScaleWindowExtEx( DC_ATTR *dc_attr, INT x_num, INT x_denom, INT y_num, INT y_denom )
1977 {
1978 EMRSCALEWINDOWEXTEX emr;
1979
1980 emr.emr.iType = EMR_SCALEWINDOWEXTEX;
1981 emr.emr.nSize = sizeof(emr);
1982 emr.xNum = x_num;
1983 emr.xDenom = x_denom;
1984 emr.yNum = y_num;
1985 emr.yDenom = y_denom;
1986 return emfdc_record( dc_attr->emf, &emr.emr );
1987 }
1988
1989 BOOL EMFDC_SetLayout( DC_ATTR *dc_attr, DWORD layout )
1990 {
1991 EMRSETLAYOUT emr;
1992
1993 emr.emr.iType = EMR_SETLAYOUT;
1994 emr.emr.nSize = sizeof(emr);
1995 emr.iMode = layout;
1996 return emfdc_record( dc_attr->emf, &emr.emr );
1997 }
1998
1999 BOOL EMFDC_SetWorldTransform( DC_ATTR *dc_attr, const XFORM *xform )
2000 {
2001 EMRSETWORLDTRANSFORM emr;
2002
2003 emr.emr.iType = EMR_SETWORLDTRANSFORM;
2004 emr.emr.nSize = sizeof(emr);
2005 emr.xform = *xform;
2006 return emfdc_record( dc_attr->emf, &emr.emr );
2007 }
2008
2009 BOOL EMFDC_ModifyWorldTransform( DC_ATTR *dc_attr, const XFORM *xform, DWORD mode )
2010 {
2011 EMRMODIFYWORLDTRANSFORM emr;
2012
2013 emr.emr.iType = EMR_MODIFYWORLDTRANSFORM;
2014 emr.emr.nSize = sizeof(emr);
2015 if (mode == MWT_IDENTITY)
2016 {
2017 emr.xform.eM11 = 1.0f;
2018 emr.xform.eM12 = 0.0f;
2019 emr.xform.eM21 = 0.0f;
2020 emr.xform.eM22 = 1.0f;
2021 emr.xform.eDx = 0.0f;
2022 emr.xform.eDy = 0.0f;
2023 }
2024 else
2025 {
2026 emr.xform = *xform;
2027 }
2028 emr.iMode = mode;
2029 return emfdc_record( dc_attr->emf, &emr.emr );
2030 }
2031
2032 BOOL EMFDC_SetMapperFlags( DC_ATTR *dc_attr, DWORD flags )
2033 {
2034 EMRSETMAPPERFLAGS emr;
2035
2036 emr.emr.iType = EMR_SETMAPPERFLAGS;
2037 emr.emr.nSize = sizeof(emr);
2038 emr.dwFlags = flags;
2039 return emfdc_record( dc_attr->emf, &emr.emr );
2040 }
2041
2042 BOOL EMFDC_AbortPath( DC_ATTR *dc_attr )
2043 {
2044 struct emf *emf = dc_attr->emf;
2045 EMRABORTPATH emr;
2046
2047 emr.emr.iType = EMR_ABORTPATH;
2048 emr.emr.nSize = sizeof(emr);
2049
2050 emf->path = FALSE;
2051 return emfdc_record( dc_attr->emf, &emr.emr );
2052 }
2053
2054 BOOL EMFDC_BeginPath( DC_ATTR *dc_attr )
2055 {
2056 struct emf *emf = dc_attr->emf;
2057 EMRBEGINPATH emr;
2058
2059 emr.emr.iType = EMR_BEGINPATH;
2060 emr.emr.nSize = sizeof(emr);
2061 if (!emfdc_record( emf, &emr.emr )) return FALSE;
2062
2063 emf->path = TRUE;
2064 return TRUE;
2065 }
2066
2067 BOOL EMFDC_CloseFigure( DC_ATTR *dc_attr )
2068 {
2069 EMRCLOSEFIGURE emr;
2070
2071 emr.emr.iType = EMR_CLOSEFIGURE;
2072 emr.emr.nSize = sizeof(emr);
2073 return emfdc_record( dc_attr->emf, &emr.emr );
2074 }
2075
2076 BOOL EMFDC_EndPath( DC_ATTR *dc_attr )
2077 {
2078 struct emf *emf = dc_attr->emf;
2079 EMRENDPATH emr;
2080
2081 emf->path = FALSE;
2082
2083 emr.emr.iType = EMR_ENDPATH;
2084 emr.emr.nSize = sizeof(emr);
2085 return emfdc_record( emf, &emr.emr );
2086 }
2087
2088 BOOL EMFDC_FlattenPath( DC_ATTR *dc_attr )
2089 {
2090 EMRFLATTENPATH emr;
2091
2092 emr.emr.iType = EMR_FLATTENPATH;
2093 emr.emr.nSize = sizeof(emr);
2094 return emfdc_record( dc_attr->emf, &emr.emr );
2095 }
2096
2097 BOOL EMFDC_SelectClipPath( DC_ATTR *dc_attr, INT mode )
2098 {
2099 EMRSELECTCLIPPATH emr;
2100
2101 emr.emr.iType = EMR_SELECTCLIPPATH;
2102 emr.emr.nSize = sizeof(emr);
2103 emr.iMode = mode;
2104 return emfdc_record( dc_attr->emf, &emr.emr );
2105 }
2106
2107 BOOL EMFDC_WidenPath( DC_ATTR *dc_attr )
2108 {
2109 EMRWIDENPATH emr;
2110
2111 emr.emr.iType = EMR_WIDENPATH;
2112 emr.emr.nSize = sizeof(emr);
2113 return emfdc_record( dc_attr->emf, &emr.emr );
2114 }
2115
2116 void EMFDC_DeleteDC( DC_ATTR *dc_attr )
2117 {
2118 struct emf *emf = dc_attr->emf;
2119 UINT index;
2120
2121 HeapFree( GetProcessHeap(), 0, emf->emh );
2122 for (index = 0; index < emf->handles_size; index++)
2123 if (emf->handles[index])
2124 GDI_hdc_not_using_object( emf->handles[index], emf->dc_attr->hdc );
2125 HeapFree( GetProcessHeap(), 0, emf->handles );
2126 }
2127
2128 /*******************************************************************
2129 * GdiComment (GDI32.@)
2130 */
2131 BOOL WINAPI GdiComment( HDC hdc, UINT bytes, const BYTE *buffer )
2132 {
2133 DC_ATTR *dc_attr;
2134 EMRGDICOMMENT *emr;
2135 UINT total, rounded_size;
2136 BOOL ret;
2137
2138 if (!(dc_attr = get_dc_attr( hdc )) || !dc_attr->emf) return FALSE;
2139
2140 rounded_size = (bytes+3) & ~3;
2141 total = offsetof(EMRGDICOMMENT,Data) + rounded_size;
2142
2143 emr = HeapAlloc(GetProcessHeap(), 0, total);
2144 emr->emr.iType = EMR_GDICOMMENT;
2145 emr->emr.nSize = total;
2146 emr->cbData = bytes;
2147 memset(&emr->Data[bytes], 0, rounded_size - bytes);
2148 memcpy(&emr->Data[0], buffer, bytes);
2149
2150 ret = emfdc_record( dc_attr->emf, &emr->emr );
2151
2152 HeapFree(GetProcessHeap(), 0, emr);
2153
2154 return ret;
2155 }
2156
2157 /**********************************************************************
2158 * CreateEnhMetaFileA (GDI32.@)
2159 */
2160 HDC WINAPI CreateEnhMetaFileA( HDC hdc, const char *filename, const RECT *rect,
2161 const char *description )
2162 {
2163 WCHAR *filenameW = NULL;
2164 WCHAR *descriptionW = NULL;
2165 DWORD len1, len2, total;
2166 HDC ret;
2167
2168 if (filename)
2169 {
2170 total = MultiByteToWideChar( CP_ACP, 0, filename, -1, NULL, 0 );
2171 filenameW = HeapAlloc( GetProcessHeap(), 0, total * sizeof(WCHAR) );
2172 MultiByteToWideChar( CP_ACP, 0, filename, -1, filenameW, total );
2173 }
2174
2175 if(description)
2176 {
2177 len1 = strlen(description);
2178 len2 = strlen(description + len1 + 1);
2179 total = MultiByteToWideChar( CP_ACP, 0, description, len1 + len2 + 3, NULL, 0 );
2180 descriptionW = HeapAlloc( GetProcessHeap(), 0, total * sizeof(WCHAR) );
2181 MultiByteToWideChar( CP_ACP, 0, description, len1 + len2 + 3, descriptionW, total );
2182 }
2183
2184 ret = CreateEnhMetaFileW( hdc, filenameW, rect, descriptionW );
2185
2186 HeapFree( GetProcessHeap(), 0, filenameW );
2187 HeapFree( GetProcessHeap(), 0, descriptionW );
2188 return ret;
2189 }
2190
2191 /**********************************************************************
2192 * CreateEnhMetaFileW (GDI32.@)
2193 */
2194 HDC WINAPI CreateEnhMetaFileW( HDC hdc, const WCHAR *filename, const RECT *rect,
2195 const WCHAR *description )
2196 {
2197 HDC ret;
2198 struct emf *emf;
2199 DC_ATTR *dc_attr;
2200 HANDLE file;
2201 DWORD size = 0, length = 0;
2202
2203 TRACE( "(%p %s %s %s)\n", hdc, debugstr_w(filename), wine_dbgstr_rect(rect),
2204 debugstr_w(description) );
2205
2206 if (!(ret = NtGdiCreateMetafileDC( hdc ))) return 0;
2207
2208 if (!(dc_attr = get_dc_attr( ret )) || !(emf = HeapAlloc( GetProcessHeap(), 0, sizeof(*emf) )))
2209 {
2210 DeleteDC( ret );
2211 return 0;
2212 }
2213
2214 emf->dc_attr = dc_attr;
2215 dc_attr->emf = emf;
2216
2217 if (description) /* App name\0Title\0\0 */
2218 {
2219 length = lstrlenW( description );
2220 length += lstrlenW( description + length + 1 );
2221 length += 3;
2222 length *= 2;
2223 }
2224 size = sizeof(ENHMETAHEADER) + (length + 3) / 4 * 4;
2225
2226 if (!(emf->emh = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size)))
2227 {
2228 DeleteDC( ret );
2229 return 0;
2230 }
2231 emf->dc_attr = dc_attr;
2232
2233 emf->handles = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
2234 HANDLE_LIST_INC * sizeof(emf->handles[0]) );
2235 emf->handles_size = HANDLE_LIST_INC;
2236 emf->cur_handles = 1;
2237 emf->file = 0;
2238 emf->dc_brush = 0;
2239 emf->dc_pen = 0;
2240 emf->path = FALSE;
2241
2242 emf->emh->iType = EMR_HEADER;
2243 emf->emh->nSize = size;
2244
2245 dc_attr->emf_bounds.left = dc_attr->emf_bounds.top = 0;
2246 dc_attr->emf_bounds.right = dc_attr->emf_bounds.bottom = -1;
2247
2248 if (rect)
2249 {
2250 emf->emh->rclFrame.left = rect->left;
2251 emf->emh->rclFrame.top = rect->top;
2252 emf->emh->rclFrame.right = rect->right;
2253 emf->emh->rclFrame.bottom = rect->bottom;
2254 }
2255 else
2256 {
2257 /* Set this to {0,0 - -1,-1} and update it at the end */
2258 emf->emh->rclFrame.left = emf->emh->rclFrame.top = 0;
2259 emf->emh->rclFrame.right = emf->emh->rclFrame.bottom = -1;
2260 }
2261
2262 emf->emh->dSignature = ENHMETA_SIGNATURE;
2263 emf->emh->nVersion = 0x10000;
2264 emf->emh->nBytes = emf->emh->nSize;
2265 emf->emh->nRecords = 1;
2266 emf->emh->nHandles = 1;
2267
2268 emf->emh->sReserved = 0; /* According to docs, this is reserved and must be 0 */
2269 emf->emh->nDescription = length / 2;
2270
2271 emf->emh->offDescription = length ? sizeof(ENHMETAHEADER) : 0;
2272
2273 emf->emh->nPalEntries = 0; /* I guess this should start at 0 */
2274
2275 /* Size in pixels */
2276 emf->emh->szlDevice.cx = GetDeviceCaps( ret, HORZRES );
2277 emf->emh->szlDevice.cy = GetDeviceCaps( ret, VERTRES );
2278
2279 /* Size in millimeters */
2280 emf->emh->szlMillimeters.cx = GetDeviceCaps( ret, HORZSIZE );
2281 emf->emh->szlMillimeters.cy = GetDeviceCaps( ret, VERTSIZE );
2282
2283 /* Size in micrometers */
2284 emf->emh->szlMicrometers.cx = emf->emh->szlMillimeters.cx * 1000;
2285 emf->emh->szlMicrometers.cy = emf->emh->szlMillimeters.cy * 1000;
2286
2287 memcpy( (char *)emf->emh + sizeof(ENHMETAHEADER), description, length );
2288
2289 if (filename) /* disk based metafile */
2290 {
2291 if ((file = CreateFileW( filename, GENERIC_WRITE | GENERIC_READ, 0,
2292 NULL, CREATE_ALWAYS, 0, 0)) == INVALID_HANDLE_VALUE)
2293 {
2294 DeleteDC( ret );
2295 return 0;
2296 }
2297 emf->file = file;
2298 }
2299
2300 TRACE( "returning %p\n", ret );
2301 return ret;
2302 }
2303
2304 /******************************************************************
2305 * CloseEnhMetaFile (GDI32.@)
2306 */
2307 HENHMETAFILE WINAPI CloseEnhMetaFile( HDC hdc )
2308 {
2309 HENHMETAFILE hmf;
2310 struct emf *emf;
2311 DC_ATTR *dc_attr;
2312 EMREOF emr;
2313 HANDLE mapping = 0;
2314
2315 TRACE("(%p)\n", hdc );
2316
2317 if (!(dc_attr = get_dc_attr( hdc )) || !dc_attr->emf) return 0;
2318 emf = dc_attr->emf;
2319
2320 if (dc_attr->save_level)
2321 RestoreDC( hdc, 1 );
2322
2323 if (emf->dc_brush) DeleteObject( emf->dc_brush );
2324 if (emf->dc_pen) DeleteObject( emf->dc_pen );
2325
2326 emr.emr.iType = EMR_EOF;
2327 emr.emr.nSize = sizeof(emr);
2328 emr.nPalEntries = 0;
2329 emr.offPalEntries = FIELD_OFFSET(EMREOF, nSizeLast);
2330 emr.nSizeLast = emr.emr.nSize;
2331 emfdc_record( emf, &emr.emr );
2332
2333 emf->emh->rclBounds = dc_attr->emf_bounds;
2334
2335 /* Update rclFrame if not initialized in CreateEnhMetaFile */
2336 if (emf->emh->rclFrame.left > emf->emh->rclFrame.right)
2337 {
2338 emf->emh->rclFrame.left = emf->emh->rclBounds.left *
2339 emf->emh->szlMillimeters.cx * 100 / emf->emh->szlDevice.cx;
2340 emf->emh->rclFrame.top = emf->emh->rclBounds.top *
2341 emf->emh->szlMillimeters.cy * 100 / emf->emh->szlDevice.cy;
2342 emf->emh->rclFrame.right = emf->emh->rclBounds.right *
2343 emf->emh->szlMillimeters.cx * 100 / emf->emh->szlDevice.cx;
2344 emf->emh->rclFrame.bottom = emf->emh->rclBounds.bottom *
2345 emf->emh->szlMillimeters.cy * 100 / emf->emh->szlDevice.cy;
2346 }
2347
2348 if (emf->file) /* disk based metafile */
2349 {
2350 if (!WriteFile( emf->file, emf->emh, emf->emh->nBytes, NULL, NULL ))
2351 {
2352 CloseHandle( emf->file );
2353 return 0;
2354 }
2355 HeapFree( GetProcessHeap(), 0, emf->emh );
2356 mapping = CreateFileMappingA( emf->file, NULL, PAGE_READONLY, 0, 0, NULL );
2357 TRACE( "mapping = %p\n", mapping );
2358 emf->emh = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 );
2359 TRACE( "view = %p\n", emf->emh );
2360 CloseHandle( mapping );
2361 CloseHandle( emf->file );
2362 }
2363
2364 hmf = EMF_Create_HENHMETAFILE( emf->emh, emf->emh->nBytes, emf->file != 0 );
2365 emf->emh = NULL; /* So it won't be deleted */
2366 DeleteDC( hdc );
2367 return hmf;
2368 }
Windows API implementation