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