diff options
Diffstat (limited to 'cppcanvas/source/mtfrenderer/emfplus.cxx')
-rw-r--r-- | cppcanvas/source/mtfrenderer/emfplus.cxx | 1617 |
1 files changed, 1617 insertions, 0 deletions
diff --git a/cppcanvas/source/mtfrenderer/emfplus.cxx b/cppcanvas/source/mtfrenderer/emfplus.cxx new file mode 100644 index 000000000000..e90db4032bf6 --- /dev/null +++ b/cppcanvas/source/mtfrenderer/emfplus.cxx @@ -0,0 +1,1617 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2010 Novell, Inc. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <tools/stream.hxx> +#include <vcl/metaact.hxx> +#include <svtools/filter.hxx> +#include <basegfx/tools/canvastools.hxx> +#include <basegfx/tools/gradienttools.hxx> +#include <basegfx/tools/tools.hxx> +#include <basegfx/numeric/ftools.hxx> +#include <basegfx/point/b2dpoint.hxx> +#include <basegfx/vector/b2dsize.hxx> +#include <basegfx/range/b2drange.hxx> +#include <basegfx/range/b2drectangle.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> +#include <basegfx/polygon/b2dpolypolygon.hxx> +#include <basegfx/polygon/b2dpolypolygontools.hxx> +#include <vcl/canvastools.hxx> +#include <rtl/ustring.hxx> +#include <sal/alloca.h> + +#include <com/sun/star/rendering/XCanvas.hpp> +#include <com/sun/star/rendering/TexturingMode.hpp> + +#include <bitmapaction.hxx> +#include <implrenderer.hxx> +#include <outdevstate.hxx> +#include <polypolyaction.hxx> +#include <textaction.hxx> + +#define EmfPlusRecordTypeHeader 16385 +#define EmfPlusRecordTypeEndOfFile 16386 +#define EmfPlusRecordTypeGetDC 16388 +#define EmfPlusRecordTypeObject 16392 +#define EmfPlusRecordTypeFillRects 16394 +#define EmfPlusRecordTypeFillPolygon 16396 +#define EmfPlusRecordTypeDrawLines 16397 +#define EmfPlusRecordTypeFillPath 16404 +#define EmfPlusRecordTypeDrawPath 16405 +#define EmfPlusRecordTypeDrawImagePoints 16411 +#define EmfPlusRecordTypeDrawString 16412 +#define EmfPlusRecordTypeSetRenderingOrigin 16413 +#define EmfPlusRecordTypeSetAntiAliasMode 16414 +#define EmfPlusRecordTypeSetTextRenderingHint 16415 +#define EmfPlusRecordTypeSetInterpolationMode 16417 +#define EmfPlusRecordTypeSetPixelOffsetMode 16418 +#define EmfPlusRecordTypeSetCompositingQuality 16420 +#define EmfPlusRecordTypeSave 16421 +#define EmfPlusRecordTypeSetWorldTransform 16426 +#define EmfPlusRecordTypeResetWorldTransform 16427 +#define EmfPlusRecordTypeSetPageTransform 16432 +#define EmfPlusRecordTypeSetClipPath 16435 +#define EmfPlusRecordTypeSetClipRegion 16436 +#define EmfPlusRecordTypeDrawDriverString 16438 + +#define EmfPlusObjectTypeBrush 0x100 +#define EmfPlusObjectTypePen 0x200 +#define EmfPlusObjectTypePath 0x300 +#define EmfPlusObjectTypeRegion 0x400 +#define EmfPlusObjectTypeImage 0x500 +#define EmfPlusObjectTypeFont 0x600 +#define EmfPlusObjectTypeStringFormat 0x700 +#define EmfPlusObjectTypeImageAttributes 0x800 + +#define EmfPlusRegionInitialStateRectangle 0x10000000 +#define EmfPlusRegionInitialStatePath 0x10000001 +#define EmfPlusRegionInitialStateEmpty 0x10000002 +#define EmfPlusRegionInitialStateInfinite 0x10000003 + +#define EMFP_DEBUG(x) +//#define EMFP_DEBUG(x) x + +using namespace ::com::sun::star; + +namespace cppcanvas +{ + namespace internal + { + + EMFP_DEBUG (void dumpWords (SvStream& s, int i) + { + sal_uInt32 pos = s.Tell (); + sal_Int16 data; + for (; i > 0; i --) { + s >> data; + printf ("EMF+\tdata: %04hX\n", data); + } + s.Seek (pos); + }); + + struct EMFPObject + { + }; + + struct EMFPPath : public EMFPObject + { + ::basegfx::B2DPolyPolygon aPolygon; + sal_Int32 nPoints; + float* pPoints; + sal_uInt8* pPointTypes; + + public: + EMFPPath (sal_Int32 _nPoints, bool bLines = false) + { + if( _nPoints<0 || sal_uInt32(_nPoints)>SAL_MAX_INT32/(2*sizeof(float)) ) + _nPoints = SAL_MAX_INT32/(2*sizeof(float)); + nPoints = _nPoints; + pPoints = new float [nPoints*2]; + if (!bLines) + pPointTypes = new sal_uInt8 [_nPoints]; + else + pPointTypes = NULL; + } + + ~EMFPPath () + { + delete [] pPoints; + delete [] pPointTypes; + } + + // TODO: remove rR argument when debug code is not longer needed + void Read (SvStream& s, sal_uInt32 pathFlags, ImplRenderer& rR) + { + for (int i = 0; i < nPoints; i ++) { + if (pathFlags & 0x4000) { + // points are stored in short 16bit integer format + sal_uInt16 x, y; + + s >> x >> y; + EMFP_DEBUG (printf ("EMF+\tpoint [x,y]: %hd,%hd\n", x, y)); + pPoints [i*2] = x; + pPoints [i*2 + 1] = y; + } else { + // points are stored in Single (float) format + s >> pPoints [i*2] >> pPoints [i*2 + 1]; + EMFP_DEBUG (printf ("EMF+\tpoint [x,y]: %f,%f\n", pPoints [i*2], pPoints [i*2 + 1])); + } + } + + if (pPointTypes) + for (int i = 0; i < nPoints; i ++) { + s >> pPointTypes [i]; + EMFP_DEBUG (printf ("EMF+\tpoint type: %x\n", pPointTypes [i])); + } + + aPolygon.clear (); + + // debug code + const ::basegfx::B2DRectangle aBounds (::basegfx::tools::getRange (GetPolygon (rR))); + EMFP_DEBUG (printf ("EMF+\tpolygon bounding box: %f,%f %fx%f (mapped)\n", aBounds.getMinX (), aBounds.getMinY (), aBounds.getWidth (), aBounds.getHeight ())); + } + + ::basegfx::B2DPolyPolygon& GetPolygon (ImplRenderer& rR, bool bMapIt = true) + { + ::basegfx::B2DPolygon polygon; + + aPolygon.clear (); + + int last_normal = 0, p = 0; + ::basegfx::B2DPoint prev, mapped; + bool hasPrev = false; + for (int i = 0; i < nPoints; i ++) { + if (p && pPointTypes && (pPointTypes [i] == 0)) { + aPolygon.append (polygon); + last_normal = i; + p = 0; + polygon.clear (); + } + + if (bMapIt) + mapped = rR.Map (pPoints [i*2], pPoints [i*2 + 1]); + else + mapped = ::basegfx::B2DPoint (pPoints [i*2], pPoints [i*2 + 1]); + //EMFP_DEBUG (printf ("polygon point: %f,%f mapped: %f,%f\n", pPoints [i*2], pPoints [i*2 + 1], mapped.getX (), mapped.getY ())); + if (pPointTypes) { + if ((pPointTypes [i] & 0x07) == 3) { + if (((i - last_normal )% 3) == 1) { + polygon.setNextControlPoint (p - 1, mapped); + continue; + } else if (((i - last_normal) % 3) == 2) { + prev = mapped; + hasPrev = true; + continue; + } + } else + last_normal = i; + } + polygon.append (mapped); + if (hasPrev) { + polygon.setPrevControlPoint (p, prev); + hasPrev = false; + } + p ++; + if (pPointTypes && (pPointTypes [i] & 0x80)) { // closed polygon + polygon.setClosed (true); + aPolygon.append (polygon); + last_normal = i + 1; + p = 0; + polygon.clear (); + } + } + + if (polygon.count ()) + aPolygon.append (polygon); + + return aPolygon; + } + }; + + struct EMFPRegion : public EMFPObject + { + sal_Int32 parts; + sal_Int32 *combineMode; + sal_Int32 initialState; + EMFPPath *initialPath; + float ix, iy, iw, ih; + + EMFPRegion () + { + combineMode = NULL; + initialPath = NULL; + } + + ~EMFPRegion () + { + if (combineMode) { + delete [] combineMode; + combineMode = NULL; + } + if (initialPath) { + delete initialPath; + initialPath = NULL; + } + } + + void Read (SvStream& s) + { + sal_uInt32 header; + + s >> header >> parts; + + EMFP_DEBUG (printf ("EMF+\tregion\n")); + EMFP_DEBUG (printf ("EMF+\theader: 0x%08x parts: %d\n", header, parts)); + + if (parts) { + if( parts<0 || sal_uInt32(parts)>SAL_MAX_INT32/sizeof(sal_Int32) ) + parts = SAL_MAX_INT32/sizeof(sal_Int32); + + combineMode = new sal_Int32 [parts]; + + for (int i = 0; i < parts; i ++) { + s >> combineMode [i]; + EMFP_DEBUG (printf ("EMF+\tcombine mode [%d]: 0x%08x\n", i, combineMode [i])); + } + } + + s >> initialState; + EMFP_DEBUG (printf ("EMF+\tinitial state: 0x%08x\n", initialState)); + } + }; + + struct EMFPBrush : public EMFPObject + { + ::Color solidColor; + sal_uInt32 type; + sal_uInt32 additionalFlags; + + /* linear gradient */ + sal_Int32 wrapMode; + float areaX, areaY, areaWidth, areaHeight; + ::Color secondColor; // first color is stored in solidColor; + XForm transformation; + bool hasTransformation; + sal_Int32 blendPoints; + float* blendPositions; + float* blendFactors; + sal_Int32 colorblendPoints; + float* colorblendPositions; + ::Color* colorblendColors; + sal_Int32 surroundColorsNumber; + ::Color* surroundColors; + EMFPPath *path; + + public: + EMFPBrush () + { + blendPositions = NULL; + colorblendPositions = NULL; + colorblendColors = NULL; + surroundColors = NULL; + path = NULL; + hasTransformation = false; + } + + ~EMFPBrush () + { + if (blendPositions != NULL) { + delete[] blendPositions; + blendPositions = NULL; + } + if (colorblendPositions != NULL) { + delete[] colorblendPositions; + colorblendPositions = NULL; + } + if (colorblendColors != NULL) { + delete[] colorblendColors; + colorblendColors = NULL; + } + if (surroundColors != NULL) { + delete[] surroundColors; + surroundColors = NULL; + } + if (path) { + delete path; + path = NULL; + } + } + + sal_uInt32 GetType() const { return type; } + const ::Color& GetColor() const { return solidColor; } + + void Read (SvStream& s, ImplRenderer& rR) + { + sal_uInt32 header; + + s >> header >> type; + + EMFP_DEBUG (printf ("EMF+\tbrush\nEMF+\theader: 0x%08x type: %d\n", header, type)); + + switch (type) { + case 0: + { + sal_uInt32 color; + + s >> color; + solidColor = ::Color (0xff - (color >> 24), (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff); + EMFP_DEBUG (printf ("EMF+\tsolid color: 0x%08x\n", color)); + + break; + } + // path gradient + case 3: + { + s >> additionalFlags >> wrapMode; + + EMFP_DEBUG (printf ("EMF+\tpath gradient, additional flags: 0x%02x\n", additionalFlags)); + + sal_uInt32 color; + + s >> color; + solidColor = ::Color (0xff - (color >> 24), (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff); + EMFP_DEBUG (printf ("EMF+\tcenter color: 0x%08x\n", color)); + + s >> areaX >> areaY; + EMFP_DEBUG (printf ("EMF+\tcenter point: %f,%f\n", areaX, areaY)); + + s >> surroundColorsNumber; + EMFP_DEBUG (printf ("EMF+\tsurround colors: %d\n", surroundColorsNumber)); + + if( surroundColorsNumber<0 || sal_uInt32(surroundColorsNumber)>SAL_MAX_INT32/sizeof(::Color) ) + surroundColorsNumber = SAL_MAX_INT32/sizeof(::Color); + + surroundColors = new ::Color [surroundColorsNumber]; + for (int i = 0; i < surroundColorsNumber; i++) { + s >> color; + surroundColors[i] = ::Color (0xff - (color >> 24), (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff); + if (i == 0) + secondColor = surroundColors [0]; + EMFP_DEBUG (printf ("EMF+\tsurround color[%d]: 0x%08x\n", i, color)); + } + + if (additionalFlags & 0x01) { + sal_Int32 pathLength; + + s >> pathLength; + EMFP_DEBUG (printf ("EMF+\tpath length: %d\n", pathLength)); + + sal_uInt32 pos = s.Tell (); + EMFP_DEBUG (dumpWords (s, 32)); + + sal_uInt32 pathHeader; + sal_Int32 pathPoints, pathFlags; + s >> pathHeader >> pathPoints >> pathFlags; + + EMFP_DEBUG (printf ("EMF+\tpath (brush path gradient)\n")); + EMFP_DEBUG (printf ("EMF+\theader: 0x%08x points: %d additional flags: 0x%08x\n", pathHeader, pathPoints, pathFlags)); + + path = new EMFPPath (pathPoints); + path->Read (s, pathFlags, rR); + + s.Seek (pos + pathLength); + + const ::basegfx::B2DRectangle aBounds (::basegfx::tools::getRange (path->GetPolygon (rR, false))); + areaWidth = aBounds.getWidth (); + areaHeight = aBounds.getHeight (); + + EMFP_DEBUG (printf ("EMF+\tpolygon bounding box: %f,%f %fx%f\n", aBounds.getMinX (), aBounds.getMinY (), aBounds.getWidth (), aBounds.getHeight ())); + + + if (additionalFlags & 0x02) { + EMFP_DEBUG (printf ("EMF+\tuse transformation\n", color)); + s >> transformation; + hasTransformation = true; + EMFP_DEBUG (printf ("EMF+\tm11: %f m12: %f\nEMF+\tm21: %f m22: %f\nEMF+\tdx: %f dy: %f\n", + transformation.eM11, transformation.eM12, + transformation.eM21, transformation.eM22, + transformation.eDx, transformation.eDy)); + } + if (additionalFlags & 0x08) { + s >> blendPoints; + EMFP_DEBUG (printf ("EMF+\tuse blend, points: %d\n", blendPoints)); + if( blendPoints<0 || sal_uInt32(blendPoints)>SAL_MAX_INT32/(2*sizeof(float)) ) + blendPoints = SAL_MAX_INT32/(2*sizeof(float)); + blendPositions = new float [2*blendPoints]; + blendFactors = blendPositions + blendPoints; + for (int i=0; i < blendPoints; i ++) { + s >> blendPositions [i]; + EMFP_DEBUG (printf ("EMF+\tposition[%d]: %f\n", i, blendPositions [i])); + } + for (int i=0; i < blendPoints; i ++) { + s >> blendFactors [i]; + EMFP_DEBUG (printf ("EMF+\tfactor[%d]: %f\n", i, blendFactors [i])); + } + } + + if (additionalFlags & 0x04) { + s >> colorblendPoints; + EMFP_DEBUG (printf ("EMF+\tuse color blend, points: %d\n", colorblendPoints)); + if( colorblendPoints<0 || sal_uInt32(colorblendPoints)>SAL_MAX_INT32/sizeof(float) ) + colorblendPoints = SAL_MAX_INT32/sizeof(float); + if( sal_uInt32(colorblendPoints)>SAL_MAX_INT32/sizeof(::Color) ) + colorblendPoints = SAL_MAX_INT32/sizeof(::Color); + colorblendPositions = new float [colorblendPoints]; + colorblendColors = new ::Color [colorblendPoints]; + for (int i=0; i < colorblendPoints; i ++) { + s >> colorblendPositions [i]; + EMFP_DEBUG (printf ("EMF+\tposition[%d]: %f\n", i, colorblendPositions [i])); + } + for (int i=0; i < colorblendPoints; i ++) { + s >> color; + colorblendColors [i] = ::Color (0xff - (color >> 24), (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff); + EMFP_DEBUG (printf ("EMF+\tcolor[%d]: 0x%08x\n", i, color)); + } + } + } else { + EMFP_DEBUG (dumpWords (s, 1024)); + } + break; + } + // linear gradient + case 4: + { + s >> additionalFlags >> wrapMode; + + EMFP_DEBUG (printf ("EMF+\tlinear gradient, additional flags: 0x%02x\n", additionalFlags)); + + s >> areaX >> areaY >> areaWidth >> areaHeight; + + EMFP_DEBUG (printf ("EMF+\tarea: %f,%f - %fx%f\n", areaX, areaY, areaWidth, areaHeight)); + + sal_uInt32 color; + + s >> color; + solidColor = ::Color (0xff - (color >> 24), (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff); + EMFP_DEBUG (printf ("EMF+\tfirst color: 0x%08x\n", color)); + + s >> color; + secondColor = ::Color (0xff - (color >> 24), (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff); + EMFP_DEBUG (printf ("EMF+\tsecond color: 0x%08x\n", color)); + + // repeated colors, unknown meaning, see http://www.aces.uiuc.edu/~jhtodd/Metafile/MetafileRecords/ObjectBrush.html + s >> color; + s >> color; + + if (additionalFlags & 0x02) { + EMFP_DEBUG (printf ("EMF+\tuse transformation\n", color)); + s >> transformation; + hasTransformation = true; + EMFP_DEBUG (printf ("EMF+\tm11: %f m12: %f\nEMF+\tm21: %f m22: %f\nEMF+\tdx: %f dy: %f\n", + transformation.eM11, transformation.eM12, + transformation.eM21, transformation.eM22, + transformation.eDx, transformation.eDy)); + } + if (additionalFlags & 0x08) { + s >> blendPoints; + EMFP_DEBUG (printf ("EMF+\tuse blend, points: %d\n", blendPoints)); + if( blendPoints<0 || sal_uInt32(blendPoints)>SAL_MAX_INT32/(2*sizeof(float)) ) + blendPoints = SAL_MAX_INT32/(2*sizeof(float)); + blendPositions = new float [2*blendPoints]; + blendFactors = blendPositions + blendPoints; + for (int i=0; i < blendPoints; i ++) { + s >> blendPositions [i]; + EMFP_DEBUG (printf ("EMF+\tposition[%d]: %f\n", i, blendPositions [i])); + } + for (int i=0; i < blendPoints; i ++) { + s >> blendFactors [i]; + EMFP_DEBUG (printf ("EMF+\tfactor[%d]: %f\n", i, blendFactors [i])); + } + } + + if (additionalFlags & 0x04) { + s >> colorblendPoints; + EMFP_DEBUG (printf ("EMF+\tuse color blend, points: %d\n", colorblendPoints)); + if( colorblendPoints<0 || sal_uInt32(colorblendPoints)>SAL_MAX_INT32/sizeof(float) ) + colorblendPoints = SAL_MAX_INT32/sizeof(float); + if( sal_uInt32(colorblendPoints)>SAL_MAX_INT32/sizeof(::Color) ) + colorblendPoints = sal_uInt32(SAL_MAX_INT32)/sizeof(::Color); + colorblendPositions = new float [colorblendPoints]; + colorblendColors = new ::Color [colorblendPoints]; + for (int i=0; i < colorblendPoints; i ++) { + s >> colorblendPositions [i]; + EMFP_DEBUG (printf ("EMF+\tposition[%d]: %f\n", i, colorblendPositions [i])); + } + for (int i=0; i < colorblendPoints; i ++) { + s >> color; + colorblendColors [i] = ::Color (0xff - (color >> 24), (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff); + EMFP_DEBUG (printf ("EMF+\tcolor[%d]: 0x%08x\n", i, color)); + } + } + + break; + } + default: + EMFP_DEBUG (printf ("EMF+\tunhandled brush type: %d\n", type)); + } + } + }; + + struct EMFPPen : public EMFPBrush + { + XForm transformation; + float width; + sal_Int32 startCap; + sal_Int32 endCap; + sal_Int32 lineJoin; + float mitterLimit; + sal_Int32 dashStyle; + sal_Int32 dashCap; + float dashOffset; + sal_Int32 dashPatternLen; + float *dashPattern; + sal_Int32 alignment; + sal_Int32 compoundArrayLen; + float *compoundArray; + sal_Int32 customStartCapLen; + sal_uInt8 *customStartCap; + sal_Int32 customEndCapLen; + sal_uInt8 *customEndCap; + + public: + EMFPPen () : EMFPBrush () + { + } + + void SetStrokeAttributes (rendering::StrokeAttributes& rStrokeAttributes, ImplRenderer& rR, const OutDevState& rState) + { + rStrokeAttributes.StrokeWidth = (rState.mapModeTransform * rR.MapSize (width, 0)).getX (); + } + + void Read (SvStream& s, ImplRenderer& rR, sal_Int32, sal_Int32 ) + { + sal_uInt32 header, unknown, penFlags, unknown2; + int i; + + s >> header >> unknown >> penFlags >> unknown2 >> width; + + EMFP_DEBUG (printf ("EMF+\tpen\nEMF+\theader: 0x%08x unknown: 0x%08x additional flags: 0x%08x unknown: 0x%08x width: %f\n", header, unknown, penFlags, unknown2, width)); + + if (penFlags & 1) + s >> transformation; + + if (penFlags & 2) + s >> startCap; + else + startCap = 0; + + if (penFlags & 4) + s >> endCap; + else + endCap = 0; + + if (penFlags & 8) + s >> lineJoin; + else + lineJoin = 0; + + if (penFlags & 16) + s >> mitterLimit; + else + mitterLimit = 0; + + if (penFlags & 32) + s >> dashStyle; + else + dashStyle = 0; + + if (penFlags & 64) + s >> dashCap; + else + dashCap = 0; + + if (penFlags & 128) + s >> dashOffset; + else + dashOffset = 0; + + if (penFlags & 256) { + s >> dashPatternLen; + if( dashPatternLen<0 || sal_uInt32(dashPatternLen)>SAL_MAX_INT32/sizeof(float) ) + dashPatternLen = SAL_MAX_INT32/sizeof(float); + dashPattern = new float [dashPatternLen]; + for (i = 0; i < dashPatternLen; i++) + s >> dashPattern [i]; + } else + dashPatternLen = 0; + + if (penFlags & 512) + s >> alignment; + else + alignment = 0; + + if (penFlags & 1024) { + s >> compoundArrayLen; + if( compoundArrayLen<0 || sal_uInt32(compoundArrayLen)>SAL_MAX_INT32/sizeof(float) ) + compoundArrayLen = SAL_MAX_INT32/sizeof(float); + compoundArray = new float [compoundArrayLen]; + for (i = 0; i < compoundArrayLen; i++) + s >> compoundArray [i]; + } else + compoundArrayLen = 0; + + if (penFlags & 2048) { + s >> customStartCapLen; + if( customStartCapLen<0 ) + customStartCapLen=0; + customStartCap = new sal_uInt8 [customStartCapLen]; + for (i = 0; i < customStartCapLen; i++) + s >> customStartCap [i]; + } else + customStartCapLen = 0; + + if (penFlags & 4096) { + s >> customEndCapLen; + if( customEndCapLen<0 ) + customEndCapLen=0; + customEndCap = new sal_uInt8 [customEndCapLen]; + for (i = 0; i < customEndCapLen; i++) + s >> customEndCap [i]; + } else + customEndCapLen = 0; + + EMFPBrush::Read (s, rR); + } + }; + + struct EMFPImage : public EMFPObject + { + sal_uInt32 type; + sal_Int32 width; + sal_Int32 height; + sal_Int32 stride; + sal_Int32 pixelFormat; + Graphic graphic; + + + void Read (SvMemoryStream &s) + { + sal_uInt32 header, unknown; + + s >> header >> type; + + EMFP_DEBUG (printf ("EMF+\timage\nEMF+\theader: 0x%08x type: 0x%08x\n", header, type)); + + if (type == 1) { // bitmap + s >> width >> height >> stride >> pixelFormat >> unknown; + EMFP_DEBUG (printf ("EMF+\tbitmap width: %d height: %d stride: %d pixelFormat: 0x%08x\n", width, height, stride, pixelFormat)); + if (width == 0) { // non native formats + GraphicFilter filter; + + filter.ImportGraphic (graphic, String (), s); + EMFP_DEBUG (printf ("EMF+\tbitmap width: %d height: %d\n", graphic.GetBitmap ().GetSizePixel ().Width (), graphic.GetBitmap ().GetSizePixel ().Height ())); + } + + } else if (type == 2) { + sal_Int32 mfType, mfSize; + + s >> mfType >> mfSize; + EMFP_DEBUG (printf ("EMF+\tmetafile type: %d dataSize: %d\n", mfType, mfSize)); + + GraphicFilter filter; + SvMemoryStream mfStream (((char *)s.GetData()) + s.Tell(), mfSize, STREAM_READ); + + filter.ImportGraphic (graphic, String (), mfStream); + + // debug code - write the stream to debug file /tmp/emf-stream.emf + EMFP_DEBUG(mfStream.Seek(0); + SvFileStream file( UniString::CreateFromAscii( "/tmp/emf-embedded-stream.emf" ), STREAM_WRITE | STREAM_TRUNC ); + + mfStream >> file; + file.Flush(); + file.Close()); + } + } + }; + + struct EMFPFont : public EMFPObject + { + sal_uInt32 version; + float emSize; + sal_uInt32 sizeUnit; + sal_Int32 fontFlags; + rtl::OUString family; + + void Read (SvMemoryStream &s) + { + sal_uInt32 header; + sal_uInt32 reserved; + sal_uInt32 length; + + s >> header >> emSize >> sizeUnit >> fontFlags >> reserved >> length; + + OSL_ASSERT( ( header >> 12 ) == 0xdbc01 ); + + EMFP_DEBUG (printf ("EMF+\tfont\nEMF+\theader: 0x%08x version: 0x%08x size: %f unit: 0x%08x\n", header >> 12, header & 0x1fff, emSize, sizeUnit)); + EMFP_DEBUG (printf ("EMF+\tflags: 0x%08x reserved: 0x%08x length: 0x%08x\n", fontFlags, reserved, length)); + + if( length > 0 && length < 0x4000 ) { + sal_Unicode *chars = (sal_Unicode *) alloca( sizeof( sal_Unicode ) * length ); + + for( sal_uInt32 i = 0; i < length; i++ ) + s >> chars[ i ]; + + family = ::rtl::OUString( chars, length ); + EMFP_DEBUG (printf ("EMF+\tfamily: %s\n", rtl::OUStringToOString( family, RTL_TEXTENCODING_UTF8).getStr())); + } + } + }; + + void ImplRenderer::ReadRectangle (SvStream& s, float& x, float& y, float &width, float& height, sal_uInt32 flags) + { + if (flags & 0x4000) { + sal_Int16 ix, iy, iw, ih; + + s >> ix >> iy >> iw >> ih; + + x = ix; + y = iy; + width = iw; + height = ih; + } else + s >> x >> y >> width >> height; + } + + void ImplRenderer::ReadPoint (SvStream& s, float& x, float& y, sal_uInt32 flags) + { + if (flags & 0x4000) { + sal_Int16 ix, iy; + + s >> ix >> iy; + + x = ix; + y = iy; + } else + s >> x >> y; + } + + void ImplRenderer::MapToDevice (double& x, double& y) + { + // TODO: other untis + x = 100*nMmX*x/nPixX; + y = 100*nMmY*y/nPixY; + } + + ::basegfx::B2DPoint ImplRenderer::Map (::basegfx::B2DPoint& p) + { + return Map (p.getX (), p.getY ()); + } + + ::basegfx::B2DPoint ImplRenderer::Map (double ix, double iy) + { + double x, y; + + x = ix*aWorldTransform.eM11 + iy*aWorldTransform.eM21 + aWorldTransform.eDx; + y = ix*aWorldTransform.eM12 + iy*aWorldTransform.eM22 + aWorldTransform.eDy; + + MapToDevice (x, y); + + x -= nFrameLeft; + y -= nFrameTop; + + x *= aBaseTransform.eM11; + y *= aBaseTransform.eM22; + + return ::basegfx::B2DPoint (x, y); + } + + ::basegfx::B2DSize ImplRenderer::MapSize (double iwidth, double iheight) + { + double w, h; + + w = iwidth*aWorldTransform.eM11 + iheight*aWorldTransform.eM21; + h = iwidth*aWorldTransform.eM12 + iheight*aWorldTransform.eM22; + + MapToDevice (w, h); + + w *= aBaseTransform.eM11; + h *= aBaseTransform.eM22; + + return ::basegfx::B2DSize (w, h); + } + + ::basegfx::B2DRange ImplRenderer::MapRectangle (double ix, double iy, double iwidth, double iheight) + { + double x, y, w, h; + + x = ix*aWorldTransform.eM11 + iy*aWorldTransform.eM21 + aWorldTransform.eDx; + y = ix*aWorldTransform.eM12 + iy*aWorldTransform.eM22 + aWorldTransform.eDy; + w = iwidth*aWorldTransform.eM11 + iheight*aWorldTransform.eM21; + h = iwidth*aWorldTransform.eM12 + iheight*aWorldTransform.eM22; + + MapToDevice (x, y); + MapToDevice (w, h); + + x -= nFrameLeft; + y -= nFrameTop; + + x *= aBaseTransform.eM11; + y *= aBaseTransform.eM22; + w *= aBaseTransform.eM11; + h *= aBaseTransform.eM22; + + return ::basegfx::B2DRange (x, y, x + w, y + h); + } + +#define COLOR(x) \ + ::vcl::unotools::colorToDoubleSequence( ::Color (0xff - (x >> 24), \ + (x >> 16) & 0xff, \ + (x >> 8) & 0xff, \ + x & 0xff), \ + rCanvas->getUNOCanvas()->getDevice()->getDeviceColorSpace()); +#define SET_FILL_COLOR(x) \ + rState.fillColor = COLOR(x); +#define SET_LINE_COLOR(x) \ + rState.lineColor = COLOR(x); +#define SET_TEXT_COLOR(x) \ + rState.textColor = COLOR(x); + + void ImplRenderer::EMFPPlusFillPolygon (::basegfx::B2DPolyPolygon& polygon, const ActionFactoryParameters& rParms, + OutDevState& rState, const CanvasSharedPtr& rCanvas, bool isColor, sal_uInt32 brushIndexOrColor) + { + ::basegfx::B2DPolyPolygon localPolygon (polygon); + + EMFP_DEBUG (printf ("EMF+\tfill polygon\n")); + + localPolygon.transform( rState.mapModeTransform ); + + ActionSharedPtr pPolyAction; + + if (isColor) { + EMFP_DEBUG (printf ("EMF+\t\tcolor fill\n")); + + rState.isFillColorSet = true; + rState.isLineColorSet = false; + SET_FILL_COLOR(brushIndexOrColor); + + pPolyAction = ActionSharedPtr ( internal::PolyPolyActionFactory::createPolyPolyAction( localPolygon, rParms.mrCanvas, rState ) ); + + } else { + rState.isFillColorSet = true; + // extract UseBrush + EMFPBrush* brush = (EMFPBrush*) aObjects [brushIndexOrColor]; + EMFP_DEBUG (printf ("EMF+\tbrush fill slot: %d (type: %d)\n", brushIndexOrColor, brush->GetType ())); + + // give up in case something wrong happened + if( !brush ) + return; + + rState.isFillColorSet = false; + rState.isLineColorSet = false; + + if (brush->type == 3 || brush->type == 4) { + + if (brush->type == 3 && !(brush->additionalFlags & 0x1)) + return; // we are unable to parse these brushes yet + + ::basegfx::B2DHomMatrix aTextureTransformation; + ::basegfx::B2DHomMatrix aWorldTransformation; + ::basegfx::B2DHomMatrix aBaseTransformation; + rendering::Texture aTexture; + + aWorldTransformation.set (0, 0, aWorldTransform.eM11); + aWorldTransformation.set (0, 1, aWorldTransform.eM21); + aWorldTransformation.set (0, 2, aWorldTransform.eDx); + aWorldTransformation.set (1, 0, aWorldTransform.eM12); + aWorldTransformation.set (1, 1, aWorldTransform.eM22); + aWorldTransformation.set (1, 2, aWorldTransform.eDy); + + aBaseTransformation.set (0, 0, aBaseTransform.eM11); + aBaseTransformation.set (0, 1, aBaseTransform.eM21); + aBaseTransformation.set (0, 2, aBaseTransform.eDx); + aBaseTransformation.set (1, 0, aBaseTransform.eM12); + aBaseTransformation.set (1, 1, aBaseTransform.eM22); + aBaseTransformation.set (1, 2, aBaseTransform.eDy); + + if (brush->type == 4) { + aTextureTransformation.scale (brush->areaWidth, brush->areaHeight); + aTextureTransformation.translate (brush->areaX, brush->areaY); + } else { + aTextureTransformation.translate (-0.5, -0.5); + aTextureTransformation.scale (brush->areaWidth, brush->areaHeight); + aTextureTransformation.translate (brush->areaX,brush->areaY); + } + + if (brush->hasTransformation) { + ::basegfx::B2DHomMatrix aTransformation; + + aTransformation.set (0, 0, brush->transformation.eM11); + aTransformation.set (0, 1, brush->transformation.eM21); + aTransformation.set (0, 2, brush->transformation.eDx); + aTransformation.set (1, 0, brush->transformation.eM12); + aTransformation.set (1, 1, brush->transformation.eM22); + aTransformation.set (1, 2, brush->transformation.eDy); + + aTextureTransformation *= aTransformation; + } + + aTextureTransformation *= aWorldTransformation; + aTextureTransformation.scale (100.0*nMmX/nPixX, 100.0*nMmY/nPixY); + aTextureTransformation.translate (-nFrameLeft, -nFrameTop); + aTextureTransformation *= rState.mapModeTransform; + aTextureTransformation *= aBaseTransformation; + + aTexture.RepeatModeX = rendering::TexturingMode::CLAMP; + aTexture.RepeatModeY = rendering::TexturingMode::CLAMP; + aTexture.Alpha = 1.0; + + basegfx::ODFGradientInfo aGradInfo; + rtl::OUString aGradientService; + + const uno::Sequence< double > aStartColor( + ::vcl::unotools::colorToDoubleSequence( brush->solidColor, + rParms.mrCanvas->getUNOCanvas()->getDevice()->getDeviceColorSpace() ) ); + const uno::Sequence< double > aEndColor( + ::vcl::unotools::colorToDoubleSequence( brush->secondColor, + rParms.mrCanvas->getUNOCanvas()->getDevice()->getDeviceColorSpace() ) ); + uno::Sequence< uno::Sequence < double > > aColors (2); + uno::Sequence< double > aStops (2); + + if (brush->blendPositions) { + EMFP_DEBUG (printf ("EMF+\t\tuse blend\n")); + aColors.realloc (brush->blendPoints); + aStops.realloc (brush->blendPoints); + int length = aStartColor.getLength (); + uno::Sequence< double > aColor (length); + + OSL_ASSERT (length == aEndColor.getLength()); + + for (int i = 0; i < brush->blendPoints; i++) { + aStops[i] = brush->blendPositions [i]; + + for (int j = 0; j < length; j++) { + if (brush->type == 4) { +// // gamma correction +// if (brush->additionalFlags & 0x80) +// aColor [j] = pow (aStartColor [j]*(1 - brush->blendFactors[i]) + aEndColor [j]*brush->blendFactors[i], 1/2.2); +// else + aColor [j] = aStartColor [j]*(1 - brush->blendFactors[i]) + aEndColor [j]*brush->blendFactors[i]; + } else + aColor [j] = aStartColor [j]*brush->blendFactors[i] + aEndColor [j]*(1 - brush->blendFactors[i]); + } + + aColors[i] = aColor; + } + } else if (brush->colorblendPositions) { + EMFP_DEBUG (printf ("EMF+\t\tuse color blend\n")); + aColors.realloc (brush->colorblendPoints); + aStops.realloc (brush->colorblendPoints); + + for (int i = 0; i < brush->colorblendPoints; i++) { + aStops[i] = brush->colorblendPositions [i]; + aColors[(brush->type == 4) ? i : brush->colorblendPoints - 1 - i] = ::vcl::unotools::colorToDoubleSequence( brush->colorblendColors [i], + rParms.mrCanvas->getUNOCanvas()->getDevice()->getDeviceColorSpace() ); + } + } else { + aStops[0] = 0.0; + aStops[1] = 1.0; + + if (brush->type == 4) { + aColors[0] = aStartColor; + aColors[1] = aEndColor; + } else { + aColors[1] = aStartColor; + aColors[0] = aEndColor; + } + } + + EMFP_DEBUG (printf ("EMF+\t\tset gradient\n")); + basegfx::B2DRange aBoundsRectangle (0, 0, 1, 1); + if (brush->type == 4) { + aGradientService = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("LinearGradient")); + basegfx::tools::createLinearODFGradientInfo( aGradInfo, + aBoundsRectangle, + aStops.getLength(), + 0, + 0 ); + + } else { + aGradientService = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("EllipticalGradient")); + basegfx::tools::createEllipticalODFGradientInfo( aGradInfo, + aBoundsRectangle, + ::basegfx::B2DVector( 0, 0 ), + aStops.getLength(), + 0, + 0 ); + } + + uno::Reference< lang::XMultiServiceFactory > xFactory( + rParms.mrCanvas->getUNOCanvas()->getDevice()->getParametricPolyPolygonFactory() ); + + if( xFactory.is() ) { + uno::Sequence<uno::Any> args( 3 ); + beans::PropertyValue aProp; + aProp.Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Colors")); + aProp.Value <<= aColors; + args[0] <<= aProp; + aProp.Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Stops")); + aProp.Value <<= aStops; + args[1] <<= aProp; + aProp.Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AspectRatio")); + aProp.Value <<= static_cast<sal_Int32>(1); + args[2] <<= aProp; + + aTexture.Gradient.set( + xFactory->createInstanceWithArguments( aGradientService, + args ), + uno::UNO_QUERY); + } + + ::basegfx::unotools::affineMatrixFromHomMatrix( aTexture.AffineTransform, + aTextureTransformation ); + + if( aTexture.Gradient.is() ) + pPolyAction = + ActionSharedPtr ( internal::PolyPolyActionFactory::createPolyPolyAction( localPolygon, + rParms.mrCanvas, + rState, + aTexture ) ); + } + } + + if( pPolyAction ) + { + EMFP_DEBUG (printf ("EMF+\t\tadd poly action\n")); + + maActions.push_back( + MtfAction( + pPolyAction, + rParms.mrCurrActionIndex ) ); + + rParms.mrCurrActionIndex += pPolyAction->getActionCount()-1; + } + } + + void ImplRenderer::processObjectRecord(SvMemoryStream& rObjectStream, sal_uInt16 flags) + { + EMFP_DEBUG (sal_uInt32 objectLen); + sal_uInt32 index; + + EMFP_DEBUG (printf ("EMF+ Object slot: %hd flags: %hx\n", flags & 0xff, flags & 0xff00)); + + index = flags & 0xff; + if (aObjects [index] != NULL) { + delete aObjects [index]; + aObjects [index] = NULL; + } + + switch (flags & 0x7f00) { + case EmfPlusObjectTypeBrush: + { + EMFPBrush *brush; + aObjects [index] = brush = new EMFPBrush (); + brush->Read (rObjectStream, *this); + + break; + } + case EmfPlusObjectTypePen: + { + EMFPPen *pen; + aObjects [index] = pen = new EMFPPen (); + pen->Read (rObjectStream, *this, nHDPI, nVDPI); + + break; + } + case EmfPlusObjectTypePath: + sal_uInt32 header, pathFlags; + sal_Int32 points; + + rObjectStream >> header >> points >> pathFlags; + + EMFP_DEBUG (printf ("EMF+\tpath\n")); + EMFP_DEBUG (printf ("EMF+\theader: 0x%08x points: %d additional flags: 0x%08x\n", header, points, pathFlags)); + + EMFPPath *path; + aObjects [index] = path = new EMFPPath (points); + path->Read (rObjectStream, pathFlags, *this); + + break; + case EmfPlusObjectTypeRegion: { + EMFPRegion *region; + + aObjects [index] = region = new EMFPRegion (); + region->Read (rObjectStream); + + break; + } + case EmfPlusObjectTypeImage: + { + EMFPImage *image; + aObjects [index] = image = new EMFPImage (); + image->Read (rObjectStream); + + break; + } + case EmfPlusObjectTypeFont: + { + EMFPFont *font; + aObjects [index] = font = new EMFPFont (); + font->Read (rObjectStream); + + break; + } + default: + EMFP_DEBUG (printf ("EMF+\tObject unhandled flags: 0x%04x\n", flags & 0xff00)); + break; + } + } + + void ImplRenderer::processEMFPlus( MetaCommentAction* pAct, const ActionFactoryParameters& rFactoryParms, + OutDevState& rState, const CanvasSharedPtr& rCanvas ) + { + sal_uInt32 length = pAct->GetDataSize (); + SvMemoryStream rMF ((void*) pAct->GetData (), length, STREAM_READ); + + length -= 4; + + while (length > 0) { + sal_uInt16 type, flags; + sal_uInt32 size, dataSize; + sal_uInt32 next; + + rMF >> type >> flags >> size >> dataSize; + + next = rMF.Tell() + ( size - 12 ); + + EMFP_DEBUG (printf ("EMF+ record size: %d type: %04hx flags: %04hx data size: %d\n", size, type, flags, dataSize)); + + if (type == EmfPlusRecordTypeObject && ((mbMultipart && (flags & 0x7fff) == (mMFlags & 0x7fff)) || (flags & 0x8000))) { + if (!mbMultipart) { + mbMultipart = true; + mMFlags = flags; + mMStream.Seek(0); + } + + // 1st 4 bytes are unknown + mMStream.Write (((const char *)rMF.GetData()) + rMF.Tell() + 4, dataSize - 4); + EMFP_DEBUG (printf ("EMF+ read next object part size: %d type: %04hx flags: %04hx data size: %d\n", size, type, flags, dataSize)); + } else { + if (mbMultipart) { + EMFP_DEBUG (printf ("EMF+ multipart record flags: %04hx\n", mMFlags)); + mMStream.Seek (0); + processObjectRecord (mMStream, mMFlags); + } + mbMultipart = false; + } + + if (type != EmfPlusRecordTypeObject || !(flags & 0x8000)) + switch (type) { + case EmfPlusRecordTypeHeader: + sal_uInt32 header, version; + + rMF >> header >> version >> nHDPI >> nVDPI; + + EMFP_DEBUG (printf ("EMF+ Header\n")); + EMFP_DEBUG (printf ("EMF+\theader: 0x%08x version: %d horizontal DPI: %d vertical DPI: %d dual: %d\n", header, version, nHDPI, nVDPI, flags & 1)); + + break; + case EmfPlusRecordTypeEndOfFile: + EMFP_DEBUG (printf ("EMF+ EndOfFile\n")); + break; + case EmfPlusRecordTypeGetDC: + EMFP_DEBUG (printf ("EMF+ GetDC\n")); + EMFP_DEBUG (printf ("EMF+\talready used in svtools wmf/emf filter parser\n")); + break; + case EmfPlusRecordTypeObject: + processObjectRecord (rMF, flags); + break; + case EmfPlusRecordTypeFillPath: + { + sal_uInt32 index = flags & 0xff; + sal_uInt32 brushIndexOrColor; + + rMF >> brushIndexOrColor; + + EMFP_DEBUG (printf ("EMF+ FillPath slot: %d\n", index)); + + EMFPPlusFillPolygon (((EMFPPath*) aObjects [index])->GetPolygon (*this), rFactoryParms, rState, rCanvas, flags & 0x8000, brushIndexOrColor); + } + break; + case EmfPlusRecordTypeFillRects: + { + EMFP_DEBUG (printf ("EMF+ FillRects\n")); + + sal_uInt32 brushIndexOrColor; + sal_Int32 rectangles; + ::basegfx::B2DPolygon polygon; + + rMF >> brushIndexOrColor >> rectangles; + + EMFP_DEBUG (printf ("EMF+\t%s: 0x%08x\n", (flags & 0x8000) ? "color" : "brush index", brushIndexOrColor)); + + for (int i=0; i < rectangles; i++) { + if (flags & 0x4000) { + /* 16bit integers */ + sal_Int16 x, y, width, height; + + rMF >> x >> y >> width >> height; + + polygon.append (Map (x, y)); + polygon.append (Map (x + width, y)); + polygon.append (Map (x + width, y + height)); + polygon.append (Map (x, y + height)); + + EMFP_DEBUG (printf ("EMF+\trectangle: %d,%d %dx%d\n", x, y, width, height)); + } else { + /* Single's */ + float x, y, width, height; + + rMF >> x >> y >> width >> height; + + polygon.append (Map (x, y)); + polygon.append (Map (x + width, y)); + polygon.append (Map (x + width, y + height)); + polygon.append (Map (x, y + height)); + + EMFP_DEBUG (printf ("EMF+\trectangle: %f,%f %fx%f\n", x, y, width, height)); + } + + ::basegfx::B2DPolyPolygon polyPolygon (polygon); + + EMFPPlusFillPolygon (polyPolygon, rFactoryParms, rState, rCanvas, flags & 0x8000, brushIndexOrColor); + } + break; + } + case EmfPlusRecordTypeFillPolygon: + { + EMFP_DEBUG (sal_uInt8 index = flags & 0xff); + sal_uInt32 brushIndexOrColor; + EMFP_DEBUG (sal_Int32 brushIndex); + sal_Int32 points; + EMFP_DEBUG (sal_uInt32 color); + EMFP_DEBUG (sal_uInt16 transparency = 0); + + rMF >> brushIndexOrColor; + rMF >> points; + + EMFP_DEBUG (printf ("EMF+ FillPolygon in slot: %d points: %d\n", index, points)); + EMFP_DEBUG (printf ("EMF+\twith solid color (ARGB): 0x%08X\n", color)); + + EMFPPath path (points, true); + path.Read (rMF, flags, *this); + + + EMFPPlusFillPolygon (path.GetPolygon (*this), rFactoryParms, rState, rCanvas, flags & 0x8000, brushIndexOrColor); + + break; + } + case EmfPlusRecordTypeDrawLines: + { + sal_uInt32 index = flags & 0xff; + sal_uInt32 points; + + rMF >> points; + + EMFP_DEBUG (printf ("EMF+ DrawLines in slot: %d points: %d\n", index, points)); + + EMFPPath path (points, true); + path.Read (rMF, flags, *this); + + EMFPPen* pen = (EMFPPen*) aObjects [index]; + + rState.isFillColorSet = false; + rState.isLineColorSet = true; + rState.lineColor = ::vcl::unotools::colorToDoubleSequence (pen->GetColor (), + rCanvas->getUNOCanvas ()->getDevice()->getDeviceColorSpace() ); + ::basegfx::B2DPolyPolygon& polygon (path.GetPolygon (*this)); + + polygon.transform( rState.mapModeTransform ); + + rendering::StrokeAttributes aStrokeAttributes; + + pen->SetStrokeAttributes (aStrokeAttributes, *this, rState); + + ActionSharedPtr pPolyAction( + internal::PolyPolyActionFactory::createPolyPolyAction( + polygon, rFactoryParms.mrCanvas, rState, aStrokeAttributes ) ); + + if( pPolyAction ) + { + maActions.push_back( + MtfAction( + pPolyAction, + rFactoryParms.mrCurrActionIndex ) ); + + rFactoryParms.mrCurrActionIndex += pPolyAction->getActionCount()-1; + } + + break; + } + case EmfPlusRecordTypeDrawPath: + { + sal_uInt32 penIndex; + + rMF >> penIndex; + + EMFP_DEBUG (printf ("EMF+ DrawPath\n")); + EMFP_DEBUG (printf ("EMF+\tpen: %d\n", penIndex)); + + EMFPPath* path = (EMFPPath*) aObjects [flags & 0xff]; + EMFPPen* pen = (EMFPPen*) aObjects [penIndex]; + + rState.isFillColorSet = false; + rState.isLineColorSet = true; + rState.lineColor = ::vcl::unotools::colorToDoubleSequence (pen->GetColor (), + rCanvas->getUNOCanvas ()->getDevice()->getDeviceColorSpace()); + ::basegfx::B2DPolyPolygon& polygon (path->GetPolygon (*this)); + + polygon.transform( rState.mapModeTransform ); + rendering::StrokeAttributes aStrokeAttributes; + + pen->SetStrokeAttributes (aStrokeAttributes, *this, rState); + + ActionSharedPtr pPolyAction( + internal::PolyPolyActionFactory::createPolyPolyAction( + polygon, rFactoryParms.mrCanvas, rState, aStrokeAttributes ) ); + + if( pPolyAction ) + { + maActions.push_back( + MtfAction( + pPolyAction, + rFactoryParms.mrCurrActionIndex ) ); + + rFactoryParms.mrCurrActionIndex += pPolyAction->getActionCount()-1; + } + break; + } + case EmfPlusRecordTypeDrawImagePoints: + { + sal_uInt32 attrIndex; + sal_Int32 sourceUnit; + + rMF >> attrIndex >> sourceUnit; + + EMFP_DEBUG (printf ("EMF+ DrawImagePoints attributes index: %d source unit: %d\n", attrIndex, sourceUnit)); + EMFP_DEBUG (printf ("EMF+\tTODO: use image attributes\n")); + + if (sourceUnit == 2 && aObjects [flags & 0xff]) { // we handle only GraphicsUnit.Pixel now + EMFPImage& image = *(EMFPImage *) aObjects [flags & 0xff]; + float sx, sy, sw, sh; + sal_Int32 unknown; + + ReadRectangle (rMF, sx, sy, sw, sh); + + rMF >> unknown; + + EMFP_DEBUG (printf ("EMF+ DrawImagePoints source rectangle: %f,%f %fx%f unknown: 0x%08x\n", sx, sy, sw, sh, unknown)); + + if (unknown == 3) { // it probably means number of points defining destination rectangle + float x1, y1, x2, y2, x3, y3; + + ReadPoint (rMF, x1, y1); + ReadPoint (rMF, x2, y2); + ReadPoint (rMF, x3, y3); + + BitmapEx aBmp( image.graphic.GetBitmapEx () ); + const Rectangle aCropRect (::vcl::unotools::pointFromB2DPoint (Map (sx, sy)), + ::vcl::unotools::sizeFromB2DSize (MapSize(sw, sh))); + aBmp.Crop( aCropRect ); + + + ActionSharedPtr pBmpAction ( + internal::BitmapActionFactory::createBitmapAction ( + aBmp, + rState.mapModeTransform * Map (x1, y1), + rState.mapModeTransform * MapSize(x2 - x1, y3 - y1), + rCanvas, + rState)); + + if( pBmpAction ) { + maActions.push_back( MtfAction( pBmpAction, + rFactoryParms.mrCurrActionIndex ) ); + + rFactoryParms.mrCurrActionIndex += pBmpAction->getActionCount()-1; + } + } else { + EMFP_DEBUG (printf ("EMF+ DrawImagePoints TODO (fixme)\n")); + } + } + break; + } + case EmfPlusRecordTypeDrawString: + EMFP_DEBUG (printf ("EMF+ DrawString\n")); + EMFP_DEBUG (printf ("EMF+\tTODO\n")); + break; + case EmfPlusRecordTypeSetPageTransform: + rMF >> fPageScale; + + EMFP_DEBUG (printf ("EMF+ SetPageTransform\n")); + EMFP_DEBUG (printf ("EMF+\tscale: %f unit: %d\n", fPageScale, flags)); + EMFP_DEBUG (printf ("EMF+\tTODO\n")); + break; + case EmfPlusRecordTypeSetRenderingOrigin: + rMF >> nOriginX >> nOriginY; + EMFP_DEBUG (printf ("EMF+ SetRenderingOrigin\n")); + EMFP_DEBUG (printf ("EMF+\torigin [x,y]: %d,%d\n", nOriginX, nOriginY)); + break; + case EmfPlusRecordTypeSetTextRenderingHint: + EMFP_DEBUG (printf ("EMF+ SetTextRenderingHint\n")); + EMFP_DEBUG (printf ("EMF+\tTODO\n")); + break; + case EmfPlusRecordTypeSetAntiAliasMode: + EMFP_DEBUG (printf ("EMF+ SetAntiAliasMode\n")); + EMFP_DEBUG (printf ("EMF+\tTODO\n")); + break; + case EmfPlusRecordTypeSetInterpolationMode: + EMFP_DEBUG (printf ("EMF+ InterpolationMode\n")); + EMFP_DEBUG (printf ("EMF+\tTODO\n")); + break; + case EmfPlusRecordTypeSetPixelOffsetMode: + EMFP_DEBUG (printf ("EMF+ SetPixelOffsetMode\n")); + EMFP_DEBUG (printf ("EMF+\tTODO\n")); + break; + case EmfPlusRecordTypeSetCompositingQuality: + EMFP_DEBUG (printf ("EMF+ SetCompositingQuality\n")); + EMFP_DEBUG (printf ("EMF+\tTODO\n")); + break; + case EmfPlusRecordTypeSave: + EMFP_DEBUG (printf ("EMF+ Save\n")); + EMFP_DEBUG (printf ("EMF+\tTODO\n")); + break; + case EmfPlusRecordTypeSetWorldTransform: { + EMFP_DEBUG (printf ("EMF+ SetWorldTransform\n")); + XForm transform; + rMF >> transform; + aWorldTransform.Set (transform); + EMFP_DEBUG (printf ("EMF+\tm11: %f m12: %f\nEMF+\tm21: %f m22: %f\nEMF+\tdx: %f dy: %f\n", + aWorldTransform.eM11, aWorldTransform.eM12, + aWorldTransform.eM21, aWorldTransform.eM22, + aWorldTransform.eDx, aWorldTransform.eDy)); + break; + } + case EmfPlusRecordTypeResetWorldTransform: + EMFP_DEBUG (printf ("EMF+ ResetWorldTransform\n")); + aWorldTransform.SetIdentity (); + break; + case EmfPlusRecordTypeSetClipPath: + { + EMFP_DEBUG (printf ("EMF+ SetClipPath\n")); + EMFP_DEBUG (printf ("EMF+\tpath in slot: %d\n", flags & 0xff)); + + EMFPPath& path = *(EMFPPath*) aObjects [flags & 0xff]; + ::basegfx::B2DPolyPolygon& clipPoly (path.GetPolygon (*this)); + + clipPoly.transform (rState.mapModeTransform); + updateClipping (clipPoly, rFactoryParms, false); + + break; + } + case EmfPlusRecordTypeSetClipRegion: { + EMFP_DEBUG (printf ("EMF+ SetClipRegion\n")); + EMFP_DEBUG (printf ("EMF+\tregion in slot: %d combine mode: %d\n", flags & 0xff, (flags & 0xff00) >> 8)); + EMFPRegion& region = *(EMFPRegion*) aObjects [flags & 0xff]; + + // reset clip + if (region.parts == 0 && region.initialState == EmfPlusRegionInitialStateInfinite) { + updateClipping (::basegfx::B2DPolyPolygon (), rFactoryParms, false); + } else { + EMFP_DEBUG (printf ("EMF+\tTODO\n")); + } + break; + } + case EmfPlusRecordTypeDrawDriverString: { + EMFP_DEBUG (printf ("EMF+ DrawDriverString, flags: 0x%04x\n", flags)); + sal_uInt32 brushIndexOrColor; + sal_uInt32 optionFlags; + sal_uInt32 hasMatrix; + sal_uInt32 glyphsCount; + + rMF >> brushIndexOrColor >> optionFlags >> hasMatrix >> glyphsCount; + + EMFP_DEBUG (printf ("EMF+\t%s: 0x%08x\n", (flags & 0x8000) ? "color" : "brush index", brushIndexOrColor)); + EMFP_DEBUG (printf ("EMF+\toption flags: 0x%08x\n", optionFlags)); + EMFP_DEBUG (printf ("EMF+\thas matrix: %d\n", hasMatrix)); + EMFP_DEBUG (printf ("EMF+\tglyphs: %d\n", glyphsCount)); + + if( ( optionFlags & 1 ) && glyphsCount > 0 ) { + sal_uInt16 *chars = new sal_uInt16[glyphsCount]; + float *charsPosX = new float[glyphsCount]; + float *charsPosY = new float[glyphsCount]; + + for( sal_uInt32 i=0; i<glyphsCount; i++) { + rMF >> chars[i]; + EMFP_DEBUG (printf ("EMF+\tglyph[%d]: 0x%04x\n", + i, chars[i])); + } + for( sal_uInt32 i=0; i<glyphsCount; i++) { + rMF >> charsPosX[i] >> charsPosY[i]; + EMFP_DEBUG (printf ("EMF+\tglyphPosition[%d]: %f, %f\n", i, charsPosX[i], charsPosY[i])); + } + + XForm transform; + if( hasMatrix ) { + rMF >> transform; + EMFP_DEBUG (printf ("EMF+\tmatrix:: %f, %f, %f, %f, %f, %f\n", transform.eM11, transform.eM12, transform.eM21, transform.eM22, transform.eDx, transform.eDy)); + } + + // create and add the text action + XubString text( chars, glyphsCount ); + + EMFPFont *font = (EMFPFont*) aObjects[ flags & 0xff ]; + + rendering::FontRequest aFontRequest; + aFontRequest.FontDescription.FamilyName = font->family; + aFontRequest.CellSize = (rState.mapModeTransform*MapSize( font->emSize, 0 )).getX(); + rState.xFont = rFactoryParms.mrCanvas->getUNOCanvas()->createFont( aFontRequest, + uno::Sequence< beans::PropertyValue >(), + geometry::Matrix2D() ); + if( flags & 0x8000 ) + SET_TEXT_COLOR(brushIndexOrColor); + + ActionSharedPtr pTextAction( + TextActionFactory::createTextAction( + ::vcl::unotools::pointFromB2DPoint ( Map( charsPosX[0], charsPosY[0] ) ), + ::Size(), + ::Color(), + ::Size(), + ::Color(), + text, + 0, + glyphsCount, + NULL, + rFactoryParms.mrVDev, + rFactoryParms.mrCanvas, + rState, + rFactoryParms.mrParms, + false ) ); + + if( pTextAction ) + { + EMFP_DEBUG (printf ("EMF+\t\tadd text action\n")); + + maActions.push_back( + MtfAction( + pTextAction, + rFactoryParms.mrCurrActionIndex ) ); + + rFactoryParms.mrCurrActionIndex += pTextAction->getActionCount()-1; + } + + delete[] chars; + delete[] charsPosX; + delete[] charsPosY; + } else { + EMFP_DEBUG (printf ("EMF+\tTODO: fonts (non-unicode glyphs chars)\n")); + } + + break; + } + default: + EMFP_DEBUG (printf ("EMF+ unhandled record type: %d\n", type)); + EMFP_DEBUG (printf ("EMF+\tTODO\n")); + } + + rMF.Seek (next); + + length -= size; + } + } + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |