xref: /aoo41x/main/filter/source/svg/svgexport.cxx (revision 33f678dd)

/**************************************************************
 *
 * 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"

#define ITEMID_FIELD 0

#include "svgwriter.hxx"
#include "svgfontexport.hxx"
#include "svgfilter.hxx"
#include "impsvgdialog.hxx"

#include <com/sun/star/graphic/XPrimitiveFactory2D.hpp>

#include <svx/unopage.hxx>
#include <svx/unoshape.hxx>
#include <svx/svdpage.hxx>
#include <svx/svdoutl.hxx>
#include <editeng/outliner.hxx>
#include <editeng/flditem.hxx>
#include <editeng/numitem.hxx>

using namespace ::com::sun::star::graphic;
using namespace ::com::sun::star::geometry;
using ::rtl::OUString;

// -------------
// - SVGExport -
// -------------

SVGExport::SVGExport(
	const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > xServiceFactory,
	const Reference< XDocumentHandler >& rxHandler,
    const Sequence< PropertyValue >& rFilterData )
: SvXMLExport( xServiceFactory, MAP_100TH_MM )
, mbTinyProfile			( sal_True )
, mbTSpans				( sal_True )
, mbEmbedFonts			( sal_False )
, mbNativeTextDecoration( sal_True )
, mbOpacity				( sal_True )
, mbGradient			( sal_True )
{
	for ( sal_Int32 i = 0, nCount = rFilterData.getLength(); i < nCount; i++ )
	{
		if ( rFilterData[ i ].Name == B2UCONST( SVG_PROP_TINYPROFILE ) )
			rFilterData[ i ].Value >>= mbTinyProfile;
		else if ( rFilterData[ i ].Name == B2UCONST( "TSpans" ) )
			rFilterData[ i ].Value >>= mbTSpans;
		else if ( rFilterData[ i ].Name == B2UCONST( SVG_PROP_EMBEDFONTS ) )
			rFilterData[ i ].Value >>= mbEmbedFonts;
		else if ( rFilterData[ i ].Name == B2UCONST( SVG_PROP_NATIVEDECORATION ) )
			rFilterData[ i ].Value >>= mbNativeTextDecoration;
		else if ( rFilterData[ i ].Name == B2UCONST( "GlyphPlacement" ) )
			rFilterData[ i ].Value >>= maGlyphPlacement;
		else if ( rFilterData[ i ].Name == B2UCONST( SVG_PROP_OPACITY ) )
			rFilterData[ i ].Value >>= mbOpacity;
		else if ( rFilterData[ i ].Name == B2UCONST( SVG_PROP_GRADIENT ) )
			rFilterData[ i ].Value >>= mbGradient;
	}
	if ( mbTinyProfile )
		mbNativeTextDecoration = sal_False;
	else
	{
		mbTSpans = sal_False;
		mbOpacity = sal_True;
		mbGradient = sal_True;
	}
	SetDocHandler( rxHandler );
	GetDocHandler()->startDocument();
}

// -----------------------------------------------------------------------------

SVGExport::~SVGExport()
{
	GetDocHandler()->endDocument();
}

// -----------------------------------------------------------------------------

void SVGExport::pushClip( const ::basegfx::B2DPolyPolygon& rPolyPoly )
{
    maClipList.push_front( ::basegfx::tools::correctOrientations( rPolyPoly ) );
}

// -----------------------------------------------------------------------------

void SVGExport::popClip()
{
    if( !maClipList.empty() )
        maClipList.pop_front();
}

// -----------------------------------------------------------------------------

sal_Bool SVGExport::hasClip() const
{
    return( !maClipList.empty() );
}

// -----------------------------------------------------------------------------

const ::basegfx::B2DPolyPolygon* SVGExport::getCurClip() const
{
    return( maClipList.empty() ? NULL : &( *maClipList.begin() ) );
}

// ------------------------
// - ObjectRepresentation -
// ------------------------

ObjectRepresentation::ObjectRepresentation() :
	mpMtf( NULL )
{
}

// -----------------------------------------------------------------------------

ObjectRepresentation::ObjectRepresentation( const Reference< XInterface >& rxObject,
											const GDIMetaFile& rMtf ) :
	mxObject( rxObject ),
	mpMtf( new GDIMetaFile( rMtf ) )
{
}

// -----------------------------------------------------------------------------

ObjectRepresentation::ObjectRepresentation( const ObjectRepresentation& rPresentation ) :
	mxObject( rPresentation.mxObject ),
	mpMtf( rPresentation.mpMtf ? new GDIMetaFile( *rPresentation.mpMtf ) : NULL )
{
}

// -----------------------------------------------------------------------------

ObjectRepresentation::~ObjectRepresentation()
{
	delete mpMtf;
}

// -----------------------------------------------------------------------------

ObjectRepresentation& ObjectRepresentation::operator=( const ObjectRepresentation& rPresentation )
{
	mxObject = rPresentation.mxObject;
	delete mpMtf, ( mpMtf = rPresentation.mpMtf ? new GDIMetaFile( *rPresentation.mpMtf ) : NULL );

	return *this;
}

// -----------------------------------------------------------------------------

sal_Bool ObjectRepresentation::operator==( const ObjectRepresentation& rPresentation ) const
{
	return( ( mxObject == rPresentation.mxObject ) &&
			( *mpMtf == *rPresentation.mpMtf ) );
}

// -------------
// - SVGFilter -
// -------------

sal_Bool SVGFilter::implExport( const Sequence< PropertyValue >& rDescriptor )
	throw (RuntimeException)
{
    Reference< XMultiServiceFactory >	xServiceFactory( ::comphelper::getProcessServiceFactory() ) ;
    Reference< XOutputStream >          xOStm;
    SvStream*                           pOStm = NULL;
	sal_Int32							nLength = rDescriptor.getLength();
    sal_Int32                           nPageToExport = SVG_EXPORT_ALLPAGES;
	const PropertyValue*				pValue = rDescriptor.getConstArray();
	sal_Bool							bRet = sal_False;

    mnMasterSlideId = mnSlideId = mnDrawingGroupId = mnDrawingId = 0;
    maFilterData.realloc( 0 );

	for ( sal_Int32 i = 0 ; i < nLength; ++i)
    {
		if( pValue[ i ].Name.equalsAscii( "OutputStream" ) )
			pValue[ i ].Value >>= xOStm;
        else if( pValue[ i ].Name.equalsAscii( "FileName" ) )
        {
            ::rtl::OUString aFileName;

            pValue[ i ].Value >>= aFileName;
            pOStm = ::utl::UcbStreamHelper::CreateStream( aFileName, STREAM_WRITE | STREAM_TRUNC );

            if( pOStm )
                xOStm = Reference< XOutputStream >( new ::utl::OOutputStreamWrapper ( *pOStm ) );
        }
        else if( pValue[ i ].Name.equalsAscii( "PagePos" ) )
        {
            pValue[ i ].Value >>= nPageToExport;
        }
        else if( pValue[ i ].Name.equalsAscii( "FilterData" ) )
        {
            pValue[ i ].Value >>= maFilterData;
        }
        else if( pValue[ i ].Name.equalsAscii( "ShapeSelection" ) )
        {
            // #124608# read selection if given
            pValue[ i ].Value >>= maShapeSelection;
        }
    }

    // if no filter data is given use stored/prepared ones
    if( !maFilterData.getLength() )
    {
#ifdef _SVG_USE_CONFIG
        FilterConfigItem aCfgItem( String( RTL_CONSTASCII_USTRINGPARAM( SVG_EXPORTFILTER_CONFIGPATH ) ) );

        aCfgItem.ReadBool( String( RTL_CONSTASCII_USTRINGPARAM( SVG_PROP_TINYPROFILE ) ), sal_True );
        aCfgItem.ReadBool( String( RTL_CONSTASCII_USTRINGPARAM( SVG_PROP_EMBEDFONTS ) ), sal_True );
        aCfgItem.ReadBool( String( RTL_CONSTASCII_USTRINGPARAM( SVG_PROP_NATIVEDECORATION ) ), sal_False );
        aCfgItem.ReadString( String( RTL_CONSTASCII_USTRINGPARAM( SVG_PROP_NATIVEDECORATION ) ), B2UCONST( "xlist" ) );
        aCfgItem.ReadString( String( RTL_CONSTASCII_USTRINGPARAM( SVG_PROP_OPACITY ) ), sal_True );
        aCfgItem.ReadString( String( RTL_CONSTASCII_USTRINGPARAM( SVG_PROP_GRADIENT ) ), sal_True );

        maFilterData = aCfgItem.GetFilterData();
#else
        maFilterData.realloc( 6 );

        maFilterData[ 0 ].Name = B2UCONST( SVG_PROP_TINYPROFILE );
        maFilterData[ 0 ].Value <<= (sal_Bool) sal_True;

        // font embedding
        const char* pSVGDisableFontEmbedding = getenv( "SVG_DISABLE_FONT_EMBEDDING" );

        maFilterData[ 1 ].Name = B2UCONST( SVG_PROP_EMBEDFONTS );
        maFilterData[ 1 ].Value <<= (sal_Bool) ( pSVGDisableFontEmbedding ? sal_False : sal_True );

        // Native decoration
        maFilterData[ 2 ].Name = B2UCONST( SVG_PROP_NATIVEDECORATION );
        maFilterData[ 2 ].Value <<= (sal_Bool) sal_False;

        // glyph placement
        const char* pSVGGlyphPlacement = getenv( "SVG_GLYPH_PLACEMENT" );

        maFilterData[ 3 ].Name = B2UCONST( SVG_PROP_GLYPHPLACEMENT );

        if( pSVGGlyphPlacement )
            maFilterData[ 3 ].Value <<= ::rtl::OUString::createFromAscii( pSVGGlyphPlacement );
        else
            maFilterData[ 3 ].Value <<= B2UCONST( "xlist" );

        // Tiny Opacity
        maFilterData[ 4 ].Name = B2UCONST( SVG_PROP_OPACITY );
        maFilterData[ 4 ].Value <<= (sal_Bool) sal_True;

        // Tiny Gradient
        maFilterData[ 5 ].Name = B2UCONST( SVG_PROP_GRADIENT );
        maFilterData[ 5 ].Value <<= (sal_Bool) sal_False;
#endif
    }

    if( xOStm.is() && xServiceFactory.is() )
    {
		Reference< XMasterPagesSupplier >	xMasterPagesSupplier( mxSrcDoc, UNO_QUERY );
		Reference< XDrawPagesSupplier >		xDrawPagesSupplier( mxSrcDoc, UNO_QUERY );

		if( xMasterPagesSupplier.is() && xDrawPagesSupplier.is() )
		{
			Reference< XDrawPages >   xMasterPages( xMasterPagesSupplier->getMasterPages(), UNO_QUERY );
			Reference< XDrawPages >   xDrawPages( xDrawPagesSupplier->getDrawPages(), UNO_QUERY );

			if( xMasterPages.is() && xMasterPages->getCount() && xDrawPages.is() && xDrawPages->getCount() )
			{
                Reference< XDocumentHandler > xDocHandler( implCreateExportDocumentHandler( xOStm ) );

                if( xDocHandler.is() )
                {
					mbPresentation = Reference< XPresentationSupplier >( mxSrcDoc, UNO_QUERY ).is();
					mpObjects = new ObjectMap;

					// #110680#
					// mpSVGExport = new SVGExport( xDocHandler );
                    mpSVGExport = new SVGExport( xServiceFactory, xDocHandler, maFilterData );

                    if( nPageToExport < 0 || nPageToExport >= xDrawPages->getCount() )
                        nPageToExport = SVG_EXPORT_ALLPAGES;

					try
					{
    					const sal_Int32 nDefaultPage = ( ( SVG_EXPORT_ALLPAGES == nPageToExport ) ? 0 : nPageToExport );

						xDrawPages->getByIndex( nDefaultPage ) >>= mxDefaultPage;

						if( mxDefaultPage.is() )
						{
							SvxDrawPage* pSvxDrawPage = SvxDrawPage::getImplementation( mxDefaultPage );

							if( pSvxDrawPage )
							{
								mpDefaultSdrPage = pSvxDrawPage->GetSdrPage();
								mpSdrModel = mpDefaultSdrPage->GetModel();

								if( mpSdrModel )
								{
									SdrOutliner& rOutl = mpSdrModel->GetDrawOutliner(NULL);

									maOldFieldHdl = rOutl.GetCalcFieldValueHdl();
									rOutl.SetCalcFieldValueHdl( LINK( this, SVGFilter, CalcFieldHdl) );
								}
							}

							if( implCreateObjects( xMasterPages, xDrawPages, nPageToExport ) )
							{
								ObjectMap::const_iterator				aIter( mpObjects->begin() );
								::std::vector< ObjectRepresentation >	aObjects( mpObjects->size() );
								sal_uInt32								nPos = 0;

								while( aIter != mpObjects->end() )
								{
									aObjects[ nPos++ ] = (*aIter).second;
									++aIter;
								}

								mpSVGFontExport = new SVGFontExport( *mpSVGExport, aObjects );
								mpSVGWriter = new SVGActionWriter( *mpSVGExport, *mpSVGFontExport );

								bRet = implExportDocument( xMasterPages, xDrawPages, nPageToExport );
							}
						}
					}
					catch( ... )
					{
						delete mpSVGDoc, mpSVGDoc = NULL;
						DBG_ERROR( "Exception caught" );
					}

					if( mpSdrModel )
						mpSdrModel->GetDrawOutliner( NULL ).SetCalcFieldValueHdl( maOldFieldHdl );

					delete mpSVGWriter, mpSVGWriter = NULL;
                    delete mpSVGExport, mpSVGExport = NULL;
					delete mpSVGFontExport, mpSVGFontExport = NULL;
					delete mpObjects, mpObjects = NULL;
                    mbPresentation = sal_False;
                }
			}
		}
	}

    delete pOStm;

	return bRet;
}

// -----------------------------------------------------------------------------

Reference< XDocumentHandler > SVGFilter::implCreateExportDocumentHandler( const Reference< XOutputStream >& rxOStm )
{
	Reference< XMultiServiceFactory >   xMgr( ::comphelper::getProcessServiceFactory() );
    Reference< XDocumentHandler >       xSaxWriter;

	if( xMgr.is() && rxOStm.is() )
	{
		xSaxWriter = Reference< XDocumentHandler >( xMgr->createInstance( B2UCONST( "com.sun.star.xml.sax.Writer" ) ), UNO_QUERY );

		if( xSaxWriter.is() )
		{
			Reference< XActiveDataSource > xActiveDataSource( xSaxWriter, UNO_QUERY );

			if( xActiveDataSource.is() )
				xActiveDataSource->setOutputStream( rxOStm );
            else
                xSaxWriter = NULL;
		}
	}

    return xSaxWriter;
}

// -----------------------------------------------------------------------------

sal_Bool SVGFilter::implExportDocument( const Reference< XDrawPages >& rxMasterPages,
										const Reference< XDrawPages >& rxDrawPages,
                                        sal_Int32 nPageToExport )
{
	DBG_ASSERT( rxMasterPages.is() && rxDrawPages.is(),
				"SVGFilter::implExportDocument: invalid parameter" );

	OUString		aAttr;
	sal_Int32		nDocX = 0, nDocY = 0; // #124608#
	sal_Int32		nDocWidth = 0, nDocHeight = 0;
	sal_Int32		nVisible = -1, nVisibleMaster = -1;
	sal_Bool 		bRet = sal_False;
	const sal_Bool	bSinglePage = ( rxDrawPages->getCount() == 1 ) || ( SVG_EXPORT_ALLPAGES != nPageToExport );
    const sal_Int32 nFirstPage = ( ( SVG_EXPORT_ALLPAGES == nPageToExport ) ? 0 : nPageToExport );
	sal_Int32       nCurPage = nFirstPage, nLastPage = ( bSinglePage ? nFirstPage : ( rxDrawPages->getCount() - 1 ) );

	const Reference< XPropertySet >             xDefaultPagePropertySet( mxDefaultPage, UNO_QUERY );
    const Reference< XExtendedDocumentHandler > xExtDocHandler( mpSVGExport->GetDocHandler(), UNO_QUERY );

    // #124608#
    mbExportSelection = maShapeSelection.is() && maShapeSelection->getCount();

    if(xDefaultPagePropertySet.is())
    {
        xDefaultPagePropertySet->getPropertyValue(B2UCONST("Width")) >>= nDocWidth;
        xDefaultPagePropertySet->getPropertyValue(B2UCONST("Height")) >>= nDocHeight;
    }

    if(mbExportSelection)
    {
        // #124608# create BoundRange and set nDocX, nDocY, nDocWidth and nDocHeight
        basegfx::B2DRange aShapeRange;

        Reference< XPrimitiveFactory2D > xPrimitiveFactory(
            mxMSF->createInstance(
                String(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.comp.graphic.PrimitiveFactory2D"))),
                UNO_QUERY);

        // use XPrimitiveFactory2D and go the way over getting the primitives; this
        // will give better precision (doubles) and be based on the true object
        // geometry. If needed aViewInformation may be expanded to carry a view
        // resolution for which to prepare the geometry.
        if(xPrimitiveFactory.is())
        {
            Reference< XShape > xShapeCandidate;
            const Sequence< PropertyValue > aViewInformation;
            const Sequence< PropertyValue > aParams;

            for(sal_Int32 a(0); a < maShapeSelection->getCount(); a++)
            {
                if((maShapeSelection->getByIndex(a) >>= xShapeCandidate) && xShapeCandidate.is())
                {
                    const Sequence< Reference< XPrimitive2D > > aPrimitiveSequence(
                        xPrimitiveFactory->createPrimitivesFromXShape( xShapeCandidate, aParams ));
                    const sal_Int32 nCount(aPrimitiveSequence.getLength());

                    for(sal_Int32 nIndex = 0; nIndex < nCount; nIndex++)
                    {
                        const RealRectangle2D aRect(aPrimitiveSequence[nIndex]->getRange(aViewInformation));

                        aShapeRange.expand(basegfx::B2DTuple(aRect.X1, aRect.Y1));
                        aShapeRange.expand(basegfx::B2DTuple(aRect.X2, aRect.Y2));
                    }
                }
            }
        }

        if(!aShapeRange.isEmpty())
        {
            nDocX = basegfx::fround(aShapeRange.getMinX());
            nDocY = basegfx::fround(aShapeRange.getMinY());
            nDocWidth  = basegfx::fround(aShapeRange.getWidth());
            nDocHeight = basegfx::fround(aShapeRange.getHeight());
        }
    }

    if( xExtDocHandler.is() && !mpSVGExport->IsUseTinyProfile() )
    {
        xExtDocHandler->unknown( SVG_DTD_STRING );
    }

    mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "version", B2UCONST( "1.2" ) );

    if( mpSVGExport->IsUseTinyProfile() )
         mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "baseProfile", B2UCONST( "tiny" ) );

#ifdef _SVG_WRITE_EXTENTS
	aAttr = OUString::valueOf( nDocWidth * 0.01 );
	aAttr += B2UCONST( "mm" );
	mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "width", aAttr );

	aAttr = OUString::valueOf( nDocHeight * 0.01 );
	aAttr += B2UCONST( "mm" );
	mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "height", aAttr );
#endif

    // #124608# set viewBox explicitely to the exported content
    if(mbExportSelection)
    {
        aAttr = OUString::valueOf( nDocX );
        aAttr += B2UCONST( " " );
        aAttr += OUString::valueOf( nDocY );
        aAttr += B2UCONST( " " );
    }
    else
    {
        aAttr = B2UCONST( "0 0 " );
    }

    aAttr += OUString::valueOf( nDocWidth );
    aAttr += B2UCONST( " " );
    aAttr += OUString::valueOf( nDocHeight );
	mpSVGExport->SetViewBox( Rectangle( Point(nDocX, nDocY), Size( nDocWidth, nDocHeight ) ) );
    mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "viewBox", aAttr );
	mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "preserveAspectRatio", B2UCONST( "xMidYMid" ) );
	mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "fill-rule", B2UCONST( "evenodd" ) );

    // standard line width is based on 1 pixel on a 90 DPI device (0.28222mmm)
    mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "stroke-width", OUString::valueOf( 28.222 ) );
    mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "stroke-linejoin", B2UCONST( "round" ) );

	if( !bSinglePage )
	{
		mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "xmlns:ooo", B2UCONST( "http://xml.openoffice.org/svg/export" ) );
		mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "onclick", B2UCONST( "onClick(evt)" ) );
		mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "onkeypress", B2UCONST( "onKeyPress(evt)" ) );
	}

	mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "xmlns", B2UCONST( "http://www.w3.org/2000/svg" ) );
	mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "xmlns:xlink", B2UCONST( "http://www.w3.org/1999/xlink" ) );

    mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "xml:space", B2UCONST( "preserve" ) );

	mpSVGDoc = new SvXMLElementExport( *mpSVGExport, XML_NAMESPACE_NONE, "svg", sal_True, sal_True );

	while( ( nCurPage <= nLastPage ) && ( -1 == nVisible ) )
	{
		Reference< XDrawPage > xDrawPage;

		rxDrawPages->getByIndex( nCurPage ) >>= xDrawPage;

		if( xDrawPage.is() )
		{
			Reference< XPropertySet > xPropSet( xDrawPage, UNO_QUERY );

			if( xPropSet.is() )
			{
				sal_Bool bVisible = sal_False;

				if( !mbPresentation || bSinglePage ||
					( ( xPropSet->getPropertyValue( B2UCONST( "Visible" ) ) >>= bVisible ) && bVisible ) )
				{
					Reference< XMasterPageTarget > xMasterTarget( xDrawPage, UNO_QUERY );

					if( xMasterTarget.is() )
					{
						Reference< XDrawPage > xMasterPage( xMasterTarget->getMasterPage() );

						nVisible = nCurPage;

						for( sal_Int32 nMaster = 0, nMasterCount = rxMasterPages->getCount();
							 ( nMaster < nMasterCount ) && ( -1 == nVisibleMaster );
							 ++nMaster )
						{
							Reference< XDrawPage > xMasterTestPage;

							rxMasterPages->getByIndex( nMaster ) >>= xMasterTestPage;

							if( xMasterTestPage == xMasterPage )
								nVisibleMaster = nMaster;
						}
					}
				}
			}
		}

		++nCurPage;
	}

    if( mpSVGExport->IsEmbedFonts() )
    {
        mpSVGFontExport->EmbedFonts();
    }

	if( -1 != nVisible )
	{
        if(bSinglePage)
        {
            if(mbExportSelection)
            {
                // #124608# export a given object selection, so no MasterPage export at all
            }
            else
            {
                implExportPages(rxMasterPages,nVisibleMaster,nVisibleMaster,nVisibleMaster,sal_True);
            }
        }
        else
        {
			implGenerateMetaData( rxMasterPages, rxDrawPages );
			implGenerateScript( rxMasterPages, rxDrawPages );
			implExportPages( rxMasterPages, 0, rxMasterPages->getCount() - 1, nVisibleMaster, sal_True );
		}

		implExportPages( rxDrawPages, nFirstPage, nLastPage, nVisible, sal_False );

		delete mpSVGDoc, mpSVGDoc = NULL;
		bRet = sal_True;
	}

    return bRet;
}

// -----------------------------------------------------------------------------

sal_Bool SVGFilter::implGenerateMetaData( const Reference< XDrawPages >& /* rxMasterPages */,
										  const Reference< XDrawPages >& rxDrawPages )
{
	sal_Bool bRet = sal_False;

	if( rxDrawPages->getCount() )
	{
		mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "id", B2UCONST( "meta_slides" ) );
		mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "numberOfSlides", OUString::valueOf( rxDrawPages->getCount() ) );

		{
			SvXMLElementExport	aExp( *mpSVGExport, XML_NAMESPACE_NONE, "ooo:slidesInfo", sal_True, sal_True );
			const OUString		aId( B2UCONST( "meta_slide" ) );

			for( sal_Int32 i = 0, nCount = rxDrawPages->getCount(); i < nCount; ++i )
			{
				OUString						aSlideId( aId );
				Reference< XDrawPage >			xDrawPage( rxDrawPages->getByIndex( i ), UNO_QUERY );
				Reference< XMasterPageTarget >	xMasterPageTarget( xDrawPage, UNO_QUERY );
				Reference< XDrawPage >			xMasterPage( xMasterPageTarget->getMasterPage(), UNO_QUERY );
                sal_Bool                        bMasterVisible = sal_True;
                OUString                        aMasterVisibility;

				aSlideId += OUString::valueOf( i );

                if( mbPresentation )
                {
                    Reference< XPropertySet > xPropSet( xDrawPage, UNO_QUERY );

                    if( xPropSet.is() )
                        xPropSet->getPropertyValue( B2UCONST( "Background" ) )  >>= bMasterVisible;
                }

                if( bMasterVisible )
                    aMasterVisibility = B2UCONST( "visible" );
                else
                    aMasterVisibility = B2UCONST( "hidden" );

                mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "id", aSlideId );
				mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "slide", implGetValidIDFromInterface( xDrawPage ) );
				mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "master", implGetValidIDFromInterface( xMasterPage ) );
				mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "master-visibility", aMasterVisibility );

				{
					SvXMLElementExport aExp2( *mpSVGExport, XML_NAMESPACE_NONE, "ooo:slideInfo", sal_True, sal_True );
				}
			}
		}


		bRet =sal_True;
	}

	return bRet;
}

// -----------------------------------------------------------------------------

sal_Bool SVGFilter::implGenerateScript( const Reference< XDrawPages >& /* rxMasterPages */,
                                        const Reference< XDrawPages >& /* rxDrawPages */ )
{
    mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "type", B2UCONST( "text/ecmascript" ) );

    {
        SvXMLElementExport	                    aExp( *mpSVGExport, XML_NAMESPACE_NONE, "script", sal_True, sal_True );
        Reference< XExtendedDocumentHandler >	xExtDocHandler( mpSVGExport->GetDocHandler(), UNO_QUERY );

        if( xExtDocHandler.is() )
        {
            xExtDocHandler->unknown( OUString::createFromAscii( aSVGScript1 ) );
            xExtDocHandler->unknown( OUString::createFromAscii( aSVGScript2 ) );
        }
    }

    return sal_True;
}

// -----------------------------------------------------------------------------

sal_Bool SVGFilter::implExportPages( const Reference< XDrawPages >& rxPages,
                                     sal_Int32 nFirstPage, sal_Int32 nLastPage,
									 sal_Int32 nVisiblePage, sal_Bool bMaster )
{
    DBG_ASSERT( nFirstPage <= nLastPage,
                "SVGFilter::implExportPages: nFirstPage > nLastPage" );

	sal_Bool bRet = sal_False;

	for( sal_Int32 i = nFirstPage; i <= nLastPage; ++i )
	{
		Reference< XDrawPage > xDrawPage;

		rxPages->getByIndex( i ) >>= xDrawPage;

		if( xDrawPage.is() )
		{
            Reference< XShapes > xShapes;

            if(mbExportSelection)
            {
                // #124608# export a given object selection
                xShapes = maShapeSelection;
            }
            else
            {
                xShapes = Reference< XShapes >( xDrawPage, UNO_QUERY );
            }

			if( xShapes.is() )
			{
                OUString aVisibility, aId, aSlideName( implGetValidIDFromInterface( xShapes, sal_True ) );

	            // add visibility attribute
                if( i == nVisiblePage )
					aVisibility = B2UCONST( "visible" );
				else
					aVisibility = B2UCONST( "hidden" );

	            mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "visibility", aVisibility );

                // add id attribute
                if( bMaster )
                    aId = ( B2UCONST( "MasterSlide_" ) ) += ::rtl::OUString::valueOf( ++mnMasterSlideId );
                else
                    aId = ( B2UCONST( "Slide_" ) ) += ::rtl::OUString::valueOf( ++mnSlideId );

                if( aSlideName.getLength() )
                    ( aId += B2UCONST( "_" ) ) += aSlideName;

                mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "id", aId );

				{
					SvXMLElementExport	aExp( *mpSVGExport, XML_NAMESPACE_NONE, "g", sal_True, sal_True );
					const Point			aNullPt;

                    if( mpObjects->find( xDrawPage ) != mpObjects->end() )
					{
						Reference< XExtendedDocumentHandler > xExtDocHandler( mpSVGExport->GetDocHandler(), UNO_QUERY );

						if( xExtDocHandler.is() )
						{
							SvXMLElementExport	aExp2( *mpSVGExport, XML_NAMESPACE_NONE, "desc", sal_True, sal_True );
							OUString			aDesc;

							if( bMaster )
                                aDesc = B2UCONST( "Master slide" );
							else
								aDesc = B2UCONST( "Slide" );

							xExtDocHandler->unknown( aDesc );
						}
					}

					if( bMaster )
					{
						const GDIMetaFile& rMtf = (*mpObjects)[ xDrawPage ].GetRepresentation();
						mpSVGWriter->WriteMetaFile( aNullPt, rMtf.GetPrefSize(), rMtf, SVGWRITER_WRITE_FILL );
					}

					bRet = implExportShapes( xShapes ) || bRet;
				}
			}
		}
	}

    return bRet;
}

// -----------------------------------------------------------------------------

sal_Bool SVGFilter::implExportShapes( const Reference< XShapes >& rxShapes )
{
    Reference< XShape > xShape;
	sal_Bool			bRet = sal_False;

    for( sal_Int32 i = 0, nCount = rxShapes->getCount(); i < nCount; ++i )
    {
        if( ( rxShapes->getByIndex( i ) >>= xShape ) && xShape.is() )
			bRet = implExportShape( xShape ) || bRet;

        xShape = NULL;
    }

	return bRet;
}

// -----------------------------------------------------------------------------

sal_Bool SVGFilter::implExportShape( const Reference< XShape >& rxShape )
{
    Reference< XPropertySet >   xShapePropSet( rxShape, UNO_QUERY );
    sal_Bool                    bRet = sal_False;

    if( xShapePropSet.is() )
    {
        const ::rtl::OUString   aShapeType( rxShape->getShapeType() );
        sal_Bool                    bHideObj = sal_False;

        if( mbPresentation )
        {
            xShapePropSet->getPropertyValue( B2UCONST( "IsEmptyPresentationObject" ) )  >>= bHideObj;

            if( !bHideObj )
            {
				const Reference< XPropertySet > xDefaultPagePropertySet( mxDefaultPage, UNO_QUERY );
				Reference< XPropertySetInfo > 	xPagePropSetInfo( xDefaultPagePropertySet->getPropertySetInfo() );

                if( xPagePropSetInfo.is() )
                {
                    const ::rtl::OUString aHeaderString( B2UCONST( "IsHeaderVisible" ) );
                    const ::rtl::OUString aFooterString( B2UCONST( "IsFooterVisible" ) );
                    const ::rtl::OUString aDateTimeString( B2UCONST( "IsDateTimeVisible" ) );
                    const ::rtl::OUString aPageNumberString( B2UCONST( "IsPageNumberVisible" ) );

                    Any     aProperty;
                    sal_Bool    bValue = sal_False;

                    if( ( aShapeType.lastIndexOf( B2UCONST( "presentation.HeaderShape" ) ) != -1 ) &&
                        xPagePropSetInfo->hasPropertyByName( aHeaderString ) &&
                        ( ( aProperty = xDefaultPagePropertySet->getPropertyValue( aHeaderString ) ) >>= bValue ) &&
                        !bValue )
                    {
                        bHideObj = sal_True;
                    }
                    else if( ( aShapeType.lastIndexOf( B2UCONST( "presentation.FooterShape" ) ) != -1 ) &&
                                xPagePropSetInfo->hasPropertyByName( aFooterString ) &&
                                ( ( aProperty = xDefaultPagePropertySet->getPropertyValue( aFooterString ) ) >>= bValue ) &&
                            !bValue )
                    {
                        bHideObj = sal_True;
                    }
                    else if( ( aShapeType.lastIndexOf( B2UCONST( "presentation.DateTimeShape" ) ) != -1 ) &&
                                xPagePropSetInfo->hasPropertyByName( aDateTimeString ) &&
                                ( ( aProperty = xDefaultPagePropertySet->getPropertyValue( aDateTimeString ) ) >>= bValue ) &&
                            !bValue )
                    {
                        bHideObj = sal_True;
                    }
                    else if( ( aShapeType.lastIndexOf( B2UCONST( "presentation.SlideNumberShape" ) ) != -1 ) &&
                                xPagePropSetInfo->hasPropertyByName( aPageNumberString ) &&
                                ( ( aProperty = xDefaultPagePropertySet->getPropertyValue( aPageNumberString ) ) >>= bValue ) &&
                            !bValue )
                    {
                        bHideObj = sal_True;
                    }
                }
            }
        }

        if( !bHideObj )
        {
		    if( aShapeType.lastIndexOf( B2UCONST( "drawing.GroupShape" ) ) != -1 )
		    {
			    Reference< XShapes > xShapes( rxShape, UNO_QUERY );

			    if( xShapes.is() )
			    {
                    OUString    aId( B2UCONST( "DrawingGroup_" ) );
                    OUString    aObjName( implGetValidIDFromInterface( rxShape, sal_True ) ), aObjDesc;

                    aId += ::rtl::OUString::valueOf( ++mnDrawingGroupId );

                    if( aObjName.getLength() )
                        ( aId += B2UCONST( "_" ) ) += aObjName;

                    mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "id", aId );

                    {
						SvXMLElementExport aExp( *mpSVGExport, XML_NAMESPACE_NONE, "g", sal_True, sal_True );
        			    bRet = implExportShapes( xShapes );
                    }
                }
		    }

		    if( !bRet && mpObjects->find( rxShape ) !=  mpObjects->end() )
		    {
 			    Reference< XText >                  xText( rxShape, UNO_QUERY );
				::com::sun::star::awt::Rectangle    aBoundRect;
				const GDIMetaFile&					rMtf = (*mpObjects)[ rxShape ].GetRepresentation();

                xShapePropSet->getPropertyValue( B2UCONST( "BoundRect" ) ) >>= aBoundRect;

                const Point aTopLeft( aBoundRect.X, aBoundRect.Y );
                const Size  aSize( aBoundRect.Width, aBoundRect.Height );

                if( rMtf.GetActionCount() )
                {
                    OUString aId( B2UCONST( "Drawing_" ) );
                    OUString aObjName( implGetValidIDFromInterface( rxShape, sal_True ) ), aObjDesc;

                    aId += ::rtl::OUString::valueOf( ++mnDrawingId );

                    if( aObjName.getLength() )
                        ( aId += B2UCONST( "_" ) ) += aObjName;

                    {
                        if( ( aShapeType.lastIndexOf( B2UCONST( "drawing.OLE2Shape" ) ) != -1 ) ||
                            ( aShapeType.lastIndexOf( B2UCONST( "drawing.GraphicObjectShape" ) ) != -1 ) )
                        {
                            mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "id", aId );

                            {
                                SvXMLElementExport aExp( *mpSVGExport, XML_NAMESPACE_NONE, "g", sal_True, sal_True );
                                mpSVGWriter->WriteMetaFile( aTopLeft, aSize, rMtf, SVGWRITER_WRITE_FILL | SVGWRITER_WRITE_TEXT );
                            }
                        }
                        else
                        {
                            if( implHasText( rMtf ) )
                            {
                                mpSVGExport->AddAttribute( XML_NAMESPACE_NONE, "id", aId );

                                {
                                    SvXMLElementExport aExp( *mpSVGExport, XML_NAMESPACE_NONE, "g", sal_True, sal_True );
                                    mpSVGWriter->WriteMetaFile( aTopLeft, aSize, rMtf, SVGWRITER_WRITE_FILL );
                                    mpSVGWriter->WriteMetaFile( aTopLeft, aSize, rMtf, SVGWRITER_WRITE_TEXT );
                                }
                            }
                            else
                            {
                                SvXMLElementExport aExp( *mpSVGExport, XML_NAMESPACE_NONE, "g", sal_True, sal_True );
                                mpSVGWriter->WriteMetaFile( aTopLeft, aSize, rMtf, SVGWRITER_WRITE_FILL | SVGWRITER_WRITE_TEXT, &aId );
                            }
                        }
                    }
                }

				bRet = sal_True;
		    }
        }
    }

    return bRet;
}

// -----------------------------------------------------------------------------

sal_Bool SVGFilter::implCreateObjects( const Reference< XDrawPages >& rxMasterPages,
								       const Reference< XDrawPages >& rxDrawPages,
                                       sal_Int32 nPageToExport )
{
    if( SVG_EXPORT_ALLPAGES == nPageToExport )
    {
        // export the whole document
	    sal_Int32 i, nCount;

        for( i = 0, nCount = rxMasterPages->getCount(); i < nCount; ++i )
    	{
    		Reference< XDrawPage > xMasterPage;

    		rxMasterPages->getByIndex( i ) >>= xMasterPage;

    		if( xMasterPage.is() )
    		{
    			Reference< XShapes > xShapes( xMasterPage, UNO_QUERY );

    			implCreateObjectsFromBackground( xMasterPage );

    			if( xShapes.is() )
    				implCreateObjectsFromShapes( xShapes );
    		}
    	}

    	for( i = 0, nCount = rxDrawPages->getCount(); i < nCount; ++i )
    	{
    		Reference< XDrawPage > xDrawPage;

    		rxDrawPages->getByIndex( i ) >>= xDrawPage;

    		if( xDrawPage.is() )
    		{
    			Reference< XShapes > xShapes( xDrawPage, UNO_QUERY );

    			if( xShapes.is() )
    				implCreateObjectsFromShapes( xShapes );
    		}
    	}
    }
    else
    {
        DBG_ASSERT( nPageToExport >= 0 && nPageToExport < rxDrawPages->getCount(),
                    "SVGFilter::implCreateObjects: invalid page number to export" );

        if(mbExportSelection)
        {
            // #124608# export a given object selection
            implCreateObjectsFromShapes(maShapeSelection);
        }
        else
        {
            // export a given xDrawPage
            Reference< XDrawPage > xDrawPage;

            rxDrawPages->getByIndex(nPageToExport) >>= xDrawPage;

            if(xDrawPage.is())
            {
                Reference< XMasterPageTarget > xMasterTarget(xDrawPage,UNO_QUERY);

                if(xMasterTarget.is())
                {
                    Reference< XDrawPage > xMasterPage(xMasterTarget->getMasterPage());

                    if(xMasterPage.is())
                    {
                        Reference< XShapes > xShapes(xMasterPage,UNO_QUERY);

                        implCreateObjectsFromBackground(xMasterPage);

                        if(xShapes.is())
                            implCreateObjectsFromShapes(xShapes);
                    }
                }

                Reference< XShapes > xShapes(xDrawPage,UNO_QUERY);

                if(xShapes.is())
                    implCreateObjectsFromShapes(xShapes);
            }
        }
    }

	return sal_True;
}

// -----------------------------------------------------------------------------

sal_Bool SVGFilter::implCreateObjectsFromShapes( const Reference< XShapes >& rxShapes )
{
    Reference< XShape > xShape;
	sal_Bool			bRet = sal_False;

    for( sal_Int32 i = 0, nCount = rxShapes->getCount(); i < nCount; ++i )
    {
        if( ( rxShapes->getByIndex( i ) >>= xShape ) && xShape.is() )
			bRet = implCreateObjectsFromShape( xShape ) || bRet;

        xShape = NULL;
    }

	return bRet;
}

// -----------------------------------------------------------------------------

sal_Bool SVGFilter::implCreateObjectsFromShape( const Reference< XShape >& rxShape )
{
    sal_Bool bRet = sal_False;

	if( rxShape->getShapeType().lastIndexOf( B2UCONST( "drawing.GroupShape" ) ) != -1 )
	{
		Reference< XShapes > xShapes( rxShape, UNO_QUERY );

		if( xShapes.is() )
			bRet = implCreateObjectsFromShapes( xShapes );
	}
	else
	{
		SdrObject*  pObj = GetSdrObjectFromXShape( rxShape );

		if( pObj )
		{
			Graphic aGraphic( SdrExchangeView::GetObjGraphic( pObj->GetModel(), pObj ) );

			if( aGraphic.GetType() != GRAPHIC_NONE )
			{
				if( aGraphic.GetType() == GRAPHIC_BITMAP )
				{
					GDIMetaFile	aMtf;
					const Point	aNullPt;
					const Size	aSize( pObj->GetCurrentBoundRect().GetSize() );

					aMtf.AddAction( new MetaBmpExScaleAction( aNullPt, aSize, aGraphic.GetBitmapEx() ) );
					aMtf.SetPrefSize( aSize );
					aMtf.SetPrefMapMode( MAP_100TH_MM );

					(*mpObjects)[ rxShape ] = ObjectRepresentation( rxShape, aMtf );
				}
				else
					(*mpObjects)[ rxShape ] = ObjectRepresentation( rxShape, aGraphic.GetGDIMetaFile() );

				bRet = sal_True;
			}
		}
	}

    return bRet;
}

// -----------------------------------------------------------------------------

sal_Bool SVGFilter::implCreateObjectsFromBackground( const Reference< XDrawPage >& rxMasterPage )
{
	Reference< XExporter >	xExporter( mxMSF->createInstance( B2UCONST( "com.sun.star.drawing.GraphicExportFilter" ) ), UNO_QUERY );
	sal_Bool				bRet = sal_False;

	if( xExporter.is() )
	{
		GDIMetaFile				aMtf;
		Reference< XFilter >	xFilter( xExporter, UNO_QUERY );

		utl::TempFile aFile;
		aFile.EnableKillingFile();

		Sequence< PropertyValue > aDescriptor( 3 );
		aDescriptor[0].Name = B2UCONST( "FilterName" );
		aDescriptor[0].Value <<= B2UCONST( "SVM" );
		aDescriptor[1].Name = B2UCONST( "URL" );
		aDescriptor[1].Value <<= OUString( aFile.GetURL() );
		aDescriptor[2].Name = B2UCONST( "ExportOnlyBackground" );
		aDescriptor[2].Value <<= (sal_Bool) sal_True;

		xExporter->setSourceDocument( Reference< XComponent >( rxMasterPage, UNO_QUERY ) );
		xFilter->filter( aDescriptor );
		aMtf.Read( *aFile.GetStream( STREAM_READ ) );

		(*mpObjects)[ rxMasterPage ] = ObjectRepresentation( rxMasterPage, aMtf );

		bRet = sal_True;
	}

	return bRet;
}

// -----------------------------------------------------------------------------

OUString SVGFilter::implGetDescriptionFromShape( const Reference< XShape >& rxShape )
{
	OUString			aRet;
    const OUString      aShapeType( rxShape->getShapeType() );

	if( aShapeType.lastIndexOf( B2UCONST( "drawing.GroupShape" ) ) != -1 )
		aRet = B2UCONST( "Group" );
	else if( aShapeType.lastIndexOf( B2UCONST( "drawing.GraphicObjectShape" ) ) != -1 )
		aRet = B2UCONST( "Graphic" );
	else if( aShapeType.lastIndexOf( B2UCONST( "drawing.OLE2Shape" ) ) != -1 )
		aRet = B2UCONST( "OLE2" );
    else if( aShapeType.lastIndexOf( B2UCONST( "presentation.HeaderShape" ) ) != -1 )
		aRet = B2UCONST( "Header" );
    else if( aShapeType.lastIndexOf( B2UCONST( "presentation.FooterShape" ) ) != -1 )
		aRet = B2UCONST( "Footer" );
    else if( aShapeType.lastIndexOf( B2UCONST( "presentation.DateTimeShape" ) ) != -1 )
		aRet = B2UCONST( "Date/Time" );
    else if( aShapeType.lastIndexOf( B2UCONST( "presentation.SlideNumberShape" ) ) != -1 )
		aRet = B2UCONST( "Slide Number" );
	else
		aRet = B2UCONST( "Drawing" );

	return aRet;
}

// -----------------------------------------------------------------------------

OUString SVGFilter::implGetValidIDFromInterface( const Reference< XInterface >& rxIf, sal_Bool bUnique )
{
	Reference< XNamed > xNamed( rxIf, UNO_QUERY );
	OUString			aRet;

	if( xNamed.is() )
    {
        aRet = xNamed->getName().replace( ' ', '_' ).
               replace( ':', '_' ).
               replace( ',', '_' ).
               replace( ';', '_' ).
               replace( '&', '_' ).
               replace( '!', '_' ).
               replace( '|', '_' );
    }

    if( ( aRet.getLength() > 0 ) && bUnique )
    {
        while( ::std::find( maUniqueIdVector.begin(), maUniqueIdVector.end(), aRet ) != maUniqueIdVector.end() )
        {
            aRet += B2UCONST( "_" );
        }

        maUniqueIdVector.push_back( aRet );
    }

	return aRet;
}

// -----------------------------------------------------------------------------

sal_Bool SVGFilter::implHasText( const GDIMetaFile& rMtf ) const
{
    sal_Bool bRet = sal_False;

    for( sal_uInt32 nCurAction = 0, nCount = rMtf.GetActionCount(); ( nCurAction < nCount ) && !bRet; ++nCurAction )
    {
        switch( rMtf.GetAction( nCurAction )->GetType() )
        {
            case( META_TEXT_ACTION ):
            case( META_TEXTRECT_ACTION ):
            case( META_TEXTARRAY_ACTION ):
            case( META_STRETCHTEXT_ACTION ):
            {
                bRet = sal_True;
            }
            break;

            default:
            break;
        }
    }

    return bRet;
}

// -----------------------------------------------------------------------------

IMPL_LINK( SVGFilter, CalcFieldHdl, EditFieldInfo*, pInfo )
{
	OUString   aRepresentation;
    sal_Bool       bFieldProcessed = sal_False;

	if( pInfo )
	{
		const ::rtl::OUString aHeaderText( B2UCONST( "HeaderText" ) );
		const ::rtl::OUString aFooterText( B2UCONST( "FooterText" ) );
		const ::rtl::OUString aDateTimeText( B2UCONST( "DateTimeText" ) );
		const ::rtl::OUString aPageNumberText( B2UCONST( "Number" ) );

		const Reference< XPropertySet >	xDefaultPagePropertySet( mxDefaultPage, UNO_QUERY );
		Reference< XPropertySetInfo > 	xDefaultPagePropSetInfo( xDefaultPagePropertySet->getPropertySetInfo() );

		if( xDefaultPagePropSetInfo.is() )
		{
			const SvxFieldData* pField = pInfo->GetField().GetField();
			Any     			aProperty;

			if( pField->ISA( SvxHeaderField ) &&
				xDefaultPagePropSetInfo->hasPropertyByName( aHeaderText ) )
			{
				xDefaultPagePropertySet->getPropertyValue( aHeaderText ) >>= aRepresentation;
                bFieldProcessed = sal_True;
			}
			else if( pField->ISA( SvxFooterField ) &&
					 xDefaultPagePropSetInfo->hasPropertyByName( aFooterText ) )
			{
				xDefaultPagePropertySet->getPropertyValue( aFooterText ) >>= aRepresentation;
                bFieldProcessed = sal_True;
			}
			else if( pField->ISA( SvxDateTimeField ) &&
					 xDefaultPagePropSetInfo->hasPropertyByName( aDateTimeText ) )
			{
				xDefaultPagePropertySet->getPropertyValue( aDateTimeText ) >>= aRepresentation;
                bFieldProcessed = sal_True;
			}
			else if( pField->ISA( SvxPageField ) &&
					 xDefaultPagePropSetInfo->hasPropertyByName( aPageNumberText ) )
			{
	            String     aPageNumValue;
				sal_Int16  nPageNumber = 0;

                xDefaultPagePropertySet->getPropertyValue( aPageNumberText ) >>= nPageNumber;

                if( mpSdrModel )
                {
                    sal_Bool bUpper = sal_False;

                	switch( mpSdrModel->GetPageNumType() )
                    {
                        case SVX_CHARS_UPPER_LETTER:
                            aPageNumValue += (sal_Unicode)(char)( ( nPageNumber - 1 ) % 26 + 'A' );
                            break;
                        case SVX_CHARS_LOWER_LETTER:
                            aPageNumValue += (sal_Unicode)(char)( ( nPageNumber- 1 ) % 26 + 'a' );
                            break;
                        case SVX_ROMAN_UPPER:
                            bUpper = sal_True;
                        case SVX_ROMAN_LOWER:
                            aPageNumValue += SvxNumberFormat::CreateRomanString( nPageNumber, bUpper );
                            break;
                        case SVX_NUMBER_NONE:
                            aPageNumValue.Erase();
                            aPageNumValue += sal_Unicode(' ');
                            break;
						default : break;
                    }
               	}

                if( !aPageNumValue.Len() )
                    aPageNumValue += String::CreateFromInt32( nPageNumber );

                aRepresentation = aPageNumValue;
                bFieldProcessed = sal_True;
			}
		}

		pInfo->SetRepresentation( aRepresentation );
	}

	return( bFieldProcessed ? 0 : maOldFieldHdl.Call( pInfo ) );
}

// -----------------------------------------------------------------------------

void SVGExport::writeMtf( const GDIMetaFile& rMtf )
{
	const Size									aSize( OutputDevice::LogicToLogic( rMtf.GetPrefSize(), rMtf.GetPrefMapMode(), MAP_MM ) );
	rtl::OUString							aAttr;
	REF( NMSP_SAX::XExtendedDocumentHandler )	xExtDocHandler( GetDocHandler(), NMSP_UNO::UNO_QUERY );

	if( xExtDocHandler.is() )
		xExtDocHandler->unknown( SVG_DTD_STRING );

	aAttr = rtl::OUString::valueOf( aSize.Width() );
	aAttr += B2UCONST( "mm" );
	AddAttribute( XML_NAMESPACE_NONE, "width", aAttr );

	aAttr = rtl::OUString::valueOf( aSize.Height() );
	aAttr += B2UCONST( "mm" );
	AddAttribute( XML_NAMESPACE_NONE, "height", aAttr );

	aAttr = B2UCONST( "0 0 " );
	aAttr += rtl::OUString::valueOf( aSize.Width() * 100L );
	aAttr += B2UCONST( " " );
	aAttr += rtl::OUString::valueOf( aSize.Height() * 100L );
	AddAttribute( XML_NAMESPACE_NONE, "viewBox", aAttr );
	SetViewBox( Rectangle( Point(), Size( aSize.Width() * 100, aSize.Height() * 100 ) ) );

	// standard line width is based on 1 pixel on a 90 DPI device (0.28222mmm)
	AddAttribute( XML_NAMESPACE_NONE, "stroke-width", OUString::valueOf( 28.222 ) );
	AddAttribute( XML_NAMESPACE_NONE, "stroke-linejoin", B2UCONST( "round" ) );

	AddAttribute( XML_NAMESPACE_NONE, "xml:space", B2UCONST( "preserve" ) );
	{
		SvXMLElementExport	aSVG( *this, XML_NAMESPACE_NONE, "svg", sal_True, sal_True );

		std::vector< ObjectRepresentation > aObjects;

		aObjects.push_back( ObjectRepresentation( Reference< XInterface >(), rMtf ) );
		SVGFontExport aSVGFontExport( *this, aObjects );

		Point aPoint100thmm( OutputDevice::LogicToLogic( rMtf.GetPrefMapMode().GetOrigin(), rMtf.GetPrefMapMode(), MAP_100TH_MM ) );
		Size  aSize100thmm( OutputDevice::LogicToLogic( rMtf.GetPrefSize(), rMtf.GetPrefMapMode(), MAP_100TH_MM ) );

		SVGActionWriter		aWriter( *this, aSVGFontExport );
		aWriter.WriteMetaFile( aPoint100thmm, aSize100thmm, rMtf,
			SVGWRITER_WRITE_FILL | SVGWRITER_WRITE_TEXT, NULL );
	}
}