/************************************************************** * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_filter.hxx" #include "svgfontexport.hxx" #include "svgwriter.hxx" #include // ----------- // - statics - // ----------- static const char aXMLElemG[] = "g"; static const char aXMLElemDefs[] = "defs"; static const char aXMLElemLine[] = "line"; static const char aXMLElemRect[] = "rect"; static const char aXMLElemEllipse[] = "ellipse"; static const char aXMLElemPath[] = "path"; static const char aXMLElemPolygon[] = "polygon"; static const char aXMLElemPolyLine[] = "polyline"; static const char aXMLElemText[] = "text"; static const char aXMLElemTSpan[] = "tspan"; static const char aXMLElemImage[] = "image"; static const char aXMLElemLinearGradient[] = "linearGradient"; static const char aXMLElemRadialGradient[] = "radialGradient"; static const char aXMLElemStop[] = "stop"; // ----------------------------------------------------------------------------- static const char aXMLAttrTransform[] = "transform"; static const char aXMLAttrStyle[] = "style"; static const char aXMLAttrId[] = "id"; static const char aXMLAttrD[] = "d"; static const char aXMLAttrX[] = "x"; static const char aXMLAttrY[] = "y"; static const char aXMLAttrX1[] = "x1"; static const char aXMLAttrY1[] = "y1"; static const char aXMLAttrX2[] = "x2"; static const char aXMLAttrY2[] = "y2"; static const char aXMLAttrCX[] = "cx"; static const char aXMLAttrCY[] = "cy"; static const char aXMLAttrR[] = "r"; static const char aXMLAttrRX[] = "rx"; static const char aXMLAttrRY[] = "ry"; static const char aXMLAttrWidth[] = "width"; static const char aXMLAttrHeight[] = "height"; static const char aXMLAttrPoints[] = "points"; static const char aXMLAttrStroke[] = "stroke"; static const char aXMLAttrStrokeOpacity[] = "stroke-opacity"; static const char aXMLAttrStrokeWidth[] = "stroke-width"; static const char aXMLAttrStrokeDashArray[] = "stroke-dasharray"; static const char aXMLAttrFill[] = "fill"; static const char aXMLAttrFillOpacity[] = "fill-opacity"; static const char aXMLAttrFontFamily[] = "font-family"; static const char aXMLAttrFontSize[] = "font-size"; static const char aXMLAttrFontStyle[] = "font-style"; static const char aXMLAttrFontWeight[] = "font-weight"; static const char aXMLAttrTextDecoration[] = "text-decoration"; static const char aXMLAttrXLinkHRef[] = "xlink:href"; static const char aXMLAttrGradientUnits[] = "gradientUnits"; static const char aXMLAttrOffset[] = "offset"; static const char aXMLAttrStopColor[] = "stop-color"; // added support for LineJoin and LineCap static const char aXMLAttrStrokeLinejoin[] = "stroke-linejoin"; static const char aXMLAttrStrokeLinecap[] = "stroke-linecap"; // ----------------------------------------------------------------------------- static const sal_Unicode pBase64[] = { //0 1 2 3 4 5 6 7 'A','B','C','D','E','F','G','H', // 0 'I','J','K','L','M','N','O','P', // 1 'Q','R','S','T','U','V','W','X', // 2 'Y','Z','a','b','c','d','e','f', // 3 'g','h','i','j','k','l','m','n', // 4 'o','p','q','r','s','t','u','v', // 5 'w','x','y','z','0','1','2','3', // 6 '4','5','6','7','8','9','+','/' // 7 }; // ---------------------- // - SVGAttributeWriter - // ---------------------- SVGAttributeWriter::SVGAttributeWriter( SVGExport& rExport, SVGFontExport& rFontExport ) : mrExport( rExport ), mrFontExport( rFontExport ), mpElemFont( NULL ), mpElemPaint( NULL ) { } // ----------------------------------------------------------------------------- SVGAttributeWriter::~SVGAttributeWriter() { delete mpElemPaint; delete mpElemFont; } // ----------------------------------------------------------------------------- double SVGAttributeWriter::ImplRound( double fValue, sal_Int32 nDecs ) { return( floor( fValue * pow( 10.0, (int)nDecs ) + 0.5 ) / pow( 10.0, (int)nDecs ) ); } // ----------------------------------------------------------------------------- void SVGAttributeWriter::ImplGetColorStr( const Color& rColor, ::rtl::OUString& rColorStr ) { if( rColor.GetTransparency() == 255 ) rColorStr = B2UCONST( "none" ); else { rColorStr = B2UCONST( "rgb(" ); rColorStr += ::rtl::OUString::valueOf( static_cast< sal_Int32 >( rColor.GetRed() ) ); rColorStr += B2UCONST( "," ); rColorStr += ::rtl::OUString::valueOf( static_cast< sal_Int32 >( rColor.GetGreen() ) ); rColorStr += B2UCONST( "," ); rColorStr += ::rtl::OUString::valueOf( static_cast< sal_Int32 >( rColor.GetBlue() ) ); rColorStr += B2UCONST( ")" ); } } // ----------------------------------------------------------------------------- void SVGAttributeWriter::AddColorAttr( const char* pColorAttrName, const char* pColorOpacityAttrName, const Color& rColor ) { ::rtl::OUString aColor, aColorOpacity; ImplGetColorStr( rColor, aColor ); if( rColor.GetTransparency() > 0 && rColor.GetTransparency() < 255 ) aColorOpacity = ::rtl::OUString::valueOf( ImplRound( ( 255.0 - rColor.GetTransparency() ) / 255.0 ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, pColorAttrName, aColor ); if( aColorOpacity.getLength() && mrExport.IsUseOpacity() ) mrExport.AddAttribute( XML_NAMESPACE_NONE, pColorOpacityAttrName, aColorOpacity ); } // ----------------------------------------------------------------------------- void SVGAttributeWriter::AddPaintAttr( const Color& rLineColor, const Color& rFillColor, const Rectangle* pObjBoundRect, const Gradient* pFillGradient ) { // Fill if( pObjBoundRect && pFillGradient ) { ::rtl::OUString aGradientId; AddGradientDef( *pObjBoundRect, *pFillGradient, aGradientId ); if( aGradientId.getLength() ) { ::rtl::OUString aGradientURL( B2UCONST( "url(#" ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrFill, ( aGradientURL += aGradientId ) += B2UCONST( ")" ) ); } } else AddColorAttr( aXMLAttrFill, aXMLAttrFillOpacity, rFillColor ); // Stroke AddColorAttr( aXMLAttrStroke, aXMLAttrStrokeOpacity, rLineColor ); } // ----------------------------------------------------------------------------- void SVGAttributeWriter::AddGradientDef( const Rectangle& rObjRect, const Gradient& rGradient, ::rtl::OUString& rGradientId ) { if( rObjRect.GetWidth() && rObjRect.GetHeight() && ( rGradient.GetStyle() == GRADIENT_LINEAR || rGradient.GetStyle() == GRADIENT_AXIAL || rGradient.GetStyle() == GRADIENT_RADIAL || rGradient.GetStyle() == GRADIENT_ELLIPTICAL ) ) { SvXMLElementExport aDesc( mrExport, XML_NAMESPACE_NONE, aXMLElemDefs, sal_True, sal_True ); Color aStartColor( rGradient.GetStartColor() ), aEndColor( rGradient.GetEndColor() ); sal_uInt16 nAngle = rGradient.GetAngle() % 3600; Point aObjRectCenter( rObjRect.Center() ); Polygon aPoly( rObjRect ); static sal_Int32 nCurGradientId = 1; aPoly.Rotate( aObjRectCenter, nAngle ); Rectangle aRect( aPoly.GetBoundRect() ); // adjust start/end colors with intensities aStartColor.SetRed( (sal_uInt8)( ( (long) aStartColor.GetRed() * rGradient.GetStartIntensity() ) / 100 ) ); aStartColor.SetGreen( (sal_uInt8)( ( (long) aStartColor.GetGreen() * rGradient.GetStartIntensity() ) / 100 ) ); aStartColor.SetBlue( (sal_uInt8)( ( (long) aStartColor.GetBlue() * rGradient.GetStartIntensity() ) / 100 ) ); aEndColor.SetRed( (sal_uInt8)( ( (long) aEndColor.GetRed() * rGradient.GetEndIntensity() ) / 100 ) ); aEndColor.SetGreen( (sal_uInt8)( ( (long) aEndColor.GetGreen() * rGradient.GetEndIntensity() ) / 100 ) ); aEndColor.SetBlue( (sal_uInt8)( ( (long) aEndColor.GetBlue() * rGradient.GetEndIntensity() ) / 100 ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrId, ( rGradientId = B2UCONST( "Gradient_" ) ) += ::rtl::OUString::valueOf( nCurGradientId++ ) ); { ::std::auto_ptr< SvXMLElementExport > apGradient; ::rtl::OUString aColorStr; if( rGradient.GetStyle() == GRADIENT_LINEAR || rGradient.GetStyle() == GRADIENT_AXIAL ) { Polygon aLinePoly( 2 ); aLinePoly[ 0 ] = Point( aObjRectCenter.X(), aRect.Top() ); aLinePoly[ 1 ] = Point( aObjRectCenter.X(), aRect.Bottom() ); aLinePoly.Rotate( aObjRectCenter, nAngle ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrGradientUnits, B2UCONST( "userSpaceOnUse" ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrX1, ::rtl::OUString::valueOf( aLinePoly[ 0 ].X() ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrY1, ::rtl::OUString::valueOf( aLinePoly[ 0 ].Y() ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrX2, ::rtl::OUString::valueOf( aLinePoly[ 1 ].X() ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrY2, ::rtl::OUString::valueOf( aLinePoly[ 1 ].Y() ) ); apGradient.reset( new SvXMLElementExport( mrExport, XML_NAMESPACE_NONE, aXMLElemLinearGradient, sal_True, sal_True ) ); // write stop values double fBorder = static_cast< double >( rGradient.GetBorder() ) * ( ( rGradient.GetStyle() == GRADIENT_AXIAL ) ? 0.005 : 0.01 ); ImplGetColorStr( ( rGradient.GetStyle() == GRADIENT_AXIAL ) ? aEndColor : aStartColor, aColorStr ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrOffset, ::rtl::OUString::valueOf( fBorder ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStopColor, aColorStr ); { SvXMLElementExport aDesc2( mrExport, XML_NAMESPACE_NONE, aXMLElemStop, sal_True, sal_True ); } if( rGradient.GetStyle() == GRADIENT_AXIAL ) { ImplGetColorStr( aStartColor, aColorStr ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrOffset, ::rtl::OUString::valueOf( 0.5 ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStopColor, aColorStr ); { SvXMLElementExport aDesc3( mrExport, XML_NAMESPACE_NONE, aXMLElemStop, sal_True, sal_True ); } } if( rGradient.GetStyle() != GRADIENT_AXIAL ) fBorder = 0.0; ImplGetColorStr( aEndColor, aColorStr ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrOffset, ::rtl::OUString::valueOf( ImplRound( 1.0 - fBorder ) ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStopColor, aColorStr ); { SvXMLElementExport aDesc4( mrExport, XML_NAMESPACE_NONE, aXMLElemStop, sal_True, sal_True ); } } else { const double fCenterX = rObjRect.Left() + rObjRect.GetWidth() * rGradient.GetOfsX() * 0.01; const double fCenterY = rObjRect.Top() + rObjRect.GetHeight() * rGradient.GetOfsY() * 0.01; const double fRadius = sqrt( static_cast< double >( rObjRect.GetWidth() ) * rObjRect.GetWidth() + rObjRect.GetHeight() * rObjRect.GetHeight() ) * 0.5; mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrGradientUnits, B2UCONST( "userSpaceOnUse" ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrCX, ::rtl::OUString::valueOf( ImplRound( fCenterX ) ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrCY, ::rtl::OUString::valueOf( ImplRound( fCenterY ) ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrR, ::rtl::OUString::valueOf( ImplRound( fRadius ) ) ); apGradient.reset( new SvXMLElementExport( mrExport, XML_NAMESPACE_NONE, aXMLElemRadialGradient, sal_True, sal_True ) ); // write stop values ImplGetColorStr( aEndColor, aColorStr ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrOffset, ::rtl::OUString::valueOf( 0.0 ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStopColor, aColorStr ); { SvXMLElementExport aDesc5( mrExport, XML_NAMESPACE_NONE, aXMLElemStop, sal_True, sal_True ); } ImplGetColorStr( aStartColor, aColorStr ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrOffset, ::rtl::OUString::valueOf( ImplRound( 1.0 - rGradient.GetBorder() * 0.01 ) ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStopColor, aColorStr ); { SvXMLElementExport aDesc6( mrExport, XML_NAMESPACE_NONE, aXMLElemStop, sal_True, sal_True ); } } } } else rGradientId = ::rtl::OUString(); } // ----------------------------------------------------------------------------- void SVGAttributeWriter::SetFontAttr( const Font& rFont ) { if( !mpElemFont || ( rFont != maCurFont ) ) { ::rtl::OUString aFontStyle, aFontWeight, aTextDecoration; sal_Int32 nFontWeight; delete mpElemPaint, mpElemPaint = NULL; delete mpElemFont; maCurFont = rFont; // Font Family mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrFontFamily, mrFontExport.GetMappedFontName( rFont.GetName() ) ); // Font Size mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrFontSize, ::rtl::OUString::valueOf( rFont.GetHeight() ) ); // Font Style if( rFont.GetItalic() != ITALIC_NONE ) { if( rFont.GetItalic() == ITALIC_OBLIQUE ) aFontStyle = B2UCONST( "oblique" ); else aFontStyle = B2UCONST( "italic" ); } else aFontStyle = B2UCONST( "normal" ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrFontStyle, aFontStyle ); // Font Weight switch( rFont.GetWeight() ) { case WEIGHT_THIN: nFontWeight = 100; break; case WEIGHT_ULTRALIGHT: nFontWeight = 200; break; case WEIGHT_LIGHT: nFontWeight = 300; break; case WEIGHT_SEMILIGHT: nFontWeight = 400; break; case WEIGHT_NORMAL: nFontWeight = 400; break; case WEIGHT_MEDIUM: nFontWeight = 500; break; case WEIGHT_SEMIBOLD: nFontWeight = 600; break; case WEIGHT_BOLD: nFontWeight = 700; break; case WEIGHT_ULTRABOLD: nFontWeight = 800; break; case WEIGHT_BLACK: nFontWeight = 900; break; default: nFontWeight = 400; break; } mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrFontWeight, ::rtl::OUString::valueOf( nFontWeight ) ); if( mrExport.IsUseNativeTextDecoration() ) { if( rFont.GetUnderline() != UNDERLINE_NONE || rFont.GetStrikeout() != STRIKEOUT_NONE ) { if( rFont.GetUnderline() != UNDERLINE_NONE ) aTextDecoration = B2UCONST( "underline " ); if( rFont.GetStrikeout() != STRIKEOUT_NONE ) aTextDecoration += B2UCONST( "line-through " ); } else aTextDecoration = B2UCONST( "none" ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrTextDecoration, aTextDecoration ); } mpElemFont = new SvXMLElementExport( mrExport, XML_NAMESPACE_NONE, aXMLElemG, sal_True, sal_True ); } } // ------------------- // - SVGActionWriter - // ------------------- SVGActionWriter::SVGActionWriter( SVGExport& rExport, SVGFontExport& rFontExport ) : mrExport( rExport ), mrFontExport( rFontExport ), mpContext( NULL ), mnInnerMtfCount( 0 ), mbClipAttrChanged( sal_False ) { mpVDev = new VirtualDevice; mpVDev->EnableOutput( sal_False ); maTargetMapMode = MAP_100TH_MM; } // ----------------------------------------------------------------------------- SVGActionWriter::~SVGActionWriter() { DBG_ASSERT( !mpContext, "Not all contexts are closed" ); delete mpVDev; } // ----------------------------------------------------------------------------- long SVGActionWriter::ImplMap( sal_Int32 nVal ) const { Size aSz( nVal, nVal ); return( ImplMap( aSz, aSz ).Width() ); } // ----------------------------------------------------------------------------- Point& SVGActionWriter::ImplMap( const Point& rPt, Point& rDstPt ) const { return( rDstPt = mpVDev->LogicToLogic( rPt, mpVDev->GetMapMode(), maTargetMapMode ) ); } // ----------------------------------------------------------------------------- Size& SVGActionWriter::ImplMap( const Size& rSz, Size& rDstSz ) const { return( rDstSz = mpVDev->LogicToLogic( rSz, mpVDev->GetMapMode(), maTargetMapMode ) ); } // ----------------------------------------------------------------------------- Rectangle& SVGActionWriter::ImplMap( const Rectangle& rRect, Rectangle& rDstRect ) const { Point aTL( rRect.TopLeft() ); Size aSz( rRect.GetSize() ); return( rDstRect = Rectangle( ImplMap( aTL, aTL ), ImplMap( aSz, aSz ) ) ); } // ----------------------------------------------------------------------------- Polygon& SVGActionWriter::ImplMap( const Polygon& rPoly, Polygon& rDstPoly ) const { rDstPoly = Polygon( rPoly.GetSize() ); for( sal_uInt16 i = 0, nSize = rPoly.GetSize(); i < nSize; ++i ) { ImplMap( rPoly[ i ], rDstPoly[ i ] ); rDstPoly.SetFlags( i, rPoly.GetFlags( i ) ); } return( rDstPoly ); } // ----------------------------------------------------------------------------- PolyPolygon& SVGActionWriter::ImplMap( const PolyPolygon& rPolyPoly, PolyPolygon& rDstPolyPoly ) const { Polygon aPoly; rDstPolyPoly = PolyPolygon(); for( sal_uInt16 i = 0, nCount = rPolyPoly.Count(); i < nCount; ++i ) { rDstPolyPoly.Insert( ImplMap( rPolyPoly[ i ], aPoly ) ); } return( rDstPolyPoly ); } // ----------------------------------------------------------------------------- ::rtl::OUString SVGActionWriter::GetPathString( const PolyPolygon& rPolyPoly, sal_Bool bLine ) { ::rtl::OUString aPathData; const ::rtl::OUString aBlank( B2UCONST( " " ) ); const ::rtl::OUString aComma( B2UCONST( "," ) ); Point aPolyPoint; for( long i = 0, nCount = rPolyPoly.Count(); i < nCount; i++ ) { const Polygon& rPoly = rPolyPoly[ (sal_uInt16) i ]; sal_uInt16 n = 1, nSize = rPoly.GetSize(); if( nSize > 1 ) { aPathData += B2UCONST( "M " ); aPathData += ::rtl::OUString::valueOf( ( aPolyPoint = rPoly[ 0 ] ).X() ); aPathData += aComma; aPathData += ::rtl::OUString::valueOf( aPolyPoint.Y() ); sal_Char nCurrentMode = 0; const bool bClose(!bLine || rPoly[0] == rPoly[nSize - 1]); while( n < nSize ) { aPathData += aBlank; if ( ( rPoly.GetFlags( n ) == POLY_CONTROL ) && ( ( n + 2 ) < nSize ) ) { if ( nCurrentMode != 'C' ) { nCurrentMode = 'C'; aPathData += B2UCONST( "C " ); } for ( int j = 0; j < 3; j++ ) { if ( j ) aPathData += aBlank; aPathData += ::rtl::OUString::valueOf( ( aPolyPoint = rPoly[ n++ ] ).X() ); aPathData += aComma; aPathData += ::rtl::OUString::valueOf( aPolyPoint.Y() ); } } else { if ( nCurrentMode != 'L' ) { nCurrentMode = 'L'; aPathData += B2UCONST( "L " ); } aPathData += ::rtl::OUString::valueOf( ( aPolyPoint = rPoly[ n++ ] ).X() ); aPathData += aComma; aPathData += ::rtl::OUString::valueOf( aPolyPoint.Y() ); } } if(bClose) aPathData += B2UCONST( " Z" ); if( i < ( nCount - 1 ) ) aPathData += aBlank; } } return aPathData; } // ----------------------------------------------------------------------------- void SVGActionWriter::ImplWriteLine( const Point& rPt1, const Point& rPt2, const Color* pLineColor, sal_Bool bApplyMapping ) { Point aPt1, aPt2; if( bApplyMapping ) { ImplMap( rPt1, aPt1 ); ImplMap( rPt2, aPt2 ); } else { aPt1 = rPt1; aPt2 = rPt2; } mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrX1, ::rtl::OUString::valueOf( aPt1.X() ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrY1, ::rtl::OUString::valueOf( aPt1.Y() ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrX2, ::rtl::OUString::valueOf( aPt2.X() ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrY2, ::rtl::OUString::valueOf( aPt2.Y() ) ); if( pLineColor ) { // !!! mrExport.AddAttribute( XML_NAMESPACE_NONE, ... ) DBG_ERROR( "SVGActionWriter::ImplWriteLine: Line color not implemented" ); } { SvXMLElementExport aElem( mrExport, XML_NAMESPACE_NONE, aXMLElemLine, sal_True, sal_True ); } } // ----------------------------------------------------------------------------- void SVGActionWriter::ImplWriteRect( const Rectangle& rRect, long nRadX, long nRadY, sal_Bool bApplyMapping ) { Rectangle aRect; if( bApplyMapping ) ImplMap( rRect, aRect ); else aRect = rRect; mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrX, ::rtl::OUString::valueOf( aRect.Left() ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrY, ::rtl::OUString::valueOf( aRect.Top() ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrWidth, ::rtl::OUString::valueOf( aRect.GetWidth() ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrHeight, ::rtl::OUString::valueOf( aRect.GetHeight() ) ); if( nRadX ) mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrRX, ::rtl::OUString::valueOf( bApplyMapping ? ImplMap( nRadX ) : nRadX ) ); if( nRadY ) mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrRY, ::rtl::OUString::valueOf( bApplyMapping ? ImplMap( nRadY ) : nRadY ) ); { SvXMLElementExport aElem( mrExport, XML_NAMESPACE_NONE, aXMLElemRect, sal_True, sal_True ); } } // ----------------------------------------------------------------------------- void SVGActionWriter::ImplWriteEllipse( const Point& rCenter, long nRadX, long nRadY, sal_Bool bApplyMapping ) { Point aCenter; if( bApplyMapping ) ImplMap( rCenter, aCenter ); else aCenter = rCenter; mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrCX, ::rtl::OUString::valueOf( aCenter.X() ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrCY, ::rtl::OUString::valueOf( aCenter.Y() ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrRX, ::rtl::OUString::valueOf( bApplyMapping ? ImplMap( nRadX ) : nRadX ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrRY, ::rtl::OUString::valueOf( bApplyMapping ? ImplMap( nRadY ) : nRadY ) ); { SvXMLElementExport aElem( mrExport, XML_NAMESPACE_NONE, aXMLElemEllipse, sal_True, sal_True ); } } // ----------------------------------------------------------------------------- void SVGActionWriter::ImplWritePolyPolygon( const PolyPolygon& rPolyPoly, sal_Bool bLineOnly, sal_Bool bApplyMapping ) { PolyPolygon aPolyPoly; if( bApplyMapping ) ImplMap( rPolyPoly, aPolyPoly ); else aPolyPoly = rPolyPoly; if( mrExport.hasClip() ) { const ::basegfx::B2DPolyPolygon aB2DPolyPoly( ::basegfx::tools::correctOrientations( aPolyPoly.getB2DPolyPolygon() ) ); aPolyPoly = PolyPolygon( ::basegfx::tools::clipPolyPolygonOnPolyPolygon( *mrExport.getCurClip(), aB2DPolyPoly, sal_False, sal_False ) ); } // add path data attribute mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrD, GetPathString( aPolyPoly, bLineOnly ) ); { // write polyline/polygon element SvXMLElementExport aElem( mrExport, XML_NAMESPACE_NONE, aXMLElemPath, sal_True, sal_True ); } } // ----------------------------------------------------------------------------- void SVGActionWriter::ImplWriteShape( const SVGShapeDescriptor& rShape, sal_Bool bApplyMapping ) { PolyPolygon aPolyPoly; if( bApplyMapping ) ImplMap( rShape.maShapePolyPoly, aPolyPoly ); else aPolyPoly = rShape.maShapePolyPoly; const sal_Bool bLineOnly = ( rShape.maShapeFillColor == Color( COL_TRANSPARENT ) ) && ( !rShape.mapShapeGradient.get() ); Rectangle aBoundRect( aPolyPoly.GetBoundRect() ); mpContext->AddPaintAttr( rShape.maShapeLineColor, rShape.maShapeFillColor, &aBoundRect, rShape.mapShapeGradient.get() ); if( rShape.maId.getLength() ) mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrId, rShape.maId ); if( rShape.mnStrokeWidth ) { sal_Int32 nStrokeWidth = ( bApplyMapping ? ImplMap( rShape.mnStrokeWidth ) : rShape.mnStrokeWidth ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStrokeWidth, ::rtl::OUString::valueOf( nStrokeWidth ) ); } // support for LineJoin switch(rShape.maLineJoin) { default: // B2DLINEJOIN_NONE, B2DLINEJOIN_MIDDLE case basegfx::B2DLINEJOIN_MITER: { // miter is Svg default, so no need to write until the exporter might write styles. // If this happens, activate here // mrExport.AddAttribute(XML_NAMESPACE_NONE, aXMLAttrStrokeLinejoin, ::rtl::OUString::createFromAscii("miter")); break; } case basegfx::B2DLINEJOIN_BEVEL: { mrExport.AddAttribute(XML_NAMESPACE_NONE, aXMLAttrStrokeLinejoin, ::rtl::OUString::createFromAscii("bevel")); break; } case basegfx::B2DLINEJOIN_ROUND: { mrExport.AddAttribute(XML_NAMESPACE_NONE, aXMLAttrStrokeLinejoin, ::rtl::OUString::createFromAscii("round")); break; } } // support for LineCap switch(rShape.maLineCap) { default: /* com::sun::star::drawing::LineCap_BUTT */ { // butt is Svg default, so no need to write until the exporter might write styles. // If this happens, activate here // mrExport.AddAttribute(XML_NAMESPACE_NONE, aXMLAttrStrokeLinecap, ::rtl::OUString::createFromAscii("butt")); break; } case com::sun::star::drawing::LineCap_ROUND: { mrExport.AddAttribute(XML_NAMESPACE_NONE, aXMLAttrStrokeLinecap, ::rtl::OUString::createFromAscii("round")); break; } case com::sun::star::drawing::LineCap_SQUARE: { mrExport.AddAttribute(XML_NAMESPACE_NONE, aXMLAttrStrokeLinecap, ::rtl::OUString::createFromAscii("square")); break; } } if( rShape.maDashArray.size() ) { const ::rtl::OUString aComma( B2UCONST( "," ) ); ::rtl::OUString aDashArrayStr; for( unsigned int k = 0; k < rShape.maDashArray.size(); ++k ) { const sal_Int32 nDash = ( bApplyMapping ? ImplMap( FRound( rShape.maDashArray[ k ] ) ) : FRound( rShape.maDashArray[ k ] ) ); if( k ) aDashArrayStr += aComma; aDashArrayStr += ::rtl::OUString::valueOf( nDash ); } mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStrokeDashArray, aDashArrayStr ); } ImplWritePolyPolygon( aPolyPoly, bLineOnly, sal_False ); } // ----------------------------------------------------------------------------- void SVGActionWriter::ImplWriteGradientEx( const PolyPolygon& rPolyPoly, const Gradient& rGradient, sal_uInt32 nWriteFlags, sal_Bool bApplyMapping ) { PolyPolygon aPolyPoly; if( bApplyMapping ) ImplMap( rPolyPoly, aPolyPoly ); else aPolyPoly = rPolyPoly; if( rGradient.GetStyle() == GRADIENT_LINEAR || rGradient.GetStyle() == GRADIENT_AXIAL || rGradient.GetStyle() == GRADIENT_RADIAL || rGradient.GetStyle() == GRADIENT_ELLIPTICAL ) { SVGShapeDescriptor aShapeDesc; aShapeDesc.maShapePolyPoly = aPolyPoly; aShapeDesc.mapShapeGradient.reset( new Gradient( rGradient ) ); ImplWriteShape( aShapeDesc, sal_False ); } else { GDIMetaFile aTmpMtf; mrExport.pushClip( aPolyPoly.getB2DPolyPolygon() ); mpVDev->AddGradientActions( rPolyPoly.GetBoundRect(), rGradient, aTmpMtf ); ++mnInnerMtfCount; ImplWriteActions( aTmpMtf, nWriteFlags, NULL ); --mnInnerMtfCount; mrExport.popClip(); } } // ----------------------------------------------------------------------------- void SVGActionWriter::ImplWriteText( const Point& rPos, const String& rText, const sal_Int32* pDXArray, long nWidth, sal_Bool bApplyMapping ) { sal_Int32 nLen = rText.Len(), i; Size aNormSize; ::std::auto_ptr< sal_Int32 > apTmpArray; ::std::auto_ptr< SvXMLElementExport > apTransform; sal_Int32* pDX; Point aPos; Point aBaseLinePos( rPos ); const FontMetric aMetric( mpVDev->GetFontMetric() ); const Font& rFont = mpVDev->GetFont(); if( rFont.GetAlign() == ALIGN_TOP ) aBaseLinePos.Y() += aMetric.GetAscent(); else if( rFont.GetAlign() == ALIGN_BOTTOM ) aBaseLinePos.Y() -= aMetric.GetDescent(); if( bApplyMapping ) ImplMap( rPos, aPos ); else aPos = rPos; // get text sizes if( pDXArray ) { aNormSize = Size( mpVDev->GetTextWidth( rText ), 0 ); pDX = const_cast< sal_Int32* >( pDXArray ); } else { apTmpArray.reset( new sal_Int32[ nLen ] ); aNormSize = Size( mpVDev->GetTextArray( rText, apTmpArray.get() ), 0 ); pDX = apTmpArray.get(); } // if text is rotated, set transform matrix at new g element if( rFont.GetOrientation() ) { Point aRot( aPos ); String aTransform; aTransform = String( ::rtl::OUString::createFromAscii( "translate" ) ); aTransform += '('; aTransform += String( ::rtl::OUString::valueOf( aRot.X() ) ); aTransform += ','; aTransform += String( ::rtl::OUString::valueOf( aRot.Y() ) ); aTransform += ')'; aTransform += String( ::rtl::OUString::createFromAscii( " rotate" ) ); aTransform += '('; aTransform += String( ::rtl::OUString::valueOf( rFont.GetOrientation() * -0.1 ) ); aTransform += ')'; aTransform += String( ::rtl::OUString::createFromAscii( " translate" ) ); aTransform += '('; aTransform += String( ::rtl::OUString::valueOf( -aRot.X() ) ); aTransform += ','; aTransform += String( ::rtl::OUString::valueOf( -aRot.Y() ) ); aTransform += ')'; mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrTransform, aTransform ); apTransform.reset( new SvXMLElementExport( mrExport, XML_NAMESPACE_NONE, aXMLElemG, sal_True, sal_True ) ); } if( nLen > 1 ) { ::com::sun::star::uno::Reference< ::com::sun::star::i18n::XBreakIterator > xBI( ::vcl::unohelper::CreateBreakIterator() ); const ::com::sun::star::lang::Locale& rLocale = Application::GetSettings().GetLocale(); sal_Int32 nCurPos = 0, nLastPos = 0, nX = aPos.X(); if ( mrExport.IsUseTSpans() ) { mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrX, ::rtl::OUString::valueOf( aPos.X() ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrY, ::rtl::OUString::valueOf( aPos.Y() ) ); SvXMLElementExport aElem( mrExport, XML_NAMESPACE_NONE, aXMLElemText, sal_True, sal_False ); { rtl::OUString aString; for( sal_Bool bCont = sal_True; bCont; ) { sal_Int32 nCount = 1; const ::rtl::OUString aSpace( ' ' ); nLastPos = nCurPos; nCurPos = xBI->nextCharacters( rText, nCurPos, rLocale, ::com::sun::star::i18n::CharacterIteratorMode::SKIPCELL, nCount, nCount ); nCount = nCurPos - nLastPos; bCont = ( nCurPos < rText.Len() ) && nCount; if( nCount ) { aString += rtl::OUString::valueOf( nX ); if( bCont ) { sal_Int32 nWidth = pDX[ nCurPos - 1 ]; if ( bApplyMapping ) nWidth = ImplMap( nWidth ); nX = aPos.X() + nWidth; aString += aSpace; } } } mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrX, aString ); SvXMLElementExport aElem( mrExport, XML_NAMESPACE_NONE, aXMLElemTSpan, sal_True, sal_False ); mrExport.GetDocHandler()->characters( rText ); } } else { aNormSize.Width() = pDX[ nLen - 2 ] + mpVDev->GetTextWidth( rText.GetChar( nLen - 1 ) ); if( nWidth && aNormSize.Width() && ( nWidth != aNormSize.Width() ) ) { const double fFactor = (double) nWidth / aNormSize.Width(); for( i = 0; i < ( nLen - 1 ); i++ ) pDX[ i ] = FRound( pDX[ i ] * fFactor ); } else { // write single glyphs at absolute text positions for( sal_Bool bCont = sal_True; bCont; ) { sal_Int32 nCount = 1; nLastPos = nCurPos; nCurPos = xBI->nextCharacters( rText, nCurPos, rLocale, ::com::sun::star::i18n::CharacterIteratorMode::SKIPCELL, nCount, nCount ); nCount = nCurPos - nLastPos; bCont = ( nCurPos < rText.Len() ) && nCount; if( nCount ) { const ::rtl::OUString aGlyph( rText.Copy( nLastPos, nCount ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrX, ::rtl::OUString::valueOf( nX ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrY, ::rtl::OUString::valueOf( aPos.Y() ) ); { SvXMLElementExport aElem( mrExport, XML_NAMESPACE_NONE, aXMLElemText, sal_True, sal_False ); mrExport.GetDocHandler()->characters( aGlyph ); } if( bCont ) { // #118796# do NOT access pDXArray, it may be zero (!) sal_Int32 nWidth = pDX[ nCurPos - 1 ]; if ( bApplyMapping ) nWidth = ImplMap( nWidth ); nX = aPos.X() + nWidth; } } } } } } else { mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrX, ::rtl::OUString::valueOf( aPos.X() ) ); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrY, ::rtl::OUString::valueOf( aPos.Y() ) ); { SvXMLElementExport aElem( mrExport, XML_NAMESPACE_NONE, aXMLElemText, sal_True, sal_False ); mrExport.GetDocHandler()->characters( rText ); } } if( !mrExport.IsUseNativeTextDecoration() ) { if( rFont.GetStrikeout() != STRIKEOUT_NONE || rFont.GetUnderline() != UNDERLINE_NONE ) { Polygon aPoly( 4 ); const long nLineHeight = Max( (long) FRound( aMetric.GetLineHeight() * 0.05 ), (long) 1 ); if( rFont.GetStrikeout() ) { const long nYLinePos = aBaseLinePos.Y() - FRound( aMetric.GetAscent() * 0.26 ); aPoly[ 0 ].X() = aBaseLinePos.X(); aPoly[ 0 ].Y() = nYLinePos - ( nLineHeight >> 1 ); aPoly[ 1 ].X() = aBaseLinePos.X() + aNormSize.Width() - 1; aPoly[ 1 ].Y() = aPoly[ 0 ].Y(); aPoly[ 2 ].X() = aPoly[ 1 ].X(); aPoly[ 2 ].Y() = aPoly[ 0 ].Y() + nLineHeight - 1; aPoly[ 3 ].X() = aPoly[ 0 ].X(); aPoly[ 3 ].Y() = aPoly[ 2 ].Y(); ImplWritePolyPolygon( aPoly, sal_False ); } if( rFont.GetUnderline() ) { const long nYLinePos = aBaseLinePos.Y() + ( nLineHeight << 1 ); aPoly[ 0 ].X() = aBaseLinePos.X(); aPoly[ 0 ].Y() = nYLinePos - ( nLineHeight >> 1 ); aPoly[ 1 ].X() = aBaseLinePos.X() + aNormSize.Width() - 1; aPoly[ 1 ].Y() = aPoly[ 0 ].Y(); aPoly[ 2 ].X() = aPoly[ 1 ].X(); aPoly[ 2 ].Y() = aPoly[ 0 ].Y() + nLineHeight - 1; aPoly[ 3 ].X() = aPoly[ 0 ].X(); aPoly[ 3 ].Y() = aPoly[ 2 ].Y(); ImplWritePolyPolygon( aPoly, sal_False ); } } } } // ----------------------------------------------------------------------------- void SVGActionWriter::ImplWriteBmp( const BitmapEx& rBmpEx, const Point& rPt, const Size& rSz, const Point& rSrcPt, const Size& rSrcSz, sal_Bool bApplyMapping ) { if( !!rBmpEx ) { BitmapEx aBmpEx( rBmpEx ); Point aPoint = Point(); const Rectangle aBmpRect( aPoint, rBmpEx.GetSizePixel() ); const Rectangle aSrcRect( rSrcPt, rSrcSz ); if( aSrcRect != aBmpRect ) aBmpEx.Crop( aSrcRect ); if( !!aBmpEx ) { SvMemoryStream aOStm( 65535, 65535 ); if( GraphicConverter::Export( aOStm, rBmpEx, CVT_PNG ) == ERRCODE_NONE ) { Point aPt; Size aSz; // #119735# Do not copy the stream data to a ::rtl::OUString any longer, this is not needed and // (of course) throws many exceptions with the used RTL_TEXTENCODING_ASCII_US. Keeping that line // to show what I'm talking about // ::rtl::OUString aImageData( (sal_Char*) aOStm.GetData(), aOStm.Tell(), RTL_TEXTENCODING_ASCII_US ); const sal_Char* pImageData = (sal_Char*)aOStm.GetData(); const sal_uInt32 nImageDataLength = aOStm.Tell(); REF( NMSP_SAX::XExtendedDocumentHandler ) xExtDocHandler( mrExport.GetDocHandler(), NMSP_UNO::UNO_QUERY ); if( bApplyMapping ) { ImplMap( rPt, aPt ); ImplMap( rSz, aSz ); } else { aPt = rPt; aSz = rSz; } const Rectangle aRect( aPt, aSz ); if( mrExport.IsVisible( aRect ) && xExtDocHandler.is() ) { static const sal_uInt32 nPartLen = 64; const ::rtl::OUString aSpace( ' ' ); const ::rtl::OUString aLineFeed( ::rtl::OUString::valueOf( (sal_Unicode) 0x0a ) ); ::rtl::OUString aString; aString = aLineFeed; aString += B2UCONST( "<" ); aString += ::rtl::OUString::createFromAscii( aXMLElemImage ); aString += aSpace; aString += ::rtl::OUString::createFromAscii( aXMLAttrX ); aString += B2UCONST( "=\"" ); aString += ::rtl::OUString::valueOf( aPt.X() ); aString += B2UCONST( "\" " ); aString += ::rtl::OUString::createFromAscii( aXMLAttrY ); aString += B2UCONST( "=\"" ); aString += ::rtl::OUString::valueOf( aPt.Y() ); aString += B2UCONST( "\" " ); aString += ::rtl::OUString::createFromAscii( aXMLAttrWidth ); aString += B2UCONST( "=\"" ); aString += ::rtl::OUString::valueOf( aSz.Width() ); aString += B2UCONST( "\" " ); aString += ::rtl::OUString::createFromAscii( aXMLAttrHeight ); aString += B2UCONST( "=\"" ); aString += ::rtl::OUString::valueOf( aSz.Height() ); aString += B2UCONST( "\" " ); aString += ::rtl::OUString::createFromAscii( aXMLAttrXLinkHRef ); aString += B2UCONST( "=\"data:image/png;base64," ); xExtDocHandler->unknown( aString ); // #119735# const sal_uInt32 nQuadCount = nImageDataLength / 3; const sal_uInt32 nRest = nImageDataLength % 3; if( nQuadCount || nRest ) { sal_Int32 nBufLen = ( ( nQuadCount + ( nRest ? 1 : 0 ) ) << 2 ); const sal_Char* pSrc = pImageData; sal_Unicode* pBuffer = new sal_Unicode[ nBufLen * sizeof( sal_Unicode ) ]; sal_Unicode* pTmpDst = pBuffer; for( sal_uInt32 i = 0; i < nQuadCount; ++i ) { const sal_Int32 nA = *pSrc++; const sal_Int32 nB = *pSrc++; const sal_Int32 nC = *pSrc++; *pTmpDst++ = pBase64[ ( nA >> 2 ) & 0x3f ]; *pTmpDst++ = pBase64[ ( ( nA << 4 ) & 0x30 ) + ( ( nB >> 4 ) & 0xf ) ]; *pTmpDst++ = pBase64[ ( ( nB << 2 ) & 0x3c ) + ( ( nC >> 6 ) & 0x3 ) ]; *pTmpDst++ = pBase64[ nC & 0x3f ]; } if( nRest ) { const sal_Int32 nA = *pSrc++; *pTmpDst++ = pBase64[ ( nA >> 2 ) & 0x3f ]; if( 2 == nRest ) { const sal_Int32 nB = *pSrc; *pTmpDst++ = pBase64[ ( ( nA << 4 ) & 0x30 ) + ( ( nB >> 4 ) & 0xf ) ]; *pTmpDst++ = pBase64[ ( nB << 2 ) & 0x3c ]; } else { *pTmpDst++ = pBase64[ ( nA << 4 ) & 0x30 ]; *pTmpDst++ = '='; } *pTmpDst = '='; } for( sal_Int32 nCurPos = 0; nCurPos < nBufLen; nCurPos += nPartLen ) { const ::rtl::OUString aPart( pBuffer + nCurPos, ::std::min< sal_Int32 >( nPartLen, nBufLen - nCurPos ) ); xExtDocHandler->unknown( aLineFeed ); xExtDocHandler->unknown( aPart ); } delete[] pBuffer; } xExtDocHandler->unknown( B2UCONST( "\"/>" ) ); } } } } } // ----------------------------------------------------------------------------- void SVGActionWriter::ImplWriteActions( const GDIMetaFile& rMtf, sal_uInt32 nWriteFlags, const ::rtl::OUString* pElementId ) { // need a counter fo rthe actions written per shape to avoid double ID // generation sal_Int32 nEntryCount(0); if( mnInnerMtfCount ) nWriteFlags |= SVGWRITER_NO_SHAPE_COMMENTS; for( sal_uLong nCurAction = 0, nCount = rMtf.GetActionCount(); nCurAction < nCount; nCurAction++ ) { const MetaAction* pAction = rMtf.GetAction( nCurAction ); const sal_uInt16 nType = pAction->GetType(); switch( nType ) { case( META_PIXEL_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_FILL ) { const MetaPixelAction* pA = (const MetaPixelAction*) pAction; mpContext->AddPaintAttr( pA->GetColor(), pA->GetColor() ); ImplWriteLine( pA->GetPoint(), pA->GetPoint(), &pA->GetColor() ); } } break; case( META_POINT_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_FILL ) { const MetaPointAction* pA = (const MetaPointAction*) pAction; mpContext->AddPaintAttr( mpVDev->GetLineColor(), mpVDev->GetLineColor() ); ImplWriteLine( pA->GetPoint(), pA->GetPoint(), NULL ); } } break; case( META_LINE_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_FILL ) { const MetaLineAction* pA = (const MetaLineAction*) pAction; mpContext->AddPaintAttr( mpVDev->GetLineColor(), mpVDev->GetLineColor() ); ImplWriteLine( pA->GetStartPoint(), pA->GetEndPoint(), NULL ); } } break; case( META_RECT_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_FILL ) { mpContext->AddPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() ); ImplWriteRect( ( (const MetaRectAction*) pAction )->GetRect(), 0, 0 ); } } break; case( META_ROUNDRECT_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_FILL ) { const MetaRoundRectAction* pA = (const MetaRoundRectAction*) pAction; mpContext->AddPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() ); ImplWriteRect( pA->GetRect(), pA->GetHorzRound(), pA->GetVertRound() ); } } break; case( META_ELLIPSE_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_FILL ) { const MetaEllipseAction* pA = (const MetaEllipseAction*) pAction; const Rectangle& rRect = pA->GetRect(); mpContext->AddPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() ); ImplWriteEllipse( rRect.Center(), rRect.GetWidth() >> 1, rRect.GetHeight() >> 1 ); } } break; case( META_ARC_ACTION ): case( META_PIE_ACTION ): case( META_CHORD_ACTION ): case( META_POLYGON_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_FILL ) { Polygon aPoly; switch( nType ) { case( META_ARC_ACTION ): { const MetaArcAction* pA = (const MetaArcAction*) pAction; aPoly = Polygon( pA->GetRect(), pA->GetStartPoint(), pA->GetEndPoint(), POLY_ARC ); } break; case( META_PIE_ACTION ): { const MetaPieAction* pA = (const MetaPieAction*) pAction; aPoly = Polygon( pA->GetRect(), pA->GetStartPoint(), pA->GetEndPoint(), POLY_PIE ); } break; case( META_CHORD_ACTION ): { const MetaChordAction* pA = (const MetaChordAction*) pAction; aPoly = Polygon( pA->GetRect(), pA->GetStartPoint(), pA->GetEndPoint(), POLY_CHORD ); } break; case( META_POLYGON_ACTION ): aPoly = ( (const MetaPolygonAction*) pAction )->GetPolygon(); break; } if( aPoly.GetSize() ) { mpContext->AddPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() ); ImplWritePolyPolygon( aPoly, sal_False ); } } } break; case( META_POLYLINE_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_FILL ) { const MetaPolyLineAction* pA = (const MetaPolyLineAction*) pAction; const Polygon& rPoly = pA->GetPolygon(); if( rPoly.GetSize() ) { const LineInfo& rLineInfo = pA->GetLineInfo(); if(rLineInfo.GetWidth()) { sal_Int32 nStrokeWidth = ImplMap(rLineInfo.GetWidth()); mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStrokeWidth, ::rtl::OUString::valueOf( nStrokeWidth ) ); } mpContext->AddPaintAttr( mpVDev->GetLineColor(), Color( COL_TRANSPARENT ) ); ImplWritePolyPolygon( rPoly, sal_True ); } } } break; case( META_POLYPOLYGON_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_FILL ) { const MetaPolyPolygonAction* pA = (const MetaPolyPolygonAction*) pAction; const PolyPolygon& rPolyPoly = pA->GetPolyPolygon(); if( rPolyPoly.Count() ) { mpContext->AddPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() ); ImplWritePolyPolygon( rPolyPoly, sal_False ); } } } break; case( META_GRADIENT_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_FILL ) { const MetaGradientAction* pA = (const MetaGradientAction*) pAction; const Polygon aRectPoly( pA->GetRect() ); const PolyPolygon aRectPolyPoly( aRectPoly ); ImplWriteGradientEx( aRectPolyPoly, pA->GetGradient(), nWriteFlags ); } } break; case( META_GRADIENTEX_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_FILL ) { const MetaGradientExAction* pA = (const MetaGradientExAction*) pAction; ImplWriteGradientEx( pA->GetPolyPolygon(), pA->GetGradient(), nWriteFlags ); } } break; case META_HATCH_ACTION: { if( nWriteFlags & SVGWRITER_WRITE_FILL ) { const MetaHatchAction* pA = (const MetaHatchAction*) pAction; GDIMetaFile aTmpMtf; mpVDev->AddHatchActions( pA->GetPolyPolygon(), pA->GetHatch(), aTmpMtf ); ++mnInnerMtfCount; ImplWriteActions( aTmpMtf, nWriteFlags, NULL ); --mnInnerMtfCount; } } break; case( META_TRANSPARENT_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_FILL ) { const MetaTransparentAction* pA = (const MetaTransparentAction*) pAction; const PolyPolygon& rPolyPoly = pA->GetPolyPolygon(); if( rPolyPoly.Count() ) { Color aNewLineColor( mpVDev->GetLineColor() ), aNewFillColor( mpVDev->GetFillColor() ); aNewLineColor.SetTransparency( sal::static_int_cast( FRound( pA->GetTransparence() * 2.55 ) ) ); aNewFillColor.SetTransparency( sal::static_int_cast( FRound( pA->GetTransparence() * 2.55 ) ) ); mpContext->AddPaintAttr( aNewLineColor, aNewFillColor ); ImplWritePolyPolygon( rPolyPoly, sal_False ); } } } break; case( META_FLOATTRANSPARENT_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_FILL ) { const MetaFloatTransparentAction* pA = (const MetaFloatTransparentAction*) pAction; GDIMetaFile aTmpMtf( pA->GetGDIMetaFile() ); Point aSrcPt( aTmpMtf.GetPrefMapMode().GetOrigin() ); const Size aSrcSize( aTmpMtf.GetPrefSize() ); const Point aDestPt( pA->GetPoint() ); const Size aDestSize( pA->GetSize() ); const double fScaleX = aSrcSize.Width() ? (double) aDestSize.Width() / aSrcSize.Width() : 1.0; const double fScaleY = aSrcSize.Height() ? (double) aDestSize.Height() / aSrcSize.Height() : 1.0; long nMoveX, nMoveY; if( fScaleX != 1.0 || fScaleY != 1.0 ) { aTmpMtf.Scale( fScaleX, fScaleY ); aSrcPt.X() = FRound( aSrcPt.X() * fScaleX ), aSrcPt.Y() = FRound( aSrcPt.Y() * fScaleY ); } nMoveX = aDestPt.X() - aSrcPt.X(), nMoveY = aDestPt.Y() - aSrcPt.Y(); if( nMoveX || nMoveY ) aTmpMtf.Move( nMoveX, nMoveY ); mpVDev->Push(); ++mnInnerMtfCount; ImplWriteActions( aTmpMtf, nWriteFlags, NULL ); --mnInnerMtfCount; mpVDev->Pop(); } } break; case( META_EPS_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_FILL ) { const MetaEPSAction* pA = (const MetaEPSAction*) pAction; const GDIMetaFile aGDIMetaFile( pA->GetSubstitute() ); sal_Bool bFound = sal_False; for( sal_uInt32 k = 0, nCount2 = aGDIMetaFile.GetActionCount(); ( k < nCount2 ) && !bFound; ++k ) { const MetaAction* pSubstAct = aGDIMetaFile.GetAction( k ); if( pSubstAct->GetType() == META_BMPSCALE_ACTION ) { bFound = sal_True; const MetaBmpScaleAction* pBmpScaleAction = (const MetaBmpScaleAction*) pSubstAct; ImplWriteBmp( pBmpScaleAction->GetBitmap(), pA->GetPoint(), pA->GetSize(), Point(), pBmpScaleAction->GetBitmap().GetSizePixel() ); } } } } break; case( META_COMMENT_ACTION ): { const MetaCommentAction* pA = (const MetaCommentAction*) pAction; String aSkipComment; if( ( pA->GetComment().CompareIgnoreCaseToAscii( "XGRAD_SEQ_BEGIN" ) == COMPARE_EQUAL ) && ( nWriteFlags & SVGWRITER_WRITE_FILL ) ) { const MetaGradientExAction* pGradAction = NULL; sal_Bool bDone = sal_False; while( !bDone && ( ++nCurAction < nCount ) ) { pAction = rMtf.GetAction( nCurAction ); if( pAction->GetType() == META_GRADIENTEX_ACTION ) pGradAction = (const MetaGradientExAction*) pAction; else if( ( pAction->GetType() == META_COMMENT_ACTION ) && ( ( (const MetaCommentAction*) pAction )->GetComment(). CompareIgnoreCaseToAscii( "XGRAD_SEQ_END" ) == COMPARE_EQUAL ) ) { bDone = sal_True; } } if( pGradAction ) ImplWriteGradientEx( pGradAction->GetPolyPolygon(), pGradAction->GetGradient(), nWriteFlags ); } else if( ( pA->GetComment().CompareIgnoreCaseToAscii( "XPATHFILL_SEQ_BEGIN" ) == COMPARE_EQUAL ) && ( nWriteFlags & SVGWRITER_WRITE_FILL ) && !( nWriteFlags & SVGWRITER_NO_SHAPE_COMMENTS ) && pA->GetDataSize() ) { // write open shape in every case if( mapCurShape.get() ) { ImplWriteShape( *mapCurShape ); mapCurShape.reset(); } SvMemoryStream aMemStm( (void*) pA->GetData(), pA->GetDataSize(), STREAM_READ ); SvtGraphicFill aFill; aMemStm >> aFill; sal_Bool bGradient = SvtGraphicFill::fillGradient == aFill.getFillType() && ( SvtGraphicFill::gradientLinear == aFill.getGradientType() || SvtGraphicFill::gradientRadial == aFill.getGradientType() ); sal_Bool bSkip = ( SvtGraphicFill::fillSolid == aFill.getFillType() || bGradient ); if( bSkip ) { PolyPolygon aShapePolyPoly; aFill.getPath( aShapePolyPoly ); if( aShapePolyPoly.Count() ) { mapCurShape.reset( new SVGShapeDescriptor ); if( pElementId ) { mapCurShape->maId = *pElementId + B2UCONST("_") + ::rtl::OUString::valueOf(nEntryCount++); } mapCurShape->maShapePolyPoly = aShapePolyPoly; mapCurShape->maShapeFillColor = aFill.getFillColor(); mapCurShape->maShapeFillColor.SetTransparency( (sal_uInt8) FRound( 255.0 * aFill.getTransparency() ) ); if( bGradient ) { // step through following actions until the first Gradient/GradientEx action is found while( !mapCurShape->mapShapeGradient.get() && bSkip && ( ++nCurAction < nCount ) ) { pAction = rMtf.GetAction( nCurAction ); if( ( pAction->GetType() == META_COMMENT_ACTION ) && ( ( (const MetaCommentAction*) pAction )->GetComment(). CompareIgnoreCaseToAscii( "XPATHFILL_SEQ_END" ) == COMPARE_EQUAL ) ) { bSkip = sal_False; } else if( pAction->GetType() == META_GRADIENTEX_ACTION ) { mapCurShape->mapShapeGradient.reset( new Gradient( static_cast< const MetaGradientExAction* >( pAction )->GetGradient() ) ); } else if( pAction->GetType() == META_GRADIENT_ACTION ) { mapCurShape->mapShapeGradient.reset( new Gradient( static_cast< const MetaGradientAction* >( pAction )->GetGradient() ) ); } } } } else bSkip = sal_False; } // skip rest of comment while( bSkip && ( ++nCurAction < nCount ) ) { pAction = rMtf.GetAction( nCurAction ); if( ( pAction->GetType() == META_COMMENT_ACTION ) && ( ( (const MetaCommentAction*) pAction )->GetComment(). CompareIgnoreCaseToAscii( "XPATHFILL_SEQ_END" ) == COMPARE_EQUAL ) ) { bSkip = sal_False; } } } else if( ( pA->GetComment().CompareIgnoreCaseToAscii( "XPATHSTROKE_SEQ_BEGIN" ) == COMPARE_EQUAL ) && ( nWriteFlags & SVGWRITER_WRITE_FILL ) && !( nWriteFlags & SVGWRITER_NO_SHAPE_COMMENTS ) && pA->GetDataSize() ) { SvMemoryStream aMemStm( (void*) pA->GetData(), pA->GetDataSize(), STREAM_READ ); SvtGraphicStroke aStroke; PolyPolygon aStartArrow, aEndArrow; aMemStm >> aStroke; aStroke.getStartArrow( aStartArrow ); aStroke.getEndArrow( aEndArrow ); // Currently no support for strokes with start/end arrow(s) // added that support Polygon aPoly; aStroke.getPath(aPoly); if(mapCurShape.get()) { if(1 != mapCurShape->maShapePolyPoly.Count() || !mapCurShape->maShapePolyPoly[0].IsEqual(aPoly)) { // this path action is not covering the same path than the already existing // fill polypolygon, so write out the fill polygon ImplWriteShape( *mapCurShape ); mapCurShape.reset(); } } if( !mapCurShape.get() ) { mapCurShape.reset( new SVGShapeDescriptor ); if( pElementId ) { mapCurShape->maId = *pElementId + B2UCONST("_") + ::rtl::OUString::valueOf(nEntryCount++); } mapCurShape->maShapePolyPoly = aPoly; } mapCurShape->maShapeLineColor = mpVDev->GetLineColor(); mapCurShape->maShapeLineColor.SetTransparency( (sal_uInt8) FRound( aStroke.getTransparency() * 255.0 ) ); mapCurShape->mnStrokeWidth = FRound( aStroke.getStrokeWidth() ); aStroke.getDashArray( mapCurShape->maDashArray ); // added support for LineJoin switch(aStroke.getJoinType()) { default: /* SvtGraphicStroke::joinMiter, SvtGraphicStroke::joinNone */ { mapCurShape->maLineJoin = basegfx::B2DLINEJOIN_MITER; break; } case SvtGraphicStroke::joinRound: { mapCurShape->maLineJoin = basegfx::B2DLINEJOIN_ROUND; break; } case SvtGraphicStroke::joinBevel: { mapCurShape->maLineJoin = basegfx::B2DLINEJOIN_BEVEL; break; } } // added support for LineCap switch(aStroke.getCapType()) { default: /* SvtGraphicStroke::capButt */ { mapCurShape->maLineCap = com::sun::star::drawing::LineCap_BUTT; break; } case SvtGraphicStroke::capRound: { mapCurShape->maLineCap = com::sun::star::drawing::LineCap_ROUND; break; } case SvtGraphicStroke::capSquare: { mapCurShape->maLineCap = com::sun::star::drawing::LineCap_SQUARE; break; } } if(mapCurShape.get() &&(aStartArrow.Count() || aEndArrow.Count())) { ImplWriteShape( *mapCurShape ); mapCurShape->maShapeFillColor = mapCurShape->maShapeLineColor; mapCurShape->maShapeLineColor = Color(COL_TRANSPARENT); mapCurShape->mnStrokeWidth = 0; mapCurShape->maDashArray.clear(); mapCurShape->maLineJoin = basegfx::B2DLINEJOIN_MITER; mapCurShape->maLineCap = com::sun::star::drawing::LineCap_BUTT; if(aStartArrow.Count()) { mapCurShape->maShapePolyPoly = aStartArrow; if( pElementId ) // #i124825# pElementId is optional, may be zero { mapCurShape->maId = *pElementId + B2UCONST("_") + ::rtl::OUString::valueOf(nEntryCount++); } ImplWriteShape( *mapCurShape ); } if(aEndArrow.Count()) { mapCurShape->maShapePolyPoly = aEndArrow; if( pElementId ) // #i124825# pElementId is optional, may be zero { mapCurShape->maId = *pElementId + B2UCONST("_") + ::rtl::OUString::valueOf(nEntryCount++); } ImplWriteShape( *mapCurShape ); } mapCurShape.reset(); } // write open shape in every case if( mapCurShape.get() ) { ImplWriteShape( *mapCurShape ); mapCurShape.reset(); } // skip rest of comment sal_Bool bSkip = true; while( bSkip && ( ++nCurAction < nCount ) ) { pAction = rMtf.GetAction( nCurAction ); if( ( pAction->GetType() == META_COMMENT_ACTION ) && ( ( (const MetaCommentAction*) pAction )->GetComment(). CompareIgnoreCaseToAscii( "XPATHSTROKE_SEQ_END" ) == COMPARE_EQUAL ) ) { bSkip = sal_False; } } } } break; case( META_BMP_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_FILL ) { const MetaBmpAction* pA = (const MetaBmpAction*) pAction; ImplWriteBmp( pA->GetBitmap(), pA->GetPoint(), mpVDev->PixelToLogic( pA->GetBitmap().GetSizePixel() ), Point(), pA->GetBitmap().GetSizePixel() ); } } break; case( META_BMPSCALE_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_FILL ) { const MetaBmpScaleAction* pA = (const MetaBmpScaleAction*) pAction; ImplWriteBmp( pA->GetBitmap(), pA->GetPoint(), pA->GetSize(), Point(), pA->GetBitmap().GetSizePixel() ); } } break; case( META_BMPSCALEPART_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_FILL ) { const MetaBmpScalePartAction* pA = (const MetaBmpScalePartAction*) pAction; ImplWriteBmp( pA->GetBitmap(), pA->GetDestPoint(), pA->GetDestSize(), pA->GetSrcPoint(), pA->GetSrcSize() ); } } break; case( META_BMPEX_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_FILL ) { const MetaBmpExAction* pA = (const MetaBmpExAction*) pAction; ImplWriteBmp( pA->GetBitmapEx(), pA->GetPoint(), mpVDev->PixelToLogic( pA->GetBitmapEx().GetSizePixel() ), Point(), pA->GetBitmapEx().GetSizePixel() ); } } break; case( META_BMPEXSCALE_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_FILL ) { const MetaBmpExScaleAction* pA = (const MetaBmpExScaleAction*) pAction; ImplWriteBmp( pA->GetBitmapEx(), pA->GetPoint(), pA->GetSize(), Point(), pA->GetBitmapEx().GetSizePixel() ); } } break; case( META_BMPEXSCALEPART_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_FILL ) { const MetaBmpExScalePartAction* pA = (const MetaBmpExScalePartAction*) pAction; ImplWriteBmp( pA->GetBitmapEx(), pA->GetDestPoint(), pA->GetDestSize(), pA->GetSrcPoint(), pA->GetSrcSize() ); } } break; case( META_TEXT_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_TEXT ) { const MetaTextAction* pA = (const MetaTextAction*) pAction; const String aText( pA->GetText(), pA->GetIndex(), pA->GetLen() ); if( aText.Len() ) { Font aFont( mpVDev->GetFont() ); Size aSz; ImplMap( Size( 0, aFont.GetHeight() ), aSz ); aFont.SetHeight( aSz.Height() ); mpContext->AddPaintAttr( COL_TRANSPARENT, mpVDev->GetTextColor() ); mpContext->SetFontAttr( aFont ); ImplWriteText( pA->GetPoint(), aText, NULL, 0 ); } } } break; case( META_TEXTRECT_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_TEXT ) { const MetaTextRectAction* pA = (const MetaTextRectAction*) pAction; if( pA->GetText().Len() ) { Font aFont( mpVDev->GetFont() ); Size aSz; ImplMap( Size( 0, aFont.GetHeight() ), aSz ); aFont.SetHeight( aSz.Height() ); mpContext->AddPaintAttr( COL_TRANSPARENT, mpVDev->GetTextColor() ); mpContext->SetFontAttr( aFont ); ImplWriteText( pA->GetRect().TopLeft(), pA->GetText(), NULL, 0 ); } } } break; case( META_TEXTARRAY_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_TEXT ) { const MetaTextArrayAction* pA = (const MetaTextArrayAction*) pAction; const String aText( pA->GetText(), pA->GetIndex(), pA->GetLen() ); if( aText.Len() ) { Font aFont( mpVDev->GetFont() ); Size aSz; ImplMap( Size( 0, aFont.GetHeight() ), aSz ); aFont.SetHeight( aSz.Height() ); mpContext->AddPaintAttr( COL_TRANSPARENT, mpVDev->GetTextColor() ); mpContext->SetFontAttr( aFont ); ImplWriteText( pA->GetPoint(), aText, pA->GetDXArray(), 0 ); } } } break; case( META_STRETCHTEXT_ACTION ): { if( nWriteFlags & SVGWRITER_WRITE_TEXT ) { const MetaStretchTextAction* pA = (const MetaStretchTextAction*) pAction; const String aText( pA->GetText(), pA->GetIndex(), pA->GetLen() ); if( aText.Len() ) { Font aFont( mpVDev->GetFont() ); Size aSz; ImplMap( Size( 0, aFont.GetHeight() ), aSz ); aFont.SetHeight( aSz.Height() ); mpContext->AddPaintAttr( COL_TRANSPARENT, mpVDev->GetTextColor() ); mpContext->SetFontAttr( aFont ); ImplWriteText( pA->GetPoint(), aText, NULL, pA->GetWidth() ); } } } break; case( META_CLIPREGION_ACTION ): case( META_ISECTRECTCLIPREGION_ACTION ): case( META_ISECTREGIONCLIPREGION_ACTION ): case( META_MOVECLIPREGION_ACTION ): { ( (MetaAction*) pAction )->Execute( mpVDev ); mbClipAttrChanged = sal_True; } break; case( META_REFPOINT_ACTION ): case( META_MAPMODE_ACTION ): case( META_LINECOLOR_ACTION ): case( META_FILLCOLOR_ACTION ): case( META_TEXTLINECOLOR_ACTION ): case( META_TEXTFILLCOLOR_ACTION ): case( META_TEXTCOLOR_ACTION ): case( META_TEXTALIGN_ACTION ): case( META_FONT_ACTION ): case( META_PUSH_ACTION ): case( META_POP_ACTION ): case( META_LAYOUTMODE_ACTION ): { ( (MetaAction*) pAction )->Execute( mpVDev ); } break; case( META_RASTEROP_ACTION ): case( META_MASK_ACTION ): case( META_MASKSCALE_ACTION ): case( META_MASKSCALEPART_ACTION ): case( META_WALLPAPER_ACTION ): case( META_TEXTLINE_ACTION ): { // !!! >>> we don't want to support these actions } break; default: DBG_ERROR( "SVGActionWriter::ImplWriteActions: unsupported MetaAction #" ); break; } } } // ----------------------------------------------------------------------------- void SVGActionWriter::WriteMetaFile( const Point& rPos100thmm, const Size& rSize100thmm, const GDIMetaFile& rMtf, sal_uInt32 nWriteFlags, const ::rtl::OUString* pElementId ) { MapMode aMapMode( rMtf.GetPrefMapMode() ); Size aPrefSize( rMtf.GetPrefSize() ); Fraction aFractionX( aMapMode.GetScaleX() ); Fraction aFractionY( aMapMode.GetScaleY() ); mpVDev->Push(); Size aSize( OutputDevice::LogicToLogic( rSize100thmm, MAP_100TH_MM, aMapMode ) ); aMapMode.SetScaleX( aFractionX *= Fraction( aSize.Width(), aPrefSize.Width() ) ); aMapMode.SetScaleY( aFractionY *= Fraction( aSize.Height(), aPrefSize.Height() ) ); Point aOffset( OutputDevice::LogicToLogic( rPos100thmm, MAP_100TH_MM, aMapMode ) ); aMapMode.SetOrigin( aOffset += aMapMode.GetOrigin() ); mpVDev->SetMapMode( aMapMode ); ImplAcquireContext(); mapCurShape.reset(); ImplWriteActions( rMtf, nWriteFlags, pElementId ); // draw open shape that doesn't have a border if( mapCurShape.get() ) { ImplWriteShape( *mapCurShape ); mapCurShape.reset(); } ImplReleaseContext(); mpVDev->Pop(); } // ------------- // - SVGWriter - // ------------- SVGWriter::SVGWriter( const REF( NMSP_LANG::XMultiServiceFactory )& rxMgr ) : mxFact( rxMgr ) { } // ----------------------------------------------------------------------------- SVGWriter::~SVGWriter() { } // ----------------------------------------------------------------------------- ANY SAL_CALL SVGWriter::queryInterface( const NMSP_UNO::Type & rType ) throw( NMSP_UNO::RuntimeException ) { const ANY aRet( NMSP_CPPU::queryInterface( rType, static_cast< NMSP_SVG::XSVGWriter* >( this ), static_cast< NMSP_LANG::XInitialization* >( this ) ) ); return( aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType ) ); } // ----------------------------------------------------------------------------- void SAL_CALL SVGWriter::acquire() throw() { OWeakObject::acquire(); } // ----------------------------------------------------------------------------- void SAL_CALL SVGWriter::release() throw() { OWeakObject::release(); } // ----------------------------------------------------------------------------- void SAL_CALL SVGWriter::write( const REF( NMSP_SAX::XDocumentHandler )& rxDocHandler, const SEQ( sal_Int8 )& rMtfSeq ) throw( NMSP_UNO::RuntimeException ) { SvMemoryStream aMemStm( (char*) rMtfSeq.getConstArray(), rMtfSeq.getLength(), STREAM_READ ); GDIMetaFile aMtf; aMemStm.SetCompressMode( COMPRESSMODE_FULL ); aMemStm >> aMtf; const REF( NMSP_SAX::XDocumentHandler ) xDocumentHandler( rxDocHandler ); SVGExport* pWriter = new SVGExport( mxFact, xDocumentHandler, maFilterData ); pWriter->writeMtf( aMtf ); delete pWriter; } // ----------------------------------------------------------------------------- void SVGWriter::initialize( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& aArguments ) throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException) { if ( aArguments.getLength() == 1 ) { ::com::sun::star::uno::Any aArg = aArguments.getConstArray()[0]; aArg >>= maFilterData; } } // ----------------------------------------------------------------------------- #define SVG_WRITER_SERVICE_NAME "com.sun.star.svg.SVGWriter" #define SVG_WRITER_IMPLEMENTATION_NAME "com.sun.star.comp.Draw.SVGWriter" rtl::OUString SVGWriter_getImplementationName() throw (RuntimeException) { return rtl::OUString ( RTL_CONSTASCII_USTRINGPARAM( SVG_WRITER_IMPLEMENTATION_NAME ) ); } // ----------------------------------------------------------------------------- Sequence< sal_Int8 > SAL_CALL SVGWriter_getImplementationId() throw(RuntimeException) { static const ::cppu::OImplementationId aId; return( aId.getImplementationId() ); } // ----------------------------------------------------------------------------- Sequence< rtl::OUString > SAL_CALL SVGWriter_getSupportedServiceNames() throw (RuntimeException) { Sequence< rtl::OUString > aRet( 1 ); aRet.getArray()[ 0 ] = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( SVG_WRITER_SERVICE_NAME ) ); return aRet; } // ----------------------------------------------------------------------------- Reference< XInterface > SAL_CALL SVGWriter_createInstance( const Reference< XMultiServiceFactory > & rSMgr ) throw( Exception ) { return( static_cast< cppu::OWeakObject* >( new SVGWriter( rSMgr ) ) ); }