2 * Enhanced MetaFile objects
4 * Copyright 1999 Huw D M Davies
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 #include "enhmfdrv/enhmetafiledrv.h"
26 #include "gdi_private.h"
27 #include "wine/debug.h"
29 WINE_DEFAULT_DEBUG_CHANNEL(enhmetafile
);
32 /******************************************************************
35 static UINT
EMFDRV_AddHandle( PHYSDEV dev
, HGDIOBJ obj
)
37 EMFDRV_PDEVICE
*physDev
= get_emf_physdev( dev
);
40 for(index
= 0; index
< physDev
->handles_size
; index
++)
41 if(physDev
->handles
[index
] == 0) break;
42 if(index
== physDev
->handles_size
) {
43 physDev
->handles_size
+= HANDLE_LIST_INC
;
44 physDev
->handles
= HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
46 physDev
->handles_size
* sizeof(physDev
->handles
[0]));
48 physDev
->handles
[index
] = get_full_gdi_handle( obj
);
50 physDev
->cur_handles
++;
51 if(physDev
->cur_handles
> physDev
->emh
->nHandles
)
52 physDev
->emh
->nHandles
++;
54 return index
+ 1; /* index 0 is reserved for the hmf, so we increment everything by 1 */
57 /******************************************************************
60 static UINT
EMFDRV_FindObject( PHYSDEV dev
, HGDIOBJ obj
)
62 EMFDRV_PDEVICE
*physDev
= get_emf_physdev( dev
);
65 for(index
= 0; index
< physDev
->handles_size
; index
++)
66 if(physDev
->handles
[index
] == obj
) break;
68 if(index
== physDev
->handles_size
) return 0;
74 /******************************************************************
77 BOOL
EMFDRV_DeleteObject( PHYSDEV dev
, HGDIOBJ obj
)
80 EMFDRV_PDEVICE
*physDev
= get_emf_physdev( dev
);
84 if(!(index
= EMFDRV_FindObject(dev
, obj
))) return FALSE
;
86 emr
.emr
.iType
= EMR_DELETEOBJECT
;
87 emr
.emr
.nSize
= sizeof(emr
);
90 if(!EMFDRV_WriteRecord( dev
, &emr
.emr
))
93 physDev
->handles
[index
- 1] = 0;
94 physDev
->cur_handles
--;
99 /***********************************************************************
100 * EMFDRV_SelectBitmap
102 HBITMAP
EMFDRV_SelectBitmap( PHYSDEV dev
, HBITMAP hbitmap
)
108 /***********************************************************************
109 * EMFDRV_CreateBrushIndirect
111 DWORD
EMFDRV_CreateBrushIndirect( PHYSDEV dev
, HBRUSH hBrush
)
116 if (!GetObjectA( hBrush
, sizeof(logbrush
), &logbrush
)) return 0;
118 switch (logbrush
.lbStyle
) {
123 EMRCREATEBRUSHINDIRECT emr
;
124 emr
.emr
.iType
= EMR_CREATEBRUSHINDIRECT
;
125 emr
.emr
.nSize
= sizeof(emr
);
126 emr
.ihBrush
= index
= EMFDRV_AddHandle( dev
, hBrush
);
127 emr
.lb
.lbStyle
= logbrush
.lbStyle
;
128 emr
.lb
.lbColor
= logbrush
.lbColor
;
129 emr
.lb
.lbHatch
= logbrush
.lbHatch
;
131 if(!EMFDRV_WriteRecord( dev
, &emr
.emr
))
138 EMRCREATEDIBPATTERNBRUSHPT
*emr
;
140 char buffer
[sizeof(BITMAPINFO
) + 255 * sizeof(RGBQUAD
)]; // ros
142 char buffer
[FIELD_OFFSET( BITMAPINFO
, bmiColors
[256] )];
144 BITMAPINFO
*info
= (BITMAPINFO
*)buffer
;
149 if (!get_brush_bitmap_info( hBrush
, info
, &bits
, &usage
)) break;
150 info_size
= get_dib_info_size( info
, usage
);
152 emr
= HeapAlloc( GetProcessHeap(), 0,
153 sizeof(EMRCREATEDIBPATTERNBRUSHPT
)+info_size
+info
->bmiHeader
.biSizeImage
);
156 if (logbrush
.lbStyle
== BS_PATTERN
&& info
->bmiHeader
.biBitCount
== 1)
158 /* Presumably to reduce the size of the written EMF, MS supports an
159 * undocumented iUsage value of 2, indicating a mono bitmap without the
160 * 8 byte 2 entry black/white palette. Stupidly, they could have saved
161 * over 20 bytes more by also ignoring the BITMAPINFO fields that are
162 * irrelevant/constant for monochrome bitmaps.
163 * FIXME: It may be that the DIB functions themselves accept this value.
165 emr
->emr
.iType
= EMR_CREATEMONOBRUSH
;
166 usage
= DIB_PAL_MONO
;
167 /* FIXME: There is an extra DWORD written by native before the BMI.
168 * Not sure what it's meant to contain.
170 emr
->offBmi
= sizeof( EMRCREATEDIBPATTERNBRUSHPT
) + sizeof(DWORD
);
171 emr
->cbBmi
= sizeof( BITMAPINFOHEADER
);
175 emr
->emr
.iType
= EMR_CREATEDIBPATTERNBRUSHPT
;
176 emr
->offBmi
= sizeof( EMRCREATEDIBPATTERNBRUSHPT
);
177 emr
->cbBmi
= info_size
;
179 emr
->ihBrush
= index
= EMFDRV_AddHandle( dev
, hBrush
);
181 emr
->offBits
= emr
->offBmi
+ emr
->cbBmi
;
182 emr
->cbBits
= info
->bmiHeader
.biSizeImage
;
183 emr
->emr
.nSize
= emr
->offBits
+ emr
->cbBits
;
185 memcpy( (BYTE
*)emr
+ emr
->offBmi
, info
, emr
->cbBmi
);
186 memcpy( (BYTE
*)emr
+ emr
->offBits
, bits
, emr
->cbBits
);
188 if(!EMFDRV_WriteRecord( dev
, &emr
->emr
))
190 HeapFree( GetProcessHeap(), 0, emr
);
195 FIXME("Unknown style %x\n", logbrush
.lbStyle
);
202 /***********************************************************************
205 HBRUSH
EMFDRV_SelectBrush( PHYSDEV dev
, HBRUSH hBrush
, const struct brush_pattern
*pattern
)
207 EMFDRV_PDEVICE
*physDev
= get_emf_physdev( dev
);
212 if (physDev
->restoring
) return hBrush
; /* don't output SelectObject records during RestoreDC */
214 /* If the object is a stock brush object, do not need to create it.
215 * See definitions in wingdi.h for range of stock brushes.
216 * We do however have to handle setting the higher order bit to
217 * designate that this is a stock object.
219 for (i
= WHITE_BRUSH
; i
<= DC_BRUSH
; i
++)
221 if (hBrush
== GetStockObject(i
))
223 index
= i
| 0x80000000;
227 if((index
= EMFDRV_FindObject(dev
, hBrush
)) != 0)
230 if (!(index
= EMFDRV_CreateBrushIndirect(dev
, hBrush
))) return 0;
231 GDI_hdc_using_object(hBrush
, dev
->hdc
);
234 emr
.emr
.iType
= EMR_SELECTOBJECT
;
235 emr
.emr
.nSize
= sizeof(emr
);
236 emr
.ihObject
= index
;
237 return EMFDRV_WriteRecord( dev
, &emr
.emr
) ? hBrush
: 0;
241 /******************************************************************
242 * EMFDRV_CreateFontIndirect
244 static BOOL
EMFDRV_CreateFontIndirect(PHYSDEV dev
, HFONT hFont
)
247 EMREXTCREATEFONTINDIRECTW emr
;
250 if (!GetObjectW( hFont
, sizeof(emr
.elfw
.elfLogFont
), &emr
.elfw
.elfLogFont
)) return FALSE
;
252 emr
.emr
.iType
= EMR_EXTCREATEFONTINDIRECTW
;
253 emr
.emr
.nSize
= (sizeof(emr
) + 3) / 4 * 4;
254 emr
.ihFont
= index
= EMFDRV_AddHandle( dev
, hFont
);
255 emr
.elfw
.elfFullName
[0] = '\0';
256 emr
.elfw
.elfStyle
[0] = '\0';
257 emr
.elfw
.elfVersion
= 0;
258 emr
.elfw
.elfStyleSize
= 0;
259 emr
.elfw
.elfMatch
= 0;
260 emr
.elfw
.elfReserved
= 0;
261 for(i
= 0; i
< ELF_VENDOR_SIZE
; i
++)
262 emr
.elfw
.elfVendorId
[i
] = 0;
263 emr
.elfw
.elfCulture
= PAN_CULTURE_LATIN
;
264 emr
.elfw
.elfPanose
.bFamilyType
= PAN_NO_FIT
;
265 emr
.elfw
.elfPanose
.bSerifStyle
= PAN_NO_FIT
;
266 emr
.elfw
.elfPanose
.bWeight
= PAN_NO_FIT
;
267 emr
.elfw
.elfPanose
.bProportion
= PAN_NO_FIT
;
268 emr
.elfw
.elfPanose
.bContrast
= PAN_NO_FIT
;
269 emr
.elfw
.elfPanose
.bStrokeVariation
= PAN_NO_FIT
;
270 emr
.elfw
.elfPanose
.bArmStyle
= PAN_NO_FIT
;
271 emr
.elfw
.elfPanose
.bLetterform
= PAN_NO_FIT
;
272 emr
.elfw
.elfPanose
.bMidline
= PAN_NO_FIT
;
273 emr
.elfw
.elfPanose
.bXHeight
= PAN_NO_FIT
;
275 if(!EMFDRV_WriteRecord( dev
, &emr
.emr
))
281 /***********************************************************************
284 HFONT
EMFDRV_SelectFont( PHYSDEV dev
, HFONT hFont
, UINT
*aa_flags
)
286 EMFDRV_PDEVICE
*physDev
= get_emf_physdev( dev
);
291 if (physDev
->restoring
) goto done
; /* don't output SelectObject records during RestoreDC */
293 /* If the object is a stock font object, do not need to create it.
294 * See definitions in wingdi.h for range of stock fonts.
295 * We do however have to handle setting the higher order bit to
296 * designate that this is a stock object.
299 for (i
= OEM_FIXED_FONT
; i
<= DEFAULT_GUI_FONT
; i
++)
301 if (i
!= DEFAULT_PALETTE
&& hFont
== GetStockObject(i
))
303 index
= i
| 0x80000000;
308 if((index
= EMFDRV_FindObject(dev
, hFont
)) != 0)
311 if (!(index
= EMFDRV_CreateFontIndirect(dev
, hFont
))) return 0;
312 GDI_hdc_using_object(hFont
, dev
->hdc
);
315 emr
.emr
.iType
= EMR_SELECTOBJECT
;
316 emr
.emr
.nSize
= sizeof(emr
);
317 emr
.ihObject
= index
;
318 if(!EMFDRV_WriteRecord( dev
, &emr
.emr
))
321 *aa_flags
= GGO_BITMAP
; /* no point in anti-aliasing on metafiles */
322 dev
= GET_NEXT_PHYSDEV( dev
, pSelectFont
);
323 dev
->funcs
->pSelectFont( dev
, hFont
, aa_flags
);
329 /******************************************************************
330 * EMFDRV_CreatePenIndirect
332 static DWORD
EMFDRV_CreatePenIndirect(PHYSDEV dev
, HPEN hPen
)
337 if (!GetObjectW( hPen
, sizeof(emr
.lopn
), &emr
.lopn
))
339 /* must be an extended pen */
341 INT size
= GetObjectW( hPen
, 0, NULL
);
345 elp
= HeapAlloc( GetProcessHeap(), 0, size
);
347 GetObjectW( hPen
, size
, elp
);
348 /* FIXME: add support for user style pens */
349 emr
.lopn
.lopnStyle
= elp
->elpPenStyle
;
350 emr
.lopn
.lopnWidth
.x
= elp
->elpWidth
;
351 emr
.lopn
.lopnWidth
.y
= 0;
352 emr
.lopn
.lopnColor
= elp
->elpColor
;
354 HeapFree( GetProcessHeap(), 0, elp
);
357 emr
.emr
.iType
= EMR_CREATEPEN
;
358 emr
.emr
.nSize
= sizeof(emr
);
359 emr
.ihPen
= index
= EMFDRV_AddHandle( dev
, hPen
);
361 if(!EMFDRV_WriteRecord( dev
, &emr
.emr
))
366 /******************************************************************
369 HPEN
EMFDRV_SelectPen(PHYSDEV dev
, HPEN hPen
, const struct brush_pattern
*pattern
)
371 EMFDRV_PDEVICE
*physDev
= get_emf_physdev( dev
);
376 if (physDev
->restoring
) return hPen
; /* don't output SelectObject records during RestoreDC */
378 /* If the object is a stock pen object, do not need to create it.
379 * See definitions in wingdi.h for range of stock pens.
380 * We do however have to handle setting the higher order bit to
381 * designate that this is a stock object.
384 for (i
= WHITE_PEN
; i
<= DC_PEN
; i
++)
386 if (hPen
== GetStockObject(i
))
388 index
= i
| 0x80000000;
392 if((index
= EMFDRV_FindObject(dev
, hPen
)) != 0)
395 if (!(index
= EMFDRV_CreatePenIndirect(dev
, hPen
))) return 0;
396 GDI_hdc_using_object(hPen
, dev
->hdc
);
399 emr
.emr
.iType
= EMR_SELECTOBJECT
;
400 emr
.emr
.nSize
= sizeof(emr
);
401 emr
.ihObject
= index
;
402 return EMFDRV_WriteRecord( dev
, &emr
.emr
) ? hPen
: 0;
406 /******************************************************************
407 * EMFDRV_CreatePalette
409 static DWORD
EMFDRV_CreatePalette(PHYSDEV dev
, HPALETTE hPal
)
413 EMRCREATEPALETTE hdr
;
414 PALETTEENTRY entry
[255];
417 memset( &pal
, 0, sizeof(pal
) );
419 if (!GetObjectW( hPal
, sizeof(pal
.hdr
.lgpl
) + sizeof(pal
.entry
), &pal
.hdr
.lgpl
))
422 for (i
= 0; i
< pal
.hdr
.lgpl
.palNumEntries
; i
++)
423 pal
.hdr
.lgpl
.palPalEntry
[i
].peFlags
= 0;
425 pal
.hdr
.emr
.iType
= EMR_CREATEPALETTE
;
426 pal
.hdr
.emr
.nSize
= sizeof(pal
.hdr
) + pal
.hdr
.lgpl
.palNumEntries
* sizeof(PALETTEENTRY
);
427 pal
.hdr
.ihPal
= EMFDRV_AddHandle( dev
, hPal
);
429 if (!EMFDRV_WriteRecord( dev
, &pal
.hdr
.emr
))
431 return pal
.hdr
.ihPal
;
434 /******************************************************************
435 * EMFDRV_SelectPalette
437 HPALETTE
EMFDRV_SelectPalette( PHYSDEV dev
, HPALETTE hPal
, BOOL force
)
439 EMFDRV_PDEVICE
*physDev
= get_emf_physdev( dev
);
440 EMRSELECTPALETTE emr
;
443 if (physDev
->restoring
) return hPal
; /* don't output SelectObject records during RestoreDC */
445 if (hPal
== GetStockObject( DEFAULT_PALETTE
))
447 index
= DEFAULT_PALETTE
| 0x80000000;
451 if ((index
= EMFDRV_FindObject( dev
, hPal
)) != 0)
454 if (!(index
= EMFDRV_CreatePalette( dev
, hPal
))) return 0;
455 GDI_hdc_using_object( hPal
, dev
->hdc
);
458 emr
.emr
.iType
= EMR_SELECTPALETTE
;
459 emr
.emr
.nSize
= sizeof(emr
);
461 return EMFDRV_WriteRecord( dev
, &emr
.emr
) ? hPal
: 0;
464 /******************************************************************
465 * EMFDRV_SetDCBrushColor
467 COLORREF
EMFDRV_SetDCBrushColor( PHYSDEV dev
, COLORREF color
)
469 EMFDRV_PDEVICE
*physDev
= get_emf_physdev( dev
);
471 DC
*dc
= get_physdev_dc( dev
);
476 if (GetCurrentObject( dev
->hdc
, OBJ_BRUSH
) != GetStockObject( DC_BRUSH
)) return color
;
478 if (dc
->hBrush
!= GetStockObject( DC_BRUSH
)) return color
;
480 if (physDev
->dc_brush
) DeleteObject( physDev
->dc_brush
);
481 if (!(physDev
->dc_brush
= CreateSolidBrush( color
))) return CLR_INVALID
;
482 if (!(index
= EMFDRV_CreateBrushIndirect(dev
, physDev
->dc_brush
))) return CLR_INVALID
;
483 GDI_hdc_using_object( physDev
->dc_brush
, dev
->hdc
);
484 emr
.emr
.iType
= EMR_SELECTOBJECT
;
485 emr
.emr
.nSize
= sizeof(emr
);
486 emr
.ihObject
= index
;
487 return EMFDRV_WriteRecord( dev
, &emr
.emr
) ? color
: CLR_INVALID
;
490 /******************************************************************
491 * EMFDRV_SetDCPenColor
493 COLORREF
EMFDRV_SetDCPenColor( PHYSDEV dev
, COLORREF color
)
495 EMFDRV_PDEVICE
*physDev
= get_emf_physdev( dev
);
497 DC
*dc
= get_physdev_dc( dev
);
501 LOGPEN logpen
= { PS_SOLID
, { 0, 0 }, color
};
503 if (GetCurrentObject( dev
->hdc
, OBJ_PEN
) != GetStockObject( DC_PEN
)) return color
;
505 if (dc
->hPen
!= GetStockObject( DC_PEN
)) return color
;
507 if (physDev
->dc_pen
) DeleteObject( physDev
->dc_pen
);
508 if (!(physDev
->dc_pen
= CreatePenIndirect( &logpen
))) return CLR_INVALID
;
509 if (!(index
= EMFDRV_CreatePenIndirect(dev
, physDev
->dc_pen
))) return CLR_INVALID
;
510 GDI_hdc_using_object( physDev
->dc_pen
, dev
->hdc
);
511 emr
.emr
.iType
= EMR_SELECTOBJECT
;
512 emr
.emr
.nSize
= sizeof(emr
);
513 emr
.ihObject
= index
;
514 return EMFDRV_WriteRecord( dev
, &emr
.emr
) ? color
: CLR_INVALID
;
517 /******************************************************************
520 BOOL
EMFDRV_GdiComment(PHYSDEV dev
, UINT bytes
, const BYTE
*buffer
)
523 UINT total
, rounded_size
;
526 rounded_size
= (bytes
+3) & ~3;
527 total
= offsetof(EMRGDICOMMENT
,Data
) + rounded_size
;
529 emr
= HeapAlloc(GetProcessHeap(), 0, total
);
530 emr
->emr
.iType
= EMR_GDICOMMENT
;
531 emr
->emr
.nSize
= total
;
533 memset(&emr
->Data
[bytes
], 0, rounded_size
- bytes
);
534 memcpy(&emr
->Data
[0], buffer
, bytes
);
536 ret
= EMFDRV_WriteRecord( dev
, &emr
->emr
);
538 HeapFree(GetProcessHeap(), 0, emr
);