|
|
/***********************************************************************
MODULE : WMFMETA.CPP
FUNCTIONS : MetaEnumProc GetMetaFileAndEnum LoadParameterLB PlayMetaFileToDest RenderClipMeta RenderPlaceableMeta SetPlaceableExts SetClipMetaExts ProcessFile
COMMENTS :
************************************************************************/
#include <windows.h>
#include <windowsx.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <objbase.h>
extern "C" {#include "mfdcod32.h"
}extern "C" { extern BOOL bConvertToGdiPlus; extern BOOL bUseGdiPlusToPlay;}
#include "GdiPlus.h"
#include "MyData.hpp"
#include "dibstream.hpp"
#include "../gpinit.inc"
#ifndef ASSERT
#ifdef _DEBUG // poor man's assert
#define ASSERT(cond) if (!(cond)) { int b = 0; b = 1 / b; }
#else
#define ASSERT(cond)
#endif
#endif
// Check if a source is needed in a 3-way bitblt operation.
// This works on both rop and rop3. We assume that a rop contains zero
// in the high byte.
//
// This is tested by comparing the rop result bits with source (column A
// below) vs. those without source (column B). If the two cases are
// identical, then the effect of the rop does not depend on the source
// and we don't need a source device. Recall the rop construction from
// input (pattern, source, target --> result):
//
// P S T | R A B mask for A = 0CCh
// ------+-------- mask for B = 33h
// 0 0 0 | x 0 x
// 0 0 1 | x 0 x
// 0 1 0 | x x 0
// 0 1 1 | x x 0
// 1 0 0 | x 0 x
// 1 0 1 | x 0 x
// 1 1 0 | x x 0
// 1 1 1 | x x 0
#define ISSOURCEINROP3(rop3) \
(((rop3) & 0xCCCC0000) != (((rop3) << 2) & 0xCCCC0000))
#ifndef EMR_SETICMMODE
#define EMR_SETICMMODE 98
#define EMR_CREATECOLORSPACE 99
#define EMR_SETCOLORSPACE 100
#define EMR_DELETECOLORSPACE 101
#define EMR_GLSRECORD 102
#define EMR_GLSBOUNDEDRECORD 103
#define EMR_PIXELFORMAT 104
#endif
#ifndef EMR_DRAWESCAPE
#define EMR_DRAWESCAPE 105
#define EMR_EXTESCAPE 106
#define EMR_STARTDOC 107
#define EMR_SMALLTEXTOUT 108
#define EMR_FORCEUFIMAPPING 109
#define EMR_NAMEDESCAPE 110
#define EMR_COLORCORRECTPALETTE 111
#define EMR_SETICMPROFILEA 112
#define EMR_SETICMPROFILEW 113
#define EMR_ALPHABLEND 114
#define EMR_SETLAYOUT 115
#define EMR_TRANSPARENTBLT 116
#define EMR_GRADIENTFILL 118
#define EMR_SETLINKEDUFIS 119
#define EMR_SETTEXTJUSTIFICATION 120
#define EMR_COLORMATCHTOTARGETW 121
#define EMR_CREATECOLORSPACEW 122
#endif
#define TOREAL(i) (static_cast<float>(i))
//
// Wrap a GDI+ TextureBrush object around DIB data
//
class DibBrush{public:
DibBrush(const BITMAPINFO* bmi, const BYTE* bits) : dibStream(bmi, bits), bitmap(&dibStream), brush(&bitmap) { }
operator Gdiplus::TextureBrush*() { return &brush; }
private:
DibStream dibStream; Gdiplus::Bitmap bitmap; Gdiplus::TextureBrush brush;};
//
//lookup table for EMF and WMF metafile records
//
EMFMETARECORDS emfMetaRecords[] = { "WmfSetBkColor" , Gdiplus::WmfRecordTypeSetBkColor , "WmfSetBkMode" , Gdiplus::WmfRecordTypeSetBkMode , "WmfSetMapMode" , Gdiplus::WmfRecordTypeSetMapMode , "WmfSetROP2" , Gdiplus::WmfRecordTypeSetROP2 , "WmfSetRelAbs" , Gdiplus::WmfRecordTypeSetRelAbs , "WmfSetPolyFillMode" , Gdiplus::WmfRecordTypeSetPolyFillMode , "WmfSetStretchBltMode" , Gdiplus::WmfRecordTypeSetStretchBltMode , "WmfSetTextCharExtra" , Gdiplus::WmfRecordTypeSetTextCharExtra , "WmfSetTextColor" , Gdiplus::WmfRecordTypeSetTextColor , "WmfSetTextJustification" , Gdiplus::WmfRecordTypeSetTextJustification , "WmfSetWindowOrg" , Gdiplus::WmfRecordTypeSetWindowOrg , "WmfSetWindowExt" , Gdiplus::WmfRecordTypeSetWindowExt , "WmfSetViewportOrg" , Gdiplus::WmfRecordTypeSetViewportOrg , "WmfSetViewportExt" , Gdiplus::WmfRecordTypeSetViewportExt , "WmfOffsetWindowOrg" , Gdiplus::WmfRecordTypeOffsetWindowOrg , "WmfScaleWindowExt" , Gdiplus::WmfRecordTypeScaleWindowExt , "WmfOffsetViewportOrg" , Gdiplus::WmfRecordTypeOffsetViewportOrg , "WmfScaleViewportExt" , Gdiplus::WmfRecordTypeScaleViewportExt , "WmfLineTo" , Gdiplus::WmfRecordTypeLineTo , "WmfMoveTo" , Gdiplus::WmfRecordTypeMoveTo , "WmfExcludeClipRect" , Gdiplus::WmfRecordTypeExcludeClipRect , "WmfIntersectClipRect" , Gdiplus::WmfRecordTypeIntersectClipRect , "WmfArc" , Gdiplus::WmfRecordTypeArc , "WmfEllipse" , Gdiplus::WmfRecordTypeEllipse , "WmfFloodFill" , Gdiplus::WmfRecordTypeFloodFill , "WmfPie" , Gdiplus::WmfRecordTypePie , "WmfRectangle" , Gdiplus::WmfRecordTypeRectangle , "WmfRoundRect" , Gdiplus::WmfRecordTypeRoundRect , "WmfPatBlt" , Gdiplus::WmfRecordTypePatBlt , "WmfSaveDC" , Gdiplus::WmfRecordTypeSaveDC , "WmfSetPixel" , Gdiplus::WmfRecordTypeSetPixel , "WmfOffsetClipRgn" , Gdiplus::WmfRecordTypeOffsetClipRgn , "WmfTextOut" , Gdiplus::WmfRecordTypeTextOut , "WmfBitBlt" , Gdiplus::WmfRecordTypeBitBlt , "WmfStretchBlt" , Gdiplus::WmfRecordTypeStretchBlt , "WmfPolygon" , Gdiplus::WmfRecordTypePolygon , "WmfPolyline" , Gdiplus::WmfRecordTypePolyline , "WmfEscape" , Gdiplus::WmfRecordTypeEscape , "WmfRestoreDC" , Gdiplus::WmfRecordTypeRestoreDC , "WmfFillRegion" , Gdiplus::WmfRecordTypeFillRegion , "WmfFrameRegion" , Gdiplus::WmfRecordTypeFrameRegion , "WmfInvertRegion" , Gdiplus::WmfRecordTypeInvertRegion , "WmfPaintRegion" , Gdiplus::WmfRecordTypePaintRegion , "WmfSelectClipRegion" , Gdiplus::WmfRecordTypeSelectClipRegion , "WmfSelectObject" , Gdiplus::WmfRecordTypeSelectObject , "WmfSetTextAlign" , Gdiplus::WmfRecordTypeSetTextAlign , "WmfDrawText" , Gdiplus::WmfRecordTypeDrawText , "WmfChord" , Gdiplus::WmfRecordTypeChord , "WmfSetMapperFlags" , Gdiplus::WmfRecordTypeSetMapperFlags , "WmfExtTextOut" , Gdiplus::WmfRecordTypeExtTextOut , "WmfSetDIBToDev" , Gdiplus::WmfRecordTypeSetDIBToDev , "WmfSelectPalette" , Gdiplus::WmfRecordTypeSelectPalette , "WmfRealizePalette" , Gdiplus::WmfRecordTypeRealizePalette , "WmfAnimatePalette" , Gdiplus::WmfRecordTypeAnimatePalette , "WmfSetPalEntries" , Gdiplus::WmfRecordTypeSetPalEntries , "WmfPolyPolygon" , Gdiplus::WmfRecordTypePolyPolygon , "WmfResizePalette" , Gdiplus::WmfRecordTypeResizePalette , "WmfDIBBitBlt" , Gdiplus::WmfRecordTypeDIBBitBlt , "WmfDIBStretchBlt" , Gdiplus::WmfRecordTypeDIBStretchBlt , "WmfDIBCreatePatternBrush" , Gdiplus::WmfRecordTypeDIBCreatePatternBrush , "WmfStretchDIB" , Gdiplus::WmfRecordTypeStretchDIB , "WmfExtFloodFill" , Gdiplus::WmfRecordTypeExtFloodFill , "WmfSetLayout" , Gdiplus::WmfRecordTypeSetLayout , "WmfResetDC" , Gdiplus::WmfRecordTypeResetDC , "WmfStartDoc" , Gdiplus::WmfRecordTypeStartDoc , "WmfStartPage" , Gdiplus::WmfRecordTypeStartPage , "WmfEndPage" , Gdiplus::WmfRecordTypeEndPage , "WmfAbortDoc" , Gdiplus::WmfRecordTypeAbortDoc , "WmfEndDoc" , Gdiplus::WmfRecordTypeEndDoc , "WmfDeleteObject" , Gdiplus::WmfRecordTypeDeleteObject , "WmfCreatePalette" , Gdiplus::WmfRecordTypeCreatePalette , "WmfCreateBrush" , Gdiplus::WmfRecordTypeCreateBrush , "WmfCreatePatternBrush" , Gdiplus::WmfRecordTypeCreatePatternBrush , "WmfCreatePenIndirect" , Gdiplus::WmfRecordTypeCreatePenIndirect , "WmfCreateFontIndirect" , Gdiplus::WmfRecordTypeCreateFontIndirect , "WmfCreateBrushIndirect" , Gdiplus::WmfRecordTypeCreateBrushIndirect , "WmfCreateBitmapIndirect" , Gdiplus::WmfRecordTypeCreateBitmapIndirect , "WmfCreateBitmap" , Gdiplus::WmfRecordTypeCreateBitmap , "WmfCreateRegion" , Gdiplus::WmfRecordTypeCreateRegion , "EmfHeader" , Gdiplus::EmfRecordTypeHeader , "EmfPolyBezier" , Gdiplus::EmfRecordTypePolyBezier , "EmfPolygon" , Gdiplus::EmfRecordTypePolygon , "EmfPolyline" , Gdiplus::EmfRecordTypePolyline , "EmfPolyBezierTo" , Gdiplus::EmfRecordTypePolyBezierTo , "EmfPolyLineTo" , Gdiplus::EmfRecordTypePolyLineTo , "EmfPolyPolyline" , Gdiplus::EmfRecordTypePolyPolyline , "EmfPolyPolygon" , Gdiplus::EmfRecordTypePolyPolygon , "EmfSetWindowExtEx" , Gdiplus::EmfRecordTypeSetWindowExtEx , "EmfSetWindowOrgEx" , Gdiplus::EmfRecordTypeSetWindowOrgEx , "EmfSetViewportExtEx" , Gdiplus::EmfRecordTypeSetViewportExtEx , "EmfSetViewportOrgEx" , Gdiplus::EmfRecordTypeSetViewportOrgEx , "EmfSetBrushOrgEx" , Gdiplus::EmfRecordTypeSetBrushOrgEx , "EmfEOF" , Gdiplus::EmfRecordTypeEOF , "EmfSetPixelV" , Gdiplus::EmfRecordTypeSetPixelV , "EmfSetMapperFlags" , Gdiplus::EmfRecordTypeSetMapperFlags , "EmfSetMapMode" , Gdiplus::EmfRecordTypeSetMapMode , "EmfSetBkMode" , Gdiplus::EmfRecordTypeSetBkMode , "EmfSetPolyFillMode" , Gdiplus::EmfRecordTypeSetPolyFillMode , "EmfSetROP2" , Gdiplus::EmfRecordTypeSetROP2 , "EmfSetStretchBltMode" , Gdiplus::EmfRecordTypeSetStretchBltMode , "EmfSetTextAlign" , Gdiplus::EmfRecordTypeSetTextAlign , "EmfSetColorAdjustment" , Gdiplus::EmfRecordTypeSetColorAdjustment , "EmfSetTextColor" , Gdiplus::EmfRecordTypeSetTextColor , "EmfSetBkColor" , Gdiplus::EmfRecordTypeSetBkColor , "EmfOffsetClipRgn" , Gdiplus::EmfRecordTypeOffsetClipRgn , "EmfMoveToEx" , Gdiplus::EmfRecordTypeMoveToEx , "EmfSetMetaRgn" , Gdiplus::EmfRecordTypeSetMetaRgn , "EmfExcludeClipRect" , Gdiplus::EmfRecordTypeExcludeClipRect , "EmfIntersectClipRect" , Gdiplus::EmfRecordTypeIntersectClipRect , "EmfScaleViewportExtEx" , Gdiplus::EmfRecordTypeScaleViewportExtEx , "EmfScaleWindowExtEx" , Gdiplus::EmfRecordTypeScaleWindowExtEx , "EmfSaveDC" , Gdiplus::EmfRecordTypeSaveDC , "EmfRestoreDC" , Gdiplus::EmfRecordTypeRestoreDC , "EmfSetWorldTransform" , Gdiplus::EmfRecordTypeSetWorldTransform , "EmfModifyWorldTransform" , Gdiplus::EmfRecordTypeModifyWorldTransform , "EmfSelectObject" , Gdiplus::EmfRecordTypeSelectObject , "EmfCreatePen" , Gdiplus::EmfRecordTypeCreatePen , "EmfCreateBrushIndirect" , Gdiplus::EmfRecordTypeCreateBrushIndirect , "EmfDeleteObject" , Gdiplus::EmfRecordTypeDeleteObject , "EmfAngleArc" , Gdiplus::EmfRecordTypeAngleArc , "EmfEllipse" , Gdiplus::EmfRecordTypeEllipse , "EmfRectangle" , Gdiplus::EmfRecordTypeRectangle , "EmfRoundRect" , Gdiplus::EmfRecordTypeRoundRect , "EmfArc" , Gdiplus::EmfRecordTypeArc , "EmfChord" , Gdiplus::EmfRecordTypeChord , "EmfPie" , Gdiplus::EmfRecordTypePie , "EmfSelectPalette" , Gdiplus::EmfRecordTypeSelectPalette , "EmfCreatePalette" , Gdiplus::EmfRecordTypeCreatePalette , "EmfSetPaletteEntries" , Gdiplus::EmfRecordTypeSetPaletteEntries , "EmfResizePalette" , Gdiplus::EmfRecordTypeResizePalette , "EmfRealizePalette" , Gdiplus::EmfRecordTypeRealizePalette , "EmfExtFloodFill" , Gdiplus::EmfRecordTypeExtFloodFill , "EmfLineTo" , Gdiplus::EmfRecordTypeLineTo , "EmfArcTo" , Gdiplus::EmfRecordTypeArcTo , "EmfPolyDraw" , Gdiplus::EmfRecordTypePolyDraw , "EmfSetArcDirection" , Gdiplus::EmfRecordTypeSetArcDirection , "EmfSetMiterLimit" , Gdiplus::EmfRecordTypeSetMiterLimit , "EmfBeginPath" , Gdiplus::EmfRecordTypeBeginPath , "EmfEndPath" , Gdiplus::EmfRecordTypeEndPath , "EmfCloseFigure" , Gdiplus::EmfRecordTypeCloseFigure , "EmfFillPath" , Gdiplus::EmfRecordTypeFillPath , "EmfStrokeAndFillPath" , Gdiplus::EmfRecordTypeStrokeAndFillPath , "EmfStrokePath" , Gdiplus::EmfRecordTypeStrokePath , "EmfFlattenPath" , Gdiplus::EmfRecordTypeFlattenPath , "EmfWidenPath" , Gdiplus::EmfRecordTypeWidenPath , "EmfSelectClipPath" , Gdiplus::EmfRecordTypeSelectClipPath , "EmfAbortPath" , Gdiplus::EmfRecordTypeAbortPath , "EmfReserved_069" , Gdiplus::EmfRecordTypeReserved_069 , "EmfGdiComment" , Gdiplus::EmfRecordTypeGdiComment , "EmfFillRgn" , Gdiplus::EmfRecordTypeFillRgn , "EmfFrameRgn" , Gdiplus::EmfRecordTypeFrameRgn , "EmfInvertRgn" , Gdiplus::EmfRecordTypeInvertRgn , "EmfPaintRgn" , Gdiplus::EmfRecordTypePaintRgn , "EmfExtSelectClipRgn" , Gdiplus::EmfRecordTypeExtSelectClipRgn , "EmfBitBlt" , Gdiplus::EmfRecordTypeBitBlt , "EmfStretchBlt" , Gdiplus::EmfRecordTypeStretchBlt , "EmfMaskBlt" , Gdiplus::EmfRecordTypeMaskBlt , "EmfPlgBlt" , Gdiplus::EmfRecordTypePlgBlt , "EmfSetDIBitsToDevice" , Gdiplus::EmfRecordTypeSetDIBitsToDevice , "EmfStretchDIBits" , Gdiplus::EmfRecordTypeStretchDIBits , "EmfExtCreateFontIndirect" , Gdiplus::EmfRecordTypeExtCreateFontIndirect , "EmfExtTextOutA" , Gdiplus::EmfRecordTypeExtTextOutA , "EmfExtTextOutW" , Gdiplus::EmfRecordTypeExtTextOutW , "EmfPolyBezier16" , Gdiplus::EmfRecordTypePolyBezier16 , "EmfPolygon16" , Gdiplus::EmfRecordTypePolygon16 , "EmfPolyline16" , Gdiplus::EmfRecordTypePolyline16 , "EmfPolyBezierTo16" , Gdiplus::EmfRecordTypePolyBezierTo16 , "EmfPolylineTo16" , Gdiplus::EmfRecordTypePolylineTo16 , "EmfPolyPolyline16" , Gdiplus::EmfRecordTypePolyPolyline16 , "EmfPolyPolygon16" , Gdiplus::EmfRecordTypePolyPolygon16 , "EmfPolyDraw16" , Gdiplus::EmfRecordTypePolyDraw16 , "EmfCreateMonoBrush" , Gdiplus::EmfRecordTypeCreateMonoBrush , "EmfCreateDIBPatternBrushPt" , Gdiplus::EmfRecordTypeCreateDIBPatternBrushPt , "EmfExtCreatePen" , Gdiplus::EmfRecordTypeExtCreatePen , "EmfPolyTextOutA" , Gdiplus::EmfRecordTypePolyTextOutA , "EmfPolyTextOutW" , Gdiplus::EmfRecordTypePolyTextOutW , "EmfSetICMMode" , Gdiplus::EmfRecordTypeSetICMMode , "EmfCreateColorSpace" , Gdiplus::EmfRecordTypeCreateColorSpace , "EmfSetColorSpace" , Gdiplus::EmfRecordTypeSetColorSpace , "EmfDeleteColorSpace" , Gdiplus::EmfRecordTypeDeleteColorSpace , "EmfGLSRecord" , Gdiplus::EmfRecordTypeGLSRecord , "EmfGLSBoundedRecord" , Gdiplus::EmfRecordTypeGLSBoundedRecord , "EmfPixelFormat" , Gdiplus::EmfRecordTypePixelFormat , "EmfDrawEscape" , Gdiplus::EmfRecordTypeDrawEscape , "EmfExtEscape" , Gdiplus::EmfRecordTypeExtEscape , "EmfStartDoc" , Gdiplus::EmfRecordTypeStartDoc , "EmfSmallTextOut" , Gdiplus::EmfRecordTypeSmallTextOut , "EmfForceUFIMapping" , Gdiplus::EmfRecordTypeForceUFIMapping , "EmfNamedEscape" , Gdiplus::EmfRecordTypeNamedEscape , "EmfColorCorrectPalette" , Gdiplus::EmfRecordTypeColorCorrectPalette , "EmfSetICMProfileA" , Gdiplus::EmfRecordTypeSetICMProfileA , "EmfSetICMProfileW" , Gdiplus::EmfRecordTypeSetICMProfileW , "EmfAlphaBlend" , Gdiplus::EmfRecordTypeAlphaBlend , "EmfSetLayout" , Gdiplus::EmfRecordTypeSetLayout , "EmfTransparentBlt" , Gdiplus::EmfRecordTypeTransparentBlt , "EmfReserved_117" , Gdiplus::EmfRecordTypeReserved_117 , "EmfGradientFill" , Gdiplus::EmfRecordTypeGradientFill , "EmfSetLinkedUFIs" , Gdiplus::EmfRecordTypeSetLinkedUFIs , "EmfSetTextJustification" , Gdiplus::EmfRecordTypeSetTextJustification , "EmfColorMatchToTargetW" , Gdiplus::EmfRecordTypeColorMatchToTargetW , "EmfCreateColorSpaceW" , Gdiplus::EmfRecordTypeCreateColorSpaceW , "EmfPlusHeader" , Gdiplus::EmfPlusRecordTypeHeader , "EmfPlusEndOfFile" , Gdiplus::EmfPlusRecordTypeEndOfFile , "EmfPlusComment" , Gdiplus::EmfPlusRecordTypeComment , "EmfPlusGetDC" , Gdiplus::EmfPlusRecordTypeGetDC , "EmfPlusMultiFormatStart" , Gdiplus::EmfPlusRecordTypeMultiFormatStart , "EmfPlusMultiFormatSection" , Gdiplus::EmfPlusRecordTypeMultiFormatSection , "EmfPlusMultiFormatEnd" , Gdiplus::EmfPlusRecordTypeMultiFormatEnd , "EmfPlusObject" , Gdiplus::EmfPlusRecordTypeObject , "EmfPlusClear" , Gdiplus::EmfPlusRecordTypeClear , "EmfPlusFillRects" , Gdiplus::EmfPlusRecordTypeFillRects , "EmfPlusDrawRects" , Gdiplus::EmfPlusRecordTypeDrawRects , "EmfPlusFillPolygon" , Gdiplus::EmfPlusRecordTypeFillPolygon , "EmfPlusDrawLines" , Gdiplus::EmfPlusRecordTypeDrawLines , "EmfPlusFillEllipse" , Gdiplus::EmfPlusRecordTypeFillEllipse , "EmfPlusDrawEllipse" , Gdiplus::EmfPlusRecordTypeDrawEllipse , "EmfPlusFillPie" , Gdiplus::EmfPlusRecordTypeFillPie , "EmfPlusDrawPie" , Gdiplus::EmfPlusRecordTypeDrawPie , "EmfPlusDrawArc" , Gdiplus::EmfPlusRecordTypeDrawArc , "EmfPlusFillRegion" , Gdiplus::EmfPlusRecordTypeFillRegion , "EmfPlusFillPath" , Gdiplus::EmfPlusRecordTypeFillPath , "EmfPlusDrawPath" , Gdiplus::EmfPlusRecordTypeDrawPath , "EmfPlusFillClosedCurve" , Gdiplus::EmfPlusRecordTypeFillClosedCurve , "EmfPlusDrawClosedCurve" , Gdiplus::EmfPlusRecordTypeDrawClosedCurve , "EmfPlusDrawCurve" , Gdiplus::EmfPlusRecordTypeDrawCurve , "EmfPlusDrawBeziers" , Gdiplus::EmfPlusRecordTypeDrawBeziers , "EmfPlusDrawImage" , Gdiplus::EmfPlusRecordTypeDrawImage , "EmfPlusDrawImagePoints" , Gdiplus::EmfPlusRecordTypeDrawImagePoints , "EmfPlusDrawString" , Gdiplus::EmfPlusRecordTypeDrawString , "EmfPlusSetRenderingOrigin" , Gdiplus::EmfPlusRecordTypeSetRenderingOrigin , "EmfPlusSetAntiAliasMode" , Gdiplus::EmfPlusRecordTypeSetAntiAliasMode , "EmfPlusSetTextRenderingHint" , Gdiplus::EmfPlusRecordTypeSetTextRenderingHint , "EmfPlusSetTextContrast" , Gdiplus::EmfPlusRecordTypeSetTextContrast , "EmfPlusSetInterpolationMode" , Gdiplus::EmfPlusRecordTypeSetInterpolationMode , "EmfPlusSetPixelOffsetMode" , Gdiplus::EmfPlusRecordTypeSetPixelOffsetMode , "EmfPlusSetCompositingMode" , Gdiplus::EmfPlusRecordTypeSetCompositingMode , "EmfPlusSetCompositingQuality" , Gdiplus::EmfPlusRecordTypeSetCompositingQuality , "EmfPlusSave" , Gdiplus::EmfPlusRecordTypeSave , "EmfPlusRestore" , Gdiplus::EmfPlusRecordTypeRestore , "EmfPlusBeginContainer" , Gdiplus::EmfPlusRecordTypeBeginContainer , "EmfPlusBeginContainerNoParams" , Gdiplus::EmfPlusRecordTypeBeginContainerNoParams , "EmfPlusEndContainer" , Gdiplus::EmfPlusRecordTypeEndContainer , "EmfPlusSetWorldTransform" , Gdiplus::EmfPlusRecordTypeSetWorldTransform , "EmfPlusResetWorldTransform" , Gdiplus::EmfPlusRecordTypeResetWorldTransform , "EmfPlusMultiplyWorldTransform" , Gdiplus::EmfPlusRecordTypeMultiplyWorldTransform , "EmfPlusTranslateWorldTransform" , Gdiplus::EmfPlusRecordTypeTranslateWorldTransform, "EmfPlusScaleWorldTransform" , Gdiplus::EmfPlusRecordTypeScaleWorldTransform , "EmfPlusRotateWorldTransform" , Gdiplus::EmfPlusRecordTypeRotateWorldTransform , "EmfPlusSetPageTransform" , Gdiplus::EmfPlusRecordTypeSetPageTransform , "EmfPlusResetClip" , Gdiplus::EmfPlusRecordTypeResetClip , "EmfPlusSetClipRect" , Gdiplus::EmfPlusRecordTypeSetClipRect , "EmfPlusSetClipPath" , Gdiplus::EmfPlusRecordTypeSetClipPath , "EmfPlusSetClipRegion" , Gdiplus::EmfPlusRecordTypeSetClipRegion , "EmfPlusOffsetClip" , Gdiplus::EmfPlusRecordTypeOffsetClip , "EmfPlusDrawDriverString" , Gdiplus::EmfPlusRecordTypeDrawDriverString ,};
/*
METAFUNCTIONS MetaFunctions[] = {
"SETBKCOLOR", 0x0201, "SETBKMODE", 0x0102, "SETMAPMODE", 0x0103, "SETROP2", 0x0104, "SETRELABS", 0x0105, "SETPOLYFILLMODE", 0x0106, "SETSTRETCHBLTMODE", 0x0107, "SETTEXTCHAREXTRA", 0x0108, "SETTEXTCOLOR", 0x0209, "SETTEXTJUSTIFICATION", 0x020A, "SETWINDOWORG", 0x020B, "SETWINDOWEXT", 0x020C, "SETVIEWPORTORG", 0x020D, "SETVIEWPORTEXT", 0x020E, "OFFSETWINDOWORG", 0x020F, "SCALEWINDOWEXT", 0x0400, "OFFSETVIEWPORTORG", 0x0211, "SCALEVIEWPORTEXT", 0x0412, "LINETO", 0x0213, "MOVETO", 0x0214, "EXCLUDECLIPRECT", 0x0415, "INTERSECTCLIPRECT", 0x0416, "ARC", 0x0817, "ELLIPSE", 0x0418, "FLOODFILL", 0x0419, "PIE", 0x081A, "RECTANGLE", 0x041B, "ROUNDRECT", 0x061C, "PATBLT", 0x061D, "SAVEDC", 0x001E, "SETPIXEL", 0x041F, "OFFSETCLIPRGN", 0x0220, "TEXTOUT", 0x0521, "BITBLT", 0x0922, "STRETCHBLT", 0x0B23, "POLYGON", 0x0324, "POLYLINE", 0x0325, "ESCAPE", 0x0626, "RESTOREDC", 0x0127, "FILLREGION", 0x0228, "FRAMEREGION", 0x0429, "INVERTREGION", 0x012A, "PAINTREGION", 0x012B, "SELECTCLIPREGION", 0x012C, "SELECTOBJECT", 0x012D, "SETTEXTALIGN", 0x012E, "DRAWTEXT", 0x062F, "CHORD", 0x0830, "SETMAPPERFLAGS", 0x0231, "EXTTEXTOUT", 0x0a32, "SETDIBTODEV", 0x0d33, "SELECTPALETTE", 0x0234, "REALIZEPALETTE", 0x0035, "ANIMATEPALETTE", 0x0436, "SETPALENTRIES", 0x0037, "POLYPOLYGON", 0x0538, "RESIZEPALETTE", 0x0139, "DIBBITBLT", 0x0940, "DIBSTRETCHBLT", 0x0b41, "DIBCREATEPATTERNBRUSH",0x0142, "STRETCHDIB", 0x0f43, "DELETEOBJECT", 0x01f0, "CREATEPALETTE", 0x00f7, "CREATEBRUSH", 0x00F8, "CREATEPATTERNBRUSH", 0x01F9, "CREATEPENINDIRECT", 0x02FA, "CREATEFONTINDIRECT", 0x02FB, "CREATEBRUSHINDIRECT", 0x02FC, "CREATEBITMAPINDIRECT", 0x02FD, "CREATEBITMAP", 0x06FE, "CREATEREGION", 0x06FF,};*/
/***********************************************************************
FUNCTION : MetaEnumProc
PARAMETERS : HDC hDC LPHANDLETABLE lpHTable LPMETARECORD lpMFR int nObj LPARAM lpClientData
PURPOSE : callback for EnumMetaFile.
CALLS : EnumMFIndirect()
MESSAGES : none
RETURNS : int
COMMENTS :
HISTORY : 1/16/91 - created - drc 5/6/93 - modified for Win32 - denniscr
************************************************************************/
int CALLBACK MetaEnumProc(HDC hDC,LPHANDLETABLE lpHTable,LPMETARECORD lpMFR,int nObj,LPARAM lpClientData)
{ return EnumMFIndirect(hDC, lpHTable, lpMFR, NULL, nObj, lpClientData);}
/***********************************************************************
FUNCTION : LoadParameterLB
PARAMETERS : HWND hDlg DWORD dwParams int nRadix - HEX to display contents in base 16 DEC to display contents in base 10
PURPOSE : display the parameters of the metafile record in the parameter listbox
CALLS : WINDOWS GlobalLock GlobalUnlock SendDlgItemMessage wsprintf lstrlen
MESSAGES : WM_SETREDRAW WM_RESETCONTENT LB_ADDSTRING
RETURNS : BOOL
COMMENTS :
HISTORY : 1/16/91 - created - drc
************************************************************************/
BOOL LoadParameterLB(HWND hDlg,DWORD dwParams,int nRadix){ DWORD i; BYTE nHiByte, nLoByte; BYTE nHiByteHi, nLoByteHi; WORD wHiWord, wLoWord; char szBuffer[40]; char szDump[100]; int iValue = 0; DWORD dwValue = 0;
switch (nRadix) /* if nRadix is not a valid value, return FALSE */ { case IDB_HEX: case IDB_DEC: case IDB_CHAR: case IDB_WORD: break;
default : return FALSE; } //
//init the strings
//
*szBuffer = '\0'; *szDump = '\0'; //
//turn off redrawing of the listbox
//
SendDlgItemMessage(hDlg, IDL_PARAMETERS, WM_SETREDRAW, FALSE, 0L); //
//reset the contents of the listbox
//
SendDlgItemMessage(hDlg, IDL_PARAMETERS, LB_RESETCONTENT, 0, 0L);
// don't load an entire bitmap or other image into the dialog in hex
if (dwParams > 1024) { dwParams = 1024; }
if (bEnhMeta) { //
//lock the memory where the parameters can be found
//
if (NULL == (lpEMFParams = (LPEMFPARAMETERS)GlobalLock(hMem))) return (FALSE); //
//loop through the metafile record parameters
//
for (i = 0; i < dwParams; i++) {
/* get the high and low byte of the parameter word */ wHiWord = HIWORD(lpEMFParams[i]); wLoWord = LOWORD(lpEMFParams[i]); nLoByteHi = LOBYTE(wHiWord); nHiByteHi = HIBYTE(wHiWord); nLoByte = LOBYTE(wLoWord); nHiByte = HIBYTE(wLoWord);
switch (nRadix) { case IDB_HEX: /* if we are to display as hexadecimal */ /* format the bytes for the hex part of dump */ wsprintf((LPSTR)szBuffer, (LPSTR)"%08x ", lpEMFParams[i]); break;
case IDB_DEC: /* format the bytes for the decimal part of dump */ dwValue = lpEMFParams[i]; wsprintf((LPSTR)szBuffer, (LPSTR)"%lu ", dwValue ); break;
case IDB_CHAR: wsprintf((LPSTR)szBuffer, (LPSTR)"%c%c%c%c", (nLoByte > 0x20) ? nLoByte : 0x2E, (nHiByte > 0x20) ? nHiByte : 0x2E, (nLoByteHi > 0x20) ? nLoByteHi : 0x2E, (nHiByteHi > 0x20) ? nHiByteHi : 0x2E); break;
case IDB_WORD: /* if we are to display as hexadecimal */ /* format the bytes for the hex part of dump */ wsprintf((LPSTR)szBuffer, (LPSTR)"%04x %04x ", wLoWord, wHiWord ); break;
default : return FALSE; }
/* concatenate it onto whatever we have already formatted */ lstrcat((LPSTR)szDump, (LPSTR)szBuffer);
/* use every 8 words for hex/dec dump */ if (!((i + 1) % 4)) {
/*add the string to the listbox */ SendDlgItemMessage(hDlg, IDL_PARAMETERS, LB_ADDSTRING, 0, (LPARAM)(LPSTR)szDump);
/* re-init the hex/dec strings in preparation for next 8 words */ *szDump = '\0'; } }
} else { /* lock the memory where the parameters can be found */ if (NULL == (lpMFParams = (LPPARAMETERS)GlobalLock(hMem))) return (FALSE);
/* loop through the metafile record parameters */ for (i = 0; i < dwParams; i++) {
/* get the high and low byte of the parameter word */ nHiByte = HIBYTE(lpMFParams[i]); nLoByte = LOBYTE(lpMFParams[i]);
switch (nRadix) { case IDB_HEX: /* if we are to display as hexadecimal */ /* format the bytes for the hex part of dump */ wsprintf((LPSTR)szBuffer, (LPSTR)"%02x %02x ", nLoByte, nHiByte ); break;
case IDB_DEC: /* format the bytes for the decimal part of dump */ iValue = lpMFParams[i]; wsprintf((LPSTR)szBuffer, (LPSTR)"%d ", iValue ); break;
case IDB_CHAR: wsprintf((LPSTR)szBuffer, (LPSTR)"%c%c", (nLoByte > 0x20) ? nLoByte : 0x2E, (nHiByte > 0x20) ? nHiByte : 0x2E); break;
case IDB_WORD: /* if we are to display as hexadecimal */ /* format the bytes for the hex part of dump */ wsprintf((LPSTR)szBuffer, (LPSTR)"%02x%02x ", nHiByte, nLoByte ); break;
default : return FALSE; }
/* concatenate it onto whatever we have already formatted */ lstrcat((LPSTR)szDump, (LPSTR)szBuffer);
/* use every 8 words for hex/dec dump */ if (!((i + 1) % 8)) {
/*add the string to the listbox */ SendDlgItemMessage(hDlg, IDL_PARAMETERS, LB_ADDSTRING, 0, (LPARAM)(LPSTR)szDump);
/* re-init the hex/dec strings in preparation for next 8 words */ *szDump = '\0'; } } } //else
//
//dump any leftover hex/dec dump
//
if (lstrlen((LPSTR)szDump)) SendDlgItemMessage(hDlg, IDL_PARAMETERS, LB_ADDSTRING, 0, (LPARAM)(LPSTR)szDump); //
//enable redraw to the listbox
//
SendDlgItemMessage(hDlg, IDL_PARAMETERS, WM_SETREDRAW, TRUE, 0L); //
//redraw it
//
InvalidateRect(GetDlgItem(hDlg,IDL_PARAMETERS), NULL, TRUE); //
//unlock the memory used for the parameters
//
GlobalUnlock(hMem);
return (TRUE);
}
extern "C"void GetMetaFileAndEnum( HWND hwnd, HDC hDC, int iAction);
/***********************************************************************
FUNCTION : PlayMetaFileToDest
PARAMETERS : HWND hWnd int nDest - DC to play metafile to DESTDISPLAY - play to the display DESTMETA - play into another metafile
PURPOSE : begin the enumeration of the metafile to the user selected destination. Perform the housekeeping needs appropriate to that destination.
CALLS : WINDOWS GetClientRect InvalidateRect GetDC SetMapMode OpenFileDialog MessageBox CreateMetaFile DeleteMetaFile CloseMetaFile
APP WaitCursor SetClipMetaExts SetPlaceableExts GetMetaFileAndEnum
MESSAGES : none
RETURNS : int
COMMENTS :
HISTORY : 1/16/91 - created - drc
************************************************************************/
BOOL PlayMetaFileToDest(HWND hWnd,int nDest){ HDC hDC; RECT rect; int iSaveRet; //
//if the file opened contained a valid metafile
//
if (bValidFile) { //
//init the record count
//
iRecNum = 0; //
//if we are stepping the metafile then clear the client area
//
if (!bPlayItAll) { GetClientRect(hWnd, (LPRECT)&rect); InvalidateRect(hWnd, (LPRECT)&rect, TRUE); }
switch (nDest) { //
//playing metafile to the display
//
case DESTDISPLAY: WaitCursor(TRUE); hDC = GetDC(hWnd);
if (!bUseGdiPlusToPlay) { //
//metafile read in from a clipboard file
//
if ( bMetaInRam && !bPlaceableMeta && !bEnhMeta) SetClipMetaExts(hDC, lpMFP, lpOldMFP, WMFDISPLAY); //
//Windows placeable metafile
//
if (bPlaceableMeta && !bEnhMeta) SetPlaceableExts(hDC, placeableWMFHeader, WMFDISPLAY); //
//Windows metafile
//
if (!bMetaInRam && !bEnhMeta) { SetNonPlaceableExts(hDC, WMFDISPLAY); } } //
//begin the enumeration of the metafile
//
DWORD start, end; DWORD renderTime; char tmpBuf[512];
start = GetTickCount();
GetMetaFileAndEnum(hWnd, hDC, ENUMMFSTEP);
end = GetTickCount(); renderTime = end - start; wsprintf(tmpBuf, "Time: %d", renderTime);
SetWindowText(hWnd, tmpBuf);
ReleaseDC(hWnd, hDC); WaitCursor(FALSE); break;
case DESTMETA: //
//get a name of a file to play the metafile into
//
iSaveRet = SaveFileDialog((LPSTR)SaveName, (LPSTR)gszSaveEMFFilter); //
//if the file selected is this metafile then warn user
//
if (!lstrcmp((LPSTR)OpenName, (LPSTR)SaveName)) MessageBox(hWnd, (LPSTR)"Cannot overwrite the opened metafile!", (LPSTR)"Play to Metafile", MB_OK | MB_ICONEXCLAMATION);
else //
//the user didn't hit the cancel button
//
if (iSaveRet) { WaitCursor(TRUE); //
//create a disk based metafile
//
hDC = (bEnhMeta) ? CreateEnhMetaFile(NULL, (LPSTR)SaveName, NULL, NULL) : CreateMetaFile((LPSTR)SaveName); //
//begin the enumeration of the metafile
//
GetMetaFileAndEnum(hWnd, hDC, ENUMMFSTEP); //
//done playing so close the metafile and delete the handle
//
if (bEnhMeta) DeleteEnhMetaFile(CloseEnhMetaFile(hDC)); else DeleteMetaFile(CloseMetaFile(hDC));
WaitCursor(FALSE); }
break;
case DESTDIB: { /* extents for the display DC */ GetClientRect(hWndMain, &rect); INT cx = rect.right - rect.left; INT cy = rect.bottom - rect.top;
/* SetMapMode(hDC, ((lpOldMFP != NULL) ? lpOldMFP->mm : lpMFP->mm));
SetViewportOrgEx(hDC, 0, 0, &lpPT); */
WaitCursor(TRUE); hDC = GetDC(hWnd); BITMAPINFOHEADER bmi; memset(&bmi, 0, sizeof(BITMAPINFOHEADER)); bmi.biSize = sizeof(BITMAPINFOHEADER); bmi.biBitCount = 24; bmi.biWidth = cx; bmi.biHeight = -cy; bmi.biPlanes = 1;
VOID* bits = NULL;
HBITMAP hBmp = CreateDIBSection(hDC, (BITMAPINFO*) &bmi, 0, &bits, NULL, 0); HDC hDCBmp = CreateCompatibleDC(hDC); ::SelectObject(hDCBmp, hBmp);
FillRect(hDCBmp, &rect, (HBRUSH) ::GetStockObject(GRAY_BRUSH));
if (!bUseGdiPlusToPlay) { //
//metafile read in from a clipboard file
//
if ( bMetaInRam && !bPlaceableMeta && !bEnhMeta) SetClipMetaExts(hDCBmp, lpMFP, lpOldMFP, WMFDISPLAY); //
//Windows placeable metafile
//
if (bPlaceableMeta && !bEnhMeta) SetPlaceableExts(hDCBmp, placeableWMFHeader, WMFDISPLAY); //
//Windows metafile
//
if (!bMetaInRam && !bEnhMeta) { SetNonPlaceableExts(hDCBmp, WMFDISPLAY); } } //
//begin the enumeration of the metafile
//
start = GetTickCount();
GetMetaFileAndEnum(hWnd, hDCBmp, ENUMMFSTEP);
end = GetTickCount(); renderTime = end - start; wsprintf(tmpBuf, "Time: %d", renderTime);
SetWindowText(hWnd, tmpBuf); StretchDIBits(hDC, 0, 0, cx, cy, 0, 0, cx, cy, bits, (BITMAPINFO*)&bmi, 0, SRCCOPY); DeleteDC(hDCBmp); DeleteObject((HGDIOBJ) hBmp);
ReleaseDC(hWnd, hDC); WaitCursor(FALSE); break;
} case DESTPRN:{ HDC hPr = (HDC)NULL; PRINTDLG pd;
memset(&pd, 0, sizeof(PRINTDLG)); pd.lStructSize = sizeof(PRINTDLG); pd.Flags = PD_RETURNDC; pd.hwndOwner = hWndMain;
//
//get a DC for the printer
//
if (PrintDlg(&pd) != 0) hPr= pd.hDC; else break;
//
//if a DC could not be created then report the error and return
//
if (!hPr) { WaitCursor(FALSE); wsprintf((LPSTR)str, "Cannot print %s", (LPSTR)fnameext); MessageBox(hWndMain, (LPSTR)str, NULL, MB_OK | MB_ICONHAND); break; }
//
//define the abort function
//
SetAbortProc(hPr, AbortProc);
//
//Initialize the members of a DOCINFO structure.
//
DOCINFO di; memset(&di, 0, sizeof(di)); di.cbSize = sizeof(DOCINFO); di.lpszDocName = (bEnhMeta) ? "Print EMF" : "Print WMF"; di.lpszOutput = (LPTSTR) NULL;
//
//Begin a print job by calling the StartDoc
//function.
//
if (SP_ERROR == (StartDoc(hPr, &di))) { //if (Escape(hPr, STARTDOC, 4, "Metafile", (LPSTR) NULL) < 0) {
MessageBox(hWndMain, "Unable to start print job", NULL, MB_OK | MB_ICONHAND); DeleteDC(hPr); break; }
//
//clear the abort flag
//
bAbort = FALSE;
//
//Create the Abort dialog box (modeless)
//
hAbortDlgWnd = CreateDialog((HINSTANCE)hInst, "AbortDlg", hWndMain, AbortDlg);
//
//if the dialog was not created report the error
//
if (!hAbortDlgWnd) { WaitCursor(FALSE); MessageBox(hWndMain, "NULL Abort window handle", NULL, MB_OK | MB_ICONHAND); break; }
//
//show Abort dialog
//
ShowWindow (hAbortDlgWnd, SW_NORMAL);
//
//disable the main window to avoid reentrancy problems
//
EnableWindow(hWndMain, FALSE); WaitCursor(FALSE);
//
//if we are still committed to printing
//
if (!bUseGdiPlusToPlay) { //
//if this is a placeable metafile then set its origins and extents
//
if (bPlaceableMeta) SetPlaceableExts(hPr, placeableWMFHeader, WMFPRINTER);
//
//if this is a metafile contained within a clipboard file then set
//its origins and extents accordingly
//
if ( (bMetaInRam) && (!bPlaceableMeta) ) SetClipMetaExts(hPr, lpMFP, lpOldMFP, WMFPRINTER); }
//
//if this is a "traditional" windows metafile
//
RECT rc;
rc.left = 0; rc.top = 0; rc.right = GetDeviceCaps(hPr, HORZRES); rc.bottom = GetDeviceCaps(hPr, VERTRES);
POINT lpPT; SIZE lpSize; if (TRUE || !bMetaInRam) { SetMapMode(hPr, MM_TEXT); SetViewportOrgEx(hPr, 0, 0, &lpPT);
//
//set the extents to the driver supplied values for horizontal
//and vertical resolution
//
SetViewportExtEx(hPr, rc.right, rc.bottom, &lpSize ); }
//
//play the metafile directly to the printer.
//No enumeration involved here
//
GetMetaFileAndEnum(hWnd, hPr, ENUMMFSTEP);
//
//eject page and end the print job
//
Escape(hPr, NEWFRAME, 0, 0L, 0L);
EndDoc(hPr);
EnableWindow(hWndMain, TRUE);
//
//destroy the Abort dialog box
//
DestroyWindow(hAbortDlgWnd);
DeleteDC(hPr);
}
default: break; } //
//if playing list records then free the memory used for the list of
//selected records
//
if (bPlayList) { GlobalUnlock(hSelMem); GlobalFree(hSelMem); bPlayList = FALSE; } //
//success
//
return (TRUE); } else //
//not a valid metafile
//
return (FALSE);}
/***********************************************************************
FUNCTION : RenderClipMeta
PARAMETERS : CLIPFILEFORMAT *ClipHeader int fh
PURPOSE : read metafile bits, metafilepict and metafile header of the metafile contained within a clipboard file
CALLS : WINDOWS GlobalAlloc GlobalLock GlobalUnlock GlobalFree MessageBox _llseek _lread _lclose SetMetaFileBits
MESSAGES : none
RETURNS : BOOL
COMMENTS :
HISTORY : 1/16/91 - created - drc 5/23/93 - ported to NT. it must handle 3.1 clipboard as well as NT clipboard files - drc
************************************************************************/
BOOL RenderClipMeta(LPVOID lpvClipHeader, int fh, WORD ClipID){ int wBytesRead; long lBytesRead; long lSize; DWORD lOffset; DWORD dwSizeOfMetaFilePict; BOOL bEMF = FALSE; LPNTCLIPFILEFORMAT lpNTClp; LPCLIPFILEFORMAT lpClp; //
//cast the void ptr to the clipfile header appropriately
//
if (bEnhMeta) { lpNTClp = (LPNTCLIPFILEFORMAT)lpvClipHeader; bEMF = TRUE; } else lpClp = (LPCLIPFILEFORMAT)lpvClipHeader; //
//obtain the appropriate size of the metafilepict. win16 vs win32
//
dwSizeOfMetaFilePict = (ClipID == CLP_ID) ? sizeof(OLDMETAFILEPICT) : sizeof(METAFILEPICT); //
//free any memory already allocated for the METAFILEPICT
//
if (lpMFP != NULL || lpOldMFP != NULL) { GlobalFreePtr(lpMFP); lpMFP = NULL; } //
//allocate enough memory to read the metafile bits into
//
if (!(lpMFBits = (char*)GlobalAllocPtr(GHND, ((bEMF) ? lpNTClp->DataLen : lpClp->DataLen - dwSizeOfMetaFilePict)))) return(FALSE); //
//offset to the metafile bits
//
lOffset = ((bEMF) ? lpNTClp->DataOffset : lpClp->DataOffset + dwSizeOfMetaFilePict ); //
//size of metafile bits
//
lSize = (long)( ((bEMF) ? lpNTClp->DataLen : lpClp->DataLen - dwSizeOfMetaFilePict)); //
//seek to the beginning of the metafile bits
//
_llseek(fh, lOffset, 0); //
//read the metafile bits
//
lBytesRead = _hread(fh, lpMFBits, lSize); //
//if unable to read the metafile bits bail out
//
if( lBytesRead == -1 || lBytesRead < lSize) { GlobalFreePtr(lpMFBits); MessageBox(hWndMain, "Unable to read metafile bits", NULL, MB_OK | MB_ICONHAND); return(FALSE); } //
//return to beginning to read metafile header
//
_llseek(fh, lOffset, 0); //
//read the metafile header
//
if (!bEMF) wBytesRead = _lread(fh, (LPSTR)&mfHeader, sizeof(METAHEADER)); else wBytesRead = _lread(fh, (LPSTR)&emfHeader, sizeof(ENHMETAHEADER)); //
//if unable to read the header return
//
if( wBytesRead == -1 || (WORD)wBytesRead < ((bEMF) ? sizeof(ENHMETAHEADER) : sizeof(METAHEADER)) ) { MessageBox(hWndMain, "Unable to read metafile header", NULL, MB_OK | MB_ICONHAND); return(FALSE); } //
//set the metafile bits to the memory allocated for that purpose
//
if (bEMF) //
//win32
//
hemf = SetEnhMetaFileBits(GlobalSizePtr(lpMFBits), (const unsigned char *)lpMFBits); else //
//win16
//
hMF = SetMetaFileBitsEx(GlobalSizePtr(lpMFBits), (const unsigned char *)lpMFBits);
if ( NULL == ((bEMF) ? hemf : hMF)) { MessageBox(hWndMain, "Unable to set metafile bits", NULL, MB_OK | MB_ICONHAND);
return(FALSE); } //
//allocate memory for the metafile pict structure
//
if (!(hMFP = GlobalAlloc(GHND, dwSizeOfMetaFilePict))) { MessageBox(hWndMain, "Unable allocate memory for metafile pict", NULL, MB_OK | MB_ICONHAND); return(FALSE); } //
//lock the memory
//
if (ClipID == CLP_ID) lpOldMFP = (LPOLDMETAFILEPICT)GlobalLock(hMFP); else lpMFP = (LPMETAFILEPICT)GlobalLock(hMFP);
if (!lpMFP && !lpOldMFP) { MessageBox(hWndMain, "unable to lock metafile pict memory", NULL, MB_OK | MB_ICONHAND); GlobalFree(hMFP); return(FALSE); } //
//reposition to the start of the METAFILEPICT header.
//
_llseek(fh, ((bEMF) ? lpNTClp->DataOffset : lpClp->DataOffset), 0); //
//read the metafile pict structure
//
wBytesRead = _lread(fh, ((ClipID == CLP_ID) ? (LPVOID)lpOldMFP : (LPVOID)lpMFP), dwSizeOfMetaFilePict); //
//if unable to read, return
//
if( wBytesRead == -1 || wBytesRead < (long)dwSizeOfMetaFilePict) { MessageBox(hWndMain, "Unable to read metafile pict", NULL, MB_OK | MB_ICONHAND); GlobalUnlock(hMFP); GlobalFree(hMFP); return(FALSE); }
if (bEnhMeta) GetEMFCoolStuff();//DENNIS - check this out....
/* update metafile handle */ if (ClipID == CLP_ID) lpOldMFP->hMF = (WORD)hMF; else lpMFP->hMF = (HMETAFILE)hemf;
return(TRUE);}
/***********************************************************************
FUNCTION : RenderPlaceableMeta
PARAMETERS : int fh - filehandle to the placeable metafile
PURPOSE : read the metafile bits, metafile header and placeable metafile header of a placeable metafile.
CALLS : WINDOWS GlobalAlloc GlobalLock Global DeleteMetaFile SetMetaFileBits _llseek _lread _lclose MessageBox
MESSAGES : none
RETURNS : BOOL
COMMENTS :
HISTORY : 1/16/91 - created - drc 7/1/93 - modified for win32 - denniscr
************************************************************************/
BOOL RenderPlaceableMeta(int fh){ int wBytesRead; long lBytesRead; DWORD dwSize; //
//if there is currently a metafile loaded, get rid of it
//
if (bMetaInRam && hMF && !bEnhMeta) DeleteMetaFile((HMETAFILE)hMF); //
//seek to beginning of file and read placeable header
//
_llseek(fh, 0, 0); //
//read the placeable header
//
wBytesRead = _lread(fh, (LPSTR)&placeableWMFHeader, sizeof(PLACEABLEWMFHEADER)); //
//if there is an error, return
//
if( wBytesRead == -1 || wBytesRead < sizeof(PLACEABLEWMFHEADER) ) { MessageBox(hWndMain, "Unable to read placeable header", NULL, MB_OK | MB_ICONHAND); return(FALSE); } //
//return to read metafile header
//
_llseek(fh, sizeof(placeableWMFHeader), 0); //
//read the metafile header
//
wBytesRead = _lread(fh, (LPSTR)&mfHeader, sizeof(METAHEADER)); //
//if there is an error return
//
if( wBytesRead == -1 || wBytesRead < sizeof(METAHEADER) ) { MessageBox(hWndMain, "Unable to read metafile header", NULL, MB_OK | MB_ICONHAND); return(FALSE); } //
//allocate memory for the metafile bits
//
if (!(lpMFBits = (char *)GlobalAllocPtr(GHND, (mfHeader.mtSize * 2L)))) { MessageBox(hWndMain, "Unable to allocate memory for metafile bits", NULL, MB_OK | MB_ICONHAND); return(FALSE); } //
//seek to the metafile bits
//
_llseek(fh, sizeof(placeableWMFHeader), 0); //
//read metafile bits
//
lBytesRead = _hread(fh, lpMFBits, mfHeader.mtSize * 2); //
//if there was an error
//
if( lBytesRead == -1 ) { MessageBox(hWndMain, "Unable to read metafile bits", NULL, MB_OK | MB_ICONHAND); GlobalFreePtr(lpMFBits); return(FALSE); } //
//set the metafile bits to the memory that we allocated
//
dwSize = GlobalSizePtr(lpMFBits);
if (!(hMF = SetMetaFileBitsEx(dwSize, (const unsigned char *)lpMFBits))) return(FALSE);
return(TRUE);}
/***********************************************************************
FUNCTION : SetPlaceableExts
PARAMETERS : HDC hDC PLACEABLEWMFHEADER phdr int nDest
PURPOSE : set the origins and extents on the DC to correspond with the origins and extents specified within the placeable metafile header
CALLS : WINDOWS GetClientRect SetMapMode SetWindowOrg SetWindowExt SetViewportOrg SetViewportExt
C runtime labs
MESSAGES : none
RETURNS : void
COMMENTS :
HISTORY : 1/16/91 - created - drc
************************************************************************/
void SetPlaceableExts(HDC hDC, PLACEABLEWMFHEADER phdr, int nDest){ RECT rect; POINT lpPT; SIZE lpSize;
/* if setting the extents on the display DC */ if (nDest != WMFPRINTER) GetClientRect(hWndMain, &rect);
SetMapMode(hDC, MM_ANISOTROPIC);
/* set the windows origin to correspond to the bounding box origin
contained in the placeable header */ SetWindowOrgEx(hDC, phdr.bbox.left, phdr.bbox.top, &lpPT);
/* set the window extents based on the abs value of the bbox coords */ SetWindowExtEx(hDC,phdr.bbox.right -phdr.bbox.left, phdr.bbox.bottom -phdr.bbox.top, &lpSize);
/* set the viewport origin and extents */ if (nDest != WMFPRINTER) { SetViewportOrgEx(hDC, 0, 0, &lpPT); SetViewportExtEx(hDC, rect.right, rect.bottom, &lpSize); } else { SetViewportOrgEx(hPr, 0, 0, &lpPT); SetViewportExtEx(hPr,GetDeviceCaps(hPr, HORZRES), GetDeviceCaps(hPr, VERTRES), &lpSize); }}
void SetNonPlaceableExts(HDC hDC, int nDest){ RECT rect; POINT lpPT; SIZE lpSize;
/* if setting the extents on the display DC */ if (nDest != WMFPRINTER) GetClientRect(hWndMain, &rect);
SetMapMode(hDC, MM_ANISOTROPIC);
/* set the viewport origin and extents */ if (nDest != WMFPRINTER) { SetViewportOrgEx(hDC, 0, 0, &lpPT); SetViewportExtEx(hDC, rect.right, rect.bottom, &lpSize); } else { SetViewportOrgEx(hPr, 0, 0, &lpPT); SetViewportExtEx(hPr,GetDeviceCaps(hPr, HORZRES), GetDeviceCaps(hPr, VERTRES), &lpSize); }}
/***********************************************************************
FUNCTION : SetClipMetaExts
PARAMETERS : HDC hDC METAFILEPICT MFP int nDest
PURPOSE : set the extents to the client rect for clipboard metafiles
CALLS : WINDOWS GetClientRect IntersectClipRect SetMapMode SetViewportOrg SetViewportExt SetWindowExt
MESSAGES : none
RETURNS : void
COMMENTS : this is not as robust as it could be. A more complete approach might be something like Petzold discusses in his Programming Windows book on page 793 in the function PrepareMetaFile().
HISTORY : 1/16/91 - created - drc
************************************************************************/
void SetClipMetaExts(HDC hDC,LPMETAFILEPICT lpMFP,LPOLDMETAFILEPICT lpOldMFP,int nDest){ int cx, cy; RECT rect; POINT lpPT; SIZE lpSize; long lmm; long lxExt; long lyExt;
/* extents for the display DC */ if (nDest != WMFPRINTER) { GetClientRect(hWndMain, &rect); cx = rect.right - rect.left; cy = rect.bottom - rect.top; IntersectClipRect(hDC, rect.left, rect.top, rect.right, rect.bottom); }
SetMapMode(hDC, ((lpOldMFP != NULL) ? lpOldMFP->mm : lpMFP->mm));
/* set physical origin to 0, 0 */ SetViewportOrgEx(hDC, 0, 0, &lpPT);
/* given the mapping mode specified in the metafilepict */ lmm = (lpOldMFP != NULL) ? lpOldMFP->mm : lpMFP->mm; lxExt = (lpOldMFP != NULL) ? lpOldMFP->xExt : lpMFP->xExt; lyExt = (lpOldMFP != NULL) ? lpOldMFP->yExt : lpMFP->yExt;
switch (lmm) { case MM_ISOTROPIC: if (lxExt && lyExt) SetWindowExtEx(hDC, lxExt, lyExt, &lpSize);
/* fall through */
case MM_ANISOTROPIC: if (nDest != WMFPRINTER) SetViewportExtEx(hDC, cx, cy, &lpSize); else SetViewportExtEx(hDC, GetDeviceCaps(hDC, HORZRES), GetDeviceCaps(hDC, VERTRES), &lpSize ); break;
default: break; }
}
/***********************************************************************
FUNCTION : ProcessFile
PARAMETERS : HWND hWnd LPSTR lpFileName
PURPOSE : open the metafile, determine if it contains a valid metafile, decide what type of metafile it is (wmf, clipboard, or placeable) and take care of some menu housekeeping tasks.
CALLS :
MESSAGES : none
RETURNS : BOOL
COMMENTS :
HISTORY : 1/16/91 - created - drc
************************************************************************/
BOOL ProcessFile(HWND hWnd,LPSTR lpFileName){ //
//for openfiledialog
//
char drive[3]; char dir[MAX_PATH+1]; char fname[MAX_PATH+1]; char ext[5];
char * pchCorrectSir; //
//initialize these global handles to metafiles
//
if (hMF && !bMetaInRam) { DeleteMetaFile((HMETAFILE)hMF); hMF = NULL; } if (hemf && !bMetaInRam) { DeleteEnhMetaFile(hemf); hemf = NULL; }
if (lpMFBits) { GlobalFreePtr(lpMFBits); lpMFBits = NULL; hemf = NULL; hMF = NULL; }
bEnhMeta = FALSE; //
//split the fully qualified filename into its components
//
SplitPath( lpFileName, (LPSTR)drive, (LPSTR)dir, (LPSTR)fname, (LPSTR)ext);
pchCorrectSir = _strupr( _strdup( ext ) ); //
//if the memory for the emf header, desc string and palette
//is still around then nuke it
//
if (EmfPtr.lpEMFHdr) { GlobalFreePtr(EmfPtr.lpEMFHdr); EmfPtr.lpEMFHdr = NULL ; } if (EmfPtr.lpDescStr) { GlobalFreePtr(EmfPtr.lpDescStr); EmfPtr.lpDescStr = NULL ; } if (EmfPtr.lpPal) { GlobalFreePtr(EmfPtr.lpPal); EmfPtr.lpPal = NULL ; } //
//if the file is an enhanced metafile
//
if (lstrcmp((LPSTR)pchCorrectSir, (LPSTR)"CLP") == 0) return ProcessCLP(hWnd, lpFileName); //
//if the file is a Windows metafile or a Windows or placeable metafile
//as per the normal naming conventions
//
if (lstrcmp((LPSTR)pchCorrectSir, (LPSTR)"WMF") == 0) return ProcessWMF(hWnd, lpFileName); //
//if the file is a clipboard file
//
if (lstrcmp((LPSTR)pchCorrectSir, (LPSTR)"EMF") == 0) return ProcessEMF(hWnd, lpFileName);
return FALSE;}
/***********************************************************************
FUNCTION : ProcessWMF
PARAMETERS : HWND hWnd LPSTR lpFileName
PURPOSE : open the metafile and determine if it is a Windows metafile or placeable metafile. Then take care of some menu housekeeping tasks.
CALLS :
MESSAGES : none
RETURNS : BOOL
COMMENTS :
HISTORY : 6/23/93 - created - drc
************************************************************************/
BOOL ProcessWMF(HWND hWnd, LPSTR lpFileName){ int fh; int wBytesRead; DWORD dwIsPlaceable; char szCaption[144];
/* for openfiledialog */ char drive[3]; char dir[MAX_PATH+1]; char fname[MAX_PATH+1]; char ext[5]; char * pchCorrectSir; //
//split the fully qualified filename into its components
//
SplitPath( lpFileName, (LPSTR)drive, (LPSTR)dir, (LPSTR)fname, (LPSTR)ext);
pchCorrectSir = _strupr( _strdup( ext ) ); //
//try to open the file. It's existence has already been
//checked by OpenFileDialog
//
fh = _lopen(lpFileName, OF_READ); //
//if opened successfully
//
if (fh != -1) { //
//always disable the clipboard and EMF header menu if we get here
//
EnableMenuItem(GetMenu(hWnd), IDM_CLIPHDR, MF_DISABLED | MF_GRAYED); EnableMenuItem(GetMenu(hWnd), IDM_ENHHEADER, MF_DISABLED | MF_GRAYED); //
// read the first dword of the file to see if it is a placeable wmf
//
wBytesRead = _lread(fh,(LPSTR)&dwIsPlaceable, sizeof(dwIsPlaceable));
if (wBytesRead == -1 || wBytesRead < sizeof(dwIsPlaceable)) { _lclose(fh); MessageBox(hWndMain, "unable to read file", NULL, MB_OK | MB_ICONEXCLAMATION); return (FALSE);
} //
// if this is windows metafile, not a placeable wmf
//
if (dwIsPlaceable != PLACEABLEKEY) { // if (!bMetaInRam)
hMF = GetMetaFile((LPSTR)OpenName); //
//disable placeable header menu item
//
EnableMenuItem(GetMenu(hWnd), IDM_PLACEABLEHDR, MF_DISABLED|MF_GRAYED); //
//seek to the beginning of the file
//
_llseek(fh, 0, 0); //
//read the wmf header
//
wBytesRead = _lread(fh, (LPSTR)&mfHeader, sizeof(METAHEADER)); //
//done with file so close it
//
_lclose(fh); //
//if read failed
//
if (wBytesRead == -1 || wBytesRead < sizeof(dwIsPlaceable)) { MessageBox(hWndMain, "unable to read metafile header", NULL, MB_OK | MB_ICONEXCLAMATION); return (FALSE); } } //
//this is a placeable metafile
//
else { //
//enable the placeable header menu item
//
EnableMenuItem(GetMenu(hWnd), IDM_PLACEABLEHDR, MF_ENABLED); //
//convert the placeable format into something that can
//be used with GDI metafile functions
//
RenderPlaceableMeta(fh); //
//close the file
//
_lclose(fh);
} //
//at this point we have a metafile header regardless of whether
//the metafile was a windows metafile or a placeable metafile
//so check to see if it is valid. There is really no good
//way to do this so just make sure that the mtType is either
//1 or 2 (memory or disk file)
//
if ( (mfHeader.mtType != 1) && (mfHeader.mtType != 2) ) { //
//set the program flags appropriately
//
bBadFile = TRUE; bMetaFileOpen = FALSE; bValidFile = FALSE; //
//let the user know that this is an invalid metafile
//
MessageBox(hWndMain, "This file is not a valid metafile", NULL, MB_OK | MB_ICONEXCLAMATION); //
//restore the caption text to the default
//
SetWindowText(hWnd, (LPSTR)APPNAME); //
//disable menu items, indicating that a valid metafile has not been
//loaded
//
EnableMenuItem(GetMenu(hWnd), IDM_VIEW, MF_DISABLED|MF_GRAYED|MF_BYPOSITION); EnableMenuItem(GetMenu(hWnd), IDM_PLAY, MF_DISABLED|MF_GRAYED|MF_BYPOSITION); EnableMenuItem(GetMenu(hWnd), IDM_PRINT, MF_DISABLED|MF_GRAYED); EnableMenuItem(GetMenu(hWnd), IDM_PRINTDLG, MF_DISABLED|MF_GRAYED); EnableMenuItem(GetMenu(hWnd), IDM_SAVEAS, MF_DISABLED|MF_GRAYED); //
//refresh the menu bar to reflect above changes
//
DrawMenuBar(hWnd); } //
//this is a valid metafile...at least based on the above criteria
//
else { //
//modify and update the caption text
//
wsprintf((LPSTR)szCaption, (LPSTR)"%s - %s.%s", (LPSTR)APPNAME, (LPSTR)fname, (LPSTR)ext); //
//this could be used by the printing routines if unable to print
//
wsprintf((LPSTR)fnameext, (LPSTR)"%s.%s", (LPSTR)fname, (LPSTR)ext);
SetWindowText(hWnd, (LPSTR)szCaption); //
//enable the appropriate menu items
//
EnableMenuItem(GetMenu(hWnd), IDM_VIEW, MF_ENABLED|MF_BYPOSITION); EnableMenuItem(GetMenu(hWnd), IDM_PLAY, MF_ENABLED|MF_BYPOSITION); EnableMenuItem(GetMenu(hWnd), IDM_PRINT, MF_ENABLED); EnableMenuItem(GetMenu(hWnd), IDM_PRINTDLG, MF_ENABLED); EnableMenuItem(GetMenu(hWnd), IDM_SAVEAS, MF_ENABLED); EnableMenuItem(GetMenu(hWnd), IDM_HEADER, MF_ENABLED); //
//refresh the menu bar to reflect above changes
//
DrawMenuBar(hWnd); //
//set global flags appropriately
//
bValidFile = TRUE; bMetaFileOpen = TRUE;
if (dwIsPlaceable != PLACEABLEKEY) { bPlaceableMeta = FALSE; bMetaInRam = FALSE; } else { bPlaceableMeta = TRUE; bMetaInRam = TRUE; } } return (TRUE);
} //if fh != -1
else return (FALSE);}
/***********************************************************************
FUNCTION : ProcessCLP
PARAMETERS : HWND hWnd LPSTR lpFileName
PURPOSE : open the metafile contained in the clipboard file and take care of some menu housekeeping tasks.
CALLS :
MESSAGES : none
RETURNS : BOOL
COMMENTS :
HISTORY : 6/23/93 - created - drc
************************************************************************/
BOOL ProcessCLP(HWND hWnd, LPSTR lpFileName){ WORD i; int fh; DWORD HeaderPos; DWORD nSizeOfClipHeader; DWORD nSizeOfClipFormat; NTCLIPFILEHEADER NTFileHeader; NTCLIPFILEFORMAT NTClipHeader; CLIPFILEHEADER FileHeader; CLIPFILEFORMAT ClipHeader; char szCaption[144]; WORD wFileID; BOOL bMetaFound = FALSE; LPVOID lpvAddressOfHdr;
/* for openfiledialog */ char drive[3]; char dir[MAX_PATH+1]; char fname[MAX_PATH+1]; char ext[5]; char * pchCorrectSir; //
//split the fully qualified filename into its components
//
SplitPath( lpFileName, (LPSTR)drive, (LPSTR)dir, (LPSTR)fname, (LPSTR)ext);
pchCorrectSir = _strupr( _strdup( ext ) ); //
//try to open the file. It's existence has already been
//checked by OpenFileDialog
fh = _lopen(lpFileName, OF_READ); //
//if opened successfully
if (fh != -1 ) { //
// read the clipboard fileidentifier
//
wFileID = 0; _lread(fh, (LPSTR)&wFileID, sizeof(WORD)); _llseek(fh, 0, 0); //
//if this is not a valid clipboard file based on the file
//identifier of the file header
//
if (wFileID != CLP_ID && wFileID != CLP_NT_ID && wFileID != CLPBK_NT_ID) {
_lclose(fh); MessageBox(hWndMain, "This file is not a valid clipboard file", NULL, MB_OK | MB_ICONEXCLAMATION); return (FALSE); } switch (wFileID) { case CLP_ID: _lread(fh, (LPSTR)&FileHeader, sizeof(CLIPFILEHEADER)); nSizeOfClipHeader = sizeof(CLIPFILEHEADER); nSizeOfClipFormat = sizeof(CLIPFILEFORMAT); HeaderPos = nSizeOfClipHeader; break;
case CLP_NT_ID: case CLPBK_NT_ID: NTFileHeader.FormatCount = 0; _lread(fh, (LPSTR)&NTFileHeader, sizeof(NTCLIPFILEHEADER)); nSizeOfClipHeader = sizeof(NTCLIPFILEHEADER); nSizeOfClipFormat = sizeof(NTCLIPFILEFORMAT); HeaderPos = nSizeOfClipHeader; break;
default: break; } //
//search the formats contained within the clipboard file looking
//for a metafile. Break if and when it is found
//
for (i=0; i < ((wFileID == CLP_ID) ? FileHeader.FormatCount : NTFileHeader.FormatCount); i++) {
_llseek(fh, HeaderPos, 0); //
//read the clipboard header found at current position
//
lpvAddressOfHdr = (wFileID == CLP_ID) ? (LPVOID)&ClipHeader : (LPVOID)&NTClipHeader;
if(_lread(fh, (LPSTR)lpvAddressOfHdr, nSizeOfClipFormat) < nSizeOfClipFormat) //if(_lread(fh, (LPSTR)&ClipHeader, nSizeOfClipHeader) < nSizeOfClipHeader)
{ _lclose(fh); MessageBox(hWndMain, "read of clipboard header failed", NULL, MB_OK | MB_ICONEXCLAMATION); return (FALSE); } //
//increment the file offset to data
//
HeaderPos += nSizeOfClipFormat; //
//if a metafile was found break...
//this break assumes that CF_METAFILEPICT formats are always written before CF_ENHMETAFILE
//formats.
//
if (wFileID == CLP_ID && ClipHeader.FormatID == CF_METAFILEPICT) { bMetaFound = TRUE; break; }
if (wFileID == CLP_NT_ID || wFileID == CLPBK_NT_ID) { if (NTClipHeader.FormatID == CF_ENHMETAFILE)// HeaderPos += NTClipHeader.DataLen;
//else
{ bMetaFound = TRUE; break; } }
} //for i < formatcount
if (bMetaFound) { //
//if there is currently a metafile loaded delete it.
//
if (wFileID == CLP_ID) { if ((bMetaInRam) && (hMF)) { DeleteMetaFile((HMETAFILE)hMF); hMF = NULL; } } else { if ((bMetaInRam) && (hemf)) { DeleteEnhMetaFile(hemf); hemf = NULL; } }
//
//modify and update the caption text
//
wsprintf((LPSTR)szCaption, (LPSTR)"%s - %s.%s", (LPSTR)APPNAME, (LPSTR)fname, (LPSTR)ext); //
//this could be used by the printing routines if unable to print
//
wsprintf((LPSTR)fnameext, (LPSTR)"%s.%s", (LPSTR)fname, (LPSTR)ext);
SetWindowText(hWnd, (LPSTR)szCaption); //
//enable the appropriate menu items
//
if (wFileID == CLP_ID) { EnableMenuItem(GetMenu(hWnd), IDM_ENHHEADER, MF_DISABLED | MF_GRAYED); EnableMenuItem(GetMenu(hWnd), IDM_HEADER, MF_ENABLED); } else { EnableMenuItem(GetMenu(hWnd), IDM_ENHHEADER, MF_ENABLED); EnableMenuItem(GetMenu(hWnd), IDM_HEADER, MF_DISABLED | MF_GRAYED); }
EnableMenuItem(GetMenu(hWnd), IDM_PLACEABLEHDR, MF_DISABLED|MF_GRAYED); EnableMenuItem(GetMenu(hWnd), IDM_CLIPHDR, MF_ENABLED); EnableMenuItem(GetMenu(hWnd), IDM_VIEW, MF_ENABLED|MF_BYPOSITION); EnableMenuItem(GetMenu(hWnd), IDM_PLAY, MF_ENABLED|MF_BYPOSITION); EnableMenuItem(GetMenu(hWnd), IDM_PRINT, MF_ENABLED); EnableMenuItem(GetMenu(hWnd), IDM_PRINTDLG, MF_ENABLED); EnableMenuItem(GetMenu(hWnd), IDM_SAVEAS, MF_ENABLED); //
//refresh the menu bar
//
DrawMenuBar(hWnd); //
//set the program flags appropriately
//
bValidFile = TRUE; bMetaFileOpen = TRUE; bMetaInRam = TRUE; bPlaceableMeta = FALSE; bEnhMeta = (wFileID == CLP_ID) ? FALSE : TRUE; //
//convert the metafile contained within the clipboard file into
//a format useable with GDI metafile functions
//
if (!RenderClipMeta(((wFileID == CLP_ID)? (LPVOID)&ClipHeader : (LPVOID)&NTClipHeader), fh, FileHeader.FileIdentifier))
MessageBox(hWndMain, "Unable to render format", NULL, MB_OK | MB_ICONEXCLAMATION); _lclose(fh);
} //
//a metafile was not found within the clipboard file
//
else { bBadFile = TRUE; bMetaFileOpen = FALSE; bValidFile = FALSE; bEnhMeta = FALSE; //
//let the user know
//
MessageBox(hWndMain, "This CLP file doesn't contain a valid metafile", NULL, MB_OK | MB_ICONEXCLAMATION); //
//restore the caption text to default
//
SetWindowText(hWnd, (LPSTR)APPNAME); //
//disable previously enabled menu items
//
EnableMenuItem(GetMenu(hWnd), IDM_VIEW, MF_DISABLED|MF_GRAYED|MF_BYPOSITION); EnableMenuItem(GetMenu(hWnd), IDM_PLAY, MF_DISABLED|MF_GRAYED|MF_BYPOSITION); EnableMenuItem(GetMenu(hWnd), IDM_PRINT, MF_DISABLED|MF_GRAYED); EnableMenuItem(GetMenu(hWnd), IDM_PRINTDLG, MF_DISABLED|MF_GRAYED); EnableMenuItem(GetMenu(hWnd), IDM_SAVEAS, MF_DISABLED|MF_GRAYED); //
//refresh the menu bar to reflect these changes
//
DrawMenuBar(hWnd); _lclose(fh); } return (TRUE); } else return (FALSE);}
/***********************************************************************
FUNCTION : ProcessEMF
PARAMETERS : HWND hWnd LPSTR lpFileName
PURPOSE : open the metafile contained in the clipboard file and take care of some menu housekeeping tasks.
CALLS :
MESSAGES : none
RETURNS : BOOL
COMMENTS :
HISTORY : 6/23/93 - created - drc
************************************************************************/
BOOL ProcessEMF(HWND hWnd, LPSTR lpFileName){ char szCaption[144];
/* for openfiledialog */ char drive[3]; char dir[MAX_PATH+1]; char fname[MAX_PATH+1]; char ext[5]; char * pchCorrectSir;
bEnhMeta = FALSE; //
//split the fully qualified filename into its components
//
SplitPath( lpFileName, (LPSTR)drive, (LPSTR)dir, (LPSTR)fname, (LPSTR)ext);
pchCorrectSir = _strupr( _strdup( ext ) ); //
//always disable the clipboard, WMF and Placeable header menu if we get here
//
EnableMenuItem(GetMenu(hWnd), IDM_CLIPHDR, MF_DISABLED | MF_GRAYED); EnableMenuItem(GetMenu(hWnd), IDM_HEADER, MF_DISABLED | MF_GRAYED); EnableMenuItem(GetMenu(hWnd), IDM_PLACEABLEHDR, MF_DISABLED|MF_GRAYED); //
//if emf was successfully opened
//
if (!hemf) hemf = GetEnhMetaFile(lpFileName);
if (hemf) { GetEMFCoolStuff(); //
//modify and update the caption text
//
wsprintf((LPSTR)szCaption, (LPSTR)"%s - %s.%s", (LPSTR)APPNAME, (LPSTR)fname, (LPSTR)ext); //
//this could be used by the printing routines if unable to print
//
wsprintf((LPSTR)fnameext, (LPSTR)"%s.%s", (LPSTR)fname, (LPSTR)ext);
SetWindowText(hWnd, (LPSTR)szCaption); //
//enable the appropriate menu items
//
EnableMenuItem(GetMenu(hWnd), IDM_ENHHEADER, MF_ENABLED); EnableMenuItem(GetMenu(hWnd), IDM_VIEW, MF_ENABLED|MF_BYPOSITION); EnableMenuItem(GetMenu(hWnd), IDM_PLAY, MF_ENABLED|MF_BYPOSITION); EnableMenuItem(GetMenu(hWnd), IDM_PRINT, MF_ENABLED); EnableMenuItem(GetMenu(hWnd), IDM_PRINTDLG, MF_ENABLED); EnableMenuItem(GetMenu(hWnd), IDM_SAVEAS, MF_ENABLED); //
//refresh the menu bar
//
DrawMenuBar(hWnd); //
//set the program flags appropriately
//
bValidFile = TRUE; bMetaFileOpen = TRUE; bEnhMeta = TRUE; bMetaInRam = FALSE; bPlaceableMeta = FALSE;
}// DeleteEnhMetaFile(hemf);
else { bEnhMeta = FALSE; bValidFile = FALSE; bBadFile = TRUE; bMetaFileOpen = FALSE; //
//let the user know
//
MessageBox(hWndMain, "This EMF file doesn't contain a valid metafile", NULL, MB_OK | MB_ICONEXCLAMATION); //
//restore the caption text to default
//
SetWindowText(hWnd, (LPSTR)APPNAME); //
//disable previously enabled menu items
//
EnableMenuItem(GetMenu(hWnd), IDM_VIEW, MF_DISABLED|MF_GRAYED|MF_BYPOSITION); EnableMenuItem(GetMenu(hWnd), IDM_PLAY, MF_DISABLED|MF_GRAYED|MF_BYPOSITION); EnableMenuItem(GetMenu(hWnd), IDM_PRINT, MF_DISABLED|MF_GRAYED); EnableMenuItem(GetMenu(hWnd), IDM_PRINTDLG, MF_DISABLED|MF_GRAYED); EnableMenuItem(GetMenu(hWnd), IDM_SAVEAS, MF_DISABLED|MF_GRAYED); //
//refresh the menu bar to reflect these changes
//
DrawMenuBar(hWnd); }
return TRUE;}
/***********************************************************************
FUNCTION : GetEMFCoolStuff
PARAMETERS :
PURPOSE :
CALLS :
MESSAGES :
RETURNS :
COMMENTS :
HISTORY : created 7/8/93 - denniscr
************************************************************************/BOOL GetEMFCoolStuff(){ //
//init these ptrs
//
EmfPtr.lpEMFHdr = NULL; EmfPtr.lpDescStr = NULL; EmfPtr.lpPal = NULL;
if (hemf) { //
//obtain the sizes of the emf header, description string and palette
//
UINT uiHdrSize = GetEnhMetaFileHeader(hemf, 0, NULL); UINT uiDescStrSize = GetEnhMetaFileDescription(hemf, 0, NULL); UINT uiPalEntries = GetEnhMetaFilePaletteEntries(hemf, 0, NULL); //
//if these are lengths > 0 then allocate memory to store them
//
if (uiHdrSize) EmfPtr.lpEMFHdr = (LPENHMETAHEADER)GlobalAllocPtr(GHND, uiHdrSize); if (uiDescStrSize) EmfPtr.lpDescStr = (LPTSTR)GlobalAllocPtr(GHND, uiDescStrSize); if (uiPalEntries) EmfPtr.lpPal = (LPPALETTEENTRY)GlobalAllocPtr(GHND, uiPalEntries * sizeof(PALETTEENTRY)); //
//so far the emf seems to be valid so continue
//
if (uiHdrSize) { //
//get the actual emf header and description string
//
if (!GetEnhMetaFileHeader(hemf, uiHdrSize, EmfPtr.lpEMFHdr)) { MessageBox(hWndMain, "unable to read enhanced metafile header", NULL, MB_OK | MB_ICONEXCLAMATION); bValidFile = FALSE; return (FALSE); } else { //
//get the description string if it exists
//
if (uiDescStrSize) GetEnhMetaFileDescription(hemf, uiDescStrSize, EmfPtr.lpDescStr); //
//get the palette if it exists
//
if (uiPalEntries) { GetEnhMetaFilePaletteEntries(hemf, uiPalEntries, EmfPtr.lpPal); EmfPtr.palNumEntries = (WORD)uiPalEntries; } } } } return (TRUE);}
float NormalizeAngle (double angle){ if (angle >= 0) { while (angle >= 360) { angle -= 360; } } else { while (angle < 0) { angle += 360; } } return static_cast<float>(angle);}
#define PI 3.1415926535897932384626433832795
#define RADIANS_TO_DEGREES (180.0 / PI)
float PointToAngle(float x, float y, float w, float h, float xVector, float yVector){ BOOL bScale = TRUE;
if (w == h) { if (w == 0) { return 0; } bScale = FALSE; }
float horRadius = w / 2; float verRadius = h / 2; float xOrigin = x + horRadius; float yOrigin = y + verRadius;
if (horRadius == 0) { double dAngle = asin(((double)(yVector - yOrigin)) / verRadius);
if (xOrigin > xVector) { dAngle = PI - dAngle; } return NormalizeAngle(dAngle * RADIANS_TO_DEGREES); } else if (verRadius == 0) { double dAngle = acos(((double)(xVector - xOrigin)) / horRadius);
if (yOrigin > yVector) { dAngle = -dAngle; } return NormalizeAngle(dAngle * RADIANS_TO_DEGREES); }
if (yOrigin == yVector) { return static_cast<float>((xOrigin <= xVector) ? 0 : 180); }
if (xOrigin == xVector) { return static_cast<float>((yOrigin < yVector) ? 90 : 270);; }
if (bScale) { xVector = (float)(xOrigin + ((xVector - xOrigin) * ((double)verRadius / horRadius))); }
return NormalizeAngle(atan2(yVector - yOrigin, xVector - xOrigin) * RADIANS_TO_DEGREES);}
#define HS_DDI_MAX 6
typedef struct { BITMAPINFOHEADER bmiHeader; RGBQUAD bmiColors[2];} HATCHBRUSHINFO;
HATCHBRUSHINFO hatchBrushInfo = { { sizeof(BITMAPINFOHEADER), 8, 8, 1, 1, BI_RGB, 32, 0, 0, 2, 0 }, { { 255, 255, 255, 0 }, { 0, 0, 0, 0 } }};
ULONG HatchPatterns[HS_DDI_MAX][8] = {
// Scans have to be DWORD aligned:
{ 0x00, // ........ HS_HORIZONTAL 0
0x00, // ........
0x00, // ........
0xff, // ********
0x00, // ........
0x00, // ........
0x00, // ........
0x00 }, // ........
{ 0x08, // ....*... HS_VERTICAL 1
0x08, // ....*...
0x08, // ....*...
0x08, // ....*...
0x08, // ....*...
0x08, // ....*...
0x08, // ....*...
0x08 }, // ....*...
{ 0x80, // *....... HS_FDIAGONAL 2
0x40, // .*......
0x20, // ..*.....
0x10, // ...*....
0x08, // ....*...
0x04, // .....*..
0x02, // ......*.
0x01 }, // .......*
{ 0x01, // .......* HS_BDIAGONAL 3
0x02, // ......*.
0x04, // .....*..
0x08, // ....*...
0x10, // ...*....
0x20, // ..*.....
0x40, // .*......
0x80 }, // *.......
{ 0x08, // ....*... HS_CROSS 4
0x08, // ....*...
0x08, // ....*...
0xff, // ********
0x08, // ....*...
0x08, // ....*...
0x08, // ....*...
0x08 }, // ....*...
{ 0x81, // *......* HS_DIAGCROSS 5
0x42, // .*....*.
0x24, // ..*..*..
0x18, // ...**...
0x18, // ...**...
0x24, // ..*..*..
0x42, // .*....*.
0x81 } // *......*
};
/***********************************************************************
FUNCTION : EnhMetaFileEnumProc
PARAMETERS : HDC hDC LPHANDLETABLE lpHTable LPMETARECORD lpMFR int nObj LPARAM lpData
PURPOSE : callback for EnumEnhMetaFile.
CALLS : EnumMFIndirect()
MESSAGES : none
RETURNS : int
COMMENTS :
HISTORY : created 6/30/93 - denniscr
************************************************************************/int CALLBACK EnhMetaFileEnumProc(HDC hDC, LPHANDLETABLE lpHTable, LPENHMETARECORD lpEMFR, int nObj, LPARAM lpData){ return EnumMFIndirect(hDC, lpHTable, NULL, lpEMFR, nObj, lpData);}
void GetPixelSize (Gdiplus::Graphics * g, float * cx, float * cy){ Gdiplus::PointF points[2];
points[0].X = points[0].Y = 0; points[1].X = points[1].Y = 1;
g->TransformPoints(Gdiplus::CoordinateSpaceWorld, Gdiplus::CoordinateSpaceDevice, points, 2);
*cx = points[1].X - points[0].X; *cy = points[1].Y - points[0].Y;}
void GpPlayEnhMetaFileRecord(HDC hDC, LPHANDLETABLE lpHTable, LPENHMETARECORD lpEMFR, UINT nObj, LPARAM lpData){if (!lpData) return;
MYDATA * myData = (MYDATA *)lpData; Gdiplus::Graphics * g = myData->g;
myData->recordNum++;
XFORM xForm; GetWorldTransform(hDC, &xForm);
INT mapMode = GetMapMode(hDC);
POINT org; SIZE size; GetViewportOrgEx(hDC, &org); GetViewportExtEx(hDC, &size); GetWindowOrgEx(hDC, &org); GetWindowExtEx(hDC, &size);
switch (lpEMFR->iType) { case EMR_HEADER: { PENHMETAHEADER pHeader = (PENHMETAHEADER)lpEMFR; RECT clientRect;
myData->recordNum = 1; myData->pObjects = new MYOBJECTS[pHeader->nHandles]; myData->numObjects = pHeader->nHandles; GetClientRect(myData->hwnd, &clientRect); int clientWidth = clientRect.right - clientRect.left; int clientHeight = clientRect.bottom - clientRect.top; myData->windowExtent.cx = clientWidth; myData->windowExtent.cy = clientHeight; myData->viewportExtent.cx = clientWidth; myData->viewportExtent.cy = clientHeight; float dstX = TOREAL(clientRect.left); float dstY = TOREAL(clientRect.top); float dstWidth = TOREAL(clientWidth); float dstHeight = TOREAL(clientHeight); float srcWidth = TOREAL(pHeader->rclFrame.right - pHeader->rclFrame.left); float srcHeight = TOREAL(pHeader->rclFrame.bottom - pHeader->rclFrame.top);
#if 0
if (srcHeight * dstWidth >= dstHeight * srcWidth) { float oldDstWidth = dstWidth; dstWidth = srcWidth * dstHeight / srcHeight; dstX += (oldDstWidth - dstWidth) / 2; } else { float oldDstHeight = dstHeight; dstHeight = srcHeight * dstWidth / srcWidth; dstY += (oldDstHeight - dstHeight) / 2; } #endif
g->SetPageUnit(Gdiplus::UnitPixel);
using Gdiplus::RectF; RectF dstRect(dstX, dstY, dstWidth, dstHeight);
int deviceLeft = pHeader->rclBounds.left; int deviceRight = pHeader->rclBounds.right; int deviceTop = pHeader->rclBounds.top; int deviceBottom = pHeader->rclBounds.bottom;
// if ((deviceLeft > deviceRight) ||
// (deviceTop > deviceBottom))
{ SIZEL deviceSize = pHeader->szlDevice; SIZEL mmSize = pHeader->szlMillimeters;
if ((deviceSize.cx <= 0) || (deviceSize.cy <= 0) || (mmSize.cx <= 0) || (mmSize.cy <= 0)) { ASSERT(0);
// Take a wild guess
deviceSize.cx = 1024; deviceSize.cy = 768; mmSize.cx = 320; mmSize.cy = 240; } deviceLeft = MulDiv(pHeader->rclFrame.left, deviceSize.cx, (mmSize.cx * 100)); deviceRight = MulDiv(pHeader->rclFrame.right, deviceSize.cx, (mmSize.cx * 100)); deviceTop = MulDiv(pHeader->rclFrame.top, deviceSize.cy, (mmSize.cy * 100)); deviceBottom = MulDiv(pHeader->rclFrame.bottom, deviceSize.cy, (mmSize.cy * 100)); }
RectF srcRect(TOREAL(deviceLeft), TOREAL(deviceTop), TOREAL(deviceRight - deviceLeft), TOREAL(deviceBottom - deviceTop)); myData->containerId = g->BeginContainer(dstRect, srcRect, Gdiplus::UnitPixel);
g->SetPageUnit(Gdiplus::UnitPixel); // Assume MM_TEXT
} break;
case EMR_POLYBEZIER: { PEMRPOLYBEZIER pBezier = (PEMRPOLYBEZIER)lpEMFR;
if (pBezier->cptl > 0) { int i = pBezier->cptl; Gdiplus::PointF * points = new Gdiplus::PointF[i];
do { i--; points[i].X = TOREAL(pBezier->aptl[i].x); points[i].Y = TOREAL(pBezier->aptl[i].y); } while (i > 0);
if (!myData->pathOpen) { if (myData->curPen != 0) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
g->DrawBeziers(&pen, points, pBezier->cptl); } } else { myData->path->AddBeziers(points, pBezier->cptl); }
delete [] points; } } break;
case EMR_POLYGON: { PEMRPOLYGON pPolygon = (PEMRPOLYGON)lpEMFR;
if (pPolygon->cptl > 0) { int i = pPolygon->cptl; Gdiplus::PointF * points = new Gdiplus::PointF[i];
do { i--; points[i].X = TOREAL(pPolygon->aptl[i].x); points[i].Y = TOREAL(pPolygon->aptl[i].y); } while (i > 0);
if (!myData->pathOpen) { Gdiplus::GraphicsPath path(myData->fillMode); path.AddPolygon(points, pPolygon->cptl);
if (myData->curBrush != 0) { if (myData->curPatIndex < 0) { if (myData->curBrushPattern == NULL) { Gdiplus::SolidBrush brush(Gdiplus::Color(myData->curBrush)); g->FillPath(&brush, &path); } else { BITMAPINFO * bmi = (BITMAPINFO *)myData->curBrushPattern->bmi; BYTE * bits = ((BYTE *)bmi) + myData->curBrushPattern->bitsOffset;
DibBrush brush(bmi, bits); g->FillPath(brush, &path); } } else { BITMAPINFO * bmi = (BITMAPINFO *)&hatchBrushInfo; BYTE * bits = (BYTE *)HatchPatterns[myData->curPatIndex];
bmi->bmiColors[1].rgbRed = (myData->curBrush & Gdiplus::Color::RedMask) >> Gdiplus::Color::RedShift; bmi->bmiColors[1].rgbGreen = (myData->curBrush & Gdiplus::Color::GreenMask) >> Gdiplus::Color::GreenShift; bmi->bmiColors[1].rgbBlue = (myData->curBrush & Gdiplus::Color::BlueMask) >> Gdiplus::Color::BlueShift;
DibBrush brush(bmi, bits); g->FillPath(brush, &path); } } if (myData->curPen != 0) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
g->DrawPath(&pen, &path); } } else { myData->path->AddPolygon(points, pPolygon->cptl); }
delete [] points; } } break;
case EMR_POLYLINE: { PEMRPOLYLINE pPolyline = (PEMRPOLYLINE)lpEMFR;
if (pPolyline->cptl > 0) { int i = pPolyline->cptl; Gdiplus::PointF * points = new Gdiplus::PointF[i];
do { i--; points[i].X = TOREAL(pPolyline->aptl[i].x); points[i].Y = TOREAL(pPolyline->aptl[i].y); } while (i > 0);
if (!myData->pathOpen) { if (myData->curPen != 0) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
g->DrawLines(&pen, points, pPolyline->cptl); } } else { myData->path->AddLines(points, pPolyline->cptl); }
delete [] points; } } break;
case EMR_POLYBEZIERTO: { PEMRPOLYBEZIERTO pBezier = (PEMRPOLYBEZIERTO)lpEMFR;
if (pBezier->cptl > 0) { int i = pBezier->cptl; Gdiplus::PointF * points = new Gdiplus::PointF[i+1];
do { points[i].X = TOREAL(pBezier->aptl[i-1].x); points[i].Y = TOREAL(pBezier->aptl[i-1].y); i--; } while (i > 0);
points[0] = myData->curPos; myData->curPos = points[pBezier->cptl];
if (!myData->pathOpen) { if (myData->curPen != 0) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
g->DrawBeziers(&pen, points, pBezier->cptl+1); } } else { myData->path->AddBeziers(points, pBezier->cptl+1); }
delete [] points; } } break;
case EMR_POLYLINETO: { PEMRPOLYLINETO pPolyline = (PEMRPOLYLINETO)lpEMFR;
if (pPolyline->cptl > 0) { int i = pPolyline->cptl; Gdiplus::PointF * points = new Gdiplus::PointF[i+1];
do { points[i].X = TOREAL(pPolyline->aptl[i-1].x); points[i].Y = TOREAL(pPolyline->aptl[i-1].y); i--; } while (i > 0);
points[0] = myData->curPos; myData->curPos = points[pPolyline->cptl];
if (!myData->pathOpen) { if (myData->curPen != 0) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
g->DrawLines(&pen, points, pPolyline->cptl+1); } } else { myData->path->AddLines(points, pPolyline->cptl+1); }
delete [] points; } } break;
case EMR_POLYPOLYLINE: { PEMRPOLYPOLYLINE pPolyline = (PEMRPOLYPOLYLINE)lpEMFR;
if ((pPolyline->cptl > 0) && (pPolyline->nPolys > 0)) { int i = pPolyline->cptl; Gdiplus::PointF * points = new Gdiplus::PointF[i]; POINTL * metaPoints = (POINTL *)(pPolyline->aPolyCounts + pPolyline->nPolys);
do { i--; points[i].X = TOREAL(metaPoints[i].x); points[i].Y = TOREAL(metaPoints[i].y); } while (i > 0);
if (!myData->pathOpen) { if (myData->curPen != 0) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
i = 0; Gdiplus::PointF * tmpPoints = points; DWORD count; do { count = pPolyline->aPolyCounts[i]; g->DrawLines(&pen, tmpPoints, count); tmpPoints += count; } while ((UINT)++i < pPolyline->nPolys); } } else { i = 0; Gdiplus::PointF * tmpPoints = points; DWORD count; do { count = pPolyline->aPolyCounts[i]; myData->path->AddLines(tmpPoints, count); tmpPoints += count; } while ((UINT)++i < pPolyline->nPolys); }
delete [] points; } } break;
case EMR_POLYPOLYGON: { PEMRPOLYPOLYGON pPolygon = (PEMRPOLYPOLYGON)lpEMFR;
if ((pPolygon->cptl > 0) && (pPolygon->nPolys > 0)) { int i = pPolygon->cptl; Gdiplus::PointF * points = new Gdiplus::PointF[i]; POINTL * metaPoints = (POINTL *)(pPolygon->aPolyCounts + pPolygon->nPolys);
do { i--; points[i].X = TOREAL(metaPoints[i].x); points[i].Y = TOREAL(metaPoints[i].y); } while (i > 0);
Gdiplus::GraphicsPath path(myData->fillMode); Gdiplus::GraphicsPath * tmpPath = &path;
if (myData->pathOpen) { tmpPath = myData->path; }
Gdiplus::PointF * tmpPoints = points; DWORD count; i = 0; do { count = pPolygon->aPolyCounts[i]; tmpPath->StartFigure(); tmpPath->AddPolygon(tmpPoints, count); tmpPoints += count; } while ((UINT)++i < pPolygon->nPolys);
if (myData->path == NULL) { if (myData->curBrush != 0) { if (myData->curPatIndex < 0) { if (myData->curBrushPattern == NULL) { Gdiplus::SolidBrush brush(Gdiplus::Color(myData->curBrush)); g->FillPath(&brush, &path); } else { BITMAPINFO * bmi = (BITMAPINFO *)myData->curBrushPattern->bmi; BYTE * bits = ((BYTE *)bmi) + myData->curBrushPattern->bitsOffset;
DibBrush brush(bmi, bits); g->FillPath(brush, &path); } } else { BITMAPINFO * bmi = (BITMAPINFO *)&hatchBrushInfo; BYTE * bits = (BYTE *)HatchPatterns[myData->curPatIndex];
bmi->bmiColors[1].rgbRed = (myData->curBrush & Gdiplus::Color::RedMask) >> Gdiplus::Color::RedShift; bmi->bmiColors[1].rgbGreen = (myData->curBrush & Gdiplus::Color::GreenMask) >> Gdiplus::Color::GreenShift; bmi->bmiColors[1].rgbBlue = (myData->curBrush & Gdiplus::Color::BlueMask) >> Gdiplus::Color::BlueShift;
DibBrush brush(bmi, bits); g->FillPath(brush, &path); } } if (myData->curPen != 0) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
g->DrawPath(&pen, &path); } }
delete [] points; } } break;
case EMR_SETWINDOWEXTEX: { PEMRSETWINDOWEXTEX pWindowExt = (PEMRSETWINDOWEXTEX)lpEMFR;
if (((myData->mapMode == MM_ANISOTROPIC) || (myData->mapMode == MM_ISOTROPIC)) && (pWindowExt->szlExtent.cx != 0) && // Note: Can be < 0!!!
(pWindowExt->szlExtent.cy != 0) && (pWindowExt->szlExtent.cx != myData->windowExtent.cx) && (pWindowExt->szlExtent.cy != myData->windowExtent.cy)) { myData->windowExtent = pWindowExt->szlExtent;
float oldDx = myData->dx; float oldDy = myData->dy; float oldSx = myData->scaleX; float oldSy = myData->scaleY;
float sX = (float)myData->viewportExtent.cx / myData->windowExtent.cx; float sY = (float)myData->viewportExtent.cy / myData->windowExtent.cy;
if (myData->mapMode == MM_ISOTROPIC) { if (sX < sY) { sY = sX; } else { sX = sY; } }
myData->scaleX = sX; myData->scaleY = sY; myData->dx = (myData->viewportOrg.x / sX) - myData->windowOrg.x; myData->dy = (myData->viewportOrg.y / sY) - myData->windowOrg.y;
Gdiplus::Matrix matrix;
matrix.Scale(sX, sY); matrix.Translate(myData->dx, myData->dy); matrix.Translate(-oldDx, -oldDy); matrix.Scale(1 / oldSx, 1 / oldSy);
g->MultiplyTransform(&matrix, Gdiplus::MatrixOrderAppend); } } break;
case EMR_SETWINDOWORGEX: { PEMRSETWINDOWORGEX pWindowOrg = (PEMRSETWINDOWORGEX)lpEMFR;
if ((pWindowOrg->ptlOrigin.x != myData->windowOrg.x) && (pWindowOrg->ptlOrigin.y != myData->windowOrg.y)) { myData->windowOrg = pWindowOrg->ptlOrigin;
float oldDx = myData->dx; float oldDy = myData->dy; float oldSx = myData->scaleX; float oldSy = myData->scaleY;
myData->dx = (myData->viewportOrg.x / oldSx) - myData->windowOrg.x; myData->dy = (myData->viewportOrg.y / oldSy) - myData->windowOrg.y;
Gdiplus::Matrix matrix;
matrix.Scale(oldSx, oldSy); matrix.Translate(myData->dx, myData->dy); matrix.Translate(-oldDx, -oldDy); matrix.Scale(1 / oldSx, 1 / oldSy);
g->MultiplyTransform(&matrix, Gdiplus::MatrixOrderAppend); } } break;
case EMR_SETVIEWPORTEXTEX: { PEMRSETVIEWPORTEXTEX pViewportExt = (PEMRSETVIEWPORTEXTEX)lpEMFR;
if (((myData->mapMode == MM_ANISOTROPIC) || (myData->mapMode == MM_ISOTROPIC)) && (pViewportExt->szlExtent.cx > 0) && (pViewportExt->szlExtent.cy > 0) && (pViewportExt->szlExtent.cx != myData->viewportExtent.cx) && (pViewportExt->szlExtent.cy != myData->viewportExtent.cy)) { myData->viewportExtent = pViewportExt->szlExtent;
float oldDx = myData->dx; float oldDy = myData->dy; float oldSx = myData->scaleX; float oldSy = myData->scaleY;
float sX = (float)myData->viewportExtent.cx / myData->windowExtent.cx; float sY = (float)myData->viewportExtent.cy / myData->windowExtent.cy;
if (myData->mapMode == MM_ISOTROPIC) { if (sX < sY) { sY = sX; } else { sX = sY; } }
myData->scaleX = sX; myData->scaleY = sY; myData->dx = (myData->viewportOrg.x / sX) - myData->windowOrg.x; myData->dy = (myData->viewportOrg.y / sY) - myData->windowOrg.y;
Gdiplus::Matrix matrix;
matrix.Scale(sX, sY); matrix.Translate(myData->dx, myData->dy); matrix.Translate(-oldDx, -oldDy); matrix.Scale(1 / oldSx, 1 / oldSy);
g->MultiplyTransform(&matrix, Gdiplus::MatrixOrderAppend); } } break;
case EMR_SETVIEWPORTORGEX: { PEMRSETVIEWPORTORGEX pViewportOrg = (PEMRSETVIEWPORTORGEX)lpEMFR;
if ((pViewportOrg->ptlOrigin.x != myData->viewportOrg.x) && (pViewportOrg->ptlOrigin.y != myData->viewportOrg.y)) { myData->viewportOrg = pViewportOrg->ptlOrigin;
float oldDx = myData->dx; float oldDy = myData->dy; float oldSx = myData->scaleX; float oldSy = myData->scaleY;
myData->dx = (myData->viewportOrg.x / oldSx) - myData->windowOrg.x; myData->dy = (myData->viewportOrg.y / oldSy) - myData->windowOrg.y;
Gdiplus::Matrix matrix;
matrix.Scale(oldSx, oldSy); matrix.Translate(myData->dx, myData->dy); matrix.Translate(-oldDx, -oldDy); matrix.Scale(1 / oldSx, 1 / oldSy);
g->MultiplyTransform(&matrix, Gdiplus::MatrixOrderAppend); } } break;
case EMR_SETBRUSHORGEX: break;
case EMR_EOF: g->EndContainer(myData->containerId); break;
case EMR_SETPIXELV: { PEMRSETPIXELV pSetPixel = (PEMRSETPIXELV)lpEMFR;
COLORREF cRef = pSetPixel->crColor;
ASSERT((cRef & 0x01000000) == 0);
Gdiplus::SolidBrush brush(Gdiplus::Color(Gdiplus::Color::MakeARGB(0xff, GetRValue(cRef), GetGValue(cRef), GetBValue(cRef)))); g->FillRectangle(&brush, TOREAL(pSetPixel->ptlPixel.x), TOREAL(pSetPixel->ptlPixel.y), TOREAL(1), TOREAL(1)); } break;
case EMR_SETMAPPERFLAGS: // for font mapping
break;
case EMR_SETMAPMODE: { PEMRSETMAPMODE pMapMode = (PEMRSETMAPMODE)lpEMFR; if (myData->mapMode != pMapMode->iMode) { float sX, sY;
myData->mapMode = pMapMode->iMode;
switch (pMapMode->iMode) { case MM_TEXT: g->SetPageUnit(Gdiplus::UnitPixel); sX = sY = 1; break; case MM_LOMETRIC: g->SetPageUnit(Gdiplus::UnitMillimeter); g->SetPageScale(TOREAL(.1)); sX = sY = 1; break; case MM_HIMETRIC: g->SetPageUnit(Gdiplus::UnitMillimeter); g->SetPageScale(TOREAL(.01)); sX = sY = 1; break; case MM_LOENGLISH: g->SetPageUnit(Gdiplus::UnitInch); g->SetPageScale(TOREAL(.01)); sX = sY = 1; break; case MM_HIENGLISH: g->SetPageUnit(Gdiplus::UnitInch); g->SetPageScale(TOREAL(.001)); sX = sY = 1; break; case MM_TWIPS: g->SetPageUnit(Gdiplus::UnitPoint); g->SetPageScale(TOREAL(.05)); sX = sY = 1; break; case MM_ISOTROPIC: g->SetPageUnit(Gdiplus::UnitPixel); sX = (float)myData->viewportExtent.cx / myData->windowExtent.cx; sY = (float)myData->viewportExtent.cy / myData->windowExtent.cy; if (sX < sY) { sY = sX; } else { sX = sY; } break; case MM_ANISOTROPIC: g->SetPageUnit(Gdiplus::UnitPixel); sX = (float)myData->viewportExtent.cx / myData->windowExtent.cx; sY = (float)myData->viewportExtent.cy / myData->windowExtent.cy; break; }
float oldDx = myData->dx; float oldDy = myData->dy; float oldSx = myData->scaleX; float oldSy = myData->scaleY;
myData->scaleX = sX; myData->scaleY = sY; myData->dx = (myData->viewportOrg.x / sX) - myData->windowOrg.x; myData->dy = (myData->viewportOrg.y / sY) - myData->windowOrg.y;
Gdiplus::Matrix matrix;
matrix.Scale(sX, sY); matrix.Translate(myData->dx, myData->dy); matrix.Translate(-oldDx, -oldDy); matrix.Scale(1 / oldSx, 1 / oldSy);
g->MultiplyTransform(&matrix, Gdiplus::MatrixOrderAppend); } } break;
case EMR_SETBKMODE: break;
case EMR_SETPOLYFILLMODE: { PEMRSETPOLYFILLMODE pPolyfillMode = (PEMRSETPOLYFILLMODE)lpEMFR;
myData->fillMode = (pPolyfillMode->iMode == ALTERNATE) ? Gdiplus::FillModeAlternate : Gdiplus::FillModeWinding; } break;
case EMR_SETROP2: break;
case EMR_SETSTRETCHBLTMODE:#ifdef _DEBUG
{ PEMRSETSTRETCHBLTMODE pStretchBltMode = (PEMRSETSTRETCHBLTMODE)lpEMFR;
int mode;
switch (pStretchBltMode->iMode) { case BLACKONWHITE: mode = 1; break; case WHITEONBLACK: mode = 2; break; case COLORONCOLOR: mode = 3; break; case HALFTONE: mode = 4; break; } }#endif
break;
case EMR_SETTEXTALIGN: break;
case EMR_SETCOLORADJUSTMENT: break;
case EMR_SETTEXTCOLOR: break;
case EMR_SETBKCOLOR: break;
case EMR_OFFSETCLIPRGN: { PEMROFFSETCLIPRGN pOffsetClipRgn = (PEMROFFSETCLIPRGN)lpEMFR;
g->TranslateClip(TOREAL(pOffsetClipRgn->ptlOffset.x), TOREAL(pOffsetClipRgn->ptlOffset.y)); } break;
case EMR_MOVETOEX: { PEMRMOVETOEX pMoveTo = (PEMRMOVETOEX)lpEMFR;
myData->curPos.X = TOREAL(pMoveTo->ptl.x); myData->curPos.Y = TOREAL(pMoveTo->ptl.y); } break;
case EMR_SETMETARGN: break;
case EMR_EXCLUDECLIPRECT: { PEMREXCLUDECLIPRECT pExcludeClipRect = (PEMREXCLUDECLIPRECT)lpEMFR;
Gdiplus::RectF clipRect(TOREAL(pExcludeClipRect->rclClip.left), TOREAL(pExcludeClipRect->rclClip.top), TOREAL(pExcludeClipRect->rclClip.right - pExcludeClipRect->rclClip.left), TOREAL(pExcludeClipRect->rclClip.bottom - pExcludeClipRect->rclClip.top)); g->ExcludeClip(clipRect); } break;
case EMR_INTERSECTCLIPRECT: { PEMRINTERSECTCLIPRECT pIntersectClipRect = (PEMRINTERSECTCLIPRECT)lpEMFR;
Gdiplus::RectF eRect;
eRect.X = TOREAL(pIntersectClipRect->rclClip.left); eRect.Y = TOREAL(pIntersectClipRect->rclClip.top); eRect.Width = TOREAL(pIntersectClipRect->rclClip.right - pIntersectClipRect->rclClip.left); eRect.Height = TOREAL(pIntersectClipRect->rclClip.bottom - pIntersectClipRect->rclClip.top);
g->IntersectClip(eRect); } break;
case EMR_SCALEVIEWPORTEXTEX: { PEMRSCALEVIEWPORTEXTEX pViewportExt = (PEMRSCALEVIEWPORTEXTEX)lpEMFR;
if (((myData->mapMode == MM_ANISOTROPIC) || (myData->mapMode == MM_ISOTROPIC)) && (pViewportExt->xNum != 0) && (pViewportExt->yNum != 0) && (pViewportExt->xDenom != 0) && (pViewportExt->yDenom != 0)) { myData->viewportExtent.cx = (myData->viewportExtent.cx * pViewportExt->xNum) / pViewportExt->xDenom; myData->viewportExtent.cy = (myData->viewportExtent.cy * pViewportExt->yNum) / pViewportExt->yDenom;
float oldDx = myData->dx; float oldDy = myData->dy; float oldSx = myData->scaleX; float oldSy = myData->scaleY;
float sX = (float)myData->viewportExtent.cx / myData->windowExtent.cx; float sY = (float)myData->viewportExtent.cy / myData->windowExtent.cy;
if (myData->mapMode == MM_ISOTROPIC) { if (sX < sY) { sY = sX; } else { sX = sY; } }
myData->scaleX = sX; myData->scaleY = sY; myData->dx = (myData->viewportOrg.x / sX) - myData->windowOrg.x; myData->dy = (myData->viewportOrg.y / sY) - myData->windowOrg.y;
Gdiplus::Matrix matrix;
matrix.Scale(sX, sY); matrix.Translate(myData->dx, myData->dy); matrix.Translate(-oldDx, -oldDy); matrix.Scale(1 / oldSx, 1 / oldSy);
g->MultiplyTransform(&matrix, Gdiplus::MatrixOrderAppend); } } break;
case EMR_SCALEWINDOWEXTEX: { PEMRSCALEWINDOWEXTEX pWindowExt = (PEMRSCALEWINDOWEXTEX)lpEMFR;
if (((myData->mapMode == MM_ANISOTROPIC) || (myData->mapMode == MM_ISOTROPIC)) && (pWindowExt->xNum != 0) && (pWindowExt->yNum != 0) && (pWindowExt->xDenom != 0) && (pWindowExt->yDenom != 0)) { myData->windowExtent.cx = (myData->windowExtent.cx * pWindowExt->xNum) / pWindowExt->xDenom; myData->windowExtent.cy = (myData->windowExtent.cy * pWindowExt->yNum) / pWindowExt->yDenom;
float oldDx = myData->dx; float oldDy = myData->dy; float oldSx = myData->scaleX; float oldSy = myData->scaleY;
float sX = (float)myData->viewportExtent.cx / myData->windowExtent.cx; float sY = (float)myData->viewportExtent.cy / myData->windowExtent.cy;
if (myData->mapMode == MM_ISOTROPIC) { if (sX < sY) { sY = sX; } else { sX = sY; } }
myData->scaleX = sX; myData->scaleY = sY; myData->dx = (myData->viewportOrg.x / sX) - myData->windowOrg.x; myData->dy = (myData->viewportOrg.y / sY) - myData->windowOrg.y;
Gdiplus::Matrix matrix;
matrix.Scale(sX, sY); matrix.Translate(myData->dx, myData->dy); matrix.Translate(-oldDx, -oldDy); matrix.Scale(1 / oldSx, 1 / oldSy);
g->MultiplyTransform(&matrix, Gdiplus::MatrixOrderAppend); } } break;
case EMR_SAVEDC: { myData->PushId(g->Save()); } break;
case EMR_RESTOREDC: { g->Restore(myData->PopId()); } break;
case EMR_SETWORLDTRANSFORM: { PEMRSETWORLDTRANSFORM pXform = (PEMRSETWORLDTRANSFORM)lpEMFR;
Gdiplus::Matrix newMatrix(pXform->xform.eM11, pXform->xform.eM12, pXform->xform.eM21, pXform->xform.eM22, pXform->xform.eDx, pXform->xform.eDy);
if (newMatrix.IsInvertible()) { myData->matrix.Invert(); myData->matrix.Multiply(&newMatrix); g->MultiplyTransform(&(myData->matrix)); myData->matrix.SetElements(pXform->xform.eM11, pXform->xform.eM12, pXform->xform.eM21, pXform->xform.eM22, pXform->xform.eDx, pXform->xform.eDy); } } break;
case EMR_MODIFYWORLDTRANSFORM: { PEMRMODIFYWORLDTRANSFORM pXform = (PEMRMODIFYWORLDTRANSFORM)lpEMFR;
switch (pXform->iMode) { case MWT_IDENTITY: default: { myData->matrix.Invert(); g->MultiplyTransform(&(myData->matrix)); myData->matrix.Reset(); } break;
case MWT_LEFTMULTIPLY: { Gdiplus::Matrix newMatrix(pXform->xform.eM11, pXform->xform.eM12, pXform->xform.eM21, pXform->xform.eM22, pXform->xform.eDx, pXform->xform.eDy);
if (newMatrix.IsInvertible()) { myData->matrix.Multiply(&newMatrix); g->MultiplyTransform(&newMatrix); } } break;
case MWT_RIGHTMULTIPLY: { Gdiplus::Matrix newMatrix(pXform->xform.eM11, pXform->xform.eM12, pXform->xform.eM21, pXform->xform.eM22, pXform->xform.eDx, pXform->xform.eDy);
if (newMatrix.IsInvertible()) { Gdiplus::Matrix * inverse = myData->matrix.Clone(); inverse->Invert();
myData->matrix.Multiply(&newMatrix, Gdiplus::MatrixOrderAppend); inverse->Multiply(&(myData->matrix)); g->MultiplyTransform(inverse); delete inverse; } } break; } } break;
case EMR_SELECTOBJECT: { PEMRSELECTOBJECT pObject = (PEMRSELECTOBJECT)lpEMFR;
int objectIndex = pObject->ihObject;
if ((objectIndex & ENHMETA_STOCK_OBJECT) != 0) { switch (objectIndex & (~ENHMETA_STOCK_OBJECT)) { case WHITE_BRUSH: myData->curBrush = 0xFFFFFFFF; break; case LTGRAY_BRUSH: myData->curBrush = 0xFFC0C0C0; break; case GRAY_BRUSH: myData->curBrush = 0xFF808080; break; case DKGRAY_BRUSH: myData->curBrush = 0xFF404040; break; case BLACK_BRUSH: myData->curBrush = 0xFF000000; break; case NULL_BRUSH: myData->curBrush = 0x00000000; break; case WHITE_PEN: myData->curPen = 0xFFFFFFFF; break; case BLACK_PEN: myData->curPen = 0xFF000000; break; case NULL_PEN: myData->curPen = 0x00000000; break; } } else { ASSERT(objectIndex < myData->numObjects); if (myData->pObjects[objectIndex].type == MYOBJECTS::PenObjectType) { myData->curPen = myData->pObjects[objectIndex].color; myData->curPenWidth = myData->pObjects[objectIndex].penWidth; } else if (myData->pObjects[objectIndex].type == MYOBJECTS::BrushObjectType) { myData->curBrush = myData->pObjects[objectIndex].color; myData->curBrushPattern = myData->pObjects[objectIndex].brushPattern;#if 1
myData->curPatIndex = myData->pObjects[objectIndex].patIndex;
#else
static dodo = 0;myData->curPatIndex = dodo++ % 6;#endif
} } } break;
case EMR_CREATEPEN: { PEMRCREATEPEN pPen = (PEMRCREATEPEN)lpEMFR; COLORREF cRef = pPen->lopn.lopnColor;
ASSERT((cRef & 0x01000000) == 0);
ASSERT(pPen->ihPen < myData->numObjects);
delete myData->pObjects[pPen->ihPen].brushPattern; myData->pObjects[pPen->ihPen].brushPattern = NULL;
myData->pObjects[pPen->ihPen].type = MYOBJECTS::PenObjectType;
myData->pObjects[pPen->ihPen].color = Gdiplus::Color::MakeARGB(0xff, GetRValue(cRef), GetGValue(cRef), GetBValue(cRef));
myData->pObjects[pPen->ihPen].penWidth = pPen->lopn.lopnWidth.x; } break;
case EMR_CREATEBRUSHINDIRECT: { PEMRCREATEBRUSHINDIRECT pBrush = (PEMRCREATEBRUSHINDIRECT)lpEMFR; COLORREF cRef = pBrush->lb.lbColor;
ASSERT((cRef & 0x01000000) == 0);
ASSERT(pBrush->ihBrush < myData->numObjects);
myData->pObjects[pBrush->ihBrush].type = MYOBJECTS::BrushObjectType; myData->pObjects[pBrush->ihBrush].patIndex = -1; delete myData->pObjects[pBrush->ihBrush].brushPattern; myData->pObjects[pBrush->ihBrush].brushPattern = NULL; if (pBrush->lb.lbStyle == BS_NULL) { myData->pObjects[pBrush->ihBrush].color = 0x00000000; } else { // Hatch Styles
if (pBrush->lb.lbStyle == BS_HATCHED) { switch (pBrush->lb.lbHatch) { case HS_HORIZONTAL: /* ----- */ case HS_VERTICAL: /* ||||| */ case HS_FDIAGONAL: /* \\\\\ */ case HS_BDIAGONAL: /* ///// */ case HS_CROSS: /* +++++ */ case HS_DIAGCROSS: /* xxxxx */ myData->pObjects[pBrush->ihBrush].patIndex = pBrush->lb.lbHatch; break; } } myData->pObjects[pBrush->ihBrush].color = Gdiplus::Color::MakeARGB(0xff, GetRValue(cRef), GetGValue(cRef), GetBValue(cRef)); } } break;
case EMR_DELETEOBJECT: {#if 0
PEMRDELETEOBJECT pObject = (PEMRDELETEOBJECT)lpEMFR;
int objectIndex = pObject->ihObject;
ASSERT(objectIndex < myData->numObjects);
if (myData->pObjects[objectIndex].type == MYOBJECTS::BrushObjectType) { if (myData->curBrushPattern != myData->pObjects[objectIndex].brushPattern) { delete myData->pObjects[objectIndex].brushPattern; myData->pObjects[objectIndex].brushPattern = NULL; } }#endif
} break;
case EMR_ANGLEARC: break;
case EMR_ELLIPSE: { PEMRELLIPSE pEllipse = (PEMRELLIPSE)lpEMFR;
float x = TOREAL(pEllipse->rclBox.left); float y = TOREAL(pEllipse->rclBox.top); float w = TOREAL(pEllipse->rclBox.right - x); float h = TOREAL(pEllipse->rclBox.bottom - y);
if (!myData->pathOpen) { Gdiplus::GraphicsPath path(myData->fillMode);
path.AddEllipse(x, y, w, h);
if (myData->curBrush != 0) { if (myData->curPatIndex < 0) { if (myData->curBrushPattern == NULL) { Gdiplus::SolidBrush brush(Gdiplus::Color(myData->curBrush)); g->FillPath(&brush, &path); } else { BITMAPINFO * bmi = (BITMAPINFO *)myData->curBrushPattern->bmi; BYTE * bits = ((BYTE *)bmi) + myData->curBrushPattern->bitsOffset;
DibBrush brush(bmi, bits); g->FillPath(brush, &path); } } else { BITMAPINFO * bmi = (BITMAPINFO *)&hatchBrushInfo; BYTE * bits = (BYTE *)HatchPatterns[myData->curPatIndex];
bmi->bmiColors[1].rgbRed = (myData->curBrush & Gdiplus::Color::RedMask) >> Gdiplus::Color::RedShift; bmi->bmiColors[1].rgbGreen = (myData->curBrush & Gdiplus::Color::GreenMask) >> Gdiplus::Color::GreenShift; bmi->bmiColors[1].rgbBlue = (myData->curBrush & Gdiplus::Color::BlueMask) >> Gdiplus::Color::BlueShift;
DibBrush brush(bmi, bits); g->FillPath(brush, &path); } } if (myData->curPen != 0) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
g->DrawPath(&pen, &path); } } else { myData->path->AddEllipse(x, y, w, h); } } break;
case EMR_RECTANGLE: { PEMRRECTANGLE pRect = (PEMRRECTANGLE)lpEMFR;
float x = TOREAL(pRect->rclBox.left); float y = TOREAL(pRect->rclBox.top); float w = TOREAL(pRect->rclBox.right - x); float h = TOREAL(pRect->rclBox.bottom - y);
if (!myData->pathOpen) { if (myData->curBrush != 0) { if (myData->curPatIndex < 0) { if (myData->curBrushPattern == NULL) { Gdiplus::SolidBrush brush(Gdiplus::Color(myData->curBrush)); g->FillRectangle(&brush, x, y, w, h); } else { BITMAPINFO * bmi = (BITMAPINFO *)myData->curBrushPattern->bmi; BYTE * bits = ((BYTE *)bmi) + myData->curBrushPattern->bitsOffset;
DibBrush brush(bmi, bits); g->FillRectangle(brush, x, y, w, h); } } else { BITMAPINFO * bmi = (BITMAPINFO *)&hatchBrushInfo; BYTE * bits = (BYTE *)HatchPatterns[myData->curPatIndex];
bmi->bmiColors[1].rgbRed = (myData->curBrush & Gdiplus::Color::RedMask) >> Gdiplus::Color::RedShift; bmi->bmiColors[1].rgbGreen = (myData->curBrush & Gdiplus::Color::GreenMask) >> Gdiplus::Color::GreenShift; bmi->bmiColors[1].rgbBlue = (myData->curBrush & Gdiplus::Color::BlueMask) >> Gdiplus::Color::BlueShift;
DibBrush brush(bmi, bits); g->FillRectangle(brush, x, y, w, h); } } if (myData->curPen != 0) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
g->DrawRectangle(&pen, x, y, w, h); } } else { myData->path->AddRectangle(Gdiplus::RectF(x, y, w, h)); } } break;
case EMR_ROUNDRECT: // for now, ignore the szlCorner param of round corners
{ PEMRROUNDRECT pRect = (PEMRROUNDRECT)lpEMFR;
float x = TOREAL(pRect->rclBox.left); float y = TOREAL(pRect->rclBox.top); float w = TOREAL(pRect->rclBox.right - x); float h = TOREAL(pRect->rclBox.bottom - y);
if (!myData->pathOpen) { if (myData->curBrush != 0) { if (myData->curPatIndex < 0) { if (myData->curBrushPattern == NULL) { Gdiplus::SolidBrush brush(Gdiplus::Color(myData->curBrush)); g->FillRectangle(&brush, x, y, w, h); } else { BITMAPINFO * bmi = (BITMAPINFO *)myData->curBrushPattern->bmi; BYTE * bits = ((BYTE *)bmi) + myData->curBrushPattern->bitsOffset;
DibBrush brush(bmi, bits); g->FillRectangle(brush, x, y, w, h); } } else { BITMAPINFO * bmi = (BITMAPINFO *)&hatchBrushInfo; BYTE * bits = (BYTE *)HatchPatterns[myData->curPatIndex];
bmi->bmiColors[1].rgbRed = (myData->curBrush & Gdiplus::Color::RedMask) >> Gdiplus::Color::RedShift; bmi->bmiColors[1].rgbGreen = (myData->curBrush & Gdiplus::Color::GreenMask) >> Gdiplus::Color::GreenShift; bmi->bmiColors[1].rgbBlue = (myData->curBrush & Gdiplus::Color::BlueMask) >> Gdiplus::Color::BlueShift;
DibBrush brush(bmi, bits); g->FillRectangle(brush, x, y, w, h); } } if (myData->curPen != 0) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
g->DrawRectangle(&pen, x, y, w, h); } } else { myData->path->AddRectangle(Gdiplus::RectF(x, y, w, h)); } } break;
case EMR_ARC: { PEMRARC pArc = (PEMRARC)lpEMFR;
float x = TOREAL(pArc->rclBox.left); float y = TOREAL(pArc->rclBox.top); float w = TOREAL(pArc->rclBox.right - x); float h = TOREAL(pArc->rclBox.bottom - y); float startAngle = PointToAngle(x, y, w, h, TOREAL(pArc->ptlStart.x), TOREAL(pArc->ptlStart.y)); float endAngle = PointToAngle(x, y, w, h, TOREAL(pArc->ptlEnd.x), TOREAL(pArc->ptlEnd.y)); if (endAngle <= startAngle) { endAngle += 360; } float sweepAngle = endAngle - startAngle; if ((myData->arcDirection != AD_COUNTERCLOCKWISE) && (sweepAngle < 360)) { sweepAngle = 360 - sweepAngle; }
if (!myData->pathOpen) { if (myData->curPen != 0) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
g->DrawArc(&pen, x, y, w, h, startAngle, sweepAngle); } } else { myData->path->AddArc(x, y, w, h, startAngle, sweepAngle); } } break;
case EMR_CHORD: break;
case EMR_PIE: { PEMRARC pPie = (PEMRARC)lpEMFR;
float x = TOREAL(pPie->rclBox.left); float y = TOREAL(pPie->rclBox.top); float w = TOREAL(pPie->rclBox.right - x); float h = TOREAL(pPie->rclBox.bottom - y); float startAngle = PointToAngle(x, y, w, h, TOREAL(pPie->ptlStart.x), TOREAL(pPie->ptlStart.y)); float endAngle = PointToAngle(x, y, w, h, TOREAL(pPie->ptlEnd.x), TOREAL(pPie->ptlEnd.y)); if (endAngle <= startAngle) { endAngle += 360; } float sweepAngle = endAngle - startAngle; if ((myData->arcDirection != AD_COUNTERCLOCKWISE) && (sweepAngle < 360)) { sweepAngle = 360 - sweepAngle; } if (!myData->pathOpen) { Gdiplus::GraphicsPath path(myData->fillMode); path.AddPie(x, y, w, h, startAngle, sweepAngle);
if (myData->curBrush != 0) { if (myData->curPatIndex < 0) { if (myData->curBrushPattern == NULL) { Gdiplus::SolidBrush brush(Gdiplus::Color(myData->curBrush)); g->FillPath(&brush, &path); } else { BITMAPINFO * bmi = (BITMAPINFO *)myData->curBrushPattern->bmi; BYTE * bits = ((BYTE *)bmi) + myData->curBrushPattern->bitsOffset;
DibBrush brush(bmi, bits); g->FillPath(brush, &path); } } else { BITMAPINFO * bmi = (BITMAPINFO *)&hatchBrushInfo; BYTE * bits = (BYTE *)HatchPatterns[myData->curPatIndex];
bmi->bmiColors[1].rgbRed = (myData->curBrush & Gdiplus::Color::RedMask) >> Gdiplus::Color::RedShift; bmi->bmiColors[1].rgbGreen = (myData->curBrush & Gdiplus::Color::GreenMask) >> Gdiplus::Color::GreenShift; bmi->bmiColors[1].rgbBlue = (myData->curBrush & Gdiplus::Color::BlueMask) >> Gdiplus::Color::BlueShift;
DibBrush brush(bmi, bits); g->FillPath(brush, &path); } } if (myData->curPen != 0) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
g->DrawPath(&pen, &path); } } else { myData->path->AddPie(x, y, w, h, startAngle, sweepAngle); } } break;
case EMR_SELECTPALETTE: break;
case EMR_CREATEPALETTE: break;
case EMR_SETPALETTEENTRIES: break;
case EMR_RESIZEPALETTE: break;
case EMR_REALIZEPALETTE: break;
case EMR_EXTFLOODFILL: break;
case EMR_LINETO: { PEMRMOVETOEX pLineTo = (PEMRMOVETOEX)lpEMFR;
float x = TOREAL(pLineTo->ptl.x); float y = TOREAL(pLineTo->ptl.y);
if (!myData->pathOpen) { if (myData->curPen != 0) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
g->DrawLine(&pen, (float)myData->curPos.X, (float)myData->curPos.Y, x, y); } } else { myData->path->AddLine((float)myData->curPos.X, (float)myData->curPos.Y, x, y); }
myData->curPos.X = x; myData->curPos.Y = y; } break;
case EMR_ARCTO: { // !!! Set and use current position
PEMRARCTO pArc = (PEMRARCTO)lpEMFR;
float x = TOREAL(pArc->rclBox.left); float y = TOREAL(pArc->rclBox.top); float w = TOREAL(pArc->rclBox.right - x); float h = TOREAL(pArc->rclBox.bottom - y); float startAngle = PointToAngle(x, y, w, h, TOREAL(pArc->ptlStart.x), TOREAL(pArc->ptlStart.y)); float endAngle = PointToAngle(x, y, w, h, TOREAL(pArc->ptlEnd.x), TOREAL(pArc->ptlEnd.y)); if (endAngle <= startAngle) { endAngle += 360; } float sweepAngle = endAngle - startAngle; if ((myData->arcDirection != AD_COUNTERCLOCKWISE) && (sweepAngle < 360)) { sweepAngle = 360 - sweepAngle; }
if (!myData->pathOpen) { if (myData->curPen != 0) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
g->DrawArc(&pen, x, y, w, h, startAngle, sweepAngle); } } else { myData->path->AddArc(x, y, w, h, startAngle, sweepAngle); } } break;
case EMR_POLYDRAW: break;
case EMR_SETARCDIRECTION: { PEMRSETARCDIRECTION pArcDirection = (PEMRSETARCDIRECTION)lpEMFR;
myData->arcDirection = pArcDirection->iArcDirection; } break;
case EMR_SETMITERLIMIT: { PEMRSETMITERLIMIT pMiterLimit = (PEMRSETMITERLIMIT)lpEMFR;
myData->miterLimit = pMiterLimit->eMiterLimit; } break;
case EMR_BEGINPATH: { delete myData->path;
myData->path = new Gdiplus::GraphicsPath (myData->fillMode); myData->pathOpen = (myData->path != NULL); } break;
case EMR_ENDPATH: myData->pathOpen = FALSE; break;
case EMR_CLOSEFIGURE: { if (myData->pathOpen) { myData->path->CloseFigure(); } } break;
case EMR_FILLPATH: { if (myData->path != NULL) { if (myData->curBrush != 0) { if (myData->curPatIndex < 0) { if (myData->curBrushPattern == NULL) { Gdiplus::SolidBrush brush(Gdiplus::Color(myData->curBrush)); g->FillPath(&brush, myData->path); } else { BITMAPINFO * bmi = (BITMAPINFO *)myData->curBrushPattern->bmi; BYTE * bits = ((BYTE *)bmi) + myData->curBrushPattern->bitsOffset;
DibBrush brush(bmi, bits); g->FillPath(brush, myData->path); } } else { BITMAPINFO * bmi = (BITMAPINFO *)&hatchBrushInfo; BYTE * bits = (BYTE *)HatchPatterns[myData->curPatIndex];
bmi->bmiColors[1].rgbRed = (myData->curBrush & Gdiplus::Color::RedMask) >> Gdiplus::Color::RedShift; bmi->bmiColors[1].rgbGreen = (myData->curBrush & Gdiplus::Color::GreenMask) >> Gdiplus::Color::GreenShift; bmi->bmiColors[1].rgbBlue = (myData->curBrush & Gdiplus::Color::BlueMask) >> Gdiplus::Color::BlueShift;
DibBrush brush(bmi, bits); g->FillPath(brush, myData->path); } } delete myData->path; myData->path = NULL; myData->pathOpen = FALSE; } } break;
case EMR_STROKEANDFILLPATH: { if (myData->path != NULL) { if (myData->curBrush != 0) { if (myData->curPatIndex < 0) { if (myData->curBrushPattern == NULL) { Gdiplus::SolidBrush brush(Gdiplus::Color(myData->curBrush)); g->FillPath(&brush, myData->path); } else { BITMAPINFO * bmi = (BITMAPINFO *)myData->curBrushPattern->bmi; BYTE * bits = ((BYTE *)bmi) + myData->curBrushPattern->bitsOffset;
DibBrush brush(bmi, bits); g->FillPath(brush, myData->path); } } else { BITMAPINFO * bmi = (BITMAPINFO *)&hatchBrushInfo; BYTE * bits = (BYTE *)HatchPatterns[myData->curPatIndex];
bmi->bmiColors[1].rgbRed = (myData->curBrush & Gdiplus::Color::RedMask) >> Gdiplus::Color::RedShift; bmi->bmiColors[1].rgbGreen = (myData->curBrush & Gdiplus::Color::GreenMask) >> Gdiplus::Color::GreenShift; bmi->bmiColors[1].rgbBlue = (myData->curBrush & Gdiplus::Color::BlueMask) >> Gdiplus::Color::BlueShift;
DibBrush brush(bmi, bits); g->FillPath(brush, myData->path); } } if (myData->curPen != 0) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
g->DrawPath(&pen, myData->path); } delete myData->path; myData->path = NULL; myData->pathOpen = FALSE; } } break;
case EMR_STROKEPATH: { if (myData->path != NULL) { if (myData->curPen != 0) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
g->DrawPath(&pen, myData->path); } delete myData->path; myData->path = NULL; myData->pathOpen = FALSE; } } break;
case EMR_FLATTENPATH: { if (myData->path != NULL) { myData->path->Flatten(NULL); } } break;
case EMR_WIDENPATH: { if (myData->path != NULL) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
myData->path->Widen(&pen); } } break;
case EMR_SELECTCLIPPATH: { if (myData->path != NULL) { PEMRSELECTCLIPPATH pSetClipPath = (PEMRSELECTCLIPPATH)lpEMFR;
switch (pSetClipPath->iMode) { case RGN_COPY: default: g->SetClip(myData->path); break; case RGN_AND: { Gdiplus::Region region(myData->path); g->IntersectClip(®ion); } break; case RGN_DIFF: { Gdiplus::Region region(myData->path); Gdiplus::Region curClip; g->GetClip(&curClip); curClip.Exclude(®ion); g->SetClip(&curClip); } break; case RGN_OR: { Gdiplus::Region region(myData->path); Gdiplus::Region curClip; g->GetClip(&curClip); curClip.Union(®ion); g->SetClip(&curClip); } break; case RGN_XOR: { Gdiplus::Region region(myData->path); Gdiplus::Region curClip; g->GetClip(&curClip); curClip.Xor(®ion); g->SetClip(&curClip); } break; } delete myData->path; myData->path = NULL; myData->pathOpen = FALSE; } } break;
case EMR_ABORTPATH: { if (myData->path != NULL) { delete myData->path; myData->path = NULL; myData->pathOpen = FALSE; } } break;
case EMR_GDICOMMENT: break;
case EMR_FILLRGN: break;
case EMR_FRAMERGN: break;
case EMR_INVERTRGN: break;
case EMR_PAINTRGN: break;
case EMR_EXTSELECTCLIPRGN: break;
case EMR_BITBLT: { PEMRBITBLT pBitBlt = (PEMRBITBLT)lpEMFR;
switch (pBitBlt->dwRop) { case BLACKNESS: { Gdiplus::SolidBrush brush(Gdiplus::Color(0xff000000)); float cx, cy; GetPixelSize (g, &cx, &cy); g->FillRectangle(&brush, TOREAL(pBitBlt->xDest), TOREAL(pBitBlt->yDest), TOREAL(pBitBlt->cxDest + cx), TOREAL(pBitBlt->cyDest + cy)); } return; case WHITENESS: { Gdiplus::SolidBrush brush(Gdiplus::Color(0xffffffff)); float cx, cy; GetPixelSize (g, &cx, &cy); g->FillRectangle(&brush, TOREAL(pBitBlt->xDest), TOREAL(pBitBlt->yDest), TOREAL(pBitBlt->cxDest + 1), TOREAL(pBitBlt->cyDest + 1)); } return; default: if (!ISSOURCEINROP3(pBitBlt->dwRop)) { if (myData->curBrush != 0) { if (myData->curPatIndex < 0) { if (myData->curBrushPattern == NULL) { Gdiplus::SolidBrush brush(Gdiplus::Color(myData->curBrush)); float cx, cy; GetPixelSize (g, &cx, &cy); g->FillRectangle(&brush, TOREAL(pBitBlt->xDest), TOREAL(pBitBlt->yDest), TOREAL(pBitBlt->cxDest + cx), TOREAL(pBitBlt->cyDest + cy)); } else { BITMAPINFO * bmi = (BITMAPINFO *)myData->curBrushPattern->bmi; BYTE * bits = ((BYTE *)bmi) + myData->curBrushPattern->bitsOffset;
DibBrush brush(bmi, bits); float cx, cy; GetPixelSize (g, &cx, &cy); g->FillRectangle(brush, TOREAL(pBitBlt->xDest), TOREAL(pBitBlt->yDest), TOREAL(pBitBlt->cxDest + cx), TOREAL(pBitBlt->cyDest + cy)); } } else { BITMAPINFO * bmi = (BITMAPINFO *)&hatchBrushInfo; BYTE * bits = (BYTE *)HatchPatterns[myData->curPatIndex];
bmi->bmiColors[1].rgbRed = (myData->curBrush & Gdiplus::Color::RedMask) >> Gdiplus::Color::RedShift; bmi->bmiColors[1].rgbGreen = (myData->curBrush & Gdiplus::Color::GreenMask) >> Gdiplus::Color::GreenShift; bmi->bmiColors[1].rgbBlue = (myData->curBrush & Gdiplus::Color::BlueMask) >> Gdiplus::Color::BlueShift;
DibBrush brush(bmi, bits); float cx, cy; GetPixelSize (g, &cx, &cy); g->FillRectangle(brush, TOREAL(pBitBlt->xDest), TOREAL(pBitBlt->yDest), TOREAL(pBitBlt->cxDest + cx), TOREAL(pBitBlt->cyDest + cy)); } } return; } break; }
// Else assume SRCCOPY
BITMAPINFO *bmi = (BITMAPINFO *)(((BYTE *)pBitBlt) + pBitBlt->offBmiSrc); BYTE *bits = ((BYTE *)pBitBlt) + pBitBlt->offBitsSrc;
DibStream dibStream(bmi, bits); Gdiplus::Bitmap gpBitmap(&dibStream); Gdiplus::RectF destRect(TOREAL(pBitBlt->xDest), TOREAL(pBitBlt->yDest), TOREAL(pBitBlt->cxDest), TOREAL(pBitBlt->cyDest));
g->DrawImage(&gpBitmap, destRect, TOREAL(pBitBlt->xSrc), TOREAL(pBitBlt->ySrc), TOREAL(pBitBlt->cxDest), TOREAL(pBitBlt->cyDest), Gdiplus::UnitPixel);
} break;
case EMR_STRETCHBLT: { PEMRSTRETCHBLT pStretchBlt = (PEMRSTRETCHBLT)lpEMFR;
switch (pStretchBlt->dwRop) { case BLACKNESS: { Gdiplus::SolidBrush brush(Gdiplus::Color(0xff000000)); float cx, cy; GetPixelSize (g, &cx, &cy); g->FillRectangle(&brush, TOREAL(pStretchBlt->xDest), TOREAL(pStretchBlt->yDest), TOREAL(pStretchBlt->cxDest + cx), TOREAL(pStretchBlt->cyDest + cy)); } return; case WHITENESS: { Gdiplus::SolidBrush brush(Gdiplus::Color(0xffffffff)); float cx, cy; GetPixelSize (g, &cx, &cy); g->FillRectangle(&brush, TOREAL(pStretchBlt->xDest), TOREAL(pStretchBlt->yDest), TOREAL(pStretchBlt->cxDest + cx), TOREAL(pStretchBlt->cyDest + cy)); } return; default: if (!ISSOURCEINROP3(pStretchBlt->dwRop)) { float cx, cy; GetPixelSize (g, &cx, &cy); if (myData->curBrush != 0) { if (myData->curPatIndex < 0) { if (myData->curBrushPattern == NULL) { Gdiplus::SolidBrush brush(Gdiplus::Color(myData->curBrush)); g->FillRectangle(&brush, TOREAL(pStretchBlt->xDest), TOREAL(pStretchBlt->yDest), TOREAL(pStretchBlt->cxDest + cx), TOREAL(pStretchBlt->cyDest + cy)); } else { BITMAPINFO * bmi = (BITMAPINFO *)myData->curBrushPattern->bmi; BYTE * bits = ((BYTE *)bmi) + myData->curBrushPattern->bitsOffset;
DibBrush brush(bmi, bits); g->FillRectangle(brush, TOREAL(pStretchBlt->xDest), TOREAL(pStretchBlt->yDest), TOREAL(pStretchBlt->cxDest + cx), TOREAL(pStretchBlt->cyDest + cy)); } } else { BITMAPINFO * bmi = (BITMAPINFO *)&hatchBrushInfo; BYTE * bits = (BYTE *)HatchPatterns[myData->curPatIndex];
bmi->bmiColors[1].rgbRed = (myData->curBrush & Gdiplus::Color::RedMask) >> Gdiplus::Color::RedShift; bmi->bmiColors[1].rgbGreen = (myData->curBrush & Gdiplus::Color::GreenMask) >> Gdiplus::Color::GreenShift; bmi->bmiColors[1].rgbBlue = (myData->curBrush & Gdiplus::Color::BlueMask) >> Gdiplus::Color::BlueShift;
DibBrush brush(bmi, bits); g->FillRectangle(brush, TOREAL(pStretchBlt->xDest), TOREAL(pStretchBlt->yDest), TOREAL(pStretchBlt->cxDest + cx), TOREAL(pStretchBlt->cyDest + cy)); } } return; } break; }
// Else assume SRCCOPY
BITMAPINFO *bmi = (BITMAPINFO *)(((BYTE *)pStretchBlt) + pStretchBlt->offBmiSrc); BYTE *bits = ((BYTE *)pStretchBlt) + pStretchBlt->offBitsSrc;
DibStream dibStream(bmi, bits); Gdiplus::Bitmap gpBitmap(&dibStream); Gdiplus::RectF destRect(TOREAL(pStretchBlt->xDest), TOREAL(pStretchBlt->yDest), TOREAL(pStretchBlt->cxDest), TOREAL(pStretchBlt->cyDest));
g->DrawImage(&gpBitmap, destRect, TOREAL(pStretchBlt->xSrc), TOREAL(pStretchBlt->ySrc), TOREAL(pStretchBlt->cxSrc), TOREAL(pStretchBlt->cySrc), Gdiplus::UnitPixel); } break;
case EMR_MASKBLT: break;
case EMR_PLGBLT: break;
case EMR_SETDIBITSTODEVICE: break;#if 0
typedef struct tagEMRSETDIBITSTODEVICE{ EMR emr; RECTL rclBounds; // Inclusive-inclusive bounds in device units
LONG xDest; LONG yDest; LONG xSrc; LONG ySrc; LONG cxSrc; LONG cySrc; DWORD offBmiSrc; // Offset to the source BITMAPINFO structure
DWORD cbBmiSrc; // Size of the source BITMAPINFO structure
DWORD offBitsSrc; // Offset to the source bitmap bits
DWORD cbBitsSrc; // Size of the source bitmap bits
DWORD iUsageSrc; // Source bitmap info color table usage
DWORD iStartScan; DWORD cScans;} EMRSETDIBITSTODEVICE, *PEMRSETDIBITSTODEVICE;#endif
case EMR_STRETCHDIBITS: { PEMRSTRETCHDIBITS pStretchBlt = (PEMRSTRETCHDIBITS)lpEMFR;
switch (pStretchBlt->dwRop) { case BLACKNESS: { float cx, cy; GetPixelSize (g, &cx, &cy); Gdiplus::SolidBrush brush(Gdiplus::Color(0xff000000)); g->FillRectangle(&brush, TOREAL(pStretchBlt->xDest), TOREAL(pStretchBlt->yDest), TOREAL(pStretchBlt->cxDest + cx), TOREAL(pStretchBlt->cyDest + cy)); } return; case WHITENESS: { float cx, cy; GetPixelSize (g, &cx, &cy); Gdiplus::SolidBrush brush(Gdiplus::Color(0xffffffff)); g->FillRectangle(&brush, TOREAL(pStretchBlt->xDest), TOREAL(pStretchBlt->yDest), TOREAL(pStretchBlt->cxDest + cx), TOREAL(pStretchBlt->cyDest + cy)); } return; default: if (!ISSOURCEINROP3(pStretchBlt->dwRop)) { float cx, cy; GetPixelSize (g, &cx, &cy); if (myData->curBrush != 0) { if (myData->curPatIndex < 0) { if (myData->curBrushPattern == NULL) { Gdiplus::SolidBrush brush(Gdiplus::Color(myData->curBrush)); g->FillRectangle(&brush, TOREAL(pStretchBlt->xDest), TOREAL(pStretchBlt->yDest), TOREAL(pStretchBlt->cxDest + cx), TOREAL(pStretchBlt->cyDest + cy)); } else { BITMAPINFO * bmi = (BITMAPINFO *)myData->curBrushPattern->bmi; BYTE * bits = ((BYTE *)bmi) + myData->curBrushPattern->bitsOffset;
DibBrush brush(bmi, bits); g->FillRectangle(brush, TOREAL(pStretchBlt->xDest), TOREAL(pStretchBlt->yDest), TOREAL(pStretchBlt->cxDest + cx), TOREAL(pStretchBlt->cyDest + cy)); } } else { BITMAPINFO * bmi = (BITMAPINFO *)&hatchBrushInfo; BYTE * bits = (BYTE *)HatchPatterns[myData->curPatIndex];
bmi->bmiColors[1].rgbRed = (myData->curBrush & Gdiplus::Color::RedMask) >> Gdiplus::Color::RedShift; bmi->bmiColors[1].rgbGreen = (myData->curBrush & Gdiplus::Color::GreenMask) >> Gdiplus::Color::GreenShift; bmi->bmiColors[1].rgbBlue = (myData->curBrush & Gdiplus::Color::BlueMask) >> Gdiplus::Color::BlueShift;
DibBrush brush(bmi, bits); g->FillRectangle(brush, TOREAL(pStretchBlt->xDest), TOREAL(pStretchBlt->yDest), TOREAL(pStretchBlt->cxDest + cx), TOREAL(pStretchBlt->cyDest + cy)); } } return; } break; }
// Else assume SRCCOPY
BITMAPINFO *bmi = (BITMAPINFO *)(((BYTE *)pStretchBlt) + pStretchBlt->offBmiSrc); BYTE *bits = ((BYTE *)pStretchBlt) + pStretchBlt->offBitsSrc;
DibStream dibStream(bmi, bits); Gdiplus::Bitmap gpBitmap(&dibStream); Gdiplus::RectF destRect(TOREAL(pStretchBlt->xDest), TOREAL(pStretchBlt->yDest), TOREAL(pStretchBlt->cxDest), TOREAL(pStretchBlt->cyDest));
g->DrawImage(&gpBitmap, destRect, TOREAL(pStretchBlt->xSrc), TOREAL(pStretchBlt->ySrc), TOREAL(pStretchBlt->cxSrc), TOREAL(pStretchBlt->cySrc), Gdiplus::UnitPixel); } break;
case EMR_EXTCREATEFONTINDIRECTW: break;
case EMR_EXTTEXTOUTA: break;
case EMR_EXTTEXTOUTW: break;
case EMR_POLYBEZIER16: { PEMRPOLYBEZIER16 pBezier = (PEMRPOLYBEZIER16)lpEMFR;
if (pBezier->cpts > 0) { int i = pBezier->cpts; Gdiplus::PointF * points = new Gdiplus::PointF[i];
do { i--; points[i].X = pBezier->apts[i].x; points[i].Y = pBezier->apts[i].y; } while (i > 0);
if (!myData->pathOpen) { if (myData->curPen != 0) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
g->DrawBeziers(&pen, points, pBezier->cpts); } } else { myData->path->AddBeziers(points, pBezier->cpts); }
delete [] points; } } break;
case EMR_POLYGON16: { PEMRPOLYGON16 pPolygon = (PEMRPOLYGON16)lpEMFR;
if (pPolygon->cpts > 0) { int i = pPolygon->cpts; Gdiplus::PointF * points = new Gdiplus::PointF[i];
do { i--; points[i].X = pPolygon->apts[i].x; points[i].Y = pPolygon->apts[i].y; } while (i > 0);
if (!myData->pathOpen) { Gdiplus::GraphicsPath path(myData->fillMode); path.AddPolygon(points, pPolygon->cpts);
if (myData->curBrush != 0) { if (myData->curPatIndex < 0) { if (myData->curBrushPattern == NULL) { Gdiplus::SolidBrush brush(Gdiplus::Color(myData->curBrush)); g->FillPath(&brush, &path); } else { BITMAPINFO * bmi = (BITMAPINFO *)myData->curBrushPattern->bmi; BYTE * bits = ((BYTE *)bmi) + myData->curBrushPattern->bitsOffset;
DibBrush brush(bmi, bits); g->FillPath(brush, &path); } } else { BITMAPINFO * bmi = (BITMAPINFO *)&hatchBrushInfo; BYTE * bits = (BYTE *)HatchPatterns[myData->curPatIndex];
bmi->bmiColors[1].rgbRed = (myData->curBrush & Gdiplus::Color::RedMask) >> Gdiplus::Color::RedShift; bmi->bmiColors[1].rgbGreen = (myData->curBrush & Gdiplus::Color::GreenMask) >> Gdiplus::Color::GreenShift; bmi->bmiColors[1].rgbBlue = (myData->curBrush & Gdiplus::Color::BlueMask) >> Gdiplus::Color::BlueShift;
DibBrush brush(bmi, bits); g->FillPath(brush, &path); } } if (myData->curPen != 0) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
g->DrawPath(&pen, &path); } } else { myData->path->AddPolygon(points, pPolygon->cpts); } delete [] points; } } break;
case EMR_POLYLINE16: { PEMRPOLYLINE16 pPolyline = (PEMRPOLYLINE16)lpEMFR;
if (pPolyline->cpts > 0) { int i = pPolyline->cpts; Gdiplus::PointF * points = new Gdiplus::PointF[i];
do { i--; points[i].X = pPolyline->apts[i].x; points[i].Y = pPolyline->apts[i].y; } while (i > 0);
if (!myData->pathOpen) { if (myData->curPen != 0) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
g->DrawLines(&pen, points, pPolyline->cpts); } } else { myData->path->AddLines(points, pPolyline->cpts); }
delete [] points; } } break;
case EMR_POLYBEZIERTO16: { PEMRPOLYBEZIERTO16 pBezier = (PEMRPOLYBEZIERTO16)lpEMFR;
if (pBezier->cpts > 0) { int i = pBezier->cpts; Gdiplus::PointF * points = new Gdiplus::PointF[i+1];
do { points[i].X = pBezier->apts[i-1].x; points[i].Y = pBezier->apts[i-1].y; i--; } while (i > 0);
points[0] = myData->curPos; myData->curPos = points[pBezier->cpts];
if (!myData->pathOpen) { if (myData->curPen != 0) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
g->DrawBeziers(&pen, points, pBezier->cpts+1); } } else { myData->path->AddBeziers(points, pBezier->cpts+1); }
delete [] points; } } break;
case EMR_POLYLINETO16: { PEMRPOLYLINETO16 pPolyline = (PEMRPOLYLINETO16)lpEMFR;
if (pPolyline->cpts > 0) { int i = pPolyline->cpts; Gdiplus::PointF * points = new Gdiplus::PointF[i+1];
do { points[i].X = pPolyline->apts[i-1].x; points[i].Y = pPolyline->apts[i-1].y; i--; } while (i > 0);
points[0] = myData->curPos; myData->curPos = points[pPolyline->cpts];
if (!myData->pathOpen) { if (myData->curPen != 0) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
g->DrawLines(&pen, points, pPolyline->cpts+1); } } else { myData->path->AddLines(points, pPolyline->cpts+1); }
delete [] points; } } break;
case EMR_POLYPOLYLINE16: { PEMRPOLYPOLYLINE16 pPolyline = (PEMRPOLYPOLYLINE16)lpEMFR;
if ((pPolyline->cpts > 0) && (pPolyline->nPolys > 0)) { int i = pPolyline->cpts; Gdiplus::PointF * points = new Gdiplus::PointF[i]; POINTS * metaPoints = (POINTS *)(pPolyline->aPolyCounts + pPolyline->nPolys);
do { i--; points[i].X = metaPoints[i].x; points[i].Y = metaPoints[i].y; } while (i > 0);
if (!myData->pathOpen) { if (myData->curPen != 0) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
i = 0; Gdiplus::PointF * tmpPoints = points; DWORD count; do { count = pPolyline->aPolyCounts[i]; g->DrawLines(&pen, tmpPoints, count); tmpPoints += count; } while ((UINT)++i < pPolyline->nPolys); } } else { i = 0; Gdiplus::PointF * tmpPoints = points; DWORD count; do { count = pPolyline->aPolyCounts[i]; myData->path->AddLines(tmpPoints, count); tmpPoints += count; } while ((UINT)++i < pPolyline->nPolys); }
delete [] points; } } break;
case EMR_POLYPOLYGON16: { PEMRPOLYPOLYGON16 pPolygon = (PEMRPOLYPOLYGON16)lpEMFR;
if ((pPolygon->cpts > 0) && (pPolygon->nPolys > 0)) { int i = pPolygon->cpts; Gdiplus::PointF * points = new Gdiplus::PointF[i]; POINTS * metaPoints = (POINTS *)(pPolygon->aPolyCounts + pPolygon->nPolys);
do { i--; points[i].X = metaPoints[i].x; points[i].Y = metaPoints[i].y; } while (i > 0);
Gdiplus::GraphicsPath path(myData->fillMode); Gdiplus::GraphicsPath * tmpPath = &path;
if (myData->pathOpen) { tmpPath = myData->path; }
Gdiplus::PointF * tmpPoints = points; DWORD count; i = 0; do { count = pPolygon->aPolyCounts[i]; tmpPath->StartFigure(); tmpPath->AddPolygon(tmpPoints, count); tmpPoints += count; } while ((UINT)++i < pPolygon->nPolys);
if (!myData->pathOpen) { if (myData->curBrush != 0) { if (myData->curPatIndex < 0) { if (myData->curBrushPattern == NULL) { Gdiplus::SolidBrush brush(Gdiplus::Color(myData->curBrush)); g->FillPath(&brush, &path); } else { BITMAPINFO * bmi = (BITMAPINFO *)myData->curBrushPattern->bmi; BYTE * bits = ((BYTE *)bmi) + myData->curBrushPattern->bitsOffset;
DibBrush brush(bmi, bits); g->FillPath(brush, &path); } } else { BITMAPINFO * bmi = (BITMAPINFO *)&hatchBrushInfo; BYTE * bits = (BYTE *)HatchPatterns[myData->curPatIndex];
bmi->bmiColors[1].rgbRed = (myData->curBrush & Gdiplus::Color::RedMask) >> Gdiplus::Color::RedShift; bmi->bmiColors[1].rgbGreen = (myData->curBrush & Gdiplus::Color::GreenMask) >> Gdiplus::Color::GreenShift; bmi->bmiColors[1].rgbBlue = (myData->curBrush & Gdiplus::Color::BlueMask) >> Gdiplus::Color::BlueShift;
DibBrush brush(bmi, bits); g->FillPath(brush, &path); } } if (myData->curPen != 0) { Gdiplus::Pen pen(Gdiplus::Color(myData->curPen), TOREAL(myData->curPenWidth)); pen.SetMiterLimit(myData->miterLimit);
g->DrawPath(&pen, &path); } }
delete [] points; } } break;
case EMR_POLYDRAW16: break;
case EMR_CREATEMONOBRUSH: break;
case EMR_CREATEDIBPATTERNBRUSHPT: { PEMRCREATEDIBPATTERNBRUSHPT pBrush = (PEMRCREATEDIBPATTERNBRUSHPT)lpEMFR;
ASSERT(pBrush->ihBrush < myData->numObjects);
myData->pObjects[pBrush->ihBrush].type = MYOBJECTS::BrushObjectType; myData->pObjects[pBrush->ihBrush].color = 0xFF808080; myData->pObjects[pBrush->ihBrush].patIndex = -1; delete myData->pObjects[pBrush->ihBrush].brushPattern; myData->pObjects[pBrush->ihBrush].brushPattern = new MYPATTERNBRUSH();
if (myData->pObjects[pBrush->ihBrush].brushPattern != NULL) { BYTE * data = new BYTE[pBrush->cbBmi + pBrush->cbBits];
if (data != NULL) { memcpy(data, ((BYTE *)pBrush) + pBrush->offBmi, pBrush->cbBmi); memcpy(data + pBrush->cbBmi, ((BYTE *)pBrush) + pBrush->offBits, pBrush->cbBits); myData->pObjects[pBrush->ihBrush].brushPattern->bmi = (BITMAPINFO *)data; myData->pObjects[pBrush->ihBrush].brushPattern->bitsOffset = pBrush->cbBmi; } else { delete myData->pObjects[pBrush->ihBrush].brushPattern; myData->pObjects[pBrush->ihBrush].brushPattern = NULL; } } } break;
case EMR_EXTCREATEPEN: { PEMREXTCREATEPEN pPen = (PEMREXTCREATEPEN)lpEMFR; COLORREF cRef = pPen->elp.elpColor;
ASSERT((cRef & 0x01000000) == 0);
ASSERT(pPen->ihPen < myData->numObjects);
delete myData->pObjects[pPen->ihPen].brushPattern; myData->pObjects[pPen->ihPen].brushPattern = NULL;
myData->pObjects[pPen->ihPen].type = MYOBJECTS::PenObjectType; myData->pObjects[pPen->ihPen].color = Gdiplus::Color::MakeARGB(0xff, GetRValue(cRef), GetGValue(cRef), GetBValue(cRef));
myData->pObjects[pPen->ihPen].penWidth = pPen->elp.elpWidth; } break;
case EMR_POLYTEXTOUTA: break;
case EMR_POLYTEXTOUTW: break;
case EMR_SETICMMODE: case EMR_CREATECOLORSPACE: case EMR_SETCOLORSPACE: case EMR_DELETECOLORSPACE: case EMR_GLSRECORD: case EMR_GLSBOUNDEDRECORD: case EMR_PIXELFORMAT: break;
case EMR_DRAWESCAPE: case EMR_EXTESCAPE: case EMR_STARTDOC: case EMR_SMALLTEXTOUT: case EMR_FORCEUFIMAPPING: case EMR_NAMEDESCAPE: case EMR_COLORCORRECTPALETTE: case EMR_SETICMPROFILEA: case EMR_SETICMPROFILEW: case EMR_ALPHABLEND: case EMR_SETLAYOUT: case EMR_TRANSPARENTBLT: case EMR_GRADIENTFILL: case EMR_SETLINKEDUFIS: case EMR_SETTEXTJUSTIFICATION: case EMR_COLORMATCHTOTARGETW: case EMR_CREATECOLORSPACEW: break; }}
BOOL StepRecord( Gdiplus::EmfPlusRecordType recordType, UINT recordFlags, UINT recordDataSize, const BYTE * recordData, VOID * callbackData, HDC hDC = NULL, LPHANDLETABLE lpHTable = NULL, LPMETARECORD lpMFR = NULL, LPENHMETARECORD lpEMFR = NULL, int nObj = 0 );
VOID ListRecord( Gdiplus::EmfPlusRecordType recordType );
/***********************************************************************
FUNCTION : EnumMFIndirect
PARAMETERS : HDC hDC LPHANDLETABLE lpHTable LPMETARECORD lpMFR LPENHMETARECORD lpEMFR int nObj LPARAM lpData
PURPOSE : called by EnumMetaFile and EnumEnhMetaFile. Handles the stepping of each metafile record.
MESSAGES : none
RETURNS : int
COMMENTS : ENUMMFSTEP is used whenever records are to be played, regardless of whether you are playing records from the list, stepping all, or stepping a range.
ENUMMFLIST is used when you need to add strings to a listbox that describe the type of reocrd.
HISTORY : created 7/1/93 - denniscr
************************************************************************/using Gdiplus::EmfPlusRecordType;
int EnumMFIndirect(HDC hDC, LPHANDLETABLE lpHTable, LPMETARECORD lpMFR, LPENHMETARECORD lpEMFR, int nObj, LPARAM lpData){ BOOL DlgRet = TRUE; //
// what is the enumeration action that we are taking?
//
switch (iEnumAction) { //
//if the enumeration was entered ala the step metafile menu selection
//
case ENUMMFSTEP: if (bEnhMeta) { return StepRecord((EmfPlusRecordType)(lpEMFR->iType), 0, lpEMFR->nSize - sizeof(EMR), (BYTE *)lpEMFR->dParm, (VOID *)lpData, hDC, lpHTable, lpMFR, lpEMFR, nObj); } else { return StepRecord(GDIP_WMF_RECORD_TO_EMFPLUS(lpMFR->rdFunction), 0, ((LONG)lpMFR->rdSize * 2) - 6, ((BYTE *)lpMFR) + 6, (VOID *)lpData, hDC, lpHTable, lpMFR, lpEMFR, nObj); }
case ENUMMFLIST: if (bEnhMeta) { ListRecord((Gdiplus::EmfPlusRecordType)lpEMFR->iType); } else { ListRecord(GDIP_WMF_RECORD_TO_EMFPLUS(lpMFR->rdFunction)); } //
//keep enumerating
//
return(1); } return 0;}
/***********************************************************************
FUNCTION : ConvertEMFtoWMF
PARAMETERS : HENHMETAFILE hEMF - handle to enhanced metafile LPSTR lpszFileName - filename of disked based metafile
PURPOSE : Convert an Windows metafile to an enhanced metafile
MESSAGES : none
RETURNS : int
COMMENTS :
HISTORY : created 7/22/93 - denniscr
************************************************************************/
BOOL ConvertWMFtoEMF(HMETAFILE hmf, LPSTR lpszFileName){ LPSTR lpWinMFBits; UINT uiSizeBuf; HENHMETAFILE hEnhMF; BOOL bRet = TRUE; //
//get the size of the Windows metafile associated with hMF
//
if ((uiSizeBuf = GetMetaFileBitsEx((HMETAFILE)hMF, 0, NULL))) { //
//allocate enough memory to hold metafile bits
//
lpWinMFBits = (char *)GlobalAllocPtr(GHND, uiSizeBuf); //
//get the bits of the Windows metafile associated with hMF
//
if (lpWinMFBits && GetMetaFileBitsEx((HMETAFILE)hMF, uiSizeBuf, (LPVOID)lpWinMFBits)) { //
//copy the bits into a memory based enhanced metafile
//
hEnhMF = SetWinMetaFileBits(uiSizeBuf, (LPBYTE)lpWinMFBits, NULL, NULL); //
//copy the enhanced metafile to a disk based enhanced metafile
//
CopyEnhMetaFile(hEnhMF, lpszFileName); //
//done with the memory base enhanced metafile so get rid of it
//
DeleteEnhMetaFile(hEnhMF); //
//done with the actual memory used to store bits so nuke it
//
GlobalFreePtr(lpWinMFBits); } else bRet = FALSE; } else bRet = FALSE; return (bRet);}
/***********************************************************************
FUNCTION : ConvertEMFtoWMF
PARAMETERS : HENHMETAFILE hEMF - handle to enhanced metafile LPSTR lpszFileName - filename of disked based metafile
PURPOSE : Convert an enhanced metafile to an Windows metafile
MESSAGES : none
RETURNS : int
COMMENTS :
HISTORY : created 7/22/93 - denniscr
************************************************************************/
BOOL ConvertEMFtoWMF(HDC hrefDC, HENHMETAFILE hEMF, LPSTR lpszFileName){ LPSTR lpEMFBits; UINT uiSizeBuf; HMETAFILE hWMF; BOOL bRet = TRUE; DWORD dwBytesWritten ; //
//get the size of the Windows metafile associated with hMF
//
if ((uiSizeBuf = Gdiplus::Metafile::EmfToWmfBits(hemf, 0, NULL, MM_ANISOTROPIC, Gdiplus::EmfToWmfBitsFlagsIncludePlaceable))) { //
//allocate enough memory to hold metafile bits
//
lpEMFBits = (LPSTR)GlobalAllocPtr(GHND, uiSizeBuf); //
//get the bits of the enhanced metafile associated with hEMF
//
if (lpEMFBits && Gdiplus::Metafile::EmfToWmfBits(hEMF, uiSizeBuf,(LPBYTE)lpEMFBits, MM_ANISOTROPIC, Gdiplus::EmfToWmfBitsFlagsIncludePlaceable))
{ // Create a file and dump the metafile bits into it
HANDLE hFile = CreateFile(lpszFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL ); if(hFile != INVALID_HANDLE_VALUE) { WriteFile( hFile, (LPCVOID) lpEMFBits, uiSizeBuf, &dwBytesWritten, NULL ) ; CloseHandle(hFile); }
/*
//
//copy the bits into a memory based Windows metafile
//
hWMF = SetMetaFileBitsEx(uiSizeBuf, (LPBYTE)lpEMFBits); //
//copy the Windows metafile to a disk based Windows metafile
//
CopyMetaFile(hWMF, lpszFileName); //
//done with the memory base enhanced metafile so get rid of it
//
DeleteMetaFile((HMETAFILE)hMF);*/ //
//done with the actual memory used to store bits so nuke it
//
GlobalFreePtr(lpEMFBits); } else bRet = FALSE; } else bRet = FALSE; return (bRet);}
BOOL StepRecord( Gdiplus::EmfPlusRecordType recordType, UINT recordFlags, UINT recordDataSize, const BYTE * recordData, VOID * callbackData, HDC hDC, LPHANDLETABLE lpHTable, LPMETARECORD lpMFR, LPENHMETARECORD lpEMFR, int nObj ){ //
//keep track of the current metafile record number
//
iRecNum++;
//
//allocate memory for the record. this memory will be used by
//other functions that need to use the contents of the record
//
hMem = GlobalAlloc(GPTR /*GHND*/, (bEnhMeta) ? sizeof(EMR) + recordDataSize : 6 + recordDataSize); //
//if the memory was successfully allocated
//
if (hMem) { BOOL DlgRet = TRUE;
if (bEnhMeta) { //
//obtain a long pointer to this memory
//
if ((lpEMFParams = (LPEMFPARAMETERS)GlobalLock(hMem)) == NULL) { //
//we were unable to allocate memory for the record
//
MessageBox(hWndMain, "Memory allocation failed", NULL, MB_OK | MB_ICONHAND); } else { //
//copy the contents of the record to the global memory
//
emfMetaRec.nSize = sizeof(EMR) + recordDataSize; emfMetaRec.iType = recordType; unsigned long i; for (i = 0;(DWORD)i < recordDataSize / sizeof(DWORD); i++) { *lpEMFParams++ = ((DWORD *)recordData)[i]; } } } else { /* obtain a long pointer to this memory */ lpMFParams = (LPPARAMETERS)GlobalLock(hMem);
/* copy the contents of the record to the global memory */ MetaRec.rdSize = (6 + recordDataSize) / 2; MetaRec.rdFunction = GDIP_EMFPLUS_RECORD_TO_WMF(recordType); DWORD i; for (i = 0; (DWORD)i < (recordDataSize / 2); i++) { *lpMFParams++ = ((WORD *)recordData)[i]; } } GlobalUnlock(hMem); //
//if STEPPING through metafile records that have been selected
//by selecting the menu options Play - Step - All, Play - Step -
//Range, or selecting records from the View - List listbox
//
if ( !bPlayItAll || ( bEnumRange && iRecNum >= (WORD)iStartRange && iRecNum <= (WORD)iEndRange ) || ( bPlayList && !bPlayItAll ) ) { //
//if playing records selected from the View - List
//listbox of records
if (bPlayList) { //
//if playing the selected records
//
if (bPlaySelList) { //
//if done playing the selected records then stop the enumeration
//
if (iCount == iNumSel) { return(0); }
//
//if this is a selected record then play it
//
if ((WORD)lpSelMem[iCount] == iRecNum - 1) { //
//initialize flag
//
bPlayRec = FALSE; //
//increment the count
//
iCount = (iCount < iLBItemsInBuf) ? ++iCount : iCount; //
//call the dialog box that lets you play or ignore this record */
//
DlgRet = (BOOL) DialogBox((HINSTANCE)hInst, (LPSTR)"WMFDLG", hWndMain, WMFRecDlgProc); } else { //
//initialize flag and do nothing else
//
bPlayRec = FALSE; } } //
//playing the unselected records
//
else { //
//if this is one of the selected records then increment
//the record count and init a flag but do nothing else
//
if ((WORD)lpSelMem[iCount] == iRecNum - 1) { //
//set count to next selected record in listbox
//
iCount = (iCount < iLBItemsInBuf) ? ++iCount : iCount; bPlayRec = FALSE; } //
//this is not one of the selected records which is what we
//want in this case. So, init a flag give the user the
//opportunity to play the record
//
else { bPlayRec = FALSE; DlgRet = (BOOL) DialogBox((HINSTANCE)hInst, (LPSTR)"WMFDLG", hWndMain, WMFRecDlgProc); } }
} //bPlayList
//
//stepping records from the Play - Step menu option
//
else { //
//init a flag and show the record contents
//
bPlayRec = FALSE; iCount = (iCount < iLBItemsInBuf) ? ++iCount : iCount; DlgRet = (BOOL) DialogBox((HINSTANCE)hInst, (LPSTR)"WMFDLG", hWndMain, WMFRecDlgProc); } } //end of STEPPING the metafile
//
//bPlayItAll is TRUE. This is set when the user either
//selects the menu option Play - All or pushes the GO button
//in the view record dialog box
//
else { //
//we were stepping records selected from the listbox and
//the user pressed the GO button
//
//Don't bother returning 0 to stop enumeration. We need to
//play to the end of the metafile in this case anyway
//
if (bPlayList) { //
//we were playing the selected records
//
if (bPlaySelList) { //
//if all of the selected records have been played then
//stop the enumeration
//
if (iCount == iNumSel) { return(0); } //
//set bPlayRec so the record will be played without user
//interation and then update the record counter
//
if ((WORD)lpSelMem[iCount] == iRecNum - 1) { bPlayRec = TRUE; iCount = (iCount < iLBItemsInBuf) ? ++iCount : iCount; } else //
//it wasn't one of the selected records so don't play
//
{ bPlayRec = FALSE; } } //
//we were playing the unselected records
//
else { //
//if it is a selected record then set bPlayRec to FALSE
//so the record is not played
//
if ((WORD)lpSelMem[iCount] == iRecNum - 1) { bPlayRec = FALSE; iCount = (iCount < iLBItemsInBuf) ? ++iCount : iCount; } else { //
//play the record
//
bPlayRec = TRUE; } } } //bPlayList
} //GO button pushed
//
//Stop the enumeration if you were stepping a range and have
//finished playing that range OR the user selected pushed
//the STOP button in the view record dialog box
//
if ( ((bEnumRange) && (iRecNum > (WORD)iEndRange)) || (!DlgRet) ) { bPlayRec = FALSE; //
//stop enumeration
//
return(0); }
} //if (hMem)
else //
//we were unable to allocate memory for the record
//
{ MessageBox(hWndMain, "Memory allocation failed", NULL, MB_OK | MB_ICONHAND); } //
//Regardless of the method the user elected to play the
//records, check the flag. If it is set then play the
//record
//
if (bPlayRec) { if (bUseGdiPlusToPlay) { ((MYDATA *)callbackData)->metafile->PlayRecord(recordType, recordFlags, recordDataSize, recordData); } else if (bEnhMeta) { if (bConvertToGdiPlus) { GpPlayEnhMetaFileRecord(hDC, lpHTable, lpEMFR, (UINT)nObj, (LPARAM)callbackData); } else { PlayEnhMetaFileRecord(hDC, lpHTable, lpEMFR, (UINT)nObj); } } else if(!PlayMetaFileRecord(hDC, lpHTable, lpMFR, (UINT)nObj)) { ASSERT(FALSE); } } //
//done with the record so get rid of it
//
GlobalFree(hMem); //
//if we made it this far then continue the enumeration
//
return(1);}
VOID ListRecord( Gdiplus::EmfPlusRecordType recordType ){ char szMetaFunction[100];
iRecNum++; //
//format the listbox string
//
wsprintf((LPSTR)szMetaFunction, (LPSTR)"%d - ", iRecNum); //
//get the function number contained in the record
//
if (bEnhMeta) emfMetaRec.iType = recordType; else MetaRec.rdFunction = GDIP_EMFPLUS_RECORD_TO_WMF(recordType);
//
//lookup the function number in the structure MetaFunctions
//
int i; if (bEnhMeta) { for (i = NUMMETAFUNCTIONS; i < NUMENHMETARECORDS; i++) { if (recordType == (INT)emfMetaRecords[i].iType) break; } } else // WMF
{ for (i = 0; i < NUMMETAFUNCTIONS; i++) { if (recordType == (INT)emfMetaRecords[i].iType) break; } }
//
//if the function number is not found then describe this record
//as an "Unknown" type otherwise use the corresponding name
//found in the lookup
//
if (recordType != (INT)emfMetaRecords[i].iType) lstrcat((LPSTR)szMetaFunction, (LPSTR)"Unknown"); else lstrcat((LPSTR)szMetaFunction,(LPSTR)emfMetaRecords[i].szRecordName); //
//add the string to the listbox
//
SendDlgItemMessage((HWND)CurrenthDlg, IDL_LBREC, LB_ADDSTRING, 0, (LPARAM)(LPSTR)szMetaFunction);}
extern "C"BOOL CALLBACKPlayGdipMetafileRecordCallback( Gdiplus::EmfPlusRecordType recordType, UINT recordFlags, UINT recordDataSize, const BYTE * recordData, VOID * callbackData ){ switch (iEnumAction) { case ENUMMFSTEP: return StepRecord(recordType, recordFlags, recordDataSize, recordData, callbackData);
case ENUMMFLIST: ListRecord(recordType); break; } return TRUE;}
/***********************************************************************
FUNCTION : GetMetaFileAndEnum
PARAMETERS : HDC hDC
PURPOSE : load the metafile if it has not already been loaded and begin enumerating it
CALLS : WINDOWS GetMetaFile MakeProcInstance EnumMetaFile FreeProcInstance DeleteMetaFile MessageBox
MESSAGES : none
RETURNS : void
COMMENTS :
HISTORY : 1/16/91 - created - drc 7/1/93 - modified to work with EMFs - denniscr
************************************************************************/extern "C"void GetMetaFileAndEnum(HWND hwnd,HDC hDC,int iAction){ MYDATA myData(hwnd);
iEnumAction = iAction; //
//if this is an enhanced metafile (emf)
//
RECT rc; GetClientRect(hWndMain, &rc);
HPALETTE hpal = NULL;
if (bEnhMeta) {
if (hemf) { LPLOGPALETTE lpLogPal; HPALETTE hPal; int i; //
//allocate memory for the logical palette including the array of
//palette entries
//
lpLogPal = (LPLOGPALETTE) GlobalAllocPtr( GHND, sizeof(LOGPALETTE) + (sizeof (PALETTEENTRY) * EmfPtr.palNumEntries)); if (lpLogPal) { //
//proceed only if there is a valid ptr to logical palette
//and a palette array obtained from the emf
//
if (EmfPtr.lpPal) { lpLogPal->palVersion = 0x300; lpLogPal->palNumEntries = EmfPtr.palNumEntries; //
//copy palette entries into palentry array
//
for (i = 0; i < EmfPtr.palNumEntries; i++) lpLogPal->palPalEntry[i] = *EmfPtr.lpPal++; //
//reposition the ptr back to the beginning should we call this
//code again
//
EmfPtr.lpPal -= EmfPtr.palNumEntries; //
//create, select and realize the palette
//
if ((hPal = CreatePalette((LPLOGPALETTE)lpLogPal))) { SelectPalette(hDC, hPal, FALSE); RealizePalette(hDC); } }
if (bUseGdiPlusToPlay) { // Select in the halftone palette for 256-color display mode testing
hpal = Gdiplus::Graphics::GetHalftonePalette(); SelectPalette(hDC, hpal, FALSE); RealizePalette(hDC);
// Need to delete this before returning;
myData.g = Gdiplus::Graphics::FromHDC(hDC);myData.g->SetPixelOffsetMode(Gdiplus::PixelOffsetModeHalf);myData.g->SetInterpolationMode(Gdiplus::InterpolationModeNearestNeighbor); }
//
//enumerate the EMF. this is a bit odd simply because PlayEnhMetaFile
//really obviates the need for doing this (this cannot be said for WMFs).
//this app does it simply because it may be stepping the metafile records.
//Most apps are generally not concerned about doing this.
//
if (bUseGdiPlusToPlay && (myData.g != NULL)) { Gdiplus::Metafile m1(hemf); Gdiplus::Rect r1(rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top); myData.metafile = &m1; if(myData.g->EnumerateMetafile(&m1, r1, PlayGdipMetafileRecordCallback, &myData) != Gdiplus::Ok) MessageBox(NULL, "An Error Occured while playing this metafile", "Error", MB_OK | MB_ICONERROR); myData.metafile = NULL; } else { // the rect needs to be inclusive-inclusive!!!
rc.right--; rc.bottom--; if(!EnumEnhMetaFile(hDC, hemf, (ENHMFENUMPROC)EnhMetaFileEnumProc, (void*)&myData, &rc)) MessageBox(NULL, "Error", "An Error Occured while playing this metafile", MB_OK | MB_ICONERROR); }
//
//free palette memory
//
GlobalFreePtr(lpLogPal); } } } else { //
//if there is a valid handle to a metafile begin enumerating it
//
if (hMF) { if (bUseGdiPlusToPlay) { // Select in the halftone palette for 256-color display mode testing
hpal = Gdiplus::Graphics::GetHalftonePalette(); SelectPalette(hDC, hpal, FALSE); RealizePalette(hDC);
// Need to delete this before returning;
myData.g = Gdiplus::Graphics::FromHDC(hDC); }
if (bUseGdiPlusToPlay && (myData.g != NULL)) { Gdiplus::WmfPlaceableFileHeader * wmfPlaceableFileHeader = NULL;
if (bPlaceableMeta) { wmfPlaceableFileHeader = (Gdiplus::WmfPlaceableFileHeader *)&placeableWMFHeader; }
Gdiplus::Metafile m1((HMETAFILE)hMF, wmfPlaceableFileHeader); Gdiplus::Rect r1(rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top); myData.metafile = &m1; if (myData.g->EnumerateMetafile(&m1, r1, PlayGdipMetafileRecordCallback, &myData) != Gdiplus::Ok) MessageBox(NULL, "An Error Occured while playing this metafile", "Error", MB_OK | MB_ICONERROR); myData.metafile = NULL; } else { if (!EnumMetaFile(hDC, (HMETAFILE)hMF, (MFENUMPROC) MetaEnumProc, (LPARAM) 0)) MessageBox(NULL, "An Error Occured while playing this metafile", "Error", MB_OK | MB_ICONERROR); } } else MessageBox(hWndMain, "Invalid metafile handle", NULL, MB_OK | MB_ICONHAND); }
if (myData.g != NULL ) { SelectObject(hDC, GetStockObject(DEFAULT_PALETTE)); DeleteObject(hpal); myData.g->Flush(); delete myData.g; myData.g = NULL; }
return;}
|
