initial import

1 files changed, 1412 insertions, 0 deletions

diff --git a/extensions/source/svg/svgaction.cxx b/extensions/source/svg/svgaction.cxx
new file mode 100644
index 000000000000..45ba9ca1c6ec
--- /dev/null
+++ b/extensions/source/svg/svgaction.cxx
@@ -0,0 +1,1412 @@
+/*************************************************************************
+ *
+ *  $RCSfile: svgaction.cxx,v $
+ *
+ *  $Revision: 1.1.1.1 $
+ *
+ *  last change: $Author: hr $ $Date: 2000-09-18 16:16:53 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  This library 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 for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *  MA  02111-1307  USA
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (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.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+#include "svgaction.hxx"
+#include <vcl/virdev.hxx>
+#include <vcl/cvtgrf.hxx>
+#include <vcl/metric.hxx>
+
+// -----------
+// - Defines -
+// -----------
+
+// #define _SVG_WRITE_TSPAN
+// #define _SVG_WRITE_STRIKEOUT
+
+// -----------
+// - statics -
+// -----------
+
+static const char   aXMLElemSVG[] = "svg";
+static const char   aXMLElemG[] = "g";
+static const char   aXMLElemDefs[] = "defs";
+static const char   aXMLElemClipPath[] = "clipPath";
+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   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   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   aXMLAttrXLinkHRef[] = "xlink:href";
+
+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
+};
+
+// --------------
+// - FastString -
+// --------------
+
+FastString::FastString( sal_uInt32 nInitLen, sal_uInt32 nIncrement ) :
+    mnBufLen( nInitLen ),
+    mnCurLen( 0 ),
+    mnBufInc( nIncrement ),
+    mpBuffer( new sal_Unicode[ nInitLen * sizeof( sal_Unicode ) ] ),
+    mnPartPos( 0 )
+{
+    DBG_ASSERT( nInitLen, "invalid initial length" );
+    DBG_ASSERT( nIncrement, "invalid increment" );
+}
+
+// -----------------------------------------------------------------------------
+
+FastString::FastString( sal_Char* pBufferForBase64Encoding, sal_uInt32 nBufLen ) :
+    mnBufInc( 2048 ),
+    mnPartPos( 0 )
+{
+    DBG_ASSERT( pBufferForBase64Encoding && nBufLen, "invalid arguments" );
+
+    const sal_uInt32 nQuadCount = nBufLen / 3;
+    const sal_uInt32 nRest = nBufLen % 3;
+
+    if( nQuadCount || nRest )
+    {
+        mnBufLen = mnCurLen = ( ( nQuadCount + ( nRest ? 1 : 0 ) ) << 2 );
+        mpBuffer = new sal_Unicode[ mnBufLen * sizeof( sal_Unicode ) ];
+
+        sal_Char*       pTmpSrc = pBufferForBase64Encoding;
+        sal_Unicode*    pTmpDst = mpBuffer;
+
+        for( sal_uInt32 i = 0, nCharCount = 0; i < nQuadCount; i++ )
+        {
+            const sal_Int32 nA = *pTmpSrc++;
+            const sal_Int32 nB = *pTmpSrc++;
+            const sal_Int32 nC = *pTmpSrc++;
+
+            *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( 1 == nRest )
+        {
+            const sal_Int32 nA = *pTmpSrc;
+
+            *pTmpDst++ = pBase64[ ( nA >> 2 ) & 0x3f ];
+            *pTmpDst++ = pBase64[ ( nA << 4 ) & 0x30 ];
+            *pTmpDst++ = '=';
+            *pTmpDst = '=';
+        }
+        else if( 2 == nRest )
+        {
+            const sal_Int32 nA = *pTmpSrc++;
+            const sal_Int32 nB = *pTmpSrc;
+
+            *pTmpDst++ = pBase64[ ( nA >> 2 ) & 0x3f ];
+            *pTmpDst++ = pBase64[ ( ( nA << 4 ) & 0x30 ) + ( ( nB >> 4 ) & 0xf ) ];
+            *pTmpDst++ = pBase64[ ( nB << 2 ) & 0x3c ];
+            *pTmpDst = '=';
+        }
+    }
+    else
+    {
+        mpBuffer = new sal_Unicode[ ( mnBufLen = 1 ) * sizeof( sal_Unicode ) ];
+        mnCurLen = 0;
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+FastString::~FastString()
+{
+    delete[] mpBuffer;
+}
+
+// -----------------------------------------------------------------------------
+
+FastString& FastString::operator+=( const NMSP_RTL::OUString& rStr )
+{
+    if( rStr.getLength() )
+    {
+        if( ( mnCurLen + rStr.getLength() ) > mnBufLen )
+        {
+            const sal_uInt32    nNewBufLen = ( mnBufLen + ( ( ( mnCurLen + rStr.getLength() ) - mnBufLen ) / mnBufInc + 1 ) * mnBufInc );
+            sal_Unicode*        pNewBuffer = new sal_Unicode[ nNewBufLen * sizeof( sal_Unicode ) ];
+
+            HMEMCPY( pNewBuffer, mpBuffer, mnBufLen * sizeof( sal_Unicode )  );
+            delete[] mpBuffer;
+            mpBuffer = pNewBuffer;
+            mnBufLen = nNewBufLen;
+        }
+
+        HMEMCPY( mpBuffer + mnCurLen, rStr.getStr(), rStr.getLength() * sizeof( sal_Unicode ) );
+        mnCurLen += rStr.getLength();
+
+        if( maString.getLength() )
+            maString = NMSP_RTL::OUString();
+    }
+
+    return *this;
+}
+
+// -----------------------------------------------------------------------------
+
+const NMSP_RTL::OUString& FastString::GetString() const
+{
+    if( !maString.getLength() && mnCurLen )
+        ( (FastString*) this )->maString = NMSP_RTL::OUString( mpBuffer, mnCurLen );
+
+    return maString;
+}
+
+// -----------------------------------------------------------------------------
+
+sal_Bool FastString::GetFirstPartString( const sal_uInt32 nPartLen, NMSP_RTL::OUString& rPartString )
+{
+    const sal_uInt32 nLength = Min( mnCurLen, nPartLen );
+
+    mnPartPos = 0;
+
+    if( nLength )
+    {
+        rPartString = NMSP_RTL::OUString( mpBuffer, nLength );
+        mnPartPos = nLength;
+    }
+
+    return( rPartString.getLength() > 0 );
+}
+
+// -----------------------------------------------------------------------------
+
+sal_Bool FastString::GetNextPartString( const sal_uInt32 nPartLen, NMSP_RTL::OUString& rPartString )
+{
+    if( mnPartPos < mnCurLen )
+    {
+        const sal_uInt32 nLength = Min( mnCurLen - mnPartPos, nPartLen );
+        rPartString = NMSP_RTL::OUString( mpBuffer + mnPartPos, nLength );
+        mnPartPos += nLength;
+    }
+    else
+        rPartString = NMSP_RTL::OUString();
+
+    return( rPartString.getLength() > 0 );
+}
+
+// ----------------------
+// - SVGAttributeWriter -
+// ----------------------
+
+SVGAttributeWriter::SVGAttributeWriter( SVGActionWriter& rParent, SvXMLExport& rExport ) :
+    mrParent( rParent ),
+    mrExport( rExport ),
+    mpElemFont( NULL ),
+    mpElemPaint( NULL )
+{
+}
+
+// -----------------------------------------------------------------------------
+
+SVGAttributeWriter::~SVGAttributeWriter()
+{
+    delete mpElemPaint;
+    delete mpElemFont;
+}
+
+// -----------------------------------------------------------------------------
+
+NMSP_RTL::OUString SVGAttributeWriter::GetFontStyle( const Font& rFont )
+{
+    FastString aStyle;
+
+    // font family
+    aStyle += B2UCONST( "font-family:" );
+    aStyle += NMSP_RTL::OUString( UniString( rFont.GetName() ) );
+
+    // font size
+    const Size aFontSize( mrParent.GetVDev().LogicToLogic( Size( 0, rFont.GetHeight() ), mrParent.GetVDev().GetMapMode(), MAP_POINT ) );
+
+    aStyle += B2UCONST( ";" );
+    aStyle += B2UCONST( "font-size:" );
+    aStyle += NMSP_RTL::OUString::valueOf( aFontSize.Height() );
+
+    if( !mrParent.HasDoublePoints() )
+        aStyle += B2UCONST( "pt" );
+
+    // font style
+    if( rFont.GetItalic() != ITALIC_NONE )
+    {
+        aStyle += B2UCONST( ";" );
+        aStyle += B2UCONST( "font-style:" );
+
+        if( rFont.GetItalic() == ITALIC_OBLIQUE )
+            aStyle += B2UCONST( "oblique" );
+        else
+            aStyle += B2UCONST( "italic" );
+    }
+
+    // font weight
+    sal_Int32 nFontWeight;
+
+    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;
+    }
+
+    aStyle += B2UCONST( ";" );
+    aStyle += B2UCONST( "font-weight:" );
+    aStyle += NMSP_RTL::OUString::valueOf( nFontWeight );
+
+    // !!!
+    // font-variant
+    // font-stretch
+    // font-size-adjust
+
+#ifdef _SVG_WRITE_STRIKEOUT
+
+    if( rFont.GetUnderline() != UNDERLINE_NONE || rFont.GetStrikeout() != STRIKEOUT_NONE )
+    {
+        aStyle += B2UCONST( ";" );
+        aStyle += B2UCONST( "text-decoration:" );
+
+        if( rFont.GetUnderline() != UNDERLINE_NONE )
+            aStyle += B2UCONST( " underline" );
+
+        if( rFont.GetStrikeout() != STRIKEOUT_NONE )
+            aStyle += B2UCONST( " line-trough" );
+    }
+
+#else // _SVG_WRITE_STRIKEOUT
+
+    if( rFont.GetUnderline() != UNDERLINE_NONE )
+    {
+        aStyle += B2UCONST( ";" );
+        aStyle += B2UCONST( "text-decoration:" );
+        aStyle += B2UCONST( "underline" );
+    }
+
+#endif // _SVG_WRITE_STRIKEOUT
+
+    return aStyle.GetString();
+}
+
+// -----------------------------------------------------------------------------
+
+NMSP_RTL::OUString SVGAttributeWriter::GetPaintStyle( const Color& rLineColor, const Color& rFillColor )
+{
+    FastString aStyle;
+
+    // line color
+    aStyle += B2UCONST( "stroke:" );
+
+    if( rLineColor.GetTransparency() == 255 )
+        aStyle += B2UCONST( "none" );
+    else
+    {
+        // line color value in rgb
+        aStyle += B2UCONST( "rgb(" );
+        aStyle += NMSP_RTL::OUString::valueOf( (sal_Int32) rLineColor.GetRed() );
+        aStyle += B2UCONST( "," );
+        aStyle += NMSP_RTL::OUString::valueOf( (sal_Int32) rLineColor.GetGreen() );
+        aStyle += B2UCONST( "," );
+        aStyle += NMSP_RTL::OUString::valueOf( (sal_Int32) rLineColor.GetBlue() );
+        aStyle += B2UCONST( ")" );
+
+        // line color opacity in percent if neccessary
+        if( rLineColor.GetTransparency() )
+        {
+            aStyle += B2UCONST( ";" );
+            aStyle += B2UCONST( "stroke-opacity:" );
+            aStyle += NMSP_RTL::OUString::valueOf( (sal_Int32) ( ( 255 - (double) rLineColor.GetTransparency() ) / 2.55 ) );
+            aStyle += B2UCONST( "%" );
+        }
+    }
+
+    // fill color
+    aStyle += B2UCONST( ";" );
+    aStyle += B2UCONST( "fill:" );
+
+    if( rFillColor.GetTransparency() == 255 )
+        aStyle += B2UCONST( "none" );
+    else
+    {
+        // fill color value in rgb
+        aStyle += B2UCONST( "rgb(" );
+        aStyle += NMSP_RTL::OUString::valueOf( (sal_Int32) rFillColor.GetRed() );
+        aStyle += B2UCONST( "," );
+        aStyle += NMSP_RTL::OUString::valueOf( (sal_Int32) rFillColor.GetGreen() );
+        aStyle += B2UCONST( "," );
+        aStyle += NMSP_RTL::OUString::valueOf( (sal_Int32) rFillColor.GetBlue() );
+        aStyle += B2UCONST( ")" );
+
+        // fill color opacity in percent if neccessary
+        if( rFillColor.GetTransparency() )
+        {
+            aStyle += B2UCONST( ";" );
+            aStyle += B2UCONST( "fill-opacity:" );
+            aStyle += NMSP_RTL::OUString::valueOf( (sal_Int32) ( ( 255 - (double) rFillColor.GetTransparency() ) / 2.55 ) );
+            aStyle += B2UCONST( "%" );
+        }
+    }
+
+    return aStyle.GetString();
+}
+
+// -----------------------------------------------------------------------------
+
+void SVGAttributeWriter::SetFontAttr( const Font& rFont )
+{
+    if( !mpElemFont || ( rFont != maCurFont ) )
+    {
+        delete mpElemPaint, mpElemPaint = NULL;
+        delete mpElemFont;
+        mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStyle, GetFontStyle( maCurFont = rFont ) );
+        mpElemFont = new SvXMLElementExport( mrExport, XML_NAMESPACE_NONE, aXMLElemG, TRUE, TRUE );
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+void SVGAttributeWriter::SetPaintAttr( const Color& rLineColor, const Color& rFillColor )
+{
+    if( !mpElemPaint || ( rLineColor != maCurLineColor ) || ( rFillColor != maCurFillColor ) )
+    {
+        delete mpElemPaint;
+        mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStyle, GetPaintStyle( maCurLineColor = rLineColor, maCurFillColor = rFillColor ) );
+        mpElemPaint = new SvXMLElementExport( mrExport, XML_NAMESPACE_NONE, aXMLElemG, TRUE, TRUE );
+    }
+}
+
+// -------------------
+// - SVGActionWriter -
+// -------------------
+
+SVGActionWriter::SVGActionWriter( SvXMLExport& rExport, const GDIMetaFile& rMtf,
+                                  VirtualDevice* pParentVDev, sal_Bool bWriteDoublePoints ) :
+    mrExport( rExport ),
+    mrMtf( rMtf ),
+    mpContext( NULL ),
+    mbClipAttrChanged( sal_False ),
+    mnCurClipId( 1 ),
+    mbDoublePoints( bWriteDoublePoints )
+{
+    if( pParentVDev )
+    {
+        mpVDev = pParentVDev;
+        mbDestroyVDev = sal_False;
+        maTargetMapMode = mpVDev->GetMapMode();
+    }
+    else
+    {
+        mpVDev = new VirtualDevice;
+        mpVDev->EnableOutput( sal_False );
+        mbDestroyVDev = sal_True;
+        maTargetMapMode = MAP_100TH_MM;
+    }
+
+    mpVDev->Push();
+    mpVDev->SetMapMode( mrMtf.GetPrefMapMode() );
+    ImplWriteActions( mrMtf );
+    mpVDev->Pop();
+}
+
+// -----------------------------------------------------------------------------
+
+SVGActionWriter::~SVGActionWriter()
+{
+    DBG_ASSERT( !mpContext, "Not all contexts are closed" );
+
+    if( mbDestroyVDev )
+        delete mpVDev;
+}
+
+// -----------------------------------------------------------------------------
+
+long SVGActionWriter::ImplMap( sal_Int32 nVal ) const
+{
+    return ImplMap( Size( nVal, nVal ) ).Width();
+}
+
+// -----------------------------------------------------------------------------
+
+Point SVGActionWriter::ImplMap( const Point& rPt ) const
+{
+    return mpVDev->LogicToLogic( rPt, mpVDev->GetMapMode(), maTargetMapMode );
+}
+
+// -----------------------------------------------------------------------------
+
+Size SVGActionWriter::ImplMap( const Size& rSz ) const
+{
+    return mpVDev->LogicToLogic( rSz, mpVDev->GetMapMode(), maTargetMapMode );
+}
+
+// -----------------------------------------------------------------------------
+
+NMSP_RTL::OUString SVGActionWriter::GetValueString( sal_Int32 nVal, sal_Bool bDoublePoints )
+{
+    if( !bDoublePoints )
+        return NMSP_RTL::OUString::valueOf( nVal );
+    else
+    {
+        const double    fPoints = nVal * 72.0 / 2540.0;
+        const sal_Int32 nInt = (sal_Int32) fPoints;
+
+        return( ( NMSP_RTL::OUString::valueOf( nInt ) +=
+                NMSP_RTL::OUString::valueOf( (sal_Unicode) '.' ) ) +=
+                NMSP_RTL::OUString::valueOf( labs( (sal_Int32) ( ( fPoints - nInt ) * 100.0 ) ) ) );
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+void SVGActionWriter::ImplWriteLine( const Point& rPt1, const Point& rPt2, const Color* pLineColor,
+                                     const NMSP_RTL::OUString* pStyle )
+{
+    const Point aPt1( ImplMap( rPt1 ) );
+    const Point aPt2( ImplMap( rPt2 ) );
+
+    mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrX1, GetValueString( aPt1.X(), mbDoublePoints ) );
+    mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrY1, GetValueString( aPt1.Y(), mbDoublePoints ) );
+    mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrX2, GetValueString( aPt2.X(), mbDoublePoints ) );
+    mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrY2, GetValueString( aPt2.Y(), mbDoublePoints ) );
+
+    // add additional style if requested
+    if( pStyle )
+        mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStyle, *pStyle );
+
+    if( pLineColor )
+    {
+        // !!! mrExport.AddAttribute( XML_NAMESPACE_NONE, ... )
+        DBG_ERROR( "SVGActionWriter::ImplWriteLine: Line color not implemented" );
+    }
+
+    {
+        SvXMLElementExport aElem( mrExport, XML_NAMESPACE_NONE, aXMLElemLine, TRUE, TRUE );
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+void SVGActionWriter::ImplWriteRect( const Rectangle& rRect, long nRadX, long nRadY,
+                                     const NMSP_RTL::OUString* pStyle )
+{
+    const Rectangle aRect( ImplMap( rRect ) );
+
+    mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrX, GetValueString( aRect.Left(), mbDoublePoints ) );
+    mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrY, GetValueString( aRect.Top(), mbDoublePoints ) );
+    mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrWidth, GetValueString( aRect.GetWidth(), mbDoublePoints ) );
+    mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrHeight, GetValueString( aRect.GetHeight(), mbDoublePoints ) );
+
+    if( nRadX )
+        mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrRX, GetValueString( ImplMap( nRadX ), mbDoublePoints ) );
+
+    if( nRadY )
+        mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrRY, GetValueString( ImplMap( nRadY ), mbDoublePoints ) );
+
+    // add additional style if requested
+    if( pStyle )
+        mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStyle, *pStyle );
+
+    {
+        SvXMLElementExport aElem( mrExport, XML_NAMESPACE_NONE, aXMLElemRect, TRUE, TRUE );
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+void SVGActionWriter::ImplWriteEllipse( const Point& rCenter, long nRadX, long nRadY,
+                                        const NMSP_RTL::OUString* pStyle )
+{
+    const Point aCenter( ImplMap( rCenter ) );
+
+    mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrCX, GetValueString( aCenter.X(), mbDoublePoints ) );
+    mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrCY, GetValueString( aCenter.Y(), mbDoublePoints ) );
+    mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrRX, GetValueString( ImplMap( nRadX ), mbDoublePoints ) );
+    mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrRY, GetValueString( ImplMap( nRadY ), mbDoublePoints ) );
+
+    // add additional style if requested
+    if( pStyle )
+        mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStyle, *pStyle );
+
+    {
+        SvXMLElementExport aElem( mrExport, XML_NAMESPACE_NONE, aXMLElemEllipse, TRUE, TRUE );
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+void SVGActionWriter::ImplWritePolygon( const Polygon& rPoly, sal_Bool bLineOnly,
+                                        const NMSP_RTL::OUString* pStyle )
+{
+    if( rPoly.GetSize() )
+    {
+        FastString                  aStyle;
+        FastString                  aPoints;
+        USHORT                      i = 0, nSize = rPoly.GetSize();
+        const NMSP_RTL::OUString    aBlank( B2UCONST( " " ) );
+
+        // points
+        while( i < nSize )
+        {
+            const Point aPolyPoint( ImplMap( rPoly[ i ] ) );
+
+            aPoints += GetValueString( aPolyPoint.X(), mbDoublePoints );
+            aPoints += B2UCONST( "," );
+            aPoints += GetValueString( aPolyPoint.Y(), mbDoublePoints );
+
+            if( ++i < nSize )
+                aPoints += aBlank;
+        }
+
+        // style
+        if( bLineOnly )
+        {
+            aStyle += B2UCONST( "fill:none" );
+
+            if( pStyle )
+            {
+                aStyle += B2UCONST( ";" );
+                aStyle += *pStyle;
+            }
+        }
+        else if( pStyle )
+            aStyle += *pStyle;
+
+        // add point attribute
+        mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrPoints, aPoints.GetString() );
+
+        // add style attribute
+        if( aStyle.GetLength() )
+            mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStyle, aStyle.GetString() );
+
+        {
+            // write polyline/polygon element
+            SvXMLElementExport aElem( mrExport, XML_NAMESPACE_NONE, bLineOnly ? aXMLElemPolyLine : aXMLElemPolygon, TRUE, TRUE );
+        }
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+void SVGActionWriter::ImplWritePolyPolygon( const PolyPolygon& rPolyPoly, sal_Bool bLineOnly,
+                                            const NMSP_RTL::OUString* pStyle )
+{
+    if( rPolyPoly.Count() )
+    {
+        if( rPolyPoly.Count() == 1 )
+            ImplWritePolygon( rPolyPoly[ 0 ], bLineOnly, pStyle );
+        else if( bLineOnly )
+        {
+            for( long i = 0, nCount = rPolyPoly.Count(); i < nCount; i++ )
+                ImplWritePolygon( rPolyPoly[ i ], sal_False, pStyle );
+        }
+        else
+        {
+            FastString                  aPathData;
+            const NMSP_RTL::OUString    aBlank( B2UCONST( " " ) );
+            const NMSP_RTL::OUString    aComma( B2UCONST( "," ) );
+            Point                       aPolyPoint;
+
+            for( long i = 0, nCount = rPolyPoly.Count(); i < nCount; i++ )
+            {
+                const Polygon&  rPoly = rPolyPoly[ i ];
+                USHORT          n = 1, nSize = rPoly.GetSize();
+
+                if( nSize > 1 )
+                {
+                    aPathData += B2UCONST( "M " );
+                    aPathData += GetValueString( ( aPolyPoint = ImplMap( rPoly[ 0 ] ) ).X(), mbDoublePoints );
+                    aPathData += aComma;
+                    aPathData += GetValueString( aPolyPoint.Y(), mbDoublePoints );
+                    aPathData += B2UCONST( " L " );
+
+                    while( n < nSize )
+                    {
+                        aPathData += GetValueString( ( aPolyPoint = ImplMap( rPoly[ n ] ) ).X(), mbDoublePoints );
+                        aPathData += aComma;
+                        aPathData += GetValueString( aPolyPoint.Y(), mbDoublePoints );
+
+                        if( ++n < nSize )
+                            aPathData += aBlank;
+                    }
+
+                    aPathData += B2UCONST( " Z" );
+
+                    if( i < ( nCount - 1 ) )
+                        aPathData += aBlank;
+                }
+            }
+
+            // add style attribute
+            if( pStyle && pStyle->getLength() )
+                mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStyle, *pStyle );
+
+            // add path data attribute
+            mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrD, aPathData.GetString() );
+
+            {
+                // write polyline/polygon element
+                SvXMLElementExport aElem( mrExport, XML_NAMESPACE_NONE, aXMLElemPath, TRUE, TRUE );
+            }
+        }
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+void SVGActionWriter::ImplWriteGradientEx( const PolyPolygon& rPolyPoly, const Gradient& rGradient,
+                                           const NMSP_RTL::OUString* pStyle )
+{
+    if( rPolyPoly.Count() )
+    {
+        SvXMLElementExport  aElemG( mrExport, XML_NAMESPACE_NONE, aXMLElemG, TRUE, TRUE );
+        FastString          aClipId;
+        FastString          aClipStyle;
+
+        aClipId += B2UCONST( "clip" );
+        aClipId += NMSP_RTL::OUString::valueOf( ImplGetNextClipId() );
+
+        {
+            SvXMLElementExport aElemDefs( mrExport, XML_NAMESPACE_NONE, aXMLElemDefs, TRUE, TRUE );
+
+            mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrId, aClipId.GetString() );
+
+            {
+                SvXMLElementExport aElemClipPath( mrExport, XML_NAMESPACE_NONE, aXMLElemClipPath, TRUE, TRUE );
+                ImplWritePolyPolygon( rPolyPoly, sal_False );
+            }
+        }
+
+        // create new context with clippath set
+        aClipStyle += B2UCONST( "clip-path:URL(#" );
+        aClipStyle += aClipId.GetString();
+        aClipStyle += B2UCONST( ")" );
+
+        mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStyle, aClipStyle.GetString() );
+
+        {
+            GDIMetaFile         aTmpMtf;
+            SvXMLElementExport  aElemG( mrExport, XML_NAMESPACE_NONE, aXMLElemG, TRUE, TRUE );
+
+            mpVDev->AddGradientActions( rPolyPoly.GetBoundRect(), rGradient, aTmpMtf );
+            ImplWriteActions( aTmpMtf, pStyle );
+        }
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+void SVGActionWriter::ImplWriteText( const Point& rPos, const String& rText,
+                                     const long* pDXArray, long nWidth,
+                                     const NMSP_RTL::OUString* pStyle )
+{
+    String  aText( rText ); aText.EraseLeadingChars( ' ' );
+    UINT32  nLen = aText.Len(), i;
+
+    if( nLen )
+    {
+        Size    aNormSize;
+        long*   pOwnArray;
+        long*   pDX;
+
+        // get text sizes
+        if( pDXArray )
+        {
+            pOwnArray = NULL;
+#ifdef _SVG_UNO3
+            aNormSize = Size( mpVDev->GetTextWidth( aText ), 0 );
+#else
+            aNormSize = mpVDev->GetTextSize( aText );
+#endif
+            pDX = (long*) pDXArray;
+        }
+        else
+        {
+            pOwnArray = new long[ nLen ];
+#ifdef _SVG_UNO3
+            aNormSize = Size( mpVDev->GetTextArray( aText, pOwnArray ), 0 );
+#else
+            aNormSize = mpVDev->GetTextArray( aText, pOwnArray );
+#endif
+            pDX = pOwnArray;
+        }
+
+        if( nLen > 1 )
+        {
+#ifdef _SVG_UNO3
+            aNormSize.Width() = pDX[ nLen - 2 ] + mpVDev->GetTextWidth( aText.GetChar(  nLen - 1 ) );
+#else
+            aNormSize.Width() = pDX[ nLen - 2 ] + mpVDev->GetTextSize( aText[ (USHORT) ( nLen - 1 ) ] ).Width();
+#endif
+
+            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 );
+            }
+        }
+
+        FastString          aStyle;
+        const Font&         rFont = mpVDev->GetFont();
+        const FontMetric    aMetric( mpVDev->GetFontMetric() );
+        Point               aBaseLinePos( rPos );
+
+        // leading whitespaces erased? => adjust position
+        if( nLen < rText.Len() )
+        {
+#ifdef _SVG_UNO3
+            aBaseLinePos.X() += mpVDev->GetTextWidth( ' ' ) * ( rText.Len() - nLen );
+#else
+            aBaseLinePos.X() += mpVDev->GetTextSize( ' ' ).Width() * ( rText.Len() - nLen );
+#endif
+        }
+
+        // always adjust text position to match baseline alignment
+        switch( rFont.GetAlign() )
+        {
+            case( ALIGN_TOP ):
+                aBaseLinePos.Y() += aMetric.GetAscent();
+            break;
+
+            case( ALIGN_BOTTOM ):
+                aBaseLinePos.Y() -= aMetric.GetDescent();
+            break;
+
+            default:
+            break;
+        }
+
+        // get mapped text position
+        const Point aPt( ImplMap( aBaseLinePos ) );
+
+        // add additional style if requested
+        if( pStyle && pStyle->getLength() )
+            mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStyle, *pStyle );
+
+        // write text element
+#ifdef _SVG_WRITE_TSPAN
+        if( pDXArray )
+        {
+            SvXMLElementExport          aElem( mrExport, XML_NAMESPACE_NONE, aXMLElemText, TRUE, TRUE );
+            FastString                  aTSpanX;
+            const NMSP_RTL::OUString    aSpace( ' ' );
+            long                        i, nX, nCount;
+
+            aTSpanX += GetValueString( aPt.X(), mbDoublePoints );
+            aTSpanX += aSpace;
+
+            for( i = 0, nX = aPt.X(), nCount = ( nLen - 1 ); i < nCount;  )
+            {
+                aTSpanX += GetValueString( aPt.X() + pDX[ i++ ], mbDoublePoints );
+                aTSpanX += aSpace;
+            }
+
+            mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrX, aTSpanX.GetString() );
+            mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrY, GetValueString( aPt.Y(), mbDoublePoints ) );
+
+            {
+                SvXMLElementExport aElem( mrExport, XML_NAMESPACE_NONE, aXMLElemTSpan, TRUE, TRUE );
+                mrExport.GetDocHandler()->characters( NMSP_RTL::OUString( UniString( aText ) ) );
+            }
+        }
+        else
+#endif // _SVG_WRITE_TSPAN
+        {
+            mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrX, GetValueString( aPt.X(), mbDoublePoints ) );
+            mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrY, GetValueString( aPt.Y(), mbDoublePoints ) );
+
+            SvXMLElementExport aElem( mrExport, XML_NAMESPACE_NONE, aXMLElemText, TRUE, TRUE );
+            mrExport.GetDocHandler()->characters( NMSP_RTL::OUString( UniString( aText ) ) );
+        }
+#ifndef _SVG_WRITE_STRIKEOUT
+
+        // write strikeout if neccessary
+        if( rFont.GetStrikeout() )
+        {
+            const long  nYStrikeoutPos = aBaseLinePos.Y() - FRound( aMetric.GetAscent() * 0.26 );
+            const long  nStrikeoutHeight = Max( (long) FRound( aMetric.GetLineHeight() * 0.05 ), (long) 1 );
+            Polygon     aPoly( 4 );
+
+            aPoly[ 0 ].X() = aBaseLinePos.X(); aPoly[ 0 ].Y() = nYStrikeoutPos - ( nStrikeoutHeight >> 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() + nStrikeoutHeight - 1;
+            aPoly[ 3 ].X() = aPoly[ 0 ].X(); aPoly[ 3 ].Y() = aPoly[ 2 ].Y();
+
+            ImplWritePolygon( aPoly, FALSE );
+        }
+
+#endif // _SVG_WRITE_STRIKEOUT
+
+        delete[] pOwnArray;
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+void SVGActionWriter::ImplWriteBmp( const BitmapEx& rBmpEx,
+                                    const Point& rPt, const Size& rSz,
+                                    const Point& rSrcPt, const Size& rSrcSz,
+                                    const NMSP_RTL::OUString* pStyle )
+{
+    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 )
+            {
+                const Point                                 aPt( ImplMap( rPt ) );
+                const Size                                  aSz( ImplMap( rSz ) );
+                FastString                                  aImageData( (sal_Char*) aOStm.GetData(), aOStm.Tell() );
+#ifndef _SVG_UNO3
+                XExtendedDocumentHandlerRef                 xExtDocHandler( mrExport.GetDocHandler(), USR_QUERY );
+#else
+                REF( NMSP_SAX::XExtendedDocumentHandler )   xExtDocHandler( mrExport.GetDocHandler(), NMSP_UNO::UNO_QUERY );
+#endif
+
+                if( xExtDocHandler.is() )
+                {
+                    static const sal_uInt32     nPartLen = 64;
+                    const NMSP_RTL::OUString    aSpace( ' ' );
+                    const NMSP_RTL::OUString    aLineFeed( NMSP_RTL::OUString::valueOf( (sal_Unicode) 0x0a ) );
+                    NMSP_RTL::OUString          aString;
+                    NMSP_RTL::OUString          aImageString;
+
+                    aString = aLineFeed;
+                    aString +=  B2UCONST( "<" );
+                    aString += NMSP_RTL::OUString::createFromAscii( aXMLElemImage );
+                    aString += aSpace;
+
+                    aString += NMSP_RTL::OUString::createFromAscii( aXMLAttrX );
+                    aString += B2UCONST( "=\"" );
+                    aString += GetValueString( aPt.X(), mbDoublePoints );
+                    aString += B2UCONST( "\" " );
+
+                    aString += NMSP_RTL::OUString::createFromAscii( aXMLAttrY );
+                    aString += B2UCONST( "=\"" );
+                    aString += GetValueString( aPt.Y(), mbDoublePoints );
+                    aString += B2UCONST( "\" " );
+
+                    aString += NMSP_RTL::OUString::createFromAscii( aXMLAttrWidth );
+                    aString += B2UCONST( "=\"" );
+                    aString += GetValueString( aSz.Width(), mbDoublePoints );
+                    aString += B2UCONST( "\" " );
+
+                    aString += NMSP_RTL::OUString::createFromAscii( aXMLAttrHeight );
+                    aString += B2UCONST( "=\"" );
+                    aString += GetValueString( aSz.Height(), mbDoublePoints );
+                    aString += B2UCONST( "\" " );
+
+                    aString += NMSP_RTL::OUString::createFromAscii( aXMLAttrXLinkHRef );
+                    aString += B2UCONST( "=\"data:image/png;base64," );
+
+                    if( aImageData.GetFirstPartString( nPartLen, aImageString ) )
+                    {
+                        xExtDocHandler->unknown( aString += aImageString );
+
+                        while( aImageData.GetNextPartString( nPartLen, aImageString ) )
+                        {
+                            xExtDocHandler->unknown( aLineFeed );
+                            xExtDocHandler->unknown( aImageString );
+                        }
+                    }
+
+                    xExtDocHandler->unknown( B2UCONST( "\"/>" ) );
+                }
+            }
+        }
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+void SVGActionWriter::ImplWriteActions( const GDIMetaFile& rMtf, const NMSP_RTL::OUString* pStyle )
+{
+    ImplAcquireContext();
+
+    for( ULONG i = 0, nCount = rMtf.GetActionCount(); i < nCount; i++ )
+    {
+        const MetaAction*   pAction = rMtf.GetAction( i );
+        const USHORT        nType = pAction->GetType();
+
+        switch( nType )
+        {
+            case( META_PIXEL_ACTION ):
+            {
+                const MetaPixelAction* pA = (const MetaPixelAction*) pAction;
+
+                mpContext->SetPaintAttr( pA->GetColor(), pA->GetColor() );
+                ImplWriteLine( pA->GetPoint(), pA->GetPoint(), &pA->GetColor(), pStyle );
+            }
+            break;
+
+            case( META_POINT_ACTION ):
+            {
+                const MetaPointAction* pA = (const MetaPointAction*) pAction;
+
+                mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetLineColor() );
+                ImplWriteLine( pA->GetPoint(), pA->GetPoint(), NULL, pStyle );
+            }
+            break;
+
+            case( META_LINE_ACTION ):
+            {
+                const MetaLineAction* pA = (const MetaLineAction*) pAction;
+
+                mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetLineColor() );
+                ImplWriteLine( pA->GetStartPoint(), pA->GetEndPoint(), NULL, pStyle );
+            }
+            break;
+
+            case( META_RECT_ACTION ):
+            {
+                mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
+                ImplWriteRect( ( (const MetaRectAction*) pAction )->GetRect(), 0, 0, pStyle );
+            }
+            break;
+
+            case( META_ROUNDRECT_ACTION ):
+            {
+                const MetaRoundRectAction* pA = (const MetaRoundRectAction*) pAction;
+
+                mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
+                ImplWriteRect( pA->GetRect(), pA->GetHorzRound(), pA->GetVertRound(), pStyle );
+            }
+            break;
+
+            case( META_ELLIPSE_ACTION ):
+            {
+                const MetaEllipseAction*    pA = (const MetaEllipseAction*) pAction;
+                const Rectangle&            rRect = pA->GetRect();
+
+                mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
+                ImplWriteEllipse( rRect.Center(), rRect.GetWidth() >> 1, rRect.GetHeight() >> 1, pStyle );
+            }
+            break;
+
+            case( META_ARC_ACTION ):
+            case( META_PIE_ACTION ):
+            case( META_CHORD_ACTION ):
+            case( META_POLYGON_ACTION ):
+            {
+                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->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
+                    ImplWritePolygon( aPoly, sal_False, pStyle );
+                }
+            }
+            break;
+
+            case( META_POLYLINE_ACTION ):
+            {
+                const MetaPolyLineAction*   pA = (const MetaPolyLineAction*) pAction;
+                const Polygon&              rPoly = pA->GetPolygon();
+
+                if( rPoly.GetSize() )
+                {
+                    mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
+                    ImplWritePolygon( rPoly, sal_True, pStyle );
+                }
+            }
+            break;
+
+            case( META_POLYPOLYGON_ACTION ):
+            {
+                const MetaPolyPolygonAction*    pA = (const MetaPolyPolygonAction*) pAction;
+                const PolyPolygon&              rPolyPoly = pA->GetPolyPolygon();
+
+                if( rPolyPoly.Count() )
+                {
+                    mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
+                    ImplWritePolyPolygon( rPolyPoly, sal_False, pStyle );
+                }
+            }
+            break;
+
+            case( META_GRADIENT_ACTION ):
+            {
+                const MetaGradientAction*   pA = (const MetaGradientAction*) pAction;
+                GDIMetaFile                 aTmpMtf;
+
+                mpVDev->AddGradientActions( pA->GetRect(), pA->GetGradient(), aTmpMtf );
+                ImplWriteActions( aTmpMtf, pStyle );
+            }
+            break;
+
+            case( META_GRADIENTEX_ACTION ):
+            {
+                const MetaGradientExAction* pA = (const MetaGradientExAction*) pAction;
+                ImplWriteGradientEx( pA->GetPolyPolygon(), pA->GetGradient(), pStyle );
+            }
+            break;
+
+            case META_HATCH_ACTION:
+            {
+                const MetaHatchAction*  pA = (const MetaHatchAction*) pAction;
+                GDIMetaFile             aTmpMtf;
+
+                mpVDev->AddHatchActions( pA->GetPolyPolygon(), pA->GetHatch(), aTmpMtf );
+                ImplWriteActions( aTmpMtf, pStyle );
+            }
+            break;
+
+            case( META_TRANSPARENT_ACTION ):
+            {
+                // !!!
+                mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
+                DBG_ERROR( "META_TRANSPARENT_ACTION not supported" );
+            }
+            break;
+
+            case( META_FLOATTRANSPARENT_ACTION ):
+            {
+                // !!!
+                mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
+                DBG_ERROR( "META_FLOATTRANSPARENT_ACTION not supported" );
+            }
+            break;
+
+            case( META_EPS_ACTION ):
+            {
+                const MetaEPSAction*    pA = (const MetaEPSAction*) pAction;
+                const GDIMetaFile       aGDIMetaFile( pA->GetSubstitute() );
+                sal_Bool                bFound = sal_False;
+
+                for( ULONG i = 0, nCount = aGDIMetaFile.GetActionCount(); ( i < nCount ) && !bFound; i++ )
+                {
+                    const MetaAction* pSubstAct = aGDIMetaFile.GetAction( i );
+
+                    if( pSubstAct->GetType() == META_BMPSCALE_ACTION )
+                    {
+                        bFound = sal_True;
+                        const MetaBmpScaleAction* pBmpScaleAction = (const MetaBmpScaleAction*) pAction;
+                        mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
+                        ImplWriteBmp( pBmpScaleAction->GetBitmap(),
+                                      pBmpScaleAction->GetPoint(), pBmpScaleAction->GetSize(),
+                                      Point(), pBmpScaleAction->GetBitmap().GetSizePixel(), pStyle );
+                    }
+                }
+            }
+            break;
+
+            case( META_COMMENT_ACTION ):
+            {
+                const MetaCommentAction*    pA = (const MetaCommentAction*) pAction;
+                String                      aSkipComment;
+
+#ifndef _SVG_UNO3
+                if( pA->GetComment().ICompare( "XGRAD_SEQ_BEGIN" ) == COMPARE_EQUAL )
+#else
+                if( pA->GetComment().CompareIgnoreCaseToAscii( "XGRAD_SEQ_BEGIN" ) == COMPARE_EQUAL )
+#endif
+                {
+                    const MetaGradientExAction* pGradAction = NULL;
+                    sal_Bool                    bDone = sal_False;
+
+                    while( !bDone && ( ++i < nCount ) )
+                    {
+                        pAction = rMtf.GetAction( i );
+
+                        if( pAction->GetType() == META_GRADIENTEX_ACTION )
+                            pGradAction = (const MetaGradientExAction*) pAction;
+                        else if( ( pAction->GetType() == META_COMMENT_ACTION ) &&
+#ifndef _SVG_UNO3
+                                 ( ( (const MetaCommentAction*) pAction )->GetComment().ICompare( "XGRAD_SEQ_END" ) == COMPARE_EQUAL ) )
+
+#else
+                                 ( ( (const MetaCommentAction*) pAction )->GetComment().CompareIgnoreCaseToAscii( "XGRAD_SEQ_END" ) == COMPARE_EQUAL ) )
+#endif
+                        {
+                            bDone = sal_True;
+                        }
+                    }
+
+                    if( pGradAction )
+                        ImplWriteGradientEx( pGradAction->GetPolyPolygon(), pGradAction->GetGradient(), pStyle );
+                }
+            }
+            break;
+
+            case( META_BMP_ACTION ):
+            {
+                const MetaBmpAction* pA = (const MetaBmpAction*) pAction;
+
+                mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
+                ImplWriteBmp( pA->GetBitmap(),
+                              pA->GetPoint(), mpVDev->PixelToLogic( pA->GetBitmap().GetSizePixel() ),
+                              Point(), pA->GetBitmap().GetSizePixel(), pStyle );
+            }
+            break;
+
+            case( META_BMPSCALE_ACTION ):
+            {
+                const MetaBmpScaleAction* pA = (const MetaBmpScaleAction*) pAction;
+
+                mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
+                ImplWriteBmp( pA->GetBitmap(),
+                              pA->GetPoint(), pA->GetSize(),
+                              Point(), pA->GetBitmap().GetSizePixel(), pStyle );
+            }
+            break;
+
+            case( META_BMPSCALEPART_ACTION ):
+            {
+                const MetaBmpScalePartAction* pA = (const MetaBmpScalePartAction*) pAction;
+
+                mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
+                ImplWriteBmp( pA->GetBitmap(),
+                              pA->GetDestPoint(), pA->GetDestSize(),
+                              pA->GetSrcPoint(), pA->GetSrcSize(), pStyle );
+            }
+            break;
+
+            case( META_BMPEX_ACTION ):
+            {
+                const MetaBmpExAction*  pA = (const MetaBmpExAction*) pAction;
+
+                mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
+                ImplWriteBmp( pA->GetBitmapEx(),
+                              pA->GetPoint(), mpVDev->PixelToLogic( pA->GetBitmapEx().GetSizePixel() ),
+                              Point(), pA->GetBitmapEx().GetSizePixel(), pStyle );
+            }
+            break;
+
+            case( META_BMPEXSCALE_ACTION ):
+            {
+                const MetaBmpExScaleAction* pA = (const MetaBmpExScaleAction*) pAction;
+
+                mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
+                ImplWriteBmp( pA->GetBitmapEx(),
+                              pA->GetPoint(), pA->GetSize(),
+                              Point(), pA->GetBitmapEx().GetSizePixel(), pStyle );
+            }
+            break;
+
+            case( META_BMPEXSCALEPART_ACTION ):
+            {
+                const MetaBmpExScalePartAction* pA = (const MetaBmpExScalePartAction*) pAction;
+
+                mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
+                ImplWriteBmp( pA->GetBitmapEx(),
+                              pA->GetDestPoint(), pA->GetDestSize(),
+                              pA->GetSrcPoint(), pA->GetSrcSize(), pStyle );
+            }
+            break;
+
+            case( META_TEXT_ACTION ):
+            {
+                const MetaTextAction* pA = (const MetaTextAction*) pAction;
+
+                mpContext->SetFontAttr( mpVDev->GetFont() );
+                mpContext->SetPaintAttr( COL_TRANSPARENT, mpVDev->GetFont().GetColor() );
+                ImplWriteText( pA->GetPoint(), String( pA->GetText(), pA->GetIndex(), pA->GetLen() ), NULL, 0, pStyle );
+            }
+            break;
+
+            case( META_TEXTRECT_ACTION ):
+            {
+                const MetaTextRectAction* pA = (const MetaTextRectAction*) pAction;
+
+                mpContext->SetFontAttr( mpVDev->GetFont() );
+                mpContext->SetPaintAttr( COL_TRANSPARENT, mpVDev->GetFont().GetColor() );
+                ImplWriteText( pA->GetRect().TopLeft(), pA->GetText(), NULL, 0, pStyle );
+            }
+            break;
+
+            case( META_TEXTARRAY_ACTION ):
+            {
+                const MetaTextArrayAction*  pA = (const MetaTextArrayAction*) pAction;
+                const Point                 aPos( ImplMap( pA->GetPoint() ) );
+
+                mpContext->SetFontAttr( mpVDev->GetFont() );
+                mpContext->SetPaintAttr( COL_TRANSPARENT, mpVDev->GetFont().GetColor() );
+                ImplWriteText( pA->GetPoint(), String( pA->GetText(), pA->GetIndex(), pA->GetLen() ), pA->GetDXArray(), 0, pStyle );
+            }
+            break;
+
+            case( META_STRETCHTEXT_ACTION ):
+            {
+                const MetaStretchTextAction* pA = (const MetaStretchTextAction*) pAction;
+
+                mpContext->SetFontAttr( mpVDev->GetFont() );
+                mpContext->SetPaintAttr( COL_TRANSPARENT, mpVDev->GetFont().GetColor() );
+                ImplWriteText( pA->GetPoint(), String( pA->GetText(), pA->GetIndex(), pA->GetLen() ), NULL, pA->GetWidth(), pStyle );
+            }
+            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 ):
+            {
+                ( (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;
+        }
+    }
+
+    ImplReleaseContext();
+}