Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

10 files changed, 16224 insertions, 0 deletions

diff --git a/oox/source/export/ColorPropertySet.cxx b/oox/source/export/ColorPropertySet.cxx
new file mode 100644
index 000000000..e2734a8e7
--- /dev/null
+++ b/oox/source/export/ColorPropertySet.cxx
@@ -0,0 +1,178 @@
+/* -*- 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 .
+ */
+
+// FIXME? This file is nearly identical to xmloff/source/chart/ColorPropertySet.cxx
+
+#include "ColorPropertySet.hxx"
+
+#include <cppuhelper/implbase.hxx>
+#include <osl/diagnose.h>
+#include <com/sun/star/drawing/FillStyle.hpp>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::beans;
+
+using ::com::sun::star::uno::Reference;
+using ::com::sun::star::uno::Sequence;
+
+namespace
+{
+class lcl_ColorPropertySetInfo : public ::cppu::WeakImplHelper<
+        XPropertySetInfo  >
+{
+public:
+    explicit lcl_ColorPropertySetInfo( bool bFillColor );
+
+protected:
+    // ____ XPropertySetInfo ____
+    virtual Sequence< Property > SAL_CALL getProperties() override;
+    virtual Property SAL_CALL getPropertyByName( const OUString& aName ) override;
+    virtual sal_Bool SAL_CALL hasPropertyByName( const OUString& Name ) override;
+
+private:
+    OUString m_aColorPropName;
+    Property m_aColorProp;
+};
+
+lcl_ColorPropertySetInfo::lcl_ColorPropertySetInfo( bool bFillColor ) :
+        // note: length of FillColor and LineColor is 9
+        m_aColorPropName( (bFillColor ? "FillColor" : "LineColor"), 9, RTL_TEXTENCODING_ASCII_US ),
+        m_aColorProp( m_aColorPropName, -1,
+                      cppu::UnoType<sal_Int32>::get(), 0)
+{}
+
+Sequence< Property > SAL_CALL lcl_ColorPropertySetInfo::getProperties()
+{
+
+    return Sequence< Property >( & m_aColorProp, 1 );
+}
+
+Property SAL_CALL lcl_ColorPropertySetInfo::getPropertyByName( const OUString& aName )
+{
+    if( aName == m_aColorPropName )
+        return m_aColorProp;
+    throw UnknownPropertyException( m_aColorPropName, static_cast< uno::XWeak * >( this ));
+}
+
+sal_Bool SAL_CALL lcl_ColorPropertySetInfo::hasPropertyByName( const OUString& Name )
+{
+    return Name == m_aColorPropName;
+}
+
+} // anonymous namespace
+
+namespace oox::drawingml
+{
+
+ColorPropertySet::ColorPropertySet( ::Color nColor, bool bFillColor /* = true */ ) :
+        // note: length of FillColor and LineColor is 9
+        m_aColorPropName( (bFillColor ? "FillColor" : "LineColor"), 9, RTL_TEXTENCODING_ASCII_US ),
+        m_nColor( nColor ),
+        m_bIsFillColor( bFillColor ),
+        m_nDefaultColor( 0x0099ccff )  // blue 8
+{}
+
+ColorPropertySet::~ColorPropertySet()
+{}
+
+// ____ XPropertySet ____
+
+Reference< XPropertySetInfo > SAL_CALL ColorPropertySet::getPropertySetInfo()
+{
+    if( ! m_xInfo.is())
+        m_xInfo.set( new lcl_ColorPropertySetInfo( m_bIsFillColor ));
+
+    return m_xInfo;
+}
+
+void SAL_CALL ColorPropertySet::setPropertyValue( const OUString& rPropertyName, const uno::Any& aValue )
+{
+    if (rPropertyName != m_aColorPropName)
+    {
+        // trying to catch these cases in the next crash testing
+        assert(false);
+        return;
+    }
+
+    aValue >>= m_nColor;
+}
+
+uno::Any SAL_CALL ColorPropertySet::getPropertyValue( const OUString& aPropertyName )
+{
+    if( aPropertyName == "FillStyle" && m_bIsFillColor )
+    {
+        return uno::makeAny(css::drawing::FillStyle_SOLID);
+    }
+    else if (aPropertyName == m_aColorPropName)
+        return uno::makeAny( m_nColor );
+
+    throw UnknownPropertyException(aPropertyName);
+}
+
+void SAL_CALL ColorPropertySet::addPropertyChangeListener( const OUString& /* aPropertyName */, const Reference< XPropertyChangeListener >& /* xListener */ )
+{
+    OSL_FAIL( "Not Implemented" );
+}
+
+void SAL_CALL ColorPropertySet::removePropertyChangeListener( const OUString& /* aPropertyName */, const Reference< XPropertyChangeListener >& /* aListener */ )
+{
+    OSL_FAIL( "Not Implemented" );
+}
+
+void SAL_CALL ColorPropertySet::addVetoableChangeListener( const OUString& /* PropertyName */, const Reference< XVetoableChangeListener >& /* aListener */ )
+{
+    OSL_FAIL( "Not Implemented" );
+}
+
+void SAL_CALL ColorPropertySet::removeVetoableChangeListener( const OUString& /* PropertyName */, const Reference< XVetoableChangeListener >& /* aListener */ )
+{
+    OSL_FAIL( "Not Implemented" );
+}
+
+// ____ XPropertyState ____
+
+PropertyState SAL_CALL ColorPropertySet::getPropertyState( const OUString& /* PropertyName */ )
+{
+    return PropertyState_DIRECT_VALUE;
+}
+
+Sequence< PropertyState > SAL_CALL ColorPropertySet::getPropertyStates( const Sequence< OUString >& /* aPropertyName */ )
+{
+    PropertyState aState = PropertyState_DIRECT_VALUE;
+    // coverity[overrun-buffer-arg : FALSE] - coverity has difficulty with css::uno::Sequence
+    return Sequence<PropertyState>(&aState, 1);
+}
+
+void SAL_CALL ColorPropertySet::setPropertyToDefault( const OUString& PropertyName )
+{
+    if( PropertyName == m_aColorPropName )
+        m_nColor = m_nDefaultColor;
+}
+
+uno::Any SAL_CALL ColorPropertySet::getPropertyDefault( const OUString& aPropertyName )
+{
+    if( aPropertyName == m_aColorPropName )
+        return uno::makeAny( m_nDefaultColor );
+
+    return uno::Any();
+}
+
+} // namespace oox::drawingml
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/oox/source/export/ColorPropertySet.hxx b/oox/source/export/ColorPropertySet.hxx
new file mode 100644
index 000000000..e1734422a
--- /dev/null
+++ b/oox/source/export/ColorPropertySet.hxx
@@ -0,0 +1,90 @@
+/* -*- 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 .
+ */
+
+#ifndef XMLOFF_COLORPROPERTYSET_HXX
+#define XMLOFF_COLORPROPERTYSET_HXX
+
+// FIXME? this file is identical to xmloff/source/chart/ColorPropertySet.hxx
+
+#include <cppuhelper/implbase.hxx>
+#include <tools/color.hxx>
+
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/beans/XPropertyState.hpp>
+
+namespace oox
+{
+namespace drawingml
+{
+
+class ColorPropertySet : public ::cppu::WeakImplHelper<
+        css::beans::XPropertySet,
+        css::beans::XPropertyState >
+{
+public:
+    // if bFillColor == false, the color is a LineColor
+    explicit ColorPropertySet( ::Color nColor, bool bFillColor = true );
+    virtual ~ColorPropertySet() override;
+
+protected:
+    // ____ XPropertySet ____
+    virtual css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL getPropertySetInfo() override;
+    virtual void SAL_CALL setPropertyValue(
+        const OUString& aPropertyName,
+        const css::uno::Any& aValue ) override;
+    virtual css::uno::Any SAL_CALL getPropertyValue(
+        const OUString& PropertyName ) override;
+    virtual void SAL_CALL addPropertyChangeListener(
+        const OUString& aPropertyName,
+        const css::uno::Reference< css::beans::XPropertyChangeListener >& xListener ) override;
+    virtual void SAL_CALL removePropertyChangeListener(
+        const OUString& aPropertyName,
+        const css::uno::Reference< css::beans::XPropertyChangeListener >& aListener ) override;
+    virtual void SAL_CALL addVetoableChangeListener(
+        const OUString& PropertyName,
+        const css::uno::Reference< css::beans::XVetoableChangeListener >& aListener ) override;
+    virtual void SAL_CALL removeVetoableChangeListener(
+        const OUString& PropertyName,
+        const css::uno::Reference< css::beans::XVetoableChangeListener >& aListener ) override;
+
+    // ____ XPropertyState ____
+    virtual css::beans::PropertyState SAL_CALL getPropertyState(
+        const OUString& PropertyName ) override;
+    virtual css::uno::Sequence< css::beans::PropertyState > SAL_CALL getPropertyStates(
+        const css::uno::Sequence< OUString >& aPropertyName ) override;
+    virtual void SAL_CALL setPropertyToDefault(
+        const OUString& PropertyName ) override;
+    virtual css::uno::Any SAL_CALL getPropertyDefault(
+        const OUString& aPropertyName ) override;
+
+private:
+    css::uno::Reference< css::beans::XPropertySetInfo > m_xInfo;
+    OUString         m_aColorPropName;
+    ::Color          m_nColor;
+    bool             m_bIsFillColor;
+    ::Color          m_nDefaultColor;
+};
+
+} //  namespace chart
+} //  namespace xmloff
+
+// XMLOFF_COLORPROPERTYSET_HXX
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/oox/source/export/README b/oox/source/export/README
new file mode 100644
index 000000000..56195b977
--- /dev/null
+++ b/oox/source/export/README
@@ -0,0 +1,2 @@
+presetTextWarpDefinitions.xml and presetShapeDefinitions.xml come from the
+OOXML documentation (TC45).
diff --git a/oox/source/export/chartexport.cxx b/oox/source/export/chartexport.cxx
new file mode 100644
index 000000000..6511cfaac
--- /dev/null
+++ b/oox/source/export/chartexport.cxx
@@ -0,0 +1,4202 @@
+/* -*- 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 <oox/token/namespaces.hxx>
+#include <oox/token/properties.hxx>
+#include <oox/token/tokens.hxx>
+#include <oox/core/xmlfilterbase.hxx>
+#include <oox/export/chartexport.hxx>
+#include <oox/token/relationship.hxx>
+#include <oox/export/utils.hxx>
+#include <drawingml/chart/typegroupconverter.hxx>
+
+#include <cstdio>
+#include <iterator>
+
+#include <com/sun/star/awt/Gradient.hpp>
+#include <com/sun/star/chart/XChartDocument.hpp>
+#include <com/sun/star/chart/ChartLegendPosition.hpp>
+#include <com/sun/star/chart/XTwoAxisXSupplier.hpp>
+#include <com/sun/star/chart/XTwoAxisYSupplier.hpp>
+#include <com/sun/star/chart/XAxisZSupplier.hpp>
+#include <com/sun/star/chart/ChartDataRowSource.hpp>
+#include <com/sun/star/chart/X3DDisplay.hpp>
+#include <com/sun/star/chart/XStatisticDisplay.hpp>
+#include <com/sun/star/chart/XSecondAxisTitleSupplier.hpp>
+#include <com/sun/star/chart/ChartSymbolType.hpp>
+#include <com/sun/star/chart/ChartAxisMarks.hpp>
+#include <com/sun/star/chart/ChartAxisLabelPosition.hpp>
+#include <com/sun/star/chart/ChartAxisPosition.hpp>
+#include <com/sun/star/chart/ChartSolidType.hpp>
+#include <com/sun/star/chart/DataLabelPlacement.hpp>
+#include <com/sun/star/chart/ErrorBarStyle.hpp>
+#include <com/sun/star/chart/MissingValueTreatment.hpp>
+#include <com/sun/star/chart/XDiagramPositioning.hpp>
+
+#include <com/sun/star/chart2/RelativePosition.hpp>
+#include <com/sun/star/chart2/RelativeSize.hpp>
+#include <com/sun/star/chart2/XChartDocument.hpp>
+#include <com/sun/star/chart2/XDiagram.hpp>
+#include <com/sun/star/chart2/XCoordinateSystemContainer.hpp>
+#include <com/sun/star/chart2/XRegressionCurveContainer.hpp>
+#include <com/sun/star/chart2/XChartTypeContainer.hpp>
+#include <com/sun/star/chart2/XDataSeriesContainer.hpp>
+#include <com/sun/star/chart2/DataPointLabel.hpp>
+#include <com/sun/star/chart2/XDataPointCustomLabelField.hpp>
+#include <com/sun/star/chart2/DataPointCustomLabelFieldType.hpp>
+#include <com/sun/star/chart2/Symbol.hpp>
+#include <com/sun/star/chart2/data/XDataSource.hpp>
+#include <com/sun/star/chart2/data/XDataProvider.hpp>
+#include <com/sun/star/chart2/data/XTextualDataSequence.hpp>
+#include <com/sun/star/chart2/data/XNumericalDataSequence.hpp>
+#include <com/sun/star/chart2/data/XLabeledDataSequence.hpp>
+#include <com/sun/star/chart2/XAnyDescriptionAccess.hpp>
+#include <com/sun/star/chart2/AxisType.hpp>
+
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/container/XNameAccess.hpp>
+#include <com/sun/star/drawing/XShape.hpp>
+#include <com/sun/star/drawing/FillStyle.hpp>
+#include <com/sun/star/drawing/LineStyle.hpp>
+#include <com/sun/star/awt/XBitmap.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/lang/XServiceName.hpp>
+
+#include <com/sun/star/table/CellAddress.hpp>
+#include <com/sun/star/sheet/XFormulaParser.hpp>
+#include <com/sun/star/sheet/FormulaToken.hpp>
+#include <com/sun/star/sheet/AddressConvention.hpp>
+
+#include <com/sun/star/container/XNamed.hpp>
+#include <com/sun/star/embed/XVisualObject.hpp>
+#include <com/sun/star/embed/Aspects.hpp>
+
+#include <comphelper/processfactory.hxx>
+#include <comphelper/random.hxx>
+#include <utility>
+#include <xmloff/SchXMLSeriesHelper.hxx>
+#include "ColorPropertySet.hxx"
+
+#include <svl/zforlist.hxx>
+#include <svl/numuno.hxx>
+#include <tools/diagnose_ex.h>
+#include <sal/log.hxx>
+
+#include <set>
+#include <unordered_set>
+
+#include <rtl/math.hxx>
+#include <o3tl/temporary.hxx>
+
+using namespace css;
+using namespace css::uno;
+using namespace css::drawing;
+using namespace ::oox::core;
+using css::beans::PropertyValue;
+using css::beans::XPropertySet;
+using css::container::XNamed;
+using css::table::CellAddress;
+using css::sheet::XFormulaParser;
+using ::oox::core::XmlFilterBase;
+using ::sax_fastparser::FSHelperPtr;
+
+namespace cssc = css::chart;
+
+namespace oox::drawingml {
+
+namespace {
+
+bool isPrimaryAxes(sal_Int32 nIndex)
+{
+    assert(nIndex == 0 || nIndex == 1);
+    return nIndex != 1;
+}
+
+class lcl_MatchesRole
+{
+public:
+    explicit lcl_MatchesRole( const OUString & aRole ) :
+            m_aRole( aRole )
+    {}
+
+    bool operator () ( const Reference< chart2::data::XLabeledDataSequence > & xSeq ) const
+    {
+        if( !xSeq.is() )
+            return  false;
+        Reference< beans::XPropertySet > xProp( xSeq->getValues(), uno::UNO_QUERY );
+        OUString aRole;
+
+        return ( xProp.is() &&
+                 (xProp->getPropertyValue( "Role" ) >>= aRole ) &&
+                 m_aRole == aRole );
+    }
+
+private:
+    OUString m_aRole;
+};
+
+}
+
+static Reference< chart2::data::XLabeledDataSequence > lcl_getCategories( const Reference< chart2::XDiagram > & xDiagram )
+{
+    Reference< chart2::data::XLabeledDataSequence >  xResult;
+    try
+    {
+        Reference< chart2::XCoordinateSystemContainer > xCooSysCnt(
+            xDiagram, uno::UNO_QUERY_THROW );
+        const Sequence< Reference< chart2::XCoordinateSystem > > aCooSysSeq(
+            xCooSysCnt->getCoordinateSystems());
+        for( const auto& xCooSys : aCooSysSeq )
+        {
+            OSL_ASSERT( xCooSys.is());
+            for( sal_Int32 nN = xCooSys->getDimension(); nN--; )
+            {
+                const sal_Int32 nMaxAxisIndex = xCooSys->getMaximumAxisIndexByDimension(nN);
+                for(sal_Int32 nI=0; nI<=nMaxAxisIndex; ++nI)
+                {
+                    Reference< chart2::XAxis > xAxis = xCooSys->getAxisByDimension( nN, nI );
+                    OSL_ASSERT( xAxis.is());
+                    if( xAxis.is())
+                    {
+                        chart2::ScaleData aScaleData = xAxis->getScaleData();
+                        if( aScaleData.Categories.is())
+                        {
+                            xResult.set( aScaleData.Categories );
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch( const uno::Exception & )
+    {
+        DBG_UNHANDLED_EXCEPTION("oox");
+    }
+
+    return xResult;
+}
+
+static Reference< chart2::data::XLabeledDataSequence >
+    lcl_getDataSequenceByRole(
+        const Sequence< Reference< chart2::data::XLabeledDataSequence > > & aLabeledSeq,
+        const OUString & rRole )
+{
+    Reference< chart2::data::XLabeledDataSequence > aNoResult;
+
+    const Reference< chart2::data::XLabeledDataSequence > * pBegin = aLabeledSeq.getConstArray();
+    const Reference< chart2::data::XLabeledDataSequence > * pEnd = pBegin + aLabeledSeq.getLength();
+    const Reference< chart2::data::XLabeledDataSequence > * pMatch =
+        ::std::find_if( pBegin, pEnd, lcl_MatchesRole( rRole ));
+
+    if( pMatch != pEnd )
+        return *pMatch;
+
+    return aNoResult;
+}
+
+static bool lcl_hasCategoryLabels( const Reference< chart2::XChartDocument >& xChartDoc )
+{
+    //categories are always the first sequence
+    Reference< chart2::XDiagram > xDiagram( xChartDoc->getFirstDiagram());
+    Reference< chart2::data::XLabeledDataSequence > xCategories( lcl_getCategories( xDiagram ) );
+    return xCategories.is();
+}
+
+static bool lcl_isCategoryAxisShifted( const Reference< chart2::XDiagram >& xDiagram )
+{
+    bool bCategoryPositionShifted = false;
+    try
+    {
+        Reference< chart2::XCoordinateSystemContainer > xCooSysCnt(
+            xDiagram, uno::UNO_QUERY_THROW);
+        const Sequence< Reference< chart2::XCoordinateSystem > > aCooSysSeq(
+            xCooSysCnt->getCoordinateSystems());
+        for (const auto& xCooSys : aCooSysSeq)
+        {
+            OSL_ASSERT(xCooSys.is());
+            if( 0 < xCooSys->getDimension() && 0 <= xCooSys->getMaximumAxisIndexByDimension(0) )
+            {
+                Reference< chart2::XAxis > xAxis = xCooSys->getAxisByDimension(0, 0);
+                OSL_ASSERT(xAxis.is());
+                if (xAxis.is())
+                {
+                    chart2::ScaleData aScaleData = xAxis->getScaleData();
+                    bCategoryPositionShifted = aScaleData.ShiftedCategoryPosition;
+                    break;
+                }
+            }
+        }
+    }
+    catch (const uno::Exception&)
+    {
+        DBG_UNHANDLED_EXCEPTION("oox");
+    }
+
+    return bCategoryPositionShifted;
+}
+
+static sal_Int32 lcl_getCategoryAxisType( const Reference< chart2::XDiagram >& xDiagram, sal_Int32 nDimensionIndex, sal_Int32 nAxisIndex )
+{
+    sal_Int32 nAxisType = -1;
+    try
+    {
+        Reference< chart2::XCoordinateSystemContainer > xCooSysCnt(
+            xDiagram, uno::UNO_QUERY_THROW);
+        const Sequence< Reference< chart2::XCoordinateSystem > > aCooSysSeq(
+            xCooSysCnt->getCoordinateSystems());
+        for( const auto& xCooSys : aCooSysSeq )
+        {
+            OSL_ASSERT(xCooSys.is());
+            if( nDimensionIndex < xCooSys->getDimension() && nAxisIndex <= xCooSys->getMaximumAxisIndexByDimension(nDimensionIndex) )
+            {
+                Reference< chart2::XAxis > xAxis = xCooSys->getAxisByDimension(nDimensionIndex, nAxisIndex);
+                OSL_ASSERT(xAxis.is());
+                if( xAxis.is() )
+                {
+                    chart2::ScaleData aScaleData = xAxis->getScaleData();
+                    nAxisType = aScaleData.AxisType;
+                    break;
+                }
+            }
+        }
+    }
+    catch (const uno::Exception&)
+    {
+        DBG_UNHANDLED_EXCEPTION("oox");
+    }
+
+    return nAxisType;
+}
+
+static bool lcl_isSeriesAttachedToFirstAxis(
+    const Reference< chart2::XDataSeries > & xDataSeries )
+{
+    bool bResult=true;
+
+    try
+    {
+        sal_Int32 nAxisIndex = 0;
+        Reference< beans::XPropertySet > xProp( xDataSeries, uno::UNO_QUERY_THROW );
+        xProp->getPropertyValue("AttachedAxisIndex") >>= nAxisIndex;
+        bResult = (0==nAxisIndex);
+    }
+    catch( const uno::Exception & )
+    {
+        DBG_UNHANDLED_EXCEPTION("oox");
+    }
+
+    return bResult;
+}
+
+static OUString lcl_flattenStringSequence( const Sequence< OUString > & rSequence )
+{
+    OUStringBuffer aResult;
+    bool bPrecedeWithSpace = false;
+    for( const auto& rString : rSequence )
+    {
+        if( !rString.isEmpty())
+        {
+            if( bPrecedeWithSpace )
+                aResult.append( ' ' );
+            aResult.append( rString );
+            bPrecedeWithSpace = true;
+        }
+    }
+    return aResult.makeStringAndClear();
+}
+
+static Sequence< OUString > lcl_getLabelSequence( const Reference< chart2::data::XDataSequence > & xLabelSeq )
+{
+    Sequence< OUString > aLabels;
+
+    uno::Reference< chart2::data::XTextualDataSequence > xTextualDataSequence( xLabelSeq, uno::UNO_QUERY );
+    if( xTextualDataSequence.is())
+    {
+        aLabels = xTextualDataSequence->getTextualData();
+    }
+    else if( xLabelSeq.is())
+    {
+        const Sequence< uno::Any > aAnies( xLabelSeq->getData());
+        aLabels.realloc( aAnies.getLength());
+        for( sal_Int32 i=0; i<aAnies.getLength(); ++i )
+            aAnies[i] >>= aLabels[i];
+    }
+
+    return aLabels;
+}
+
+static void lcl_fillCategoriesIntoStringVector(
+    const Reference< chart2::data::XDataSequence > & xCategories,
+    ::std::vector< OUString > & rOutCategories )
+{
+    OSL_ASSERT( xCategories.is());
+    if( !xCategories.is())
+        return;
+    Reference< chart2::data::XTextualDataSequence > xTextualDataSequence( xCategories, uno::UNO_QUERY );
+    if( xTextualDataSequence.is())
+    {
+        rOutCategories.clear();
+        Sequence< OUString > aTextData( xTextualDataSequence->getTextualData());
+        ::std::copy( aTextData.begin(), aTextData.end(),
+                     ::std::back_inserter( rOutCategories ));
+    }
+    else
+    {
+        Sequence< uno::Any > aAnies( xCategories->getData());
+        rOutCategories.resize( aAnies.getLength());
+        for( sal_Int32 i=0; i<aAnies.getLength(); ++i )
+            aAnies[i] >>= rOutCategories[i];
+    }
+}
+
+static ::std::vector< double > lcl_getAllValuesFromSequence( const Reference< chart2::data::XDataSequence > & xSeq )
+{
+    double fNan = 0.0;
+    ::rtl::math::setNan( &fNan );
+    ::std::vector< double > aResult;
+
+    Reference< chart2::data::XNumericalDataSequence > xNumSeq( xSeq, uno::UNO_QUERY );
+    if( xNumSeq.is())
+    {
+        Sequence< double > aValues( xNumSeq->getNumericalData());
+        ::std::copy( aValues.begin(), aValues.end(),
+                     ::std::back_inserter( aResult ));
+    }
+    else if( xSeq.is())
+    {
+        Sequence< uno::Any > aAnies( xSeq->getData());
+        aResult.resize( aAnies.getLength(), fNan );
+        for( sal_Int32 i=0; i<aAnies.getLength(); ++i )
+            aAnies[i] >>= aResult[i];
+    }
+    return aResult;
+}
+
+static sal_Int32 lcl_getChartType( const OUString& sChartType )
+{
+    chart::TypeId eChartTypeId = chart::TYPEID_UNKNOWN;
+    if( sChartType == "com.sun.star.chart.BarDiagram"
+        || sChartType == "com.sun.star.chart2.ColumnChartType" )
+        eChartTypeId = chart::TYPEID_BAR;
+    else if( sChartType == "com.sun.star.chart.AreaDiagram"
+             || sChartType == "com.sun.star.chart2.AreaChartType" )
+        eChartTypeId = chart::TYPEID_AREA;
+    else if( sChartType == "com.sun.star.chart.LineDiagram"
+             || sChartType == "com.sun.star.chart2.LineChartType" )
+        eChartTypeId = chart::TYPEID_LINE;
+    else if( sChartType == "com.sun.star.chart.PieDiagram"
+             || sChartType == "com.sun.star.chart2.PieChartType" )
+        eChartTypeId = chart::TYPEID_PIE;
+    else if( sChartType == "com.sun.star.chart.DonutDiagram"
+             || sChartType == "com.sun.star.chart2.DonutChartType" )
+        eChartTypeId = chart::TYPEID_DOUGHNUT;
+    else if( sChartType == "com.sun.star.chart.XYDiagram"
+             || sChartType == "com.sun.star.chart2.ScatterChartType" )
+        eChartTypeId = chart::TYPEID_SCATTER;
+    else if( sChartType == "com.sun.star.chart.NetDiagram"
+             || sChartType == "com.sun.star.chart2.NetChartType" )
+        eChartTypeId = chart::TYPEID_RADARLINE;
+    else if( sChartType == "com.sun.star.chart.FilledNetDiagram"
+             || sChartType == "com.sun.star.chart2.FilledNetChartType" )
+        eChartTypeId = chart::TYPEID_RADARAREA;
+    else if( sChartType == "com.sun.star.chart.StockDiagram"
+             || sChartType == "com.sun.star.chart2.CandleStickChartType" )
+        eChartTypeId = chart::TYPEID_STOCK;
+    else if( sChartType == "com.sun.star.chart.BubbleDiagram"
+             || sChartType == "com.sun.star.chart2.BubbleChartType" )
+        eChartTypeId = chart::TYPEID_BUBBLE;
+
+    return eChartTypeId;
+}
+
+static sal_Int32 lcl_generateRandomValue()
+{
+    return comphelper::rng::uniform_int_distribution(0, 100000000-1);
+}
+
+ChartExport::ChartExport( sal_Int32 nXmlNamespace, FSHelperPtr pFS, Reference< frame::XModel > const & xModel, XmlFilterBase* pFB, DocumentType eDocumentType )
+    : DrawingML( std::move(pFS), pFB, eDocumentType )
+    , mnXmlNamespace( nXmlNamespace )
+    , mnSeriesCount(0)
+    , mxChartModel( xModel )
+    , mpURLTransformer(std::make_shared<URLTransformer>())
+    , mbHasCategoryLabels( false )
+    , mbHasZAxis( false )
+    , mbIs3DChart( false )
+    , mbStacked(false)
+    , mbPercent(false)
+{
+}
+
+void ChartExport::SetURLTranslator(const std::shared_ptr<URLTransformer>& pTransformer)
+{
+    mpURLTransformer = pTransformer;
+}
+
+sal_Int32 ChartExport::getChartType( )
+{
+    OUString sChartType = mxDiagram->getDiagramType();
+    return lcl_getChartType( sChartType );
+}
+
+namespace {
+
+uno::Sequence< beans::PropertyValue > createArguments(
+    const OUString & rRangeRepresentation, bool bUseColumns)
+{
+    css::chart::ChartDataRowSource eRowSource = css::chart::ChartDataRowSource_ROWS;
+    if (bUseColumns)
+        eRowSource = css::chart::ChartDataRowSource_COLUMNS;
+
+    uno::Sequence< beans::PropertyValue > aArguments(4);
+    aArguments[0] = beans::PropertyValue("DataRowSource"
+        , -1, uno::Any(eRowSource)
+        , beans::PropertyState_DIRECT_VALUE);
+    aArguments[1] = beans::PropertyValue("FirstCellAsLabel"
+        , -1, uno::Any(false)
+        , beans::PropertyState_DIRECT_VALUE);
+    aArguments[2] = beans::PropertyValue("HasCategories"
+        , -1, uno::Any(false)
+        , beans::PropertyState_DIRECT_VALUE);
+    aArguments[3] = beans::PropertyValue("CellRangeRepresentation"
+        , -1, uno::Any(rRangeRepresentation)
+        , beans::PropertyState_DIRECT_VALUE);
+
+    return aArguments;
+}
+
+Reference<chart2::XDataSeries> getPrimaryDataSeries(const Reference<chart2::XChartType>& xChartType)
+{
+    Reference< chart2::XDataSeriesContainer > xDSCnt(xChartType, uno::UNO_QUERY_THROW);
+
+    // export dataseries for current chart-type
+    const Sequence< Reference< chart2::XDataSeries > > aSeriesSeq(xDSCnt->getDataSeries());
+    for (const auto& rSeries : aSeriesSeq)
+    {
+        Reference<chart2::XDataSeries> xSource(rSeries, uno::UNO_QUERY);
+        if (xSource.is())
+            return xSource;
+    }
+
+    return Reference<chart2::XDataSeries>();
+}
+
+}
+
+Sequence< Sequence< OUString > > ChartExport::getSplitCategoriesList( const OUString& rRange )
+{
+    Reference< chart2::XChartDocument > xChartDoc(getModel(), uno::UNO_QUERY);
+    OSL_ASSERT(xChartDoc.is());
+    if (xChartDoc.is())
+    {
+        Reference< chart2::data::XDataProvider > xDataProvider(xChartDoc->getDataProvider());
+        OSL_ENSURE(xDataProvider.is(), "No DataProvider");
+        if (xDataProvider.is())
+        {
+            //detect whether the first series is a row or a column
+            bool bSeriesUsesColumns = true;
+            Reference< chart2::XDiagram > xDiagram(xChartDoc->getFirstDiagram());
+            try
+            {
+                Reference< chart2::XCoordinateSystemContainer > xCooSysCnt(xDiagram, uno::UNO_QUERY_THROW);
+                const Sequence< Reference< chart2::XCoordinateSystem > > aCooSysSeq(xCooSysCnt->getCoordinateSystems());
+                for (const auto& rCooSys : aCooSysSeq)
+                {
+                    const Reference< chart2::XChartTypeContainer > xCTCnt(rCooSys, uno::UNO_QUERY_THROW);
+                    const Sequence< Reference< chart2::XChartType > > aChartTypeSeq(xCTCnt->getChartTypes());
+                    for (const auto& rChartType : aChartTypeSeq)
+                    {
+                        Reference< chart2::XDataSeries > xDataSeries = getPrimaryDataSeries(rChartType);
+                        if (xDataSeries.is())
+                        {
+                            uno::Reference< chart2::data::XDataSource > xSeriesSource(xDataSeries, uno::UNO_QUERY);
+                            const uno::Sequence< beans::PropertyValue > rArguments = xDataProvider->detectArguments(xSeriesSource);
+                            for (const beans::PropertyValue& rProperty : rArguments)
+                            {
+                                if (rProperty.Name == "DataRowSource")
+                                {
+                                    css::chart::ChartDataRowSource eRowSource;
+                                    if (rProperty.Value >>= eRowSource)
+                                    {
+                                        bSeriesUsesColumns = (eRowSource == css::chart::ChartDataRowSource_COLUMNS);
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (const uno::Exception &)
+            {
+                DBG_UNHANDLED_EXCEPTION("chart2");
+            }
+            // detect we have an inner data table or not
+            if (xChartDoc->hasInternalDataProvider() && rRange == "categories")
+            {
+                try
+                {
+                    css::uno::Reference< css::chart2::XAnyDescriptionAccess > xDataAccess(xChartDoc->getDataProvider(), uno::UNO_QUERY);
+                    const Sequence< Sequence< uno::Any > >aAnyCategories(bSeriesUsesColumns ? xDataAccess->getAnyRowDescriptions() : xDataAccess->getAnyColumnDescriptions());
+                    auto pMax = std::max_element(aAnyCategories.begin(), aAnyCategories.end(),
+                        [](const Sequence<uno::Any>& a, const Sequence<uno::Any>& b) {
+                            return a.getLength() < b.getLength(); });
+
+                    //minimum is 1!
+                    if (pMax != aAnyCategories.end() && pMax->getLength() > 1)
+                    {
+                        sal_Int32 nLevelCount = pMax->getLength();
+                        //we have complex categories
+                        //sort the categories name
+                        Sequence<Sequence<OUString>>aFinalSplitSource(nLevelCount);
+                        for (sal_Int32 i = 0; i < nLevelCount; i++)
+                        {
+                            sal_Int32 nElemLabel = 0;
+                            aFinalSplitSource[nLevelCount - i - 1].realloc(aAnyCategories.getLength());
+                            for (auto const& elemLabel : aAnyCategories)
+                            {
+                                // make sure elemLabel[i] exists!
+                                if (elemLabel.getLength() > i)
+                                {
+                                    aFinalSplitSource[nLevelCount - i - 1][nElemLabel] = elemLabel[i].get<OUString>();
+                                    nElemLabel++;
+                                }
+                            }
+                        }
+                        return aFinalSplitSource;
+                    }
+                }
+                catch (const uno::Exception &)
+                {
+                    DBG_UNHANDLED_EXCEPTION("oox");
+                }
+            }
+            else
+            {
+                try
+                {
+                    uno::Reference< chart2::data::XDataSource > xCategoriesSource(xDataProvider->createDataSource(
+                        createArguments(rRange, bSeriesUsesColumns)));
+
+                    if (xCategoriesSource.is())
+                    {
+                        const Sequence< Reference< chart2::data::XLabeledDataSequence >> aCategories = xCategoriesSource->getDataSequences();
+                        if (aCategories.getLength() > 1)
+                        {
+                            //we have complex categories
+                            //sort the categories name
+                            Sequence<Sequence<OUString>> aFinalSplitSource(aCategories.getLength());
+                            std::transform(aCategories.begin(), aCategories.end(),
+                                std::reverse_iterator(aFinalSplitSource.end()),
+                                [](const Reference<chart2::data::XLabeledDataSequence>& xCat) {
+                                    return lcl_getLabelSequence(xCat->getValues()); });
+                            return aFinalSplitSource;
+                        }
+                    }
+                }
+                catch (const uno::Exception &)
+                {
+                    DBG_UNHANDLED_EXCEPTION("oox");
+                }
+            }
+        }
+    }
+
+    return Sequence< Sequence< OUString>>(0);
+}
+
+OUString ChartExport::parseFormula( const OUString& rRange )
+{
+    OUString aResult;
+    Reference< XFormulaParser > xParser;
+    uno::Reference< lang::XMultiServiceFactory > xSF = GetFB()->getModelFactory();
+    if( xSF.is() )
+    {
+        try
+        {
+            xParser.set( xSF->createInstance("com.sun.star.sheet.FormulaParser"), UNO_QUERY );
+        }
+        catch( Exception& )
+        {
+        }
+    }
+
+    SAL_WARN_IF(!xParser.is(), "oox", "creating formula parser failed");
+
+    if( xParser.is() )
+    {
+        Reference< XPropertySet > xParserProps( xParser, uno::UNO_QUERY );
+        // rRange is the result of a
+        // css::chart2::data::XDataSequence::getSourceRangeRepresentation()
+        // call that returns the range in the document's current UI notation.
+        // Creating a FormulaParser defaults to the same notation, for
+        // parseFormula() do not attempt to override the FormulaConvention
+        // property with css::sheet::AddressConvention::OOO or some such.
+        /* TODO: it would be much better to introduce a
+         * getSourceRangeRepresentation(css::sheet::AddressConvention) to
+         * return the ranges in a specific convention than converting them with
+         * the overhead of creating an XFormulaParser for each... */
+        uno::Sequence<sheet::FormulaToken> aTokens = xParser->parseFormula( rRange, CellAddress( 0, 0, 0 ) );
+        if( xParserProps.is() )
+        {
+            xParserProps->setPropertyValue("FormulaConvention", uno::makeAny(css::sheet::AddressConvention::XL_OOX) );
+        }
+        aResult = xParser->printFormula( aTokens, CellAddress( 0, 0, 0 ) );
+    }
+    else
+    {
+        //FIXME: currently just using simple converter, e.g $Sheet1.$A$1:$C$1 -> Sheet1!$A$1:$C$1
+        OUString aRange( rRange );
+        if( aRange.startsWith("$") )
+            aRange = aRange.copy(1);
+        aRange = aRange.replaceAll(".$", "!$" );
+        aResult = aRange;
+    }
+
+    return aResult;
+}
+
+void ChartExport::WriteChartObj( const Reference< XShape >& xShape, sal_Int32 nID, sal_Int32 nChartCount )
+{
+    FSHelperPtr pFS = GetFS();
+
+    Reference< XPropertySet > xShapeProps( xShape, UNO_QUERY );
+
+    pFS->startElementNS(mnXmlNamespace, XML_graphicFrame);
+
+    pFS->startElementNS(mnXmlNamespace, XML_nvGraphicFramePr);
+
+    // TODO: get the correct chart name chart id
+    OUString sName = "Object 1";
+    Reference< XNamed > xNamed( xShape, UNO_QUERY );
+    if (xNamed.is())
+        sName = xNamed->getName();
+
+    pFS->startElementNS( mnXmlNamespace, XML_cNvPr,
+                          XML_id,     OString::number(nID),
+                          XML_name,   sName.toUtf8());
+
+    OUString sURL;
+    if ( GetProperty( xShapeProps, "URL" ) )
+        mAny >>= sURL;
+    if( !sURL.isEmpty() )
+    {
+        OUString sRelId = mpFB->addRelation( mpFS->getOutputStream(),
+                oox::getRelationship(Relationship::HYPERLINK),
+                mpURLTransformer->getTransformedString(sURL),
+                mpURLTransformer->isExternalURL(sURL));
+
+        mpFS->singleElementNS( XML_a, XML_hlinkClick,
+                FSNS( XML_r,XML_id ), sRelId.toUtf8() );
+    }
+    pFS->endElementNS(mnXmlNamespace, XML_cNvPr);
+
+    pFS->singleElementNS(mnXmlNamespace, XML_cNvGraphicFramePr);
+
+    if( GetDocumentType() == DOCUMENT_PPTX )
+        pFS->singleElementNS(mnXmlNamespace, XML_nvPr);
+    pFS->endElementNS( mnXmlNamespace, XML_nvGraphicFramePr );
+
+    // visual chart properties
+    WriteShapeTransformation( xShape, mnXmlNamespace );
+
+    // writer chart object
+    pFS->startElement(FSNS(XML_a, XML_graphic));
+    pFS->startElement( FSNS( XML_a, XML_graphicData ),
+                       XML_uri, "http://schemas.openxmlformats.org/drawingml/2006/chart" );
+    OUString sId;
+    const char* sFullPath = nullptr;
+    const char* sRelativePath = nullptr;
+    switch( GetDocumentType() )
+    {
+        case DOCUMENT_DOCX:
+        {
+            sFullPath = "word/charts/chart";
+            sRelativePath = "charts/chart";
+            break;
+        }
+        case DOCUMENT_PPTX:
+        {
+            sFullPath = "ppt/charts/chart";
+            sRelativePath = "../charts/chart";
+            break;
+        }
+        case DOCUMENT_XLSX:
+        {
+            sFullPath = "xl/charts/chart";
+            sRelativePath = "../charts/chart";
+            break;
+        }
+        default:
+        {
+            sFullPath = "charts/chart";
+            sRelativePath = "charts/chart";
+            break;
+        }
+    }
+    OUString sFullStream = OUStringBuffer()
+                            .appendAscii(sFullPath)
+                            .append(nChartCount)
+                            .append( ".xml" )
+                            .makeStringAndClear();
+    OUString sRelativeStream = OUStringBuffer()
+                            .appendAscii(sRelativePath)
+                            .append(nChartCount)
+                            .append( ".xml" )
+                            .makeStringAndClear();
+    FSHelperPtr pChart = CreateOutputStream(
+            sFullStream,
+            sRelativeStream,
+            pFS->getOutputStream(),
+            "application/vnd.openxmlformats-officedocument.drawingml.chart+xml",
+            OUStringToOString(oox::getRelationship(Relationship::CHART), RTL_TEXTENCODING_UTF8).getStr(),
+            &sId );
+
+    XmlFilterBase* pFB = GetFB();
+    pFS->singleElement(  FSNS( XML_c, XML_chart ),
+            FSNS(XML_xmlns, XML_c), pFB->getNamespaceURL(OOX_NS(dmlChart)).toUtf8(),
+            FSNS(XML_xmlns, XML_r), pFB->getNamespaceURL(OOX_NS(officeRel)).toUtf8(),
+            FSNS(XML_r, XML_id), sId.toUtf8() );
+
+    pFS->endElement( FSNS( XML_a, XML_graphicData ) );
+    pFS->endElement( FSNS( XML_a, XML_graphic ) );
+    pFS->endElementNS( mnXmlNamespace, XML_graphicFrame );
+
+    SetFS( pChart );
+    ExportContent();
+}
+
+void ChartExport::InitRangeSegmentationProperties( const Reference< chart2::XChartDocument > & xChartDoc )
+{
+    if( !xChartDoc.is())
+        return;
+
+    try
+    {
+        Reference< chart2::data::XDataProvider > xDataProvider( xChartDoc->getDataProvider() );
+        OSL_ENSURE( xDataProvider.is(), "No DataProvider" );
+        if( xDataProvider.is())
+        {
+            mbHasCategoryLabels = lcl_hasCategoryLabels( xChartDoc );
+        }
+    }
+    catch( const uno::Exception & )
+    {
+        DBG_UNHANDLED_EXCEPTION("oox");
+    }
+}
+
+void ChartExport::ExportContent()
+{
+    Reference< chart2::XChartDocument > xChartDoc( getModel(), uno::UNO_QUERY );
+    OSL_ASSERT( xChartDoc.is() );
+    if( !xChartDoc.is() )
+        return;
+    InitRangeSegmentationProperties( xChartDoc );
+    // TODO: export chart
+    ExportContent_( );
+}
+
+void ChartExport::ExportContent_()
+{
+    Reference< css::chart::XChartDocument > xChartDoc( getModel(), uno::UNO_QUERY );
+    if( xChartDoc.is())
+    {
+        // determine if data comes from the outside
+        bool bIncludeTable = true;
+
+        Reference< chart2::XChartDocument > xNewDoc( xChartDoc, uno::UNO_QUERY );
+        if( xNewDoc.is())
+        {
+            // check if we have own data.  If so we must not export the complete
+            // range string, as this is our only indicator for having own or
+            // external data. @todo: fix this in the file format!
+            Reference< lang::XServiceInfo > xDPServiceInfo( xNewDoc->getDataProvider(), uno::UNO_QUERY );
+            if( ! (xDPServiceInfo.is() && xDPServiceInfo->getImplementationName() == "com.sun.star.comp.chart.InternalDataProvider" ))
+            {
+                bIncludeTable = false;
+            }
+        }
+        exportChartSpace( xChartDoc, bIncludeTable );
+    }
+    else
+    {
+        OSL_FAIL( "Couldn't export chart due to wrong XModel" );
+    }
+}
+
+void ChartExport::exportChartSpace( const Reference< css::chart::XChartDocument >& xChartDoc,
+                                    bool bIncludeTable )
+{
+    FSHelperPtr pFS = GetFS();
+    XmlFilterBase* pFB = GetFB();
+    pFS->startElement( FSNS( XML_c, XML_chartSpace ),
+            FSNS( XML_xmlns, XML_c ), pFB->getNamespaceURL(OOX_NS(dmlChart)).toUtf8(),
+            FSNS( XML_xmlns, XML_a ), pFB->getNamespaceURL(OOX_NS(dml)).toUtf8(),
+            FSNS( XML_xmlns, XML_r ), pFB->getNamespaceURL(OOX_NS(officeRel)).toUtf8());
+    // TODO: get the correct editing language
+    pFS->singleElement(FSNS(XML_c, XML_lang), XML_val, "en-US");
+
+    pFS->singleElement(FSNS(XML_c, XML_roundedCorners), XML_val, "0");
+
+    if( !bIncludeTable )
+    {
+        // TODO:external data
+    }
+    //XML_chart
+    exportChart(xChartDoc);
+
+    // TODO: printSettings
+    // TODO: style
+    // TODO: text properties
+    // TODO: shape properties
+    Reference< XPropertySet > xPropSet = xChartDoc->getArea();
+    if( xPropSet.is() )
+        exportShapeProps( xPropSet );
+
+    //XML_externalData
+    exportExternalData(xChartDoc);
+
+    pFS->endElement( FSNS( XML_c, XML_chartSpace ) );
+}
+
+void ChartExport::exportExternalData( const Reference< css::chart::XChartDocument >& xChartDoc )
+{
+    // Embedded external data is grab bagged for docx file hence adding export part of
+    // external data for docx files only.
+    if(GetDocumentType() != DOCUMENT_DOCX)
+        return;
+
+    OUString externalDataPath;
+    Reference< beans::XPropertySet > xDocPropSet( xChartDoc->getDiagram(), uno::UNO_QUERY );
+    if( xDocPropSet.is())
+    {
+        try
+        {
+            Any aAny( xDocPropSet->getPropertyValue( "ExternalData" ));
+            aAny >>= externalDataPath;
+        }
+        catch( beans::UnknownPropertyException & )
+        {
+            SAL_WARN("oox", "Required property not found in ChartDocument");
+        }
+    }
+    if(externalDataPath.isEmpty())
+        return;
+
+    // Here adding external data entry to relationship.
+    OUString relationPath = externalDataPath;
+    // Converting absolute path to relative path.
+    if( externalDataPath[ 0 ] != '.' && externalDataPath[ 1 ] != '.')
+    {
+        sal_Int32 nSepPos = externalDataPath.indexOf( '/', 0 );
+        if( nSepPos > 0)
+        {
+            relationPath = relationPath.copy( nSepPos,  ::std::max< sal_Int32 >( externalDataPath.getLength(), 0 ) -  nSepPos );
+            relationPath = ".." + relationPath;
+        }
+    }
+    FSHelperPtr pFS = GetFS();
+    OUString type = oox::getRelationship(Relationship::PACKAGE);
+    if (relationPath.endsWith(".bin"))
+        type = oox::getRelationship(Relationship::OLEOBJECT);
+
+    OUString sRelId = GetFB()->addRelation(pFS->getOutputStream(),
+                    type,
+                    relationPath);
+    pFS->singleElementNS(XML_c, XML_externalData, FSNS(XML_r, XML_id), sRelId.toUtf8());
+}
+
+void ChartExport::exportChart( const Reference< css::chart::XChartDocument >& xChartDoc )
+{
+    Reference< chart2::XChartDocument > xNewDoc( xChartDoc, uno::UNO_QUERY );
+    mxDiagram.set( xChartDoc->getDiagram() );
+    if( xNewDoc.is())
+        mxNewDiagram.set( xNewDoc->getFirstDiagram());
+
+    // get Properties of ChartDocument
+    bool bHasMainTitle = false;
+    OUString aSubTitle;
+    bool bHasLegend = false;
+    Reference< beans::XPropertySet > xDocPropSet( xChartDoc, uno::UNO_QUERY );
+    if( xDocPropSet.is())
+    {
+        try
+        {
+            Any aAny( xDocPropSet->getPropertyValue("HasMainTitle"));
+            aAny >>= bHasMainTitle;
+            aAny = xDocPropSet->getPropertyValue("HasLegend");
+            aAny >>= bHasLegend;
+        }
+        catch( beans::UnknownPropertyException & )
+        {
+            SAL_WARN("oox", "Required property not found in ChartDocument");
+        }
+    } // if( xDocPropSet.is())
+
+    Reference< beans::XPropertySet > xPropSubTitle( xChartDoc->getSubTitle(), UNO_QUERY );
+    if( xPropSubTitle.is())
+    {
+        try
+        {
+            xPropSubTitle->getPropertyValue("String") >>= aSubTitle;
+        }
+        catch( beans::UnknownPropertyException & )
+        {
+        }
+    }
+
+    // chart element
+    FSHelperPtr pFS = GetFS();
+    pFS->startElement(FSNS(XML_c, XML_chart));
+
+    // titles
+    if( bHasMainTitle )
+    {
+        exportTitle( xChartDoc->getTitle(), !aSubTitle.isEmpty() ? &aSubTitle : nullptr );
+        pFS->singleElement(FSNS(XML_c, XML_autoTitleDeleted), XML_val, "0");
+    }
+    else if( !aSubTitle.isEmpty() )
+    {
+        exportTitle( xChartDoc->getSubTitle(), nullptr );
+        pFS->singleElement(FSNS(XML_c, XML_autoTitleDeleted), XML_val, "0");
+    }
+    else
+    {
+        pFS->singleElement(FSNS(XML_c, XML_autoTitleDeleted), XML_val, "1");
+    }
+
+    InitPlotArea( );
+    if( mbIs3DChart )
+    {
+        exportView3D();
+
+        // floor
+        Reference< beans::XPropertySet > xFloor = mxNewDiagram->getFloor();
+        if( xFloor.is() )
+        {
+            pFS->startElement(FSNS(XML_c, XML_floor));
+            exportShapeProps( xFloor );
+            pFS->endElement( FSNS( XML_c, XML_floor ) );
+        }
+
+        // LibreOffice doesn't distinguish between sideWall and backWall (both are using the same color).
+        // It is controlled by the same Wall property.
+        Reference< beans::XPropertySet > xWall = mxNewDiagram->getWall();
+        if( xWall.is() )
+        {
+            // sideWall
+            pFS->startElement(FSNS(XML_c, XML_sideWall));
+            exportShapeProps( xWall );
+            pFS->endElement( FSNS( XML_c, XML_sideWall ) );
+
+            // backWall
+            pFS->startElement(FSNS(XML_c, XML_backWall));
+            exportShapeProps( xWall );
+            pFS->endElement( FSNS( XML_c, XML_backWall ) );
+        }
+
+    }
+    // plot area
+    exportPlotArea( xChartDoc );
+    // legend
+    if( bHasLegend )
+        exportLegend( xChartDoc );
+
+    uno::Reference<beans::XPropertySet> xDiagramPropSet(xChartDoc->getDiagram(), uno::UNO_QUERY);
+    uno::Any aPlotVisOnly = xDiagramPropSet->getPropertyValue("IncludeHiddenCells");
+    bool bIncludeHiddenCells = false;
+    aPlotVisOnly >>= bIncludeHiddenCells;
+    pFS->singleElement(FSNS(XML_c, XML_plotVisOnly), XML_val, ToPsz10(!bIncludeHiddenCells));
+
+    exportMissingValueTreatment(Reference<beans::XPropertySet>(mxDiagram, uno::UNO_QUERY));
+
+    pFS->endElement( FSNS( XML_c, XML_chart ) );
+}
+
+void ChartExport::exportMissingValueTreatment(const uno::Reference<beans::XPropertySet>& xPropSet)
+{
+    if (!xPropSet.is())
+        return;
+
+    sal_Int32 nVal = 0;
+    uno::Any aAny = xPropSet->getPropertyValue("MissingValueTreatment");
+    if (!(aAny >>= nVal))
+        return;
+
+    const char* pVal = nullptr;
+    switch (nVal)
+    {
+        case cssc::MissingValueTreatment::LEAVE_GAP:
+            pVal = "gap";
+        break;
+        case cssc::MissingValueTreatment::USE_ZERO:
+            pVal = "zero";
+        break;
+        case cssc::MissingValueTreatment::CONTINUE:
+            pVal = "span";
+        break;
+        default:
+            SAL_WARN("oox", "unknown MissingValueTreatment value");
+        break;
+    }
+
+    FSHelperPtr pFS = GetFS();
+    pFS->singleElement(FSNS(XML_c, XML_dispBlanksAs), XML_val, pVal);
+}
+
+void ChartExport::exportLegend( const Reference< css::chart::XChartDocument >& xChartDoc )
+{
+    FSHelperPtr pFS = GetFS();
+    pFS->startElement(FSNS(XML_c, XML_legend));
+
+    Reference< beans::XPropertySet > xProp( xChartDoc->getLegend(), uno::UNO_QUERY );
+    if( xProp.is() )
+    {
+        // position
+        css::chart::ChartLegendPosition aLegendPos = css::chart::ChartLegendPosition_NONE;
+        try
+        {
+            Any aAny( xProp->getPropertyValue( "Alignment" ));
+            aAny >>= aLegendPos;
+        }
+        catch( beans::UnknownPropertyException & )
+        {
+            SAL_WARN("oox", "Property Align not found in ChartLegend");
+        }
+
+        const char* strPos = nullptr;
+        switch( aLegendPos )
+        {
+            case css::chart::ChartLegendPosition_LEFT:
+                strPos = "l";
+                break;
+            case css::chart::ChartLegendPosition_RIGHT:
+                strPos = "r";
+                break;
+            case css::chart::ChartLegendPosition_TOP:
+                strPos = "t";
+                break;
+            case css::chart::ChartLegendPosition_BOTTOM:
+                strPos = "b";
+                break;
+            case css::chart::ChartLegendPosition_NONE:
+            case css::chart::ChartLegendPosition::ChartLegendPosition_MAKE_FIXED_SIZE:
+                // nothing
+                break;
+        }
+
+        if( strPos != nullptr )
+        {
+            pFS->singleElement(FSNS(XML_c, XML_legendPos), XML_val, strPos);
+        }
+
+        // legendEntry
+        Reference<chart2::XCoordinateSystemContainer> xCooSysContainer(mxNewDiagram, UNO_QUERY_THROW);
+        const Sequence<Reference<chart2::XCoordinateSystem>> xCooSysSequence(xCooSysContainer->getCoordinateSystems());
+
+        sal_Int32 nIndex = 0;
+        bool bShowLegendEntry;
+        for (const auto& rCooSys : xCooSysSequence)
+        {
+            PropertySet aCooSysProp(rCooSys);
+            bool bSwapXAndY = aCooSysProp.getBoolProperty(PROP_SwapXAndYAxis);
+
+            Reference<chart2::XChartTypeContainer> xChartTypeContainer(rCooSys, UNO_QUERY_THROW);
+            const Sequence<Reference<chart2::XChartType>> xChartTypeSequence(xChartTypeContainer->getChartTypes());
+            if (!xChartTypeSequence.hasElements())
+                continue;
+
+            for (const auto& rCT : xChartTypeSequence)
+            {
+                Reference<chart2::XDataSeriesContainer> xDSCont(rCT, UNO_QUERY);
+                if (!xDSCont.is())
+                    continue;
+
+                const Sequence<Reference<chart2::XDataSeries>> aDataSeriesSeq = xDSCont->getDataSeries();
+                if (bSwapXAndY)
+                    nIndex += aDataSeriesSeq.getLength() - 1;
+                for (const auto& rDataSeries : aDataSeriesSeq)
+                {
+                    PropertySet aSeriesProp(rDataSeries);
+                    bool bVaryColorsByPoint = aSeriesProp.getBoolProperty(PROP_VaryColorsByPoint);
+                    if (bVaryColorsByPoint)
+                    {
+                        Sequence<sal_Int32> deletedLegendEntriesSeq;
+                        aSeriesProp.getProperty(deletedLegendEntriesSeq, PROP_DeletedLegendEntries);
+                        for (auto& deletedLegendEntry : deletedLegendEntriesSeq)
+                        {
+                            pFS->startElement(FSNS(XML_c, XML_legendEntry));
+                            pFS->singleElement(FSNS(XML_c, XML_idx), XML_val,
+                                               OString::number(nIndex + deletedLegendEntry));
+                            pFS->singleElement(FSNS(XML_c, XML_delete), XML_val, "1");
+                            pFS->endElement(FSNS(XML_c, XML_legendEntry));
+                        }
+                        Reference<chart2::data::XDataSource> xDSrc(rDataSeries, UNO_QUERY);
+                        if (!xDSrc.is())
+                            continue;
+
+                        const Sequence<Reference<chart2::data::XLabeledDataSequence>> aDataSeqs = xDSrc->getDataSequences();
+                        for (const auto& rDataSeq : aDataSeqs)
+                        {
+                            Reference<chart2::data::XDataSequence> xValues = rDataSeq->getValues();
+                            if (!xValues.is())
+                                continue;
+
+                            sal_Int32 nDataSeqSize = xValues->getData().getLength();
+                            nIndex += nDataSeqSize;
+                        }
+                    }
+                    else
+                    {
+                        bShowLegendEntry = aSeriesProp.getBoolProperty(PROP_ShowLegendEntry);
+                        if (!bShowLegendEntry)
+                        {
+                            pFS->startElement(FSNS(XML_c, XML_legendEntry));
+                            pFS->singleElement(FSNS(XML_c, XML_idx), XML_val,
+                                               OString::number(nIndex));
+                            pFS->singleElement(FSNS(XML_c, XML_delete), XML_val, "1");
+                            pFS->endElement(FSNS(XML_c, XML_legendEntry));
+                        }
+                        bSwapXAndY ? nIndex-- : nIndex++;
+                    }
+                }
+                if (bSwapXAndY)
+                    nIndex += aDataSeriesSeq.getLength() + 1;
+            }
+        }
+
+        uno::Any aRelativePos = xProp->getPropertyValue("RelativePosition");
+        if (aRelativePos.hasValue())
+        {
+            pFS->startElement(FSNS(XML_c, XML_layout));
+            pFS->startElement(FSNS(XML_c, XML_manualLayout));
+
+            pFS->singleElement(FSNS(XML_c, XML_xMode), XML_val, "edge");
+            pFS->singleElement(FSNS(XML_c, XML_yMode), XML_val, "edge");
+            chart2::RelativePosition aPos = aRelativePos.get<chart2::RelativePosition>();
+
+            const double x = aPos.Primary;
+            const double y = aPos.Secondary;
+
+            pFS->singleElement(FSNS(XML_c, XML_x), XML_val, OString::number(x));
+            pFS->singleElement(FSNS(XML_c, XML_y), XML_val, OString::number(y));
+
+            uno::Any aRelativeSize = xProp->getPropertyValue("RelativeSize");
+            if (aRelativeSize.hasValue())
+            {
+                chart2::RelativeSize aSize = aRelativeSize.get<chart2::RelativeSize>();
+
+                const double w = aSize.Primary;
+                const double h = aSize.Secondary;
+
+                pFS->singleElement(FSNS(XML_c, XML_w), XML_val, OString::number(w));
+
+                pFS->singleElement(FSNS(XML_c, XML_h), XML_val, OString::number(h));
+            }
+
+            SAL_WARN_IF(aPos.Anchor != css::drawing::Alignment_TOP_LEFT, "oox", "unsupported anchor position");
+
+            pFS->endElement(FSNS(XML_c, XML_manualLayout));
+            pFS->endElement(FSNS(XML_c, XML_layout));
+        }
+
+        if (strPos != nullptr)
+        {
+            uno::Any aOverlay = xProp->getPropertyValue("Overlay");
+            if(aOverlay.get<bool>())
+                pFS->singleElement(FSNS(XML_c, XML_overlay), XML_val, "1");
+            else
+                pFS->singleElement(FSNS(XML_c, XML_overlay), XML_val, "0");
+        }
+
+        // shape properties
+        exportShapeProps( xProp );
+
+        // draw-chart:txPr text properties
+        exportTextProps( xProp );
+    }
+
+    pFS->endElement( FSNS( XML_c, XML_legend ) );
+}
+
+void ChartExport::exportTitle( const Reference< XShape >& xShape, const OUString* pSubText)
+{
+    OUString sText;
+    Reference< beans::XPropertySet > xPropSet( xShape, uno::UNO_QUERY );
+    if( xPropSet.is())
+    {
+        xPropSet->getPropertyValue("String") >>= sText;
+    }
+
+    // tdf#101322: add subtitle to title
+    if( pSubText )
+        sText = sText.isEmpty() ? *pSubText : sText + "\n" + *pSubText;
+
+    if( sText.isEmpty() )
+        return;
+
+    FSHelperPtr pFS = GetFS();
+    pFS->startElement(FSNS(XML_c, XML_title));
+
+    pFS->startElement(FSNS(XML_c, XML_tx));
+    pFS->startElement(FSNS(XML_c, XML_rich));
+
+    // TODO: bodyPr
+    const char* sWritingMode = nullptr;
+    bool bVertical = false;
+    xPropSet->getPropertyValue("StackedText") >>= bVertical;
+    if( bVertical )
+        sWritingMode = "wordArtVert";
+
+    sal_Int32 nRotation = 0;
+    xPropSet->getPropertyValue("TextRotation") >>= nRotation;
+
+    pFS->singleElement( FSNS( XML_a, XML_bodyPr ),
+            XML_vert, sWritingMode,
+            XML_rot, oox::drawingml::calcRotationValue(nRotation) );
+    // TODO: lstStyle
+    pFS->singleElement(FSNS(XML_a, XML_lstStyle));
+    // FIXME: handle multiple paragraphs to parse aText
+    pFS->startElement(FSNS(XML_a, XML_p));
+
+    pFS->startElement(FSNS(XML_a, XML_pPr));
+
+    bool bDummy = false;
+    sal_Int32 nDummy;
+    WriteRunProperties(xPropSet, false, XML_defRPr, true, bDummy, nDummy );
+
+    pFS->endElement( FSNS( XML_a, XML_pPr ) );
+
+    pFS->startElement(FSNS(XML_a, XML_r));
+    bDummy = false;
+    WriteRunProperties( xPropSet, false, XML_rPr, true, bDummy, nDummy );
+    pFS->startElement(FSNS(XML_a, XML_t));
+    pFS->writeEscaped( sText );
+    pFS->endElement( FSNS( XML_a, XML_t ) );
+    pFS->endElement( FSNS( XML_a, XML_r ) );
+
+    pFS->endElement( FSNS( XML_a, XML_p ) );
+
+    pFS->endElement( FSNS( XML_c, XML_rich ) );
+    pFS->endElement( FSNS( XML_c, XML_tx ) );
+
+    uno::Any aManualLayout = xPropSet->getPropertyValue("RelativePosition");
+    if (aManualLayout.hasValue())
+    {
+        pFS->startElement(FSNS(XML_c, XML_layout));
+        pFS->startElement(FSNS(XML_c, XML_manualLayout));
+        pFS->singleElement(FSNS(XML_c, XML_xMode), XML_val, "edge");
+        pFS->singleElement(FSNS(XML_c, XML_yMode), XML_val, "edge");
+
+        Reference<embed::XVisualObject> xVisObject(mxChartModel, uno::UNO_QUERY);
+        awt::Size aPageSize = xVisObject->getVisualAreaSize(embed::Aspects::MSOLE_CONTENT);
+
+        awt::Size aSize = xShape->getSize();
+        awt::Point aPos2 = xShape->getPosition();
+        // rotated shapes need special handling...
+        double fSin = fabs(sin(basegfx::deg2rad(nRotation*0.01)));
+        // remove part of height from X direction, if title is rotated down
+        if( nRotation*0.01 > 180.0 )
+            aPos2.X -= static_cast<sal_Int32>(fSin * aSize.Height + 0.5);
+        // remove part of width from Y direction, if title is rotated up
+        else if( nRotation*0.01 > 0.0 )
+            aPos2.Y -= static_cast<sal_Int32>(fSin * aSize.Width + 0.5);
+
+        double x = static_cast<double>(aPos2.X) / static_cast<double>(aPageSize.Width);
+        double y = static_cast<double>(aPos2.Y) / static_cast<double>(aPageSize.Height);
+        /*
+        pFS->singleElement(FSNS(XML_c, XML_wMode), XML_val, "edge");
+        pFS->singleElement(FSNS(XML_c, XML_hMode), XML_val, "edge");
+                */
+        pFS->singleElement(FSNS(XML_c, XML_x), XML_val, OString::number(x));
+        pFS->singleElement(FSNS(XML_c, XML_y), XML_val, OString::number(y));
+        /*
+        pFS->singleElement(FSNS(XML_c, XML_w), XML_val, "");
+        pFS->singleElement(FSNS(XML_c, XML_h), XML_val, "");
+                */
+        pFS->endElement(FSNS(XML_c, XML_manualLayout));
+        pFS->endElement(FSNS(XML_c, XML_layout));
+    }
+
+    pFS->singleElement(FSNS(XML_c, XML_overlay), XML_val, "0");
+
+    // shape properties
+    if( xPropSet.is() )
+    {
+        exportShapeProps( xPropSet );
+    }
+
+    pFS->endElement( FSNS( XML_c, XML_title ) );
+}
+
+void ChartExport::exportPlotArea( const Reference< css::chart::XChartDocument >& xChartDoc )
+{
+    Reference< chart2::XCoordinateSystemContainer > xBCooSysCnt( mxNewDiagram, uno::UNO_QUERY );
+    if( ! xBCooSysCnt.is())
+        return;
+
+    // plot-area element
+
+    FSHelperPtr pFS = GetFS();
+    pFS->startElement(FSNS(XML_c, XML_plotArea));
+
+    Reference<beans::XPropertySet> xWall(mxNewDiagram, uno::UNO_QUERY);
+    if( xWall.is() )
+    {
+        uno::Any aAny = xWall->getPropertyValue("RelativePosition");
+        if (aAny.hasValue())
+        {
+            chart2::RelativePosition aPos = aAny.get<chart2::RelativePosition>();
+            aAny = xWall->getPropertyValue("RelativeSize");
+            chart2::RelativeSize aSize = aAny.get<chart2::RelativeSize>();
+            uno::Reference< css::chart::XDiagramPositioning > xDiagramPositioning( xChartDoc->getDiagram(), uno::UNO_QUERY );
+            exportManualLayout(aPos, aSize, xDiagramPositioning->isExcludingDiagramPositioning() );
+        }
+    }
+
+    // chart type
+    const Sequence< Reference< chart2::XCoordinateSystem > >
+        aCooSysSeq( xBCooSysCnt->getCoordinateSystems());
+    for( const auto& rCS : aCooSysSeq )
+    {
+        Reference< chart2::XChartTypeContainer > xCTCnt( rCS, uno::UNO_QUERY );
+        if( ! xCTCnt.is())
+            continue;
+        mnSeriesCount=0;
+        const Sequence< Reference< chart2::XChartType > > aCTSeq( xCTCnt->getChartTypes());
+        for( const auto& rCT : aCTSeq )
+        {
+            Reference< chart2::XDataSeriesContainer > xDSCnt( rCT, uno::UNO_QUERY );
+            if( ! xDSCnt.is())
+                return;
+            Reference< chart2::XChartType > xChartType( rCT, uno::UNO_QUERY );
+            if( ! xChartType.is())
+                continue;
+            // note: if xDSCnt.is() then also aCTSeq[nCTIdx]
+            OUString aChartType( xChartType->getChartType());
+            sal_Int32 eChartType = lcl_getChartType( aChartType );
+            switch( eChartType )
+            {
+                case chart::TYPEID_BAR:
+                    {
+                        exportBarChart( xChartType );
+                        break;
+                    }
+                case chart::TYPEID_AREA:
+                    {
+                        exportAreaChart( xChartType );
+                        break;
+                    }
+                case chart::TYPEID_LINE:
+                    {
+                        exportLineChart( xChartType );
+                        break;
+                    }
+                case chart::TYPEID_BUBBLE:
+                    {
+                        exportBubbleChart( xChartType );
+                        break;
+                    }
+                case chart::TYPEID_OFPIE:
+                    {
+                        break;
+                    }
+                case chart::TYPEID_DOUGHNUT:
+                case chart::TYPEID_PIE:
+                    {
+                        exportPieChart( xChartType );
+                        break;
+                    }
+                case chart::TYPEID_RADARLINE:
+                case chart::TYPEID_RADARAREA:
+                    {
+                        exportRadarChart( xChartType );
+                        break;
+                    }
+                case chart::TYPEID_SCATTER:
+                    {
+                        exportScatterChart( xChartType );
+                        break;
+                    }
+                case chart::TYPEID_STOCK:
+                    {
+                        exportStockChart( xChartType );
+                        break;
+                    }
+                case chart::TYPEID_SURFACE:
+                    {
+                        exportSurfaceChart( xChartType );
+                        break;
+                    }
+                default:
+                    {
+                        SAL_WARN("oox", "ChartExport::exportPlotArea -- not support chart type");
+                        break;
+                    }
+            }
+
+        }
+    }
+    //Axis Data
+    exportAxes( );
+    // Data Table
+    exportDataTable();
+
+    // shape properties
+    /*
+     * Export the Plot area Shape Properties
+     * eg: Fill and Outline
+     */
+    Reference< css::chart::X3DDisplay > xWallFloorSupplier( mxDiagram, uno::UNO_QUERY );
+    // tdf#114139 For 2D charts Plot Area equivalent is Chart Wall.
+    // Unfortunately LibreOffice doesn't have Plot Area equivalent for 3D charts.
+    // It means that Plot Area couldn't be displayed and changed for 3D chars in LibreOffice.
+    // We cannot write Wall attributes into Plot Area for 3D charts, because Wall us used as background wall.
+    if( !mbIs3DChart && xWallFloorSupplier.is() )
+    {
+        Reference< beans::XPropertySet > xWallPropSet = xWallFloorSupplier->getWall();
+        if( xWallPropSet.is() )
+        {
+            uno::Any aAny = xWallPropSet->getPropertyValue("LineStyle");
+            sal_Int32 eChartType = getChartType( );
+            // Export LineStyle_NONE instead of default linestyle of PlotArea border, because LibreOffice
+            // make invisible the Wall shape properties, in case of these charts. Or in the future set
+            // the default LineStyle of these charts to LineStyle_NONE.
+            bool noSupportWallProp = ( (eChartType == chart::TYPEID_PIE) || (eChartType == chart::TYPEID_RADARLINE) || (eChartType == chart::TYPEID_RADARAREA) );
+            if ( noSupportWallProp && (aAny != drawing::LineStyle_NONE) )
+            {
+                xWallPropSet->setPropertyValue( "LineStyle", uno::Any(drawing::LineStyle_NONE) );
+            }
+            exportShapeProps( xWallPropSet );
+        }
+    }
+
+    pFS->endElement( FSNS( XML_c, XML_plotArea ) );
+
+}
+
+void ChartExport::exportManualLayout(const css::chart2::RelativePosition& rPos,
+                                     const css::chart2::RelativeSize& rSize,
+                                     const bool bIsExcludingDiagramPositioning)
+{
+    FSHelperPtr pFS = GetFS();
+    pFS->startElement(FSNS(XML_c, XML_layout));
+    pFS->startElement(FSNS(XML_c, XML_manualLayout));
+
+    // By default layoutTarget is set to "outer" and we shouldn't save it in that case
+    if ( bIsExcludingDiagramPositioning )
+    {
+        pFS->singleElement(FSNS(XML_c, XML_layoutTarget), XML_val, "inner");
+    }
+    pFS->singleElement(FSNS(XML_c, XML_xMode), XML_val, "edge");
+    pFS->singleElement(FSNS(XML_c, XML_yMode), XML_val, "edge");
+
+    double x = rPos.Primary;
+    double y = rPos.Secondary;
+    const double w = rSize.Primary;
+    const double h = rSize.Secondary;
+    switch (rPos.Anchor)
+    {
+        case drawing::Alignment_LEFT:
+            y -= (h/2);
+        break;
+        case drawing::Alignment_TOP_LEFT:
+        break;
+        case drawing::Alignment_BOTTOM_LEFT:
+            y -= h;
+        break;
+        case drawing::Alignment_TOP:
+            x -= (w/2);
+        break;
+        case drawing::Alignment_CENTER:
+            x -= (w/2);
+            y -= (h/2);
+        break;
+        case drawing::Alignment_BOTTOM:
+            x -= (w/2);
+            y -= h;
+        break;
+        case drawing::Alignment_TOP_RIGHT:
+            x -= w;
+        break;
+        case drawing::Alignment_BOTTOM_RIGHT:
+            x -= w;
+            y -= h;
+        break;
+        case drawing::Alignment_RIGHT:
+            y -= (h/2);
+            x -= w;
+        break;
+        default:
+            SAL_WARN("oox", "unhandled alignment case for manual layout export " << static_cast<sal_uInt16>(rPos.Anchor));
+    }
+
+    pFS->singleElement(FSNS(XML_c, XML_x), XML_val, OString::number(x));
+
+    pFS->singleElement(FSNS(XML_c, XML_y), XML_val, OString::number(y));
+
+    pFS->singleElement(FSNS(XML_c, XML_w), XML_val, OString::number(w));
+
+    pFS->singleElement(FSNS(XML_c, XML_h), XML_val, OString::number(h));
+
+    pFS->endElement(FSNS(XML_c, XML_manualLayout));
+    pFS->endElement(FSNS(XML_c, XML_layout));
+}
+
+void ChartExport::exportFill( const Reference< XPropertySet >& xPropSet )
+{
+    if ( !GetProperty( xPropSet, "FillStyle" ) )
+        return;
+    FillStyle aFillStyle( FillStyle_NONE );
+    xPropSet->getPropertyValue( "FillStyle" ) >>= aFillStyle;
+    switch( aFillStyle )
+    {
+        case FillStyle_GRADIENT :
+            exportGradientFill( xPropSet );
+            break;
+        case FillStyle_BITMAP :
+            exportBitmapFill( xPropSet );
+            break;
+        case FillStyle_HATCH:
+            exportHatch(xPropSet);
+        break;
+        default:
+            WriteFill( xPropSet );
+    }
+}
+
+void ChartExport::exportHatch( const Reference< XPropertySet >& xPropSet )
+{
+    if (!xPropSet.is())
+        return;
+
+    if (GetProperty(xPropSet, "FillHatchName"))
+    {
+        OUString aHatchName;
+        mAny >>= aHatchName;
+        uno::Reference< lang::XMultiServiceFactory > xFact( getModel(), uno::UNO_QUERY );
+        uno::Reference< container::XNameAccess > xHatchTable( xFact->createInstance("com.sun.star.drawing.HatchTable"), uno::UNO_QUERY );
+        uno::Any rValue = xHatchTable->getByName(aHatchName);
+        css::drawing::Hatch aHatch;
+        rValue >>= aHatch;
+        WritePattFill(xPropSet, aHatch);
+    }
+
+}
+
+void ChartExport::exportBitmapFill( const Reference< XPropertySet >& xPropSet )
+{
+    if( !xPropSet.is() )
+        return;
+
+    OUString sFillBitmapName;
+    xPropSet->getPropertyValue("FillBitmapName") >>= sFillBitmapName;
+
+    uno::Reference< lang::XMultiServiceFactory > xFact( getModel(), uno::UNO_QUERY );
+    try
+    {
+        uno::Reference< container::XNameAccess > xBitmapTable( xFact->createInstance("com.sun.star.drawing.BitmapTable"), uno::UNO_QUERY );
+        uno::Any rValue = xBitmapTable->getByName( sFillBitmapName );
+        if (rValue.has<uno::Reference<awt::XBitmap>>())
+        {
+            uno::Reference<awt::XBitmap> xBitmap = rValue.get<uno::Reference<awt::XBitmap>>();
+            uno::Reference<graphic::XGraphic> xGraphic(xBitmap, uno::UNO_QUERY);
+            if (xGraphic.is())
+            {
+                WriteXGraphicBlipFill(xPropSet, xGraphic, XML_a, true, true);
+            }
+        }
+    }
+    catch (const uno::Exception &)
+    {
+        TOOLS_WARN_EXCEPTION("oox", "ChartExport::exportBitmapFill");
+    }
+}
+
+void ChartExport::exportGradientFill( const Reference< XPropertySet >& xPropSet )
+{
+    if( !xPropSet.is() )
+        return;
+
+    OUString sFillGradientName;
+    xPropSet->getPropertyValue("FillGradientName") >>= sFillGradientName;
+
+    awt::Gradient aGradient;
+    awt::Gradient aTransparenceGradient;
+    uno::Reference< lang::XMultiServiceFactory > xFact( getModel(), uno::UNO_QUERY );
+    try
+    {
+        uno::Reference< container::XNameAccess > xGradient( xFact->createInstance("com.sun.star.drawing.GradientTable"), uno::UNO_QUERY );
+        uno::Any rGradientValue = xGradient->getByName( sFillGradientName );
+        if( rGradientValue >>= aGradient )
+        {
+            mpFS->startElementNS(XML_a, XML_gradFill);
+            OUString sFillTransparenceGradientName;
+            if( (xPropSet->getPropertyValue("FillTransparenceGradientName") >>= sFillTransparenceGradientName) && !sFillTransparenceGradientName.isEmpty())
+            {
+                uno::Reference< container::XNameAccess > xTransparenceGradient(xFact->createInstance("com.sun.star.drawing.TransparencyGradientTable"), uno::UNO_QUERY);
+                uno::Any rTransparenceValue = xTransparenceGradient->getByName(sFillTransparenceGradientName);
+                rTransparenceValue >>= aTransparenceGradient;
+                WriteGradientFill(aGradient, aTransparenceGradient);
+            }
+            else
+            {
+                WriteGradientFill(aGradient, aTransparenceGradient, xPropSet);
+            }
+            mpFS->endElementNS(XML_a, XML_gradFill);
+        }
+    }
+    catch (const uno::Exception &)
+    {
+        TOOLS_INFO_EXCEPTION("oox", "ChartExport::exportGradientFill");
+    }
+}
+
+void ChartExport::exportDataTable( )
+{
+    FSHelperPtr pFS = GetFS();
+    Reference< beans::XPropertySet > aPropSet( mxDiagram, uno::UNO_QUERY );
+
+    bool bShowVBorder = false;
+    bool bShowHBorder = false;
+    bool bShowOutline = false;
+
+    if (GetProperty( aPropSet, "DataTableHBorder"))
+        mAny >>= bShowHBorder;
+    if (GetProperty( aPropSet, "DataTableVBorder"))
+        mAny >>= bShowVBorder;
+    if (GetProperty( aPropSet, "DataTableOutline"))
+        mAny >>= bShowOutline;
+
+    if (!(bShowVBorder || bShowHBorder || bShowOutline))
+        return;
+
+    pFS->startElement(FSNS(XML_c, XML_dTable));
+    if (bShowHBorder)
+        pFS->singleElement( FSNS( XML_c, XML_showHorzBorder ),
+                        XML_val, "1" );
+    if (bShowVBorder)
+        pFS->singleElement(FSNS(XML_c, XML_showVertBorder), XML_val, "1");
+    if (bShowOutline)
+        pFS->singleElement(FSNS(XML_c, XML_showOutline), XML_val, "1");
+
+    pFS->endElement(  FSNS( XML_c, XML_dTable));
+
+}
+void ChartExport::exportAreaChart( const Reference< chart2::XChartType >& xChartType )
+{
+    FSHelperPtr pFS = GetFS();
+    sal_Int32 nTypeId = XML_areaChart;
+    if( mbIs3DChart )
+        nTypeId = XML_area3DChart;
+    pFS->startElement(FSNS(XML_c, nTypeId));
+
+    exportGrouping( );
+    bool bPrimaryAxes = true;
+    exportAllSeries(xChartType, bPrimaryAxes);
+    exportAxesId(bPrimaryAxes);
+
+    pFS->endElement( FSNS( XML_c, nTypeId ) );
+}
+
+void ChartExport::exportBarChart( const Reference< chart2::XChartType >& xChartType )
+{
+    sal_Int32 nTypeId = XML_barChart;
+    if( mbIs3DChart )
+        nTypeId = XML_bar3DChart;
+    FSHelperPtr pFS = GetFS();
+    pFS->startElement(FSNS(XML_c, nTypeId));
+    // bar direction
+    bool bVertical = false;
+    Reference< XPropertySet > xPropSet( mxDiagram , uno::UNO_QUERY);
+    if( GetProperty( xPropSet, "Vertical" ) )
+        mAny >>= bVertical;
+
+    const char* bardir = bVertical? "bar":"col";
+    pFS->singleElement(FSNS(XML_c, XML_barDir), XML_val, bardir);
+
+    exportGrouping( true );
+
+    exportVaryColors(xChartType);
+
+    bool bPrimaryAxes = true;
+    exportAllSeries(xChartType, bPrimaryAxes);
+
+    Reference< XPropertySet > xTypeProp( xChartType, uno::UNO_QUERY );
+
+    if( xTypeProp.is() && GetProperty( xTypeProp, "GapwidthSequence") )
+    {
+        uno::Sequence< sal_Int32 > aBarPositionSequence;
+        mAny >>= aBarPositionSequence;
+        if( aBarPositionSequence.hasElements() )
+        {
+            sal_Int32 nGapWidth = aBarPositionSequence[0];
+            pFS->singleElement(FSNS(XML_c, XML_gapWidth), XML_val, OString::number(nGapWidth));
+        }
+    }
+
+    if( mbIs3DChart )
+    {
+        // Shape
+        namespace cssc = css::chart;
+        sal_Int32 nGeom3d = cssc::ChartSolidType::RECTANGULAR_SOLID;
+        if( xPropSet.is() && GetProperty( xPropSet, "SolidType") )
+            mAny >>= nGeom3d;
+        const char* sShapeType = nullptr;
+        switch( nGeom3d )
+        {
+            case cssc::ChartSolidType::RECTANGULAR_SOLID:
+                sShapeType = "box";
+                break;
+            case cssc::ChartSolidType::CONE:
+                sShapeType = "cone";
+                break;
+            case cssc::ChartSolidType::CYLINDER:
+                sShapeType = "cylinder";
+                break;
+            case cssc::ChartSolidType::PYRAMID:
+                sShapeType = "pyramid";
+                break;
+        }
+        pFS->singleElement(FSNS(XML_c, XML_shape), XML_val, sShapeType);
+    }
+
+    //overlap
+    if( !mbIs3DChart && xTypeProp.is() && GetProperty( xTypeProp, "OverlapSequence") )
+    {
+        uno::Sequence< sal_Int32 > aBarPositionSequence;
+        mAny >>= aBarPositionSequence;
+        if( aBarPositionSequence.hasElements() )
+        {
+            sal_Int32 nOverlap = aBarPositionSequence[0];
+            // Stacked/Percent Bar/Column chart Overlap-workaround
+            // Export the Overlap value with 100% for stacked charts,
+            // because the default overlap value of the Bar/Column chart is 0% and
+            // LibreOffice do nothing with the overlap value in Stacked charts case,
+            // unlike the MS Office, which is interpreted differently.
+            if( ( mbStacked || mbPercent ) && nOverlap != 100 )
+            {
+                nOverlap = 100;
+                pFS->singleElement(FSNS(XML_c, XML_overlap), XML_val, OString::number(nOverlap));
+            }
+            else // Normal bar chart
+            {
+                pFS->singleElement(FSNS(XML_c, XML_overlap), XML_val, OString::number(nOverlap));
+            }
+        }
+    }
+
+    exportAxesId(bPrimaryAxes);
+
+    pFS->endElement( FSNS( XML_c, nTypeId ) );
+}
+
+void ChartExport::exportBubbleChart( const Reference< chart2::XChartType >& xChartType )
+{
+    FSHelperPtr pFS = GetFS();
+    pFS->startElement(FSNS(XML_c, XML_bubbleChart));
+
+    exportVaryColors(xChartType);
+
+    bool bPrimaryAxes = true;
+    exportAllSeries(xChartType, bPrimaryAxes);
+
+    exportAxesId(bPrimaryAxes);
+
+    pFS->endElement( FSNS( XML_c, XML_bubbleChart ) );
+}
+
+void ChartExport::exportDoughnutChart( const Reference< chart2::XChartType >& xChartType )
+{
+    FSHelperPtr pFS = GetFS();
+    pFS->startElement(FSNS(XML_c, XML_doughnutChart));
+
+    exportVaryColors(xChartType);
+
+    bool bPrimaryAxes = true;
+    exportAllSeries(xChartType, bPrimaryAxes);
+    // firstSliceAng
+    exportFirstSliceAng( );
+    //FIXME: holeSize
+    pFS->singleElement(FSNS(XML_c, XML_holeSize), XML_val, OString::number(50));
+
+    pFS->endElement( FSNS( XML_c, XML_doughnutChart ) );
+}
+
+namespace {
+
+std::vector<Sequence<Reference<chart2::XDataSeries> > > splitDataSeriesByAxis(const Reference< chart2::XChartType >& xChartType)
+{
+    std::vector<Sequence<Reference<chart2::XDataSeries> > > aSplitSeries;
+    std::map<sal_Int32, size_t> aMapAxisToIndex;
+
+    Reference< chart2::XDataSeriesContainer > xDSCnt( xChartType, uno::UNO_QUERY );
+    if(xDSCnt.is())
+    {
+        sal_Int32 nAxisIndexOfFirstSeries = -1;
+        const Sequence< Reference< chart2::XDataSeries > > aSeriesSeq( xDSCnt->getDataSeries());
+        for (const uno::Reference<chart2::XDataSeries>& xSeries : aSeriesSeq)
+        {
+            Reference<beans::XPropertySet> xPropSet(xSeries, uno::UNO_QUERY);
+            if (!xPropSet.is())
+                continue;
+
+            sal_Int32 nAxisIndex = -1;
+            uno::Any aAny = xPropSet->getPropertyValue("AttachedAxisIndex");
+            aAny >>= nAxisIndex;
+            size_t nVectorPos = 0;
+            if (nAxisIndexOfFirstSeries == -1)
+            {
+                nAxisIndexOfFirstSeries = nAxisIndex;
+            }
+
+            auto it = aMapAxisToIndex.find(nAxisIndex);
+            if (it == aMapAxisToIndex.end())
+            {
+                aSplitSeries.emplace_back();
+                nVectorPos = aSplitSeries.size() - 1;
+                aMapAxisToIndex.insert(std::pair<sal_Int32, size_t>(nAxisIndex, nVectorPos));
+            }
+            else
+            {
+                nVectorPos = it->second;
+            }
+
+            uno::Sequence<Reference<chart2::XDataSeries> >& rAxisSeriesSeq = aSplitSeries[nVectorPos];
+            sal_Int32 nLength = rAxisSeriesSeq.getLength();
+            rAxisSeriesSeq.realloc(nLength + 1);
+            rAxisSeriesSeq[nLength] = xSeries;
+        }
+        // if the first series attached to secondary axis, then export those series first, which are attached to primary axis
+        // also the MS Office export every time in this order
+        if ( aSplitSeries.size() > 1 && nAxisIndexOfFirstSeries == 1 )
+        {
+            std::swap( aSplitSeries[0], aSplitSeries[1] );
+        }
+    }
+
+    return aSplitSeries;
+}
+
+}
+
+void ChartExport::exportLineChart( const Reference< chart2::XChartType >& xChartType )
+{
+    FSHelperPtr pFS = GetFS();
+    std::vector<Sequence<Reference<chart2::XDataSeries> > > aSplitDataSeries = splitDataSeriesByAxis(xChartType);
+    for (auto & splitDataSeries : aSplitDataSeries)
+    {
+        if (!splitDataSeries.hasElements())
+            continue;
+
+        sal_Int32 nTypeId = XML_lineChart;
+        if( mbIs3DChart )
+            nTypeId = XML_line3DChart;
+        pFS->startElement(FSNS(XML_c, nTypeId));
+
+        exportGrouping( );
+
+        exportVaryColors(xChartType);
+        // TODO: show marker symbol in series?
+        bool bPrimaryAxes = true;
+        exportSeries(xChartType, splitDataSeries, bPrimaryAxes);
+
+        // show marker?
+        sal_Int32 nSymbolType = css::chart::ChartSymbolType::NONE;
+        Reference< XPropertySet > xPropSet( mxDiagram , uno::UNO_QUERY);
+        if( GetProperty( xPropSet, "SymbolType" ) )
+            mAny >>= nSymbolType;
+
+        if( !mbIs3DChart )
+        {
+            exportHiLowLines();
+            exportUpDownBars(xChartType);
+            const char* marker = nSymbolType == css::chart::ChartSymbolType::NONE? "0":"1";
+            pFS->singleElement(FSNS(XML_c, XML_marker), XML_val, marker);
+        }
+
+        exportAxesId(bPrimaryAxes, true);
+
+        pFS->endElement( FSNS( XML_c, nTypeId ) );
+    }
+}
+
+void ChartExport::exportPieChart( const Reference< chart2::XChartType >& xChartType )
+{
+    sal_Int32 eChartType = getChartType( );
+    if(eChartType == chart::TYPEID_DOUGHNUT)
+    {
+        exportDoughnutChart( xChartType );
+        return;
+    }
+    FSHelperPtr pFS = GetFS();
+    sal_Int32 nTypeId = XML_pieChart;
+    if( mbIs3DChart )
+        nTypeId = XML_pie3DChart;
+    pFS->startElement(FSNS(XML_c, nTypeId));
+
+    exportVaryColors(xChartType);
+
+    bool bPrimaryAxes = true;
+    exportAllSeries(xChartType, bPrimaryAxes);
+
+    if( !mbIs3DChart )
+    {
+        // firstSliceAng
+        exportFirstSliceAng( );
+    }
+
+    pFS->endElement( FSNS( XML_c, nTypeId ) );
+}
+
+void ChartExport::exportRadarChart( const Reference< chart2::XChartType >& xChartType)
+{
+    FSHelperPtr pFS = GetFS();
+    pFS->startElement(FSNS(XML_c, XML_radarChart));
+
+    // radarStyle
+    sal_Int32 eChartType = getChartType( );
+    const char* radarStyle = nullptr;
+    if( eChartType == chart::TYPEID_RADARAREA )
+        radarStyle = "filled";
+    else
+        radarStyle = "marker";
+    pFS->singleElement(FSNS(XML_c, XML_radarStyle), XML_val, radarStyle);
+
+    exportVaryColors(xChartType);
+    bool bPrimaryAxes = true;
+    exportAllSeries(xChartType, bPrimaryAxes);
+    exportAxesId(bPrimaryAxes);
+
+    pFS->endElement( FSNS( XML_c, XML_radarChart ) );
+}
+
+void ChartExport::exportScatterChartSeries( const Reference< chart2::XChartType >& xChartType,
+        css::uno::Sequence<css::uno::Reference<chart2::XDataSeries>>* pSeries)
+{
+    FSHelperPtr pFS = GetFS();
+    pFS->startElement(FSNS(XML_c, XML_scatterChart));
+    // TODO:scatterStyle
+
+    sal_Int32 nSymbolType = css::chart::ChartSymbolType::NONE;
+    Reference< XPropertySet > xPropSet( mxDiagram , uno::UNO_QUERY);
+    if( GetProperty( xPropSet, "SymbolType" ) )
+        mAny >>= nSymbolType;
+
+    const char* scatterStyle = "lineMarker";
+    if (nSymbolType == css::chart::ChartSymbolType::NONE)
+    {
+        scatterStyle = "line";
+    }
+
+    pFS->singleElement(FSNS(XML_c, XML_scatterStyle), XML_val, scatterStyle);
+
+    exportVaryColors(xChartType);
+    // FIXME: should export xVal and yVal
+    bool bPrimaryAxes = true;
+    if (pSeries)
+        exportSeries(xChartType, *pSeries, bPrimaryAxes);
+    exportAxesId(bPrimaryAxes);
+
+    pFS->endElement( FSNS( XML_c, XML_scatterChart ) );
+}
+
+void ChartExport::exportScatterChart( const Reference< chart2::XChartType >& xChartType )
+{
+    std::vector<Sequence<Reference<chart2::XDataSeries> > > aSplitDataSeries = splitDataSeriesByAxis(xChartType);
+    bool bExported = false;
+    for (auto & splitDataSeries : aSplitDataSeries)
+    {
+        if (!splitDataSeries.hasElements())
+            continue;
+
+        bExported = true;
+        exportScatterChartSeries(xChartType, &splitDataSeries);
+    }
+    if (!bExported)
+        exportScatterChartSeries(xChartType, nullptr);
+}
+
+void ChartExport::exportStockChart( const Reference< chart2::XChartType >& xChartType )
+{
+    FSHelperPtr pFS = GetFS();
+    pFS->startElement(FSNS(XML_c, XML_stockChart));
+
+    bool bPrimaryAxes = true;
+    Reference< chart2::XDataSeriesContainer > xDSCnt( xChartType, uno::UNO_QUERY );
+    if(xDSCnt.is())
+        exportCandleStickSeries( xDSCnt->getDataSeries(), bPrimaryAxes );
+
+    // export stock properties
+    Reference< css::chart::XStatisticDisplay > xStockPropProvider( mxDiagram, uno::UNO_QUERY );
+    if( xStockPropProvider.is())
+    {
+        exportHiLowLines();
+        exportUpDownBars(xChartType);
+    }
+
+    exportAxesId(bPrimaryAxes);
+
+    pFS->endElement( FSNS( XML_c, XML_stockChart ) );
+}
+
+void ChartExport::exportHiLowLines()
+{
+    FSHelperPtr pFS = GetFS();
+    // export the chart property
+    Reference< css::chart::XStatisticDisplay > xChartPropProvider( mxDiagram, uno::UNO_QUERY );
+
+    if (!xChartPropProvider.is())
+        return;
+
+    Reference< beans::XPropertySet > xStockPropSet = xChartPropProvider->getMinMaxLine();
+    if( !xStockPropSet.is() )
+        return;
+
+    pFS->startElement(FSNS(XML_c, XML_hiLowLines));
+    exportShapeProps( xStockPropSet );
+    pFS->endElement( FSNS( XML_c, XML_hiLowLines ) );
+}
+
+void ChartExport::exportUpDownBars( const Reference< chart2::XChartType >& xChartType)
+{
+    if(xChartType->getChartType() != "com.sun.star.chart2.CandleStickChartType")
+        return;
+
+    FSHelperPtr pFS = GetFS();
+    // export the chart property
+    Reference< css::chart::XStatisticDisplay > xChartPropProvider( mxDiagram, uno::UNO_QUERY );
+    if(!xChartPropProvider.is())
+        return;
+
+    //  updownbar
+    pFS->startElement(FSNS(XML_c, XML_upDownBars));
+    // TODO: gapWidth
+    pFS->singleElement(FSNS(XML_c, XML_gapWidth), XML_val, OString::number(150));
+
+    Reference< beans::XPropertySet > xChartPropSet = xChartPropProvider->getUpBar();
+    if( xChartPropSet.is() )
+    {
+        pFS->startElement(FSNS(XML_c, XML_upBars));
+        // For Linechart with UpDownBars, spPr is not getting imported
+        // so no need to call the exportShapeProps() for LineChart
+        if(xChartType->getChartType() == "com.sun.star.chart2.CandleStickChartType")
+        {
+            exportShapeProps(xChartPropSet);
+        }
+        pFS->endElement( FSNS( XML_c, XML_upBars ) );
+    }
+    xChartPropSet = xChartPropProvider->getDownBar();
+    if( xChartPropSet.is() )
+    {
+        pFS->startElement(FSNS(XML_c, XML_downBars));
+        if(xChartType->getChartType() == "com.sun.star.chart2.CandleStickChartType")
+        {
+            exportShapeProps(xChartPropSet);
+        }
+        pFS->endElement( FSNS( XML_c, XML_downBars ) );
+    }
+    pFS->endElement( FSNS( XML_c, XML_upDownBars ) );
+}
+
+void ChartExport::exportSurfaceChart( const Reference< chart2::XChartType >& xChartType )
+{
+    FSHelperPtr pFS = GetFS();
+    sal_Int32 nTypeId = XML_surfaceChart;
+    if( mbIs3DChart )
+        nTypeId = XML_surface3DChart;
+    pFS->startElement(FSNS(XML_c, nTypeId));
+    exportVaryColors(xChartType);
+    bool bPrimaryAxes = true;
+    exportAllSeries(xChartType, bPrimaryAxes);
+    exportAxesId(bPrimaryAxes);
+
+    pFS->endElement( FSNS( XML_c, nTypeId ) );
+}
+
+void ChartExport::exportAllSeries(const Reference<chart2::XChartType>& xChartType, bool& rPrimaryAxes)
+{
+    Reference< chart2::XDataSeriesContainer > xDSCnt( xChartType, uno::UNO_QUERY );
+    if( ! xDSCnt.is())
+        return;
+
+    // export dataseries for current chart-type
+    Sequence< Reference< chart2::XDataSeries > > aSeriesSeq( xDSCnt->getDataSeries());
+    exportSeries(xChartType, aSeriesSeq, rPrimaryAxes);
+}
+
+void ChartExport::exportVaryColors(const Reference<chart2::XChartType>& xChartType)
+{
+    FSHelperPtr pFS = GetFS();
+    try
+    {
+        Reference<chart2::XDataSeries> xDataSeries = getPrimaryDataSeries(xChartType);
+        Reference<beans::XPropertySet> xDataSeriesProps(xDataSeries, uno::UNO_QUERY_THROW);
+        Any aAnyVaryColors = xDataSeriesProps->getPropertyValue("VaryColorsByPoint");
+        bool bVaryColors = false;
+        aAnyVaryColors >>= bVaryColors;
+        pFS->singleElement(FSNS(XML_c, XML_varyColors), XML_val, ToPsz10(bVaryColors));
+    }
+    catch (...)
+    {
+        pFS->singleElement(FSNS(XML_c, XML_varyColors), XML_val, "0");
+    }
+}
+
+void ChartExport::exportSeries( const Reference<chart2::XChartType>& xChartType,
+        Sequence<Reference<chart2::XDataSeries> >& rSeriesSeq, bool& rPrimaryAxes )
+{
+    OUString aLabelRole = xChartType->getRoleOfSequenceForSeriesLabel();
+    OUString aChartType( xChartType->getChartType());
+    sal_Int32 eChartType = lcl_getChartType( aChartType );
+
+    for( const auto& rSeries : std::as_const(rSeriesSeq) )
+    {
+        // export series
+        Reference< chart2::data::XDataSource > xSource( rSeries, uno::UNO_QUERY );
+        if( xSource.is())
+        {
+            Reference< chart2::XDataSeries > xDataSeries( xSource, uno::UNO_QUERY );
+            Sequence< Reference< chart2::data::XLabeledDataSequence > > aSeqCnt(
+                xSource->getDataSequences());
+            // search for main sequence and create a series element
+            {
+                sal_Int32 nMainSequenceIndex = -1;
+                sal_Int32 nSeriesLength = 0;
+                Reference< chart2::data::XDataSequence > xValuesSeq;
+                Reference< chart2::data::XDataSequence > xLabelSeq;
+                sal_Int32 nSeqIdx=0;
+                for( ; nSeqIdx<aSeqCnt.getLength(); ++nSeqIdx )
+                {
+                    OUString aRole;
+                    Reference< chart2::data::XDataSequence > xTempValueSeq( aSeqCnt[nSeqIdx]->getValues() );
+                    if( nMainSequenceIndex==-1 )
+                    {
+                        Reference< beans::XPropertySet > xSeqProp( xTempValueSeq, uno::UNO_QUERY );
+                        if( xSeqProp.is())
+                            xSeqProp->getPropertyValue("Role") >>= aRole;
+                        // "main" sequence
+                        if( aRole == aLabelRole )
+                        {
+                            xValuesSeq.set( xTempValueSeq );
+                            xLabelSeq.set( aSeqCnt[nSeqIdx]->getLabel());
+                            nMainSequenceIndex = nSeqIdx;
+                        }
+                    }
+                    sal_Int32 nSequenceLength = (xTempValueSeq.is()? xTempValueSeq->getData().getLength() : sal_Int32(0));
+                    if( nSeriesLength < nSequenceLength )
+                        nSeriesLength = nSequenceLength;
+                }
+
+                // have found the main sequence, then xValuesSeq and
+                // xLabelSeq contain those.  Otherwise both are empty
+                {
+                    FSHelperPtr pFS = GetFS();
+
+                    pFS->startElement(FSNS(XML_c, XML_ser));
+
+                    // TODO: idx and order
+                    pFS->singleElement( FSNS( XML_c, XML_idx ),
+                        XML_val, OString::number(mnSeriesCount) );
+                    pFS->singleElement( FSNS( XML_c, XML_order ),
+                        XML_val, OString::number(mnSeriesCount++) );
+
+                    // export label
+                    if( xLabelSeq.is() )
+                        exportSeriesText( xLabelSeq );
+
+                    Reference<XPropertySet> xPropSet(xDataSeries, UNO_QUERY_THROW);
+                    if( GetProperty( xPropSet, "AttachedAxisIndex") )
+                    {
+                        sal_Int32 nLocalAttachedAxis = 0;
+                        mAny >>= nLocalAttachedAxis;
+                        rPrimaryAxes = isPrimaryAxes(nLocalAttachedAxis);
+                    }
+
+                    // export shape properties
+                    Reference< XPropertySet > xOldPropSet = SchXMLSeriesHelper::createOldAPISeriesPropertySet(
+                        rSeries, getModel() );
+                    if( xOldPropSet.is() )
+                    {
+                        exportShapeProps( xOldPropSet );
+                    }
+
+                    switch( eChartType )
+                    {
+                        case chart::TYPEID_BUBBLE:
+                        case chart::TYPEID_HORBAR:
+                        case chart::TYPEID_BAR:
+                        {
+                            pFS->singleElement(FSNS(XML_c, XML_invertIfNegative), XML_val, "0");
+                        }
+                        break;
+                        case chart::TYPEID_LINE:
+                        {
+                            exportMarker(xOldPropSet);
+                            break;
+                        }
+                        case chart::TYPEID_PIE:
+                        case chart::TYPEID_DOUGHNUT:
+                        {
+                            if( xOldPropSet.is() && GetProperty( xOldPropSet, "SegmentOffset") )
+                            {
+                                sal_Int32 nOffset = 0;
+                                mAny >>= nOffset;
+                                pFS->singleElement( FSNS( XML_c, XML_explosion ),
+                                    XML_val, OString::number( nOffset ) );
+                            }
+                            break;
+                        }
+                        case chart::TYPEID_SCATTER:
+                        {
+                            exportMarker(xOldPropSet);
+                            break;
+                        }
+                        case chart::TYPEID_RADARLINE:
+                        {
+                            exportMarker(xOldPropSet);
+                            break;
+                        }
+                    }
+
+                    // export data points
+                    exportDataPoints( uno::Reference< beans::XPropertySet >( rSeries, uno::UNO_QUERY ), nSeriesLength, eChartType );
+
+                    // export data labels
+                    exportDataLabels(rSeries, nSeriesLength, eChartType);
+
+                    exportTrendlines( rSeries );
+
+                    if( eChartType != chart::TYPEID_PIE &&
+                            eChartType != chart::TYPEID_RADARLINE )
+                    {
+                        //export error bars here
+                        Reference< XPropertySet > xSeriesPropSet( xSource, uno::UNO_QUERY );
+                        Reference< XPropertySet > xErrorBarYProps;
+                        xSeriesPropSet->getPropertyValue("ErrorBarY") >>= xErrorBarYProps;
+                        if(xErrorBarYProps.is())
+                            exportErrorBar(xErrorBarYProps, true);
+                        if (eChartType != chart::TYPEID_BAR &&
+                                eChartType != chart::TYPEID_HORBAR)
+                        {
+                            Reference< XPropertySet > xErrorBarXProps;
+                            xSeriesPropSet->getPropertyValue("ErrorBarX") >>= xErrorBarXProps;
+                            if(xErrorBarXProps.is())
+                                exportErrorBar(xErrorBarXProps, false);
+                        }
+                    }
+
+                    // export categories
+                    if( eChartType != chart::TYPEID_SCATTER && eChartType != chart::TYPEID_BUBBLE && mxCategoriesValues.is() )
+                        exportSeriesCategory( mxCategoriesValues );
+
+                    if( (eChartType == chart::TYPEID_SCATTER)
+                        || (eChartType == chart::TYPEID_BUBBLE) )
+                    {
+                        // export xVal
+                        Reference< chart2::data::XLabeledDataSequence > xSequence( lcl_getDataSequenceByRole( aSeqCnt, "values-x" ) );
+                        if( xSequence.is() )
+                        {
+                            Reference< chart2::data::XDataSequence > xValues( xSequence->getValues() );
+                            if( xValues.is() )
+                                exportSeriesValues( xValues, XML_xVal );
+                        }
+                        else if( mxCategoriesValues.is() )
+                            exportSeriesCategory( mxCategoriesValues, XML_xVal );
+                    }
+
+                    if( eChartType == chart::TYPEID_BUBBLE )
+                    {
+                        // export yVal
+                        Reference< chart2::data::XLabeledDataSequence > xSequence( lcl_getDataSequenceByRole( aSeqCnt, "values-y" ) );
+                        if( xSequence.is() )
+                        {
+                            Reference< chart2::data::XDataSequence > xValues( xSequence->getValues() );
+                            if( xValues.is() )
+                                exportSeriesValues( xValues, XML_yVal );
+                        }
+                    }
+
+                    // export values
+                    if( xValuesSeq.is() )
+                    {
+                        sal_Int32 nYValueType = XML_val;
+                        if( eChartType == chart::TYPEID_SCATTER )
+                            nYValueType = XML_yVal;
+                        else if( eChartType == chart::TYPEID_BUBBLE )
+                            nYValueType = XML_bubbleSize;
+                        exportSeriesValues( xValuesSeq, nYValueType );
+                    }
+
+                    if( eChartType == chart::TYPEID_SCATTER
+                            || eChartType == chart::TYPEID_LINE )
+                        exportSmooth();
+
+                    // tdf103988: "corrupted" files with Bubble chart opening in MSO
+                    if( eChartType == chart::TYPEID_BUBBLE )
+                        pFS->singleElement(FSNS(XML_c, XML_bubble3D), XML_val, "0");
+
+                    pFS->endElement( FSNS( XML_c, XML_ser ) );
+                }
+            }
+        }
+    }
+}
+
+void ChartExport::exportCandleStickSeries(
+    const Sequence< Reference< chart2::XDataSeries > > & aSeriesSeq,
+    bool& rPrimaryAxes)
+{
+    for( const Reference< chart2::XDataSeries >& xSeries : aSeriesSeq )
+    {
+        rPrimaryAxes = lcl_isSeriesAttachedToFirstAxis(xSeries);
+
+        Reference< chart2::data::XDataSource > xSource( xSeries, uno::UNO_QUERY );
+        if( xSource.is())
+        {
+            // export series in correct order (as we don't store roles)
+            // with japanese candlesticks: open, low, high, close
+            // otherwise: low, high, close
+            Sequence< Reference< chart2::data::XLabeledDataSequence > > aSeqCnt(
+                xSource->getDataSequences());
+
+            const char* sSeries[] = {"values-first","values-max","values-min","values-last",nullptr};
+
+            for( sal_Int32 idx = 0; sSeries[idx] != nullptr ; idx++ )
+            {
+                Reference< chart2::data::XLabeledDataSequence > xLabeledSeq( lcl_getDataSequenceByRole( aSeqCnt, OUString::createFromAscii(sSeries[idx]) ) );
+                if( xLabeledSeq.is())
+                {
+                    Reference< chart2::data::XDataSequence > xLabelSeq( xLabeledSeq->getLabel());
+                    Reference< chart2::data::XDataSequence > xValueSeq( xLabeledSeq->getValues());
+                    {
+                        FSHelperPtr pFS = GetFS();
+                        pFS->startElement(FSNS(XML_c, XML_ser));
+
+                        // TODO: idx and order
+                        // idx attribute should start from 1 and not from 0.
+                        pFS->singleElement( FSNS( XML_c, XML_idx ),
+                                XML_val, OString::number(idx+1) );
+                        pFS->singleElement( FSNS( XML_c, XML_order ),
+                                XML_val, OString::number(idx+1) );
+
+                        // export label
+                        if( xLabelSeq.is() )
+                            exportSeriesText( xLabelSeq );
+
+                        // TODO:export shape properties
+
+                        // export categories
+                        if( mxCategoriesValues.is() )
+                            exportSeriesCategory( mxCategoriesValues );
+
+                        // export values
+                        if( xValueSeq.is() )
+                            exportSeriesValues( xValueSeq );
+
+                        pFS->endElement( FSNS( XML_c, XML_ser ) );
+                    }
+                }
+            }
+        }
+    }
+}
+
+void ChartExport::exportSeriesText( const Reference< chart2::data::XDataSequence > & xValueSeq )
+{
+    FSHelperPtr pFS = GetFS();
+    pFS->startElement(FSNS(XML_c, XML_tx));
+
+    OUString aCellRange =  xValueSeq->getSourceRangeRepresentation();
+    aCellRange = parseFormula( aCellRange );
+    pFS->startElement(FSNS(XML_c, XML_strRef));
+
+    pFS->startElement(FSNS(XML_c, XML_f));
+    pFS->writeEscaped( aCellRange );
+    pFS->endElement( FSNS( XML_c, XML_f ) );
+
+    OUString aLabelString = lcl_flattenStringSequence(lcl_getLabelSequence(xValueSeq));
+    pFS->startElement(FSNS(XML_c, XML_strCache));
+    pFS->singleElement(FSNS(XML_c, XML_ptCount), XML_val, "1");
+    pFS->startElement(FSNS(XML_c, XML_pt), XML_idx, "0");
+    pFS->startElement(FSNS(XML_c, XML_v));
+    pFS->writeEscaped( aLabelString );
+    pFS->endElement( FSNS( XML_c, XML_v ) );
+    pFS->endElement( FSNS( XML_c, XML_pt ) );
+    pFS->endElement( FSNS( XML_c, XML_strCache ) );
+    pFS->endElement( FSNS( XML_c, XML_strRef ) );
+    pFS->endElement( FSNS( XML_c, XML_tx ) );
+}
+
+void ChartExport::exportSeriesCategory( const Reference< chart2::data::XDataSequence > & xValueSeq, sal_Int32 nValueType )
+{
+    FSHelperPtr pFS = GetFS();
+    pFS->startElement(FSNS(XML_c, nValueType));
+
+    OUString aCellRange = xValueSeq.is() ? xValueSeq->getSourceRangeRepresentation() : OUString();
+    const Sequence< Sequence< OUString >> aFinalSplitSource = (nValueType == XML_cat) ? getSplitCategoriesList(aCellRange) : Sequence< Sequence< OUString>>(0);
+    aCellRange = parseFormula( aCellRange );
+
+    if(aFinalSplitSource.getLength() > 1)
+    {
+        // export multi level category axis labels
+        pFS->startElement(FSNS(XML_c, XML_multiLvlStrRef));
+
+        pFS->startElement(FSNS(XML_c, XML_f));
+        pFS->writeEscaped(aCellRange);
+        pFS->endElement(FSNS(XML_c, XML_f));
+
+        pFS->startElement(FSNS(XML_c, XML_multiLvlStrCache));
+        pFS->singleElement(FSNS(XML_c, XML_ptCount), XML_val, OString::number(aFinalSplitSource[0].getLength()));
+        for(const auto& rSeq : aFinalSplitSource)
+        {
+            pFS->startElement(FSNS(XML_c, XML_lvl));
+            for(sal_Int32 j = 0; j < rSeq.getLength(); j++)
+            {
+                if(!rSeq[j].isEmpty())
+                {
+                    pFS->startElement(FSNS(XML_c, XML_pt), XML_idx, OString::number(j));
+                    pFS->startElement(FSNS(XML_c, XML_v));
+                    pFS->writeEscaped(rSeq[j]);
+                    pFS->endElement(FSNS(XML_c, XML_v));
+                    pFS->endElement(FSNS(XML_c, XML_pt));
+                }
+            }
+            pFS->endElement(FSNS(XML_c, XML_lvl));
+        }
+
+        pFS->endElement(FSNS(XML_c, XML_multiLvlStrCache));
+        pFS->endElement(FSNS(XML_c, XML_multiLvlStrRef));
+    }
+    else
+    {
+        // export single category axis labels
+        pFS->startElement(FSNS(XML_c, XML_strRef));
+
+        pFS->startElement(FSNS(XML_c, XML_f));
+        pFS->writeEscaped(aCellRange);
+        pFS->endElement(FSNS(XML_c, XML_f));
+
+        ::std::vector< OUString > aCategories;
+        lcl_fillCategoriesIntoStringVector(xValueSeq, aCategories);
+        sal_Int32 ptCount = aCategories.size();
+        pFS->startElement(FSNS(XML_c, XML_strCache));
+        pFS->singleElement(FSNS(XML_c, XML_ptCount), XML_val, OString::number(ptCount));
+        for (sal_Int32 i = 0; i < ptCount; i++)
+        {
+            pFS->startElement(FSNS(XML_c, XML_pt), XML_idx, OString::number(i));
+            pFS->startElement(FSNS(XML_c, XML_v));
+            pFS->writeEscaped(aCategories[i]);
+            pFS->endElement(FSNS(XML_c, XML_v));
+            pFS->endElement(FSNS(XML_c, XML_pt));
+        }
+
+        pFS->endElement(FSNS(XML_c, XML_strCache));
+        pFS->endElement(FSNS(XML_c, XML_strRef));
+    }
+
+    pFS->endElement( FSNS( XML_c, nValueType ) );
+}
+
+void ChartExport::exportSeriesValues( const Reference< chart2::data::XDataSequence > & xValueSeq, sal_Int32 nValueType )
+{
+    FSHelperPtr pFS = GetFS();
+    pFS->startElement(FSNS(XML_c, nValueType));
+
+    OUString aCellRange = xValueSeq.is() ? xValueSeq->getSourceRangeRepresentation() : OUString();
+    aCellRange = parseFormula( aCellRange );
+    // TODO: need to handle XML_multiLvlStrRef according to aCellRange
+    pFS->startElement(FSNS(XML_c, XML_numRef));
+
+    pFS->startElement(FSNS(XML_c, XML_f));
+    pFS->writeEscaped( aCellRange );
+    pFS->endElement( FSNS( XML_c, XML_f ) );
+
+    ::std::vector< double > aValues = lcl_getAllValuesFromSequence( xValueSeq );
+    sal_Int32 ptCount = aValues.size();
+    pFS->startElement(FSNS(XML_c, XML_numCache));
+    pFS->startElement(FSNS(XML_c, XML_formatCode));
+    // TODO: what format code?
+    pFS->writeEscaped( "General" );
+    pFS->endElement( FSNS( XML_c, XML_formatCode ) );
+    pFS->singleElement(FSNS(XML_c, XML_ptCount), XML_val, OString::number(ptCount));
+
+    for( sal_Int32 i = 0; i < ptCount; i++ )
+    {
+        if (!std::isnan(aValues[i]))
+        {
+            pFS->startElement(FSNS(XML_c, XML_pt), XML_idx, OString::number(i));
+            pFS->startElement(FSNS(XML_c, XML_v));
+            pFS->write(aValues[i]);
+            pFS->endElement(FSNS(XML_c, XML_v));
+            pFS->endElement(FSNS(XML_c, XML_pt));
+        }
+    }
+
+    pFS->endElement( FSNS( XML_c, XML_numCache ) );
+    pFS->endElement( FSNS( XML_c, XML_numRef ) );
+    pFS->endElement( FSNS( XML_c, nValueType ) );
+}
+
+void ChartExport::exportShapeProps( const Reference< XPropertySet >& xPropSet )
+{
+    FSHelperPtr pFS = GetFS();
+    pFS->startElement(FSNS(XML_c, XML_spPr));
+
+    exportFill( xPropSet );
+    WriteOutline( xPropSet, getModel() );
+
+    pFS->endElement( FSNS( XML_c, XML_spPr ) );
+}
+
+void ChartExport::exportTextProps(const Reference<XPropertySet>& xPropSet)
+{
+    FSHelperPtr pFS = GetFS();
+    pFS->startElement(FSNS(XML_c, XML_txPr));
+
+    sal_Int32 nRotation = 0;
+    const char* textWordWrap = nullptr;
+
+    if (auto xServiceInfo = uno::Reference<lang::XServiceInfo>(xPropSet, uno::UNO_QUERY))
+    {
+        double fMultiplier = 0.0;
+        // We have at least two possible units of returned value: degrees (e.g., for data labels),
+        // and 100ths of degree (e.g., for axes labels). The latter is returned as an Any wrapping
+        // a sal_Int32 value (see WrappedTextRotationProperty::convertInnerToOuterValue), while
+        // the former is double. So we could test the contained type to decide which multiplier to
+        // use. But testing the service info should be more robust.
+        if (xServiceInfo->supportsService("com.sun.star.chart.ChartAxis"))
+            fMultiplier = -600.0;
+        else if (xServiceInfo->supportsService("com.sun.star.chart2.DataSeries") || xServiceInfo->supportsService("com.sun.star.chart2.DataPointProperties"))
+        {
+            fMultiplier = -60000.0;
+            bool bTextWordWrap = false;
+            if ((xPropSet->getPropertyValue("TextWordWrap") >>= bTextWordWrap) && bTextWordWrap)
+                textWordWrap = "square";
+            else
+                textWordWrap = "none";
+        }
+
+        if (fMultiplier)
+        {
+            double fTextRotation = 0.0;
+            uno::Any aAny = xPropSet->getPropertyValue("TextRotation");
+            if (aAny.hasValue() && (aAny >>= fTextRotation))
+            {
+                fTextRotation *= fMultiplier;
+                // The MS Office UI allows values only in range of [-90,90].
+                if (fTextRotation < -5400000.0 && fTextRotation > -16200000.0)
+                {
+                    // Reflect the angle if the value is between 90° and 270°
+                    fTextRotation += 10800000.0;
+                }
+                else if (fTextRotation <= -16200000.0)
+                {
+                    fTextRotation += 21600000.0;
+                }
+                nRotation = std::round(fTextRotation);
+            }
+        }
+    }
+
+    if (nRotation)
+        pFS->singleElement(FSNS(XML_a, XML_bodyPr), XML_rot, OString::number(nRotation), XML_wrap, textWordWrap);
+    else
+        pFS->singleElement(FSNS(XML_a, XML_bodyPr), XML_wrap, textWordWrap);
+
+    pFS->singleElement(FSNS(XML_a, XML_lstStyle));
+
+    pFS->startElement(FSNS(XML_a, XML_p));
+    pFS->startElement(FSNS(XML_a, XML_pPr));
+
+    WriteRunProperties(xPropSet, false, XML_defRPr, true, o3tl::temporary(false),
+                       o3tl::temporary(sal_Int32()));
+
+    pFS->endElement(FSNS(XML_a, XML_pPr));
+    pFS->endElement(FSNS(XML_a, XML_p));
+    pFS->endElement(FSNS(XML_c, XML_txPr));
+}
+
+void ChartExport::InitPlotArea( )
+{
+    Reference< XPropertySet > xDiagramProperties (mxDiagram, uno::UNO_QUERY);
+
+    //    Check for supported services and then the properties provided by this service.
+    Reference<lang::XServiceInfo> xServiceInfo (mxDiagram, uno::UNO_QUERY);
+    if (xServiceInfo.is())
+    {
+        if (xServiceInfo->supportsService("com.sun.star.chart.ChartAxisZSupplier"))
+        {
+            xDiagramProperties->getPropertyValue("HasZAxis") >>= mbHasZAxis;
+        }
+    }
+
+    xDiagramProperties->getPropertyValue("Dim3D") >>=  mbIs3DChart;
+
+    if( mbHasCategoryLabels && mxNewDiagram.is())
+    {
+        Reference< chart2::data::XLabeledDataSequence > xCategories( lcl_getCategories( mxNewDiagram ) );
+        if( xCategories.is() )
+        {
+            mxCategoriesValues.set( xCategories->getValues() );
+        }
+    }
+}
+
+void ChartExport::exportAxes( )
+{
+    sal_Int32 nSize = maAxes.size();
+    // let's export the axis types in the right order
+    for ( sal_Int32 nSortIdx = AXIS_PRIMARY_X; nSortIdx <= AXIS_SECONDARY_Y; nSortIdx++ )
+    {
+        for ( sal_Int32 nIdx = 0; nIdx < nSize; nIdx++ )
+        {
+            if (nSortIdx == maAxes[nIdx].nAxisType)
+                exportAxis( maAxes[nIdx] );
+        }
+    }
+}
+
+namespace {
+
+sal_Int32 getXAxisTypeByChartType(sal_Int32 eChartType)
+{
+    if( (eChartType == chart::TYPEID_SCATTER)
+            || (eChartType == chart::TYPEID_BUBBLE) )
+        return  XML_valAx;
+    else if( eChartType == chart::TYPEID_STOCK )
+        return  XML_dateAx;
+
+    return XML_catAx;
+}
+
+sal_Int32 getRealXAxisType(sal_Int32 nAxisType)
+{
+    if( nAxisType == chart2::AxisType::CATEGORY )
+        return XML_catAx;
+    else if( nAxisType == chart2::AxisType::DATE )
+        return XML_dateAx;
+    else if( nAxisType == chart2::AxisType::SERIES )
+        return XML_serAx;
+
+    return XML_valAx;
+}
+
+}
+
+void ChartExport::exportAxis(const AxisIdPair& rAxisIdPair)
+{
+    // get some properties from document first
+    bool bHasXAxisTitle = false,
+         bHasYAxisTitle = false,
+         bHasZAxisTitle = false,
+         bHasSecondaryXAxisTitle = false,
+         bHasSecondaryYAxisTitle = false;
+    bool bHasXAxisMajorGrid = false,
+         bHasXAxisMinorGrid = false,
+         bHasYAxisMajorGrid = false,
+         bHasYAxisMinorGrid = false,
+         bHasZAxisMajorGrid = false,
+         bHasZAxisMinorGrid = false;
+
+    Reference< XPropertySet > xDiagramProperties (mxDiagram, uno::UNO_QUERY);
+
+    xDiagramProperties->getPropertyValue("HasXAxisTitle") >>= bHasXAxisTitle;
+    xDiagramProperties->getPropertyValue("HasYAxisTitle") >>= bHasYAxisTitle;
+    xDiagramProperties->getPropertyValue("HasZAxisTitle") >>= bHasZAxisTitle;
+    xDiagramProperties->getPropertyValue("HasSecondaryXAxisTitle") >>=  bHasSecondaryXAxisTitle;
+    xDiagramProperties->getPropertyValue("HasSecondaryYAxisTitle") >>=  bHasSecondaryYAxisTitle;
+
+    xDiagramProperties->getPropertyValue("HasXAxisGrid") >>=  bHasXAxisMajorGrid;
+    xDiagramProperties->getPropertyValue("HasYAxisGrid") >>=  bHasYAxisMajorGrid;
+    xDiagramProperties->getPropertyValue("HasZAxisGrid") >>=  bHasZAxisMajorGrid;
+
+    xDiagramProperties->getPropertyValue("HasXAxisHelpGrid") >>=  bHasXAxisMinorGrid;
+    xDiagramProperties->getPropertyValue("HasYAxisHelpGrid") >>=  bHasYAxisMinorGrid;
+    xDiagramProperties->getPropertyValue("HasZAxisHelpGrid") >>=  bHasZAxisMinorGrid;
+
+    Reference< XPropertySet > xAxisProp;
+    Reference< drawing::XShape > xAxisTitle;
+    Reference< beans::XPropertySet > xMajorGrid;
+    Reference< beans::XPropertySet > xMinorGrid;
+    sal_Int32 nAxisType = XML_catAx;
+    const char* sAxPos = nullptr;
+
+    switch( rAxisIdPair.nAxisType )
+    {
+        case AXIS_PRIMARY_X:
+        {
+            Reference< css::chart::XAxisXSupplier > xAxisXSupp( mxDiagram, uno::UNO_QUERY );
+            if( xAxisXSupp.is())
+                xAxisProp = xAxisXSupp->getXAxis();
+            if( bHasXAxisTitle )
+                xAxisTitle = xAxisXSupp->getXAxisTitle();
+            if( bHasXAxisMajorGrid )
+                xMajorGrid = xAxisXSupp->getXMainGrid();
+            if( bHasXAxisMinorGrid )
+                xMinorGrid = xAxisXSupp->getXHelpGrid();
+
+            nAxisType = lcl_getCategoryAxisType(mxNewDiagram, 0, 0);
+            if( nAxisType != -1 )
+                nAxisType = getRealXAxisType(nAxisType);
+            else
+                nAxisType = getXAxisTypeByChartType( getChartType() );
+            // FIXME: axPos, need to check axis direction
+            sAxPos = "b";
+            break;
+        }
+        case AXIS_PRIMARY_Y:
+        {
+            Reference< css::chart::XAxisYSupplier > xAxisYSupp( mxDiagram, uno::UNO_QUERY );
+            if( xAxisYSupp.is())
+                xAxisProp = xAxisYSupp->getYAxis();
+            if( bHasYAxisTitle )
+                xAxisTitle = xAxisYSupp->getYAxisTitle();
+            if( bHasYAxisMajorGrid )
+                xMajorGrid = xAxisYSupp->getYMainGrid();
+            if( bHasYAxisMinorGrid )
+                xMinorGrid = xAxisYSupp->getYHelpGrid();
+
+            nAxisType = XML_valAx;
+            // FIXME: axPos, need to check axis direction
+            sAxPos = "l";
+            break;
+        }
+        case AXIS_PRIMARY_Z:
+        {
+            Reference< css::chart::XAxisZSupplier > xAxisZSupp( mxDiagram, uno::UNO_QUERY );
+            if( xAxisZSupp.is())
+                xAxisProp = xAxisZSupp->getZAxis();
+            if( bHasZAxisTitle )
+                xAxisTitle = xAxisZSupp->getZAxisTitle();
+            if( bHasZAxisMajorGrid )
+                xMajorGrid = xAxisZSupp->getZMainGrid();
+            if( bHasZAxisMinorGrid )
+                xMinorGrid = xAxisZSupp->getZHelpGrid();
+
+            sal_Int32 eChartType = getChartType( );
+            if( (eChartType == chart::TYPEID_SCATTER)
+                || (eChartType == chart::TYPEID_BUBBLE) )
+                nAxisType = XML_valAx;
+            else if( eChartType == chart::TYPEID_STOCK )
+                nAxisType = XML_dateAx;
+            else if( eChartType == chart::TYPEID_BAR || eChartType == chart::TYPEID_AREA )
+                nAxisType = XML_serAx;
+            // FIXME: axPos, need to check axis direction
+            sAxPos = "b";
+            break;
+        }
+        case AXIS_SECONDARY_X:
+        {
+            Reference< css::chart::XTwoAxisXSupplier > xAxisTwoXSupp( mxDiagram, uno::UNO_QUERY );
+            if( xAxisTwoXSupp.is())
+                xAxisProp = xAxisTwoXSupp->getSecondaryXAxis();
+            if( bHasSecondaryXAxisTitle )
+            {
+                Reference< css::chart::XSecondAxisTitleSupplier > xAxisSupp( mxDiagram, uno::UNO_QUERY );
+                xAxisTitle = xAxisSupp->getSecondXAxisTitle();
+            }
+
+            nAxisType = lcl_getCategoryAxisType(mxNewDiagram, 0, 1);
+            if( nAxisType != -1 )
+                nAxisType = getRealXAxisType(nAxisType);
+            else
+                nAxisType = getXAxisTypeByChartType( getChartType() );
+            // FIXME: axPos, need to check axis direction
+            sAxPos = "t";
+            break;
+        }
+        case AXIS_SECONDARY_Y:
+        {
+            Reference< css::chart::XTwoAxisYSupplier > xAxisTwoYSupp( mxDiagram, uno::UNO_QUERY );
+            if( xAxisTwoYSupp.is())
+                xAxisProp = xAxisTwoYSupp->getSecondaryYAxis();
+            if( bHasSecondaryYAxisTitle )
+            {
+                Reference< css::chart::XSecondAxisTitleSupplier > xAxisSupp( mxDiagram, uno::UNO_QUERY );
+                xAxisTitle = xAxisSupp->getSecondYAxisTitle();
+            }
+
+            nAxisType = XML_valAx;
+            // FIXME: axPos, need to check axis direction
+            sAxPos = "r";
+            break;
+        }
+    }
+
+    _exportAxis(xAxisProp, xAxisTitle, xMajorGrid, xMinorGrid, nAxisType, sAxPos, rAxisIdPair);
+}
+
+void ChartExport::_exportAxis(
+    const Reference< XPropertySet >& xAxisProp,
+    const Reference< drawing::XShape >& xAxisTitle,
+    const Reference< XPropertySet >& xMajorGrid,
+    const Reference< XPropertySet >& xMinorGrid,
+    sal_Int32 nAxisType,
+    const char* sAxisPos,
+    const AxisIdPair& rAxisIdPair )
+{
+    FSHelperPtr pFS = GetFS();
+    pFS->startElement(FSNS(XML_c, nAxisType));
+    pFS->singleElement(FSNS(XML_c, XML_axId), XML_val, OString::number(rAxisIdPair.nAxisId));
+
+    pFS->startElement(FSNS(XML_c, XML_scaling));
+
+    // logBase, min, max
+    if(GetProperty( xAxisProp, "Logarithmic" ) )
+    {
+        bool bLogarithmic = false;
+        mAny >>= bLogarithmic;
+        if( bLogarithmic )
+        {
+            // default value is 10?
+            pFS->singleElement(FSNS(XML_c, XML_logBase), XML_val, OString::number(10));
+        }
+    }
+
+    // orientation: minMax, maxMin
+    bool bReverseDirection = false;
+    if(GetProperty( xAxisProp, "ReverseDirection" ) )
+        mAny >>= bReverseDirection;
+
+    const char* orientation = bReverseDirection ? "maxMin":"minMax";
+    pFS->singleElement(FSNS(XML_c, XML_orientation), XML_val, orientation);
+
+    bool bAutoMax = false;
+    if(GetProperty( xAxisProp, "AutoMax" ) )
+        mAny >>= bAutoMax;
+
+    if( !bAutoMax && (GetProperty( xAxisProp, "Max" ) ) )
+    {
+        double dMax = 0;
+        mAny >>= dMax;
+        pFS->singleElement(FSNS(XML_c, XML_max), XML_val, OString::number(dMax));
+    }
+
+    bool bAutoMin = false;
+    if(GetProperty( xAxisProp, "AutoMin" ) )
+        mAny >>= bAutoMin;
+
+    if( !bAutoMin && (GetProperty( xAxisProp, "Min" ) ) )
+    {
+        double dMin = 0;
+        mAny >>= dMin;
+        pFS->singleElement(FSNS(XML_c, XML_min), XML_val, OString::number(dMin));
+    }
+
+    pFS->endElement( FSNS( XML_c, XML_scaling ) );
+
+    bool bVisible = true;
+    if( xAxisProp.is() )
+    {
+        xAxisProp->getPropertyValue("Visible") >>=  bVisible;
+    }
+
+    // only export each axis only once non-deleted
+    bool bDeleted = maExportedAxis.find(rAxisIdPair.nAxisType) != maExportedAxis.end();
+
+    if (!bDeleted)
+        maExportedAxis.insert(rAxisIdPair.nAxisType);
+
+    pFS->singleElement(FSNS(XML_c, XML_delete), XML_val, !bDeleted && bVisible ? "0" : "1");
+
+    // FIXME: axPos, need to check the property "ReverseDirection"
+    pFS->singleElement(FSNS(XML_c, XML_axPos), XML_val, sAxisPos);
+    // major grid line
+    if( xMajorGrid.is())
+    {
+        pFS->startElement(FSNS(XML_c, XML_majorGridlines));
+        exportShapeProps( xMajorGrid );
+        pFS->endElement( FSNS( XML_c, XML_majorGridlines ) );
+    }
+
+    // minor grid line
+    if( xMinorGrid.is())
+    {
+        pFS->startElement(FSNS(XML_c, XML_minorGridlines));
+        exportShapeProps( xMinorGrid );
+        pFS->endElement( FSNS( XML_c, XML_minorGridlines ) );
+    }
+
+    // title
+    if( xAxisTitle.is() )
+        exportTitle( xAxisTitle );
+
+    bool bLinkedNumFmt = true;
+    if (GetProperty(xAxisProp, "LinkNumberFormatToSource"))
+        mAny >>= bLinkedNumFmt;
+
+    OUString aNumberFormatString("General");
+    if (GetProperty(xAxisProp, "NumberFormat"))
+    {
+        sal_Int32 nKey = 0;
+        mAny >>= nKey;
+        aNumberFormatString = getNumberFormatCode(nKey);
+    }
+
+    OString sNumberFormatString = OUStringToOString(aNumberFormatString, RTL_TEXTENCODING_UTF8);
+    pFS->singleElement(FSNS(XML_c, XML_numFmt),
+            XML_formatCode, sNumberFormatString.getStr(),
+            XML_sourceLinked, bLinkedNumFmt ? "1" : "0");
+
+    // majorTickMark
+    sal_Int32 nValue = 0;
+    if(GetProperty( xAxisProp, "Marks" ) )
+    {
+        mAny >>= nValue;
+        bool bInner = nValue & css::chart::ChartAxisMarks::INNER;
+        bool bOuter = nValue & css::chart::ChartAxisMarks::OUTER;
+        const char* majorTickMark = nullptr;
+        if( bInner && bOuter )
+            majorTickMark = "cross";
+        else if( bInner )
+            majorTickMark = "in";
+        else if( bOuter )
+            majorTickMark = "out";
+        else
+            majorTickMark = "none";
+        pFS->singleElement(FSNS(XML_c, XML_majorTickMark), XML_val, majorTickMark);
+    }
+    // minorTickMark
+    if(GetProperty( xAxisProp, "HelpMarks" ) )
+    {
+        mAny >>= nValue;
+        bool bInner = nValue & css::chart::ChartAxisMarks::INNER;
+        bool bOuter = nValue & css::chart::ChartAxisMarks::OUTER;
+        const char* minorTickMark = nullptr;
+        if( bInner && bOuter )
+            minorTickMark = "cross";
+        else if( bInner )
+            minorTickMark = "in";
+        else if( bOuter )
+            minorTickMark = "out";
+        else
+            minorTickMark = "none";
+        pFS->singleElement(FSNS(XML_c, XML_minorTickMark), XML_val, minorTickMark);
+    }
+    // tickLblPos
+    const char* sTickLblPos = nullptr;
+    bool bDisplayLabel = true;
+    if(GetProperty( xAxisProp, "DisplayLabels" ) )
+        mAny >>= bDisplayLabel;
+    if( bDisplayLabel && (GetProperty( xAxisProp, "LabelPosition" ) ) )
+    {
+        css::chart::ChartAxisLabelPosition eLabelPosition = css::chart::ChartAxisLabelPosition_NEAR_AXIS;
+        mAny >>= eLabelPosition;
+        switch( eLabelPosition )
+        {
+            case css::chart::ChartAxisLabelPosition_NEAR_AXIS:
+            case css::chart::ChartAxisLabelPosition_NEAR_AXIS_OTHER_SIDE:
+                sTickLblPos = "nextTo";
+                break;
+            case css::chart::ChartAxisLabelPosition_OUTSIDE_START:
+                sTickLblPos = "low";
+                break;
+            case css::chart::ChartAxisLabelPosition_OUTSIDE_END:
+                sTickLblPos = "high";
+                break;
+            default:
+                sTickLblPos = "nextTo";
+                break;
+        }
+    }
+    else
+    {
+        sTickLblPos = "none";
+    }
+    pFS->singleElement(FSNS(XML_c, XML_tickLblPos), XML_val, sTickLblPos);
+
+    // shape properties
+    exportShapeProps( xAxisProp );
+
+    exportTextProps(xAxisProp);
+
+    pFS->singleElement(FSNS(XML_c, XML_crossAx), XML_val, OString::number(rAxisIdPair.nCrossAx));
+
+    // crosses & crossesAt
+    bool bCrossesValue = false;
+    const char* sCrosses = nullptr;
+    // do not export the CrossoverPosition/CrossoverValue, if the axis is deleted and not visible
+    if( GetProperty( xAxisProp, "CrossoverPosition" ) && !bDeleted && bVisible )
+    {
+        css::chart::ChartAxisPosition ePosition( css::chart::ChartAxisPosition_ZERO );
+        mAny >>= ePosition;
+        switch( ePosition )
+        {
+            case css::chart::ChartAxisPosition_START:
+                sCrosses = "min";
+                break;
+            case css::chart::ChartAxisPosition_END:
+                sCrosses = "max";
+                break;
+            case css::chart::ChartAxisPosition_ZERO:
+                sCrosses = "autoZero";
+                break;
+            default:
+                bCrossesValue = true;
+                break;
+        }
+    }
+
+    if( bCrossesValue && GetProperty( xAxisProp, "CrossoverValue" ) )
+    {
+        double dValue = 0;
+        mAny >>= dValue;
+        pFS->singleElement(FSNS(XML_c, XML_crossesAt), XML_val, OString::number(dValue));
+    }
+    else
+    {
+        if(sCrosses)
+        {
+            pFS->singleElement(FSNS(XML_c, XML_crosses), XML_val, sCrosses);
+        }
+    }
+
+    if( ( nAxisType == XML_catAx )
+        || ( nAxisType == XML_dateAx ) )
+    {
+        // FIXME: seems not support? use default value,
+        const char* const isAuto = "1";
+        pFS->singleElement(FSNS(XML_c, XML_auto), XML_val, isAuto);
+
+        if( nAxisType == XML_catAx )
+        {
+            // FIXME: seems not support? lblAlgn
+            const char* const sLblAlgn = "ctr";
+            pFS->singleElement(FSNS(XML_c, XML_lblAlgn), XML_val, sLblAlgn);
+        }
+
+        // FIXME: seems not support? lblOffset
+        pFS->singleElement(FSNS(XML_c, XML_lblOffset), XML_val, OString::number(100));
+
+        // FIXME: seems not support? noMultiLvlLbl
+        pFS->singleElement(FSNS(XML_c, XML_noMultiLvlLbl), XML_val, OString::number(0));
+    }
+
+    // crossBetween
+    if( nAxisType == XML_valAx )
+    {
+        if( lcl_isCategoryAxisShifted( mxNewDiagram ))
+            pFS->singleElement(FSNS(XML_c, XML_crossBetween), XML_val, "between");
+        else
+            pFS->singleElement(FSNS(XML_c, XML_crossBetween), XML_val, "midCat");
+    }
+
+    // majorUnit
+    bool bAutoStepMain = false;
+    if(GetProperty( xAxisProp, "AutoStepMain" ) )
+        mAny >>= bAutoStepMain;
+
+    if( !bAutoStepMain && (GetProperty( xAxisProp, "StepMain" ) ) )
+    {
+        double dMajorUnit = 0;
+        mAny >>= dMajorUnit;
+        pFS->singleElement(FSNS(XML_c, XML_majorUnit), XML_val, OString::number(dMajorUnit));
+    }
+    // minorUnit
+    bool bAutoStepHelp = false;
+    if(GetProperty( xAxisProp, "AutoStepHelp" ) )
+        mAny >>= bAutoStepHelp;
+
+    if( !bAutoStepHelp && (GetProperty( xAxisProp, "StepHelp" ) ) )
+    {
+        double dMinorUnit = 0;
+        mAny >>= dMinorUnit;
+        if( GetProperty( xAxisProp, "StepHelpCount" ) )
+        {
+            sal_Int32 dMinorUnitCount = 0;
+            mAny >>= dMinorUnitCount;
+            // tdf#114168 Don't save minor unit if number of step help count is 5 (which is default for MS Excel),
+            // to allow proper .xlsx import. If minorUnit is set and majorUnit not, then it is impossible
+            // to calculate StepHelpCount.
+            if( dMinorUnitCount != 5 )
+            {
+                pFS->singleElement( FSNS( XML_c, XML_minorUnit ),
+                    XML_val, OString::number( dMinorUnit ) );
+            }
+        }
+    }
+
+    if( nAxisType == XML_valAx && GetProperty( xAxisProp, "DisplayUnits" ) )
+    {
+        bool bDisplayUnits = false;
+        mAny >>= bDisplayUnits;
+        if(bDisplayUnits)
+        {
+            OUString aVal;
+            if(GetProperty( xAxisProp, "BuiltInUnit" ))
+            {
+                mAny >>= aVal;
+                if(!aVal.isEmpty())
+                {
+                    pFS->startElement(FSNS(XML_c, XML_dispUnits));
+
+                    pFS->singleElement(FSNS(XML_c, XML_builtInUnit), XML_val, aVal.toUtf8());
+
+                    pFS->singleElement(FSNS( XML_c, XML_dispUnitsLbl ));
+                    pFS->endElement( FSNS( XML_c, XML_dispUnits ) );
+                }
+             }
+        }
+    }
+
+    pFS->endElement( FSNS( XML_c, nAxisType ) );
+}
+
+namespace {
+
+struct LabelPlacementParam
+{
+    bool mbExport;
+    sal_Int32 meDefault;
+
+    std::unordered_set<sal_Int32> maAllowedValues;
+
+    LabelPlacementParam(bool bExport, sal_Int32 nDefault) :
+        mbExport(bExport),
+        meDefault(nDefault),
+        maAllowedValues(
+          {
+           css::chart::DataLabelPlacement::OUTSIDE,
+           css::chart::DataLabelPlacement::INSIDE,
+           css::chart::DataLabelPlacement::CENTER,
+           css::chart::DataLabelPlacement::NEAR_ORIGIN,
+           css::chart::DataLabelPlacement::TOP,
+           css::chart::DataLabelPlacement::BOTTOM,
+           css::chart::DataLabelPlacement::LEFT,
+           css::chart::DataLabelPlacement::RIGHT,
+           css::chart::DataLabelPlacement::AVOID_OVERLAP
+          }
+        )
+    {}
+};
+
+const char* toOOXMLPlacement( sal_Int32 nPlacement )
+{
+    switch (nPlacement)
+    {
+        case css::chart::DataLabelPlacement::OUTSIDE:       return "outEnd";
+        case css::chart::DataLabelPlacement::INSIDE:        return "inEnd";
+        case css::chart::DataLabelPlacement::CENTER:        return "ctr";
+        case css::chart::DataLabelPlacement::NEAR_ORIGIN:   return "inBase";
+        case css::chart::DataLabelPlacement::TOP:           return "t";
+        case css::chart::DataLabelPlacement::BOTTOM:        return "b";
+        case css::chart::DataLabelPlacement::LEFT:          return "l";
+        case css::chart::DataLabelPlacement::RIGHT:         return "r";
+        case css::chart::DataLabelPlacement::AVOID_OVERLAP: return "bestFit";
+        default:
+            ;
+    }
+
+    return "outEnd";
+}
+
+OUString getFieldTypeString( const chart2::DataPointCustomLabelFieldType aType )
+{
+    switch (aType)
+    {
+    case chart2::DataPointCustomLabelFieldType_CATEGORYNAME:
+        return "CATEGORYNAME";
+
+    case chart2::DataPointCustomLabelFieldType_SERIESNAME:
+        return "SERIESNAME";
+
+    case chart2::DataPointCustomLabelFieldType_VALUE:
+        return "VALUE";
+
+    case chart2::DataPointCustomLabelFieldType_CELLREF:
+        return "CELLREF";
+
+    default:
+        break;
+    }
+    return OUString();
+}
+
+void writeRunProperties( ChartExport* pChartExport, Reference<XPropertySet> const & xPropertySet )
+{
+    bool bDummy = false;
+    sal_Int32 nDummy;
+    pChartExport->WriteRunProperties(xPropertySet, false, XML_rPr, true, bDummy, nDummy);
+}
+
+void writeCustomLabel( const FSHelperPtr& pFS, ChartExport* pChartExport,
+                       const Sequence<Reference<chart2::XDataPointCustomLabelField>>& rCustomLabelFields )
+{
+    pFS->startElement(FSNS(XML_c, XML_tx));
+    pFS->startElement(FSNS(XML_c, XML_rich));
+
+    // TODO: body properties?
+    pFS->singleElement(FSNS(XML_a, XML_bodyPr));
+
+    OUString sFieldType;
+    pFS->startElement(FSNS(XML_a, XML_p));
+
+    for (auto& rField : rCustomLabelFields)
+    {
+        Reference<XPropertySet> xPropertySet(rField, UNO_QUERY);
+        chart2::DataPointCustomLabelFieldType aType = rField->getFieldType();
+        sFieldType.clear();
+        bool bNewParagraph = false;
+
+        if (aType == chart2::DataPointCustomLabelFieldType_NEWLINE)
+            bNewParagraph = true;
+        else if (aType != chart2::DataPointCustomLabelFieldType_TEXT)
+            sFieldType = getFieldTypeString(aType);
+
+        if (bNewParagraph)
+        {
+            pFS->endElement(FSNS(XML_a, XML_p));
+            pFS->startElement(FSNS(XML_a, XML_p));
+            continue;
+        }
+
+        if (sFieldType.isEmpty())
+        {
+            // Normal text run
+            pFS->startElement(FSNS(XML_a, XML_r));
+            writeRunProperties(pChartExport, xPropertySet);
+
+            pFS->startElement(FSNS(XML_a, XML_t));
+            pFS->writeEscaped(rField->getString());
+            pFS->endElement(FSNS(XML_a, XML_t));
+
+            pFS->endElement(FSNS(XML_a, XML_r));
+        }
+        else
+        {
+            // Field
+            pFS->startElement(FSNS(XML_a, XML_fld), XML_id, rField->getGuid().toUtf8(), XML_type,
+                              sFieldType.toUtf8());
+            writeRunProperties(pChartExport, xPropertySet);
+
+            pFS->startElement(FSNS(XML_a, XML_t));
+            pFS->writeEscaped(rField->getString());
+            pFS->endElement(FSNS(XML_a, XML_t));
+
+            pFS->endElement(FSNS(XML_a, XML_fld));
+        }
+    }
+
+    pFS->endElement(FSNS(XML_a, XML_p));
+    pFS->endElement(FSNS(XML_c, XML_rich));
+    pFS->endElement(FSNS(XML_c, XML_tx));
+}
+
+void writeLabelProperties( const FSHelperPtr& pFS, ChartExport* pChartExport,
+    const uno::Reference<beans::XPropertySet>& xPropSet, const LabelPlacementParam& rLabelParam )
+{
+    if (!xPropSet.is())
+        return;
+
+    chart2::DataPointLabel aLabel;
+    Sequence<Reference<chart2::XDataPointCustomLabelField>> aCustomLabelFields;
+    sal_Int32 nLabelBorderWidth = 0;
+    sal_Int32 nLabelBorderColor = 0x00FFFFFF;
+
+    xPropSet->getPropertyValue("Label") >>= aLabel;
+    xPropSet->getPropertyValue("CustomLabelFields") >>= aCustomLabelFields;
+    xPropSet->getPropertyValue("LabelBorderWidth") >>= nLabelBorderWidth;
+    xPropSet->getPropertyValue("LabelBorderColor") >>= nLabelBorderColor;
+
+    if (nLabelBorderWidth > 0)
+    {
+        pFS->startElement(FSNS(XML_c, XML_spPr));
+        pFS->startElement(FSNS(XML_a, XML_ln), XML_w,
+                          OString::number(convertHmmToEmu(nLabelBorderWidth)));
+        if (nLabelBorderColor != -1)
+        {
+            pFS->startElement(FSNS(XML_a, XML_solidFill));
+
+            OString aStr = OString::number(nLabelBorderColor, 16).toAsciiUpperCase();
+            pFS->singleElement(FSNS(XML_a, XML_srgbClr), XML_val, aStr);
+
+            pFS->endElement(FSNS(XML_a, XML_solidFill));
+        }
+        pFS->endElement(FSNS(XML_a, XML_ln));
+        pFS->endElement(FSNS(XML_c, XML_spPr));
+    }
+
+    if (aCustomLabelFields.hasElements())
+        writeCustomLabel(pFS, pChartExport, aCustomLabelFields);
+
+    if (rLabelParam.mbExport)
+    {
+        sal_Int32 nLabelPlacement = rLabelParam.meDefault;
+        if (xPropSet->getPropertyValue("LabelPlacement") >>= nLabelPlacement)
+        {
+            if (!rLabelParam.maAllowedValues.count(nLabelPlacement))
+                nLabelPlacement = rLabelParam.meDefault;
+            pFS->singleElement(FSNS(XML_c, XML_dLblPos), XML_val, toOOXMLPlacement(nLabelPlacement));
+        }
+    }
+
+    pFS->singleElement(FSNS(XML_c, XML_showLegendKey), XML_val, ToPsz10(aLabel.ShowLegendSymbol));
+    pFS->singleElement(FSNS(XML_c, XML_showVal), XML_val, ToPsz10(aLabel.ShowNumber));
+    pFS->singleElement(FSNS(XML_c, XML_showCatName), XML_val, ToPsz10(aLabel.ShowCategoryName));
+    pFS->singleElement(FSNS(XML_c, XML_showSerName), XML_val, ToPsz10(false));
+    pFS->singleElement(FSNS(XML_c, XML_showPercent), XML_val, ToPsz10(aLabel.ShowNumberInPercent));
+
+    // Export the text "separator" if exists
+    uno::Any aAny = xPropSet->getPropertyValue("LabelSeparator");
+    if( aAny.hasValue() )
+    {
+        OUString nLabelSeparator;
+        aAny >>= nLabelSeparator;
+        pFS->startElement(FSNS(XML_c, XML_separator));
+        pFS->writeEscaped( nLabelSeparator );
+        pFS->endElement( FSNS( XML_c, XML_separator ) );
+    }
+}
+
+}
+
+void ChartExport::exportDataLabels(
+    const uno::Reference<chart2::XDataSeries> & xSeries, sal_Int32 nSeriesLength, sal_Int32 eChartType )
+{
+    if (!xSeries.is() || nSeriesLength <= 0)
+        return;
+
+    uno::Reference<beans::XPropertySet> xPropSet(xSeries, uno::UNO_QUERY);
+    if (!xPropSet.is())
+        return;
+
+    FSHelperPtr pFS = GetFS();
+    pFS->startElement(FSNS(XML_c, XML_dLbls));
+
+    bool bLinkedNumFmt = true;
+    if (GetProperty(xPropSet, "LinkNumberFormatToSource"))
+        mAny >>= bLinkedNumFmt;
+
+    chart2::DataPointLabel aLabel;
+    bool bLabelIsNumberFormat = true;
+    if( xPropSet->getPropertyValue("Label") >>= aLabel )
+        bLabelIsNumberFormat = aLabel.ShowNumber;
+
+    if (GetProperty(xPropSet, bLabelIsNumberFormat ? OUString("NumberFormat") : OUString("PercentageNumberFormat")))
+    {
+        sal_Int32 nKey = 0;
+        mAny >>= nKey;
+
+        OUString aNumberFormatString = getNumberFormatCode(nKey);
+        OString sNumberFormatString = OUStringToOString(aNumberFormatString, RTL_TEXTENCODING_UTF8);
+
+        pFS->singleElement(FSNS(XML_c, XML_numFmt),
+            XML_formatCode, sNumberFormatString,
+            XML_sourceLinked, ToPsz10(bLinkedNumFmt));
+    }
+
+    uno::Sequence<sal_Int32> aAttrLabelIndices;
+    xPropSet->getPropertyValue("AttributedDataPoints") >>= aAttrLabelIndices;
+
+    // We must not export label placement property when the chart type doesn't
+    // support this option in MS Office, else MS Office would think the file
+    // is corrupt & refuse to open it.
+
+    const chart::TypeGroupInfo& rInfo = chart::GetTypeGroupInfo(static_cast<chart::TypeId>(eChartType));
+    LabelPlacementParam aParam(!mbIs3DChart, rInfo.mnDefLabelPos);
+    switch (eChartType) // diagram chart type
+    {
+        case chart::TYPEID_PIE:
+            if(getChartType() == chart::TYPEID_DOUGHNUT)
+                aParam.mbExport = false;
+            else
+            // All pie charts support label placement.
+            aParam.mbExport = true;
+        break;
+        case chart::TYPEID_AREA:
+        case chart::TYPEID_RADARLINE:
+        case chart::TYPEID_RADARAREA:
+            // These chart types don't support label placement.
+            aParam.mbExport = false;
+        break;
+        case chart::TYPEID_BAR:
+            if (mbStacked || mbPercent)
+            {
+                aParam.maAllowedValues.clear();
+                aParam.maAllowedValues.insert(css::chart::DataLabelPlacement::CENTER);
+                aParam.maAllowedValues.insert(css::chart::DataLabelPlacement::INSIDE);
+                aParam.maAllowedValues.insert(css::chart::DataLabelPlacement::NEAR_ORIGIN);
+                aParam.meDefault = css::chart::DataLabelPlacement::CENTER;
+            }
+            else  // Clustered bar chart
+            {
+                aParam.maAllowedValues.clear();
+                aParam.maAllowedValues.insert(css::chart::DataLabelPlacement::CENTER);
+                aParam.maAllowedValues.insert(css::chart::DataLabelPlacement::INSIDE);
+                aParam.maAllowedValues.insert(css::chart::DataLabelPlacement::OUTSIDE);
+                aParam.maAllowedValues.insert(css::chart::DataLabelPlacement::NEAR_ORIGIN);
+                aParam.meDefault = css::chart::DataLabelPlacement::OUTSIDE;
+            }
+        break;
+        default:
+            ;
+    }
+
+    for (const sal_Int32 nIdx : std::as_const(aAttrLabelIndices))
+    {
+        uno::Reference<beans::XPropertySet> xLabelPropSet = xSeries->getDataPointByIndex(nIdx);
+
+        if (!xLabelPropSet.is())
+            continue;
+
+        pFS->startElement(FSNS(XML_c, XML_dLbl));
+        pFS->singleElement(FSNS(XML_c, XML_idx), XML_val, OString::number(nIdx));
+
+        // export custom position of data label
+        if( eChartType != chart::TYPEID_PIE )
+        {
+            chart2::RelativePosition aCustomLabelPosition;
+            if( xLabelPropSet->getPropertyValue("CustomLabelPosition") >>= aCustomLabelPosition )
+            {
+                pFS->startElement(FSNS(XML_c, XML_layout));
+                pFS->startElement(FSNS(XML_c, XML_manualLayout));
+
+                pFS->singleElement(FSNS(XML_c, XML_x), XML_val, OString::number(aCustomLabelPosition.Primary));
+                pFS->singleElement(FSNS(XML_c, XML_y), XML_val, OString::number(aCustomLabelPosition.Secondary));
+
+                SAL_WARN_IF(aCustomLabelPosition.Anchor != css::drawing::Alignment_TOP_LEFT, "oox", "unsupported anchor position");
+
+                pFS->endElement(FSNS(XML_c, XML_manualLayout));
+                pFS->endElement(FSNS(XML_c, XML_layout));
+            }
+        }
+
+        if( GetProperty(xLabelPropSet, "LinkNumberFormatToSource") )
+            mAny >>= bLinkedNumFmt;
+
+        if( xLabelPropSet->getPropertyValue("Label") >>= aLabel )
+            bLabelIsNumberFormat = aLabel.ShowNumber;
+        else
+            bLabelIsNumberFormat = true;
+
+        if (GetProperty(xLabelPropSet, bLabelIsNumberFormat ? OUString("NumberFormat") : OUString("PercentageNumberFormat")))
+        {
+            sal_Int32 nKey = 0;
+            mAny >>= nKey;
+
+            OUString aNumberFormatString = getNumberFormatCode(nKey);
+            OString sNumberFormatString = OUStringToOString(aNumberFormatString, RTL_TEXTENCODING_UTF8);
+
+            pFS->singleElement(FSNS(XML_c, XML_numFmt), XML_formatCode, sNumberFormatString.getStr(),
+                               XML_sourceLinked, ToPsz10(bLinkedNumFmt));
+        }
+
+        // Individual label property that overwrites the baseline.
+        exportTextProps( xLabelPropSet );
+        writeLabelProperties(pFS, this, xLabelPropSet, aParam);
+        pFS->endElement(FSNS(XML_c, XML_dLbl));
+    }
+
+    exportTextProps( xPropSet );
+    // Baseline label properties for all labels.
+    writeLabelProperties(pFS, this, xPropSet, aParam);
+
+    pFS->singleElement(FSNS(XML_c, XML_showLeaderLines), XML_val, "0");
+
+    // Export leader line
+    if( eChartType != chart::TYPEID_PIE )
+    {
+        pFS->startElement(FSNS(XML_c, XML_extLst));
+        pFS->startElement(FSNS(XML_c, XML_ext), XML_uri, "{CE6537A1-D6FC-4f65-9D91-7224C49458BB}", FSNS(XML_xmlns, XML_c15), GetFB()->getNamespaceURL(OOX_NS(c15)).toUtf8());
+        pFS->singleElement(FSNS(XML_c15, XML_showLeaderLines), XML_val, "1");
+        pFS->endElement(FSNS(XML_c, XML_ext));
+        pFS->endElement(FSNS(XML_c, XML_extLst));
+    }
+    pFS->endElement(FSNS(XML_c, XML_dLbls));
+}
+
+void ChartExport::exportDataPoints(
+    const uno::Reference< beans::XPropertySet > & xSeriesProperties,
+    sal_Int32 nSeriesLength, sal_Int32 eChartType )
+{
+    uno::Reference< chart2::XDataSeries > xSeries( xSeriesProperties, uno::UNO_QUERY );
+    bool bVaryColorsByPoint = false;
+    Sequence< sal_Int32 > aDataPointSeq;
+    if( xSeriesProperties.is())
+    {
+        Any aAny = xSeriesProperties->getPropertyValue( "AttributedDataPoints" );
+        aAny >>= aDataPointSeq;
+        xSeriesProperties->getPropertyValue( "VaryColorsByPoint" ) >>= bVaryColorsByPoint;
+    }
+
+    const sal_Int32 * pPoints = aDataPointSeq.getConstArray();
+    sal_Int32 nElement;
+    Reference< chart2::XColorScheme > xColorScheme;
+    if( mxNewDiagram.is())
+        xColorScheme.set( mxNewDiagram->getDefaultColorScheme());
+
+    if( bVaryColorsByPoint && xColorScheme.is() )
+    {
+        ::std::set< sal_Int32 > aAttrPointSet;
+        ::std::copy( pPoints, pPoints + aDataPointSeq.getLength(),
+                    ::std::inserter( aAttrPointSet, aAttrPointSet.begin()));
+        const ::std::set< sal_Int32 >::const_iterator aEndIt( aAttrPointSet.end());
+        for( nElement = 0; nElement < nSeriesLength; ++nElement )
+        {
+            uno::Reference< beans::XPropertySet > xPropSet;
+            if( aAttrPointSet.find( nElement ) != aEndIt )
+            {
+                try
+                {
+                    xPropSet = SchXMLSeriesHelper::createOldAPIDataPointPropertySet(
+                            xSeries, nElement, getModel() );
+                }
+                catch( const uno::Exception & )
+                {
+                    DBG_UNHANDLED_EXCEPTION( "oox", "Exception caught during Export of data point" );
+                }
+            }
+            else
+            {
+                // property set only containing the color
+                xPropSet.set( new ColorPropertySet( xColorScheme->getColorByIndex( nElement )));
+            }
+
+            if( xPropSet.is() )
+            {
+                FSHelperPtr pFS = GetFS();
+                pFS->startElement(FSNS(XML_c, XML_dPt));
+                pFS->singleElement(FSNS(XML_c, XML_idx), XML_val, OString::number(nElement));
+
+                switch (eChartType)
+                {
+                    case chart::TYPEID_PIE:
+                    case chart::TYPEID_DOUGHNUT:
+                    {
+                        if( xPropSet.is() && GetProperty( xPropSet, "SegmentOffset") )
+                        {
+                            sal_Int32 nOffset = 0;
+                            mAny >>= nOffset;
+                            if (nOffset)
+                                pFS->singleElement( FSNS( XML_c, XML_explosion ),
+                                        XML_val, OString::number( nOffset ) );
+                        }
+                        break;
+                    }
+                    default:
+                        break;
+                }
+                exportShapeProps( xPropSet );
+
+                pFS->endElement( FSNS( XML_c, XML_dPt ) );
+            }
+        }
+    }
+
+    // Export Data Point Property in Charts even if the VaryColors is false
+    if( bVaryColorsByPoint )
+        return;
+
+    ::std::set< sal_Int32 > aAttrPointSet;
+    ::std::copy( pPoints, pPoints + aDataPointSeq.getLength(),
+                ::std::inserter( aAttrPointSet, aAttrPointSet.begin()));
+    const ::std::set< sal_Int32 >::const_iterator aEndIt( aAttrPointSet.end());
+    for( nElement = 0; nElement < nSeriesLength; ++nElement )
+    {
+        uno::Reference< beans::XPropertySet > xPropSet;
+        if( aAttrPointSet.find( nElement ) != aEndIt )
+        {
+            try
+            {
+                xPropSet = SchXMLSeriesHelper::createOldAPIDataPointPropertySet(
+                        xSeries, nElement, getModel() );
+            }
+            catch( const uno::Exception & )
+            {
+                DBG_UNHANDLED_EXCEPTION( "oox", "Exception caught during Export of data point" );
+            }
+        }
+
+        if( xPropSet.is() )
+        {
+            FSHelperPtr pFS = GetFS();
+            pFS->startElement(FSNS(XML_c, XML_dPt));
+            pFS->singleElement(FSNS(XML_c, XML_idx), XML_val, OString::number(nElement));
+
+            switch( eChartType )
+            {
+                case chart::TYPEID_BUBBLE:
+                case chart::TYPEID_HORBAR:
+                case chart::TYPEID_BAR:
+                    pFS->singleElement(FSNS(XML_c, XML_invertIfNegative), XML_val, "0");
+                    exportShapeProps(xPropSet);
+                    break;
+
+                case chart::TYPEID_LINE:
+                case chart::TYPEID_SCATTER:
+                case chart::TYPEID_RADARLINE:
+                    exportMarker(xPropSet);
+                    break;
+
+                default:
+                    exportShapeProps(xPropSet);
+                    break;
+            }
+
+            pFS->endElement( FSNS( XML_c, XML_dPt ) );
+        }
+    }
+}
+
+void ChartExport::exportAxesId(bool bPrimaryAxes, bool bCheckCombinedAxes)
+{
+    sal_Int32 nAxisIdx, nAxisIdy;
+    bool bPrimaryAxisExists = false;
+    bool bSecondaryAxisExists = false;
+    // let's check which axis already exists and which axis is attached to the actual dataseries
+    if (maAxes.size() >= 2)
+    {
+        bPrimaryAxisExists = bPrimaryAxes && maAxes[1].nAxisType == AXIS_PRIMARY_Y;
+        bSecondaryAxisExists = !bPrimaryAxes && maAxes[1].nAxisType == AXIS_SECONDARY_Y;
+    }
+    // tdf#114181 keep axes of combined charts
+    if ( bCheckCombinedAxes && ( bPrimaryAxisExists || bSecondaryAxisExists ) )
+    {
+        nAxisIdx = maAxes[0].nAxisId;
+        nAxisIdy = maAxes[1].nAxisId;
+    }
+    else
+    {
+        nAxisIdx = lcl_generateRandomValue();
+        nAxisIdy = lcl_generateRandomValue();
+        AxesType eXAxis = bPrimaryAxes ? AXIS_PRIMARY_X : AXIS_SECONDARY_X;
+        AxesType eYAxis = bPrimaryAxes ? AXIS_PRIMARY_Y : AXIS_SECONDARY_Y;
+        maAxes.emplace_back( eXAxis, nAxisIdx, nAxisIdy );
+        maAxes.emplace_back( eYAxis, nAxisIdy, nAxisIdx );
+    }
+    FSHelperPtr pFS = GetFS();
+    pFS->singleElement(FSNS(XML_c, XML_axId), XML_val, OString::number(nAxisIdx));
+    pFS->singleElement(FSNS(XML_c, XML_axId), XML_val, OString::number(nAxisIdy));
+    if (mbHasZAxis)
+    {
+        sal_Int32 nAxisIdz = 0;
+        if( isDeep3dChart() )
+        {
+            nAxisIdz = lcl_generateRandomValue();
+            maAxes.emplace_back( AXIS_PRIMARY_Z, nAxisIdz, nAxisIdy );
+        }
+        pFS->singleElement(FSNS(XML_c, XML_axId), XML_val, OString::number(nAxisIdz));
+    }
+}
+
+void ChartExport::exportGrouping( bool isBar )
+{
+    FSHelperPtr pFS = GetFS();
+    Reference< XPropertySet > xPropSet( mxDiagram , uno::UNO_QUERY);
+    // grouping
+    if( GetProperty( xPropSet, "Stacked" ) )
+        mAny >>= mbStacked;
+    if( GetProperty( xPropSet, "Percent" ) )
+        mAny >>= mbPercent;
+
+    const char* grouping = nullptr;
+    if (mbStacked)
+        grouping = "stacked";
+    else if (mbPercent)
+        grouping = "percentStacked";
+    else
+    {
+        if( isBar && !isDeep3dChart() )
+        {
+            grouping = "clustered";
+        }
+        else
+            grouping = "standard";
+    }
+    pFS->singleElement(FSNS(XML_c, XML_grouping), XML_val, grouping);
+}
+
+void ChartExport::exportTrendlines( const Reference< chart2::XDataSeries >& xSeries )
+{
+    FSHelperPtr pFS = GetFS();
+    Reference< chart2::XRegressionCurveContainer > xRegressionCurveContainer( xSeries, UNO_QUERY );
+    if( !xRegressionCurveContainer.is() )
+        return;
+
+    const Sequence< Reference< chart2::XRegressionCurve > > aRegCurveSeq = xRegressionCurveContainer->getRegressionCurves();
+    for( const Reference< chart2::XRegressionCurve >& xRegCurve : aRegCurveSeq )
+    {
+        if (!xRegCurve.is())
+            continue;
+
+        Reference< XPropertySet > xProperties( xRegCurve , uno::UNO_QUERY );
+
+        OUString aService;
+        Reference< lang::XServiceName > xServiceName( xProperties, UNO_QUERY );
+        if( !xServiceName.is() )
+            continue;
+
+        aService = xServiceName->getServiceName();
+
+        if(aService != "com.sun.star.chart2.LinearRegressionCurve" &&
+                aService != "com.sun.star.chart2.ExponentialRegressionCurve" &&
+                aService != "com.sun.star.chart2.LogarithmicRegressionCurve" &&
+                aService != "com.sun.star.chart2.PotentialRegressionCurve" &&
+                aService != "com.sun.star.chart2.PolynomialRegressionCurve" &&
+                aService != "com.sun.star.chart2.MovingAverageRegressionCurve")
+            continue;
+
+        pFS->startElement(FSNS(XML_c, XML_trendline));
+
+        OUString aName;
+        xProperties->getPropertyValue("CurveName") >>= aName;
+        if(!aName.isEmpty())
+        {
+            pFS->startElement(FSNS(XML_c, XML_name));
+            pFS->writeEscaped(aName);
+            pFS->endElement( FSNS( XML_c, XML_name) );
+        }
+
+        exportShapeProps( xProperties );
+
+        if( aService == "com.sun.star.chart2.LinearRegressionCurve" )
+        {
+            pFS->singleElement(FSNS(XML_c, XML_trendlineType), XML_val, "linear");
+        }
+        else if( aService == "com.sun.star.chart2.ExponentialRegressionCurve" )
+        {
+            pFS->singleElement(FSNS(XML_c, XML_trendlineType), XML_val, "exp");
+        }
+        else if( aService == "com.sun.star.chart2.LogarithmicRegressionCurve" )
+        {
+            pFS->singleElement(FSNS(XML_c, XML_trendlineType), XML_val, "log");
+        }
+        else if( aService == "com.sun.star.chart2.PotentialRegressionCurve" )
+        {
+            pFS->singleElement(FSNS(XML_c, XML_trendlineType), XML_val, "power");
+        }
+        else if( aService == "com.sun.star.chart2.PolynomialRegressionCurve" )
+        {
+            pFS->singleElement(FSNS(XML_c, XML_trendlineType), XML_val, "poly");
+
+            sal_Int32 aDegree = 2;
+            xProperties->getPropertyValue( "PolynomialDegree") >>= aDegree;
+            pFS->singleElement(FSNS(XML_c, XML_order), XML_val, OString::number(aDegree));
+        }
+        else if( aService == "com.sun.star.chart2.MovingAverageRegressionCurve" )
+        {
+            pFS->singleElement(FSNS(XML_c, XML_trendlineType), XML_val, "movingAvg");
+
+            sal_Int32 aPeriod = 2;
+            xProperties->getPropertyValue( "MovingAveragePeriod") >>= aPeriod;
+
+            pFS->singleElement(FSNS(XML_c, XML_period), XML_val, OString::number(aPeriod));
+        }
+        else
+        {
+            // should never happen
+            // This would produce invalid OOXML files so we check earlier for the type
+            assert(false);
+        }
+
+        double fExtrapolateForward = 0.0;
+        double fExtrapolateBackward = 0.0;
+
+        xProperties->getPropertyValue("ExtrapolateForward") >>= fExtrapolateForward;
+        xProperties->getPropertyValue("ExtrapolateBackward") >>= fExtrapolateBackward;
+
+        pFS->singleElement( FSNS( XML_c, XML_forward ),
+                XML_val, OString::number(fExtrapolateForward) );
+
+        pFS->singleElement( FSNS( XML_c, XML_backward ),
+                XML_val, OString::number(fExtrapolateBackward) );
+
+        bool bForceIntercept = false;
+        xProperties->getPropertyValue("ForceIntercept") >>= bForceIntercept;
+
+        if (bForceIntercept)
+        {
+            double fInterceptValue = 0.0;
+            xProperties->getPropertyValue("InterceptValue") >>= fInterceptValue;
+
+            pFS->singleElement( FSNS( XML_c, XML_intercept ),
+                XML_val, OString::number(fInterceptValue) );
+        }
+
+        // Equation properties
+        Reference< XPropertySet > xEquationProperties( xRegCurve->getEquationProperties() );
+
+        // Show Equation
+        bool bShowEquation = false;
+        xEquationProperties->getPropertyValue("ShowEquation") >>= bShowEquation;
+
+        // Show R^2
+        bool bShowCorrelationCoefficient = false;
+        xEquationProperties->getPropertyValue("ShowCorrelationCoefficient") >>= bShowCorrelationCoefficient;
+
+        pFS->singleElement( FSNS( XML_c, XML_dispRSqr ),
+                XML_val, ToPsz10(bShowCorrelationCoefficient) );
+
+        pFS->singleElement(FSNS(XML_c, XML_dispEq), XML_val, ToPsz10(bShowEquation));
+
+        pFS->endElement( FSNS( XML_c, XML_trendline ) );
+    }
+}
+
+void ChartExport::exportMarker(const Reference< XPropertySet >& xPropSet)
+{
+    chart2::Symbol aSymbol;
+    if( GetProperty( xPropSet, "Symbol" ) )
+        mAny >>= aSymbol;
+
+    if(aSymbol.Style != chart2::SymbolStyle_STANDARD && aSymbol.Style != chart2::SymbolStyle_NONE)
+        return;
+
+    FSHelperPtr pFS = GetFS();
+    pFS->startElement(FSNS(XML_c, XML_marker));
+
+    sal_Int32 nSymbol = aSymbol.StandardSymbol;
+    // TODO: more properties support for marker
+    const char* pSymbolType; // no initialization here, to let compiler warn if we have a code path
+                             // where it stays uninitialized
+    switch( nSymbol )
+    {
+        case 0:
+            pSymbolType = "square";
+            break;
+        case 1:
+            pSymbolType = "diamond";
+            break;
+        case 2:
+        case 3:
+        case 4:
+        case 5:
+            pSymbolType = "triangle";
+            break;
+        case 8:
+            pSymbolType = "circle";
+            break;
+        case 9:
+            pSymbolType = "star";
+            break;
+        case 10:
+            pSymbolType = "x"; // in MS office 2010 built in symbol marker 'X' is represented as 'x'
+            break;
+        case 11:
+            pSymbolType = "plus";
+            break;
+        case 13:
+            pSymbolType = "dash";
+            break;
+        default:
+            pSymbolType = "square";
+            break;
+    }
+
+    bool bSkipFormatting = false;
+    if (aSymbol.Style == chart2::SymbolStyle_NONE)
+    {
+        bSkipFormatting = true;
+        pSymbolType = "none";
+    }
+
+    pFS->singleElement(FSNS(XML_c, XML_symbol), XML_val, pSymbolType);
+
+    if (!bSkipFormatting)
+    {
+        awt::Size aSymbolSize = aSymbol.Size;
+        sal_Int32 nSize = std::max( aSymbolSize.Width, aSymbolSize.Height );
+
+        nSize = nSize/250.0*7.0 + 1; // just guessed based on some test cases,
+        //the value is always 1 less than the actual value.
+        nSize = std::min<sal_Int32>( 72, std::max<sal_Int32>( 2, nSize ) );
+        pFS->singleElement(FSNS(XML_c, XML_size), XML_val, OString::number(nSize));
+
+        pFS->startElement(FSNS(XML_c, XML_spPr));
+
+        util::Color aColor = aSymbol.FillColor;
+        if (GetProperty(xPropSet, "Color"))
+            mAny >>= aColor;
+
+        if (aColor == -1)
+        {
+            pFS->singleElement(FSNS(XML_a, XML_noFill));
+        }
+        else
+            WriteSolidFill(::Color(aColor));
+
+        pFS->endElement( FSNS( XML_c, XML_spPr ) );
+    }
+
+    pFS->endElement( FSNS( XML_c, XML_marker ) );
+}
+
+void ChartExport::exportSmooth()
+{
+    FSHelperPtr pFS = GetFS();
+    Reference< XPropertySet > xPropSet( mxDiagram , uno::UNO_QUERY );
+    sal_Int32 nSplineType = 0;
+    if( GetProperty( xPropSet, "SplineType" ) )
+        mAny >>= nSplineType;
+    const char* pVal = nSplineType != 0 ? "1" : "0";
+    pFS->singleElement(FSNS(XML_c, XML_smooth), XML_val, pVal);
+}
+
+void ChartExport::exportFirstSliceAng( )
+{
+    FSHelperPtr pFS = GetFS();
+    sal_Int32 nStartingAngle = 0;
+    Reference< XPropertySet > xPropSet( mxDiagram , uno::UNO_QUERY);
+    if( GetProperty( xPropSet, "StartingAngle" ) )
+        mAny >>= nStartingAngle;
+
+    // convert to ooxml angle
+    nStartingAngle = (450 - nStartingAngle ) % 360;
+    pFS->singleElement(FSNS(XML_c, XML_firstSliceAng), XML_val, OString::number(nStartingAngle));
+}
+
+namespace {
+
+const char* getErrorBarStyle(sal_Int32 nErrorBarStyle)
+{
+    switch(nErrorBarStyle)
+    {
+        case cssc::ErrorBarStyle::NONE:
+            return nullptr;
+        case cssc::ErrorBarStyle::VARIANCE:
+            break;
+        case cssc::ErrorBarStyle::STANDARD_DEVIATION:
+            return "stdDev";
+        case cssc::ErrorBarStyle::ABSOLUTE:
+            return "fixedVal";
+        case cssc::ErrorBarStyle::RELATIVE:
+            return "percentage";
+        case cssc::ErrorBarStyle::ERROR_MARGIN:
+            break;
+        case cssc::ErrorBarStyle::STANDARD_ERROR:
+            return "stdErr";
+        case cssc::ErrorBarStyle::FROM_DATA:
+            return "cust";
+        default:
+            assert(false && "can't happen");
+    }
+    return nullptr;
+}
+
+Reference< chart2::data::XDataSequence>  getLabeledSequence(
+        const uno::Sequence< uno::Reference< chart2::data::XLabeledDataSequence > >& aSequences,
+        bool bPositive )
+{
+    OUString aDirection;
+    if(bPositive)
+        aDirection = "positive";
+    else
+        aDirection = "negative";
+
+    for( const auto& rSequence : aSequences )
+    {
+        if( rSequence.is())
+        {
+            uno::Reference< chart2::data::XDataSequence > xSequence( rSequence->getValues());
+            uno::Reference< beans::XPropertySet > xSeqProp( xSequence, uno::UNO_QUERY_THROW );
+            OUString aRole;
+            if( ( xSeqProp->getPropertyValue( "Role" ) >>= aRole ) &&
+                    aRole.match( "error-bars" ) && aRole.indexOf(aDirection) >= 0 )
+            {
+                return xSequence;
+            }
+        }
+    }
+
+    return Reference< chart2::data::XDataSequence > ();
+}
+
+}
+
+void ChartExport::exportErrorBar(const Reference< XPropertySet>& xErrorBarProps, bool bYError)
+{
+    sal_Int32 nErrorBarStyle = cssc::ErrorBarStyle::NONE;
+    xErrorBarProps->getPropertyValue("ErrorBarStyle") >>= nErrorBarStyle;
+    const char* pErrorBarStyle = getErrorBarStyle(nErrorBarStyle);
+    if(!pErrorBarStyle)
+        return;
+
+    FSHelperPtr pFS = GetFS();
+    pFS->startElement(FSNS(XML_c, XML_errBars));
+    pFS->singleElement(FSNS(XML_c, XML_errDir), XML_val, bYError ? "y" : "x");
+    bool bPositive = false, bNegative = false;
+    xErrorBarProps->getPropertyValue("ShowPositiveError") >>= bPositive;
+    xErrorBarProps->getPropertyValue("ShowNegativeError") >>= bNegative;
+    const char* pErrBarType;
+    if(bPositive && bNegative)
+        pErrBarType = "both";
+    else if(bPositive)
+        pErrBarType = "plus";
+    else if(bNegative)
+        pErrBarType = "minus";
+    else
+    {
+        // what the hell should we do now?
+        // at least this makes the file valid
+        pErrBarType = "both";
+    }
+    pFS->singleElement(FSNS(XML_c, XML_errBarType), XML_val, pErrBarType);
+    pFS->singleElement(FSNS(XML_c, XML_errValType), XML_val, pErrorBarStyle);
+    pFS->singleElement(FSNS(XML_c, XML_noEndCap), XML_val, "0");
+    if(nErrorBarStyle == cssc::ErrorBarStyle::FROM_DATA)
+    {
+        uno::Reference< chart2::data::XDataSource > xDataSource(xErrorBarProps, uno::UNO_QUERY);
+        Sequence< Reference < chart2::data::XLabeledDataSequence > > aSequences =
+            xDataSource->getDataSequences();
+
+        if(bPositive)
+        {
+            exportSeriesValues(getLabeledSequence(aSequences, true), XML_plus);
+        }
+
+        if(bNegative)
+        {
+            exportSeriesValues(getLabeledSequence(aSequences, false), XML_minus);
+        }
+    }
+    else
+    {
+        double nVal = 0.0;
+        if(nErrorBarStyle == cssc::ErrorBarStyle::STANDARD_DEVIATION)
+        {
+            xErrorBarProps->getPropertyValue("Weight") >>= nVal;
+        }
+        else
+        {
+            if(bPositive)
+                xErrorBarProps->getPropertyValue("PositiveError") >>= nVal;
+            else
+                xErrorBarProps->getPropertyValue("NegativeError") >>= nVal;
+        }
+
+        pFS->singleElement(FSNS(XML_c, XML_val), XML_val, OString::number(nVal));
+    }
+
+    exportShapeProps( xErrorBarProps );
+
+    pFS->endElement( FSNS( XML_c, XML_errBars) );
+}
+
+void ChartExport::exportView3D()
+{
+    Reference< XPropertySet > xPropSet( mxDiagram , uno::UNO_QUERY);
+    if( !xPropSet.is() )
+        return;
+    FSHelperPtr pFS = GetFS();
+    pFS->startElement(FSNS(XML_c, XML_view3D));
+    sal_Int32 eChartType = getChartType( );
+    // rotX
+    if( GetProperty( xPropSet, "RotationHorizontal" ) )
+    {
+        sal_Int32 nRotationX = 0;
+        mAny >>= nRotationX;
+        if( nRotationX < 0 )
+        {
+            if(eChartType == chart::TYPEID_PIE)
+            {
+            /* In OOXML we get value in 0..90 range for pie chart X rotation , whereas we expect it to be in -90..90 range,
+               so we convert that during import. It is modified in View3DConverter::convertFromModel()
+               here we convert it back to 0..90 as we received in import */
+               nRotationX += 90;  // X rotation (map Chart2 [-179,180] to OOXML [0..90])
+            }
+            else
+                nRotationX += 360; // X rotation (map Chart2 [-179,180] to OOXML [-90..90])
+        }
+        pFS->singleElement(FSNS(XML_c, XML_rotX), XML_val, OString::number(nRotationX));
+    }
+    // rotY
+    if( GetProperty( xPropSet, "RotationVertical" ) )
+    {
+        // Y rotation (map Chart2 [-179,180] to OOXML [0..359])
+        if( eChartType == chart::TYPEID_PIE && GetProperty( xPropSet, "StartingAngle" ) )
+        {
+         // Y rotation used as 'first pie slice angle' in 3D pie charts
+            sal_Int32 nStartingAngle=0;
+            mAny >>= nStartingAngle;
+            // convert to ooxml angle
+            nStartingAngle = (450 - nStartingAngle ) % 360;
+            pFS->singleElement(FSNS(XML_c, XML_rotY), XML_val, OString::number(nStartingAngle));
+        }
+        else
+        {
+            sal_Int32 nRotationY = 0;
+            mAny >>= nRotationY;
+            // Y rotation (map Chart2 [-179,180] to OOXML [0..359])
+            if( nRotationY < 0 )
+                nRotationY += 360;
+            pFS->singleElement(FSNS(XML_c, XML_rotY), XML_val, OString::number(nRotationY));
+        }
+    }
+    // rAngAx
+    if( GetProperty( xPropSet, "RightAngledAxes" ) )
+    {
+        bool bRightAngled = false;
+        mAny >>= bRightAngled;
+        const char* sRightAngled = bRightAngled ? "1":"0";
+        pFS->singleElement(FSNS(XML_c, XML_rAngAx), XML_val, sRightAngled);
+    }
+    // perspective
+    if( GetProperty( xPropSet, "Perspective" ) )
+    {
+        sal_Int32 nPerspective = 0;
+        mAny >>= nPerspective;
+        // map Chart2 [0,100] to OOXML [0..200]
+        nPerspective *= 2;
+        pFS->singleElement(FSNS(XML_c, XML_perspective), XML_val, OString::number(nPerspective));
+    }
+    pFS->endElement( FSNS( XML_c, XML_view3D ) );
+}
+
+bool ChartExport::isDeep3dChart()
+{
+    bool isDeep = false;
+    if( mbIs3DChart )
+    {
+        Reference< XPropertySet > xPropSet( mxDiagram , uno::UNO_QUERY);
+        if( GetProperty( xPropSet, "Deep" ) )
+            mAny >>= isDeep;
+    }
+    return isDeep;
+}
+
+OUString ChartExport::getNumberFormatCode(sal_Int32 nKey) const
+{
+    /* XXX if this was called more than one or two times per export the two
+     * SvNumberFormatter instances and NfKeywordTable should be member
+     * variables and initialized only once. */
+
+    OUString aCode("General");  // init with fallback
+    uno::Reference<util::XNumberFormatsSupplier> xNumberFormatsSupplier(mxChartModel, uno::UNO_QUERY_THROW);
+    SvNumberFormatsSupplierObj* pSupplierObj = comphelper::getUnoTunnelImplementation<SvNumberFormatsSupplierObj>( xNumberFormatsSupplier);
+    if (!pSupplierObj)
+        return aCode;
+
+    SvNumberFormatter* pNumberFormatter = pSupplierObj->GetNumberFormatter();
+    if (!pNumberFormatter)
+        return aCode;
+
+    SvNumberFormatter aTempFormatter( comphelper::getProcessComponentContext(), LANGUAGE_ENGLISH_US);
+    NfKeywordTable aKeywords;
+    aTempFormatter.FillKeywordTableForExcel( aKeywords);
+    aCode = pNumberFormatter->GetFormatStringForExcel( nKey, aKeywords, aTempFormatter);
+
+    return aCode;
+}
+
+}// oox
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/oox/source/export/drawingml.cxx b/oox/source/export/drawingml.cxx
new file mode 100644
index 000000000..de2d34979
--- /dev/null
+++ b/oox/source/export/drawingml.cxx
@@ -0,0 +1,4634 @@
+/* -*- 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 <config_features.h>
+
+#include <config_folders.h>
+#include <rtl/bootstrap.hxx>
+#include <sal/log.hxx>
+#include <oox/core/xmlfilterbase.hxx>
+#include <oox/export/drawingml.hxx>
+#include <oox/export/utils.hxx>
+#include <oox/helper/propertyset.hxx>
+#include <oox/drawingml/color.hxx>
+#include <drawingml/fillproperties.hxx>
+#include <drawingml/textparagraph.hxx>
+#include <oox/token/namespaces.hxx>
+#include <oox/token/properties.hxx>
+#include <oox/token/relationship.hxx>
+#include <oox/token/tokens.hxx>
+#include <oox/drawingml/drawingmltypes.hxx>
+#include <svtools/unitconv.hxx>
+#include <sax/fastattribs.hxx>
+#include <tools/diagnose_ex.h>
+#include <comphelper/processfactory.hxx>
+#include <i18nlangtag/languagetag.hxx>
+
+#include <numeric>
+#include <com/sun/star/awt/CharSet.hpp>
+#include <com/sun/star/awt/FontDescriptor.hpp>
+#include <com/sun/star/awt/FontSlant.hpp>
+#include <com/sun/star/awt/FontStrikeout.hpp>
+#include <com/sun/star/awt/FontWeight.hpp>
+#include <com/sun/star/awt/FontUnderline.hpp>
+#include <com/sun/star/awt/Gradient.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/beans/XPropertyState.hpp>
+#include <com/sun/star/beans/XPropertySetInfo.hpp>
+#include <com/sun/star/container/XEnumerationAccess.hpp>
+#include <com/sun/star/container/XIndexAccess.hpp>
+#include <com/sun/star/container/XNameAccess.hpp>
+#include <com/sun/star/drawing/BitmapMode.hpp>
+#include <com/sun/star/drawing/ColorMode.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeAdjustmentValue.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeParameterPair.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeSegment.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeSegmentCommand.hpp>
+#include <com/sun/star/drawing/Hatch.hpp>
+#include <com/sun/star/drawing/LineDash.hpp>
+#include <com/sun/star/drawing/LineJoint.hpp>
+#include <com/sun/star/drawing/LineStyle.hpp>
+#include <com/sun/star/drawing/TextFitToSizeType.hpp>
+#include <com/sun/star/drawing/TextHorizontalAdjust.hpp>
+#include <com/sun/star/drawing/TextVerticalAdjust.hpp>
+#include <com/sun/star/drawing/XShape.hpp>
+#include <com/sun/star/drawing/XShapes.hpp>
+#include <com/sun/star/drawing/FillStyle.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/graphic/XGraphic.hpp>
+#include <com/sun/star/i18n/ScriptType.hpp>
+#include <com/sun/star/i18n/BreakIterator.hpp>
+#include <com/sun/star/i18n/XBreakIterator.hpp>
+#include <com/sun/star/io/XOutputStream.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/style/LineSpacing.hpp>
+#include <com/sun/star/style/LineSpacingMode.hpp>
+#include <com/sun/star/text/WritingMode.hpp>
+#include <com/sun/star/text/WritingMode2.hpp>
+#include <com/sun/star/text/GraphicCrop.hpp>
+#include <com/sun/star/text/XText.hpp>
+#include <com/sun/star/text/XTextContent.hpp>
+#include <com/sun/star/text/XTextField.hpp>
+#include <com/sun/star/text/XTextRange.hpp>
+#include <com/sun/star/style/CaseMap.hpp>
+#include <com/sun/star/xml/dom/XNodeList.hpp>
+#include <com/sun/star/xml/sax/Writer.hpp>
+#include <com/sun/star/xml/sax/XSAXSerializable.hpp>
+
+#include <comphelper/random.hxx>
+#include <comphelper/seqstream.hxx>
+#include <comphelper/storagehelper.hxx>
+#include <comphelper/xmltools.hxx>
+#include <o3tl/any.hxx>
+#include <o3tl/safeint.hxx>
+#include <tools/stream.hxx>
+#include <unotools/fontdefs.hxx>
+#include <vcl/cvtgrf.hxx>
+#include <vcl/graph.hxx>
+#include <vcl/svapp.hxx>
+#include <rtl/strbuf.hxx>
+#include <filter/msfilter/escherex.hxx>
+#include <filter/msfilter/util.hxx>
+#include <editeng/outlobj.hxx>
+#include <editeng/svxenum.hxx>
+#include <editeng/unonames.hxx>
+#include <editeng/unoprnms.hxx>
+#include <editeng/flditem.hxx>
+#include <svx/svdoashp.hxx>
+#include <svx/svdomedia.hxx>
+#include <svx/unoapi.hxx>
+#include <svx/unoshape.hxx>
+#include <svx/EnhancedCustomShape2d.hxx>
+
+using namespace ::css;
+using namespace ::css::beans;
+using namespace ::css::drawing;
+using namespace ::css::i18n;
+using namespace ::css::style;
+using namespace ::css::text;
+using namespace ::css::uno;
+using namespace ::css::container;
+
+using ::css::io::XOutputStream;
+using ::sax_fastparser::FSHelperPtr;
+using ::sax_fastparser::FastSerializerHelper;
+
+namespace
+{
+/// Extracts start or end alpha information from a transparency gradient.
+sal_Int32 GetAlphaFromTransparenceGradient(const awt::Gradient& rGradient, bool bStart)
+{
+    // Our alpha is a gray color value.
+    sal_uInt8 nRed = ::Color(bStart ? rGradient.StartColor : rGradient.EndColor).GetRed();
+    // drawingML alpha is a percentage on a 0..100000 scale.
+    return (255 - nRed) * oox::drawingml::MAX_PERCENT / 255;
+}
+}
+
+namespace oox::drawingml {
+
+URLTransformer::~URLTransformer()
+{
+}
+
+OUString URLTransformer::getTransformedString(const OUString& rString) const
+{
+    return rString;
+}
+
+bool URLTransformer::isExternalURL(const OUString& /*rURL*/) const
+{
+    return true;
+}
+
+static css::uno::Any getLineDash( const css::uno::Reference<css::frame::XModel>& xModel, const OUString& rDashName )
+    {
+        css::uno::Reference<css::lang::XMultiServiceFactory> xFact(xModel, css::uno::UNO_QUERY);
+        css::uno::Reference<css::container::XNameAccess> xNameAccess(
+            xFact->createInstance("com.sun.star.drawing.DashTable"),
+            css::uno::UNO_QUERY );
+        if(xNameAccess.is())
+        {
+            if (!xNameAccess->hasByName(rDashName))
+                return css::uno::Any();
+
+            return xNameAccess->getByName(rDashName);
+        }
+
+        return css::uno::Any();
+    }
+
+namespace
+{
+void WriteGradientPath(const awt::Gradient& rGradient, const FSHelperPtr& pFS, const bool bCircle)
+{
+    pFS->startElementNS(XML_a, XML_path, XML_path, bCircle ? "circle" : "rect");
+
+    // Write the focus rectangle. Work with the focus point, and assume
+    // that it extends 50% in all directions.  The below
+    // left/top/right/bottom values are percentages, where 0 means the
+    // edge of the tile rectangle and 100% means the center of it.
+    rtl::Reference<sax_fastparser::FastAttributeList> pAttributeList(
+        sax_fastparser::FastSerializerHelper::createAttrList());
+    sal_Int32 nLeftPercent = rGradient.XOffset;
+    pAttributeList->add(XML_l, OString::number(nLeftPercent * PER_PERCENT));
+    sal_Int32 nTopPercent = rGradient.YOffset;
+    pAttributeList->add(XML_t, OString::number(nTopPercent * PER_PERCENT));
+    sal_Int32 nRightPercent = 100 - rGradient.XOffset;
+    pAttributeList->add(XML_r, OString::number(nRightPercent * PER_PERCENT));
+    sal_Int32 nBottomPercent = 100 - rGradient.YOffset;
+    pAttributeList->add(XML_b, OString::number(nBottomPercent * PER_PERCENT));
+    sax_fastparser::XFastAttributeListRef xAttributeList(pAttributeList.get());
+    pFS->singleElementNS(XML_a, XML_fillToRect, xAttributeList);
+
+    pFS->endElementNS(XML_a, XML_path);
+}
+}
+
+// not thread safe
+int DrawingML::mnImageCounter = 1;
+int DrawingML::mnWdpImageCounter = 1;
+std::map<OUString, OUString> DrawingML::maWdpCache;
+
+sal_Int16 DrawingML::GetScriptType(const OUString& rStr)
+{
+    if (rStr.getLength() > 0)
+    {
+        static Reference<css::i18n::XBreakIterator> xBreakIterator =
+            css::i18n::BreakIterator::create(comphelper::getProcessComponentContext());
+
+        sal_Int16 nScriptType = xBreakIterator->getScriptType(rStr, 0);
+
+        if (nScriptType == css::i18n::ScriptType::WEAK)
+        {
+            sal_Int32 nPos = xBreakIterator->nextScript(rStr, 0, nScriptType);
+            if (nPos < rStr.getLength())
+                nScriptType = xBreakIterator->getScriptType(rStr, nPos);
+
+        }
+
+        if (nScriptType != css::i18n::ScriptType::WEAK)
+            return nScriptType;
+    }
+
+    return css::i18n::ScriptType::LATIN;
+}
+
+void DrawingML::ResetCounters()
+{
+    mnImageCounter = 1;
+    mnWdpImageCounter = 1;
+    maWdpCache.clear();
+}
+
+bool DrawingML::GetProperty( const Reference< XPropertySet >& rXPropertySet, const OUString& aName )
+{
+    try
+    {
+        mAny = rXPropertySet->getPropertyValue(aName);
+        if (mAny.hasValue())
+            return true;
+    }
+    catch( const Exception& )
+    {
+        /* printf ("exception when trying to get value of property: %s\n", aName.toUtf8()); */
+    }
+    return false;
+}
+
+bool DrawingML::GetPropertyAndState( const Reference< XPropertySet >& rXPropertySet, const Reference< XPropertyState >& rXPropertyState, const OUString& aName, PropertyState& eState )
+{
+    try
+    {
+        mAny = rXPropertySet->getPropertyValue(aName);
+        if (mAny.hasValue())
+        {
+            eState = rXPropertyState->getPropertyState(aName);
+            return true;
+        }
+    }
+    catch( const Exception& )
+    {
+        /* printf ("exception when trying to get value of property: %s\n", aName.toUtf8()); */
+    }
+    return false;
+}
+
+void DrawingML::WriteColor( ::Color nColor, sal_Int32 nAlpha )
+{
+    // Transparency is a separate element.
+    OString sColor = OString::number(  sal_uInt32(nColor) & 0x00FFFFFF, 16 );
+    if( sColor.getLength() < 6 )
+    {
+        OStringBuffer sBuf( "0" );
+        int remains = 5 - sColor.getLength();
+
+        while( remains > 0 )
+        {
+            sBuf.append( "0" );
+            remains--;
+        }
+
+        sBuf.append( sColor );
+
+        sColor = sBuf.getStr();
+    }
+    if( nAlpha < MAX_PERCENT )
+    {
+        mpFS->startElementNS(XML_a, XML_srgbClr, XML_val, sColor);
+        mpFS->singleElementNS(XML_a, XML_alpha, XML_val, OString::number(nAlpha));
+        mpFS->endElementNS( XML_a, XML_srgbClr );
+
+    }
+    else
+    {
+        mpFS->singleElementNS(XML_a, XML_srgbClr, XML_val, sColor);
+    }
+}
+
+void DrawingML::WriteColor( const OUString& sColorSchemeName, const Sequence< PropertyValue >& aTransformations, sal_Int32 nAlpha )
+{
+    // prevent writing a tag with empty val attribute
+    if( sColorSchemeName.isEmpty() )
+        return;
+
+    if( aTransformations.hasElements() )
+    {
+        mpFS->startElementNS(XML_a, XML_schemeClr, XML_val, sColorSchemeName.toUtf8());
+        WriteColorTransformations( aTransformations, nAlpha );
+        mpFS->endElementNS( XML_a, XML_schemeClr );
+    }
+    else if(nAlpha < MAX_PERCENT)
+    {
+        mpFS->startElementNS(XML_a, XML_schemeClr, XML_val, sColorSchemeName.toUtf8());
+        mpFS->singleElementNS(XML_a, XML_alpha, XML_val, OString::number(nAlpha));
+        mpFS->endElementNS( XML_a, XML_schemeClr );
+    }
+    else
+    {
+        mpFS->singleElementNS(XML_a, XML_schemeClr, XML_val, sColorSchemeName.toUtf8());
+    }
+}
+
+void DrawingML::WriteColorTransformations( const Sequence< PropertyValue >& aTransformations, sal_Int32 nAlpha )
+{
+    for( const auto& rTransformation : aTransformations )
+    {
+        sal_Int32 nToken = Color::getColorTransformationToken( rTransformation.Name );
+        if( nToken != XML_TOKEN_INVALID && rTransformation.Value.hasValue() )
+        {
+            if(nToken == XML_alpha && nAlpha < MAX_PERCENT)
+            {
+                mpFS->singleElementNS(XML_a, nToken, XML_val, OString::number(nAlpha));
+            }
+            else
+            {
+                sal_Int32 nValue = rTransformation.Value.get<sal_Int32>();
+                mpFS->singleElementNS(XML_a, nToken, XML_val, OString::number(nValue));
+            }
+        }
+    }
+}
+
+void DrawingML::WriteSolidFill( ::Color nColor, sal_Int32 nAlpha )
+{
+    mpFS->startElementNS(XML_a, XML_solidFill);
+    WriteColor( nColor, nAlpha );
+    mpFS->endElementNS( XML_a, XML_solidFill );
+}
+
+void DrawingML::WriteSolidFill( const OUString& sSchemeName, const Sequence< PropertyValue >& aTransformations, sal_Int32 nAlpha )
+{
+    mpFS->startElementNS(XML_a, XML_solidFill);
+    WriteColor( sSchemeName, aTransformations, nAlpha );
+    mpFS->endElementNS( XML_a, XML_solidFill );
+}
+
+void DrawingML::WriteSolidFill( const Reference< XPropertySet >& rXPropSet )
+{
+    // get fill color
+    if ( !GetProperty( rXPropSet, "FillColor" ) )
+        return;
+    sal_uInt32 nFillColor = mAny.get<sal_uInt32>();
+
+    // get InteropGrabBag and search the relevant attributes
+    OUString sColorFillScheme;
+    sal_uInt32 nOriginalColor = 0;
+    Sequence< PropertyValue > aStyleProperties, aTransformations;
+    if ( GetProperty( rXPropSet, "InteropGrabBag" ) )
+    {
+        Sequence< PropertyValue > aGrabBag;
+        mAny >>= aGrabBag;
+        for( const auto& rProp : std::as_const(aGrabBag) )
+        {
+            if( rProp.Name == "SpPrSolidFillSchemeClr" )
+                rProp.Value >>= sColorFillScheme;
+            else if( rProp.Name == "OriginalSolidFillClr" )
+                rProp.Value >>= nOriginalColor;
+            else if( rProp.Name == "StyleFillRef" )
+                rProp.Value >>= aStyleProperties;
+            else if( rProp.Name == "SpPrSolidFillSchemeClrTransformations" )
+                rProp.Value >>= aTransformations;
+        }
+    }
+
+    sal_Int32 nAlpha = MAX_PERCENT;
+    if( GetProperty( rXPropSet, "FillTransparence" ) )
+    {
+        sal_Int32 nTransparency = 0;
+        mAny >>= nTransparency;
+        // Calculate alpha value (see oox/source/drawingml/color.cxx : getTransparency())
+        nAlpha = (MAX_PERCENT - ( PER_PERCENT * nTransparency ) );
+    }
+
+    // OOXML has no separate transparence gradient but uses transparency in the gradient stops.
+    // So we merge transparency and color and use gradient fill in such case.
+    awt::Gradient aTransparenceGradient;
+    bool bNeedGradientFill(false);
+    if (GetProperty(rXPropSet, "FillTransparenceGradient"))
+    {
+        mAny >>= aTransparenceGradient;
+        if (aTransparenceGradient.StartColor != aTransparenceGradient.EndColor)
+            bNeedGradientFill = true;
+        else if (aTransparenceGradient.StartColor != 0)
+            nAlpha = GetAlphaFromTransparenceGradient(aTransparenceGradient, true);
+    }
+
+    // write XML
+    if (bNeedGradientFill)
+    {
+        awt::Gradient aPseudoColorGradient;
+        aPseudoColorGradient.XOffset = aTransparenceGradient.XOffset;
+        aPseudoColorGradient.YOffset = aTransparenceGradient.YOffset;
+        aPseudoColorGradient.StartIntensity = 100;
+        aPseudoColorGradient.EndIntensity = 100;
+        aPseudoColorGradient.Angle = aTransparenceGradient.Angle;
+        aPseudoColorGradient.Border = aTransparenceGradient.Border;
+        aPseudoColorGradient.Style = aTransparenceGradient.Style;
+        aPseudoColorGradient.StartColor = nFillColor;
+        aPseudoColorGradient.EndColor = nFillColor;
+        aPseudoColorGradient.StepCount = aTransparenceGradient.StepCount;
+        mpFS->startElementNS(XML_a, XML_gradFill, XML_rotWithShape, "0");
+        WriteGradientFill(aPseudoColorGradient, aTransparenceGradient);
+        mpFS->endElementNS( XML_a, XML_gradFill );
+    }
+    else if ( nFillColor != nOriginalColor )
+    {
+        // the user has set a different color for the shape
+        WriteSolidFill( ::Color(nFillColor & 0xffffff), nAlpha );
+    }
+    else if ( !sColorFillScheme.isEmpty() )
+    {
+        // the shape had a scheme color and the user didn't change it
+        WriteSolidFill( sColorFillScheme, aTransformations, nAlpha );
+    }
+    else
+    {
+        // the shape had a custom color and the user didn't change it
+        // tdf#124013
+        WriteSolidFill( ::Color(nFillColor & 0xffffff), nAlpha );
+    }
+}
+
+void DrawingML::WriteGradientStop(sal_uInt16 nStop, ::Color nColor, sal_Int32 nAlpha)
+{
+    mpFS->startElementNS(XML_a, XML_gs, XML_pos, OString::number(nStop * 1000));
+    WriteColor(nColor, nAlpha);
+    mpFS->endElementNS( XML_a, XML_gs );
+}
+
+::Color DrawingML::ColorWithIntensity( sal_uInt32 nColor, sal_uInt32 nIntensity )
+{
+    return ::Color(( ( ( nColor & 0xff ) * nIntensity ) / 100 )
+        | ( ( ( ( ( nColor & 0xff00 ) >> 8 ) * nIntensity ) / 100 ) << 8 )
+        | ( ( ( ( ( nColor & 0xff0000 ) >> 8 ) * nIntensity ) / 100 ) << 8 ));
+}
+
+bool DrawingML::EqualGradients( awt::Gradient aGradient1, awt::Gradient aGradient2 )
+{
+    return aGradient1.Style == aGradient2.Style &&
+            aGradient1.StartColor == aGradient2.StartColor &&
+            aGradient1.EndColor == aGradient2.EndColor &&
+            aGradient1.Angle == aGradient2.Angle &&
+            aGradient1.Border == aGradient2.Border &&
+            aGradient1.XOffset == aGradient2.XOffset &&
+            aGradient1.YOffset == aGradient2.YOffset &&
+            aGradient1.StartIntensity == aGradient2.StartIntensity &&
+            aGradient1.EndIntensity == aGradient2.EndIntensity &&
+            aGradient1.StepCount == aGradient2.StepCount;
+}
+
+void DrawingML::WriteGradientFill( const Reference< XPropertySet >& rXPropSet )
+{
+    awt::Gradient aGradient;
+    awt::Gradient aTransparenceGradient;
+    if (!GetProperty(rXPropSet, "FillGradient"))
+        return;
+
+    aGradient = *o3tl::doAccess<awt::Gradient>(mAny);
+
+    // get InteropGrabBag and search the relevant attributes
+    awt::Gradient aOriginalGradient;
+    Sequence< PropertyValue > aGradientStops;
+    if ( GetProperty( rXPropSet, "InteropGrabBag" ) )
+    {
+        Sequence< PropertyValue > aGrabBag;
+        mAny >>= aGrabBag;
+        for( const auto& rProp : std::as_const(aGrabBag) )
+            if( rProp.Name == "GradFillDefinition" )
+                rProp.Value >>= aGradientStops;
+            else if( rProp.Name == "OriginalGradFill" )
+                rProp.Value >>= aOriginalGradient;
+    }
+
+    // check if an ooxml gradient had been imported and if the user has modified it
+    // Gradient grab-bag depends on theme grab-bag, which is implemented
+    // only for DOCX.
+    if( EqualGradients( aOriginalGradient, aGradient ) && GetDocumentType() == DOCUMENT_DOCX)
+    {
+        // If we have no gradient stops that means original gradient were defined by a theme.
+        if( aGradientStops.hasElements() )
+        {
+            mpFS->startElementNS(XML_a, XML_gradFill, XML_rotWithShape, "0");
+            WriteGrabBagGradientFill(aGradientStops, aGradient);
+            mpFS->endElementNS( XML_a, XML_gradFill );
+        }
+    }
+    else
+    {
+        mpFS->startElementNS(XML_a, XML_gradFill, XML_rotWithShape, "0");
+        if( GetProperty(rXPropSet, "FillTransparenceGradient") )
+            aTransparenceGradient = *o3tl::doAccess<awt::Gradient>(mAny);
+        WriteGradientFill(aGradient, aTransparenceGradient);
+        mpFS->endElementNS( XML_a, XML_gradFill );
+    }
+}
+
+void DrawingML::WriteGrabBagGradientFill( const Sequence< PropertyValue >& aGradientStops, awt::Gradient rGradient )
+{
+    // write back the original gradient
+    mpFS->startElementNS(XML_a, XML_gsLst);
+
+    // get original stops and write them
+    for( const auto& rGradientStop : aGradientStops )
+    {
+        Sequence< PropertyValue > aGradientStop;
+        rGradientStop.Value >>= aGradientStop;
+
+        // get values
+        OUString sSchemeClr;
+        double nPos = 0;
+        sal_Int16 nTransparency = 0;
+        ::Color nRgbClr;
+        Sequence< PropertyValue > aTransformations;
+        for( const auto& rProp : std::as_const(aGradientStop) )
+        {
+            if( rProp.Name == "SchemeClr" )
+                rProp.Value >>= sSchemeClr;
+            else if( rProp.Name == "RgbClr" )
+                rProp.Value >>= nRgbClr;
+            else if( rProp.Name == "Pos" )
+                rProp.Value >>= nPos;
+            else if( rProp.Name == "Transparency" )
+                rProp.Value >>= nTransparency;
+            else if( rProp.Name == "Transformations" )
+                rProp.Value >>= aTransformations;
+        }
+        // write stop
+        mpFS->startElementNS(XML_a, XML_gs, XML_pos, OString::number(nPos * 100000.0).getStr());
+        if( sSchemeClr.isEmpty() )
+        {
+            // Calculate alpha value (see oox/source/drawingml/color.cxx : getTransparency())
+            sal_Int32 nAlpha = MAX_PERCENT - ( PER_PERCENT * nTransparency );
+            WriteColor( nRgbClr, nAlpha );
+        }
+        else
+        {
+            WriteColor( sSchemeClr, aTransformations );
+        }
+        mpFS->endElementNS( XML_a, XML_gs );
+    }
+    mpFS->endElementNS( XML_a, XML_gsLst );
+
+    switch (rGradient.Style)
+    {
+        default:
+            mpFS->singleElementNS(
+                XML_a, XML_lin, XML_ang,
+                OString::number((((3600 - rGradient.Angle + 900) * 6000) % 21600000)));
+            break;
+        case awt::GradientStyle_RADIAL:
+            WriteGradientPath(rGradient, mpFS, true);
+            break;
+    }
+}
+
+void DrawingML::WriteGradientFill(awt::Gradient rGradient, awt::Gradient rTransparenceGradient,
+                                  const uno::Reference<beans::XPropertySet>& rXPropSet)
+{
+    sal_Int32 nStartAlpha;
+    sal_Int32 nEndAlpha;
+    if( rXPropSet.is() && GetProperty(rXPropSet, "FillTransparence") )
+    {
+        sal_Int32 nTransparency = 0;
+        mAny >>= nTransparency;
+        nStartAlpha = nEndAlpha = (MAX_PERCENT - (PER_PERCENT * nTransparency));
+    }
+    else
+    {
+        nStartAlpha = GetAlphaFromTransparenceGradient(rTransparenceGradient, true);
+        nEndAlpha = GetAlphaFromTransparenceGradient(rTransparenceGradient, false);
+    }
+    switch( rGradient.Style )
+    {
+        default:
+        case awt::GradientStyle_LINEAR:
+        {
+            mpFS->startElementNS(XML_a, XML_gsLst);
+            WriteGradientStop(rGradient.Border, ColorWithIntensity(rGradient.StartColor, rGradient.StartIntensity),
+                              nStartAlpha);
+            WriteGradientStop(100, ColorWithIntensity(rGradient.EndColor, rGradient.EndIntensity),
+                              nEndAlpha);
+            mpFS->endElementNS( XML_a, XML_gsLst );
+            mpFS->singleElementNS(
+                XML_a, XML_lin, XML_ang,
+                OString::number((((3600 - rGradient.Angle + 900) * 6000) % 21600000)));
+            break;
+        }
+
+        case awt::GradientStyle_AXIAL:
+        {
+            mpFS->startElementNS(XML_a, XML_gsLst);
+            WriteGradientStop(0, ColorWithIntensity(rGradient.EndColor, rGradient.EndIntensity),
+                              nEndAlpha);
+            if (rGradient.Border > 0 && rGradient.Border < 100)
+            {
+                WriteGradientStop(rGradient.Border/2,
+                                  ColorWithIntensity(rGradient.EndColor, rGradient.EndIntensity),
+                                  nEndAlpha);
+            }
+            WriteGradientStop(50, ColorWithIntensity(rGradient.StartColor, rGradient.StartIntensity),
+                              nStartAlpha);
+            if (rGradient.Border > 0 && rGradient.Border < 100)
+            {
+                WriteGradientStop(100 - rGradient.Border/2,
+                                  ColorWithIntensity(rGradient.EndColor, rGradient.EndIntensity),
+                                  nEndAlpha);
+            }
+            WriteGradientStop(100, ColorWithIntensity(rGradient.EndColor, rGradient.EndIntensity),
+                              nEndAlpha);
+            mpFS->endElementNS(XML_a, XML_gsLst);
+            mpFS->singleElementNS(
+                XML_a, XML_lin, XML_ang,
+                OString::number((((3600 - rGradient.Angle + 900) * 6000) % 21600000)));
+            break;
+        }
+
+        case awt::GradientStyle_RADIAL:
+        case awt::GradientStyle_ELLIPTICAL:
+        case awt::GradientStyle_RECT:
+        case awt::GradientStyle_SQUARE:
+        {
+            mpFS->startElementNS(XML_a, XML_gsLst);
+            WriteGradientStop(0, ColorWithIntensity(rGradient.EndColor, rGradient.EndIntensity),
+                              nEndAlpha);
+            if (rGradient.Border > 0 && rGradient.Border < 100)
+            {
+                // Map border to an additional gradient stop, which has the
+                // same color as the final stop.
+                WriteGradientStop(100 - rGradient.Border,
+                                  ColorWithIntensity(rGradient.StartColor, rGradient.StartIntensity),
+                                  nStartAlpha);
+            }
+            WriteGradientStop(100,
+                              ColorWithIntensity(rGradient.StartColor, rGradient.StartIntensity),
+                              nStartAlpha);
+            mpFS->endElementNS(XML_a, XML_gsLst);
+
+            WriteGradientPath(rGradient, mpFS, rGradient.Style == awt::GradientStyle_RADIAL || rGradient.Style == awt::GradientStyle_ELLIPTICAL);
+            break;
+        }
+    }
+}
+
+void DrawingML::WriteLineArrow( const Reference< XPropertySet >& rXPropSet, bool bLineStart )
+{
+    ESCHER_LineEnd eLineEnd;
+    sal_Int32 nArrowLength;
+    sal_Int32 nArrowWidth;
+
+    if ( !EscherPropertyContainer::GetLineArrow( bLineStart, rXPropSet, eLineEnd, nArrowLength, nArrowWidth ) )
+        return;
+
+    const char* len;
+    const char* type;
+    const char* width;
+
+    switch( nArrowLength )
+    {
+        case ESCHER_LineShortArrow:
+            len = "sm";
+            break;
+        default:
+        case ESCHER_LineMediumLenArrow:
+            len = "med";
+            break;
+        case ESCHER_LineLongArrow:
+            len = "lg";
+            break;
+    }
+
+    switch( eLineEnd )
+    {
+        default:
+        case ESCHER_LineNoEnd:
+            type = "none";
+            break;
+        case ESCHER_LineArrowEnd:
+            type = "triangle";
+            break;
+        case ESCHER_LineArrowStealthEnd:
+            type = "stealth";
+            break;
+        case ESCHER_LineArrowDiamondEnd:
+            type = "diamond";
+            break;
+        case ESCHER_LineArrowOvalEnd:
+            type = "oval";
+            break;
+        case ESCHER_LineArrowOpenEnd:
+            type = "arrow";
+            break;
+    }
+
+    switch( nArrowWidth )
+    {
+        case ESCHER_LineNarrowArrow:
+            width = "sm";
+            break;
+        default:
+        case ESCHER_LineMediumWidthArrow:
+            width = "med";
+            break;
+        case ESCHER_LineWideArrow:
+            width = "lg";
+            break;
+    }
+
+    mpFS->singleElementNS( XML_a, bLineStart ? XML_headEnd : XML_tailEnd,
+                           XML_len, len,
+                           XML_type, type,
+                           XML_w, width );
+}
+
+void DrawingML::WriteOutline( const Reference<XPropertySet>& rXPropSet, Reference< frame::XModel > const & xModel )
+{
+    drawing::LineStyle aLineStyle( drawing::LineStyle_NONE );
+    if (GetProperty(rXPropSet, "LineStyle"))
+        mAny >>= aLineStyle;
+
+    const LineCap aLineCap = GetProperty(rXPropSet, "LineCap") ? mAny.get<drawing::LineCap>() : LineCap_BUTT;
+
+    sal_uInt32 nLineWidth = 0;
+    sal_uInt32 nEmuLineWidth = 0;
+    ::Color nColor;
+    sal_Int32 nColorAlpha = MAX_PERCENT;
+    bool bColorSet = false;
+    const char* cap = nullptr;
+    drawing::LineDash aLineDash;
+    bool bDashSet = false;
+    bool bNoFill = false;
+
+
+    // get InteropGrabBag and search the relevant attributes
+    OUString sColorFillScheme;
+
+    ::Color nOriginalColor;
+    ::Color nStyleColor;
+    sal_uInt32 nStyleLineWidth = 0;
+
+    Sequence<PropertyValue> aStyleProperties;
+    Sequence<PropertyValue> aTransformations;
+
+    drawing::LineStyle aStyleLineStyle(drawing::LineStyle_NONE);
+    drawing::LineJoint aStyleLineJoint(drawing::LineJoint_NONE);
+
+    if (GetProperty(rXPropSet, "InteropGrabBag"))
+    {
+        Sequence<PropertyValue> aGrabBag;
+        mAny >>= aGrabBag;
+
+        for (const auto& rProp : std::as_const(aGrabBag))
+        {
+            if( rProp.Name == "SpPrLnSolidFillSchemeClr" )
+                rProp.Value >>= sColorFillScheme;
+            else if( rProp.Name == "OriginalLnSolidFillClr" )
+                rProp.Value >>= nOriginalColor;
+            else if( rProp.Name == "StyleLnRef" )
+                rProp.Value >>= aStyleProperties;
+            else if( rProp.Name == "SpPrLnSolidFillSchemeClrTransformations" )
+                rProp.Value >>= aTransformations;
+            else if( rProp.Name == "EmuLineWidth" )
+                rProp.Value >>= nEmuLineWidth;
+        }
+        for (const auto& rStyleProp : std::as_const(aStyleProperties))
+        {
+            if( rStyleProp.Name == "Color" )
+                rStyleProp.Value >>= nStyleColor;
+            else if( rStyleProp.Name == "LineStyle" )
+                rStyleProp.Value >>= aStyleLineStyle;
+            else if( rStyleProp.Name == "LineJoint" )
+                rStyleProp.Value >>= aStyleLineJoint;
+            else if( rStyleProp.Name == "LineWidth" )
+                rStyleProp.Value >>= nStyleLineWidth;
+        }
+    }
+
+    if (GetProperty(rXPropSet, "LineWidth"))
+        mAny >>= nLineWidth;
+
+    switch (aLineStyle)
+    {
+        case drawing::LineStyle_NONE:
+            bNoFill = true;
+            break;
+        case drawing::LineStyle_DASH:
+            if (GetProperty(rXPropSet, "LineDash"))
+            {
+                aLineDash = mAny.get<drawing::LineDash>();
+                //this query is good for shapes, but in the case of charts it returns 0 values
+                if (aLineDash.Dots == 0 && aLineDash.DotLen == 0 && aLineDash.Dashes == 0 && aLineDash.DashLen == 0 && aLineDash.Distance == 0) {
+                    OUString aLineDashName;
+                    if (GetProperty(rXPropSet, "LineDashName"))
+                        mAny >>= aLineDashName;
+                    if (!aLineDashName.isEmpty() && xModel) {
+                        css::uno::Any aAny = getLineDash(xModel, aLineDashName);
+                        aAny >>= aLineDash;
+                    }
+                }
+            }
+            else
+            {
+                //export the linestyle of chart wall (plot area) and chart page
+                OUString aLineDashName;
+                if (GetProperty(rXPropSet, "LineDashName"))
+                    mAny >>= aLineDashName;
+                if (!aLineDashName.isEmpty() && xModel) {
+                    css::uno::Any aAny = getLineDash(xModel, aLineDashName);
+                    aAny >>= aLineDash;
+                }
+            }
+            bDashSet = true;
+            if (aLineDash.Style == DashStyle_ROUND || aLineDash.Style == DashStyle_ROUNDRELATIVE)
+            {
+                cap = "rnd";
+            }
+
+            SAL_INFO("oox.shape", "dash dots: " << aLineDash.Dots << " dashes: " << aLineDash.Dashes
+                    << " dotlen: " << aLineDash.DotLen << " dashlen: " << aLineDash.DashLen << " distance: " <<  aLineDash.Distance);
+
+            [[fallthrough]];
+        case drawing::LineStyle_SOLID:
+        default:
+            if (GetProperty(rXPropSet, "LineColor"))
+            {
+                nColor = ::Color(mAny.get<sal_uInt32>() & 0xffffff);
+                bColorSet = true;
+            }
+            if (GetProperty(rXPropSet, "LineTransparence"))
+            {
+                nColorAlpha = MAX_PERCENT - (mAny.get<sal_Int16>() * PER_PERCENT);
+            }
+            if (aLineCap == LineCap_ROUND)
+                cap = "rnd";
+            else if (aLineCap == LineCap_SQUARE)
+                 cap = "sq";
+            break;
+    }
+
+    // if the line-width was not modified after importing then the original EMU value will be exported to avoid unexpected conversion (rounding) error
+    if (nEmuLineWidth == 0 || static_cast<sal_uInt32>(oox::drawingml::convertEmuToHmm(nEmuLineWidth)) != nLineWidth)
+        nEmuLineWidth = oox::drawingml::convertHmmToEmu(nLineWidth);
+    mpFS->startElementNS( XML_a, XML_ln,
+                          XML_cap, cap,
+                          XML_w, nLineWidth == 0 || (nLineWidth > 1 && nStyleLineWidth != nLineWidth) ?
+                              OString::number(nEmuLineWidth).getStr() : nullptr );
+
+    if( bColorSet )
+    {
+        if( nColor != nOriginalColor )
+        {
+            // the user has set a different color for the line
+            WriteSolidFill( nColor, nColorAlpha );
+        }
+        else if( !sColorFillScheme.isEmpty() )
+        {
+            // the line had a scheme color and the user didn't change it
+            WriteSolidFill( sColorFillScheme, aTransformations );
+        }
+        else
+        {
+            WriteSolidFill( nColor, nColorAlpha );
+        }
+    }
+
+    if( bDashSet && aStyleLineStyle != drawing::LineStyle_DASH )
+    {
+        // Try to detect if it might come from ms preset line style import.
+        // MS Office styles are always relative, both binary and OOXML.
+        // "dot" is always the first dash and "dash" the second one. All OOXML presets linestyles
+        // start with the longer one. Definitions are in OOXML part 1, 20.1.10.49
+        // The tests are strict, for to not catch styles from standard.sod (as of Aug 2019).
+        bool bIsConverted = false;
+
+        bool bIsRelative(aLineDash.Style == DashStyle_RECTRELATIVE || aLineDash.Style == DashStyle_ROUNDRELATIVE);
+        if ( bIsRelative && aLineDash.Dots == 1)
+        {   // The length were tweaked on import in case of prstDash. Revert it here.
+            sal_uInt32 nDotLen = aLineDash.DotLen;
+            sal_uInt32 nDashLen = aLineDash.DashLen;
+            sal_uInt32 nDistance = aLineDash.Distance;
+            if (aLineCap != LineCap_BUTT && nDistance >= 99)
+            {
+                nDistance -= 99;
+                nDotLen += 99;
+                if (nDashLen > 0)
+                    nDashLen += 99;
+            }
+            // LO uses length 0 for 100%, if the attribute is missing in ODF.
+            // Other applications might write 100%. Make is unique for the conditions.
+            if (nDotLen == 0)
+                nDotLen = 100;
+            if (nDashLen == 0 && aLineDash.Dashes > 0)
+                nDashLen = 100;
+            bIsConverted = true;
+            if (nDotLen == 100 && aLineDash.Dashes == 0 && nDashLen == 0 && nDistance == 300)
+            {
+                mpFS->singleElementNS(XML_a, XML_prstDash, XML_val, "dot");
+            }
+            else if (nDotLen == 400 && aLineDash.Dashes == 0 && nDashLen == 0 && nDistance == 300)
+            {
+                mpFS->singleElementNS(XML_a, XML_prstDash, XML_val, "dash");
+            }
+            else if (nDotLen == 400 && aLineDash.Dashes == 1 && nDashLen == 100 && nDistance == 300)
+            {
+                mpFS->singleElementNS(XML_a, XML_prstDash, XML_val, "dashDot");
+            }
+            else if (nDotLen == 800 && aLineDash.Dashes == 0 && nDashLen == 0 && nDistance == 300)
+            {
+                mpFS->singleElementNS(XML_a, XML_prstDash, XML_val, "lgDash");
+            }
+            else if (nDotLen == 800 && aLineDash.Dashes == 1 && nDashLen == 100 && nDistance == 300)
+            {
+                mpFS->singleElementNS(XML_a, XML_prstDash, XML_val, "lgDashDot");
+            }
+            else if (nDotLen == 800 && aLineDash.Dashes == 2 && nDashLen == 100 && nDistance == 300)
+            {
+                mpFS->singleElementNS(XML_a, XML_prstDash, XML_val, "lgDashDotDot");
+            }
+            else if (nDotLen == 100 && aLineDash.Dashes == 0 && nDashLen == 0 && nDistance == 100)
+            {
+                mpFS->singleElementNS(XML_a, XML_prstDash, XML_val, "sysDot");
+            }
+            else if (nDotLen == 300 && aLineDash.Dashes == 0 && nDashLen == 0 && nDistance == 100)
+            {
+                mpFS->singleElementNS(XML_a, XML_prstDash, XML_val, "sysDash");
+            }
+            else if (nDotLen == 300 && aLineDash.Dashes == 1 && nDashLen == 100 && nDistance == 100)
+            {
+                mpFS->singleElementNS(XML_a, XML_prstDash, XML_val, "sysDashDot");
+            }
+            else if (nDotLen == 300 && aLineDash.Dashes == 2 && nDashLen == 100 && nDistance == 100)
+            {
+                mpFS->singleElementNS(XML_a, XML_prstDash, XML_val, "sysDashDotDot");
+            }
+            else
+                bIsConverted = false;
+        }
+        // Do not map our own line styles to OOXML prstDash values, because custDash gives better results.
+        if (!bIsConverted)
+        {
+            mpFS->startElementNS(XML_a, XML_custDash);
+            // In case of hairline we would need the current pixel size. Instead use a reasonable
+            // ersatz for it. The value is the same as SMALLEST_DASH_WIDTH in xattr.cxx.
+            // (And it makes sure fLineWidth is not zero in below division.)
+            double fLineWidth = nLineWidth > 0 ? nLineWidth : 26.95;
+            int i;
+            double fSp = bIsRelative ? aLineDash.Distance : aLineDash.Distance * 100.0 / fLineWidth;
+            // LO uses line width, in case Distance is zero. MS Office would use a space of zero length.
+            // So set 100% explicitly.
+            if (aLineDash.Distance <= 0)
+                    fSp = 100.0;
+            // In case of custDash, round caps are included in dash length in MS Office. Square caps are added
+            // to dash length, same as in ODF. Change the length values accordingly.
+            if (aLineCap == LineCap_ROUND && fSp > 99.0)
+                fSp -= 99.0;
+
+            if (aLineDash.Dots > 0)
+            {
+                double fD = bIsRelative ? aLineDash.DotLen : aLineDash.DotLen * 100.0 / fLineWidth;
+                // LO sets length to 0, if attribute is missing in ODF. Then a relative length of 100% is intended.
+                if (aLineDash.DotLen == 0)
+                    fD = 100.0;
+                // Tweak dash length, see above.
+                if (aLineCap == LineCap_ROUND && fSp > 99.0)
+                    fD += 99.0;
+
+                for( i = 0; i < aLineDash.Dots; i ++ )
+                {
+                    mpFS->singleElementNS( XML_a, XML_ds,
+                                           XML_d , write1000thOfAPercent(fD),
+                                           XML_sp, write1000thOfAPercent(fSp) );
+                }
+            }
+            if ( aLineDash.Dashes > 0 )
+            {
+                double fD = bIsRelative ? aLineDash.DashLen : aLineDash.DashLen * 100.0 / fLineWidth;
+                // LO sets length to 0, if attribute is missing in ODF. Then a relative length of 100% is intended.
+                if (aLineDash.DashLen == 0)
+                    fD = 100.0;
+                // Tweak dash length, see above.
+                if (aLineCap == LineCap_ROUND && fSp > 99.0)
+                    fD += 99.0;
+
+                for( i = 0; i < aLineDash.Dashes; i ++ )
+                {
+                    mpFS->singleElementNS( XML_a , XML_ds,
+                                           XML_d , write1000thOfAPercent(fD),
+                                           XML_sp, write1000thOfAPercent(fSp) );
+                }
+            }
+
+            SAL_WARN_IF(nLineWidth <= 0,
+                        "oox.shape", "while writing outline - custom dash - line width was < 0  : " << nLineWidth);
+            SAL_WARN_IF(aLineDash.Dashes < 0,
+                        "oox.shape", "while writing outline - custom dash - number of dashes was < 0  : " << aLineDash.Dashes);
+            SAL_WARN_IF(aLineDash.Dashes > 0 && aLineDash.DashLen <= 0,
+                        "oox.shape", "while writing outline - custom dash - dash length was < 0  : " << aLineDash.DashLen);
+            SAL_WARN_IF(aLineDash.Dots < 0,
+                        "oox.shape", "while writing outline - custom dash - number of dots was < 0  : " << aLineDash.Dots);
+            SAL_WARN_IF(aLineDash.Dots > 0 && aLineDash.DotLen <= 0,
+                        "oox.shape", "while writing outline - custom dash - dot length was < 0  : " << aLineDash.DotLen);
+            SAL_WARN_IF(aLineDash.Distance <= 0,
+                        "oox.shape", "while writing outline - custom dash - distance was < 0  : " << aLineDash.Distance);
+
+            mpFS->endElementNS( XML_a, XML_custDash );
+        }
+    }
+
+    if (!bNoFill && nLineWidth > 1 && GetProperty(rXPropSet, "LineJoint"))
+    {
+        LineJoint eLineJoint = mAny.get<LineJoint>();
+
+        if( aStyleLineJoint == LineJoint_NONE || aStyleLineJoint != eLineJoint )
+        {
+            // style-defined line joint does not exist, or is different from the shape's joint
+            switch( eLineJoint )
+            {
+                case LineJoint_NONE:
+                case LineJoint_BEVEL:
+                    mpFS->singleElementNS(XML_a, XML_bevel);
+                    break;
+                default:
+                case LineJoint_MIDDLE:
+                case LineJoint_MITER:
+                    mpFS->singleElementNS(XML_a, XML_miter);
+                    break;
+                case LineJoint_ROUND:
+                    mpFS->singleElementNS(XML_a, XML_round);
+                    break;
+            }
+        }
+    }
+
+    if( !bNoFill )
+    {
+        WriteLineArrow( rXPropSet, true );
+        WriteLineArrow( rXPropSet, false );
+    }
+    else
+    {
+        mpFS->singleElementNS(XML_a, XML_noFill);
+    }
+
+    mpFS->endElementNS( XML_a, XML_ln );
+}
+
+const char* DrawingML::GetComponentDir() const
+{
+    switch ( meDocumentType )
+    {
+        case DOCUMENT_DOCX: return "word";
+        case DOCUMENT_PPTX: return "ppt";
+        case DOCUMENT_XLSX: return "xl";
+    }
+
+    return "unknown";
+}
+
+const char* DrawingML::GetRelationCompPrefix() const
+{
+    switch ( meDocumentType )
+    {
+        case DOCUMENT_DOCX: return "";
+        case DOCUMENT_PPTX:
+        case DOCUMENT_XLSX: return "../";
+    }
+
+    return "unknown";
+}
+
+OUString DrawingML::WriteImage( const Graphic& rGraphic , bool bRelPathToMedia )
+{
+    GfxLink aLink = rGraphic.GetGfxLink ();
+    OUString sMediaType;
+    const char* pExtension = "";
+    OUString sRelId;
+
+    SvMemoryStream aStream;
+    const void* aData = aLink.GetData();
+    std::size_t nDataSize = aLink.GetDataSize();
+
+    switch ( aLink.GetType() )
+    {
+        case GfxLinkType::NativeGif:
+            sMediaType = "image/gif";
+            pExtension = ".gif";
+            break;
+
+        // #i15508# added BMP type for better exports
+        // export not yet active, so adding for reference (not checked)
+        case GfxLinkType::NativeBmp:
+            sMediaType = "image/bmp";
+            pExtension = ".bmp";
+            break;
+
+        case GfxLinkType::NativeJpg:
+            sMediaType = "image/jpeg";
+            pExtension = ".jpeg";
+            break;
+        case GfxLinkType::NativePng:
+            sMediaType = "image/png";
+            pExtension = ".png";
+            break;
+        case GfxLinkType::NativeTif:
+            sMediaType = "image/tiff";
+            pExtension = ".tif";
+            break;
+        case GfxLinkType::NativeWmf:
+            sMediaType = "image/x-wmf";
+            pExtension = ".wmf";
+            break;
+        case GfxLinkType::NativeMet:
+            sMediaType = "image/x-met";
+            pExtension = ".met";
+            break;
+        case GfxLinkType::NativePct:
+            sMediaType = "image/x-pict";
+            pExtension = ".pct";
+            break;
+        case GfxLinkType::NativeMov:
+            sMediaType = "application/movie";
+            pExtension = ".MOV";
+            break;
+        default:
+        {
+            GraphicType aType = rGraphic.GetType();
+            if ( aType == GraphicType::Bitmap || aType == GraphicType::GdiMetafile)
+            {
+                if ( aType == GraphicType::Bitmap )
+                {
+                    (void)GraphicConverter::Export( aStream, rGraphic, ConvertDataFormat::PNG );
+                    sMediaType = "image/png";
+                    pExtension = ".png";
+                }
+                else
+                {
+                    (void)GraphicConverter::Export( aStream, rGraphic, ConvertDataFormat::EMF );
+                    sMediaType = "image/x-emf";
+                    pExtension = ".emf";
+                }
+            }
+            else
+            {
+                SAL_WARN("oox.shape", "unhandled graphic type " << static_cast<int>(aType) );
+                /*Earlier, even in case of unhandled graphic types we were
+                  proceeding to write the image, which would eventually
+                  write an empty image with a zero size, and return a valid
+                  relationID, which is incorrect.
+                  */
+                return sRelId;
+            }
+
+            aData = aStream.GetData();
+            nDataSize = aStream.GetEndOfData();
+            break;
+        }
+    }
+
+    Reference< XOutputStream > xOutStream = mpFB->openFragmentStream( OUStringBuffer()
+                                                                      .appendAscii( GetComponentDir() )
+                                                                      .append( "/media/image" )
+                                                                      .append( static_cast<sal_Int32>(mnImageCounter) )
+                                                                      .appendAscii( pExtension )
+                                                                      .makeStringAndClear(),
+                                                                      sMediaType );
+    xOutStream->writeBytes( Sequence< sal_Int8 >( static_cast<const sal_Int8*>(aData), nDataSize ) );
+    xOutStream->closeOutput();
+
+    const OString sRelPathToMedia = "media/image";
+    OString sRelationCompPrefix;
+    if ( bRelPathToMedia )
+        sRelationCompPrefix = "../";
+    else
+        sRelationCompPrefix = GetRelationCompPrefix();
+    sRelId = mpFB->addRelation( mpFS->getOutputStream(),
+                                oox::getRelationship(Relationship::IMAGE),
+                                OUStringBuffer()
+                                .appendAscii( sRelationCompPrefix.getStr() )
+                                .appendAscii( sRelPathToMedia.getStr() )
+                                .append( static_cast<sal_Int32>(mnImageCounter ++) )
+                                .appendAscii( pExtension )
+                                .makeStringAndClear() );
+
+    return sRelId;
+}
+
+void DrawingML::WriteMediaNonVisualProperties(const css::uno::Reference<css::drawing::XShape>& xShape)
+{
+    SdrMediaObj* pMediaObj = dynamic_cast<SdrMediaObj*>(GetSdrObjectFromXShape(xShape));
+    if (!pMediaObj)
+        return;
+
+    // extension
+    OUString aExtension;
+    const OUString& rURL(pMediaObj->getURL());
+    int nLastDot = rURL.lastIndexOf('.');
+    if (nLastDot >= 0)
+        aExtension = rURL.copy(nLastDot);
+
+    bool bEmbed = rURL.startsWith("vnd.sun.star.Package:");
+    Relationship eMediaType = Relationship::VIDEO;
+
+    // mime type
+#if HAVE_FEATURE_AVMEDIA
+    OUString aMimeType(pMediaObj->getMediaProperties().getMimeType());
+#else
+    OUString aMimeType("none");
+#endif
+    if (aMimeType == "application/vnd.sun.star.media")
+    {
+        // try to set something better
+        // TODO fix the importer to actually set the mimetype on import
+        if (aExtension.equalsIgnoreAsciiCase(".avi"))
+            aMimeType = "video/x-msvideo";
+        else if (aExtension.equalsIgnoreAsciiCase(".flv"))
+            aMimeType = "video/x-flv";
+        else if (aExtension.equalsIgnoreAsciiCase(".mp4"))
+            aMimeType = "video/mp4";
+        else if (aExtension.equalsIgnoreAsciiCase(".mov"))
+            aMimeType = "video/quicktime";
+        else if (aExtension.equalsIgnoreAsciiCase(".ogv"))
+            aMimeType = "video/ogg";
+        else if (aExtension.equalsIgnoreAsciiCase(".wmv"))
+            aMimeType = "video/x-ms-wmv";
+        else if (aExtension.equalsIgnoreAsciiCase(".wav"))
+        {
+            aMimeType = "audio/x-wav";
+            eMediaType = Relationship::AUDIO;
+        }
+    }
+
+    OUString aVideoFileRelId;
+    OUString aMediaRelId;
+
+    if (bEmbed)
+    {
+        // copy the video stream
+        Reference<XOutputStream> xOutStream = mpFB->openFragmentStream(OUStringBuffer()
+                                                                       .appendAscii(GetComponentDir())
+                                                                       .append("/media/media")
+                                                                       .append(static_cast<sal_Int32>(mnImageCounter))
+                                                                       .append(aExtension)
+                                                                       .makeStringAndClear(),
+                                                                       aMimeType);
+
+        uno::Reference<io::XInputStream> xInputStream(pMediaObj->GetInputStream());
+        comphelper::OStorageHelper::CopyInputToOutput(xInputStream, xOutStream);
+
+        xOutStream->closeOutput();
+
+        // create the relation
+        OUString aPath = OUStringBuffer().appendAscii(GetRelationCompPrefix())
+                                         .append("media/media")
+                                         .append(static_cast<sal_Int32>(mnImageCounter++))
+                                         .append(aExtension)
+                                         .makeStringAndClear();
+        aVideoFileRelId = mpFB->addRelation(mpFS->getOutputStream(), oox::getRelationship(eMediaType), aPath);
+        aMediaRelId = mpFB->addRelation(mpFS->getOutputStream(), oox::getRelationship(Relationship::MEDIA), aPath);
+    }
+    else
+    {
+        aVideoFileRelId = mpFB->addRelation(mpFS->getOutputStream(), oox::getRelationship(eMediaType), rURL);
+        aMediaRelId = mpFB->addRelation(mpFS->getOutputStream(), oox::getRelationship(Relationship::MEDIA), rURL);
+    }
+
+    GetFS()->startElementNS(XML_p, XML_nvPr);
+
+    GetFS()->singleElementNS(XML_a, eMediaType == Relationship::VIDEO ? XML_videoFile : XML_audioFile,
+                    FSNS(XML_r, XML_link), aVideoFileRelId.toUtf8());
+
+    GetFS()->startElementNS(XML_p, XML_extLst);
+    // media extensions; google this ID for details
+    GetFS()->startElementNS(XML_p, XML_ext, XML_uri, "{DAA4B4D4-6D71-4841-9C94-3DE7FCFB9230}");
+
+    GetFS()->singleElementNS(XML_p14, XML_media,
+            bEmbed? FSNS(XML_r, XML_embed): FSNS(XML_r, XML_link), aMediaRelId.toUtf8());
+
+    GetFS()->endElementNS(XML_p, XML_ext);
+    GetFS()->endElementNS(XML_p, XML_extLst);
+
+    GetFS()->endElementNS(XML_p, XML_nvPr);
+}
+
+void DrawingML::WriteImageBrightnessContrastTransparence(uno::Reference<beans::XPropertySet> const & rXPropSet)
+{
+    sal_Int16 nBright = 0;
+    sal_Int32 nContrast = 0;
+    sal_Int32 nTransparence = 0;
+
+    if (GetProperty(rXPropSet, "AdjustLuminance"))
+        nBright = mAny.get<sal_Int16>();
+    if (GetProperty(rXPropSet, "AdjustContrast"))
+        nContrast = mAny.get<sal_Int32>();
+    // Used for shapes with picture fill
+    if (GetProperty(rXPropSet, "FillTransparence"))
+        nTransparence = mAny.get<sal_Int32>();
+    // Used for pictures
+    if (nTransparence == 0 && GetProperty(rXPropSet, "Transparency"))
+        nTransparence = static_cast<sal_Int32>(mAny.get<sal_Int16>());
+
+    if (GetProperty(rXPropSet, "GraphicColorMode"))
+    {
+        drawing::ColorMode aColorMode;
+        mAny >>= aColorMode;
+        if (aColorMode == drawing::ColorMode_GREYS)
+            mpFS->singleElementNS(XML_a, XML_grayscl);
+        else if (aColorMode == drawing::ColorMode_MONO)
+            //black/white has a 0,5 threshold in LibreOffice
+            mpFS->singleElementNS(XML_a, XML_biLevel, XML_thresh, OString::number(50000));
+        else if (aColorMode == drawing::ColorMode_WATERMARK)
+        {
+            //map watermark with mso washout
+            nBright = 70;
+            nContrast = -70;
+        }
+    }
+
+
+    if (nBright || nContrast)
+    {
+        mpFS->singleElementNS(XML_a, XML_lum,
+                   XML_bright, nBright ? OString::number(nBright * 1000).getStr() : nullptr,
+                   XML_contrast, nContrast ? OString::number(nContrast * 1000).getStr() : nullptr);
+    }
+
+    if (nTransparence)
+    {
+        sal_Int32 nAlphaMod = (100 - nTransparence ) * PER_PERCENT;
+        mpFS->singleElementNS(XML_a, XML_alphaModFix, XML_amt, OString::number(nAlphaMod));
+    }
+}
+
+OUString DrawingML::WriteXGraphicBlip(uno::Reference<beans::XPropertySet> const & rXPropSet,
+                                      uno::Reference<graphic::XGraphic> const & rxGraphic,
+                                      bool bRelPathToMedia)
+{
+    OUString sRelId;
+
+    if (!rxGraphic.is())
+        return sRelId;
+
+    Graphic aGraphic(rxGraphic);
+    if (mpTextExport)
+    {
+        BitmapChecksum nChecksum = aGraphic.GetChecksum();
+        sRelId = mpTextExport->FindRelId(nChecksum);
+    }
+    if (sRelId.isEmpty())
+    {
+        sRelId = WriteImage(aGraphic, bRelPathToMedia);
+        if (mpTextExport)
+        {
+            BitmapChecksum nChecksum = aGraphic.GetChecksum();
+            mpTextExport->CacheRelId(nChecksum, sRelId);
+        }
+    }
+
+    mpFS->startElementNS(XML_a, XML_blip, FSNS(XML_r, XML_embed), sRelId.toUtf8());
+
+    WriteImageBrightnessContrastTransparence(rXPropSet);
+
+    WriteArtisticEffect(rXPropSet);
+
+    mpFS->endElementNS(XML_a, XML_blip);
+
+    return sRelId;
+}
+
+void DrawingML::WriteXGraphicBlipMode(uno::Reference<beans::XPropertySet> const & rXPropSet,
+                                      uno::Reference<graphic::XGraphic> const & rxGraphic)
+{
+    BitmapMode eBitmapMode(BitmapMode_NO_REPEAT);
+    if (GetProperty(rXPropSet, "FillBitmapMode"))
+        mAny >>= eBitmapMode;
+
+    SAL_INFO("oox.shape", "fill bitmap mode: " << int(eBitmapMode));
+
+    switch (eBitmapMode)
+    {
+    case BitmapMode_REPEAT:
+        mpFS->singleElementNS(XML_a, XML_tile);
+        break;
+    case BitmapMode_STRETCH:
+        WriteXGraphicStretch(rXPropSet, rxGraphic);
+        break;
+    default:
+        break;
+    }
+}
+
+void DrawingML::WriteBlipOrNormalFill( const Reference< XPropertySet >& xPropSet, const OUString& rURLPropName )
+{
+    // check for blip and otherwise fall back to normal fill
+    // we always store normal fill properties but OOXML
+    // uses a choice between our fill props and BlipFill
+    if (GetProperty ( xPropSet, rURLPropName ))
+        WriteBlipFill( xPropSet, rURLPropName );
+    else
+        WriteFill(xPropSet);
+}
+
+void DrawingML::WriteBlipFill( const Reference< XPropertySet >& rXPropSet, const OUString& sURLPropName )
+{
+    WriteBlipFill( rXPropSet, sURLPropName, XML_a );
+}
+
+void DrawingML::WriteBlipFill( const Reference< XPropertySet >& rXPropSet, const OUString& sURLPropName, sal_Int32 nXmlNamespace )
+{
+    if ( !GetProperty( rXPropSet, sURLPropName ) )
+        return;
+
+    uno::Reference<graphic::XGraphic> xGraphic;
+    if (mAny.has<uno::Reference<awt::XBitmap>>())
+    {
+        uno::Reference<awt::XBitmap> xBitmap = mAny.get<uno::Reference<awt::XBitmap>>();
+        if (xBitmap.is())
+            xGraphic.set(xBitmap, uno::UNO_QUERY);
+    }
+    else if (mAny.has<uno::Reference<graphic::XGraphic>>())
+    {
+        xGraphic = mAny.get<uno::Reference<graphic::XGraphic>>();
+    }
+
+    if (xGraphic.is())
+    {
+        bool bWriteMode = false;
+        if (sURLPropName == "FillBitmap" || sURLPropName == "BackGraphic")
+            bWriteMode = true;
+        WriteXGraphicBlipFill(rXPropSet, xGraphic, nXmlNamespace, bWriteMode);
+    }
+}
+
+void DrawingML::WriteXGraphicBlipFill(uno::Reference<beans::XPropertySet> const & rXPropSet,
+                                      uno::Reference<graphic::XGraphic> const & rxGraphic,
+                                      sal_Int32 nXmlNamespace, bool bWriteMode, bool bRelPathToMedia)
+{
+    if (!rxGraphic.is() )
+        return;
+
+    mpFS->startElementNS(nXmlNamespace , XML_blipFill, XML_rotWithShape, "0");
+
+    WriteXGraphicBlip(rXPropSet, rxGraphic, bRelPathToMedia);
+
+    if (GetDocumentType() != DOCUMENT_DOCX)
+    {
+        // Write the crop rectangle of Impress as a source rectangle.
+        WriteSrcRectXGraphic(rXPropSet, rxGraphic);
+    }
+
+    if (bWriteMode)
+    {
+        WriteXGraphicBlipMode(rXPropSet, rxGraphic);
+    }
+    else if(GetProperty(rXPropSet, "FillBitmapStretch"))
+    {
+            bool bStretch = mAny.get<bool>();
+
+            if (bStretch)
+            {
+                WriteXGraphicStretch(rXPropSet, rxGraphic);
+            }
+    }
+    mpFS->endElementNS(nXmlNamespace, XML_blipFill);
+}
+
+void DrawingML::WritePattFill( const Reference< XPropertySet >& rXPropSet )
+{
+    if ( GetProperty( rXPropSet, "FillHatch" ) )
+    {
+        drawing::Hatch aHatch;
+        mAny >>= aHatch;
+        WritePattFill(rXPropSet, aHatch);
+    }
+}
+
+void DrawingML::WritePattFill(const Reference<XPropertySet>& rXPropSet, const css::drawing::Hatch& rHatch)
+{
+        mpFS->startElementNS(XML_a, XML_pattFill, XML_prst, GetHatchPattern(rHatch));
+
+        mpFS->startElementNS(XML_a, XML_fgClr);
+        WriteColor(::Color(rHatch.Color));
+        mpFS->endElementNS( XML_a , XML_fgClr );
+
+        ::Color nColor = COL_WHITE;
+        sal_Int32 nAlpha  = 0;
+
+        if ( GetProperty( rXPropSet, "FillBackground" ) )
+        {
+            bool isBackgroundFilled = false;
+            mAny >>= isBackgroundFilled;
+            if( isBackgroundFilled )
+            {
+                nAlpha = MAX_PERCENT;
+
+                if( GetProperty( rXPropSet, "FillColor" ) )
+                {
+                    mAny >>= nColor;
+                }
+            }
+        }
+
+        mpFS->startElementNS(XML_a, XML_bgClr);
+        WriteColor(nColor, nAlpha);
+        mpFS->endElementNS( XML_a , XML_bgClr );
+
+        mpFS->endElementNS( XML_a , XML_pattFill );
+}
+
+void DrawingML::WriteGraphicCropProperties(uno::Reference<beans::XPropertySet> const & rXPropSet, Size const & rOriginalSize, MapMode const & rMapMode)
+{
+    if (!GetProperty(rXPropSet, "GraphicCrop"))
+        return;
+
+    Size aOriginalSize(rOriginalSize);
+
+    // GraphicCrop is in mm100, so in case the original size is in pixels, convert it over.
+    if (rMapMode.GetMapUnit() == MapUnit::MapPixel)
+        aOriginalSize = Application::GetDefaultDevice()->PixelToLogic(aOriginalSize, MapMode(MapUnit::Map100thMM));
+
+    css::text::GraphicCrop aGraphicCropStruct;
+    mAny >>= aGraphicCropStruct;
+
+    if ( (0 != aGraphicCropStruct.Left) || (0 != aGraphicCropStruct.Top) || (0 != aGraphicCropStruct.Right) || (0 != aGraphicCropStruct.Bottom) )
+    {
+        mpFS->singleElementNS( XML_a, XML_srcRect,
+            XML_l, OString::number(rtl::math::round(aGraphicCropStruct.Left * 100000.0 / aOriginalSize.Width())),
+            XML_t, OString::number(rtl::math::round(aGraphicCropStruct.Top * 100000.0 / aOriginalSize.Height())),
+            XML_r, OString::number(rtl::math::round(aGraphicCropStruct.Right * 100000.0 / aOriginalSize.Width())),
+            XML_b, OString::number(rtl::math::round(aGraphicCropStruct.Bottom * 100000.0 / aOriginalSize.Height())) );
+    }
+}
+
+void DrawingML::WriteSrcRectXGraphic(uno::Reference<beans::XPropertySet> const & rxPropertySet,
+                                     uno::Reference<graphic::XGraphic> const & rxGraphic)
+{
+    Graphic aGraphic(rxGraphic);
+    Size aOriginalSize = aGraphic.GetPrefSize();
+    const MapMode& rMapMode = aGraphic.GetPrefMapMode();
+    WriteGraphicCropProperties(rxPropertySet, aOriginalSize, rMapMode);
+}
+
+void DrawingML::WriteXGraphicStretch(uno::Reference<beans::XPropertySet> const & rXPropSet,
+                                     uno::Reference<graphic::XGraphic> const & rxGraphic)
+{
+    if (GetDocumentType() != DOCUMENT_DOCX)
+    {
+        // Limiting the area used for stretching is not supported in Impress.
+        mpFS->singleElementNS(XML_a, XML_stretch);
+        return;
+    }
+
+    mpFS->startElementNS(XML_a, XML_stretch);
+
+    bool bCrop = false;
+    if (GetProperty(rXPropSet, "GraphicCrop"))
+    {
+        css::text::GraphicCrop aGraphicCropStruct;
+        mAny >>= aGraphicCropStruct;
+
+        if ((0 != aGraphicCropStruct.Left)
+         || (0 != aGraphicCropStruct.Top)
+         || (0 != aGraphicCropStruct.Right)
+         || (0 != aGraphicCropStruct.Bottom))
+        {
+            Graphic aGraphic(rxGraphic);
+            Size aOriginalSize(aGraphic.GetPrefSize());
+            mpFS->singleElementNS(XML_a, XML_fillRect,
+                XML_l, OString::number(((aGraphicCropStruct.Left)   * 100000) / aOriginalSize.Width()),
+                XML_t, OString::number(((aGraphicCropStruct.Top)    * 100000) / aOriginalSize.Height()),
+                XML_r, OString::number(((aGraphicCropStruct.Right)  * 100000) / aOriginalSize.Width()),
+                XML_b, OString::number(((aGraphicCropStruct.Bottom) * 100000) / aOriginalSize.Height()));
+            bCrop = true;
+        }
+    }
+
+    if (!bCrop)
+    {
+        mpFS->singleElementNS(XML_a, XML_fillRect);
+    }
+
+    mpFS->endElementNS(XML_a, XML_stretch);
+}
+
+void DrawingML::WriteTransformation(const tools::Rectangle& rRect,
+        sal_Int32 nXmlNamespace, bool bFlipH, bool bFlipV, sal_Int32 nRotation, bool bIsGroupShape)
+{
+
+    mpFS->startElementNS( nXmlNamespace, XML_xfrm,
+                          XML_flipH, bFlipH ? "1" : nullptr,
+                          XML_flipV, bFlipV ? "1" : nullptr,
+                          XML_rot, (nRotation % 21600000) ? OString::number(nRotation).getStr() : nullptr );
+
+    sal_Int32 nLeft = rRect.Left();
+    sal_Int32 nTop = rRect.Top();
+    if (GetDocumentType() == DOCUMENT_DOCX && !m_xParent.is())
+    {
+        nLeft = 0;
+        nTop = 0;
+    }
+
+    mpFS->singleElementNS(XML_a, XML_off,
+        XML_x, OString::number(oox::drawingml::convertHmmToEmu(nLeft)),
+        XML_y, OString::number(oox::drawingml::convertHmmToEmu(nTop)));
+    mpFS->singleElementNS(XML_a, XML_ext,
+        XML_cx, OString::number(oox::drawingml::convertHmmToEmu(rRect.GetWidth())),
+        XML_cy, OString::number(oox::drawingml::convertHmmToEmu(rRect.GetHeight())));
+
+    if (GetDocumentType() != DOCUMENT_DOCX && bIsGroupShape)
+    {
+        mpFS->singleElementNS(XML_a, XML_chOff,
+            XML_x, OString::number(oox::drawingml::convertHmmToEmu(nLeft)),
+            XML_y, OString::number(oox::drawingml::convertHmmToEmu(nTop)));
+        mpFS->singleElementNS(XML_a, XML_chExt,
+            XML_cx, OString::number(oox::drawingml::convertHmmToEmu(rRect.GetWidth())),
+            XML_cy, OString::number(oox::drawingml::convertHmmToEmu(rRect.GetHeight())));
+    }
+
+    mpFS->endElementNS( nXmlNamespace, XML_xfrm );
+}
+
+void DrawingML::WriteShapeTransformation( const Reference< XShape >& rXShape, sal_Int32 nXmlNamespace, bool bFlipH, bool bFlipV, bool bSuppressRotation, bool bSuppressFlipping, bool bFlippedBeforeRotation )
+{
+    SAL_INFO("oox.shape",  "write shape transformation");
+
+    sal_Int32 nRotation=0;
+    awt::Point aPos = rXShape->getPosition();
+    awt::Size aSize = rXShape->getSize();
+
+    bool bFlipHWrite = bFlipH && !bSuppressFlipping;
+    bool bFlipVWrite = bFlipV && !bSuppressFlipping;
+    bFlipH = bFlipH && !bFlippedBeforeRotation;
+    bFlipV = bFlipV && !bFlippedBeforeRotation;
+
+    if (GetDocumentType() == DOCUMENT_DOCX && m_xParent.is())
+    {
+        awt::Point aParentPos = m_xParent->getPosition();
+        aPos.X -= aParentPos.X;
+        aPos.Y -= aParentPos.Y;
+    }
+
+    if ( aSize.Width < 0 )
+        aSize.Width = 1000;
+    if ( aSize.Height < 0 )
+        aSize.Height = 1000;
+    if (!bSuppressRotation)
+    {
+        SdrObject* pShape = GetSdrObjectFromXShape( rXShape );
+        nRotation = pShape ? pShape->GetRotateAngle() : 0;
+        if ( GetDocumentType() != DOCUMENT_DOCX )
+        {
+            int faccos=bFlipV ? -1 : 1;
+            int facsin=bFlipH ? -1 : 1;
+            aPos.X-=(1-faccos*cos(nRotation*F_PI18000))*aSize.Width/2-facsin*sin(nRotation*F_PI18000)*aSize.Height/2;
+            aPos.Y-=(1-faccos*cos(nRotation*F_PI18000))*aSize.Height/2+facsin*sin(nRotation*F_PI18000)*aSize.Width/2;
+        }
+
+        // The RotateAngle property's value is independent from any flipping, and that's exactly what we need here.
+        uno::Reference<beans::XPropertySet> xPropertySet(rXShape, uno::UNO_QUERY);
+        uno::Reference<beans::XPropertySetInfo> xPropertySetInfo = xPropertySet->getPropertySetInfo();
+        if (xPropertySetInfo->hasPropertyByName("RotateAngle"))
+            xPropertySet->getPropertyValue("RotateAngle") >>= nRotation;
+    }
+
+    // OOXML flips shapes before rotating them.
+    if(bFlipH != bFlipV)
+        nRotation = nRotation * -1 + 36000;
+
+    WriteTransformation(tools::Rectangle(Point(aPos.X, aPos.Y), Size(aSize.Width, aSize.Height)), nXmlNamespace,
+            bFlipHWrite, bFlipVWrite, ExportRotateClockwisify(nRotation), IsGroupShape( rXShape ));
+}
+
+void DrawingML::WriteRunProperties( const Reference< XPropertySet >& rRun, bool bIsField, sal_Int32 nElement, bool bCheckDirect,
+                                    bool& rbOverridingCharHeight, sal_Int32& rnCharHeight, sal_Int16 nScriptType )
+{
+    Reference< XPropertySet > rXPropSet = rRun;
+    Reference< XPropertyState > rXPropState( rRun, UNO_QUERY );
+    OUString usLanguage;
+    PropertyState eState;
+    bool bComplex = ( nScriptType ==  css::i18n::ScriptType::COMPLEX );
+    const char* bold = "0";
+    const char* italic = nullptr;
+    const char* underline = nullptr;
+    const char* strikeout = nullptr;
+    const char* cap = nullptr;
+    sal_Int32 nSize = 1800;
+    sal_Int32 nCharEscapement = 0;
+    sal_Int32 nCharKerning = 0;
+
+    if ( nElement == XML_endParaRPr && rbOverridingCharHeight )
+    {
+        nSize = rnCharHeight;
+    }
+    else if (GetProperty(rXPropSet, "CharHeight"))
+    {
+        nSize = static_cast<sal_Int32>(100*(*o3tl::doAccess<float>(mAny)));
+        if ( nElement == XML_rPr )
+        {
+            rbOverridingCharHeight = true;
+            rnCharHeight = nSize;
+        }
+    }
+
+    if (GetProperty(rXPropSet, "CharKerning"))
+        nCharKerning = static_cast<sal_Int32>(*o3tl::doAccess<sal_Int16>(mAny));
+    /**  While setting values in propertymap,
+    *    CharKerning converted using GetTextSpacingPoint
+    *    i.e set @ https://opengrok.libreoffice.org/xref/core/oox/source/drawingml/textcharacterproperties.cxx#129
+    *    therefore to get original value CharKerning need to be convert.
+    *    https://opengrok.libreoffice.org/xref/core/oox/source/drawingml/drawingmltypes.cxx#95
+    **/
+    nCharKerning = ((nCharKerning * 720)-360) / 254;
+
+    if ((bComplex && GetProperty(rXPropSet, "CharWeightComplex"))
+        || GetProperty(rXPropSet, "CharWeight"))
+    {
+        if ( *o3tl::doAccess<float>(mAny) >= awt::FontWeight::SEMIBOLD )
+            bold = "1";
+    }
+
+    if ((bComplex && GetProperty(rXPropSet, "CharPostureComplex"))
+        || GetProperty(rXPropSet, "CharPosture"))
+        switch ( *o3tl::doAccess<awt::FontSlant>(mAny) )
+        {
+            case awt::FontSlant_OBLIQUE :
+            case awt::FontSlant_ITALIC :
+                italic = "1";
+                break;
+            default:
+                break;
+        }
+
+    if ((bCheckDirect && GetPropertyAndState(rXPropSet, rXPropState, "CharUnderline", eState)
+         && eState == beans::PropertyState_DIRECT_VALUE)
+        || GetProperty(rXPropSet, "CharUnderline"))
+    {
+        switch ( *o3tl::doAccess<sal_Int16>(mAny) )
+        {
+            case awt::FontUnderline::SINGLE :
+                underline = "sng";
+                break;
+            case awt::FontUnderline::DOUBLE :
+                underline = "dbl";
+                break;
+            case awt::FontUnderline::DOTTED :
+                underline = "dotted";
+                break;
+            case awt::FontUnderline::DASH :
+                underline = "dash";
+                break;
+            case awt::FontUnderline::LONGDASH :
+                underline = "dashLong";
+                break;
+            case awt::FontUnderline::DASHDOT :
+                underline = "dotDash";
+                break;
+            case awt::FontUnderline::DASHDOTDOT :
+                underline = "dotDotDash";
+                break;
+            case awt::FontUnderline::WAVE :
+                underline = "wavy";
+                break;
+            case awt::FontUnderline::DOUBLEWAVE :
+                underline = "wavyDbl";
+                break;
+            case awt::FontUnderline::BOLD :
+                underline = "heavy";
+                break;
+            case awt::FontUnderline::BOLDDOTTED :
+                underline = "dottedHeavy";
+                break;
+            case awt::FontUnderline::BOLDDASH :
+                underline = "dashHeavy";
+                break;
+            case awt::FontUnderline::BOLDLONGDASH :
+                underline = "dashLongHeavy";
+                break;
+            case awt::FontUnderline::BOLDDASHDOT :
+                underline = "dotDashHeavy";
+                break;
+            case awt::FontUnderline::BOLDDASHDOTDOT :
+                underline = "dotDotDashHeavy";
+                break;
+            case awt::FontUnderline::BOLDWAVE :
+                underline = "wavyHeavy";
+                break;
+        }
+    }
+
+    if ((bCheckDirect && GetPropertyAndState(rXPropSet, rXPropState, "CharStrikeout", eState)
+         && eState == beans::PropertyState_DIRECT_VALUE)
+        || GetProperty(rXPropSet, "CharStrikeout"))
+    {
+        switch ( *o3tl::doAccess<sal_Int16>(mAny) )
+        {
+            case awt::FontStrikeout::NONE :
+               strikeout = "noStrike";
+               break;
+            case awt::FontStrikeout::SINGLE :
+            // LibO supports further values of character
+            // strikeout, OOXML standard (20.1.10.78,
+            // ST_TextStrikeType) however specifies only
+            // 3 - single, double and none. Approximate
+            // the remaining ones by single strike (better
+            // some strike than none at all).
+            // TODO: figure out how to do this better
+            case awt::FontStrikeout::BOLD :
+            case awt::FontStrikeout::SLASH :
+            case awt::FontStrikeout::X :
+               strikeout = "sngStrike";
+               break;
+            case awt::FontStrikeout::DOUBLE :
+               strikeout = "dblStrike";
+               break;
+        }
+    }
+
+    bool bLang = false;
+    switch(nScriptType)
+    {
+        case css::i18n::ScriptType::ASIAN:
+            bLang = GetProperty(rXPropSet, "CharLocaleAsian"); break;
+        case css::i18n::ScriptType::COMPLEX:
+            bLang = GetProperty(rXPropSet, "CharLocaleComplex"); break;
+        default:
+            bLang = GetProperty(rXPropSet, "CharLocale"); break;
+    }
+
+    if (bLang)
+    {
+        css::lang::Locale aLocale;
+        mAny >>= aLocale;
+        LanguageTag aLanguageTag( aLocale);
+        if (!aLanguageTag.isSystemLocale())
+            usLanguage = aLanguageTag.getBcp47MS();
+    }
+
+    if (GetPropertyAndState(rXPropSet, rXPropState, "CharEscapement", eState)
+        && eState == beans::PropertyState_DIRECT_VALUE)
+        mAny >>= nCharEscapement;
+
+    if (nCharEscapement
+        && (GetPropertyAndState(rXPropSet, rXPropState, "CharEscapementHeight", eState)
+            && eState == beans::PropertyState_DIRECT_VALUE))
+    {
+        sal_uInt32 nCharEscapementHeight = 0;
+        mAny >>= nCharEscapementHeight;
+        nSize = (nSize * nCharEscapementHeight) / 100;
+        // MSO uses default ~58% size
+        nSize = (nSize / 0.58);
+    }
+
+    if (GetProperty(rXPropSet, "CharCaseMap"))
+    {
+        switch ( *o3tl::doAccess<sal_Int16>(mAny) )
+        {
+            case CaseMap::UPPERCASE :
+                cap = "all";
+                break;
+            case CaseMap::SMALLCAPS :
+                cap = "small";
+                break;
+        }
+    }
+
+    mpFS->startElementNS( XML_a, nElement,
+                          XML_b, bold,
+                          XML_i, italic,
+                          XML_lang, usLanguage.isEmpty() ? nullptr : usLanguage.toUtf8().getStr(),
+                          XML_sz, OString::number(nSize),
+            // For Condensed character spacing spc value is negative.
+                          XML_spc, nCharKerning ? OString::number(nCharKerning).getStr() : nullptr,
+                          XML_strike, strikeout,
+                          XML_u, underline,
+                          XML_baseline, nCharEscapement == 0 ? nullptr : OString::number(nCharEscapement*1000).getStr(),
+                          XML_cap, cap );
+
+    // mso doesn't like text color to be placed after typeface
+    if ((bCheckDirect && GetPropertyAndState(rXPropSet, rXPropState, "CharColor", eState)
+         && eState == beans::PropertyState_DIRECT_VALUE)
+        || GetProperty(rXPropSet, "CharColor"))
+    {
+        ::Color color( *o3tl::doAccess<sal_uInt32>(mAny) );
+        SAL_INFO("oox.shape", "run color: " << sal_uInt32(color) << " auto: " << sal_uInt32(COL_AUTO));
+
+        // WriteSolidFill() handles MAX_PERCENT as "no transparency".
+        sal_Int32 nTransparency = MAX_PERCENT;
+        if (rXPropSet->getPropertySetInfo()->hasPropertyByName("CharTransparence"))
+        {
+            rXPropSet->getPropertyValue("CharTransparence") >>= nTransparency;
+            // UNO scale is 0..100, OOXML scale is 0..100000; also UNO tracks transparency, OOXML
+            // tracks opacity.
+            nTransparency = MAX_PERCENT - (nTransparency * PER_PERCENT);
+        }
+
+        // tdf#104219 In LibreOffice and MS Office, there are two types of colors:
+        // Automatic and Fixed. OOXML is setting automatic color, by not providing color.
+        if( color != COL_AUTO )
+        {
+            color.SetTransparency(0);
+            // TODO: special handle embossed/engraved
+            WriteSolidFill(color, nTransparency);
+        }
+    }
+
+    // tdf#128096, exporting XML_highlight to docx already works fine,
+    // so make sure this code is only run when exporting to pptx, just in case
+    if (GetDocumentType() == DOCUMENT_PPTX)
+    {
+        if (GetProperty(rXPropSet, "CharBackColor"))
+        {
+            ::Color color(*o3tl::doAccess<sal_uInt32>(mAny));
+            if( color != COL_AUTO )
+            {
+                mpFS->startElementNS(XML_a, XML_highlight);
+                WriteColor( color );
+                mpFS->endElementNS( XML_a, XML_highlight );
+            }
+        }
+    }
+
+    if (underline
+        && ((bCheckDirect
+             && GetPropertyAndState(rXPropSet, rXPropState, "CharUnderlineColor", eState)
+             && eState == beans::PropertyState_DIRECT_VALUE)
+            || GetProperty(rXPropSet, "CharUnderlineColor")))
+    {
+        ::Color color(*o3tl::doAccess<sal_uInt32>(mAny));
+        // if color is automatic, then we shouldn't write information about color but to take color from character
+        if( color != COL_AUTO )
+        {
+            mpFS->startElementNS(XML_a, XML_uFill);
+            WriteSolidFill( color );
+            mpFS->endElementNS( XML_a, XML_uFill );
+        }
+        else
+        {
+            mpFS->singleElementNS(XML_a, XML_uFillTx);
+        }
+    }
+
+    if (GetProperty(rXPropSet, "CharFontName"))
+    {
+        const char* const pitch = nullptr;
+        const char* const charset = nullptr;
+        OUString usTypeface;
+
+        mAny >>= usTypeface;
+        OUString aSubstName( GetSubsFontName( usTypeface, SubsFontFlags::ONLYONE | SubsFontFlags::MS ) );
+        if (!aSubstName.isEmpty())
+            usTypeface = aSubstName;
+
+        mpFS->singleElementNS( XML_a, XML_latin,
+                               XML_typeface, usTypeface.toUtf8(),
+                               XML_pitchFamily, pitch,
+                               XML_charset, charset );
+    }
+
+    if ((bComplex
+         && (GetPropertyAndState(rXPropSet, rXPropState, "CharFontNameComplex", eState)
+             && eState == beans::PropertyState_DIRECT_VALUE))
+        || (!bComplex
+            && (GetPropertyAndState(rXPropSet, rXPropState, "CharFontNameAsian", eState)
+                && eState == beans::PropertyState_DIRECT_VALUE)))
+    {
+        const char* const pitch = nullptr;
+        const char* const charset = nullptr;
+        OUString usTypeface;
+
+        mAny >>= usTypeface;
+        OUString aSubstName( GetSubsFontName( usTypeface, SubsFontFlags::ONLYONE | SubsFontFlags::MS ) );
+        if (!aSubstName.isEmpty())
+            usTypeface = aSubstName;
+
+        mpFS->singleElementNS( XML_a, bComplex ? XML_cs : XML_ea,
+                               XML_typeface, usTypeface.toUtf8(),
+                               XML_pitchFamily, pitch,
+                               XML_charset, charset );
+    }
+
+    if( bIsField )
+    {
+        Reference< XTextField > rXTextField;
+        if (GetProperty(rXPropSet, "TextField"))
+            mAny >>= rXTextField;
+        if( rXTextField.is() )
+            rXPropSet.set( rXTextField, UNO_QUERY );
+    }
+
+    // field properties starts here
+    if (GetProperty(rXPropSet, "URL"))
+    {
+        OUString sURL;
+
+        mAny >>= sURL;
+        if( !sURL.isEmpty() ) {
+            OUString sRelId = mpFB->addRelation( mpFS->getOutputStream(),
+                                  oox::getRelationship(Relationship::HYPERLINK),
+                                  sURL, true );
+
+            mpFS->singleElementNS(XML_a, XML_hlinkClick, FSNS(XML_r, XML_id), sRelId.toUtf8());
+        }
+    }
+
+    mpFS->endElementNS( XML_a, nElement );
+}
+
+OUString DrawingML::GetFieldValue( const css::uno::Reference< css::text::XTextRange >& rRun, bool& bIsURLField )
+{
+    Reference< XPropertySet > rXPropSet( rRun, UNO_QUERY );
+    OUString aFieldType, aFieldValue;
+
+    if (GetProperty(rXPropSet, "TextPortionType"))
+    {
+        aFieldType = *o3tl::doAccess<OUString>(mAny);
+        SAL_INFO("oox.shape", "field type: " << aFieldType);
+    }
+
+    if( aFieldType == "TextField" )
+    {
+        Reference< XTextField > rXTextField;
+        if (GetProperty(rXPropSet, "TextField"))
+            mAny >>= rXTextField;
+        if( rXTextField.is() )
+        {
+            rXPropSet.set( rXTextField, UNO_QUERY );
+            if( rXPropSet.is() )
+            {
+                OUString aFieldKind( rXTextField->getPresentation( true ) );
+                SAL_INFO("oox.shape", "field kind: " << aFieldKind);
+                if( aFieldKind == "Page" )
+                {
+                    aFieldValue = "slidenum";
+                }
+                else if( aFieldKind == "Pages" )
+                {
+                    aFieldValue = "slidecount";
+                }
+                else if( aFieldKind == "PageName" )
+                {
+                    aFieldValue = "slidename";
+                }
+                else if( aFieldKind == "URL" )
+                {
+                    bIsURLField = true;
+                    if (GetProperty(rXPropSet, "Representation"))
+                        mAny >>= aFieldValue;
+
+                }
+                else if(aFieldKind == "Date")
+                {
+                    sal_Int32 nNumFmt = -1;
+                    rXPropSet->getPropertyValue(UNO_TC_PROP_NUMFORMAT) >>= nNumFmt;
+                    switch(static_cast<SvxDateFormat>(nNumFmt))
+                    {
+                        case SvxDateFormat::StdSmall:
+                        case SvxDateFormat::A: aFieldValue = "datetime"; // 13/02/96
+                                              break;
+                        case SvxDateFormat::B: aFieldValue = "datetime1"; // 13/02/1996
+                                              break;
+                        case SvxDateFormat::StdBig:
+                        case SvxDateFormat::D: aFieldValue = "datetime3"; // 13 February 1996
+                                              break;
+                        default: break;
+                    }
+                }
+                else if(aFieldKind == "ExtTime")
+                {
+                    sal_Int32 nNumFmt = -1;
+                    rXPropSet->getPropertyValue(UNO_TC_PROP_NUMFORMAT) >>= nNumFmt;
+                    switch(static_cast<SvxTimeFormat>(nNumFmt))
+                    {
+                        case SvxTimeFormat::Standard:
+                        case SvxTimeFormat::HH24_MM_SS:
+                            aFieldValue = "datetime11"; // 13:49:38
+                            break;
+                        case SvxTimeFormat::HH24_MM:
+                            aFieldValue = "datetime10"; // 13:49
+                            break;
+                        case SvxTimeFormat::HH12_MM:
+                            aFieldValue = "datetime12"; // 01:49 PM
+                            break;
+                        case SvxTimeFormat::HH12_MM_SS:
+                            aFieldValue = "datetime13"; // 01:49:38 PM
+                            break;
+                        default: break;
+                    }
+                }
+                else if(aFieldKind == "ExtFile")
+                {
+                    sal_Int32 nNumFmt = -1;
+                    rXPropSet->getPropertyValue(UNO_TC_PROP_FILE_FORMAT) >>= nNumFmt;
+                    switch(nNumFmt)
+                    {
+                        case 0: aFieldValue = "file"; // Path/File name
+                                break;
+                        case 1: aFieldValue = "file1"; // Path
+                                break;
+                        case 2: aFieldValue = "file2"; // File name without extension
+                                break;
+                        case 3: aFieldValue = "file3"; // File name with extension
+                    }
+                }
+                else if(aFieldKind == "Author")
+                {
+                    aFieldValue = "author";
+                }
+            }
+        }
+    }
+    return aFieldValue;
+}
+
+void DrawingML::WriteRun( const Reference< XTextRange >& rRun,
+                          bool& rbOverridingCharHeight, sal_Int32& rnCharHeight)
+{
+    Reference< XPropertySet > rXPropSet( rRun, UNO_QUERY );
+    sal_Int16 nLevel = -1;
+    if (GetProperty(rXPropSet, "NumberingLevel"))
+        mAny >>= nLevel;
+
+    bool bNumberingIsNumber = true;
+    if (GetProperty(rXPropSet, "NumberingIsNumber"))
+        mAny >>= bNumberingIsNumber;
+
+    bool bIsURLField = false;
+    OUString sFieldValue = GetFieldValue( rRun, bIsURLField );
+    bool bWriteField  = !( sFieldValue.isEmpty() || bIsURLField );
+
+    OUString sText = rRun->getString();
+
+    //if there is no text following the bullet, add a space after the bullet
+    if (nLevel !=-1 && bNumberingIsNumber && sText.isEmpty() )
+         sText=" ";
+
+    if ( bIsURLField )
+        sText = sFieldValue;
+
+    if( sText.isEmpty())
+    {
+        Reference< XPropertySet > xPropSet( rRun, UNO_QUERY );
+
+        try
+        {
+            if( !xPropSet.is() || !( xPropSet->getPropertyValue( "PlaceholderText" ) >>= sText ) )
+                return;
+            if( sText.isEmpty() )
+                return;
+        }
+        catch (const Exception &)
+        {
+            return;
+        }
+    }
+
+    if (sText == "\n")
+    {
+        mpFS->singleElementNS(XML_a, XML_br);
+    }
+    else
+    {
+        if( bWriteField )
+        {
+            OString sUUID(comphelper::xml::generateGUIDString());
+            mpFS->startElementNS( XML_a, XML_fld,
+                                  XML_id, sUUID.getStr(),
+                                  XML_type, sFieldValue.toUtf8() );
+        }
+        else
+        {
+            mpFS->startElementNS(XML_a, XML_r);
+        }
+
+        Reference< XPropertySet > xPropSet( rRun, uno::UNO_QUERY );
+
+        WriteRunProperties( xPropSet, bIsURLField, XML_rPr, true, rbOverridingCharHeight, rnCharHeight, GetScriptType(sText) );
+        mpFS->startElementNS(XML_a, XML_t);
+        mpFS->writeEscaped( sText );
+        mpFS->endElementNS( XML_a, XML_t );
+
+        if( bWriteField )
+            mpFS->endElementNS( XML_a, XML_fld );
+        else
+            mpFS->endElementNS( XML_a, XML_r );
+    }
+}
+
+static OUString GetAutoNumType(SvxNumType nNumberingType, bool bSDot, bool bPBehind, bool bPBoth)
+{
+    OUString sPrefixSuffix;
+
+    if (bPBoth)
+        sPrefixSuffix = "ParenBoth";
+    else if (bPBehind)
+        sPrefixSuffix = "ParenR";
+    else if (bSDot)
+        sPrefixSuffix = "Period";
+
+    switch( nNumberingType )
+    {
+        case SVX_NUM_CHARS_UPPER_LETTER_N :
+        case SVX_NUM_CHARS_UPPER_LETTER :
+            return "alphaUc" + sPrefixSuffix;
+
+        case SVX_NUM_CHARS_LOWER_LETTER_N :
+        case SVX_NUM_CHARS_LOWER_LETTER :
+            return "alphaLc" + sPrefixSuffix;
+
+        case SVX_NUM_ROMAN_UPPER :
+            return "romanUc" + sPrefixSuffix;
+
+        case SVX_NUM_ROMAN_LOWER :
+            return "romanLc" + sPrefixSuffix;
+
+        case SVX_NUM_ARABIC :
+        {
+            if (sPrefixSuffix.isEmpty())
+                return "arabicPlain";
+            else
+                return "arabic" + sPrefixSuffix;
+        }
+        default:
+            break;
+    }
+
+    return OUString();
+}
+
+void DrawingML::WriteParagraphNumbering(const Reference< XPropertySet >& rXPropSet, float fFirstCharHeight, sal_Int16 nLevel )
+{
+    if (nLevel < 0 || !GetProperty(rXPropSet, "NumberingRules"))
+        return;
+
+    Reference< XIndexAccess > rXIndexAccess;
+
+    if (!(mAny >>= rXIndexAccess) || nLevel >= rXIndexAccess->getCount())
+        return;
+
+    SAL_INFO("oox.shape", "numbering rules");
+
+    Sequence<PropertyValue> aPropertySequence;
+    rXIndexAccess->getByIndex(nLevel) >>= aPropertySequence;
+
+    if (!aPropertySequence.hasElements())
+        return;
+
+    SvxNumType nNumberingType = SVX_NUM_NUMBER_NONE;
+    bool bSDot = false;
+    bool bPBehind = false;
+    bool bPBoth = false;
+    sal_Unicode aBulletChar = 0x2022; // a bullet
+    awt::FontDescriptor aFontDesc;
+    bool bHasFontDesc = false;
+    uno::Reference<graphic::XGraphic> xGraphic;
+    sal_Int16 nBulletRelSize = 0;
+    sal_Int16 nStartWith = 1;
+    ::Color nBulletColor;
+    bool bHasBulletColor = false;
+    awt::Size aGraphicSize;
+
+    for ( const PropertyValue& rPropValue : std::as_const(aPropertySequence) )
+    {
+        OUString aPropName( rPropValue.Name );
+        SAL_INFO("oox.shape", "pro name: " << aPropName);
+        if ( aPropName == "NumberingType" )
+        {
+            nNumberingType = static_cast<SvxNumType>(*o3tl::doAccess<sal_Int16>(rPropValue.Value));
+        }
+        else if ( aPropName == "Prefix" )
+        {
+            if( *o3tl::doAccess<OUString>(rPropValue.Value) == ")")
+                bPBoth = true;
+        }
+        else if ( aPropName == "Suffix" )
+        {
+            auto s = o3tl::doAccess<OUString>(rPropValue.Value);
+            if( *s == ".")
+                bSDot = true;
+            else if( *s == ")")
+                bPBehind = true;
+        }
+        else if(aPropName == "BulletColor")
+        {
+            nBulletColor = ::Color(*o3tl::doAccess<sal_uInt32>(rPropValue.Value));
+            bHasBulletColor = true;
+        }
+        else if ( aPropName == "BulletChar" )
+        {
+            aBulletChar = (*o3tl::doAccess<OUString>(rPropValue.Value))[ 0 ];
+        }
+        else if ( aPropName == "BulletFont" )
+        {
+            aFontDesc = *o3tl::doAccess<awt::FontDescriptor>(rPropValue.Value);
+            bHasFontDesc = true;
+
+            // Our numbullet dialog has set the wrong textencoding for our "StarSymbol" font,
+            // instead of a Unicode encoding the encoding RTL_TEXTENCODING_SYMBOL was used.
+            // Because there might exist a lot of damaged documemts I added this two lines
+            // which fixes the bullet problem for the export.
+            if ( aFontDesc.Name.equalsIgnoreAsciiCase("StarSymbol") )
+                aFontDesc.CharSet = RTL_TEXTENCODING_MS_1252;
+
+        }
+        else if ( aPropName == "BulletRelSize" )
+        {
+            nBulletRelSize = *o3tl::doAccess<sal_Int16>(rPropValue.Value);
+        }
+        else if ( aPropName == "StartWith" )
+        {
+            nStartWith = *o3tl::doAccess<sal_Int16>(rPropValue.Value);
+        }
+        else if (aPropName == "GraphicBitmap")
+        {
+            auto xBitmap = rPropValue.Value.get<uno::Reference<awt::XBitmap>>();
+            xGraphic.set(xBitmap, uno::UNO_QUERY);
+        }
+        else if ( aPropName == "GraphicSize" )
+        {
+            aGraphicSize = *o3tl::doAccess<awt::Size>(rPropValue.Value);
+            SAL_INFO("oox.shape", "graphic size: " << aGraphicSize.Width << "x" << aGraphicSize.Height);
+        }
+    }
+
+    if (nNumberingType == SVX_NUM_NUMBER_NONE)
+        return;
+
+    Graphic aGraphic(xGraphic);
+    if (xGraphic.is() && aGraphic.GetType() != GraphicType::NONE)
+    {
+        long nFirstCharHeightMm = TransformMetric(fFirstCharHeight * 100.f, FieldUnit::POINT, FieldUnit::MM);
+        float fBulletSizeRel = aGraphicSize.Height / static_cast<float>(nFirstCharHeightMm) / OOX_BULLET_LIST_SCALE_FACTOR;
+
+        OUString sRelationId;
+
+        if (fBulletSizeRel < 1.0f)
+        {
+            // Add padding to get the bullet point centered in PPT
+            Size aDestSize(64, 64);
+            float fBulletSizeRelX = fBulletSizeRel / aGraphicSize.Height * aGraphicSize.Width;
+            long nPaddingX = std::max<long>(0, std::lround((aDestSize.Width() - fBulletSizeRelX * aDestSize.Width()) / 2.f));
+            long nPaddingY = std::lround((aDestSize.Height() - fBulletSizeRel * aDestSize.Height()) / 2.f);
+            tools::Rectangle aDestRect(nPaddingX, nPaddingY, aDestSize.Width() - nPaddingX, aDestSize.Height() - nPaddingY);
+
+            AlphaMask aMask(aDestSize);
+            aMask.Erase(255);
+            BitmapEx aSourceBitmap(aGraphic.GetBitmapEx());
+            aSourceBitmap.Scale(aDestRect.GetSize());
+            tools::Rectangle aSourceRect(Point(0, 0), aDestRect.GetSize());
+            BitmapEx aDestBitmap(Bitmap(aDestSize, 24), aMask);
+            aDestBitmap.CopyPixel(aDestRect, aSourceRect, &aSourceBitmap);
+            Graphic aDestGraphic(aDestBitmap);
+            sRelationId = WriteImage(aDestGraphic);
+            fBulletSizeRel = 1.0f;
+        }
+        else
+        {
+            sRelationId = WriteImage(aGraphic);
+        }
+
+        mpFS->singleElementNS( XML_a, XML_buSzPct,
+                               XML_val, OString::number(std::min<sal_Int32>(std::lround(100000.f * fBulletSizeRel), 400000)));
+        mpFS->startElementNS(XML_a, XML_buBlip);
+        mpFS->singleElementNS(XML_a, XML_blip, FSNS(XML_r, XML_embed), sRelationId.toUtf8());
+        mpFS->endElementNS( XML_a, XML_buBlip );
+    }
+    else
+    {
+        if(bHasBulletColor)
+        {
+               if (nBulletColor == COL_AUTO )
+               {
+                   nBulletColor = ::Color(mbIsBackgroundDark ? 0xffffff : 0x000000);
+               }
+               mpFS->startElementNS(XML_a, XML_buClr);
+               WriteColor( nBulletColor );
+               mpFS->endElementNS( XML_a, XML_buClr );
+        }
+
+        if( nBulletRelSize && nBulletRelSize != 100 )
+            mpFS->singleElementNS( XML_a, XML_buSzPct,
+                                   XML_val, OString::number(std::clamp<sal_Int32>(1000*nBulletRelSize, 25000, 400000)));
+        if( bHasFontDesc )
+        {
+            if ( SVX_NUM_CHAR_SPECIAL == nNumberingType )
+                aBulletChar = SubstituteBullet( aBulletChar, aFontDesc );
+            mpFS->singleElementNS( XML_a, XML_buFont,
+                                   XML_typeface, aFontDesc.Name.toUtf8(),
+                                   XML_charset, (aFontDesc.CharSet == awt::CharSet::SYMBOL) ? "2" : nullptr );
+        }
+
+        OUString aAutoNumType = GetAutoNumType( nNumberingType, bSDot, bPBehind, bPBoth );
+
+        if (!aAutoNumType.isEmpty())
+        {
+            mpFS->singleElementNS(XML_a, XML_buAutoNum,
+                                  XML_type, aAutoNumType.toUtf8(),
+                                  XML_startAt, nStartWith > 1 ? OString::number(nStartWith).getStr() : nullptr);
+        }
+        else
+        {
+            mpFS->singleElementNS(XML_a, XML_buChar, XML_char, OUString(aBulletChar).toUtf8());
+        }
+    }
+}
+
+void DrawingML::WriteParagraphTabStops(const Reference<XPropertySet>& rXPropSet)
+{
+    css::uno::Sequence<css::style::TabStop> aTabStops;
+    if (GetProperty(rXPropSet, "ParaTabStops"))
+        aTabStops = *o3tl::doAccess<css::uno::Sequence<css::style::TabStop>>(mAny);
+
+    if (aTabStops.getLength() > 0)
+        mpFS->startElementNS(XML_a, XML_tabLst);
+
+    for (const css::style::TabStop& rTabStop : std::as_const(aTabStops))
+    {
+        OString sPosition = OString::number(GetPointFromCoordinate(rTabStop.Position));
+        OString sAlignment;
+        switch (rTabStop.Alignment)
+        {
+            case css::style::TabAlign_DECIMAL:
+                sAlignment = "dec";
+                break;
+            case css::style::TabAlign_RIGHT:
+                sAlignment = "r";
+                break;
+            case css::style::TabAlign_CENTER:
+                sAlignment = "ctr";
+                break;
+            case css::style::TabAlign_LEFT:
+            default:
+                sAlignment = "l";
+        }
+        mpFS->singleElementNS(XML_a, XML_tab, XML_algn, sAlignment, XML_pos, sPosition);
+    }
+    if (aTabStops.getLength() > 0)
+        mpFS->endElementNS(XML_a, XML_tabLst);
+}
+
+bool DrawingML::IsGroupShape( const Reference< XShape >& rXShape )
+{
+    bool bRet = false;
+    if ( rXShape.is() )
+    {
+        uno::Reference<lang::XServiceInfo> xServiceInfo(rXShape, uno::UNO_QUERY_THROW);
+        bRet = xServiceInfo->supportsService("com.sun.star.drawing.GroupShape");
+    }
+    return bRet;
+}
+
+bool DrawingML::IsDiagram(const Reference<XShape>& rXShape)
+{
+    uno::Reference<beans::XPropertySet> xPropSet(rXShape, uno::UNO_QUERY);
+    if (!xPropSet.is())
+        return false;
+
+    // if the shape doesn't have the InteropGrabBag property, it's not a diagram
+    uno::Reference<beans::XPropertySetInfo> xPropSetInfo = xPropSet->getPropertySetInfo();
+    OUString aName = UNO_NAME_MISC_OBJ_INTEROPGRABBAG;
+    if (!xPropSetInfo->hasPropertyByName(aName))
+        return false;
+
+    uno::Sequence<beans::PropertyValue> propList;
+    xPropSet->getPropertyValue(aName) >>= propList;
+    return std::any_of(std::cbegin(propList), std::cend(propList),
+        [](const beans::PropertyValue& rProp) {
+            // if we find any of the diagram components, it's a diagram
+            OUString propName = rProp.Name;
+            return propName == "OOXData" || propName == "OOXLayout" || propName == "OOXStyle"
+                || propName == "OOXColor" || propName == "OOXDrawing";
+        });
+}
+
+sal_Int32 DrawingML::getBulletMarginIndentation (const Reference< XPropertySet >& rXPropSet,sal_Int16 nLevel, const OUString& propName)
+{
+    if (nLevel < 0 || !GetProperty(rXPropSet, "NumberingRules"))
+        return 0;
+
+    Reference< XIndexAccess > rXIndexAccess;
+
+    if (!(mAny >>= rXIndexAccess) || nLevel >= rXIndexAccess->getCount())
+        return 0;
+
+    SAL_INFO("oox.shape", "numbering rules");
+
+    Sequence<PropertyValue> aPropertySequence;
+    rXIndexAccess->getByIndex(nLevel) >>= aPropertySequence;
+
+    if (!aPropertySequence.hasElements())
+        return 0;
+
+    for ( const PropertyValue& rPropValue : std::as_const(aPropertySequence) )
+    {
+        OUString aPropName( rPropValue.Name );
+        SAL_INFO("oox.shape", "pro name: " << aPropName);
+        if ( aPropName == propName )
+            return *o3tl::doAccess<sal_Int32>(rPropValue.Value);
+    }
+
+    return 0;
+}
+
+const char* DrawingML::GetAlignment( style::ParagraphAdjust nAlignment )
+{
+    const char* sAlignment = nullptr;
+
+    switch( nAlignment )
+    {
+        case style::ParagraphAdjust_CENTER:
+            sAlignment = "ctr";
+            break;
+        case style::ParagraphAdjust_RIGHT:
+            sAlignment = "r";
+            break;
+        case style::ParagraphAdjust_BLOCK:
+            sAlignment = "just";
+            break;
+        default:
+            ;
+    }
+
+    return sAlignment;
+}
+
+void DrawingML::WriteLinespacing( const LineSpacing& rSpacing )
+{
+    if( rSpacing.Mode == LineSpacingMode::PROP )
+    {
+        mpFS->singleElementNS( XML_a, XML_spcPct,
+                               XML_val, OString::number(static_cast<sal_Int32>(rSpacing.Height)*1000));
+    }
+    else
+    {
+        mpFS->singleElementNS( XML_a, XML_spcPts,
+                               XML_val, OString::number(std::lround(rSpacing.Height / 25.4 * 72)));
+    }
+}
+
+void DrawingML::WriteParagraphProperties( const Reference< XTextContent >& rParagraph, float fFirstCharHeight)
+{
+    Reference< XPropertySet > rXPropSet( rParagraph, UNO_QUERY );
+    Reference< XPropertyState > rXPropState( rParagraph, UNO_QUERY );
+    PropertyState eState;
+
+    if( !rXPropSet.is() || !rXPropState.is() )
+        return;
+
+    sal_Int16 nLevel = -1;
+    if (GetProperty(rXPropSet, "NumberingLevel"))
+        mAny >>= nLevel;
+
+    sal_Int16 nTmp = sal_Int16(style::ParagraphAdjust_LEFT);
+    if (GetProperty(rXPropSet, "ParaAdjust"))
+        mAny >>= nTmp;
+    style::ParagraphAdjust nAlignment = static_cast<style::ParagraphAdjust>(nTmp);
+
+    bool bHasLinespacing = false;
+    LineSpacing aLineSpacing;
+    if (GetPropertyAndState(rXPropSet, rXPropState, "ParaLineSpacing", eState)
+        && eState == beans::PropertyState_DIRECT_VALUE)
+        bHasLinespacing = ( mAny >>= aLineSpacing );
+
+    bool bRtl = false;
+    if (GetProperty(rXPropSet, "WritingMode"))
+    {
+        sal_Int16 nWritingMode;
+        if( ( mAny >>= nWritingMode ) && nWritingMode == text::WritingMode2::RL_TB )
+        {
+            bRtl = true;
+        }
+    }
+
+    sal_Int32 nParaLeftMargin = 0;
+    sal_Int32 nParaFirstLineIndent = 0;
+
+    if (GetProperty(rXPropSet, "ParaLeftMargin"))
+        mAny >>= nParaLeftMargin;
+    if (GetProperty(rXPropSet, "ParaFirstLineIndent"))
+        mAny >>= nParaFirstLineIndent;
+
+    sal_Int32 nParaTopMargin = 0;
+    sal_Int32 nParaBottomMargin = 0;
+
+    if (GetProperty(rXPropSet, "ParaTopMargin"))
+        mAny >>= nParaTopMargin;
+    if (GetProperty(rXPropSet, "ParaBottomMargin"))
+        mAny >>= nParaBottomMargin;
+
+    sal_Int32 nLeftMargin =  getBulletMarginIndentation ( rXPropSet, nLevel,"LeftMargin");
+    sal_Int32 nLineIndentation = getBulletMarginIndentation ( rXPropSet, nLevel,"FirstLineOffset");
+
+    if( !(nLevel != -1
+        || nAlignment != style::ParagraphAdjust_LEFT
+        || bHasLinespacing) )
+        return;
+
+    if (nParaLeftMargin) // For Paragraph
+        mpFS->startElementNS( XML_a, XML_pPr,
+                           XML_lvl, nLevel > 0 ? OString::number(nLevel).getStr() : nullptr,
+                           XML_marL, nParaLeftMargin > 0 ? OString::number(oox::drawingml::convertHmmToEmu(nParaLeftMargin)).getStr() : nullptr,
+                           XML_indent, nParaFirstLineIndent ? OString::number(oox::drawingml::convertHmmToEmu(nParaFirstLineIndent)).getStr() : nullptr,
+                           XML_algn, GetAlignment( nAlignment ),
+                           XML_rtl, bRtl ? ToPsz10(bRtl) : nullptr );
+    else
+        mpFS->startElementNS( XML_a, XML_pPr,
+                           XML_lvl, nLevel > 0 ? OString::number(nLevel).getStr() : nullptr,
+                           XML_marL, nLeftMargin > 0 ? OString::number(oox::drawingml::convertHmmToEmu(nLeftMargin)).getStr() : nullptr,
+                           XML_indent, nLineIndentation ? OString::number(oox::drawingml::convertHmmToEmu(nLineIndentation)).getStr() : nullptr,
+                           XML_algn, GetAlignment( nAlignment ),
+                           XML_rtl, bRtl ? ToPsz10(bRtl) : nullptr );
+
+
+    if( bHasLinespacing )
+    {
+        mpFS->startElementNS(XML_a, XML_lnSpc);
+        WriteLinespacing( aLineSpacing );
+        mpFS->endElementNS( XML_a, XML_lnSpc );
+    }
+
+    if( nParaTopMargin != 0 )
+    {
+        mpFS->startElementNS(XML_a, XML_spcBef);
+        {
+            mpFS->singleElementNS( XML_a, XML_spcPts,
+                                   XML_val, OString::number(std::lround(nParaTopMargin / 25.4 * 72)));
+        }
+        mpFS->endElementNS( XML_a, XML_spcBef );
+    }
+
+    if( nParaBottomMargin != 0 )
+    {
+        mpFS->startElementNS(XML_a, XML_spcAft);
+        {
+            mpFS->singleElementNS( XML_a, XML_spcPts,
+                                   XML_val, OString::number(std::lround(nParaBottomMargin / 25.4 * 72)));
+        }
+        mpFS->endElementNS( XML_a, XML_spcAft );
+    }
+
+    WriteParagraphNumbering( rXPropSet, fFirstCharHeight, nLevel );
+
+    WriteParagraphTabStops( rXPropSet );
+
+    mpFS->endElementNS( XML_a, XML_pPr );
+}
+
+void DrawingML::WriteParagraph( const Reference< XTextContent >& rParagraph,
+                                bool& rbOverridingCharHeight, sal_Int32& rnCharHeight )
+{
+    Reference< XEnumerationAccess > access( rParagraph, UNO_QUERY );
+    if( !access.is() )
+        return;
+
+    Reference< XEnumeration > enumeration( access->createEnumeration() );
+    if( !enumeration.is() )
+        return;
+
+    mpFS->startElementNS(XML_a, XML_p);
+
+    bool bPropertiesWritten = false;
+    while( enumeration->hasMoreElements() )
+    {
+        Reference< XTextRange > run;
+        Any any ( enumeration->nextElement() );
+
+        if (any >>= run)
+        {
+            if( !bPropertiesWritten )
+            {
+                float fFirstCharHeight = rnCharHeight / 1000.;
+                Reference< XPropertySet > xFirstRunPropSet (run, UNO_QUERY);
+                Reference< XPropertySetInfo > xFirstRunPropSetInfo = xFirstRunPropSet->getPropertySetInfo();
+                if( xFirstRunPropSetInfo->hasPropertyByName("CharHeight") )
+                    fFirstCharHeight = xFirstRunPropSet->getPropertyValue("CharHeight").get<float>();
+                WriteParagraphProperties( rParagraph, fFirstCharHeight );
+                bPropertiesWritten = true;
+            }
+            WriteRun( run, rbOverridingCharHeight, rnCharHeight );
+        }
+    }
+    Reference< XPropertySet > rXPropSet( rParagraph, UNO_QUERY );
+    WriteRunProperties( rXPropSet, false, XML_endParaRPr, false, rbOverridingCharHeight, rnCharHeight );
+
+    mpFS->endElementNS( XML_a, XML_p );
+}
+
+void DrawingML::WriteText( const Reference< XInterface >& rXIface, const OUString& presetWarp, bool bBodyPr, bool bText, sal_Int32 nXmlNamespace )
+{
+    Reference< XText > xXText( rXIface, UNO_QUERY );
+    Reference< XPropertySet > rXPropSet( rXIface, UNO_QUERY );
+
+    if( !xXText.is() )
+        return;
+
+    sal_Int32 nTextPreRotateAngle = 0;
+    double nTextRotateAngle = 0;
+    bool bIsFontworkShape(presetWarp.startsWith("text") && (presetWarp != "textNoShape"));
+
+#define DEFLRINS 254
+#define DEFTBINS 127
+    sal_Int32 nLeft, nRight, nTop, nBottom;
+    nLeft = nRight = DEFLRINS;
+    nTop = nBottom = DEFTBINS;
+
+    // top inset looks a bit different compared to ppt export
+    // check if something related doesn't work as expected
+    if (GetProperty(rXPropSet, "TextLeftDistance"))
+        mAny >>= nLeft;
+    if (GetProperty(rXPropSet, "TextRightDistance"))
+        mAny >>= nRight;
+    if (GetProperty(rXPropSet, "TextUpperDistance"))
+        mAny >>= nTop;
+    if (GetProperty(rXPropSet, "TextLowerDistance"))
+        mAny >>= nBottom;
+
+    TextVerticalAdjust eVerticalAlignment( TextVerticalAdjust_TOP );
+    const char* sVerticalAlignment = nullptr;
+    if (GetProperty(rXPropSet, "TextVerticalAdjust"))
+        mAny >>= eVerticalAlignment;
+    if( eVerticalAlignment != TextVerticalAdjust_TOP )
+        sVerticalAlignment = GetTextVerticalAdjust(eVerticalAlignment);
+
+    const char* sWritingMode = nullptr;
+    bool bVertical = false;
+    if (GetProperty(rXPropSet, "TextWritingMode"))
+    {
+        WritingMode eMode;
+
+        if( ( mAny >>= eMode ) && eMode == WritingMode_TB_RL )
+        {
+            sWritingMode = "eaVert";
+            bVertical = true;
+        }
+    }
+
+    Sequence<drawing::EnhancedCustomShapeAdjustmentValue> aAdjustmentSeq;
+    uno::Sequence<beans::PropertyValue> aTextPathSeq;
+    bool bScaleX(false);
+
+    if (GetProperty(rXPropSet, "CustomShapeGeometry"))
+    {
+        Sequence< PropertyValue > aProps;
+        if ( mAny >>= aProps )
+        {
+            for ( const auto& rProp : std::as_const(aProps) )
+            {
+                if ( rProp.Name == "TextPreRotateAngle" && ( rProp.Value >>= nTextPreRotateAngle ) )
+                {
+                    if ( nTextPreRotateAngle == -90 )
+                    {
+                        sWritingMode = "vert";
+                        bVertical = true;
+                    }
+                    else if ( nTextPreRotateAngle == -270 )
+                    {
+                        sWritingMode = "vert270";
+                        bVertical = true;
+                    }
+                    if (!bIsFontworkShape)
+                        break;
+                }
+                else if (rProp.Name == "AdjustmentValues")
+                    rProp.Value >>= aAdjustmentSeq;
+                else if( rProp.Name == "TextRotateAngle" )
+                    rProp.Value >>= nTextRotateAngle;
+                else if (rProp.Name == "TextPath")
+                {
+                    rProp.Value >>= aTextPathSeq;
+                    for (const auto& rTextPath : std::as_const(aTextPathSeq))
+                    {
+                        if (rTextPath.Name == "ScaleX")
+                            rTextPath.Value >>= bScaleX;
+                    }
+                }
+            }
+        }
+    }
+
+    bool bFromWordArt = !bScaleX
+                        && ( presetWarp == "textArchDown" || presetWarp == "textArchUp"
+                            || presetWarp == "textButton" || presetWarp == "textCircle");
+
+    TextHorizontalAdjust eHorizontalAlignment( TextHorizontalAdjust_CENTER );
+    bool bHorizontalCenter = false;
+    if (GetProperty(rXPropSet, "TextHorizontalAdjust"))
+        mAny >>= eHorizontalAlignment;
+    if( eHorizontalAlignment == TextHorizontalAdjust_CENTER )
+        bHorizontalCenter = true;
+    else if( bVertical && eHorizontalAlignment == TextHorizontalAdjust_LEFT )
+        sVerticalAlignment = "b";
+
+    bool bHasWrap = false;
+    bool bWrap = false;
+    // Only custom shapes obey the TextWordWrap option, normal text always wraps.
+    if (dynamic_cast<SvxCustomShape*>(rXIface.get()) && GetProperty(rXPropSet, "TextWordWrap"))
+    {
+        mAny >>= bWrap;
+        bHasWrap = true;
+    }
+
+    if (bBodyPr)
+    {
+        const char* pWrap = bHasWrap && !bWrap ? "none" : nullptr;
+        if (GetDocumentType() == DOCUMENT_DOCX)
+        {
+            // In case of DOCX, if we want to have the same effect as
+            // TextShape's automatic word wrapping, then we need to set
+            // wrapping to square.
+            uno::Reference<lang::XServiceInfo> xServiceInfo(rXIface, uno::UNO_QUERY);
+            if (xServiceInfo.is() && xServiceInfo->supportsService("com.sun.star.drawing.TextShape"))
+                pWrap = "square";
+        }
+        mpFS->startElementNS( (nXmlNamespace ? nXmlNamespace : XML_a), XML_bodyPr,
+                               XML_wrap, pWrap,
+                               XML_fromWordArt, bFromWordArt ? "1" : nullptr,
+                               XML_lIns, (nLeft != DEFLRINS) ? OString::number(oox::drawingml::convertHmmToEmu(nLeft)).getStr() : nullptr,
+                               XML_rIns, (nRight != DEFLRINS) ? OString::number(oox::drawingml::convertHmmToEmu(nRight)).getStr() : nullptr,
+                               XML_tIns, (nTop != DEFTBINS) ? OString::number(oox::drawingml::convertHmmToEmu(nTop)).getStr() : nullptr,
+                               XML_bIns, (nBottom != DEFTBINS) ? OString::number(oox::drawingml::convertHmmToEmu(nBottom)).getStr() : nullptr,
+                               XML_anchor, sVerticalAlignment,
+                               XML_anchorCtr, bHorizontalCenter ? "1" : nullptr,
+                               XML_vert, sWritingMode,
+                               XML_rot, ((nTextPreRotateAngle + nTextRotateAngle) != 0) ? oox::drawingml::calcRotationValue( (nTextPreRotateAngle + nTextRotateAngle) * 100 ).getStr() : nullptr );
+        if (bIsFontworkShape)
+        {
+            if (aAdjustmentSeq.hasElements())
+            {
+                mpFS->startElementNS(XML_a, XML_prstTxWarp, XML_prst, presetWarp.toUtf8());
+                mpFS->startElementNS(XML_a, XML_avLst);
+                for (sal_Int32 i = 0, nElems = aAdjustmentSeq.getLength(); i < nElems; ++i )
+                {
+                    OString sName = "adj" + (( nElems > 1 ) ? OString::number(i + 1) : OString());
+                    double fValue(0.0);
+                    if (aAdjustmentSeq[i].Value.getValueTypeClass() == TypeClass_DOUBLE)
+                        aAdjustmentSeq[i].Value >>= fValue;
+                    else
+                    {
+                        sal_Int32 nNumber(0);
+                        aAdjustmentSeq[i].Value >>= nNumber;
+                        fValue = static_cast<double>(nNumber);
+                    }
+                    // Convert from binary coordinate system with viewBox "0 0 21600 21600" and simple degree
+                    // to DrawingML with coordinate range 0..100000 and angle in 1/60000 degree.
+                    // Reverse to conversion in lcl_createPresetShape in drawingml/shape.cxx on import.
+                    if (presetWarp == "textArchDown" || presetWarp == "textArchUp"
+                        || presetWarp == "textButton" || presetWarp == "textCircle"
+                        || ((i == 0) && (presetWarp == "textArchDownPour" || presetWarp == "textArchUpPour"
+                        || presetWarp == "textButtonPour" || presetWarp == "textCirclePour")))
+                    {
+                        fValue *= 60000.0;
+                    }
+                    else if ((i == 1) && (presetWarp == "textDoubleWave1" || presetWarp == "textWave1"
+                            || presetWarp == "textWave2" || presetWarp == "textWave4"))
+                    {
+                        fValue = fValue / 0.216 - 50000.0;
+                    }
+                    else if ((i == 1) && (presetWarp == "textArchDownPour" || presetWarp == "textArchUpPour"
+                        || presetWarp == "textButtonPour" || presetWarp == "textCirclePour"))
+                    {
+                        fValue /= 0.108;
+                    }
+                    else
+                    {
+                        fValue /= 0.216;
+                    }
+                    OString sFmla = "val " + OString::number(std::lround(fValue));
+                    mpFS->singleElementNS(XML_a, XML_gd, XML_name, sName, XML_fmla, sFmla);
+                }
+                mpFS->endElementNS( XML_a, XML_avLst );
+                mpFS->endElementNS(XML_a, XML_prstTxWarp);
+            }
+            else
+            {
+                mpFS->singleElementNS(XML_a, XML_prstTxWarp, XML_prst, presetWarp.toUtf8());
+            }
+        }
+
+        if (GetDocumentType() == DOCUMENT_DOCX || GetDocumentType() == DOCUMENT_XLSX)
+        {
+            // tdf#112312: only custom shapes obey the TextAutoGrowHeight option
+            bool bTextAutoGrowHeight = false;
+            uno::Reference<drawing::XShape> xShape(rXIface, uno::UNO_QUERY);
+            auto pSdrObjCustomShape = xShape.is() ? dynamic_cast<SdrObjCustomShape*>(GetSdrObjectFromXShape(xShape)) : nullptr;
+            if (pSdrObjCustomShape && GetProperty(rXPropSet, "TextAutoGrowHeight"))
+            {
+                mAny >>= bTextAutoGrowHeight;
+            }
+            mpFS->singleElementNS(XML_a, (bTextAutoGrowHeight ? XML_spAutoFit : XML_noAutofit));
+        }
+        if (GetDocumentType() == DOCUMENT_PPTX)
+        {
+            TextFitToSizeType eFit = TextFitToSizeType_NONE;
+            if (GetProperty(rXPropSet, "TextFitToSize"))
+                mAny >>= eFit;
+
+            if (eFit == TextFitToSizeType_AUTOFIT)
+            {
+                const sal_Int32 MAX_SCALE_VAL = 100000;
+                sal_Int32 nFontScale = MAX_SCALE_VAL;
+                SvxShapeText* pTextShape = dynamic_cast<SvxShapeText*>(rXIface.get());
+                if (pTextShape)
+                {
+                    SdrTextObj* pTextObject = dynamic_cast<SdrTextObj*>(pTextShape->GetSdrObject());
+                    if (pTextObject)
+                    {
+                        double fScaleY = pTextObject->GetFontScaleY();
+                        nFontScale = static_cast<sal_uInt32>(fScaleY * 100) * 1000;
+                    }
+                }
+
+                mpFS->singleElementNS(XML_a, XML_normAutofit, XML_fontScale,
+                    ( nFontScale < MAX_SCALE_VAL && nFontScale > 0 ) ? OString::number(nFontScale).getStr() : nullptr);
+            }
+            else
+            {
+                // tdf#127030: Only custom shapes obey the TextAutoGrowHeight option.
+                bool bTextAutoGrowHeight = false;
+                if (dynamic_cast<SvxCustomShape*>(rXIface.get()) && GetProperty(rXPropSet, "TextAutoGrowHeight"))
+                    mAny >>= bTextAutoGrowHeight;
+                mpFS->singleElementNS(XML_a, (bTextAutoGrowHeight ? XML_spAutoFit : XML_noAutofit));
+            }
+        }
+
+        WriteShape3DEffects( rXPropSet );
+
+        mpFS->endElementNS((nXmlNamespace ? nXmlNamespace : XML_a), XML_bodyPr);
+    }
+
+    Reference< XEnumerationAccess > access( xXText, UNO_QUERY );
+    if( !access.is() || !bText )
+        return;
+
+    Reference< XEnumeration > enumeration( access->createEnumeration() );
+    if( !enumeration.is() )
+        return;
+
+    uno::Reference<drawing::XShape> xShape(rXIface, uno::UNO_QUERY);
+    SdrObject* pSdrObject = xShape.is() ? GetSdrObjectFromXShape(xShape) : nullptr;
+    const SdrTextObj* pTxtObj = dynamic_cast<SdrTextObj*>( pSdrObject );
+    if (pTxtObj && mpTextExport)
+    {
+        const OutlinerParaObject* pParaObj = nullptr;
+        bool bOwnParaObj = false;
+
+        /*
+        #i13885#
+        When the object is actively being edited, that text is not set into
+        the objects normal text object, but lives in a separate object.
+        */
+        if (pTxtObj->IsTextEditActive())
+        {
+            pParaObj = pTxtObj->CreateEditOutlinerParaObject().release();
+            bOwnParaObj = true;
+        }
+        else
+            pParaObj = pTxtObj->GetOutlinerParaObject();
+
+        if (pParaObj)
+        {
+            // this is reached only in case some text is attached to the shape
+            mpTextExport->WriteOutliner(*pParaObj);
+            if (bOwnParaObj)
+                delete pParaObj;
+        }
+        return;
+    }
+
+    bool bOverridingCharHeight = false;
+    sal_Int32 nCharHeight = -1;
+
+    while( enumeration->hasMoreElements() )
+    {
+        Reference< XTextContent > paragraph;
+        Any any ( enumeration->nextElement() );
+
+        if( any >>= paragraph)
+            WriteParagraph( paragraph, bOverridingCharHeight, nCharHeight );
+    }
+}
+
+void DrawingML::WritePresetShape( const char* pShape , std::vector< std::pair<sal_Int32,sal_Int32>> & rAvList )
+{
+    mpFS->startElementNS(XML_a, XML_prstGeom, XML_prst, pShape);
+    if ( !rAvList.empty() )
+    {
+
+        mpFS->startElementNS(XML_a, XML_avLst);
+        for (auto const& elem : rAvList)
+        {
+            OString sName = "adj" + ( ( elem.first > 0 ) ? OString::number(elem.first) : OString() );
+            OString sFmla = "val " + OString::number( elem.second );
+
+            mpFS->singleElementNS(XML_a, XML_gd, XML_name, sName, XML_fmla, sFmla);
+        }
+        mpFS->endElementNS( XML_a, XML_avLst );
+    }
+    else
+        mpFS->singleElementNS(XML_a, XML_avLst);
+
+    mpFS->endElementNS(  XML_a, XML_prstGeom );
+}
+
+void DrawingML::WritePresetShape( const char* pShape )
+{
+    mpFS->startElementNS(XML_a, XML_prstGeom, XML_prst, pShape);
+    mpFS->singleElementNS(XML_a, XML_avLst);
+    mpFS->endElementNS(  XML_a, XML_prstGeom );
+}
+
+static std::map< OString, std::vector<OString> > lcl_getAdjNames()
+{
+    std::map< OString, std::vector<OString> > aRet;
+
+    OUString aPath("$BRAND_BASE_DIR/" LIBO_SHARE_FOLDER "/filter/oox-drawingml-adj-names");
+    rtl::Bootstrap::expandMacros(aPath);
+    SvFileStream aStream(aPath, StreamMode::READ);
+    if (aStream.GetError() != ERRCODE_NONE)
+        SAL_WARN("oox.shape", "failed to open oox-drawingml-adj-names");
+    OString aLine;
+    bool bNotDone = aStream.ReadLine(aLine);
+    while (bNotDone)
+    {
+        sal_Int32 nIndex = 0;
+        // Each line is in a "key\tvalue" format: read the key, the rest is the value.
+        OString aKey = aLine.getToken(0, '\t', nIndex);
+        OString aValue = aLine.copy(nIndex);
+        aRet[aKey].push_back(aValue);
+        bNotDone = aStream.ReadLine(aLine);
+    }
+    return aRet;
+}
+
+void DrawingML::WritePresetShape( const char* pShape, MSO_SPT eShapeType, bool bPredefinedHandlesUsed, const PropertyValue& rProp )
+{
+    static std::map< OString, std::vector<OString> > aAdjMap = lcl_getAdjNames();
+    // If there are predefined adj names for this shape type, look them up now.
+    std::vector<OString> aAdjustments;
+    if (aAdjMap.find(OString(pShape)) != aAdjMap.end())
+        aAdjustments = aAdjMap[OString(pShape)];
+
+    mpFS->startElementNS(XML_a, XML_prstGeom, XML_prst, pShape);
+    mpFS->startElementNS(XML_a, XML_avLst);
+
+    Sequence< drawing::EnhancedCustomShapeAdjustmentValue > aAdjustmentSeq;
+    if ( ( rProp.Value >>= aAdjustmentSeq )
+         && eShapeType != mso_sptActionButtonForwardNext  // we have adjustments values for these type of shape, but MSO doesn't like them
+         && eShapeType != mso_sptActionButtonBackPrevious // so they are now disabled
+         && OString(pShape) != "rect" //some shape types are commented out in pCustomShapeTypeTranslationTable[] & are being defaulted to rect & rect does not have adjustment values/name.
+        )
+    {
+        SAL_INFO("oox.shape", "adj seq len: " << aAdjustmentSeq.getLength());
+        sal_Int32 nAdjustmentsWhichNeedsToBeConverted = 0;
+        if ( bPredefinedHandlesUsed )
+            EscherPropertyContainer::LookForPolarHandles( eShapeType, nAdjustmentsWhichNeedsToBeConverted );
+
+        sal_Int32 nValue, nLength = aAdjustmentSeq.getLength();
+        // aAdjustments will give info about the number of adj values for a particular geometry. For example for hexagon aAdjustments.size() will be 2 and for circular arrow it will be 5 as per lcl_getAdjNames.
+        // Sometimes there are more values than needed, so we ignore the excessive ones.
+        if (aAdjustments.size() <= o3tl::make_unsigned(nLength))
+        {
+            for (sal_Int32 i = 0; i < static_cast<sal_Int32>(aAdjustments.size()); i++)
+            {
+                if( EscherPropertyContainer::GetAdjustmentValue( aAdjustmentSeq[ i ], i, nAdjustmentsWhichNeedsToBeConverted, nValue ) )
+                {
+                    // If the document model doesn't have an adjustment name (e.g. shape was created from VML), then take it from the predefined list.
+                    OString aAdjName = aAdjustmentSeq[i].Name.isEmpty()
+                                           ? aAdjustments[i]
+                                           : aAdjustmentSeq[i].Name.toUtf8();
+
+                    mpFS->singleElementNS( XML_a, XML_gd,
+                                       XML_name, aAdjName,
+                                       XML_fmla, "val " + OString::number(nValue));
+                }
+            }
+        }
+    }
+
+    mpFS->endElementNS( XML_a, XML_avLst );
+    mpFS->endElementNS(  XML_a, XML_prstGeom );
+}
+
+bool DrawingML::WriteCustomGeometry(
+    const Reference< XShape >& rXShape,
+    const SdrObjCustomShape& rSdrObjCustomShape)
+{
+    uno::Reference< beans::XPropertySet > aXPropSet;
+    uno::Any aAny( rXShape->queryInterface(cppu::UnoType<beans::XPropertySet>::get()));
+
+    if ( ! (aAny >>= aXPropSet) )
+        return false;
+
+    try
+    {
+        aAny = aXPropSet->getPropertyValue( "CustomShapeGeometry" );
+        if ( !aAny.hasValue() )
+            return false;
+    }
+    catch( const ::uno::Exception& )
+    {
+        return false;
+    }
+
+
+    auto pGeometrySeq = o3tl::tryAccess<uno::Sequence<beans::PropertyValue>>(aAny);
+
+    if ( pGeometrySeq )
+    {
+        for( const beans::PropertyValue& rProp : *pGeometrySeq )
+        {
+            if ( rProp.Name == "Path" )
+            {
+                uno::Sequence<beans::PropertyValue> aPathProp;
+                rProp.Value >>= aPathProp;
+
+                uno::Sequence<drawing::EnhancedCustomShapeParameterPair> aPairs;
+                uno::Sequence<drawing::EnhancedCustomShapeSegment> aSegments;
+                uno::Sequence<awt::Size> aPathSize;
+                for (const beans::PropertyValue& rPathProp : std::as_const(aPathProp))
+                {
+                    if (rPathProp.Name == "Coordinates")
+                        rPathProp.Value >>= aPairs;
+                    else if (rPathProp.Name == "Segments")
+                        rPathProp.Value >>= aSegments;
+                    else if (rPathProp.Name == "SubViewSize")
+                        rPathProp.Value >>= aPathSize;
+                }
+
+                if ( !aPairs.hasElements() )
+                    return false;
+
+                if ( !aSegments.hasElements() )
+                {
+                    aSegments = uno::Sequence<drawing::EnhancedCustomShapeSegment>(4);
+                    aSegments[0].Count = 1;
+                    aSegments[0].Command = drawing::EnhancedCustomShapeSegmentCommand::MOVETO;
+                    aSegments[1].Count = static_cast<sal_Int16>(std::min( aPairs.getLength() - 1, sal_Int32(32767) ));
+                    aSegments[1].Command = drawing::EnhancedCustomShapeSegmentCommand::LINETO;
+                    aSegments[2].Count = 0;
+                    aSegments[2].Command = drawing::EnhancedCustomShapeSegmentCommand::CLOSESUBPATH;
+                    aSegments[3].Count = 0;
+                    aSegments[3].Command = drawing::EnhancedCustomShapeSegmentCommand::ENDSUBPATH;
+                }
+
+                int nExpectedPairCount = std::accumulate(std::cbegin(aSegments), std::cend(aSegments), 0,
+                    [](const int nSum, const drawing::EnhancedCustomShapeSegment& rSegment) { return nSum + rSegment.Count; });
+
+                if ( nExpectedPairCount > aPairs.getLength() )
+                {
+                    SAL_WARN("oox.shape", "Segments need " << nExpectedPairCount << " coordinates, but Coordinates have only " << aPairs.getLength() << " pairs.");
+                    return false;
+                }
+
+                mpFS->startElementNS(XML_a, XML_custGeom);
+                mpFS->singleElementNS(XML_a, XML_avLst);
+                mpFS->singleElementNS(XML_a, XML_gdLst);
+                mpFS->singleElementNS(XML_a, XML_ahLst);
+                mpFS->singleElementNS(XML_a, XML_rect, XML_l, "l", XML_t, "t",
+                                      XML_r, "r", XML_b, "b");
+                mpFS->startElementNS(XML_a, XML_pathLst);
+
+                if ( aPathSize.hasElements() )
+                {
+                    mpFS->startElementNS( XML_a, XML_path,
+                          XML_w, OString::number(aPathSize[0].Width),
+                          XML_h, OString::number(aPathSize[0].Height) );
+                }
+                else
+                {
+                    sal_Int32 nXMin(0);
+                    aPairs[0].First.Value >>= nXMin;
+                    sal_Int32 nXMax = nXMin;
+                    sal_Int32 nYMin(0);
+                    aPairs[0].Second.Value >>= nYMin;
+                    sal_Int32 nYMax = nYMin;
+
+                    for ( const auto& rPair : std::as_const(aPairs) )
+                    {
+                        sal_Int32 nX = GetCustomGeometryPointValue(rPair.First, rSdrObjCustomShape);
+                        sal_Int32 nY = GetCustomGeometryPointValue(rPair.Second, rSdrObjCustomShape);
+                        if (nX < nXMin)
+                            nXMin = nX;
+                        if (nY < nYMin)
+                            nYMin = nY;
+                        if (nX > nXMax)
+                            nXMax = nX;
+                        if (nY > nYMax)
+                            nYMax = nY;
+                    }
+                    mpFS->startElementNS( XML_a, XML_path,
+                          XML_w, OString::number(nXMax - nXMin),
+                          XML_h, OString::number(nYMax - nYMin) );
+                }
+
+
+                int nPairIndex = 0;
+                bool bOK = true;
+                for (const auto& rSegment : std::as_const(aSegments))
+                {
+                    if ( rSegment.Command == drawing::EnhancedCustomShapeSegmentCommand::CLOSESUBPATH )
+                    {
+                        mpFS->singleElementNS(XML_a, XML_close);
+                    }
+                    for (int k = 0; k < rSegment.Count && bOK; ++k)
+                    {
+                        switch( rSegment.Command )
+                        {
+                            case drawing::EnhancedCustomShapeSegmentCommand::MOVETO :
+                            {
+                                if (nPairIndex >= aPairs.getLength())
+                                    bOK = false;
+                                else
+                                {
+                                    mpFS->startElementNS(XML_a, XML_moveTo);
+                                    WriteCustomGeometryPoint(aPairs[nPairIndex], rSdrObjCustomShape);
+                                    mpFS->endElementNS( XML_a, XML_moveTo );
+                                    nPairIndex++;
+                                }
+                                break;
+                            }
+                            case drawing::EnhancedCustomShapeSegmentCommand::LINETO :
+                            {
+                                if (nPairIndex >= aPairs.getLength())
+                                    bOK = false;
+                                else
+                                {
+                                    mpFS->startElementNS(XML_a, XML_lnTo);
+                                    WriteCustomGeometryPoint(aPairs[nPairIndex], rSdrObjCustomShape);
+                                    mpFS->endElementNS( XML_a, XML_lnTo );
+                                    nPairIndex++;
+                                }
+                                break;
+                            }
+                            case drawing::EnhancedCustomShapeSegmentCommand::CURVETO :
+                            {
+                                if (nPairIndex + 2 >= aPairs.getLength())
+                                    bOK = false;
+                                else
+                                {
+                                    mpFS->startElementNS(XML_a, XML_cubicBezTo);
+                                    for( sal_uInt8 l = 0; l <= 2; ++l )
+                                    {
+                                        WriteCustomGeometryPoint(aPairs[nPairIndex+l], rSdrObjCustomShape);
+                                    }
+                                    mpFS->endElementNS( XML_a, XML_cubicBezTo );
+                                    nPairIndex += 3;
+                                }
+                                break;
+                            }
+                            case drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSETO :
+                            case drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSE :
+                            {
+                                nPairIndex += 3;
+                                break;
+                            }
+                            case drawing::EnhancedCustomShapeSegmentCommand::ARCTO :
+                            case drawing::EnhancedCustomShapeSegmentCommand::ARC :
+                            case drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARCTO :
+                            case drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARC :
+                            {
+                                nPairIndex += 4;
+                                break;
+                            }
+                            case drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTX :
+                            case drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTY :
+                            {
+                                nPairIndex++;
+                                break;
+                            }
+                            case drawing::EnhancedCustomShapeSegmentCommand::QUADRATICCURVETO :
+                            {
+                                if (nPairIndex + 1 >= aPairs.getLength())
+                                    bOK = false;
+                                else
+                                {
+                                    mpFS->startElementNS(XML_a, XML_quadBezTo);
+                                    for( sal_uInt8 l = 0; l < 2; ++l )
+                                    {
+                                        WriteCustomGeometryPoint(aPairs[nPairIndex+l], rSdrObjCustomShape);
+                                    }
+                                    mpFS->endElementNS( XML_a, XML_quadBezTo );
+                                    nPairIndex += 2;
+                                }
+                                break;
+                            }
+                            case drawing::EnhancedCustomShapeSegmentCommand::ARCANGLETO :
+                            {
+                                nPairIndex += 2;
+                                break;
+                            }
+                            default:
+                                // do nothing
+                                break;
+                        }
+                    }
+                    if (!bOK)
+                        break;
+                }
+                mpFS->endElementNS( XML_a, XML_path );
+                mpFS->endElementNS( XML_a, XML_pathLst );
+                mpFS->endElementNS( XML_a, XML_custGeom );
+                return bOK;
+            }
+        }
+    }
+    return false;
+}
+
+void DrawingML::WriteCustomGeometryPoint(
+    const drawing::EnhancedCustomShapeParameterPair& rParamPair,
+    const SdrObjCustomShape& rSdrObjCustomShape)
+{
+    sal_Int32 nX = GetCustomGeometryPointValue(rParamPair.First, rSdrObjCustomShape);
+    sal_Int32 nY = GetCustomGeometryPointValue(rParamPair.Second, rSdrObjCustomShape);
+
+    mpFS->singleElementNS(XML_a, XML_pt, XML_x, OString::number(nX), XML_y, OString::number(nY));
+}
+
+sal_Int32 DrawingML::GetCustomGeometryPointValue(
+    const css::drawing::EnhancedCustomShapeParameter& rParam,
+    const SdrObjCustomShape& rSdrObjCustomShape)
+{
+    const EnhancedCustomShape2d aCustoShape2d(const_cast< SdrObjCustomShape& >(rSdrObjCustomShape));
+    double fValue = 0.0;
+    aCustoShape2d.GetParameter(fValue, rParam, false, false);
+    sal_Int32 nValue(std::lround(fValue));
+
+    return nValue;
+}
+
+void DrawingML::WritePolyPolygon( const tools::PolyPolygon& rPolyPolygon, const bool bClosed )
+{
+    // In case of Writer, the parent element is <wps:spPr>, and there the
+    // <a:custGeom> element is not optional.
+    if (rPolyPolygon.Count() < 1 && GetDocumentType() != DOCUMENT_DOCX)
+        return;
+
+    mpFS->startElementNS(XML_a, XML_custGeom);
+    mpFS->singleElementNS(XML_a, XML_avLst);
+    mpFS->singleElementNS(XML_a, XML_gdLst);
+    mpFS->singleElementNS(XML_a, XML_ahLst);
+    mpFS->singleElementNS(XML_a, XML_rect, XML_l, "0", XML_t, "0", XML_r, "r", XML_b, "b");
+
+    mpFS->startElementNS( XML_a, XML_pathLst );
+
+    const tools::Rectangle aRect( rPolyPolygon.GetBoundRect() );
+
+    // Put all polygons of rPolyPolygon in the same path element
+    // to subtract the overlapped areas.
+    mpFS->startElementNS( XML_a, XML_path,
+            XML_w, OString::number(aRect.GetWidth()),
+            XML_h, OString::number(aRect.GetHeight()) );
+
+    for( sal_uInt16 i = 0; i < rPolyPolygon.Count(); i ++ )
+    {
+
+        const tools::Polygon& rPoly = rPolyPolygon[ i ];
+
+        if( rPoly.GetSize() > 0 )
+        {
+            mpFS->startElementNS(XML_a, XML_moveTo);
+
+            mpFS->singleElementNS( XML_a, XML_pt,
+                                   XML_x, OString::number(rPoly[0].X() - aRect.Left()),
+                                   XML_y, OString::number(rPoly[0].Y() - aRect.Top()) );
+
+            mpFS->endElementNS( XML_a, XML_moveTo );
+        }
+
+        for( sal_uInt16 j = 1; j < rPoly.GetSize(); j ++ )
+        {
+            PolyFlags flags = rPoly.GetFlags(j);
+            if( flags == PolyFlags::Control )
+            {
+                // a:cubicBezTo can only contain 3 a:pt elements, so we need to make sure of this
+                if( j+2 < rPoly.GetSize() && rPoly.GetFlags(j+1) == PolyFlags::Control && rPoly.GetFlags(j+2) != PolyFlags::Control )
+                {
+
+                    mpFS->startElementNS(XML_a, XML_cubicBezTo);
+                    for( sal_uInt8 k = 0; k <= 2; ++k )
+                    {
+                        mpFS->singleElementNS(XML_a, XML_pt,
+                                              XML_x, OString::number(rPoly[j+k].X() - aRect.Left()),
+                                              XML_y, OString::number(rPoly[j+k].Y() - aRect.Top()));
+
+                    }
+                    mpFS->endElementNS( XML_a, XML_cubicBezTo );
+                    j += 2;
+                }
+            }
+            else if( flags == PolyFlags::Normal )
+            {
+                mpFS->startElementNS(XML_a, XML_lnTo);
+                mpFS->singleElementNS( XML_a, XML_pt,
+                                       XML_x, OString::number(rPoly[j].X() - aRect.Left()),
+                                       XML_y, OString::number(rPoly[j].Y() - aRect.Top()) );
+                mpFS->endElementNS( XML_a, XML_lnTo );
+            }
+        }
+    }
+    if (bClosed)
+        mpFS->singleElementNS( XML_a, XML_close);
+    mpFS->endElementNS( XML_a, XML_path );
+
+    mpFS->endElementNS( XML_a, XML_pathLst );
+
+    mpFS->endElementNS( XML_a, XML_custGeom );
+}
+
+void DrawingML::WriteConnectorConnections( EscherConnectorListEntry& rConnectorEntry, sal_Int32 nStartID, sal_Int32 nEndID )
+{
+    if( nStartID != -1 )
+    {
+        mpFS->singleElementNS( XML_a, XML_stCxn,
+                               XML_id, OString::number(nStartID),
+                               XML_idx, OString::number(rConnectorEntry.GetConnectorRule(true)) );
+    }
+    if( nEndID != -1 )
+    {
+        mpFS->singleElementNS( XML_a, XML_endCxn,
+                               XML_id, OString::number(nEndID),
+                               XML_idx, OString::number(rConnectorEntry.GetConnectorRule(false)) );
+    }
+}
+
+sal_Unicode DrawingML::SubstituteBullet( sal_Unicode cBulletId, css::awt::FontDescriptor& rFontDesc )
+{
+    if ( IsStarSymbol(rFontDesc.Name) )
+    {
+        rtl_TextEncoding eCharSet = rFontDesc.CharSet;
+        cBulletId = msfilter::util::bestFitOpenSymbolToMSFont(cBulletId, eCharSet, rFontDesc.Name);
+        rFontDesc.CharSet = eCharSet;
+    }
+
+    return cBulletId;
+}
+
+sax_fastparser::FSHelperPtr DrawingML::CreateOutputStream (
+    const OUString& sFullStream,
+    const OUString& sRelativeStream,
+    const Reference< XOutputStream >& xParentRelation,
+    const char* sContentType,
+    const char* sRelationshipType,
+    OUString* pRelationshipId )
+{
+    OUString sRelationshipId;
+    if (xParentRelation.is())
+        sRelationshipId = GetFB()->addRelation( xParentRelation, OUString::createFromAscii( sRelationshipType), sRelativeStream );
+    else
+        sRelationshipId = GetFB()->addRelation( OUString::createFromAscii( sRelationshipType ), sRelativeStream );
+
+    if( pRelationshipId )
+        *pRelationshipId = sRelationshipId;
+
+    sax_fastparser::FSHelperPtr p = GetFB()->openFragmentStreamWithSerializer( sFullStream, OUString::createFromAscii( sContentType ) );
+
+    return p;
+}
+
+void DrawingML::WriteFill( const Reference< XPropertySet >& xPropSet )
+{
+    if ( !GetProperty( xPropSet, "FillStyle" ) )
+        return;
+    FillStyle aFillStyle( FillStyle_NONE );
+    xPropSet->getPropertyValue( "FillStyle" ) >>= aFillStyle;
+
+    // map full transparent background to no fill
+    if ( aFillStyle == FillStyle_SOLID && GetProperty( xPropSet, "FillTransparence" ) )
+    {
+        sal_Int16 nVal = 0;
+        xPropSet->getPropertyValue( "FillTransparence" ) >>= nVal;
+        if ( nVal == 100 )
+            aFillStyle = FillStyle_NONE;
+    }
+    if (aFillStyle == FillStyle_SOLID && GetProperty( xPropSet, "FillTransparenceGradient"))
+    {
+        awt::Gradient aTransparenceGradient;
+        mAny >>= aTransparenceGradient;
+        if (aTransparenceGradient.StartColor == 0xffffff && aTransparenceGradient.EndColor == 0xffffff)
+            aFillStyle = FillStyle_NONE;
+    }
+
+    switch( aFillStyle )
+    {
+    case FillStyle_SOLID :
+        WriteSolidFill( xPropSet );
+        break;
+    case FillStyle_GRADIENT :
+        WriteGradientFill( xPropSet );
+        break;
+    case FillStyle_BITMAP :
+        WriteBlipFill( xPropSet, "FillBitmap" );
+        break;
+    case FillStyle_HATCH :
+        WritePattFill( xPropSet );
+        break;
+    case FillStyle_NONE:
+        mpFS->singleElementNS(XML_a, XML_noFill);
+        break;
+    default:
+        ;
+    }
+}
+
+void DrawingML::WriteStyleProperties( sal_Int32 nTokenId, const Sequence< PropertyValue >& aProperties )
+{
+    if( aProperties.hasElements() )
+    {
+        OUString sSchemeClr;
+        sal_uInt32 nIdx = 0;
+        Sequence< PropertyValue > aTransformations;
+        for( const auto& rProp : aProperties)
+        {
+            if( rProp.Name == "SchemeClr" )
+                rProp.Value >>= sSchemeClr;
+            else if( rProp.Name == "Idx" )
+                rProp.Value >>= nIdx;
+            else if( rProp.Name == "Transformations" )
+                rProp.Value >>= aTransformations;
+        }
+        mpFS->startElementNS(XML_a, nTokenId, XML_idx, OString::number(nIdx));
+        WriteColor(sSchemeClr, aTransformations);
+        mpFS->endElementNS( XML_a, nTokenId );
+    }
+    else
+    {
+        // write mock <a:*Ref> tag
+        mpFS->singleElementNS(XML_a, nTokenId, XML_idx, OString::number(0));
+    }
+}
+
+void DrawingML::WriteShapeStyle( const Reference< XPropertySet >& xPropSet )
+{
+    // check existence of the grab bag
+    if ( !GetProperty( xPropSet, "InteropGrabBag" ) )
+        return;
+
+    // extract the relevant properties from the grab bag
+    Sequence< PropertyValue > aGrabBag;
+    Sequence< PropertyValue > aFillRefProperties, aLnRefProperties, aEffectRefProperties;
+    mAny >>= aGrabBag;
+    for( const auto& rProp : std::as_const(aGrabBag))
+    {
+        if( rProp.Name == "StyleFillRef" )
+            rProp.Value >>= aFillRefProperties;
+        else if( rProp.Name == "StyleLnRef" )
+            rProp.Value >>= aLnRefProperties;
+        else if( rProp.Name == "StyleEffectRef" )
+            rProp.Value >>= aEffectRefProperties;
+    }
+
+    WriteStyleProperties( XML_lnRef, aLnRefProperties );
+    WriteStyleProperties( XML_fillRef, aFillRefProperties );
+    WriteStyleProperties( XML_effectRef, aEffectRefProperties );
+
+    // write mock <a:fontRef>
+    mpFS->singleElementNS(XML_a, XML_fontRef, XML_idx, "minor");
+}
+
+void DrawingML::WriteShapeEffect( const OUString& sName, const Sequence< PropertyValue >& aEffectProps )
+{
+    if( !aEffectProps.hasElements() )
+        return;
+
+    // assign the proper tag and enable bContainsColor if necessary
+    sal_Int32 nEffectToken = 0;
+    bool bContainsColor = false;
+    if( sName == "outerShdw" )
+    {
+        nEffectToken = FSNS( XML_a, XML_outerShdw );
+        bContainsColor = true;
+    }
+    else if( sName == "innerShdw" )
+    {
+        nEffectToken = FSNS( XML_a, XML_innerShdw );
+        bContainsColor = true;
+    }
+    else if( sName == "glow" )
+    {
+        nEffectToken = FSNS( XML_a, XML_glow );
+        bContainsColor = true;
+    }
+    else if( sName == "softEdge" )
+        nEffectToken = FSNS( XML_a, XML_softEdge );
+    else if( sName == "reflection" )
+        nEffectToken = FSNS( XML_a, XML_reflection );
+    else if( sName == "blur" )
+        nEffectToken = FSNS( XML_a, XML_blur );
+
+    OUString sSchemeClr;
+    ::Color nRgbClr;
+    sal_Int32 nAlpha = MAX_PERCENT;
+    Sequence< PropertyValue > aTransformations;
+    sax_fastparser::FastAttributeList *aOuterShdwAttrList = FastSerializerHelper::createAttrList();
+    sax_fastparser::XFastAttributeListRef xOuterShdwAttrList( aOuterShdwAttrList );
+    for( const auto& rEffectProp : aEffectProps )
+    {
+        if( rEffectProp.Name == "Attribs" )
+        {
+            // read tag attributes
+            uno::Sequence< beans::PropertyValue > aOuterShdwProps;
+            rEffectProp.Value >>= aOuterShdwProps;
+            for( const auto& rOuterShdwProp : std::as_const(aOuterShdwProps) )
+            {
+                if( rOuterShdwProp.Name == "algn" )
+                {
+                    OUString sVal;
+                    rOuterShdwProp.Value >>= sVal;
+                    aOuterShdwAttrList->add( XML_algn, OUStringToOString( sVal, RTL_TEXTENCODING_UTF8 ).getStr() );
+                }
+                else if( rOuterShdwProp.Name == "blurRad" )
+                {
+                    sal_Int32 nVal = 0;
+                    rOuterShdwProp.Value >>= nVal;
+                    aOuterShdwAttrList->add( XML_blurRad, OString::number( nVal ).getStr() );
+                }
+                else if( rOuterShdwProp.Name == "dir" )
+                {
+                    sal_Int32 nVal = 0;
+                    rOuterShdwProp.Value >>= nVal;
+                    aOuterShdwAttrList->add( XML_dir, OString::number( nVal ).getStr() );
+                }
+                else if( rOuterShdwProp.Name == "dist" )
+                {
+                    sal_Int32 nVal = 0;
+                    rOuterShdwProp.Value >>= nVal;
+                    aOuterShdwAttrList->add( XML_dist, OString::number( nVal ).getStr() );
+                }
+                else if( rOuterShdwProp.Name == "kx" )
+                {
+                    sal_Int32 nVal = 0;
+                    rOuterShdwProp.Value >>= nVal;
+                    aOuterShdwAttrList->add( XML_kx, OString::number( nVal ).getStr() );
+                }
+                else if( rOuterShdwProp.Name == "ky" )
+                {
+                    sal_Int32 nVal = 0;
+                    rOuterShdwProp.Value >>= nVal;
+                    aOuterShdwAttrList->add( XML_ky, OString::number( nVal ).getStr() );
+                }
+                else if( rOuterShdwProp.Name == "rotWithShape" )
+                {
+                    sal_Int32 nVal = 0;
+                    rOuterShdwProp.Value >>= nVal;
+                    aOuterShdwAttrList->add( XML_rotWithShape, OString::number( nVal ).getStr() );
+                }
+                else if( rOuterShdwProp.Name == "sx" )
+                {
+                    sal_Int32 nVal = 0;
+                    rOuterShdwProp.Value >>= nVal;
+                    aOuterShdwAttrList->add( XML_sx, OString::number( nVal ).getStr() );
+                }
+                else if( rOuterShdwProp.Name == "sy" )
+                {
+                    sal_Int32 nVal = 0;
+                    rOuterShdwProp.Value >>= nVal;
+                    aOuterShdwAttrList->add( XML_sy, OString::number( nVal ).getStr() );
+                }
+                else if( rOuterShdwProp.Name == "rad" )
+                {
+                    sal_Int64 nVal = 0;
+                    rOuterShdwProp.Value >>= nVal;
+                    aOuterShdwAttrList->add( XML_rad, OString::number( nVal ).getStr() );
+                }
+                else if( rOuterShdwProp.Name == "endA" )
+                {
+                    sal_Int32 nVal = 0;
+                    rOuterShdwProp.Value >>= nVal;
+                    aOuterShdwAttrList->add( XML_endA, OString::number( nVal ).getStr() );
+                }
+                else if( rOuterShdwProp.Name == "endPos" )
+                {
+                    sal_Int32 nVal = 0;
+                    rOuterShdwProp.Value >>= nVal;
+                    aOuterShdwAttrList->add( XML_endPos, OString::number( nVal ).getStr() );
+                }
+                else if( rOuterShdwProp.Name == "fadeDir" )
+                {
+                    sal_Int32 nVal = 0;
+                    rOuterShdwProp.Value >>= nVal;
+                    aOuterShdwAttrList->add( XML_fadeDir, OString::number( nVal ).getStr() );
+                }
+                else if( rOuterShdwProp.Name == "stA" )
+                {
+                    sal_Int32 nVal = 0;
+                    rOuterShdwProp.Value >>= nVal;
+                    aOuterShdwAttrList->add( XML_stA, OString::number( nVal ).getStr() );
+                }
+                else if( rOuterShdwProp.Name == "stPos" )
+                {
+                    sal_Int32 nVal = 0;
+                    rOuterShdwProp.Value >>= nVal;
+                    aOuterShdwAttrList->add( XML_stPos, OString::number( nVal ).getStr() );
+                }
+                else if( rOuterShdwProp.Name == "grow" )
+                {
+                    sal_Int32 nVal = 0;
+                    rOuterShdwProp.Value >>= nVal;
+                    aOuterShdwAttrList->add( XML_grow, OString::number( nVal ).getStr() );
+                }
+            }
+        }
+        else if(rEffectProp.Name == "RgbClr")
+        {
+            rEffectProp.Value >>= nRgbClr;
+        }
+        else if(rEffectProp.Name == "RgbClrTransparency")
+        {
+            sal_Int32 nTransparency;
+            if (rEffectProp.Value >>= nTransparency)
+                // Calculate alpha value (see oox/source/drawingml/color.cxx : getTransparency())
+                nAlpha = MAX_PERCENT - ( PER_PERCENT * nTransparency );
+        }
+        else if(rEffectProp.Name == "SchemeClr")
+        {
+            rEffectProp.Value >>= sSchemeClr;
+        }
+        else if(rEffectProp.Name == "SchemeClrTransformations")
+        {
+            rEffectProp.Value >>= aTransformations;
+        }
+    }
+
+    if( nEffectToken <= 0 )
+        return;
+
+    mpFS->startElement( nEffectToken, xOuterShdwAttrList );
+
+    if( bContainsColor )
+    {
+        if( sSchemeClr.isEmpty() )
+            WriteColor( nRgbClr, nAlpha );
+        else
+            WriteColor( sSchemeClr, aTransformations );
+    }
+
+    mpFS->endElement( nEffectToken );
+}
+
+static sal_Int32 lcl_CalculateDist(const double dX, const double dY)
+{
+    return static_cast< sal_Int32 >(sqrt(dX*dX + dY*dY) * 360);
+}
+
+static sal_Int32 lcl_CalculateDir(const double dX, const double dY)
+{
+    return (static_cast< sal_Int32 >(basegfx::rad2deg(atan2(dY,dX)) * 60000) + 21600000) % 21600000;
+}
+
+void DrawingML::WriteShapeEffects( const Reference< XPropertySet >& rXPropSet )
+{
+    Sequence< PropertyValue > aGrabBag, aEffects, aOuterShdwProps;
+    if( GetProperty( rXPropSet, "InteropGrabBag" ) )
+    {
+        mAny >>= aGrabBag;
+        auto pProp = std::find_if(std::cbegin(aGrabBag), std::cend(aGrabBag),
+            [](const PropertyValue& rProp) { return rProp.Name == "EffectProperties"; });
+        if (pProp != std::cend(aGrabBag))
+        {
+            pProp->Value >>= aEffects;
+            auto pEffect = std::find_if(std::cbegin(aEffects), std::cend(aEffects),
+                [](const PropertyValue& rEffect) { return rEffect.Name == "outerShdw"; });
+            if (pEffect != std::cend(aEffects))
+                pEffect->Value >>= aOuterShdwProps;
+        }
+    }
+
+    // tdf#132201: the order of effects is important. Effects order (CT_EffectList in ECMA-376):
+    // blur -> fillOverlay -> glow -> innerShdw -> outerShdw -> prstShdw -> reflection -> softEdge
+
+    if( !aEffects.hasElements() )
+    {
+        bool bHasShadow = false;
+        if( GetProperty( rXPropSet, "Shadow" ) )
+            mAny >>= bHasShadow;
+        bool bHasEffects = bHasShadow;
+        if (!bHasEffects && GetProperty(rXPropSet, "GlowEffectRadius"))
+        {
+            sal_Int32 rad = 0;
+            mAny >>= rad;
+            bHasEffects = rad > 0;
+        }
+        if (!bHasEffects && GetProperty(rXPropSet, "SoftEdgeRadius"))
+        {
+            sal_Int32 rad = 0;
+            mAny >>= rad;
+            bHasEffects = rad > 0;
+        }
+
+        if (bHasEffects)
+        {
+            mpFS->startElementNS(XML_a, XML_effectLst);
+            WriteGlowEffect(rXPropSet);
+            if( bHasShadow )
+            {
+                Sequence< PropertyValue > aShadowGrabBag( 3 );
+                Sequence< PropertyValue > aShadowAttribsGrabBag( 2 );
+
+                double dX = +0.0, dY = +0.0;
+                rXPropSet->getPropertyValue( "ShadowXDistance" ) >>= dX;
+                rXPropSet->getPropertyValue( "ShadowYDistance" ) >>= dY;
+
+                aShadowAttribsGrabBag[0].Name = "dist";
+                aShadowAttribsGrabBag[0].Value <<= lcl_CalculateDist(dX, dY);
+                aShadowAttribsGrabBag[1].Name = "dir";
+                aShadowAttribsGrabBag[1].Value <<= lcl_CalculateDir(dX, dY);
+
+                aShadowGrabBag[0].Name = "Attribs";
+                aShadowGrabBag[0].Value <<= aShadowAttribsGrabBag;
+                aShadowGrabBag[1].Name = "RgbClr";
+                aShadowGrabBag[1].Value = rXPropSet->getPropertyValue( "ShadowColor" );
+                aShadowGrabBag[2].Name = "RgbClrTransparency";
+                aShadowGrabBag[2].Value = rXPropSet->getPropertyValue( "ShadowTransparence" );
+
+                WriteShapeEffect( "outerShdw", aShadowGrabBag );
+            }
+            WriteSoftEdgeEffect(rXPropSet);
+            mpFS->endElementNS(XML_a, XML_effectLst);
+        }
+    }
+    else
+    {
+        for( auto& rOuterShdwProp : aOuterShdwProps )
+        {
+            if( rOuterShdwProp.Name == "Attribs" )
+            {
+                Sequence< PropertyValue > aAttribsProps;
+                rOuterShdwProp.Value >>= aAttribsProps;
+
+                double dX = +0.0, dY = +0.0;
+                rXPropSet->getPropertyValue( "ShadowXDistance" ) >>= dX;
+                rXPropSet->getPropertyValue( "ShadowYDistance" ) >>= dY;
+
+                for( auto& rAttribsProp : aAttribsProps )
+                {
+                    if( rAttribsProp.Name == "dist" )
+                    {
+                        rAttribsProp.Value <<= lcl_CalculateDist(dX, dY);
+                    }
+                    else if( rAttribsProp.Name == "dir" )
+                    {
+                        rAttribsProp.Value <<= lcl_CalculateDir(dX, dY);
+                    }
+                }
+
+                rOuterShdwProp.Value <<= aAttribsProps;
+            }
+            else if( rOuterShdwProp.Name == "RgbClr" )
+            {
+                rOuterShdwProp.Value = rXPropSet->getPropertyValue( "ShadowColor" );
+            }
+            else if( rOuterShdwProp.Name == "RgbClrTransparency" )
+            {
+                rOuterShdwProp.Value = rXPropSet->getPropertyValue( "ShadowTransparence" );
+            }
+        }
+
+        mpFS->startElementNS(XML_a, XML_effectLst);
+        bool bGlowWritten = false;
+        for( const auto& rEffect : std::as_const(aEffects) )
+        {
+            if (!bGlowWritten
+                && (rEffect.Name == "innerShdw" || rEffect.Name == "outerShdw"
+                    || rEffect.Name == "prstShdw" || rEffect.Name == "reflection"
+                    || rEffect.Name == "softEdge"))
+            {
+                WriteGlowEffect(rXPropSet);
+                bGlowWritten = true;
+            }
+
+            if( rEffect.Name == "outerShdw" )
+            {
+                WriteShapeEffect( rEffect.Name, aOuterShdwProps );
+            }
+            else
+            {
+                Sequence< PropertyValue > aEffectProps;
+                rEffect.Value >>= aEffectProps;
+                WriteShapeEffect( rEffect.Name, aEffectProps );
+            }
+        }
+        if (!bGlowWritten)
+            WriteGlowEffect(rXPropSet);
+        WriteSoftEdgeEffect(rXPropSet); // the last
+
+        mpFS->endElementNS(XML_a, XML_effectLst);
+    }
+}
+
+void DrawingML::WriteGlowEffect(const Reference< XPropertySet >& rXPropSet)
+{
+    sal_Int32 nRad = 0;
+    rXPropSet->getPropertyValue("GlowEffectRadius") >>= nRad;
+    if (!nRad)
+        return;
+
+    Sequence< PropertyValue > aGlowAttribs(1);
+    aGlowAttribs[0].Name = "rad";
+    aGlowAttribs[0].Value <<= oox::drawingml::convertHmmToEmu(nRad);
+    Sequence< PropertyValue > aGlowProps(3);
+    aGlowProps[0].Name = "Attribs";
+    aGlowProps[0].Value <<= aGlowAttribs;
+    aGlowProps[1].Name = "RgbClr";
+    aGlowProps[1].Value = rXPropSet->getPropertyValue("GlowEffectColor");
+    aGlowProps[2].Name = "RgbClrTransparency";
+    aGlowProps[2].Value = rXPropSet->getPropertyValue("GlowEffectTransparency");
+    // TODO other stuff like saturation or luminance
+
+    WriteShapeEffect("glow", aGlowProps);
+}
+
+void DrawingML::WriteSoftEdgeEffect(const css::uno::Reference<css::beans::XPropertySet>& rXPropSet)
+{
+    sal_Int32 nRad = 0;
+    rXPropSet->getPropertyValue("SoftEdgeRadius") >>= nRad;
+    if (!nRad)
+        return;
+
+    css::uno::Sequence<css::beans::PropertyValue> aAttribs(1);
+    aAttribs[0].Name = "rad";
+    aAttribs[0].Value <<= oox::drawingml::convertHmmToEmu(nRad);
+    css::uno::Sequence<css::beans::PropertyValue> aProps(1);
+    aProps[0].Name = "Attribs";
+    aProps[0].Value <<= aAttribs;
+
+    WriteShapeEffect("softEdge", aProps);
+}
+
+void DrawingML::WriteShape3DEffects( const Reference< XPropertySet >& xPropSet )
+{
+    // check existence of the grab bag
+    if( !GetProperty( xPropSet, "InteropGrabBag" ) )
+        return;
+
+    // extract the relevant properties from the grab bag
+    Sequence< PropertyValue > aGrabBag, aEffectProps, aLightRigProps, aShape3DProps;
+    mAny >>= aGrabBag;
+    auto pShapeProp = std::find_if(std::cbegin(aGrabBag), std::cend(aGrabBag),
+        [](const PropertyValue& rProp) { return rProp.Name == "3DEffectProperties"; });
+    if (pShapeProp != std::cend(aGrabBag))
+    {
+        Sequence< PropertyValue > a3DEffectProps;
+        pShapeProp->Value >>= a3DEffectProps;
+        for( const auto& r3DEffectProp : std::as_const(a3DEffectProps) )
+        {
+            if( r3DEffectProp.Name == "Camera" )
+                r3DEffectProp.Value >>= aEffectProps;
+            else if( r3DEffectProp.Name == "LightRig" )
+                r3DEffectProp.Value >>= aLightRigProps;
+            else if( r3DEffectProp.Name == "Shape3D" )
+                r3DEffectProp.Value >>= aShape3DProps;
+        }
+    }
+
+    auto pTextProp = std::find_if(std::cbegin(aGrabBag), std::cend(aGrabBag),
+        [](const PropertyValue& rProp) { return rProp.Name == "Text3DEffectProperties"; });
+
+    if (pTextProp != std::cend(aGrabBag))
+    {
+        Sequence< PropertyValue > a3DEffectProps;
+        pTextProp->Value >>= a3DEffectProps;
+        for( const auto& r3DEffectProp : std::as_const(a3DEffectProps) )
+        {
+            if( r3DEffectProp.Name == "Camera" )
+                r3DEffectProp.Value >>= aEffectProps;
+            else if( r3DEffectProp.Name == "LightRig" )
+                r3DEffectProp.Value >>= aLightRigProps;
+            else if( r3DEffectProp.Name == "Shape3D" )
+                r3DEffectProp.Value >>= aShape3DProps;
+        }
+    }
+
+    if( !aEffectProps.hasElements() && !aLightRigProps.hasElements() && !aShape3DProps.hasElements() )
+        return;
+
+    bool bCameraRotationPresent = false;
+    sax_fastparser::FastAttributeList *aCameraAttrList = FastSerializerHelper::createAttrList();
+    sax_fastparser::XFastAttributeListRef xCameraAttrList( aCameraAttrList );
+    sax_fastparser::FastAttributeList *aCameraRotationAttrList = FastSerializerHelper::createAttrList();
+    sax_fastparser::XFastAttributeListRef xRotAttrList( aCameraRotationAttrList );
+    for( const auto& rEffectProp : std::as_const(aEffectProps) )
+    {
+        if( rEffectProp.Name == "prst" )
+        {
+            OUString sVal;
+            rEffectProp.Value >>= sVal;
+            aCameraAttrList->add( XML_prst, OUStringToOString( sVal, RTL_TEXTENCODING_UTF8 ).getStr() );
+        }
+        else if( rEffectProp.Name == "fov" )
+        {
+            float fVal = 0;
+            rEffectProp.Value >>= fVal;
+            aCameraAttrList->add( XML_fov, OString::number( fVal * 60000 ).getStr() );
+        }
+        else if( rEffectProp.Name == "zoom" )
+        {
+            float fVal = 1;
+            rEffectProp.Value >>= fVal;
+            aCameraAttrList->add( XML_zoom, OString::number( fVal * 100000 ).getStr() );
+        }
+        else if( rEffectProp.Name == "rotLat" ||
+                rEffectProp.Name == "rotLon" ||
+                rEffectProp.Name == "rotRev" )
+        {
+            sal_Int32 nVal = 0, nToken = XML_none;
+            rEffectProp.Value >>= nVal;
+            if( rEffectProp.Name == "rotLat" )
+                nToken = XML_lat;
+            else if( rEffectProp.Name == "rotLon" )
+                nToken = XML_lon;
+            else if( rEffectProp.Name == "rotRev" )
+                nToken = XML_rev;
+            aCameraRotationAttrList->add( nToken, OString::number( nVal ).getStr() );
+            bCameraRotationPresent = true;
+        }
+    }
+
+    bool bLightRigRotationPresent = false;
+    sax_fastparser::FastAttributeList *aLightRigAttrList = FastSerializerHelper::createAttrList();
+    sax_fastparser::XFastAttributeListRef xLightAttrList( aLightRigAttrList );
+    sax_fastparser::FastAttributeList *aLightRigRotationAttrList = FastSerializerHelper::createAttrList();
+    sax_fastparser::XFastAttributeListRef xLightRotAttrList( aLightRigRotationAttrList );
+    for( const auto& rLightRigProp : std::as_const(aLightRigProps) )
+    {
+        if( rLightRigProp.Name == "rig" || rLightRigProp.Name == "dir" )
+        {
+            OUString sVal;
+            sal_Int32 nToken = XML_none;
+            rLightRigProp.Value >>= sVal;
+            if( rLightRigProp.Name == "rig" )
+                nToken = XML_rig;
+            else if( rLightRigProp.Name == "dir" )
+                nToken = XML_dir;
+            aLightRigAttrList->add( nToken, OUStringToOString( sVal, RTL_TEXTENCODING_UTF8 ).getStr() );
+        }
+        else if( rLightRigProp.Name == "rotLat" ||
+                rLightRigProp.Name == "rotLon" ||
+                rLightRigProp.Name == "rotRev" )
+        {
+            sal_Int32 nVal = 0, nToken = XML_none;
+            rLightRigProp.Value >>= nVal;
+            if( rLightRigProp.Name == "rotLat" )
+                nToken = XML_lat;
+            else if( rLightRigProp.Name == "rotLon" )
+                nToken = XML_lon;
+            else if( rLightRigProp.Name == "rotRev" )
+                nToken = XML_rev;
+            aLightRigRotationAttrList->add( nToken, OString::number( nVal ).getStr() );
+            bLightRigRotationPresent = true;
+        }
+    }
+
+    mpFS->startElementNS(XML_a, XML_scene3d);
+
+    if( aEffectProps.hasElements() )
+    {
+        mpFS->startElementNS( XML_a, XML_camera, xCameraAttrList );
+        if( bCameraRotationPresent )
+        {
+            mpFS->singleElementNS( XML_a, XML_rot, xRotAttrList );
+        }
+        mpFS->endElementNS( XML_a, XML_camera );
+    }
+    else
+    {
+        // a:camera with Word default values - Word won't open the document if this is not present
+        mpFS->singleElementNS(XML_a, XML_camera, XML_prst, "orthographicFront");
+    }
+
+    if( aEffectProps.hasElements() )
+    {
+        mpFS->startElementNS( XML_a, XML_lightRig, xLightAttrList );
+        if( bLightRigRotationPresent )
+        {
+            mpFS->singleElementNS( XML_a, XML_rot, xLightRotAttrList );
+        }
+        mpFS->endElementNS( XML_a, XML_lightRig );
+    }
+    else
+    {
+        // a:lightRig with Word default values - Word won't open the document if this is not present
+        mpFS->singleElementNS(XML_a, XML_lightRig, XML_rig, "threePt", XML_dir, "t");
+    }
+
+    mpFS->endElementNS( XML_a, XML_scene3d );
+
+    if( !aShape3DProps.hasElements() )
+        return;
+
+    bool bBevelTPresent = false, bBevelBPresent = false;
+    Sequence< PropertyValue > aExtrusionColorProps, aContourColorProps;
+    sax_fastparser::FastAttributeList *aBevelTAttrList = FastSerializerHelper::createAttrList();
+    sax_fastparser::XFastAttributeListRef xBevelTAttrList( aBevelTAttrList );
+    sax_fastparser::FastAttributeList *aBevelBAttrList = FastSerializerHelper::createAttrList();
+    sax_fastparser::XFastAttributeListRef xBevelBAttrList( aBevelBAttrList );
+    sax_fastparser::FastAttributeList *aShape3DAttrList = FastSerializerHelper::createAttrList();
+    for( const auto& rShape3DProp : std::as_const(aShape3DProps) )
+    {
+        if( rShape3DProp.Name == "extrusionH" || rShape3DProp.Name == "contourW" || rShape3DProp.Name == "z" )
+        {
+            sal_Int32 nVal = 0, nToken = XML_none;
+            rShape3DProp.Value >>= nVal;
+            if( rShape3DProp.Name == "extrusionH" )
+                nToken = XML_extrusionH;
+            else if( rShape3DProp.Name == "contourW" )
+                nToken = XML_contourW;
+            else if( rShape3DProp.Name == "z" )
+                nToken = XML_z;
+            aShape3DAttrList->add( nToken, OString::number( nVal ).getStr() );
+        }
+        else if( rShape3DProp.Name == "prstMaterial" )
+        {
+            OUString sVal;
+            rShape3DProp.Value >>= sVal;
+            aShape3DAttrList->add( XML_prstMaterial, OUStringToOString( sVal, RTL_TEXTENCODING_UTF8 ).getStr() );
+        }
+        else if( rShape3DProp.Name == "extrusionClr" )
+        {
+            rShape3DProp.Value >>= aExtrusionColorProps;
+        }
+        else if( rShape3DProp.Name == "contourClr" )
+        {
+            rShape3DProp.Value >>= aContourColorProps;
+        }
+        else if( rShape3DProp.Name == "bevelT" || rShape3DProp.Name == "bevelB" )
+        {
+            Sequence< PropertyValue > aBevelProps;
+            rShape3DProp.Value >>= aBevelProps;
+            if ( !aBevelProps.hasElements() )
+                continue;
+
+            sax_fastparser::FastAttributeList *aBevelAttrList = nullptr;
+            if( rShape3DProp.Name == "bevelT" )
+            {
+                bBevelTPresent = true;
+                aBevelAttrList = aBevelTAttrList;
+            }
+            else
+            {
+                bBevelBPresent = true;
+                aBevelAttrList = aBevelBAttrList;
+            }
+            for( const auto& rBevelProp : std::as_const(aBevelProps) )
+            {
+                if( rBevelProp.Name == "w" || rBevelProp.Name == "h" )
+                {
+                    sal_Int32 nVal = 0, nToken = XML_none;
+                    rBevelProp.Value >>= nVal;
+                    if( rBevelProp.Name == "w" )
+                        nToken = XML_w;
+                    else if( rBevelProp.Name == "h" )
+                        nToken = XML_h;
+                    aBevelAttrList->add( nToken, OString::number( nVal ).getStr() );
+                }
+                else  if( rBevelProp.Name == "prst" )
+                {
+                    OUString sVal;
+                    rBevelProp.Value >>= sVal;
+                    aBevelAttrList->add( XML_prst, OUStringToOString( sVal, RTL_TEXTENCODING_UTF8 ).getStr() );
+                }
+            }
+
+        }
+    }
+
+    sax_fastparser::XFastAttributeListRef xAttrList( aShape3DAttrList );
+    mpFS->startElementNS( XML_a, XML_sp3d, xAttrList );
+    if( bBevelTPresent )
+    {
+        mpFS->singleElementNS( XML_a, XML_bevelT, xBevelTAttrList );
+    }
+    if( bBevelBPresent )
+    {
+        mpFS->singleElementNS( XML_a, XML_bevelB, xBevelBAttrList );
+    }
+    if( aExtrusionColorProps.hasElements() )
+    {
+        OUString sSchemeClr;
+        ::Color nColor;
+        sal_Int32 nTransparency(0);
+        Sequence< PropertyValue > aColorTransformations;
+        for( const auto& rExtrusionColorProp : std::as_const(aExtrusionColorProps) )
+        {
+            if( rExtrusionColorProp.Name == "schemeClr" )
+                rExtrusionColorProp.Value >>= sSchemeClr;
+            else if( rExtrusionColorProp.Name == "schemeClrTransformations" )
+                rExtrusionColorProp.Value >>= aColorTransformations;
+            else if( rExtrusionColorProp.Name == "rgbClr" )
+                rExtrusionColorProp.Value >>= nColor;
+            else if( rExtrusionColorProp.Name == "rgbClrTransparency" )
+                rExtrusionColorProp.Value >>= nTransparency;
+        }
+        mpFS->startElementNS(XML_a, XML_extrusionClr);
+
+        if( sSchemeClr.isEmpty() )
+            WriteColor( nColor, MAX_PERCENT - ( PER_PERCENT * nTransparency ) );
+        else
+            WriteColor( sSchemeClr, aColorTransformations );
+
+        mpFS->endElementNS( XML_a, XML_extrusionClr );
+    }
+    if( aContourColorProps.hasElements() )
+    {
+        OUString sSchemeClr;
+        ::Color nColor;
+        sal_Int32 nTransparency(0);
+        Sequence< PropertyValue > aColorTransformations;
+        for( const auto& rContourColorProp : std::as_const(aContourColorProps) )
+        {
+            if( rContourColorProp.Name == "schemeClr" )
+                rContourColorProp.Value >>= sSchemeClr;
+            else if( rContourColorProp.Name == "schemeClrTransformations" )
+                rContourColorProp.Value >>= aColorTransformations;
+            else if( rContourColorProp.Name == "rgbClr" )
+                rContourColorProp.Value >>= nColor;
+            else if( rContourColorProp.Name == "rgbClrTransparency" )
+                rContourColorProp.Value >>= nTransparency;
+        }
+        mpFS->startElementNS(XML_a, XML_contourClr);
+
+        if( sSchemeClr.isEmpty() )
+            WriteColor( nColor, MAX_PERCENT - ( PER_PERCENT * nTransparency ) );
+        else
+            WriteColor( sSchemeClr, aContourColorProps );
+
+        mpFS->endElementNS( XML_a, XML_contourClr );
+    }
+    mpFS->endElementNS( XML_a, XML_sp3d );
+}
+
+void DrawingML::WriteArtisticEffect( const Reference< XPropertySet >& rXPropSet )
+{
+    if( !GetProperty( rXPropSet, "InteropGrabBag" ) )
+        return;
+
+    PropertyValue aEffect;
+    Sequence< PropertyValue > aGrabBag;
+    mAny >>= aGrabBag;
+    auto pProp = std::find_if(std::cbegin(aGrabBag), std::cend(aGrabBag),
+        [](const PropertyValue& rProp) { return rProp.Name == "ArtisticEffectProperties"; });
+    if (pProp != std::cend(aGrabBag))
+        pProp->Value >>= aEffect;
+    sal_Int32 nEffectToken = ArtisticEffectProperties::getEffectToken( aEffect.Name );
+    if( nEffectToken == XML_none )
+        return;
+
+    Sequence< PropertyValue > aAttrs;
+    aEffect.Value >>= aAttrs;
+    sax_fastparser::FastAttributeList *aAttrList = FastSerializerHelper::createAttrList();
+    OString sRelId;
+    for( const auto& rAttr : std::as_const(aAttrs) )
+    {
+        sal_Int32 nToken = ArtisticEffectProperties::getEffectToken( rAttr.Name );
+        if( nToken != XML_none )
+        {
+            sal_Int32 nVal = 0;
+            rAttr.Value >>= nVal;
+            aAttrList->add( nToken, OString::number( nVal ).getStr() );
+        }
+        else if( rAttr.Name == "OriginalGraphic" )
+        {
+            Sequence< PropertyValue > aGraphic;
+            rAttr.Value >>= aGraphic;
+            Sequence< sal_Int8 > aGraphicData;
+            OUString sGraphicId;
+            for( const auto& rProp : std::as_const(aGraphic) )
+            {
+                if( rProp.Name == "Id" )
+                    rProp.Value >>= sGraphicId;
+                else if( rProp.Name == "Data" )
+                    rProp.Value >>= aGraphicData;
+            }
+            sRelId = WriteWdpPicture( sGraphicId, aGraphicData );
+        }
+    }
+
+    mpFS->startElementNS(XML_a, XML_extLst);
+    mpFS->startElementNS(XML_a, XML_ext, XML_uri, "{BEBA8EAE-BF5A-486C-A8C5-ECC9F3942E4B}");
+    mpFS->startElementNS( XML_a14, XML_imgProps,
+                          FSNS(XML_xmlns, XML_a14), mpFB->getNamespaceURL(OOX_NS(a14)).toUtf8() );
+    mpFS->startElementNS(XML_a14, XML_imgLayer, FSNS(XML_r, XML_embed), sRelId);
+    mpFS->startElementNS(XML_a14, XML_imgEffect);
+
+    sax_fastparser::XFastAttributeListRef xAttrList( aAttrList );
+    mpFS->singleElementNS( XML_a14, nEffectToken, xAttrList );
+
+    mpFS->endElementNS( XML_a14, XML_imgEffect );
+    mpFS->endElementNS( XML_a14, XML_imgLayer );
+    mpFS->endElementNS( XML_a14, XML_imgProps );
+    mpFS->endElementNS( XML_a, XML_ext );
+    mpFS->endElementNS( XML_a, XML_extLst );
+}
+
+OString DrawingML::WriteWdpPicture( const OUString& rFileId, const Sequence< sal_Int8 >& rPictureData )
+{
+    std::map<OUString, OUString>::iterator aCachedItem = maWdpCache.find( rFileId );
+    if( aCachedItem != maWdpCache.end() )
+        return OUStringToOString( aCachedItem->second, RTL_TEXTENCODING_UTF8 );
+
+    OUString sFileName = "media/hdphoto" + OUString::number( mnWdpImageCounter++ ) + ".wdp";
+    Reference< XOutputStream > xOutStream = mpFB->openFragmentStream( OUStringBuffer()
+                                                                      .appendAscii( GetComponentDir() )
+                                                                      .append( "/" )
+                                                                      .append( sFileName )
+                                                                      .makeStringAndClear(),
+                                                                      "image/vnd.ms-photo" );
+    OUString sId;
+    xOutStream->writeBytes( rPictureData );
+    xOutStream->closeOutput();
+
+    sId = mpFB->addRelation( mpFS->getOutputStream(),
+                             oox::getRelationship(Relationship::HDPHOTO),
+                             OUStringBuffer()
+                             .appendAscii( GetRelationCompPrefix() )
+                             .append( sFileName )
+                             .makeStringAndClear() );
+
+    maWdpCache[rFileId] = sId;
+    return OUStringToOString( sId, RTL_TEXTENCODING_UTF8 );
+}
+
+void DrawingML::WriteDiagram(const css::uno::Reference<css::drawing::XShape>& rXShape, int nDiagramId)
+{
+    uno::Reference<beans::XPropertySet> xPropSet(rXShape, uno::UNO_QUERY);
+
+    uno::Reference<xml::dom::XDocument> dataDom;
+    uno::Reference<xml::dom::XDocument> layoutDom;
+    uno::Reference<xml::dom::XDocument> styleDom;
+    uno::Reference<xml::dom::XDocument> colorDom;
+    uno::Reference<xml::dom::XDocument> drawingDom;
+    uno::Sequence<uno::Sequence<uno::Any>> xDataRelSeq;
+    uno::Sequence<uno::Any> diagramDrawing;
+
+    // retrieve the doms from the GrabBag
+    uno::Sequence<beans::PropertyValue> propList;
+    xPropSet->getPropertyValue(UNO_NAME_MISC_OBJ_INTEROPGRABBAG) >>= propList;
+    for (const auto& rProp : std::as_const(propList))
+    {
+        OUString propName = rProp.Name;
+        if (propName == "OOXData")
+            rProp.Value >>= dataDom;
+        else if (propName == "OOXLayout")
+            rProp.Value >>= layoutDom;
+        else if (propName == "OOXStyle")
+            rProp.Value >>= styleDom;
+        else if (propName == "OOXColor")
+            rProp.Value >>= colorDom;
+        else if (propName == "OOXDrawing")
+        {
+            rProp.Value >>= diagramDrawing;
+            diagramDrawing[0]
+                >>= drawingDom; // if there is OOXDrawing property then set drawingDom here only.
+        }
+        else if (propName == "OOXDiagramDataRels")
+            rProp.Value >>= xDataRelSeq;
+    }
+
+    // check that we have the 4 mandatory XDocuments
+    // if not, there was an error importing and we won't output anything
+    if (!dataDom.is() || !layoutDom.is() || !styleDom.is() || !colorDom.is())
+        return;
+
+    // generate a unique id
+    sax_fastparser::FastAttributeList* pDocPrAttrList
+        = sax_fastparser::FastSerializerHelper::createAttrList();
+    pDocPrAttrList->add(XML_id, OString::number(nDiagramId).getStr());
+    OUString sName = "Diagram" + OUString::number(nDiagramId);
+    pDocPrAttrList->add(XML_name, OUStringToOString(sName, RTL_TEXTENCODING_UTF8).getStr());
+    sax_fastparser::XFastAttributeListRef xDocPrAttrListRef(pDocPrAttrList);
+
+    if (GetDocumentType() == DOCUMENT_DOCX)
+    {
+        mpFS->singleElementNS(XML_wp, XML_docPr, xDocPrAttrListRef);
+        mpFS->singleElementNS(XML_wp, XML_cNvGraphicFramePr);
+
+        mpFS->startElementNS(
+            XML_a, XML_graphic, FSNS(XML_xmlns, XML_a),
+            mpFB->getNamespaceURL(OOX_NS(dml)).toUtf8());
+    }
+    else
+    {
+        mpFS->startElementNS(XML_p, XML_nvGraphicFramePr);
+
+        mpFS->singleElementNS(XML_p, XML_cNvPr, xDocPrAttrListRef);
+        mpFS->singleElementNS(XML_p, XML_cNvGraphicFramePr);
+
+        mpFS->startElementNS(XML_p, XML_nvPr);
+        mpFS->startElementNS(XML_p, XML_extLst);
+        // change tracking extension - required in PPTX
+        mpFS->startElementNS(XML_p, XML_ext, XML_uri, "{D42A27DB-BD31-4B8C-83A1-F6EECF244321}");
+        mpFS->singleElementNS(XML_p14, XML_modId,
+            FSNS(XML_xmlns, XML_p14), mpFB->getNamespaceURL(OOX_NS(p14)).toUtf8(),
+            XML_val,
+            OString::number(comphelper::rng::uniform_uint_distribution(1, SAL_MAX_UINT32)));
+        mpFS->endElementNS(XML_p, XML_ext);
+        mpFS->endElementNS(XML_p, XML_extLst);
+        mpFS->endElementNS(XML_p, XML_nvPr);
+
+        mpFS->endElementNS(XML_p, XML_nvGraphicFramePr);
+
+        // store size and position of background shape instead of group shape
+        // as some shapes may be outside
+        css::uno::Reference<css::drawing::XShapes> xShapes(rXShape, uno::UNO_QUERY);
+        if (xShapes.is() && xShapes->hasElements())
+        {
+            css::uno::Reference<css::drawing::XShape> xShapeBg(xShapes->getByIndex(0),
+                                                               uno::UNO_QUERY);
+            awt::Point aPos = xShapeBg->getPosition();
+            awt::Size aSize = xShapeBg->getSize();
+            WriteTransformation(
+                tools::Rectangle(Point(aPos.X, aPos.Y), Size(aSize.Width, aSize.Height)),
+                XML_p, false, false, 0, false);
+        }
+
+        mpFS->startElementNS(XML_a, XML_graphic);
+    }
+
+    mpFS->startElementNS(XML_a, XML_graphicData, XML_uri,
+                         "http://schemas.openxmlformats.org/drawingml/2006/diagram");
+
+    OUString sRelationCompPrefix = OUString::createFromAscii(GetRelationCompPrefix());
+
+    // add data relation
+    OUString dataFileName = "diagrams/data" + OUString::number(nDiagramId) + ".xml";
+    OString dataRelId = OUStringToOString(
+        mpFB->addRelation(mpFS->getOutputStream(), oox::getRelationship(Relationship::DIAGRAMDATA),
+                          sRelationCompPrefix + dataFileName),
+        RTL_TEXTENCODING_UTF8);
+
+    // add layout relation
+    OUString layoutFileName = "diagrams/layout" + OUString::number(nDiagramId) + ".xml";
+    OString layoutRelId
+        = OUStringToOString(mpFB->addRelation(mpFS->getOutputStream(),
+                                              oox::getRelationship(Relationship::DIAGRAMLAYOUT),
+                                              sRelationCompPrefix + layoutFileName),
+                            RTL_TEXTENCODING_UTF8);
+
+    // add style relation
+    OUString styleFileName = "diagrams/quickStyle" + OUString::number(nDiagramId) + ".xml";
+    OString styleRelId
+        = OUStringToOString(mpFB->addRelation(mpFS->getOutputStream(),
+                                              oox::getRelationship(Relationship::DIAGRAMQUICKSTYLE),
+                                              sRelationCompPrefix + styleFileName),
+                            RTL_TEXTENCODING_UTF8);
+
+    // add color relation
+    OUString colorFileName = "diagrams/colors" + OUString::number(nDiagramId) + ".xml";
+    OString colorRelId
+        = OUStringToOString(mpFB->addRelation(mpFS->getOutputStream(),
+                                              oox::getRelationship(Relationship::DIAGRAMCOLORS),
+                                              sRelationCompPrefix + colorFileName),
+                            RTL_TEXTENCODING_UTF8);
+
+    OUString drawingFileName;
+    if (drawingDom.is())
+    {
+        // add drawing relation
+        drawingFileName = "diagrams/drawing" + OUString::number(nDiagramId) + ".xml";
+        OUString drawingRelId = mpFB->addRelation(
+            mpFS->getOutputStream(), oox::getRelationship(Relationship::DIAGRAMDRAWING),
+            sRelationCompPrefix + drawingFileName);
+
+        // the data dom contains a reference to the drawing relation. We need to update it with the new generated
+        // relation value before writing the dom to a file
+
+        // Get the dsp:damaModelExt node from the dom
+        uno::Reference<xml::dom::XNodeList> nodeList = dataDom->getElementsByTagNameNS(
+            "http://schemas.microsoft.com/office/drawing/2008/diagram", "dataModelExt");
+
+        // There must be one element only so get it
+        uno::Reference<xml::dom::XNode> node = nodeList->item(0);
+
+        // Get the list of attributes of the node
+        uno::Reference<xml::dom::XNamedNodeMap> nodeMap = node->getAttributes();
+
+        // Get the node with the relId attribute and set its new value
+        uno::Reference<xml::dom::XNode> relIdNode = nodeMap->getNamedItem("relId");
+        relIdNode->setNodeValue(drawingRelId);
+    }
+
+    mpFS->singleElementNS(XML_dgm, XML_relIds,
+        FSNS(XML_xmlns, XML_dgm), mpFB->getNamespaceURL(OOX_NS(dmlDiagram)).toUtf8(),
+        FSNS(XML_xmlns, XML_r), mpFB->getNamespaceURL(OOX_NS(officeRel)).toUtf8(),
+        FSNS(XML_r, XML_dm), dataRelId, FSNS(XML_r, XML_lo), layoutRelId,
+        FSNS(XML_r, XML_qs), styleRelId, FSNS(XML_r, XML_cs), colorRelId);
+
+    mpFS->endElementNS(XML_a, XML_graphicData);
+    mpFS->endElementNS(XML_a, XML_graphic);
+
+    uno::Reference<xml::sax::XSAXSerializable> serializer;
+    uno::Reference<xml::sax::XWriter> writer
+        = xml::sax::Writer::create(comphelper::getProcessComponentContext());
+
+    OUString sDir = OUString::createFromAscii(GetComponentDir());
+
+    // write data file
+    serializer.set(dataDom, uno::UNO_QUERY);
+    uno::Reference<io::XOutputStream> xDataOutputStream = mpFB->openFragmentStream(
+        sDir + "/" + dataFileName,
+        "application/vnd.openxmlformats-officedocument.drawingml.diagramData+xml");
+    writer->setOutputStream(xDataOutputStream);
+    serializer->serialize(uno::Reference<xml::sax::XDocumentHandler>(writer, uno::UNO_QUERY_THROW),
+                          uno::Sequence<beans::StringPair>());
+
+    // write the associated Images and rels for data file
+    writeDiagramRels(xDataRelSeq, xDataOutputStream, "OOXDiagramDataRels", nDiagramId);
+
+    // write layout file
+    serializer.set(layoutDom, uno::UNO_QUERY);
+    writer->setOutputStream(mpFB->openFragmentStream(
+        sDir + "/" + layoutFileName,
+        "application/vnd.openxmlformats-officedocument.drawingml.diagramLayout+xml"));
+    serializer->serialize(uno::Reference<xml::sax::XDocumentHandler>(writer, uno::UNO_QUERY_THROW),
+                          uno::Sequence<beans::StringPair>());
+
+    // write style file
+    serializer.set(styleDom, uno::UNO_QUERY);
+    writer->setOutputStream(mpFB->openFragmentStream(
+        sDir + "/" + styleFileName,
+        "application/vnd.openxmlformats-officedocument.drawingml.diagramStyle+xml"));
+    serializer->serialize(uno::Reference<xml::sax::XDocumentHandler>(writer, uno::UNO_QUERY_THROW),
+                          uno::Sequence<beans::StringPair>());
+
+    // write color file
+    serializer.set(colorDom, uno::UNO_QUERY);
+    writer->setOutputStream(mpFB->openFragmentStream(
+        sDir + "/" + colorFileName,
+        "application/vnd.openxmlformats-officedocument.drawingml.diagramColors+xml"));
+    serializer->serialize(uno::Reference<xml::sax::XDocumentHandler>(writer, uno::UNO_QUERY_THROW),
+                          uno::Sequence<beans::StringPair>());
+
+    // write drawing file
+    if (!drawingDom.is())
+        return;
+
+    serializer.set(drawingDom, uno::UNO_QUERY);
+    uno::Reference<io::XOutputStream> xDrawingOutputStream = mpFB->openFragmentStream(
+        sDir + "/" + drawingFileName, "application/vnd.ms-office.drawingml.diagramDrawing+xml");
+    writer->setOutputStream(xDrawingOutputStream);
+    serializer->serialize(
+        uno::Reference<xml::sax::XDocumentHandler>(writer, uno::UNO_QUERY_THROW),
+        uno::Sequence<beans::StringPair>());
+
+    // write the associated Images and rels for drawing file
+    uno::Sequence<uno::Sequence<uno::Any>> xDrawingRelSeq;
+    diagramDrawing[1] >>= xDrawingRelSeq;
+    writeDiagramRels(xDrawingRelSeq, xDrawingOutputStream, "OOXDiagramDrawingRels", nDiagramId);
+}
+
+void DrawingML::writeDiagramRels(const uno::Sequence<uno::Sequence<uno::Any>>& xRelSeq,
+                                 const uno::Reference<io::XOutputStream>& xOutStream,
+                                 const OUString& sGrabBagProperyName, int nDiagramId)
+{
+    // add image relationships of OOXData, OOXDiagram
+    OUString sType(oox::getRelationship(Relationship::IMAGE));
+    uno::Reference<xml::sax::XWriter> xWriter
+        = xml::sax::Writer::create(comphelper::getProcessComponentContext());
+    xWriter->setOutputStream(xOutStream);
+
+    // retrieve the relationships from Sequence
+    for (sal_Int32 j = 0; j < xRelSeq.getLength(); j++)
+    {
+        // diagramDataRelTuple[0] => RID,
+        // diagramDataRelTuple[1] => xInputStream
+        // diagramDataRelTuple[2] => extension
+        uno::Sequence<uno::Any> diagramDataRelTuple = xRelSeq[j];
+
+        OUString sRelId;
+        OUString sExtension;
+        diagramDataRelTuple[0] >>= sRelId;
+        diagramDataRelTuple[2] >>= sExtension;
+        OUString sContentType;
+        if (sExtension.equalsIgnoreAsciiCase(".WMF"))
+            sContentType = "image/x-wmf";
+        else
+            sContentType = "image/" + sExtension.copy(1);
+        sRelId = sRelId.copy(3);
+
+        StreamDataSequence dataSeq;
+        diagramDataRelTuple[1] >>= dataSeq;
+        uno::Reference<io::XInputStream> dataImagebin(
+            new ::comphelper::SequenceInputStream(dataSeq));
+
+        //nDiagramId is used to make the name unique irrespective of the number of smart arts.
+        OUString sFragment = "media/" + sGrabBagProperyName + OUString::number(nDiagramId) + "_"
+                             + OUString::number(j) + sExtension;
+
+        PropertySet aProps(xOutStream);
+        aProps.setAnyProperty(PROP_RelId, uno::makeAny(sRelId.toInt32()));
+
+        mpFB->addRelation(xOutStream, sType, "../" + sFragment);
+
+        OUString sDir = OUString::createFromAscii(GetComponentDir());
+        uno::Reference<io::XOutputStream> xBinOutStream
+            = mpFB->openFragmentStream(sDir + "/" + sFragment, sContentType);
+
+        try
+        {
+            comphelper::OStorageHelper::CopyInputToOutput(dataImagebin, xBinOutStream);
+        }
+        catch (const uno::Exception&)
+        {
+            TOOLS_WARN_EXCEPTION("oox.drawingml", "DrawingML::writeDiagramRels Failed to copy grabbaged Image");
+        }
+        dataImagebin->closeInput();
+    }
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/oox/source/export/ooxml-export-notes.txt b/oox/source/export/ooxml-export-notes.txt
new file mode 100644
index 000000000..36c42fc53
--- /dev/null
+++ b/oox/source/export/ooxml-export-notes.txt
@@ -0,0 +1,235 @@
+#
+# 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 .
+#
+
+OOXML generally
+---------------
+
+- http://www.ecma-international.org/publications/standards/Ecma-376.htm
+- http://www.asahi-net.or.jp/~eb2m-mrt/ooxml/dependencies.html
+
+Related modules
+---------------
+
+- oox
+  - .xlsx and .pptx import
+
+- writerfilter
+  - import of .docx, uses also oox for the graphics etc.
+
+- filter
+  - the configuration stuff (so that the filters appear in the filepicker)
+
+Old binary filters (export)
+---------------------------
+
+- doc export
+  - sw/source/filter/ww8/wrtww8*
+    - wrtww8.cxx:2191 [SwWW8Writer::StoreDoc()] is the entry point
+
+  - eg.
+    #0  SwWW8Writer::WriteText (this=0x2aaab3dfb7c0) at /local/ooxml/ooxml/sw/source/filter/ww8/wrtww8.cxx:1846
+    #1  0x00002aaaae75a545 in SwWW8Writer::WriteMainText (this=0x2aaab3d6a870)
+        at /local/ooxml/ooxml/sw/source/filter/ww8/wrtww8.cxx:1925
+    #2  0x00002aaaae75e357 in SwWW8Writer::StoreDoc1 (this=0x2aaab3d6a870)
+        at /local/ooxml/ooxml/sw/source/filter/ww8/wrtww8.cxx:2076
+    #3  0x00002aaaae7605ec in SwWW8Writer::StoreDoc (this=0x2aaab3d6a870)
+        at /local/ooxml/ooxml/sw/source/filter/ww8/wrtww8.cxx:2383
+    #4  0x00002aaaae760fd5 in SwWW8Writer::WriteStorage (this=0x2aaab3d6a870)
+        at /local/ooxml/ooxml/sw/source/filter/ww8/wrtww8.cxx:2547
+    #5  0x00002aaaae70b793 in StgWriter::Write (this=0x2aaab3d6a870, rPaM=@0x2b3802a2b640, rStg=@0x2aaab3d621c0,
+        pFName=0x7fffb1b285c0) at /local/ooxml/ooxml/sw/source/filter/writer/writer.cxx:653
+    #6  0x00002aaaae70b84d in Writer::Write (this=0x2aaab3d6a870, rPaM=@0x2b3802a2b640, rStrm=@0x2aaaad979d20,
+        pFName=0x7fffb1b285c0) at /local/ooxml/ooxml/sw/source/filter/writer/writer.cxx:358
+    #7  0x00002aaaae70b993 in Writer::Write (this=0x2aaab3d6a870, rPam=@0x2b3802a2b640, rMed=@0x2aaaad999f30,
+        pFileName=0x7fffb1b285c0) at /local/ooxml/ooxml/sw/source/filter/writer/writer.cxx:385
+    #8  0x00002aaaae6375d7 in SwWriter::Write (this=0x7fffb1b28410, rxWriter=@0x7fffb1b285d0,
+        pRealFileName=0x7fffb1b285c0) at /local/ooxml/ooxml/sw/source/filter/basflt/shellio.cxx:963
+    #9  0x00002aaaae87cc1e in SwDocShell::ConvertTo (this=0xcc27f0, rMedium=@0x2aaaad999f30)
+        at /local/ooxml/ooxml/sw/source/ui/app/docsh.cxx:924
+    #10 0x00002b37faae6b58 in SfxObjectShell::DoLoad ()
+        from /local/ooxml/inst/openoffice.org3.0/program/../basis-link/program//libsfxlx.so
+
+- xls export
+  - sc/source/filter/excel/xe*
+
+  - eg.
+    #0  XclExpRecord::Save (this=0x11ae4c0, rStrm=@0x7fff5e6335d0)
+        at /local/ooxml/ooxml/sc/source/filter/excel/xerecord.cxx:88
+    #1  0x00002aaaae562c4a in ExcRecord::Save (this=0x11ae4c0, rStrm=@0x7fff5e6335d0)
+        at /local/ooxml/ooxml/sc/source/filter/excel/excrecds.cxx:168
+    #2  0x00002aaaae54b0fa in XclExpRecordList<XclExpRecordBase>::Save (this=0x11c5d18, rStrm=@0x7fff5e6335d0)
+        at ../inc/xerecord.hxx:281
+    #3  0x00002aaaae547541 in ExcTable::Write (this=0x11c5cf8, rStr=@0x7fff5e6335d0)
+        at /local/ooxml/ooxml/sc/source/filter/excel/excdoc.cxx:455
+    #4  0x00002aaaae5475fb in ExcDocument::Write (this=0x11c5ce0, rSvStrm=@0x2aaab3dcd070)
+        at /local/ooxml/ooxml/sc/source/filter/excel/excdoc.cxx:525
+    #5  0x00002aaaae568add in ExportBiff5::Write (this=0x7fff5e6339c0)
+        at /local/ooxml/ooxml/sc/source/filter/excel/expop2.cxx:119
+    #6  0x00002aaaae54f4af in ScExportExcel5 (rMedium=@0x2aaab3d87410, pDocument=0xce6a00, bBiff8=1 '\001', eNach=1)
+        at /local/ooxml/ooxml/sc/source/filter/excel/excel.cxx:252
+    #7  0x00002aaaadf1b70a in ScDocShell::ConvertTo (this=0xce6990, rMed=@0x2aaab3d87410)
+        at /local/ooxml/ooxml/sc/source/ui/docshell/docsh.cxx:2080
+    #8  0x00002b354dfd8b58 in SfxObjectShell::DoLoad ()
+        from /local/ooxml/inst/openoffice.org3.0/program/../basis-link/program//libsfxlx.so
+
+  - Current approach is to add a XclExpRecordBase::SaveXml() method, which
+    would be used to write the XML content (while Save() would continue
+    writing the BIFF format).
+  - Q: How do we get to the Save()/SaveXml() methods (e.g. the SST export code)
+    #0  XclExpSstImpl::Save (this=0x1b170b0, rStrm=@0x7fffd4d5c4a0)
+        at /home/jon/Development/OpenOffice.org/ooxml/sc/source/filter/excel/xecontent.cxx:224
+    #1  0x00007f68b7e46ff7 in XclExpSst::Save (this=0x1abc300, 
+        rStrm=@0x7fffd4d5c4a0)
+        at /home/jon/Development/OpenOffice.org/ooxml/sc/source/filter/excel/xecontent.cxx:351
+    #2  0x00007f68b7de5090 in XclExpRecordList<XclExpRecordBase>::Save (
+        this=0x1b2d168, rStrm=@0x7fffd4d5c4a0) at ../inc/xerecord.hxx:282
+    // as above, starting at frame 2
+
+  - Thus, to get to the SaveXml() method, we need to add a slew of WriteXml()
+    methods that will (eventually) invoke the SaveXml() methods.
+
+  - ZipStorage for XML handling and StorageRef (XStorage interface)
+		- To construct ZipStorage, need XMultiServiceFactory (!), and
+			XInputStream.
+		- Have an SvStream; need to wrap SvStream with XInputStream
+			- OInputStreamWrapper in <unotools/streamwrap.hxx>
+		- Where do I get XMultiServiceFactory?
+			- Lots of places -- just grep
+			- perhaps XmlFilterBase _does_ make sense here.
+				- Do it anyway.
+	- Looking into having XclExpXmlStream inherit from ZipFilterBase
+		- problem: exception during construction, because ZipStorage hates me:
+		#0  OStorageFactory::createInstanceWithArguments (this=0x10612a0, 
+				aArguments=@0x7fffe2ef76d0)
+				at /home/jon/Development/OpenOffice.org/ooxml/package/source/xstor/xfactory.cxx:275
+		#1  0x00007f12d93f0d5c in comphelper::OStorageHelper::GetStorageOfFormatFromStream (aFormat=@0x7fffe2ef7780, xStream=@0x1a502d8, nStorageMode=15, 
+				xFactory=@0x1a502c0)
+				at /home/jon/Development/OpenOffice.org/ooxml/comphelper/source/misc/storagehelper.cxx:342
+		#2  0x00007f12c33d1a6d in ZipStorage (this=0x1a92550, rxFactory=@0x1a502c0, 
+				rxStream=@0x1a502d8)
+				at /home/jon/Development/OpenOffice.org/ooxml/oox/source/helper/zipstorage.cxx:87
+		#3  0x00007f12c33f089e in oox::core::XmlFilterBase::implCreateStorage (
+				this=0x7fffe2ef7930, rxInStream=@0x1a502d0, rxStream=@0x1a502d8)
+				at /home/jon/Development/OpenOffice.org/ooxml/oox/source/core/xmlfilterbase.cxx:298
+		#4  0x00007f12c33dd204 in oox::core::FilterBase::filter (this=0x7fffe2ef7930, 
+				rDescriptor=@0x7fffe2ef78d0)
+				at /home/jon/Development/OpenOffice.org/ooxml/oox/source/core/filterbase.cxx:284
+		#5  0x00007f12c68097a2 in XclExpXmlStream (this=0x7fffe2ef7930, 
+				rSMgr=@0x7fffe2ef79a0, rStrm=@0x18d6f90)
+				at /home/jon/Development/OpenOffice.org/ooxml/sc/source/filter/excel/xestream.cxx:659
+		#6  0x00007f12c674c8c1 in ExcDocument::WriteXml (this=0x15911f0, 
+				rStrm=@0x18d6f90)
+				at /home/jon/Development/OpenOffice.org/ooxml/sc/source/filter/excel/excdoc.cxx:575
+		...
+		- Actual problem: xfactory.cxx:274, the CheckPackageSignature_Impl() call.
+			- fails because the empty file has content (!), thus fails the "package
+				signature check" (which tries to ensure the file format is correct).
+		- Underlying file is an SvFileStream, created in
+			SfxMedium::GetOutStream().
+		- So why's CheckPackageSignature_Impl() fail?  Because
+			lcl_ExportExcel2007Xml() had the code:
+
+				tools::SvRef<SotStorage> xRootStrg = new SotStorage( pMedStrm, FALSE );
+
+			That is, it was creating an OLE Structured Storage document over the
+			SvStream, and then (later) used the *same* SvStream and passed it to
+			ZipStorage.  This caused ZipStorage to complain because OLESS data was
+			already present in the file, with a different file signature than what
+			ZipPackage was expecting (go figure).
+
+- ppt export
+  - sd/source/filter/eppt/*
+  - svx/source/msfilter
+    - for eg. Escher export
+    - Escher: http://chicago.sourceforge.net/devel/docs/escher/index.html
+
+  - eg.
+    #0  PPTWriter (this=0x15807d0, rSvStorage=@0x7fff894f5340, rXModel=@0x142a2e8, rXStatInd=@0x142a2f0, pVBA=0x0,
+        nCnvrtFlags=15) at /local/ooxml/ooxml/sd/source/filter/eppt/eppt.cxx:268
+    #1  0x00002aaab3895719 in ExportPPT (rSvStorage=@0x7fff894f5340, rXModel=@0x142a2e8, rXStatInd=@0x142a2f0,
+        pVBA=0x0, nCnvrtFlags=15) at /local/ooxml/ooxml/sd/source/filter/eppt/eppt.cxx:2503
+    #2  0x00002aaaadef85b7 in SdPage::onParagraphRemoving ()
+       from /local/ooxml/inst/openoffice.org3.0/program/../basis-link/program/libsdlx.so
+    #3  0x00002aaaade202e3 in sd::DrawDocShell::ConvertTo ()
+       from /local/ooxml/inst/openoffice.org3.0/program/../basis-link/program/libsdlx.so
+    #4  0x00002aec23119b58 in SfxObjectShell::DoLoad ()
+       from /local/ooxml/inst/openoffice.org3.0/program/../basis-link/program//libsfxlx.so
+
+- pptx export
+  - sd/source/filter/eppt/pptx-epptooxml.cxx,
+    oox::core::PowerPointExport::exportDocument()
+
+- odp export
+    #0  ZipPackage (this=0x1805e80, xNewFactory=@0x7fffe284e990) at /home/rodo/git/ooxml/package/source/zippackage/ZipPackage.cxx:279
+    #1  0x00002aaaadd3dc94 in ZipPackage_createInstance (xMgr=@0x7fffe284e990) at /home/rodo/git/ooxml/package/source/zippackage/ZipPackage.cxx:1546
+    #2  0x00002b0fca7ab6b3 in ?? () from /opt/libreoffice/program/../basis-link/program/../ure-link/lib/libuno_cppuhelpergcc3.so.3
+    #3  0x00002b0fca7a7fda in ?? () from /opt/libreoffice/program/../basis-link/program/../ure-link/lib/libuno_cppuhelpergcc3.so.3
+    #4  0x00002b0fca7a811e in ?? () from /opt/libreoffice/program/../basis-link/program/../ure-link/lib/libuno_cppuhelpergcc3.so.3
+    #5  0x00002b0fca7aa7cc in ?? () from /opt/libreoffice/program/../basis-link/program/../ure-link/lib/libuno_cppuhelpergcc3.so.3
+    #6  0x00002b0fca7aacbe in ?? () from /opt/libreoffice/program/../basis-link/program/../ure-link/lib/libuno_cppuhelpergcc3.so.3
+    #7  0x00002b0fca7aa035 in ?? () from /opt/libreoffice/program/../basis-link/program/../ure-link/lib/libuno_cppuhelpergcc3.so.3
+    #8  0x00002aaaaadae1b3 in ?? () from /opt/libreoffice/ure/lib/bootstrap.uno.so
+    #9  0x00002aaaaadaa84c in ?? () from /opt/libreoffice/ure/lib/bootstrap.uno.so
+    #10 0x00002aaab5c7a7e5 in OStorage_Impl::OpenOwnPackage (this=0x185cac0) at /home/rodo/git/ooxml/package/source/xstor/xstorage.cxx:549
+    #11 0x00002aaab5c7ab3e in OStorage_Impl::ReadContents (this=0x185cac0) at /home/rodo/git/ooxml/package/source/xstor/xstorage.cxx:649
+    #12 0x00002aaab5c7d32f in OStorage_Impl::FindElement (this=0x185cac0, rName=@0x7fffe284f280) at /home/rodo/git/ooxml/package/source/xstor/xstorage.cxx:1387
+    #13 0x00002aaab5c7dc45 in OStorage::hasByName (this=0x1808880, aName=@0x7fffe284f280) at /home/rodo/git/ooxml/package/source/xstor/xstorage.cxx:4045
+    #14 0x00002aaab1fde8c5 in XMLVersionListPersistence::load () from /opt/libreoffice/program/../basis-link/program/libxolx.so
+    #15 0x00002b0fcb058bb2 in SfxMedium::GetVersionList (this=0x1750050, _bNoReload=false) at /home/rodo/git/ooxml/sfx2/source/doc/docfile.cxx:3247
+    #16 0x00002b0fcb0571b5 in SfxMedium::GetStorage (this=0x1750050) at /home/rodo/git/ooxml/sfx2/source/doc/docfile.cxx:1328
+    #17 0x00002b0fcb05d0d7 in SfxMedium::GetOutputStorage (this=0x1750050) at /home/rodo/git/ooxml/sfx2/source/doc/docfile.cxx:1068
+    #18 0x00002b0fcb091227 in SfxObjectShell::SaveTo_Impl (this=0xf44d60, rMedium=@0x1750050, pSet=0x0) at /home/rodo/git/ooxml/sfx2/source/doc/objstor.cxx:1557
+    #19 0x00002b0fcb09443c in SfxObjectShell::PreDoSaveAs_Impl (this=0xf44d60, rFileName=@0x7fffe2850700, aFilterName=@0x7fffe28507f0, pParams=0xf10c10)
+        at /home/rodo/git/ooxml/sfx2/source/doc/objstor.cxx:2984
+    #20 0x00002b0fcb094ea5 in SfxObjectShell::CommonSaveAs_Impl (this=0xf44d60, aURL=@0x7fffe2850870, aFilterName=@0x7fffe28507f0, aParams=0x1740310)
+        at /home/rodo/git/ooxml/sfx2/source/doc/objstor.cxx:2855
+    #21 0x00002b0fcb0a1da2 in SfxObjectShell::APISaveAs_Impl (this=0xf44d60, aFileName=@0x7fffe2850b70, aParams=0x1740310)
+        at /home/rodo/git/ooxml/sfx2/source/doc/objserv.cxx:432
+    #22 0x00002b0fcb0e74c8 in SfxBaseModel::impl_store (this=0xf96a00, sURL=@0x7fffe28516b0, seqArguments=@0x7fffe2851ae0, bSaveTo=0 '\0')
+        at /home/rodo/git/ooxml/sfx2/source/doc/sfxbasemodel.cxx:2591
+    #23 0x00002b0fcb0f124b in SfxBaseModel::storeAsURL (this=0xf96a00, rURL=@0x7fffe28516b0, rArgs=@0x7fffe2851ae0)
+        at /home/rodo/git/ooxml/sfx2/source/doc/sfxbasemodel.cxx:1568
+    #24 0x00002b0fcb101d3d in SfxStoringHelper::GUIStoreModel (this=0x7fffe28519f0, xModel=@0xf18798, aSlotName=@0x7fffe2852200, aArgsSequence=@0x7fffe2851ae0, 
+        bPreselectPassword=0 '\0') at /home/rodo/git/ooxml/sfx2/source/doc/guisaveas.cxx:1529
+    #25 0x00002b0fcb0a4051 in SfxObjectShell::ExecFile_Impl (this=0xf44d60, rReq=@0x1484f20) at /home/rodo/git/ooxml/sfx2/source/doc/objserv.cxx:744
+    #26 0x00002b0fcb0a5c73 in SfxStubSfxObjectShellExecFile_Impl (pShell=0xf44d60, rReq=@0x1484f20) at ../../unxlngx6.pro/inc/sfxslots.hxx:161
+    #27 0x00002b0fcb17f398 in SfxShell::CallExec (this=0xf44d60, pFunc=0x2b0fcb0a5c56 <SfxStubSfxObjectShellExecFile_Impl(SfxShell*, SfxRequest&)>, rReq=@0x1484f20)
+        at ../../inc/sfx2/shell.hxx:226
+    #28 0x00002b0fcb17cec3 in SfxDispatcher::Call_Impl (this=0x110fde0, rShell=@0xf44d60, rSlot=@0x2b0fcb576368, rReq=@0x1484f20, bRecord=1 '\001')
+        at /home/rodo/git/ooxml/sfx2/source/control/dispatch.cxx:338
+    #29 0x00002b0fcb17d3f2 in SfxDispatcher::PostMsgHandler (this=0x110fde0, pReq=0x1484f20) at /home/rodo/git/ooxml/sfx2/source/control/dispatch.cxx:1643
+    #30 0x00002b0fcb17d51d in SfxDispatcher::LinkStubPostMsgHandler (pThis=0x110fde0, pCaller=0x1484f20) at /home/rodo/git/ooxml/sfx2/source/control/dispatch.cxx:1610
+    #31 0x00002b0fcafb3e70 in Link::Call (this=0x11488f8, pCaller=0x1484f20) at /home/rodo/git/ooxml/solver/300/unxlngx6.pro/inc/tools/link.hxx:158
+    #32 0x00002b0fcb1a9952 in GenLink::Call (this=0x11488f8, pCaller=0x1484f20) at ../../inc/sfx2/genlink.hxx:63
+    #33 0x00002b0fcb1a9773 in SfxHintPoster::Event (this=0x11488e0, pPostedHint=0x1484f20) at /home/rodo/git/ooxml/sfx2/source/notify/hintpost.cxx:98
+    #34 0x00002b0fcb1a9984 in SfxHintPoster::DoEvent_Impl (this=0x11488e0, pPostedHint=0x1484f20) at /home/rodo/git/ooxml/sfx2/source/notify/hintpost.cxx:88
+    #35 0x00002b0fcb1a974f in SfxHintPoster::LinkStubDoEvent_Impl (pThis=0x11488e0, pCaller=0x1484f20) at /home/rodo/git/ooxml/sfx2/source/notify/hintpost.cxx:92
+    #36 0x00002b0fccef69f8 in ImplWindowFrameProc () from /opt/libreoffice/program/../basis-link/program/libvcllx.so
+    #37 0x00002b0fd3f91f8f in SalDisplay::DispatchInternalEvent () from /opt/libreoffice/basis3.0/program/libvclplug_genlx.so
+    #38 0x00002b0fd0fa4a84 in GtkXLib::userEventFn () from /opt/libreoffice/basis3.0/program/libvclplug_gtklx.so
+    #39 0x00002b0fd3cb0204 in g_main_context_dispatch () from /usr/lib64/libglib-2.0.so.0
+    #40 0x00002b0fd3cb34fd in ?? () from /usr/lib64/libglib-2.0.so.0
+    #41 0x00002b0fd3cb39ce in g_main_context_iteration () from /usr/lib64/libglib-2.0.so.0
+    #42 0x00002b0fd0fa4fd9 in GtkXLib::Yield () from /opt/libreoffice/basis3.0/program/libvclplug_gtklx.so
+    #43 0x00002b0fccd1859e in Application::Yield () from /opt/libreoffice/program/../basis-link/program/libvcllx.so
+    #44 0x00002b0fccd18677 in Application::Execute () from /opt/libreoffice/program/../basis-link/program/libvcllx.so
+    #45 0x00002b0fc86fd803 in ?? () from /opt/libreoffice/program/../basis-link/program/libsoffice.so
+    #46 0x00002b0fccd1da24 in ImplSVMain () from /opt/libreoffice/program/../basis-link/program/libvcllx.so
+    #47 0x00002b0fccd1db15 in SVMain () from /opt/libreoffice/program/../basis-link/program/libvcllx.so
+    #48 0x00002b0fc872fe6c in soffice_main () from /opt/libreoffice/program/../basis-link/program/libsoffice.so
+    #49 0x000000000040114b in main ()
diff --git a/oox/source/export/preset-definitions-to-shape-types.pl b/oox/source/export/preset-definitions-to-shape-types.pl
new file mode 100644
index 000000000..f6bd260f7
--- /dev/null
+++ b/oox/source/export/preset-definitions-to-shape-types.pl
@@ -0,0 +1,1237 @@
+#!/usr/bin/env perl -w
+#
+# 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 .
+#
+
+use strict;
+use warnings;
+
+sub usage() {
+    print STDERR <<EOF;
+Usage: preset-definitions-to-shape-types.pl [ --drawingml-adj-names-data | --vml-shape-types-data ] <shapes> <text>
+
+Converts presetShapeDefinitions.xml and presetTextWarpDefinitions.xml to a
+.cxx that contains VML with the definitions of the shapes.  The result is
+written to stdout.
+
+<shapes> presetShapeDefinitions.xml (including the path to it)
+<text>   presetTextWarpDefinitions.xml (including the path to it)
+EOF
+    exit 1;
+}
+
+sub show_call_stack
+{
+    my ( $path, $line, $subr );
+    my $max_depth = 30;
+    my $i = 1;
+    print STDERR "--- Begin stack trace ---\n";
+    while ( (my @call_details = (caller($i++))) && ($i<$max_depth) ) {
+        print STDERR "$call_details[1] line $call_details[2] in function $call_details[3]\n";
+    }
+    print STDERR "--- End stack trace ---\n";
+}
+
+my $drawingml_adj_names_data = 0;
+my $vml_shape_types_data = 0;
+my $src_shapes = shift;
+if ($src_shapes eq "--drawingml-adj-names-data") {
+    $drawingml_adj_names_data = 1;
+    $src_shapes = shift;
+} elsif ($src_shapes eq "--vml-shape-types-data") {
+    $vml_shape_types_data = 1;
+    $src_shapes = shift;
+}
+my $src_text = shift;
+
+usage() if ( !defined( $src_shapes ) || !defined( $src_text ) ||
+             $src_shapes eq "-h" || $src_shapes eq "--help" ||
+             !-f $src_shapes || !-f $src_text );
+
+# Global variables
+my @levels = ();
+my $shape_name = "";
+my $state = "";
+my $path = "";
+my $adjust = "";
+my %adj_names;
+my $max_adj_no = 0;
+my @formulas = ();
+my %variables = ();
+my $ignore_this_shape = 0;
+my $handles = "";
+my $textboxrect = "";
+my $last_pos_x = "";
+my $last_pos_y = "";
+my $no_stroke = 0;
+my $no_fill = 0;
+my $path_w = 1;
+my $path_h = 1;
+my @quadratic_bezier = ();
+
+my %result_shapes = ();
+
+my %shapes_ids = (
+    0 => 'notPrimitive',
+    1 => 'rectangle',
+    2 => 'roundRectangle',
+    3 => 'ellipse',
+    4 => 'diamond',
+    5 => 'triangle',
+    6 => 'rtTriangle',
+    7 => 'parallelogram',
+    8 => 'trapezoid',
+    9 => 'hexagon',
+    10 => 'octagon',
+    11 => 'plus',
+    12 => 'star5',
+    13 => 'rightArrow',
+    14 => 'thickArrow', # should not be used
+    15 => 'homePlate',
+    16 => 'cube',
+    17 => 'wedgeRoundRectCallout', # balloon
+    18 => 'star16', # seal
+    19 => 'arc',
+    20 => 'line',
+    21 => 'plaque',
+    22 => 'can',
+    23 => 'donut',
+    24 => 'textPlain', # textSimple - FIXME MS Office 2007 converts these to textboxes with unstyled text, so is it actually correct to map it to a real style?
+    25 => 'textStop', # textOctagon FIXME see 24
+    26 => 'textTriangle', # textHexagon FIXMME see 24
+    27 => 'textCanDown', # textCurve FIXMME see 24
+    28 => 'textWave1', # textWave FIXMME see 24
+    29 => 'textArchUpPour', # textRing FIXMME see 24
+    30 => 'textCanDown', # textOnCurve FIXMME see 24
+    31 => 'textArchUp', # textOnRing FIXMME see 24
+    32 => 'straightConnector1',
+    33 => 'bentConnector2',
+    34 => 'bentConnector3',
+    35 => 'bentConnector4',
+    36 => 'bentConnector5',
+    37 => 'curvedConnector2',
+    38 => 'curvedConnector3',
+    39 => 'curvedConnector4',
+    40 => 'curvedConnector5',
+    41 => 'callout1',
+    42 => 'callout2',
+    43 => 'callout3',
+    44 => 'accentCallout1',
+    45 => 'accentCallout2',
+    46 => 'accentCallout3',
+    47 => 'borderCallout1',
+    48 => 'borderCallout2',
+    49 => 'borderCallout3',
+    50 => 'accentBorderCallout1',
+    51 => 'accentBorderCallout2',
+    52 => 'accentBorderCallout3',
+    53 => 'ribbon',
+    54 => 'ribbon2',
+    55 => 'chevron',
+    56 => 'pentagon',
+    57 => 'noSmoking',
+    58 => 'star8', # seal8
+    59 => 'star16', # seal16
+    60 => 'star32', # seal32
+    61 => 'wedgeRectCallout',
+    62 => 'wedgeRoundRectCallout', # wedgeRRectCallout
+    63 => 'wedgeEllipseCallout',
+    64 => 'wave',
+    65 => 'foldedCorner',
+    66 => 'leftArrow',
+    67 => 'downArrow',
+    68 => 'upArrow',
+    69 => 'leftRightArrow',
+    70 => 'upDownArrow',
+    71 => 'irregularSeal1',
+    72 => 'irregularSeal2',
+    73 => 'lightningBolt',
+    74 => 'heart',
+    75 => 'pictureFrame',
+    76 => 'quadArrow',
+    77 => 'leftArrowCallout',
+    78 => 'rightArrowCallout',
+    79 => 'upArrowCallout',
+    80 => 'downArrowCallout',
+    81 => 'leftRightArrowCallout',
+    82 => 'upDownArrowCallout',
+    83 => 'quadArrowCallout',
+    84 => 'bevel',
+    85 => 'leftBracket',
+    86 => 'rightBracket',
+    87 => 'leftBrace',
+    88 => 'rightBrace',
+    89 => 'leftUpArrow',
+    90 => 'bentUpArrow',
+    91 => 'bentArrow',
+    92 => 'star24', # seal24
+    93 => 'stripedRightArrow',
+    94 => 'notchedRightArrow',
+    95 => 'blockArc',
+    96 => 'smileyFace',
+    97 => 'verticalScroll',
+    98 => 'horizontalScroll',
+    99 => 'circularArrow',
+    100 => 'notchedCircularArrow', # should not be used
+    101 => 'uturnArrow',
+    102 => 'curvedRightArrow',
+    103 => 'curvedLeftArrow',
+    104 => 'curvedUpArrow',
+    105 => 'curvedDownArrow',
+    106 => 'cloudCallout',
+    107 => 'ellipseRibbon',
+    108 => 'ellipseRibbon2',
+    109 => 'flowChartProcess',
+    110 => 'flowChartDecision',
+    111 => 'flowChartInputOutput',
+    112 => 'flowChartPredefinedProcess',
+    113 => 'flowChartInternalStorage',
+    114 => 'flowChartDocument',
+    115 => 'flowChartMultidocument',
+    116 => 'flowChartTerminator',
+    117 => 'flowChartPreparation',
+    118 => 'flowChartManualInput',
+    119 => 'flowChartManualOperation',
+    120 => 'flowChartConnector',
+    121 => 'flowChartPunchedCard',
+    122 => 'flowChartPunchedTape',
+    123 => 'flowChartSummingJunction',
+    124 => 'flowChartOr',
+    125 => 'flowChartCollate',
+    126 => 'flowChartSort',
+    127 => 'flowChartExtract',
+    128 => 'flowChartMerge',
+    129 => 'flowChartOfflineStorage',
+    130 => 'flowChartOnlineStorage',
+    131 => 'flowChartMagneticTape',
+    132 => 'flowChartMagneticDisk',
+    133 => 'flowChartMagneticDrum',
+    134 => 'flowChartDisplay',
+    135 => 'flowChartDelay',
+    136 => 'textPlain', # textPlainText
+    137 => 'textStop',
+    138 => 'textTriangle',
+    139 => 'textTriangleInverted',
+    140 => 'textChevron',
+    141 => 'textChevronInverted',
+    142 => 'textRingInside',
+    143 => 'textRingOutside',
+    144 => 'textArchUp', # textArchUpCurve
+    145 => 'textArchDown', # textArchDownCurve
+    146 => 'textCircle', # textCircleCurve
+    147 => 'textButton', # textButtonCurve
+    148 => 'textArchUpPour',
+    149 => 'textArchDownPour',
+    150 => 'textCirclePour',
+    151 => 'textButtonPour',
+    152 => 'textCurveUp',
+    153 => 'textCurveDown',
+    154 => 'textCascadeUp',
+    155 => 'textCascadeDown',
+    156 => 'textWave1',
+    157 => 'textWave2',
+    158 => 'textWave3',
+    159 => 'textWave4',
+    160 => 'textInflate',
+    161 => 'textDeflate',
+    162 => 'textInflateBottom',
+    163 => 'textDeflateBottom',
+    164 => 'textInflateTop',
+    165 => 'textDeflateTop',
+    166 => 'textDeflateInflate',
+    167 => 'textDeflateInflateDeflate',
+    168 => 'textFadeRight',
+    169 => 'textFadeLeft',
+    170 => 'textFadeUp',
+    171 => 'textFadeDown',
+    172 => 'textSlantUp',
+    173 => 'textSlantDown',
+    174 => 'textCanUp',
+    175 => 'textCanDown',
+    176 => 'flowChartAlternateProcess',
+    177 => 'flowChartOffpageConnector',
+    178 => 'callout1', # callout90
+    179 => 'accentCallout1', # accentCallout90
+    180 => 'borderCallout1', # borderCallout90
+    181 => 'accentBorderCallout1', # accentBorderCallout90
+    182 => 'leftRightUpArrow',
+    183 => 'sun',
+    184 => 'moon',
+    185 => 'bracketPair',
+    186 => 'bracePair',
+    187 => 'star4', # seal4
+    188 => 'doubleWave',
+    189 => 'actionButtonBlank',
+    190 => 'actionButtonHome',
+    191 => 'actionButtonHelp',
+    192 => 'actionButtonInformation',
+    193 => 'actionButtonForwardNext',
+    194 => 'actionButtonBackPrevious',
+    195 => 'actionButtonEnd',
+    196 => 'actionButtonBeginning',
+    197 => 'actionButtonReturn',
+    198 => 'actionButtonDocument',
+    199 => 'actionButtonSound',
+    200 => 'actionButtonMovie',
+    201 => 'hostControl',
+    202 => 'textBox'
+);
+# An error occurred, we have to ignore this shape
+sub error( $ )
+{
+    my ( $msg ) = @_;
+
+    $ignore_this_shape = 1;
+    print STDERR "ERROR (in $shape_name ): $msg\n";
+}
+
+# Setup the %variables map with predefined values
+sub setup_variables()
+{
+    %variables = (
+        'l'        => 0,
+        't'        => 0,
+        'r'        => 21600,
+        'b'        => 21600,
+
+        'w'        => 21600,
+        'h'        => 21600,
+        'ss'       => 21600,
+        'ls'       => 21600,
+
+        'ssd2'     => 10800, # 1/2
+        'ssd4'     => 5400,  # 1/4
+        'ssd6'     => 3600,  # 1/6
+        'ssd8'     => 2700,  # 1/8
+        'ssd16'    => 1350,  # 1/16
+        'ssd32'    => 675,   # 1/32
+
+        'hc'       => 10800, # horizontal center
+        'vc'       => 10800, # vertical center
+
+        'wd2'      => 10800, # 1/2
+        'wd3'      => 7200,  # 1/3
+        'wd4'      => 5400,  # 1/4
+        'wd5'      => 4320,  # 1/5
+        'wd6'      => 3600,  # 1/6
+        'wd8'      => 2700,  # 1/8
+        'wd10'     => 2160,  # 1/10
+        'wd12'     => 1800,  # 1/12
+        'wd32'     => 675,   # 1/32
+
+        'hd2'      => 10800, # 1/2
+        'hd3'      => 7200,  # 1/3
+        'hd4'      => 5400,  # 1/4
+        'hd5'      => 4320,  # 1/5
+        'hd6'      => 3600,  # 1/6
+        'hd8'      => 2700,  # 1/8
+        'hd10'     => 2160,  # 1/10
+        'hd12'     => 1800,  # 1/12
+        'hd32'     => 675,   # 1/32
+
+        '25000'    => 5400,
+        '12500'    => 2700,
+
+        'cd4'      => 90,    # 1/4 of a circle
+        'cd2'      => 180,   # 1/2 of a circle
+        '3cd4'     => 270,   # 3/4 of a circle
+
+        'cd8'      => 45,    # 1/8 of a circle
+        '3cd8'     => 135,   # 3/8 of a circle
+        '5cd8'     => 225,   # 5/8 of a circle
+        '7cd8'     => 315,   # 7/8 of a circle
+
+        '-5400000' => -90,
+        '-10800000'=> -180,
+        '-16200000'=> -270,
+        '-21600000'=> -360,
+        '-21599999'=> -360,
+
+        '5400000'  => 90,
+        '10800000' => 180,
+        '16200000' => 270,
+        '21600000' => 360,
+        '21599999' => 360
+#
+#        '21600000' => 360,   # angle conversions
+#        '27000000' => 450,
+#        '32400000' => 540,
+#        '37800000' => 630
+    );
+}
+
+# Convert the (predefined) value to a number
+sub value( $ )
+{
+    my ( $val ) = @_;
+
+    my $result = $variables{$val};
+    return $result if ( defined( $result ) );
+
+    return $val if ( $val =~ /^[0-9-]+$/ );
+
+    error( "Unknown variable '$val'." );
+
+    show_call_stack();
+    return $val;
+}
+
+# Convert the DrawingML formula to a VML one
+my %command_variables = (
+    'w' => 'width',
+    'h' => 'height',
+    'r' => 'width',
+    'b' => 'height'
+);
+
+# The same as value(), but some of the hardcoded values can have a name
+sub command_value( $ )
+{
+    my ( $value ) = @_;
+
+    return "" if ( $value eq "" );
+
+    return $value if ( $value =~ /^@/ );
+
+    my $command_val = $command_variables{$value};
+    if ( defined( $command_val ) ) {
+        return $command_val;
+    }
+
+    return value( $value );
+}
+
+# Insert the new formula to the list of formulas
+# Creates the name if it's empty...
+sub insert_formula( $$ )
+{
+    my ( $name, $fmla ) = @_;
+
+    my $i = 0;
+    foreach my $f ( @formulas ) {
+        if ( $f eq $fmla ) {
+            if ( $name ne "" ) {
+                $variables{$name} = "@" . $i;
+            }
+            return "@" . $i;
+        }
+        ++$i;
+    }
+
+    if ( $name eq "" ) {
+        $name = "@" . ( $#formulas + 1 );
+    }
+
+    $variables{$name} = "@" . ( $#formulas + 1 );
+    push @formulas, $fmla;
+
+    if ( $#formulas > 127 ) {
+        error( "Reached the maximum amount of formulas, have to ignore the shape '$shape_name'" );
+    }
+
+    return $variables{$name};
+}
+
+# The same as insert_formula(), but converts the params
+sub insert_formula_params( $$$$$ )
+{
+    my ( $name, $command, $p1, $p2, $p3 ) = @_;
+
+    my $result = $command;
+    if ( $p1 ne "" ) {
+        $result .= " " . command_value( $p1 );
+        if ( $p2 ne "" ) {
+            $result .= " " . command_value( $p2 );
+            if ( $p3 ne "" ) {
+                $result .= " " . command_value( $p3 );
+            }
+        }
+    }
+
+    return insert_formula( $name, $result );
+}
+
+# Convert the formula from DrawingML to VML
+sub convert_formula( $$ )
+{
+    my ( $name, $fmla ) = @_;
+
+    if ( $fmla =~ /^([^ ]+)/ ) {
+        my $command = $1;
+
+        # parse the parameters
+        ( my $values = $fmla ) =~ s/^([^ ]+) *//;
+        my $p1 = "";
+	my $p2 = "";
+	my $p3 = "";
+        if ( $values =~ /^([^ ]+)/ ) {
+            $p1 = $1;
+            $values =~ s/^([^ ]+) *//;
+            if ( $values =~ /^([^ ]+)/ ) {
+                $p2 = $1;
+                $values =~ s/^([^ ]+) *//;
+                if ( $values =~ /^([^ ]+)/ ) {
+                    $p3 = $1;
+                }
+            }
+        }
+
+        # now convert the formula
+        if ( $command eq "+-" ) {
+            if ( $p1 eq "100000" ) {
+                $p1 = value( 'w' );
+            }
+            insert_formula_params( $name, "sum", $p1, $p2, $p3 );
+            return;
+        }
+        elsif ( $command eq "*/" ) {
+            if ( ( $p2 =~ /^(w|h|ss|hd2|wd2|vc)$/ ) && defined( $variables{$p1} ) ) {
+                # switch it ;-) - presetTextWarpDefinitions.xml has it in other order
+                my $tmp = $p1;
+                $p1 = $p2;
+                $p2 = $tmp;
+            }
+
+            if ( ( $p1 =~ /^(w|h|ss|hd2|wd2|vc)$/ ) && defined( $variables{$p2} ) ) {
+                my $val3 = $p3;
+                if ( $val3 =~ /^[0-9-]+$/ ) {
+                    $val3 *= ( value( 'w' ) / value( $p1 ) );
+
+                    # Oh yes, I'm too lazy to implement the full GCD here ;-)
+                    if ( ( $val3 % 100000 ) == 0 ) {
+                        $p1 = 1;
+                        $p3 = sprintf( "%.0f", ( $val3 / 100000 ) );
+                    }
+                    elsif ( $val3 < 100000 ) {
+                        $p3 = 1;
+                        while ( ( ( $p3 * 100000 ) % $val3 ) != 0 ) {
+                            ++$p3
+                        }
+                        $p1 = ( $p3 * 100000 ) / $val3;
+                    }
+                    else {
+                        error( "Need to count the greatest common divisor." );
+                    }
+                }
+            }
+            elsif ( $p3 eq "100000" && $p2 =~ /^[0-9-]+$/ ) {
+                # prevent overflows in some shapes
+                $p2 = sprintf( "%.0f", ( $p2 / 10 ) );
+                $p3 /= 10;
+            }
+            elsif ( $p3 eq "32768" && $p2 =~ /^[0-9-]+$/ ) {
+                # prevent overflows in some shapes
+                $p2 = sprintf( "%.0f", ( $p2 / 8 ) );
+                $p3 /= 8;
+            }
+            elsif ( $p3 eq "50000" ) {
+                $p3 = 10800;
+            }
+            elsif ( $name =~ /^maxAdj/ ) {
+                my $val = value( $p1 );
+                if ( $val =~ /^[0-9-]+$/ ) {
+                    $p1 = sprintf( "%.0f", ( value( 'w' ) * $val / 100000 ) );
+                }
+            }
+
+            if ( ( value( $p1 ) eq value( $p3 ) ) || ( value( $p2 ) eq value( $p3 ) ) ) {
+                my $val = value( ( value( $p1 ) eq value( $p3 ) )? $p2: $p1 );
+                if ( $val =~ /^@([0-9]+)$/ ) {
+                    insert_formula( $name, $formulas[$1] );
+                }
+                else {
+                    insert_formula( $name, "val $val" );
+                }
+            }
+            else {
+                insert_formula_params( $name, "prod", $p1, $p2, $p3 );
+            }
+            return;
+        }
+        elsif ( $command eq "+/" ) {
+            # we have to split this into 2 formulas - 'sum' and 'prod'
+            my $constructed = insert_formula_params( "", "sum", $p1, $p2, "0" );
+            insert_formula_params( $name, "prod", 1, $constructed, $p3); # references the 'sum' formula
+            return;
+        }
+        elsif ( $command eq "?:" ) {
+            insert_formula_params( $name, "if", $p1, $p2, $p3 );
+            return;
+        }
+        elsif ( $command eq "sin" || $command eq "cos" ) {
+            if ( $p2 =~ /^[0-9-]+$/ && ( ( $p2 % 60000 ) == 0 ) ) {
+                $p2 /= 60000;
+            }
+            else {
+                $p2 = insert_formula_params( "", "prod", "1", $p2, "60000" );
+            }
+            # we have to use 'sumangle' even for the case when $p2 is const
+            # and theoretically could be written as such; but Word does not
+            # accept it :-(
+            my $conv = insert_formula_params( "", "sumangle", "0", $p2, "0" );
+
+            $p2 = $conv;
+
+            insert_formula_params( $name, $command, $p1, $p2, "" );
+            return;
+        }
+        elsif ( $command eq "abs" ) {
+            insert_formula_params( $name, $command, $p1, "", "" );
+            return;
+        }
+        elsif ( $command eq "max" || $command eq "min" ) {
+            insert_formula_params( $name, $command, $p1, $p2, "" );
+            return;
+        }
+        elsif ( $command eq "at2" ) {
+            insert_formula_params( $name, "atan2", $p1, $p2, "" );
+            return;
+        }
+        elsif ( $command eq "cat2" ) {
+            insert_formula_params( $name, "cosatan2", $p1, $p2, $p3 );
+            return;
+        }
+        elsif ( $command eq "sat2" ) {
+            insert_formula_params( $name, "sinatan2", $p1, $p2, $p3 );
+            return;
+        }
+        elsif ( $command eq "sqrt" ) {
+            insert_formula_params( $name, "sqrt", $p1, "", "" );
+            return;
+        }
+        elsif ( $command eq "mod" ) {
+            insert_formula_params( $name, "mod", $p1, $p2, $p3 );
+            return;
+        }
+        elsif ( $command eq "val" ) {
+            insert_formula_params( $name, "val", value( $p1 ), "", "" );
+            return;
+        }
+        else {
+            error( "Unknown formula '$name', '$fmla'." );
+        }
+    }
+    else {
+        error( "Cannot convert formula's command '$name', '$fmla'." );
+    }
+}
+
+# There's no exact equivalent of 'arcTo' in VML, we have to do some special casing...
+my %convert_arcTo = (
+    '0' => {
+        '90' => {
+            'path' => 'qy',
+            'op' => [ 'sum 0 __last_x__ __wR__', 'sum __hR__ __last_y__ 0' ],
+        },
+        '-90' => {
+            'path' => 'qy',
+            'op' => [ 'sum 0 __last_x__ __wR__', 'sum 0 __last_y__ __hR__' ],
+        },
+    },
+    '90' => {
+        '90' => {
+            'path' => 'qx',
+            'op' => [ 'sum 0 __last_x__ __wR__', 'sum 0 __last_y__ __hR__' ],
+        },
+        '-90' => {
+            'path' => 'qx',
+            'op' => [ 'sum __wR__ __last_x__ 0', 'sum 0 __last_y__ __hR__' ],
+        },
+    },
+    '180' => {
+        '90' => {
+            'path' => 'qy',
+            'op' => [ 'sum __wR__ __last_x__ 0', 'sum 0 __last_y__ __hR__' ],
+        },
+        '-90' => {
+            'path' => 'qy',
+            'op' => [ 'sum __wR__ __last_x__ 0', 'sum __hR__ __last_y__ 0' ],
+        },
+    },
+    '270' => {
+        '90' => {
+            'path' => 'qx',
+            'op' => [ 'sum __wR__ __last_x__ 0', 'sum __hR__ __last_y__ 0' ],
+        },
+        '-90' => {
+            'path' => 'qx',
+            'op' => [ 'sum 0 __last_x__ __wR__', 'sum __hR__ __last_y__ 0' ],
+        },
+    },
+);
+
+# Elliptic quadrant
+# FIXME optimize so that we compute the const values when possible
+sub elliptic_quadrant( $$$$ )
+{
+    my ( $wR, $hR, $stAng, $swAng ) = @_;
+
+    if ( defined( $convert_arcTo{$stAng} ) && defined( $convert_arcTo{$stAng}{$swAng} ) ) {
+        my $conv_path = $convert_arcTo{$stAng}{$swAng}{'path'};
+        my $conv_op_ref = $convert_arcTo{$stAng}{$swAng}{'op'};
+
+        $path .= "$conv_path";
+
+        my $pos_x = $last_pos_x;
+        my $pos_y = $last_pos_y;
+        for ( my $i = 0; $i <= $#{$conv_op_ref}; ++$i ) {
+            my $op = $conv_op_ref->[$i];
+
+            $op =~ s/__last_x__/$last_pos_x/g;
+            $op =~ s/__last_y__/$last_pos_y/g;
+            $op =~ s/__wR__/$wR/g;
+            $op =~ s/__hR__/$hR/g;
+
+            my $fmla = insert_formula( "", $op );
+
+            $path .= $fmla;
+
+            # so far it's sufficient just to rotate the positions
+            # FIXME if not ;-)
+            $pos_x = $pos_y;
+            $pos_y = $fmla;
+        }
+        $last_pos_x = $pos_x;
+        $last_pos_y = $pos_y;
+    }
+    else {
+        error( "Unhandled elliptic_quadrant(), input is ($wR, $hR, $stAng, $swAng)." );
+    }
+}
+
+# Convert the quadratic bezier to cubic (exact)
+# No idea why, but the 'qb' did not work for me :-(
+sub quadratic_to_cubic_bezier( $ )
+{
+    my ( $axis ) = @_;
+
+    my $a0 = $quadratic_bezier[0]->{$axis};
+    my $a1 = $quadratic_bezier[1]->{$axis};
+    my $a2 = $quadratic_bezier[2]->{$axis};
+
+    my $b0 = $a0;
+
+    # $b1 = $a0 + 2/3 * ( $a1 - $a0 ), but in VML
+    # FIXME optimize for constants - compute directly
+    my $b1_1 = insert_formula_params( "", "sum", "0", $a1, $a0 );
+    my $b1_2 = insert_formula_params( "", "prod", "2", $b1_1, "3" );
+    my $b1   = insert_formula_params( "", "sum", $a0, $b1_2, "0" );
+
+    # $b2 = $b1 + 1/3 * ( $a2 - $a0 );
+    # FIXME optimize for constants - compute directly
+    my $b2_1 = insert_formula_params( "", "sum", "0", $a2, $a0 );
+    my $b2_2 = insert_formula_params( "", "prod", "1", $b2_1, "3" );
+    my $b2   = insert_formula_params( "", "sum", $b1, $b2_2, "0" );
+
+    my $b3 = $a2;
+
+    return ( $b0, $b1, $b2, $b3 );
+}
+
+# Extend $path by one more point
+sub add_point_to_path( $$ )
+{
+    my ( $x, $y ) = @_;
+
+    if ( $path =~ /[0-9]$/ && $x =~ /^[0-9-]/ ) {
+        $path .= ",";
+    }
+    $path .= $x;
+
+    if ( $path =~ /[0-9]$/ && $y =~ /^[0-9-]/ ) {
+        $path .= ",";
+    }
+    $path .= $y;
+}
+
+# Start of an element
+sub start_element( $% )
+{
+    my ( $element, %attr ) = @_;
+
+    push @levels, $element;
+
+    #print "element: $element\n";
+
+    if ( @levels > 1 && ( $levels[-2] eq "presetShapeDefinitons" ||
+			  $levels[-2] eq "presetTextWarpDefinitions" ) ) {
+        $shape_name = $element;
+
+        $state = "";
+        $ignore_this_shape = 0;
+        $path = "";
+        $adjust = "";
+        $max_adj_no = 0;
+        @formulas = ();
+        $handles = "";
+        $textboxrect = "";
+        $last_pos_x = "";
+        $last_pos_y = "";
+        $no_stroke = 0;
+        $no_fill = 0;
+        @quadratic_bezier = ();
+
+        setup_variables();
+
+        if ( $shape_name eq "sun" ) {
+            # hack for this shape
+            $variables{'100000'} = "21600";
+            $variables{'50000'} = "10800";
+            $variables{'25000'} = "5400";
+            $variables{'12500'} = "2700";
+            $variables{'3662'} = "791";
+        }
+
+        my $found = 0;
+        foreach my $name ( values( %shapes_ids ) ) {
+            if ( $name eq $shape_name ) {
+                $found = 1;
+                last;
+            }
+        }
+        if ( !$found ) {
+            error( "Unknown shape '$shape_name'." );
+        }
+    }
+    elsif ( $element eq "pathLst" ) {
+        $state = "path";
+    }
+    elsif ( $element eq "avLst" ) {
+        $state = "adjust";
+    }
+    elsif ( $element eq "gdLst" ) {
+        $state = "formulas";
+    }
+    elsif ( $element eq "ahLst" ) {
+        $state = "handles";
+    }
+    elsif ( $element eq "rect" ) {
+        $textboxrect = value( $attr{'l'} ) . "," . value( $attr{'t'} ) . "," .
+                       value( $attr{'r'} ) . "," . value( $attr{'b'} );
+    }
+    elsif ( $state eq "path" ) {
+        if ( $element eq "path" ) {
+            $no_stroke = ( defined( $attr{'stroke'} ) && $attr{'stroke'} eq 'false' );
+            $no_fill = ( defined( $attr{'fill'} ) && $attr{'fill'} eq 'none' );
+            $path_w = $attr{'w'};
+            $path_h = $attr{'h'};
+        }
+        elsif ( $element eq "moveTo" ) {
+            $path .= "m";
+        }
+        elsif ( $element eq "lnTo" ) {
+            $path .= "l";
+        }
+        elsif ( $element eq "cubicBezTo" ) {
+            $path .= "c";
+        }
+        elsif ( $element eq "quadBezTo" ) {
+            my %points = ( 'x' => $last_pos_x, 'y' => $last_pos_y );
+            @quadratic_bezier = ( \%points );
+        }
+        elsif ( $element eq "close" ) {
+            $path .= "x";
+        }
+        elsif ( $element eq "pt" ) {
+            # remember the last position for the arcTo
+            $last_pos_x = value( $attr{'x'} );
+            $last_pos_y = value( $attr{'y'} );
+
+            $last_pos_x *= ( value( 'w' ) / $path_w ) if ( defined( $path_w ) );
+            $last_pos_y *= ( value( 'h' ) / $path_h ) if ( defined( $path_h ) );
+
+            if ( $#quadratic_bezier >= 0 ) {
+                my %points = ( 'x' => $last_pos_x, 'y' => $last_pos_y );
+                push( @quadratic_bezier, \%points );
+            }
+            else {
+                add_point_to_path( $last_pos_x, $last_pos_y );
+            }
+        }
+        elsif ( ( $element eq "arcTo" ) && ( $last_pos_x ne "" ) && ( $last_pos_y ne "" ) ) {
+            # there's no exact equivalent of arcTo in VML, so we have to
+            # compute here a bit...
+            my $stAng = value( $attr{'stAng'} );
+            my $swAng = value( $attr{'swAng'} );
+            my $wR = value( $attr{'wR'} );
+            my $hR = value( $attr{'hR'} );
+
+            $wR *= ( value( 'w' ) / $path_w ) if ( defined( $path_w ) );
+            $hR *= ( value( 'h' ) / $path_h ) if ( defined( $path_h ) );
+
+            if ( ( $stAng =~ /^[0-9-]+$/ ) && ( $swAng =~ /^[0-9-]+$/ ) ) {
+                if ( ( ( $stAng % 90 ) == 0 ) && ( ( $swAng % 90 ) == 0 ) && ( $swAng != 0 ) ) {
+                    my $end = $stAng + $swAng;
+                    my $step = ( $swAng > 0 )? 90: -90;
+
+                    for ( my $cur = $stAng; $cur != $end; $cur += $step ) {
+                        elliptic_quadrant( $wR, $hR, ( $cur % 360 ), $step );
+                    }
+                }
+                else {
+                    error( "Unsupported numeric 'arcTo' ($attr{'wR'}, $attr{'hR'}, $stAng, $swAng)." );
+                }
+            }
+            else {
+                error( "Unsupported 'arcTo' conversion ($attr{'wR'}, $attr{'hR'}, $stAng, $swAng)." );
+            }
+        }
+        else {
+            error( "Unhandled path element '$element'." );
+        }
+    }
+    elsif ( $state eq "adjust" ) {
+        if ( $element eq "gd" ) {
+            my $adj_no = $attr{'name'};
+
+            # Save this adj number for this type for later use.
+            push(@{$adj_names{$shape_name}}, $adj_no);
+
+            my $is_const = 0;
+
+            $adj_no =~ s/^adj//;
+            if ( $adj_no eq "" ) {
+                $max_adj_no = 0;
+            }
+            elsif ( !( $adj_no =~ /^[0-9]*$/ ) ) {
+                ++$max_adj_no;
+                $is_const = 1;
+            }
+            elsif ( $adj_no != $max_adj_no + 1 ) {
+                error( "Wrong order of adj values." );
+                ++$max_adj_no;
+            }
+            else {
+                $max_adj_no = $adj_no;
+            }
+
+            if ( $attr{'fmla'} =~ /^val ([0-9-]*)$/ ) {
+                my $val = sprintf( "%.0f", ( 21600 * $1 ) / 100000 );
+                if ( $is_const ) {
+                    $variables{$adj_no} = $val;
+                }
+                elsif ( $adjust eq "" ) {
+                    $adjust = $val;
+                }
+                else {
+                    $adjust = "$val,$adjust";
+                }
+            }
+            else {
+                error( "Wrong fmla '$attr{'fmla'}'." );
+            }
+        }
+        else {
+            error( "Unhandled adjust element '$element'." );
+        }
+    }
+    elsif ( $state eq "formulas" ) {
+        if ( $element eq "gd" ) {
+            if ( $attr{'fmla'} =~ /^\*\/ (h|w|ss) adj([0-9]+) 100000$/ ) {
+                insert_formula( $attr{'name'}, "val #" . ( $max_adj_no - $2 ) );
+            }
+            elsif ( $attr{'fmla'} =~ /^pin [^ ]+ ([^ ]+) / ) {
+                print STDERR "TODO Map 'pin' to VML as xrange for handles.\n";
+                my $pin_val = $1;
+                if ( $pin_val eq "adj" ) {
+                    insert_formula( $attr{'name'}, "val #0" );
+                }
+                elsif ( $pin_val =~ /^adj([0-9]+)/ ) {
+                    insert_formula( $attr{'name'}, "val #" . ( $max_adj_no - $1 ) );
+                }
+                else {
+                    insert_formula( $attr{'name'}, "val " . value( $pin_val ) );
+                }
+            }
+            elsif ( $attr{'fmla'} =~ /adj/ ) {
+                error( "Non-standard usage of adj in '$attr{'fmla'}'." );
+            }
+            else {
+                convert_formula( $attr{'name'}, $attr{'fmla'} );
+            }
+        }
+    }
+    elsif ( $state eq "handles" ) {
+        if ( $element eq "pos" ) {
+            $handles .= "<v:h position=\"" . value( $attr{'x'} ) . "," . value( $attr{'y'} ) . "\"/>\n";
+        }
+    }
+}
+
+# End of an element
+sub end_element( $ )
+{
+    my ( $element ) = @_;
+
+    pop @levels;
+
+    if ( $element eq $shape_name ) {
+        if ( !$ignore_this_shape ) {
+            # we have all the info, generate the shape now
+            $state = "";
+
+            # shape path
+            my $out = "<v:shapetype id=\"shapetype___ID__\" coordsize=\"21600,21600\" o:spt=\"__ID__\" ";
+            if ( $adjust ne "" ) {
+                $out .= "adj=\"$adjust\" ";
+            }
+
+            # optimize it [yes, we need this twice ;-)]
+            $path =~ s/([^0-9-@])0([^0-9-@])/$1$2/g;
+            $path =~ s/([^0-9-@])0([^0-9-@])/$1$2/g;
+
+            $out .= "path=\"$path\">\n";
+
+            # stroke
+            $out .= "<v:stroke joinstyle=\"miter\"/>\n";
+
+            # formulas
+            if ( $#formulas >= 0 )
+            {
+                $out .= "<v:formulas>\n";
+                foreach my $fmla ( @formulas ) {
+                    $out .= "<v:f eqn=\"$fmla\"/>\n"
+                }
+                $out .= "</v:formulas>\n";
+            }
+
+            # path
+            if ( $textboxrect ne "" ) { # TODO connectlocs, connectangles
+                $out .= "<v:path gradientshapeok=\"t\" o:connecttype=\"rect\" textboxrect=\"$textboxrect\"/>\n";
+            }
+
+            # handles
+            if ( $handles ne "" ) {
+                $out .= "<v:handles>\n$handles</v:handles>\n";
+            }
+
+            $out .="</v:shapetype>";
+
+            # hooray! :-)
+            $result_shapes{$shape_name} = $out;
+        }
+        else {
+            print STDERR "Shape '$shape_name' ignored; see the above error(s) for the reason.\n";
+        }
+        $shape_name = "";
+    }
+    elsif ( $state eq "path" ) {
+        if ( $element eq "path" ) {
+            $path .= "ns" if ( $no_stroke );
+            $path .= "nf" if ( $no_fill );
+            $path .= "e";
+        }
+        elsif ( $element eq "quadBezTo" ) {
+            # we have to convert the quadratic bezier to cubic
+            if ( $#quadratic_bezier == 2 ) {
+                my @points_x = quadratic_to_cubic_bezier( 'x' );
+                my @points_y = quadratic_to_cubic_bezier( 'y' );
+
+                $path .= "c";
+                # ignore the starting point
+                for ( my $i = 1; $i < 4; ++$i ) {
+                    add_point_to_path( $points_x[$i], $points_y[$i] );
+                }
+            }
+            else {
+                error( "Wrong number of points of the quadratic bezier." );
+            }
+            @quadratic_bezier = ();
+        }
+    }
+    elsif ( $element eq "avLst" ) {
+        $state = "";
+    }
+    elsif ( $element eq "gdLst" ) {
+        $state = "";
+    }
+    elsif ( $element eq "ahLst" ) {
+        $state = "";
+    }
+}
+
+# Text inside an element
+sub characters( $ )
+{
+    #my ( $text ) = @_;
+}
+
+#################### A trivial XML parser ####################
+
+# Parse the attributes
+sub parse_start_element( $ )
+{
+    # split the string containing both the elements and attributes
+    my ( $element_tmp ) = @_;
+
+    $element_tmp =~ s/\s*$//;
+    $element_tmp =~ s/^\s*//;
+
+    ( my $element = $element_tmp ) =~ s/\s.*$//;
+    if ( $element_tmp =~ /\s/ ) {
+        $element_tmp =~ s/^[^\s]*\s//;
+    }
+    else {
+        $element_tmp = "";
+    }
+
+    # we have the element, now the attributes
+    my %attr;
+    my $is_key = 1;
+    my $key = "";
+    foreach my $tmp ( split( /"/, $element_tmp ) ) {
+        if ( $is_key ) {
+            $key = $tmp;
+            $key =~ s/^\s*//;
+            $key =~ s/\s*=\s*$//;
+        }
+        else {
+            $attr{$key} = $tmp;
+        }
+        $is_key = !$is_key;
+    }
+
+    if ( $element ne "" ) {
+        start_element( $element, %attr );
+    }
+}
+
+# Parse the file
+sub parse( $ )
+{
+    my ( $file ) = @_;
+
+    my $in_comment = 0;
+    my $line = "";
+    while (<$file>) {
+        # ignore comments
+        s/<\?[^>]*\?>//g;
+        s/<!--[^>]*-->//g;
+        if ( /<!--/ ) {
+            $in_comment = 1;
+            s/<!--.*//;
+        }
+        elsif ( /-->/ && $in_comment ) {
+            $in_comment = 0;
+            s/.*-->//;
+        }
+        elsif ( $in_comment ) {
+            next;
+        }
+        # ignore empty lines
+        chomp;
+        s/^\s*//;
+        s/\s*$//;
+        next if ( $_ eq "" );
+
+        # take care of lines where element continues
+        if ( $line ne "" ) {
+            $line .= " " . $_;
+        }
+        else {
+            $line = $_;
+        }
+        next if ( !/>$/ );
+
+        # the actual parsing
+        my @starts = split( /</, $line );
+        $line = "";
+        foreach my $start ( @starts ) {
+            next if ( $start eq "" );
+
+            my @ends = split( />/, $start );
+            my $element = $ends[0];
+            my $data = $ends[1];
+
+            # start or end element
+            if ( $element =~ /^\/(.*)/ ) {
+                end_element( $1 );
+            }
+            elsif ( $element =~ /^(.*)\/$/ ) {
+                parse_start_element( $1 );
+                ( my $end = $1 ) =~ s/\s.*$//;
+                end_element( $end );
+            }
+            else {
+                parse_start_element( $element );
+            }
+
+            # the data
+            characters( $data ) if ( defined( $data ) && $data ne "" );
+        }
+    }
+}
+
+# Do the real work
+my $file;
+open( $file, "<$src_shapes" ) || die "Cannot open $src_shapes: $!";
+parse( $file );
+close( $file );
+
+open( $file, "<$src_text" ) || die "Cannot open $src_text: $!";
+parse( $file );
+close( $file );
+
+if ( !defined( $result_shapes{'textBox'} ) ) {
+    # tdf#114842 shapetype id of the textbox, must be the same as defined
+    $result_shapes{'textBox'} =
+        "<v:shapetype id=\"_x0000_t__ID__\" coordsize=\"21600,21600\" " .
+        "o:spt=\"__ID__\" path=\"m,l,21600l21600,21600l21600,xe\">\n" .
+        "<v:stroke joinstyle=\"miter\"/>\n" .
+        "<v:path gradientshapeok=\"t\" o:connecttype=\"rect\"/>\n" .
+        "</v:shapetype>";
+}
+
+# Generate the data
+if ($drawingml_adj_names_data eq 1) {
+    foreach my $adj_name (sort(keys %adj_names))
+    {
+        foreach my $adj (@{$adj_names{$adj_name}})
+        {
+            print "$adj_name\t$adj\n";
+        }
+    }
+    exit 0;
+} elsif ($vml_shape_types_data eq 1) {
+    for ( my $i = 0; $i < 203; ++$i ) {
+        if ( $i < 4 ) {
+            print "/* $i - $shapes_ids{$i} - handled separately */\nNULL\n";
+        }
+        else {
+            print "/* $i - $shapes_ids{$i} */\n";
+            my $out = $result_shapes{$shapes_ids{$i}};
+            if ( defined( $out ) ) {
+                # set the id
+                $out =~ s/__ID__/$i/g;
+
+                # output as string
+                $out =~ s/\n//g;
+
+                print "$out\n";
+            }
+            else {
+                print "NULL\n";
+            }
+        }
+    }
+    exit 0;
+}
+
+# should not happen
+exit 1;
+
+# vim:set ft=perl shiftwidth=4 softtabstop=4 expandtab: #
diff --git a/oox/source/export/presetTextWarpDefinitions.xml b/oox/source/export/presetTextWarpDefinitions.xml
new file mode 100644
index 000000000..e5f0c4f88
--- /dev/null
+++ b/oox/source/export/presetTextWarpDefinitions.xml
@@ -0,0 +1,1902 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!--
+ * 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 .
+ -->
+<presetTextWarpDefinitions>
+  <textArchDown>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 0"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adval" fmla="pin 0 adj 21599999"/>
+      <gd name="v1" fmla="+- 10800000 0 adval"/>
+      <gd name="v2" fmla="+- 32400000 0 adval"/>
+      <gd name="nv1" fmla="+- 0 0 v1"/>
+      <gd name="stAng" fmla="?: nv1 v2 v1"/>
+      <gd name="w1" fmla="+- 5400000 0 adval"/>
+      <gd name="w2" fmla="+- 16200000 0 adval"/>
+      <gd name="d1" fmla="+- adval 0 stAng"/>
+      <gd name="d2" fmla="+- d1 0 21600000"/>
+      <gd name="v3" fmla="+- 0 0 10800000"/>
+      <gd name="c2" fmla="?: w2 d1 d2"/>
+      <gd name="c1" fmla="?: v1 d2 c2"/>
+      <gd name="c0" fmla="?: w1 d1 c1"/>
+      <gd name="swAng" fmla="?: stAng c0 v3"/>
+      <gd name="wt1" fmla="sin wd2 adj"/>
+      <gd name="ht1" fmla="cos hd2 adj"/>
+      <gd name="dx1" fmla="cat2 wd2 ht1 wt1"/>
+      <gd name="dy1" fmla="sat2 hd2 ht1 wt1"/>
+      <gd name="x1" fmla="+- hc dx1 0"/>
+      <gd name="y1" fmla="+- vc dy1 0"/>
+      <gd name="wt2" fmla="sin wd2 stAng"/>
+      <gd name="ht2" fmla="cos hd2 stAng"/>
+      <gd name="dx2" fmla="cat2 wd2 ht2 wt2"/>
+      <gd name="dy2" fmla="sat2 hd2 ht2 wt2"/>
+      <gd name="x2" fmla="+- hc dx2 0"/>
+      <gd name="y2" fmla="+- vc dy2 0"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahPolar gdRefAng="adj" minAng="0" maxAng="21599999">
+        <pos x="x1" y="y1"/>
+      </ahPolar>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="x2" y="y2"/>
+        </moveTo>
+        <arcTo wR="wd2" hR="hd2" stAng="stAng" swAng="swAng"/>
+      </path>
+    </pathLst>
+  </textArchDown>
+  <textArchDownPour>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj1" fmla="val 0"/>
+      <gd name="adj2" fmla="val 25000"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adval" fmla="pin 0 adj1 21599999"/>
+      <gd name="v1" fmla="+- 10800000 0 adval"/>
+      <gd name="v2" fmla="+- 32400000 0 adval"/>
+      <gd name="nv1" fmla="+- 0 0 v1"/>
+      <gd name="stAng" fmla="?: nv1 v2 v1"/>
+      <gd name="w1" fmla="+- 5400000 0 adval"/>
+      <gd name="w2" fmla="+- 16200000 0 adval"/>
+      <gd name="d1" fmla="+- adval 0 stAng"/>
+      <gd name="d2" fmla="+- d1 0 21600000"/>
+      <gd name="v3" fmla="+- 0 0 10800000"/>
+      <gd name="c2" fmla="?: w2 d1 d2"/>
+      <gd name="c1" fmla="?: v1 d2 c2"/>
+      <gd name="c0" fmla="?: w1 d1 c1"/>
+      <gd name="swAng" fmla="?: stAng c0 v3"/>
+      <gd name="wt1" fmla="sin wd2 stAng"/>
+      <gd name="ht1" fmla="cos hd2 stAng"/>
+      <gd name="dx1" fmla="cat2 wd2 ht1 wt1"/>
+      <gd name="dy1" fmla="sat2 hd2 ht1 wt1"/>
+      <gd name="x1" fmla="+- hc dx1 0"/>
+      <gd name="y1" fmla="+- vc dy1 0"/>
+      <gd name="adval2" fmla="pin 0 adj2 99000"/>
+      <gd name="ratio" fmla="*/ adval2 1 100000"/>
+      <gd name="iwd2" fmla="*/ wd2 ratio 1"/>
+      <gd name="ihd2" fmla="*/ hd2 ratio 1"/>
+      <gd name="wt2" fmla="sin iwd2 adval"/>
+      <gd name="ht2" fmla="cos ihd2 adval"/>
+      <gd name="dx2" fmla="cat2 iwd2 ht2 wt2"/>
+      <gd name="dy2" fmla="sat2 ihd2 ht2 wt2"/>
+      <gd name="x2" fmla="+- hc dx2 0"/>
+      <gd name="y2" fmla="+- vc dy2 0"/>
+      <gd name="wt3" fmla="sin iwd2 stAng"/>
+      <gd name="ht3" fmla="cos ihd2 stAng"/>
+      <gd name="dx3" fmla="cat2 iwd2 ht3 wt3"/>
+      <gd name="dy3" fmla="sat2 ihd2 ht3 wt3"/>
+      <gd name="x3" fmla="+- hc dx3 0"/>
+      <gd name="y3" fmla="+- vc dy3 0"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahPolar gdRefR="adj2" minR="0" maxR="100000" gdRefAng="adj1" minAng="0" maxAng="21599999">
+        <pos x="x2" y="y2"/>
+      </ahPolar>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="x3" y="y3"/>
+        </moveTo>
+        <arcTo wR="iwd2" hR="ihd2" stAng="stAng" swAng="swAng"/>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="x1" y="y1"/>
+        </moveTo>
+        <arcTo wR="wd2" hR="hd2" stAng="stAng" swAng="swAng"/>
+      </path>
+    </pathLst>
+  </textArchDownPour>
+  <textArchUp>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val cd2"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adval" fmla="pin 0 adj 21599999"/>
+      <gd name="v1" fmla="+- 10800000 0 adval"/>
+      <gd name="v2" fmla="+- 32400000 0 adval"/>
+      <gd name="end" fmla="?: v1 v1 v2"/>
+      <gd name="w1" fmla="+- 5400000 0 adval"/>
+      <gd name="w2" fmla="+- 16200000 0 adval"/>
+      <gd name="d1" fmla="+- end 0 adval"/>
+      <gd name="d2" fmla="+- 21600000 d1 0"/>
+      <gd name="c2" fmla="?: w2 d1 d2"/>
+      <gd name="c1" fmla="?: v1 d2 c2"/>
+      <gd name="swAng" fmla="?: w1 d1 c1"/>
+      <gd name="wt1" fmla="sin wd2 adj"/>
+      <gd name="ht1" fmla="cos hd2 adj"/>
+      <gd name="dx1" fmla="cat2 wd2 ht1 wt1"/>
+      <gd name="dy1" fmla="sat2 hd2 ht1 wt1"/>
+      <gd name="x1" fmla="+- hc dx1 0"/>
+      <gd name="y1" fmla="+- vc dy1 0"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahPolar gdRefAng="adj" minAng="0" maxAng="21599999">
+        <pos x="x1" y="y1"/>
+      </ahPolar>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="x1" y="y1"/>
+        </moveTo>
+        <arcTo wR="wd2" hR="hd2" stAng="adval" swAng="swAng"/>
+      </path>
+    </pathLst>
+  </textArchUp>
+  <textArchUpPour>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj1" fmla="val cd2"/>
+      <gd name="adj2" fmla="val 50000"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adval" fmla="pin 0 adj1 21599999"/>
+      <gd name="v1" fmla="+- 10800000 0 adval"/>
+      <gd name="v2" fmla="+- 32400000 0 adval"/>
+      <gd name="end" fmla="?: v1 v1 v2"/>
+      <gd name="w1" fmla="+- 5400000 0 adval"/>
+      <gd name="w2" fmla="+- 16200000 0 adval"/>
+      <gd name="d1" fmla="+- end 0 adval"/>
+      <gd name="d2" fmla="+- 21600000 d1 0"/>
+      <gd name="c2" fmla="?: w2 d1 d2"/>
+      <gd name="c1" fmla="?: v1 d2 c2"/>
+      <gd name="swAng" fmla="?: w1 d1 c1"/>
+      <gd name="wt1" fmla="sin wd2 adval"/>
+      <gd name="ht1" fmla="cos hd2 adval"/>
+      <gd name="dx1" fmla="cat2 wd2 ht1 wt1"/>
+      <gd name="dy1" fmla="sat2 hd2 ht1 wt1"/>
+      <gd name="x1" fmla="+- hc dx1 0"/>
+      <gd name="y1" fmla="+- vc dy1 0"/>
+      <gd name="adval2" fmla="pin 0 adj2 99000"/>
+      <gd name="ratio" fmla="*/ adval2 1 100000"/>
+      <gd name="iwd2" fmla="*/ wd2 ratio 1"/>
+      <gd name="ihd2" fmla="*/ hd2 ratio 1"/>
+      <gd name="wt2" fmla="sin iwd2 adval"/>
+      <gd name="ht2" fmla="cos ihd2 adval"/>
+      <gd name="dx2" fmla="cat2 iwd2 ht2 wt2"/>
+      <gd name="dy2" fmla="sat2 ihd2 ht2 wt2"/>
+      <gd name="x2" fmla="+- hc dx2 0"/>
+      <gd name="y2" fmla="+- vc dy2 0"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahPolar gdRefR="adj2" minR="0" maxR="100000" gdRefAng="adj1" minAng="0" maxAng="21599999">
+        <pos x="x2" y="y2"/>
+      </ahPolar>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="x1" y="y1"/>
+        </moveTo>
+        <arcTo wR="wd2" hR="hd2" stAng="adval" swAng="swAng"/>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="x2" y="y2"/>
+        </moveTo>
+        <arcTo wR="iwd2" hR="ihd2" stAng="adval" swAng="swAng"/>
+      </path>
+    </pathLst>
+  </textArchUpPour>
+  <textButton>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 10800000"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adval" fmla="pin 0 adj 21599999"/>
+      <gd name="bot" fmla="+- 5400000 0 adval"/>
+      <gd name="lef" fmla="+- 10800000 0 adval"/>
+      <gd name="top" fmla="+- 16200000 0 adval"/>
+      <gd name="rig" fmla="+- 21600000 0 adval"/>
+      <gd name="c3" fmla="?: top adval 0"/>
+      <gd name="c2" fmla="?: lef 10800000 c3"/>
+      <gd name="c1" fmla="?: bot rig c2"/>
+      <gd name="stAng" fmla="?: adval c1 0"/>
+      <gd name="w1" fmla="+- 21600000 0 stAng"/>
+      <gd name="stAngB" fmla="?: stAng w1 0"/>
+      <gd name="td1" fmla="*/ bot 2 1"/>
+      <gd name="td2" fmla="*/ top 2 1"/>
+      <gd name="ntd2" fmla="+- 0 0 td2"/>
+      <gd name="w2" fmla="+- 0 0 10800000"/>
+      <gd name="c6" fmla="?: top ntd2 w2"/>
+      <gd name="c5" fmla="?: lef 10800000 c6"/>
+      <gd name="c4" fmla="?: bot td1 c5"/>
+      <gd name="v1" fmla="?: adval c4 10800000"/>
+      <gd name="swAngT" fmla="+- 0 0 v1"/>
+      <gd name="stT" fmla="?: lef stAngB stAng"/>
+      <gd name="stB" fmla="?: lef stAng stAngB"/>
+      <gd name="swT" fmla="?: lef v1 swAngT"/>
+      <gd name="swB" fmla="?: lef swAngT v1"/>
+      <gd name="wt1" fmla="sin wd2 stT"/>
+      <gd name="ht1" fmla="cos hd2 stT"/>
+      <gd name="dx1" fmla="cat2 wd2 ht1 wt1"/>
+      <gd name="dy1" fmla="sat2 hd2 ht1 wt1"/>
+      <gd name="x1" fmla="+- hc dx1 0"/>
+      <gd name="y1" fmla="+- vc dy1 0"/>
+      <gd name="wt2" fmla="sin wd2 stB"/>
+      <gd name="ht2" fmla="cos hd2 stB"/>
+      <gd name="dx2" fmla="cat2 wd2 ht2 wt2"/>
+      <gd name="dy2" fmla="sat2 hd2 ht2 wt2"/>
+      <gd name="x2" fmla="+- hc dx2 0"/>
+      <gd name="y2" fmla="+- vc dy2 0"/>
+      <gd name="wt3" fmla="sin wd2 adj"/>
+      <gd name="ht3" fmla="cos hd2 adj"/>
+      <gd name="dx3" fmla="cat2 wd2 ht3 wt3"/>
+      <gd name="dy3" fmla="sat2 hd2 ht3 wt3"/>
+      <gd name="x3" fmla="+- hc dx3 0"/>
+      <gd name="y3" fmla="+- vc dy3 0"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahPolar gdRefAng="adj" minAng="0" maxAng="21599999">
+        <pos x="x3" y="y3"/>
+      </ahPolar>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="x1" y="y1"/>
+        </moveTo>
+        <arcTo wR="wd2" hR="hd2" stAng="stT" swAng="swT"/>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="vc"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="vc"/>
+        </lnTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="x2" y="y2"/>
+        </moveTo>
+        <arcTo wR="wd2" hR="hd2" stAng="stB" swAng="swB"/>
+      </path>
+    </pathLst>
+  </textButton>
+  <textButtonPour>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj1" fmla="val cd2"/>
+      <gd name="adj2" fmla="val 50000"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adval" fmla="pin 0 adj1 21599999"/>
+      <gd name="bot" fmla="+- 5400000 0 adval"/>
+      <gd name="lef" fmla="+- 10800000 0 adval"/>
+      <gd name="top" fmla="+- 16200000 0 adval"/>
+      <gd name="rig" fmla="+- 21600000 0 adval"/>
+      <gd name="c3" fmla="?: top adval 0"/>
+      <gd name="c2" fmla="?: lef 10800000 c3"/>
+      <gd name="c1" fmla="?: bot rig c2"/>
+      <gd name="stAng" fmla="?: adval c1 0"/>
+      <gd name="w1" fmla="+- 21600000 0 stAng"/>
+      <gd name="stAngB" fmla="?: stAng w1 0"/>
+      <gd name="td1" fmla="*/ bot 2 1"/>
+      <gd name="td2" fmla="*/ top 2 1"/>
+      <gd name="ntd2" fmla="+- 0 0 td2"/>
+      <gd name="w2" fmla="+- 0 0 10800000"/>
+      <gd name="c6" fmla="?: top ntd2 w2"/>
+      <gd name="c5" fmla="?: lef 10800000 c6"/>
+      <gd name="c4" fmla="?: bot td1 c5"/>
+      <gd name="v1" fmla="?: adval c4 10800000"/>
+      <gd name="swAngT" fmla="+- 0 0 v1"/>
+      <gd name="stT" fmla="?: lef stAngB stAng"/>
+      <gd name="stB" fmla="?: lef stAng stAngB"/>
+      <gd name="swT" fmla="?: lef v1 swAngT"/>
+      <gd name="swB" fmla="?: lef swAngT v1"/>
+      <gd name="wt1" fmla="sin wd2 stT"/>
+      <gd name="ht1" fmla="cos hd2 stT"/>
+      <gd name="dx1" fmla="cat2 wd2 ht1 wt1"/>
+      <gd name="dy1" fmla="sat2 hd2 ht1 wt1"/>
+      <gd name="x1" fmla="+- hc dx1 0"/>
+      <gd name="y1" fmla="+- vc dy1 0"/>
+      <gd name="wt6" fmla="sin wd2 stB"/>
+      <gd name="ht6" fmla="cos hd2 stB"/>
+      <gd name="dx6" fmla="cat2 wd2 ht6 wt6"/>
+      <gd name="dy6" fmla="sat2 hd2 ht6 wt6"/>
+      <gd name="x6" fmla="+- hc dx6 0"/>
+      <gd name="y6" fmla="+- vc dy6 0"/>
+      <gd name="adval2" fmla="pin 40000 adj2 99000"/>
+      <gd name="ratio" fmla="*/ adval2 1 100000"/>
+      <gd name="iwd2" fmla="*/ wd2 ratio 1"/>
+      <gd name="ihd2" fmla="*/ hd2 ratio 1"/>
+      <gd name="wt2" fmla="sin iwd2 stT"/>
+      <gd name="ht2" fmla="cos ihd2 stT"/>
+      <gd name="dx2" fmla="cat2 iwd2 ht2 wt2"/>
+      <gd name="dy2" fmla="sat2 ihd2 ht2 wt2"/>
+      <gd name="x2" fmla="+- hc dx2 0"/>
+      <gd name="y2" fmla="+- vc dy2 0"/>
+      <gd name="wt5" fmla="sin iwd2 stB"/>
+      <gd name="ht5" fmla="cos ihd2 stB"/>
+      <gd name="dx5" fmla="cat2 iwd2 ht5 wt5"/>
+      <gd name="dy5" fmla="sat2 ihd2 ht5 wt5"/>
+      <gd name="x5" fmla="+- hc dx5 0"/>
+      <gd name="y5" fmla="+- vc dy5 0"/>
+      <gd name="d1" fmla="+- hd2 0 ihd2"/>
+      <gd name="d12" fmla="*/ d1 1 2"/>
+      <gd name="yu" fmla="+- vc 0 d12"/>
+      <gd name="yd" fmla="+- vc d12 0"/>
+      <gd name="v1" fmla="*/ d12 d12 1"/>
+      <gd name="v2" fmla="*/ ihd2 ihd2 1"/>
+      <gd name="v3" fmla="*/ v1 1 v2"/>
+      <gd name="v4" fmla="+- 1 0 v3"/>
+      <gd name="v5" fmla="*/ iwd2 iwd2 1"/>
+      <gd name="v6" fmla="*/ v4 v5 1"/>
+      <gd name="v7" fmla="sqrt v6"/>
+      <gd name="xl" fmla="+- hc 0 v7"/>
+      <gd name="xr" fmla="+- hc v7 0"/>
+      <gd name="wtadj" fmla="sin iwd2 adj1"/>
+      <gd name="htadj" fmla="cos ihd2 adj1"/>
+      <gd name="dxadj" fmla="cat2 iwd2 htadj wtadj"/>
+      <gd name="dyadj" fmla="sat2 ihd2 htadj wtadj"/>
+      <gd name="xadj" fmla="+- hc dxadj 0"/>
+      <gd name="yadj" fmla="+- vc dyadj 0"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahPolar gdRefR="adj2" minR="0" maxR="100000" gdRefAng="adj1" minAng="0" maxAng="21599999">
+        <pos x="xadj" y="yadj"/>
+      </ahPolar>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="x1" y="y1"/>
+        </moveTo>
+        <arcTo wR="wd2" hR="hd2" stAng="stT" swAng="swT"/>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="x2" y="y2"/>
+        </moveTo>
+        <arcTo wR="iwd2" hR="ihd2" stAng="stT" swAng="swT"/>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="xl" y="yu"/>
+        </moveTo>
+        <lnTo>
+          <pt x="xr" y="yu"/>
+        </lnTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="xl" y="yd"/>
+        </moveTo>
+        <lnTo>
+          <pt x="xr" y="yd"/>
+        </lnTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="x5" y="y5"/>
+        </moveTo>
+        <arcTo wR="iwd2" hR="ihd2" stAng="stB" swAng="swB"/>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="x6" y="y6"/>
+        </moveTo>
+        <arcTo wR="wd2" hR="hd2" stAng="stB" swAng="swB"/>
+      </path>
+    </pathLst>
+  </textButtonPour>
+  <textCanDown>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 14286"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 0 adj 33333"/>
+      <gd name="dy" fmla="*/ a h 100000"/>
+      <gd name="y0" fmla="+- t dy 0"/>
+      <gd name="y1" fmla="+- b 0 dy"/>
+      <gd name="ncd2" fmla="*/ cd2 -1 1"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="0" maxY="33333">
+        <pos x="hc" y="y0"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="t"/>
+        </moveTo>
+        <arcTo wR="wd2" hR="dy" stAng="cd2" swAng="ncd2"/>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="y1"/>
+        </moveTo>
+        <arcTo wR="wd2" hR="dy" stAng="cd2" swAng="ncd2"/>
+      </path>
+    </pathLst>
+  </textCanDown>
+  <textCanUp>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 85714"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 66667 adj 100000"/>
+      <gd name="dy1" fmla="*/ a h 100000"/>
+      <gd name="dy" fmla="+- h 0 dy1"/>
+      <gd name="y0" fmla="+- t dy1 0"/>
+      <gd name="y1" fmla="+- t dy 0"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="66667" maxY="100000">
+        <pos x="hc" y="y0"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="y1"/>
+        </moveTo>
+        <arcTo wR="wd2" hR="dy" stAng="cd2" swAng="cd2"/>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="b"/>
+        </moveTo>
+        <arcTo wR="wd2" hR="dy" stAng="cd2" swAng="cd2"/>
+      </path>
+    </pathLst>
+  </textCanUp>
+  <textCascadeDown>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 44444"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 28570 adj 100000"/>
+      <gd name="dy" fmla="*/ a h 100000"/>
+      <gd name="y1" fmla="+- t dy 0"/>
+      <gd name="dy2" fmla="+- h 0 dy"/>
+      <gd name="dy3" fmla="*/ dy2 1 4"/>
+      <gd name="y2" fmla="+- t dy3 0"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="28570" maxY="100000">
+        <pos x="l" y="y1"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="t"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="y2"/>
+        </lnTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="y1"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="b"/>
+        </lnTo>
+      </path>
+    </pathLst>
+  </textCascadeDown>
+  <textCascadeUp>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 44444"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 28570 adj 100000"/>
+      <gd name="dy" fmla="*/ a h 100000"/>
+      <gd name="y1" fmla="+- t dy 0"/>
+      <gd name="dy2" fmla="+- h 0 dy"/>
+      <gd name="dy3" fmla="*/ dy2 1 4"/>
+      <gd name="y2" fmla="+- t dy3 0"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="28570" maxY="100000">
+        <pos x="r" y="y1"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="y2"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="t"/>
+        </lnTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="b"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="y1"/>
+        </lnTo>
+      </path>
+    </pathLst>
+  </textCascadeUp>
+  <textChevron>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 25000"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 0 adj 50000"/>
+      <gd name="y" fmla="*/ a h 100000"/>
+      <gd name="y1" fmla="+- t b y"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="0" maxY="50000">
+        <pos x="l" y="y"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="y"/>
+        </moveTo>
+        <lnTo>
+          <pt x="hc" y="t"/>
+        </lnTo>
+        <lnTo>
+          <pt x="r" y="y"/>
+        </lnTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="b"/>
+        </moveTo>
+        <lnTo>
+          <pt x="hc" y="y1"/>
+        </lnTo>
+        <lnTo>
+          <pt x="r" y="b"/>
+        </lnTo>
+      </path>
+    </pathLst>
+  </textChevron>
+  <textChevronInverted>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 75000"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 50000 adj 100000"/>
+      <gd name="y" fmla="*/ a h 100000"/>
+      <gd name="y1" fmla="+- b 0 y"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="50000" maxY="100000">
+        <pos x="l" y="y"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="t"/>
+        </moveTo>
+        <lnTo>
+          <pt x="hc" y="y1"/>
+        </lnTo>
+        <lnTo>
+          <pt x="r" y="t"/>
+        </lnTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="y"/>
+        </moveTo>
+        <lnTo>
+          <pt x="hc" y="b"/>
+        </lnTo>
+        <lnTo>
+          <pt x="r" y="y"/>
+        </lnTo>
+      </path>
+    </pathLst>
+  </textChevronInverted>
+  <textCircle>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 10800000"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adval" fmla="pin 0 adj 21599999"/>
+      <gd name="d0" fmla="+- adval 0 10800000"/>
+      <gd name="d1" fmla="+- 10800000 0 adval"/>
+      <gd name="d2" fmla="+- 21600000 0 adval"/>
+      <gd name="d3" fmla="?: d1 d1 10799999"/>
+      <gd name="d4" fmla="?: d0 d2 d3"/>
+      <gd name="swAng" fmla="*/ d4 2 1"/>
+      <gd name="wt1" fmla="sin wd2 adj"/>
+      <gd name="ht1" fmla="cos hd2 adj"/>
+      <gd name="dx1" fmla="cat2 wd2 ht1 wt1"/>
+      <gd name="dy1" fmla="sat2 hd2 ht1 wt1"/>
+      <gd name="x1" fmla="+- hc dx1 0"/>
+      <gd name="y1" fmla="+- vc dy1 0"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahPolar gdRefAng="adj" minAng="0" maxAng="21599999">
+        <pos x="x1" y="y1"/>
+      </ahPolar>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="x1" y="y1"/>
+        </moveTo>
+        <arcTo wR="wd2" hR="hd2" stAng="adval" swAng="swAng"/>
+      </path>
+    </pathLst>
+  </textCircle>
+  <textCirclePour>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj1" fmla="val cd2"/>
+      <gd name="adj2" fmla="val 50000"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adval" fmla="pin 0 adj1 21599999"/>
+      <gd name="d0" fmla="+- adval 0 10800000"/>
+      <gd name="d1" fmla="+- 10800000 0 adval"/>
+      <gd name="d2" fmla="+- 21600000 0 adval"/>
+      <gd name="d3" fmla="?: d1 d1 10799999"/>
+      <gd name="d4" fmla="?: d0 d2 d3"/>
+      <gd name="swAng" fmla="*/ d4 2 1"/>
+      <gd name="wt1" fmla="sin wd2 adval"/>
+      <gd name="ht1" fmla="cos hd2 adval"/>
+      <gd name="dx1" fmla="cat2 wd2 ht1 wt1"/>
+      <gd name="dy1" fmla="sat2 hd2 ht1 wt1"/>
+      <gd name="x1" fmla="+- hc dx1 0"/>
+      <gd name="y1" fmla="+- vc dy1 0"/>
+      <gd name="adval2" fmla="pin 0 adj2 99000"/>
+      <gd name="ratio" fmla="*/ adval2 1 100000"/>
+      <gd name="iwd2" fmla="*/ wd2 ratio 1"/>
+      <gd name="ihd2" fmla="*/ hd2 ratio 1"/>
+      <gd name="wt2" fmla="sin iwd2 adval"/>
+      <gd name="ht2" fmla="cos ihd2 adval"/>
+      <gd name="dx2" fmla="cat2 iwd2 ht2 wt2"/>
+      <gd name="dy2" fmla="sat2 ihd2 ht2 wt2"/>
+      <gd name="x2" fmla="+- hc dx2 0"/>
+      <gd name="y2" fmla="+- vc dy2 0"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahPolar gdRefR="adj2" minR="0" maxR="100000" gdRefAng="adj1" minAng="0" maxAng="21599999">
+        <pos x="x2" y="y2"/>
+      </ahPolar>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="x1" y="y1"/>
+        </moveTo>
+        <arcTo wR="wd2" hR="hd2" stAng="adval" swAng="swAng"/>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="x2" y="y2"/>
+        </moveTo>
+        <arcTo wR="iwd2" hR="ihd2" stAng="adval" swAng="swAng"/>
+      </path>
+    </pathLst>
+  </textCirclePour>
+  <textCurveDown>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 45977"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 0 adj 56338"/>
+      <gd name="dy" fmla="*/ a h 100000"/>
+      <gd name="gd1" fmla="*/ dy 3 4"/>
+      <gd name="gd2" fmla="*/ dy 5 4"/>
+      <gd name="gd3" fmla="*/ dy 3 8"/>
+      <gd name="gd4" fmla="*/ dy 1 8"/>
+      <gd name="gd5" fmla="+- h 0 gd3"/>
+      <gd name="gd6" fmla="+- gd4 h 0"/>
+      <gd name="y0" fmla="+- t dy 0"/>
+      <gd name="y1" fmla="+- t gd1 0"/>
+      <gd name="y2" fmla="+- t gd2 0"/>
+      <gd name="y3" fmla="+- t gd3 0"/>
+      <gd name="y4" fmla="+- t gd4 0"/>
+      <gd name="y5" fmla="+- t gd5 0"/>
+      <gd name="y6" fmla="+- t gd6 0"/>
+      <gd name="x1" fmla="+- l wd3 0"/>
+      <gd name="x2" fmla="+- r 0 wd3"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="0" maxY="56338">
+        <pos x="r" y="y0"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="t"/>
+        </moveTo>
+        <cubicBezTo>
+          <pt x="x1" y="y1"/>
+          <pt x="x2" y="y2"/>
+          <pt x="r" y="y0"/>
+        </cubicBezTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="y5"/>
+        </moveTo>
+        <cubicBezTo>
+          <pt x="x1" y="y6"/>
+          <pt x="x2" y="y6"/>
+          <pt x="r" y="y5"/>
+        </cubicBezTo>
+      </path>
+    </pathLst>
+  </textCurveDown>
+  <textCurveUp>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 45977"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 0 adj 56338"/>
+      <gd name="dy" fmla="*/ a h 100000"/>
+      <gd name="gd1" fmla="*/ dy 3 4"/>
+      <gd name="gd2" fmla="*/ dy 5 4"/>
+      <gd name="gd3" fmla="*/ dy 3 8"/>
+      <gd name="gd4" fmla="*/ dy 1 8"/>
+      <gd name="gd5" fmla="+- h 0 gd3"/>
+      <gd name="gd6" fmla="+- gd4 h 0"/>
+      <gd name="y0" fmla="+- t dy 0"/>
+      <gd name="y1" fmla="+- t gd1 0"/>
+      <gd name="y2" fmla="+- t gd2 0"/>
+      <gd name="y3" fmla="+- t gd3 0"/>
+      <gd name="y4" fmla="+- t gd4 0"/>
+      <gd name="y5" fmla="+- t gd5 0"/>
+      <gd name="y6" fmla="+- t gd6 0"/>
+      <gd name="x1" fmla="+- l wd3 0"/>
+      <gd name="x2" fmla="+- r 0 wd3"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="0" maxY="56338">
+        <pos x="l" y="y0"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="y0"/>
+        </moveTo>
+        <cubicBezTo>
+          <pt x="x1" y="y2"/>
+          <pt x="x2" y="y1"/>
+          <pt x="r" y="t"/>
+        </cubicBezTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="y5"/>
+        </moveTo>
+        <cubicBezTo>
+          <pt x="x1" y="y6"/>
+          <pt x="x2" y="y6"/>
+          <pt x="r" y="y5"/>
+        </cubicBezTo>
+      </path>
+    </pathLst>
+  </textCurveUp>
+  <textDeflate>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 18750"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 0 adj 37500"/>
+      <gd name="dy" fmla="*/ a ss 100000"/>
+      <gd name="gd0" fmla="*/ dy 4 3"/>
+      <gd name="gd1" fmla="+- h 0 gd0"/>
+      <gd name="adjY" fmla="+- t dy 0"/>
+      <gd name="y0" fmla="+- t gd0 0"/>
+      <gd name="y1" fmla="+- t gd1 0"/>
+      <gd name="x0" fmla="+- l wd3 0"/>
+      <gd name="x1" fmla="+- r 0 wd3"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="0" maxY="37500">
+        <pos x="hc" y="adjY"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="t"/>
+        </moveTo>
+        <cubicBezTo>
+          <pt x="x0" y="y0"/>
+          <pt x="x1" y="y0"/>
+          <pt x="r" y="t"/>
+        </cubicBezTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="b"/>
+        </moveTo>
+        <cubicBezTo>
+          <pt x="x0" y="y1"/>
+          <pt x="x1" y="y1"/>
+          <pt x="r" y="b"/>
+        </cubicBezTo>
+      </path>
+    </pathLst>
+  </textDeflate>
+  <textDeflateBottom>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 50000"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 6250 adj 100000"/>
+      <gd name="dy" fmla="*/ a ss 100000"/>
+      <gd name="dy2" fmla="+- h 0 dy"/>
+      <gd name="y1" fmla="+- t dy 0"/>
+      <gd name="cp" fmla="+- y1 0 dy2"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="6250" maxY="100000">
+        <pos x="hc" y="y1"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="t"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="t"/>
+        </lnTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="b"/>
+        </moveTo>
+        <quadBezTo>
+          <pt x="hc" y="cp"/>
+          <pt x="r" y="b"/>
+        </quadBezTo>
+      </path>
+    </pathLst>
+  </textDeflateBottom>
+  <textDeflateInflate>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 35000"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 5000 adj 95000"/>
+      <gd name="dy" fmla="*/ a h 100000"/>
+      <gd name="del" fmla="*/ h 5 100"/>
+      <gd name="dh1" fmla="*/ h 45 100"/>
+      <gd name="dh2" fmla="*/ h 55 100"/>
+      <gd name="yh" fmla="+- dy 0 del"/>
+      <gd name="yl" fmla="+- dy del 0"/>
+      <gd name="y3" fmla="+- yh yh dh1"/>
+      <gd name="y4" fmla="+- yl yl dh2"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="5000" maxY="95000">
+        <pos x="hc" y="dy"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="t"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="t"/>
+        </lnTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="dh1"/>
+        </moveTo>
+        <quadBezTo>
+          <pt x="hc" y="y3"/>
+          <pt x="r" y="dh1"/>
+        </quadBezTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="dh2"/>
+        </moveTo>
+        <quadBezTo>
+          <pt x="hc" y="y4"/>
+          <pt x="r" y="dh2"/>
+        </quadBezTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="b"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="b"/>
+        </lnTo>
+      </path>
+    </pathLst>
+  </textDeflateInflate>
+  <textDeflateInflateDeflate>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 25000"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 3000 adj 47000"/>
+      <gd name="dy" fmla="*/ a h 100000"/>
+      <gd name="del" fmla="*/ h 3 100"/>
+      <gd name="ey1" fmla="*/ h 30 100"/>
+      <gd name="ey2" fmla="*/ h 36 100"/>
+      <gd name="ey3" fmla="*/ h 63 100"/>
+      <gd name="ey4" fmla="*/ h 70 100"/>
+      <gd name="by" fmla="+- b 0 dy"/>
+      <gd name="yh1" fmla="+- dy 0 del"/>
+      <gd name="yl1" fmla="+- dy del 0"/>
+      <gd name="yh2" fmla="+- by 0 del"/>
+      <gd name="yl2" fmla="+- by del 0"/>
+      <gd name="y1" fmla="+- yh1 yh1 ey1"/>
+      <gd name="y2" fmla="+- yl1 yl1 ey2"/>
+      <gd name="y3" fmla="+- yh2 yh2 ey3"/>
+      <gd name="y4" fmla="+- yl2 yl2 ey4"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="3000" maxY="47000">
+        <pos x="hc" y="dy"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="t"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="t"/>
+        </lnTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="ey1"/>
+        </moveTo>
+        <quadBezTo>
+          <pt x="hc" y="y1"/>
+          <pt x="r" y="ey1"/>
+        </quadBezTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="ey2"/>
+        </moveTo>
+        <quadBezTo>
+          <pt x="hc" y="y2"/>
+          <pt x="r" y="ey2"/>
+        </quadBezTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="ey3"/>
+        </moveTo>
+        <quadBezTo>
+          <pt x="hc" y="y3"/>
+          <pt x="r" y="ey3"/>
+        </quadBezTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="ey4"/>
+        </moveTo>
+        <quadBezTo>
+          <pt x="hc" y="y4"/>
+          <pt x="r" y="ey4"/>
+        </quadBezTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="b"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="b"/>
+        </lnTo>
+      </path>
+    </pathLst>
+  </textDeflateInflateDeflate>
+  <textDeflateTop>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 50000"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 0 adj 93750"/>
+      <gd name="dy" fmla="*/ a h 100000"/>
+      <gd name="y1" fmla="+- t dy 0"/>
+      <gd name="cp" fmla="+- y1 dy 0"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="0" maxY="93750">
+        <pos x="hc" y="y1"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="t"/>
+        </moveTo>
+        <quadBezTo>
+          <pt x="hc" y="cp"/>
+          <pt x="r" y="t"/>
+        </quadBezTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="b"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="b"/>
+        </lnTo>
+      </path>
+    </pathLst>
+  </textDeflateTop>
+  <textDoubleWave1>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj1" fmla="val 6250"/>
+      <gd name="adj2" fmla="val 0"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a1" fmla="pin 0 adj1 12500"/>
+      <gd name="a2" fmla="pin -10000 adj2 10000"/>
+      <gd name="y1" fmla="*/ h a1 100000"/>
+      <gd name="dy2" fmla="*/ y1 10 3"/>
+      <gd name="y2" fmla="+- y1 0 dy2"/>
+      <gd name="y3" fmla="+- y1 dy2 0"/>
+      <gd name="y4" fmla="+- b 0 y1"/>
+      <gd name="y5" fmla="+- y4 0 dy2"/>
+      <gd name="y6" fmla="+- y4 dy2 0"/>
+      <gd name="of" fmla="*/ w a2 100000"/>
+      <gd name="of2" fmla="*/ w a2 50000"/>
+      <gd name="x1" fmla="abs of"/>
+      <gd name="dx2" fmla="?: of2 0 of2"/>
+      <gd name="x2" fmla="+- l 0 dx2"/>
+      <gd name="dx8" fmla="?: of2 of2 0"/>
+      <gd name="x8" fmla="+- r 0 dx8"/>
+      <gd name="dx3" fmla="+/ dx2 x8 6"/>
+      <gd name="x3" fmla="+- x2 dx3 0"/>
+      <gd name="dx4" fmla="+/ dx2 x8 3"/>
+      <gd name="x4" fmla="+- x2 dx4 0"/>
+      <gd name="x5" fmla="+/ x2 x8 2"/>
+      <gd name="x6" fmla="+- x5 dx3 0"/>
+      <gd name="x7" fmla="+/ x6 x8 2"/>
+      <gd name="x9" fmla="+- l dx8 0"/>
+      <gd name="x15" fmla="+- r dx2 0"/>
+      <gd name="x10" fmla="+- x9 dx3 0"/>
+      <gd name="x11" fmla="+- x9 dx4 0"/>
+      <gd name="x12" fmla="+/ x9 x15 2"/>
+      <gd name="x13" fmla="+- x12 dx3 0"/>
+      <gd name="x14" fmla="+/ x13 x15 2"/>
+      <gd name="x16" fmla="+- r 0 x1"/>
+      <gd name="xAdj" fmla="+- hc of 0"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj1" minY="0" maxY="12500">
+        <pos x="l" y="y1"/>
+      </ahXY>
+      <ahXY gdRefX="adj2" minX="-10000" maxX="10000">
+        <pos x="xAdj" y="b"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="x2" y="y1"/>
+        </moveTo>
+        <cubicBezTo>
+          <pt x="x3" y="y2"/>
+          <pt x="x4" y="y3"/>
+          <pt x="x5" y="y1"/>
+        </cubicBezTo>
+        <cubicBezTo>
+          <pt x="x6" y="y2"/>
+          <pt x="x7" y="y3"/>
+          <pt x="x8" y="y1"/>
+        </cubicBezTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="x9" y="y4"/>
+        </moveTo>
+        <cubicBezTo>
+          <pt x="x10" y="y5"/>
+          <pt x="x11" y="y6"/>
+          <pt x="x12" y="y4"/>
+        </cubicBezTo>
+        <cubicBezTo>
+          <pt x="x13" y="y5"/>
+          <pt x="x14" y="y6"/>
+          <pt x="x15" y="y4"/>
+        </cubicBezTo>
+      </path>
+    </pathLst>
+  </textDoubleWave1>
+  <textFadeDown>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 33333"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 0 adj 49999"/>
+      <gd name="dx" fmla="*/ a w 100000"/>
+      <gd name="x1" fmla="+- l dx 0"/>
+      <gd name="x2" fmla="+- r 0 dx"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefX="adj" minX="0" maxX="49999">
+        <pos x="x1" y="b"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="t"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="t"/>
+        </lnTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="x1" y="b"/>
+        </moveTo>
+        <lnTo>
+          <pt x="x2" y="b"/>
+        </lnTo>
+      </path>
+    </pathLst>
+  </textFadeDown>
+  <textFadeLeft>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 33333"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 0 adj 49999"/>
+      <gd name="dy" fmla="*/ a h 100000"/>
+      <gd name="y1" fmla="+- t dy 0"/>
+      <gd name="y2" fmla="+- b 0 dy"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="0" maxY="49999">
+        <pos x="l" y="y1"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="y1"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="t"/>
+        </lnTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="y2"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="b"/>
+        </lnTo>
+      </path>
+    </pathLst>
+  </textFadeLeft>
+  <textFadeRight>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 33333"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 0 adj 49999"/>
+      <gd name="dy" fmla="*/ a h 100000"/>
+      <gd name="y1" fmla="+- t dy 0"/>
+      <gd name="y2" fmla="+- b 0 dy"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="0" maxY="49999">
+        <pos x="r" y="y1"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="t"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="y1"/>
+        </lnTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="b"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="y2"/>
+        </lnTo>
+      </path>
+    </pathLst>
+  </textFadeRight>
+  <textFadeUp>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 33333"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 0 adj 49999"/>
+      <gd name="dx" fmla="*/ a w 100000"/>
+      <gd name="x1" fmla="+- l dx 0"/>
+      <gd name="x2" fmla="+- r 0 dx"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefX="adj" minX="0" maxX="49999">
+        <pos x="x1" y="t"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="x1" y="t"/>
+        </moveTo>
+        <lnTo>
+          <pt x="x2" y="t"/>
+        </lnTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="b"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="b"/>
+        </lnTo>
+      </path>
+    </pathLst>
+  </textFadeUp>
+  <textInflate>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 18750"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 0 adj 20000"/>
+      <gd name="dy" fmla="*/ a h 100000"/>
+      <gd name="gd" fmla="*/ dy 1 3"/>
+      <gd name="gd0" fmla="+- 0 0 gd"/>
+      <gd name="gd1" fmla="+- h 0 gd0"/>
+      <gd name="ty" fmla="+- t dy 0"/>
+      <gd name="by" fmla="+- b 0 dy"/>
+      <gd name="y0" fmla="+- t gd0 0"/>
+      <gd name="y1" fmla="+- t gd1 0"/>
+      <gd name="x0" fmla="+- l wd3 0"/>
+      <gd name="x1" fmla="+- r 0 wd3"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="0" maxY="20000">
+        <pos x="l" y="ty"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="ty"/>
+        </moveTo>
+        <cubicBezTo>
+          <pt x="x0" y="y0"/>
+          <pt x="x1" y="y0"/>
+          <pt x="r" y="ty"/>
+        </cubicBezTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="by"/>
+        </moveTo>
+        <cubicBezTo>
+          <pt x="x0" y="y1"/>
+          <pt x="x1" y="y1"/>
+          <pt x="r" y="by"/>
+        </cubicBezTo>
+      </path>
+    </pathLst>
+  </textInflate>
+  <textInflateBottom>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 60000"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 60000 adj 100000"/>
+      <gd name="dy" fmla="*/ a h 100000"/>
+      <gd name="ty" fmla="+- t dy 0"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="60000" maxY="100000">
+        <pos x="l" y="ty"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="t"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="t"/>
+        </lnTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="ty"/>
+        </moveTo>
+        <quadBezTo>
+          <pt x="hc" y="b"/>
+          <pt x="r" y="ty"/>
+        </quadBezTo>
+      </path>
+    </pathLst>
+  </textInflateBottom>
+  <textInflateTop>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 40000"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 0 adj 50000"/>
+      <gd name="dy" fmla="*/ a h 100000"/>
+      <gd name="ty" fmla="+- t dy 0"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="0" maxY="50000">
+        <pos x="l" y="ty"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="ty"/>
+        </moveTo>
+        <quadBezTo>
+          <pt x="hc" y="t"/>
+          <pt x="r" y="ty"/>
+        </quadBezTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="b"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="b"/>
+        </lnTo>
+      </path>
+    </pathLst>
+  </textInflateTop>
+  <textPlain>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 50000"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 30000 adj 70000"/>
+      <gd name="mid" fmla="*/ a w 100000"/>
+      <gd name="midDir" fmla="+- mid 0 hc"/>
+      <gd name="dl" fmla="+- mid 0 l"/>
+      <gd name="dr" fmla="+- r 0 mid"/>
+      <gd name="dl2" fmla="*/ dl 2 1"/>
+      <gd name="dr2" fmla="*/ dr 2 1"/>
+      <gd name="dx" fmla="?: midDir dr2 dl2"/>
+      <gd name="xr" fmla="+- l dx 0"/>
+      <gd name="xl" fmla="+- r 0 dx"/>
+      <gd name="tlx" fmla="?: midDir l xl"/>
+      <gd name="trx" fmla="?: midDir xr r"/>
+      <gd name="blx" fmla="?: midDir xl l"/>
+      <gd name="brx" fmla="?: midDir r xr"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefX="adj" minX="30000" maxX="70000">
+        <pos x="mid" y="b"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="tlx" y="t"/>
+        </moveTo>
+        <lnTo>
+          <pt x="trx" y="t"/>
+        </lnTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="blx" y="b"/>
+        </moveTo>
+        <lnTo>
+          <pt x="brx" y="b"/>
+        </lnTo>
+      </path>
+    </pathLst>
+  </textPlain>
+  <textRingInside>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 60000"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 50000 adj 99000"/>
+      <gd name="dy" fmla="*/ a h 100000"/>
+      <gd name="y" fmla="+- t dy 0"/>
+      <gd name="r" fmla="*/ dy 1 2"/>
+      <gd name="y1" fmla="+- t r 0"/>
+      <gd name="y2" fmla="+- b 0 r"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="50000" maxY="99000">
+        <pos x="hc" y="y"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="y1"/>
+        </moveTo>
+        <arcTo wR="wd2" hR="r" stAng="10800000" swAng="21599999"/>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="y2"/>
+        </moveTo>
+        <arcTo wR="wd2" hR="r" stAng="10800000" swAng="21599999"/>
+      </path>
+    </pathLst>
+  </textRingInside>
+  <textRingOutside>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 60000"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 50000 adj 99000"/>
+      <gd name="dy" fmla="*/ a h 100000"/>
+      <gd name="y" fmla="+- t dy 0"/>
+      <gd name="r" fmla="*/ dy 1 2"/>
+      <gd name="y1" fmla="+- t r 0"/>
+      <gd name="y2" fmla="+- b 0 r"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="50000" maxY="99000">
+        <pos x="hc" y="y"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="y1"/>
+        </moveTo>
+        <arcTo wR="wd2" hR="r" stAng="10800000" swAng="-21599999"/>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="y2"/>
+        </moveTo>
+        <arcTo wR="wd2" hR="r" stAng="10800000" swAng="-21599999"/>
+      </path>
+    </pathLst>
+  </textRingOutside>
+  <textSlantDown>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 44445"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 28569 adj 100000"/>
+      <gd name="dy" fmla="*/ a h 100000"/>
+      <gd name="y1" fmla="+- t dy 0"/>
+      <gd name="y2" fmla="+- b 0 dy"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="28569" maxY="100000">
+        <pos x="l" y="y1"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="t"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="y2"/>
+        </lnTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="y1"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="b"/>
+        </lnTo>
+      </path>
+    </pathLst>
+  </textSlantDown>
+  <textSlantUp>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 55555"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 0 adj 71431"/>
+      <gd name="dy" fmla="*/ a h 100000"/>
+      <gd name="y1" fmla="+- t dy 0"/>
+      <gd name="y2" fmla="+- b 0 dy"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="0" maxY="71431">
+        <pos x="l" y="y1"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="y1"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="t"/>
+        </lnTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="b"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="y2"/>
+        </lnTo>
+      </path>
+    </pathLst>
+  </textSlantUp>
+  <textStop>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 25000"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 14286 adj 50000"/>
+      <gd name="dx" fmla="*/ w 1 3"/>
+      <gd name="dy" fmla="*/ a h 100000"/>
+      <gd name="x1" fmla="+- l dx 0"/>
+      <gd name="x2" fmla="+- r 0 dx"/>
+      <gd name="y1" fmla="+- t dy 0"/>
+      <gd name="y2" fmla="+- b 0 dy"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="14286" maxY="50000">
+        <pos x="l" y="dy"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="y1"/>
+        </moveTo>
+        <lnTo>
+          <pt x="x1" y="t"/>
+        </lnTo>
+        <lnTo>
+          <pt x="x2" y="t"/>
+        </lnTo>
+        <lnTo>
+          <pt x="r" y="y1"/>
+        </lnTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="y2"/>
+        </moveTo>
+        <lnTo>
+          <pt x="x1" y="b"/>
+        </lnTo>
+        <lnTo>
+          <pt x="x2" y="b"/>
+        </lnTo>
+        <lnTo>
+          <pt x="r" y="y2"/>
+        </lnTo>
+      </path>
+    </pathLst>
+  </textStop>
+  <textTriangle>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 50000"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 0 adj 100000"/>
+      <gd name="y" fmla="*/ a h 100000"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="0" maxY="100000">
+        <pos x="l" y="y"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="y"/>
+        </moveTo>
+        <lnTo>
+          <pt x="hc" y="t"/>
+        </lnTo>
+        <lnTo>
+          <pt x="r" y="y"/>
+        </lnTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="b"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="b"/>
+        </lnTo>
+      </path>
+    </pathLst>
+  </textTriangle>
+  <textTriangleInverted>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj" fmla="val 50000"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a" fmla="pin 0 adj 100000"/>
+      <gd name="y" fmla="*/ a h 100000"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj" minY="0" maxY="100000">
+        <pos x="l" y="y"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="l" y="t"/>
+        </moveTo>
+        <lnTo>
+          <pt x="r" y="t"/>
+        </lnTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="l" y="y"/>
+        </moveTo>
+        <lnTo>
+          <pt x="hc" y="b"/>
+        </lnTo>
+        <lnTo>
+          <pt x="r" y="y"/>
+        </lnTo>
+      </path>
+    </pathLst>
+  </textTriangleInverted>
+  <textWave1>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj1" fmla="val 12500"/>
+      <gd name="adj2" fmla="val 0"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a1" fmla="pin 0 adj1 20000"/>
+      <gd name="a2" fmla="pin -10000 adj2 10000"/>
+      <gd name="y1" fmla="*/ h a1 100000"/>
+      <gd name="dy2" fmla="*/ y1 10 3"/>
+      <gd name="y2" fmla="+- y1 0 dy2"/>
+      <gd name="y3" fmla="+- y1 dy2 0"/>
+      <gd name="y4" fmla="+- b 0 y1"/>
+      <gd name="y5" fmla="+- y4 0 dy2"/>
+      <gd name="y6" fmla="+- y4 dy2 0"/>
+      <gd name="of" fmla="*/ w a2 100000"/>
+      <gd name="of2" fmla="*/ w a2 50000"/>
+      <gd name="x1" fmla="abs of"/>
+      <gd name="dx2" fmla="?: of2 0 of2"/>
+      <gd name="x2" fmla="+- l 0 dx2"/>
+      <gd name="dx5" fmla="?: of2 of2 0"/>
+      <gd name="x5" fmla="+- r 0 dx5"/>
+      <gd name="dx3" fmla="+/ dx2 x5 3"/>
+      <gd name="x3" fmla="+- x2 dx3 0"/>
+      <gd name="x4" fmla="+/ x3 x5 2"/>
+      <gd name="x6" fmla="+- l dx5 0"/>
+      <gd name="x10" fmla="+- r dx2 0"/>
+      <gd name="x7" fmla="+- x6 dx3 0"/>
+      <gd name="x8" fmla="+/ x7 x10 2"/>
+      <gd name="x9" fmla="+- r 0 x1"/>
+      <gd name="xAdj" fmla="+- hc of 0"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj1" minY="0" maxY="20000">
+        <pos x="l" y="y1"/>
+      </ahXY>
+      <ahXY gdRefX="adj2" minX="-10000" maxX="10000">
+        <pos x="xAdj" y="b"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="x2" y="y1"/>
+        </moveTo>
+        <cubicBezTo>
+          <pt x="x3" y="y2"/>
+          <pt x="x4" y="y3"/>
+          <pt x="x5" y="y1"/>
+        </cubicBezTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="x6" y="y4"/>
+        </moveTo>
+        <cubicBezTo>
+          <pt x="x7" y="y5"/>
+          <pt x="x8" y="y6"/>
+          <pt x="x10" y="y4"/>
+        </cubicBezTo>
+      </path>
+    </pathLst>
+  </textWave1>
+  <textWave2>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj1" fmla="val 12500"/>
+      <gd name="adj2" fmla="val 0"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a1" fmla="pin 0 adj1 20000"/>
+      <gd name="a2" fmla="pin -10000 adj2 10000"/>
+      <gd name="y1" fmla="*/ h a1 100000"/>
+      <gd name="dy2" fmla="*/ y1 10 3"/>
+      <gd name="y2" fmla="+- y1 0 dy2"/>
+      <gd name="y3" fmla="+- y1 dy2 0"/>
+      <gd name="y4" fmla="+- b 0 y1"/>
+      <gd name="y5" fmla="+- y4 0 dy2"/>
+      <gd name="y6" fmla="+- y4 dy2 0"/>
+      <gd name="of" fmla="*/ w a2 100000"/>
+      <gd name="of2" fmla="*/ w a2 50000"/>
+      <gd name="x1" fmla="abs of"/>
+      <gd name="dx2" fmla="?: of2 0 of2"/>
+      <gd name="x2" fmla="+- l 0 dx2"/>
+      <gd name="dx5" fmla="?: of2 of2 0"/>
+      <gd name="x5" fmla="+- r 0 dx5"/>
+      <gd name="dx3" fmla="+/ dx2 x5 3"/>
+      <gd name="x3" fmla="+- x2 dx3 0"/>
+      <gd name="x4" fmla="+/ x3 x5 2"/>
+      <gd name="x6" fmla="+- l dx5 0"/>
+      <gd name="x10" fmla="+- r dx2 0"/>
+      <gd name="x7" fmla="+- x6 dx3 0"/>
+      <gd name="x8" fmla="+/ x7 x10 2"/>
+      <gd name="x9" fmla="+- r 0 x1"/>
+      <gd name="xAdj" fmla="+- hc of 0"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj1" minY="0" maxY="20000">
+        <pos x="l" y="y1"/>
+      </ahXY>
+      <ahXY gdRefX="adj2" minX="-10000" maxX="10000">
+        <pos x="xAdj" y="b"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="x2" y="y1"/>
+        </moveTo>
+        <cubicBezTo>
+          <pt x="x3" y="y3"/>
+          <pt x="x4" y="y2"/>
+          <pt x="x5" y="y1"/>
+        </cubicBezTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="x6" y="y4"/>
+        </moveTo>
+        <cubicBezTo>
+          <pt x="x7" y="y6"/>
+          <pt x="x8" y="y5"/>
+          <pt x="x10" y="y4"/>
+        </cubicBezTo>
+      </path>
+    </pathLst>
+  </textWave2>
+  <textWave4>
+    <avLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="adj1" fmla="val 6250"/>
+      <gd name="adj2" fmla="val 0"/>
+    </avLst>
+    <gdLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <gd name="a1" fmla="pin 0 adj1 12500"/>
+      <gd name="a2" fmla="pin -10000 adj2 10000"/>
+      <gd name="y1" fmla="*/ h a1 100000"/>
+      <gd name="dy2" fmla="*/ y1 10 3"/>
+      <gd name="y2" fmla="+- y1 0 dy2"/>
+      <gd name="y3" fmla="+- y1 dy2 0"/>
+      <gd name="y4" fmla="+- b 0 y1"/>
+      <gd name="y5" fmla="+- y4 0 dy2"/>
+      <gd name="y6" fmla="+- y4 dy2 0"/>
+      <gd name="of" fmla="*/ w a2 100000"/>
+      <gd name="of2" fmla="*/ w a2 50000"/>
+      <gd name="x1" fmla="abs of"/>
+      <gd name="dx2" fmla="?: of2 0 of2"/>
+      <gd name="x2" fmla="+- l 0 dx2"/>
+      <gd name="dx8" fmla="?: of2 of2 0"/>
+      <gd name="x8" fmla="+- r 0 dx8"/>
+      <gd name="dx3" fmla="+/ dx2 x8 6"/>
+      <gd name="x3" fmla="+- x2 dx3 0"/>
+      <gd name="dx4" fmla="+/ dx2 x8 3"/>
+      <gd name="x4" fmla="+- x2 dx4 0"/>
+      <gd name="x5" fmla="+/ x2 x8 2"/>
+      <gd name="x6" fmla="+- x5 dx3 0"/>
+      <gd name="x7" fmla="+/ x6 x8 2"/>
+      <gd name="x9" fmla="+- l dx8 0"/>
+      <gd name="x15" fmla="+- r dx2 0"/>
+      <gd name="x10" fmla="+- x9 dx3 0"/>
+      <gd name="x11" fmla="+- x9 dx4 0"/>
+      <gd name="x12" fmla="+/ x9 x15 2"/>
+      <gd name="x13" fmla="+- x12 dx3 0"/>
+      <gd name="x14" fmla="+/ x13 x15 2"/>
+      <gd name="x16" fmla="+- r 0 x1"/>
+      <gd name="xAdj" fmla="+- hc of 0"/>
+    </gdLst>
+    <ahLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <ahXY gdRefY="adj1" minY="0" maxY="12500">
+        <pos x="l" y="y1"/>
+      </ahXY>
+      <ahXY gdRefX="adj2" minX="-10000" maxX="10000">
+        <pos x="xAdj" y="b"/>
+      </ahXY>
+    </ahLst>
+    <pathLst xmlns="http://schemas.openxmlformats.org/drawingml/2006/main">
+      <path>
+        <moveTo>
+          <pt x="x2" y="y1"/>
+        </moveTo>
+        <cubicBezTo>
+          <pt x="x3" y="y3"/>
+          <pt x="x4" y="y2"/>
+          <pt x="x5" y="y1"/>
+        </cubicBezTo>
+        <cubicBezTo>
+          <pt x="x6" y="y3"/>
+          <pt x="x7" y="y2"/>
+          <pt x="x8" y="y1"/>
+        </cubicBezTo>
+      </path>
+      <path>
+        <moveTo>
+          <pt x="x9" y="y4"/>
+        </moveTo>
+        <cubicBezTo>
+          <pt x="x10" y="y6"/>
+          <pt x="x11" y="y5"/>
+          <pt x="x12" y="y4"/>
+        </cubicBezTo>
+        <cubicBezTo>
+          <pt x="x13" y="y6"/>
+          <pt x="x14" y="y5"/>
+          <pt x="x15" y="y4"/>
+        </cubicBezTo>
+      </path>
+    </pathLst>
+  </textWave4>
+</presetTextWarpDefinitions>
diff --git a/oox/source/export/shapes.cxx b/oox/source/export/shapes.cxx
new file mode 100644
index 000000000..6828bc629
--- /dev/null
+++ b/oox/source/export/shapes.cxx
@@ -0,0 +1,2221 @@
+/* -*- 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 <sal/config.h>
+
+#include <sal/log.hxx>
+#include <filter/msfilter/util.hxx>
+#include <oox/core/xmlfilterbase.hxx>
+#include <oox/export/shapes.hxx>
+#include <oox/export/utils.hxx>
+#include <oox/token/namespaces.hxx>
+#include <oox/token/relationship.hxx>
+#include <oox/token/tokens.hxx>
+
+#include <initializer_list>
+
+#include <com/sun/star/beans/PropertyValues.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/beans/XPropertySetInfo.hpp>
+#include <com/sun/star/beans/XPropertyState.hpp>
+#include <com/sun/star/container/XChild.hpp>
+#include <com/sun/star/document/XExporter.hpp>
+#include <com/sun/star/document/XStorageBasedDocument.hpp>
+#include <com/sun/star/drawing/CircleKind.hpp>
+#include <com/sun/star/drawing/FillStyle.hpp>
+#include <com/sun/star/drawing/ConnectorType.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeParameterPair.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeParameterType.hpp>
+#include <com/sun/star/embed/EmbedStates.hpp>
+#include <com/sun/star/embed/XEmbeddedObject.hpp>
+#include <com/sun/star/embed/XEmbedPersist.hpp>
+#include <com/sun/star/frame/XStorable.hpp>
+#include <com/sun/star/graphic/XGraphic.hpp>
+#include <com/sun/star/i18n/ScriptType.hpp>
+#include <com/sun/star/io/XOutputStream.hpp>
+#include <com/sun/star/text/XSimpleText.hpp>
+#include <com/sun/star/text/XText.hpp>
+#include <com/sun/star/table/XTable.hpp>
+#include <com/sun/star/table/XMergeableCell.hpp>
+#include <com/sun/star/chart2/XChartDocument.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+#include <tools/globname.hxx>
+#include <comphelper/classids.hxx>
+#include <comphelper/propertysequence.hxx>
+#include <comphelper/storagehelper.hxx>
+#include <sot/exchange.hxx>
+#include <utility>
+#include <vcl/graph.hxx>
+#include <vcl/outdev.hxx>
+#include <filter/msfilter/escherex.hxx>
+#include <svx/svdoashp.hxx>
+#include <svx/svdoole2.hxx>
+#include <tools/diagnose_ex.h>
+#include <svx/unoapi.hxx>
+#include <oox/export/chartexport.hxx>
+#include <oox/mathml/export.hxx>
+#include <drawingml/presetgeometrynames.hxx>
+#include <basegfx/numeric/ftools.hxx>
+
+using namespace ::css;
+using namespace ::css::beans;
+using namespace ::css::uno;
+using namespace ::css::drawing;
+using namespace ::css::i18n;
+using namespace ::css::table;
+using namespace ::css::container;
+using namespace ::css::document;
+using namespace ::css::text;
+
+using ::css::io::XOutputStream;
+using ::css::chart2::XChartDocument;
+using ::css::frame::XModel;
+
+using ::oox::core::XmlFilterBase;
+using ::sax_fastparser::FSHelperPtr;
+
+#define IDS(x) OString(#x " " + OString::number(mnShapeIdMax++)).getStr()
+
+namespace oox {
+
+static void lcl_ConvertProgID(OUString const& rProgID,
+    OUString & o_rMediaType, OUString & o_rRelationType, OUString & o_rFileExtension)
+{
+    if (rProgID == "Excel.Sheet.12")
+    {
+        o_rMediaType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+        o_rRelationType = oox::getRelationship(Relationship::PACKAGE);
+        o_rFileExtension = "xlsx";
+    }
+    else if (rProgID.startsWith("Excel.SheetBinaryMacroEnabled.12") )
+    {
+        o_rMediaType = "application/vnd.ms-excel.sheet.binary.macroEnabled.12";
+        o_rRelationType = oox::getRelationship(Relationship::PACKAGE);
+        o_rFileExtension = "xlsb";
+    }
+    else if (rProgID.startsWith("Excel.SheetMacroEnabled.12"))
+    {
+        o_rMediaType = "application/vnd.ms-excel.sheet.macroEnabled.12";
+        o_rRelationType = oox::getRelationship(Relationship::PACKAGE);
+        o_rFileExtension = "xlsm";
+    }
+    else if (rProgID.startsWith("Excel.Sheet"))
+    {
+        o_rMediaType = "application/vnd.ms-excel";
+        o_rRelationType = oox::getRelationship(Relationship::OLEOBJECT);
+        o_rFileExtension = "xls";
+    }
+    else if (rProgID == "PowerPoint.Show.12")
+    {
+        o_rMediaType = "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+        o_rRelationType = oox::getRelationship(Relationship::PACKAGE);
+        o_rFileExtension = "pptx";
+    }
+    else if (rProgID == "PowerPoint.ShowMacroEnabled.12")
+    {
+        o_rMediaType = "application/vnd.ms-powerpoint.presentation.macroEnabled.12";
+        o_rRelationType = oox::getRelationship(Relationship::PACKAGE);
+        o_rFileExtension = "pptm";
+    }
+    else if (rProgID.startsWith("PowerPoint.Show"))
+    {
+        o_rMediaType = "application/vnd.ms-powerpoint";
+        o_rRelationType = oox::getRelationship(Relationship::OLEOBJECT);
+        o_rFileExtension = "ppt";
+    }
+    else if (rProgID.startsWith("PowerPoint.Slide.12"))
+    {
+       o_rMediaType = "application/vnd.openxmlformats-officedocument.presentationml.slide";
+       o_rRelationType = oox::getRelationship(Relationship::PACKAGE);
+       o_rFileExtension = "sldx";
+    }
+    else if (rProgID == "PowerPoint.SlideMacroEnabled.12")
+    {
+       o_rMediaType = "application/vnd.ms-powerpoint.slide.macroEnabled.12";
+       o_rRelationType = oox::getRelationship(Relationship::PACKAGE);
+       o_rFileExtension = "sldm";
+    }
+    else if (rProgID == "Word.DocumentMacroEnabled.12")
+    {
+        o_rMediaType = "application/vnd.ms-word.document.macroEnabled.12";
+        o_rRelationType = oox::getRelationship(Relationship::PACKAGE);
+        o_rFileExtension = "docm";
+    }
+    else if (rProgID == "Word.Document.12")
+    {
+        o_rMediaType = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+        o_rRelationType = oox::getRelationship(Relationship::PACKAGE);
+        o_rFileExtension = "docx";
+    }
+    else if (rProgID == "Word.Document.8")
+    {
+        o_rMediaType = "application/msword";
+        o_rRelationType = oox::getRelationship(Relationship::OLEOBJECT);
+        o_rFileExtension = "doc";
+    }
+    else if (rProgID == "Excel.Chart.8")
+    {
+        o_rMediaType = "application/vnd.ms-excel";
+        o_rRelationType = oox::getRelationship(Relationship::OLEOBJECT);
+        o_rFileExtension = "xls";
+    }
+    else if (rProgID == "AcroExch.Document.11")
+    {
+        o_rMediaType = "application/pdf";
+        o_rRelationType = oox::getRelationship(Relationship::OLEOBJECT);
+        o_rFileExtension = "pdf";
+    }
+    else
+    {
+        o_rMediaType = "application/vnd.openxmlformats-officedocument.oleObject";
+        o_rRelationType = oox::getRelationship(Relationship::OLEOBJECT);
+        o_rFileExtension = "bin";
+    }
+}
+
+static uno::Reference<io::XInputStream> lcl_StoreOwnAsOOXML(
+    uno::Reference<uno::XComponentContext> const& xContext,
+    uno::Reference<embed::XEmbeddedObject> const& xObj,
+    char const*& o_rpProgID,
+    OUString & o_rMediaType, OUString & o_rRelationType, OUString & o_rSuffix)
+{
+    static struct {
+        struct {
+            sal_uInt32 n1;
+            sal_uInt16 n2, n3;
+            sal_uInt8 b8, b9, b10, b11, b12, b13, b14, b15;
+        } ClassId;
+        char const* pFilterName;
+        char const* pMediaType;
+        char const* pProgID;
+        char const* pSuffix;
+    } const s_Mapping[] = {
+        { {SO3_SW_CLASSID_60}, "MS Word 2007 XML", "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "Word.Document.12", "docx" },
+        { {SO3_SC_CLASSID_60}, "Calc MS Excel 2007 XML", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Excel.Sheet.12", "xlsx" },
+        { {SO3_SIMPRESS_CLASSID_60}, "Impress MS PowerPoint 2007 XML", "application/vnd.openxmlformats-officedocument.presentationml.presentation", "PowerPoint.Show.12", "pptx" },
+        // FIXME: Draw does not appear to have a MSO format export filter?
+//            { {SO3_SDRAW_CLASSID}, "", "", "", "" },
+        { {SO3_SCH_CLASSID_60}, "unused", "", "", "" },
+        { {SO3_SM_CLASSID_60}, "unused", "", "", "" },
+    };
+
+    const char * pFilterName(nullptr);
+    SvGlobalName const classId(xObj->getClassID());
+    for (auto & i : s_Mapping)
+    {
+        auto const& rId(i.ClassId);
+        SvGlobalName const temp(rId.n1, rId.n2, rId.n3, rId.b8, rId.b9, rId.b10, rId.b11, rId.b12, rId.b13, rId.b14, rId.b15);
+        if (temp == classId)
+        {
+            assert(SvGlobalName(SO3_SCH_CLASSID_60) != classId); // chart should be written elsewhere!
+            assert(SvGlobalName(SO3_SM_CLASSID_60) != classId); // formula should be written elsewhere!
+            pFilterName = i.pFilterName;
+            o_rMediaType = OUString::createFromAscii(i.pMediaType);
+            o_rpProgID = i.pProgID;
+            o_rSuffix = OUString::createFromAscii(i.pSuffix);
+            o_rRelationType = oox::getRelationship(Relationship::PACKAGE);
+            break;
+        }
+    }
+
+    if (!pFilterName)
+    {
+        SAL_WARN("oox.shape", "oox::GetOLEObjectStream: unknown ClassId " << classId.GetHexName());
+        return nullptr;
+    }
+
+    if (embed::EmbedStates::LOADED == xObj->getCurrentState())
+    {
+        xObj->changeState(embed::EmbedStates::RUNNING);
+    }
+    // use a temp stream - while it would work to store directly to a
+    // fragment stream, an error during export means we'd have to delete it
+    uno::Reference<io::XStream> const xTempStream(
+        xContext->getServiceManager()->createInstanceWithContext(
+            "com.sun.star.comp.MemoryStream", xContext),
+        uno::UNO_QUERY_THROW);
+    uno::Sequence<beans::PropertyValue> args( comphelper::InitPropertySequence({
+            { "OutputStream", Any(xTempStream->getOutputStream()) },
+            { "FilterName", Any(OUString::createFromAscii(pFilterName)) }
+        }));
+    uno::Reference<frame::XStorable> xStorable(xObj->getComponent(), uno::UNO_QUERY);
+    try
+    {
+        xStorable->storeToURL("private:stream", args);
+    }
+    catch (uno::Exception const&)
+    {
+        TOOLS_WARN_EXCEPTION("oox.shape", "oox::GetOLEObjectStream");
+        return nullptr;
+    }
+    xTempStream->getOutputStream()->closeOutput();
+    return xTempStream->getInputStream();
+}
+
+uno::Reference<io::XInputStream> GetOLEObjectStream(
+        uno::Reference<uno::XComponentContext> const& xContext,
+        uno::Reference<embed::XEmbeddedObject> const& xObj,
+        OUString const& i_rProgID,
+        OUString & o_rMediaType,
+        OUString & o_rRelationType,
+        OUString & o_rSuffix,
+        const char *& o_rpProgID)
+{
+    uno::Reference<io::XInputStream> xInStream;
+    try
+    {
+        uno::Reference<document::XStorageBasedDocument> const xParent(
+            uno::Reference<container::XChild>(xObj, uno::UNO_QUERY_THROW)->getParent(),
+            uno::UNO_QUERY_THROW);
+        uno::Reference<embed::XStorage> const xParentStorage(xParent->getDocumentStorage());
+        OUString const entryName(
+            uno::Reference<embed::XEmbedPersist>(xObj, uno::UNO_QUERY_THROW)->getEntryName());
+
+        if (xParentStorage->isStreamElement(entryName))
+        {
+            lcl_ConvertProgID(i_rProgID, o_rMediaType, o_rRelationType, o_rSuffix);
+            xInStream = xParentStorage->cloneStreamElement(entryName)->getInputStream();
+            // TODO: make it possible to take the sMediaType from the stream
+        }
+        else // the object is ODF - either the whole document is
+        {    // ODF, or the OLE was edited so it was converted to ODF
+            xInStream = lcl_StoreOwnAsOOXML(xContext, xObj,
+                    o_rpProgID, o_rMediaType, o_rRelationType, o_rSuffix);
+        }
+    }
+    catch (uno::Exception const&)
+    {
+        TOOLS_WARN_EXCEPTION("oox.shape", "oox::GetOLEObjectStream");
+    }
+    return xInStream;
+}
+
+} // namespace oox
+
+namespace oox::drawingml {
+
+#define GETA(propName) \
+    GetProperty( rXPropSet, #propName)
+
+#define GETAD(propName) \
+    ( GetPropertyAndState( rXPropSet, rXPropState, #propName, eState ) && eState == beans::PropertyState_DIRECT_VALUE )
+
+#define GET(variable, propName) \
+    if ( GETA(propName) ) \
+        mAny >>= variable;
+
+ShapeExport::ShapeExport( sal_Int32 nXmlNamespace, FSHelperPtr pFS, ShapeHashMap* pShapeMap, XmlFilterBase* pFB, DocumentType eDocumentType, DMLTextExport* pTextExport )
+    : DrawingML( std::move(pFS), pFB, eDocumentType, pTextExport )
+    , m_nEmbeddedObjects(0)
+    , mnShapeIdMax( 1 )
+    , mnPictureIdMax( 1 )
+    , mnXmlNamespace( nXmlNamespace )
+    , maMapModeSrc( MapUnit::Map100thMM )
+    , maMapModeDest( MapUnit::MapInch, Point(), Fraction( 1, 576 ), Fraction( 1, 576 ) )
+    , mpShapeMap( pShapeMap ? pShapeMap : &maShapeMap )
+{
+    mpURLTransformer = std::make_shared<URLTransformer>();
+}
+
+void ShapeExport::SetURLTranslator(const std::shared_ptr<URLTransformer>& pTransformer)
+{
+    mpURLTransformer = pTransformer;
+}
+
+awt::Size ShapeExport::MapSize( const awt::Size& rSize ) const
+{
+    Size aRetSize( OutputDevice::LogicToLogic( Size( rSize.Width, rSize.Height ), maMapModeSrc, maMapModeDest ) );
+
+    if ( !aRetSize.Width() )
+        aRetSize.AdjustWidth( 1 );
+    if ( !aRetSize.Height() )
+        aRetSize.AdjustHeight( 1 );
+    return awt::Size( aRetSize.Width(), aRetSize.Height() );
+}
+
+static bool IsNonEmptySimpleText(const Reference<XInterface>& xIface)
+{
+    if (Reference<XSimpleText> xText{ xIface, UNO_QUERY })
+        return xText->getString().getLength();
+
+    return false;
+}
+
+bool ShapeExport::NonEmptyText( const Reference< XInterface >& xIface )
+{
+    Reference< XPropertySet > xPropSet( xIface, UNO_QUERY );
+
+    if( xPropSet.is() )
+    {
+        Reference< XPropertySetInfo > xPropSetInfo = xPropSet->getPropertySetInfo();
+        if ( xPropSetInfo.is() )
+        {
+            if ( xPropSetInfo->hasPropertyByName( "IsEmptyPresentationObject" ) )
+            {
+                bool bIsEmptyPresObj = false;
+                if ( xPropSet->getPropertyValue( "IsEmptyPresentationObject" ) >>= bIsEmptyPresObj )
+                {
+                    SAL_INFO("oox.shape", "empty presentation object " << bIsEmptyPresObj << " , props:");
+                    if( bIsEmptyPresObj )
+                       return true;
+                }
+            }
+
+            if ( xPropSetInfo->hasPropertyByName( "IsPresentationObject" ) )
+            {
+                bool bIsPresObj = false;
+                if ( xPropSet->getPropertyValue( "IsPresentationObject" ) >>= bIsPresObj )
+                {
+                    SAL_INFO("oox.shape", "presentation object " << bIsPresObj << ", props:");
+                    if( bIsPresObj )
+                       return true;
+                }
+            }
+        }
+    }
+
+    return IsNonEmptySimpleText(xIface);
+}
+
+ShapeExport& ShapeExport::WritePolyPolygonShape( const Reference< XShape >& xShape, const bool bClosed )
+{
+    SAL_INFO("oox.shape", "write polypolygon shape");
+
+    FSHelperPtr pFS = GetFS();
+    pFS->startElementNS(mnXmlNamespace, (GetDocumentType() != DOCUMENT_DOCX ? XML_sp : XML_wsp));
+
+    tools::PolyPolygon aPolyPolygon = EscherPropertyContainer::GetPolyPolygon( xShape );
+    tools::Rectangle aRect( aPolyPolygon.GetBoundRect() );
+
+#if OSL_DEBUG_LEVEL > 0
+    awt::Size size = MapSize( awt::Size( aRect.GetWidth(), aRect.GetHeight() ) );
+    SAL_INFO("oox.shape", "poly count " << aPolyPolygon.Count());
+    SAL_INFO("oox.shape", "size: " << size.Width << " x " << size.Height);
+#endif
+
+    // non visual shape properties
+    if (GetDocumentType() != DOCUMENT_DOCX)
+    {
+        pFS->startElementNS(mnXmlNamespace, XML_nvSpPr);
+        pFS->singleElementNS( mnXmlNamespace, XML_cNvPr,
+                              XML_id, OString::number(GetNewShapeID(xShape)),
+                              XML_name, IDS( Freeform ) );
+    }
+    pFS->singleElementNS(mnXmlNamespace, XML_cNvSpPr);
+    if (GetDocumentType() != DOCUMENT_DOCX)
+    {
+        WriteNonVisualProperties( xShape );
+        pFS->endElementNS( mnXmlNamespace, XML_nvSpPr );
+    }
+
+    // visual shape properties
+    pFS->startElementNS(mnXmlNamespace, XML_spPr);
+    WriteTransformation( aRect, XML_a );
+    WritePolyPolygon( aPolyPolygon, bClosed );
+    Reference< XPropertySet > xProps( xShape, UNO_QUERY );
+    if( xProps.is() ) {
+        if( bClosed )
+            WriteFill( xProps );
+        WriteOutline( xProps );
+    }
+
+    pFS->endElementNS( mnXmlNamespace, XML_spPr );
+
+    // write text
+    WriteTextBox( xShape, mnXmlNamespace );
+
+    pFS->endElementNS( mnXmlNamespace, (GetDocumentType() != DOCUMENT_DOCX ? XML_sp : XML_wsp) );
+
+    return *this;
+}
+
+ShapeExport& ShapeExport::WriteClosedPolyPolygonShape( const Reference< XShape >& xShape )
+{
+    return WritePolyPolygonShape( xShape, true );
+}
+
+ShapeExport& ShapeExport::WriteOpenPolyPolygonShape( const Reference< XShape >& xShape )
+{
+    return WritePolyPolygonShape( xShape, false );
+}
+
+ShapeExport& ShapeExport::WriteGroupShape(const uno::Reference<drawing::XShape>& xShape)
+{
+    FSHelperPtr pFS = GetFS();
+
+    sal_Int32 nGroupShapeToken = XML_grpSp;
+    if (GetDocumentType() == DOCUMENT_DOCX)
+    {
+        if (!m_xParent.is())
+            nGroupShapeToken = XML_wgp; // toplevel
+        else
+            mnXmlNamespace = XML_wpg;
+    }
+
+    pFS->startElementNS(mnXmlNamespace, nGroupShapeToken);
+
+    // non visual properties
+    if (GetDocumentType() != DOCUMENT_DOCX)
+    {
+        pFS->startElementNS(mnXmlNamespace, XML_nvGrpSpPr);
+        pFS->singleElementNS(mnXmlNamespace, XML_cNvPr,
+                XML_id, OString::number(GetNewShapeID(xShape)),
+                XML_name, IDS(Group));
+        pFS->singleElementNS(mnXmlNamespace, XML_cNvGrpSpPr);
+        WriteNonVisualProperties(xShape );
+        pFS->endElementNS(mnXmlNamespace, XML_nvGrpSpPr);
+    }
+    else
+        pFS->singleElementNS(mnXmlNamespace, XML_cNvGrpSpPr);
+
+    // visual properties
+    pFS->startElementNS(mnXmlNamespace, XML_grpSpPr);
+    WriteShapeTransformation(xShape, XML_a, false, false, true);
+    pFS->endElementNS(mnXmlNamespace, XML_grpSpPr);
+
+    uno::Reference<drawing::XShapes> xGroupShape(xShape, uno::UNO_QUERY_THROW);
+    uno::Reference<drawing::XShape> xParent = m_xParent;
+    m_xParent = xShape;
+    for (sal_Int32 i = 0; i < xGroupShape->getCount(); ++i)
+    {
+        uno::Reference<drawing::XShape> xChild(xGroupShape->getByIndex(i), uno::UNO_QUERY_THROW);
+        sal_Int32 nSavedNamespace = mnXmlNamespace;
+
+        uno::Reference<lang::XServiceInfo> xServiceInfo(xChild, uno::UNO_QUERY_THROW);
+        if (GetDocumentType() == DOCUMENT_DOCX)
+        {
+            // tdf#128820: WriteGraphicObjectShapePart calls WriteTextShape for non-empty simple
+            // text objects, which needs writing into wps::wsp element, so make sure to use wps
+            // namespace for those objects
+            if (xServiceInfo->supportsService("com.sun.star.drawing.GraphicObjectShape")
+                && !IsNonEmptySimpleText(xChild))
+                mnXmlNamespace = XML_pic;
+            else
+                mnXmlNamespace = XML_wps;
+        }
+        WriteShape(xChild);
+
+        mnXmlNamespace = nSavedNamespace;
+    }
+    m_xParent = xParent;
+
+    pFS->endElementNS(mnXmlNamespace, nGroupShapeToken);
+    return *this;
+}
+
+static bool lcl_IsOnBlacklist(OUString const & rShapeType)
+{
+    static const std::initializer_list<OUStringLiteral> vBlacklist = {
+        "block-arc",
+        "rectangle",
+        "ellipse",
+        "ring",
+        "can",
+        "cube",
+        "paper",
+        "frame",
+        "forbidden",
+        "smiley",
+        "sun",
+        "flower",
+        "bracket-pair",
+        "brace-pair",
+        "col-60da8460",
+        "col-502ad400",
+        "quad-bevel",
+        "round-rectangular-callout",
+        "rectangular-callout",
+        "round-callout",
+        "cloud-callout",
+        "line-callout-1",
+        "line-callout-2",
+        "line-callout-3",
+        "paper",
+        "vertical-scroll",
+        "horizontal-scroll",
+        "mso-spt34",
+        "mso-spt75",
+        "mso-spt164",
+        "mso-spt180",
+        "flowchart-process",
+        "flowchart-alternate-process",
+        "flowchart-decision",
+        "flowchart-data",
+        "flowchart-predefined-process",
+        "flowchart-internal-storage",
+        "flowchart-document",
+        "flowchart-multidocument",
+        "flowchart-terminator",
+        "flowchart-preparation",
+        "flowchart-manual-input",
+        "flowchart-manual-operation",
+        "flowchart-connector",
+        "flowchart-off-page-connector",
+        "flowchart-card",
+        "flowchart-punched-tape",
+        "flowchart-summing-junction",
+        "flowchart-or",
+        "flowchart-collate",
+        "flowchart-sort",
+        "flowchart-extract",
+        "flowchart-merge",
+        "flowchart-stored-data",
+        "flowchart-delay",
+        "flowchart-sequential-access",
+        "flowchart-magnetic-disk",
+        "flowchart-direct-access-storage",
+        "flowchart-display"
+    };
+
+    return std::find(vBlacklist.begin(), vBlacklist.end(), rShapeType) != vBlacklist.end();
+}
+
+static bool lcl_IsOnWhitelist(OUString const & rShapeType)
+{
+    static const std::initializer_list<OUStringLiteral> vWhitelist = {
+        "heart",
+        "puzzle"
+    };
+
+    return std::find(vWhitelist.begin(), vWhitelist.end(), rShapeType) != vWhitelist.end();
+}
+
+static bool lcl_GetHandlePosition( sal_Int32 &nValue, const EnhancedCustomShapeParameter &rParam, Sequence< EnhancedCustomShapeAdjustmentValue > &rSeq)
+{
+    bool bAdj = false;
+    if ( rParam.Value.getValueTypeClass() == TypeClass_DOUBLE )
+    {
+        double fValue(0.0);
+        if ( rParam.Value >>= fValue )
+            nValue = static_cast<sal_Int32>(fValue);
+    }
+    else
+        rParam.Value >>= nValue;
+
+    if ( rParam.Type == EnhancedCustomShapeParameterType::ADJUSTMENT)
+    {
+        bAdj = true;
+        sal_Int32 nIdx = nValue;
+        if ( nIdx < rSeq.getLength() )
+        {
+            if ( rSeq[ nIdx ] .Value.getValueTypeClass() == TypeClass_DOUBLE )
+            {
+                double fValue(0.0);
+                rSeq[ nIdx ].Value >>= fValue;
+                nValue = fValue;
+
+            }
+            else
+            {
+                rSeq[ nIdx ].Value >>= nValue;
+            }
+        }
+    }
+    return bAdj;
+}
+
+static void lcl_AnalyzeHandles( const uno::Sequence<beans::PropertyValues> & rHandles,
+        std::vector< std::pair< sal_Int32, sal_Int32> > &rHandlePositionList,
+        Sequence< EnhancedCustomShapeAdjustmentValue > &rSeq)
+{
+    for ( const Sequence< PropertyValue >& rPropSeq : rHandles )
+    {
+        const OUString sPosition( "Position"  );
+        bool bPosition = false;
+        EnhancedCustomShapeParameterPair aPosition;
+        for ( const PropertyValue& rPropVal: rPropSeq )
+        {
+            if ( rPropVal.Name == sPosition )
+            {
+                if ( rPropVal.Value >>= aPosition )
+                    bPosition = true;
+            }
+        }
+        if ( bPosition )
+        {
+            sal_Int32 nXPosition = 0;
+            sal_Int32 nYPosition = 0;
+            // For polar handles, nXPosition is radius and nYPosition is angle
+            lcl_GetHandlePosition( nXPosition, aPosition.First , rSeq );
+            lcl_GetHandlePosition( nYPosition, aPosition.Second, rSeq );
+            rHandlePositionList.emplace_back( nXPosition, nYPosition );
+        }
+    }
+}
+
+static void lcl_AppendAdjustmentValue( std::vector< std::pair< sal_Int32, sal_Int32> > &rAvList, sal_Int32 nAdjIdx, sal_Int32 nValue )
+{
+    rAvList.emplace_back( nAdjIdx , nValue );
+}
+
+static sal_Int32 lcl_NormalizeAngle( sal_Int32 nAngle )
+{
+    nAngle = nAngle % 360;
+    return nAngle < 0 ? ( nAngle + 360 ) : nAngle ;
+}
+
+static sal_Int32 lcl_CircleAngle2CustomShapeEllipseAngleOOX(const sal_Int32 nInternAngle, const sal_Int32 nWidth, const sal_Int32 nHeight)
+{
+    if (nWidth != 0 || nHeight != 0)
+    {
+        double fAngle = basegfx::deg2rad(nInternAngle / 100.0); // intern 1/100 deg to degree to rad
+        fAngle = atan2(nHeight * sin(fAngle), nWidth * cos(fAngle)); // circle to ellipse
+        fAngle = basegfx::rad2deg(fAngle) * 60000.0; // rad to degree to OOXML angle unit
+        sal_Int32 nAngle = basegfx::fround(fAngle); // normalize
+        nAngle = nAngle % 21600000;
+        return nAngle < 0 ? (nAngle + 21600000) : nAngle;
+    }
+    else // should be handled by caller, dummy value
+        return 0;
+}
+
+ShapeExport& ShapeExport::WriteCustomShape( const Reference< XShape >& xShape )
+{
+    // First check, if this is a Fontwork-shape. For DrawingML, such a shape is a
+    // TextBox shape with body property prstTxWarp.
+    SAL_INFO("oox.shape", "write custom shape");
+    Reference< XPropertySet > rXPropSet( xShape, UNO_QUERY );
+    bool bIsFontworkShape(false);
+    bool bHasGeometrySeq(false);
+    Sequence< PropertyValue > aGeometrySeq;
+    OUString sShapeType;
+    if (GETA(CustomShapeGeometry))
+    {
+        SAL_INFO("oox.shape", "got custom shape geometry");
+        if (mAny >>= aGeometrySeq)
+        {
+            bHasGeometrySeq = true;
+            SAL_INFO("oox.shape", "got custom shape geometry sequence");
+            for (const PropertyValue& rProp : std::as_const(aGeometrySeq))
+            {
+                SAL_INFO("oox.shape", "geometry property: " << rProp.Name);
+                if (rProp.Name == "TextPath")
+                {
+                    uno::Sequence<beans::PropertyValue> aTextPathSeq;
+                    rProp.Value >>= aTextPathSeq;
+                    for (const PropertyValue& rTextProp : std::as_const(aTextPathSeq))
+                    {
+                        if (rTextProp.Name == "TextPath")
+                        {
+                            rTextProp.Value >>= bIsFontworkShape;
+                        }
+                    }
+                }
+                else if (rProp.Name == "Type")
+                    rProp.Value >>= sShapeType;
+            }
+        }
+    }
+    if (bIsFontworkShape)
+    {
+        // write the correct type to m_presetWarp, WriteTextShape() needs it
+        // to set TextWarp.
+        m_presetWarp = PresetGeometryTypeNames::GetMsoName(sShapeType);
+        ShapeExport::WriteTextShape(xShape); // qualifier to prevent PowerPointShapeExport
+        return *this;
+    }
+
+
+    bool bPredefinedHandlesUsed = true;
+    bool bHasHandles = false;
+
+    ShapeFlag nMirrorFlags = ShapeFlag::NONE;
+    MSO_SPT eShapeType = EscherPropertyContainer::GetCustomShapeType( xShape, nMirrorFlags, sShapeType );
+    OSL_ENSURE(nullptr != dynamic_cast< SdrObjCustomShape* >(GetSdrObjectFromXShape(xShape)), "Not a SdrObjCustomShape (!)");
+    SdrObjCustomShape& rSdrObjCustomShape(static_cast< SdrObjCustomShape& >(*GetSdrObjectFromXShape(xShape)));
+    const bool bIsDefaultObject(
+        EscherPropertyContainer::IsDefaultObject(
+            rSdrObjCustomShape,
+            eShapeType));
+    const char* sPresetShape = msfilter::util::GetOOXMLPresetGeometry(sShapeType.toUtf8().getStr());
+    SAL_INFO("oox.shape", "custom shape type: " << sShapeType << " ==> " << sPresetShape);
+
+    sal_Int32 nAdjustmentValuesIndex = -1;
+    awt::Rectangle aViewBox;
+    uno::Sequence<beans::PropertyValues> aHandles;
+
+    bool bFlipH = false;
+    bool bFlipV = false;
+
+    // Avoid interference of preset type to the next shape
+    m_presetWarp = "";
+
+    if (bHasGeometrySeq)
+    {
+        for (int i = 0; i < aGeometrySeq.getLength(); i++)
+        {
+                const PropertyValue& rProp = aGeometrySeq[ i ];
+                SAL_INFO("oox.shape", "geometry property: " << rProp.Name);
+
+                if ( rProp.Name == "MirroredX" )
+                    rProp.Value >>= bFlipH;
+
+                if ( rProp.Name == "MirroredY" )
+                    rProp.Value >>= bFlipV;
+                if ( rProp.Name == "AdjustmentValues" )
+                    nAdjustmentValuesIndex = i;
+                else if ( rProp.Name == "Handles" )
+                {
+                    rProp.Value >>= aHandles;
+                    if ( aHandles.hasElements() )
+                        bHasHandles = true;
+                    if( !bIsDefaultObject )
+                        bPredefinedHandlesUsed = false;
+                    // TODO: update nAdjustmentsWhichNeedsToBeConverted here
+                }
+                else if ( rProp.Name == "PresetTextWarp" )
+                {
+                    rProp.Value >>= m_presetWarp;
+                }
+                else if ( rProp.Name == "ViewBox" )
+                    rProp.Value >>= aViewBox;
+        }
+    }
+
+    FSHelperPtr pFS = GetFS();
+    pFS->startElementNS(mnXmlNamespace, (GetDocumentType() != DOCUMENT_DOCX ? XML_sp : XML_wsp));
+
+    // non visual shape properties
+    if (GetDocumentType() != DOCUMENT_DOCX)
+    {
+        bool isVisible = true ;
+        if( GETA (Visible))
+        {
+            mAny >>= isVisible;
+        }
+        pFS->startElementNS( mnXmlNamespace, XML_nvSpPr );
+        pFS->startElementNS( mnXmlNamespace, XML_cNvPr,
+                XML_id, OString::number(GetNewShapeID(xShape)),
+                XML_name, IDS( CustomShape ),
+                XML_hidden, isVisible ? nullptr : "1" );
+
+        if( GETA( URL ) )
+        {
+            OUString sURL;
+            mAny >>= sURL;
+            if( !sURL.isEmpty() )
+            {
+                OUString sRelId = mpFB->addRelation( mpFS->getOutputStream(),
+                        oox::getRelationship(Relationship::HYPERLINK),
+                        mpURLTransformer->getTransformedString(sURL),
+                        mpURLTransformer->isExternalURL(sURL));
+
+                mpFS->singleElementNS(XML_a, XML_hlinkClick, FSNS(XML_r, XML_id), sRelId.toUtf8());
+            }
+        }
+        pFS->endElementNS(mnXmlNamespace, XML_cNvPr);
+        pFS->singleElementNS(mnXmlNamespace, XML_cNvSpPr);
+        WriteNonVisualProperties( xShape );
+        pFS->endElementNS( mnXmlNamespace, XML_nvSpPr );
+    }
+    else
+        pFS->singleElementNS(mnXmlNamespace, XML_cNvSpPr);
+
+    // visual shape properties
+    pFS->startElementNS(mnXmlNamespace, XML_spPr);
+    // moon is flipped in MSO, and mso-spt89 (right up arrow) is mapped to leftUpArrow
+    if ( sShapeType == "moon" || sShapeType == "mso-spt89" )
+        bFlipH = !bFlipH;
+
+    // we export non-primitive shapes to custom geometry
+    // we also export non-ooxml shapes which have handles/equations to custom geometry, because
+    // we cannot convert ODF equations to DrawingML equations. TODO: see what binary DOC export filter does.
+    // but our WritePolyPolygon()/WriteCustomGeometry() functions are incomplete, therefore we use a blacklist
+    // we use a whitelist for shapes where mapping to MSO preset shape is not optimal
+    bool bCustGeom = true;
+    bool bOnBlacklist = false;
+    if( sShapeType == "ooxml-non-primitive" )
+        bCustGeom = true;
+    else if( sShapeType.startsWith("ooxml") )
+        bCustGeom = false;
+    else if( lcl_IsOnWhitelist(sShapeType) )
+        bCustGeom = true;
+    else if( lcl_IsOnBlacklist(sShapeType) )
+    {
+        bCustGeom = false;
+        bOnBlacklist = true;
+    }
+    else if( bHasHandles )
+        bCustGeom = true;
+
+    if (bHasHandles && bCustGeom)
+    {
+        WriteShapeTransformation( xShape, XML_a, bFlipH, bFlipV, false, true );// do not flip, polypolygon coordinates are flipped already
+        tools::PolyPolygon aPolyPolygon( rSdrObjCustomShape.GetLineGeometry(true) );
+        sal_Int32 nRotation = 0;
+        // The RotateAngle property's value is independent from any flipping, and that's exactly what we need here.
+        uno::Reference<beans::XPropertySet> xPropertySet(xShape, uno::UNO_QUERY);
+        uno::Reference<beans::XPropertySetInfo> xPropertySetInfo = xPropertySet->getPropertySetInfo();
+        if (xPropertySetInfo->hasPropertyByName("RotateAngle"))
+            xPropertySet->getPropertyValue("RotateAngle") >>= nRotation;
+        // Remove rotation
+        bool bInvertRotation = bFlipH != bFlipV;
+        if (nRotation != 0)
+            aPolyPolygon.Rotate(Point(0,0), static_cast<sal_uInt16>(bInvertRotation ? nRotation/10 : 3600-nRotation/10));
+        WritePolyPolygon( aPolyPolygon, false );
+    }
+    else if (bCustGeom)
+    {
+        WriteShapeTransformation( xShape, XML_a, bFlipH, bFlipV );
+        bool bSuccess = WriteCustomGeometry(xShape, rSdrObjCustomShape);
+        if (!bSuccess)
+            WritePresetShape( sPresetShape );
+    }
+    else if (bOnBlacklist && bHasHandles && nAdjustmentValuesIndex !=-1 && !sShapeType.startsWith("mso-spt"))
+    {
+        WriteShapeTransformation( xShape, XML_a, bFlipH, bFlipV );
+        Sequence< EnhancedCustomShapeAdjustmentValue > aAdjustmentSeq;
+        std::vector< std::pair< sal_Int32, sal_Int32> > aHandlePositionList;
+        std::vector< std::pair< sal_Int32, sal_Int32> > aAvList;
+        aGeometrySeq[ nAdjustmentValuesIndex ].Value >>= aAdjustmentSeq ;
+
+        lcl_AnalyzeHandles( aHandles, aHandlePositionList, aAdjustmentSeq );
+
+        sal_Int32 nXPosition = 0;
+        sal_Int32 nYPosition = 0;
+        if ( !aHandlePositionList.empty() )
+        {
+            nXPosition = aHandlePositionList[0].first ;
+            nYPosition = aHandlePositionList[0].second ;
+        }
+        switch( eShapeType )
+        {
+            case mso_sptBorderCallout1:
+            {
+                sal_Int32 adj3 =  double(nYPosition)/aViewBox.Height *100000;
+                sal_Int32 adj4 =  double(nXPosition)/aViewBox.Width *100000;
+                lcl_AppendAdjustmentValue( aAvList, 1, 18750 );
+                lcl_AppendAdjustmentValue( aAvList, 2, -8333 );
+                lcl_AppendAdjustmentValue( aAvList, 3, adj3 );
+                lcl_AppendAdjustmentValue( aAvList, 4, adj4 );
+                break;
+            }
+            case mso_sptBorderCallout2:
+            {
+                sal_Int32 adj5 =  double(nYPosition)/aViewBox.Height *100000;
+                sal_Int32 adj6 =  double(nXPosition)/aViewBox.Width *100000;
+                sal_Int32 adj3 =  18750;
+                sal_Int32 adj4 =  -16667;
+                lcl_AppendAdjustmentValue( aAvList, 1, 18750 );
+                lcl_AppendAdjustmentValue( aAvList, 2, -8333 );
+                if ( aHandlePositionList.size() > 1 )
+                {
+                    nXPosition = aHandlePositionList[1].first ;
+                    nYPosition = aHandlePositionList[1].second ;
+                    adj3 =  double(nYPosition)/aViewBox.Height *100000;
+                    adj4 =  double(nXPosition)/aViewBox.Width *100000;
+                }
+                lcl_AppendAdjustmentValue( aAvList, 3, adj3 );
+                lcl_AppendAdjustmentValue( aAvList, 4, adj4 );
+                lcl_AppendAdjustmentValue( aAvList, 5, adj5 );
+                lcl_AppendAdjustmentValue( aAvList, 6, adj6 );
+                break;
+            }
+            case mso_sptWedgeRectCallout:
+            case mso_sptWedgeRRectCallout:
+            case mso_sptWedgeEllipseCallout:
+            case mso_sptCloudCallout:
+            {
+                sal_Int32 adj1 =  (double(nXPosition)/aViewBox.Width -0.5) *100000;
+                sal_Int32 adj2 =  (double(nYPosition)/aViewBox.Height -0.5) *100000;
+                lcl_AppendAdjustmentValue( aAvList, 1, adj1 );
+                lcl_AppendAdjustmentValue( aAvList, 2, adj2 );
+                if ( eShapeType == mso_sptWedgeRRectCallout)
+                {
+                    lcl_AppendAdjustmentValue( aAvList, 3, 16667);
+                }
+
+                break;
+            }
+            case mso_sptFoldedCorner:
+            {
+                sal_Int32 adj =  double( aViewBox.Width - nXPosition) / std::min( aViewBox.Width,aViewBox.Height ) * 100000;
+                lcl_AppendAdjustmentValue( aAvList, 0, adj );
+                break;
+            }
+            case mso_sptDonut:
+            case mso_sptSun:
+            case mso_sptMoon:
+            case mso_sptNoSmoking:
+            case mso_sptHorizontalScroll:
+            case mso_sptBevel:
+            case mso_sptBracketPair:
+            {
+                sal_Int32 adj =  double( nXPosition )/aViewBox.Width*100000 ;
+                lcl_AppendAdjustmentValue( aAvList, 0, adj );
+                break;
+            }
+            case mso_sptCan:
+            case mso_sptCube:
+            case mso_sptBracePair:
+            case mso_sptVerticalScroll:
+            {
+                sal_Int32 adj =  double( nYPosition )/aViewBox.Height *100000 ;
+                lcl_AppendAdjustmentValue( aAvList, 0, adj );
+                break;
+            }
+            case mso_sptSmileyFace:
+            {
+                sal_Int32 adj =  double( nYPosition )/aViewBox.Height *100000 - 76458.0;
+                lcl_AppendAdjustmentValue( aAvList, 0, adj );
+                break;
+            }
+            case mso_sptBlockArc:
+            {
+                sal_Int32 nRadius = 50000 * ( 1 - double(nXPosition) / 10800);
+                sal_Int32 nAngleStart = lcl_NormalizeAngle( nYPosition );
+                sal_Int32 nAngleEnd = lcl_NormalizeAngle( 180 - nAngleStart );
+                lcl_AppendAdjustmentValue( aAvList, 1, 21600000 / 360 * nAngleStart );
+                lcl_AppendAdjustmentValue( aAvList, 2, 21600000 / 360 * nAngleEnd );
+                lcl_AppendAdjustmentValue( aAvList, 3, nRadius );
+                break;
+            }
+            // case mso_sptNil:
+            // case mso_sptBentConnector3:
+            // case mso_sptBorderCallout3:
+            default:
+            {
+                if (!strcmp( sPresetShape, "frame" ))
+                {
+                    sal_Int32 adj1 =  double( nYPosition )/aViewBox.Height *100000 ;
+                    lcl_AppendAdjustmentValue( aAvList, 1, adj1 );
+                }
+                break;
+            }
+        }
+        WritePresetShape( sPresetShape  , aAvList );
+    }
+    else // preset geometry
+    {
+        WriteShapeTransformation( xShape, XML_a, bFlipH, bFlipV );
+        if( nAdjustmentValuesIndex != -1 )
+        {
+            WritePresetShape( sPresetShape, eShapeType, bPredefinedHandlesUsed,
+                              aGeometrySeq[ nAdjustmentValuesIndex ] );
+        }
+        else
+            WritePresetShape( sPresetShape );
+    }
+    if( rXPropSet.is() )
+    {
+        WriteFill( rXPropSet );
+        WriteOutline( rXPropSet );
+        WriteShapeEffects( rXPropSet );
+
+        bool bHas3DEffectinShape = false;
+        uno::Sequence<beans::PropertyValue> grabBag;
+        rXPropSet->getPropertyValue("InteropGrabBag") >>= grabBag;
+
+        for (auto const& it : std::as_const(grabBag))
+            if (it.Name == "3DEffectProperties")
+                bHas3DEffectinShape = true;
+
+        if( bHas3DEffectinShape)
+            WriteShape3DEffects( rXPropSet );
+    }
+
+    pFS->endElementNS( mnXmlNamespace, XML_spPr );
+
+    pFS->startElementNS(mnXmlNamespace, XML_style);
+    WriteShapeStyle( rXPropSet );
+    pFS->endElementNS( mnXmlNamespace, XML_style );
+
+    // write text
+    WriteTextBox( xShape, mnXmlNamespace );
+
+    pFS->endElementNS( mnXmlNamespace, (GetDocumentType() != DOCUMENT_DOCX ? XML_sp : XML_wsp) );
+
+    return *this;
+}
+
+ShapeExport& ShapeExport::WriteEllipseShape( const Reference< XShape >& xShape )
+{
+    SAL_INFO("oox.shape", "write ellipse shape");
+
+    FSHelperPtr pFS = GetFS();
+
+    pFS->startElementNS(mnXmlNamespace, (GetDocumentType() != DOCUMENT_DOCX ? XML_sp : XML_wsp));
+
+    // TODO: connector ?
+
+    // non visual shape properties
+    if (GetDocumentType() != DOCUMENT_DOCX)
+    {
+        pFS->startElementNS(mnXmlNamespace, XML_nvSpPr);
+        pFS->singleElementNS( mnXmlNamespace, XML_cNvPr,
+                XML_id, OString::number(GetNewShapeID(xShape)),
+                XML_name, IDS( Ellipse ) );
+        pFS->singleElementNS( mnXmlNamespace, XML_cNvSpPr );
+        WriteNonVisualProperties( xShape );
+        pFS->endElementNS( mnXmlNamespace, XML_nvSpPr );
+    }
+    else
+        pFS->singleElementNS(mnXmlNamespace, XML_cNvSpPr);
+
+    Reference< XPropertySet > xProps( xShape, UNO_QUERY );
+    CircleKind  eCircleKind(CircleKind_FULL);
+    if (xProps.is())
+        xProps->getPropertyValue("CircleKind" ) >>= eCircleKind;
+
+    // visual shape properties
+    pFS->startElementNS( mnXmlNamespace, XML_spPr );
+    WriteShapeTransformation( xShape, XML_a );
+
+    if (CircleKind_FULL == eCircleKind)
+        WritePresetShape("ellipse");
+    else
+    {
+        sal_Int32 nStartAngleIntern(9000);
+        sal_Int32 nEndAngleIntern(0);
+        if (xProps.is())
+        {
+           xProps->getPropertyValue("CircleStartAngle" ) >>= nStartAngleIntern;
+           xProps->getPropertyValue("CircleEndAngle") >>= nEndAngleIntern;
+        }
+        std::vector< std::pair<sal_Int32,sal_Int32>> aAvList;
+        awt::Size aSize = xShape->getSize();
+        if (aSize.Width != 0 || aSize.Height != 0)
+        {
+            // Our arc has 90° up, OOXML has 90° down, so mirror it.
+            // API angles are 1/100 degree.
+            sal_Int32 nStartAngleOOXML(lcl_CircleAngle2CustomShapeEllipseAngleOOX(36000 - nEndAngleIntern, aSize.Width, aSize.Height));
+            sal_Int32 nEndAngleOOXML(lcl_CircleAngle2CustomShapeEllipseAngleOOX(36000 - nStartAngleIntern, aSize.Width, aSize.Height));
+            lcl_AppendAdjustmentValue( aAvList, 1, nStartAngleOOXML);
+            lcl_AppendAdjustmentValue( aAvList, 2, nEndAngleOOXML);
+        }
+        switch (eCircleKind)
+        {
+            case CircleKind_ARC :
+                WritePresetShape("arc", aAvList);
+            break;
+            case CircleKind_SECTION :
+                WritePresetShape("pie", aAvList);
+            break;
+            case CircleKind_CUT :
+                WritePresetShape("chord", aAvList);
+            break;
+        default :
+            WritePresetShape("ellipse");
+        }
+    }
+    if( xProps.is() )
+    {
+        if (CircleKind_ARC == eCircleKind)
+        {
+            // An arc in ODF is never filled, even if a fill style other than
+            // "none" is set. OOXML arc can be filled, so set fill explicit to
+            // NONE, otherwise some hidden or inherited filling is shown.
+            FillStyle eFillStyle(FillStyle_NONE);
+            uno::Any aNewValue;
+            aNewValue <<= eFillStyle;
+            xProps->setPropertyValue("FillStyle", aNewValue);
+        }
+        WriteFill( xProps );
+        WriteOutline( xProps );
+    }
+    pFS->endElementNS( mnXmlNamespace, XML_spPr );
+
+    // write text
+    WriteTextBox( xShape, mnXmlNamespace );
+
+    pFS->endElementNS( mnXmlNamespace, (GetDocumentType() != DOCUMENT_DOCX ? XML_sp : XML_wsp) );
+
+    return *this;
+}
+
+ShapeExport& ShapeExport::WriteGraphicObjectShape( const Reference< XShape >& xShape )
+{
+    WriteGraphicObjectShapePart( xShape );
+
+    return *this;
+}
+
+void ShapeExport::WriteGraphicObjectShapePart( const Reference< XShape >& xShape, const Graphic* pGraphic )
+{
+    SAL_INFO("oox.shape", "write graphic object shape");
+
+    if (IsNonEmptySimpleText(xShape))
+    {
+        SAL_INFO("oox.shape", "graphicObject: wrote only text");
+
+        WriteTextShape(xShape);
+
+        return;
+    }
+
+    SAL_INFO("oox.shape", "graphicObject without text");
+
+    uno::Reference<graphic::XGraphic> xGraphic;
+    OUString sMediaURL;
+
+    Reference< XPropertySet > xShapeProps( xShape, UNO_QUERY );
+
+    if (pGraphic)
+    {
+        xGraphic.set(pGraphic->GetXGraphic());
+    }
+    else if (xShapeProps.is() && xShapeProps->getPropertySetInfo()->hasPropertyByName("Graphic"))
+    {
+        xShapeProps->getPropertyValue("Graphic") >>= xGraphic;
+    }
+
+    bool bHasMediaURL = xShapeProps.is() && xShapeProps->getPropertySetInfo()->hasPropertyByName("MediaURL") && (xShapeProps->getPropertyValue("MediaURL") >>= sMediaURL);
+
+    if (!xGraphic.is() && !bHasMediaURL)
+    {
+        SAL_INFO("oox.shape", "no graphic or media URL found");
+        return;
+    }
+
+    FSHelperPtr pFS = GetFS();
+    XmlFilterBase* pFB = GetFB();
+
+    if (GetDocumentType() != DOCUMENT_DOCX)
+        pFS->startElementNS(mnXmlNamespace, XML_pic);
+    else
+        pFS->startElementNS(mnXmlNamespace, XML_pic,
+            FSNS(XML_xmlns, XML_pic), pFB->getNamespaceURL(OOX_NS(dmlPicture)).toUtf8());
+
+    pFS->startElementNS(mnXmlNamespace, XML_nvPicPr);
+
+    OUString sName, sDescr, sURL;
+    bool bHaveName, bHaveDesc;
+
+    if ( ( bHaveName= GetProperty( xShapeProps, "Name" ) ) )
+        mAny >>= sName;
+    if ( ( bHaveDesc = GetProperty( xShapeProps, "Description" ) ) )
+        mAny >>= sDescr;
+    if ( GetProperty( xShapeProps, "URL" ) )
+        mAny >>= sURL;
+
+    pFS->startElementNS( mnXmlNamespace, XML_cNvPr,
+                          XML_id,     OString::number(GetNewShapeID(xShape)),
+                          XML_name,   bHaveName
+                                          ? sName.toUtf8()
+                                          : OString("Picture " + OString::number(mnPictureIdMax++)),
+                          XML_descr,  bHaveDesc ? sDescr.toUtf8().getStr() : nullptr );
+
+    // OOXTODO: //cNvPr children: XML_extLst, XML_hlinkHover
+    if (bHasMediaURL)
+        pFS->singleElementNS(XML_a, XML_hlinkClick,
+                             FSNS(XML_r, XML_id), "",
+                             XML_action, "ppaction://media");
+    if( !sURL.isEmpty() )
+    {
+        OUString sRelId = mpFB->addRelation( mpFS->getOutputStream(),
+                oox::getRelationship(Relationship::HYPERLINK),
+                mpURLTransformer->getTransformedString(sURL),
+                mpURLTransformer->isExternalURL(sURL));
+
+        mpFS->singleElementNS(XML_a, XML_hlinkClick, FSNS(XML_r, XML_id), sRelId.toUtf8());
+    }
+    pFS->endElementNS(mnXmlNamespace, XML_cNvPr);
+
+    pFS->singleElementNS(mnXmlNamespace, XML_cNvPicPr
+                         // OOXTODO: XML_preferRelativeSize
+                        );
+    if (bHasMediaURL)
+        WriteMediaNonVisualProperties(xShape);
+    else
+        WriteNonVisualProperties(xShape);
+
+    pFS->endElementNS( mnXmlNamespace, XML_nvPicPr );
+
+    pFS->startElementNS(mnXmlNamespace, XML_blipFill);
+
+    if (xGraphic.is())
+    {
+        WriteXGraphicBlip(xShapeProps, xGraphic, false);
+    }
+    else if (bHasMediaURL)
+    {
+        Reference<graphic::XGraphic> xFallbackGraphic;
+        if (xShapeProps->getPropertySetInfo()->hasPropertyByName("FallbackGraphic"))
+            xShapeProps->getPropertyValue("FallbackGraphic") >>= xFallbackGraphic;
+
+        WriteXGraphicBlip(xShapeProps, xFallbackGraphic, false);
+    }
+
+    if (xGraphic.is())
+    {
+        WriteSrcRectXGraphic(xShapeProps, xGraphic);
+    }
+
+    // now we stretch always when we get pGraphic (when changing that
+    // behavior, test n#780830 for regression, where the OLE sheet might get tiled
+    bool bStretch = false;
+    if( !pGraphic && GetProperty( xShapeProps, "FillBitmapStretch" ) )
+        mAny >>= bStretch;
+
+    if ( pGraphic || bStretch )
+        pFS->singleElementNS(XML_a, XML_stretch);
+
+    pFS->endElementNS( mnXmlNamespace, XML_blipFill );
+
+    // visual shape properties
+    pFS->startElementNS(mnXmlNamespace, XML_spPr);
+    bool bFlipH = false;
+    if( xShapeProps->getPropertySetInfo()->hasPropertyByName("IsMirrored") )
+    {
+        xShapeProps->getPropertyValue("IsMirrored") >>= bFlipH;
+    }
+    WriteShapeTransformation( xShape, XML_a, bFlipH, false, false, false, true );
+    WritePresetShape( "rect" );
+    // graphic object can come with the frame (bnc#654525)
+    WriteOutline( xShapeProps );
+
+    WriteShapeEffects( xShapeProps );
+    WriteShape3DEffects( xShapeProps );
+
+    pFS->endElementNS( mnXmlNamespace, XML_spPr );
+
+    pFS->endElementNS( mnXmlNamespace, XML_pic );
+}
+
+ShapeExport& ShapeExport::WriteConnectorShape( const Reference< XShape >& xShape )
+{
+    bool bFlipH = false;
+    bool bFlipV = false;
+
+    SAL_INFO("oox.shape", "write connector shape");
+
+    FSHelperPtr pFS = GetFS();
+
+    const char* sGeometry = "line";
+    Reference< XPropertySet > rXPropSet( xShape, UNO_QUERY );
+    Reference< XPropertyState > rXPropState( xShape, UNO_QUERY );
+    awt::Point aStartPoint, aEndPoint;
+    Reference< XShape > rXShapeA;
+    Reference< XShape > rXShapeB;
+    PropertyState eState;
+    ConnectorType eConnectorType;
+    if( GETAD( EdgeKind ) ) {
+        mAny >>= eConnectorType;
+
+        switch( eConnectorType ) {
+            case ConnectorType_CURVE:
+                sGeometry = "curvedConnector3";
+                break;
+            case ConnectorType_STANDARD:
+                sGeometry = "bentConnector3";
+                break;
+            default:
+            case ConnectorType_LINE:
+            case ConnectorType_LINES:
+                sGeometry = "straightConnector1";
+                break;
+        }
+
+        if( GETAD( EdgeStartPoint ) ) {
+            mAny >>= aStartPoint;
+            if( GETAD( EdgeEndPoint ) ) {
+                mAny >>= aEndPoint;
+            }
+        }
+        GET( rXShapeA, EdgeStartConnection );
+        GET( rXShapeB, EdgeEndConnection );
+    }
+    EscherConnectorListEntry aConnectorEntry( xShape, aStartPoint, rXShapeA, aEndPoint, rXShapeB );
+
+    tools::Rectangle aRect( Point( aStartPoint.X, aStartPoint.Y ), Point( aEndPoint.X, aEndPoint.Y ) );
+    if( aRect.getWidth() < 0 ) {
+        bFlipH = true;
+        aRect.setX( aEndPoint.X );
+        aRect.setWidth( aStartPoint.X - aEndPoint.X );
+    }
+
+    if( aRect.getHeight() < 0 ) {
+        bFlipV = true;
+        aRect.setY( aEndPoint.Y );
+        aRect.setHeight( aStartPoint.Y - aEndPoint.Y );
+    }
+
+    pFS->startElementNS(mnXmlNamespace, XML_cxnSp);
+
+    // non visual shape properties
+    pFS->startElementNS(mnXmlNamespace, XML_nvCxnSpPr);
+    pFS->singleElementNS( mnXmlNamespace, XML_cNvPr,
+                          XML_id, OString::number(GetNewShapeID(xShape)),
+                          XML_name, IDS( Line ) );
+    // non visual connector shape drawing properties
+    pFS->startElementNS(mnXmlNamespace, XML_cNvCxnSpPr);
+    WriteConnectorConnections( aConnectorEntry, GetShapeID( rXShapeA ), GetShapeID( rXShapeB ) );
+    pFS->endElementNS( mnXmlNamespace, XML_cNvCxnSpPr );
+    pFS->singleElementNS(mnXmlNamespace, XML_nvPr);
+    pFS->endElementNS( mnXmlNamespace, XML_nvCxnSpPr );
+
+    // visual shape properties
+    pFS->startElementNS(mnXmlNamespace, XML_spPr);
+    WriteTransformation( aRect, XML_a, bFlipH, bFlipV );
+    // TODO: write adjustments (ppt export doesn't work well there either)
+    WritePresetShape( sGeometry );
+    Reference< XPropertySet > xShapeProps( xShape, UNO_QUERY );
+    if( xShapeProps.is() )
+        WriteOutline( xShapeProps );
+    pFS->endElementNS( mnXmlNamespace, XML_spPr );
+
+    // write text
+    WriteTextBox( xShape, mnXmlNamespace );
+
+    pFS->endElementNS( mnXmlNamespace, XML_cxnSp );
+
+    return *this;
+}
+
+ShapeExport& ShapeExport::WriteLineShape( const Reference< XShape >& xShape )
+{
+    bool bFlipH = false;
+    bool bFlipV = false;
+
+    SAL_INFO("oox.shape", "write line shape");
+
+    FSHelperPtr pFS = GetFS();
+
+    pFS->startElementNS(mnXmlNamespace, (GetDocumentType() != DOCUMENT_DOCX ? XML_sp : XML_wsp));
+
+    tools::PolyPolygon aPolyPolygon = EscherPropertyContainer::GetPolyPolygon( xShape );
+    if( aPolyPolygon.Count() == 1 && aPolyPolygon[ 0 ].GetSize() == 2)
+    {
+        const tools::Polygon& rPoly = aPolyPolygon[ 0 ];
+
+        bFlipH = ( rPoly[ 0 ].X() > rPoly[ 1 ].X() );
+        bFlipV = ( rPoly[ 0 ].Y() > rPoly[ 1 ].Y() );
+    }
+
+    // non visual shape properties
+    if (GetDocumentType() != DOCUMENT_DOCX)
+    {
+        pFS->startElementNS(mnXmlNamespace, XML_nvSpPr);
+        pFS->singleElementNS( mnXmlNamespace, XML_cNvPr,
+                              XML_id, OString::number(GetNewShapeID(xShape)),
+                              XML_name, IDS( Line ) );
+    }
+    pFS->singleElementNS( mnXmlNamespace, XML_cNvSpPr );
+    if (GetDocumentType() != DOCUMENT_DOCX)
+    {
+        WriteNonVisualProperties( xShape );
+        pFS->endElementNS( mnXmlNamespace, XML_nvSpPr );
+    }
+
+    // visual shape properties
+    pFS->startElementNS(mnXmlNamespace, XML_spPr);
+    WriteShapeTransformation( xShape, XML_a, bFlipH, bFlipV, true);
+    WritePresetShape( "line" );
+    Reference< XPropertySet > xShapeProps( xShape, UNO_QUERY );
+    if( xShapeProps.is() )
+        WriteOutline( xShapeProps );
+    pFS->endElementNS( mnXmlNamespace, XML_spPr );
+
+    //write style
+    pFS->startElementNS(mnXmlNamespace, XML_style);
+    WriteShapeStyle( xShapeProps );
+    pFS->endElementNS( mnXmlNamespace, XML_style );
+
+    // write text
+    WriteTextBox( xShape, mnXmlNamespace );
+
+    pFS->endElementNS( mnXmlNamespace, (GetDocumentType() != DOCUMENT_DOCX ? XML_sp : XML_wsp) );
+
+    return *this;
+}
+
+ShapeExport& ShapeExport::WriteNonVisualDrawingProperties( const Reference< XShape >& xShape, const char* pName )
+{
+    GetFS()->singleElementNS( mnXmlNamespace, XML_cNvPr,
+                              XML_id, OString::number(GetNewShapeID(xShape)),
+                              XML_name, pName );
+
+    return *this;
+}
+
+ShapeExport& ShapeExport::WriteNonVisualProperties( const Reference< XShape >& )
+{
+    // Override to generate //nvPr elements.
+    return *this;
+}
+
+ShapeExport& ShapeExport::WriteRectangleShape( const Reference< XShape >& xShape )
+{
+    SAL_INFO("oox.shape", "write rectangle shape");
+
+    FSHelperPtr pFS = GetFS();
+
+    pFS->startElementNS(mnXmlNamespace, (GetDocumentType() != DOCUMENT_DOCX ? XML_sp : XML_wsp));
+
+    sal_Int32 nRadius = 0;
+
+    Reference< XPropertySet > xShapeProps( xShape, UNO_QUERY );
+    if( xShapeProps.is() )
+    {
+        xShapeProps->getPropertyValue( "CornerRadius" ) >>= nRadius;
+    }
+
+    if( nRadius )
+    {
+        nRadius = MapSize( awt::Size( nRadius, 0 ) ).Width;
+    }
+    //TODO: use nRadius value more precisely than just deciding whether to use
+    // "rect" or "roundRect" preset shape below
+
+    // non visual shape properties
+    if (GetDocumentType() == DOCUMENT_DOCX)
+        pFS->singleElementNS(mnXmlNamespace, XML_cNvSpPr);
+    pFS->startElementNS(mnXmlNamespace, XML_nvSpPr);
+    pFS->singleElementNS( mnXmlNamespace, XML_cNvPr,
+                          XML_id, OString::number(GetNewShapeID(xShape)),
+                          XML_name, IDS( Rectangle ) );
+    pFS->singleElementNS(mnXmlNamespace, XML_cNvSpPr);
+    WriteNonVisualProperties( xShape );
+    pFS->endElementNS( mnXmlNamespace, XML_nvSpPr );
+
+    // visual shape properties
+    pFS->startElementNS(mnXmlNamespace, XML_spPr);
+    WriteShapeTransformation( xShape, XML_a );
+    WritePresetShape( nRadius == 0 ? "rect" : "roundRect" );
+    Reference< XPropertySet > xProps( xShape, UNO_QUERY );
+    if( xProps.is() )
+    {
+        WriteFill( xProps );
+        WriteOutline( xProps );
+    }
+    pFS->endElementNS( mnXmlNamespace, XML_spPr );
+
+    // write text
+    WriteTextBox( xShape, mnXmlNamespace );
+
+    pFS->endElementNS( mnXmlNamespace, (GetDocumentType() != DOCUMENT_DOCX ? XML_sp : XML_wsp) );
+
+    return *this;
+}
+
+typedef ShapeExport& (ShapeExport::*ShapeConverter)( const Reference< XShape >& );
+typedef std::unordered_map< const char*, ShapeConverter, rtl::CStringHash, rtl::CStringEqual> NameToConvertMapType;
+
+static const NameToConvertMapType& lcl_GetConverters()
+{
+    static NameToConvertMapType const shape_converters
+    {
+        { "com.sun.star.drawing.ClosedBezierShape"         , &ShapeExport::WriteClosedPolyPolygonShape },
+        { "com.sun.star.drawing.ConnectorShape"            , &ShapeExport::WriteConnectorShape },
+        { "com.sun.star.drawing.CustomShape"               , &ShapeExport::WriteCustomShape },
+        { "com.sun.star.drawing.EllipseShape"              , &ShapeExport::WriteEllipseShape },
+        { "com.sun.star.drawing.GraphicObjectShape"        , &ShapeExport::WriteGraphicObjectShape },
+        { "com.sun.star.drawing.LineShape"                 , &ShapeExport::WriteLineShape },
+        { "com.sun.star.drawing.OpenBezierShape"           , &ShapeExport::WriteOpenPolyPolygonShape },
+        { "com.sun.star.drawing.PolyPolygonShape"          , &ShapeExport::WriteClosedPolyPolygonShape },
+        { "com.sun.star.drawing.PolyLineShape"             , &ShapeExport::WriteOpenPolyPolygonShape },
+        { "com.sun.star.drawing.RectangleShape"            , &ShapeExport::WriteRectangleShape },
+        { "com.sun.star.drawing.OLE2Shape"                 , &ShapeExport::WriteOLE2Shape },
+        { "com.sun.star.drawing.TableShape"                , &ShapeExport::WriteTableShape },
+        { "com.sun.star.drawing.TextShape"                 , &ShapeExport::WriteTextShape },
+        { "com.sun.star.drawing.GroupShape"                , &ShapeExport::WriteGroupShape },
+
+        { "com.sun.star.presentation.GraphicObjectShape"   , &ShapeExport::WriteGraphicObjectShape },
+        { "com.sun.star.presentation.MediaShape"           , &ShapeExport::WriteGraphicObjectShape },
+        { "com.sun.star.presentation.ChartShape"           , &ShapeExport::WriteOLE2Shape },
+        { "com.sun.star.presentation.OLE2Shape"            , &ShapeExport::WriteOLE2Shape },
+        { "com.sun.star.presentation.TableShape"           , &ShapeExport::WriteTableShape },
+        { "com.sun.star.presentation.TextShape"            , &ShapeExport::WriteTextShape },
+
+        { "com.sun.star.presentation.DateTimeShape"        , &ShapeExport::WriteTextShape },
+        { "com.sun.star.presentation.FooterShape"          , &ShapeExport::WriteTextShape },
+        { "com.sun.star.presentation.HeaderShape"          , &ShapeExport::WriteTextShape },
+        { "com.sun.star.presentation.NotesShape"           , &ShapeExport::WriteTextShape },
+        { "com.sun.star.presentation.OutlinerShape"        , &ShapeExport::WriteTextShape },
+        { "com.sun.star.presentation.SlideNumberShape"     , &ShapeExport::WriteTextShape },
+        { "com.sun.star.presentation.TitleTextShape"       , &ShapeExport::WriteTextShape },
+    };
+    return shape_converters;
+}
+
+ShapeExport& ShapeExport::WriteShape( const Reference< XShape >& xShape )
+{
+    OUString sShapeType = xShape->getShapeType();
+    SAL_INFO("oox.shape", "write shape: " << sShapeType);
+    NameToConvertMapType::const_iterator aConverter
+        = lcl_GetConverters().find(sShapeType.toUtf8().getStr());
+    if (aConverter == lcl_GetConverters().end())
+    {
+        SAL_INFO("oox.shape", "unknown shape");
+        return WriteUnknownShape( xShape );
+    }
+    (this->*(aConverter->second))( xShape );
+
+    return *this;
+}
+
+ShapeExport& ShapeExport::WriteTextBox( const Reference< XInterface >& xIface, sal_Int32 nXmlNamespace )
+{
+    // In case this shape has an associated textbox, then export that, and we're done.
+    if (GetDocumentType() == DOCUMENT_DOCX && GetTextExport())
+    {
+        uno::Reference<beans::XPropertySet> xPropertySet(xIface, uno::UNO_QUERY);
+        if (xPropertySet.is())
+        {
+            uno::Reference<beans::XPropertySetInfo> xPropertySetInfo = xPropertySet->getPropertySetInfo();
+            if (xPropertySetInfo->hasPropertyByName("TextBox") && xPropertySet->getPropertyValue("TextBox").get<bool>())
+            {
+                GetTextExport()->WriteTextBox(uno::Reference<drawing::XShape>(xIface, uno::UNO_QUERY_THROW));
+                WriteText( xIface, m_presetWarp, /*bBodyPr=*/true, /*bText=*/false, /*nXmlNamespace=*/nXmlNamespace );
+                return *this;
+            }
+        }
+    }
+
+    Reference< XText > xXText( xIface, UNO_QUERY );
+    if( NonEmptyText( xIface ) && xXText.is() )
+    {
+        FSHelperPtr pFS = GetFS();
+
+        pFS->startElementNS(nXmlNamespace,
+                            (GetDocumentType() != DOCUMENT_DOCX ? XML_txBody : XML_txbx));
+        WriteText( xIface, m_presetWarp, /*bBodyPr=*/(GetDocumentType() != DOCUMENT_DOCX) );
+        pFS->endElementNS( nXmlNamespace, (GetDocumentType() != DOCUMENT_DOCX ? XML_txBody : XML_txbx) );
+        if (GetDocumentType() == DOCUMENT_DOCX)
+            WriteText( xIface, m_presetWarp, /*bBodyPr=*/true, /*bText=*/false, /*nXmlNamespace=*/nXmlNamespace );
+    }
+    else if (GetDocumentType() == DOCUMENT_DOCX)
+        mpFS->singleElementNS(nXmlNamespace, XML_bodyPr);
+
+    return *this;
+}
+
+void ShapeExport::WriteTable( const Reference< XShape >& rXShape  )
+{
+    Reference< XTable > xTable;
+    Reference< XPropertySet > xPropSet( rXShape, UNO_QUERY );
+
+    mpFS->startElementNS(XML_a, XML_graphic);
+    mpFS->startElementNS(XML_a, XML_graphicData,
+                         XML_uri, "http://schemas.openxmlformats.org/drawingml/2006/table");
+
+    if ( xPropSet.is() && ( xPropSet->getPropertyValue( "Model" ) >>= xTable ) )
+    {
+        mpFS->startElementNS(XML_a, XML_tbl);
+        mpFS->singleElementNS(XML_a, XML_tblPr);
+
+        Reference< container::XIndexAccess > xColumns( xTable->getColumns(), UNO_QUERY_THROW );
+        Reference< container::XIndexAccess > xRows( xTable->getRows(), UNO_QUERY_THROW );
+        sal_uInt16 nRowCount = static_cast< sal_uInt16 >( xRows->getCount() );
+        sal_uInt16 nColumnCount = static_cast< sal_uInt16 >( xColumns->getCount() );
+
+        mpFS->startElementNS(XML_a, XML_tblGrid);
+
+        for ( sal_Int32 x = 0; x < nColumnCount; x++ )
+        {
+            Reference< XPropertySet > xColPropSet( xColumns->getByIndex( x ), UNO_QUERY_THROW );
+            sal_Int32 nWidth(0);
+            xColPropSet->getPropertyValue( "Width" ) >>= nWidth;
+
+            mpFS->singleElementNS(XML_a, XML_gridCol,
+                                  XML_w, OString::number(oox::drawingml::convertHmmToEmu(nWidth)));
+        }
+
+        mpFS->endElementNS( XML_a, XML_tblGrid );
+
+        // map for holding the transpose index of the merged cells and pair<parentTransposeIndex, parentCell>
+        typedef std::unordered_map<sal_Int32, std::pair<sal_Int32, Reference< XMergeableCell> > > transposeTableMap;
+        transposeTableMap mergedCellMap;
+
+        for( sal_Int32 nRow = 0; nRow < nRowCount; nRow++ )
+        {
+            Reference< XPropertySet > xRowPropSet( xRows->getByIndex( nRow ), UNO_QUERY_THROW );
+            sal_Int32 nRowHeight(0);
+
+            xRowPropSet->getPropertyValue( "Height" ) >>= nRowHeight;
+
+            mpFS->startElementNS(XML_a, XML_tr,
+                XML_h, OString::number(oox::drawingml::convertHmmToEmu(nRowHeight)));
+            for( sal_Int32 nColumn = 0; nColumn < nColumnCount; nColumn++ )
+            {
+                Reference< XMergeableCell > xCell( xTable->getCellByPosition( nColumn, nRow ),
+                                                   UNO_QUERY_THROW );
+                sal_Int32 transposedIndexofCell = (nRow * nColumnCount) + nColumn;
+
+                //assume we will open a cell, set to false below if we won't
+                bool bCellOpened = true;
+
+                if(xCell->getColumnSpan() > 1 && xCell->getRowSpan() > 1)
+                {
+                    // having both : horizontal and vertical merge
+                    mpFS->startElementNS(XML_a, XML_tc,
+                                         XML_gridSpan, OString::number(xCell->getColumnSpan()),
+                                         XML_rowSpan, OString::number(xCell->getRowSpan()));
+                    // since, XMergeableCell doesn't have the information about
+                    // cell having hMerge or vMerge.
+                    // So, Populating the merged cell map in-order to use it to
+                    // decide the attribute for the individual cell.
+                    for(sal_Int32 columnIndex = nColumn; columnIndex < nColumn+xCell->getColumnSpan(); ++columnIndex)
+                    {
+                        for(sal_Int32 rowIndex = nRow; rowIndex < nRow+xCell->getRowSpan(); ++rowIndex)
+                        {
+                            sal_Int32 transposeIndexForMergeCell =
+                                (rowIndex * nColumnCount) + columnIndex;
+                            mergedCellMap[transposeIndexForMergeCell] =
+                                std::make_pair(transposedIndexofCell, xCell);
+                        }
+                    }
+
+                }
+                else if(xCell->getColumnSpan() > 1)
+                {
+                    // having : horizontal merge
+                    mpFS->startElementNS(XML_a, XML_tc,
+                                         XML_gridSpan, OString::number(xCell->getColumnSpan()));
+                    for(sal_Int32 columnIndex = nColumn; columnIndex < nColumn + xCell->getColumnSpan(); ++columnIndex) {
+                        sal_Int32 transposeIndexForMergeCell = (nRow*nColumnCount) + columnIndex;
+                        mergedCellMap[transposeIndexForMergeCell] =
+                            std::make_pair(transposedIndexofCell, xCell);
+                    }
+                }
+                else if(xCell->getRowSpan() > 1)
+                {
+                    // having : vertical merge
+                    mpFS->startElementNS(XML_a, XML_tc,
+                                         XML_rowSpan, OString::number(xCell->getRowSpan()));
+
+                    for(sal_Int32 rowIndex = nRow; rowIndex < nRow + xCell->getRowSpan(); ++rowIndex) {
+                        sal_Int32 transposeIndexForMergeCell = (rowIndex*nColumnCount) + nColumn;
+                        mergedCellMap[transposeIndexForMergeCell] =
+                            std::make_pair(transposedIndexofCell, xCell);
+                    }
+                }
+                else
+                {
+                    // now, the cell can be an independent cell or
+                    // it can be a cell which is been merged to some parent cell
+                    if(!xCell->isMerged())
+                    {
+                        // independent cell
+                        mpFS->startElementNS(XML_a, XML_tc);
+                    }
+                    else
+                    {
+                        // it a merged cell to some parent cell
+                        // find the parent cell for the current cell at hand
+                        transposeTableMap::iterator it = mergedCellMap.find(transposedIndexofCell);
+                        if(it != mergedCellMap.end())
+                        {
+                            sal_Int32 transposeIndexOfParent = it->second.first;
+                            Reference< XMergeableCell > parentCell = it->second.second;
+                            // finding the row and column index for the parent cell from transposed index
+                            sal_Int32 parentColumnIndex = transposeIndexOfParent % nColumnCount;
+                            sal_Int32 parentRowIndex = transposeIndexOfParent / nColumnCount;
+                            if(nColumn == parentColumnIndex)
+                            {
+                                // the cell is vertical merge and it might have gridspan
+                                if(parentCell->getColumnSpan() > 1)
+                                {
+                                    // vMerge and has gridSpan
+                                    mpFS->startElementNS(XML_a, XML_tc,
+                                                         XML_vMerge, OString::number(1),
+                                                         XML_gridSpan, OString::number(xCell->getColumnSpan()));
+                                }
+                                else
+                                {
+                                    // only vMerge
+                                    mpFS->startElementNS(XML_a, XML_tc,
+                                                         XML_vMerge, OString::number(1));
+                                }
+                            }
+                            else if(nRow == parentRowIndex)
+                            {
+                                // the cell is horizontal merge and it might have rowspan
+                                if(parentCell->getRowSpan() > 1)
+                                {
+                                    // hMerge and has rowspan
+                                    mpFS->startElementNS(XML_a, XML_tc,
+                                                         XML_hMerge, OString::number(1),
+                                                         XML_rowSpan, OString::number(xCell->getRowSpan()));
+                                }
+                                else
+                                {
+                                    // only hMerge
+                                    mpFS->startElementNS(XML_a, XML_tc,
+                                                         XML_hMerge, OString::number(1));
+                                }
+                            }
+                            else
+                            {
+                                // has hMerge and vMerge
+                                mpFS->startElementNS(XML_a, XML_tc,
+                                                     XML_vMerge, OString::number(1),
+                                                     XML_hMerge, OString::number(1));
+                            }
+                        }
+                        else
+                            bCellOpened = false;
+                    }
+                }
+
+                if (bCellOpened)
+                {
+                    WriteTextBox( xCell, XML_a );
+
+                    Reference< XPropertySet > xCellPropSet(xCell, UNO_QUERY_THROW);
+                    WriteTableCellProperties(xCellPropSet);
+
+                    mpFS->endElementNS( XML_a, XML_tc );
+                }
+            }
+
+            mpFS->endElementNS( XML_a, XML_tr );
+        }
+
+        mpFS->endElementNS( XML_a, XML_tbl );
+    }
+
+    mpFS->endElementNS( XML_a, XML_graphicData );
+    mpFS->endElementNS( XML_a, XML_graphic );
+}
+
+void ShapeExport::WriteTableCellProperties(const Reference< XPropertySet>& xCellPropSet)
+{
+    sal_Int32 nLeftMargin(0), nRightMargin(0);
+
+    Any aLeftMargin = xCellPropSet->getPropertyValue("TextLeftDistance");
+    aLeftMargin >>= nLeftMargin;
+
+    Any aRightMargin = xCellPropSet->getPropertyValue("TextRightDistance");
+    aRightMargin >>= nRightMargin;
+
+    mpFS->startElementNS(XML_a, XML_tcPr,
+    XML_marL, nLeftMargin > 0 ? OString::number(oox::drawingml::convertHmmToEmu(nLeftMargin)).getStr() : nullptr,
+    XML_marR, nRightMargin > 0 ? OString::number(oox::drawingml::convertHmmToEmu(nRightMargin)).getStr() : nullptr);
+
+    // Write background fill for table cell.
+    // TODO
+    // tcW : Table cell width
+    WriteTableCellBorders(xCellPropSet);
+    DrawingML::WriteFill(xCellPropSet);
+    mpFS->endElementNS( XML_a, XML_tcPr );
+}
+
+void ShapeExport::WriteBorderLine(const sal_Int32 XML_line, const BorderLine2& rBorderLine)
+{
+// While importing the table cell border line width, it converts EMU->Hmm then divided result by 2.
+// To get original value of LineWidth need to multiple by 2.
+    sal_Int32 nBorderWidth = rBorderLine.LineWidth;
+    nBorderWidth *= 2;
+    nBorderWidth = oox::drawingml::convertHmmToEmu( nBorderWidth );
+
+    if ( nBorderWidth > 0 )
+    {
+        mpFS->startElementNS(XML_a, XML_line, XML_w, OString::number(nBorderWidth));
+        if ( rBorderLine.Color == sal_Int32( COL_AUTO ) )
+            mpFS->singleElementNS(XML_a, XML_noFill);
+        else
+            DrawingML::WriteSolidFill( ::Color(rBorderLine.Color) );
+        mpFS->endElementNS( XML_a, XML_line );
+    }
+}
+
+void ShapeExport::WriteTableCellBorders(const Reference< XPropertySet>& xCellPropSet)
+{
+    BorderLine2 aBorderLine;
+
+// lnL - Left Border Line Properties of table cell
+    xCellPropSet->getPropertyValue("LeftBorder") >>= aBorderLine;
+    WriteBorderLine( XML_lnL, aBorderLine );
+
+// lnR - Right Border Line Properties of table cell
+    xCellPropSet->getPropertyValue("RightBorder") >>= aBorderLine;
+    WriteBorderLine( XML_lnR, aBorderLine );
+
+// lnT - Top Border Line Properties of table cell
+    xCellPropSet->getPropertyValue("TopBorder") >>= aBorderLine;
+    WriteBorderLine( XML_lnT, aBorderLine );
+
+// lnB - Bottom Border Line Properties of table cell
+    xCellPropSet->getPropertyValue("BottomBorder") >>= aBorderLine;
+    WriteBorderLine( XML_lnB, aBorderLine );
+}
+
+ShapeExport& ShapeExport::WriteTableShape( const Reference< XShape >& xShape )
+{
+    FSHelperPtr pFS = GetFS();
+
+    pFS->startElementNS(mnXmlNamespace, XML_graphicFrame);
+
+    pFS->startElementNS(mnXmlNamespace, XML_nvGraphicFramePr);
+
+    pFS->singleElementNS( mnXmlNamespace, XML_cNvPr,
+                          XML_id, OString::number(GetNewShapeID(xShape)),
+                          XML_name,   IDS(Table) );
+
+    pFS->singleElementNS(mnXmlNamespace, XML_cNvGraphicFramePr);
+
+    if( GetDocumentType() == DOCUMENT_PPTX )
+        pFS->singleElementNS(mnXmlNamespace, XML_nvPr);
+    pFS->endElementNS( mnXmlNamespace, XML_nvGraphicFramePr );
+
+    WriteShapeTransformation( xShape, mnXmlNamespace );
+    WriteTable( xShape );
+
+    pFS->endElementNS( mnXmlNamespace, XML_graphicFrame );
+
+    return *this;
+}
+
+ShapeExport& ShapeExport::WriteTextShape( const Reference< XShape >& xShape )
+{
+    bool bIsFontworkShape(m_presetWarp.startsWith("text") && m_presetWarp != "textNoShape");
+    FSHelperPtr pFS = GetFS();
+    Reference<XPropertySet> xShapeProps(xShape, UNO_QUERY);
+    pFS->startElementNS(mnXmlNamespace, (GetDocumentType() != DOCUMENT_DOCX ? XML_sp : XML_wsp));
+
+    // non visual shape properties
+    if (GetDocumentType() != DOCUMENT_DOCX)
+    {
+        pFS->startElementNS(mnXmlNamespace, XML_nvSpPr);
+        pFS->startElementNS(mnXmlNamespace, XML_cNvPr,
+                              XML_id, OString::number(GetNewShapeID(xShape)),
+                              XML_name, IDS(TextShape));
+        OUString sURL;
+        if (GetProperty(xShapeProps, "URL"))
+            mAny >>= sURL;
+
+        if (!sURL.isEmpty())
+        {
+            OUString sRelId = mpFB->addRelation(mpFS->getOutputStream(),
+                    oox::getRelationship(Relationship::HYPERLINK),
+                    mpURLTransformer->getTransformedString(sURL),
+                    mpURLTransformer->isExternalURL(sURL));
+
+            mpFS->singleElementNS(XML_a, XML_hlinkClick, FSNS(XML_r, XML_id), sRelId.toUtf8());
+        }
+        pFS->endElementNS(mnXmlNamespace, XML_cNvPr);
+    }
+    pFS->singleElementNS(mnXmlNamespace, XML_cNvSpPr, XML_txBox, "1");
+    if (GetDocumentType() != DOCUMENT_DOCX)
+    {
+        WriteNonVisualProperties( xShape );
+        pFS->endElementNS( mnXmlNamespace, XML_nvSpPr );
+    }
+
+    // visual shape properties
+    pFS->startElementNS(mnXmlNamespace, XML_spPr);
+    WriteShapeTransformation( xShape, XML_a );
+    WritePresetShape( "rect" );
+    uno::Reference<beans::XPropertySet> xPropertySet(xShape, UNO_QUERY);
+    if (!bIsFontworkShape) // Fontwork needs fill and outline on char instead.
+    {
+        WriteBlipOrNormalFill(xPropertySet, "Graphic");
+        WriteOutline(xPropertySet);
+    }
+    WriteShapeEffects(xPropertySet);
+    pFS->endElementNS( mnXmlNamespace, XML_spPr );
+
+    WriteTextBox( xShape, mnXmlNamespace );
+
+    pFS->endElementNS( mnXmlNamespace, (GetDocumentType() != DOCUMENT_DOCX ? XML_sp : XML_wsp) );
+
+    return *this;
+}
+
+void ShapeExport::WriteMathShape(Reference<XShape> const& xShape)
+{
+    Reference<XPropertySet> const xPropSet(xShape, UNO_QUERY);
+    assert(xPropSet.is());
+    Reference<XModel> xMathModel;
+    xPropSet->getPropertyValue("Model") >>= xMathModel;
+    assert(xMathModel.is());
+    assert(GetDocumentType() != DOCUMENT_DOCX); // should be written in DocxAttributeOutput
+    SAL_WARN_IF(GetDocumentType() == DOCUMENT_XLSX, "oox.shape", "Math export to XLSX isn't tested, should it happen here?");
+
+    // ECMA standard does not actually allow oMath outside of
+    // WordProcessingML so write a MCE like PPT 2010 does
+    mpFS->startElementNS(XML_mc, XML_AlternateContent);
+    mpFS->startElementNS(XML_mc, XML_Choice,
+        FSNS(XML_xmlns, XML_a14), mpFB->getNamespaceURL(OOX_NS(a14)).toUtf8(),
+        XML_Requires, "a14");
+    mpFS->startElementNS(mnXmlNamespace, XML_sp);
+    mpFS->startElementNS(mnXmlNamespace, XML_nvSpPr);
+    mpFS->singleElementNS(mnXmlNamespace, XML_cNvPr,
+         XML_id, OString::number(GetNewShapeID(xShape)),
+         XML_name, IDS(Formula));
+    mpFS->singleElementNS(mnXmlNamespace, XML_cNvSpPr, XML_txBox, "1");
+    mpFS->singleElementNS(mnXmlNamespace, XML_nvPr);
+    mpFS->endElementNS(mnXmlNamespace, XML_nvSpPr);
+    mpFS->startElementNS(mnXmlNamespace, XML_spPr);
+    WriteShapeTransformation(xShape, XML_a);
+    WritePresetShape("rect");
+    mpFS->endElementNS(mnXmlNamespace, XML_spPr);
+    mpFS->startElementNS(mnXmlNamespace, XML_txBody);
+    mpFS->startElementNS(XML_a, XML_bodyPr);
+    mpFS->endElementNS(XML_a, XML_bodyPr);
+    mpFS->startElementNS(XML_a, XML_p);
+    mpFS->startElementNS(XML_a14, XML_m);
+
+    oox::FormulaExportBase *const pMagic(dynamic_cast<oox::FormulaExportBase*>(xMathModel.get()));
+    assert(pMagic);
+    pMagic->writeFormulaOoxml(GetFS(), GetFB()->getVersion(), GetDocumentType(),
+        FormulaExportBase::eFormulaAlign::INLINE);
+
+    mpFS->endElementNS(XML_a14, XML_m);
+    mpFS->endElementNS(XML_a, XML_p);
+    mpFS->endElementNS(mnXmlNamespace, XML_txBody);
+    mpFS->endElementNS(mnXmlNamespace, XML_sp);
+    mpFS->endElementNS(XML_mc, XML_Choice);
+    mpFS->startElementNS(XML_mc, XML_Fallback);
+    // TODO: export bitmap shape as fallback
+    mpFS->endElementNS(XML_mc, XML_Fallback);
+    mpFS->endElementNS(XML_mc, XML_AlternateContent);
+}
+
+ShapeExport& ShapeExport::WriteOLE2Shape( const Reference< XShape >& xShape )
+{
+    Reference< XPropertySet > xPropSet( xShape, UNO_QUERY );
+    if (!xPropSet.is())
+        return *this;
+
+    enum { CHART, MATH, OTHER } eType(OTHER);
+    OUString clsid;
+    xPropSet->getPropertyValue("CLSID") >>= clsid;
+    if (!clsid.isEmpty())
+    {
+        SvGlobalName aClassID;
+        bool const isValid = aClassID.MakeId(clsid);
+        assert(isValid); (void)isValid;
+        if (SotExchange::IsChart(aClassID))
+            eType = CHART;
+        else if (SotExchange::IsMath(aClassID))
+            eType = MATH;
+    }
+
+    if (CHART == eType)
+    {
+        Reference< XChartDocument > xChartDoc;
+        xPropSet->getPropertyValue("Model") >>= xChartDoc;
+        assert(xChartDoc.is());
+        //export the chart
+        ChartExport aChartExport( mnXmlNamespace, GetFS(), xChartDoc, GetFB(), GetDocumentType() );
+        static sal_Int32 nChartCount = 0;
+        aChartExport.WriteChartObj( xShape, GetNewShapeID( xShape ), ++nChartCount );
+        return *this;
+    }
+
+    if (MATH == eType)
+    {
+        WriteMathShape(xShape);
+        return *this;
+    }
+
+    uno::Reference<embed::XEmbeddedObject> const xObj(
+        xPropSet->getPropertyValue("EmbeddedObject"), uno::UNO_QUERY);
+
+    if (!xObj.is())
+    {
+        SAL_WARN("oox.shape", "ShapeExport::WriteOLE2Shape: no object");
+        return *this;
+    }
+
+    uno::Sequence<beans::PropertyValue> grabBag;
+    OUString entryName;
+    try
+    {
+        uno::Reference<beans::XPropertySet> const xParent(
+            uno::Reference<container::XChild>(xObj, uno::UNO_QUERY_THROW)->getParent(),
+            uno::UNO_QUERY_THROW);
+
+        xParent->getPropertyValue("InteropGrabBag") >>= grabBag;
+
+        entryName = uno::Reference<embed::XEmbedPersist>(xObj, uno::UNO_QUERY_THROW)->getEntryName();
+    }
+    catch (uno::Exception const&)
+    {
+        TOOLS_WARN_EXCEPTION("oox.shape", "ShapeExport::WriteOLE2Shape");
+        return *this;
+    }
+
+    OUString progID;
+
+    for (auto const& it : std::as_const(grabBag))
+    {
+        if (it.Name == "EmbeddedObjects")
+        {
+            uno::Sequence<beans::PropertyValue> objects;
+            it.Value >>= objects;
+            for (auto const& object : std::as_const(objects))
+            {
+                if (object.Name == entryName)
+                {
+                    uno::Sequence<beans::PropertyValue> props;
+                    object.Value >>= props;
+                    for (auto const& prop : std::as_const(props))
+                    {
+                        if (prop.Name == "ProgID")
+                        {
+                            prop.Value >>= progID;
+                            break;
+                        }
+                    }
+                    break;
+                }
+            }
+            break;
+        }
+    }
+
+    OUString sMediaType;
+    OUString sRelationType;
+    OUString sSuffix;
+    const char * pProgID(nullptr);
+
+    uno::Reference<io::XInputStream> const xInStream =
+        oox::GetOLEObjectStream(
+            mpFB->getComponentContext(), xObj, progID,
+            sMediaType, sRelationType, sSuffix, pProgID);
+
+    if (!xInStream.is())
+    {
+        return *this;
+    }
+
+    OString anotherProgID;
+    if (!pProgID && !progID.isEmpty())
+    {
+        anotherProgID = OUStringToOString(progID, RTL_TEXTENCODING_UTF8);
+        pProgID = anotherProgID.getStr();
+    }
+
+    assert(!sMediaType.isEmpty());
+    assert(!sRelationType.isEmpty());
+    assert(!sSuffix.isEmpty());
+
+    OUString sFileName = "embeddings/oleObject" + OUString::number(++m_nEmbeddedObjects) + "." + sSuffix;
+    uno::Reference<io::XOutputStream> const xOutStream(
+        mpFB->openFragmentStream(
+            OUString::createFromAscii(GetComponentDir()) + "/" + sFileName,
+            sMediaType));
+    assert(xOutStream.is()); // no reason why that could fail
+
+    try {
+        ::comphelper::OStorageHelper::CopyInputToOutput(xInStream, xOutStream);
+    } catch (uno::Exception const&) {
+        TOOLS_WARN_EXCEPTION("oox.shape", "ShapeExport::WriteOLEObject");
+    }
+
+    OUString const sRelId = mpFB->addRelation(
+        mpFS->getOutputStream(), sRelationType,
+        OUString::createFromAscii(GetRelationCompPrefix()) + sFileName);
+
+    mpFS->startElementNS(mnXmlNamespace, XML_graphicFrame);
+
+    mpFS->startElementNS(mnXmlNamespace, XML_nvGraphicFramePr);
+
+    mpFS->singleElementNS( mnXmlNamespace, XML_cNvPr,
+                           XML_id,     OString::number(GetNewShapeID(xShape)),
+                           XML_name,   IDS(Object) );
+
+    mpFS->singleElementNS(mnXmlNamespace, XML_cNvGraphicFramePr);
+
+    if (GetDocumentType() == DOCUMENT_PPTX)
+        mpFS->singleElementNS(mnXmlNamespace, XML_nvPr);
+    mpFS->endElementNS( mnXmlNamespace, XML_nvGraphicFramePr );
+
+    WriteShapeTransformation( xShape, mnXmlNamespace );
+
+    mpFS->startElementNS(XML_a, XML_graphic);
+    mpFS->startElementNS(XML_a, XML_graphicData,
+                         XML_uri, "http://schemas.openxmlformats.org/presentationml/2006/ole");
+    if (pProgID)
+    {
+        mpFS->startElementNS( mnXmlNamespace, XML_oleObj,
+                          XML_progId, pProgID,
+                          FSNS(XML_r, XML_id), sRelId.toUtf8(),
+                          XML_spid, "" );
+    }
+    else
+    {
+        mpFS->startElementNS( mnXmlNamespace, XML_oleObj,
+//?                                              XML_name, "Document",
+                          FSNS(XML_r, XML_id), sRelId.toUtf8(),
+                          // The spec says that this is a required attribute, but PowerPoint can only handle an empty value.
+                          XML_spid, "" );
+    }
+
+    mpFS->singleElementNS( mnXmlNamespace, XML_embed );
+
+    // pic element
+    SdrObject* pSdrOLE2( GetSdrObjectFromXShape( xShape ) );
+    // The spec doesn't allow <p:pic> here, but PowerPoint requires it.
+    bool bEcma = mpFB->getVersion() == oox::core::ECMA_DIALECT;
+    if (dynamic_cast<const SdrOle2Obj*>( pSdrOLE2) && bEcma)
+    {
+        const Graphic* pGraphic = static_cast<SdrOle2Obj*>(pSdrOLE2)->GetGraphic();
+        if (pGraphic)
+            WriteGraphicObjectShapePart( xShape, pGraphic );
+    }
+
+    mpFS->endElementNS( mnXmlNamespace, XML_oleObj );
+
+    mpFS->endElementNS( XML_a, XML_graphicData );
+    mpFS->endElementNS( XML_a, XML_graphic );
+
+    mpFS->endElementNS( mnXmlNamespace, XML_graphicFrame );
+
+    return *this;
+}
+
+ShapeExport& ShapeExport::WriteUnknownShape( const Reference< XShape >& )
+{
+    // Override this method to do something useful.
+    return *this;
+}
+
+sal_Int32 ShapeExport::GetNewShapeID( const Reference< XShape >& rXShape )
+{
+    return GetNewShapeID( rXShape, GetFB() );
+}
+
+sal_Int32 ShapeExport::GetNewShapeID( const Reference< XShape >& rXShape, XmlFilterBase* pFB )
+{
+    if( !rXShape.is() )
+        return -1;
+
+    sal_Int32 nID = pFB->GetUniqueId();
+
+    (*mpShapeMap)[ rXShape ] = nID;
+
+    return nID;
+}
+
+sal_Int32 ShapeExport::GetShapeID( const Reference< XShape >& rXShape )
+{
+    return GetShapeID( rXShape, mpShapeMap );
+}
+
+sal_Int32 ShapeExport::GetShapeID( const Reference< XShape >& rXShape, ShapeHashMap* pShapeMap )
+{
+    if( !rXShape.is() )
+        return -1;
+
+    ShapeHashMap::const_iterator aIter = pShapeMap->find( rXShape );
+
+    if( aIter == pShapeMap->end() )
+        return -1;
+
+    return aIter->second;
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/oox/source/export/vmlexport.cxx b/oox/source/export/vmlexport.cxx
new file mode 100644
index 000000000..54eba8b7e
--- /dev/null
+++ b/oox/source/export/vmlexport.cxx
@@ -0,0 +1,1523 @@
+/* -*- 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 <config_folders.h>
+#include <rtl/bootstrap.hxx>
+#include <svl/itemset.hxx>
+#include <oox/export/drawingml.hxx>
+#include <oox/export/vmlexport.hxx>
+#include <sax/fastattribs.hxx>
+
+#include <oox/token/tokens.hxx>
+
+#include <rtl/strbuf.hxx>
+#include <rtl/ustring.hxx>
+#include <sal/log.hxx>
+
+#include <tools/stream.hxx>
+#include <comphelper/sequenceashashmap.hxx>
+#include <svx/svdotext.hxx>
+#include <svx/svdograf.hxx>
+#include <svx/sdmetitm.hxx>
+#include <vcl/cvtgrf.hxx>
+#include <filter/msfilter/msdffimp.hxx>
+#include <filter/msfilter/util.hxx>
+#include <filter/msfilter/escherex.hxx>
+
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/beans/XPropertySetInfo.hpp>
+#include <com/sun/star/drawing/XShape.hpp>
+#include <com/sun/star/text/HoriOrientation.hpp>
+#include <com/sun/star/text/VertOrientation.hpp>
+#include <com/sun/star/text/RelOrientation.hpp>
+
+#include <cstdio>
+
+using namespace sax_fastparser;
+using namespace oox::vml;
+using namespace com::sun::star;
+
+static const sal_Int32 Tag_Container = 44444;
+static const sal_Int32 Tag_Commit = 44445;
+
+VMLExport::VMLExport( ::sax_fastparser::FSHelperPtr const & pSerializer, VMLTextExport* pTextExport )
+    : EscherEx( std::make_shared<EscherExGlobal>(), nullptr, /*bOOXML=*/true )
+    , m_pSerializer( pSerializer )
+    , m_pTextExport( pTextExport )
+    , m_eHOri( 0 )
+    , m_eVOri( 0 )
+    , m_eHRel( 0 )
+    , m_eVRel( 0 )
+    , m_bInline( false )
+    , m_pSdrObject( nullptr )
+    , m_pShapeAttrList( nullptr )
+    , m_nShapeType( ESCHER_ShpInst_Nil )
+    , m_nShapeFlags(ShapeFlag::NONE)
+    , m_ShapeStyle( 200 )
+    , m_aShapeTypeWritten( ESCHER_ShpInst_COUNT )
+    , m_bSkipwzName( false )
+    , m_bUseHashMarkForType( false )
+    , m_bOverrideShapeIdGeneration( false )
+    , m_nShapeIDCounter( 0 )
+{
+    mnGroupLevel = 1;
+}
+
+void VMLExport::SetFS( const ::sax_fastparser::FSHelperPtr& pSerializer )
+{
+    m_pSerializer = pSerializer;
+}
+
+VMLExport::~VMLExport()
+{
+    delete mpOutStrm;
+    mpOutStrm = nullptr;
+}
+
+void VMLExport::OpenContainer( sal_uInt16 nEscherContainer, int nRecInstance )
+{
+    EscherEx::OpenContainer( nEscherContainer, nRecInstance );
+
+    if ( nEscherContainer != ESCHER_SpContainer )
+        return;
+
+    // opening a shape container
+    SAL_WARN_IF(m_nShapeType != ESCHER_ShpInst_Nil, "oox.vml", "opening shape inside of a shape!");
+    m_nShapeType = ESCHER_ShpInst_Nil;
+    m_pShapeAttrList = FastSerializerHelper::createAttrList();
+
+    m_ShapeStyle.setLength(0);
+    m_ShapeStyle.ensureCapacity(200);
+
+    // postpone the output so that we are able to write even the elements
+    // that we learn inside Commit()
+    m_pSerializer->mark(Tag_Container);
+}
+
+void VMLExport::CloseContainer()
+{
+    if ( mRecTypes.back() == ESCHER_SpContainer )
+    {
+        // write the shape now when we have all the info
+        sal_Int32 nShapeElement = StartShape();
+
+        m_pSerializer->mergeTopMarks(Tag_Container);
+
+        EndShape( nShapeElement );
+
+        // cleanup
+        m_nShapeType = ESCHER_ShpInst_Nil;
+        m_pShapeAttrList = nullptr;
+    }
+
+    EscherEx::CloseContainer();
+}
+
+sal_uInt32 VMLExport::EnterGroup( const OUString& rShapeName, const tools::Rectangle* pRect )
+{
+    sal_uInt32 nShapeId = GenerateShapeId();
+
+    OStringBuffer aStyle( 200 );
+    FastAttributeList *pAttrList = FastSerializerHelper::createAttrList();
+
+    pAttrList->add( XML_id, ShapeIdString( nShapeId ) );
+
+    if ( rShapeName.getLength() )
+        pAttrList->add( XML_alt, OUStringToOString( rShapeName, RTL_TEXTENCODING_UTF8 ) );
+
+    bool rbAbsolutePos = true;
+    //editAs
+    OUString rEditAs = EscherEx::GetEditAs();
+    if (!rEditAs.isEmpty())
+    {
+        pAttrList->add(XML_editas, OUStringToOString( rEditAs, RTL_TEXTENCODING_UTF8 ));
+        rbAbsolutePos = false;
+    }
+
+    // style
+    if ( pRect )
+        AddRectangleDimensions( aStyle, *pRect, rbAbsolutePos );
+
+    if ( !aStyle.isEmpty() )
+        pAttrList->add( XML_style, aStyle.makeStringAndClear() );
+
+    // coordorigin/coordsize
+    if ( pRect && ( mnGroupLevel == 1 ) )
+    {
+        pAttrList->add( XML_coordorigin,
+                OStringBuffer( 20 ).append( sal_Int32( pRect->Left() ) )
+                .append( "," ).append( sal_Int32( pRect->Top() ) )
+                .makeStringAndClear() );
+
+        pAttrList->add( XML_coordsize,
+                OStringBuffer( 20 ).append( sal_Int32( pRect->Right() ) - sal_Int32( pRect->Left() ) )
+                .append( "," ).append( sal_Int32( pRect->Bottom() ) - sal_Int32( pRect->Top() ) )
+                .makeStringAndClear() );
+    }
+
+    m_pSerializer->startElementNS( XML_v, XML_group, XFastAttributeListRef( pAttrList ) );
+
+    mnGroupLevel++;
+    return nShapeId;
+}
+
+void VMLExport::LeaveGroup()
+{
+    --mnGroupLevel;
+    m_pSerializer->endElementNS( XML_v, XML_group );
+}
+
+void VMLExport::AddShape( sal_uInt32 nShapeType, ShapeFlag nShapeFlags, sal_uInt32 nShapeId )
+{
+    m_nShapeType = nShapeType;
+    m_nShapeFlags = nShapeFlags;
+
+    m_sShapeId = ShapeIdString( nShapeId );
+    // If shape is a watermark object - should keep the original shape's name
+    // because Microsoft detects if it is a watermark by the actual name
+    if (!IsWaterMarkShape(m_pSdrObject->GetName()))
+    {
+        // Not a watermark object
+        m_pShapeAttrList->add( XML_id, m_sShapeId );
+    }
+    else
+    {
+        // A watermark object - store the optional shape ID
+        m_pShapeAttrList->add( XML_id, OUStringToOString(m_pSdrObject->GetName(), RTL_TEXTENCODING_UTF8) );
+        // also ('o:spid')
+        m_pShapeAttrList->addNS( XML_o, XML_spid, m_sShapeId );
+    }
+}
+
+bool VMLExport::IsWaterMarkShape(const OUString& rStr)
+{
+     if (rStr.isEmpty() )  return false;
+
+     return rStr.match("PowerPlusWaterMarkObject") || rStr.match("WordPictureWatermark");
+}
+
+void VMLExport::OverrideShapeIDGen(bool bOverrideShapeIdGen, const OString& sShapeIDPrefix)
+{
+    m_bOverrideShapeIdGeneration = bOverrideShapeIdGen;
+    if(bOverrideShapeIdGen)
+    {
+        assert(!sShapeIDPrefix.isEmpty());
+        m_sShapeIDPrefix = sShapeIDPrefix;
+    }
+    else
+        m_sShapeIDPrefix.clear();
+}
+
+static void impl_AddArrowHead( sax_fastparser::FastAttributeList *pAttrList, sal_Int32 nElement, sal_uInt32 nValue )
+{
+    if ( !pAttrList )
+        return;
+
+    const char *pArrowHead = nullptr;
+    switch ( nValue )
+    {
+        case ESCHER_LineNoEnd:           pArrowHead = "none"; break;
+        case ESCHER_LineArrowEnd:        pArrowHead = "block"; break;
+        case ESCHER_LineArrowStealthEnd: pArrowHead = "classic"; break;
+        case ESCHER_LineArrowDiamondEnd: pArrowHead = "diamond"; break;
+        case ESCHER_LineArrowOvalEnd:    pArrowHead = "oval"; break;
+        case ESCHER_LineArrowOpenEnd:    pArrowHead = "open"; break;
+    }
+
+    if ( pArrowHead )
+        pAttrList->add( nElement, pArrowHead );
+}
+
+static void impl_AddArrowLength( sax_fastparser::FastAttributeList *pAttrList, sal_Int32 nElement, sal_uInt32 nValue )
+{
+    if ( !pAttrList )
+        return;
+
+    const char *pArrowLength = nullptr;
+    switch ( nValue )
+    {
+        case ESCHER_LineShortArrow:     pArrowLength = "short"; break;
+        case ESCHER_LineMediumLenArrow: pArrowLength = "medium"; break;
+        case ESCHER_LineLongArrow:      pArrowLength = "long"; break;
+    }
+
+    if ( pArrowLength )
+        pAttrList->add( nElement, pArrowLength );
+}
+
+static void impl_AddArrowWidth( sax_fastparser::FastAttributeList *pAttrList, sal_Int32 nElement, sal_uInt32 nValue )
+{
+    if ( !pAttrList )
+        return;
+
+    const char *pArrowWidth = nullptr;
+    switch ( nValue )
+    {
+        case ESCHER_LineNarrowArrow:      pArrowWidth = "narrow"; break;
+        case ESCHER_LineMediumWidthArrow: pArrowWidth = "medium"; break;
+        case ESCHER_LineWideArrow:        pArrowWidth = "wide"; break;
+    }
+
+    if ( pArrowWidth )
+        pAttrList->add( nElement, pArrowWidth );
+}
+
+static void impl_AddBool( sax_fastparser::FastAttributeList *pAttrList, sal_Int32 nElement, bool bValue )
+{
+    if ( !pAttrList )
+        return;
+
+    pAttrList->add( nElement, bValue? "t": "f" );
+}
+
+static void impl_AddColor( sax_fastparser::FastAttributeList *pAttrList, sal_Int32 nElement, sal_uInt32 nColor )
+{
+#if OSL_DEBUG_LEVEL > 0
+    if ( nColor & 0xFF000000 )
+        fprintf( stderr, "TODO: this is not a RGB value!\n" );
+#endif
+
+    if ( !pAttrList || ( nColor & 0xFF000000 ) )
+        return;
+
+    nColor = ( ( nColor & 0xFF ) << 16 ) + ( nColor & 0xFF00 ) + ( ( nColor & 0xFF0000 ) >> 16 );
+
+    const char *pColor = nullptr;
+    char pRgbColor[10];
+    switch ( nColor )
+    {
+        case 0x000000: pColor = "black"; break;
+        case 0xC0C0C0: pColor = "silver"; break;
+        case 0x808080: pColor = "gray"; break;
+        case 0xFFFFFF: pColor = "white"; break;
+        case 0x800000: pColor = "maroon"; break;
+        case 0xFF0000: pColor = "red"; break;
+        case 0x800080: pColor = "purple"; break;
+        case 0xFF00FF: pColor = "fuchsia"; break;
+        case 0x008000: pColor = "green"; break;
+        case 0x00FF00: pColor = "lime"; break;
+        case 0x808000: pColor = "olive"; break;
+        case 0xFFFF00: pColor = "yellow"; break;
+        case 0x000080: pColor = "navy"; break;
+        case 0x0000FF: pColor = "blue"; break;
+        case 0x008080: pColor = "teal"; break;
+        case 0x00FFFF: pColor = "aqua"; break;
+        default:
+            {
+                snprintf( pRgbColor, sizeof( pRgbColor ), "#%06x", static_cast< unsigned int >( nColor ) ); // not too handy to use OString::valueOf() here :-(
+                pColor = pRgbColor;
+            }
+            break;
+    }
+
+    pAttrList->add( nElement, pColor );
+}
+
+static void impl_AddInt( sax_fastparser::FastAttributeList *pAttrList, sal_Int32 nElement, sal_uInt32 nValue )
+{
+    if ( !pAttrList )
+        return;
+
+    pAttrList->add( nElement, OString::number( nValue ).getStr() );
+}
+
+static sal_uInt16 impl_GetUInt16( const sal_uInt8* &pVal )
+{
+    sal_uInt16 nRet = *pVal++;
+    nRet += ( *pVal++ ) << 8;
+    return nRet;
+}
+
+static sal_Int32 impl_GetPointComponent( const sal_uInt8* &pVal, sal_uInt16 nPointSize )
+{
+    sal_Int32 nRet = 0;
+    if ( ( nPointSize == 0xfff0 ) || ( nPointSize == 4 ) )
+    {
+        sal_uInt16 nUnsigned = *pVal++;
+        nUnsigned += ( *pVal++ ) << 8;
+
+        nRet = sal_Int16( nUnsigned );
+    }
+    else if ( nPointSize == 8 )
+    {
+        sal_uInt32 nUnsigned = *pVal++;
+        nUnsigned += ( *pVal++ ) << 8;
+        nUnsigned += ( *pVal++ ) << 16;
+        nUnsigned += ( *pVal++ ) << 24;
+
+        nRet = nUnsigned;
+    }
+
+    return nRet;
+}
+
+void  VMLExport::AddSdrObjectVMLObject( const SdrObject& rObj)
+{
+   m_pSdrObject = &rObj;
+}
+void VMLExport::Commit( EscherPropertyContainer& rProps, const tools::Rectangle& rRect )
+{
+    if ( m_nShapeType == ESCHER_ShpInst_Nil )
+        return;
+
+    // postpone the output of the embedded elements so that they are written
+    // inside the shapes
+    m_pSerializer->mark(Tag_Commit);
+
+    // dimensions
+    if ( m_nShapeType == ESCHER_ShpInst_Line )
+        AddLineDimensions( rRect );
+    else
+    {
+        if ( IsWaterMarkShape( m_pSdrObject->GetName() ) )
+        {
+            // Watermark need some padding to be compatible with MSO
+            long nPaddingY = 0;
+            const SfxItemSet& rSet = m_pSdrObject->GetMergedItemSet();
+            if ( const SdrMetricItem* pItem = rSet.GetItem( SDRATTR_TEXT_UPPERDIST ) )
+                nPaddingY += pItem->GetValue();
+
+            tools::Rectangle aRect( rRect );
+            aRect.setHeight( aRect.getHeight() + nPaddingY );
+            AddRectangleDimensions( m_ShapeStyle, aRect );
+        }
+        else
+            AddRectangleDimensions( m_ShapeStyle, rRect );
+    }
+
+    // properties
+    bool bAlreadyWritten[ 0xFFF ] = {};
+    const EscherProperties &rOpts = rProps.GetOpts();
+    for (auto const& opt : rOpts)
+    {
+        sal_uInt16 nId = ( opt.nPropId & 0x0FFF );
+
+        if ( bAlreadyWritten[ nId ] )
+            continue;
+
+        switch ( nId )
+        {
+            case ESCHER_Prop_WrapText: // 133
+                {
+                    const char *pWrapType = nullptr;
+                    switch ( opt.nPropValue )
+                    {
+                        case ESCHER_WrapSquare:
+                        case ESCHER_WrapByPoints:  pWrapType = "square"; break; // these two are equivalent according to the docu
+                        case ESCHER_WrapNone:      pWrapType = "none"; break;
+                        case ESCHER_WrapTopBottom:
+                        case ESCHER_WrapThrough:
+                            break; // last two are *undefined* in MS-ODRAW, don't exist in VML
+                    }
+                    if ( pWrapType )
+                    {
+                        m_ShapeStyle.append(";mso-wrap-style:");
+                        m_ShapeStyle.append(pWrapType);
+                    }
+                }
+                bAlreadyWritten[ ESCHER_Prop_WrapText ] = true;
+                break;
+
+            case ESCHER_Prop_AnchorText: // 135
+                {
+                    char const* pValue(nullptr);
+                    switch (opt.nPropValue)
+                    {
+                        case ESCHER_AnchorTop:
+                            pValue = "top";
+                        break;
+                        case ESCHER_AnchorMiddle:
+                            pValue = "middle";
+                        break;
+                        case ESCHER_AnchorBottom:
+                            pValue = "bottom";
+                        break;
+                        case ESCHER_AnchorTopCentered:
+                            pValue = "top-center";
+                        break;
+                        case ESCHER_AnchorMiddleCentered:
+                            pValue = "middle-center";
+                        break;
+                        case ESCHER_AnchorBottomCentered:
+                            pValue = "bottom-center";
+                        break;
+                        case ESCHER_AnchorTopBaseline:
+                            pValue = "top-baseline";
+                        break;
+                        case ESCHER_AnchorBottomBaseline:
+                            pValue = "bottom-baseline";
+                        break;
+                        case ESCHER_AnchorTopCenteredBaseline:
+                            pValue = "top-center-baseline";
+                        break;
+                        case ESCHER_AnchorBottomCenteredBaseline:
+                            pValue = "bottom-center-baseline";
+                        break;
+                    }
+                    m_ShapeStyle.append(";v-text-anchor:");
+                    m_ShapeStyle.append(pValue);
+                }
+                break;
+
+            case ESCHER_Prop_txflTextFlow: // 136
+                {
+                    // at least "bottom-to-top" only has an effect when it's on the v:textbox element, not on v:shape
+                    assert(m_TextboxStyle.isEmpty());
+                    switch (opt.nPropValue)
+                    {
+                        case ESCHER_txflHorzN:
+                            m_TextboxStyle.append("layout-flow:horizontal");
+                        break;
+                        case ESCHER_txflTtoBA:
+                            m_TextboxStyle.append("layout-flow:vertical");
+                        break;
+                        case ESCHER_txflBtoT:
+                            m_TextboxStyle.append("mso-layout-flow-alt:bottom-to-top");
+                        break;
+                        default:
+                            assert(false); // unimplemented in escher export
+                        break;
+                    }
+                }
+                break;
+
+            // coordorigin
+            case ESCHER_Prop_geoLeft: // 320
+            case ESCHER_Prop_geoTop: // 321
+                {
+                    sal_uInt32 nLeft = 0, nTop = 0;
+
+                    if ( nId == ESCHER_Prop_geoLeft )
+                    {
+                        nLeft = opt.nPropValue;
+                        rProps.GetOpt( ESCHER_Prop_geoTop, nTop );
+                    }
+                    else
+                    {
+                        nTop = opt.nPropValue;
+                        rProps.GetOpt( ESCHER_Prop_geoLeft, nLeft );
+                    }
+                    if(nTop!=0 && nLeft!=0)
+                        m_pShapeAttrList->add( XML_coordorigin,
+                                OStringBuffer( 20 ).append( sal_Int32( nLeft ) )
+                                .append( "," ).append( sal_Int32( nTop ) )
+                                .makeStringAndClear() );
+                }
+                bAlreadyWritten[ ESCHER_Prop_geoLeft ] = true;
+                bAlreadyWritten[ ESCHER_Prop_geoTop ] = true;
+                break;
+
+            // coordsize
+            case ESCHER_Prop_geoRight: // 322
+            case ESCHER_Prop_geoBottom: // 323
+                {
+                    sal_uInt32 nLeft = 0, nRight = 0, nTop = 0, nBottom = 0;
+                    rProps.GetOpt( ESCHER_Prop_geoLeft, nLeft );
+                    rProps.GetOpt( ESCHER_Prop_geoTop, nTop );
+
+                    if ( nId == ESCHER_Prop_geoRight )
+                    {
+                        nRight = opt.nPropValue;
+                        rProps.GetOpt( ESCHER_Prop_geoBottom, nBottom );
+                    }
+                    else
+                    {
+                        nBottom = opt.nPropValue;
+                        rProps.GetOpt( ESCHER_Prop_geoRight, nRight );
+                    }
+
+                    if(nTop!=0 && nLeft!=0 &&  nBottom!=0 &&  nRight!=0 )
+                        m_pShapeAttrList->add( XML_coordsize,
+                                OStringBuffer( 20 ).append( sal_Int32( nRight ) - sal_Int32( nLeft ) )
+                                .append( "," ).append( sal_Int32( nBottom ) - sal_Int32( nTop ) )
+                                .makeStringAndClear() );
+                }
+                bAlreadyWritten[ ESCHER_Prop_geoRight ] = true;
+                bAlreadyWritten[ ESCHER_Prop_geoBottom ] = true;
+                break;
+
+            case ESCHER_Prop_pVertices: // 325
+            case ESCHER_Prop_pSegmentInfo: // 326
+                {
+                    EscherPropSortStruct aVertices;
+                    EscherPropSortStruct aSegments;
+
+                    if ( rProps.GetOpt( ESCHER_Prop_pVertices, aVertices ) &&
+                         rProps.GetOpt( ESCHER_Prop_pSegmentInfo, aSegments ) )
+                    {
+                        const sal_uInt8 *pVerticesIt = aVertices.nProp.data() + 6;
+                        const sal_uInt8 *pSegmentIt = aSegments.nProp.data();
+                        OStringBuffer aPath( 512 );
+
+                        sal_uInt16 nPointSize = aVertices.nProp[4] + ( aVertices.nProp[5] << 8 );
+
+                        // number of segments
+                        sal_uInt16 nSegments = impl_GetUInt16( pSegmentIt );
+                        pSegmentIt += 4;
+
+                        for ( ; nSegments; --nSegments )
+                        {
+                            sal_uInt16 nSeg = impl_GetUInt16( pSegmentIt );
+
+                            // The segment type is stored in the upper 3 bits
+                            // and segment count is stored in the lower 13
+                            // bits.
+                            unsigned char nSegmentType = (nSeg & 0xE000) >> 13;
+                            unsigned short nSegmentCount = nSeg & 0x03FF;
+
+                            switch (nSegmentType)
+                            {
+                                case msopathMoveTo:
+                                {
+                                    sal_Int32 nX = impl_GetPointComponent( pVerticesIt, nPointSize );
+                                    sal_Int32 nY = impl_GetPointComponent( pVerticesIt, nPointSize );
+                                    if (nX >= 0 && nY >= 0 )
+                                        aPath.append( "m" ).append( nX ).append( "," ).append( nY );
+                                    break;
+                                }
+                                case msopathClientEscape:
+                                    break;
+                                case msopathEscape:
+                                {
+                                    // If the segment type is msopathEscape, the lower 13 bits are
+                                    // divided in a 5 bit escape code and 8 bit
+                                    // vertex count (not segment count!)
+                                    unsigned char nEscapeCode = (nSegmentCount & 0x1F00) >> 8;
+                                    unsigned char nVertexCount = nSegmentCount & 0x00FF;
+                                    pVerticesIt += nVertexCount;
+
+                                    switch (nEscapeCode)
+                                    {
+                                        case 0xa: // nofill
+                                            aPath.append( "nf" );
+                                            break;
+                                        case 0xb: // nostroke
+                                            aPath.append( "ns" );
+                                            break;
+                                    }
+
+                                    break;
+                                }
+                                case msopathLineTo:
+                                    for (unsigned short i = 0; i < nSegmentCount; ++i)
+                                    {
+                                        sal_Int32 nX = impl_GetPointComponent( pVerticesIt, nPointSize );
+                                        sal_Int32 nY = impl_GetPointComponent( pVerticesIt, nPointSize );
+                                        aPath.append( "l" ).append( nX ).append( "," ).append( nY );
+                                    }
+                                    break;
+                                case msopathCurveTo:
+                                    for (unsigned short i = 0; i < nSegmentCount; ++i)
+                                    {
+                                        sal_Int32 nX1 = impl_GetPointComponent( pVerticesIt, nPointSize );
+                                        sal_Int32 nY1 = impl_GetPointComponent( pVerticesIt, nPointSize );
+                                        sal_Int32 nX2 = impl_GetPointComponent( pVerticesIt, nPointSize );
+                                        sal_Int32 nY2 = impl_GetPointComponent( pVerticesIt, nPointSize );
+                                        sal_Int32 nX3 = impl_GetPointComponent( pVerticesIt, nPointSize );
+                                        sal_Int32 nY3 = impl_GetPointComponent( pVerticesIt, nPointSize );
+                                        aPath.append( "c" ).append( nX1 ).append( "," ).append( nY1 ).append( "," )
+                                            .append( nX2 ).append( "," ).append( nY2 ).append( "," )
+                                            .append( nX3 ).append( "," ).append( nY3 );
+                                    }
+                                    break;
+                                case msopathClose:
+                                    aPath.append( "x" );
+                                    break;
+                                case msopathEnd:
+                                    aPath.append( "e" );
+                                    break;
+                                default:
+                                    SAL_WARN("oox", "Totally b0rked");
+                                    break;
+                                case msopathInvalid:
+                                    SAL_WARN("oox", "Invalid - should never be found");
+                                    break;
+                            }
+                        }
+                        OString pathString = aPath.makeStringAndClear();
+                        if ( !aPath.isEmpty() && pathString != "xe" )
+                            m_pShapeAttrList->add( XML_path, pathString );
+                    }
+                    else
+                        SAL_WARN("oox.vml", "unhandled shape path, missing either pVertices or pSegmentInfo.");
+                }
+                bAlreadyWritten[ ESCHER_Prop_pVertices ] = true;
+                bAlreadyWritten[ ESCHER_Prop_pSegmentInfo ] = true;
+                break;
+
+            case ESCHER_Prop_fillType: // 384
+            case ESCHER_Prop_fillColor: // 385
+            case ESCHER_Prop_fillBackColor: // 387
+            case ESCHER_Prop_fillBlip: // 390
+            case ESCHER_Prop_fNoFillHitTest: // 447
+            case ESCHER_Prop_fillOpacity: // 386
+                {
+                    sal_uInt32 nValue;
+                    sax_fastparser::FastAttributeList* pAttrList
+                        = FastSerializerHelper::createAttrList();
+
+                    bool imageData = false;
+                    EscherPropSortStruct aStruct;
+                    const SdrGrafObj* pSdrGrafObj = dynamic_cast<const SdrGrafObj*>(m_pSdrObject);
+
+                    if (pSdrGrafObj && pSdrGrafObj->isSignatureLine() && m_pTextExport)
+                    {
+                        sax_fastparser::FastAttributeList* pAttrListSignatureLine
+                            = FastSerializerHelper::createAttrList();
+                        pAttrListSignatureLine->add(XML_issignatureline, "t");
+                        if (!pSdrGrafObj->getSignatureLineId().isEmpty())
+                        {
+                            pAttrListSignatureLine->add(
+                                XML_id, OUStringToOString(pSdrGrafObj->getSignatureLineId(),
+                                                          RTL_TEXTENCODING_UTF8));
+                        }
+                        if (!pSdrGrafObj->getSignatureLineSuggestedSignerName().isEmpty())
+                        {
+                            pAttrListSignatureLine->add(
+                                FSNS(XML_o, XML_suggestedsigner),
+                                OUStringToOString(
+                                    pSdrGrafObj->getSignatureLineSuggestedSignerName(),
+                                    RTL_TEXTENCODING_UTF8));
+                        }
+                        if (!pSdrGrafObj->getSignatureLineSuggestedSignerTitle().isEmpty())
+                        {
+                            pAttrListSignatureLine->add(
+                                FSNS(XML_o, XML_suggestedsigner2),
+                                OUStringToOString(
+                                    pSdrGrafObj->getSignatureLineSuggestedSignerTitle(),
+                                    RTL_TEXTENCODING_UTF8));
+                        }
+                        if (!pSdrGrafObj->getSignatureLineSuggestedSignerEmail().isEmpty())
+                        {
+                            pAttrListSignatureLine->add(
+                                FSNS(XML_o, XML_suggestedsigneremail),
+                                OUStringToOString(
+                                    pSdrGrafObj->getSignatureLineSuggestedSignerEmail(),
+                                    RTL_TEXTENCODING_UTF8));
+                        }
+                        if (!pSdrGrafObj->getSignatureLineSigningInstructions().isEmpty())
+                        {
+                            pAttrListSignatureLine->add(XML_signinginstructionsset, "t");
+                            pAttrListSignatureLine->add(
+                                FSNS(XML_o, XML_signinginstructions),
+                                OUStringToOString(
+                                    pSdrGrafObj->getSignatureLineSigningInstructions(),
+                                    RTL_TEXTENCODING_UTF8));
+                        }
+                        pAttrListSignatureLine->add(
+                            XML_showsigndate,
+                            pSdrGrafObj->isSignatureLineShowSignDate() ? "t" : "f");
+                        pAttrListSignatureLine->add(
+                            XML_allowcomments,
+                            pSdrGrafObj->isSignatureLineCanAddComment() ? "t" : "f");
+
+                        m_pSerializer->singleElementNS(
+                            XML_o, XML_signatureline,
+                            XFastAttributeListRef(pAttrListSignatureLine));
+
+                        // Get signature line graphic
+                        const uno::Reference<graphic::XGraphic>& xGraphic
+                            = pSdrGrafObj->getSignatureLineUnsignedGraphic();
+                        Graphic aGraphic(xGraphic);
+
+                        BitmapChecksum nChecksum = aGraphic.GetChecksum();
+                        OUString aImageId = m_pTextExport->FindRelId(nChecksum);
+                        if (aImageId.isEmpty())
+                        {
+                            aImageId = m_pTextExport->GetDrawingML().WriteImage(aGraphic);
+                            m_pTextExport->CacheRelId(nChecksum, aImageId);
+                        }
+                        pAttrList->add(FSNS(XML_r, XML_id),
+                                       OUStringToOString(aImageId, RTL_TEXTENCODING_UTF8));
+                        imageData = true;
+                    }
+                    else if (rProps.GetOpt(ESCHER_Prop_fillBlip, aStruct) && m_pTextExport)
+                    {
+                        SvMemoryStream aStream;
+                        // The first bytes are WW8-specific, we're only interested in the PNG
+                        int nHeaderSize = 25;
+                        aStream.WriteBytes(aStruct.nProp.data() + nHeaderSize,
+                                           aStruct.nProp.size() - nHeaderSize);
+                        aStream.Seek(0);
+                        Graphic aGraphic;
+                        GraphicConverter::Import(aStream, aGraphic);
+
+                        BitmapChecksum nChecksum = aGraphic.GetChecksum();
+                        OUString aImageId = m_pTextExport->FindRelId(nChecksum);
+                        if (aImageId.isEmpty())
+                        {
+                            aImageId = m_pTextExport->GetDrawingML().WriteImage(aGraphic);
+                            m_pTextExport->CacheRelId(nChecksum, aImageId);
+                        }
+                        pAttrList->add(FSNS(XML_r, XML_id),
+                                       OUStringToOString(aImageId, RTL_TEXTENCODING_UTF8));
+                        imageData = true;
+                    }
+
+                    if (rProps.GetOpt(ESCHER_Prop_fNoFillHitTest, nValue))
+                        impl_AddBool(pAttrList, FSNS(XML_o, XML_detectmouseclick), nValue != 0);
+
+                    if (imageData)
+                        m_pSerializer->singleElementNS( XML_v, XML_imagedata, XFastAttributeListRef( pAttrList ) );
+                    else
+                    {
+                        if ( rProps.GetOpt( ESCHER_Prop_fillType, nValue ) )
+                        {
+                            const char *pFillType = nullptr;
+                            switch ( nValue )
+                            {
+                                case ESCHER_FillSolid:       pFillType = "solid"; break;
+                                // TODO case ESCHER_FillPattern:     pFillType = ""; break;
+                                case ESCHER_FillTexture:     pFillType = "tile"; break;
+                                // TODO case ESCHER_FillPicture:     pFillType = ""; break;
+                                // TODO case ESCHER_FillShade:       pFillType = ""; break;
+                                // TODO case ESCHER_FillShadeCenter: pFillType = ""; break;
+                                // TODO case ESCHER_FillShadeShape:  pFillType = ""; break;
+                                // TODO case ESCHER_FillShadeScale:  pFillType = ""; break;
+                                // TODO case ESCHER_FillShadeTitle:  pFillType = ""; break;
+                                // TODO case ESCHER_FillBackground:  pFillType = ""; break;
+                                default:
+                                    SAL_INFO("oox.vml", "Unhandled fill type: " << nValue);
+                                    break;
+                            }
+                            if ( pFillType )
+                                pAttrList->add( XML_type, pFillType );
+                        }
+                        else if (!rProps.GetOpt(ESCHER_Prop_fillColor, nValue))
+                            pAttrList->add( XML_on, "false" );
+
+                        if ( rProps.GetOpt( ESCHER_Prop_fillColor, nValue ) )
+                            impl_AddColor( m_pShapeAttrList, XML_fillcolor, nValue );
+
+                        if ( rProps.GetOpt( ESCHER_Prop_fillBackColor, nValue ) )
+                            impl_AddColor( pAttrList, XML_color2, nValue );
+
+
+                        if (rProps.GetOpt(ESCHER_Prop_fillOpacity, nValue))
+                            // Partly undo the transformation at the end of EscherPropertyContainer::CreateFillProperties(): VML opacity is 0..1.
+                            pAttrList->add(XML_opacity, OString::number(double((nValue * 100) >> 16) / 100));
+                        m_pSerializer->singleElementNS( XML_v, XML_fill, XFastAttributeListRef( pAttrList ) );
+
+                    }
+                }
+                bAlreadyWritten[ ESCHER_Prop_fillType ] = true;
+                bAlreadyWritten[ ESCHER_Prop_fillColor ] = true;
+                bAlreadyWritten[ ESCHER_Prop_fillBackColor ] = true;
+                bAlreadyWritten[ ESCHER_Prop_fillBlip ] = true;
+                bAlreadyWritten[ ESCHER_Prop_fNoFillHitTest ] = true;
+                bAlreadyWritten[ ESCHER_Prop_fillOpacity ] = true;
+                break;
+
+            case ESCHER_Prop_lineColor: // 448
+            case ESCHER_Prop_lineWidth: // 459
+            case ESCHER_Prop_lineDashing: // 462
+            case ESCHER_Prop_lineStartArrowhead: // 464
+            case ESCHER_Prop_lineEndArrowhead: // 465
+            case ESCHER_Prop_lineStartArrowWidth: // 466
+            case ESCHER_Prop_lineStartArrowLength: // 467
+            case ESCHER_Prop_lineEndArrowWidth: // 468
+            case ESCHER_Prop_lineEndArrowLength: // 469
+            case ESCHER_Prop_lineJoinStyle: // 470
+            case ESCHER_Prop_lineEndCapStyle: // 471
+                {
+                    sal_uInt32 nValue;
+                    sax_fastparser::FastAttributeList *pAttrList = FastSerializerHelper::createAttrList();
+
+                    if ( rProps.GetOpt( ESCHER_Prop_lineColor, nValue ) )
+                        impl_AddColor( pAttrList, XML_color, nValue );
+
+                    if ( rProps.GetOpt( ESCHER_Prop_lineWidth, nValue ) )
+                        impl_AddInt( pAttrList, XML_weight, nValue );
+
+                    if ( rProps.GetOpt( ESCHER_Prop_lineDashing, nValue ) )
+                    {
+                        const char *pDashStyle = nullptr;
+                        switch ( nValue )
+                        {
+                            case ESCHER_LineSolid:             pDashStyle = "solid"; break;
+                            case ESCHER_LineDashSys:           pDashStyle = "shortdash"; break;
+                            case ESCHER_LineDotSys:            pDashStyle = "shortdot"; break;
+                            case ESCHER_LineDashDotSys:        pDashStyle = "shortdashdot"; break;
+                            case ESCHER_LineDashDotDotSys:     pDashStyle = "shortdashdotdot"; break;
+                            case ESCHER_LineDotGEL:            pDashStyle = "dot"; break;
+                            case ESCHER_LineDashGEL:           pDashStyle = "dash"; break;
+                            case ESCHER_LineLongDashGEL:       pDashStyle = "longdash"; break;
+                            case ESCHER_LineDashDotGEL:        pDashStyle = "dashdot"; break;
+                            case ESCHER_LineLongDashDotGEL:    pDashStyle = "longdashdot"; break;
+                            case ESCHER_LineLongDashDotDotGEL: pDashStyle = "longdashdotdot"; break;
+                        }
+                        if ( pDashStyle )
+                            pAttrList->add( XML_dashstyle, pDashStyle );
+                    }
+
+                    if ( rProps.GetOpt( ESCHER_Prop_lineStartArrowhead, nValue ) )
+                        impl_AddArrowHead( pAttrList, XML_startarrow, nValue );
+
+                    if ( rProps.GetOpt( ESCHER_Prop_lineEndArrowhead, nValue ) )
+                        impl_AddArrowHead( pAttrList, XML_endarrow, nValue );
+
+                    if ( rProps.GetOpt( ESCHER_Prop_lineStartArrowWidth, nValue ) )
+                        impl_AddArrowWidth( pAttrList, XML_startarrowwidth, nValue );
+
+                    if ( rProps.GetOpt( ESCHER_Prop_lineStartArrowLength, nValue ) )
+                        impl_AddArrowLength( pAttrList, XML_startarrowlength, nValue );
+
+                    if ( rProps.GetOpt( ESCHER_Prop_lineEndArrowWidth, nValue ) )
+                        impl_AddArrowWidth( pAttrList, XML_endarrowwidth, nValue );
+
+                    if ( rProps.GetOpt( ESCHER_Prop_lineEndArrowLength, nValue ) )
+                        impl_AddArrowLength( pAttrList, XML_endarrowlength, nValue );
+
+                    if ( rProps.GetOpt( ESCHER_Prop_lineJoinStyle, nValue ) )
+                    {
+                        const char *pJoinStyle = nullptr;
+                        switch ( nValue )
+                        {
+                            case ESCHER_LineJoinBevel: pJoinStyle = "bevel"; break;
+                            case ESCHER_LineJoinMiter: pJoinStyle = "miter"; break;
+                            case ESCHER_LineJoinRound: pJoinStyle = "round"; break;
+                        }
+                        if ( pJoinStyle )
+                            pAttrList->add( XML_joinstyle, pJoinStyle );
+                    }
+
+                    if ( rProps.GetOpt( ESCHER_Prop_lineEndCapStyle, nValue ) )
+                    {
+                        const char *pEndCap = nullptr;
+                        switch ( nValue )
+                        {
+                            case ESCHER_LineEndCapRound:  pEndCap = "round"; break;
+                            case ESCHER_LineEndCapSquare: pEndCap = "square"; break;
+                            case ESCHER_LineEndCapFlat:   pEndCap = "flat"; break;
+                        }
+                        if ( pEndCap )
+                            pAttrList->add( XML_endcap, pEndCap );
+                    }
+
+                    m_pSerializer->singleElementNS( XML_v, XML_stroke, XFastAttributeListRef( pAttrList ) );
+                }
+                bAlreadyWritten[ ESCHER_Prop_lineColor ] = true;
+                bAlreadyWritten[ ESCHER_Prop_lineWidth ] = true;
+                bAlreadyWritten[ ESCHER_Prop_lineDashing ] = true;
+                bAlreadyWritten[ ESCHER_Prop_lineStartArrowhead ] = true;
+                bAlreadyWritten[ ESCHER_Prop_lineEndArrowhead ] = true;
+                bAlreadyWritten[ ESCHER_Prop_lineStartArrowWidth ] = true;
+                bAlreadyWritten[ ESCHER_Prop_lineStartArrowLength ] = true;
+                bAlreadyWritten[ ESCHER_Prop_lineEndArrowWidth ] = true;
+                bAlreadyWritten[ ESCHER_Prop_lineEndArrowLength ] = true;
+                bAlreadyWritten[ ESCHER_Prop_lineJoinStyle ] = true;
+                bAlreadyWritten[ ESCHER_Prop_lineEndCapStyle ] = true;
+                break;
+
+            case ESCHER_Prop_fHidden:
+                if ( !opt.nPropValue )
+                    m_ShapeStyle.append( ";visibility:hidden" );
+                break;
+            case ESCHER_Prop_shadowColor:
+            case ESCHER_Prop_fshadowObscured:
+                {
+                    sal_uInt32 nValue = 0;
+                    bool bShadow = false;
+                    bool bObscured = false;
+                    if ( rProps.GetOpt( ESCHER_Prop_fshadowObscured, nValue ) )
+                    {
+                        bShadow = (( nValue & 0x20002 ) == 0x20002 );
+                        bObscured = (( nValue & 0x10001 ) == 0x10001 );
+                    }
+                    if ( bShadow )
+                    {
+                        sax_fastparser::FastAttributeList *pAttrList = FastSerializerHelper::createAttrList();
+                        impl_AddBool( pAttrList, XML_on, bShadow );
+                        impl_AddBool( pAttrList, XML_obscured, bObscured );
+
+                        if ( rProps.GetOpt( ESCHER_Prop_shadowColor, nValue ) )
+                            impl_AddColor( pAttrList, XML_color, nValue );
+
+                        m_pSerializer->singleElementNS( XML_v, XML_shadow, XFastAttributeListRef( pAttrList ) );
+                        bAlreadyWritten[ ESCHER_Prop_fshadowObscured ] = true;
+                        bAlreadyWritten[ ESCHER_Prop_shadowColor ] = true;
+                    }
+                }
+                break;
+            case ESCHER_Prop_gtextUNICODE:
+            case ESCHER_Prop_gtextFont:
+                {
+                    EscherPropSortStruct aUnicode;
+                    if (rProps.GetOpt(ESCHER_Prop_gtextUNICODE, aUnicode))
+                    {
+                        SvMemoryStream aStream;
+
+                        if(!opt.nProp.empty())
+                        {
+                            aStream.WriteBytes(opt.nProp.data(), opt.nProp.size());
+                        }
+
+                        aStream.Seek(0);
+                        OUString aTextPathString = SvxMSDffManager::MSDFFReadZString(aStream, opt.nProp.size(), true);
+                        aStream.Seek(0);
+
+                        m_pSerializer->singleElementNS(XML_v, XML_path, XML_textpathok, "t");
+
+                        sax_fastparser::FastAttributeList* pAttrList = FastSerializerHelper::createAttrList();
+                        pAttrList->add(XML_on, "t");
+                        pAttrList->add(XML_fitshape, "t");
+                        pAttrList->add(XML_string, OUStringToOString(aTextPathString, RTL_TEXTENCODING_UTF8));
+                        EscherPropSortStruct aFont;
+                        OUString aStyle;
+                        if (rProps.GetOpt(ESCHER_Prop_gtextFont, aFont))
+                        {
+                            aStream.WriteBytes(aFont.nProp.data(), aFont.nProp.size());
+                            aStream.Seek(0);
+                            OUString aTextPathFont = SvxMSDffManager::MSDFFReadZString(aStream, aFont.nProp.size(), true);
+                            aStyle += "font-family:\"" + aTextPathFont + "\"";
+                        }
+                        sal_uInt32 nSize;
+                        if (rProps.GetOpt(ESCHER_Prop_gtextSize, nSize))
+                        {
+                            float nSizeF = static_cast<sal_Int32>(nSize) / 65536.0;
+                            OUString aSize = OUString::number(nSizeF);
+                            aStyle += ";font-size:" + aSize + "pt";
+                        }
+                        if (IsWaterMarkShape(m_pSdrObject->GetName()))
+                            pAttrList->add(XML_trim, "t");
+
+                        if (!aStyle.isEmpty())
+                            pAttrList->add(XML_style, OUStringToOString(aStyle, RTL_TEXTENCODING_UTF8));
+                        m_pSerializer->singleElementNS(XML_v, XML_textpath, XFastAttributeListRef(pAttrList));
+                    }
+
+                    bAlreadyWritten[ESCHER_Prop_gtextUNICODE] = true;
+                    bAlreadyWritten[ESCHER_Prop_gtextFont] = true;
+                }
+                break;
+            case ESCHER_Prop_Rotation:
+                {
+                    // The higher half of the variable contains the angle.
+                    m_ShapeStyle.append(";rotation:").append(double(opt.nPropValue >> 16));
+                    bAlreadyWritten[ESCHER_Prop_Rotation] = true;
+                }
+                break;
+            case ESCHER_Prop_fNoLineDrawDash:
+                {
+                    // See DffPropertyReader::ApplyLineAttributes().
+                    impl_AddBool( m_pShapeAttrList, XML_stroked, (opt.nPropValue & 8) != 0 );
+                    bAlreadyWritten[ESCHER_Prop_fNoLineDrawDash] = true;
+                }
+                break;
+            case ESCHER_Prop_wzName:
+                {
+                    SvMemoryStream aStream;
+
+                    if(!opt.nProp.empty())
+                    {
+                        aStream.WriteBytes(opt.nProp.data(), opt.nProp.size());
+                    }
+
+                    aStream.Seek(0);
+                    OUString idStr = SvxMSDffManager::MSDFFReadZString(aStream, opt.nProp.size(), true);
+                    aStream.Seek(0);
+                    if (!IsWaterMarkShape(m_pSdrObject->GetName()) && !m_bSkipwzName)
+                         m_pShapeAttrList->add(XML_ID, OUStringToOString(idStr, RTL_TEXTENCODING_UTF8).getStr());
+
+                    bAlreadyWritten[ESCHER_Prop_wzName] = true;
+                }
+                break;
+            default:
+#if OSL_DEBUG_LEVEL > 0
+                const size_t opt_nProp_size(opt.nProp.size());
+                const sal_uInt8 opt_nProp_empty(0);
+                fprintf( stderr, "TODO VMLExport::Commit(), unimplemented id: %d, value: %" SAL_PRIuUINT32 ", data: [%zu, %p]\n",
+                        nId,
+                        opt.nPropValue,
+                        opt_nProp_size,
+                        0 == opt_nProp_size ? &opt_nProp_empty : opt.nProp.data());
+                if ( opt.nProp.size() )
+                {
+                    const sal_uInt8 *pIt = opt.nProp.data();
+                    fprintf( stderr, "    ( " );
+                    for ( int nCount = opt.nProp.size(); nCount; --nCount )
+                    {
+                        fprintf( stderr, "%02x ", *pIt );
+                        ++pIt;
+                    }
+                    fprintf( stderr, ")\n" );
+                }
+#endif
+                break;
+        }
+    }
+
+    m_pSerializer->mergeTopMarks(Tag_Commit, sax_fastparser::MergeMarks::POSTPONE );
+}
+
+OString VMLExport::ShapeIdString( sal_uInt32 nId )
+{
+    if(m_bOverrideShapeIdGeneration)
+        return m_sShapeIDPrefix + OString::number( nId );
+    else
+        return "shape_" + OString::number( nId );
+}
+
+void VMLExport::AddFlipXY( )
+{
+    if (m_nShapeFlags & (ShapeFlag::FlipH | ShapeFlag::FlipV))
+    {
+        m_ShapeStyle.append( ";flip:" );
+
+        if (m_nShapeFlags & ShapeFlag::FlipH)
+            m_ShapeStyle.append( "x" );
+
+        if (m_nShapeFlags & ShapeFlag::FlipV)
+            m_ShapeStyle.append( "y" );
+    }
+}
+
+void VMLExport::AddLineDimensions( const tools::Rectangle& rRectangle )
+{
+    // style
+    if (!m_ShapeStyle.isEmpty())
+        m_ShapeStyle.append( ";" );
+
+    m_ShapeStyle.append( "position:absolute" );
+
+    AddFlipXY();
+
+    // the actual dimensions
+    OString aLeft, aTop, aRight, aBottom;
+
+    if ( mnGroupLevel == 1 )
+    {
+        const OString aPt( "pt" );
+        aLeft = OString::number( double( rRectangle.Left() ) / 20 ) + aPt;
+        aTop = OString::number( double( rRectangle.Top() ) / 20 ) + aPt;
+        aRight = OString::number( double( rRectangle.Right() ) / 20 ) + aPt;
+        aBottom = OString::number( double( rRectangle.Bottom() ) / 20 ) + aPt;
+    }
+    else
+    {
+        aLeft = OString::number( rRectangle.Left() );
+        aTop = OString::number( rRectangle.Top() );
+        aRight = OString::number( rRectangle.Right() );
+        aBottom = OString::number( rRectangle.Bottom() );
+    }
+
+    m_pShapeAttrList->add( XML_from,
+            OStringBuffer( 20 ).append( aLeft )
+            .append( "," ).append( aTop )
+            .makeStringAndClear() );
+
+    m_pShapeAttrList->add( XML_to,
+            OStringBuffer( 20 ).append( aRight )
+            .append( "," ).append( aBottom )
+            .makeStringAndClear() );
+}
+
+void VMLExport::AddRectangleDimensions( OStringBuffer& rBuffer, const tools::Rectangle& rRectangle, bool rbAbsolutePos)
+{
+    if ( !rBuffer.isEmpty() )
+        rBuffer.append( ";" );
+
+    if (rbAbsolutePos && !m_bInline)
+    {
+        rBuffer.append( "position:absolute;" );
+    }
+
+    if(m_bInline)
+    {
+        rBuffer.append( "width:" ).append( double( rRectangle.Right() - rRectangle.Left() ) / 20 )
+            .append( "pt;height:" ).append( double( rRectangle.Bottom() - rRectangle.Top() ) / 20 )
+            .append( "pt" );
+    }
+    else if ( mnGroupLevel == 1 )
+    {
+        rBuffer.append( "margin-left:" ).append( double( rRectangle.Left() ) / 20 )
+            .append( "pt;margin-top:" ).append( double( rRectangle.Top() ) / 20 )
+            .append( "pt;width:" ).append( double( rRectangle.Right() - rRectangle.Left() ) / 20 )
+            .append( "pt;height:" ).append( double( rRectangle.Bottom() - rRectangle.Top() ) / 20 )
+            .append( "pt" );
+    }
+    else
+    {
+        rBuffer.append( "left:" ).append( rRectangle.Left() )
+            .append( ";top:" ).append( rRectangle.Top() )
+            .append( ";width:" ).append( rRectangle.Right() - rRectangle.Left() )
+            .append( ";height:" ).append( rRectangle.Bottom() - rRectangle.Top() );
+    }
+
+    AddFlipXY();
+}
+
+void VMLExport::AddShapeAttribute( sal_Int32 nAttribute, const OString& rValue )
+{
+    m_pShapeAttrList->add( nAttribute, rValue );
+}
+
+static std::vector<OString> lcl_getShapeTypes()
+{
+    std::vector<OString> aRet;
+
+    OUString aPath("$BRAND_BASE_DIR/" LIBO_SHARE_FOLDER "/filter/vml-shape-types");
+    rtl::Bootstrap::expandMacros(aPath);
+    SvFileStream aStream(aPath, StreamMode::READ);
+    if (aStream.GetError() != ERRCODE_NONE)
+        SAL_WARN("oox", "failed to open vml-shape-types");
+    OString aLine;
+    bool bNotDone = aStream.ReadLine(aLine);
+    while (bNotDone)
+    {
+        // Filter out comments.
+        if (!aLine.startsWith("/"))
+            aRet.push_back(aLine);
+        bNotDone = aStream.ReadLine(aLine);
+    }
+    return aRet;
+}
+
+static bool lcl_isTextBox(const SdrObject* pSdrObject)
+{
+    uno::Reference<beans::XPropertySet> xPropertySet(const_cast<SdrObject*>(pSdrObject)->getUnoShape(), uno::UNO_QUERY);
+    if (xPropertySet.is())
+    {
+        uno::Reference<beans::XPropertySetInfo> xPropertySetInfo = xPropertySet->getPropertySetInfo();
+        return xPropertySetInfo->hasPropertyByName("TextBox") && xPropertySet->getPropertyValue("TextBox").get<bool>();
+    }
+    return false;
+}
+
+static OUString lcl_getAnchorIdFromGrabBag(const SdrObject* pSdrObject)
+{
+    OUString aResult;
+
+    uno::Reference<beans::XPropertySet> xShape(const_cast<SdrObject*>(pSdrObject)->getUnoShape(), uno::UNO_QUERY);
+    if (xShape->getPropertySetInfo()->hasPropertyByName("InteropGrabBag"))
+    {
+        comphelper::SequenceAsHashMap aInteropGrabBag(xShape->getPropertyValue("InteropGrabBag"));
+        if (aInteropGrabBag.find("AnchorId") != aInteropGrabBag.end())
+            aInteropGrabBag["AnchorId"] >>= aResult;
+    }
+
+    return aResult;
+}
+
+sal_uInt32 VMLExport::GenerateShapeId()
+{
+    if(!m_bOverrideShapeIdGeneration)
+        return EscherEx::GenerateShapeId();
+    else
+        return m_nShapeIDCounter++;
+}
+
+sal_Int32 VMLExport::StartShape()
+{
+    if ( m_nShapeType == ESCHER_ShpInst_Nil )
+        return -1;
+
+    // some of the shapes have their own name ;-)
+    sal_Int32 nShapeElement = -1;
+    bool bReferToShapeType = false;
+    switch ( m_nShapeType )
+    {
+        case ESCHER_ShpInst_NotPrimitive:   nShapeElement = XML_shape;     break;
+        case ESCHER_ShpInst_Rectangle:      nShapeElement = XML_rect;      break;
+        case ESCHER_ShpInst_RoundRectangle: nShapeElement = XML_roundrect; break;
+        case ESCHER_ShpInst_Ellipse:        nShapeElement = XML_oval;      break;
+        case ESCHER_ShpInst_Arc:            nShapeElement = XML_arc;       break;
+        case ESCHER_ShpInst_Line:           nShapeElement = XML_line;      break;
+        case ESCHER_ShpInst_HostControl:
+        {
+            // We don't have a shape definition for host control in presetShapeDefinitions.xml
+            // So use a definition copied from DOCX file created with MSO
+            bReferToShapeType = true;
+            nShapeElement = XML_shape;
+            if ( !m_aShapeTypeWritten[ m_nShapeType ] )
+            {
+                OString sShapeType =
+                    "<v:shapetype id=\"shapetype_" + OString::number(m_nShapeType) +
+                        "\" coordsize=\"21600,21600\" o:spt=\"" + OString::number(m_nShapeType) +
+                        "\" path=\"m,l,21600l21600,21600l21600,xe\">\n"
+                        "<v:stroke joinstyle=\"miter\"/>\n"
+                        "<v:path shadowok=\"f\" o:extrusionok=\"f\" strokeok=\"f\" fillok=\"f\" o:connecttype=\"rect\"/>\n"
+                        "<o:lock v:ext=\"edit\" shapetype=\"t\"/>\n"
+                    "</v:shapetype>";
+                m_pSerializer->write(sShapeType);
+                m_aShapeTypeWritten[ m_nShapeType ] = true;
+            }
+            break;
+        }
+        case ESCHER_ShpInst_PictureFrame:
+        {
+            // We don't have a shape definition for picture frame in presetShapeDefinitions.xml
+            // So use a definition copied from DOCX file created with MSO
+            bReferToShapeType = true;
+            nShapeElement = XML_shape;
+            if ( !m_aShapeTypeWritten[ m_nShapeType ] )
+            {
+                OString sShapeType =
+                    "<v:shapetype id=\"shapetype_" + OString::number(m_nShapeType) +
+                        "\" coordsize=\"21600,21600\" o:spt=\"" + OString::number(m_nShapeType) +
+                        "\" o:preferrelative=\"t\" path=\"m@4@5l@4@11@9@11@9@5xe\" filled=\"f\" stroked=\"f\">\n"
+                        "<v:stroke joinstyle=\"miter\"/>\n"
+                        "<v:formulas>\n"
+                            "<v:f eqn=\"if lineDrawn pixelLineWidth 0\"/>\n"
+                            "<v:f eqn=\"sum @0 1 0\"/>\n"
+                            "<v:f eqn=\"sum 0 0 @1\"/>\n"
+                            "<v:f eqn=\"prod @2 1 2\"/>\n"
+                            "<v:f eqn=\"prod @3 21600 pixelWidth\"/>\n"
+                            "<v:f eqn=\"prod @3 21600 pixelHeight\"/>\n"
+                            "<v:f eqn=\"sum @0 0 1\"/>\n"
+                            "<v:f eqn=\"prod @6 1 2\"/>\n"
+                            "<v:f eqn=\"prod @7 21600 pixelWidth\"/>\n"
+                            "<v:f eqn=\"sum @8 21600 0\"/>\n"
+                            "<v:f eqn=\"prod @7 21600 pixelHeight\"/>\n"
+                            "<v:f eqn=\"sum @10 21600 0\"/>\n"
+                        "</v:formulas>\n"
+                        "<v:path o:extrusionok=\"f\" gradientshapeok=\"t\" o:connecttype=\"rect\"/>\n"
+                        "<o:lock v:ext=\"edit\" aspectratio=\"t\"/>\n"
+                        "</v:shapetype>";
+                m_pSerializer->write(sShapeType);
+                m_aShapeTypeWritten[ m_nShapeType ] = true;
+            }
+            break;
+        }
+        default:
+            if ( m_nShapeType < ESCHER_ShpInst_COUNT )
+            {
+                nShapeElement = XML_shape;
+
+                // a predefined shape?
+                static std::vector<OString> aShapeTypes = lcl_getShapeTypes();
+                OString aShapeType = aShapeTypes[ m_nShapeType ];
+                if ( aShapeType != "NULL" )
+                {
+                    bReferToShapeType = true;
+                    if ( !m_aShapeTypeWritten[ m_nShapeType ] )
+                    {
+                        m_pSerializer->write( aShapeType.getStr() );
+                        m_aShapeTypeWritten[ m_nShapeType ] = true;
+                    }
+                }
+                else
+                {
+                    // rectangle is probably the best fallback...
+                    nShapeElement = XML_rect;
+                }
+            }
+            break;
+    }
+
+    // anchoring
+    switch (m_eHOri)
+    {
+        case text::HoriOrientation::LEFT:
+            m_ShapeStyle.append(";mso-position-horizontal:left");
+            break;
+        case text::HoriOrientation::CENTER:
+            m_ShapeStyle.append(";mso-position-horizontal:center");
+            break;
+        case text::HoriOrientation::RIGHT:
+            m_ShapeStyle.append(";mso-position-horizontal:right");
+            break;
+        case text::HoriOrientation::INSIDE:
+            m_ShapeStyle.append(";mso-position-horizontal:inside");
+            break;
+        case text::HoriOrientation::OUTSIDE:
+            m_ShapeStyle.append(";mso-position-horizontal:outside");
+            break;
+        default:
+        case text::HoriOrientation::NONE:
+            break;
+    }
+    switch (m_eHRel)
+    {
+        case text::RelOrientation::PAGE_PRINT_AREA:
+            m_ShapeStyle.append(";mso-position-horizontal-relative:margin");
+            break;
+        case text::RelOrientation::PAGE_FRAME:
+        case text::RelOrientation::PAGE_LEFT:
+        case text::RelOrientation::PAGE_RIGHT:
+            m_ShapeStyle.append(";mso-position-horizontal-relative:page");
+            break;
+        case text::RelOrientation::CHAR:
+            m_ShapeStyle.append(";mso-position-horizontal-relative:char");
+            break;
+        default:
+            break;
+    }
+
+    switch (m_eVOri)
+    {
+        case text::VertOrientation::TOP:
+        case text::VertOrientation::LINE_TOP:
+        case text::VertOrientation::CHAR_TOP:
+            m_ShapeStyle.append(";mso-position-vertical:top");
+            break;
+        case text::VertOrientation::CENTER:
+        case text::VertOrientation::LINE_CENTER:
+            m_ShapeStyle.append(";mso-position-vertical:center");
+            break;
+        case text::VertOrientation::BOTTOM:
+        case text::VertOrientation::LINE_BOTTOM:
+        case text::VertOrientation::CHAR_BOTTOM:
+            m_ShapeStyle.append(";mso-position-vertical:bottom");
+            break;
+        default:
+        case text::VertOrientation::NONE:
+            break;
+    }
+    switch (m_eVRel)
+    {
+        case text::RelOrientation::PAGE_PRINT_AREA:
+            m_ShapeStyle.append(";mso-position-vertical-relative:margin");
+            break;
+        case text::RelOrientation::PAGE_FRAME:
+            m_ShapeStyle.append(";mso-position-vertical-relative:page");
+            break;
+        default:
+            break;
+    }
+
+    // add style
+    m_pShapeAttrList->add( XML_style, m_ShapeStyle.makeStringAndClear() );
+
+    OUString sAnchorId = lcl_getAnchorIdFromGrabBag(m_pSdrObject);
+    if (!sAnchorId.isEmpty())
+        m_pShapeAttrList->addNS(XML_wp14, XML_anchorId, OUStringToOString(sAnchorId, RTL_TEXTENCODING_UTF8));
+
+    if ( nShapeElement >= 0 && !m_pShapeAttrList->hasAttribute( XML_type ) && bReferToShapeType )
+    {
+        OStringBuffer sTypeBuffer( 20 );
+        if (m_bUseHashMarkForType)
+            sTypeBuffer.append("#");
+        m_pShapeAttrList->add( XML_type, sTypeBuffer
+                .append( "shapetype_" ).append( sal_Int32( m_nShapeType ) )
+                .makeStringAndClear() );
+    }
+
+    // start of the shape
+    m_pSerializer->startElementNS( XML_v, nShapeElement, XFastAttributeListRef( m_pShapeAttrList ) );
+
+    OString const textboxStyle(m_TextboxStyle.makeStringAndClear());
+
+    // now check if we have some editeng text (not associated textbox) and we have a text exporter registered
+    const SdrTextObj* pTxtObj = dynamic_cast<const SdrTextObj*>( m_pSdrObject );
+    if (pTxtObj && m_pTextExport && msfilter::util::HasTextBoxContent(m_nShapeType) && !IsWaterMarkShape(m_pSdrObject->GetName()) && !lcl_isTextBox(m_pSdrObject))
+    {
+        const OutlinerParaObject* pParaObj = nullptr;
+        bool bOwnParaObj = false;
+
+        /*
+        #i13885#
+        When the object is actively being edited, that text is not set into
+        the objects normal text object, but lives in a separate object.
+        */
+        if (pTxtObj->IsTextEditActive())
+        {
+            pParaObj = pTxtObj->CreateEditOutlinerParaObject().release();
+            bOwnParaObj = true;
+        }
+        else
+        {
+            pParaObj = pTxtObj->GetOutlinerParaObject();
+        }
+
+        if( pParaObj )
+        {
+            sax_fastparser::FastAttributeList* pTextboxAttrList = FastSerializerHelper::createAttrList();
+            sax_fastparser::XFastAttributeListRef xTextboxAttrList(pTextboxAttrList);
+            if (!textboxStyle.isEmpty())
+            {
+                pTextboxAttrList->add(XML_style, textboxStyle);
+            }
+
+            // this is reached only in case some text is attached to the shape
+            m_pSerializer->startElementNS(XML_v, XML_textbox, xTextboxAttrList);
+            m_pTextExport->WriteOutliner(*pParaObj);
+            m_pSerializer->endElementNS(XML_v, XML_textbox);
+            if( bOwnParaObj )
+                delete pParaObj;
+        }
+    }
+
+    return nShapeElement;
+}
+
+void VMLExport::EndShape( sal_Int32 nShapeElement )
+{
+    if ( nShapeElement < 0 )
+        return;
+
+    if (m_pTextExport && lcl_isTextBox(m_pSdrObject))
+    {
+        uno::Reference<beans::XPropertySet> xPropertySet(const_cast<SdrObject*>(m_pSdrObject)->getUnoShape(), uno::UNO_QUERY);
+        comphelper::SequenceAsHashMap aCustomShapeProperties(xPropertySet->getPropertyValue("CustomShapeGeometry"));
+        sax_fastparser::FastAttributeList* pTextboxAttrList = FastSerializerHelper::createAttrList();
+        if (aCustomShapeProperties.find("TextPreRotateAngle") != aCustomShapeProperties.end())
+        {
+            sal_Int32 nTextRotateAngle = aCustomShapeProperties["TextPreRotateAngle"].get<sal_Int32>();
+            if (nTextRotateAngle == -270)
+                pTextboxAttrList->add(XML_style, "mso-layout-flow-alt:bottom-to-top");
+        }
+        sax_fastparser::XFastAttributeListRef xTextboxAttrList(pTextboxAttrList);
+        pTextboxAttrList = nullptr;
+        m_pSerializer->startElementNS(XML_v, XML_textbox, xTextboxAttrList);
+
+        m_pTextExport->WriteVMLTextBox(uno::Reference<drawing::XShape>(xPropertySet, uno::UNO_QUERY_THROW));
+
+        m_pSerializer->endElementNS(XML_v, XML_textbox);
+    }
+
+    if (m_pWrapAttrList)
+    {
+        sax_fastparser::XFastAttributeListRef const pWrapAttrList(m_pWrapAttrList.release());
+        m_pSerializer->singleElementNS(XML_w10, XML_wrap, pWrapAttrList);
+    }
+
+    // end of the shape
+    m_pSerializer->endElementNS( XML_v, nShapeElement );
+}
+
+OString const & VMLExport::AddSdrObject( const SdrObject& rObj, sal_Int16 eHOri, sal_Int16 eVOri, sal_Int16 eHRel, sal_Int16 eVRel,
+        std::unique_ptr<FastAttributeList> pWrapAttrList,
+        const bool bOOxmlExport )
+{
+    m_pSdrObject = &rObj;
+    m_eHOri = eHOri;
+    m_eVOri = eVOri;
+    m_eHRel = eHRel;
+    m_eVRel = eVRel;
+    m_pWrapAttrList = std::move(pWrapAttrList);
+    m_bInline = false;
+    EscherEx::AddSdrObject(rObj, bOOxmlExport);
+    return m_sShapeId;
+}
+
+OString const & VMLExport::AddInlineSdrObject( const SdrObject& rObj, const bool bOOxmlExport )
+{
+    m_pSdrObject = &rObj;
+    m_eHOri = -1;
+    m_eVOri = -1;
+    m_eHRel = -1;
+    m_eVRel = -1;
+    m_pWrapAttrList.reset();
+    m_bInline = true;
+    EscherEx::AddSdrObject(rObj, bOOxmlExport);
+    return m_sShapeId;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */