Combine a pointlessly split class implementation and bin unused private field

Change-Id: I44cee32e256e0767bb3b40bdba93e15b717c9ba6

6 files changed, 3785 insertions, 3914 deletions

diff --git a/include/xmloff/shapeexport.hxx b/include/xmloff/shapeexport.hxx
index 8dfaa0f89d5e..6dbe719cc352 100644
--- a/include/xmloff/shapeexport.hxx
+++ b/include/xmloff/shapeexport.hxx
@@ -162,7 +162,6 @@ private:
     UniReference< XMLPropertyHandlerFactory >   mxSdPropHdlFactory;
     UniReference< SvXMLExportPropertyMapper >   mxPropertySetMapper;
     UniReference< XMLAnimationsExporter >       mxAnimationsExporter;
-    sal_Int32                                   mnNextUniqueShapeId;
     ShapesInfos                                 maShapesInfos;
     ShapesInfos::iterator                       maCurrentShapesIter;
     sal_Bool                                    mbExportLayer;
diff --git a/xmloff/Library_xo.mk b/xmloff/Library_xo.mk
index b72172b8cb3a..46ae11fbe24a 100644
--- a/xmloff/Library_xo.mk
+++ b/xmloff/Library_xo.mk
@@ -138,9 +138,6 @@ $(eval $(call gb_Library_add_exception_objects,xo,\
     xmloff/source/draw/sdxmlexp \
     xmloff/source/draw/sdxmlimp \
     xmloff/source/draw/shapeexport \
-    xmloff/source/draw/shapeexport2 \
-    xmloff/source/draw/shapeexport3 \
-    xmloff/source/draw/shapeexport4 \
     xmloff/source/draw/shapeimport \
     xmloff/source/draw/xexptran \
     xmloff/source/draw/ximp3dobject \
diff --git a/xmloff/source/draw/shapeexport.cxx b/xmloff/source/draw/shapeexport.cxx
index 6274da4c7f30..16f5d173b282 100644
--- a/xmloff/source/draw/shapeexport.cxx
+++ b/xmloff/source/draw/shapeexport.cxx
@@ -19,47 +19,99 @@
 
 #include <memory>
 
-#include <xmloff/unointerfacetouniqueidentifiermapper.hxx>
-#include <com/sun/star/presentation/ClickAction.hpp>
-#include <com/sun/star/lang/ServiceNotRegisteredException.hpp>
-#include <com/sun/star/container/XChild.hpp>
-#include <com/sun/star/text/XText.hpp>
+#include <basegfx/matrix/b2dhommatrix.hxx>
+#include <basegfx/tuple/b2dtuple.hxx>
+#include <basegfx/vector/b3dvector.hxx>
+
+#include <com/sun/star/beans/XPropertyState.hpp>
+#include <com/sun/star/beans/PropertyValues.hpp>
 #include <com/sun/star/chart/XChartDocument.hpp>
-#include <com/sun/star/drawing/XControlShape.hpp>
-#include <com/sun/star/style/XStyle.hpp>
-#include <com/sun/star/drawing/XGluePointsSupplier.hpp>
+#include <com/sun/star/container/XChild.hpp>
+#include <com/sun/star/container/XEnumerationAccess.hpp>
 #include <com/sun/star/container/XIdentifierAccess.hpp>
-#include <com/sun/star/drawing/GluePoint2.hpp>
+#include <com/sun/star/container/XIdentifierContainer.hpp>
+#include <com/sun/star/container/XNamed.hpp>
+#include <com/sun/star/document/XEventsSupplier.hpp>
 #include <com/sun/star/drawing/Alignment.hpp>
+#include <com/sun/star/drawing/CameraGeometry.hpp>
+#include <com/sun/star/drawing/CircleKind.hpp>
+#include <com/sun/star/drawing/ConnectorType.hpp>
+#include <com/sun/star/drawing/Direction3D.hpp>
+#include <com/sun/star/drawing/DoubleSequence.hpp>
 #include <com/sun/star/drawing/EscapeDirection.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeAdjustmentValue.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeGluePointType.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeParameterPair.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeParameterType.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeSegment.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeSegmentCommand.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeTextFrame.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeTextPathMode.hpp>
+#include <com/sun/star/drawing/GluePoint2.hpp>
+#include <com/sun/star/drawing/HomogenMatrix.hpp>
+#include <com/sun/star/drawing/HomogenMatrix3.hpp>
+#include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
+#include <com/sun/star/drawing/PolyPolygonShape3D.hpp>
+#include <com/sun/star/drawing/Position3D.hpp>
+#include <com/sun/star/drawing/ProjectionMode.hpp>
+#include <com/sun/star/drawing/ShadeMode.hpp>
+#include <com/sun/star/drawing/XControlShape.hpp>
+#include <com/sun/star/drawing/XCustomShapeEngine.hpp>
+#include <com/sun/star/drawing/XGluePointsSupplier.hpp>
+#include <com/sun/star/embed/ElementModes.hpp>
+#include <com/sun/star/embed/XTransactedObject.hpp>
+#include <com/sun/star/graphic/XGraphic.hpp>
+#include <com/sun/star/graphic/GraphicProvider.hpp>
+#include <com/sun/star/graphic/XGraphicProvider.hpp>
+#include <com/sun/star/io/XSeekableInputStream.hpp>
+#include <com/sun/star/lang/ServiceNotRegisteredException.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/media/ZoomLevel.hpp>
+#include <com/sun/star/presentation/AnimationSpeed.hpp>
+#include <com/sun/star/presentation/ClickAction.hpp>
+#include <com/sun/star/style/XStyle.hpp>
 #include <com/sun/star/table/XColumnRowRange.hpp>
-#include <xmloff/xmluconv.hxx>
-#include "PropertySetMerger.hxx"
+#include <com/sun/star/text/XText.hpp>
 
-#include <xmloff/shapeexport.hxx>
-#include "sdpropls.hxx"
-#include "sdxmlexp_impl.hxx"
-#include <xmloff/families.hxx>
-#include <tools/debug.hxx>
-#include <xmloff/contextid.hxx>
-#include <xmloff/xmltoken.hxx>
 #include <comphelper/classids.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/storagehelper.hxx>
+
+#include <rtl/math.hxx>
+#include <rtl/ustrbuf.hxx>
+
+#include <sax/tools/converter.hxx>
+
+#include <tools/debug.hxx>
 #include <tools/globname.hxx>
-#include <com/sun/star/beans/XPropertyState.hpp>
+#include <tools/helpers.hxx>
 
-#include <comphelper/processfactory.hxx>
-#include <com/sun/star/lang/XMultiServiceFactory.hpp>
-#include <com/sun/star/drawing/XCustomShapeEngine.hpp>
+#include <xmloff/contextid.hxx>
+#include <xmloff/families.hxx>
+#include <xmloff/nmspmap.hxx>
+#include <xmloff/shapeexport.hxx>
+#include <xmloff/unointerfacetouniqueidentifiermapper.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <xmloff/xmlnmspe.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
 
-#include "xmloff/xmlnmspe.hxx"
+#include "anim.hxx"
+#include "EnhancedCustomShapeToken.hxx"
+#include "PropertySetMerger.hxx"
+#include "sdpropls.hxx"
+#include "sdxmlexp_impl.hxx"
+#include "xexptran.hxx"
+#include "XMLBase64Export.hxx"
+#include "XMLImageMapExport.hxx"
 
 using namespace ::com::sun::star;
+using namespace ::xmloff::EnhancedCustomShapeToken;
 using namespace ::xmloff::token;
 
 XMLShapeExport::XMLShapeExport(SvXMLExport& rExp,
                                 SvXMLExportPropertyMapper *pExtMapper )
 :   mrExport( rExp ),
-    mnNextUniqueShapeId(1),
     maShapesInfos(),
     maCurrentShapesIter(maShapesInfos.end()),
     mbExportLayer( sal_False ),
@@ -1214,4 +1266,3713 @@ const rtl::Reference< XMLTableExport >& XMLShapeExport::GetShapeTableExport()
     return mxShapeTableExport;
 }
 
+void XMLShapeExport::ImpExportNewTrans(const uno::Reference< beans::XPropertySet >& xPropSet,
+    sal_Int32 nFeatures, awt::Point* pRefPoint)
+{
+    // get matrix
+    ::basegfx::B2DHomMatrix aMatrix;
+    ImpExportNewTrans_GetB2DHomMatrix(aMatrix, xPropSet);
+
+    // decompose and correct abour pRefPoint
+    ::basegfx::B2DTuple aTRScale;
+    double fTRShear(0.0);
+    double fTRRotate(0.0);
+    ::basegfx::B2DTuple aTRTranslate;
+    ImpExportNewTrans_DecomposeAndRefPoint(aMatrix, aTRScale, fTRShear, fTRRotate, aTRTranslate, pRefPoint);
+
+    // use features and write
+    ImpExportNewTrans_FeaturesAndWrite(aTRScale, fTRShear, fTRRotate, aTRTranslate, nFeatures);
+}
+
+void XMLShapeExport::ImpExportNewTrans_GetB2DHomMatrix(::basegfx::B2DHomMatrix& rMatrix,
+    const uno::Reference< beans::XPropertySet >& xPropSet)
+{
+    /* Get <TransformationInHoriL2R>, if it exist
+       and if the document is exported into the OpenOffice.org file format.
+       This property only exists at service com::sun::star::text::Shape - the
+       Writer UNO service for shapes.
+       This code is needed, because the positioning attributes in the
+       OpenOffice.org file format are given in horizontal left-to-right layout
+       regardless the layout direction the shape is in. In the OASIS Open Office
+       file format the positioning attributes are correctly given in the layout
+       direction the shape is in. Thus, this code provides the conversion from
+       the OASIS Open Office file format to the OpenOffice.org file format. (#i28749#)
+    */
+    uno::Any aAny;
+    if ( ( GetExport().getExportFlags() & EXPORT_OASIS ) == 0 &&
+         xPropSet->getPropertySetInfo()->hasPropertyByName(
+            OUString("TransformationInHoriL2R")) )
+    {
+        aAny = xPropSet->getPropertyValue("TransformationInHoriL2R");
+    }
+    else
+    {
+        aAny = xPropSet->getPropertyValue("Transformation");
+    }
+    drawing::HomogenMatrix3 aMatrix;
+    aAny >>= aMatrix;
+
+    rMatrix.set(0, 0, aMatrix.Line1.Column1);
+    rMatrix.set(0, 1, aMatrix.Line1.Column2);
+    rMatrix.set(0, 2, aMatrix.Line1.Column3);
+    rMatrix.set(1, 0, aMatrix.Line2.Column1);
+    rMatrix.set(1, 1, aMatrix.Line2.Column2);
+    rMatrix.set(1, 2, aMatrix.Line2.Column3);
+    rMatrix.set(2, 0, aMatrix.Line3.Column1);
+    rMatrix.set(2, 1, aMatrix.Line3.Column2);
+    rMatrix.set(2, 2, aMatrix.Line3.Column3);
+}
+
+void XMLShapeExport::ImpExportNewTrans_DecomposeAndRefPoint(const ::basegfx::B2DHomMatrix& rMatrix, ::basegfx::B2DTuple& rTRScale,
+    double& fTRShear, double& fTRRotate, ::basegfx::B2DTuple& rTRTranslate, com::sun::star::awt::Point* pRefPoint)
+{
+    // decompose matrix
+    rMatrix.decompose(rTRScale, rTRTranslate, fTRRotate, fTRShear);
+
+    // correct translation about pRefPoint
+    if(pRefPoint)
+    {
+        rTRTranslate -= ::basegfx::B2DTuple(pRefPoint->X, pRefPoint->Y);
+    }
+}
+
+void XMLShapeExport::ImpExportNewTrans_FeaturesAndWrite(::basegfx::B2DTuple& rTRScale, double fTRShear,
+    double fTRRotate, ::basegfx::B2DTuple& rTRTranslate, const sal_Int32 nFeatures)
+{
+    // always write Size (rTRScale) since this statement carries the union
+    // of the object
+    OUString aStr;
+    OUStringBuffer sStringBuffer;
+    ::basegfx::B2DTuple aTRScale(rTRScale);
+
+    // svg: width
+    if(!(nFeatures & SEF_EXPORT_WIDTH))
+    {
+        aTRScale.setX(1.0);
+    }
+    else
+    {
+        if( aTRScale.getX() > 0.0 )
+            aTRScale.setX(aTRScale.getX() - 1.0);
+        else if( aTRScale.getX() < 0.0 )
+            aTRScale.setX(aTRScale.getX() + 1.0);
+    }
+
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+            FRound(aTRScale.getX()));
+    aStr = sStringBuffer.makeStringAndClear();
+    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_WIDTH, aStr);
+
+    // svg: height
+    if(!(nFeatures & SEF_EXPORT_HEIGHT))
+    {
+        aTRScale.setY(1.0);
+    }
+    else
+    {
+        if( aTRScale.getY() > 0.0 )
+            aTRScale.setY(aTRScale.getY() - 1.0);
+        else if( aTRScale.getY() < 0.0 )
+            aTRScale.setY(aTRScale.getY() + 1.0);
+    }
+
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+            FRound(aTRScale.getY()));
+    aStr = sStringBuffer.makeStringAndClear();
+    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_HEIGHT, aStr);
+
+    // decide if transformation is necessary
+    sal_Bool bTransformationIsNeccessary(fTRShear != 0.0 || fTRRotate != 0.0);
+
+    if(bTransformationIsNeccessary)
+    {
+        // write transformation, but WITHOUT scale which is exported as size above
+        SdXMLImExTransform2D aTransform;
+
+        aTransform.AddSkewX(atan(fTRShear));
+
+        // #i78696#
+        // fTRRotate is mathematically correct, but due to the error
+        // we export/import it mirrored. Since the API implementation is fixed and
+        // uses the correctly oriented angle, it is necessary for compatibility to
+        // mirror the angle here to stay at the old behaviour. There is a follow-up
+        // task (#i78698#) to fix this in the next ODF FileFormat version
+        aTransform.AddRotate(-fTRRotate);
+
+        aTransform.AddTranslate(rTRTranslate);
+
+        // does transformation need to be exported?
+        if(aTransform.NeedsAction())
+            mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_TRANSFORM, aTransform.GetExportString(mrExport.GetMM100UnitConverter()));
+    }
+    else
+    {
+        // no shear, no rotate; just add object position to export and we are done
+        if(nFeatures & SEF_EXPORT_X)
+        {
+            // svg: x
+            mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                    FRound(rTRTranslate.getX()));
+            aStr = sStringBuffer.makeStringAndClear();
+            mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X, aStr);
+        }
+
+        if(nFeatures & SEF_EXPORT_Y)
+        {
+            // svg: y
+            mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                    FRound(rTRTranslate.getY()));
+            aStr = sStringBuffer.makeStringAndClear();
+            mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y, aStr);
+        }
+    }
+}
+
+sal_Bool XMLShapeExport::ImpExportPresentationAttributes( const uno::Reference< beans::XPropertySet >& xPropSet, const OUString& rClass )
+{
+    sal_Bool bIsEmpty = sal_False;
+
+    // write presentation class entry
+    mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_CLASS, rClass);
+
+    if( xPropSet.is() )
+    {
+        uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
+
+        sal_Bool bTemp = false;
+
+        // is empty pes shape?
+        if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName("IsEmptyPresentationObject"))
+        {
+            xPropSet->getPropertyValue("IsEmptyPresentationObject") >>= bIsEmpty;
+            if( bIsEmpty )
+                mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_PLACEHOLDER, XML_TRUE);
+        }
+
+        // is user-transformed?
+        if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName("IsPlaceholderDependent"))
+        {
+            xPropSet->getPropertyValue("IsPlaceholderDependent") >>= bTemp;
+            if(!bTemp)
+                mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_USER_TRANSFORMED, XML_TRUE);
+        }
+    }
+
+    return bIsEmpty;
+}
+
+void XMLShapeExport::ImpExportText( const uno::Reference< drawing::XShape >& xShape )
+{
+    uno::Reference< text::XText > xText( xShape, uno::UNO_QUERY );
+    if( xText.is() )
+    {
+        uno::Reference< container::XEnumerationAccess > xEnumAccess( xShape, uno::UNO_QUERY );
+        if( xEnumAccess.is() && xEnumAccess->hasElements() )
+            mrExport.GetTextParagraphExport()->exportText( xText );
+    }
+}
+
+
+namespace {
+
+const sal_Int32 FOUND_CLICKACTION       = 0x00000001;
+const sal_Int32 FOUND_BOOKMARK          = 0x00000002;
+const sal_Int32 FOUND_EFFECT            = 0x00000004;
+const sal_Int32 FOUND_PLAYFULL          = 0x00000008;
+const sal_Int32 FOUND_VERB              = 0x00000010;
+const sal_Int32 FOUND_SOUNDURL          = 0x00000020;
+const sal_Int32 FOUND_SPEED             = 0x00000040;
+const sal_Int32 FOUND_CLICKEVENTTYPE    = 0x00000080;
+const sal_Int32 FOUND_MACRO             = 0x00000100;
+const sal_Int32 FOUND_LIBRARY           = 0x00000200;
+
+} // namespace
+
+void XMLShapeExport::ImpExportEvents( const uno::Reference< drawing::XShape >& xShape )
+{
+    uno::Reference< document::XEventsSupplier > xEventsSupplier( xShape, uno::UNO_QUERY );
+    if( !xEventsSupplier.is() )
+        return;
+
+    uno::Reference< container::XNameAccess > xEvents( xEventsSupplier->getEvents(), uno::UNO_QUERY );
+    DBG_ASSERT( xEvents.is(), "XEventsSupplier::getEvents() returned NULL" );
+    if( !xEvents.is() )
+        return;
+
+    sal_Int32 nFound = 0;
+
+    OUString aClickEventType;
+    presentation::ClickAction eClickAction = presentation::ClickAction_NONE;
+    presentation::AnimationEffect eEffect = presentation::AnimationEffect_NONE;
+    presentation::AnimationSpeed eSpeed = presentation::AnimationSpeed_SLOW;
+    OUString aStrSoundURL;
+    sal_Bool bPlayFull = false;
+    sal_Int32 nVerb = 0;
+    OUString aStrMacro;
+    OUString aStrLibrary;
+    OUString aStrBookmark;
+
+    uno::Sequence< beans::PropertyValue > aClickProperties;
+    if( xEvents->hasByName( msOnClick ) && (xEvents->getByName( msOnClick ) >>= aClickProperties) )
+    {
+        const beans::PropertyValue* pProperty = aClickProperties.getConstArray();
+        const beans::PropertyValue* pPropertyEnd = pProperty + aClickProperties.getLength();
+        for( ; pProperty != pPropertyEnd; ++pProperty )
+        {
+            if( ( ( nFound & FOUND_CLICKEVENTTYPE ) == 0 ) && pProperty->Name == msEventType )
+            {
+                if( pProperty->Value >>= aClickEventType )
+                    nFound |= FOUND_CLICKEVENTTYPE;
+            }
+            else if( ( ( nFound & FOUND_CLICKACTION ) == 0 ) && pProperty->Name == msClickAction )
+            {
+                if( pProperty->Value >>= eClickAction )
+                    nFound |= FOUND_CLICKACTION;
+            }
+            else if( ( ( nFound & FOUND_MACRO ) == 0 ) && ( pProperty->Name == msMacroName || pProperty->Name == msScript ) )
+            {
+                if( pProperty->Value >>= aStrMacro )
+                    nFound |= FOUND_MACRO;
+            }
+            else if( ( ( nFound & FOUND_LIBRARY ) == 0 ) && pProperty->Name == msLibrary )
+            {
+                if( pProperty->Value >>= aStrLibrary )
+                    nFound |= FOUND_LIBRARY;
+            }
+            else if( ( ( nFound & FOUND_EFFECT ) == 0 ) && pProperty->Name == msEffect )
+            {
+                if( pProperty->Value >>= eEffect )
+                    nFound |= FOUND_EFFECT;
+            }
+            else if( ( ( nFound & FOUND_BOOKMARK ) == 0 ) && pProperty->Name == msBookmark )
+            {
+                if( pProperty->Value >>= aStrBookmark )
+                    nFound |= FOUND_BOOKMARK;
+            }
+            else if( ( ( nFound & FOUND_SPEED ) == 0 ) && pProperty->Name == msSpeed )
+            {
+                if( pProperty->Value >>= eSpeed )
+                    nFound |= FOUND_SPEED;
+            }
+            else if( ( ( nFound & FOUND_SOUNDURL ) == 0 ) && pProperty->Name == msSoundURL )
+            {
+                if( pProperty->Value >>= aStrSoundURL )
+                    nFound |= FOUND_SOUNDURL;
+            }
+            else if( ( ( nFound & FOUND_PLAYFULL ) == 0 ) && pProperty->Name == msPlayFull )
+            {
+                if( pProperty->Value >>= bPlayFull )
+                    nFound |= FOUND_PLAYFULL;
+            }
+            else if( ( ( nFound & FOUND_VERB ) == 0 ) && pProperty->Name == msVerb )
+            {
+                if( pProperty->Value >>= nVerb )
+                    nFound |= FOUND_VERB;
+            }
+        }
+    }
+
+    // create the XML elements
+
+    if( aClickEventType == msPresentation )
+    {
+        if( ((nFound & FOUND_CLICKACTION) == 0) || (eClickAction == presentation::ClickAction_NONE) )
+            return;
+
+        SvXMLElementExport aEventsElemt(mrExport, XML_NAMESPACE_OFFICE, XML_EVENT_LISTENERS, sal_True, sal_True);
+
+        enum XMLTokenEnum eStrAction;
+
+        switch( eClickAction )
+        {
+            case presentation::ClickAction_PREVPAGE:        eStrAction = XML_PREVIOUS_PAGE; break;
+            case presentation::ClickAction_NEXTPAGE:        eStrAction = XML_NEXT_PAGE; break;
+            case presentation::ClickAction_FIRSTPAGE:       eStrAction = XML_FIRST_PAGE; break;
+            case presentation::ClickAction_LASTPAGE:        eStrAction = XML_LAST_PAGE; break;
+            case presentation::ClickAction_INVISIBLE:       eStrAction = XML_HIDE; break;
+            case presentation::ClickAction_STOPPRESENTATION:eStrAction = XML_STOP; break;
+            case presentation::ClickAction_PROGRAM:         eStrAction = XML_EXECUTE; break;
+            case presentation::ClickAction_BOOKMARK:        eStrAction = XML_SHOW; break;
+            case presentation::ClickAction_DOCUMENT:        eStrAction = XML_SHOW; break;
+            case presentation::ClickAction_MACRO:           eStrAction = XML_EXECUTE_MACRO; break;
+            case presentation::ClickAction_VERB:            eStrAction = XML_VERB; break;
+            case presentation::ClickAction_VANISH:          eStrAction = XML_FADE_OUT; break;
+            case presentation::ClickAction_SOUND:           eStrAction = XML_SOUND; break;
+            default:
+                OSL_FAIL( "unknown presentation::ClickAction found!" );
+                eStrAction = XML_UNKNOWN;
+        }
+
+        OUString aEventQName(
+            mrExport.GetNamespaceMap().GetQNameByKey(
+                    XML_NAMESPACE_DOM, OUString(  "click"  ) ) );
+        mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_EVENT_NAME, aEventQName );
+        mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_ACTION, eStrAction );
+
+        if( eClickAction == presentation::ClickAction_VANISH )
+        {
+            if( nFound & FOUND_EFFECT )
+            {
+                XMLEffect eKind;
+                XMLEffectDirection eDirection;
+                sal_Int16 nStartScale;
+                bool bIn;
+
+                SdXMLImplSetEffect( eEffect, eKind, eDirection, nStartScale, bIn );
+
+                if( eKind != EK_none )
+                {
+                    SvXMLUnitConverter::convertEnum( msBuffer, eKind, aXML_AnimationEffect_EnumMap );
+                    mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_EFFECT, msBuffer.makeStringAndClear() );
+                }
+
+                if( eDirection != ED_none )
+                {
+                    SvXMLUnitConverter::convertEnum( msBuffer, eDirection, aXML_AnimationDirection_EnumMap );
+                    mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_DIRECTION, msBuffer.makeStringAndClear() );
+                }
+
+                if( nStartScale != -1 )
+                {
+                    ::sax::Converter::convertPercent( msBuffer, nStartScale );
+                    mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_START_SCALE, msBuffer.makeStringAndClear() );
+                }
+            }
+
+            if( nFound & FOUND_SPEED && eEffect != presentation::AnimationEffect_NONE )
+            {
+                 if( eSpeed != presentation::AnimationSpeed_MEDIUM )
+                    {
+                    SvXMLUnitConverter::convertEnum( msBuffer, eSpeed, aXML_AnimationSpeed_EnumMap );
+                    mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_SPEED, msBuffer.makeStringAndClear() );
+                }
+            }
+        }
+
+        if( eClickAction == presentation::ClickAction_PROGRAM ||
+            eClickAction == presentation::ClickAction_BOOKMARK ||
+            eClickAction == presentation::ClickAction_DOCUMENT )
+        {
+            if( eClickAction == presentation::ClickAction_BOOKMARK )
+                msBuffer.append( sal_Unicode('#') );
+
+            msBuffer.append( aStrBookmark );
+            mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(msBuffer.makeStringAndClear()) );
+            mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+            mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+            mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONREQUEST );
+        }
+
+        if( ( nFound & FOUND_VERB ) && eClickAction == presentation::ClickAction_VERB )
+        {
+            msBuffer.append( nVerb );
+            mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_VERB, msBuffer.makeStringAndClear());
+        }
+
+        SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_PRESENTATION, XML_EVENT_LISTENER, sal_True, sal_True);
+
+        if( eClickAction == presentation::ClickAction_VANISH || eClickAction == presentation::ClickAction_SOUND )
+        {
+            if( ( nFound & FOUND_SOUNDURL ) && !aStrSoundURL.isEmpty() )
+            {
+                mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStrSoundURL) );
+                mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+                mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_NEW );
+                mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONREQUEST );
+                if( nFound & FOUND_PLAYFULL && bPlayFull )
+                    mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_PLAY_FULL, XML_TRUE );
+
+                SvXMLElementExport aElem( mrExport, XML_NAMESPACE_PRESENTATION, XML_SOUND, sal_True, sal_True );
+            }
+       }
+    }
+    else if( aClickEventType == msStarBasic )
+    {
+        if( nFound & FOUND_MACRO )
+        {
+            SvXMLElementExport aEventsElemt(mrExport, XML_NAMESPACE_OFFICE, XML_EVENT_LISTENERS, sal_True, sal_True);
+
+            mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_LANGUAGE,
+                        mrExport.GetNamespaceMap().GetQNameByKey(
+                            XML_NAMESPACE_OOO,
+                            OUString( "starbasic"  ) ) );
+            OUString aEventQName(
+                mrExport.GetNamespaceMap().GetQNameByKey(
+                        XML_NAMESPACE_DOM, OUString(  "click"  ) ) );
+            mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_EVENT_NAME, aEventQName );
+
+            if( nFound & FOUND_LIBRARY )
+            {
+                OUString sLocation( GetXMLToken(
+                    (aStrLibrary.equalsIgnoreAsciiCase("StarOffice") ||
+                     aStrLibrary.equalsIgnoreAsciiCase("application") ) ? XML_APPLICATION
+                                                                       : XML_DOCUMENT ) );
+                mrExport.AddAttribute(XML_NAMESPACE_SCRIPT, XML_MACRO_NAME,
+                    sLocation + ":" + aStrMacro);
+            }
+            else
+            {
+                mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_MACRO_NAME, aStrMacro );
+            }
+
+            SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SCRIPT, XML_EVENT_LISTENER, sal_True, sal_True);
+        }
+    }
+    else if( aClickEventType == msScript )
+    {
+        if( nFound & FOUND_MACRO )
+        {
+            SvXMLElementExport aEventsElemt(mrExport, XML_NAMESPACE_OFFICE, XML_EVENT_LISTENERS, sal_True, sal_True);
+            if ( nFound & FOUND_MACRO )
+            {
+                mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_LANGUAGE, mrExport.GetNamespaceMap().GetQNameByKey(
+                         XML_NAMESPACE_OOO, GetXMLToken(XML_SCRIPT) ) );
+                OUString aEventQName(
+                    mrExport.GetNamespaceMap().GetQNameByKey(
+                            XML_NAMESPACE_DOM, OUString(  "click"  ) ) );
+                mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_EVENT_NAME, aEventQName );
+                mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, aStrMacro );
+
+                SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SCRIPT, XML_EVENT_LISTENER, sal_True, sal_True);
+            }
+        }
+    }
+}
+
+/** #i68101# export shape Title and Description */
+void XMLShapeExport::ImpExportDescription( const uno::Reference< drawing::XShape >& xShape )
+{
+    try
+    {
+        OUString aTitle;
+        OUString aDescription;
+
+        uno::Reference< beans::XPropertySet > xProps( xShape, uno::UNO_QUERY_THROW );
+        xProps->getPropertyValue("Title") >>= aTitle;
+        xProps->getPropertyValue("Description") >>= aDescription;
+
+        if(!aTitle.isEmpty())
+        {
+            SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SVG, XML_TITLE, sal_True, sal_False);
+            mrExport.Characters( aTitle );
+        }
+
+        if(!aDescription.isEmpty())
+        {
+            SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SVG, XML_DESC, sal_True, sal_False );
+            mrExport.Characters( aDescription );
+        }
+    }
+    catch( uno::Exception& )
+    {
+        OSL_FAIL( "could not export Title and/or Description for shape!" );
+    }
+}
+
+void XMLShapeExport::ImpExportGroupShape( const uno::Reference< drawing::XShape >& xShape, XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint)
+{
+    uno::Reference< drawing::XShapes > xShapes(xShape, uno::UNO_QUERY);
+    if(xShapes.is() && xShapes->getCount())
+    {
+        // write group shape
+        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
+        SvXMLElementExport aPGR(mrExport, XML_NAMESPACE_DRAW, XML_G, bCreateNewline, sal_True);
+
+        ImpExportDescription( xShape ); // #i68101#
+        ImpExportEvents( xShape );
+        ImpExportGluePoints( xShape );
+
+        // #89764# if export of position is supressed for group shape,
+        // positions of contained objects should be written relative to
+        // the upper left edge of the group.
+        awt::Point aUpperLeft;
+
+        if(!(nFeatures & SEF_EXPORT_POSITION))
+        {
+            nFeatures |= SEF_EXPORT_POSITION;
+            aUpperLeft = xShape->getPosition();
+            pRefPoint = &aUpperLeft;
+        }
+
+        // write members
+        exportShapes( xShapes, nFeatures, pRefPoint );
+    }
+}
+
+void XMLShapeExport::ImpExportTextBoxShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType eShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(xPropSet.is())
+    {
+        uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
+
+        // presentation attribute (if presentation)
+        sal_Bool bIsPresShape(sal_False);
+        sal_Bool bIsEmptyPresObj(sal_False);
+        OUString aStr;
+
+        switch(eShapeType)
+        {
+            case XmlShapeTypePresSubtitleShape:
+            {
+                aStr = GetXMLToken(XML_PRESENTATION_SUBTITLE);
+                bIsPresShape = sal_True;
+                break;
+            }
+            case XmlShapeTypePresTitleTextShape:
+            {
+                aStr = GetXMLToken(XML_PRESENTATION_TITLE);
+                bIsPresShape = sal_True;
+                break;
+            }
+            case XmlShapeTypePresOutlinerShape:
+            {
+                aStr = GetXMLToken(XML_PRESENTATION_OUTLINE);
+                bIsPresShape = sal_True;
+                break;
+            }
+            case XmlShapeTypePresNotesShape:
+            {
+                aStr = GetXMLToken(XML_PRESENTATION_NOTES);
+                bIsPresShape = sal_True;
+                break;
+            }
+            case XmlShapeTypePresHeaderShape:
+            {
+                aStr = GetXMLToken(XML_HEADER);
+                bIsPresShape = sal_True;
+                break;
+            }
+            case XmlShapeTypePresFooterShape:
+            {
+                aStr = GetXMLToken(XML_FOOTER);
+                bIsPresShape = sal_True;
+                break;
+            }
+            case XmlShapeTypePresSlideNumberShape:
+            {
+                aStr = GetXMLToken(XML_PAGE_NUMBER);
+                bIsPresShape = sal_True;
+                break;
+            }
+            case XmlShapeTypePresDateTimeShape:
+            {
+                aStr = GetXMLToken(XML_DATE_TIME);
+                bIsPresShape = sal_True;
+                break;
+            }
+            default:
+                break;
+        }
+
+        // Transformation
+        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+        if(bIsPresShape)
+            bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, aStr );
+
+        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
+        SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW,
+                                  XML_FRAME, bCreateNewline, sal_True );
+
+        // evtl. corner radius?
+        sal_Int32 nCornerRadius(0L);
+        xPropSet->getPropertyValue("CornerRadius") >>= nCornerRadius;
+        if(nCornerRadius)
+        {
+            OUStringBuffer sStringBuffer;
+            mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                    nCornerRadius);
+            mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CORNER_RADIUS, sStringBuffer.makeStringAndClear());
+        }
+
+        {
+            // write text-box
+            SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_TEXT_BOX, sal_True, sal_True);
+            if(!bIsEmptyPresObj)
+                ImpExportText( xShape );
+        }
+
+        ImpExportDescription( xShape ); // #i68101#
+        ImpExportEvents( xShape );
+        ImpExportGluePoints( xShape );
+    }
+}
+
+void XMLShapeExport::ImpExportRectangleShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(xPropSet.is())
+    {
+        // Transformation
+        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+        // evtl. corner radius?
+        sal_Int32 nCornerRadius(0L);
+        xPropSet->getPropertyValue("CornerRadius") >>= nCornerRadius;
+        if(nCornerRadius)
+        {
+            OUStringBuffer sStringBuffer;
+            mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                    nCornerRadius);
+            mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CORNER_RADIUS, sStringBuffer.makeStringAndClear());
+        }
+
+        // write rectangle
+        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
+        SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_RECT, bCreateNewline, sal_True);
+
+        ImpExportDescription( xShape ); // #i68101#
+        ImpExportEvents( xShape );
+        ImpExportGluePoints( xShape );
+        ImpExportText( xShape );
+    }
+}
+
+void XMLShapeExport::ImpExportLineShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(xPropSet.is())
+    {
+        OUString aStr;
+        OUStringBuffer sStringBuffer;
+        awt::Point aStart(0,0);
+        awt::Point aEnd(1,1);
+
+        // #85920# use 'Geometry' to get the points of the line
+        // since this slot take anchor pos into account.
+
+        // get matrix
+        ::basegfx::B2DHomMatrix aMatrix;
+        ImpExportNewTrans_GetB2DHomMatrix(aMatrix, xPropSet);
+
+        // decompose and correct about pRefPoint
+        ::basegfx::B2DTuple aTRScale;
+        double fTRShear(0.0);
+        double fTRRotate(0.0);
+        ::basegfx::B2DTuple aTRTranslate;
+        ImpExportNewTrans_DecomposeAndRefPoint(aMatrix, aTRScale, fTRShear, fTRRotate, aTRTranslate, pRefPoint);
+
+        // create base position
+        awt::Point aBasePosition(FRound(aTRTranslate.getX()), FRound(aTRTranslate.getY()));
+
+        // get the two points
+        uno::Any aAny(xPropSet->getPropertyValue("Geometry"));
+        drawing::PointSequenceSequence* pSourcePolyPolygon = (drawing::PointSequenceSequence*)aAny.getValue();
+
+        if(pSourcePolyPolygon)
+        {
+            drawing::PointSequence* pOuterSequence = pSourcePolyPolygon->getArray();
+            if(pOuterSequence)
+            {
+                drawing::PointSequence* pInnerSequence = pOuterSequence++;
+                if(pInnerSequence)
+                {
+                    awt::Point* pArray = pInnerSequence->getArray();
+                    if(pArray)
+                    {
+                        if(pInnerSequence->getLength() > 0)
+                        {
+                            aStart = awt::Point(
+                                pArray->X + aBasePosition.X,
+                                pArray->Y + aBasePosition.Y);
+                            pArray++;
+                        }
+
+                        if(pInnerSequence->getLength() > 1)
+                        {
+                            aEnd = awt::Point(
+                                pArray->X + aBasePosition.X,
+                                pArray->Y + aBasePosition.Y);
+                        }
+                    }
+                }
+            }
+        }
+
+        if( nFeatures & SEF_EXPORT_X )
+        {
+            // svg: x1
+            mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                    aStart.X);
+            aStr = sStringBuffer.makeStringAndClear();
+            mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X1, aStr);
+        }
+        else
+        {
+            aEnd.X -= aStart.X;
+        }
+
+        if( nFeatures & SEF_EXPORT_Y )
+        {
+            // svg: y1
+            mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                    aStart.Y);
+            aStr = sStringBuffer.makeStringAndClear();
+            mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y1, aStr);
+        }
+        else
+        {
+            aEnd.Y -= aStart.Y;
+        }
+
+        // svg: x2
+        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                aEnd.X);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X2, aStr);
+
+        // svg: y2
+        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                aEnd.Y);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y2, aStr);
+
+        // write line
+        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
+        SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_LINE, bCreateNewline, sal_True);
+
+        ImpExportDescription( xShape ); // #i68101#
+        ImpExportEvents( xShape );
+        ImpExportGluePoints( xShape );
+        ImpExportText( xShape );
+    }
+}
+
+void XMLShapeExport::ImpExportEllipseShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(xPropSet.is())
+    {
+        // get size to decide between Circle and Ellipse
+        awt::Size aSize = xShape->getSize();
+        sal_Int32 nRx((aSize.Width + 1) / 2);
+        sal_Int32 nRy((aSize.Height + 1) / 2);
+        sal_Bool bCircle(nRx == nRy);
+
+        // Transformation
+        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+        drawing::CircleKind eKind = drawing::CircleKind_FULL;
+        xPropSet->getPropertyValue("CircleKind") >>= eKind;
+        if( eKind != drawing::CircleKind_FULL )
+        {
+            OUStringBuffer sStringBuffer;
+            sal_Int32 nStartAngle = 0;
+            sal_Int32 nEndAngle = 0;
+            xPropSet->getPropertyValue("CircleStartAngle") >>= nStartAngle;
+            xPropSet->getPropertyValue("CircleEndAngle") >>= nEndAngle;
+
+            const double dStartAngle = nStartAngle / 100.0;
+            const double dEndAngle = nEndAngle / 100.0;
+
+            // export circle kind
+            SvXMLUnitConverter::convertEnum( sStringBuffer, (sal_uInt16)eKind, aXML_CircleKind_EnumMap );
+            mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_KIND, sStringBuffer.makeStringAndClear() );
+
+            // export start angle
+            ::sax::Converter::convertDouble( sStringBuffer, dStartAngle );
+            mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_START_ANGLE, sStringBuffer.makeStringAndClear() );
+
+            // export end angle
+            ::sax::Converter::convertDouble( sStringBuffer, dEndAngle );
+            mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_END_ANGLE, sStringBuffer.makeStringAndClear() );
+        }
+
+        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
+
+        if(bCircle)
+        {
+            // write circle
+            SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_CIRCLE, bCreateNewline, sal_True);
+
+            ImpExportDescription( xShape ); // #i68101#
+            ImpExportEvents( xShape );
+            ImpExportGluePoints( xShape );
+            ImpExportText( xShape );
+        }
+        else
+        {
+            // write ellipse
+            SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_ELLIPSE, bCreateNewline, sal_True);
+
+            ImpExportDescription( xShape ); // #i68101#
+            ImpExportEvents( xShape );
+            ImpExportGluePoints( xShape );
+            ImpExportText( xShape );
+        }
+    }
+}
+
+void XMLShapeExport::ImpExportPolygonShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType eShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(xPropSet.is())
+    {
+        sal_Bool bClosed(eShapeType == XmlShapeTypeDrawPolyPolygonShape
+            || eShapeType == XmlShapeTypeDrawClosedBezierShape);
+        sal_Bool bBezier(eShapeType == XmlShapeTypeDrawClosedBezierShape
+            || eShapeType == XmlShapeTypeDrawOpenBezierShape);
+
+        // get matrix
+        ::basegfx::B2DHomMatrix aMatrix;
+        ImpExportNewTrans_GetB2DHomMatrix(aMatrix, xPropSet);
+
+        // decompose and correct abour pRefPoint
+        ::basegfx::B2DTuple aTRScale;
+        double fTRShear(0.0);
+        double fTRRotate(0.0);
+        ::basegfx::B2DTuple aTRTranslate;
+        ImpExportNewTrans_DecomposeAndRefPoint(aMatrix, aTRScale, fTRShear, fTRRotate, aTRTranslate, pRefPoint);
+
+        // use features and write
+        ImpExportNewTrans_FeaturesAndWrite(aTRScale, fTRShear, fTRRotate, aTRTranslate, nFeatures);
+
+        // create and export ViewBox
+        awt::Point aPoint(0, 0);
+        awt::Size aSize(FRound(aTRScale.getX()), FRound(aTRScale.getY()));
+        SdXMLImExViewBox aViewBox(0, 0, aSize.Width, aSize.Height);
+        mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_VIEWBOX, aViewBox.GetExportString());
+
+        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
+
+        if(bBezier)
+        {
+            // get PolygonBezier
+            uno::Any aAny( xPropSet->getPropertyValue("Geometry") );
+            drawing::PolyPolygonBezierCoords* pSourcePolyPolygon =
+                (drawing::PolyPolygonBezierCoords*)aAny.getValue();
+
+            if(pSourcePolyPolygon && pSourcePolyPolygon->Coordinates.getLength())
+            {
+                sal_Int32 nOuterCnt(pSourcePolyPolygon->Coordinates.getLength());
+                drawing::PointSequence* pOuterSequence = pSourcePolyPolygon->Coordinates.getArray();
+                drawing::FlagSequence*  pOuterFlags = pSourcePolyPolygon->Flags.getArray();
+
+                if(pOuterSequence && pOuterFlags)
+                {
+                    // prepare svx:d element export
+                    SdXMLImExSvgDElement aSvgDElement(aViewBox, GetExport());
+
+                    for(sal_Int32 a(0L); a < nOuterCnt; a++)
+                    {
+                        drawing::PointSequence* pSequence = pOuterSequence++;
+                        drawing::FlagSequence* pFlags = pOuterFlags++;
+
+                        if(pSequence && pFlags)
+                        {
+                            aSvgDElement.AddPolygon(pSequence, pFlags,
+                                aPoint, aSize, bClosed);
+                        }
+                    }
+
+                    // write point array
+                    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aSvgDElement.GetExportString());
+                }
+
+                // write object now
+                SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PATH, bCreateNewline, sal_True);
+
+                ImpExportDescription( xShape ); // #i68101#
+                ImpExportEvents( xShape );
+                ImpExportGluePoints( xShape );
+                ImpExportText( xShape );
+            }
+        }
+        else
+        {
+            // get non-bezier polygon
+            uno::Any aAny( xPropSet->getPropertyValue("Geometry") );
+            drawing::PointSequenceSequence* pSourcePolyPolygon = (drawing::PointSequenceSequence*)aAny.getValue();
+
+            if(pSourcePolyPolygon && pSourcePolyPolygon->getLength())
+            {
+                sal_Int32 nOuterCnt(pSourcePolyPolygon->getLength());
+
+                if(1L == nOuterCnt && !bBezier)
+                {
+                    // simple polygon shape, can be written as svg:points sequence
+                    drawing::PointSequence* pSequence = pSourcePolyPolygon->getArray();
+                    if(pSequence)
+                    {
+                        SdXMLImExPointsElement aPoints(pSequence, aViewBox, aPoint, aSize,
+                            // #96328#
+                            bClosed);
+
+                        // write point array
+                        mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_POINTS, aPoints.GetExportString());
+                    }
+
+                    // write object now
+                    SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW,
+                        bClosed ? XML_POLYGON : XML_POLYLINE , bCreateNewline, sal_True);
+
+                    ImpExportDescription( xShape ); // #i68101#
+                    ImpExportEvents( xShape );
+                    ImpExportGluePoints( xShape );
+                    ImpExportText( xShape );
+                }
+                else
+                {
+                    // polypolygon or bezier, needs to be written as a svg:path sequence
+                    drawing::PointSequence* pOuterSequence = pSourcePolyPolygon->getArray();
+                    if(pOuterSequence)
+                    {
+                        // prepare svx:d element export
+                        SdXMLImExSvgDElement aSvgDElement(aViewBox, GetExport());
+
+                        for(sal_Int32 a(0L); a < nOuterCnt; a++)
+                        {
+                            drawing::PointSequence* pSequence = pOuterSequence++;
+                            if(pSequence)
+                            {
+                                aSvgDElement.AddPolygon(pSequence, 0L, aPoint,
+                                    aSize, bClosed);
+                            }
+                        }
+
+                        // write point array
+                        mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aSvgDElement.GetExportString());
+                    }
+
+                    // write object now
+                    SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PATH, bCreateNewline, sal_True);
+
+                    ImpExportDescription( xShape ); // #i68101#
+                    ImpExportEvents( xShape );
+                    ImpExportGluePoints( xShape );
+                    ImpExportText( xShape );
+                }
+            }
+        }
+    }
+}
+
+void XMLShapeExport::ImpExportGraphicObjectShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType eShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(xPropSet.is())
+    {
+        sal_Bool bIsEmptyPresObj = sal_False;
+        uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
+
+        // Transformation
+        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+        OUString sImageURL;
+
+        if(eShapeType == XmlShapeTypePresGraphicObjectShape)
+            bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_GRAPHIC) );
+
+        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
+        SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW,
+                                  XML_FRAME, bCreateNewline, sal_True );
+
+        const bool bSaveBackwardsCompatible = ( mrExport.getExportFlags() & EXPORT_SAVEBACKWARDCOMPATIBLE );
+
+        if( !bIsEmptyPresObj || bSaveBackwardsCompatible )
+        {
+            if( !bIsEmptyPresObj )
+            {
+                OUString aReplacementUrl;
+                xPropSet->getPropertyValue("ReplacementGraphicURL") >>= aReplacementUrl;
+
+                // If there is no url, then then graphic is empty
+                if(!aReplacementUrl.isEmpty())
+                {
+                    const OUString aStr = mrExport.AddEmbeddedGraphicObject(aReplacementUrl);
+
+                    if(aStr.getLength())
+                    {
+                        mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, aStr);
+                        mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+                        mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+                        mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
+
+                        // xlink:href for replacement, only written for Svg content
+                        SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_IMAGE, sal_True, sal_True);
+
+                        // optional office:binary-data
+                        mrExport.AddEmbeddedGraphicObjectAsBase64(aReplacementUrl);
+                    }
+                }
+
+                OUString aStreamURL;
+                OUString aStr;
+
+                xPropSet->getPropertyValue("GraphicStreamURL") >>= aStreamURL;
+                xPropSet->getPropertyValue("GraphicURL") >>= sImageURL;
+
+                OUString aResolveURL( sImageURL );
+                const OUString sPackageURL( "vnd.sun.star.Package:" );
+
+                    // sj: trying to preserve the filename
+                if ( aStreamURL.match( sPackageURL, 0 ) )
+                {
+                    OUString sRequestedName( aStreamURL.copy( sPackageURL.getLength(), aStreamURL.getLength() - sPackageURL.getLength() ) );
+                    sal_Int32 nLastIndex = sRequestedName.lastIndexOf( '/' ) + 1;
+                    if ( ( nLastIndex > 0 ) && ( nLastIndex < sRequestedName.getLength() ) )
+                        sRequestedName = sRequestedName.copy( nLastIndex, sRequestedName.getLength() - nLastIndex );
+                    nLastIndex = sRequestedName.lastIndexOf( '.' );
+                    if ( nLastIndex >= 0 )
+                        sRequestedName = sRequestedName.copy( 0, nLastIndex );
+                    if ( !sRequestedName.isEmpty() )
+                    {
+                        aResolveURL = aResolveURL.concat( OUString("?requestedName="));
+                        aResolveURL = aResolveURL.concat( sRequestedName );
+                    }
+                }
+
+                aStr = mrExport.AddEmbeddedGraphicObject( aResolveURL );
+                mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, aStr );
+
+                if( !aStr.isEmpty() )
+                {
+                    if( aStr[ 0 ] == '#' )
+                    {
+                        aStreamURL = sPackageURL;
+                        aStreamURL = aStreamURL.concat( aStr.copy( 1, aStr.getLength() - 1 ) );
+                    }
+
+                    // update stream URL for load on demand
+                    uno::Any aAny;
+                    aAny <<= aStreamURL;
+                    xPropSet->setPropertyValue("GraphicStreamURL", aAny );
+
+                    mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+                    mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+                    mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
+                }
+            }
+            else
+            {
+                OUString aStr;
+                mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, aStr );
+                mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+                mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+                mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
+            }
+
+            {
+                SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_IMAGE, sal_True, sal_True);
+
+                if( !sImageURL.isEmpty() )
+                {
+                    // optional office:binary-data
+                    mrExport.AddEmbeddedGraphicObjectAsBase64( sImageURL );
+                }
+                if( !bIsEmptyPresObj )
+                    ImpExportText( xShape );
+            }
+        }
+
+        ImpExportEvents( xShape );
+        ImpExportGluePoints( xShape );
+
+        // image map
+        GetExport().GetImageMapExport().Export( xPropSet );
+        ImpExportDescription( xShape ); // #i68101#
+    }
+}
+
+void XMLShapeExport::ImpExportChartShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType eShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint,
+    SvXMLAttributeList* pAttrList )
+{
+    ImpExportOLE2Shape( xShape, eShapeType, nFeatures, pRefPoint, pAttrList );
+}
+
+void XMLShapeExport::ImpExportControlShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(xPropSet.is())
+    {
+        // Transformation
+        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+    }
+
+    uno::Reference< drawing::XControlShape > xControl( xShape, uno::UNO_QUERY );
+    DBG_ASSERT( xControl.is(), "Control shape is not supporting XControlShape" );
+    if( xControl.is() )
+    {
+        uno::Reference< beans::XPropertySet > xControlModel( xControl->getControl(), uno::UNO_QUERY );
+        DBG_ASSERT( xControlModel.is(), "Control shape has not XControlModel" );
+        if( xControlModel.is() )
+        {
+            mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CONTROL, mrExport.GetFormExport()->getControlId( xControlModel ) );
+        }
+    }
+
+    sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
+    SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_CONTROL, bCreateNewline, sal_True);
+
+    ImpExportDescription( xShape ); // #i68101#
+}
+
+void XMLShapeExport::ImpExportConnectorShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */)
+{
+    uno::Reference< beans::XPropertySet > xProps( xShape, uno::UNO_QUERY );
+
+    OUString aStr;
+    OUStringBuffer sStringBuffer;
+
+    // export connection kind
+    drawing::ConnectorType eType = drawing::ConnectorType_STANDARD;
+    uno::Any aAny = xProps->getPropertyValue("EdgeKind");
+    aAny >>= eType;
+
+    if( eType != drawing::ConnectorType_STANDARD )
+    {
+        SvXMLUnitConverter::convertEnum( sStringBuffer, (sal_uInt16)eType, aXML_ConnectionKind_EnumMap );
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_TYPE, aStr);
+    }
+
+    // export line skew
+    sal_Int32 nDelta1 = 0, nDelta2 = 0, nDelta3 = 0;
+
+    aAny = xProps->getPropertyValue("EdgeLine1Delta");
+    aAny >>= nDelta1;
+    aAny = xProps->getPropertyValue("EdgeLine2Delta");
+    aAny >>= nDelta2;
+    aAny = xProps->getPropertyValue("EdgeLine3Delta");
+    aAny >>= nDelta3;
+
+    if( nDelta1 != 0 || nDelta2 != 0 || nDelta3 != 0 )
+    {
+        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                nDelta1);
+        if( nDelta2 != 0 || nDelta3 != 0 )
+        {
+            const char aSpace = ' ';
+            sStringBuffer.appendAscii( &aSpace, 1 );
+            mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                    nDelta2);
+            if( nDelta3 != 0 )
+            {
+                sStringBuffer.appendAscii( &aSpace, 1 );
+                mrExport.GetMM100UnitConverter().convertMeasureToXML(
+                        sStringBuffer, nDelta3);
+            }
+        }
+
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_LINE_SKEW, aStr);
+    }
+
+    // export start and end point
+    awt::Point aStart(0,0);
+    awt::Point aEnd(1,1);
+
+    /* Get <StartPositionInHoriL2R> and
+       <EndPositionInHoriL2R>, if they exist and if the document is exported
+       into the OpenOffice.org file format.
+       These properties only exist at service com::sun::star::text::Shape - the
+       Writer UNO service for shapes.
+       This code is needed, because the positioning attributes in the
+       OpenOffice.org file format are given in horizontal left-to-right layout
+       regardless the layout direction the shape is in. In the OASIS Open Office
+       file format the positioning attributes are correctly given in the layout
+       direction the shape is in. Thus, this code provides the conversion from
+       the OASIS Open Office file format to the OpenOffice.org file format. (#i36248#)
+    */
+    if ( ( GetExport().getExportFlags() & EXPORT_OASIS ) == 0 &&
+         xProps->getPropertySetInfo()->hasPropertyByName(
+            OUString("StartPositionInHoriL2R")) &&
+         xProps->getPropertySetInfo()->hasPropertyByName(
+            OUString("EndPositionInHoriL2R")) )
+    {
+        xProps->getPropertyValue("StartPositionInHoriL2R") >>= aStart;
+        xProps->getPropertyValue("EndPositionInHoriL2R") >>= aEnd;
+    }
+    else
+    {
+        xProps->getPropertyValue("StartPosition") >>= aStart;
+        xProps->getPropertyValue("EndPosition") >>= aEnd;
+    }
+
+    if( pRefPoint )
+    {
+        aStart.X -= pRefPoint->X;
+        aStart.Y -= pRefPoint->Y;
+        aEnd.X -= pRefPoint->X;
+        aEnd.Y -= pRefPoint->Y;
+    }
+
+    if( nFeatures & SEF_EXPORT_X )
+    {
+        // svg: x1
+        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                aStart.X);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X1, aStr);
+    }
+    else
+    {
+        aEnd.X -= aStart.X;
+    }
+
+    if( nFeatures & SEF_EXPORT_Y )
+    {
+        // svg: y1
+        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                aStart.Y);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y1, aStr);
+    }
+    else
+    {
+        aEnd.Y -= aStart.Y;
+    }
+
+    // svg: x2
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, aEnd.X);
+    aStr = sStringBuffer.makeStringAndClear();
+    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X2, aStr);
+
+    // svg: y2
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, aEnd.Y);
+    aStr = sStringBuffer.makeStringAndClear();
+    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y2, aStr);
+
+    // #i39320#
+    uno::Reference< uno::XInterface > xRefS;
+    uno::Reference< uno::XInterface > xRefE;
+
+    // export start connection
+    xProps->getPropertyValue("StartShape") >>= xRefS;
+    if( xRefS.is() )
+    {
+        const OUString& rShapeId = mrExport.getInterfaceToIdentifierMapper().getIdentifier( xRefS );
+        mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_START_SHAPE, rShapeId);
+
+        aAny = xProps->getPropertyValue("StartGluePointIndex");
+        sal_Int32 nGluePointId = 0;
+        if( aAny >>= nGluePointId )
+        {
+            if( nGluePointId != -1 )
+            {
+                mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_START_GLUE_POINT, OUString::number( nGluePointId ));
+            }
+        }
+    }
+
+    // export end connection
+    xProps->getPropertyValue("EndShape") >>= xRefE;
+    if( xRefE.is() )
+    {
+        const OUString& rShapeId = mrExport.getInterfaceToIdentifierMapper().getIdentifier( xRefE );
+        mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_END_SHAPE, rShapeId);
+
+        aAny = xProps->getPropertyValue("EndGluePointIndex");
+        sal_Int32 nGluePointId = 0;
+        if( aAny >>= nGluePointId )
+        {
+            if( nGluePointId != -1 )
+            {
+                mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_END_GLUE_POINT, OUString::number( nGluePointId ));
+            }
+        }
+    }
+
+    if( xProps->getPropertyValue("PolyPolygonBezier") >>= aAny )
+    {
+        // get PolygonBezier
+        drawing::PolyPolygonBezierCoords* pSourcePolyPolygon =
+            (drawing::PolyPolygonBezierCoords*)aAny.getValue();
+
+        if(pSourcePolyPolygon && pSourcePolyPolygon->Coordinates.getLength())
+        {
+            sal_Int32 nOuterCnt(pSourcePolyPolygon->Coordinates.getLength());
+            drawing::PointSequence* pOuterSequence = pSourcePolyPolygon->Coordinates.getArray();
+            drawing::FlagSequence*  pOuterFlags = pSourcePolyPolygon->Flags.getArray();
+
+            if(pOuterSequence && pOuterFlags)
+            {
+                // prepare svx:d element export
+                awt::Point aPoint( 0, 0 );
+                awt::Size aSize( 1, 1 );
+                SdXMLImExViewBox aViewBox( 0, 0, 1, 1 );
+                SdXMLImExSvgDElement aSvgDElement(aViewBox, GetExport());
+
+                for(sal_Int32 a(0L); a < nOuterCnt; a++)
+                {
+                    drawing::PointSequence* pSequence = pOuterSequence++;
+                    drawing::FlagSequence* pFlags = pOuterFlags++;
+
+                    if(pSequence && pFlags)
+                    {
+                        aSvgDElement.AddPolygon(pSequence, pFlags,
+                            aPoint, aSize, sal_False );
+                    }
+                }
+
+                // write point array
+                mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aSvgDElement.GetExportString());
+            }
+        }
+    }
+
+    // get matrix
+    ::basegfx::B2DHomMatrix aMatrix;
+    ImpExportNewTrans_GetB2DHomMatrix(aMatrix, xProps);
+
+    // decompose and correct about pRefPoint
+    ::basegfx::B2DTuple aTRScale;
+    double fTRShear(0.0);
+    double fTRRotate(0.0);
+    ::basegfx::B2DTuple aTRTranslate;
+    ImpExportNewTrans_DecomposeAndRefPoint(aMatrix, aTRScale, fTRShear,
+            fTRRotate, aTRTranslate, pRefPoint);
+
+    // fdo#49678: create and export ViewBox
+    awt::Point aPoint(0, 0);
+    awt::Size aSize(FRound(aTRScale.getX()), FRound(aTRScale.getY()));
+    SdXMLImExViewBox aViewBox(0, 0, aSize.Width, aSize.Height);
+    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_VIEWBOX, aViewBox.GetExportString());
+
+    // write connector shape. Add Export later.
+    sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
+    SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_CONNECTOR, bCreateNewline, sal_True);
+
+    ImpExportDescription( xShape ); // #i68101#
+    ImpExportEvents( xShape );
+    ImpExportGluePoints( xShape );
+    ImpExportText( xShape );
+}
+
+void XMLShapeExport::ImpExportMeasureShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */)
+{
+    uno::Reference< beans::XPropertySet > xProps( xShape, uno::UNO_QUERY );
+
+    OUString aStr;
+    OUStringBuffer sStringBuffer;
+
+    // export start and end point
+    awt::Point aStart(0,0);
+    awt::Point aEnd(1,1);
+
+    /* Get <StartPositionInHoriL2R> and
+       <EndPositionInHoriL2R>, if they exist and if the document is exported
+       into the OpenOffice.org file format.
+       These properties only exist at service com::sun::star::text::Shape - the
+       Writer UNO service for shapes.
+       This code is needed, because the positioning attributes in the
+       OpenOffice.org file format are given in horizontal left-to-right layout
+       regardless the layout direction the shape is in. In the OASIS Open Office
+       file format the positioning attributes are correctly given in the layout
+       direction the shape is in. Thus, this code provides the conversion from
+       the OASIS Open Office file format to the OpenOffice.org file format. (#i36248#)
+    */
+    if ( ( GetExport().getExportFlags() & EXPORT_OASIS ) == 0 &&
+         xProps->getPropertySetInfo()->hasPropertyByName(
+            OUString("StartPositionInHoriL2R")) &&
+         xProps->getPropertySetInfo()->hasPropertyByName(
+            OUString("EndPositionInHoriL2R")) )
+    {
+        xProps->getPropertyValue("StartPositionInHoriL2R") >>= aStart;
+        xProps->getPropertyValue("EndPositionInHoriL2R") >>= aEnd;
+    }
+    else
+    {
+        xProps->getPropertyValue("StartPosition") >>= aStart;
+        xProps->getPropertyValue("EndPosition") >>= aEnd;
+    }
+
+    if( pRefPoint )
+    {
+        aStart.X -= pRefPoint->X;
+        aStart.Y -= pRefPoint->Y;
+        aEnd.X -= pRefPoint->X;
+        aEnd.Y -= pRefPoint->Y;
+    }
+
+    if( nFeatures & SEF_EXPORT_X )
+    {
+        // svg: x1
+        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                aStart.X);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X1, aStr);
+    }
+    else
+    {
+        aEnd.X -= aStart.X;
+    }
+
+    if( nFeatures & SEF_EXPORT_Y )
+    {
+        // svg: y1
+        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                aStart.Y);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y1, aStr);
+    }
+    else
+    {
+        aEnd.Y -= aStart.Y;
+    }
+
+    // svg: x2
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, aEnd.X);
+    aStr = sStringBuffer.makeStringAndClear();
+    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X2, aStr);
+
+    // svg: y2
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, aEnd.Y);
+    aStr = sStringBuffer.makeStringAndClear();
+    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y2, aStr);
+
+    // write measure shape
+    sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
+    SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_MEASURE, bCreateNewline, sal_True);
+
+    ImpExportDescription( xShape ); // #i68101#
+    ImpExportEvents( xShape );
+    ImpExportGluePoints( xShape );
+
+    uno::Reference< text::XText > xText( xShape, uno::UNO_QUERY );
+    if( xText.is() )
+        mrExport.GetTextParagraphExport()->exportText( xText );
+}
+
+void XMLShapeExport::ImpExportOLE2Shape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType eShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */,
+    SvXMLAttributeList* pAttrList /* = NULL */ )
+{
+    uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    uno::Reference< container::XNamed > xNamed(xShape, uno::UNO_QUERY);
+
+    DBG_ASSERT( xPropSet.is() && xNamed.is(), "ole shape is not implementing needed interfaces");
+    if(xPropSet.is() && xNamed.is())
+    {
+        // Transformation
+        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+        sal_Bool bIsEmptyPresObj = sal_False;
+
+        // presentation settings
+        if(eShapeType == XmlShapeTypePresOLE2Shape)
+            bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_OBJECT) );
+        else if(eShapeType == XmlShapeTypePresChartShape)
+            bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_CHART) );
+        else if(eShapeType == XmlShapeTypePresSheetShape)
+            bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_TABLE) );
+
+        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
+        sal_Bool bExportEmbedded(0 != (mrExport.getExportFlags() & EXPORT_EMBEDDED));
+        OUString sPersistName;
+        SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW,
+                                  XML_FRAME, bCreateNewline, sal_True );
+
+        const bool bSaveBackwardsCompatible = ( mrExport.getExportFlags() & EXPORT_SAVEBACKWARDCOMPATIBLE );
+
+        if( !bIsEmptyPresObj || bSaveBackwardsCompatible )
+        {
+            if (pAttrList)
+            {
+                mrExport.AddAttributeList(pAttrList);
+            }
+
+            OUString sClassId;
+            OUString sURL;
+            sal_Bool bInternal = false;
+            xPropSet->getPropertyValue("IsInternal") >>= bInternal;
+
+            if( !bIsEmptyPresObj )
+            {
+
+                if ( bInternal )
+                {
+                    // OOo internal links have no storage persistance, URL is stored in the XML file
+                    // the result LinkURL is empty in case the object is not a link
+                    xPropSet->getPropertyValue("LinkURL") >>= sURL;
+                }
+
+                xPropSet->getPropertyValue("PersistName") >>= sPersistName;
+                if ( sURL.isEmpty() )
+                {
+                    if( !sPersistName.isEmpty() )
+                    {
+                        sURL = OUString(  "vnd.sun.star.EmbeddedObject:"  );
+                        sURL += sPersistName;
+                    }
+                }
+
+                if( !bInternal )
+                    xPropSet->getPropertyValue("CLSID") >>= sClassId;
+
+                if( !sClassId.isEmpty() )
+                    mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CLASS_ID, sClassId );
+
+                if(eShapeType != XmlShapeTypePresChartShape && eShapeType != XmlShapeTypeDrawChartShape)
+                {
+                    // #i118485# Add text export, the draw OLE shape allows text now
+                    // fdo#58571 chart objects don't allow text:p
+                    ImpExportText( xShape );
+                }
+
+                if(!bExportEmbedded)
+                {
+                    // xlink:href
+                    if( !sURL.isEmpty() )
+                    {
+                        // #96717# in theorie, if we don't have a url we shouldn't even
+                        // export this ole shape. But practical its to risky right now
+                        // to change this so we better dispose this on load
+                        sURL = mrExport.AddEmbeddedObject( sURL );
+
+                        mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sURL );
+                        mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+                        mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+                        mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
+                    }
+                }
+            }
+            else
+            {
+                // export empty href for empty placeholders to be valid ODF
+                OUString sEmptyURL;
+
+                mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sEmptyURL );
+                mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+                mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+                mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
+            }
+
+            enum XMLTokenEnum eElem = sClassId.isEmpty() ? XML_OBJECT : XML_OBJECT_OLE ;
+            SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, eElem, sal_True, sal_True );
+
+            if(bExportEmbedded && !bIsEmptyPresObj)
+            {
+                // #100592#
+                if(bInternal)
+                {
+                    // embedded XML
+                    uno::Reference< lang::XComponent > xComp;
+                    xPropSet->getPropertyValue("Model") >>= xComp;
+                    DBG_ASSERT( xComp.is(), "no xModel for own OLE format" );
+                    mrExport.ExportEmbeddedOwnObject( xComp );
+                }
+                else
+                {
+                    // embed as Base64
+                    // this is an alien object ( currently MSOLE is the only supported type of such objects )
+                    // in case it is not an OASIS format the object should be asked to store replacement image if possible
+
+                    OUString sURLRequest( sURL );
+                    if ( ( mrExport.getExportFlags() & EXPORT_OASIS ) == 0 )
+                        sURLRequest += OUString(  "?oasis=false"  );
+                    mrExport.AddEmbeddedObjectAsBase64( sURLRequest );
+                }
+            }
+        }
+        if( !bIsEmptyPresObj )
+        {
+            OUString sURL(  "vnd.sun.star.GraphicObject:"  );
+            sURL += sPersistName;
+            if( !bExportEmbedded )
+            {
+                sURL = GetExport().AddEmbeddedObject( sURL );
+                mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sURL );
+                mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+                mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+                mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
+            }
+
+            SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_DRAW,
+                                      XML_IMAGE, sal_False, sal_True );
+
+            if( bExportEmbedded )
+                GetExport().AddEmbeddedObjectAsBase64( sURL );
+        }
+
+        ImpExportEvents( xShape );
+        ImpExportGluePoints( xShape );
+        ImpExportDescription( xShape ); // #i68101#
+    }
+}
+
+void XMLShapeExport::ImpExportPageShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType eShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(xPropSet.is())
+    {
+        // #86163# Transformation
+        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+        // export page number used for this page
+        uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
+        const OUString aPageNumberStr("PageNumber");
+        if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName(aPageNumberStr))
+        {
+            sal_Int32 nPageNumber = 0;
+            xPropSet->getPropertyValue(aPageNumberStr) >>= nPageNumber;
+            if( nPageNumber )
+                mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_PAGE_NUMBER, OUString::number(nPageNumber));
+        }
+
+        // a presentation page shape, normally used on notes pages only. If
+        // it is used not as presentation shape, it may have been created with
+        // copy-paste exchange between draw and impress (this IS possible...)
+        if(eShapeType == XmlShapeTypePresPageShape)
+        {
+            mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_CLASS,
+                                 XML_PRESENTATION_PAGE);
+        }
+
+        // write Page shape
+        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
+        SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PAGE_THUMBNAIL, bCreateNewline, sal_True);
+    }
+}
+
+void XMLShapeExport::ImpExportCaptionShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(xPropSet.is())
+    {
+        // Transformation
+        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+        // evtl. corner radius?
+        sal_Int32 nCornerRadius(0L);
+        xPropSet->getPropertyValue("CornerRadius") >>= nCornerRadius;
+        if(nCornerRadius)
+        {
+            OUStringBuffer sStringBuffer;
+            mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                    nCornerRadius);
+            mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CORNER_RADIUS, sStringBuffer.makeStringAndClear());
+        }
+
+        awt::Point aCaptionPoint;
+        xPropSet->getPropertyValue("CaptionPoint") >>= aCaptionPoint;
+
+        mrExport.GetMM100UnitConverter().convertMeasureToXML(msBuffer,
+                aCaptionPoint.X);
+        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CAPTION_POINT_X, msBuffer.makeStringAndClear() );
+        mrExport.GetMM100UnitConverter().convertMeasureToXML(msBuffer,
+                aCaptionPoint.Y);
+        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CAPTION_POINT_Y, msBuffer.makeStringAndClear() );
+
+        // write Caption shape. Add export later.
+        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
+        sal_Bool bAnnotation( (nFeatures & SEF_EXPORT_ANNOTATION) == SEF_EXPORT_ANNOTATION );
+
+        SvXMLElementExport aObj( mrExport,
+                                 (bAnnotation ? XML_NAMESPACE_OFFICE
+                                               : XML_NAMESPACE_DRAW),
+                                 (bAnnotation ? XML_ANNOTATION : XML_CAPTION),
+                                 bCreateNewline, sal_True );
+
+        ImpExportDescription( xShape ); // #i68101#
+        ImpExportEvents( xShape );
+        ImpExportGluePoints( xShape );
+        if( bAnnotation )
+            mrExport.exportAnnotationMeta( xShape );
+        ImpExportText( xShape );
+    }
+}
+
+void XMLShapeExport::ImpExportFrameShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(xPropSet.is())
+    {
+        // Transformation
+        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
+        SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW,
+                                  XML_FRAME, bCreateNewline, sal_True );
+
+        // export frame url
+        OUString aStr;
+        xPropSet->getPropertyValue("FrameURL") >>= aStr;
+        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStr) );
+        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
+
+        // export name
+        xPropSet->getPropertyValue("FrameName") >>= aStr;
+        if( !aStr.isEmpty() )
+            mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_FRAME_NAME, aStr );
+
+        // write floating frame
+        {
+            SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_FLOATING_FRAME, sal_True, sal_True);
+        }
+    }
+}
+
+void XMLShapeExport::ImpExportAppletShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(xPropSet.is())
+    {
+        // Transformation
+        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
+        SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW,
+                                  XML_FRAME, bCreateNewline, sal_True );
+
+        // export frame url
+        OUString aStr;
+        xPropSet->getPropertyValue("AppletCodeBase") >>= aStr;
+        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStr) );
+        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
+
+        // export draw:applet-name
+        xPropSet->getPropertyValue("AppletName") >>= aStr;
+        if( !aStr.isEmpty() )
+            mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_APPLET_NAME, aStr );
+
+        // export draw:code
+        xPropSet->getPropertyValue("AppletCode") >>= aStr;
+        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CODE, aStr );
+
+        // export draw:may-script
+        sal_Bool bIsScript = false;
+        xPropSet->getPropertyValue("AppletIsScript") >>= bIsScript;
+        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MAY_SCRIPT, bIsScript ? XML_TRUE : XML_FALSE );
+
+        {
+            // write applet
+            SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_APPLET, sal_True, sal_True);
+
+            // export parameters
+            uno::Sequence< beans::PropertyValue > aCommands;
+            xPropSet->getPropertyValue("AppletCommands") >>= aCommands;
+            const sal_Int32 nCount = aCommands.getLength();
+            for( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++ )
+            {
+                aCommands[nIndex].Value >>= aStr;
+                mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aCommands[nIndex].Name );
+                mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, aStr );
+                SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True );
+            }
+        }
+    }
+}
+
+void XMLShapeExport::ImpExportPluginShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(xPropSet.is())
+    {
+        // Transformation
+        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
+        SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW,
+                                  XML_FRAME, bCreateNewline, sal_True );
+
+        // export plugin url
+        OUString aStr;
+        xPropSet->getPropertyValue("PluginURL") >>= aStr;
+        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStr) );
+        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
+
+        // export mime-type
+        xPropSet->getPropertyValue("PluginMimeType") >>= aStr;
+        if(!aStr.isEmpty())
+            mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIME_TYPE, aStr );
+
+        {
+            // write plugin
+            SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PLUGIN, sal_True, sal_True);
+
+            // export parameters
+            uno::Sequence< beans::PropertyValue > aCommands;
+            xPropSet->getPropertyValue("PluginCommands") >>= aCommands;
+            const sal_Int32 nCount = aCommands.getLength();
+            for( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++ )
+            {
+                aCommands[nIndex].Value >>= aStr;
+                mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aCommands[nIndex].Name );
+                mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, aStr );
+                SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True );
+            }
+        }
+    }
+}
+
+static void lcl_CopyStream(
+        uno::Reference<io::XInputStream> const& xInStream,
+        uno::Reference<embed::XStorage> const& xTarget,
+        OUString const& rPath)
+{
+    ::comphelper::LifecycleProxy proxy;
+    uno::Reference<io::XStream> const xStream(
+        ::comphelper::OStorageHelper::GetStreamAtPackageURL(xTarget, rPath,
+            embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE, proxy));
+    uno::Reference<io::XOutputStream> const xOutStream(
+            (xStream.is()) ? xStream->getOutputStream() : 0);
+    if (!xOutStream.is())
+    {
+        SAL_WARN("xmloff", "no output stream");
+        throw uno::Exception(
+            OUString("no output stream"),0);
+    }
+    uno::Reference< beans::XPropertySet > const xStreamProps(xStream,
+        uno::UNO_QUERY);
+    if (xStreamProps.is()) { // this is NOT supported in FileSystemStorage
+        xStreamProps->setPropertyValue(
+            OUString("MediaType"),
+            uno::makeAny(OUString(
+            //FIXME how to detect real media type?
+            //but currently xmloff has this one hardcoded anyway...
+                    "application/vnd.sun.star.media")));
+        xStreamProps->setPropertyValue( // turn off compression
+            OUString("Compressed"),
+            uno::makeAny(sal_False));
+    }
+    ::comphelper::OStorageHelper::CopyInputToOutput(xInStream, xOutStream);
+    xOutStream->closeOutput();
+    proxy.commitStorages();
+}
+
+static char const s_PkgScheme[] = "vnd.sun.star.Package:";
+
+static OUString
+lcl_StoreMediaAndGetURL(SvXMLExport & rExport,
+    uno::Reference<beans::XPropertySet> const& xPropSet,
+    OUString const& rURL)
+{
+    if (0 == rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength(
+                rURL.getStr(), rURL.getLength(),
+                s_PkgScheme, SAL_N_ELEMENTS(s_PkgScheme) - 1))
+    {
+        try // video is embedded
+        {
+            uno::Reference<embed::XStorage> const xTarget(
+                    rExport.GetTargetStorage(), uno::UNO_QUERY_THROW);
+            uno::Reference<io::XInputStream> xInStream;
+            xPropSet->getPropertyValue(
+                OUString("PrivateStream"))
+                    >>= xInStream;
+
+            if (!xInStream.is())
+            {
+                SAL_WARN("xmloff", "no input stream");
+                return OUString();
+            }
+
+            OUString const urlPath(
+                    rURL.copy(SAL_N_ELEMENTS(s_PkgScheme)-1));
+
+            lcl_CopyStream(xInStream, xTarget, rURL);
+
+            return urlPath;
+        }
+        catch (uno::Exception const& e)
+        {
+            SAL_INFO("xmloff", "exception while storing embedded media: '"
+                        << e.Message << "'");
+        }
+        return OUString();
+    }
+    else
+    {
+        return rExport.GetRelativeReference(rURL); // linked
+    }
+}
+
+void XMLShapeExport::ImpExportMediaShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType eShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(xPropSet.is())
+    {
+        // Transformation
+        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+        if(eShapeType == XmlShapeTypePresMediaShape)
+            ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_OBJECT) );
+
+        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
+        SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW,
+                                  XML_FRAME, bCreateNewline, sal_True );
+
+        // export media url
+        OUString aMediaURL;
+        xPropSet->getPropertyValue("MediaURL") >>= aMediaURL;
+        OUString const persistentURL =
+            lcl_StoreMediaAndGetURL(GetExport(), xPropSet, aMediaURL);
+        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, persistentURL );
+        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
+
+        // export mime-type
+        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIME_TYPE, OUString(  "application/vnd.sun.star.media"  ) );
+
+        // write plugin
+        SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PLUGIN, !( nFeatures & SEF_EXPORT_NO_WS ), sal_True);
+
+        // export parameters
+        const OUString aFalseStr(  "false"  ), aTrueStr(  "true"  );
+
+        sal_Bool bLoop = false;
+        const OUString aLoopStr(  "Loop"  );
+        xPropSet->getPropertyValue( aLoopStr ) >>= bLoop;
+        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aLoopStr );
+        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, bLoop ? aTrueStr : aFalseStr );
+        delete( new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ) );
+
+        sal_Bool bMute = false;
+        const OUString aMuteStr(  "Mute"  );
+        xPropSet->getPropertyValue( aMuteStr ) >>= bMute;
+        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aMuteStr );
+        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, bMute ? aTrueStr : aFalseStr );
+        delete( new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ) );
+
+        sal_Int16 nVolumeDB = 0;
+        const OUString aVolumeDBStr(  "VolumeDB"  );
+        xPropSet->getPropertyValue("VolumeDB") >>= nVolumeDB;
+        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aVolumeDBStr );
+        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, OUString::number( nVolumeDB ) );
+        delete( new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ) );
+
+        media::ZoomLevel eZoom;
+        const OUString aZoomStr(  "Zoom"  );
+        OUString aZoomValue;
+        xPropSet->getPropertyValue("Zoom") >>= eZoom;
+        switch( eZoom )
+        {
+            case( media::ZoomLevel_ZOOM_1_TO_4 ): aZoomValue = OUString(  "25%"  ); break;
+            case( media::ZoomLevel_ZOOM_1_TO_2 ): aZoomValue = OUString(  "50%"  ); break;
+            case( media::ZoomLevel_ORIGINAL ): aZoomValue = OUString(  "100%"  ); break;
+            case( media::ZoomLevel_ZOOM_2_TO_1 ): aZoomValue = OUString(  "200%"  ); break;
+            case( media::ZoomLevel_ZOOM_4_TO_1 ): aZoomValue = OUString(  "400%"  ); break;
+            case( media::ZoomLevel_FIT_TO_WINDOW ): aZoomValue = OUString(  "fit"  ); break;
+            case( media::ZoomLevel_FIT_TO_WINDOW_FIXED_ASPECT ): aZoomValue = OUString(  "fixedfit"  ); break;
+            case( media::ZoomLevel_FULLSCREEN ): aZoomValue = OUString(  "fullscreen"  ); break;
+
+            default:
+            break;
+        }
+
+        if( !aZoomValue.isEmpty() )
+        {
+            mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aZoomStr );
+            mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, aZoomValue );
+            delete( new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ) );
+        }
+    }
+}
+
+void XMLShapeExport::ImpExport3DSceneShape( const uno::Reference< drawing::XShape >& xShape, XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint)
+{
+    uno::Reference< drawing::XShapes > xShapes(xShape, uno::UNO_QUERY);
+    if(xShapes.is() && xShapes->getCount())
+    {
+        uno::Reference< beans::XPropertySet > xPropSet( xShape, uno::UNO_QUERY );
+        DBG_ASSERT( xPropSet.is(), "XMLShapeExport::ImpExport3DSceneShape can't export a scene without a propertyset" );
+        if( xPropSet.is() )
+        {
+            // Transformation
+            ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+            // 3d attributes
+            export3DSceneAttributes( xPropSet );
+
+            // write 3DScene shape
+            sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
+            SvXMLElementExport aOBJ( mrExport, XML_NAMESPACE_DR3D, XML_SCENE, bCreateNewline, sal_True);
+
+            ImpExportDescription( xShape ); // #i68101#
+            ImpExportEvents( xShape );
+
+            // write 3DSceneLights
+            export3DLamps( xPropSet );
+
+            // #89764# if export of position is supressed for group shape,
+            // positions of contained objects should be written relative to
+            // the upper left edge of the group.
+            awt::Point aUpperLeft;
+
+            if(!(nFeatures & SEF_EXPORT_POSITION))
+            {
+                nFeatures |= SEF_EXPORT_POSITION;
+                aUpperLeft = xShape->getPosition();
+                pRefPoint = &aUpperLeft;
+            }
+
+            // write members
+            exportShapes( xShapes, nFeatures, pRefPoint );
+        }
+    }
+}
+
+void XMLShapeExport::ImpExport3DShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType eShapeType, sal_Int32 /* nFeatures = SEF_DEFAULT */, awt::Point* /*pRefPoint = NULL */)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(xPropSet.is())
+    {
+        OUString aStr;
+        OUStringBuffer sStringBuffer;
+
+        // transformation (UNO_NAME_3D_TRANSFORM_MATRIX == "D3DTransformMatrix")
+        uno::Any aAny = xPropSet->getPropertyValue("D3DTransformMatrix");
+        drawing::HomogenMatrix xHomMat;
+        aAny >>= xHomMat;
+        SdXMLImExTransform3D aTransform;
+        aTransform.AddHomogenMatrix(xHomMat);
+        if(aTransform.NeedsAction())
+            mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_TRANSFORM, aTransform.GetExportString(mrExport.GetMM100UnitConverter()));
+
+        switch(eShapeType)
+        {
+            case XmlShapeTypeDraw3DCubeObject:
+            {
+                // write 3DCube shape
+                SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_CUBE, sal_True, sal_True);
+
+                // minEdge
+                aAny = xPropSet->getPropertyValue("D3DPosition");
+                drawing::Position3D aPosition3D;
+                aAny >>= aPosition3D;
+                ::basegfx::B3DVector aPos3D(aPosition3D.PositionX, aPosition3D.PositionY, aPosition3D.PositionZ);
+
+                // maxEdge
+                aAny = xPropSet->getPropertyValue("D3DSize");
+                drawing::Direction3D aDirection3D;
+                aAny >>= aDirection3D;
+                ::basegfx::B3DVector aDir3D(aDirection3D.DirectionX, aDirection3D.DirectionY, aDirection3D.DirectionZ);
+
+                // transform maxEdge from distance to pos
+                aDir3D = aPos3D + aDir3D;
+
+                // write minEdge
+                if(aPos3D != ::basegfx::B3DVector(-2500.0, -2500.0, -2500.0)) // write only when not default
+                {
+                    mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aPos3D);
+                    aStr = sStringBuffer.makeStringAndClear();
+                    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_MIN_EDGE, aStr);
+                }
+
+                // write maxEdge
+                if(aDir3D != ::basegfx::B3DVector(2500.0, 2500.0, 2500.0)) // write only when not default
+                {
+                    mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aDir3D);
+                    aStr = sStringBuffer.makeStringAndClear();
+                    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_MAX_EDGE, aStr);
+                }
+
+                break;
+            }
+            case XmlShapeTypeDraw3DSphereObject:
+            {
+                // write 3DSphere shape
+                SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_SPHERE, sal_True, sal_True);
+
+                // Center
+                aAny = xPropSet->getPropertyValue("D3DPosition");
+                drawing::Position3D aPosition3D;
+                aAny >>= aPosition3D;
+                ::basegfx::B3DVector aPos3D(aPosition3D.PositionX, aPosition3D.PositionY, aPosition3D.PositionZ);
+
+                // Size
+                aAny = xPropSet->getPropertyValue("D3DSize");
+                drawing::Direction3D aDirection3D;
+                aAny >>= aDirection3D;
+                ::basegfx::B3DVector aDir3D(aDirection3D.DirectionX, aDirection3D.DirectionY, aDirection3D.DirectionZ);
+
+                // write Center
+                if(aPos3D != ::basegfx::B3DVector(0.0, 0.0, 0.0)) // write only when not default
+                {
+                    mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aPos3D);
+                    aStr = sStringBuffer.makeStringAndClear();
+                    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_CENTER, aStr);
+                }
+
+                // write Size
+                if(aDir3D != ::basegfx::B3DVector(5000.0, 5000.0, 5000.0)) // write only when not default
+                {
+                    mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aDir3D);
+                    aStr = sStringBuffer.makeStringAndClear();
+                    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_SIZE, aStr);
+                }
+
+                break;
+            }
+            case XmlShapeTypeDraw3DLatheObject:
+            case XmlShapeTypeDraw3DExtrudeObject:
+            {
+                // write special 3DLathe/3DExtrude attributes
+                aAny = xPropSet->getPropertyValue("D3DPolyPolygon3D");
+                drawing::PolyPolygonShape3D xPolyPolygon3D;
+                aAny >>= xPolyPolygon3D;
+
+                // look for maximal values
+                double fXMin = 0;
+                double fXMax = 0;
+                double fYMin = 0;
+                double fYMax = 0;
+                sal_Bool bInit(sal_False);
+                sal_Int32 nOuterSequenceCount(xPolyPolygon3D.SequenceX.getLength());
+                drawing::DoubleSequence* pInnerSequenceX = xPolyPolygon3D.SequenceX.getArray();
+                drawing::DoubleSequence* pInnerSequenceY = xPolyPolygon3D.SequenceY.getArray();
+
+                sal_Int32 a;
+                for (a = 0; a < nOuterSequenceCount; a++)
+                {
+                    sal_Int32 nInnerSequenceCount(pInnerSequenceX->getLength());
+                    double* pArrayX = pInnerSequenceX->getArray();
+                    double* pArrayY = pInnerSequenceY->getArray();
+
+                    for(sal_Int32 b(0L); b < nInnerSequenceCount; b++)
+                    {
+                        double fX = *pArrayX++;
+                        double fY = *pArrayY++;
+
+                        if(bInit)
+                        {
+                            if(fX > fXMax)
+                                fXMax = fX;
+
+                            if(fX < fXMin)
+                                fXMin = fX;
+
+                            if(fY > fYMax)
+                                fYMax = fY;
+
+                            if(fY < fYMin)
+                                fYMin = fY;
+                        }
+                        else
+                        {
+                            fXMin = fXMax = fX;
+                            fYMin = fYMax = fY;
+                            bInit = sal_True;
+                        }
+                    }
+
+                    pInnerSequenceX++;
+                    pInnerSequenceY++;
+                }
+
+                // export ViewBox
+                awt::Point aMinPoint(FRound(fXMin), FRound(fYMin));
+                awt::Size aMaxSize(FRound(fXMax) - aMinPoint.X, FRound(fYMax) - aMinPoint.Y);
+                SdXMLImExViewBox aViewBox(
+                    aMinPoint.X, aMinPoint.Y, aMaxSize.Width, aMaxSize.Height);
+                mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_VIEWBOX,
+                    aViewBox.GetExportString());
+
+                // prepare svx:d element export
+                SdXMLImExSvgDElement aSvgDElement(aViewBox, GetExport());
+                pInnerSequenceX = xPolyPolygon3D.SequenceX.getArray();
+                pInnerSequenceY = xPolyPolygon3D.SequenceY.getArray();
+
+                for (a = 0; a < nOuterSequenceCount; a++)
+                {
+                    sal_Int32 nInnerSequenceCount(pInnerSequenceX->getLength());
+                    double* pArrayX = pInnerSequenceX->getArray();
+                    double* pArrayY = pInnerSequenceY->getArray();
+                    drawing::PointSequence aPoly(nInnerSequenceCount);
+                    awt::Point* pInnerSequence = aPoly.getArray();
+
+                    for(sal_Int32 b(0L); b < nInnerSequenceCount; b++)
+                    {
+                        double fX = *pArrayX++;
+                        double fY = *pArrayY++;
+
+                        *pInnerSequence = awt::Point(FRound(fX), FRound(fY));
+                        pInnerSequence++;
+                    }
+
+                    // calculate closed flag
+                    awt::Point* pFirst = aPoly.getArray();
+                    awt::Point* pLast = pFirst + (nInnerSequenceCount - 1);
+                    sal_Bool bClosed = (pFirst->X == pLast->X && pFirst->Y == pLast->Y);
+
+                    aSvgDElement.AddPolygon(&aPoly, 0L, aMinPoint,
+                        aMaxSize, bClosed);
+
+                    // #80594# corrected error in PolyPolygon3D export for 3D XML
+                    pInnerSequenceX++;
+                    pInnerSequenceY++;
+                }
+
+                // write point array
+                mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aSvgDElement.GetExportString());
+
+                if(eShapeType == XmlShapeTypeDraw3DLatheObject)
+                {
+                    // write 3DLathe shape
+                    SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_ROTATE, sal_True, sal_True);
+                }
+                else
+                {
+                    // write 3DExtrude shape
+                    SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_EXTRUDE, sal_True, sal_True);
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+}
+
+/** helper for chart that adds all attributes of a 3d scene element to the export */
+void XMLShapeExport::export3DSceneAttributes( const com::sun::star::uno::Reference< com::sun::star::beans::XPropertySet >& xPropSet )
+{
+    OUString aStr;
+    OUStringBuffer sStringBuffer;
+
+    // world transformation (UNO_NAME_3D_TRANSFORM_MATRIX == "D3DTransformMatrix")
+    uno::Any aAny = xPropSet->getPropertyValue("D3DTransformMatrix");
+    drawing::HomogenMatrix xHomMat;
+    aAny >>= xHomMat;
+    SdXMLImExTransform3D aTransform;
+    aTransform.AddHomogenMatrix(xHomMat);
+    if(aTransform.NeedsAction())
+        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_TRANSFORM, aTransform.GetExportString(mrExport.GetMM100UnitConverter()));
+
+    // VRP, VPN, VUP
+    aAny = xPropSet->getPropertyValue("D3DCameraGeometry");
+    drawing::CameraGeometry aCamGeo;
+    aAny >>= aCamGeo;
+
+    ::basegfx::B3DVector aVRP(aCamGeo.vrp.PositionX, aCamGeo.vrp.PositionY, aCamGeo.vrp.PositionZ);
+    if(aVRP != ::basegfx::B3DVector(0.0, 0.0, 1.0)) // write only when not default
+    {
+        mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aVRP);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_VRP, aStr);
+    }
+
+    ::basegfx::B3DVector aVPN(aCamGeo.vpn.DirectionX, aCamGeo.vpn.DirectionY, aCamGeo.vpn.DirectionZ);
+    if(aVPN != ::basegfx::B3DVector(0.0, 0.0, 1.0)) // write only when not default
+    {
+        mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aVPN);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_VPN, aStr);
+    }
+
+    ::basegfx::B3DVector aVUP(aCamGeo.vup.DirectionX, aCamGeo.vup.DirectionY, aCamGeo.vup.DirectionZ);
+    if(aVUP != ::basegfx::B3DVector(0.0, 1.0, 0.0)) // write only when not default
+    {
+        mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aVUP);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_VUP, aStr);
+    }
+
+    // projection "D3DScenePerspective" drawing::ProjectionMode
+    aAny = xPropSet->getPropertyValue("D3DScenePerspective");
+    drawing::ProjectionMode xPrjMode;
+    aAny >>= xPrjMode;
+    if(xPrjMode == drawing::ProjectionMode_PARALLEL)
+        aStr = GetXMLToken(XML_PARALLEL);
+    else
+        aStr = GetXMLToken(XML_PERSPECTIVE);
+    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_PROJECTION, aStr);
+
+    // distance
+    aAny = xPropSet->getPropertyValue("D3DSceneDistance");
+    sal_Int32 nDistance = 0;
+    aAny >>= nDistance;
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+            nDistance);
+    aStr = sStringBuffer.makeStringAndClear();
+    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_DISTANCE, aStr);
+
+    // focalLength
+    aAny = xPropSet->getPropertyValue("D3DSceneFocalLength");
+    sal_Int32 nFocalLength = 0;
+    aAny >>= nFocalLength;
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+            nFocalLength);
+    aStr = sStringBuffer.makeStringAndClear();
+    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_FOCAL_LENGTH, aStr);
+
+    // shadowSlant
+    aAny = xPropSet->getPropertyValue("D3DSceneShadowSlant");
+    sal_Int16 nShadowSlant = 0;
+    aAny >>= nShadowSlant;
+    ::sax::Converter::convertNumber(sStringBuffer, (sal_Int32)nShadowSlant);
+    aStr = sStringBuffer.makeStringAndClear();
+    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_SHADOW_SLANT, aStr);
+
+    // shadeMode
+    aAny = xPropSet->getPropertyValue("D3DSceneShadeMode");
+    drawing::ShadeMode xShadeMode;
+    if(aAny >>= xShadeMode)
+    {
+        if(xShadeMode == drawing::ShadeMode_FLAT)
+            aStr = GetXMLToken(XML_FLAT);
+        else if(xShadeMode == drawing::ShadeMode_PHONG)
+            aStr = GetXMLToken(XML_PHONG);
+        else if(xShadeMode == drawing::ShadeMode_SMOOTH)
+            aStr = GetXMLToken(XML_GOURAUD);
+        else
+            aStr = GetXMLToken(XML_DRAFT);
+    }
+    else
+    {
+        // ShadeMode enum not there, write default
+        aStr = GetXMLToken(XML_GOURAUD);
+    }
+    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_SHADE_MODE, aStr);
+
+    // ambientColor
+    aAny = xPropSet->getPropertyValue("D3DSceneAmbientColor");
+    sal_Int32 nAmbientColor = 0;
+    aAny >>= nAmbientColor;
+    ::sax::Converter::convertColor(sStringBuffer, nAmbientColor);
+    aStr = sStringBuffer.makeStringAndClear();
+    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_AMBIENT_COLOR, aStr);
+
+    // lightingMode
+    aAny = xPropSet->getPropertyValue("D3DSceneTwoSidedLighting");
+    sal_Bool bTwoSidedLighting = false;
+    aAny >>= bTwoSidedLighting;
+    ::sax::Converter::convertBool(sStringBuffer, bTwoSidedLighting);
+    aStr = sStringBuffer.makeStringAndClear();
+    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_LIGHTING_MODE, aStr);
+}
+
+/** helper for chart that exports all lamps from the propertyset */
+void XMLShapeExport::export3DLamps( const com::sun::star::uno::Reference< com::sun::star::beans::XPropertySet >& xPropSet )
+{
+    // write lamps 1..8 as content
+    OUString aStr;
+    OUStringBuffer sStringBuffer;
+
+    const OUString aColorPropName("D3DSceneLightColor");
+    const OUString aDirectionPropName("D3DSceneLightDirection");
+    const OUString aLightOnPropName("D3DSceneLightOn");
+
+    OUString aPropName;
+    OUString aIndexStr;
+    ::basegfx::B3DVector aLightDirection;
+    drawing::Direction3D xLightDir;
+    sal_Bool bLightOnOff = false;
+    for(sal_Int32 nLamp = 1; nLamp <= 8; nLamp++)
+    {
+        aIndexStr = OUString::number( nLamp );
+
+        // lightcolor
+        aPropName = aColorPropName;
+        aPropName += aIndexStr;
+        sal_Int32 nLightColor = 0;
+        xPropSet->getPropertyValue( aPropName ) >>= nLightColor;
+        ::sax::Converter::convertColor(sStringBuffer, nLightColor);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_DIFFUSE_COLOR, aStr);
+
+        // lightdirection
+        aPropName = aDirectionPropName;
+        aPropName += aIndexStr;
+        xPropSet->getPropertyValue(aPropName) >>= xLightDir;
+        aLightDirection = ::basegfx::B3DVector(xLightDir.DirectionX, xLightDir.DirectionY, xLightDir.DirectionZ);
+        mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aLightDirection);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_DIRECTION, aStr);
+
+        // lighton
+        aPropName = aLightOnPropName;
+        aPropName += aIndexStr;
+        xPropSet->getPropertyValue(aPropName) >>= bLightOnOff;
+        ::sax::Converter::convertBool(sStringBuffer, bLightOnOff);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_ENABLED, aStr);
+
+        // specular
+        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_SPECULAR,
+            nLamp == 1 ? XML_TRUE : XML_FALSE);
+
+        // write light entry
+        SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_LIGHT, sal_True, sal_True);
+    }
+}
+
+
+// using namespace ::com::sun::star::io;
+// using namespace ::xmloff::EnhancedCustomShapeToken;
+
+
+void ExportParameter( OUStringBuffer& rStrBuffer, const com::sun::star::drawing::EnhancedCustomShapeParameter& rParameter )
+{
+    if ( !rStrBuffer.isEmpty() )
+        rStrBuffer.append( (sal_Unicode)' ' );
+    if ( rParameter.Value.getValueTypeClass() == uno::TypeClass_DOUBLE )
+    {
+        double fNumber = 0.0;
+        rParameter.Value >>= fNumber;
+        ::rtl::math::doubleToUStringBuffer( rStrBuffer, fNumber, rtl_math_StringFormat_Automatic, rtl_math_DecimalPlaces_Max, '.', sal_True );
+    }
+    else
+    {
+        sal_Int32 nValue = 0;
+        rParameter.Value >>= nValue;
+
+        switch( rParameter.Type )
+        {
+            case com::sun::star::drawing::EnhancedCustomShapeParameterType::EQUATION :
+            {
+                rStrBuffer.append( "?f" + OUString::number( nValue ) );
+            }
+            break;
+
+            case com::sun::star::drawing::EnhancedCustomShapeParameterType::ADJUSTMENT :
+            {
+                rStrBuffer.append( (sal_Unicode)'$' );
+                rStrBuffer.append( OUString::number( nValue ) );
+            }
+            break;
+
+            case com::sun::star::drawing::EnhancedCustomShapeParameterType::BOTTOM :
+                rStrBuffer.append( GetXMLToken( XML_BOTTOM ) ); break;
+            case com::sun::star::drawing::EnhancedCustomShapeParameterType::RIGHT :
+                rStrBuffer.append( GetXMLToken( XML_RIGHT ) ); break;
+            case com::sun::star::drawing::EnhancedCustomShapeParameterType::TOP :
+                rStrBuffer.append( GetXMLToken( XML_TOP ) ); break;
+            case com::sun::star::drawing::EnhancedCustomShapeParameterType::LEFT :
+                rStrBuffer.append( GetXMLToken( XML_LEFT ) ); break;
+            case com::sun::star::drawing::EnhancedCustomShapeParameterType::XSTRETCH :
+                rStrBuffer.append( GetXMLToken( XML_XSTRETCH ) ); break;
+            case com::sun::star::drawing::EnhancedCustomShapeParameterType::YSTRETCH :
+                rStrBuffer.append( GetXMLToken( XML_YSTRETCH ) ); break;
+            case com::sun::star::drawing::EnhancedCustomShapeParameterType::HASSTROKE :
+                rStrBuffer.append( GetXMLToken( XML_HASSTROKE ) ); break;
+            case com::sun::star::drawing::EnhancedCustomShapeParameterType::HASFILL :
+                rStrBuffer.append( GetXMLToken( XML_HASFILL ) ); break;
+            case com::sun::star::drawing::EnhancedCustomShapeParameterType::WIDTH :
+                rStrBuffer.append( GetXMLToken( XML_WIDTH ) ); break;
+            case com::sun::star::drawing::EnhancedCustomShapeParameterType::HEIGHT :
+                rStrBuffer.append( GetXMLToken( XML_HEIGHT ) ); break;
+            case com::sun::star::drawing::EnhancedCustomShapeParameterType::LOGWIDTH :
+                rStrBuffer.append( GetXMLToken( XML_LOGWIDTH ) ); break;
+            case com::sun::star::drawing::EnhancedCustomShapeParameterType::LOGHEIGHT :
+                rStrBuffer.append( GetXMLToken( XML_LOGHEIGHT ) ); break;
+            default :
+                rStrBuffer.append( OUString::number( nValue ) );
+        }
+    }
+}
+
+void ImpExportEquations( SvXMLExport& rExport, const uno::Sequence< OUString >& rEquations )
+{
+    sal_Int32 i;
+    for ( i = 0; i < rEquations.getLength(); i++ )
+    {
+        OUString aStr(static_cast<sal_Unicode>('f'));
+        aStr += OUString::number( i );
+        rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aStr );
+
+        aStr = rEquations[ i ];
+        sal_Int32 nIndex = 0;
+        do
+        {
+            nIndex = aStr.indexOf( (sal_Unicode)'?', nIndex );
+            if ( nIndex != -1 )
+            {
+                OUString aNew( aStr.copy( 0, nIndex + 1 ) );
+                aNew += OUString(static_cast<sal_Unicode>('f'));
+                aNew += aStr.copy( nIndex + 1, ( aStr.getLength() - nIndex ) - 1 );
+                aStr = aNew;
+                nIndex++;
+            }
+        } while( nIndex != -1 );
+        rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_FORMULA, aStr );
+        SvXMLElementExport aOBJ( rExport, XML_NAMESPACE_DRAW, XML_EQUATION, sal_True, sal_True );
+    }
+}
+
+void ImpExportHandles( SvXMLExport& rExport, const uno::Sequence< beans::PropertyValues >& rHandles )
+{
+    sal_uInt32 i, j, nElements = rHandles.getLength();
+    if ( nElements )
+    {
+        OUString       aStr;
+        OUStringBuffer aStrBuffer;
+
+        for ( i = 0; i < nElements; i++ )
+        {
+            sal_Bool bPosition = sal_False;
+            const uno::Sequence< beans::PropertyValue >& rPropSeq = rHandles[ i ];
+            for ( j = 0; j < (sal_uInt32)rPropSeq.getLength(); j++ )
+            {
+                const beans::PropertyValue& rPropVal = rPropSeq[ j ];
+                switch( EASGet( rPropVal.Name ) )
+                {
+                    case EAS_Position :
+                    {
+                        com::sun::star::drawing::EnhancedCustomShapeParameterPair aPosition;
+                        if ( rPropVal.Value >>= aPosition )
+                        {
+                            ExportParameter( aStrBuffer, aPosition.First );
+                            ExportParameter( aStrBuffer, aPosition.Second );
+                            aStr = aStrBuffer.makeStringAndClear();
+                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_POSITION, aStr );
+                            bPosition = sal_True;
+                        }
+                    }
+                    break;
+                    case EAS_MirroredX :
+                    {
+                        sal_Bool bMirroredX = sal_Bool();
+                        if ( rPropVal.Value >>= bMirroredX )
+                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_MIRROR_HORIZONTAL,
+                                bMirroredX ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                    }
+                    break;
+                    case EAS_MirroredY :
+                    {
+                        sal_Bool bMirroredY = sal_Bool();
+                        if ( rPropVal.Value >>= bMirroredY )
+                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_MIRROR_VERTICAL,
+                                bMirroredY ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                    }
+                    break;
+                    case EAS_Switched :
+                    {
+                        sal_Bool bSwitched = sal_Bool();
+                        if ( rPropVal.Value >>= bSwitched )
+                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_SWITCHED,
+                                bSwitched ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                    }
+                    break;
+                    case EAS_Polar :
+                    {
+                        com::sun::star::drawing::EnhancedCustomShapeParameterPair aPolar;
+                        if ( rPropVal.Value >>= aPolar )
+                        {
+                            ExportParameter( aStrBuffer, aPolar.First );
+                            ExportParameter( aStrBuffer, aPolar.Second );
+                            aStr = aStrBuffer.makeStringAndClear();
+                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_POLAR, aStr );
+                        }
+                    }
+                    break;
+                    case EAS_RadiusRangeMinimum :
+                    {
+                        com::sun::star::drawing::EnhancedCustomShapeParameter aRadiusRangeMinimum;
+                        if ( rPropVal.Value >>= aRadiusRangeMinimum )
+                        {
+                            ExportParameter( aStrBuffer, aRadiusRangeMinimum );
+                            aStr = aStrBuffer.makeStringAndClear();
+                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RADIUS_RANGE_MINIMUM, aStr );
+                        }
+                    }
+                    break;
+                    case EAS_RadiusRangeMaximum :
+                    {
+                        com::sun::star::drawing::EnhancedCustomShapeParameter aRadiusRangeMaximum;
+                        if ( rPropVal.Value >>= aRadiusRangeMaximum )
+                        {
+                            ExportParameter( aStrBuffer, aRadiusRangeMaximum );
+                            aStr = aStrBuffer.makeStringAndClear();
+                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RADIUS_RANGE_MAXIMUM, aStr );
+                        }
+                    }
+                    break;
+                    case EAS_RangeXMinimum :
+                    {
+                        com::sun::star::drawing::EnhancedCustomShapeParameter aXRangeMinimum;
+                        if ( rPropVal.Value >>= aXRangeMinimum )
+                        {
+                            ExportParameter( aStrBuffer, aXRangeMinimum );
+                            aStr = aStrBuffer.makeStringAndClear();
+                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_X_MINIMUM, aStr );
+                        }
+                    }
+                    break;
+                    case EAS_RangeXMaximum :
+                    {
+                        com::sun::star::drawing::EnhancedCustomShapeParameter aXRangeMaximum;
+                        if ( rPropVal.Value >>= aXRangeMaximum )
+                        {
+                            ExportParameter( aStrBuffer, aXRangeMaximum );
+                            aStr = aStrBuffer.makeStringAndClear();
+                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_X_MAXIMUM, aStr );
+                        }
+                    }
+                    break;
+                    case EAS_RangeYMinimum :
+                    {
+                        com::sun::star::drawing::EnhancedCustomShapeParameter aYRangeMinimum;
+                        if ( rPropVal.Value >>= aYRangeMinimum )
+                        {
+                            ExportParameter( aStrBuffer, aYRangeMinimum );
+                            aStr = aStrBuffer.makeStringAndClear();
+                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_Y_MINIMUM, aStr );
+                        }
+                    }
+                    break;
+                    case EAS_RangeYMaximum :
+                    {
+                        com::sun::star::drawing::EnhancedCustomShapeParameter aYRangeMaximum;
+                        if ( rPropVal.Value >>= aYRangeMaximum )
+                        {
+                            ExportParameter( aStrBuffer, aYRangeMaximum );
+                            aStr = aStrBuffer.makeStringAndClear();
+                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_Y_MAXIMUM, aStr );
+                        }
+                    }
+                    break;
+                    default:
+                        break;
+                }
+            }
+            if ( bPosition )
+                SvXMLElementExport aOBJ( rExport, XML_NAMESPACE_DRAW, XML_HANDLE, sal_True, sal_True );
+            else
+                rExport.ClearAttrList();
+        }
+    }
+}
+
+void ImpExportEnhancedPath( SvXMLExport& rExport,
+                            const uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair >& rCoordinates,
+                            const uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeSegment >& rSegments,
+                            bool bExtended = false )
+{
+
+    OUString       aStr;
+    OUStringBuffer aStrBuffer;
+    bool bNeedExtended = false;
+
+    sal_Int32 i, j, k, l;
+
+    sal_Int32 nCoords = rCoordinates.getLength();
+    sal_Int32 nSegments = rSegments.getLength();
+    sal_Bool bSimpleSegments = nSegments == 0;
+    if ( bSimpleSegments )
+        nSegments = 4;
+    for ( j = i = 0; j < nSegments; j++ )
+    {
+        com::sun::star::drawing::EnhancedCustomShapeSegment aSegment;
+        if ( bSimpleSegments )
+        {
+            // if there are not enough segments we will default them
+            switch( j )
+            {
+                case 0 :
+                {
+                    aSegment.Count = 1;
+                    aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::MOVETO;
+                }
+                break;
+                case 1 :
+                {
+                    aSegment.Count = (sal_Int16)std::min( nCoords - 1, (sal_Int32)32767 );
+                    aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LINETO;
+                }
+                break;
+                case 2 :
+                {
+                    aSegment.Count = 1;
+                    aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOSESUBPATH;
+                }
+                break;
+                case 3 :
+                {
+                    aSegment.Count = 1;
+                    aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ENDSUBPATH;
+                }
+                break;
+            }
+        }
+        else
+            aSegment = rSegments[ j ];
+
+        if ( !aStrBuffer.isEmpty() )
+            aStrBuffer.append( (sal_Unicode)' ' );
+
+        sal_Int32 nParameter = 0;
+        switch( aSegment.Command )
+        {
+            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOSESUBPATH :
+                aStrBuffer.append( (sal_Unicode)'Z' ); break;
+            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ENDSUBPATH :
+                aStrBuffer.append( (sal_Unicode)'N' ); break;
+            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::NOFILL :
+                aStrBuffer.append( (sal_Unicode)'F' ); break;
+            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::NOSTROKE :
+                aStrBuffer.append( (sal_Unicode)'S' ); break;
+
+            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::MOVETO :
+                aStrBuffer.append( (sal_Unicode)'M' ); nParameter = 1; break;
+            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LINETO :
+                aStrBuffer.append( (sal_Unicode)'L' ); nParameter = 1; break;
+            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CURVETO :
+                aStrBuffer.append( (sal_Unicode)'C' ); nParameter = 3; break;
+            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSETO :
+                aStrBuffer.append( (sal_Unicode)'T' ); nParameter = 3; break;
+            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSE :
+                aStrBuffer.append( (sal_Unicode)'U' ); nParameter = 3; break;
+            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ARCTO :
+                aStrBuffer.append( (sal_Unicode)'A' ); nParameter = 4; break;
+            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ARC :
+                aStrBuffer.append( (sal_Unicode)'B' ); nParameter = 4; break;
+            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARCTO :
+                aStrBuffer.append( (sal_Unicode)'W' ); nParameter = 4; break;
+            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARC :
+                aStrBuffer.append( (sal_Unicode)'V' ); nParameter = 4; break;
+            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTX :
+                aStrBuffer.append( (sal_Unicode)'X' ); nParameter = 1; break;
+            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTY :
+                aStrBuffer.append( (sal_Unicode)'Y' ); nParameter = 1; break;
+            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::QUADRATICCURVETO :
+                aStrBuffer.append( (sal_Unicode)'Q' ); nParameter = 2; break;
+            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ARCANGLETO :
+                if ( bExtended ) {
+                    aStrBuffer.append( (sal_Unicode)'G' );
+                    nParameter = 2;
+                } else {
+                    aStrBuffer.setLength( aStrBuffer.getLength() - 1);
+                    bNeedExtended = true;
+                    i += 2;
+                }
+                break;
+            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::DARKEN :
+                if ( bExtended )
+                    aStrBuffer.append( (sal_Unicode)'H' );
+                else
+                    bNeedExtended = true;
+                break;
+            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::DARKENLESS :
+                if ( bExtended )
+                    aStrBuffer.append( (sal_Unicode)'I' );
+                else
+                    bNeedExtended = true;
+                break;
+            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LIGHTEN :
+                if ( bExtended )
+                    aStrBuffer.append( (sal_Unicode)'J' );
+                else
+                    bNeedExtended = true;
+                break;
+            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LIGHTENLESS :
+                if ( bExtended )
+                    aStrBuffer.append( (sal_Unicode)'K' );
+                else
+                    bNeedExtended = true;
+                break;
+            default : // ups, seems to be something wrong
+            {
+                aSegment.Count = 1;
+                aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LINETO;
+            }
+            break;
+        }
+        if ( nParameter )
+        {
+            for ( k = 0; k < aSegment.Count; k++ )
+            {
+                if ( ( i + nParameter ) <= nCoords )
+                {
+                    for ( l = 0; l < nParameter; l++ )
+                    {
+                        ExportParameter( aStrBuffer, rCoordinates[ i ].First );
+                        ExportParameter( aStrBuffer, rCoordinates[ i++ ].Second );
+                    }
+                }
+                else
+                {
+                    j = nSegments;  // error -> exiting
+                    break;
+                }
+            }
+        }
+    }
+    aStr = aStrBuffer.makeStringAndClear();
+    rExport.AddAttribute( bExtended ? XML_NAMESPACE_DRAW_EXT : XML_NAMESPACE_DRAW, XML_ENHANCED_PATH, aStr );
+    if ( !bExtended && bNeedExtended )
+        ImpExportEnhancedPath( rExport, rCoordinates, rSegments, true );
+}
+
+void ImpExportEnhancedGeometry( SvXMLExport& rExport, const uno::Reference< beans::XPropertySet >& xPropSet )
+{
+    sal_Bool bEquations = sal_False;
+    uno::Sequence< OUString > aEquations;
+
+    sal_Bool bHandles = sal_False;
+    uno::Sequence< beans::PropertyValues > aHandles;
+
+    sal_Bool bCoordinates = sal_False;
+    uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeSegment > aSegments;
+    uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair > aCoordinates;
+
+    uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue > aAdjustmentValues;
+
+    OUString       aStr;
+    OUStringBuffer aStrBuffer;
+    SvXMLUnitConverter& rUnitConverter = rExport.GetMM100UnitConverter();
+
+    uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
+
+    // geometry
+    const OUString sCustomShapeGeometry( "CustomShapeGeometry" );
+    if ( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName( sCustomShapeGeometry ) )
+    {
+        uno::Any aGeoPropSet( xPropSet->getPropertyValue( sCustomShapeGeometry ) );
+        uno::Sequence< beans::PropertyValue > aGeoPropSeq;
+
+        if ( aGeoPropSet >>= aGeoPropSeq )
+        {
+            const OUString sCustomShapeType( "non-primitive" );
+            OUString aCustomShapeType( sCustomShapeType );
+
+            sal_Int32 j, nGeoPropCount = aGeoPropSeq.getLength();
+            for ( j = 0; j < nGeoPropCount; j++ )
+            {
+                const beans::PropertyValue& rGeoProp = aGeoPropSeq[ j ];
+                switch( EASGet( rGeoProp.Name ) )
+                {
+                    case EAS_Type :
+                    {
+                        rGeoProp.Value >>= aCustomShapeType;
+                    }
+                    break;
+                    case EAS_MirroredX :
+                    {
+                        sal_Bool bMirroredX = sal_Bool();
+                        if ( rGeoProp.Value >>= bMirroredX )
+                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIRROR_HORIZONTAL,
+                                bMirroredX ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                    }
+                    break;
+                    case EAS_MirroredY :
+                    {
+                        sal_Bool bMirroredY = sal_Bool();
+                        if ( rGeoProp.Value >>= bMirroredY )
+                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIRROR_VERTICAL,
+                                bMirroredY ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                    }
+                    break;
+                    case EAS_ViewBox :
+                    {
+                        awt::Rectangle aRect;
+                        if ( rGeoProp.Value >>= aRect )
+                        {
+                            SdXMLImExViewBox aViewBox( aRect.X, aRect.Y, aRect.Width, aRect.Height );
+                            rExport.AddAttribute( XML_NAMESPACE_SVG, XML_VIEWBOX, aViewBox.GetExportString() );
+                        }
+                    }
+                    break;
+                    case EAS_TextRotateAngle :
+                    {
+                        double fTextRotateAngle = 0;
+                        if ( rGeoProp.Value >>= fTextRotateAngle )
+                        {
+                            ::sax::Converter::convertDouble(
+                                    aStrBuffer, fTextRotateAngle );
+                            aStr = aStrBuffer.makeStringAndClear();
+                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_ROTATE_ANGLE, aStr );
+                        }
+                    }
+                    break;
+                    case EAS_Extrusion :
+                    {
+                        uno::Sequence< beans::PropertyValue > aExtrusionPropSeq;
+                        if ( rGeoProp.Value >>= aExtrusionPropSeq )
+                        {
+                            sal_Int32 i, nCount = aExtrusionPropSeq.getLength();
+                            for ( i = 0; i < nCount; i++ )
+                            {
+                                const beans::PropertyValue& rProp = aExtrusionPropSeq[ i ];
+                                switch( EASGet( rProp.Name ) )
+                                {
+                                    case EAS_Extrusion :
+                                    {
+                                        sal_Bool bExtrusionOn = sal_Bool();
+                                        if ( rProp.Value >>= bExtrusionOn )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION,
+                                                bExtrusionOn ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                                    }
+                                    break;
+                                    case EAS_Brightness :
+                                    {
+                                        double fExtrusionBrightness = 0;
+                                        if ( rProp.Value >>= fExtrusionBrightness )
+                                        {
+                                            ::sax::Converter::convertDouble(
+                                                aStrBuffer,
+                                                fExtrusionBrightness,
+                                                false,
+                                                util::MeasureUnit::PERCENT,
+                                                util::MeasureUnit::PERCENT);
+                                            aStrBuffer.append( (sal_Unicode)'%' );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_BRIGHTNESS, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_Depth :
+                                    {
+                                        com::sun::star::drawing::EnhancedCustomShapeParameterPair aDepthParaPair;
+                                        if ( rProp.Value >>= aDepthParaPair )
+                                        {
+                                            double fDepth = 0;
+                                            if ( aDepthParaPair.First.Value >>= fDepth )
+                                            {
+                                                rExport.GetMM100UnitConverter().convertDouble( aStrBuffer, fDepth, sal_True );
+                                                ExportParameter( aStrBuffer, aDepthParaPair.Second );
+                                                aStr = aStrBuffer.makeStringAndClear();
+                                                rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_DEPTH, aStr );
+                                            }
+                                        }
+                                    }
+                                    break;
+                                    case EAS_Diffusion :
+                                    {
+                                        double fExtrusionDiffusion = 0;
+                                        if ( rProp.Value >>= fExtrusionDiffusion )
+                                        {
+                                            ::sax::Converter::convertDouble(
+                                                aStrBuffer,
+                                                fExtrusionDiffusion,
+                                                false,
+                                                util::MeasureUnit::PERCENT,
+                                                util::MeasureUnit::PERCENT);
+                                            aStrBuffer.append( (sal_Unicode)'%' );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_DIFFUSION, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_NumberOfLineSegments :
+                                    {
+                                        sal_Int32 nExtrusionNumberOfLineSegments = 0;
+                                        if ( rProp.Value >>= nExtrusionNumberOfLineSegments )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_NUMBER_OF_LINE_SEGMENTS, OUString::number( nExtrusionNumberOfLineSegments ) );
+                                    }
+                                    break;
+                                    case EAS_LightFace :
+                                    {
+                                        sal_Bool bExtrusionLightFace = sal_Bool();
+                                        if ( rProp.Value >>= bExtrusionLightFace )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_LIGHT_FACE,
+                                                bExtrusionLightFace ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                                    }
+                                    break;
+                                    case EAS_FirstLightHarsh :
+                                    {
+                                        sal_Bool bExtrusionFirstLightHarsh = sal_Bool();
+                                        if ( rProp.Value >>= bExtrusionFirstLightHarsh )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_FIRST_LIGHT_HARSH,
+                                                bExtrusionFirstLightHarsh ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                                    }
+                                    break;
+                                    case EAS_SecondLightHarsh :
+                                    {
+                                        sal_Bool bExtrusionSecondLightHarsh = sal_Bool();
+                                        if ( rProp.Value >>= bExtrusionSecondLightHarsh )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SECOND_LIGHT_HARSH,
+                                                bExtrusionSecondLightHarsh ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                                    }
+                                    break;
+                                    case EAS_FirstLightLevel :
+                                    {
+                                        double fExtrusionFirstLightLevel = 0;
+                                        if ( rProp.Value >>= fExtrusionFirstLightLevel )
+                                        {
+                                            ::sax::Converter::convertDouble(
+                                                aStrBuffer,
+                                                fExtrusionFirstLightLevel,
+                                                false,
+                                                util::MeasureUnit::PERCENT,
+                                                util::MeasureUnit::PERCENT);
+                                            aStrBuffer.append( (sal_Unicode)'%' );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_FIRST_LIGHT_LEVEL, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_SecondLightLevel :
+                                    {
+                                        double fExtrusionSecondLightLevel = 0;
+                                        if ( rProp.Value >>= fExtrusionSecondLightLevel )
+                                        {
+                                            ::sax::Converter::convertDouble(
+                                                aStrBuffer,
+                                                fExtrusionSecondLightLevel,
+                                                false,
+                                                util::MeasureUnit::PERCENT,
+                                                util::MeasureUnit::PERCENT);
+                                            aStrBuffer.append( (sal_Unicode)'%' );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SECOND_LIGHT_LEVEL, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_FirstLightDirection :
+                                    {
+                                        drawing::Direction3D aExtrusionFirstLightDirection;
+                                        if ( rProp.Value >>= aExtrusionFirstLightDirection )
+                                        {
+                                            ::basegfx::B3DVector aVec3D( aExtrusionFirstLightDirection.DirectionX, aExtrusionFirstLightDirection.DirectionY,
+                                                aExtrusionFirstLightDirection.DirectionZ );
+                                            rUnitConverter.convertB3DVector( aStrBuffer, aVec3D );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_FIRST_LIGHT_DIRECTION, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_SecondLightDirection :
+                                    {
+                                        drawing::Direction3D aExtrusionSecondLightDirection;
+                                        if ( rProp.Value >>= aExtrusionSecondLightDirection )
+                                        {
+                                            ::basegfx::B3DVector aVec3D( aExtrusionSecondLightDirection.DirectionX, aExtrusionSecondLightDirection.DirectionY,
+                                                aExtrusionSecondLightDirection.DirectionZ );
+                                            rUnitConverter.convertB3DVector( aStrBuffer, aVec3D );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SECOND_LIGHT_DIRECTION, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_Metal :
+                                    {
+                                        sal_Bool bExtrusionMetal = sal_Bool();
+                                        if ( rProp.Value >>= bExtrusionMetal )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_METAL,
+                                                bExtrusionMetal ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                                    }
+                                    break;
+                                    case EAS_ShadeMode :
+                                    {
+                                        // shadeMode
+                                        drawing::ShadeMode eShadeMode;
+                                        if( rProp.Value >>= eShadeMode )
+                                        {
+                                            if( eShadeMode == drawing::ShadeMode_FLAT )
+                                                aStr = GetXMLToken( XML_FLAT );
+                                            else if( eShadeMode == drawing::ShadeMode_PHONG )
+                                                aStr = GetXMLToken( XML_PHONG );
+                                            else if( eShadeMode == drawing::ShadeMode_SMOOTH )
+                                                aStr = GetXMLToken( XML_GOURAUD );
+                                            else
+                                                aStr = GetXMLToken( XML_DRAFT );
+                                        }
+                                        else
+                                        {
+                                            // ShadeMode enum not there, write default
+                                            aStr = GetXMLToken( XML_FLAT);
+                                        }
+                                        rExport.AddAttribute( XML_NAMESPACE_DR3D, XML_SHADE_MODE, aStr );
+                                    }
+                                    break;
+                                    case EAS_RotateAngle :
+                                    {
+                                        com::sun::star::drawing::EnhancedCustomShapeParameterPair aRotateAngleParaPair;
+                                        if ( rProp.Value >>= aRotateAngleParaPair )
+                                        {
+                                            ExportParameter( aStrBuffer, aRotateAngleParaPair.First );
+                                            ExportParameter( aStrBuffer, aRotateAngleParaPair.Second );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ROTATION_ANGLE, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_RotationCenter :
+                                    {
+                                        drawing::Direction3D aExtrusionRotationCenter;
+                                        if ( rProp.Value >>= aExtrusionRotationCenter )
+                                        {
+                                            ::basegfx::B3DVector aVec3D( aExtrusionRotationCenter.DirectionX, aExtrusionRotationCenter.DirectionY,
+                                                aExtrusionRotationCenter.DirectionZ );
+                                            rUnitConverter.convertB3DVector( aStrBuffer, aVec3D );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ROTATION_CENTER, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_Shininess :
+                                    {
+                                        double fExtrusionShininess = 0;
+                                        if ( rProp.Value >>= fExtrusionShininess )
+                                        {
+                                            ::sax::Converter::convertDouble(
+                                                aStrBuffer,
+                                                fExtrusionShininess,
+                                                false,
+                                                util::MeasureUnit::PERCENT,
+                                                util::MeasureUnit::PERCENT);
+                                            aStrBuffer.append( (sal_Unicode)'%' );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SHININESS, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_Skew :
+                                    {
+                                        com::sun::star::drawing::EnhancedCustomShapeParameterPair aSkewParaPair;
+                                        if ( rProp.Value >>= aSkewParaPair )
+                                        {
+                                            ExportParameter( aStrBuffer, aSkewParaPair.First );
+                                            ExportParameter( aStrBuffer, aSkewParaPair.Second );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SKEW, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_Specularity :
+                                    {
+                                        double fExtrusionSpecularity = 0;
+                                        if ( rProp.Value >>= fExtrusionSpecularity )
+                                        {
+                                            ::sax::Converter::convertDouble(
+                                                aStrBuffer,
+                                                fExtrusionSpecularity,
+                                                false,
+                                                util::MeasureUnit::PERCENT,
+                                                util::MeasureUnit::PERCENT);
+                                            aStrBuffer.append( (sal_Unicode)'%' );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SPECULARITY, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_ProjectionMode :
+                                    {
+                                        drawing::ProjectionMode eProjectionMode;
+                                        if ( rProp.Value >>= eProjectionMode )
+                                            rExport.AddAttribute( XML_NAMESPACE_DR3D, XML_PROJECTION,
+                                                eProjectionMode == drawing::ProjectionMode_PARALLEL ? GetXMLToken( XML_PARALLEL ) : GetXMLToken( XML_PERSPECTIVE ) );
+                                    }
+                                    break;
+                                    case EAS_ViewPoint :
+                                    {
+                                        drawing::Position3D aExtrusionViewPoint;
+                                        if ( rProp.Value >>= aExtrusionViewPoint )
+                                        {
+                                            rUnitConverter.convertPosition3D( aStrBuffer, aExtrusionViewPoint );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_VIEWPOINT, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_Origin :
+                                    {
+                                        com::sun::star::drawing::EnhancedCustomShapeParameterPair aOriginParaPair;
+                                        if ( rProp.Value >>= aOriginParaPair )
+                                        {
+                                            ExportParameter( aStrBuffer, aOriginParaPair.First );
+                                            ExportParameter( aStrBuffer, aOriginParaPair.Second );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ORIGIN, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_Color :
+                                    {
+                                        sal_Bool bExtrusionColor = sal_Bool();
+                                        if ( rProp.Value >>= bExtrusionColor )
+                                        {
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_COLOR,
+                                                bExtrusionColor ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                                        }
+                                    }
+                                    break;
+                                    default:
+                                        break;
+                                }
+                            }
+                        }
+                    }
+                    break;
+                    case EAS_TextPath :
+                    {
+                        uno::Sequence< beans::PropertyValue > aTextPathPropSeq;
+                        if ( rGeoProp.Value >>= aTextPathPropSeq )
+                        {
+                            sal_Int32 i, nCount = aTextPathPropSeq.getLength();
+                            for ( i = 0; i < nCount; i++ )
+                            {
+                                const beans::PropertyValue& rProp = aTextPathPropSeq[ i ];
+                                switch( EASGet( rProp.Name ) )
+                                {
+                                    case EAS_TextPath :
+                                    {
+                                        sal_Bool bTextPathOn = sal_Bool();
+                                        if ( rProp.Value >>= bTextPathOn )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH,
+                                                bTextPathOn ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                                    }
+                                    break;
+                                    case EAS_TextPathMode :
+                                    {
+                                        com::sun::star::drawing::EnhancedCustomShapeTextPathMode eTextPathMode;
+                                        if ( rProp.Value >>= eTextPathMode )
+                                        {
+                                            switch ( eTextPathMode )
+                                            {
+                                                case com::sun::star::drawing::EnhancedCustomShapeTextPathMode_NORMAL: aStr = GetXMLToken( XML_NORMAL ); break;
+                                                case com::sun::star::drawing::EnhancedCustomShapeTextPathMode_PATH  : aStr = GetXMLToken( XML_PATH );   break;
+                                                case com::sun::star::drawing::EnhancedCustomShapeTextPathMode_SHAPE : aStr = GetXMLToken( XML_SHAPE );  break;
+                                                default:
+                                                    break;
+                                            }
+                                            if ( !aStr.isEmpty() )
+                                                rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_MODE, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_ScaleX :
+                                    {
+                                        sal_Bool bScaleX = sal_Bool();
+                                        if ( rProp.Value >>= bScaleX )
+                                        {
+                                            aStr = bScaleX ? GetXMLToken( XML_SHAPE ) : GetXMLToken( XML_PATH );
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_SCALE, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_SameLetterHeights :
+                                    {
+                                        sal_Bool bSameLetterHeights = sal_Bool();
+                                        if ( rProp.Value >>= bSameLetterHeights )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_SAME_LETTER_HEIGHTS,
+                                                bSameLetterHeights ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                                    }
+                                    break;
+                                    default:
+                                        break;
+                                }
+                            }
+                        }
+                    }
+                    break;
+                    case EAS_Path :
+                    {
+                        uno::Sequence< beans::PropertyValue > aPathPropSeq;
+                        if ( rGeoProp.Value >>= aPathPropSeq )
+                        {
+                            sal_Int32 i, nCount = aPathPropSeq.getLength();
+                            for ( i = 0; i < nCount; i++ )
+                            {
+                                const beans::PropertyValue& rProp = aPathPropSeq[ i ];
+
+                                switch( EASGet( rProp.Name ) )
+                                {
+                                    case EAS_SubViewSize:
+                                    {
+                                        uno::Sequence< awt::Size > aSubViewSizes;
+                                        rProp.Value >>= aSubViewSizes;
+
+                                        for ( int nIdx = 0; nIdx < aSubViewSizes.getLength(); nIdx++ )
+                                        {
+                                            if ( nIdx )
+                                                aStrBuffer.append(' ');
+                                            ::sax::Converter::convertNumber( aStrBuffer, aSubViewSizes[nIdx].Width );
+                                            aStrBuffer.append(' ');
+                                            ::sax::Converter::convertNumber( aStrBuffer, aSubViewSizes[nIdx].Height );
+                                        }
+                                        aStr = aStrBuffer.makeStringAndClear();
+                                        rExport.AddAttribute( XML_NAMESPACE_DRAW_EXT, XML_SUB_VIEW_SIZE, aStr );
+                                    }
+                                    break;
+                                    case EAS_ExtrusionAllowed :
+                                    {
+                                        sal_Bool bExtrusionAllowed = sal_Bool();
+                                        if ( rProp.Value >>= bExtrusionAllowed )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ALLOWED,
+                                                bExtrusionAllowed ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                                    }
+                                    break;
+                                    case EAS_ConcentricGradientFillAllowed :
+                                    {
+                                        sal_Bool bConcentricGradientFillAllowed = sal_Bool();
+                                        if ( rProp.Value >>= bConcentricGradientFillAllowed )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CONCENTRIC_GRADIENT_FILL_ALLOWED,
+                                                bConcentricGradientFillAllowed ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                                    }
+                                    break;
+                                    case EAS_TextPathAllowed  :
+                                    {
+                                        sal_Bool bTextPathAllowed = sal_Bool();
+                                        if ( rProp.Value >>= bTextPathAllowed )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_ALLOWED,
+                                                bTextPathAllowed ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                                    }
+                                    break;
+                                    case EAS_GluePoints :
+                                    {
+                                        com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair> aGluePoints;
+                                        if ( rProp.Value >>= aGluePoints )
+                                        {
+                                            sal_Int32 k, nElements = aGluePoints.getLength();
+                                            if ( nElements )
+                                            {
+                                                for( k = 0; k < nElements; k++ )
+                                                {
+                                                    ExportParameter( aStrBuffer, aGluePoints[ k ].First );
+                                                    ExportParameter( aStrBuffer, aGluePoints[ k ].Second );
+                                                }
+                                                aStr = aStrBuffer.makeStringAndClear();
+                                            }
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_GLUE_POINTS, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_GluePointType :
+                                    {
+                                        sal_Int16 nGluePointType = sal_Int16();
+                                        if ( rProp.Value >>= nGluePointType )
+                                        {
+                                            switch ( nGluePointType )
+                                            {
+                                                case com::sun::star::drawing::EnhancedCustomShapeGluePointType::NONE     : aStr = GetXMLToken( XML_NONE );    break;
+                                                case com::sun::star::drawing::EnhancedCustomShapeGluePointType::SEGMENTS : aStr = GetXMLToken( XML_SEGMENTS ); break;
+                                                case com::sun::star::drawing::EnhancedCustomShapeGluePointType::RECT     : aStr = GetXMLToken( XML_RECTANGLE ); break;
+                                            }
+                                            if ( !aStr.isEmpty() )
+                                                rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_GLUE_POINT_TYPE, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_Coordinates :
+                                    {
+                                        bCoordinates = ( rProp.Value >>= aCoordinates );
+                                    }
+                                    break;
+                                    case EAS_Segments :
+                                    {
+                                        rProp.Value >>= aSegments;
+                                    }
+                                    break;
+                                    case EAS_StretchX :
+                                    {
+                                        sal_Int32 nStretchPoint = 0;
+                                        if ( rProp.Value >>= nStretchPoint )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_PATH_STRETCHPOINT_X, OUString::number( nStretchPoint ) );
+                                    }
+                                    break;
+                                    case EAS_StretchY :
+                                    {
+                                        sal_Int32 nStretchPoint = 0;
+                                        if ( rProp.Value >>= nStretchPoint )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_PATH_STRETCHPOINT_Y, OUString::number( nStretchPoint ) );
+                                    }
+                                    break;
+                                    case EAS_TextFrames :
+                                    {
+                                        com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeTextFrame > aPathTextFrames;
+                                        if ( rProp.Value >>= aPathTextFrames )
+                                        {
+                                            if ( (sal_uInt16)aPathTextFrames.getLength() )
+                                            {
+                                                sal_uInt16 k, nElements = (sal_uInt16)aPathTextFrames.getLength();
+                                                for ( k = 0; k < nElements; k++ )
+                                                {
+                                                    ExportParameter( aStrBuffer, aPathTextFrames[ k ].TopLeft.First );
+                                                    ExportParameter( aStrBuffer, aPathTextFrames[ k ].TopLeft.Second );
+                                                    ExportParameter( aStrBuffer, aPathTextFrames[ k ].BottomRight.First );
+                                                    ExportParameter( aStrBuffer, aPathTextFrames[ k ].BottomRight.Second );
+                                                }
+                                                aStr = aStrBuffer.makeStringAndClear();
+                                            }
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_AREAS, aStr );
+                                        }
+                                    }
+                                    break;
+                                    default:
+                                        break;
+                                }
+                            }
+                        }
+                    }
+                    break;
+                    case EAS_Equations :
+                    {
+                        bEquations = ( rGeoProp.Value >>= aEquations );
+                    }
+                    break;
+                    case EAS_Handles :
+                    {
+                        bHandles = ( rGeoProp.Value >>= aHandles );
+                    }
+                    break;
+                    case EAS_AdjustmentValues :
+                    {
+                        rGeoProp.Value >>= aAdjustmentValues;
+                    }
+                    break;
+                    default:
+                        break;
+                }
+            }   // for
+            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TYPE, aCustomShapeType );
+
+            // adjustments
+            sal_Int32 nAdjustmentValues = aAdjustmentValues.getLength();
+            if ( nAdjustmentValues )
+            {
+                sal_Int32 i, nValue = 0;
+                for ( i = 0; i < nAdjustmentValues; i++ )
+                {
+                    if ( i )
+                        aStrBuffer.append( (sal_Unicode)' ' );
+
+                    const com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue& rAdj = aAdjustmentValues[ i ];
+                    if ( rAdj.State == beans::PropertyState_DIRECT_VALUE )
+                    {
+                        if ( rAdj.Value.getValueTypeClass() == uno::TypeClass_DOUBLE )
+                        {
+                            double fValue = 0.0;
+                            rAdj.Value >>= fValue;
+                            ::sax::Converter::convertDouble(aStrBuffer, fValue);
+                        }
+                        else
+                        {
+                            rAdj.Value >>= nValue;
+                            ::sax::Converter::convertNumber(aStrBuffer, nValue);
+                        }
+                    }
+                    else
+                    {
+                        // this should not be, but better than setting nothing
+                        ::sax::Converter::convertNumber( aStrBuffer, 0 );
+                    }
+                }
+                aStr = aStrBuffer.makeStringAndClear();
+                rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MODIFIERS, aStr );
+            }
+            if ( bCoordinates )
+                ImpExportEnhancedPath( rExport, aCoordinates, aSegments );
+        }
+    }
+    SvXMLElementExport aOBJ( rExport, XML_NAMESPACE_DRAW, XML_ENHANCED_GEOMETRY, sal_True, sal_True );
+    if ( bEquations )
+        ImpExportEquations( rExport, aEquations );
+    if ( bHandles )
+        ImpExportHandles( rExport, aHandles );
+}
+
+void XMLShapeExport::ImpExportCustomShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint )
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if ( xPropSet.is() )
+    {
+        OUString aStr;
+        uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
+
+        // Transformation
+        ImpExportNewTrans( xPropSet, nFeatures, pRefPoint );
+
+        if ( xPropSetInfo.is() )
+        {
+            const OUString sCustomShapeEngine( "CustomShapeEngine" );
+            if ( xPropSetInfo->hasPropertyByName( sCustomShapeEngine ) )
+            {
+                uno::Any aEngine( xPropSet->getPropertyValue( sCustomShapeEngine ) );
+                if ( ( aEngine >>= aStr ) && !aStr.isEmpty() )
+                    mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_ENGINE, aStr );
+            }
+            const OUString sCustomShapeData( "CustomShapeData" );
+            if ( xPropSetInfo->hasPropertyByName( sCustomShapeData ) )
+            {
+                uno::Any aData( xPropSet->getPropertyValue( sCustomShapeData ) );
+                if ( ( aData >>= aStr ) && !aStr.isEmpty() )
+                    mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DATA, aStr );
+            }
+        }
+        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
+        SvXMLElementExport aOBJ( mrExport, XML_NAMESPACE_DRAW, XML_CUSTOM_SHAPE, bCreateNewline, sal_True );
+        ImpExportDescription( xShape ); // #i68101#
+        ImpExportEvents( xShape );
+        ImpExportGluePoints( xShape );
+        ImpExportText( xShape );
+        ImpExportEnhancedGeometry( mrExport, xPropSet );
+    }
+}
+
+void XMLShapeExport::ImpExportTableShape( const uno::Reference< drawing::XShape >& xShape, XmlShapeType eShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint )
+{
+    uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    uno::Reference< container::XNamed > xNamed(xShape, uno::UNO_QUERY);
+
+    DBG_ASSERT( xPropSet.is() && xNamed.is(), "xmloff::XMLShapeExport::ImpExportTableShape(), tabe shape is not implementing needed interfaces");
+    if(xPropSet.is() && xNamed.is()) try
+    {
+        // Transformation
+        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+        sal_Bool bIsEmptyPresObj = sal_False;
+
+        // presentation settings
+        if(eShapeType == XmlShapeTypePresTableShape)
+            bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_TABLE) );
+
+        const bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 );
+        const bool bExportEmbedded(0 != (mrExport.getExportFlags() & EXPORT_EMBEDDED));
+
+        SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW, XML_FRAME, bCreateNewline, sal_True );
+
+        // do not export in ODF 1.1 or older
+        if( mrExport.getDefaultVersion() >= SvtSaveOptions::ODFVER_012 )
+        {
+            if( !bIsEmptyPresObj )
+            {
+                uno::Reference< container::XNamed > xTemplate( xPropSet->getPropertyValue("TableTemplate"), uno::UNO_QUERY );
+                if( xTemplate.is() )
+                {
+                    const OUString sTemplate( xTemplate->getName() );
+                    if( !sTemplate.isEmpty() )
+                    {
+                        mrExport.AddAttribute(XML_NAMESPACE_TABLE, XML_TEMPLATE_NAME, sTemplate );
+
+                        for( const XMLPropertyMapEntry* pEntry = &aXMLTableShapeAttributes[0]; pEntry->msApiName; pEntry++ )
+                        {
+                            try
+                            {
+                                sal_Bool bBool = sal_False;
+                                const OUString sAPIPropertyName( OUString(pEntry->msApiName, pEntry->nApiNameLength, RTL_TEXTENCODING_ASCII_US ) );
+
+                                xPropSet->getPropertyValue( sAPIPropertyName ) >>= bBool;
+                                if( bBool )
+                                    mrExport.AddAttribute(pEntry->mnNameSpace, pEntry->meXMLName, XML_TRUE );
+                            }
+                            catch( uno::Exception& )
+                            {
+                            OSL_FAIL("XMLShapeExport::ImpExportTableShape(), exception caught!");
+                            }
+                        }
+                    }
+                }
+
+                uno::Reference< table::XColumnRowRange > xRange( xPropSet->getPropertyValue( msModel ), uno::UNO_QUERY_THROW );
+                GetShapeTableExport()->exportTable( xRange );
+            }
+        }
+
+        if( !bIsEmptyPresObj )
+        {
+            uno::Reference< graphic::XGraphic > xGraphic( xPropSet->getPropertyValue("ReplacementGraphic"), uno::UNO_QUERY );
+            if( xGraphic.is() ) try
+            {
+                uno::Reference< uno::XComponentContext > xContext = GetExport().getComponentContext();
+
+                uno::Reference< embed::XStorage > xPictureStorage;
+                uno::Reference< embed::XStorage > xStorage;
+                uno::Reference< io::XStream > xPictureStream;
+
+                OUString sPictureName;
+                if( bExportEmbedded )
+                {
+                    xPictureStream.set( xContext->getServiceManager()->createInstanceWithContext( "com.sun.star.comp.MemoryStream", xContext), uno::UNO_QUERY_THROW );
+                }
+                else
+                {
+                    xStorage.set( GetExport().GetTargetStorage(), uno::UNO_QUERY_THROW );
+
+                    xPictureStorage.set( xStorage->openStorageElement( OUString( "Pictures" ), ::embed::ElementModes::READWRITE ), uno::UNO_QUERY_THROW );
+                    const OUString sPrefix( "TablePreview" );
+                    const OUString sSuffix( ".svm" );
+
+                    sal_Int32 nIndex = 0;
+                    do
+                    {
+                        sPictureName = sPrefix;
+                        sPictureName += OUString::number( ++nIndex );
+                        sPictureName += sSuffix;
+                    }
+                    while( xPictureStorage->hasByName( sPictureName ) );
+
+                    xPictureStream.set( xPictureStorage->openStreamElement( sPictureName, ::embed::ElementModes::READWRITE ), uno::UNO_QUERY_THROW );
+                }
+
+                uno::Reference< graphic::XGraphicProvider > xProvider( graphic::GraphicProvider::create(xContext) );
+                uno::Sequence< beans::PropertyValue > aArgs( 2 );
+                aArgs[ 0 ].Name = OUString( "MimeType" );
+                aArgs[ 0 ].Value <<= OUString( "image/x-vclgraphic" );
+                aArgs[ 1 ].Name = OUString( "OutputStream" );
+                aArgs[ 1 ].Value <<= xPictureStream->getOutputStream();
+                xProvider->storeGraphic( xGraphic, aArgs );
+
+                if( xPictureStorage.is() )
+                {
+                    uno::Reference< embed::XTransactedObject > xTrans( xPictureStorage, uno::UNO_QUERY );
+                    if( xTrans.is() )
+                        xTrans->commit();
+                }
+
+                if( !bExportEmbedded )
+                {
+                    OUString sURL( "Pictures/" );
+                    sURL += sPictureName;
+                    mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sURL );
+                    mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+                    mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+                    mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
+                }
+
+                SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_DRAW, XML_IMAGE, sal_False, sal_True );
+
+                if( bExportEmbedded )
+                {
+                    uno::Reference< io::XSeekableInputStream > xSeekable( xPictureStream, uno::UNO_QUERY_THROW );
+                    xSeekable->seek(0);
+
+                    XMLBase64Export aBase64Exp( GetExport() );
+                    aBase64Exp.exportOfficeBinaryDataElement( uno::Reference < io::XInputStream >( xPictureStream, uno::UNO_QUERY_THROW ) );
+                }
+            }
+            catch( uno::Exception& )
+            {
+                OSL_FAIL("xmloff::XMLShapeExport::ImpExportTableShape(), exception caught!");
+            }
+        }
+
+        ImpExportEvents( xShape );
+        ImpExportGluePoints( xShape );
+        ImpExportDescription( xShape ); // #i68101#
+    }
+    catch( uno::Exception& )
+    {
+        OSL_FAIL( "xmloff::XMLShapeExport::ImpExportTableShape(), exception caught!" );
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
+
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/shapeexport2.cxx b/xmloff/source/draw/shapeexport2.cxx
deleted file mode 100644
index 781bdab3bcba..000000000000
--- a/xmloff/source/draw/shapeexport2.cxx
+++ /dev/null
@@ -1,2095 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * This file is part of the LibreOffice project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * This file incorporates work covered by the following license notice:
- *
- *   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 .
- */
-
-#include <xmloff/unointerfacetouniqueidentifiermapper.hxx>
-#include <com/sun/star/text/XText.hpp>
-#include <com/sun/star/container/XNamed.hpp>
-#include <com/sun/star/container/XEnumerationAccess.hpp>
-#include <com/sun/star/drawing/CircleKind.hpp>
-#include <com/sun/star/drawing/ConnectorType.hpp>
-#include <com/sun/star/drawing/XControlShape.hpp>
-#include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
-#include <com/sun/star/document/XEventsSupplier.hpp>
-#include <com/sun/star/drawing/HomogenMatrix3.hpp>
-#include <com/sun/star/embed/ElementModes.hpp>
-#include <com/sun/star/embed/XTransactedObject.hpp>
-#include <com/sun/star/media/ZoomLevel.hpp>
-
-#include <sax/tools/converter.hxx>
-
-#include <comphelper/storagehelper.hxx>
-
-#include "anim.hxx"
-
-#include <xmloff/shapeexport.hxx>
-#include "sdpropls.hxx"
-#include <tools/debug.hxx>
-#include <tools/helpers.hxx>
-#include <rtl/ustrbuf.hxx>
-#include <xmloff/xmlexp.hxx>
-#include <xmloff/xmluconv.hxx>
-#include "XMLImageMapExport.hxx"
-#include "xexptran.hxx"
-#include <xmloff/xmltoken.hxx>
-#include <xmloff/nmspmap.hxx>
-
-#include "xmloff/xmlnmspe.hxx"
-#include <basegfx/matrix/b2dhommatrix.hxx>
-#include <basegfx/tuple/b2dtuple.hxx>
-
-using namespace ::com::sun::star;
-using namespace ::xmloff::token;
-
-void XMLShapeExport::ImpExportNewTrans(const uno::Reference< beans::XPropertySet >& xPropSet,
-    sal_Int32 nFeatures, awt::Point* pRefPoint)
-{
-    // get matrix
-    ::basegfx::B2DHomMatrix aMatrix;
-    ImpExportNewTrans_GetB2DHomMatrix(aMatrix, xPropSet);
-
-    // decompose and correct abour pRefPoint
-    ::basegfx::B2DTuple aTRScale;
-    double fTRShear(0.0);
-    double fTRRotate(0.0);
-    ::basegfx::B2DTuple aTRTranslate;
-    ImpExportNewTrans_DecomposeAndRefPoint(aMatrix, aTRScale, fTRShear, fTRRotate, aTRTranslate, pRefPoint);
-
-    // use features and write
-    ImpExportNewTrans_FeaturesAndWrite(aTRScale, fTRShear, fTRRotate, aTRTranslate, nFeatures);
-}
-
-void XMLShapeExport::ImpExportNewTrans_GetB2DHomMatrix(::basegfx::B2DHomMatrix& rMatrix,
-    const uno::Reference< beans::XPropertySet >& xPropSet)
-{
-    /* Get <TransformationInHoriL2R>, if it exist
-       and if the document is exported into the OpenOffice.org file format.
-       This property only exists at service com::sun::star::text::Shape - the
-       Writer UNO service for shapes.
-       This code is needed, because the positioning attributes in the
-       OpenOffice.org file format are given in horizontal left-to-right layout
-       regardless the layout direction the shape is in. In the OASIS Open Office
-       file format the positioning attributes are correctly given in the layout
-       direction the shape is in. Thus, this code provides the conversion from
-       the OASIS Open Office file format to the OpenOffice.org file format. (#i28749#)
-    */
-    uno::Any aAny;
-    if ( ( GetExport().getExportFlags() & EXPORT_OASIS ) == 0 &&
-         xPropSet->getPropertySetInfo()->hasPropertyByName(
-            OUString("TransformationInHoriL2R")) )
-    {
-        aAny = xPropSet->getPropertyValue("TransformationInHoriL2R");
-    }
-    else
-    {
-        aAny = xPropSet->getPropertyValue("Transformation");
-    }
-    drawing::HomogenMatrix3 aMatrix;
-    aAny >>= aMatrix;
-
-    rMatrix.set(0, 0, aMatrix.Line1.Column1);
-    rMatrix.set(0, 1, aMatrix.Line1.Column2);
-    rMatrix.set(0, 2, aMatrix.Line1.Column3);
-    rMatrix.set(1, 0, aMatrix.Line2.Column1);
-    rMatrix.set(1, 1, aMatrix.Line2.Column2);
-    rMatrix.set(1, 2, aMatrix.Line2.Column3);
-    rMatrix.set(2, 0, aMatrix.Line3.Column1);
-    rMatrix.set(2, 1, aMatrix.Line3.Column2);
-    rMatrix.set(2, 2, aMatrix.Line3.Column3);
-}
-
-void XMLShapeExport::ImpExportNewTrans_DecomposeAndRefPoint(const ::basegfx::B2DHomMatrix& rMatrix, ::basegfx::B2DTuple& rTRScale,
-    double& fTRShear, double& fTRRotate, ::basegfx::B2DTuple& rTRTranslate, com::sun::star::awt::Point* pRefPoint)
-{
-    // decompose matrix
-    rMatrix.decompose(rTRScale, rTRTranslate, fTRRotate, fTRShear);
-
-    // correct translation about pRefPoint
-    if(pRefPoint)
-    {
-        rTRTranslate -= ::basegfx::B2DTuple(pRefPoint->X, pRefPoint->Y);
-    }
-}
-
-void XMLShapeExport::ImpExportNewTrans_FeaturesAndWrite(::basegfx::B2DTuple& rTRScale, double fTRShear,
-    double fTRRotate, ::basegfx::B2DTuple& rTRTranslate, const sal_Int32 nFeatures)
-{
-    // always write Size (rTRScale) since this statement carries the union
-    // of the object
-    OUString aStr;
-    OUStringBuffer sStringBuffer;
-    ::basegfx::B2DTuple aTRScale(rTRScale);
-
-    // svg: width
-    if(!(nFeatures & SEF_EXPORT_WIDTH))
-    {
-        aTRScale.setX(1.0);
-    }
-    else
-    {
-        if( aTRScale.getX() > 0.0 )
-            aTRScale.setX(aTRScale.getX() - 1.0);
-        else if( aTRScale.getX() < 0.0 )
-            aTRScale.setX(aTRScale.getX() + 1.0);
-    }
-
-    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
-            FRound(aTRScale.getX()));
-    aStr = sStringBuffer.makeStringAndClear();
-    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_WIDTH, aStr);
-
-    // svg: height
-    if(!(nFeatures & SEF_EXPORT_HEIGHT))
-    {
-        aTRScale.setY(1.0);
-    }
-    else
-    {
-        if( aTRScale.getY() > 0.0 )
-            aTRScale.setY(aTRScale.getY() - 1.0);
-        else if( aTRScale.getY() < 0.0 )
-            aTRScale.setY(aTRScale.getY() + 1.0);
-    }
-
-    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
-            FRound(aTRScale.getY()));
-    aStr = sStringBuffer.makeStringAndClear();
-    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_HEIGHT, aStr);
-
-    // decide if transformation is necessary
-    sal_Bool bTransformationIsNeccessary(fTRShear != 0.0 || fTRRotate != 0.0);
-
-    if(bTransformationIsNeccessary)
-    {
-        // write transformation, but WITHOUT scale which is exported as size above
-        SdXMLImExTransform2D aTransform;
-
-        aTransform.AddSkewX(atan(fTRShear));
-
-        // #i78696#
-        // fTRRotate is mathematically correct, but due to the error
-        // we export/import it mirrored. Since the API implementation is fixed and
-        // uses the correctly oriented angle, it is necessary for compatibility to
-        // mirror the angle here to stay at the old behaviour. There is a follow-up
-        // task (#i78698#) to fix this in the next ODF FileFormat version
-        aTransform.AddRotate(-fTRRotate);
-
-        aTransform.AddTranslate(rTRTranslate);
-
-        // does transformation need to be exported?
-        if(aTransform.NeedsAction())
-            mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_TRANSFORM, aTransform.GetExportString(mrExport.GetMM100UnitConverter()));
-    }
-    else
-    {
-        // no shear, no rotate; just add object position to export and we are done
-        if(nFeatures & SEF_EXPORT_X)
-        {
-            // svg: x
-            mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
-                    FRound(rTRTranslate.getX()));
-            aStr = sStringBuffer.makeStringAndClear();
-            mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X, aStr);
-        }
-
-        if(nFeatures & SEF_EXPORT_Y)
-        {
-            // svg: y
-            mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
-                    FRound(rTRTranslate.getY()));
-            aStr = sStringBuffer.makeStringAndClear();
-            mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y, aStr);
-        }
-    }
-}
-
-sal_Bool XMLShapeExport::ImpExportPresentationAttributes( const uno::Reference< beans::XPropertySet >& xPropSet, const OUString& rClass )
-{
-    sal_Bool bIsEmpty = sal_False;
-
-    // write presentation class entry
-    mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_CLASS, rClass);
-
-    if( xPropSet.is() )
-    {
-        uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
-
-        sal_Bool bTemp = false;
-
-        // is empty pes shape?
-        if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName("IsEmptyPresentationObject"))
-        {
-            xPropSet->getPropertyValue("IsEmptyPresentationObject") >>= bIsEmpty;
-            if( bIsEmpty )
-                mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_PLACEHOLDER, XML_TRUE);
-        }
-
-        // is user-transformed?
-        if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName("IsPlaceholderDependent"))
-        {
-            xPropSet->getPropertyValue("IsPlaceholderDependent") >>= bTemp;
-            if(!bTemp)
-                mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_USER_TRANSFORMED, XML_TRUE);
-        }
-    }
-
-    return bIsEmpty;
-}
-
-void XMLShapeExport::ImpExportText( const uno::Reference< drawing::XShape >& xShape )
-{
-    uno::Reference< text::XText > xText( xShape, uno::UNO_QUERY );
-    if( xText.is() )
-    {
-        uno::Reference< container::XEnumerationAccess > xEnumAccess( xShape, uno::UNO_QUERY );
-        if( xEnumAccess.is() && xEnumAccess->hasElements() )
-            mrExport.GetTextParagraphExport()->exportText( xText );
-    }
-}
-
-#include <com/sun/star/presentation/ClickAction.hpp>
-#include <com/sun/star/presentation/AnimationSpeed.hpp>
-
-namespace {
-
-const sal_Int32 FOUND_CLICKACTION       = 0x00000001;
-const sal_Int32 FOUND_BOOKMARK          = 0x00000002;
-const sal_Int32 FOUND_EFFECT            = 0x00000004;
-const sal_Int32 FOUND_PLAYFULL          = 0x00000008;
-const sal_Int32 FOUND_VERB              = 0x00000010;
-const sal_Int32 FOUND_SOUNDURL          = 0x00000020;
-const sal_Int32 FOUND_SPEED             = 0x00000040;
-const sal_Int32 FOUND_CLICKEVENTTYPE    = 0x00000080;
-const sal_Int32 FOUND_MACRO             = 0x00000100;
-const sal_Int32 FOUND_LIBRARY           = 0x00000200;
-
-} // namespace
-
-void XMLShapeExport::ImpExportEvents( const uno::Reference< drawing::XShape >& xShape )
-{
-    uno::Reference< document::XEventsSupplier > xEventsSupplier( xShape, uno::UNO_QUERY );
-    if( !xEventsSupplier.is() )
-        return;
-
-    uno::Reference< container::XNameAccess > xEvents( xEventsSupplier->getEvents(), uno::UNO_QUERY );
-    DBG_ASSERT( xEvents.is(), "XEventsSupplier::getEvents() returned NULL" );
-    if( !xEvents.is() )
-        return;
-
-    sal_Int32 nFound = 0;
-
-    OUString aClickEventType;
-    presentation::ClickAction eClickAction = presentation::ClickAction_NONE;
-    presentation::AnimationEffect eEffect = presentation::AnimationEffect_NONE;
-    presentation::AnimationSpeed eSpeed = presentation::AnimationSpeed_SLOW;
-    OUString aStrSoundURL;
-    sal_Bool bPlayFull = false;
-    sal_Int32 nVerb = 0;
-    OUString aStrMacro;
-    OUString aStrLibrary;
-    OUString aStrBookmark;
-
-    uno::Sequence< beans::PropertyValue > aClickProperties;
-    if( xEvents->hasByName( msOnClick ) && (xEvents->getByName( msOnClick ) >>= aClickProperties) )
-    {
-        const beans::PropertyValue* pProperty = aClickProperties.getConstArray();
-        const beans::PropertyValue* pPropertyEnd = pProperty + aClickProperties.getLength();
-        for( ; pProperty != pPropertyEnd; ++pProperty )
-        {
-            if( ( ( nFound & FOUND_CLICKEVENTTYPE ) == 0 ) && pProperty->Name == msEventType )
-            {
-                if( pProperty->Value >>= aClickEventType )
-                    nFound |= FOUND_CLICKEVENTTYPE;
-            }
-            else if( ( ( nFound & FOUND_CLICKACTION ) == 0 ) && pProperty->Name == msClickAction )
-            {
-                if( pProperty->Value >>= eClickAction )
-                    nFound |= FOUND_CLICKACTION;
-            }
-            else if( ( ( nFound & FOUND_MACRO ) == 0 ) && ( pProperty->Name == msMacroName || pProperty->Name == msScript ) )
-            {
-                if( pProperty->Value >>= aStrMacro )
-                    nFound |= FOUND_MACRO;
-            }
-            else if( ( ( nFound & FOUND_LIBRARY ) == 0 ) && pProperty->Name == msLibrary )
-            {
-                if( pProperty->Value >>= aStrLibrary )
-                    nFound |= FOUND_LIBRARY;
-            }
-            else if( ( ( nFound & FOUND_EFFECT ) == 0 ) && pProperty->Name == msEffect )
-            {
-                if( pProperty->Value >>= eEffect )
-                    nFound |= FOUND_EFFECT;
-            }
-            else if( ( ( nFound & FOUND_BOOKMARK ) == 0 ) && pProperty->Name == msBookmark )
-            {
-                if( pProperty->Value >>= aStrBookmark )
-                    nFound |= FOUND_BOOKMARK;
-            }
-            else if( ( ( nFound & FOUND_SPEED ) == 0 ) && pProperty->Name == msSpeed )
-            {
-                if( pProperty->Value >>= eSpeed )
-                    nFound |= FOUND_SPEED;
-            }
-            else if( ( ( nFound & FOUND_SOUNDURL ) == 0 ) && pProperty->Name == msSoundURL )
-            {
-                if( pProperty->Value >>= aStrSoundURL )
-                    nFound |= FOUND_SOUNDURL;
-            }
-            else if( ( ( nFound & FOUND_PLAYFULL ) == 0 ) && pProperty->Name == msPlayFull )
-            {
-                if( pProperty->Value >>= bPlayFull )
-                    nFound |= FOUND_PLAYFULL;
-            }
-            else if( ( ( nFound & FOUND_VERB ) == 0 ) && pProperty->Name == msVerb )
-            {
-                if( pProperty->Value >>= nVerb )
-                    nFound |= FOUND_VERB;
-            }
-        }
-    }
-
-    // create the XML elements
-
-    if( aClickEventType == msPresentation )
-    {
-        if( ((nFound & FOUND_CLICKACTION) == 0) || (eClickAction == presentation::ClickAction_NONE) )
-            return;
-
-        SvXMLElementExport aEventsElemt(mrExport, XML_NAMESPACE_OFFICE, XML_EVENT_LISTENERS, sal_True, sal_True);
-
-        enum XMLTokenEnum eStrAction;
-
-        switch( eClickAction )
-        {
-            case presentation::ClickAction_PREVPAGE:        eStrAction = XML_PREVIOUS_PAGE; break;
-            case presentation::ClickAction_NEXTPAGE:        eStrAction = XML_NEXT_PAGE; break;
-            case presentation::ClickAction_FIRSTPAGE:       eStrAction = XML_FIRST_PAGE; break;
-            case presentation::ClickAction_LASTPAGE:        eStrAction = XML_LAST_PAGE; break;
-            case presentation::ClickAction_INVISIBLE:       eStrAction = XML_HIDE; break;
-            case presentation::ClickAction_STOPPRESENTATION:eStrAction = XML_STOP; break;
-            case presentation::ClickAction_PROGRAM:         eStrAction = XML_EXECUTE; break;
-            case presentation::ClickAction_BOOKMARK:        eStrAction = XML_SHOW; break;
-            case presentation::ClickAction_DOCUMENT:        eStrAction = XML_SHOW; break;
-            case presentation::ClickAction_MACRO:           eStrAction = XML_EXECUTE_MACRO; break;
-            case presentation::ClickAction_VERB:            eStrAction = XML_VERB; break;
-            case presentation::ClickAction_VANISH:          eStrAction = XML_FADE_OUT; break;
-            case presentation::ClickAction_SOUND:           eStrAction = XML_SOUND; break;
-            default:
-                OSL_FAIL( "unknown presentation::ClickAction found!" );
-                eStrAction = XML_UNKNOWN;
-        }
-
-        OUString aEventQName(
-            mrExport.GetNamespaceMap().GetQNameByKey(
-                    XML_NAMESPACE_DOM, OUString(  "click"  ) ) );
-        mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_EVENT_NAME, aEventQName );
-        mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_ACTION, eStrAction );
-
-        if( eClickAction == presentation::ClickAction_VANISH )
-        {
-            if( nFound & FOUND_EFFECT )
-            {
-                XMLEffect eKind;
-                XMLEffectDirection eDirection;
-                sal_Int16 nStartScale;
-                bool bIn;
-
-                SdXMLImplSetEffect( eEffect, eKind, eDirection, nStartScale, bIn );
-
-                if( eKind != EK_none )
-                {
-                    SvXMLUnitConverter::convertEnum( msBuffer, eKind, aXML_AnimationEffect_EnumMap );
-                    mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_EFFECT, msBuffer.makeStringAndClear() );
-                }
-
-                if( eDirection != ED_none )
-                {
-                    SvXMLUnitConverter::convertEnum( msBuffer, eDirection, aXML_AnimationDirection_EnumMap );
-                    mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_DIRECTION, msBuffer.makeStringAndClear() );
-                }
-
-                if( nStartScale != -1 )
-                {
-                    ::sax::Converter::convertPercent( msBuffer, nStartScale );
-                    mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_START_SCALE, msBuffer.makeStringAndClear() );
-                }
-            }
-
-            if( nFound & FOUND_SPEED && eEffect != presentation::AnimationEffect_NONE )
-            {
-                 if( eSpeed != presentation::AnimationSpeed_MEDIUM )
-                    {
-                    SvXMLUnitConverter::convertEnum( msBuffer, eSpeed, aXML_AnimationSpeed_EnumMap );
-                    mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_SPEED, msBuffer.makeStringAndClear() );
-                }
-            }
-        }
-
-        if( eClickAction == presentation::ClickAction_PROGRAM ||
-            eClickAction == presentation::ClickAction_BOOKMARK ||
-            eClickAction == presentation::ClickAction_DOCUMENT )
-        {
-            if( eClickAction == presentation::ClickAction_BOOKMARK )
-                msBuffer.append( sal_Unicode('#') );
-
-            msBuffer.append( aStrBookmark );
-            mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(msBuffer.makeStringAndClear()) );
-            mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
-            mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
-            mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONREQUEST );
-        }
-
-        if( ( nFound & FOUND_VERB ) && eClickAction == presentation::ClickAction_VERB )
-        {
-            msBuffer.append( nVerb );
-            mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_VERB, msBuffer.makeStringAndClear());
-        }
-
-        SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_PRESENTATION, XML_EVENT_LISTENER, sal_True, sal_True);
-
-        if( eClickAction == presentation::ClickAction_VANISH || eClickAction == presentation::ClickAction_SOUND )
-        {
-            if( ( nFound & FOUND_SOUNDURL ) && !aStrSoundURL.isEmpty() )
-            {
-                mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStrSoundURL) );
-                mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
-                mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_NEW );
-                mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONREQUEST );
-                if( nFound & FOUND_PLAYFULL && bPlayFull )
-                    mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_PLAY_FULL, XML_TRUE );
-
-                SvXMLElementExport aElem( mrExport, XML_NAMESPACE_PRESENTATION, XML_SOUND, sal_True, sal_True );
-            }
-       }
-    }
-    else if( aClickEventType == msStarBasic )
-    {
-        if( nFound & FOUND_MACRO )
-        {
-            SvXMLElementExport aEventsElemt(mrExport, XML_NAMESPACE_OFFICE, XML_EVENT_LISTENERS, sal_True, sal_True);
-
-            mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_LANGUAGE,
-                        mrExport.GetNamespaceMap().GetQNameByKey(
-                            XML_NAMESPACE_OOO,
-                            OUString( "starbasic"  ) ) );
-            OUString aEventQName(
-                mrExport.GetNamespaceMap().GetQNameByKey(
-                        XML_NAMESPACE_DOM, OUString(  "click"  ) ) );
-            mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_EVENT_NAME, aEventQName );
-
-            if( nFound & FOUND_LIBRARY )
-            {
-                OUString sLocation( GetXMLToken(
-                    (aStrLibrary.equalsIgnoreAsciiCase("StarOffice") ||
-                     aStrLibrary.equalsIgnoreAsciiCase("application") ) ? XML_APPLICATION
-                                                                       : XML_DOCUMENT ) );
-                mrExport.AddAttribute(XML_NAMESPACE_SCRIPT, XML_MACRO_NAME,
-                    sLocation + ":" + aStrMacro);
-            }
-            else
-            {
-                mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_MACRO_NAME, aStrMacro );
-            }
-
-            SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SCRIPT, XML_EVENT_LISTENER, sal_True, sal_True);
-        }
-    }
-    else if( aClickEventType == msScript )
-    {
-        if( nFound & FOUND_MACRO )
-        {
-            SvXMLElementExport aEventsElemt(mrExport, XML_NAMESPACE_OFFICE, XML_EVENT_LISTENERS, sal_True, sal_True);
-            if ( nFound & FOUND_MACRO )
-            {
-                mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_LANGUAGE, mrExport.GetNamespaceMap().GetQNameByKey(
-                         XML_NAMESPACE_OOO, GetXMLToken(XML_SCRIPT) ) );
-                OUString aEventQName(
-                    mrExport.GetNamespaceMap().GetQNameByKey(
-                            XML_NAMESPACE_DOM, OUString(  "click"  ) ) );
-                mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_EVENT_NAME, aEventQName );
-                mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, aStrMacro );
-
-                SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SCRIPT, XML_EVENT_LISTENER, sal_True, sal_True);
-            }
-        }
-    }
-}
-
-/** #i68101# export shape Title and Description */
-void XMLShapeExport::ImpExportDescription( const uno::Reference< drawing::XShape >& xShape )
-{
-    try
-    {
-        OUString aTitle;
-        OUString aDescription;
-
-        uno::Reference< beans::XPropertySet > xProps( xShape, uno::UNO_QUERY_THROW );
-        xProps->getPropertyValue("Title") >>= aTitle;
-        xProps->getPropertyValue("Description") >>= aDescription;
-
-        if(!aTitle.isEmpty())
-        {
-            SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SVG, XML_TITLE, sal_True, sal_False);
-            mrExport.Characters( aTitle );
-        }
-
-        if(!aDescription.isEmpty())
-        {
-            SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SVG, XML_DESC, sal_True, sal_False );
-            mrExport.Characters( aDescription );
-        }
-    }
-    catch( uno::Exception& )
-    {
-        OSL_FAIL( "could not export Title and/or Description for shape!" );
-    }
-}
-
-void XMLShapeExport::ImpExportGroupShape( const uno::Reference< drawing::XShape >& xShape, XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint)
-{
-    uno::Reference< drawing::XShapes > xShapes(xShape, uno::UNO_QUERY);
-    if(xShapes.is() && xShapes->getCount())
-    {
-        // write group shape
-        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
-        SvXMLElementExport aPGR(mrExport, XML_NAMESPACE_DRAW, XML_G, bCreateNewline, sal_True);
-
-        ImpExportDescription( xShape ); // #i68101#
-        ImpExportEvents( xShape );
-        ImpExportGluePoints( xShape );
-
-        // #89764# if export of position is supressed for group shape,
-        // positions of contained objects should be written relative to
-        // the upper left edge of the group.
-        awt::Point aUpperLeft;
-
-        if(!(nFeatures & SEF_EXPORT_POSITION))
-        {
-            nFeatures |= SEF_EXPORT_POSITION;
-            aUpperLeft = xShape->getPosition();
-            pRefPoint = &aUpperLeft;
-        }
-
-        // write members
-        exportShapes( xShapes, nFeatures, pRefPoint );
-    }
-}
-
-void XMLShapeExport::ImpExportTextBoxShape(
-    const uno::Reference< drawing::XShape >& xShape,
-    XmlShapeType eShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint)
-{
-    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
-    if(xPropSet.is())
-    {
-        uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
-
-        // presentation attribute (if presentation)
-        sal_Bool bIsPresShape(sal_False);
-        sal_Bool bIsEmptyPresObj(sal_False);
-        OUString aStr;
-
-        switch(eShapeType)
-        {
-            case XmlShapeTypePresSubtitleShape:
-            {
-                aStr = GetXMLToken(XML_PRESENTATION_SUBTITLE);
-                bIsPresShape = sal_True;
-                break;
-            }
-            case XmlShapeTypePresTitleTextShape:
-            {
-                aStr = GetXMLToken(XML_PRESENTATION_TITLE);
-                bIsPresShape = sal_True;
-                break;
-            }
-            case XmlShapeTypePresOutlinerShape:
-            {
-                aStr = GetXMLToken(XML_PRESENTATION_OUTLINE);
-                bIsPresShape = sal_True;
-                break;
-            }
-            case XmlShapeTypePresNotesShape:
-            {
-                aStr = GetXMLToken(XML_PRESENTATION_NOTES);
-                bIsPresShape = sal_True;
-                break;
-            }
-            case XmlShapeTypePresHeaderShape:
-            {
-                aStr = GetXMLToken(XML_HEADER);
-                bIsPresShape = sal_True;
-                break;
-            }
-            case XmlShapeTypePresFooterShape:
-            {
-                aStr = GetXMLToken(XML_FOOTER);
-                bIsPresShape = sal_True;
-                break;
-            }
-            case XmlShapeTypePresSlideNumberShape:
-            {
-                aStr = GetXMLToken(XML_PAGE_NUMBER);
-                bIsPresShape = sal_True;
-                break;
-            }
-            case XmlShapeTypePresDateTimeShape:
-            {
-                aStr = GetXMLToken(XML_DATE_TIME);
-                bIsPresShape = sal_True;
-                break;
-            }
-            default:
-                break;
-        }
-
-        // Transformation
-        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
-
-        if(bIsPresShape)
-            bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, aStr );
-
-        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
-        SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW,
-                                  XML_FRAME, bCreateNewline, sal_True );
-
-        // evtl. corner radius?
-        sal_Int32 nCornerRadius(0L);
-        xPropSet->getPropertyValue("CornerRadius") >>= nCornerRadius;
-        if(nCornerRadius)
-        {
-            OUStringBuffer sStringBuffer;
-            mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
-                    nCornerRadius);
-            mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CORNER_RADIUS, sStringBuffer.makeStringAndClear());
-        }
-
-        {
-            // write text-box
-            SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_TEXT_BOX, sal_True, sal_True);
-            if(!bIsEmptyPresObj)
-                ImpExportText( xShape );
-        }
-
-        ImpExportDescription( xShape ); // #i68101#
-        ImpExportEvents( xShape );
-        ImpExportGluePoints( xShape );
-    }
-}
-
-void XMLShapeExport::ImpExportRectangleShape(
-    const uno::Reference< drawing::XShape >& xShape,
-    XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint)
-{
-    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
-    if(xPropSet.is())
-    {
-        // Transformation
-        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
-
-        // evtl. corner radius?
-        sal_Int32 nCornerRadius(0L);
-        xPropSet->getPropertyValue("CornerRadius") >>= nCornerRadius;
-        if(nCornerRadius)
-        {
-            OUStringBuffer sStringBuffer;
-            mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
-                    nCornerRadius);
-            mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CORNER_RADIUS, sStringBuffer.makeStringAndClear());
-        }
-
-        // write rectangle
-        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
-        SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_RECT, bCreateNewline, sal_True);
-
-        ImpExportDescription( xShape ); // #i68101#
-        ImpExportEvents( xShape );
-        ImpExportGluePoints( xShape );
-        ImpExportText( xShape );
-    }
-}
-
-void XMLShapeExport::ImpExportLineShape(
-    const uno::Reference< drawing::XShape >& xShape,
-    XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint)
-{
-    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
-    if(xPropSet.is())
-    {
-        OUString aStr;
-        OUStringBuffer sStringBuffer;
-        awt::Point aStart(0,0);
-        awt::Point aEnd(1,1);
-
-        // #85920# use 'Geometry' to get the points of the line
-        // since this slot take anchor pos into account.
-
-        // get matrix
-        ::basegfx::B2DHomMatrix aMatrix;
-        ImpExportNewTrans_GetB2DHomMatrix(aMatrix, xPropSet);
-
-        // decompose and correct about pRefPoint
-        ::basegfx::B2DTuple aTRScale;
-        double fTRShear(0.0);
-        double fTRRotate(0.0);
-        ::basegfx::B2DTuple aTRTranslate;
-        ImpExportNewTrans_DecomposeAndRefPoint(aMatrix, aTRScale, fTRShear, fTRRotate, aTRTranslate, pRefPoint);
-
-        // create base position
-        awt::Point aBasePosition(FRound(aTRTranslate.getX()), FRound(aTRTranslate.getY()));
-
-        // get the two points
-        uno::Any aAny(xPropSet->getPropertyValue("Geometry"));
-        drawing::PointSequenceSequence* pSourcePolyPolygon = (drawing::PointSequenceSequence*)aAny.getValue();
-
-        if(pSourcePolyPolygon)
-        {
-            drawing::PointSequence* pOuterSequence = pSourcePolyPolygon->getArray();
-            if(pOuterSequence)
-            {
-                drawing::PointSequence* pInnerSequence = pOuterSequence++;
-                if(pInnerSequence)
-                {
-                    awt::Point* pArray = pInnerSequence->getArray();
-                    if(pArray)
-                    {
-                        if(pInnerSequence->getLength() > 0)
-                        {
-                            aStart = awt::Point(
-                                pArray->X + aBasePosition.X,
-                                pArray->Y + aBasePosition.Y);
-                            pArray++;
-                        }
-
-                        if(pInnerSequence->getLength() > 1)
-                        {
-                            aEnd = awt::Point(
-                                pArray->X + aBasePosition.X,
-                                pArray->Y + aBasePosition.Y);
-                        }
-                    }
-                }
-            }
-        }
-
-        if( nFeatures & SEF_EXPORT_X )
-        {
-            // svg: x1
-            mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
-                    aStart.X);
-            aStr = sStringBuffer.makeStringAndClear();
-            mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X1, aStr);
-        }
-        else
-        {
-            aEnd.X -= aStart.X;
-        }
-
-        if( nFeatures & SEF_EXPORT_Y )
-        {
-            // svg: y1
-            mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
-                    aStart.Y);
-            aStr = sStringBuffer.makeStringAndClear();
-            mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y1, aStr);
-        }
-        else
-        {
-            aEnd.Y -= aStart.Y;
-        }
-
-        // svg: x2
-        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
-                aEnd.X);
-        aStr = sStringBuffer.makeStringAndClear();
-        mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X2, aStr);
-
-        // svg: y2
-        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
-                aEnd.Y);
-        aStr = sStringBuffer.makeStringAndClear();
-        mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y2, aStr);
-
-        // write line
-        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
-        SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_LINE, bCreateNewline, sal_True);
-
-        ImpExportDescription( xShape ); // #i68101#
-        ImpExportEvents( xShape );
-        ImpExportGluePoints( xShape );
-        ImpExportText( xShape );
-    }
-}
-
-void XMLShapeExport::ImpExportEllipseShape(
-    const uno::Reference< drawing::XShape >& xShape,
-    XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint)
-{
-    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
-    if(xPropSet.is())
-    {
-        // get size to decide between Circle and Ellipse
-        awt::Size aSize = xShape->getSize();
-        sal_Int32 nRx((aSize.Width + 1) / 2);
-        sal_Int32 nRy((aSize.Height + 1) / 2);
-        sal_Bool bCircle(nRx == nRy);
-
-        // Transformation
-        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
-
-        drawing::CircleKind eKind = drawing::CircleKind_FULL;
-        xPropSet->getPropertyValue("CircleKind") >>= eKind;
-        if( eKind != drawing::CircleKind_FULL )
-        {
-            OUStringBuffer sStringBuffer;
-            sal_Int32 nStartAngle = 0;
-            sal_Int32 nEndAngle = 0;
-            xPropSet->getPropertyValue("CircleStartAngle") >>= nStartAngle;
-            xPropSet->getPropertyValue("CircleEndAngle") >>= nEndAngle;
-
-            const double dStartAngle = nStartAngle / 100.0;
-            const double dEndAngle = nEndAngle / 100.0;
-
-            // export circle kind
-            SvXMLUnitConverter::convertEnum( sStringBuffer, (sal_uInt16)eKind, aXML_CircleKind_EnumMap );
-            mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_KIND, sStringBuffer.makeStringAndClear() );
-
-            // export start angle
-            ::sax::Converter::convertDouble( sStringBuffer, dStartAngle );
-            mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_START_ANGLE, sStringBuffer.makeStringAndClear() );
-
-            // export end angle
-            ::sax::Converter::convertDouble( sStringBuffer, dEndAngle );
-            mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_END_ANGLE, sStringBuffer.makeStringAndClear() );
-        }
-
-        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
-
-        if(bCircle)
-        {
-            // write circle
-            SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_CIRCLE, bCreateNewline, sal_True);
-
-            ImpExportDescription( xShape ); // #i68101#
-            ImpExportEvents( xShape );
-            ImpExportGluePoints( xShape );
-            ImpExportText( xShape );
-        }
-        else
-        {
-            // write ellipse
-            SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_ELLIPSE, bCreateNewline, sal_True);
-
-            ImpExportDescription( xShape ); // #i68101#
-            ImpExportEvents( xShape );
-            ImpExportGluePoints( xShape );
-            ImpExportText( xShape );
-        }
-    }
-}
-
-void XMLShapeExport::ImpExportPolygonShape(
-    const uno::Reference< drawing::XShape >& xShape,
-    XmlShapeType eShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint)
-{
-    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
-    if(xPropSet.is())
-    {
-        sal_Bool bClosed(eShapeType == XmlShapeTypeDrawPolyPolygonShape
-            || eShapeType == XmlShapeTypeDrawClosedBezierShape);
-        sal_Bool bBezier(eShapeType == XmlShapeTypeDrawClosedBezierShape
-            || eShapeType == XmlShapeTypeDrawOpenBezierShape);
-
-        // get matrix
-        ::basegfx::B2DHomMatrix aMatrix;
-        ImpExportNewTrans_GetB2DHomMatrix(aMatrix, xPropSet);
-
-        // decompose and correct abour pRefPoint
-        ::basegfx::B2DTuple aTRScale;
-        double fTRShear(0.0);
-        double fTRRotate(0.0);
-        ::basegfx::B2DTuple aTRTranslate;
-        ImpExportNewTrans_DecomposeAndRefPoint(aMatrix, aTRScale, fTRShear, fTRRotate, aTRTranslate, pRefPoint);
-
-        // use features and write
-        ImpExportNewTrans_FeaturesAndWrite(aTRScale, fTRShear, fTRRotate, aTRTranslate, nFeatures);
-
-        // create and export ViewBox
-        awt::Point aPoint(0, 0);
-        awt::Size aSize(FRound(aTRScale.getX()), FRound(aTRScale.getY()));
-        SdXMLImExViewBox aViewBox(0, 0, aSize.Width, aSize.Height);
-        mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_VIEWBOX, aViewBox.GetExportString());
-
-        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
-
-        if(bBezier)
-        {
-            // get PolygonBezier
-            uno::Any aAny( xPropSet->getPropertyValue("Geometry") );
-            drawing::PolyPolygonBezierCoords* pSourcePolyPolygon =
-                (drawing::PolyPolygonBezierCoords*)aAny.getValue();
-
-            if(pSourcePolyPolygon && pSourcePolyPolygon->Coordinates.getLength())
-            {
-                sal_Int32 nOuterCnt(pSourcePolyPolygon->Coordinates.getLength());
-                drawing::PointSequence* pOuterSequence = pSourcePolyPolygon->Coordinates.getArray();
-                drawing::FlagSequence*  pOuterFlags = pSourcePolyPolygon->Flags.getArray();
-
-                if(pOuterSequence && pOuterFlags)
-                {
-                    // prepare svx:d element export
-                    SdXMLImExSvgDElement aSvgDElement(aViewBox, GetExport());
-
-                    for(sal_Int32 a(0L); a < nOuterCnt; a++)
-                    {
-                        drawing::PointSequence* pSequence = pOuterSequence++;
-                        drawing::FlagSequence* pFlags = pOuterFlags++;
-
-                        if(pSequence && pFlags)
-                        {
-                            aSvgDElement.AddPolygon(pSequence, pFlags,
-                                aPoint, aSize, bClosed);
-                        }
-                    }
-
-                    // write point array
-                    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aSvgDElement.GetExportString());
-                }
-
-                // write object now
-                SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PATH, bCreateNewline, sal_True);
-
-                ImpExportDescription( xShape ); // #i68101#
-                ImpExportEvents( xShape );
-                ImpExportGluePoints( xShape );
-                ImpExportText( xShape );
-            }
-        }
-        else
-        {
-            // get non-bezier polygon
-            uno::Any aAny( xPropSet->getPropertyValue("Geometry") );
-            drawing::PointSequenceSequence* pSourcePolyPolygon = (drawing::PointSequenceSequence*)aAny.getValue();
-
-            if(pSourcePolyPolygon && pSourcePolyPolygon->getLength())
-            {
-                sal_Int32 nOuterCnt(pSourcePolyPolygon->getLength());
-
-                if(1L == nOuterCnt && !bBezier)
-                {
-                    // simple polygon shape, can be written as svg:points sequence
-                    drawing::PointSequence* pSequence = pSourcePolyPolygon->getArray();
-                    if(pSequence)
-                    {
-                        SdXMLImExPointsElement aPoints(pSequence, aViewBox, aPoint, aSize,
-                            // #96328#
-                            bClosed);
-
-                        // write point array
-                        mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_POINTS, aPoints.GetExportString());
-                    }
-
-                    // write object now
-                    SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW,
-                        bClosed ? XML_POLYGON : XML_POLYLINE , bCreateNewline, sal_True);
-
-                    ImpExportDescription( xShape ); // #i68101#
-                    ImpExportEvents( xShape );
-                    ImpExportGluePoints( xShape );
-                    ImpExportText( xShape );
-                }
-                else
-                {
-                    // polypolygon or bezier, needs to be written as a svg:path sequence
-                    drawing::PointSequence* pOuterSequence = pSourcePolyPolygon->getArray();
-                    if(pOuterSequence)
-                    {
-                        // prepare svx:d element export
-                        SdXMLImExSvgDElement aSvgDElement(aViewBox, GetExport());
-
-                        for(sal_Int32 a(0L); a < nOuterCnt; a++)
-                        {
-                            drawing::PointSequence* pSequence = pOuterSequence++;
-                            if(pSequence)
-                            {
-                                aSvgDElement.AddPolygon(pSequence, 0L, aPoint,
-                                    aSize, bClosed);
-                            }
-                        }
-
-                        // write point array
-                        mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aSvgDElement.GetExportString());
-                    }
-
-                    // write object now
-                    SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PATH, bCreateNewline, sal_True);
-
-                    ImpExportDescription( xShape ); // #i68101#
-                    ImpExportEvents( xShape );
-                    ImpExportGluePoints( xShape );
-                    ImpExportText( xShape );
-                }
-            }
-        }
-    }
-}
-
-void XMLShapeExport::ImpExportGraphicObjectShape(
-    const uno::Reference< drawing::XShape >& xShape,
-    XmlShapeType eShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint)
-{
-    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
-    if(xPropSet.is())
-    {
-        sal_Bool bIsEmptyPresObj = sal_False;
-        uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
-
-        // Transformation
-        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
-
-        OUString sImageURL;
-
-        if(eShapeType == XmlShapeTypePresGraphicObjectShape)
-            bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_GRAPHIC) );
-
-        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
-        SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW,
-                                  XML_FRAME, bCreateNewline, sal_True );
-
-        const bool bSaveBackwardsCompatible = ( mrExport.getExportFlags() & EXPORT_SAVEBACKWARDCOMPATIBLE );
-
-        if( !bIsEmptyPresObj || bSaveBackwardsCompatible )
-        {
-            if( !bIsEmptyPresObj )
-            {
-                OUString aReplacementUrl;
-                xPropSet->getPropertyValue("ReplacementGraphicURL") >>= aReplacementUrl;
-
-                // If there is no url, then then graphic is empty
-                if(!aReplacementUrl.isEmpty())
-                {
-                    const OUString aStr = mrExport.AddEmbeddedGraphicObject(aReplacementUrl);
-
-                    if(aStr.getLength())
-                    {
-                        mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, aStr);
-                        mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
-                        mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
-                        mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
-
-                        // xlink:href for replacement, only written for Svg content
-                        SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_IMAGE, sal_True, sal_True);
-
-                        // optional office:binary-data
-                        mrExport.AddEmbeddedGraphicObjectAsBase64(aReplacementUrl);
-                    }
-                }
-
-                OUString aStreamURL;
-                OUString aStr;
-
-                xPropSet->getPropertyValue("GraphicStreamURL") >>= aStreamURL;
-                xPropSet->getPropertyValue("GraphicURL") >>= sImageURL;
-
-                OUString aResolveURL( sImageURL );
-                const OUString sPackageURL( "vnd.sun.star.Package:" );
-
-                    // sj: trying to preserve the filename
-                if ( aStreamURL.match( sPackageURL, 0 ) )
-                {
-                    OUString sRequestedName( aStreamURL.copy( sPackageURL.getLength(), aStreamURL.getLength() - sPackageURL.getLength() ) );
-                    sal_Int32 nLastIndex = sRequestedName.lastIndexOf( '/' ) + 1;
-                    if ( ( nLastIndex > 0 ) && ( nLastIndex < sRequestedName.getLength() ) )
-                        sRequestedName = sRequestedName.copy( nLastIndex, sRequestedName.getLength() - nLastIndex );
-                    nLastIndex = sRequestedName.lastIndexOf( '.' );
-                    if ( nLastIndex >= 0 )
-                        sRequestedName = sRequestedName.copy( 0, nLastIndex );
-                    if ( !sRequestedName.isEmpty() )
-                    {
-                        aResolveURL = aResolveURL.concat( OUString("?requestedName="));
-                        aResolveURL = aResolveURL.concat( sRequestedName );
-                    }
-                }
-
-                aStr = mrExport.AddEmbeddedGraphicObject( aResolveURL );
-                mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, aStr );
-
-                if( !aStr.isEmpty() )
-                {
-                    if( aStr[ 0 ] == '#' )
-                    {
-                        aStreamURL = sPackageURL;
-                        aStreamURL = aStreamURL.concat( aStr.copy( 1, aStr.getLength() - 1 ) );
-                    }
-
-                    // update stream URL for load on demand
-                    uno::Any aAny;
-                    aAny <<= aStreamURL;
-                    xPropSet->setPropertyValue("GraphicStreamURL", aAny );
-
-                    mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
-                    mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
-                    mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
-                }
-            }
-            else
-            {
-                OUString aStr;
-                mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, aStr );
-                mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
-                mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
-                mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
-            }
-
-            {
-                SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_IMAGE, sal_True, sal_True);
-
-                if( !sImageURL.isEmpty() )
-                {
-                    // optional office:binary-data
-                    mrExport.AddEmbeddedGraphicObjectAsBase64( sImageURL );
-                }
-                if( !bIsEmptyPresObj )
-                    ImpExportText( xShape );
-            }
-        }
-
-        ImpExportEvents( xShape );
-        ImpExportGluePoints( xShape );
-
-        // image map
-        GetExport().GetImageMapExport().Export( xPropSet );
-        ImpExportDescription( xShape ); // #i68101#
-    }
-}
-
-void XMLShapeExport::ImpExportChartShape(
-    const uno::Reference< drawing::XShape >& xShape,
-    XmlShapeType eShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint,
-    SvXMLAttributeList* pAttrList )
-{
-    ImpExportOLE2Shape( xShape, eShapeType, nFeatures, pRefPoint, pAttrList );
-}
-
-void XMLShapeExport::ImpExportControlShape(
-    const uno::Reference< drawing::XShape >& xShape,
-    XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint)
-{
-    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
-    if(xPropSet.is())
-    {
-        // Transformation
-        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
-    }
-
-    uno::Reference< drawing::XControlShape > xControl( xShape, uno::UNO_QUERY );
-    DBG_ASSERT( xControl.is(), "Control shape is not supporting XControlShape" );
-    if( xControl.is() )
-    {
-        uno::Reference< beans::XPropertySet > xControlModel( xControl->getControl(), uno::UNO_QUERY );
-        DBG_ASSERT( xControlModel.is(), "Control shape has not XControlModel" );
-        if( xControlModel.is() )
-        {
-            mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CONTROL, mrExport.GetFormExport()->getControlId( xControlModel ) );
-        }
-    }
-
-    sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
-    SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_CONTROL, bCreateNewline, sal_True);
-
-    ImpExportDescription( xShape ); // #i68101#
-}
-
-void XMLShapeExport::ImpExportConnectorShape(
-    const uno::Reference< drawing::XShape >& xShape,
-    XmlShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */)
-{
-    uno::Reference< beans::XPropertySet > xProps( xShape, uno::UNO_QUERY );
-
-    OUString aStr;
-    OUStringBuffer sStringBuffer;
-
-    // export connection kind
-    drawing::ConnectorType eType = drawing::ConnectorType_STANDARD;
-    uno::Any aAny = xProps->getPropertyValue("EdgeKind");
-    aAny >>= eType;
-
-    if( eType != drawing::ConnectorType_STANDARD )
-    {
-        SvXMLUnitConverter::convertEnum( sStringBuffer, (sal_uInt16)eType, aXML_ConnectionKind_EnumMap );
-        aStr = sStringBuffer.makeStringAndClear();
-        mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_TYPE, aStr);
-    }
-
-    // export line skew
-    sal_Int32 nDelta1 = 0, nDelta2 = 0, nDelta3 = 0;
-
-    aAny = xProps->getPropertyValue("EdgeLine1Delta");
-    aAny >>= nDelta1;
-    aAny = xProps->getPropertyValue("EdgeLine2Delta");
-    aAny >>= nDelta2;
-    aAny = xProps->getPropertyValue("EdgeLine3Delta");
-    aAny >>= nDelta3;
-
-    if( nDelta1 != 0 || nDelta2 != 0 || nDelta3 != 0 )
-    {
-        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
-                nDelta1);
-        if( nDelta2 != 0 || nDelta3 != 0 )
-        {
-            const char aSpace = ' ';
-            sStringBuffer.appendAscii( &aSpace, 1 );
-            mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
-                    nDelta2);
-            if( nDelta3 != 0 )
-            {
-                sStringBuffer.appendAscii( &aSpace, 1 );
-                mrExport.GetMM100UnitConverter().convertMeasureToXML(
-                        sStringBuffer, nDelta3);
-            }
-        }
-
-        aStr = sStringBuffer.makeStringAndClear();
-        mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_LINE_SKEW, aStr);
-    }
-
-    // export start and end point
-    awt::Point aStart(0,0);
-    awt::Point aEnd(1,1);
-
-    /* Get <StartPositionInHoriL2R> and
-       <EndPositionInHoriL2R>, if they exist and if the document is exported
-       into the OpenOffice.org file format.
-       These properties only exist at service com::sun::star::text::Shape - the
-       Writer UNO service for shapes.
-       This code is needed, because the positioning attributes in the
-       OpenOffice.org file format are given in horizontal left-to-right layout
-       regardless the layout direction the shape is in. In the OASIS Open Office
-       file format the positioning attributes are correctly given in the layout
-       direction the shape is in. Thus, this code provides the conversion from
-       the OASIS Open Office file format to the OpenOffice.org file format. (#i36248#)
-    */
-    if ( ( GetExport().getExportFlags() & EXPORT_OASIS ) == 0 &&
-         xProps->getPropertySetInfo()->hasPropertyByName(
-            OUString("StartPositionInHoriL2R")) &&
-         xProps->getPropertySetInfo()->hasPropertyByName(
-            OUString("EndPositionInHoriL2R")) )
-    {
-        xProps->getPropertyValue("StartPositionInHoriL2R") >>= aStart;
-        xProps->getPropertyValue("EndPositionInHoriL2R") >>= aEnd;
-    }
-    else
-    {
-        xProps->getPropertyValue("StartPosition") >>= aStart;
-        xProps->getPropertyValue("EndPosition") >>= aEnd;
-    }
-
-    if( pRefPoint )
-    {
-        aStart.X -= pRefPoint->X;
-        aStart.Y -= pRefPoint->Y;
-        aEnd.X -= pRefPoint->X;
-        aEnd.Y -= pRefPoint->Y;
-    }
-
-    if( nFeatures & SEF_EXPORT_X )
-    {
-        // svg: x1
-        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
-                aStart.X);
-        aStr = sStringBuffer.makeStringAndClear();
-        mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X1, aStr);
-    }
-    else
-    {
-        aEnd.X -= aStart.X;
-    }
-
-    if( nFeatures & SEF_EXPORT_Y )
-    {
-        // svg: y1
-        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
-                aStart.Y);
-        aStr = sStringBuffer.makeStringAndClear();
-        mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y1, aStr);
-    }
-    else
-    {
-        aEnd.Y -= aStart.Y;
-    }
-
-    // svg: x2
-    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, aEnd.X);
-    aStr = sStringBuffer.makeStringAndClear();
-    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X2, aStr);
-
-    // svg: y2
-    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, aEnd.Y);
-    aStr = sStringBuffer.makeStringAndClear();
-    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y2, aStr);
-
-    // #i39320#
-    uno::Reference< uno::XInterface > xRefS;
-    uno::Reference< uno::XInterface > xRefE;
-
-    // export start connection
-    xProps->getPropertyValue("StartShape") >>= xRefS;
-    if( xRefS.is() )
-    {
-        const OUString& rShapeId = mrExport.getInterfaceToIdentifierMapper().getIdentifier( xRefS );
-        mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_START_SHAPE, rShapeId);
-
-        aAny = xProps->getPropertyValue("StartGluePointIndex");
-        sal_Int32 nGluePointId = 0;
-        if( aAny >>= nGluePointId )
-        {
-            if( nGluePointId != -1 )
-            {
-                mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_START_GLUE_POINT, OUString::number( nGluePointId ));
-            }
-        }
-    }
-
-    // export end connection
-    xProps->getPropertyValue("EndShape") >>= xRefE;
-    if( xRefE.is() )
-    {
-        const OUString& rShapeId = mrExport.getInterfaceToIdentifierMapper().getIdentifier( xRefE );
-        mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_END_SHAPE, rShapeId);
-
-        aAny = xProps->getPropertyValue("EndGluePointIndex");
-        sal_Int32 nGluePointId = 0;
-        if( aAny >>= nGluePointId )
-        {
-            if( nGluePointId != -1 )
-            {
-                mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_END_GLUE_POINT, OUString::number( nGluePointId ));
-            }
-        }
-    }
-
-    if( xProps->getPropertyValue("PolyPolygonBezier") >>= aAny )
-    {
-        // get PolygonBezier
-        drawing::PolyPolygonBezierCoords* pSourcePolyPolygon =
-            (drawing::PolyPolygonBezierCoords*)aAny.getValue();
-
-        if(pSourcePolyPolygon && pSourcePolyPolygon->Coordinates.getLength())
-        {
-            sal_Int32 nOuterCnt(pSourcePolyPolygon->Coordinates.getLength());
-            drawing::PointSequence* pOuterSequence = pSourcePolyPolygon->Coordinates.getArray();
-            drawing::FlagSequence*  pOuterFlags = pSourcePolyPolygon->Flags.getArray();
-
-            if(pOuterSequence && pOuterFlags)
-            {
-                // prepare svx:d element export
-                awt::Point aPoint( 0, 0 );
-                awt::Size aSize( 1, 1 );
-                SdXMLImExViewBox aViewBox( 0, 0, 1, 1 );
-                SdXMLImExSvgDElement aSvgDElement(aViewBox, GetExport());
-
-                for(sal_Int32 a(0L); a < nOuterCnt; a++)
-                {
-                    drawing::PointSequence* pSequence = pOuterSequence++;
-                    drawing::FlagSequence* pFlags = pOuterFlags++;
-
-                    if(pSequence && pFlags)
-                    {
-                        aSvgDElement.AddPolygon(pSequence, pFlags,
-                            aPoint, aSize, sal_False );
-                    }
-                }
-
-                // write point array
-                mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aSvgDElement.GetExportString());
-            }
-        }
-    }
-
-    // get matrix
-    ::basegfx::B2DHomMatrix aMatrix;
-    ImpExportNewTrans_GetB2DHomMatrix(aMatrix, xProps);
-
-    // decompose and correct about pRefPoint
-    ::basegfx::B2DTuple aTRScale;
-    double fTRShear(0.0);
-    double fTRRotate(0.0);
-    ::basegfx::B2DTuple aTRTranslate;
-    ImpExportNewTrans_DecomposeAndRefPoint(aMatrix, aTRScale, fTRShear,
-            fTRRotate, aTRTranslate, pRefPoint);
-
-    // fdo#49678: create and export ViewBox
-    awt::Point aPoint(0, 0);
-    awt::Size aSize(FRound(aTRScale.getX()), FRound(aTRScale.getY()));
-    SdXMLImExViewBox aViewBox(0, 0, aSize.Width, aSize.Height);
-    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_VIEWBOX, aViewBox.GetExportString());
-
-    // write connector shape. Add Export later.
-    sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
-    SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_CONNECTOR, bCreateNewline, sal_True);
-
-    ImpExportDescription( xShape ); // #i68101#
-    ImpExportEvents( xShape );
-    ImpExportGluePoints( xShape );
-    ImpExportText( xShape );
-}
-
-void XMLShapeExport::ImpExportMeasureShape(
-    const uno::Reference< drawing::XShape >& xShape,
-    XmlShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */)
-{
-    uno::Reference< beans::XPropertySet > xProps( xShape, uno::UNO_QUERY );
-
-    OUString aStr;
-    OUStringBuffer sStringBuffer;
-
-    // export start and end point
-    awt::Point aStart(0,0);
-    awt::Point aEnd(1,1);
-
-    /* Get <StartPositionInHoriL2R> and
-       <EndPositionInHoriL2R>, if they exist and if the document is exported
-       into the OpenOffice.org file format.
-       These properties only exist at service com::sun::star::text::Shape - the
-       Writer UNO service for shapes.
-       This code is needed, because the positioning attributes in the
-       OpenOffice.org file format are given in horizontal left-to-right layout
-       regardless the layout direction the shape is in. In the OASIS Open Office
-       file format the positioning attributes are correctly given in the layout
-       direction the shape is in. Thus, this code provides the conversion from
-       the OASIS Open Office file format to the OpenOffice.org file format. (#i36248#)
-    */
-    if ( ( GetExport().getExportFlags() & EXPORT_OASIS ) == 0 &&
-         xProps->getPropertySetInfo()->hasPropertyByName(
-            OUString("StartPositionInHoriL2R")) &&
-         xProps->getPropertySetInfo()->hasPropertyByName(
-            OUString("EndPositionInHoriL2R")) )
-    {
-        xProps->getPropertyValue("StartPositionInHoriL2R") >>= aStart;
-        xProps->getPropertyValue("EndPositionInHoriL2R") >>= aEnd;
-    }
-    else
-    {
-        xProps->getPropertyValue("StartPosition") >>= aStart;
-        xProps->getPropertyValue("EndPosition") >>= aEnd;
-    }
-
-    if( pRefPoint )
-    {
-        aStart.X -= pRefPoint->X;
-        aStart.Y -= pRefPoint->Y;
-        aEnd.X -= pRefPoint->X;
-        aEnd.Y -= pRefPoint->Y;
-    }
-
-    if( nFeatures & SEF_EXPORT_X )
-    {
-        // svg: x1
-        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
-                aStart.X);
-        aStr = sStringBuffer.makeStringAndClear();
-        mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X1, aStr);
-    }
-    else
-    {
-        aEnd.X -= aStart.X;
-    }
-
-    if( nFeatures & SEF_EXPORT_Y )
-    {
-        // svg: y1
-        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
-                aStart.Y);
-        aStr = sStringBuffer.makeStringAndClear();
-        mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y1, aStr);
-    }
-    else
-    {
-        aEnd.Y -= aStart.Y;
-    }
-
-    // svg: x2
-    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, aEnd.X);
-    aStr = sStringBuffer.makeStringAndClear();
-    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X2, aStr);
-
-    // svg: y2
-    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, aEnd.Y);
-    aStr = sStringBuffer.makeStringAndClear();
-    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y2, aStr);
-
-    // write measure shape
-    sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
-    SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_MEASURE, bCreateNewline, sal_True);
-
-    ImpExportDescription( xShape ); // #i68101#
-    ImpExportEvents( xShape );
-    ImpExportGluePoints( xShape );
-
-    uno::Reference< text::XText > xText( xShape, uno::UNO_QUERY );
-    if( xText.is() )
-        mrExport.GetTextParagraphExport()->exportText( xText );
-}
-
-void XMLShapeExport::ImpExportOLE2Shape(
-    const uno::Reference< drawing::XShape >& xShape,
-    XmlShapeType eShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */,
-    SvXMLAttributeList* pAttrList /* = NULL */ )
-{
-    uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
-    uno::Reference< container::XNamed > xNamed(xShape, uno::UNO_QUERY);
-
-    DBG_ASSERT( xPropSet.is() && xNamed.is(), "ole shape is not implementing needed interfaces");
-    if(xPropSet.is() && xNamed.is())
-    {
-        // Transformation
-        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
-
-        sal_Bool bIsEmptyPresObj = sal_False;
-
-        // presentation settings
-        if(eShapeType == XmlShapeTypePresOLE2Shape)
-            bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_OBJECT) );
-        else if(eShapeType == XmlShapeTypePresChartShape)
-            bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_CHART) );
-        else if(eShapeType == XmlShapeTypePresSheetShape)
-            bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_TABLE) );
-
-        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
-        sal_Bool bExportEmbedded(0 != (mrExport.getExportFlags() & EXPORT_EMBEDDED));
-        OUString sPersistName;
-        SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW,
-                                  XML_FRAME, bCreateNewline, sal_True );
-
-        const bool bSaveBackwardsCompatible = ( mrExport.getExportFlags() & EXPORT_SAVEBACKWARDCOMPATIBLE );
-
-        if( !bIsEmptyPresObj || bSaveBackwardsCompatible )
-        {
-            if (pAttrList)
-            {
-                mrExport.AddAttributeList(pAttrList);
-            }
-
-            OUString sClassId;
-            OUString sURL;
-            sal_Bool bInternal = false;
-            xPropSet->getPropertyValue("IsInternal") >>= bInternal;
-
-            if( !bIsEmptyPresObj )
-            {
-
-                if ( bInternal )
-                {
-                    // OOo internal links have no storage persistance, URL is stored in the XML file
-                    // the result LinkURL is empty in case the object is not a link
-                    xPropSet->getPropertyValue("LinkURL") >>= sURL;
-                }
-
-                xPropSet->getPropertyValue("PersistName") >>= sPersistName;
-                if ( sURL.isEmpty() )
-                {
-                    if( !sPersistName.isEmpty() )
-                    {
-                        sURL = OUString(  "vnd.sun.star.EmbeddedObject:"  );
-                        sURL += sPersistName;
-                    }
-                }
-
-                if( !bInternal )
-                    xPropSet->getPropertyValue("CLSID") >>= sClassId;
-
-                if( !sClassId.isEmpty() )
-                    mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CLASS_ID, sClassId );
-
-                if(eShapeType != XmlShapeTypePresChartShape && eShapeType != XmlShapeTypeDrawChartShape)
-                {
-                    // #i118485# Add text export, the draw OLE shape allows text now
-                    // fdo#58571 chart objects don't allow text:p
-                    ImpExportText( xShape );
-                }
-
-                if(!bExportEmbedded)
-                {
-                    // xlink:href
-                    if( !sURL.isEmpty() )
-                    {
-                        // #96717# in theorie, if we don't have a url we shouldn't even
-                        // export this ole shape. But practical its to risky right now
-                        // to change this so we better dispose this on load
-                        sURL = mrExport.AddEmbeddedObject( sURL );
-
-                        mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sURL );
-                        mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
-                        mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
-                        mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
-                    }
-                }
-            }
-            else
-            {
-                // export empty href for empty placeholders to be valid ODF
-                OUString sEmptyURL;
-
-                mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sEmptyURL );
-                mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
-                mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
-                mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
-            }
-
-            enum XMLTokenEnum eElem = sClassId.isEmpty() ? XML_OBJECT : XML_OBJECT_OLE ;
-            SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, eElem, sal_True, sal_True );
-
-            if(bExportEmbedded && !bIsEmptyPresObj)
-            {
-                // #100592#
-                if(bInternal)
-                {
-                    // embedded XML
-                    uno::Reference< lang::XComponent > xComp;
-                    xPropSet->getPropertyValue("Model") >>= xComp;
-                    DBG_ASSERT( xComp.is(), "no xModel for own OLE format" );
-                    mrExport.ExportEmbeddedOwnObject( xComp );
-                }
-                else
-                {
-                    // embed as Base64
-                    // this is an alien object ( currently MSOLE is the only supported type of such objects )
-                    // in case it is not an OASIS format the object should be asked to store replacement image if possible
-
-                    OUString sURLRequest( sURL );
-                    if ( ( mrExport.getExportFlags() & EXPORT_OASIS ) == 0 )
-                        sURLRequest += OUString(  "?oasis=false"  );
-                    mrExport.AddEmbeddedObjectAsBase64( sURLRequest );
-                }
-            }
-        }
-        if( !bIsEmptyPresObj )
-        {
-            OUString sURL(  "vnd.sun.star.GraphicObject:"  );
-            sURL += sPersistName;
-            if( !bExportEmbedded )
-            {
-                sURL = GetExport().AddEmbeddedObject( sURL );
-                mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sURL );
-                mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
-                mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
-                mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
-            }
-
-            SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_DRAW,
-                                      XML_IMAGE, sal_False, sal_True );
-
-            if( bExportEmbedded )
-                GetExport().AddEmbeddedObjectAsBase64( sURL );
-        }
-
-        ImpExportEvents( xShape );
-        ImpExportGluePoints( xShape );
-        ImpExportDescription( xShape ); // #i68101#
-    }
-}
-
-void XMLShapeExport::ImpExportPageShape(
-    const uno::Reference< drawing::XShape >& xShape,
-    XmlShapeType eShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */)
-{
-    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
-    if(xPropSet.is())
-    {
-        // #86163# Transformation
-        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
-
-        // export page number used for this page
-        uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
-        const OUString aPageNumberStr("PageNumber");
-        if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName(aPageNumberStr))
-        {
-            sal_Int32 nPageNumber = 0;
-            xPropSet->getPropertyValue(aPageNumberStr) >>= nPageNumber;
-            if( nPageNumber )
-                mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_PAGE_NUMBER, OUString::number(nPageNumber));
-        }
-
-        // a presentation page shape, normally used on notes pages only. If
-        // it is used not as presentation shape, it may have been created with
-        // copy-paste exchange between draw and impress (this IS possible...)
-        if(eShapeType == XmlShapeTypePresPageShape)
-        {
-            mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_CLASS,
-                                 XML_PRESENTATION_PAGE);
-        }
-
-        // write Page shape
-        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
-        SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PAGE_THUMBNAIL, bCreateNewline, sal_True);
-    }
-}
-
-void XMLShapeExport::ImpExportCaptionShape(
-    const uno::Reference< drawing::XShape >& xShape,
-    XmlShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */)
-{
-    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
-    if(xPropSet.is())
-    {
-        // Transformation
-        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
-
-        // evtl. corner radius?
-        sal_Int32 nCornerRadius(0L);
-        xPropSet->getPropertyValue("CornerRadius") >>= nCornerRadius;
-        if(nCornerRadius)
-        {
-            OUStringBuffer sStringBuffer;
-            mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
-                    nCornerRadius);
-            mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CORNER_RADIUS, sStringBuffer.makeStringAndClear());
-        }
-
-        awt::Point aCaptionPoint;
-        xPropSet->getPropertyValue("CaptionPoint") >>= aCaptionPoint;
-
-        mrExport.GetMM100UnitConverter().convertMeasureToXML(msBuffer,
-                aCaptionPoint.X);
-        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CAPTION_POINT_X, msBuffer.makeStringAndClear() );
-        mrExport.GetMM100UnitConverter().convertMeasureToXML(msBuffer,
-                aCaptionPoint.Y);
-        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CAPTION_POINT_Y, msBuffer.makeStringAndClear() );
-
-        // write Caption shape. Add export later.
-        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
-        sal_Bool bAnnotation( (nFeatures & SEF_EXPORT_ANNOTATION) == SEF_EXPORT_ANNOTATION );
-
-        SvXMLElementExport aObj( mrExport,
-                                 (bAnnotation ? XML_NAMESPACE_OFFICE
-                                               : XML_NAMESPACE_DRAW),
-                                 (bAnnotation ? XML_ANNOTATION : XML_CAPTION),
-                                 bCreateNewline, sal_True );
-
-        ImpExportDescription( xShape ); // #i68101#
-        ImpExportEvents( xShape );
-        ImpExportGluePoints( xShape );
-        if( bAnnotation )
-            mrExport.exportAnnotationMeta( xShape );
-        ImpExportText( xShape );
-    }
-}
-
-void XMLShapeExport::ImpExportFrameShape(
-    const uno::Reference< drawing::XShape >& xShape,
-    XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint)
-{
-    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
-    if(xPropSet.is())
-    {
-        // Transformation
-        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
-
-        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
-        SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW,
-                                  XML_FRAME, bCreateNewline, sal_True );
-
-        // export frame url
-        OUString aStr;
-        xPropSet->getPropertyValue("FrameURL") >>= aStr;
-        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStr) );
-        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
-        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
-        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
-
-        // export name
-        xPropSet->getPropertyValue("FrameName") >>= aStr;
-        if( !aStr.isEmpty() )
-            mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_FRAME_NAME, aStr );
-
-        // write floating frame
-        {
-            SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_FLOATING_FRAME, sal_True, sal_True);
-        }
-    }
-}
-
-void XMLShapeExport::ImpExportAppletShape(
-    const uno::Reference< drawing::XShape >& xShape,
-    XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint)
-{
-    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
-    if(xPropSet.is())
-    {
-        // Transformation
-        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
-
-        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
-        SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW,
-                                  XML_FRAME, bCreateNewline, sal_True );
-
-        // export frame url
-        OUString aStr;
-        xPropSet->getPropertyValue("AppletCodeBase") >>= aStr;
-        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStr) );
-        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
-        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
-        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
-
-        // export draw:applet-name
-        xPropSet->getPropertyValue("AppletName") >>= aStr;
-        if( !aStr.isEmpty() )
-            mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_APPLET_NAME, aStr );
-
-        // export draw:code
-        xPropSet->getPropertyValue("AppletCode") >>= aStr;
-        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CODE, aStr );
-
-        // export draw:may-script
-        sal_Bool bIsScript = false;
-        xPropSet->getPropertyValue("AppletIsScript") >>= bIsScript;
-        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MAY_SCRIPT, bIsScript ? XML_TRUE : XML_FALSE );
-
-        {
-            // write applet
-            SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_APPLET, sal_True, sal_True);
-
-            // export parameters
-            uno::Sequence< beans::PropertyValue > aCommands;
-            xPropSet->getPropertyValue("AppletCommands") >>= aCommands;
-            const sal_Int32 nCount = aCommands.getLength();
-            for( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++ )
-            {
-                aCommands[nIndex].Value >>= aStr;
-                mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aCommands[nIndex].Name );
-                mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, aStr );
-                SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True );
-            }
-        }
-    }
-}
-
-void XMLShapeExport::ImpExportPluginShape(
-    const uno::Reference< drawing::XShape >& xShape,
-    XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint)
-{
-    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
-    if(xPropSet.is())
-    {
-        // Transformation
-        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
-
-        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
-        SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW,
-                                  XML_FRAME, bCreateNewline, sal_True );
-
-        // export plugin url
-        OUString aStr;
-        xPropSet->getPropertyValue("PluginURL") >>= aStr;
-        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStr) );
-        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
-        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
-        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
-
-        // export mime-type
-        xPropSet->getPropertyValue("PluginMimeType") >>= aStr;
-        if(!aStr.isEmpty())
-            mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIME_TYPE, aStr );
-
-        {
-            // write plugin
-            SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PLUGIN, sal_True, sal_True);
-
-            // export parameters
-            uno::Sequence< beans::PropertyValue > aCommands;
-            xPropSet->getPropertyValue("PluginCommands") >>= aCommands;
-            const sal_Int32 nCount = aCommands.getLength();
-            for( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++ )
-            {
-                aCommands[nIndex].Value >>= aStr;
-                mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aCommands[nIndex].Name );
-                mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, aStr );
-                SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True );
-            }
-        }
-    }
-}
-
-static void lcl_CopyStream(
-        uno::Reference<io::XInputStream> const& xInStream,
-        uno::Reference<embed::XStorage> const& xTarget,
-        OUString const& rPath)
-{
-    ::comphelper::LifecycleProxy proxy;
-    uno::Reference<io::XStream> const xStream(
-        ::comphelper::OStorageHelper::GetStreamAtPackageURL(xTarget, rPath,
-            embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE, proxy));
-    uno::Reference<io::XOutputStream> const xOutStream(
-            (xStream.is()) ? xStream->getOutputStream() : 0);
-    if (!xOutStream.is())
-    {
-        SAL_WARN("xmloff", "no output stream");
-        throw uno::Exception(
-            OUString("no output stream"),0);
-    }
-    uno::Reference< beans::XPropertySet > const xStreamProps(xStream,
-        uno::UNO_QUERY);
-    if (xStreamProps.is()) { // this is NOT supported in FileSystemStorage
-        xStreamProps->setPropertyValue(
-            OUString("MediaType"),
-            uno::makeAny(OUString(
-            //FIXME how to detect real media type?
-            //but currently xmloff has this one hardcoded anyway...
-                    "application/vnd.sun.star.media")));
-        xStreamProps->setPropertyValue( // turn off compression
-            OUString("Compressed"),
-            uno::makeAny(sal_False));
-    }
-    ::comphelper::OStorageHelper::CopyInputToOutput(xInStream, xOutStream);
-    xOutStream->closeOutput();
-    proxy.commitStorages();
-}
-
-static char const s_PkgScheme[] = "vnd.sun.star.Package:";
-
-static OUString
-lcl_StoreMediaAndGetURL(SvXMLExport & rExport,
-    uno::Reference<beans::XPropertySet> const& xPropSet,
-    OUString const& rURL)
-{
-    if (0 == rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength(
-                rURL.getStr(), rURL.getLength(),
-                s_PkgScheme, SAL_N_ELEMENTS(s_PkgScheme) - 1))
-    {
-        try // video is embedded
-        {
-            uno::Reference<embed::XStorage> const xTarget(
-                    rExport.GetTargetStorage(), uno::UNO_QUERY_THROW);
-            uno::Reference<io::XInputStream> xInStream;
-            xPropSet->getPropertyValue(
-                OUString("PrivateStream"))
-                    >>= xInStream;
-
-            if (!xInStream.is())
-            {
-                SAL_WARN("xmloff", "no input stream");
-                return OUString();
-            }
-
-            OUString const urlPath(
-                    rURL.copy(SAL_N_ELEMENTS(s_PkgScheme)-1));
-
-            lcl_CopyStream(xInStream, xTarget, rURL);
-
-            return urlPath;
-        }
-        catch (uno::Exception const& e)
-        {
-            SAL_INFO("xmloff", "exception while storing embedded media: '"
-                        << e.Message << "'");
-        }
-        return OUString();
-    }
-    else
-    {
-        return rExport.GetRelativeReference(rURL); // linked
-    }
-}
-
-void XMLShapeExport::ImpExportMediaShape(
-    const uno::Reference< drawing::XShape >& xShape,
-    XmlShapeType eShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint)
-{
-    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
-    if(xPropSet.is())
-    {
-        // Transformation
-        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
-
-        if(eShapeType == XmlShapeTypePresMediaShape)
-            ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_OBJECT) );
-
-        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
-        SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW,
-                                  XML_FRAME, bCreateNewline, sal_True );
-
-        // export media url
-        OUString aMediaURL;
-        xPropSet->getPropertyValue("MediaURL") >>= aMediaURL;
-        OUString const persistentURL =
-            lcl_StoreMediaAndGetURL(GetExport(), xPropSet, aMediaURL);
-        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, persistentURL );
-        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
-        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
-        mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
-
-        // export mime-type
-        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIME_TYPE, OUString(  "application/vnd.sun.star.media"  ) );
-
-        // write plugin
-        SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PLUGIN, !( nFeatures & SEF_EXPORT_NO_WS ), sal_True);
-
-        // export parameters
-        const OUString aFalseStr(  "false"  ), aTrueStr(  "true"  );
-
-        sal_Bool bLoop = false;
-        const OUString aLoopStr(  "Loop"  );
-        xPropSet->getPropertyValue( aLoopStr ) >>= bLoop;
-        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aLoopStr );
-        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, bLoop ? aTrueStr : aFalseStr );
-        delete( new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ) );
-
-        sal_Bool bMute = false;
-        const OUString aMuteStr(  "Mute"  );
-        xPropSet->getPropertyValue( aMuteStr ) >>= bMute;
-        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aMuteStr );
-        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, bMute ? aTrueStr : aFalseStr );
-        delete( new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ) );
-
-        sal_Int16 nVolumeDB = 0;
-        const OUString aVolumeDBStr(  "VolumeDB"  );
-        xPropSet->getPropertyValue("VolumeDB") >>= nVolumeDB;
-        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aVolumeDBStr );
-        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, OUString::number( nVolumeDB ) );
-        delete( new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ) );
-
-        media::ZoomLevel eZoom;
-        const OUString aZoomStr(  "Zoom"  );
-        OUString aZoomValue;
-        xPropSet->getPropertyValue("Zoom") >>= eZoom;
-        switch( eZoom )
-        {
-            case( media::ZoomLevel_ZOOM_1_TO_4 ): aZoomValue = OUString(  "25%"  ); break;
-            case( media::ZoomLevel_ZOOM_1_TO_2 ): aZoomValue = OUString(  "50%"  ); break;
-            case( media::ZoomLevel_ORIGINAL ): aZoomValue = OUString(  "100%"  ); break;
-            case( media::ZoomLevel_ZOOM_2_TO_1 ): aZoomValue = OUString(  "200%"  ); break;
-            case( media::ZoomLevel_ZOOM_4_TO_1 ): aZoomValue = OUString(  "400%"  ); break;
-            case( media::ZoomLevel_FIT_TO_WINDOW ): aZoomValue = OUString(  "fit"  ); break;
-            case( media::ZoomLevel_FIT_TO_WINDOW_FIXED_ASPECT ): aZoomValue = OUString(  "fixedfit"  ); break;
-            case( media::ZoomLevel_FULLSCREEN ): aZoomValue = OUString(  "fullscreen"  ); break;
-
-            default:
-            break;
-        }
-
-        if( !aZoomValue.isEmpty() )
-        {
-            mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aZoomStr );
-            mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, aZoomValue );
-            delete( new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ) );
-        }
-    }
-}
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/shapeexport3.cxx b/xmloff/source/draw/shapeexport3.cxx
deleted file mode 100644
index b2d6cbb7e864..000000000000
--- a/xmloff/source/draw/shapeexport3.cxx
+++ /dev/null
@@ -1,477 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * This file is part of the LibreOffice project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * This file incorporates work covered by the following license notice:
- *
- *   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 .
- */
-
-#include <com/sun/star/drawing/HomogenMatrix.hpp>
-#include <com/sun/star/drawing/PolyPolygonShape3D.hpp>
-#include <com/sun/star/drawing/ProjectionMode.hpp>
-#include <com/sun/star/drawing/ShadeMode.hpp>
-#include <com/sun/star/drawing/Direction3D.hpp>
-#include <com/sun/star/drawing/Position3D.hpp>
-#include <com/sun/star/drawing/CameraGeometry.hpp>
-#include <com/sun/star/drawing/DoubleSequence.hpp>
-#include <tools/helpers.hxx>
-
-#include <sax/tools/converter.hxx>
-
-#include <xmloff/shapeexport.hxx>
-#include "sdpropls.hxx"
-#include <tools/debug.hxx>
-#include <rtl/ustrbuf.hxx>
-#include <xmloff/xmlexp.hxx>
-#include <xmloff/xmluconv.hxx>
-#include "xexptran.hxx"
-#include <xmloff/xmltoken.hxx>
-#include <basegfx/vector/b3dvector.hxx>
-
-#include "xmloff/xmlnmspe.hxx"
-
-using namespace ::com::sun::star;
-using namespace ::xmloff::token;
-
-void XMLShapeExport::ImpExport3DSceneShape( const uno::Reference< drawing::XShape >& xShape, XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint)
-{
-    uno::Reference< drawing::XShapes > xShapes(xShape, uno::UNO_QUERY);
-    if(xShapes.is() && xShapes->getCount())
-    {
-        uno::Reference< beans::XPropertySet > xPropSet( xShape, uno::UNO_QUERY );
-        DBG_ASSERT( xPropSet.is(), "XMLShapeExport::ImpExport3DSceneShape can't export a scene without a propertyset" );
-        if( xPropSet.is() )
-        {
-            // Transformation
-            ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
-
-            // 3d attributes
-            export3DSceneAttributes( xPropSet );
-
-            // write 3DScene shape
-            sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
-            SvXMLElementExport aOBJ( mrExport, XML_NAMESPACE_DR3D, XML_SCENE, bCreateNewline, sal_True);
-
-            ImpExportDescription( xShape ); // #i68101#
-            ImpExportEvents( xShape );
-
-            // write 3DSceneLights
-            export3DLamps( xPropSet );
-
-            // #89764# if export of position is supressed for group shape,
-            // positions of contained objects should be written relative to
-            // the upper left edge of the group.
-            awt::Point aUpperLeft;
-
-            if(!(nFeatures & SEF_EXPORT_POSITION))
-            {
-                nFeatures |= SEF_EXPORT_POSITION;
-                aUpperLeft = xShape->getPosition();
-                pRefPoint = &aUpperLeft;
-            }
-
-            // write members
-            exportShapes( xShapes, nFeatures, pRefPoint );
-        }
-    }
-}
-
-void XMLShapeExport::ImpExport3DShape(
-    const uno::Reference< drawing::XShape >& xShape,
-    XmlShapeType eShapeType, sal_Int32 /* nFeatures = SEF_DEFAULT */, awt::Point* /*pRefPoint = NULL */)
-{
-    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
-    if(xPropSet.is())
-    {
-        OUString aStr;
-        OUStringBuffer sStringBuffer;
-
-        // transformation (UNO_NAME_3D_TRANSFORM_MATRIX == "D3DTransformMatrix")
-        uno::Any aAny = xPropSet->getPropertyValue("D3DTransformMatrix");
-        drawing::HomogenMatrix xHomMat;
-        aAny >>= xHomMat;
-        SdXMLImExTransform3D aTransform;
-        aTransform.AddHomogenMatrix(xHomMat);
-        if(aTransform.NeedsAction())
-            mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_TRANSFORM, aTransform.GetExportString(mrExport.GetMM100UnitConverter()));
-
-        switch(eShapeType)
-        {
-            case XmlShapeTypeDraw3DCubeObject:
-            {
-                // write 3DCube shape
-                SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_CUBE, sal_True, sal_True);
-
-                // minEdge
-                aAny = xPropSet->getPropertyValue("D3DPosition");
-                drawing::Position3D aPosition3D;
-                aAny >>= aPosition3D;
-                ::basegfx::B3DVector aPos3D(aPosition3D.PositionX, aPosition3D.PositionY, aPosition3D.PositionZ);
-
-                // maxEdge
-                aAny = xPropSet->getPropertyValue("D3DSize");
-                drawing::Direction3D aDirection3D;
-                aAny >>= aDirection3D;
-                ::basegfx::B3DVector aDir3D(aDirection3D.DirectionX, aDirection3D.DirectionY, aDirection3D.DirectionZ);
-
-                // transform maxEdge from distance to pos
-                aDir3D = aPos3D + aDir3D;
-
-                // write minEdge
-                if(aPos3D != ::basegfx::B3DVector(-2500.0, -2500.0, -2500.0)) // write only when not default
-                {
-                    mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aPos3D);
-                    aStr = sStringBuffer.makeStringAndClear();
-                    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_MIN_EDGE, aStr);
-                }
-
-                // write maxEdge
-                if(aDir3D != ::basegfx::B3DVector(2500.0, 2500.0, 2500.0)) // write only when not default
-                {
-                    mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aDir3D);
-                    aStr = sStringBuffer.makeStringAndClear();
-                    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_MAX_EDGE, aStr);
-                }
-
-                break;
-            }
-            case XmlShapeTypeDraw3DSphereObject:
-            {
-                // write 3DSphere shape
-                SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_SPHERE, sal_True, sal_True);
-
-                // Center
-                aAny = xPropSet->getPropertyValue("D3DPosition");
-                drawing::Position3D aPosition3D;
-                aAny >>= aPosition3D;
-                ::basegfx::B3DVector aPos3D(aPosition3D.PositionX, aPosition3D.PositionY, aPosition3D.PositionZ);
-
-                // Size
-                aAny = xPropSet->getPropertyValue("D3DSize");
-                drawing::Direction3D aDirection3D;
-                aAny >>= aDirection3D;
-                ::basegfx::B3DVector aDir3D(aDirection3D.DirectionX, aDirection3D.DirectionY, aDirection3D.DirectionZ);
-
-                // write Center
-                if(aPos3D != ::basegfx::B3DVector(0.0, 0.0, 0.0)) // write only when not default
-                {
-                    mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aPos3D);
-                    aStr = sStringBuffer.makeStringAndClear();
-                    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_CENTER, aStr);
-                }
-
-                // write Size
-                if(aDir3D != ::basegfx::B3DVector(5000.0, 5000.0, 5000.0)) // write only when not default
-                {
-                    mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aDir3D);
-                    aStr = sStringBuffer.makeStringAndClear();
-                    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_SIZE, aStr);
-                }
-
-                break;
-            }
-            case XmlShapeTypeDraw3DLatheObject:
-            case XmlShapeTypeDraw3DExtrudeObject:
-            {
-                // write special 3DLathe/3DExtrude attributes
-                aAny = xPropSet->getPropertyValue("D3DPolyPolygon3D");
-                drawing::PolyPolygonShape3D xPolyPolygon3D;
-                aAny >>= xPolyPolygon3D;
-
-                // look for maximal values
-                double fXMin = 0;
-                double fXMax = 0;
-                double fYMin = 0;
-                double fYMax = 0;
-                sal_Bool bInit(sal_False);
-                sal_Int32 nOuterSequenceCount(xPolyPolygon3D.SequenceX.getLength());
-                drawing::DoubleSequence* pInnerSequenceX = xPolyPolygon3D.SequenceX.getArray();
-                drawing::DoubleSequence* pInnerSequenceY = xPolyPolygon3D.SequenceY.getArray();
-
-                sal_Int32 a;
-                for (a = 0; a < nOuterSequenceCount; a++)
-                {
-                    sal_Int32 nInnerSequenceCount(pInnerSequenceX->getLength());
-                    double* pArrayX = pInnerSequenceX->getArray();
-                    double* pArrayY = pInnerSequenceY->getArray();
-
-                    for(sal_Int32 b(0L); b < nInnerSequenceCount; b++)
-                    {
-                        double fX = *pArrayX++;
-                        double fY = *pArrayY++;
-
-                        if(bInit)
-                        {
-                            if(fX > fXMax)
-                                fXMax = fX;
-
-                            if(fX < fXMin)
-                                fXMin = fX;
-
-                            if(fY > fYMax)
-                                fYMax = fY;
-
-                            if(fY < fYMin)
-                                fYMin = fY;
-                        }
-                        else
-                        {
-                            fXMin = fXMax = fX;
-                            fYMin = fYMax = fY;
-                            bInit = sal_True;
-                        }
-                    }
-
-                    pInnerSequenceX++;
-                    pInnerSequenceY++;
-                }
-
-                // export ViewBox
-                awt::Point aMinPoint(FRound(fXMin), FRound(fYMin));
-                awt::Size aMaxSize(FRound(fXMax) - aMinPoint.X, FRound(fYMax) - aMinPoint.Y);
-                SdXMLImExViewBox aViewBox(
-                    aMinPoint.X, aMinPoint.Y, aMaxSize.Width, aMaxSize.Height);
-                mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_VIEWBOX,
-                    aViewBox.GetExportString());
-
-                // prepare svx:d element export
-                SdXMLImExSvgDElement aSvgDElement(aViewBox, GetExport());
-                pInnerSequenceX = xPolyPolygon3D.SequenceX.getArray();
-                pInnerSequenceY = xPolyPolygon3D.SequenceY.getArray();
-
-                for (a = 0; a < nOuterSequenceCount; a++)
-                {
-                    sal_Int32 nInnerSequenceCount(pInnerSequenceX->getLength());
-                    double* pArrayX = pInnerSequenceX->getArray();
-                    double* pArrayY = pInnerSequenceY->getArray();
-                    drawing::PointSequence aPoly(nInnerSequenceCount);
-                    awt::Point* pInnerSequence = aPoly.getArray();
-
-                    for(sal_Int32 b(0L); b < nInnerSequenceCount; b++)
-                    {
-                        double fX = *pArrayX++;
-                        double fY = *pArrayY++;
-
-                        *pInnerSequence = awt::Point(FRound(fX), FRound(fY));
-                        pInnerSequence++;
-                    }
-
-                    // calculate closed flag
-                    awt::Point* pFirst = aPoly.getArray();
-                    awt::Point* pLast = pFirst + (nInnerSequenceCount - 1);
-                    sal_Bool bClosed = (pFirst->X == pLast->X && pFirst->Y == pLast->Y);
-
-                    aSvgDElement.AddPolygon(&aPoly, 0L, aMinPoint,
-                        aMaxSize, bClosed);
-
-                    // #80594# corrected error in PolyPolygon3D export for 3D XML
-                    pInnerSequenceX++;
-                    pInnerSequenceY++;
-                }
-
-                // write point array
-                mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aSvgDElement.GetExportString());
-
-                if(eShapeType == XmlShapeTypeDraw3DLatheObject)
-                {
-                    // write 3DLathe shape
-                    SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_ROTATE, sal_True, sal_True);
-                }
-                else
-                {
-                    // write 3DExtrude shape
-                    SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_EXTRUDE, sal_True, sal_True);
-                }
-                break;
-            }
-            default:
-                break;
-        }
-    }
-}
-
-/** helper for chart that adds all attributes of a 3d scene element to the export */
-void XMLShapeExport::export3DSceneAttributes( const com::sun::star::uno::Reference< com::sun::star::beans::XPropertySet >& xPropSet )
-{
-    OUString aStr;
-    OUStringBuffer sStringBuffer;
-
-    // world transformation (UNO_NAME_3D_TRANSFORM_MATRIX == "D3DTransformMatrix")
-    uno::Any aAny = xPropSet->getPropertyValue("D3DTransformMatrix");
-    drawing::HomogenMatrix xHomMat;
-    aAny >>= xHomMat;
-    SdXMLImExTransform3D aTransform;
-    aTransform.AddHomogenMatrix(xHomMat);
-    if(aTransform.NeedsAction())
-        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_TRANSFORM, aTransform.GetExportString(mrExport.GetMM100UnitConverter()));
-
-    // VRP, VPN, VUP
-    aAny = xPropSet->getPropertyValue("D3DCameraGeometry");
-    drawing::CameraGeometry aCamGeo;
-    aAny >>= aCamGeo;
-
-    ::basegfx::B3DVector aVRP(aCamGeo.vrp.PositionX, aCamGeo.vrp.PositionY, aCamGeo.vrp.PositionZ);
-    if(aVRP != ::basegfx::B3DVector(0.0, 0.0, 1.0)) // write only when not default
-    {
-        mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aVRP);
-        aStr = sStringBuffer.makeStringAndClear();
-        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_VRP, aStr);
-    }
-
-    ::basegfx::B3DVector aVPN(aCamGeo.vpn.DirectionX, aCamGeo.vpn.DirectionY, aCamGeo.vpn.DirectionZ);
-    if(aVPN != ::basegfx::B3DVector(0.0, 0.0, 1.0)) // write only when not default
-    {
-        mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aVPN);
-        aStr = sStringBuffer.makeStringAndClear();
-        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_VPN, aStr);
-    }
-
-    ::basegfx::B3DVector aVUP(aCamGeo.vup.DirectionX, aCamGeo.vup.DirectionY, aCamGeo.vup.DirectionZ);
-    if(aVUP != ::basegfx::B3DVector(0.0, 1.0, 0.0)) // write only when not default
-    {
-        mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aVUP);
-        aStr = sStringBuffer.makeStringAndClear();
-        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_VUP, aStr);
-    }
-
-    // projection "D3DScenePerspective" drawing::ProjectionMode
-    aAny = xPropSet->getPropertyValue("D3DScenePerspective");
-    drawing::ProjectionMode xPrjMode;
-    aAny >>= xPrjMode;
-    if(xPrjMode == drawing::ProjectionMode_PARALLEL)
-        aStr = GetXMLToken(XML_PARALLEL);
-    else
-        aStr = GetXMLToken(XML_PERSPECTIVE);
-    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_PROJECTION, aStr);
-
-    // distance
-    aAny = xPropSet->getPropertyValue("D3DSceneDistance");
-    sal_Int32 nDistance = 0;
-    aAny >>= nDistance;
-    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
-            nDistance);
-    aStr = sStringBuffer.makeStringAndClear();
-    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_DISTANCE, aStr);
-
-    // focalLength
-    aAny = xPropSet->getPropertyValue("D3DSceneFocalLength");
-    sal_Int32 nFocalLength = 0;
-    aAny >>= nFocalLength;
-    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
-            nFocalLength);
-    aStr = sStringBuffer.makeStringAndClear();
-    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_FOCAL_LENGTH, aStr);
-
-    // shadowSlant
-    aAny = xPropSet->getPropertyValue("D3DSceneShadowSlant");
-    sal_Int16 nShadowSlant = 0;
-    aAny >>= nShadowSlant;
-    ::sax::Converter::convertNumber(sStringBuffer, (sal_Int32)nShadowSlant);
-    aStr = sStringBuffer.makeStringAndClear();
-    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_SHADOW_SLANT, aStr);
-
-    // shadeMode
-    aAny = xPropSet->getPropertyValue("D3DSceneShadeMode");
-    drawing::ShadeMode xShadeMode;
-    if(aAny >>= xShadeMode)
-    {
-        if(xShadeMode == drawing::ShadeMode_FLAT)
-            aStr = GetXMLToken(XML_FLAT);
-        else if(xShadeMode == drawing::ShadeMode_PHONG)
-            aStr = GetXMLToken(XML_PHONG);
-        else if(xShadeMode == drawing::ShadeMode_SMOOTH)
-            aStr = GetXMLToken(XML_GOURAUD);
-        else
-            aStr = GetXMLToken(XML_DRAFT);
-    }
-    else
-    {
-        // ShadeMode enum not there, write default
-        aStr = GetXMLToken(XML_GOURAUD);
-    }
-    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_SHADE_MODE, aStr);
-
-    // ambientColor
-    aAny = xPropSet->getPropertyValue("D3DSceneAmbientColor");
-    sal_Int32 nAmbientColor = 0;
-    aAny >>= nAmbientColor;
-    ::sax::Converter::convertColor(sStringBuffer, nAmbientColor);
-    aStr = sStringBuffer.makeStringAndClear();
-    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_AMBIENT_COLOR, aStr);
-
-    // lightingMode
-    aAny = xPropSet->getPropertyValue("D3DSceneTwoSidedLighting");
-    sal_Bool bTwoSidedLighting = false;
-    aAny >>= bTwoSidedLighting;
-    ::sax::Converter::convertBool(sStringBuffer, bTwoSidedLighting);
-    aStr = sStringBuffer.makeStringAndClear();
-    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_LIGHTING_MODE, aStr);
-}
-
-/** helper for chart that exports all lamps from the propertyset */
-void XMLShapeExport::export3DLamps( const com::sun::star::uno::Reference< com::sun::star::beans::XPropertySet >& xPropSet )
-{
-    // write lamps 1..8 as content
-    OUString aStr;
-    OUStringBuffer sStringBuffer;
-
-    const OUString aColorPropName("D3DSceneLightColor");
-    const OUString aDirectionPropName("D3DSceneLightDirection");
-    const OUString aLightOnPropName("D3DSceneLightOn");
-
-    OUString aPropName;
-    OUString aIndexStr;
-    ::basegfx::B3DVector aLightDirection;
-    drawing::Direction3D xLightDir;
-    sal_Bool bLightOnOff = false;
-    for(sal_Int32 nLamp = 1; nLamp <= 8; nLamp++)
-    {
-        aIndexStr = OUString::number( nLamp );
-
-        // lightcolor
-        aPropName = aColorPropName;
-        aPropName += aIndexStr;
-        sal_Int32 nLightColor = 0;
-        xPropSet->getPropertyValue( aPropName ) >>= nLightColor;
-        ::sax::Converter::convertColor(sStringBuffer, nLightColor);
-        aStr = sStringBuffer.makeStringAndClear();
-        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_DIFFUSE_COLOR, aStr);
-
-        // lightdirection
-        aPropName = aDirectionPropName;
-        aPropName += aIndexStr;
-        xPropSet->getPropertyValue(aPropName) >>= xLightDir;
-        aLightDirection = ::basegfx::B3DVector(xLightDir.DirectionX, xLightDir.DirectionY, xLightDir.DirectionZ);
-        mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aLightDirection);
-        aStr = sStringBuffer.makeStringAndClear();
-        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_DIRECTION, aStr);
-
-        // lighton
-        aPropName = aLightOnPropName;
-        aPropName += aIndexStr;
-        xPropSet->getPropertyValue(aPropName) >>= bLightOnOff;
-        ::sax::Converter::convertBool(sStringBuffer, bLightOnOff);
-        aStr = sStringBuffer.makeStringAndClear();
-        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_ENABLED, aStr);
-
-        // specular
-        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_SPECULAR,
-            nLamp == 1 ? XML_TRUE : XML_FALSE);
-
-        // write light entry
-        SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_LIGHT, sal_True, sal_True);
-    }
-}
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/shapeexport4.cxx b/xmloff/source/draw/shapeexport4.cxx
deleted file mode 100644
index 472d6ae732cd..000000000000
--- a/xmloff/source/draw/shapeexport4.cxx
+++ /dev/null
@@ -1,1314 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * This file is part of the LibreOffice project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * This file incorporates work covered by the following license notice:
- *
- *   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 .
- */
-
-#include <com/sun/star/graphic/XGraphic.hpp>
-#include <com/sun/star/graphic/GraphicProvider.hpp>
-#include <com/sun/star/graphic/XGraphicProvider.hpp>
-#include <com/sun/star/embed/ElementModes.hpp>
-#include <com/sun/star/embed/XTransactedObject.hpp>
-#include <com/sun/star/io/XSeekableInputStream.hpp>
-#include <com/sun/star/drawing/HomogenMatrix.hpp>
-#include <com/sun/star/drawing/PolyPolygonShape3D.hpp>
-#include <com/sun/star/drawing/ProjectionMode.hpp>
-#include <com/sun/star/drawing/ShadeMode.hpp>
-#include <com/sun/star/drawing/Direction3D.hpp>
-#include <com/sun/star/drawing/Position3D.hpp>
-#include <com/sun/star/drawing/CameraGeometry.hpp>
-#include <com/sun/star/drawing/DoubleSequence.hpp>
-
-#include <com/sun/star/table/XColumnRowRange.hpp>
-
-#include <sax/tools/converter.hxx>
-
-#include <xmloff/shapeexport.hxx>
-#include "sdpropls.hxx"
-#include <tools/debug.hxx>
-#include <rtl/ustrbuf.hxx>
-#include <xmloff/xmlexp.hxx>
-#include <xmloff/xmluconv.hxx>
-#include "xexptran.hxx"
-#include <xmloff/xmltoken.hxx>
-#include "EnhancedCustomShapeToken.hxx"
-#include <com/sun/star/container/XIdentifierContainer.hpp>
-#include <com/sun/star/drawing/EnhancedCustomShapeParameterType.hpp>
-#include <com/sun/star/drawing/EnhancedCustomShapeParameterPair.hpp>
-#include <com/sun/star/drawing/EnhancedCustomShapeGluePointType.hpp>
-#include <com/sun/star/drawing/EnhancedCustomShapeTextFrame.hpp>
-#include <com/sun/star/drawing/EnhancedCustomShapeSegment.hpp>
-#include <com/sun/star/drawing/EnhancedCustomShapeSegmentCommand.hpp>
-#include <com/sun/star/drawing/EnhancedCustomShapeAdjustmentValue.hpp>
-#include <com/sun/star/drawing/EnhancedCustomShapeTextPathMode.hpp>
-#include <com/sun/star/beans/PropertyValues.hpp>
-#include <rtl/math.hxx>
-#include <basegfx/vector/b3dvector.hxx>
-
-#include "xmloff/xmlnmspe.hxx"
-#include "XMLBase64Export.hxx"
-#include <comphelper/processfactory.hxx>
-
-using namespace ::com::sun::star;
-using namespace ::com::sun::star::io;
-using namespace ::xmloff::token;
-using namespace ::xmloff::EnhancedCustomShapeToken;
-
-using ::com::sun::star::embed::XStorage;
-using ::com::sun::star::uno::UNO_QUERY;
-using ::com::sun::star::uno::UNO_QUERY_THROW;
-using ::com::sun::star::uno::Reference;
-using ::com::sun::star::uno::Sequence;
-
-void ExportParameter( OUStringBuffer& rStrBuffer, const com::sun::star::drawing::EnhancedCustomShapeParameter& rParameter )
-{
-    if ( !rStrBuffer.isEmpty() )
-        rStrBuffer.append( (sal_Unicode)' ' );
-    if ( rParameter.Value.getValueTypeClass() == uno::TypeClass_DOUBLE )
-    {
-        double fNumber = 0.0;
-        rParameter.Value >>= fNumber;
-        ::rtl::math::doubleToUStringBuffer( rStrBuffer, fNumber, rtl_math_StringFormat_Automatic, rtl_math_DecimalPlaces_Max, '.', sal_True );
-    }
-    else
-    {
-        sal_Int32 nValue = 0;
-        rParameter.Value >>= nValue;
-
-        switch( rParameter.Type )
-        {
-            case com::sun::star::drawing::EnhancedCustomShapeParameterType::EQUATION :
-            {
-                rStrBuffer.append( "?f" + OUString::number( nValue ) );
-            }
-            break;
-
-            case com::sun::star::drawing::EnhancedCustomShapeParameterType::ADJUSTMENT :
-            {
-                rStrBuffer.append( (sal_Unicode)'$' );
-                rStrBuffer.append( OUString::number( nValue ) );
-            }
-            break;
-
-            case com::sun::star::drawing::EnhancedCustomShapeParameterType::BOTTOM :
-                rStrBuffer.append( GetXMLToken( XML_BOTTOM ) ); break;
-            case com::sun::star::drawing::EnhancedCustomShapeParameterType::RIGHT :
-                rStrBuffer.append( GetXMLToken( XML_RIGHT ) ); break;
-            case com::sun::star::drawing::EnhancedCustomShapeParameterType::TOP :
-                rStrBuffer.append( GetXMLToken( XML_TOP ) ); break;
-            case com::sun::star::drawing::EnhancedCustomShapeParameterType::LEFT :
-                rStrBuffer.append( GetXMLToken( XML_LEFT ) ); break;
-            case com::sun::star::drawing::EnhancedCustomShapeParameterType::XSTRETCH :
-                rStrBuffer.append( GetXMLToken( XML_XSTRETCH ) ); break;
-            case com::sun::star::drawing::EnhancedCustomShapeParameterType::YSTRETCH :
-                rStrBuffer.append( GetXMLToken( XML_YSTRETCH ) ); break;
-            case com::sun::star::drawing::EnhancedCustomShapeParameterType::HASSTROKE :
-                rStrBuffer.append( GetXMLToken( XML_HASSTROKE ) ); break;
-            case com::sun::star::drawing::EnhancedCustomShapeParameterType::HASFILL :
-                rStrBuffer.append( GetXMLToken( XML_HASFILL ) ); break;
-            case com::sun::star::drawing::EnhancedCustomShapeParameterType::WIDTH :
-                rStrBuffer.append( GetXMLToken( XML_WIDTH ) ); break;
-            case com::sun::star::drawing::EnhancedCustomShapeParameterType::HEIGHT :
-                rStrBuffer.append( GetXMLToken( XML_HEIGHT ) ); break;
-            case com::sun::star::drawing::EnhancedCustomShapeParameterType::LOGWIDTH :
-                rStrBuffer.append( GetXMLToken( XML_LOGWIDTH ) ); break;
-            case com::sun::star::drawing::EnhancedCustomShapeParameterType::LOGHEIGHT :
-                rStrBuffer.append( GetXMLToken( XML_LOGHEIGHT ) ); break;
-            default :
-                rStrBuffer.append( OUString::number( nValue ) );
-        }
-    }
-}
-
-void ImpExportEquations( SvXMLExport& rExport, const uno::Sequence< OUString >& rEquations )
-{
-    sal_Int32 i;
-    for ( i = 0; i < rEquations.getLength(); i++ )
-    {
-        OUString aStr(static_cast<sal_Unicode>('f'));
-        aStr += OUString::number( i );
-        rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aStr );
-
-        aStr = rEquations[ i ];
-        sal_Int32 nIndex = 0;
-        do
-        {
-            nIndex = aStr.indexOf( (sal_Unicode)'?', nIndex );
-            if ( nIndex != -1 )
-            {
-                OUString aNew( aStr.copy( 0, nIndex + 1 ) );
-                aNew += OUString(static_cast<sal_Unicode>('f'));
-                aNew += aStr.copy( nIndex + 1, ( aStr.getLength() - nIndex ) - 1 );
-                aStr = aNew;
-                nIndex++;
-            }
-        } while( nIndex != -1 );
-        rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_FORMULA, aStr );
-        SvXMLElementExport aOBJ( rExport, XML_NAMESPACE_DRAW, XML_EQUATION, sal_True, sal_True );
-    }
-}
-
-void ImpExportHandles( SvXMLExport& rExport, const uno::Sequence< beans::PropertyValues >& rHandles )
-{
-    sal_uInt32 i, j, nElements = rHandles.getLength();
-    if ( nElements )
-    {
-        OUString       aStr;
-        OUStringBuffer aStrBuffer;
-
-        for ( i = 0; i < nElements; i++ )
-        {
-            sal_Bool bPosition = sal_False;
-            const uno::Sequence< beans::PropertyValue >& rPropSeq = rHandles[ i ];
-            for ( j = 0; j < (sal_uInt32)rPropSeq.getLength(); j++ )
-            {
-                const beans::PropertyValue& rPropVal = rPropSeq[ j ];
-                switch( EASGet( rPropVal.Name ) )
-                {
-                    case EAS_Position :
-                    {
-                        com::sun::star::drawing::EnhancedCustomShapeParameterPair aPosition;
-                        if ( rPropVal.Value >>= aPosition )
-                        {
-                            ExportParameter( aStrBuffer, aPosition.First );
-                            ExportParameter( aStrBuffer, aPosition.Second );
-                            aStr = aStrBuffer.makeStringAndClear();
-                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_POSITION, aStr );
-                            bPosition = sal_True;
-                        }
-                    }
-                    break;
-                    case EAS_MirroredX :
-                    {
-                        sal_Bool bMirroredX = sal_Bool();
-                        if ( rPropVal.Value >>= bMirroredX )
-                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_MIRROR_HORIZONTAL,
-                                bMirroredX ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
-                    }
-                    break;
-                    case EAS_MirroredY :
-                    {
-                        sal_Bool bMirroredY = sal_Bool();
-                        if ( rPropVal.Value >>= bMirroredY )
-                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_MIRROR_VERTICAL,
-                                bMirroredY ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
-                    }
-                    break;
-                    case EAS_Switched :
-                    {
-                        sal_Bool bSwitched = sal_Bool();
-                        if ( rPropVal.Value >>= bSwitched )
-                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_SWITCHED,
-                                bSwitched ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
-                    }
-                    break;
-                    case EAS_Polar :
-                    {
-                        com::sun::star::drawing::EnhancedCustomShapeParameterPair aPolar;
-                        if ( rPropVal.Value >>= aPolar )
-                        {
-                            ExportParameter( aStrBuffer, aPolar.First );
-                            ExportParameter( aStrBuffer, aPolar.Second );
-                            aStr = aStrBuffer.makeStringAndClear();
-                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_POLAR, aStr );
-                        }
-                    }
-                    break;
-                    case EAS_RadiusRangeMinimum :
-                    {
-                        com::sun::star::drawing::EnhancedCustomShapeParameter aRadiusRangeMinimum;
-                        if ( rPropVal.Value >>= aRadiusRangeMinimum )
-                        {
-                            ExportParameter( aStrBuffer, aRadiusRangeMinimum );
-                            aStr = aStrBuffer.makeStringAndClear();
-                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RADIUS_RANGE_MINIMUM, aStr );
-                        }
-                    }
-                    break;
-                    case EAS_RadiusRangeMaximum :
-                    {
-                        com::sun::star::drawing::EnhancedCustomShapeParameter aRadiusRangeMaximum;
-                        if ( rPropVal.Value >>= aRadiusRangeMaximum )
-                        {
-                            ExportParameter( aStrBuffer, aRadiusRangeMaximum );
-                            aStr = aStrBuffer.makeStringAndClear();
-                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RADIUS_RANGE_MAXIMUM, aStr );
-                        }
-                    }
-                    break;
-                    case EAS_RangeXMinimum :
-                    {
-                        com::sun::star::drawing::EnhancedCustomShapeParameter aXRangeMinimum;
-                        if ( rPropVal.Value >>= aXRangeMinimum )
-                        {
-                            ExportParameter( aStrBuffer, aXRangeMinimum );
-                            aStr = aStrBuffer.makeStringAndClear();
-                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_X_MINIMUM, aStr );
-                        }
-                    }
-                    break;
-                    case EAS_RangeXMaximum :
-                    {
-                        com::sun::star::drawing::EnhancedCustomShapeParameter aXRangeMaximum;
-                        if ( rPropVal.Value >>= aXRangeMaximum )
-                        {
-                            ExportParameter( aStrBuffer, aXRangeMaximum );
-                            aStr = aStrBuffer.makeStringAndClear();
-                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_X_MAXIMUM, aStr );
-                        }
-                    }
-                    break;
-                    case EAS_RangeYMinimum :
-                    {
-                        com::sun::star::drawing::EnhancedCustomShapeParameter aYRangeMinimum;
-                        if ( rPropVal.Value >>= aYRangeMinimum )
-                        {
-                            ExportParameter( aStrBuffer, aYRangeMinimum );
-                            aStr = aStrBuffer.makeStringAndClear();
-                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_Y_MINIMUM, aStr );
-                        }
-                    }
-                    break;
-                    case EAS_RangeYMaximum :
-                    {
-                        com::sun::star::drawing::EnhancedCustomShapeParameter aYRangeMaximum;
-                        if ( rPropVal.Value >>= aYRangeMaximum )
-                        {
-                            ExportParameter( aStrBuffer, aYRangeMaximum );
-                            aStr = aStrBuffer.makeStringAndClear();
-                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_Y_MAXIMUM, aStr );
-                        }
-                    }
-                    break;
-                    default:
-                        break;
-                }
-            }
-            if ( bPosition )
-                SvXMLElementExport aOBJ( rExport, XML_NAMESPACE_DRAW, XML_HANDLE, sal_True, sal_True );
-            else
-                rExport.ClearAttrList();
-        }
-    }
-}
-
-void ImpExportEnhancedPath( SvXMLExport& rExport,
-                            const uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair >& rCoordinates,
-                            const uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeSegment >& rSegments,
-                            bool bExtended = false )
-{
-
-    OUString       aStr;
-    OUStringBuffer aStrBuffer;
-    bool bNeedExtended = false;
-
-    sal_Int32 i, j, k, l;
-
-    sal_Int32 nCoords = rCoordinates.getLength();
-    sal_Int32 nSegments = rSegments.getLength();
-    sal_Bool bSimpleSegments = nSegments == 0;
-    if ( bSimpleSegments )
-        nSegments = 4;
-    for ( j = i = 0; j < nSegments; j++ )
-    {
-        com::sun::star::drawing::EnhancedCustomShapeSegment aSegment;
-        if ( bSimpleSegments )
-        {
-            // if there are not enough segments we will default them
-            switch( j )
-            {
-                case 0 :
-                {
-                    aSegment.Count = 1;
-                    aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::MOVETO;
-                }
-                break;
-                case 1 :
-                {
-                    aSegment.Count = (sal_Int16)std::min( nCoords - 1, (sal_Int32)32767 );
-                    aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LINETO;
-                }
-                break;
-                case 2 :
-                {
-                    aSegment.Count = 1;
-                    aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOSESUBPATH;
-                }
-                break;
-                case 3 :
-                {
-                    aSegment.Count = 1;
-                    aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ENDSUBPATH;
-                }
-                break;
-            }
-        }
-        else
-            aSegment = rSegments[ j ];
-
-        if ( !aStrBuffer.isEmpty() )
-            aStrBuffer.append( (sal_Unicode)' ' );
-
-        sal_Int32 nParameter = 0;
-        switch( aSegment.Command )
-        {
-            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOSESUBPATH :
-                aStrBuffer.append( (sal_Unicode)'Z' ); break;
-            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ENDSUBPATH :
-                aStrBuffer.append( (sal_Unicode)'N' ); break;
-            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::NOFILL :
-                aStrBuffer.append( (sal_Unicode)'F' ); break;
-            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::NOSTROKE :
-                aStrBuffer.append( (sal_Unicode)'S' ); break;
-
-            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::MOVETO :
-                aStrBuffer.append( (sal_Unicode)'M' ); nParameter = 1; break;
-            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LINETO :
-                aStrBuffer.append( (sal_Unicode)'L' ); nParameter = 1; break;
-            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CURVETO :
-                aStrBuffer.append( (sal_Unicode)'C' ); nParameter = 3; break;
-            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSETO :
-                aStrBuffer.append( (sal_Unicode)'T' ); nParameter = 3; break;
-            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSE :
-                aStrBuffer.append( (sal_Unicode)'U' ); nParameter = 3; break;
-            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ARCTO :
-                aStrBuffer.append( (sal_Unicode)'A' ); nParameter = 4; break;
-            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ARC :
-                aStrBuffer.append( (sal_Unicode)'B' ); nParameter = 4; break;
-            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARCTO :
-                aStrBuffer.append( (sal_Unicode)'W' ); nParameter = 4; break;
-            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARC :
-                aStrBuffer.append( (sal_Unicode)'V' ); nParameter = 4; break;
-            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTX :
-                aStrBuffer.append( (sal_Unicode)'X' ); nParameter = 1; break;
-            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTY :
-                aStrBuffer.append( (sal_Unicode)'Y' ); nParameter = 1; break;
-            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::QUADRATICCURVETO :
-                aStrBuffer.append( (sal_Unicode)'Q' ); nParameter = 2; break;
-            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ARCANGLETO :
-                if ( bExtended ) {
-                    aStrBuffer.append( (sal_Unicode)'G' );
-                    nParameter = 2;
-                } else {
-                    aStrBuffer.setLength( aStrBuffer.getLength() - 1);
-                    bNeedExtended = true;
-                    i += 2;
-                }
-                break;
-            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::DARKEN :
-                if ( bExtended )
-                    aStrBuffer.append( (sal_Unicode)'H' );
-                else
-                    bNeedExtended = true;
-                break;
-            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::DARKENLESS :
-                if ( bExtended )
-                    aStrBuffer.append( (sal_Unicode)'I' );
-                else
-                    bNeedExtended = true;
-                break;
-            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LIGHTEN :
-                if ( bExtended )
-                    aStrBuffer.append( (sal_Unicode)'J' );
-                else
-                    bNeedExtended = true;
-                break;
-            case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LIGHTENLESS :
-                if ( bExtended )
-                    aStrBuffer.append( (sal_Unicode)'K' );
-                else
-                    bNeedExtended = true;
-                break;
-            default : // ups, seems to be something wrong
-            {
-                aSegment.Count = 1;
-                aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LINETO;
-            }
-            break;
-        }
-        if ( nParameter )
-        {
-            for ( k = 0; k < aSegment.Count; k++ )
-            {
-                if ( ( i + nParameter ) <= nCoords )
-                {
-                    for ( l = 0; l < nParameter; l++ )
-                    {
-                        ExportParameter( aStrBuffer, rCoordinates[ i ].First );
-                        ExportParameter( aStrBuffer, rCoordinates[ i++ ].Second );
-                    }
-                }
-                else
-                {
-                    j = nSegments;  // error -> exiting
-                    break;
-                }
-            }
-        }
-    }
-    aStr = aStrBuffer.makeStringAndClear();
-    rExport.AddAttribute( bExtended ? XML_NAMESPACE_DRAW_EXT : XML_NAMESPACE_DRAW, XML_ENHANCED_PATH, aStr );
-    if ( !bExtended && bNeedExtended )
-        ImpExportEnhancedPath( rExport, rCoordinates, rSegments, true );
-}
-
-void ImpExportEnhancedGeometry( SvXMLExport& rExport, const uno::Reference< beans::XPropertySet >& xPropSet )
-{
-    sal_Bool bEquations = sal_False;
-    uno::Sequence< OUString > aEquations;
-
-    sal_Bool bHandles = sal_False;
-    uno::Sequence< beans::PropertyValues > aHandles;
-
-    sal_Bool bCoordinates = sal_False;
-    uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeSegment > aSegments;
-    uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair > aCoordinates;
-
-    uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue > aAdjustmentValues;
-
-    OUString       aStr;
-    OUStringBuffer aStrBuffer;
-    SvXMLUnitConverter& rUnitConverter = rExport.GetMM100UnitConverter();
-
-    uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
-
-    // geometry
-    const OUString sCustomShapeGeometry( "CustomShapeGeometry" );
-    if ( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName( sCustomShapeGeometry ) )
-    {
-        uno::Any aGeoPropSet( xPropSet->getPropertyValue( sCustomShapeGeometry ) );
-        uno::Sequence< beans::PropertyValue > aGeoPropSeq;
-
-        if ( aGeoPropSet >>= aGeoPropSeq )
-        {
-            const OUString sCustomShapeType( "non-primitive" );
-            OUString aCustomShapeType( sCustomShapeType );
-
-            sal_Int32 j, nGeoPropCount = aGeoPropSeq.getLength();
-            for ( j = 0; j < nGeoPropCount; j++ )
-            {
-                const beans::PropertyValue& rGeoProp = aGeoPropSeq[ j ];
-                switch( EASGet( rGeoProp.Name ) )
-                {
-                    case EAS_Type :
-                    {
-                        rGeoProp.Value >>= aCustomShapeType;
-                    }
-                    break;
-                    case EAS_MirroredX :
-                    {
-                        sal_Bool bMirroredX = sal_Bool();
-                        if ( rGeoProp.Value >>= bMirroredX )
-                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIRROR_HORIZONTAL,
-                                bMirroredX ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
-                    }
-                    break;
-                    case EAS_MirroredY :
-                    {
-                        sal_Bool bMirroredY = sal_Bool();
-                        if ( rGeoProp.Value >>= bMirroredY )
-                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIRROR_VERTICAL,
-                                bMirroredY ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
-                    }
-                    break;
-                    case EAS_ViewBox :
-                    {
-                        awt::Rectangle aRect;
-                        if ( rGeoProp.Value >>= aRect )
-                        {
-                            SdXMLImExViewBox aViewBox( aRect.X, aRect.Y, aRect.Width, aRect.Height );
-                            rExport.AddAttribute( XML_NAMESPACE_SVG, XML_VIEWBOX, aViewBox.GetExportString() );
-                        }
-                    }
-                    break;
-                    case EAS_TextRotateAngle :
-                    {
-                        double fTextRotateAngle = 0;
-                        if ( rGeoProp.Value >>= fTextRotateAngle )
-                        {
-                            ::sax::Converter::convertDouble(
-                                    aStrBuffer, fTextRotateAngle );
-                            aStr = aStrBuffer.makeStringAndClear();
-                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_ROTATE_ANGLE, aStr );
-                        }
-                    }
-                    break;
-                    case EAS_Extrusion :
-                    {
-                        uno::Sequence< beans::PropertyValue > aExtrusionPropSeq;
-                        if ( rGeoProp.Value >>= aExtrusionPropSeq )
-                        {
-                            sal_Int32 i, nCount = aExtrusionPropSeq.getLength();
-                            for ( i = 0; i < nCount; i++ )
-                            {
-                                const beans::PropertyValue& rProp = aExtrusionPropSeq[ i ];
-                                switch( EASGet( rProp.Name ) )
-                                {
-                                    case EAS_Extrusion :
-                                    {
-                                        sal_Bool bExtrusionOn = sal_Bool();
-                                        if ( rProp.Value >>= bExtrusionOn )
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION,
-                                                bExtrusionOn ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
-                                    }
-                                    break;
-                                    case EAS_Brightness :
-                                    {
-                                        double fExtrusionBrightness = 0;
-                                        if ( rProp.Value >>= fExtrusionBrightness )
-                                        {
-                                            ::sax::Converter::convertDouble(
-                                                aStrBuffer,
-                                                fExtrusionBrightness,
-                                                false,
-                                                util::MeasureUnit::PERCENT,
-                                                util::MeasureUnit::PERCENT);
-                                            aStrBuffer.append( (sal_Unicode)'%' );
-                                            aStr = aStrBuffer.makeStringAndClear();
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_BRIGHTNESS, aStr );
-                                        }
-                                    }
-                                    break;
-                                    case EAS_Depth :
-                                    {
-                                        com::sun::star::drawing::EnhancedCustomShapeParameterPair aDepthParaPair;
-                                        if ( rProp.Value >>= aDepthParaPair )
-                                        {
-                                            double fDepth = 0;
-                                            if ( aDepthParaPair.First.Value >>= fDepth )
-                                            {
-                                                rExport.GetMM100UnitConverter().convertDouble( aStrBuffer, fDepth, sal_True );
-                                                ExportParameter( aStrBuffer, aDepthParaPair.Second );
-                                                aStr = aStrBuffer.makeStringAndClear();
-                                                rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_DEPTH, aStr );
-                                            }
-                                        }
-                                    }
-                                    break;
-                                    case EAS_Diffusion :
-                                    {
-                                        double fExtrusionDiffusion = 0;
-                                        if ( rProp.Value >>= fExtrusionDiffusion )
-                                        {
-                                            ::sax::Converter::convertDouble(
-                                                aStrBuffer,
-                                                fExtrusionDiffusion,
-                                                false,
-                                                util::MeasureUnit::PERCENT,
-                                                util::MeasureUnit::PERCENT);
-                                            aStrBuffer.append( (sal_Unicode)'%' );
-                                            aStr = aStrBuffer.makeStringAndClear();
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_DIFFUSION, aStr );
-                                        }
-                                    }
-                                    break;
-                                    case EAS_NumberOfLineSegments :
-                                    {
-                                        sal_Int32 nExtrusionNumberOfLineSegments = 0;
-                                        if ( rProp.Value >>= nExtrusionNumberOfLineSegments )
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_NUMBER_OF_LINE_SEGMENTS, OUString::number( nExtrusionNumberOfLineSegments ) );
-                                    }
-                                    break;
-                                    case EAS_LightFace :
-                                    {
-                                        sal_Bool bExtrusionLightFace = sal_Bool();
-                                        if ( rProp.Value >>= bExtrusionLightFace )
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_LIGHT_FACE,
-                                                bExtrusionLightFace ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
-                                    }
-                                    break;
-                                    case EAS_FirstLightHarsh :
-                                    {
-                                        sal_Bool bExtrusionFirstLightHarsh = sal_Bool();
-                                        if ( rProp.Value >>= bExtrusionFirstLightHarsh )
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_FIRST_LIGHT_HARSH,
-                                                bExtrusionFirstLightHarsh ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
-                                    }
-                                    break;
-                                    case EAS_SecondLightHarsh :
-                                    {
-                                        sal_Bool bExtrusionSecondLightHarsh = sal_Bool();
-                                        if ( rProp.Value >>= bExtrusionSecondLightHarsh )
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SECOND_LIGHT_HARSH,
-                                                bExtrusionSecondLightHarsh ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
-                                    }
-                                    break;
-                                    case EAS_FirstLightLevel :
-                                    {
-                                        double fExtrusionFirstLightLevel = 0;
-                                        if ( rProp.Value >>= fExtrusionFirstLightLevel )
-                                        {
-                                            ::sax::Converter::convertDouble(
-                                                aStrBuffer,
-                                                fExtrusionFirstLightLevel,
-                                                false,
-                                                util::MeasureUnit::PERCENT,
-                                                util::MeasureUnit::PERCENT);
-                                            aStrBuffer.append( (sal_Unicode)'%' );
-                                            aStr = aStrBuffer.makeStringAndClear();
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_FIRST_LIGHT_LEVEL, aStr );
-                                        }
-                                    }
-                                    break;
-                                    case EAS_SecondLightLevel :
-                                    {
-                                        double fExtrusionSecondLightLevel = 0;
-                                        if ( rProp.Value >>= fExtrusionSecondLightLevel )
-                                        {
-                                            ::sax::Converter::convertDouble(
-                                                aStrBuffer,
-                                                fExtrusionSecondLightLevel,
-                                                false,
-                                                util::MeasureUnit::PERCENT,
-                                                util::MeasureUnit::PERCENT);
-                                            aStrBuffer.append( (sal_Unicode)'%' );
-                                            aStr = aStrBuffer.makeStringAndClear();
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SECOND_LIGHT_LEVEL, aStr );
-                                        }
-                                    }
-                                    break;
-                                    case EAS_FirstLightDirection :
-                                    {
-                                        drawing::Direction3D aExtrusionFirstLightDirection;
-                                        if ( rProp.Value >>= aExtrusionFirstLightDirection )
-                                        {
-                                            ::basegfx::B3DVector aVec3D( aExtrusionFirstLightDirection.DirectionX, aExtrusionFirstLightDirection.DirectionY,
-                                                aExtrusionFirstLightDirection.DirectionZ );
-                                            rUnitConverter.convertB3DVector( aStrBuffer, aVec3D );
-                                            aStr = aStrBuffer.makeStringAndClear();
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_FIRST_LIGHT_DIRECTION, aStr );
-                                        }
-                                    }
-                                    break;
-                                    case EAS_SecondLightDirection :
-                                    {
-                                        drawing::Direction3D aExtrusionSecondLightDirection;
-                                        if ( rProp.Value >>= aExtrusionSecondLightDirection )
-                                        {
-                                            ::basegfx::B3DVector aVec3D( aExtrusionSecondLightDirection.DirectionX, aExtrusionSecondLightDirection.DirectionY,
-                                                aExtrusionSecondLightDirection.DirectionZ );
-                                            rUnitConverter.convertB3DVector( aStrBuffer, aVec3D );
-                                            aStr = aStrBuffer.makeStringAndClear();
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SECOND_LIGHT_DIRECTION, aStr );
-                                        }
-                                    }
-                                    break;
-                                    case EAS_Metal :
-                                    {
-                                        sal_Bool bExtrusionMetal = sal_Bool();
-                                        if ( rProp.Value >>= bExtrusionMetal )
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_METAL,
-                                                bExtrusionMetal ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
-                                    }
-                                    break;
-                                    case EAS_ShadeMode :
-                                    {
-                                        // shadeMode
-                                        drawing::ShadeMode eShadeMode;
-                                        if( rProp.Value >>= eShadeMode )
-                                        {
-                                            if( eShadeMode == drawing::ShadeMode_FLAT )
-                                                aStr = GetXMLToken( XML_FLAT );
-                                            else if( eShadeMode == drawing::ShadeMode_PHONG )
-                                                aStr = GetXMLToken( XML_PHONG );
-                                            else if( eShadeMode == drawing::ShadeMode_SMOOTH )
-                                                aStr = GetXMLToken( XML_GOURAUD );
-                                            else
-                                                aStr = GetXMLToken( XML_DRAFT );
-                                        }
-                                        else
-                                        {
-                                            // ShadeMode enum not there, write default
-                                            aStr = GetXMLToken( XML_FLAT);
-                                        }
-                                        rExport.AddAttribute( XML_NAMESPACE_DR3D, XML_SHADE_MODE, aStr );
-                                    }
-                                    break;
-                                    case EAS_RotateAngle :
-                                    {
-                                        com::sun::star::drawing::EnhancedCustomShapeParameterPair aRotateAngleParaPair;
-                                        if ( rProp.Value >>= aRotateAngleParaPair )
-                                        {
-                                            ExportParameter( aStrBuffer, aRotateAngleParaPair.First );
-                                            ExportParameter( aStrBuffer, aRotateAngleParaPair.Second );
-                                            aStr = aStrBuffer.makeStringAndClear();
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ROTATION_ANGLE, aStr );
-                                        }
-                                    }
-                                    break;
-                                    case EAS_RotationCenter :
-                                    {
-                                        drawing::Direction3D aExtrusionRotationCenter;
-                                        if ( rProp.Value >>= aExtrusionRotationCenter )
-                                        {
-                                            ::basegfx::B3DVector aVec3D( aExtrusionRotationCenter.DirectionX, aExtrusionRotationCenter.DirectionY,
-                                                aExtrusionRotationCenter.DirectionZ );
-                                            rUnitConverter.convertB3DVector( aStrBuffer, aVec3D );
-                                            aStr = aStrBuffer.makeStringAndClear();
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ROTATION_CENTER, aStr );
-                                        }
-                                    }
-                                    break;
-                                    case EAS_Shininess :
-                                    {
-                                        double fExtrusionShininess = 0;
-                                        if ( rProp.Value >>= fExtrusionShininess )
-                                        {
-                                            ::sax::Converter::convertDouble(
-                                                aStrBuffer,
-                                                fExtrusionShininess,
-                                                false,
-                                                util::MeasureUnit::PERCENT,
-                                                util::MeasureUnit::PERCENT);
-                                            aStrBuffer.append( (sal_Unicode)'%' );
-                                            aStr = aStrBuffer.makeStringAndClear();
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SHININESS, aStr );
-                                        }
-                                    }
-                                    break;
-                                    case EAS_Skew :
-                                    {
-                                        com::sun::star::drawing::EnhancedCustomShapeParameterPair aSkewParaPair;
-                                        if ( rProp.Value >>= aSkewParaPair )
-                                        {
-                                            ExportParameter( aStrBuffer, aSkewParaPair.First );
-                                            ExportParameter( aStrBuffer, aSkewParaPair.Second );
-                                            aStr = aStrBuffer.makeStringAndClear();
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SKEW, aStr );
-                                        }
-                                    }
-                                    break;
-                                    case EAS_Specularity :
-                                    {
-                                        double fExtrusionSpecularity = 0;
-                                        if ( rProp.Value >>= fExtrusionSpecularity )
-                                        {
-                                            ::sax::Converter::convertDouble(
-                                                aStrBuffer,
-                                                fExtrusionSpecularity,
-                                                false,
-                                                util::MeasureUnit::PERCENT,
-                                                util::MeasureUnit::PERCENT);
-                                            aStrBuffer.append( (sal_Unicode)'%' );
-                                            aStr = aStrBuffer.makeStringAndClear();
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SPECULARITY, aStr );
-                                        }
-                                    }
-                                    break;
-                                    case EAS_ProjectionMode :
-                                    {
-                                        drawing::ProjectionMode eProjectionMode;
-                                        if ( rProp.Value >>= eProjectionMode )
-                                            rExport.AddAttribute( XML_NAMESPACE_DR3D, XML_PROJECTION,
-                                                eProjectionMode == drawing::ProjectionMode_PARALLEL ? GetXMLToken( XML_PARALLEL ) : GetXMLToken( XML_PERSPECTIVE ) );
-                                    }
-                                    break;
-                                    case EAS_ViewPoint :
-                                    {
-                                        drawing::Position3D aExtrusionViewPoint;
-                                        if ( rProp.Value >>= aExtrusionViewPoint )
-                                        {
-                                            rUnitConverter.convertPosition3D( aStrBuffer, aExtrusionViewPoint );
-                                            aStr = aStrBuffer.makeStringAndClear();
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_VIEWPOINT, aStr );
-                                        }
-                                    }
-                                    break;
-                                    case EAS_Origin :
-                                    {
-                                        com::sun::star::drawing::EnhancedCustomShapeParameterPair aOriginParaPair;
-                                        if ( rProp.Value >>= aOriginParaPair )
-                                        {
-                                            ExportParameter( aStrBuffer, aOriginParaPair.First );
-                                            ExportParameter( aStrBuffer, aOriginParaPair.Second );
-                                            aStr = aStrBuffer.makeStringAndClear();
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ORIGIN, aStr );
-                                        }
-                                    }
-                                    break;
-                                    case EAS_Color :
-                                    {
-                                        sal_Bool bExtrusionColor = sal_Bool();
-                                        if ( rProp.Value >>= bExtrusionColor )
-                                        {
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_COLOR,
-                                                bExtrusionColor ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
-                                        }
-                                    }
-                                    break;
-                                    default:
-                                        break;
-                                }
-                            }
-                        }
-                    }
-                    break;
-                    case EAS_TextPath :
-                    {
-                        uno::Sequence< beans::PropertyValue > aTextPathPropSeq;
-                        if ( rGeoProp.Value >>= aTextPathPropSeq )
-                        {
-                            sal_Int32 i, nCount = aTextPathPropSeq.getLength();
-                            for ( i = 0; i < nCount; i++ )
-                            {
-                                const beans::PropertyValue& rProp = aTextPathPropSeq[ i ];
-                                switch( EASGet( rProp.Name ) )
-                                {
-                                    case EAS_TextPath :
-                                    {
-                                        sal_Bool bTextPathOn = sal_Bool();
-                                        if ( rProp.Value >>= bTextPathOn )
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH,
-                                                bTextPathOn ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
-                                    }
-                                    break;
-                                    case EAS_TextPathMode :
-                                    {
-                                        com::sun::star::drawing::EnhancedCustomShapeTextPathMode eTextPathMode;
-                                        if ( rProp.Value >>= eTextPathMode )
-                                        {
-                                            switch ( eTextPathMode )
-                                            {
-                                                case com::sun::star::drawing::EnhancedCustomShapeTextPathMode_NORMAL: aStr = GetXMLToken( XML_NORMAL ); break;
-                                                case com::sun::star::drawing::EnhancedCustomShapeTextPathMode_PATH  : aStr = GetXMLToken( XML_PATH );   break;
-                                                case com::sun::star::drawing::EnhancedCustomShapeTextPathMode_SHAPE : aStr = GetXMLToken( XML_SHAPE );  break;
-                                                default:
-                                                    break;
-                                            }
-                                            if ( !aStr.isEmpty() )
-                                                rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_MODE, aStr );
-                                        }
-                                    }
-                                    break;
-                                    case EAS_ScaleX :
-                                    {
-                                        sal_Bool bScaleX = sal_Bool();
-                                        if ( rProp.Value >>= bScaleX )
-                                        {
-                                            aStr = bScaleX ? GetXMLToken( XML_SHAPE ) : GetXMLToken( XML_PATH );
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_SCALE, aStr );
-                                        }
-                                    }
-                                    break;
-                                    case EAS_SameLetterHeights :
-                                    {
-                                        sal_Bool bSameLetterHeights = sal_Bool();
-                                        if ( rProp.Value >>= bSameLetterHeights )
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_SAME_LETTER_HEIGHTS,
-                                                bSameLetterHeights ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
-                                    }
-                                    break;
-                                    default:
-                                        break;
-                                }
-                            }
-                        }
-                    }
-                    break;
-                    case EAS_Path :
-                    {
-                        uno::Sequence< beans::PropertyValue > aPathPropSeq;
-                        if ( rGeoProp.Value >>= aPathPropSeq )
-                        {
-                            sal_Int32 i, nCount = aPathPropSeq.getLength();
-                            for ( i = 0; i < nCount; i++ )
-                            {
-                                const beans::PropertyValue& rProp = aPathPropSeq[ i ];
-
-                                switch( EASGet( rProp.Name ) )
-                                {
-                                    case EAS_SubViewSize:
-                                    {
-                                        uno::Sequence< awt::Size > aSubViewSizes;
-                                        rProp.Value >>= aSubViewSizes;
-
-                                        for ( int nIdx = 0; nIdx < aSubViewSizes.getLength(); nIdx++ )
-                                        {
-                                            if ( nIdx )
-                                                aStrBuffer.append(' ');
-                                            ::sax::Converter::convertNumber( aStrBuffer, aSubViewSizes[nIdx].Width );
-                                            aStrBuffer.append(' ');
-                                            ::sax::Converter::convertNumber( aStrBuffer, aSubViewSizes[nIdx].Height );
-                                        }
-                                        aStr = aStrBuffer.makeStringAndClear();
-                                        rExport.AddAttribute( XML_NAMESPACE_DRAW_EXT, XML_SUB_VIEW_SIZE, aStr );
-                                    }
-                                    break;
-                                    case EAS_ExtrusionAllowed :
-                                    {
-                                        sal_Bool bExtrusionAllowed = sal_Bool();
-                                        if ( rProp.Value >>= bExtrusionAllowed )
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ALLOWED,
-                                                bExtrusionAllowed ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
-                                    }
-                                    break;
-                                    case EAS_ConcentricGradientFillAllowed :
-                                    {
-                                        sal_Bool bConcentricGradientFillAllowed = sal_Bool();
-                                        if ( rProp.Value >>= bConcentricGradientFillAllowed )
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CONCENTRIC_GRADIENT_FILL_ALLOWED,
-                                                bConcentricGradientFillAllowed ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
-                                    }
-                                    break;
-                                    case EAS_TextPathAllowed  :
-                                    {
-                                        sal_Bool bTextPathAllowed = sal_Bool();
-                                        if ( rProp.Value >>= bTextPathAllowed )
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_ALLOWED,
-                                                bTextPathAllowed ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
-                                    }
-                                    break;
-                                    case EAS_GluePoints :
-                                    {
-                                        com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair> aGluePoints;
-                                        if ( rProp.Value >>= aGluePoints )
-                                        {
-                                            sal_Int32 k, nElements = aGluePoints.getLength();
-                                            if ( nElements )
-                                            {
-                                                for( k = 0; k < nElements; k++ )
-                                                {
-                                                    ExportParameter( aStrBuffer, aGluePoints[ k ].First );
-                                                    ExportParameter( aStrBuffer, aGluePoints[ k ].Second );
-                                                }
-                                                aStr = aStrBuffer.makeStringAndClear();
-                                            }
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_GLUE_POINTS, aStr );
-                                        }
-                                    }
-                                    break;
-                                    case EAS_GluePointType :
-                                    {
-                                        sal_Int16 nGluePointType = sal_Int16();
-                                        if ( rProp.Value >>= nGluePointType )
-                                        {
-                                            switch ( nGluePointType )
-                                            {
-                                                case com::sun::star::drawing::EnhancedCustomShapeGluePointType::NONE     : aStr = GetXMLToken( XML_NONE );    break;
-                                                case com::sun::star::drawing::EnhancedCustomShapeGluePointType::SEGMENTS : aStr = GetXMLToken( XML_SEGMENTS ); break;
-                                                case com::sun::star::drawing::EnhancedCustomShapeGluePointType::RECT     : aStr = GetXMLToken( XML_RECTANGLE ); break;
-                                            }
-                                            if ( !aStr.isEmpty() )
-                                                rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_GLUE_POINT_TYPE, aStr );
-                                        }
-                                    }
-                                    break;
-                                    case EAS_Coordinates :
-                                    {
-                                        bCoordinates = ( rProp.Value >>= aCoordinates );
-                                    }
-                                    break;
-                                    case EAS_Segments :
-                                    {
-                                        rProp.Value >>= aSegments;
-                                    }
-                                    break;
-                                    case EAS_StretchX :
-                                    {
-                                        sal_Int32 nStretchPoint = 0;
-                                        if ( rProp.Value >>= nStretchPoint )
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_PATH_STRETCHPOINT_X, OUString::number( nStretchPoint ) );
-                                    }
-                                    break;
-                                    case EAS_StretchY :
-                                    {
-                                        sal_Int32 nStretchPoint = 0;
-                                        if ( rProp.Value >>= nStretchPoint )
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_PATH_STRETCHPOINT_Y, OUString::number( nStretchPoint ) );
-                                    }
-                                    break;
-                                    case EAS_TextFrames :
-                                    {
-                                        com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeTextFrame > aPathTextFrames;
-                                        if ( rProp.Value >>= aPathTextFrames )
-                                        {
-                                            if ( (sal_uInt16)aPathTextFrames.getLength() )
-                                            {
-                                                sal_uInt16 k, nElements = (sal_uInt16)aPathTextFrames.getLength();
-                                                for ( k = 0; k < nElements; k++ )
-                                                {
-                                                    ExportParameter( aStrBuffer, aPathTextFrames[ k ].TopLeft.First );
-                                                    ExportParameter( aStrBuffer, aPathTextFrames[ k ].TopLeft.Second );
-                                                    ExportParameter( aStrBuffer, aPathTextFrames[ k ].BottomRight.First );
-                                                    ExportParameter( aStrBuffer, aPathTextFrames[ k ].BottomRight.Second );
-                                                }
-                                                aStr = aStrBuffer.makeStringAndClear();
-                                            }
-                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_AREAS, aStr );
-                                        }
-                                    }
-                                    break;
-                                    default:
-                                        break;
-                                }
-                            }
-                        }
-                    }
-                    break;
-                    case EAS_Equations :
-                    {
-                        bEquations = ( rGeoProp.Value >>= aEquations );
-                    }
-                    break;
-                    case EAS_Handles :
-                    {
-                        bHandles = ( rGeoProp.Value >>= aHandles );
-                    }
-                    break;
-                    case EAS_AdjustmentValues :
-                    {
-                        rGeoProp.Value >>= aAdjustmentValues;
-                    }
-                    break;
-                    default:
-                        break;
-                }
-            }   // for
-            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TYPE, aCustomShapeType );
-
-            // adjustments
-            sal_Int32 nAdjustmentValues = aAdjustmentValues.getLength();
-            if ( nAdjustmentValues )
-            {
-                sal_Int32 i, nValue = 0;
-                for ( i = 0; i < nAdjustmentValues; i++ )
-                {
-                    if ( i )
-                        aStrBuffer.append( (sal_Unicode)' ' );
-
-                    const com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue& rAdj = aAdjustmentValues[ i ];
-                    if ( rAdj.State == beans::PropertyState_DIRECT_VALUE )
-                    {
-                        if ( rAdj.Value.getValueTypeClass() == uno::TypeClass_DOUBLE )
-                        {
-                            double fValue = 0.0;
-                            rAdj.Value >>= fValue;
-                            ::sax::Converter::convertDouble(aStrBuffer, fValue);
-                        }
-                        else
-                        {
-                            rAdj.Value >>= nValue;
-                            ::sax::Converter::convertNumber(aStrBuffer, nValue);
-                        }
-                    }
-                    else
-                    {
-                        // this should not be, but better than setting nothing
-                        ::sax::Converter::convertNumber( aStrBuffer, 0 );
-                    }
-                }
-                aStr = aStrBuffer.makeStringAndClear();
-                rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MODIFIERS, aStr );
-            }
-            if ( bCoordinates )
-                ImpExportEnhancedPath( rExport, aCoordinates, aSegments );
-        }
-    }
-    SvXMLElementExport aOBJ( rExport, XML_NAMESPACE_DRAW, XML_ENHANCED_GEOMETRY, sal_True, sal_True );
-    if ( bEquations )
-        ImpExportEquations( rExport, aEquations );
-    if ( bHandles )
-        ImpExportHandles( rExport, aHandles );
-}
-
-void XMLShapeExport::ImpExportCustomShape(
-    const uno::Reference< drawing::XShape >& xShape,
-    XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint )
-{
-    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
-    if ( xPropSet.is() )
-    {
-        OUString aStr;
-        uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
-
-        // Transformation
-        ImpExportNewTrans( xPropSet, nFeatures, pRefPoint );
-
-        if ( xPropSetInfo.is() )
-        {
-            const OUString sCustomShapeEngine( "CustomShapeEngine" );
-            if ( xPropSetInfo->hasPropertyByName( sCustomShapeEngine ) )
-            {
-                uno::Any aEngine( xPropSet->getPropertyValue( sCustomShapeEngine ) );
-                if ( ( aEngine >>= aStr ) && !aStr.isEmpty() )
-                    mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_ENGINE, aStr );
-            }
-            const OUString sCustomShapeData( "CustomShapeData" );
-            if ( xPropSetInfo->hasPropertyByName( sCustomShapeData ) )
-            {
-                uno::Any aData( xPropSet->getPropertyValue( sCustomShapeData ) );
-                if ( ( aData >>= aStr ) && !aStr.isEmpty() )
-                    mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DATA, aStr );
-            }
-        }
-        sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
-        SvXMLElementExport aOBJ( mrExport, XML_NAMESPACE_DRAW, XML_CUSTOM_SHAPE, bCreateNewline, sal_True );
-        ImpExportDescription( xShape ); // #i68101#
-        ImpExportEvents( xShape );
-        ImpExportGluePoints( xShape );
-        ImpExportText( xShape );
-        ImpExportEnhancedGeometry( mrExport, xPropSet );
-    }
-}
-
-void XMLShapeExport::ImpExportTableShape( const uno::Reference< drawing::XShape >& xShape, XmlShapeType eShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint )
-{
-    uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
-    uno::Reference< container::XNamed > xNamed(xShape, uno::UNO_QUERY);
-
-    DBG_ASSERT( xPropSet.is() && xNamed.is(), "xmloff::XMLShapeExport::ImpExportTableShape(), tabe shape is not implementing needed interfaces");
-    if(xPropSet.is() && xNamed.is()) try
-    {
-        // Transformation
-        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
-
-        sal_Bool bIsEmptyPresObj = sal_False;
-
-        // presentation settings
-        if(eShapeType == XmlShapeTypePresTableShape)
-            bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_TABLE) );
-
-        const bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 );
-        const bool bExportEmbedded(0 != (mrExport.getExportFlags() & EXPORT_EMBEDDED));
-
-        SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW, XML_FRAME, bCreateNewline, sal_True );
-
-        // do not export in ODF 1.1 or older
-        if( mrExport.getDefaultVersion() >= SvtSaveOptions::ODFVER_012 )
-        {
-            if( !bIsEmptyPresObj )
-            {
-                uno::Reference< container::XNamed > xTemplate( xPropSet->getPropertyValue("TableTemplate"), uno::UNO_QUERY );
-                if( xTemplate.is() )
-                {
-                    const OUString sTemplate( xTemplate->getName() );
-                    if( !sTemplate.isEmpty() )
-                    {
-                        mrExport.AddAttribute(XML_NAMESPACE_TABLE, XML_TEMPLATE_NAME, sTemplate );
-
-                        for( const XMLPropertyMapEntry* pEntry = &aXMLTableShapeAttributes[0]; pEntry->msApiName; pEntry++ )
-                        {
-                            try
-                            {
-                                sal_Bool bBool = sal_False;
-                                const OUString sAPIPropertyName( OUString(pEntry->msApiName, pEntry->nApiNameLength, RTL_TEXTENCODING_ASCII_US ) );
-
-                                xPropSet->getPropertyValue( sAPIPropertyName ) >>= bBool;
-                                if( bBool )
-                                    mrExport.AddAttribute(pEntry->mnNameSpace, pEntry->meXMLName, XML_TRUE );
-                            }
-                            catch( uno::Exception& )
-                            {
-                            OSL_FAIL("XMLShapeExport::ImpExportTableShape(), exception caught!");
-                            }
-                        }
-                    }
-                }
-
-                uno::Reference< table::XColumnRowRange > xRange( xPropSet->getPropertyValue( msModel ), uno::UNO_QUERY_THROW );
-                GetShapeTableExport()->exportTable( xRange );
-            }
-        }
-
-        if( !bIsEmptyPresObj )
-        {
-            uno::Reference< graphic::XGraphic > xGraphic( xPropSet->getPropertyValue("ReplacementGraphic"), uno::UNO_QUERY );
-            if( xGraphic.is() ) try
-            {
-                Reference< uno::XComponentContext > xContext = GetExport().getComponentContext();
-
-                uno::Reference< embed::XStorage > xPictureStorage;
-                uno::Reference< embed::XStorage > xStorage;
-                uno::Reference< io::XStream > xPictureStream;
-
-                OUString sPictureName;
-                if( bExportEmbedded )
-                {
-                    xPictureStream.set( xContext->getServiceManager()->createInstanceWithContext( "com.sun.star.comp.MemoryStream", xContext), UNO_QUERY_THROW );
-                }
-                else
-                {
-                    xStorage.set( GetExport().GetTargetStorage(), UNO_QUERY_THROW );
-
-                    xPictureStorage.set( xStorage->openStorageElement( OUString( "Pictures" ), ::embed::ElementModes::READWRITE ), uno::UNO_QUERY_THROW );
-                    const OUString sPrefix( "TablePreview" );
-                    const OUString sSuffix( ".svm" );
-
-                    sal_Int32 nIndex = 0;
-                    do
-                    {
-                        sPictureName = sPrefix;
-                        sPictureName += OUString::number( ++nIndex );
-                        sPictureName += sSuffix;
-                    }
-                    while( xPictureStorage->hasByName( sPictureName ) );
-
-                    xPictureStream.set( xPictureStorage->openStreamElement( sPictureName, ::embed::ElementModes::READWRITE ), UNO_QUERY_THROW );
-                }
-
-                Reference< graphic::XGraphicProvider > xProvider( graphic::GraphicProvider::create(xContext) );
-                Sequence< beans::PropertyValue > aArgs( 2 );
-                aArgs[ 0 ].Name = OUString( "MimeType" );
-                aArgs[ 0 ].Value <<= OUString( "image/x-vclgraphic" );
-                aArgs[ 1 ].Name = OUString( "OutputStream" );
-                aArgs[ 1 ].Value <<= xPictureStream->getOutputStream();
-                xProvider->storeGraphic( xGraphic, aArgs );
-
-                if( xPictureStorage.is() )
-                {
-                    Reference< embed::XTransactedObject > xTrans( xPictureStorage, UNO_QUERY );
-                    if( xTrans.is() )
-                        xTrans->commit();
-                }
-
-                if( !bExportEmbedded )
-                {
-                    OUString sURL( "Pictures/" );
-                    sURL += sPictureName;
-                    mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sURL );
-                    mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
-                    mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
-                    mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
-                }
-
-                SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_DRAW, XML_IMAGE, sal_False, sal_True );
-
-                if( bExportEmbedded )
-                {
-                    Reference< XSeekableInputStream > xSeekable( xPictureStream, UNO_QUERY_THROW );
-                    xSeekable->seek(0);
-
-                    XMLBase64Export aBase64Exp( GetExport() );
-                    aBase64Exp.exportOfficeBinaryDataElement( Reference < XInputStream >( xPictureStream, UNO_QUERY_THROW ) );
-                }
-            }
-            catch( uno::Exception& )
-            {
-                OSL_FAIL("xmloff::XMLShapeExport::ImpExportTableShape(), exception caught!");
-            }
-        }
-
-        ImpExportEvents( xShape );
-        ImpExportGluePoints( xShape );
-        ImpExportDescription( xShape ); // #i68101#
-    }
-    catch( uno::Exception& )
-    {
-        OSL_FAIL( "xmloff::XMLShapeExport::ImpExportTableShape(), exception caught!" );
-    }
-}
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */