Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

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

59 files changed, 32210 insertions, 0 deletions

diff --git a/xmloff/source/draw/EnhancedCustomShapeToken.cxx b/xmloff/source/draw/EnhancedCustomShapeToken.cxx
new file mode 100644
index 000000000..bd0613e9e
--- /dev/null
+++ b/xmloff/source/draw/EnhancedCustomShapeToken.cxx
@@ -0,0 +1,214 @@
+/* -*- 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 <EnhancedCustomShapeToken.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <unordered_map>
+#include <memory>
+
+namespace xmloff::EnhancedCustomShapeToken {
+
+
+namespace {
+
+struct TokenTable
+{
+    const char*                         pS;
+    EnhancedCustomShapeTokenEnum        pE;
+};
+
+}
+
+const TokenTable pTokenTableArray[] =
+{
+    { "type",                               EAS_type },
+    { "name",                               EAS_name },
+    { "mirror-horizontal",                  EAS_mirror_horizontal },
+    { "mirror-vertical",                    EAS_mirror_vertical },
+    { "viewBox",                            EAS_viewBox },
+    { "text-rotate-angle",                  EAS_text_rotate_angle },
+    { "extrusion-allowed",                  EAS_extrusion_allowed },
+    { "extrusion-text-path-allowed",        EAS_text_path_allowed },
+    { "extrusion-concentric-gradient-fill", EAS_concentric_gradient_fill_allowed },
+    { "extrusion",                          EAS_extrusion },
+    { "extrusion-brightness",               EAS_extrusion_brightness },
+    { "extrusion-depth",                    EAS_extrusion_depth },
+    { "extrusion-diffusion",                EAS_extrusion_diffusion },
+    { "extrusion-number-of-line-segments",  EAS_extrusion_number_of_line_segments },
+    { "extrusion-light-face",               EAS_extrusion_light_face },
+    { "extrusion-first-light-harsh",        EAS_extrusion_first_light_harsh },
+    { "extrusion-second-light-harsh",       EAS_extrusion_second_light_harsh },
+    { "extrusion-first-light-level",        EAS_extrusion_first_light_level },
+    { "extrusion-second-light-level",       EAS_extrusion_second_light_level },
+    { "extrusion-first-light-direction",    EAS_extrusion_first_light_direction },
+    { "extrusion-second-light-direction",   EAS_extrusion_second_light_direction },
+    { "extrusion-metal",                    EAS_extrusion_metal },
+    { "extrusion-metal-type",               EAS_extrusion_metal_type },
+    { "shade-mode",                         EAS_shade_mode },
+    { "extrusion-rotation-angle",           EAS_extrusion_rotation_angle },
+    { "extrusion-rotation-center",          EAS_extrusion_rotation_center },
+    { "extrusion-shininess",                EAS_extrusion_shininess },
+    { "extrusion-skew",                     EAS_extrusion_skew },
+    { "extrusion-specularity",              EAS_extrusion_specularity },
+    { "extrusion-specularity-loext",        EAS_extrusion_specularity_loext },
+    { "projection",                         EAS_projection },
+    { "extrusion-viewpoint",                EAS_extrusion_viewpoint },
+    { "extrusion-origin",                   EAS_extrusion_origin },
+    { "extrusion-color",                    EAS_extrusion_color },
+    { "enhanced-path",                      EAS_enhanced_path },
+    { "path-stretchpoint-x",                EAS_path_stretchpoint_x },
+    { "path-stretchpoint-y",                EAS_path_stretchpoint_y },
+    { "text-areas",                         EAS_text_areas },
+    { "glue-points",                        EAS_glue_points },
+    { "glue-point-type",                    EAS_glue_point_type },
+    { "glue-point-leaving-directions",      EAS_glue_point_leaving_directions },
+    { "text-path",                          EAS_text_path },
+    { "text-path-mode",                     EAS_text_path_mode },
+    { "text-path-scale",                    EAS_text_path_scale },
+    { "text-path-same-letter-heights",      EAS_text_path_same_letter_heights },
+    { "modifiers",                          EAS_modifiers },
+    { "equation",                           EAS_equation },
+    { "formula",                            EAS_formula },
+    { "handle",                             EAS_handle },
+    { "handle-mirror-horizontal",           EAS_handle_mirror_horizontal },
+    { "handle-mirror-vertical",             EAS_handle_mirror_vertical },
+    { "handle-switched",                    EAS_handle_switched },
+    { "handle-position",                    EAS_handle_position },
+    { "handle-range-x-minimum",             EAS_handle_range_x_minimum },
+    { "handle-range-x-maximum",             EAS_handle_range_x_maximum },
+    { "handle-range-y-minimum",             EAS_handle_range_y_minimum },
+    { "handle-range-y-maximum",             EAS_handle_range_y_maximum },
+    { "handle-polar",                       EAS_handle_polar },
+    { "handle-radius-range-minimum",        EAS_handle_radius_range_minimum },
+    { "handle-radius-range-maximum",        EAS_handle_radius_range_maximum },
+    { "sub-view-size",                      EAS_sub_view_size },
+
+    { "CustomShapeEngine",                  EAS_CustomShapeEngine },
+    { "CustomShapeData",                    EAS_CustomShapeData },
+    { "Type",                               EAS_Type },
+    { "MirroredX",                          EAS_MirroredX },
+    { "MirroredY",                          EAS_MirroredY },
+    { "ViewBox",                            EAS_ViewBox },
+    { "TextRotateAngle",                    EAS_TextRotateAngle },
+    { "TextPreRotateAngle",                 EAS_TextPreRotateAngle },
+    { "ExtrusionAllowed",                   EAS_ExtrusionAllowed },
+    { "TextPathAllowed",                    EAS_TextPathAllowed },
+    { "ConcentricGradientFillAllowed",      EAS_ConcentricGradientFillAllowed },
+    { "Extrusion",                          EAS_Extrusion },
+    { "Equations",                          EAS_Equations },
+    { "Equation",                           EAS_Equation },
+    { "Path",                               EAS_Path },
+    { "TextPath",                           EAS_TextPath },
+    { "Handles",                            EAS_Handles },
+    { "Handle",                             EAS_Handle },
+    { "Brightness",                         EAS_Brightness },
+    { "Depth",                              EAS_Depth },
+    { "Diffusion",                          EAS_Diffusion },
+    { "NumberOfLineSegments",               EAS_NumberOfLineSegments },
+    { "LightFace",                          EAS_LightFace },
+    { "FirstLightHarsh",                    EAS_FirstLightHarsh },
+    { "SecondLightHarsh",                   EAS_SecondLightHarsh },
+    { "FirstLightLevel",                    EAS_FirstLightLevel },
+    { "SecondLightLevel",                   EAS_SecondLightLevel },
+    { "FirstLightDirection",                EAS_FirstLightDirection },
+    { "SecondLightDirection",               EAS_SecondLightDirection },
+    { "Metal",                              EAS_Metal },
+    { "MetalType",                          EAS_MetalType },
+    { "ShadeMode",                          EAS_ShadeMode },
+    { "RotateAngle",                        EAS_RotateAngle },
+    { "RotationCenter",                     EAS_RotationCenter },
+    { "Shininess",                          EAS_Shininess },
+    { "Skew",                               EAS_Skew },
+    { "Specularity",                        EAS_Specularity },
+    { "ProjectionMode",                     EAS_ProjectionMode },
+    { "ViewPoint",                          EAS_ViewPoint },
+    { "Origin",                             EAS_Origin },
+    { "Color",                              EAS_Color },
+    { "Switched",                           EAS_Switched },
+    { "Polar",                              EAS_Polar },
+    { "RangeXMinimum",                      EAS_RangeXMinimum },
+    { "RangeXMaximum",                      EAS_RangeXMaximum },
+    { "RangeYMinimum",                      EAS_RangeYMinimum },
+    { "RangeYMaximum",                      EAS_RangeYMaximum },
+    { "RadiusRangeMinimum",                 EAS_RadiusRangeMinimum },
+    { "RadiusRangeMaximum",                 EAS_RadiusRangeMaximum },
+    { "Coordinates",                        EAS_Coordinates },
+    { "Segments",                           EAS_Segments },
+    { "StretchX",                           EAS_StretchX },
+    { "StretchY",                           EAS_StretchY },
+    { "TextFrames",                         EAS_TextFrames },
+    { "GluePoints",                         EAS_GluePoints },
+    { "GluePointLeavingDirections",         EAS_GluePointLeavingDirections },
+    { "GluePointType",                      EAS_GluePointType },
+    { "TextPathMode",                       EAS_TextPathMode },
+    { "ScaleX",                             EAS_ScaleX },
+    { "SameLetterHeights",                  EAS_SameLetterHeights },
+    { "Position",                           EAS_Position },
+    { "AdjustmentValues",                   EAS_AdjustmentValues },
+    { "SubViewSize",                        EAS_SubViewSize },
+
+    { "Last",                               EAS_Last },
+    { "NotFound",                           EAS_NotFound }
+};
+
+typedef std::unordered_map< const char*, EnhancedCustomShapeTokenEnum, rtl::CStringHash, rtl::CStringEqual> TypeNameHashMap;
+static const TypeNameHashMap& GetNameHashMap()
+{
+    static TypeNameHashMap aHashMap = []()
+        {   // init hash map
+            TypeNameHashMap res;
+            for (auto const & pair : pTokenTableArray)
+                res[pair.pS] = pair.pE;
+            return res;
+        }();
+
+    return aHashMap;
+}
+
+EnhancedCustomShapeTokenEnum EASGet( const OUString& rShapeType )
+{
+    EnhancedCustomShapeTokenEnum eRetValue = EAS_NotFound;
+    int i, nLen = rShapeType.getLength();
+    std::unique_ptr<char[]> pBuf(new char[ nLen + 1 ]);
+    for ( i = 0; i < nLen; i++ )
+        pBuf[ i ] = static_cast<char>(rShapeType[ i ]);
+    pBuf[ i ] = 0;
+    auto& rHashMap = GetNameHashMap();
+    TypeNameHashMap::const_iterator aHashIter( rHashMap.find( pBuf.get() ) );
+    if ( aHashIter != rHashMap.end() )
+        eRetValue = (*aHashIter).second;
+    return eRetValue;
+}
+
+EnhancedCustomShapeTokenEnum EASGet( sal_Int32 nToken )
+{
+    return EASGet(SvXMLImport::getNameFromToken(nToken));
+}
+
+OUString EASGet( const EnhancedCustomShapeTokenEnum eToken )
+{
+    sal_uInt32 i = eToken >= EAS_Last
+        ? sal_uInt32(EAS_NotFound)
+        : static_cast<sal_uInt32>(eToken);
+    return OUString::createFromAscii( pTokenTableArray[ i ].pS );
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/QRCodeContext.cxx b/xmloff/source/draw/QRCodeContext.cxx
new file mode 100644
index 000000000..597838f78
--- /dev/null
+++ b/xmloff/source/draw/QRCodeContext.cxx
@@ -0,0 +1,91 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * 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/.
+ */
+
+#include "QRCodeContext.hxx"
+
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/embed/XStorage.hpp>
+#include <com/sun/star/frame/XStorable.hpp>
+#include <com/sun/star/graphic/XGraphic.hpp>
+#include <com/sun/star/drawing/BarCode.hpp>
+#include <com/sun/star/drawing/BarCodeErrorCorrection.hpp>
+#include <com/sun/star/xml/sax/XAttributeList.hpp>
+
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/namespacemap.hxx>
+#include <sax/tools/converter.hxx>
+
+#include <rtl/ustring.hxx>
+
+using namespace css;
+using namespace css::xml::sax;
+using namespace css::uno;
+using namespace css::drawing;
+using namespace css::embed;
+using namespace css::frame;
+using namespace css::io;
+using namespace css::graphic;
+using namespace xmloff::token;
+
+QRCodeContext::QRCodeContext(SvXMLImport& rImport, sal_Int32 /*nElement*/,
+                             const Reference<XFastAttributeList>& xAttrList,
+                             const Reference<XShape>& rxShape)
+    : SvXMLImportContext(rImport)
+{
+    Reference<beans::XPropertySet> xPropSet(rxShape, UNO_QUERY_THROW);
+
+    css::drawing::BarCode aBarCode;
+
+    for (auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList))
+    {
+        switch (aIter.getToken())
+        {
+            case XML_ELEMENT(LO_EXT, XML_QRCODE_ERROR_CORRECTION):
+            {
+                OUString aErrorCorrValue = aIter.toString();
+
+                if (aErrorCorrValue == "low")
+                    aBarCode.ErrorCorrection = css::drawing::BarCodeErrorCorrection::LOW;
+                else if (aErrorCorrValue == "medium")
+                    aBarCode.ErrorCorrection = css::drawing::BarCodeErrorCorrection::MEDIUM;
+                else if (aErrorCorrValue == "quartile")
+                    aBarCode.ErrorCorrection = css::drawing::BarCodeErrorCorrection::QUARTILE;
+                else
+                    aBarCode.ErrorCorrection = css::drawing::BarCodeErrorCorrection::HIGH;
+                break;
+            }
+            case XML_ELEMENT(LO_EXT, XML_QRCODE_BORDER):
+            {
+                sal_Int32 nAttrVal;
+                if (sax::Converter::convertNumber(nAttrVal, aIter.toView(), 0))
+                    aBarCode.Border = nAttrVal;
+                break;
+            }
+            case XML_ELEMENT(OFFICE, XML_STRING_VALUE):
+            {
+                aBarCode.Payload = aIter.toString();
+                break;
+            }
+            case XML_ELEMENT(LO_EXT, XML_QRCODE_TYPE):
+            {
+                sal_Int32 nAttrVal;
+                if (sax::Converter::convertNumber(nAttrVal, aIter.toView(), 0))
+                    aBarCode.Type = nAttrVal;
+                break;
+            }
+            default:
+                XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+        }
+    }
+    xPropSet->setPropertyValue("BarCodeProperties", Any(aBarCode));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/xmloff/source/draw/QRCodeContext.hxx b/xmloff/source/draw/QRCodeContext.hxx
new file mode 100644
index 000000000..c35c6f9bd
--- /dev/null
+++ b/xmloff/source/draw/QRCodeContext.hxx
@@ -0,0 +1,26 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * 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/.
+ */
+
+#pragma once
+
+#include <com/sun/star/drawing/XShape.hpp>
+#include <xmloff/xmlictxt.hxx>
+
+// Used to import QR code properties from a QR code in ODF document
+// @see ximpshap
+
+class QRCodeContext : public SvXMLImportContext
+{
+public:
+    QRCodeContext(SvXMLImport& rImport, sal_Int32 nElement,
+                  const css::uno::Reference<css::xml::sax::XFastAttributeList>& xAttrList,
+                  const css::uno::Reference<css::drawing::XShape>& rxShape);
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/xmloff/source/draw/SignatureLineContext.cxx b/xmloff/source/draw/SignatureLineContext.cxx
new file mode 100644
index 000000000..0217156e3
--- /dev/null
+++ b/xmloff/source/draw/SignatureLineContext.cxx
@@ -0,0 +1,136 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * 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/.
+ */
+
+#include "SignatureLineContext.hxx"
+
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/embed/XStorage.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/frame/XStorable.hpp>
+#include <com/sun/star/graphic/XGraphic.hpp>
+#include <com/sun/star/security/DocumentDigitalSignatures.hpp>
+#include <com/sun/star/security/XDocumentDigitalSignatures.hpp>
+#include <com/sun/star/xml/sax/XAttributeList.hpp>
+
+#include <sal/log.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/storagehelper.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/xmlnamespace.hxx>
+
+using namespace css;
+using namespace css::xml::sax;
+using namespace css::uno;
+using namespace css::drawing;
+using namespace css::embed;
+using namespace css::frame;
+using namespace css::io;
+using namespace css::graphic;
+using namespace css::security;
+using namespace xmloff::token;
+
+SignatureLineContext::SignatureLineContext(SvXMLImport& rImport, sal_Int32 /*nElement*/,
+                                           const Reference<XFastAttributeList>& xAttrList,
+                                           const Reference<XShape>& rxShape)
+    : SvXMLImportContext(rImport)
+{
+    Reference<beans::XPropertySet> xPropSet(rxShape, UNO_QUERY_THROW);
+
+    xPropSet->setPropertyValue("IsSignatureLine", Any(true));
+
+    xPropSet->setPropertyValue("SignatureLineId",
+                               Any(xAttrList->getOptionalValue(XML_ELEMENT(LO_EXT, XML_ID))));
+    xPropSet->setPropertyValue(
+        "SignatureLineSuggestedSignerName",
+        Any(xAttrList->getOptionalValue(XML_ELEMENT(LO_EXT, XML_SUGGESTED_SIGNER_NAME))));
+    xPropSet->setPropertyValue(
+        "SignatureLineSuggestedSignerTitle",
+        Any(xAttrList->getOptionalValue(XML_ELEMENT(LO_EXT, XML_SUGGESTED_SIGNER_TITLE))));
+    xPropSet->setPropertyValue(
+        "SignatureLineSuggestedSignerEmail",
+        Any(xAttrList->getOptionalValue(XML_ELEMENT(LO_EXT, XML_SUGGESTED_SIGNER_EMAIL))));
+    xPropSet->setPropertyValue(
+        "SignatureLineSigningInstructions",
+        Any(xAttrList->getOptionalValue(XML_ELEMENT(LO_EXT, XML_SIGNING_INSTRUCTIONS))));
+
+    bool bShowSignDate = xAttrList->getOptionalValue(XML_ELEMENT(LO_EXT, XML_SHOW_SIGN_DATE))
+                         == GetXMLToken(XML_TRUE);
+    bool bCanAddComment = xAttrList->getOptionalValue(XML_ELEMENT(LO_EXT, XML_CAN_ADD_COMMENT))
+                          == GetXMLToken(XML_TRUE);
+    xPropSet->setPropertyValue("SignatureLineShowSignDate", Any(bShowSignDate));
+    xPropSet->setPropertyValue("SignatureLineCanAddComment", Any(bCanAddComment));
+
+    // Save unsigned graphic (need it when exporting)
+    Reference<XGraphic> xUnsignedGraphic;
+    xPropSet->getPropertyValue("Graphic") >>= xUnsignedGraphic;
+    if (xUnsignedGraphic.is())
+        xPropSet->setPropertyValue("SignatureLineUnsignedImage", Any(xUnsignedGraphic));
+
+    Reference<XGraphic> xGraphic;
+    try
+    {
+        // Get the document signatures
+        css::uno::Reference<XStorable> xStorable(GetImport().GetModel(), UNO_QUERY_THROW);
+        Reference<XStorage> xStorage = comphelper::OStorageHelper::GetStorageOfFormatFromURL(
+            ZIP_STORAGE_FORMAT_STRING, xStorable->getLocation(), ElementModes::READ);
+
+        if (!xStorage.is())
+        {
+            SAL_WARN("xmloff", "No xStorage!");
+            return;
+        }
+
+        OUString const aODFVersion(comphelper::OStorageHelper::GetODFVersionFromStorage(xStorage));
+        Reference<XDocumentDigitalSignatures> xSignatures(
+            security::DocumentDigitalSignatures::createWithVersion(
+                comphelper::getProcessComponentContext(), aODFVersion));
+
+        const Sequence<DocumentSignatureInformation> xSignatureInfo
+            = xSignatures->verifyDocumentContentSignatures(xStorage, Reference<XInputStream>());
+
+        // Try to find matching signature line image - if none exists that is fine,
+        // then the signature line is not digitally signed.
+        auto pSignatureInfo
+            = std::find_if(xSignatureInfo.begin(), xSignatureInfo.end(),
+                           [&xAttrList](const DocumentSignatureInformation& rSignatureInfo) {
+                               return rSignatureInfo.SignatureLineId
+                                      == xAttrList->getOptionalValue(XML_ELEMENT(LO_EXT, XML_ID));
+                           });
+        bool bIsSigned(false);
+        if (pSignatureInfo != xSignatureInfo.end())
+        {
+            bIsSigned = true;
+            if (pSignatureInfo->SignatureIsValid)
+            {
+                // Signature is valid, use the 'valid' image
+                SAL_WARN_IF(!pSignatureInfo->ValidSignatureLineImage.is(), "xmloff",
+                            "No ValidSignatureLineImage!");
+                xGraphic = pSignatureInfo->ValidSignatureLineImage;
+            }
+            else
+            {
+                // Signature is invalid, use the 'invalid' image
+                SAL_WARN_IF(!pSignatureInfo->InvalidSignatureLineImage.is(), "xmloff",
+                            "No InvalidSignatureLineImage!");
+                xGraphic = pSignatureInfo->InvalidSignatureLineImage;
+            }
+
+            xPropSet->setPropertyValue("Graphic", Any(xGraphic));
+        }
+        xPropSet->setPropertyValue("SignatureLineIsSigned", Any(bIsSigned));
+    }
+    catch (css::uno::Exception&)
+    {
+        // DocumentDigitalSignatures service not available.
+        // We render the "unsigned" shape instead.
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/xmloff/source/draw/SignatureLineContext.hxx b/xmloff/source/draw/SignatureLineContext.hxx
new file mode 100644
index 000000000..68a9373ae
--- /dev/null
+++ b/xmloff/source/draw/SignatureLineContext.hxx
@@ -0,0 +1,25 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * 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/.
+ */
+
+#pragma once
+
+#include <com/sun/star/drawing/XShape.hpp>
+#include <xmloff/xmlictxt.hxx>
+
+// signatureline inside a shape
+
+class SignatureLineContext : public SvXMLImportContext
+{
+public:
+    SignatureLineContext(SvXMLImport& rImport, sal_Int32 nElement,
+                         const css::uno::Reference<css::xml::sax::XFastAttributeList>& xAttrList,
+                         const css::uno::Reference<css::drawing::XShape>& rxShape);
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/xmloff/source/draw/XMLGraphicsDefaultStyle.cxx b/xmloff/source/draw/XMLGraphicsDefaultStyle.cxx
new file mode 100644
index 000000000..4f9799c48
--- /dev/null
+++ b/xmloff/source/draw/XMLGraphicsDefaultStyle.cxx
@@ -0,0 +1,189 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <xmloff/XMLGraphicsDefaultStyle.hxx>
+
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+
+#include <tools/color.hxx>
+
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/families.hxx>
+#include <xmloff/xmltypes.hxx>
+#include <xmloff/maptype.hxx>
+#include <xmloff/xmlimppr.hxx>
+#include <xmloff/xmlprmap.hxx>
+
+#include <XMLShapePropertySetContext.hxx>
+#include <algorithm>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::xml::sax;
+
+using ::xmloff::token::IsXMLToken;
+using ::xmloff::token::XML_TEXT_PROPERTIES;
+using ::xmloff::token::XML_GRAPHIC_PROPERTIES;
+using ::xmloff::token::XML_PARAGRAPH_PROPERTIES;
+
+
+XMLGraphicsDefaultStyle::XMLGraphicsDefaultStyle( SvXMLImport& rImport, SvXMLStylesContext& rStyles )
+: XMLPropStyleContext( rImport, rStyles, XmlStyleFamily::SD_GRAPHICS_ID, true )
+{
+}
+
+XMLGraphicsDefaultStyle::~XMLGraphicsDefaultStyle()
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > XMLGraphicsDefaultStyle::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    if( IsTokenInNamespace(nElement, XML_NAMESPACE_STYLE) ||
+        IsTokenInNamespace(nElement, XML_NAMESPACE_LO_EXT) )
+    {
+        sal_Int32 nLocalName = nElement & TOKEN_MASK;
+        sal_uInt32 nFamily = 0;
+        if( nLocalName == XML_TEXT_PROPERTIES )
+            nFamily = XML_TYPE_PROP_TEXT;
+        else if( nLocalName == XML_PARAGRAPH_PROPERTIES )
+            nFamily = XML_TYPE_PROP_PARAGRAPH;
+        else if( nLocalName == XML_GRAPHIC_PROPERTIES )
+            nFamily = XML_TYPE_PROP_GRAPHIC;
+        if( nFamily )
+        {
+            rtl::Reference < SvXMLImportPropertyMapper > xImpPrMap = GetStyles()->GetImportPropertyMapper( GetFamily() );
+            if( xImpPrMap.is() )
+                return new XMLShapePropertySetContext( GetImport(), nElement, xAttrList, nFamily, GetProperties(), xImpPrMap );
+        }
+    }
+
+    return XMLPropStyleContext::createFastChildContext( nElement, xAttrList );
+}
+
+namespace {
+
+struct XMLPropertyByIndex {
+    sal_Int32 const m_nIndex;
+    explicit XMLPropertyByIndex(sal_Int32 const nIndex) : m_nIndex(nIndex) {}
+    bool operator()(XMLPropertyState const& rProp) {
+        return m_nIndex == rProp.mnIndex;
+    }
+};
+
+}
+
+// This method is called for every default style
+void XMLGraphicsDefaultStyle::SetDefaults()
+{
+    Reference< XMultiServiceFactory > xFact( GetImport().GetModel(), UNO_QUERY );
+    if( !xFact.is() )
+        return;
+
+    Reference< XPropertySet > xDefaults( xFact->createInstance( "com.sun.star.drawing.Defaults" ), UNO_QUERY );
+    if( !xDefaults.is() )
+        return;
+                                            // SJ: #i114750#
+    bool bWordWrapDefault = true;   // initializing with correct ODF fo:wrap-option default
+    sal_Int32 nUPD( 0 );
+    sal_Int32 nBuild( 0 );
+    const bool bBuildIdFound = GetImport().getBuildIds( nUPD, nBuild );
+    if ( bBuildIdFound && (
+        ((nUPD >= 600) &&  (nUPD < 700))
+        ||
+        ((nUPD == 300) && (nBuild <= 9535))
+        ||
+        ((nUPD > 300) && (nUPD <= 330))
+    ) )
+        bWordWrapDefault = false;
+
+    static const OUStringLiteral sTextWordWrap( u"TextWordWrap" );
+    Reference< XPropertySetInfo > xInfo( xDefaults->getPropertySetInfo() );
+    if ( xInfo->hasPropertyByName( sTextWordWrap ) )
+        xDefaults->setPropertyValue( sTextWordWrap, Any( bWordWrapDefault ) );
+
+    if (GetImport().IsOOoXML()
+        && xInfo->hasPropertyByName("IsFollowingTextFlow"))
+    {
+        // OOo 1.x only supported "true" so that is the more appropriate
+        // default for OOoXML format documents.
+        xDefaults->setPropertyValue("IsFollowingTextFlow", uno::Any(true));
+    }
+
+    // NOTE: the only reason why it's legal to check "==" (not "<") against
+    // arbitrary versions here is that the default value of these attributes
+    // is not defined by ODF, therefore it is implementation-defined
+    // (and we of course must not override any attributes that are actually
+    // in the document, so check for that)
+    bool const bIsAOO4(
+           GetImport().getGeneratorVersion() >= SvXMLImport::AOO_40x
+        && GetImport().getGeneratorVersion() <= SvXMLImport::AOO_4x);
+
+    // fdo#75872: backward compatibility for pool defaults change
+    if (GetImport().isGeneratorVersionOlderThan(
+                SvXMLImport::AOO_40x, SvXMLImport::LO_42x)
+        // argh... it turns out that LO has also changed defaults for these
+        // since LO 4.0, and so even the _new_ AOO 4.0+ default needs
+        // special handling since AOO still does _not_ write it into the file
+        || bIsAOO4)
+    {
+        rtl::Reference<XMLPropertySetMapper> const pImpPrMap(
+            GetStyles()->GetImportPropertyMapper(GetFamily())
+                ->getPropertySetMapper());
+        sal_Int32 const nStrokeIndex(
+            pImpPrMap->GetEntryIndex(XML_NAMESPACE_SVG, u"stroke-color", 0));
+        if (std::none_of(GetProperties().begin(), GetProperties().end(),
+                         XMLPropertyByIndex(nStrokeIndex)))
+        {
+            Color const nStroke(
+                    bIsAOO4 ? Color(128, 128, 128) : COL_BLACK);
+            xDefaults->setPropertyValue("LineColor", Any(nStroke));
+        }
+        Color const nFillColor( bIsAOO4
+            ? Color(0xCF, 0xE7, 0xF5) : Color(153, 204, 255));
+        sal_Int32 const nFillIndex(
+            pImpPrMap->GetEntryIndex(XML_NAMESPACE_DRAW, u"fill-color", 0));
+        if (std::none_of(GetProperties().begin(), GetProperties().end(),
+                         XMLPropertyByIndex(nFillIndex)))
+        {
+            xDefaults->setPropertyValue("FillColor", Any(nFillColor));
+        }
+        if (xInfo->hasPropertyByName("FillColor2"))
+        {
+            sal_Int32 const nFill2Index(pImpPrMap->GetEntryIndex(
+                        XML_NAMESPACE_DRAW, u"secondary-fill-color", 0));
+            if (std::none_of(GetProperties().begin(), GetProperties().end(),
+                             XMLPropertyByIndex(nFill2Index)))
+            {
+                xDefaults->setPropertyValue("FillColor2", Any(sal_Int32(nFillColor)));
+            }
+        }
+    }
+
+    FillPropertySet( xDefaults );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/XMLImageMapContext.cxx b/xmloff/source/draw/XMLImageMapContext.cxx
new file mode 100644
index 000000000..1b9c295d0
--- /dev/null
+++ b/xmloff/source/draw/XMLImageMapContext.cxx
@@ -0,0 +1,542 @@
+/* -*- 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 <XMLImageMapContext.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <com/sun/star/uno/Reference.h>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/beans/XPropertySetInfo.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/xml/sax/XAttributeList.hpp>
+#include <com/sun/star/container/XIndexContainer.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/document/XEventsSupplier.hpp>
+#include <com/sun/star/awt/Rectangle.hpp>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/xmltkmap.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/namespacemap.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xexptran.hxx>
+#include <xmloff/xmlerror.hxx>
+#include <xmloff/XMLEventsImportContext.hxx>
+#include <XMLStringBufferImportContext.hxx>
+#include <tools/debug.hxx>
+#include <basegfx/polygon/b2dpolygon.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <sal/log.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+using ::com::sun::star::beans::XPropertySet;
+using ::com::sun::star::beans::XPropertySetInfo;
+using ::com::sun::star::container::XIndexContainer;
+using ::com::sun::star::lang::XMultiServiceFactory;
+using ::com::sun::star::uno::Reference;
+using ::com::sun::star::uno::UNO_QUERY;
+using ::com::sun::star::xml::sax::XAttributeList;
+using ::com::sun::star::uno::XInterface;
+using ::com::sun::star::uno::Any;
+using ::com::sun::star::document::XEventsSupplier;
+
+namespace {
+
+class XMLImageMapObjectContext : public SvXMLImportContext
+{
+
+protected:
+
+    Reference<XIndexContainer> xImageMap;   /// the image map
+    Reference<XPropertySet> xMapEntry;      /// one map-entry (one area)
+
+    OUString sUrl;
+    OUString sTargt;
+    OUStringBuffer sDescriptionBuffer;
+    OUStringBuffer sTitleBuffer;
+    OUString sNam;
+    bool bIsActive;
+
+    bool bValid;
+
+public:
+
+    XMLImageMapObjectContext(
+        SvXMLImport& rImport,
+        css::uno::Reference<css::container::XIndexContainer> const & xMap,
+        const char* pServiceName);
+
+    virtual void SAL_CALL startFastElement( sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+
+protected:
+
+    virtual void ProcessAttribute(const sax_fastparser::FastAttributeList::FastAttributeIter &);
+
+    virtual void Prepare(
+        css::uno::Reference<css::beans::XPropertySet> & rPropertySet);
+};
+
+}
+
+XMLImageMapObjectContext::XMLImageMapObjectContext(
+    SvXMLImport& rImport,
+    Reference<XIndexContainer> const & xMap,
+    const char* pServiceName) :
+        SvXMLImportContext(rImport),
+        xImageMap(xMap),
+        bIsActive(true),
+        bValid(false)
+{
+    DBG_ASSERT(nullptr != pServiceName,
+               "Please supply the image map object service name");
+
+    Reference<XMultiServiceFactory> xFactory(GetImport().GetModel(),UNO_QUERY);
+    if( !xFactory.is() )
+        return;
+
+    Reference<XInterface> xIfc = xFactory->createInstance(
+        OUString::createFromAscii(pServiceName));
+    DBG_ASSERT(xIfc.is(), "can't create image map object!");
+    if( xIfc.is() )
+    {
+        Reference<XPropertySet> xPropertySet( xIfc, UNO_QUERY );
+
+        xMapEntry = xPropertySet;
+    }
+    // else: can't create service -> ignore
+    // else: can't even get factory -> ignore
+}
+
+void XMLImageMapObjectContext::startFastElement( sal_Int32 /*nElement*/,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    for( auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList) )
+        ProcessAttribute(aIter);
+}
+
+void XMLImageMapObjectContext::endFastElement(sal_Int32 )
+{
+    // only create and insert image map object if validity flag is set
+    // (and we actually have an image map)
+    if ( bValid && xImageMap.is() && xMapEntry.is() )
+    {
+        // set values
+        Prepare( xMapEntry );
+
+        // insert into image map
+        xImageMap->insertByIndex( xImageMap->getCount(), Any(xMapEntry) );
+    }
+    // else: not valid -> don't create and insert
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > XMLImageMapObjectContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >&  )
+{
+    switch (nElement)
+    {
+        case XML_ELEMENT(OFFICE, XML_EVENT_LISTENERS):
+        {
+            Reference<XEventsSupplier> xEvents( xMapEntry, UNO_QUERY );
+            return new XMLEventsImportContext(
+                GetImport(), xEvents);
+        }
+        case XML_ELEMENT(SVG, XML_TITLE):
+        case XML_ELEMENT(SVG_COMPAT, XML_TITLE):
+            return new XMLStringBufferImportContext(
+                GetImport(), sTitleBuffer);
+        case XML_ELEMENT(SVG, XML_DESC):
+        case XML_ELEMENT(SVG_COMPAT, XML_DESC):
+            return new XMLStringBufferImportContext(
+                GetImport(), sDescriptionBuffer);
+    }
+    XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+    return nullptr;
+}
+
+void XMLImageMapObjectContext::ProcessAttribute(
+    const sax_fastparser::FastAttributeList::FastAttributeIter & aIter)
+{
+    switch (aIter.getToken())
+    {
+        case XML_ELEMENT(XLINK, XML_HREF):
+            sUrl = GetImport().GetAbsoluteReference(aIter.toString());
+            break;
+
+        case XML_ELEMENT(OFFICE, XML_TARGET_FRAME_NAME):
+            sTargt = aIter.toString();
+            break;
+
+        case XML_ELEMENT(DRAW, XML_NOHREF):
+            bIsActive = ! IsXMLToken(aIter, XML_NOHREF);
+            break;
+
+        case XML_ELEMENT(OFFICE, XML_NAME):
+            sNam = aIter.toString();
+            break;
+        default:
+            // do nothing
+            XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+            break;
+    }
+}
+
+void XMLImageMapObjectContext::Prepare(
+    Reference<XPropertySet> & rPropertySet)
+{
+    rPropertySet->setPropertyValue( "URL", Any( sUrl ) );
+    rPropertySet->setPropertyValue( "Title", Any( sTitleBuffer.makeStringAndClear() ) );
+    rPropertySet->setPropertyValue( "Description", Any( sDescriptionBuffer.makeStringAndClear() ) );
+    rPropertySet->setPropertyValue( "Target", Any( sTargt ) );
+    rPropertySet->setPropertyValue( "IsActive", Any( bIsActive ) );
+    rPropertySet->setPropertyValue( "Name", Any( sNam ) );
+}
+
+namespace {
+
+class XMLImageMapRectangleContext : public XMLImageMapObjectContext
+{
+    awt::Rectangle aRectangle;
+
+    bool bXOK;
+    bool bYOK;
+    bool bWidthOK;
+    bool bHeightOK;
+
+public:
+
+    XMLImageMapRectangleContext(
+        SvXMLImport& rImport,
+        css::uno::Reference<css::container::XIndexContainer> const & xMap);
+
+protected:
+    virtual void ProcessAttribute(
+        const sax_fastparser::FastAttributeList::FastAttributeIter &) override;
+
+    virtual void Prepare(
+        css::uno::Reference<css::beans::XPropertySet> & rPropertySet) override;
+};
+
+}
+
+XMLImageMapRectangleContext::XMLImageMapRectangleContext(
+    SvXMLImport& rImport,
+    Reference<XIndexContainer> const & xMap) :
+        XMLImageMapObjectContext(rImport, xMap,
+                                 "com.sun.star.image.ImageMapRectangleObject"),
+        bXOK(false),
+        bYOK(false),
+        bWidthOK(false),
+        bHeightOK(false)
+{
+}
+
+void XMLImageMapRectangleContext::ProcessAttribute(
+    const sax_fastparser::FastAttributeList::FastAttributeIter & aIter)
+{
+    sal_Int32 nTmp;
+    switch (aIter.getToken())
+    {
+        case XML_ELEMENT(SVG, XML_X):
+        case XML_ELEMENT(SVG_COMPAT, XML_X):
+            if (GetImport().GetMM100UnitConverter().convertMeasureToCore(nTmp,
+                                                                   aIter.toView()))
+            {
+                aRectangle.X = nTmp;
+                bXOK = true;
+            }
+            break;
+        case  XML_ELEMENT(SVG, XML_Y):
+        case  XML_ELEMENT(SVG_COMPAT, XML_Y):
+            if (GetImport().GetMM100UnitConverter().convertMeasureToCore(nTmp,
+                                                                   aIter.toView()))
+            {
+                aRectangle.Y = nTmp;
+                bYOK = true;
+            }
+            break;
+        case XML_ELEMENT(SVG, XML_WIDTH):
+        case XML_ELEMENT(SVG_COMPAT, XML_WIDTH):
+            if (GetImport().GetMM100UnitConverter().convertMeasureToCore(nTmp,
+                                                                   aIter.toView()))
+            {
+                aRectangle.Width = nTmp;
+                bWidthOK = true;
+            }
+            break;
+        case  XML_ELEMENT(SVG, XML_HEIGHT):
+        case  XML_ELEMENT(SVG_COMPAT, XML_HEIGHT):
+            if (GetImport().GetMM100UnitConverter().convertMeasureToCore(nTmp,
+                                                                   aIter.toView()))
+            {
+                aRectangle.Height = nTmp;
+                bHeightOK = true;
+            }
+            break;
+        default:
+            XMLImageMapObjectContext::ProcessAttribute(aIter);
+    }
+
+    bValid = bHeightOK && bXOK && bYOK && bWidthOK;
+}
+
+void XMLImageMapRectangleContext::Prepare(
+    Reference<XPropertySet> & rPropertySet)
+{
+    rPropertySet->setPropertyValue( "Boundary", uno::Any(aRectangle) );
+
+    // common properties handled by super class
+    XMLImageMapObjectContext::Prepare(rPropertySet);
+}
+
+namespace {
+
+class XMLImageMapPolygonContext : public XMLImageMapObjectContext
+{
+    OUString sViewBoxString;
+    OUString sPointsString;
+
+    bool bViewBoxOK;
+    bool bPointsOK;
+
+public:
+
+    XMLImageMapPolygonContext(
+        SvXMLImport& rImport,
+        css::uno::Reference<css::container::XIndexContainer> const & xMap);
+
+protected:
+    virtual void ProcessAttribute(const sax_fastparser::FastAttributeList::FastAttributeIter &) override;
+
+    virtual void Prepare(
+        css::uno::Reference<css::beans::XPropertySet> & rPropertySet) override;
+};
+
+}
+
+XMLImageMapPolygonContext::XMLImageMapPolygonContext(
+    SvXMLImport& rImport,
+    Reference<XIndexContainer> const & xMap) :
+        XMLImageMapObjectContext(rImport, xMap,
+                                 "com.sun.star.image.ImageMapPolygonObject"),
+        bViewBoxOK(false),
+        bPointsOK(false)
+{
+}
+
+void XMLImageMapPolygonContext::ProcessAttribute(
+    const sax_fastparser::FastAttributeList::FastAttributeIter & aIter)
+{
+    switch (aIter.getToken())
+    {
+        case XML_ELEMENT(DRAW, XML_POINTS):
+            sPointsString = aIter.toString();
+            bPointsOK = true;
+            break;
+        case XML_ELEMENT(SVG, XML_VIEWBOX):
+        case XML_ELEMENT(SVG_COMPAT, XML_VIEWBOX):
+            sViewBoxString = aIter.toString();
+            bViewBoxOK = true;
+            break;
+        default:
+            XMLImageMapObjectContext::ProcessAttribute(aIter);
+            break;
+    }
+
+    bValid = bViewBoxOK && bPointsOK;
+}
+
+void XMLImageMapPolygonContext::Prepare(Reference<XPropertySet> & rPropertySet)
+{
+    // process view box
+    SdXMLImExViewBox aViewBox(sViewBoxString, GetImport().GetMM100UnitConverter());
+
+    // get polygon sequence
+    basegfx::B2DPolygon aPolygon;
+
+    if(basegfx::utils::importFromSvgPoints(aPolygon, sPointsString))
+    {
+        if(aPolygon.count())
+        {
+            css::drawing::PointSequence aPointSequence;
+            basegfx::utils::B2DPolygonToUnoPointSequence(aPolygon, aPointSequence);
+            rPropertySet->setPropertyValue("Polygon", Any(aPointSequence));
+        }
+    }
+
+    // parent properties
+    XMLImageMapObjectContext::Prepare(rPropertySet);
+}
+
+namespace {
+
+class XMLImageMapCircleContext : public XMLImageMapObjectContext
+{
+    awt::Point aCenter;
+    sal_Int32 nRadius;
+
+    bool bXOK;
+    bool bYOK;
+    bool bRadiusOK;
+
+public:
+
+    XMLImageMapCircleContext(
+        SvXMLImport& rImport,
+        css::uno::Reference<css::container::XIndexContainer> const & xMap);
+
+protected:
+    virtual void ProcessAttribute(
+        const sax_fastparser::FastAttributeList::FastAttributeIter &) override;
+
+    virtual void Prepare(
+        css::uno::Reference<css::beans::XPropertySet> & rPropertySet) override;
+};
+
+}
+
+XMLImageMapCircleContext::XMLImageMapCircleContext(
+    SvXMLImport& rImport,
+    Reference<XIndexContainer> const & xMap)
+    : XMLImageMapObjectContext(rImport, xMap,
+          "com.sun.star.image.ImageMapCircleObject")
+    , nRadius(0)
+    , bXOK(false)
+    , bYOK(false)
+    , bRadiusOK(false)
+{
+}
+
+void XMLImageMapCircleContext::ProcessAttribute(
+    const sax_fastparser::FastAttributeList::FastAttributeIter & aIter)
+{
+    sal_Int32 nTmp;
+    switch (aIter.getToken())
+    {
+        case XML_ELEMENT(SVG, XML_CX):
+        case XML_ELEMENT(SVG_COMPAT, XML_CX):
+            if (GetImport().GetMM100UnitConverter().convertMeasureToCore(nTmp,
+                                                                   aIter.toView()))
+            {
+                aCenter.X = nTmp;
+                bXOK = true;
+            }
+            break;
+        case XML_ELEMENT(SVG, XML_CY):
+        case XML_ELEMENT(SVG_COMPAT, XML_CY):
+            if (GetImport().GetMM100UnitConverter().convertMeasureToCore(nTmp,
+                                                                   aIter.toView()))
+            {
+                aCenter.Y = nTmp;
+                bYOK = true;
+            }
+            break;
+        case XML_ELEMENT(SVG, XML_R):
+        case XML_ELEMENT(SVG_COMPAT, XML_R):
+            if (GetImport().GetMM100UnitConverter().convertMeasureToCore(nTmp,
+                                                                   aIter.toView()))
+            {
+                nRadius = nTmp;
+                bRadiusOK = true;
+            }
+            break;
+        default:
+            XMLImageMapObjectContext::ProcessAttribute(aIter);
+    }
+
+    bValid = bRadiusOK && bXOK && bYOK;
+}
+
+void XMLImageMapCircleContext::Prepare(
+    Reference<XPropertySet> & rPropertySet)
+{
+    // center (x,y)
+    rPropertySet->setPropertyValue( "Center", uno::Any(aCenter) );
+    // radius
+    rPropertySet->setPropertyValue( "Radius", uno::Any(nRadius) );
+
+    // common properties handled by super class
+    XMLImageMapObjectContext::Prepare(rPropertySet);
+}
+
+
+constexpr OUStringLiteral gsImageMap(u"ImageMap");
+
+XMLImageMapContext::XMLImageMapContext(
+    SvXMLImport& rImport,
+    Reference<XPropertySet> const & rPropertySet) :
+        SvXMLImportContext(rImport),
+        xPropertySet(rPropertySet)
+{
+    try
+    {
+        Reference < XPropertySetInfo > xInfo =
+            xPropertySet->getPropertySetInfo();
+        if( xInfo.is() && xInfo->hasPropertyByName( gsImageMap ) )
+            xPropertySet->getPropertyValue(gsImageMap) >>= xImageMap;
+    }
+    catch(const css::uno::Exception& e)
+    {
+        rImport.SetError( XMLERROR_FLAG_WARNING | XMLERROR_API, {}, e.Message, nullptr );
+    }
+}
+
+XMLImageMapContext::~XMLImageMapContext()
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > XMLImageMapContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >&  )
+{
+    switch (nElement)
+    {
+        case XML_ELEMENT(DRAW, XML_AREA_RECTANGLE):
+            return new XMLImageMapRectangleContext(
+                GetImport(), xImageMap);
+        case XML_ELEMENT(DRAW, XML_AREA_POLYGON):
+            return new XMLImageMapPolygonContext(
+                GetImport(), xImageMap);
+        case XML_ELEMENT(DRAW, XML_AREA_CIRCLE):
+            return new XMLImageMapCircleContext(
+                GetImport(), xImageMap);
+        default:
+            XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+    }
+
+    return nullptr;
+}
+
+void XMLImageMapContext::endFastElement(sal_Int32 )
+{
+    Reference < XPropertySetInfo > xInfo =
+        xPropertySet->getPropertySetInfo();
+    if( xInfo.is() && xInfo->hasPropertyByName( gsImageMap ) )
+        xPropertySet->setPropertyValue(gsImageMap, uno::Any( xImageMap ) );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/XMLImageMapExport.cxx b/xmloff/source/draw/XMLImageMapExport.cxx
new file mode 100644
index 000000000..918d13ad0
--- /dev/null
+++ b/xmloff/source/draw/XMLImageMapExport.cxx
@@ -0,0 +1,339 @@
+/* -*- 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 <XMLImageMapExport.hxx>
+#include <o3tl/any.hxx>
+#include <rtl/ustring.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <tools/debug.hxx>
+#include <com/sun/star/uno/Reference.h>
+#include <com/sun/star/uno/Sequence.h>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/container/XIndexContainer.hpp>
+#include <com/sun/star/document/XEventsSupplier.hpp>
+#include <com/sun/star/awt/Rectangle.hpp>
+#include <com/sun/star/awt/Point.hpp>
+#include <com/sun/star/drawing/PointSequence.hpp>
+#include <xmloff/xmlexp.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/XMLEventExport.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xexptran.hxx>
+#include <basegfx/polygon/b2dpolygon.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+using ::com::sun::star::uno::Any;
+using ::com::sun::star::uno::UNO_QUERY;
+using ::com::sun::star::uno::Sequence;
+using ::com::sun::star::uno::Reference;
+using ::com::sun::star::beans::XPropertySet;
+using ::com::sun::star::container::XIndexContainer;
+using ::com::sun::star::document::XEventsSupplier;
+using ::com::sun::star::lang::XServiceInfo;
+using ::com::sun::star::drawing::PointSequence;
+
+constexpr OUStringLiteral gsBoundary(u"Boundary");
+constexpr OUStringLiteral gsCenter(u"Center");
+constexpr OUStringLiteral gsDescription(u"Description");
+constexpr OUStringLiteral gsImageMap(u"ImageMap");
+constexpr OUStringLiteral gsIsActive(u"IsActive");
+constexpr OUStringLiteral gsName(u"Name");
+constexpr OUStringLiteral gsPolygon(u"Polygon");
+constexpr OUStringLiteral gsRadius(u"Radius");
+constexpr OUStringLiteral gsTarget(u"Target");
+constexpr OUStringLiteral gsURL(u"URL");
+constexpr OUStringLiteral gsTitle(u"Title");
+
+XMLImageMapExport::XMLImageMapExport(SvXMLExport& rExp) :
+    mrExport(rExp)
+{
+}
+
+void XMLImageMapExport::Export(
+    const Reference<XPropertySet> & rPropertySet)
+{
+    if (rPropertySet->getPropertySetInfo()->hasPropertyByName(gsImageMap))
+    {
+        Any aAny = rPropertySet->getPropertyValue(gsImageMap);
+        Reference<XIndexContainer> aContainer;
+        aAny >>= aContainer;
+
+        Export(aContainer);
+    }
+    // else: no ImageMap property -> nothing to do
+}
+
+void XMLImageMapExport::Export(
+    const Reference<XIndexContainer> & rContainer)
+{
+    if (!rContainer.is())
+        return;
+
+    if (!rContainer->hasElements())
+        return;
+
+    // image map container element
+    SvXMLElementExport aImageMapElement(
+        mrExport, XML_NAMESPACE_DRAW, XML_IMAGE_MAP,
+        true/*bWhiteSpace*/, true/*bWhiteSpace*/);
+
+    // iterate over image map elements and call ExportMapEntry(...)
+    // for each
+    sal_Int32 nLength = rContainer->getCount();
+    for(sal_Int32 i = 0; i < nLength; i++)
+    {
+        Any aAny = rContainer->getByIndex(i);
+        Reference<XPropertySet> rElement;
+        aAny >>= rElement;
+
+        DBG_ASSERT(rElement.is(), "Image map element is empty!");
+        if (rElement.is())
+        {
+            ExportMapEntry(rElement);
+        }
+    }
+    // else: container is empty -> nothing to do
+    // else: no container -> nothing to do
+}
+
+
+void XMLImageMapExport::ExportMapEntry(
+    const Reference<XPropertySet> & rPropertySet)
+{
+    Reference<XServiceInfo> xServiceInfo(rPropertySet, UNO_QUERY);
+    if (!xServiceInfo.is())
+        return;
+
+    enum XMLTokenEnum eType = XML_TOKEN_INVALID;
+
+    // distinguish map entries by their service name
+    const Sequence<OUString> sServiceNames =
+        xServiceInfo->getSupportedServiceNames();
+    for( const OUString& rName : sServiceNames )
+    {
+        if ( rName == "com.sun.star.image.ImageMapRectangleObject" )
+        {
+            eType = XML_AREA_RECTANGLE;
+            break;
+        }
+        else if ( rName == "com.sun.star.image.ImageMapCircleObject" )
+        {
+            eType = XML_AREA_CIRCLE;
+            break;
+        }
+        else if ( rName == "com.sun.star.image.ImageMapPolygonObject" )
+        {
+            eType = XML_AREA_POLYGON;
+            break;
+        }
+    }
+
+    // return from method if no proper service is found!
+    DBG_ASSERT(XML_TOKEN_INVALID != eType,
+               "Image map element doesn't support appropriate service!");
+    if (XML_TOKEN_INVALID == eType)
+        return;
+
+    // now: handle ImageMapObject properties (those for all types)
+
+    // XLINK (URL property)
+    Any aAny = rPropertySet->getPropertyValue(gsURL);
+    OUString sHref;
+    aAny >>= sHref;
+    if (!sHref.isEmpty())
+    {
+        mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, mrExport.GetRelativeReference(sHref));
+    }
+    mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+
+    // Target property (and xlink:show)
+    aAny = rPropertySet->getPropertyValue(gsTarget);
+    OUString sTargt;
+    aAny >>= sTargt;
+    if (!sTargt.isEmpty())
+    {
+        mrExport.AddAttribute(
+            XML_NAMESPACE_OFFICE, XML_TARGET_FRAME_NAME, sTargt);
+
+        mrExport.AddAttribute(
+            XML_NAMESPACE_XLINK, XML_SHOW,
+            sTargt == "_blank" ? XML_NEW : XML_REPLACE );
+    }
+
+    // name
+    aAny = rPropertySet->getPropertyValue(gsName);
+    OUString sItemName;
+    aAny >>= sItemName;
+    if (!sItemName.isEmpty())
+    {
+        mrExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_NAME, sItemName);
+    }
+
+    // is-active
+    aAny = rPropertySet->getPropertyValue(gsIsActive);
+    if (! *o3tl::doAccess<bool>(aAny))
+    {
+        mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_NOHREF, XML_NOHREF);
+    }
+
+    // call specific rectangle/circle/... method
+    // also prepare element name
+    switch (eType)
+    {
+        case XML_AREA_RECTANGLE:
+            ExportRectangle(rPropertySet);
+            break;
+        case XML_AREA_CIRCLE:
+            ExportCircle(rPropertySet);
+            break;
+        case XML_AREA_POLYGON:
+            ExportPolygon(rPropertySet);
+            break;
+        default:
+            break;
+    }
+
+    // write element
+    DBG_ASSERT(XML_TOKEN_INVALID != eType,
+               "No name?! How did this happen?");
+    SvXMLElementExport aAreaElement(mrExport, XML_NAMESPACE_DRAW, eType,
+                                    true/*bWhiteSpace*/, true/*bWhiteSpace*/);
+
+    // title property (as <svg:title> element)
+    OUString sTitle;
+    rPropertySet->getPropertyValue(gsTitle) >>= sTitle;
+    if(!sTitle.isEmpty())
+    {
+        SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SVG, XML_TITLE, true/*bWhiteSpace*/, false);
+        mrExport.Characters(sTitle);
+    }
+
+    // description property (as <svg:desc> element)
+    OUString sDescription;
+    rPropertySet->getPropertyValue(gsDescription) >>= sDescription;
+    if (!sDescription.isEmpty())
+    {
+        SvXMLElementExport aDesc(mrExport, XML_NAMESPACE_SVG, XML_DESC, true/*bWhiteSpace*/, false);
+        mrExport.Characters(sDescription);
+    }
+
+    // export events attached to this
+    Reference<XEventsSupplier> xSupplier(rPropertySet, UNO_QUERY);
+    mrExport.GetEventExport().Export(xSupplier);
+
+    // else: no service info -> can't determine type -> ignore entry
+}
+
+void XMLImageMapExport::ExportRectangle(
+    const Reference<XPropertySet> & rPropertySet)
+{
+    // get boundary rectangle
+    Any aAny = rPropertySet->getPropertyValue(gsBoundary);
+    awt::Rectangle aRectangle;
+    aAny >>= aRectangle;
+
+    // parameters svg:x, svg:y, svg:width, svg:height
+    OUStringBuffer aBuffer;
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(aBuffer, aRectangle.X);
+    mrExport.AddAttribute( XML_NAMESPACE_SVG, XML_X,
+                          aBuffer.makeStringAndClear() );
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(aBuffer, aRectangle.Y);
+    mrExport.AddAttribute( XML_NAMESPACE_SVG, XML_Y,
+                          aBuffer.makeStringAndClear() );
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(aBuffer,
+            aRectangle.Width);
+    mrExport.AddAttribute( XML_NAMESPACE_SVG, XML_WIDTH,
+                          aBuffer.makeStringAndClear() );
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(aBuffer,
+            aRectangle.Height);
+    mrExport.AddAttribute( XML_NAMESPACE_SVG, XML_HEIGHT,
+                          aBuffer.makeStringAndClear() );
+}
+
+void XMLImageMapExport::ExportCircle(
+    const Reference<XPropertySet> & rPropertySet)
+{
+    // get boundary rectangle
+    Any aAny = rPropertySet->getPropertyValue(gsCenter);
+    awt::Point aCenter;
+    aAny >>= aCenter;
+
+    // parameters svg:cx, svg:cy
+    OUStringBuffer aBuffer;
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(aBuffer, aCenter.X);
+    mrExport.AddAttribute( XML_NAMESPACE_SVG, XML_CX,
+                          aBuffer.makeStringAndClear() );
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(aBuffer, aCenter.Y);
+    mrExport.AddAttribute( XML_NAMESPACE_SVG, XML_CY,
+                          aBuffer.makeStringAndClear() );
+
+    // radius
+    aAny = rPropertySet->getPropertyValue(gsRadius);
+    sal_Int32 nRadius = 0;
+    aAny >>= nRadius;
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(aBuffer, nRadius);
+    mrExport.AddAttribute( XML_NAMESPACE_SVG, XML_R,
+                          aBuffer.makeStringAndClear() );
+}
+
+void XMLImageMapExport::ExportPolygon(const Reference<XPropertySet> & rPropertySet)
+{
+    // polygons get exported as bounding box, viewbox, and coordinate
+    // pair sequence. The bounding box is always the entire image.
+
+    // get polygon point sequence
+    Any aAny = rPropertySet->getPropertyValue(gsPolygon);
+    PointSequence aPoly;
+    aAny >>= aPoly;
+
+    const basegfx::B2DPolygon aPolygon(
+        basegfx::utils::UnoPointSequenceToB2DPolygon(
+            aPoly));
+    const basegfx::B2DRange aPolygonRange(aPolygon.getB2DRange());
+
+    // parameters svg:x, svg:y, svg:width, svg:height
+    OUStringBuffer aBuffer;
+
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(aBuffer, 0);
+    mrExport.AddAttribute( XML_NAMESPACE_SVG, XML_X, aBuffer.makeStringAndClear() );
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(aBuffer, 0);
+    mrExport.AddAttribute( XML_NAMESPACE_SVG, XML_Y, aBuffer.makeStringAndClear() );
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(aBuffer, basegfx::fround(aPolygonRange.getWidth()));
+    mrExport.AddAttribute( XML_NAMESPACE_SVG, XML_WIDTH, aBuffer.makeStringAndClear() );
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(aBuffer, basegfx::fround(aPolygonRange.getHeight()));
+    mrExport.AddAttribute( XML_NAMESPACE_SVG, XML_HEIGHT, aBuffer.makeStringAndClear() );
+
+    // svg:viewbox
+    SdXMLImExViewBox aViewBox(0.0, 0.0, aPolygonRange.getWidth(), aPolygonRange.getHeight());
+    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_VIEWBOX, aViewBox.GetExportString());
+
+    // export point sequence
+    const OUString aPointString(
+        basegfx::utils::exportToSvgPoints(
+            aPolygon));
+
+    mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_POINTS, aPointString);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/XMLNumberStyles.cxx b/xmloff/source/draw/XMLNumberStyles.cxx
new file mode 100644
index 000000000..48bf04c82
--- /dev/null
+++ b/xmloff/source/draw/XMLNumberStyles.cxx
@@ -0,0 +1,711 @@
+/* -*- 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 "XMLNumberStylesExport.hxx"
+#include <XMLNumberStylesImport.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/namespacemap.hxx>
+#include <xmloff/xmltoken.hxx>
+
+#include <o3tl/string_view.hxx>
+#include <sal/log.hxx>
+
+#include "sdxmlexp_impl.hxx"
+#include "sdxmlimp_impl.hxx"
+
+using namespace ::xmloff::token;
+
+namespace {
+
+struct SdXMLDataStyleNumber
+{
+    enum XMLTokenEnum meNumberStyle;
+    bool    mbLong;
+    bool    mbTextual;
+    bool    mbDecimal02;
+    const char* mpText;
+};
+
+}
+
+SdXMLDataStyleNumber const aSdXMLDataStyleNumbers[] =
+{
+    { XML_DAY,          false,      false,      false,      nullptr },
+    { XML_DAY,          true,       false,      false,      nullptr },
+    { XML_MONTH,        true,       false,      false,      nullptr },
+    { XML_MONTH,        false,      true,       false,      nullptr },
+    { XML_MONTH,        true,       true,       false,      nullptr },
+    { XML_YEAR,         false,      false,      false,      nullptr },
+    { XML_YEAR,         true,       false,      false,      nullptr },
+    { XML_DAY_OF_WEEK,  false,      false,      false,      nullptr },
+    { XML_DAY_OF_WEEK,  true,       false,      false,      nullptr },
+    { XML_TEXT,         false,      false,      false,      "."  },
+    { XML_TEXT,         false,      false,      false,      " "  },
+    { XML_TEXT,         false,      false,      false,      ", " },
+    { XML_TEXT,         false,      false,      false,      ". " },
+    { XML_HOURS,        false,      false,      false,      nullptr },
+    { XML_MINUTES,      false,      false,      false,      nullptr },
+    { XML_TEXT,         false,      false,      false,      ":"  },
+    { XML_AM_PM,        false,      false,      false,      nullptr },
+    { XML_SECONDS,      false,      false,      false,      nullptr },
+    { XML_SECONDS,      false,      false,      true,       nullptr },
+    { XML_TOKEN_INVALID,        false,              false,             false,       nullptr  }
+};
+
+// date
+enum class DataStyleNumber : sal_uInt8
+{
+    NONE              = 0,
+    Day               = 1,   // <number:day/>
+    DayLong           = 2,   // <number:day number:style="long"/>
+    MonthLong         = 3,   // <number:month number:style="long"/>
+    MonthText         = 4,   // <number:month number:textual="true"/>
+    MonthLongText     = 5,   // <number:month number:style="long" number:textual="true"/>
+    Year              = 6,   // <number:year/>
+    YearLong          = 7,   // <number:year number:style="long"/>
+    DayOfWeek         = 8,   // <number:day-of-week/>
+    DayOfWeekLong     = 9,   // <number:day-of-week number:style="long"/>
+    TextPoint         = 10,  // <number:text>.</number:text>
+    TextSpace         = 11,  // <number:text> </number:text>
+    TextCommaSpace    = 12,  // <number:text>, </number:text>
+    TextPointSpace    = 13,  // <number:text>. </number:text>
+    Hours             = 14,  // <number:hours/>
+    Minutes           = 15,  // <number:minutes/>
+    TextColon         = 16,  // <number:text>:</number:text>
+    AmPm              = 17,  // <number:am-pm/>
+    Seconds           = 18,  // <number:seconds/>
+    Seconds_02        = 19,  // <number:seconds number:/>
+};
+
+struct SdXMLFixedDataStyle
+{
+    const char* mpName;
+    bool    mbAutomatic;
+    bool    mbDateStyle;
+    DataStyleNumber mpFormat[8];
+};
+
+const SdXMLFixedDataStyle aSdXML_Standard_Short =
+{
+    "D1", true, true,
+    {
+        DataStyleNumber::DayLong,
+        DataStyleNumber::TextPoint,
+        DataStyleNumber::MonthLong,
+        DataStyleNumber::TextPoint,
+        DataStyleNumber::YearLong,
+        DataStyleNumber::NONE, DataStyleNumber::NONE, DataStyleNumber::NONE
+    }
+};
+
+const SdXMLFixedDataStyle aSdXML_Standard_Long =
+{
+    "D2", true, true,
+    {
+        DataStyleNumber::DayOfWeekLong,
+        DataStyleNumber::TextCommaSpace,
+        DataStyleNumber::Day,
+        DataStyleNumber::TextPointSpace,
+        DataStyleNumber::MonthLongText,
+        DataStyleNumber::TextSpace,
+        DataStyleNumber::YearLong,
+        DataStyleNumber::NONE
+    }
+};
+
+const SdXMLFixedDataStyle aSdXML_DateStyle_1 =
+{
+    "D3", false, true,
+    {
+        DataStyleNumber::DayLong,
+        DataStyleNumber::TextPoint,
+        DataStyleNumber::MonthLong,
+        DataStyleNumber::TextPoint,
+        DataStyleNumber::Year,
+        DataStyleNumber::NONE, DataStyleNumber::NONE, DataStyleNumber::NONE
+    }
+};
+
+const SdXMLFixedDataStyle aSdXML_DateStyle_2 =
+{
+    "D4", false, true,
+    {
+        DataStyleNumber::DayLong,
+        DataStyleNumber::TextPoint,
+        DataStyleNumber::MonthLong,
+        DataStyleNumber::TextPoint,
+        DataStyleNumber::YearLong,
+        DataStyleNumber::NONE, DataStyleNumber::NONE, DataStyleNumber::NONE
+    }
+};
+
+const SdXMLFixedDataStyle aSdXML_DateStyle_3 =
+{
+    "D5", false, true,
+    {
+        DataStyleNumber::Day,
+        DataStyleNumber::TextPointSpace,
+        DataStyleNumber::MonthText,
+        DataStyleNumber::TextSpace,
+        DataStyleNumber::YearLong,
+        DataStyleNumber::NONE, DataStyleNumber::NONE, DataStyleNumber::NONE
+    }
+};
+
+const SdXMLFixedDataStyle aSdXML_DateStyle_4 =
+{
+    "D6", false, true,
+    {
+        DataStyleNumber::Day,
+        DataStyleNumber::TextPointSpace,
+        DataStyleNumber::MonthLongText,
+        DataStyleNumber::TextSpace,
+        DataStyleNumber::YearLong,
+        DataStyleNumber::NONE, DataStyleNumber::NONE, DataStyleNumber::NONE
+    }
+};
+
+const SdXMLFixedDataStyle aSdXML_DateStyle_5 =
+{
+    "D7", false, true,
+    {
+        DataStyleNumber::DayOfWeek,
+        DataStyleNumber::TextCommaSpace,
+        DataStyleNumber::Day,
+        DataStyleNumber::TextPointSpace,
+        DataStyleNumber::MonthLongText,
+        DataStyleNumber::TextSpace,
+        DataStyleNumber::YearLong,
+        DataStyleNumber::NONE
+    }
+};
+
+const SdXMLFixedDataStyle aSdXML_DateStyle_6 =
+{
+    "D8", false, true,
+    {
+        DataStyleNumber::DayOfWeekLong,
+        DataStyleNumber::TextCommaSpace,
+        DataStyleNumber::Day,
+        DataStyleNumber::TextPointSpace,
+        DataStyleNumber::MonthLongText,
+        DataStyleNumber::TextSpace,
+        DataStyleNumber::YearLong,
+        DataStyleNumber::NONE
+    }
+};
+
+const SdXMLFixedDataStyle aSdXML_TimeStyle_1 =
+{   "T1", true, false,
+    {
+        DataStyleNumber::Hours,
+        DataStyleNumber::TextColon,
+        DataStyleNumber::Minutes,
+        DataStyleNumber::TextColon,
+        DataStyleNumber::Seconds,
+        DataStyleNumber::AmPm,
+        DataStyleNumber::NONE, DataStyleNumber::NONE
+    }
+};
+
+const SdXMLFixedDataStyle aSdXML_TimeStyle_2 =
+{   "T2", false, false,
+    {
+        DataStyleNumber::Hours,
+        DataStyleNumber::TextColon,
+        DataStyleNumber::Minutes,
+        DataStyleNumber::NONE, DataStyleNumber::NONE, DataStyleNumber::NONE, DataStyleNumber::NONE, DataStyleNumber::NONE
+    }
+};
+
+const SdXMLFixedDataStyle aSdXML_TimeStyle_3 =
+{   "T3", false, false,
+    {
+        DataStyleNumber::Hours,
+        DataStyleNumber::TextColon,
+        DataStyleNumber::Minutes,
+        DataStyleNumber::TextColon,
+        DataStyleNumber::Seconds,
+        DataStyleNumber::NONE, DataStyleNumber::NONE, DataStyleNumber::NONE
+    }
+};
+
+const SdXMLFixedDataStyle aSdXML_TimeStyle_4 =
+{   "T4", false, false,
+    {
+        DataStyleNumber::Hours,
+        DataStyleNumber::TextColon,
+        DataStyleNumber::Minutes,
+        DataStyleNumber::TextColon,
+        DataStyleNumber::Seconds_02,
+        DataStyleNumber::NONE, DataStyleNumber::NONE, DataStyleNumber::NONE
+    }
+};
+
+const SdXMLFixedDataStyle aSdXML_TimeStyle_5 =
+{   "T5", false, false,
+    {
+        DataStyleNumber::Hours,
+        DataStyleNumber::TextColon,
+        DataStyleNumber::Minutes,
+        DataStyleNumber::AmPm,
+        DataStyleNumber::NONE, DataStyleNumber::NONE, DataStyleNumber::NONE, DataStyleNumber::NONE
+    }
+};
+
+const SdXMLFixedDataStyle aSdXML_TimeStyle_6 =
+{   "T6", false, false,
+    {
+        DataStyleNumber::Hours,
+        DataStyleNumber::TextColon,
+        DataStyleNumber::Minutes,
+        DataStyleNumber::TextColon,
+        DataStyleNumber::Seconds,
+        DataStyleNumber::AmPm,
+        DataStyleNumber::NONE, DataStyleNumber::NONE
+    }
+};
+
+const SdXMLFixedDataStyle aSdXML_TimeStyle_7 =
+{   "T7", false, false,
+    {
+        DataStyleNumber::Hours,
+        DataStyleNumber::TextColon,
+        DataStyleNumber::Minutes,
+        DataStyleNumber::TextColon,
+        DataStyleNumber::Seconds_02,
+        DataStyleNumber::AmPm,
+        DataStyleNumber::NONE, DataStyleNumber::NONE
+    }
+};
+
+const SdXMLFixedDataStyle* const aSdXMLFixedDateFormats[SdXMLDateFormatCount] =
+{
+    &aSdXML_Standard_Short,
+    &aSdXML_Standard_Long,
+    &aSdXML_DateStyle_1,
+    &aSdXML_DateStyle_2,
+    &aSdXML_DateStyle_3,
+    &aSdXML_DateStyle_4,
+    &aSdXML_DateStyle_5,
+    &aSdXML_DateStyle_6,
+};
+
+const SdXMLFixedDataStyle* const aSdXMLFixedTimeFormats[SdXMLTimeFormatCount] =
+{
+    &aSdXML_TimeStyle_1,
+    &aSdXML_TimeStyle_2,
+    &aSdXML_TimeStyle_3,
+    &aSdXML_TimeStyle_4,
+    &aSdXML_TimeStyle_5,
+    &aSdXML_TimeStyle_6,
+    &aSdXML_TimeStyle_7
+};
+
+// export
+
+static void SdXMLExportDataStyleNumber( SdXMLExport& rExport, SdXMLDataStyleNumber const & rElement )
+{
+    if( rElement.mbDecimal02 )
+    {
+        rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_DECIMAL_PLACES, XML_2 );
+    }
+
+    if( rElement.mbLong )
+    {
+        rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_STYLE, XML_LONG );
+    }
+
+    if( rElement.mbTextual )
+    {
+        rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_TEXTUAL, XML_TRUE );
+    }
+
+    SvXMLElementExport aNumberStyle( rExport, XML_NAMESPACE_NUMBER, rElement.meNumberStyle, true, false );
+    if( rElement.mpText )
+    {
+        OUString sAttrValue( OUString::createFromAscii( rElement.mpText ) );
+        rExport.GetDocHandler()->characters( sAttrValue );
+    }
+}
+
+static void SdXMLExportStyle( SdXMLExport& rExport, const SdXMLFixedDataStyle* pStyle, const SdXMLFixedDataStyle* pStyle2 = nullptr )
+{
+    // name
+    OUString sAttrValue = OUString::createFromAscii( pStyle->mpName );
+    if( pStyle2 )
+        sAttrValue += OUString::createFromAscii( pStyle2->mpName );
+
+    rExport.AddAttribute( XML_NAMESPACE_STYLE, XML_NAME, sAttrValue );
+
+    if( pStyle->mbAutomatic )
+    {
+        rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_AUTOMATIC_ORDER, XML_TRUE );
+    }
+
+    SvXMLElementExport aElement( rExport, XML_NAMESPACE_NUMBER, pStyle->mbDateStyle ? XML_DATE_STYLE : XML_TIME_STYLE, true, true );
+
+    do
+    {
+
+        const DataStyleNumber* pElements = &pStyle->mpFormat[0];
+
+        while( *pElements != DataStyleNumber::NONE )
+        {
+            SdXMLDataStyleNumber const & rElement = aSdXMLDataStyleNumbers[ static_cast<int>(*pElements++) - 1 ];
+            SdXMLExportDataStyleNumber( rExport, rElement );
+        }
+
+        if( pStyle2 )
+        {
+            SdXMLDataStyleNumber const & rElement = aSdXMLDataStyleNumbers[ static_cast<int>(DataStyleNumber::TextSpace) - 1 ];
+            SdXMLExportDataStyleNumber( rExport, rElement );
+        }
+
+        pStyle = pStyle2;
+        pStyle2 = nullptr;
+    }
+    while( pStyle );
+}
+
+void SdXMLNumberStylesExporter::exportTimeStyle( SdXMLExport& rExport, sal_Int32 nStyle )
+{
+    SAL_WARN_IF( (nStyle < 0) || (nStyle >= SdXMLTimeFormatCount), "xmloff", "Unknown time style!" );
+    if( (nStyle >= 0) && (nStyle < SdXMLTimeFormatCount) )
+        SdXMLExportStyle( rExport, aSdXMLFixedTimeFormats[ nStyle ] );
+}
+
+void SdXMLNumberStylesExporter::exportDateStyle( SdXMLExport& rExport, sal_Int32 nStyle )
+{
+    if( nStyle > 0x0f )
+    {
+        int nDateStyle = nStyle & 0x0f;
+        bool bHasDate = nDateStyle != 0;
+
+        if( nDateStyle > 1 )
+            nDateStyle -= 2;
+
+        SAL_WARN_IF(nDateStyle >= SdXMLDateFormatCount, "xmloff", "unknown date style!");
+
+        int nTimeStyle = (nStyle >> 4) & 0x0f;
+        bool bHasTime = nTimeStyle != 0;
+
+        if( nTimeStyle > 1 )
+            nTimeStyle -= 2;
+
+        SAL_WARN_IF(nTimeStyle >= SdXMLTimeFormatCount, "xmloff", "Unknown time style!");
+
+        if ((nDateStyle < SdXMLDateFormatCount) && (nTimeStyle < SdXMLTimeFormatCount))
+        {
+            if( bHasDate )
+            {
+                if( bHasTime )
+                {
+                    SdXMLExportStyle( rExport, aSdXMLFixedDateFormats[ nDateStyle ], aSdXMLFixedTimeFormats[ nTimeStyle ] );
+                }
+                else
+                {
+                    SdXMLExportStyle( rExport, aSdXMLFixedDateFormats[ nDateStyle ] );
+                }
+            }
+            else if( bHasTime )
+            {
+                SdXMLExportStyle( rExport, aSdXMLFixedTimeFormats[ nTimeStyle ] );
+            }
+        }
+    }
+    else
+    {
+        SAL_WARN_IF( (nStyle < 0) || (nStyle >= SdXMLDateFormatCount), "xmloff", "unknown date style!" );
+        if( (nStyle >= 0) && (nStyle < SdXMLDateFormatCount) )
+            SdXMLExportStyle( rExport, aSdXMLFixedDateFormats[ nStyle ] );
+    }
+}
+
+OUString SdXMLNumberStylesExporter::getTimeStyleName(const sal_Int32 nTimeFormat )
+{
+    sal_Int32 nFormat = nTimeFormat;
+    if( nFormat > 1 )
+        nFormat -= 2;
+
+    if( (nFormat >= 0) && (nFormat < SdXMLTimeFormatCount) )
+    {
+        return OUString::createFromAscii(aSdXMLFixedTimeFormats[nFormat]->mpName );
+    }
+    else
+    {
+        return OUString();
+    }
+}
+
+OUString SdXMLNumberStylesExporter::getDateStyleName(const sal_Int32 nDateFormat )
+{
+    sal_Int32 nFormat = nDateFormat;
+
+    if( nFormat > 0x0f )
+    {
+        OUString aStr;
+        if( nFormat & 0x0f )
+            aStr = getDateStyleName( nFormat & 0x0f );
+        aStr += getTimeStyleName( (nFormat >> 4) & 0x0f );
+        return aStr;
+    }
+
+    if( nFormat > 1 )
+        nFormat -= 2;
+
+    if( (nFormat >= 0) && (nFormat < SdXMLDateFormatCount) )
+    {
+        return OUString::createFromAscii(aSdXMLFixedDateFormats[nFormat]->mpName );
+    }
+    else
+    {
+        return OUString();
+    }
+}
+
+// import
+
+class SdXMLNumberFormatMemberImportContext : public SvXMLImportContext
+{
+private:
+    SdXMLNumberFormatImportContext* mpParent;
+
+    OUString maNumberStyle;
+    bool mbLong;
+    bool mbTextual;
+    bool mbDecimal02;
+    OUString maText;
+    SvXMLImportContextRef mxSlaveContext;
+
+public:
+
+    SdXMLNumberFormatMemberImportContext( SvXMLImport& rImport,
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        SdXMLNumberFormatImportContext* pParent,
+        const SvXMLImportContextRef& rSlaveContext );
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+
+    virtual void SAL_CALL startFastElement( sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& ) override;
+
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+
+    virtual void SAL_CALL characters( const OUString& rChars ) override;
+};
+
+
+SdXMLNumberFormatMemberImportContext::SdXMLNumberFormatMemberImportContext(
+    SvXMLImport& rImport,
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    SdXMLNumberFormatImportContext* pParent,
+    const SvXMLImportContextRef& rSlaveContext )
+:   SvXMLImportContext(rImport),
+    mpParent( pParent ),
+    maNumberStyle( SvXMLImport::getNameFromToken(nElement) ),
+    mxSlaveContext( rSlaveContext )
+{
+    mbLong = false;
+    mbTextual = false;
+    mbDecimal02 = false;
+
+    for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+    {
+        switch (aIter.getToken())
+        {
+            case XML_ELEMENT(NUMBER, XML_DECIMAL_PLACES):
+                mbDecimal02 =  IsXMLToken( aIter, XML_2 );
+                break;
+            case XML_ELEMENT(NUMBER, XML_STYLE):
+                mbLong = IsXMLToken( aIter, XML_LONG );
+                break;
+            case XML_ELEMENT(NUMBER, XML_TEXTUAL):
+                mbTextual = IsXMLToken( aIter, XML_TRUE );
+                break;
+            default:
+                XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+        }
+    }
+
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLNumberFormatMemberImportContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    return mxSlaveContext->createFastChildContext( nElement, xAttrList );
+}
+
+void SdXMLNumberFormatMemberImportContext::startFastElement(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    mxSlaveContext->startFastElement( nElement, xAttrList );
+}
+
+void SdXMLNumberFormatMemberImportContext::endFastElement(sal_Int32 nElement)
+{
+    mxSlaveContext->endFastElement(nElement);
+
+    if( mpParent )
+        mpParent->add( maNumberStyle, mbLong, mbTextual, mbDecimal02, maText );
+}
+
+void SdXMLNumberFormatMemberImportContext::characters( const OUString& rChars )
+{
+    mxSlaveContext->characters( rChars );
+    maText += rChars;
+}
+
+
+SdXMLNumberFormatImportContext::SdXMLNumberFormatImportContext( SdXMLImport& rImport, sal_Int32 nElement, SvXMLNumImpData* pNewData, SvXMLStylesTokens nNewType, const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList, SvXMLStylesContext& rStyles)
+:   SvXMLNumFormatContext(rImport, nElement, pNewData, nNewType, xAttrList, rStyles),
+    mbAutomatic( false ),
+    mnElements{},
+    mnIndex(0),
+    mnKey( -1 )
+{
+    mbTimeStyle = (nElement & TOKEN_MASK) == XML_TIME_STYLE;
+
+    for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+    {
+        if( aIter.getToken() == XML_ELEMENT(NUMBER, XML_AUTOMATIC_ORDER) )
+                mbAutomatic = IsXMLToken( aIter, XML_TRUE );
+        else
+            XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+    }
+}
+
+SdXMLNumberFormatImportContext::~SdXMLNumberFormatImportContext()
+{
+}
+
+void SdXMLNumberFormatImportContext::add( std::u16string_view rNumberStyle, bool bLong, bool bTextual, bool bDecimal02, std::u16string_view rText )
+{
+    if (mnIndex == 16)
+        return;
+
+    const SdXMLDataStyleNumber* pStyleMember = aSdXMLDataStyleNumbers;
+    for( sal_uInt8 nIndex = 0; pStyleMember->meNumberStyle != XML_TOKEN_INVALID; nIndex++, pStyleMember++ )
+    {
+        if( IsXMLToken(rNumberStyle, pStyleMember->meNumberStyle) &&
+            (pStyleMember->mbLong == bLong) &&
+            (pStyleMember->mbTextual == bTextual) &&
+            (pStyleMember->mbDecimal02 == bDecimal02) &&
+            ( ( (pStyleMember->mpText == nullptr) && (rText.empty()) ) ||
+              ( pStyleMember->mpText && (o3tl::equalsAscii( rText, pStyleMember->mpText ) ) ) ) )
+        {
+            mnElements[mnIndex++] = static_cast<DataStyleNumber>(nIndex + 1);
+            return;
+        }
+    }
+}
+
+bool SdXMLNumberFormatImportContext::compareStyle( const SdXMLFixedDataStyle* pStyle, sal_Int16& nIndex ) const
+{
+    if( (pStyle->mbAutomatic != mbAutomatic) && (nIndex == 0))
+        return false;
+
+    sal_Int16 nCompareIndex;
+    for( nCompareIndex = 0; nCompareIndex < 8; nIndex++, nCompareIndex++ )
+    {
+        if( pStyle->mpFormat[nCompareIndex] != mnElements[nIndex] )
+            return false;
+    }
+
+    return true;
+}
+
+void SdXMLNumberFormatImportContext::endFastElement(sal_Int32 )
+{
+    for( ; mnIndex < 16; mnIndex++ )
+    {
+        mnElements[mnIndex] = DataStyleNumber::NONE;
+    }
+
+    if( mbTimeStyle )
+    {
+        // compare import with all time styles
+        for( sal_Int16 nFormat = 0; nFormat < SdXMLTimeFormatCount; nFormat++ )
+        {
+            sal_Int16 nIndex = 0;
+            if( compareStyle( aSdXMLFixedTimeFormats[nFormat], nIndex ) )
+            {
+                mnKey = nFormat + 2;
+                break;
+            }
+        }
+    }
+    else
+    {
+        // compare import with all date styles
+        for( sal_Int16 nFormat = 0; nFormat < SdXMLDateFormatCount; nFormat++ )
+        {
+            sal_Int16 nIndex = 0;
+            if( compareStyle( aSdXMLFixedDateFormats[nFormat], nIndex ) )
+            {
+                mnKey = nFormat + 2;
+                break;
+            }
+            else if( mnElements[nIndex] == DataStyleNumber::TextSpace )
+            {
+                // if it's a valid date ending with a space, see if a time style follows
+                for( sal_Int16 nTimeFormat = 0; nTimeFormat < SdXMLTimeFormatCount; nTimeFormat++ )
+                {
+                    sal_Int16 nIndex2 = nIndex + 1;
+                    if( compareStyle( aSdXMLFixedTimeFormats[nTimeFormat], nIndex2 ) )
+                    {
+                        mnKey = (nFormat + 2) | ((nTimeFormat + 2) << 4);
+                        break;
+                    }
+                }
+            }
+        }
+
+        // no date style found? maybe it's an extended time style
+        if( mnKey == -1 )
+        {
+            // compare import with all time styles
+            for( sal_Int16 nFormat = 0; nFormat < SdXMLTimeFormatCount; nFormat++ )
+            {
+                sal_Int16 nIndex = 0;
+                if( compareStyle( aSdXMLFixedTimeFormats[nFormat], nIndex ) )
+                {
+                    mnKey = (nFormat + 2) << 4;
+                    break;
+                }
+            }
+        }
+    }
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLNumberFormatImportContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    return new SdXMLNumberFormatMemberImportContext( GetImport(), nElement, xAttrList,
+        this, static_cast<SvXMLImportContext*>(SvXMLNumFormatContext::createFastChildContext( nElement, xAttrList ).get()) );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/XMLNumberStylesExport.hxx b/xmloff/source/draw/XMLNumberStylesExport.hxx
new file mode 100644
index 000000000..8b4f39dc5
--- /dev/null
+++ b/xmloff/source/draw/XMLNumberStylesExport.hxx
@@ -0,0 +1,40 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <sal/types.h>
+#include <rtl/ustring.hxx>
+
+class SdXMLExport;
+
+const sal_Int16 SdXMLDateFormatCount = 8;
+const sal_Int16 SdXMLTimeFormatCount = 7;
+
+class SdXMLNumberStylesExporter
+{
+public:
+    static void exportTimeStyle(SdXMLExport& rExport, sal_Int32 nStyle);
+    static void exportDateStyle(SdXMLExport& rExport, sal_Int32 nStyle);
+
+    static OUString getTimeStyleName(const sal_Int32 nTimeFormat);
+    static OUString getDateStyleName(const sal_Int32 nDateFormat);
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/XMLReplacementImageContext.cxx b/xmloff/source/draw/XMLReplacementImageContext.cxx
new file mode 100644
index 000000000..5321d5578
--- /dev/null
+++ b/xmloff/source/draw/XMLReplacementImageContext.cxx
@@ -0,0 +1,99 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/graphic/XGraphic.hpp>
+#include <osl/diagnose.h>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/namespacemap.hxx>
+#include <xmloff/XMLBase64ImportContext.hxx>
+#include <XMLReplacementImageContext.hxx>
+#include <sal/log.hxx>
+
+using ::com::sun::star::uno::Reference;
+using namespace ::com::sun::star::xml::sax;
+using namespace ::com::sun::star::beans;
+using namespace css;
+using namespace ::xmloff::token;
+
+XMLReplacementImageContext::XMLReplacementImageContext(
+        SvXMLImport& rImport,
+        sal_Int32 /*nElement*/,
+        const Reference< XFastAttributeList > & rAttrList,
+        const Reference< XPropertySet > & rPropSet ) :
+    SvXMLImportContext( rImport ),
+    m_xPropSet( rPropSet )
+{
+    m_sHRef = rAttrList->getOptionalValue(XML_ELEMENT(XLINK, XML_HREF));
+}
+
+XMLReplacementImageContext::~XMLReplacementImageContext()
+{
+}
+
+void XMLReplacementImageContext::endFastElement(sal_Int32 )
+{
+    OSL_ENSURE( !m_sHRef.isEmpty() || m_xBase64Stream.is(),
+                "neither URL nor base64 image data given" );
+    uno::Reference<graphic::XGraphic> xGraphic;
+
+    try
+    {
+        if( !m_sHRef.isEmpty() )
+        {
+            xGraphic = GetImport().loadGraphicByURL(m_sHRef);
+        }
+        else if( m_xBase64Stream.is() )
+        {
+            xGraphic = GetImport().loadGraphicFromBase64(m_xBase64Stream);
+            m_xBase64Stream = nullptr;
+        }
+    }
+    catch (uno::Exception const &)
+    {}
+
+    Reference < XPropertySetInfo > xPropSetInfo = m_xPropSet->getPropertySetInfo();
+
+    if (xGraphic.is() && xPropSetInfo->hasPropertyByName("Graphic"))
+    {
+        m_xPropSet->setPropertyValue("Graphic", uno::Any(xGraphic));
+    }
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > XMLReplacementImageContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >&  )
+{
+    if( nElement == XML_ELEMENT(OFFICE, XML_BINARY_DATA) &&
+        !m_xBase64Stream.is() )
+    {
+        m_xBase64Stream = GetImport().GetStreamForGraphicObjectURLFromBase64();
+        if( m_xBase64Stream.is() )
+            return new XMLBase64ImportContext( GetImport(),
+                                                    m_xBase64Stream );
+    }
+
+    XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+    return nullptr;
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/XMLShapePropertySetContext.cxx b/xmloff/source/draw/XMLShapePropertySetContext.cxx
new file mode 100644
index 000000000..c702bccf9
--- /dev/null
+++ b/xmloff/source/draw/XMLShapePropertySetContext.cxx
@@ -0,0 +1,91 @@
+/* -*- 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 <XMLShapePropertySetContext.hxx>
+#include <XMLTextColumnsContext.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/xmlnumi.hxx>
+#include <xmltabi.hxx>
+#include <xmlsdtypes.hxx>
+#include <xmloff/txtprmap.hxx>
+#include <xmloff/xmlimppr.hxx>
+
+#include <com/sun/star/container/XIndexReplace.hpp>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+
+
+XMLShapePropertySetContext::XMLShapePropertySetContext(
+                 SvXMLImport& rImport, sal_Int32 nElement,
+                 const Reference< xml::sax::XFastAttributeList > & xAttrList,
+                 sal_uInt32 nFam,
+                 ::std::vector< XMLPropertyState > &rProps,
+                 const rtl::Reference < SvXMLImportPropertyMapper > &rMap ) :
+    SvXMLPropertySetContext( rImport, nElement, xAttrList, nFam,
+                             rProps, rMap ),
+    mnBulletIndex(-1)
+{
+}
+
+XMLShapePropertySetContext::~XMLShapePropertySetContext()
+{
+}
+
+void XMLShapePropertySetContext::endFastElement(sal_Int32 )
+{
+    Reference< container::XIndexReplace > xNumRule;
+    if( mxBulletStyle.is() )
+    {
+        SvxXMLListStyleContext* pBulletStyle = static_cast<SvxXMLListStyleContext*>(mxBulletStyle.get());
+        xNumRule = SvxXMLListStyleContext::CreateNumRule( GetImport().GetModel() );
+        if( xNumRule.is() )
+            pBulletStyle->FillUnoNumRule(xNumRule);
+    }
+
+    XMLPropertyState aPropState( mnBulletIndex, Any(xNumRule) );
+    mrProperties.push_back( aPropState );
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > XMLShapePropertySetContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList,
+    ::std::vector< XMLPropertyState > &rProperties,
+    const XMLPropertyState& rProp )
+{
+    switch( mxMapper->getPropertySetMapper()->GetEntryContextId( rProp.mnIndex ) )
+    {
+    case CTF_NUMBERINGRULES:
+        mnBulletIndex = rProp.mnIndex;
+        mxBulletStyle = new SvxXMLListStyleContext( GetImport() );
+        return mxBulletStyle;
+    case CTF_TABSTOP:
+        return new SvxXMLTabStopImportContext( GetImport(), nElement,
+                                                   rProp,
+                                                   rProperties );
+    case CTF_TEXTCOLUMNS:
+        return new XMLTextColumnsContext(GetImport(), nElement, xAttrList, rProp, rProperties);
+    }
+
+    return SvXMLPropertySetContext::createFastChildContext( nElement,
+                                                            xAttrList,
+                                                            rProperties, rProp );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/XMLShapeStyleContext.cxx b/xmloff/source/draw/XMLShapeStyleContext.cxx
new file mode 100644
index 000000000..da4341731
--- /dev/null
+++ b/xmloff/source/draw/XMLShapeStyleContext.cxx
@@ -0,0 +1,323 @@
+/* -*- 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 <tools/debug.hxx>
+#include <sal/log.hxx>
+#include <xmloff/XMLShapeStyleContext.hxx>
+#include <XMLShapePropertySetContext.hxx>
+#include <xmloff/contextid.hxx>
+#include <com/sun/star/drawing/FillStyle.hpp>
+#include <com/sun/star/drawing/XControlShape.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/beans/XPropertySetInfo.hpp>
+#include <com/sun/star/lang/IllegalArgumentException.hpp>
+#include <com/sun/star/container/XIndexReplace.hpp>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/xmlnumi.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmlprmap.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlerror.hxx>
+#include <xmloff/maptype.hxx>
+#include <xmloff/xmlimppr.hxx>
+
+#include <xmlsdtypes.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::drawing;
+using namespace ::xmloff::token;
+
+
+XMLShapeStyleContext::XMLShapeStyleContext(
+    SvXMLImport& rImport,
+    SvXMLStylesContext& rStyles,
+    XmlStyleFamily nFamily)
+:   XMLPropStyleContext(rImport, rStyles, nFamily ),
+    m_bIsNumRuleAlreadyConverted( false )
+{
+}
+
+XMLShapeStyleContext::~XMLShapeStyleContext()
+{
+}
+
+void XMLShapeStyleContext::SetAttribute( sal_Int32 nElement, const OUString& rValue )
+{
+    if (m_sControlDataStyleName.isEmpty() && (nElement & TOKEN_MASK) == XML_DATA_STYLE_NAME)
+    {
+        m_sControlDataStyleName = rValue;
+    }
+    else if( nElement == XML_ELEMENT(STYLE, XML_LIST_STYLE_NAME) )
+    {
+        m_sListStyleName = rValue;
+    }
+    else
+    {
+        XMLPropStyleContext::SetAttribute( nElement, rValue );
+
+        if( nElement == XML_ELEMENT(STYLE, XML_NAME) || nElement == XML_ELEMENT(STYLE, XML_DISPLAY_NAME) )
+        {
+            if( !GetName().isEmpty() && !GetDisplayName().isEmpty() && GetName() != GetDisplayName() )
+            {
+                GetImport().
+                    AddStyleDisplayName( GetFamily(), GetName(), GetDisplayName() );
+            }
+        }
+    }
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > XMLShapeStyleContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    if( IsTokenInNamespace(nElement, XML_NAMESPACE_STYLE) ||
+        IsTokenInNamespace(nElement, XML_NAMESPACE_LO_EXT) )
+    {
+        sal_Int32 nLocalName = nElement & TOKEN_MASK;
+        sal_uInt32 nFamily = 0;
+        if( nLocalName == XML_TEXT_PROPERTIES )
+            nFamily = XML_TYPE_PROP_TEXT;
+        else if( nLocalName == XML_PARAGRAPH_PROPERTIES )
+            nFamily = XML_TYPE_PROP_PARAGRAPH;
+        else if( nLocalName == XML_GRAPHIC_PROPERTIES )
+            nFamily = XML_TYPE_PROP_GRAPHIC;
+        if( nFamily )
+        {
+            rtl::Reference < SvXMLImportPropertyMapper > xImpPrMap =
+                GetStyles()->GetImportPropertyMapper( GetFamily() );
+            if( xImpPrMap.is() )
+                return new XMLShapePropertySetContext( GetImport(), nElement, xAttrList,
+                                                        nFamily,
+                                                        GetProperties(),
+                                                        xImpPrMap );
+        }
+    }
+
+    return XMLPropStyleContext::createFastChildContext( nElement, xAttrList );
+}
+
+void XMLShapeStyleContext::FillPropertySet( const Reference< beans::XPropertySet > & rPropSet )
+{
+    if( !m_bIsNumRuleAlreadyConverted )
+    {
+        m_bIsNumRuleAlreadyConverted = true;
+
+        // for compatibility to beta files, search for CTF_SD_NUMBERINGRULES_NAME to
+        // import numbering rules from the style:properties element
+        const rtl::Reference< XMLPropertySetMapper >&rMapper = GetStyles()->GetImportPropertyMapper( GetFamily() )->getPropertySetMapper();
+
+        ::std::vector< XMLPropertyState > &rProperties = GetProperties();
+        ::std::vector< XMLPropertyState >::iterator end( rProperties.end() );
+
+        // first, look for the old format, where we had a text:list-style-name
+        // attribute in the style:properties element
+        auto property = std::find_if(rProperties.begin(), end, [&rMapper](XMLPropertyState& rProp) {
+            // find properties with context
+            return (rProp.mnIndex != -1) && (rMapper->GetEntryContextId( rProp.mnIndex ) == CTF_SD_NUMBERINGRULES_NAME); });
+
+        // if we did not find an old list-style-name in the properties, and we need one
+        // because we got a style:list-style attribute in the style-style element
+        // we generate one
+        if( (property == end) && ( !m_sListStyleName.isEmpty() ) )
+        {
+            sal_Int32 nIndex = rMapper->FindEntryIndex( CTF_SD_NUMBERINGRULES_NAME );
+            SAL_WARN_IF( -1 == nIndex, "xmloff", "can't find numbering rules property entry, can't set numbering rule!" );
+
+            XMLPropertyState aNewState( nIndex );
+            rProperties.push_back( aNewState );
+            end = rProperties.end();
+            property = end - 1;
+        }
+
+        // so, if we have an old or a new list style name, we set its value to
+        // a numbering rule
+        if( property != end )
+        {
+            if( m_sListStyleName.isEmpty() )
+            {
+                property->maValue >>= m_sListStyleName;
+            }
+
+            const SvxXMLListStyleContext *pListStyle = GetImport().GetTextImport()->FindAutoListStyle( m_sListStyleName );
+
+            SAL_WARN_IF( !pListStyle, "xmloff", "list-style not found for shape style" );
+            if( pListStyle )
+            {
+                uno::Reference< container::XIndexReplace > xNumRule( SvxXMLListStyleContext::CreateNumRule( GetImport().GetModel() ) );
+                pListStyle->FillUnoNumRule(xNumRule);
+                property->maValue <<= xNumRule;
+            }
+            else
+            {
+                property->mnIndex = -1;
+            }
+        }
+    }
+
+    struct ContextID_Index_Pair aContextIDs[] =
+    {
+        { CTF_DASHNAME, -1, drawing::FillStyle::FillStyle_MAKE_FIXED_SIZE },
+        { CTF_LINESTARTNAME, -1, drawing::FillStyle::FillStyle_MAKE_FIXED_SIZE },
+        { CTF_LINEENDNAME, -1, drawing::FillStyle::FillStyle_MAKE_FIXED_SIZE },
+        { CTF_FILLGRADIENTNAME, -1, drawing::FillStyle::FillStyle_GRADIENT },
+        { CTF_FILLTRANSNAME, -1, drawing::FillStyle::FillStyle_MAKE_FIXED_SIZE },
+        { CTF_FILLHATCHNAME, -1, drawing::FillStyle::FillStyle_HATCH },
+        { CTF_FILLBITMAPNAME, -1, drawing::FillStyle::FillStyle_BITMAP },
+        { CTF_SD_OLE_VIS_AREA_IMPORT_LEFT, -1, drawing::FillStyle::FillStyle_MAKE_FIXED_SIZE },
+        { CTF_SD_OLE_VIS_AREA_IMPORT_TOP, -1, drawing::FillStyle::FillStyle_MAKE_FIXED_SIZE },
+        { CTF_SD_OLE_VIS_AREA_IMPORT_WIDTH, -1, drawing::FillStyle::FillStyle_MAKE_FIXED_SIZE },
+        { CTF_SD_OLE_VIS_AREA_IMPORT_HEIGHT, -1, drawing::FillStyle::FillStyle_MAKE_FIXED_SIZE },
+        { -1, -1, drawing::FillStyle::FillStyle_MAKE_FIXED_SIZE }
+    };
+    static const XmlStyleFamily aFamilies[] =
+    {
+        XmlStyleFamily::SD_STROKE_DASH_ID,
+        XmlStyleFamily::SD_MARKER_ID,
+        XmlStyleFamily::SD_MARKER_ID,
+        XmlStyleFamily::SD_GRADIENT_ID,
+        XmlStyleFamily::SD_GRADIENT_ID,
+        XmlStyleFamily::SD_HATCH_ID,
+        XmlStyleFamily::SD_FILL_IMAGE_ID
+    };
+
+    rtl::Reference < SvXMLImportPropertyMapper > xImpPrMap =
+        GetStyles()->GetImportPropertyMapper( GetFamily() );
+    SAL_WARN_IF( !xImpPrMap.is(), "xmloff", "There is the import prop mapper" );
+    if( xImpPrMap.is() )
+        xImpPrMap->FillPropertySet( GetProperties(), rPropSet, aContextIDs );
+
+    Reference< XPropertySetInfo > xInfo;
+    // get property set mapper
+    rtl::Reference<XMLPropertySetMapper> xPropMapper( xImpPrMap->getPropertySetMapper() );
+
+    for( sal_uInt16 i=0; aContextIDs[i].nContextID != -1; i++ )
+    {
+        sal_Int32 nIndex = aContextIDs[i].nIndex;
+        if( nIndex != -1 ) switch( aContextIDs[i].nContextID )
+        {
+        case CTF_DASHNAME:
+        case CTF_LINESTARTNAME:
+        case CTF_LINEENDNAME:
+        case CTF_FILLGRADIENTNAME:
+        case CTF_FILLTRANSNAME:
+        case CTF_FILLHATCHNAME:
+        case CTF_FILLBITMAPNAME:
+        {
+            struct XMLPropertyState& rState = GetProperties()[nIndex];
+            OUString sStyleName;
+            rState.maValue >>= sStyleName;
+            sStyleName = GetImport().GetStyleDisplayName( aFamilies[i], sStyleName );
+            // All of these attributes refer to something with draw:name
+            // of type styleName = NCName which is non-empty.
+            // tdf#89802: for Writer frames there would be no exception here but
+            // it will fail later on attach() and take out the entire frame
+            if (sStyleName.isEmpty() &&
+                (   CTF_FILLGRADIENTNAME == aContextIDs[i].nContextID
+                 || CTF_FILLTRANSNAME    == aContextIDs[i].nContextID
+                 || CTF_FILLHATCHNAME    == aContextIDs[i].nContextID
+                 || CTF_FILLBITMAPNAME   == aContextIDs[i].nContextID))
+            {
+                Sequence<OUString> const seq{ sStyleName };
+                GetImport().SetError(
+                    XMLERROR_STYLE_PROP_VALUE | XMLERROR_FLAG_WARNING,
+                    seq, "empty style name reference", nullptr );
+                break;
+            }
+
+            if (::xmloff::IsIgnoreFillStyleNamedItem(rPropSet, aContextIDs[i].nExpectedFillStyle))
+            {
+                SAL_INFO("xmloff.style", "ShapeStyleContext: dropping fill named item: " << sStyleName);
+                break; // ignore it, it's not used
+            }
+
+            try
+            {
+
+                // set property
+                const OUString& rPropertyName = xPropMapper->GetEntryAPIName(rState.mnIndex);
+                if( !xInfo.is() )
+                    xInfo = rPropSet->getPropertySetInfo();
+                if ( xInfo->hasPropertyByName( rPropertyName ) )
+                {
+                    rPropSet->setPropertyValue( rPropertyName, Any( sStyleName ) );
+                }
+            }
+            catch ( const css::lang::IllegalArgumentException& e )
+            {
+                Sequence<OUString> aSeq { sStyleName };
+                GetImport().SetError(
+                    XMLERROR_STYLE_PROP_VALUE | XMLERROR_FLAG_WARNING,
+                    aSeq, e.Message, nullptr );
+            }
+            break;
+        }
+        case CTF_SD_OLE_VIS_AREA_IMPORT_LEFT:
+        case CTF_SD_OLE_VIS_AREA_IMPORT_TOP:
+        case CTF_SD_OLE_VIS_AREA_IMPORT_WIDTH:
+        case CTF_SD_OLE_VIS_AREA_IMPORT_HEIGHT:
+        {
+            struct XMLPropertyState& rState = GetProperties()[nIndex];
+            const OUString& rPropertyName = xPropMapper->GetEntryAPIName(rState.mnIndex);
+            try
+            {
+                if( !xInfo.is() )
+                    xInfo = rPropSet->getPropertySetInfo();
+                if ( xInfo->hasPropertyByName( rPropertyName ) )
+                {
+                    rPropSet->setPropertyValue( rPropertyName, rState.maValue );
+                }
+            }
+            catch ( const css::lang::IllegalArgumentException& e )
+            {
+                Sequence<OUString> aSeq;
+                GetImport().SetError(
+                    XMLERROR_STYLE_PROP_VALUE | XMLERROR_FLAG_WARNING,
+                    aSeq, e.Message, nullptr );
+            }
+            break;
+        }
+        }
+    }
+
+    if (m_sControlDataStyleName.isEmpty())
+        return;
+
+    // we had a data-style-name attribute
+
+    // set the formatting on the control model of the control shape
+    uno::Reference< drawing::XControlShape > xControlShape(rPropSet, uno::UNO_QUERY);
+    DBG_ASSERT(xControlShape.is(), "XMLShapeStyleContext::FillPropertySet: data style for a non-control shape!");
+    if (xControlShape.is())
+    {
+        uno::Reference< beans::XPropertySet > xControlModel(xControlShape->getControl(), uno::UNO_QUERY);
+        DBG_ASSERT(xControlModel.is(), "XMLShapeStyleContext::FillPropertySet: no control model for the shape!");
+        if (xControlModel.is())
+        {
+            GetImport().GetFormImport()->applyControlNumberStyle(xControlModel, m_sControlDataStyleName);
+        }
+    }
+}
+
+void XMLShapeStyleContext::Finish( bool /*bOverwrite*/ )
+{
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/animationexport.cxx b/xmloff/source/draw/animationexport.cxx
new file mode 100644
index 000000000..2a48e16c3
--- /dev/null
+++ b/xmloff/source/draw/animationexport.cxx
@@ -0,0 +1,1743 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+
+#include <com/sun/star/animations/XAnimateColor.hpp>
+#include <com/sun/star/animations/XCommand.hpp>
+#include <com/sun/star/animations/Timing.hpp>
+#include <com/sun/star/animations/Event.hpp>
+#include <com/sun/star/animations/XAnimateMotion.hpp>
+#include <com/sun/star/animations/XAnimatePhysics.hpp>
+#include <com/sun/star/animations/XAnimateTransform.hpp>
+#include <com/sun/star/animations/XTransitionFilter.hpp>
+#include <com/sun/star/animations/XIterateContainer.hpp>
+#include <com/sun/star/animations/XAudio.hpp>
+#include <com/sun/star/animations/AnimationColorSpace.hpp>
+#include <com/sun/star/animations/AnimationNodeType.hpp>
+#include <com/sun/star/animations/AnimationRestart.hpp>
+#include <com/sun/star/animations/EventTrigger.hpp>
+#include <com/sun/star/animations/AnimationFill.hpp>
+#include <com/sun/star/animations/AnimationEndSync.hpp>
+#include <com/sun/star/animations/AnimationCalcMode.hpp>
+#include <com/sun/star/animations/AnimationAdditiveMode.hpp>
+#include <com/sun/star/animations/AnimationTransformType.hpp>
+#include <com/sun/star/animations/TransitionType.hpp>
+#include <com/sun/star/animations/TransitionSubType.hpp>
+#include <com/sun/star/animations/ValuePair.hpp>
+#include <com/sun/star/container/XEnumerationAccess.hpp>
+#include <com/sun/star/beans/NamedValue.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/document/XStorageBasedDocument.hpp>
+#include <com/sun/star/embed/ElementModes.hpp>
+#include <com/sun/star/embed/XTransactedObject.hpp>
+#include <com/sun/star/presentation/EffectNodeType.hpp>
+#include <com/sun/star/presentation/EffectPresetClass.hpp>
+#include <com/sun/star/presentation/ParagraphTarget.hpp>
+#include <com/sun/star/presentation/TextAnimationType.hpp>
+#include <com/sun/star/presentation/ShapeAnimationSubType.hpp>
+#include <com/sun/star/presentation/EffectCommands.hpp>
+#include <o3tl/any.hxx>
+#include <sax/tools/converter.hxx>
+#include <sal/log.hxx>
+#include <tools/diagnose_ex.h>
+
+#include <xmloff/unointerfacetouniqueidentifiermapper.hxx>
+#include "sdpropls.hxx"
+#include <xmlsdtypes.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <xmloff/xmlement.hxx>
+#include <xmloff/xmlprhdl.hxx>
+
+#include <animations.hxx>
+#include <xmloff/animationexport.hxx>
+
+using namespace css;
+using namespace ::std;
+using namespace ::cppu;
+using namespace ::com::sun::star::animations;
+using namespace ::com::sun::star::presentation;
+using namespace ::com::sun::star::drawing;
+using namespace ::com::sun::star::beans;
+using namespace ::xmloff::token;
+
+using ::com::sun::star::uno::Any;
+using ::com::sun::star::uno::UNO_QUERY;
+using ::com::sun::star::uno::UNO_QUERY_THROW;
+using ::com::sun::star::uno::Reference;
+using ::com::sun::star::uno::Sequence;
+using ::com::sun::star::uno::Exception;
+using ::com::sun::star::uno::RuntimeException;
+using ::com::sun::star::uno::XInterface;
+using ::com::sun::star::beans::NamedValue;
+using ::com::sun::star::container::XEnumerationAccess;
+using ::com::sun::star::container::XEnumeration;
+
+namespace xmloff
+{
+
+const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_Fill[] =
+{
+    { XML_DEFAULT,      AnimationFill::DEFAULT },
+    { XML_REMOVE,       AnimationFill::REMOVE },
+    { XML_FREEZE,       AnimationFill::FREEZE },
+    { XML_HOLD,         AnimationFill::HOLD },
+    { XML_TRANSITION,   AnimationFill::TRANSITION },
+    { XML_AUTO,         AnimationFill::AUTO },
+    { XML_TOKEN_INVALID, 0 }
+};
+const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_FillDefault[] =
+{
+    { XML_INHERIT,      AnimationFill::INHERIT },
+    { XML_REMOVE,       AnimationFill::REMOVE },
+    { XML_FREEZE,       AnimationFill::FREEZE },
+    { XML_HOLD,         AnimationFill::HOLD },
+    { XML_TRANSITION,   AnimationFill::TRANSITION },
+    { XML_AUTO,         AnimationFill::AUTO },
+    { XML_TOKEN_INVALID, 0 }
+};
+const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_Restart[] =
+{
+    { XML_DEFAULT,      AnimationRestart::DEFAULT },
+    { XML_ALWAYS,       AnimationRestart::ALWAYS },
+    { XML_WHENNOTACTIVE,AnimationRestart::WHEN_NOT_ACTIVE },
+    { XML_NEVER,        AnimationRestart::NEVER },
+    { XML_TOKEN_INVALID, 0 }
+};
+const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_RestartDefault[] =
+{
+    { XML_INHERIT,      AnimationRestart::INHERIT },
+    { XML_ALWAYS,       AnimationRestart::ALWAYS },
+    { XML_WHENNOTACTIVE,AnimationRestart::WHEN_NOT_ACTIVE },
+    { XML_NEVER,        AnimationRestart::NEVER },
+    { XML_TOKEN_INVALID, 0 }
+};
+const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_Endsync[] =
+{
+    { XML_FIRST,        AnimationEndSync::FIRST },
+    { XML_LAST,         AnimationEndSync::LAST },
+    { XML_ALL,          AnimationEndSync::ALL },
+    { XML_MEDIA,        AnimationEndSync::MEDIA },
+    { XML_TOKEN_INVALID, 0 }
+};
+const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_CalcMode[] =
+{
+    { XML_DISCRETE,     AnimationCalcMode::DISCRETE },
+    { XML_LINEAR,       AnimationCalcMode::LINEAR },
+    { XML_PACED,        AnimationCalcMode::PACED },
+    { XML_SPLINE,       AnimationCalcMode::SPLINE },
+    { XML_TOKEN_INVALID, 0 }
+};
+const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_AdditiveMode[] =
+{
+    { XML_BASE,         AnimationAdditiveMode::BASE },
+    { XML_SUM,          AnimationAdditiveMode::SUM },
+    { XML_REPLACE,      AnimationAdditiveMode::REPLACE },
+    { XML_MULTIPLY,     AnimationAdditiveMode::MULTIPLY },
+    { XML_NONE,         AnimationAdditiveMode::NONE },
+    { XML_TOKEN_INVALID, 0 }
+};
+const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_TransformType[] =
+{
+    { XML_TRANSLATE,    AnimationTransformType::TRANSLATE },
+    { XML_SCALE,        AnimationTransformType::SCALE },
+    { XML_ROTATE,       AnimationTransformType::ROTATE },
+    { XML_SKEWX,        AnimationTransformType::SKEWX },
+    { XML_SKEWY,        AnimationTransformType::SKEWY },
+    { XML_TOKEN_INVALID, 0 }
+};
+const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_TransitionType[] =
+{
+    { XML_BARWIPE,          TransitionType::BARWIPE },
+    { XML_BOXWIPE,          TransitionType::BOXWIPE },
+    { XML_FOURBOXWIPE,      TransitionType::FOURBOXWIPE },
+    { XML_BARNDOORWIPE,     TransitionType::BARNDOORWIPE },
+    { XML_DIAGONALWIPE,     TransitionType::DIAGONALWIPE },
+    { XML_BOWTIEWIPE,       TransitionType::BOWTIEWIPE },
+    { XML_MISCDIAGONALWIPE, TransitionType::MISCDIAGONALWIPE },
+    { XML_VEEWIPE,          TransitionType::VEEWIPE },
+    { XML_BARNVEEWIPE,      TransitionType::BARNVEEWIPE },
+    { XML_ZIGZAGWIPE,       TransitionType::ZIGZAGWIPE },
+    { XML_BARNZIGZAGWIPE,   TransitionType::BARNZIGZAGWIPE },
+    { XML_IRISWIPE,         TransitionType::IRISWIPE },
+    { XML_TRIANGLEWIPE,     TransitionType::TRIANGLEWIPE },
+    { XML_ARROWHEADWIPE,    TransitionType::ARROWHEADWIPE },
+    { XML_PENTAGONWIPE,     TransitionType::PENTAGONWIPE },
+    { XML_HEXAGONWIPE,      TransitionType::HEXAGONWIPE },
+    { XML_ELLIPSEWIPE,      TransitionType::ELLIPSEWIPE },
+    { XML_EYEWIPE,          TransitionType::EYEWIPE },
+    { XML_ROUNDRECTWIPE,    TransitionType::ROUNDRECTWIPE },
+    { XML_STARWIPE,         TransitionType::STARWIPE },
+    { XML_MISCSHAPEWIPE,    TransitionType::MISCSHAPEWIPE },
+    { XML_CLOCKWIPE,        TransitionType::CLOCKWIPE },
+    { XML_PINWHEELWIPE,     TransitionType::PINWHEELWIPE },
+    { XML_SINGLESWEEPWIPE,  TransitionType::SINGLESWEEPWIPE },
+    { XML_FANWIPE,          TransitionType::FANWIPE },
+    { XML_DOUBLEFANWIPE,    TransitionType::DOUBLEFANWIPE },
+    { XML_DOUBLESWEEPWIPE,  TransitionType::DOUBLESWEEPWIPE },
+    { XML_SALOONDOORWIPE,   TransitionType::SALOONDOORWIPE },
+    { XML_WINDSHIELDWIPE,   TransitionType::WINDSHIELDWIPE },
+    { XML_SNAKEWIPE,        TransitionType::SNAKEWIPE },
+    { XML_SPIRALWIPE,       TransitionType::SPIRALWIPE },
+    { XML_PARALLELSNAKESWIPE,TransitionType::PARALLELSNAKESWIPE },
+    { XML_BOXSNAKESWIPE,    TransitionType::BOXSNAKESWIPE },
+    { XML_WATERFALLWIPE,    TransitionType::WATERFALLWIPE },
+    { XML_PUSHWIPE,         TransitionType::PUSHWIPE },
+    { XML_SLIDEWIPE,        TransitionType::SLIDEWIPE },
+    { XML_FADE,             TransitionType::FADE },
+    { XML_RANDOMBARWIPE,    TransitionType::RANDOMBARWIPE },
+    { XML_CHECKERBOARDWIPE, TransitionType::CHECKERBOARDWIPE },
+    { XML_DISSOLVE,         TransitionType::DISSOLVE },
+    { XML_BLINDSWIPE,       TransitionType::BLINDSWIPE },
+    { XML_RANDOM,           TransitionType::RANDOM },
+    { XML_ZOOM,             TransitionType::ZOOM },
+    { XML_TOKEN_INVALID, 0 }
+};
+const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_TransitionSubType[] =
+{
+    { XML_DEFAULT,              TransitionSubType::DEFAULT },
+    { XML_LEFTTORIGHT,          TransitionSubType::LEFTTORIGHT },
+    { XML_TOPTOBOTTOM,          TransitionSubType::TOPTOBOTTOM },
+    { XML_TOPLEFT,              TransitionSubType::TOPLEFT },
+    { XML_TOPRIGHT,             TransitionSubType::TOPRIGHT },
+    { XML_BOTTOMRIGHT,          TransitionSubType::BOTTOMRIGHT },
+    { XML_BOTTOMLEFT,           TransitionSubType::BOTTOMLEFT },
+    { XML_TOPCENTER,            TransitionSubType::TOPCENTER },
+    { XML_RIGHTCENTER,          TransitionSubType::RIGHTCENTER },
+    { XML_BOTTOMCENTER,         TransitionSubType::BOTTOMCENTER },
+    { XML_LEFTCENTER,           TransitionSubType::LEFTCENTER },
+    { XML_CORNERSIN,            TransitionSubType::CORNERSIN },
+    { XML_CORNERSOUT,           TransitionSubType::CORNERSOUT },
+    { XML_VERTICAL,             TransitionSubType::VERTICAL },
+    { XML_HORIZONTAL,           TransitionSubType::HORIZONTAL },
+    { XML_DIAGONALBOTTOMLEFT,   TransitionSubType::DIAGONALBOTTOMLEFT },
+    { XML_DIAGONALTOPLEFT,      TransitionSubType::DIAGONALTOPLEFT },
+    { XML_DOUBLEBARNDOOR,       TransitionSubType::DOUBLEBARNDOOR },
+    { XML_DOUBLEDIAMOND,        TransitionSubType::DOUBLEDIAMOND },
+    { XML_DOWN,                 TransitionSubType::DOWN },
+    { XML_LEFT,                 TransitionSubType::LEFT },
+    { XML_UP,                   TransitionSubType::UP },
+    { XML_RIGHT,                TransitionSubType::RIGHT },
+    { XML_RECTANGLE,            TransitionSubType::RECTANGLE },
+    { XML_DIAMOND,              TransitionSubType::DIAMOND },
+    { XML_CIRCLE,               TransitionSubType::CIRCLE },
+    { XML_FOURPOINT,            TransitionSubType::FOURPOINT },
+    { XML_FIVEPOINT,            TransitionSubType::FIVEPOINT },
+    { XML_SIXPOINT,             TransitionSubType::SIXPOINT },
+    { XML_HEART,                TransitionSubType::HEART },
+    { XML_KEYHOLE,              TransitionSubType::KEYHOLE },
+    { XML_CLOCKWISETWELVE,      TransitionSubType::CLOCKWISETWELVE },
+    { XML_CLOCKWISETHREE,       TransitionSubType::CLOCKWISETHREE },
+    { XML_CLOCKWISESIX,         TransitionSubType::CLOCKWISESIX },
+    { XML_CLOCKWISENINE,        TransitionSubType::CLOCKWISENINE },
+    { XML_TWOBLADEVERTICAL,     TransitionSubType::TWOBLADEVERTICAL },
+    { XML_TWOBLADEHORIZONTAL,   TransitionSubType::TWOBLADEHORIZONTAL },
+    { XML_FOURBLADE,            TransitionSubType::FOURBLADE },
+    { XML_CLOCKWISETOP,         TransitionSubType::CLOCKWISETOP },
+    { XML_CLOCKWISERIGHT,       TransitionSubType::CLOCKWISERIGHT },
+    { XML_CLOCKWISEBOTTOM,      TransitionSubType::CLOCKWISEBOTTOM },
+    { XML_CLOCKWISELEFT,        TransitionSubType::CLOCKWISELEFT },
+    { XML_CLOCKWISETOPLEFT,     TransitionSubType::CLOCKWISETOPLEFT },
+    { XML_COUNTERCLOCKWISEBOTTOMLEFT,TransitionSubType::COUNTERCLOCKWISEBOTTOMLEFT },
+    { XML_CLOCKWISEBOTTOMRIGHT, TransitionSubType::CLOCKWISEBOTTOMRIGHT },
+    { XML_COUNTERCLOCKWISETOPRIGHT,TransitionSubType::COUNTERCLOCKWISETOPRIGHT },
+    { XML_CENTERTOP,            TransitionSubType::CENTERTOP },
+    { XML_CENTERRIGHT,          TransitionSubType::CENTERRIGHT },
+    { XML_TOP,                  TransitionSubType::TOP },
+    { XML_BOTTOM,               TransitionSubType::BOTTOM },
+    { XML_FANOUTVERTICAL,       TransitionSubType::FANOUTVERTICAL },
+    { XML_FANOUTHORIZONTAL,     TransitionSubType::FANOUTHORIZONTAL },
+    { XML_FANINVERTICAL,        TransitionSubType::FANINVERTICAL },
+    { XML_FANINHORIZONTAL,      TransitionSubType::FANINHORIZONTAL },
+    { XML_PARALLELVERTICAL,     TransitionSubType::PARALLELVERTICAL },
+    { XML_PARALLELDIAGONAL,     TransitionSubType::PARALLELDIAGONAL },
+    { XML_OPPOSITEVERTICAL,     TransitionSubType::OPPOSITEVERTICAL },
+    { XML_OPPOSITEHORIZONTAL,   TransitionSubType::OPPOSITEHORIZONTAL },
+    { XML_PARALLELDIAGONALTOPLEFT,TransitionSubType::PARALLELDIAGONALTOPLEFT },
+    { XML_PARALLELDIAGONALBOTTOMLEFT,TransitionSubType::PARALLELDIAGONALBOTTOMLEFT },
+    { XML_TOPLEFTHORIZONTAL,    TransitionSubType::TOPLEFTHORIZONTAL },
+    { XML_TOPLEFTDIAGONAL,      TransitionSubType::TOPLEFTDIAGONAL },
+    { XML_TOPRIGHTDIAGONAL,     TransitionSubType::TOPRIGHTDIAGONAL },
+    { XML_BOTTOMRIGHTDIAGONAL,  TransitionSubType::BOTTOMRIGHTDIAGONAL },
+    { XML_BOTTOMLEFTDIAGONAL,   TransitionSubType::BOTTOMLEFTDIAGONAL },
+    { XML_TOPLEFTCLOCKWISE,     TransitionSubType::TOPLEFTCLOCKWISE },
+    { XML_TOPRIGHTCLOCKWISE,    TransitionSubType::TOPRIGHTCLOCKWISE },
+    { XML_BOTTOMRIGHTCLOCKWISE, TransitionSubType::BOTTOMRIGHTCLOCKWISE },
+    { XML_BOTTOMLEFTCLOCKWISE,  TransitionSubType::BOTTOMLEFTCLOCKWISE },
+    { XML_TOPLEFTCOUNTERCLOCKWISE,TransitionSubType::TOPLEFTCOUNTERCLOCKWISE },
+    { XML_TOPRIGHTCOUNTERCLOCKWISE,TransitionSubType::TOPRIGHTCOUNTERCLOCKWISE },
+    { XML_BOTTOMRIGHTCOUNTERCLOCKWISE,TransitionSubType::BOTTOMRIGHTCOUNTERCLOCKWISE },
+    { XML_BOTTOMLEFTCOUNTERCLOCKWISE,TransitionSubType::BOTTOMLEFTCOUNTERCLOCKWISE },
+    { XML_VERTICALTOPSAME,      TransitionSubType::VERTICALTOPSAME },
+    { XML_VERTICALBOTTOMSAME,   TransitionSubType::VERTICALBOTTOMSAME },
+    { XML_VERTICALTOPLEFTOPPOSITE,TransitionSubType::VERTICALTOPLEFTOPPOSITE },
+    { XML_VERTICALBOTTOMLEFTOPPOSITE,TransitionSubType::VERTICALBOTTOMLEFTOPPOSITE },
+    { XML_HORIZONTALLEFTSAME,   TransitionSubType::HORIZONTALLEFTSAME },
+    { XML_HORIZONTALRIGHTSAME,  TransitionSubType::HORIZONTALRIGHTSAME },
+    { XML_HORIZONTALTOPLEFTOPPOSITE,TransitionSubType::HORIZONTALTOPLEFTOPPOSITE },
+    { XML_HORIZONTALTOPRIGHTOPPOSITE,TransitionSubType::HORIZONTALTOPRIGHTOPPOSITE },
+    { XML_DIAGONALBOTTOMLEFTOPPOSITE,TransitionSubType::DIAGONALBOTTOMLEFTOPPOSITE },
+    { XML_DIAGONALTOPLEFTOPPOSITE,TransitionSubType::DIAGONALTOPLEFTOPPOSITE },
+    { XML_TWOBOXTOP,            TransitionSubType::TWOBOXTOP },
+    { XML_TWOBOXBOTTOM,         TransitionSubType::TWOBOXBOTTOM },
+    { XML_TWOBOXLEFT,           TransitionSubType::TWOBOXLEFT },
+    { XML_TWOBOXRIGHT,          TransitionSubType::TWOBOXRIGHT },
+    { XML_FOURBOXVERTICAL,      TransitionSubType::FOURBOXVERTICAL },
+    { XML_FOURBOXHORIZONTAL,    TransitionSubType::FOURBOXHORIZONTAL },
+    { XML_VERTICALLEFT,         TransitionSubType::VERTICALLEFT },
+    { XML_VERTICALRIGHT,        TransitionSubType::VERTICALRIGHT },
+    { XML_HORIZONTALLEFT,       TransitionSubType::HORIZONTALLEFT },
+    { XML_HORIZONTALRIGHT,      TransitionSubType::HORIZONTALRIGHT },
+    { XML_FROMLEFT,             TransitionSubType::FROMLEFT },
+    { XML_FROMTOP,              TransitionSubType::FROMTOP },
+    { XML_FROMRIGHT,            TransitionSubType::FROMRIGHT },
+    { XML_FROMBOTTOM,           TransitionSubType::FROMBOTTOM },
+    { XML_CROSSFADE,            TransitionSubType::CROSSFADE },
+    { XML_FADETOCOLOR,          TransitionSubType::FADETOCOLOR },
+    { XML_FADEFROMCOLOR,        TransitionSubType::FADEFROMCOLOR },
+    { XML_FADEOVERCOLOR,        TransitionSubType::FADEOVERCOLOR },
+    { XML_THREEBLADE,           TransitionSubType::THREEBLADE },
+    { XML_EIGHTBLADE,           TransitionSubType::EIGHTBLADE },
+    { XML_ONEBLADE,             TransitionSubType::ONEBLADE },
+    { XML_ACROSS,               TransitionSubType::ACROSS },
+    { XML_TOPLEFTVERTICAL,      TransitionSubType::TOPLEFTVERTICAL },
+    { XML_COMBHORIZONTAL,       TransitionSubType::COMBHORIZONTAL },
+    { XML_COMBVERTICAL,         TransitionSubType::COMBVERTICAL },
+    { XML_IN,                   TransitionSubType::IN },
+    { XML_OUT,                  TransitionSubType::OUT },
+    { XML_ROTATEIN,             TransitionSubType::ROTATEIN },
+    { XML_ROTATEOUT,            TransitionSubType::ROTATEOUT },
+    { XML_FROMTOPLEFT,          TransitionSubType::FROMTOPLEFT },
+    { XML_FROMTOPRIGHT,         TransitionSubType::FROMTOPRIGHT },
+    { XML_FROMBOTTOMLEFT,       TransitionSubType::FROMBOTTOMLEFT },
+    { XML_FROMBOTTOMRIGHT,      TransitionSubType::FROMBOTTOMRIGHT },
+
+    { XML_TOKEN_INVALID, 0 }
+};
+const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_EventTrigger[] =
+{
+    { XML_ONBEGIN,          EventTrigger::ON_BEGIN },
+    { XML_ONEND,            EventTrigger::ON_END },
+    { XML_BEGIN,            EventTrigger::BEGIN_EVENT },
+    { XML_END,              EventTrigger::END_EVENT },
+    { XML_CLICK,            EventTrigger::ON_CLICK },
+    { XML_DOUBLECLICK,      EventTrigger::ON_DBL_CLICK },
+    { XML_MOUSEOVER,        EventTrigger::ON_MOUSE_ENTER },
+    { XML_MOUSEOUT,         EventTrigger::ON_MOUSE_LEAVE },
+    { XML_NEXT,             EventTrigger::ON_NEXT },
+    { XML_PREVIOUS,         EventTrigger::ON_PREV },
+    { XML_STOP_AUDIO,       EventTrigger::ON_STOP_AUDIO },
+    { XML_REPEAT,           EventTrigger::REPEAT },
+    { XML_TOKEN_INVALID, 0 }
+};
+const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_EffectPresetClass[] =
+{
+    { XML_CUSTOM,       EffectPresetClass::CUSTOM },
+    { XML_ENTRANCE,     EffectPresetClass::ENTRANCE },
+    { XML_EXIT,         EffectPresetClass::EXIT },
+    { XML_EMPHASIS,     EffectPresetClass::EMPHASIS },
+    { XML_MOTION_PATH,  EffectPresetClass::MOTIONPATH },
+    { XML_OLE_ACTION,   EffectPresetClass::OLEACTION },
+    { XML_MEDIA_CALL,   EffectPresetClass::MEDIACALL },
+    { XML_TOKEN_INVALID, 0 }
+};
+const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_EffectNodeType[] =
+{
+    { XML_DEFAULT,                  EffectNodeType::DEFAULT },
+    { XML_ON_CLICK,                 EffectNodeType::ON_CLICK },
+    { XML_WITH_PREVIOUS,            EffectNodeType::WITH_PREVIOUS },
+    { XML_AFTER_PREVIOUS,           EffectNodeType::AFTER_PREVIOUS },
+    { XML_MAIN_SEQUENCE,            EffectNodeType::MAIN_SEQUENCE },
+    { XML_TIMING_ROOT,              EffectNodeType::TIMING_ROOT },
+    { XML_INTERACTIVE_SEQUENCE,     EffectNodeType::INTERACTIVE_SEQUENCE },
+    { XML_TOKEN_INVALID, 0 }
+};
+const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_SubItem[] =
+{
+    { XML_WHOLE,                    ShapeAnimationSubType::AS_WHOLE },
+    { XML_BACKGROUND,               ShapeAnimationSubType::ONLY_BACKGROUND },
+    { XML_TEXT,                     ShapeAnimationSubType::ONLY_TEXT },
+    { XML_TOKEN_INVALID, 0 }
+};
+const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_IterateType[] =
+{
+    { XML_BY_PARAGRAPH,             TextAnimationType::BY_PARAGRAPH },
+    { XML_BY_WORD,                  TextAnimationType::BY_WORD },
+    { XML_BY_LETTER,                TextAnimationType::BY_LETTER },
+    { XML_TOKEN_INVALID, 0 }
+};
+const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_Command[] =
+{
+    { XML_CUSTOM,                   EffectCommands::CUSTOM },
+    { XML_VERB,                     EffectCommands::VERB },
+    { XML_PLAY,                     EffectCommands::PLAY },
+    { XML_TOGGLE_PAUSE,             EffectCommands::TOGGLEPAUSE },
+    { XML_STOP,                     EffectCommands::STOP },
+    { XML_STOP_AUDIO,               EffectCommands::STOPAUDIO },
+    { XML_TOKEN_INVALID, 0 }
+};
+
+const struct ImplAttributeNameConversion* getAnimationAttributeNamesConversionList()
+{
+    static const struct ImplAttributeNameConversion gImplConversionList[] =
+    {
+        { XML_X,                        "X" },
+        { XML_Y,                        "Y" },
+        { XML_WIDTH,                    "Width" },
+        { XML_HEIGHT,                   "Height" },
+        { XML_ROTATE,                   "Rotate" },
+        { XML_SKEWX,                    "SkewX" },
+        { XML_FILL_COLOR,               "FillColor" },
+        { XML_FILL,                     "FillStyle" },
+        { XML_STROKE_COLOR,             "LineColor" },
+        { XML_STROKE,                   "LineStyle" },
+        { XML_COLOR,                    "CharColor" },
+        { XML_TEXT_ROTATION_ANGLE,      "CharRotation" },
+        { XML_FONT_WEIGHT,              "CharWeight" },
+        { XML_TEXT_UNDERLINE,           "CharUnderline" },
+        { XML_FONT_FAMILY,              "CharFontName" },
+        { XML_FONT_SIZE,                "CharHeight" },
+        { XML_FONT_STYLE,               "CharPosture" },
+        { XML_VISIBILITY,               "Visibility" },
+        { XML_OPACITY,                  "Opacity" },
+        { XML_DIM,                      "DimColor" },
+        { XML_TOKEN_INVALID,            nullptr }
+    };
+
+    return gImplConversionList;
+}
+
+
+class AnimationsExporterImpl
+{
+public:
+    AnimationsExporterImpl( SvXMLExport& rExport, const Reference< XPropertySet >& xPageProps );
+
+    void prepareNode( const Reference< XAnimationNode >& xNode );
+    void exportNode( const Reference< XAnimationNode >& xNode );
+
+    void exportContainer( const Reference< XTimeContainer >& xNode, sal_Int16 nContainerNodeType );
+    void exportAnimate( const Reference< XAnimate >& xNode );
+    void exportAudio( const Reference< XAudio >& xAudio );
+    void exportCommand( const Reference< XCommand >& xCommand );
+
+    static Reference< XInterface > getParagraphTarget( const ParagraphTarget& pTarget );
+
+    static void convertPath( OUStringBuffer& sTmp, const Any& rPath );
+    void convertValue( XMLTokenEnum eAttributeName, OUStringBuffer& sTmp, const Any& rValue ) const;
+    void convertTiming( OUStringBuffer& sTmp, const Any& rTiming ) const;
+    void convertTarget( OUStringBuffer& sTmp, const Any& rTarget ) const;
+
+    void prepareValue( const Any& rValue );
+
+    void exportTransitionNode();
+    void prepareTransitionNode();
+
+    bool mbHasTransition;
+private:
+    rtl::Reference<SvXMLExport> mxExport;
+    Reference< XPropertySet > mxPageProps;
+    rtl::Reference<XMLSdPropHdlFactory> mxSdPropHdlFactory;
+};
+
+AnimationsExporterImpl::AnimationsExporterImpl( SvXMLExport& rExport, const Reference< XPropertySet >& xPageProps )
+: mbHasTransition(false)
+, mxExport( &rExport )
+, mxPageProps( xPageProps )
+, mxSdPropHdlFactory(new XMLSdPropHdlFactory( rExport.GetModel(), rExport ))
+{
+}
+
+
+/** split a uri hierarchy into first segment and rest */
+static bool splitPath(OUString const & i_rPath,
+    OUString & o_rDir, OUString& o_rRest)
+{
+    const sal_Int32 idx(i_rPath.indexOf(u'/'));
+    if (idx < 0 || idx >= i_rPath.getLength()) {
+        o_rDir = OUString();
+        o_rRest = i_rPath;
+        return true;
+    } else if (idx == 0 || idx == i_rPath.getLength() - 1) {
+        // input must not start or end with '/'
+        return false;
+    } else {
+        o_rDir  = i_rPath.copy(0, idx);
+        o_rRest = i_rPath.copy(idx+1);
+        return true;
+    }
+}
+
+static void lcl_CopyStream(
+        uno::Reference<embed::XStorage> const& xSource,
+        uno::Reference<embed::XStorage> const& xTarget,
+         OUString const& rPath)
+{
+    OUString dir;
+    OUString rest;
+    if (!splitPath(rPath, dir, rest))
+        throw uno::RuntimeException();
+
+    if (dir.getLength() == 0)
+        xSource->copyElementTo(rPath, xTarget, rPath);
+    else
+    {
+        uno::Reference<embed::XStorage> const xSubSource(
+            xSource->openStorageElement(dir, embed::ElementModes::READ));
+        uno::Reference<embed::XStorage> const xSubTarget(
+            xTarget->openStorageElement(dir, embed::ElementModes::WRITE));
+        lcl_CopyStream(xSubSource, xSubTarget, rest);
+    }
+    uno::Reference<embed::XTransactedObject> const xTransaction(xTarget, uno::UNO_QUERY);
+    if (xTransaction.is())
+        xTransaction->commit();
+}
+
+char const s_PkgScheme[] = "vnd.sun.star.Package:";
+
+static OUString lcl_StoreMediaAndGetURL(SvXMLExport & rExport, OUString const& rURL)
+{
+    OUString urlPath;
+    if (rURL.startsWithIgnoreAsciiCase(s_PkgScheme, &urlPath))
+    {
+        try // video is embedded
+        {
+            // copy the media stream from document storage to target storage
+            // (not sure if this is the best way to store these?)
+            uno::Reference<document::XStorageBasedDocument> const xSBD(
+                    rExport.GetModel(), uno::UNO_QUERY_THROW);
+            uno::Reference<embed::XStorage> const xSource(
+                    xSBD->getDocumentStorage(), uno::UNO_SET_THROW);
+            uno::Reference<embed::XStorage> const xTarget(
+                    rExport.GetTargetStorage(), uno::UNO_SET_THROW);
+
+            urlPath = rURL.copy(SAL_N_ELEMENTS(s_PkgScheme)-1);
+
+            lcl_CopyStream(xSource, xTarget, urlPath);
+
+            return urlPath;
+        }
+        catch (uno::Exception const&)
+        {
+            TOOLS_INFO_EXCEPTION("xmloff", "exception while storing embedded media");
+        }
+        return OUString();
+    }
+    else
+    {
+        return rExport.GetRelativeReference(rURL); // linked
+    }
+}
+
+void AnimationsExporterImpl::exportTransitionNode()
+{
+    if( !(mbHasTransition && mxPageProps.is()) )
+        return;
+
+    sal_Int16 nTransition = 0;
+    mxPageProps->getPropertyValue("TransitionType") >>= nTransition;
+
+    Any aSound( mxPageProps->getPropertyValue("Sound") );
+    OUString sSoundURL;
+    aSound >>= sSoundURL;
+    bool bStopSound = false;
+    if( !(aSound >>= bStopSound) )
+        bStopSound = false;
+
+
+    OUStringBuffer sTmp;
+    if( !((nTransition != 0) || !sSoundURL.isEmpty() || bStopSound) )
+        return;
+
+    Reference< XInterface > xSource( mxPageProps );
+    Event aEvent;
+    aEvent.Source <<= xSource;
+    aEvent.Trigger = EventTrigger::BEGIN_EVENT;
+    aEvent.Repeat = 0;
+
+    convertTiming( sTmp, Any( aEvent ) );
+    mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_BEGIN, sTmp.makeStringAndClear() );
+
+    SvXMLElementExport aElement( *mxExport, XML_NAMESPACE_ANIMATION, XML_PAR, true, true );
+
+    if( nTransition != 0 )
+    {
+        sal_Int16 nSubtype = 0;
+        bool bDirection = false;
+        sal_Int32 nFadeColor = 0;
+        double fDuration = 0.0;
+        mxPageProps->getPropertyValue("TransitionSubtype") >>= nSubtype;
+        mxPageProps->getPropertyValue("TransitionDirection") >>= bDirection;
+        mxPageProps->getPropertyValue("TransitionFadeColor") >>= nFadeColor;
+        mxPageProps->getPropertyValue("TransitionDuration") >>= fDuration;
+
+        ::sax::Converter::convertDouble( sTmp, fDuration );
+        sTmp.append( 's');
+        mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_DUR, sTmp.makeStringAndClear() );
+
+        SvXMLUnitConverter::convertEnum( sTmp, nTransition, aAnimations_EnumMap_TransitionType );
+        mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_TYPE, sTmp.makeStringAndClear() );
+
+        if( nSubtype != TransitionSubType::DEFAULT )
+        {
+            SvXMLUnitConverter::convertEnum( sTmp, nSubtype, aAnimations_EnumMap_TransitionSubType );
+            mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_SUBTYPE, sTmp.makeStringAndClear() );
+        }
+
+        if( !bDirection )
+            mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_DIRECTION, XML_REVERSE );
+
+        if( (nTransition == TransitionType::FADE)
+                && ((nSubtype == TransitionSubType::FADETOCOLOR) || (nSubtype == TransitionSubType::FADEFROMCOLOR)
+                    || (nSubtype == TransitionSubType::FADEOVERCOLOR)))
+        {
+            ::sax::Converter::convertColor( sTmp, nFadeColor );
+            mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_FADECOLOR, sTmp.makeStringAndClear() );
+        }
+        SvXMLElementExport aElement2( *mxExport, XML_NAMESPACE_ANIMATION, XML_TRANSITIONFILTER, true, true );
+    }
+
+    if( bStopSound )
+    {
+        mxExport->AddAttribute( XML_NAMESPACE_ANIMATION, XML_COMMAND, XML_STOP_AUDIO );
+        SvXMLElementExport aElement2( *mxExport, XML_NAMESPACE_ANIMATION, XML_COMMAND, true, true );
+    }
+    else if( !sSoundURL.isEmpty())
+    {
+        sSoundURL = lcl_StoreMediaAndGetURL(*mxExport, sSoundURL);
+        mxExport->AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, sSoundURL );
+
+        bool bLoopSound = false;
+        mxPageProps->getPropertyValue("LoopSound") >>= bLoopSound;
+
+        if( bLoopSound )
+            mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_REPEATCOUNT, XML_INDEFINITE );
+        SvXMLElementExport aElement2( *mxExport, XML_NAMESPACE_ANIMATION, XML_AUDIO, true, true );
+    }
+}
+
+void AnimationsExporterImpl::prepareTransitionNode()
+{
+    if( !mxPageProps.is() )
+        return;
+
+    try
+    {
+        sal_Int16 nTransition = 0;
+        mxPageProps->getPropertyValue("TransitionType") >>= nTransition;
+
+        bool bStopSound = false;
+        OUString sSoundURL;
+
+        if( nTransition == 0 )
+        {
+            Any aSound( mxPageProps->getPropertyValue("Sound") );
+            aSound >>= sSoundURL;
+
+            if( !(aSound >>= bStopSound) )
+                bStopSound = false;
+        }
+
+        if( (nTransition != 0) || !sSoundURL.isEmpty() || bStopSound )
+        {
+            mbHasTransition = true;
+            Reference< XInterface > xInt( mxPageProps );
+            mxExport->getInterfaceToIdentifierMapper().registerReference( xInt );
+        }
+    }
+    catch (const Exception&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw", "");
+    }
+}
+
+void AnimationsExporterImpl::prepareNode( const Reference< XAnimationNode >& xNode )
+{
+    try
+    {
+        prepareValue( xNode->getBegin() );
+        prepareValue( xNode->getEnd() );
+
+        sal_Int16 nNodeType = xNode->getType();
+        switch( nNodeType )
+        {
+        case AnimationNodeType::ITERATE:
+        {
+            Reference< XIterateContainer > xIter( xNode, UNO_QUERY_THROW );
+            prepareValue( xIter->getTarget() );
+            [[fallthrough]];
+        }
+        case AnimationNodeType::PAR:
+        case AnimationNodeType::SEQ:
+        {
+            Reference< XEnumerationAccess > xEnumerationAccess( xNode, UNO_QUERY_THROW );
+            Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), css::uno::UNO_SET_THROW );
+            while( xEnumeration->hasMoreElements() )
+            {
+                Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
+                prepareNode( xChildNode );
+            }
+        }
+        break;
+
+        case AnimationNodeType::ANIMATE:
+        case AnimationNodeType::SET:
+        case AnimationNodeType::ANIMATEMOTION:
+        case AnimationNodeType::ANIMATEPHYSICS:
+        case AnimationNodeType::ANIMATECOLOR:
+        case AnimationNodeType::ANIMATETRANSFORM:
+        case AnimationNodeType::TRANSITIONFILTER:
+        {
+            Reference< XAnimate > xAnimate( xNode, UNO_QUERY_THROW );
+            prepareValue( xAnimate->getTarget() );
+        }
+        break;
+
+        case AnimationNodeType::COMMAND:
+        {
+            Reference< XCommand > xCommand( xNode, UNO_QUERY_THROW );
+            prepareValue( xCommand->getTarget() );
+        }
+        break;
+
+        case AnimationNodeType::AUDIO:
+        {
+            Reference< XAudio > xAudio( xNode, UNO_QUERY_THROW );
+            prepareValue( xAudio->getSource() );
+        }
+        break;
+        }
+
+        const Sequence< NamedValue > aUserData( xNode->getUserData() );
+        for( const auto& rValue : aUserData )
+        {
+            if( IsXMLToken( rValue.Name, XML_MASTER_ELEMENT ) )
+            {
+                Reference< XInterface > xMaster;
+                rValue.Value >>= xMaster;
+                if( xMaster.is() )
+                    mxExport->getInterfaceToIdentifierMapper().registerReference( xMaster );
+            }
+        }
+    }
+    catch (const Exception&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw", "");
+    }
+}
+
+void AnimationsExporterImpl::exportNode( const Reference< XAnimationNode >& xNode )
+{
+    try
+    {
+        OUStringBuffer sTmp;
+
+        const OUString& rExportIdentifier = mxExport->getInterfaceToIdentifierMapper().getIdentifier( xNode );
+        if( !rExportIdentifier.isEmpty() )
+        {
+            mxExport->AddAttributeIdLegacy(
+                XML_NAMESPACE_ANIMATION, rExportIdentifier);
+        }
+
+        Any aTemp( xNode->getBegin() );
+        if( aTemp.hasValue() )
+        {
+            convertTiming( sTmp, aTemp );
+            mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_BEGIN, sTmp.makeStringAndClear() );
+        }
+
+        double fTemp = 0;
+        sal_Int16 nTemp;
+
+        aTemp = xNode->getDuration();
+        if( aTemp.hasValue() )
+        {
+            if( aTemp >>= fTemp )
+            {
+                ::sax::Converter::convertDouble( sTmp, fTemp );
+                sTmp.append( 's');
+                mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_DUR, sTmp.makeStringAndClear() );
+            }
+            else
+            {
+                Timing eTiming;
+                if( aTemp >>= eTiming )
+                    mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_DUR, eTiming == Timing_INDEFINITE ? XML_INDEFINITE : XML_MEDIA );
+            }
+        }
+
+        aTemp = xNode->getEnd();
+        if( aTemp.hasValue() )
+        {
+            convertTiming( sTmp, aTemp );
+            mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_END, sTmp.makeStringAndClear() );
+        }
+
+        nTemp = xNode->getFill();
+        if( nTemp != AnimationFill::DEFAULT )
+        {
+            SvXMLUnitConverter::convertEnum( sTmp, nTemp, aAnimations_EnumMap_Fill );
+            mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_FILL, sTmp.makeStringAndClear() );
+        }
+
+        nTemp = xNode->getFillDefault();
+        if( nTemp != AnimationFill::INHERIT )
+        {
+            SvXMLUnitConverter::convertEnum( sTmp, nTemp, aAnimations_EnumMap_FillDefault );
+            mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_FILLDEFAULT, sTmp.makeStringAndClear() );
+        }
+
+        nTemp = xNode->getRestart();
+        if( nTemp != AnimationRestart::DEFAULT )
+        {
+            SvXMLUnitConverter::convertEnum( sTmp, nTemp, aAnimations_EnumMap_Restart );
+            mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_RESTART, sTmp.makeStringAndClear() );
+        }
+
+        nTemp = xNode->getRestartDefault();
+        if( nTemp != AnimationRestart::INHERIT )
+        {
+            SvXMLUnitConverter::convertEnum( sTmp, nTemp, aAnimations_EnumMap_RestartDefault );
+            mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_RESTARTDEFAULT, sTmp.makeStringAndClear() );
+        }
+
+        fTemp = xNode->getAcceleration();
+        if( fTemp != 0.0 )
+        {
+            ::sax::Converter::convertDouble( sTmp, fTemp );
+            mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_ACCELERATE, sTmp.makeStringAndClear() );
+        }
+
+        fTemp = xNode->getDecelerate();
+        if( fTemp != 0.0 )
+        {
+            ::sax::Converter::convertDouble( sTmp, fTemp );
+            mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_DECELERATE, sTmp.makeStringAndClear() );
+        }
+
+        bool bTemp = xNode->getAutoReverse();
+        if( bTemp )
+        {
+            ::sax::Converter::convertBool( sTmp, bTemp );
+            mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_AUTOREVERSE, sTmp.makeStringAndClear() );
+        }
+
+        aTemp = xNode->getRepeatCount();
+        if( aTemp.hasValue() )
+        {
+            Timing eTiming;
+            if( (aTemp >>= eTiming ) && (eTiming == Timing_INDEFINITE ) )
+                mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_REPEATCOUNT, XML_INDEFINITE );
+            else if( aTemp >>= fTemp )
+            {
+                ::sax::Converter::convertDouble( sTmp, fTemp );
+                mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_REPEATCOUNT, sTmp.makeStringAndClear() );
+            }
+        }
+
+        aTemp = xNode->getRepeatDuration();
+        if( aTemp.hasValue() )
+        {
+            Timing eTiming;
+            if( ( aTemp >>= eTiming ) && (eTiming == Timing_INDEFINITE) )
+            {
+                mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_REPEATDUR, XML_INDEFINITE );
+            }
+            else if( aTemp >>= fTemp )
+            {
+                ::sax::Converter::convertDouble( sTmp, fTemp );
+                mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_REPEATDUR, sTmp.makeStringAndClear() );
+            }
+        }
+
+        aTemp = xNode->getEndSync();
+        if( aTemp.hasValue() && (aTemp >>= nTemp) )
+        {
+            SvXMLUnitConverter::convertEnum( sTmp, nTemp, aAnimations_EnumMap_Endsync );
+            mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_ENDSYNC, sTmp.makeStringAndClear() );
+        }
+
+        sal_Int16 nContainerNodeType = EffectNodeType::DEFAULT;
+        OUString aPresetId;
+        const Sequence< NamedValue > aUserData( xNode->getUserData() );
+        for( const auto& rValue : aUserData )
+        {
+            if( IsXMLToken( rValue.Name, XML_NODE_TYPE ) )
+            {
+                if( (rValue.Value >>= nContainerNodeType) && (nContainerNodeType != EffectNodeType::DEFAULT) )
+                {
+                    SvXMLUnitConverter::convertEnum( sTmp, nContainerNodeType, aAnimations_EnumMap_EffectNodeType );
+                    mxExport->AddAttribute( XML_NAMESPACE_PRESENTATION, XML_NODE_TYPE, sTmp.makeStringAndClear() );
+                }
+            }
+            else if( IsXMLToken( rValue.Name, XML_PRESET_ID ) )
+            {
+                if( rValue.Value >>= aPresetId )
+                {
+                    mxExport->AddAttribute( XML_NAMESPACE_PRESENTATION, XML_PRESET_ID, aPresetId );
+                }
+            }
+            else if( IsXMLToken( rValue.Name, XML_PRESET_SUB_TYPE ) )
+            {
+                OUString aPresetSubType;
+                if( rValue.Value >>= aPresetSubType )
+                {
+                    mxExport->AddAttribute( XML_NAMESPACE_PRESENTATION, XML_PRESET_SUB_TYPE, aPresetSubType );
+                }
+            }
+            else if( IsXMLToken( rValue.Name, XML_PRESET_CLASS ) )
+            {
+                sal_Int16 nEffectPresetClass = sal_uInt16();
+                if( rValue.Value >>= nEffectPresetClass )
+                {
+                    SvXMLUnitConverter::convertEnum( sTmp, nEffectPresetClass, aAnimations_EnumMap_EffectPresetClass );
+                    mxExport->AddAttribute( XML_NAMESPACE_PRESENTATION, XML_PRESET_CLASS, sTmp.makeStringAndClear() );
+                }
+            }
+            else if( IsXMLToken( rValue.Name, XML_MASTER_ELEMENT ) )
+            {
+                Reference< XInterface > xMaster;
+                rValue.Value >>= xMaster;
+                if( xMaster.is() )
+                {
+                    const OUString& rIdentifier = mxExport->getInterfaceToIdentifierMapper().getIdentifier(xMaster);
+                    if( !rIdentifier.isEmpty() )
+                        mxExport->AddAttribute( XML_NAMESPACE_PRESENTATION, XML_MASTER_ELEMENT, rIdentifier );
+                }
+            }
+            else if( IsXMLToken( rValue.Name, XML_GROUP_ID ) )
+            {
+                sal_Int32 nGroupId = 0;
+                if( rValue.Value >>= nGroupId )
+                    mxExport->AddAttribute( XML_NAMESPACE_PRESENTATION, XML_GROUP_ID, OUString::number( nGroupId ) );
+            }
+            else
+            {
+                OUString aTmp;
+                if( rValue.Value >>= aTmp )
+                    mxExport->AddAttribute( XML_NAMESPACE_PRESENTATION, rValue.Name, aTmp );
+            }
+        }
+
+        nTemp = xNode->getType();
+        switch( nTemp )
+        {
+        case AnimationNodeType::PAR:
+        case AnimationNodeType::SEQ:
+        case AnimationNodeType::ITERATE:
+        {
+            Reference< XTimeContainer > xContainer( xNode, UNO_QUERY_THROW );
+            exportContainer( xContainer, nContainerNodeType );
+        }
+        break;
+
+        case AnimationNodeType::ANIMATE:
+        case AnimationNodeType::SET:
+        case AnimationNodeType::ANIMATEMOTION:
+        case AnimationNodeType::ANIMATEPHYSICS:
+        case AnimationNodeType::ANIMATECOLOR:
+        case AnimationNodeType::ANIMATETRANSFORM:
+        case AnimationNodeType::TRANSITIONFILTER:
+        {
+            Reference< XAnimate > xAnimate( xNode, UNO_QUERY_THROW );
+            exportAnimate( xAnimate );
+        }
+        break;
+        case AnimationNodeType::AUDIO:
+        {
+            Reference< XAudio > xAudio( xNode, UNO_QUERY_THROW );
+            exportAudio( xAudio );
+        }
+        break;
+        case AnimationNodeType::COMMAND:
+        {
+            Reference< XCommand > xCommand( xNode, UNO_QUERY_THROW );
+            exportCommand( xCommand );
+        }
+        break;
+        default:
+            OSL_FAIL( "xmloff::AnimationsExporterImpl::exportNode(), invalid AnimationNodeType!" );
+        }
+    }
+    catch (const RuntimeException&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw", "");
+    }
+
+    // if something goes wrong, its always a good idea to clear the attribute list
+    mxExport->ClearAttrList();
+}
+
+void AnimationsExporterImpl::exportContainer( const Reference< XTimeContainer >& xContainer, sal_Int16 nContainerNodeType )
+{
+    try
+    {
+        const sal_Int32 nNodeType = xContainer->getType();
+
+        if( nNodeType == AnimationNodeType::ITERATE )
+        {
+            OUStringBuffer sTmp;
+            Reference< XIterateContainer > xIter( xContainer, UNO_QUERY_THROW );
+
+            Any aTemp( xIter->getTarget() );
+            if( aTemp.hasValue() )
+            {
+                convertTarget( sTmp, aTemp );
+                mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_TARGETELEMENT, sTmp.makeStringAndClear() );
+            }
+
+            sal_Int16 nTemp = xIter->getSubItem();
+            if( nTemp )
+            {
+                SvXMLUnitConverter::convertEnum( sTmp, nTemp, aAnimations_EnumMap_SubItem );
+                mxExport->AddAttribute( XML_NAMESPACE_ANIMATION, XML_SUB_ITEM, sTmp.makeStringAndClear() );
+            }
+
+            nTemp = xIter->getIterateType();
+            if( nTemp )
+            {
+                SvXMLUnitConverter::convertEnum( sTmp, nTemp, aAnimations_EnumMap_IterateType );
+                mxExport->AddAttribute( XML_NAMESPACE_ANIMATION, XML_ITERATE_TYPE, sTmp.makeStringAndClear() );
+            }
+
+            double fTemp = xIter->getIterateInterval();
+            if( fTemp )
+            {
+                OUStringBuffer buf;
+                ::sax::Converter::convertDuration(buf, fTemp / (24*60*60));
+                mxExport->AddAttribute( XML_NAMESPACE_ANIMATION,
+                        XML_ITERATE_INTERVAL, buf.makeStringAndClear());
+            }
+        }
+
+        XMLTokenEnum eElementToken;
+        switch( nNodeType )
+        {
+        case AnimationNodeType::PAR:    eElementToken = XML_PAR; break;
+        case AnimationNodeType::SEQ:    eElementToken = XML_SEQ; break;
+        case AnimationNodeType::ITERATE:eElementToken = XML_ITERATE; break;
+        default:
+            OSL_FAIL( "xmloff::AnimationsExporterImpl::exportContainer(), invalid TimeContainerType!" );
+            return;
+        }
+        SvXMLElementExport aElement( *mxExport, XML_NAMESPACE_ANIMATION, eElementToken, true, true );
+
+        if( nContainerNodeType == EffectNodeType::TIMING_ROOT )
+            exportTransitionNode();
+
+        Reference< XEnumerationAccess > xEnumerationAccess( xContainer, UNO_QUERY_THROW );
+        Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), css::uno::UNO_SET_THROW );
+        while( xEnumeration->hasMoreElements() )
+        {
+            Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
+            exportNode( xChildNode );
+        }
+    }
+    catch (const RuntimeException&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw", "");
+    }
+}
+
+void AnimationsExporterImpl::exportAnimate( const Reference< XAnimate >& xAnimate )
+{
+    try
+    {
+        const sal_Int16 nNodeType = xAnimate->getType();
+
+        OUStringBuffer sTmp;
+        sal_Int16 nTemp;
+        bool bTemp;
+
+        Any aTemp( xAnimate->getTarget() );
+        if( aTemp.hasValue() )
+        {
+            convertTarget( sTmp, aTemp );
+            mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_TARGETELEMENT, sTmp.makeStringAndClear() );
+        }
+
+        nTemp = xAnimate->getSubItem();
+        if( nTemp )
+        {
+            SvXMLUnitConverter::convertEnum( sTmp, nTemp, aAnimations_EnumMap_SubItem );
+            mxExport->AddAttribute( XML_NAMESPACE_ANIMATION, XML_SUB_ITEM, sTmp.makeStringAndClear() );
+        }
+
+        XMLTokenEnum eAttributeName = XML_TOKEN_INVALID;
+
+        if( nNodeType == AnimationNodeType::TRANSITIONFILTER )
+        {
+            eAttributeName = XML_TRANSITIONFILTER;
+        }
+        else if( nNodeType == AnimationNodeType::ANIMATETRANSFORM )
+        {
+            eAttributeName = XML_ANIMATETRANSFORM;
+        }
+        else if( nNodeType == AnimationNodeType::ANIMATEMOTION )
+        {
+            eAttributeName = XML_ANIMATEMOTION;
+        }
+        else if( nNodeType == AnimationNodeType::ANIMATEPHYSICS )
+        {
+            eAttributeName = XML_ANIMATEPHYSICS;
+        }
+        else
+        {
+            OUString sTemp( xAnimate->getAttributeName() );
+            if( !sTemp.isEmpty() )
+            {
+                const struct ImplAttributeNameConversion* p = getAnimationAttributeNamesConversionList();
+                while( p->mpAPIName )
+                {
+                    if( sTemp.equalsAscii( p->mpAPIName ) )
+                    {
+                        sTemp = GetXMLToken( p->meXMLToken );
+                        eAttributeName = p->meXMLToken;
+                        break;
+                    }
+
+                    p++;
+                }
+
+                mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_ATTRIBUTENAME, sTemp );
+            }
+            else
+            {
+                mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_ATTRIBUTENAME, "invalid" );
+            }
+        }
+
+        Sequence< Any > aValues( xAnimate->getValues() );
+        if( aValues.hasElements() )
+        {
+            aTemp <<= aValues;
+            convertValue( eAttributeName, sTmp, aTemp );
+            mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_VALUES, sTmp.makeStringAndClear() );
+        }
+        else
+        {
+            aTemp = xAnimate->getFrom();
+            if( aTemp.hasValue() )
+            {
+                convertValue( eAttributeName, sTmp, aTemp );
+                mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_FROM, sTmp.makeStringAndClear() );
+            }
+
+            aTemp = xAnimate->getBy();
+            if( aTemp.hasValue() )
+            {
+                convertValue( eAttributeName, sTmp, aTemp );
+                mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_BY, sTmp.makeStringAndClear() );
+            }
+
+            aTemp = xAnimate->getTo();
+            if( aTemp.hasValue() )
+            {
+                convertValue( eAttributeName, sTmp, aTemp );
+                mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_TO, sTmp.makeStringAndClear() );
+            }
+        }
+
+        if(nNodeType != AnimationNodeType::SET)
+        {
+            const Sequence< double > aKeyTimes( xAnimate->getKeyTimes() );
+            if( aKeyTimes.hasElements() )
+            {
+                for( const auto& rKeyTime : aKeyTimes )
+                {
+                    if( !sTmp.isEmpty() )
+                        sTmp.append( ';' );
+
+                    sTmp.append( rKeyTime );
+                }
+                mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_KEYTIMES, sTmp.makeStringAndClear() );
+            }
+
+            OUString sTemp( xAnimate->getFormula() );
+            if( !sTemp.isEmpty() )
+                mxExport->AddAttribute( XML_NAMESPACE_ANIMATION, XML_FORMULA, sTemp );
+
+            if( (nNodeType != AnimationNodeType::TRANSITIONFILTER) &&
+                (nNodeType != AnimationNodeType::AUDIO ) )
+            {
+                // calcMode  = "discrete | linear | paced | spline"
+                nTemp = xAnimate->getCalcMode();
+                if( ((nNodeType == AnimationNodeType::ANIMATEMOTION ) && (nTemp != AnimationCalcMode::PACED)) ||
+                    ((nNodeType != AnimationNodeType::ANIMATEMOTION ) && (nTemp != AnimationCalcMode::LINEAR)) )
+                {
+                    SvXMLUnitConverter::convertEnum( sTmp, nTemp, aAnimations_EnumMap_CalcMode );
+                    mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_CALCMODE, sTmp.makeStringAndClear() );
+                }
+
+                bTemp = xAnimate->getAccumulate();
+                if( bTemp )
+                    mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_ACCUMULATE, XML_SUM );
+
+                nTemp = xAnimate->getAdditive();
+                if( nTemp != AnimationAdditiveMode::REPLACE )
+                {
+                    SvXMLUnitConverter::convertEnum( sTmp, nTemp, aAnimations_EnumMap_AdditiveMode );
+                    mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_ADDITIVE, sTmp.makeStringAndClear() );
+                }
+            }
+
+            const Sequence< TimeFilterPair > aTimeFilter( xAnimate->getTimeFilter() );
+            if( aTimeFilter.hasElements() )
+            {
+                for( const auto& rPair : aTimeFilter )
+                {
+                    if( !sTmp.isEmpty() )
+                        sTmp.append( ';' );
+
+                    sTmp.append(OUString::number(rPair.Time) + "," + OUString::number(rPair.Progress));
+                }
+
+                mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_KEYSPLINES, sTmp.makeStringAndClear() );
+            }
+        }
+
+        XMLTokenEnum eElementToken = XML_ANIMATE;
+
+        switch( nNodeType )
+        {
+        case AnimationNodeType::ANIMATE:
+            eElementToken = XML_ANIMATE;
+            break;
+
+        case AnimationNodeType::SET:
+            eElementToken = XML_SET;
+            break;
+
+        case AnimationNodeType::ANIMATEMOTION:
+        {
+            eElementToken = XML_ANIMATEMOTION;
+
+            Reference< XAnimateMotion > xAnimateMotion( xAnimate, UNO_QUERY_THROW );
+
+            aTemp = xAnimateMotion->getPath();
+            if( aTemp.hasValue() )
+            {
+                convertPath( sTmp, aTemp );
+                mxExport->AddAttribute( XML_NAMESPACE_SVG, XML_PATH, sTmp.makeStringAndClear() );
+            }
+
+            // TODO: origin = ( parent | layout )
+            aTemp = xAnimateMotion->getOrigin();
+        }
+        break;
+
+        case AnimationNodeType::ANIMATEPHYSICS:
+        {
+            eElementToken = XML_ANIMATEPHYSICS;
+            double fTemp = 0;
+
+            Reference< XAnimatePhysics > xAnimatePhysics( xAnimate, UNO_QUERY_THROW );
+            aTemp = xAnimatePhysics->getStartVelocityX();
+            if( aTemp.hasValue() )
+            {
+                aTemp >>= fTemp;
+                ::sax::Converter::convertDouble( sTmp, fTemp );
+                mxExport->AddAttribute( XML_NAMESPACE_LO_EXT, XML_PHYSICS_ANIMATION_START_VELOCITY_X, sTmp.makeStringAndClear() );
+            }
+
+            aTemp = xAnimatePhysics->getStartVelocityY();
+            if( aTemp.hasValue() )
+            {
+                aTemp >>= fTemp;
+                ::sax::Converter::convertDouble( sTmp, fTemp );
+                mxExport->AddAttribute( XML_NAMESPACE_LO_EXT, XML_PHYSICS_ANIMATION_START_VELOCITY_Y, sTmp.makeStringAndClear() );
+            }
+
+            aTemp = xAnimatePhysics->getDensity();
+            if( aTemp.hasValue() )
+            {
+                aTemp >>= fTemp;
+                ::sax::Converter::convertDouble( sTmp, fTemp );
+                mxExport->AddAttribute( XML_NAMESPACE_LO_EXT, XML_PHYSICS_ANIMATION_DENSITY, sTmp.makeStringAndClear() );
+            }
+
+            aTemp = xAnimatePhysics->getBounciness();
+            if( aTemp.hasValue() )
+            {
+                aTemp >>= fTemp;
+                ::sax::Converter::convertDouble( sTmp, fTemp );
+                mxExport->AddAttribute( XML_NAMESPACE_LO_EXT, XML_PHYSICS_ANIMATION_BOUNCINESS, sTmp.makeStringAndClear() );
+            }
+        }
+        break;
+
+        case AnimationNodeType::ANIMATECOLOR:
+        {
+            eElementToken = XML_ANIMATECOLOR;
+
+            Reference< XAnimateColor > xAnimateColor( xAnimate, UNO_QUERY_THROW );
+
+            nTemp = xAnimateColor->getColorInterpolation();
+            mxExport->AddAttribute( XML_NAMESPACE_ANIMATION, XML_COLOR_INTERPOLATION, (nTemp == AnimationColorSpace::RGB) ? XML_RGB : XML_HSL );
+
+            bTemp = xAnimateColor->getDirection();
+            mxExport->AddAttribute( XML_NAMESPACE_ANIMATION, XML_COLOR_INTERPOLATION_DIRECTION, bTemp ? XML_CLOCKWISE : XML_COUNTER_CLOCKWISE );
+        }
+        break;
+
+        case AnimationNodeType::ANIMATETRANSFORM:
+        {
+            eElementToken = XML_ANIMATETRANSFORM;
+
+            mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_ATTRIBUTENAME, XML_TRANSFORM );
+
+            Reference< XAnimateTransform > xTransform( xAnimate, UNO_QUERY_THROW );
+            nTemp = xTransform->getTransformType();
+            SvXMLUnitConverter::convertEnum( sTmp, nTemp, aAnimations_EnumMap_TransformType );
+            mxExport->AddAttribute( XML_NAMESPACE_SVG, XML_TYPE, sTmp.makeStringAndClear() );
+        }
+        break;
+
+        case AnimationNodeType::TRANSITIONFILTER:
+        {
+            Reference< XTransitionFilter > xTransitionFilter( xAnimate, UNO_QUERY );
+            eElementToken = XML_TRANSITIONFILTER;
+
+            sal_Int16 nTransition = xTransitionFilter->getTransition();
+            SvXMLUnitConverter::convertEnum( sTmp, nTransition, aAnimations_EnumMap_TransitionType );
+            mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_TYPE, sTmp.makeStringAndClear() );
+
+            sal_Int16 nSubtype = xTransitionFilter->getSubtype();
+            if( nSubtype != TransitionSubType::DEFAULT )
+            {
+                SvXMLUnitConverter::convertEnum( sTmp, nSubtype, aAnimations_EnumMap_TransitionSubType );
+                mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_SUBTYPE, sTmp.makeStringAndClear() );
+            }
+
+            bTemp = xTransitionFilter->getMode();
+            if( !bTemp )
+                mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_MODE, XML_OUT );
+
+            bTemp = xTransitionFilter->getDirection();
+            if( !bTemp )
+                mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_DIRECTION, XML_REVERSE );
+
+            if( (nTransition == TransitionType::FADE) && ((nSubtype == TransitionSubType::FADETOCOLOR) || (nSubtype == TransitionSubType::FADEFROMCOLOR) ))
+            {
+                nTemp = xTransitionFilter->getFadeColor();
+                ::sax::Converter::convertColor( sTmp, nTemp );
+                mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_FADECOLOR, sTmp.makeStringAndClear() );
+            }
+        }
+        break;
+        }
+
+        if( eElementToken == XML_ANIMATEPHYSICS ) // not a standard should use the extension namespace
+        {
+            SvXMLElementExport aElement( *mxExport, XML_NAMESPACE_LO_EXT, eElementToken, true, true );
+        }
+        else
+        {
+            SvXMLElementExport aElement( *mxExport, XML_NAMESPACE_ANIMATION, eElementToken, true, true );
+        }
+
+    }
+    catch (const Exception&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw", "");
+    }
+}
+
+void AnimationsExporterImpl::exportAudio( const Reference< XAudio >& xAudio )
+{
+    if( !xAudio.is() )
+        return;
+
+    try
+    {
+        OUString aSourceURL;
+        xAudio->getSource() >>= aSourceURL;
+        if( !aSourceURL.isEmpty() )
+            mxExport->AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, mxExport->GetRelativeReference( aSourceURL ) );
+
+        const double fVolume = xAudio->getVolume();
+        if( fVolume != 1.0 )
+        {
+            OUStringBuffer sTmp;
+            ::sax::Converter::convertDouble( sTmp, fVolume );
+            mxExport->AddAttribute( XML_NAMESPACE_ANIMATION, XML_AUDIO_LEVEL, sTmp.makeStringAndClear() );
+        }
+
+    /* todo?
+       sal_Int32 nEndAfterSlide = 0;
+        xAudio->getEndAfterSlide() >>= nEndAfterSlide;
+        if( nEndAfterSlide != 0 )
+            mxExport->AddAttribute( );
+    */
+        SvXMLElementExport aElement( *mxExport, XML_NAMESPACE_ANIMATION, XML_AUDIO, true, true );
+
+    }
+    catch (const Exception&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw", "");
+    }
+}
+
+void AnimationsExporterImpl::exportCommand( const Reference< XCommand >& xCommand )
+{
+    if( !xCommand.is() )
+        return;
+
+    try
+    {
+        OUStringBuffer sTmp;
+        Any aTemp( xCommand->getTarget() );
+        if( aTemp.hasValue() )
+        {
+            convertTarget( sTmp, aTemp );
+            mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_TARGETELEMENT, sTmp.makeStringAndClear() );
+        }
+
+        sal_Int16 nCommand = xCommand->getCommand();
+        SvXMLUnitConverter::convertEnum( sTmp, nCommand, aAnimations_EnumMap_Command );
+        mxExport->AddAttribute( XML_NAMESPACE_ANIMATION, XML_COMMAND, sTmp.makeStringAndClear() );
+
+    // todo virtual css::uno::Any SAL_CALL getParameter() throw (css::uno::RuntimeException) = 0;
+
+        SvXMLElementExport aElement( *mxExport, XML_NAMESPACE_ANIMATION, XML_COMMAND, true, true );
+
+    }
+    catch (const Exception&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw", "");
+    }
+}
+
+Reference< XInterface > AnimationsExporterImpl::getParagraphTarget( const ParagraphTarget& pTarget )
+{
+    try
+    {
+        Reference< XEnumerationAccess > xParaEnumAccess( pTarget.Shape, UNO_QUERY_THROW );
+
+        Reference< XEnumeration > xEnumeration( xParaEnumAccess->createEnumeration(), css::uno::UNO_SET_THROW );
+        sal_Int32 nParagraph = pTarget.Paragraph;
+
+        while( xEnumeration->hasMoreElements() )
+        {
+            Reference< XInterface > xRef( xEnumeration->nextElement(), UNO_QUERY );
+            if( nParagraph-- == 0 )
+                return xRef;
+        }
+    }
+    catch (const RuntimeException&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw", "");
+    }
+
+    Reference< XInterface > xRef;
+    return xRef;
+}
+
+void AnimationsExporterImpl::convertPath( OUStringBuffer& sTmp, const Any& rPath )
+{
+    OUString aStr;
+    rPath >>= aStr;
+
+    sTmp = aStr;
+}
+
+void AnimationsExporterImpl::convertValue( XMLTokenEnum eAttributeName, OUStringBuffer& sTmp, const Any& rValue ) const
+{
+    if( !rValue.hasValue() )
+        return;
+
+    if( auto pValuePair = o3tl::tryAccess<ValuePair>(rValue) )
+    {
+        OUStringBuffer sTmp2;
+        convertValue( eAttributeName, sTmp, pValuePair->First );
+        sTmp.append( ',' );
+        convertValue( eAttributeName, sTmp2, pValuePair->Second );
+        sTmp.append( sTmp2 );
+    }
+    else if( auto pSequence = o3tl::tryAccess<Sequence<Any>>(rValue) )
+    {
+        const sal_Int32 nLength = pSequence->getLength();
+        sal_Int32 nElement;
+        const Any* pAny = pSequence->getConstArray();
+
+        OUStringBuffer sTmp2;
+
+        for( nElement = 0; nElement < nLength; nElement++, pAny++ )
+        {
+            if( !sTmp.isEmpty() )
+                sTmp.append( ';' );
+            convertValue( eAttributeName, sTmp2, *pAny );
+            sTmp.append( sTmp2 );
+            sTmp2.setLength(0);
+        }
+    }
+    else
+    {
+        sal_Int32 nType;
+
+        switch( eAttributeName )
+        {
+        case XML_X:
+        case XML_Y:
+        case XML_WIDTH:
+        case XML_HEIGHT:
+        case XML_ANIMATETRANSFORM:
+        case XML_ANIMATEMOTION:
+        case XML_ANIMATEPHYSICS:
+        {
+            if( auto aString = o3tl::tryAccess<OUString>(rValue) )
+            {
+                sTmp.append( *aString );
+            }
+            else if( auto x = o3tl::tryAccess<double>(rValue) )
+            {
+                sTmp.append( *x );
+            }
+            else
+            {
+                OSL_FAIL( "xmloff::AnimationsExporterImpl::convertValue(), invalid value type!" );
+            }
+            return;
+        }
+
+        case XML_SKEWX:
+        case XML_ROTATE:            nType = XML_TYPE_DOUBLE;                    break;
+        case XML_TEXT_ROTATION_ANGLE: nType = XML_TYPE_NUMBER16;                break;
+        case XML_FILL_COLOR:
+        case XML_STROKE_COLOR:
+        case XML_DIM:
+        case XML_COLOR:             nType = XML_TYPE_COLOR;                     break;
+        case XML_FILL:              nType = XML_SD_TYPE_FILLSTYLE;              break;
+        case XML_STROKE:            nType = XML_SD_TYPE_STROKE;                 break;
+        case XML_FONT_WEIGHT:       nType = XML_TYPE_TEXT_WEIGHT;               break;
+        case XML_FONT_STYLE:        nType = XML_TYPE_TEXT_POSTURE;              break;
+        case XML_TEXT_UNDERLINE:    nType = XML_TYPE_TEXT_UNDERLINE_STYLE;      break;
+        case XML_FONT_SIZE:         nType = XML_TYPE_DOUBLE_PERCENT;            break;
+        case XML_VISIBILITY:        nType = XML_SD_TYPE_PRESPAGE_VISIBILITY;    break;
+        case XML_OPACITY:
+        case XML_TRANSITIONFILTER:  nType = XML_TYPE_DOUBLE;                    break;
+        default:
+            OSL_FAIL( "xmloff::AnimationsExporterImpl::convertValue(), invalid AttributeName!" );
+            nType = XML_TYPE_STRING;
+        }
+
+        //const XMLPropertyHandler* pHandler = static_cast<SdXMLExport*>(&mrExport)->GetSdPropHdlFactory()->GetPropertyHandler( nType );
+        const XMLPropertyHandler* pHandler = mxSdPropHdlFactory->GetPropertyHandler( nType );
+        if( pHandler )
+        {
+            OUString aString;
+            pHandler->exportXML( aString, rValue, mxExport->GetMM100UnitConverter() );
+            sTmp.append( aString );
+        }
+    }
+}
+
+void AnimationsExporterImpl::convertTiming( OUStringBuffer& sTmp, const Any& rValue ) const
+{
+    if( !rValue.hasValue() )
+        return;
+
+    if( auto pSequence = o3tl::tryAccess<Sequence<Any>>(rValue) )
+    {
+        const sal_Int32 nLength = pSequence->getLength();
+        sal_Int32 nElement;
+        const Any* pAny = pSequence->getConstArray();
+
+        OUStringBuffer sTmp2;
+
+        for( nElement = 0; nElement < nLength; nElement++, pAny++ )
+        {
+            if( !sTmp.isEmpty() )
+                sTmp.append( ';' );
+            convertTiming( sTmp2, *pAny );
+            sTmp.append( sTmp2 );
+            sTmp2.setLength(0);
+        }
+    }
+    else if( auto x = o3tl::tryAccess<double>(rValue) )
+    {
+        sTmp.append( *x );
+        sTmp.append( 's');
+    }
+    else if( auto pTiming = o3tl::tryAccess<Timing>(rValue) )
+    {
+        sTmp.append( GetXMLToken( (*pTiming == Timing_MEDIA) ? XML_MEDIA : XML_INDEFINITE ) );
+    }
+    else if( auto pEvent = o3tl::tryAccess<Event>(rValue) )
+    {
+        OUStringBuffer sTmp2;
+
+        if( pEvent->Trigger != EventTrigger::NONE )
+        {
+            if( pEvent->Source.hasValue() )
+            {
+                convertTarget( sTmp, pEvent->Source );
+                sTmp.append( '.' );
+            }
+
+            SvXMLUnitConverter::convertEnum( sTmp2, pEvent->Trigger, aAnimations_EnumMap_EventTrigger );
+
+            sTmp.append( sTmp2 );
+            sTmp2.setLength(0);
+        }
+
+        if( pEvent->Offset.hasValue() )
+        {
+            convertTiming( sTmp2, pEvent->Offset );
+
+            if( !sTmp.isEmpty() )
+                sTmp.append( '+' );
+
+            sTmp.append( sTmp2 );
+            sTmp2.setLength(0);
+        }
+    }
+    else
+    {
+        OSL_FAIL( "xmloff::AnimationsExporterImpl::convertTiming(), invalid value type!" );
+    }
+}
+
+void AnimationsExporterImpl::convertTarget( OUStringBuffer& sTmp, const Any& rTarget ) const
+{
+    if( !rTarget.hasValue() )
+        return;
+
+    Reference< XInterface > xRef;
+
+    if( !(rTarget >>= xRef) )
+    {
+        if( auto pt = o3tl::tryAccess<ParagraphTarget>(rTarget) )
+        {
+            xRef = getParagraphTarget( *pt );
+        }
+    }
+
+    SAL_WARN_IF( !xRef.is(), "xmloff", "xmloff::AnimationsExporterImpl::convertTarget(), invalid target type!" );
+    if( xRef.is() )
+    {
+        const OUString& rIdentifier = mxExport->getInterfaceToIdentifierMapper().getIdentifier(xRef);
+        if( !rIdentifier.isEmpty() )
+            sTmp.append( rIdentifier );
+    }
+}
+
+void AnimationsExporterImpl::prepareValue( const Any& rValue )
+{
+    if( !rValue.hasValue() )
+        return;
+
+    if( auto pValuePair = o3tl::tryAccess<ValuePair>(rValue) )
+    {
+        prepareValue( pValuePair->First );
+        prepareValue( pValuePair->Second );
+    }
+    else if( auto pSequence = o3tl::tryAccess<Sequence<Any>>(rValue) )
+    {
+        const sal_Int32 nLength = pSequence->getLength();
+        sal_Int32 nElement;
+        const Any* pAny = pSequence->getConstArray();
+
+        for( nElement = 0; nElement < nLength; nElement++, pAny++ )
+            prepareValue( *pAny );
+    }
+    else if( rValue.getValueTypeClass() == css::uno::TypeClass_INTERFACE )
+    {
+        Reference< XInterface> xRef( rValue, UNO_QUERY );
+        if( xRef.is() )
+            mxExport->getInterfaceToIdentifierMapper().registerReference( xRef );
+    }
+    else if( auto pt = o3tl::tryAccess<ParagraphTarget>(rValue) )
+    {
+        Reference< XInterface> xRef( getParagraphTarget( *pt ) );
+        if( xRef.is() )
+            mxExport->getInterfaceToIdentifierMapper().registerReference( xRef );
+    }
+    else if( auto pEvent = o3tl::tryAccess<Event>(rValue) )
+    {
+        prepareValue( pEvent->Source );
+    }
+}
+
+AnimationsExporter::AnimationsExporter( SvXMLExport& rExport, const Reference< XPropertySet >& xPageProps )
+    : mpImpl( new AnimationsExporterImpl( rExport, xPageProps ) )
+{
+}
+
+AnimationsExporter::~AnimationsExporter()
+{
+}
+
+void AnimationsExporter::prepare( const Reference< XAnimationNode >& xRootNode )
+{
+    try
+    {
+        if( xRootNode.is() )
+        {
+            mpImpl->prepareTransitionNode();
+            mpImpl->prepareNode( xRootNode );
+        }
+    }
+    catch (const RuntimeException&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw", "");
+    }
+}
+
+void AnimationsExporter::exportAnimations( const Reference< XAnimationNode >& xRootNode )
+{
+    try
+    {
+        if( xRootNode.is() )
+        {
+            bool bHasEffects = mpImpl->mbHasTransition;
+
+            if( !bHasEffects )
+            {
+                // first check if there are no animations
+                Reference< XEnumerationAccess > xEnumerationAccess( xRootNode, UNO_QUERY_THROW );
+                Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), css::uno::UNO_SET_THROW );
+                if( xEnumeration->hasMoreElements() )
+                {
+                    // first child node may be an empty main sequence, check this
+                    Reference< XAnimationNode > xMainNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
+                    Reference< XEnumerationAccess > xMainEnumerationAccess( xMainNode, UNO_QUERY_THROW );
+                    Reference< XEnumeration > xMainEnumeration( xMainEnumerationAccess->createEnumeration(), css::uno::UNO_SET_THROW );
+
+                    // only export if the main sequence is not empty or if there are additional
+                    // trigger sequences
+                    bHasEffects = xMainEnumeration->hasMoreElements() || xEnumeration->hasMoreElements();
+                }
+            }
+
+            if( bHasEffects )
+                mpImpl->exportNode( xRootNode );
+        }
+    }
+    catch (const RuntimeException&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw", "");
+    }
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/animationimport.cxx b/xmloff/source/draw/animationimport.cxx
new file mode 100644
index 000000000..826b4b0a0
--- /dev/null
+++ b/xmloff/source/draw/animationimport.cxx
@@ -0,0 +1,1357 @@
+/* -*- 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 <memory>
+#include <xmloff/unointerfacetouniqueidentifiermapper.hxx>
+#include <com/sun/star/lang/XInitialization.hpp>
+#include <com/sun/star/animations/AnimationTransformType.hpp>
+#include <com/sun/star/animations/XAnimationNodeSupplier.hpp>
+#include <com/sun/star/animations/AnimationNodeType.hpp>
+#include <com/sun/star/animations/SequenceTimeContainer.hpp>
+#include <com/sun/star/animations/XIterateContainer.hpp>
+#include <com/sun/star/animations/XAnimateMotion.hpp>
+#include <com/sun/star/animations/XAnimatePhysics.hpp>
+#include <com/sun/star/animations/XAnimateColor.hpp>
+#include <com/sun/star/animations/XAnimateTransform.hpp>
+#include <com/sun/star/animations/XTransitionFilter.hpp>
+#include <com/sun/star/animations/XCommand.hpp>
+#include <com/sun/star/animations/XAudio.hpp>
+#include <com/sun/star/animations/ValuePair.hpp>
+#include <com/sun/star/animations/AnimationColorSpace.hpp>
+#include <com/sun/star/presentation/EffectPresetClass.hpp>
+#include <com/sun/star/animations/Timing.hpp>
+#include <com/sun/star/animations/Event.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/io/WrongFormatException.hpp>
+#include <com/sun/star/xml/sax/XFastAttributeList.hpp>
+#include <com/sun/star/text/XTextCursor.hpp>
+#include <com/sun/star/text/XTextRangeCompare.hpp>
+#include <com/sun/star/presentation/ParagraphTarget.hpp>
+#include <com/sun/star/container/XEnumerationAccess.hpp>
+#include <com/sun/star/animations/EventTrigger.hpp>
+#include <com/sun/star/presentation/EffectCommands.hpp>
+#include <com/sun/star/util/Duration.hpp>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/string.hxx>
+
+#include <rtl/math.h>
+#include <sal/log.hxx>
+#include <tools/diagnose_ex.h>
+#include <o3tl/string_view.hxx>
+#include <sax/tools/converter.hxx>
+
+#include <vector>
+
+#include <xmloff/xmltypes.hxx>
+#include "sdpropls.hxx"
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlprhdl.hxx>
+#include <xmlsdtypes.hxx>
+
+#include <animations.hxx>
+#include <animationimport.hxx>
+
+using namespace ::std;
+using namespace ::cppu;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::animations;
+using namespace ::com::sun::star::presentation;
+using namespace ::com::sun::star::drawing;
+using namespace ::com::sun::star::uno;
+using namespace ::xmloff::token;
+
+using ::com::sun::star::xml::sax::XFastAttributeList;
+using ::com::sun::star::beans::NamedValue;
+using ::com::sun::star::text::XTextRange;
+using ::com::sun::star::text::XTextCursor;
+using ::com::sun::star::text::XTextRangeCompare;
+using ::com::sun::star::container::XEnumerationAccess;
+using ::com::sun::star::container::XEnumeration;
+using ::com::sun::star::lang::XInitialization;
+
+static OUString
+lcl_GetMediaReference(SvXMLImport const& rImport, OUString const& rURL)
+{
+    if (rImport.IsPackageURL(rURL))
+        return "vnd.sun.star.Package:" + rURL;
+
+    return rImport.GetAbsoluteReference(rURL);
+}
+
+namespace xmloff
+{
+
+class AnimationsImportHelperImpl
+{
+private:
+    SvXMLImport& mrImport;
+
+public:
+    explicit AnimationsImportHelperImpl( SvXMLImport& rImport );
+
+    Any convertValue( XMLTokenEnum eAttributeName, const OUString& rValue );
+    Sequence< Any > convertValueSequence( XMLTokenEnum eAttributeName, std::u16string_view rValue );
+
+    Any convertTarget( const OUString& rValue );
+    static Any convertPath( const OUString& rValue );
+    Any convertTiming( const OUString& rValue );
+    static Sequence< double > convertKeyTimes( std::string_view rValue );
+    static Sequence< TimeFilterPair > convertTimeFilter( std::string_view rValue );
+};
+
+AnimationsImportHelperImpl::AnimationsImportHelperImpl( SvXMLImport& rImport )
+:   mrImport( rImport )
+{
+}
+
+static bool isDouble( std::string_view rValue )
+{
+    sal_Int32 nLength = rValue.size();
+    const char * pStr = rValue.data();
+    while( nLength )
+    {
+        if( (*pStr >= '0' && *pStr <= '9') || *pStr == '-' || *pStr == '.' || *pStr == '+' || *pStr == 'e' || *pStr == 'E' )
+        {
+            pStr++;
+            nLength--;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+static bool isTime( const OUString& rValue )
+{
+    sal_Int32 nLength = rValue.getLength();
+    const sal_Unicode * pStr;
+    for( pStr = rValue.getStr(); nLength; pStr++, nLength-- )
+    {
+        if( !( (*pStr >= '0' && *pStr <= '9') || *pStr == '-' || *pStr == '.' || *pStr == '+' || *pStr == 'e' || *pStr == 'E' ) )
+            break;
+    }
+
+    // return true if this is a double (if someone forgot the 's' we silently ignore it)
+    // or if it's a double that ends with a 's' or 'S'
+    return (nLength == 0) || ((*pStr == 's' || *pStr == 'S') && (nLength == 1));
+}
+
+Any AnimationsImportHelperImpl::convertTarget( const OUString& rValue )
+{
+    try
+    {
+        Reference< XInterface > xRef( mrImport.getInterfaceToIdentifierMapper().getReference( rValue ) );
+
+        Reference< XShape > _xShape( xRef, UNO_QUERY );
+        if( _xShape.is() )
+            return Any( _xShape );
+
+        Reference< XTextCursor > xTextCursor( xRef, UNO_QUERY );
+        if( xTextCursor.is() )
+        {
+            Reference< XTextRange > xStart( xTextCursor->getStart() ), xRange;
+            Reference< XShape > xShape( xTextCursor->getText(), UNO_QUERY_THROW );
+            Reference< XTextRangeCompare > xTextRangeCompare( xShape, UNO_QUERY_THROW );
+
+            Reference< XEnumerationAccess > xParaEnumAccess( xShape, UNO_QUERY_THROW );
+            Reference< XEnumeration > xEnumeration( xParaEnumAccess->createEnumeration(), UNO_SET_THROW );
+            sal_Int16 nParagraph = 0;
+
+            while( xEnumeration->hasMoreElements() )
+            {
+                xEnumeration->nextElement() >>= xRange;
+
+                // break if start of selection is prior to end of current paragraph
+                if( xRange.is() && (xTextRangeCompare->compareRegionEnds( xStart, xRange ) >= 0 ) )
+                {
+                    return Any( ParagraphTarget( xShape, nParagraph ) );
+                }
+
+                nParagraph++;
+            }
+        }
+    }
+    catch (const RuntimeException&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw", "");
+    }
+
+    Any aAny;
+    return aAny;
+}
+
+Any AnimationsImportHelperImpl::convertValue( XMLTokenEnum eAttributeName, const OUString& rValue )
+{
+    sal_Int32 nCommaPos = -1, nPos;
+    sal_Int32 nOpenBrackets = 0;
+    for( nPos = 0; (nPos < rValue.getLength()) && (nCommaPos == -1); nPos++ )
+    {
+        switch( rValue[nPos] )
+        {
+        case ',':
+            if( nOpenBrackets == 0 )
+                nCommaPos = nPos;
+            break;
+        case '(':
+        case '[':
+        case '{':
+            nOpenBrackets++;
+            break;
+        case ')':
+        case ']':
+        case '}':
+            nOpenBrackets--;
+            break;
+        }
+    }
+
+    if( nCommaPos >= 0 )
+    {
+        ValuePair aPair;
+        aPair.First = convertValue( eAttributeName, rValue.copy( 0, nCommaPos ) );
+        aPair.Second = convertValue( eAttributeName, rValue.copy( nCommaPos+1 ) );
+        return Any( aPair );
+    }
+    else
+    {
+        Any aAny;
+        sal_Int32 nType = XML_TYPE_STRING;
+
+        if( rValue.getLength() ) switch( eAttributeName )
+        {
+        case XML_X:
+        case XML_Y:
+        case XML_WIDTH:
+        case XML_HEIGHT:
+        case XML_TRANSLATE:
+        {
+            return Any( rValue );
+        }
+
+        case XML_SCALE:
+        case XML_SKEWY:
+        case XML_SKEWX:
+        case XML_OPACITY:
+        case XML_ROTATE:            nType = XML_TYPE_DOUBLE;                    break;
+        case XML_TEXT_ROTATION_ANGLE:nType = XML_TYPE_TEXT_ROTATION_ANGLE;      break;
+        case XML_FILL_COLOR:
+        case XML_STROKE_COLOR:
+        case XML_DIM:
+        case XML_COLOR:             nType = XML_TYPE_COLOR;                     break;
+        case XML_FILL:              nType = XML_SD_TYPE_FILLSTYLE;              break;
+        case XML_STROKE:            nType = XML_SD_TYPE_STROKE;                 break;
+        case XML_FONT_WEIGHT:       nType = XML_TYPE_TEXT_WEIGHT;               break;
+        case XML_FONT_STYLE:        nType = XML_TYPE_TEXT_POSTURE;              break;
+        case XML_TEXT_UNDERLINE:    nType = XML_TYPE_TEXT_UNDERLINE_STYLE;      break;
+        case XML_FONT_SIZE:         nType = XML_TYPE_DOUBLE_PERCENT;            break;
+        case XML_VISIBILITY:        nType = XML_SD_TYPE_PRESPAGE_VISIBILITY;    break;
+
+        default:
+            if( !rValue.isEmpty() )
+                aAny <<= rValue;
+            return aAny;
+        }
+
+        const XMLPropertyHandler* pHandler = mrImport.GetShapeImport()->GetSdPropHdlFactory()->GetPropertyHandler( nType );
+        if( pHandler )
+            pHandler->importXML( rValue, aAny, mrImport.GetMM100UnitConverter() );
+
+        return aAny;
+    }
+}
+
+Sequence< Any > AnimationsImportHelperImpl::convertValueSequence( XMLTokenEnum eAttributeName, std::u16string_view rValue )
+{
+    Sequence< Any > aValues;
+
+    const sal_Int32 nElements { comphelper::string::getTokenCount(rValue, ';') };
+    if ( nElements>0 )
+    {
+        // prepare the sequence
+        aValues.realloc( nElements );
+
+        // fill the sequence
+        Any* pValues = aValues.getArray();
+        for (sal_Int32 nIndex = 0; nIndex >= 0; )
+            *pValues++ = convertValue( eAttributeName, OUString(o3tl::getToken(rValue, 0, ';', nIndex )) );
+    }
+
+    return aValues;
+}
+
+Any AnimationsImportHelperImpl::convertTiming( const OUString& rValue )
+{
+    Any aAny;
+
+    const sal_Int32 nElements { comphelper::string::getTokenCount(rValue, ';') };
+    if ( nElements>0 )
+    {
+        if( nElements == 1 )
+        {
+            if( IsXMLToken( rValue, XML_MEDIA ) )
+            {
+                aAny <<= Timing_MEDIA;
+            }
+            else if( IsXMLToken( rValue, XML_INDEFINITE ) )
+            {
+                aAny <<= Timing_INDEFINITE;
+            }
+            else if( isTime( rValue ) )
+            {
+                aAny <<= rValue.toDouble();
+            }
+            else
+            {
+                Event aEvent;
+                aEvent.Repeat = 0;
+                aEvent.Trigger = 0;
+
+                OUString aEventTrigger;
+
+                sal_Int32 nPos = rValue.indexOf( '+' );
+                if( nPos == -1 )
+                {
+                    aEventTrigger = rValue;
+                }
+                else
+                {
+                    aEventTrigger = rValue.copy( 0, nPos );
+
+                    // convert offset
+                    aEvent.Offset = convertTiming( rValue.copy( nPos + 1 ) );
+                }
+
+                nPos = aEventTrigger.indexOf( '.' );
+                if( nPos != -1 )
+                {
+                    aEvent.Source <<= mrImport.getInterfaceToIdentifierMapper().getReference( aEventTrigger.copy( 0, nPos ) );
+                    aEventTrigger = aEventTrigger.copy( nPos + 1 );
+                }
+
+                sal_Int16 nEnum;
+                if( SvXMLUnitConverter::convertEnum( nEnum, aEventTrigger, aAnimations_EnumMap_EventTrigger ) )
+                {
+                    aEvent.Trigger = nEnum;
+                }
+                else
+                {
+                    OSL_FAIL("AnimationsImportHelperImpl::convertTiming(), unknown event trigger!");
+                }
+
+                aAny <<= aEvent;
+            }
+        }
+        else
+        {
+            // fill the sequence
+            Sequence< Any > aValues( nElements );
+            Any* pValues = aValues.getArray();
+            for (sal_Int32 nIndex = 0; nIndex >= 0; )
+                *pValues++ = convertTiming( rValue.getToken( 0, ';', nIndex ) );
+
+            aAny <<= aValues;
+        }
+    }
+    return aAny;
+}
+
+Sequence< double > AnimationsImportHelperImpl::convertKeyTimes( std::string_view rValue )
+{
+    const sal_Int32 nElements { comphelper::string::getTokenCount(rValue, ';') };
+
+    Sequence< double > aKeyTimes( nElements );
+
+    if( nElements )
+    {
+        double* pValues = aKeyTimes.getArray();
+        for (sal_Int32 nIndex = 0; nIndex >= 0; )
+            *pValues++ = o3tl::toDouble(o3tl::getToken(rValue, 0, ';', nIndex ));
+    }
+
+    return aKeyTimes;
+}
+
+Sequence< TimeFilterPair > AnimationsImportHelperImpl::convertTimeFilter( std::string_view rValue )
+{
+    const sal_Int32 nElements { comphelper::string::getTokenCount(rValue, ';') };
+
+    Sequence< TimeFilterPair > aTimeFilter( nElements );
+
+    if( nElements )
+    {
+        TimeFilterPair* pValues = aTimeFilter.getArray();
+        for (sal_Int32 nIndex = 0; nIndex >= 0; )
+        {
+            const std::string_view aToken( o3tl::getToken(rValue, 0, ';', nIndex ) );
+
+            size_t nPos = aToken.find( ',' );
+            if( nPos != std::string_view::npos )
+            {
+                pValues->Time = rtl_math_stringToDouble(
+                    aToken.data(), aToken.data() + nPos, '.', 0, nullptr, nullptr);
+                pValues->Progress = rtl_math_stringToDouble(
+                    aToken.data() + nPos + 1, aToken.data() + aToken.size(), '.', 0,
+                    nullptr, nullptr);
+            }
+            pValues++;
+        }
+    }
+
+    return aTimeFilter;
+}
+
+Any AnimationsImportHelperImpl::convertPath( const OUString& rValue )
+{
+    return Any( rValue );
+}
+
+
+AnimationNodeContext::AnimationNodeContext(
+        const Reference< XAnimationNode >& xParentNode,
+        SvXMLImport& rImport, sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        const std::shared_ptr<AnimationsImportHelperImpl>& pHelper )
+:   SvXMLImportContext(rImport),
+    mpHelper( pHelper )
+{
+    bool bRootContext = !pHelper;
+    try
+    {
+        if( bRootContext )
+        {
+            mpHelper = std::make_shared<AnimationsImportHelperImpl>( rImport );
+            mxNode = xParentNode;
+        }
+        else
+        {
+            sal_Int16 nPresetClass = EffectPresetClass::CUSTOM;
+
+            const char* pServiceName = nullptr;
+
+            // we see namespace ANIMATION and ANIMATION_OOO and PRESENTATION_OASIS and PRESENTATION_SO52 and PRESENTATION_OOO
+            switch( nElement & TOKEN_MASK )
+            {
+            case XML_SEQ:
+                pServiceName = "com.sun.star.animations.SequenceTimeContainer"; break;
+            case XML_ITERATE:
+                pServiceName = "com.sun.star.animations.IterateContainer"; break;
+            case XML_ANIMATE:
+                pServiceName = "com.sun.star.animations.Animate"; break;
+            case XML_SET:
+                pServiceName = "com.sun.star.animations.AnimateSet"; break;
+            case XML_ANIMATEMOTION:
+                pServiceName = "com.sun.star.animations.AnimateMotion"; break;
+            case XML_ANIMATEPHYSICS:
+                pServiceName = "com.sun.star.animations.AnimatePhysics"; break;
+            case XML_ANIMATECOLOR:
+                pServiceName = "com.sun.star.animations.AnimateColor"; break;
+            case XML_ANIMATETRANSFORM:
+                pServiceName = "com.sun.star.animations.AnimateTransform"; break;
+            case XML_TRANSITIONFILTER:
+                pServiceName = "com.sun.star.animations.TransitionFilter"; break;
+            case XML_AUDIO:
+                pServiceName = "com.sun.star.animations.Audio"; break;
+            case XML_COMMAND:
+                pServiceName = "com.sun.star.animations.Command"; break;
+            case XML_PAR:
+                {
+                    for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+                    {
+                        if( (aIter.getToken() & TOKEN_MASK) == XML_PRESET_ID)
+                        {
+                            const OUString& rValue = aIter.toString();
+                            if ( rValue == "ooo-entrance-random" )
+                            {
+                                nPresetClass = EffectPresetClass::ENTRANCE;
+                            }
+                            else if ( rValue == "ooo-exit-random" )
+                            {
+                                nPresetClass = EffectPresetClass::EXIT;
+                            }
+
+                            if( nPresetClass != EffectPresetClass::CUSTOM )
+                            {
+                                pServiceName = "com.sun.star.comp.sd.RandomAnimationNode";
+                                break;
+                            }
+                        }
+                    }
+                    if( !pServiceName )
+                        pServiceName = "com.sun.star.animations.ParallelTimeContainer";
+                }
+                break;
+            default:
+                SAL_WARN("xmloff", "unexpected token '" + SvXMLImport::getNameFromToken(nElement)
+                            << "' 0x" << std::hex << nElement);
+                break;
+            }
+
+            if( pServiceName )
+            {
+                Reference< XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
+
+                mxNode.set(
+                    xContext->getServiceManager()->createInstanceWithContext(OUString::createFromAscii(pServiceName), xContext),
+                    UNO_QUERY_THROW );
+
+                if( nPresetClass != EffectPresetClass::CUSTOM )
+                {
+                    Reference< XInitialization > xInit( mxNode, UNO_QUERY_THROW );
+                    const Any aAny( nPresetClass );
+                    Sequence< Any > aArgs( &aAny, 1 ) ;
+                    xInit->initialize( aArgs );
+                }
+
+                init_node( xAttrList );
+
+                Reference< XTimeContainer > xParentContainer( xParentNode, UNO_QUERY_THROW );
+                xParentContainer->appendChild( mxNode );
+            }
+        }
+    }
+    catch (const RuntimeException&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw", "");
+    }
+}
+
+void AnimationNodeContext::init_node(  const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    if( !mxNode.is() )
+        return;
+
+    try
+    {
+        const sal_Int16 nNodeType = mxNode->getType();
+
+        // query for optional interfaces that are often used later
+        Reference< XAnimate > xAnimate( mxNode, UNO_QUERY );
+        Reference< XCommand > xCommand( mxNode, UNO_QUERY );
+        Reference< XTransitionFilter > xTransitionFilter( mxNode, UNO_QUERY );
+        Reference< XIterateContainer > xIter( mxNode, UNO_QUERY );
+
+        std::vector< NamedValue > aUserData;
+        XMLTokenEnum meAttributeName = XML_TOKEN_INVALID;
+        OUString aFrom, aBy, aTo, aValues;
+        bool bHaveXmlId( false );
+        OUString sXmlId;
+
+        sal_Int16 nEnum;
+        for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+        {
+            auto nToken = aIter.getToken();
+            switch( nToken )
+            {
+            case XML_ELEMENT(SMIL, XML_BEGIN):
+            case XML_ELEMENT(SMIL_COMPAT, XML_BEGIN):
+            case XML_ELEMENT(SMIL_SO52, XML_BEGIN):
+            {
+                mxNode->setBegin( mpHelper->convertTiming( aIter.toString() ) );
+            }
+            break;
+            case XML_ELEMENT(SMIL, XML_DUR):
+            case XML_ELEMENT(SMIL_COMPAT, XML_DUR):
+            case XML_ELEMENT(SMIL_SO52, XML_DUR):
+            {
+                mxNode->setDuration( mpHelper->convertTiming( aIter.toString() ) );
+            }
+            break;
+            case XML_ELEMENT(SMIL, XML_END):
+            case XML_ELEMENT(SMIL_COMPAT, XML_END):
+            case XML_ELEMENT(SMIL_SO52, XML_END):
+            {
+                mxNode->setEnd( mpHelper->convertTiming( aIter.toString() ) );
+            }
+            break;
+            case XML_ELEMENT(SMIL, XML_FILL):
+            case XML_ELEMENT(SMIL_COMPAT, XML_FILL):
+            case XML_ELEMENT(SMIL_SO52, XML_FILL):
+            {
+                if( SvXMLUnitConverter::convertEnum( nEnum, aIter.toView(), aAnimations_EnumMap_Fill ) )
+                    mxNode->setFill( nEnum );
+            }
+            break;
+            case XML_ELEMENT(SMIL, XML_FILLDEFAULT):
+            case XML_ELEMENT(SMIL_COMPAT, XML_FILLDEFAULT):
+            case XML_ELEMENT(SMIL_SO52, XML_FILLDEFAULT):
+            {
+                if( SvXMLUnitConverter::convertEnum( nEnum, aIter.toView(), aAnimations_EnumMap_FillDefault ) )
+                    mxNode->setFillDefault( nEnum );
+            }
+            break;
+            case XML_ELEMENT(SMIL, XML_RESTART):
+            case XML_ELEMENT(SMIL_COMPAT, XML_RESTART):
+            case XML_ELEMENT(SMIL_SO52, XML_RESTART):
+            {
+                if( SvXMLUnitConverter::convertEnum( nEnum, aIter.toView(), aAnimations_EnumMap_Restart ) )
+                    mxNode->setRestart( nEnum );
+            }
+            break;
+            case XML_ELEMENT(SMIL, XML_RESTARTDEFAULT):
+            case XML_ELEMENT(SMIL_COMPAT, XML_RESTARTDEFAULT):
+            case XML_ELEMENT(SMIL_SO52, XML_RESTARTDEFAULT):
+            {
+                if( SvXMLUnitConverter::convertEnum( nEnum, aIter.toView(), aAnimations_EnumMap_RestartDefault ) )
+                    mxNode->setRestartDefault( nEnum );
+            }
+            break;
+            case XML_ELEMENT(SMIL, XML_ACCELERATE):
+            case XML_ELEMENT(SMIL_COMPAT, XML_ACCELERATE):
+            case XML_ELEMENT(SMIL_SO52, XML_ACCELERATE):
+            {
+                if( isDouble( aIter.toView() ) )
+                    mxNode->setAcceleration( aIter.toDouble() );
+            }
+            break;
+            case XML_ELEMENT(SMIL, XML_DECELERATE):
+            case XML_ELEMENT(SMIL_COMPAT, XML_DECELERATE):
+            case XML_ELEMENT(SMIL_SO52, XML_DECELERATE):
+            {
+                if( isDouble( aIter.toView() ) )
+                    mxNode->setDecelerate( aIter.toDouble() );
+            }
+            break;
+            case XML_ELEMENT(SMIL, XML_AUTOREVERSE):
+            case XML_ELEMENT(SMIL_COMPAT, XML_AUTOREVERSE):
+            case XML_ELEMENT(SMIL_SO52, XML_AUTOREVERSE):
+            {
+                bool bTemp;
+                if (::sax::Converter::convertBool( bTemp, aIter.toView() ))
+                    mxNode->setAutoReverse( bTemp  );
+            }
+            break;
+            case XML_ELEMENT(SMIL, XML_REPEATCOUNT):
+            case XML_ELEMENT(SMIL_COMPAT, XML_REPEATCOUNT):
+            case XML_ELEMENT(SMIL_SO52, XML_REPEATCOUNT):
+            {
+                mxNode->setRepeatCount( mpHelper->convertTiming( aIter.toString() ) );
+            }
+            break;
+            case XML_ELEMENT(SMIL, XML_REPEATDUR):
+            case XML_ELEMENT(SMIL_COMPAT, XML_REPEATDUR):
+            case XML_ELEMENT(SMIL_SO52, XML_REPEATDUR):
+            {
+                mxNode->setRepeatDuration( mpHelper->convertTiming( aIter.toString() ) );
+            }
+            break;
+            case XML_ELEMENT(SMIL, XML_ENDSYNC):
+            case XML_ELEMENT(SMIL_COMPAT, XML_ENDSYNC):
+            case XML_ELEMENT(SMIL_SO52, XML_ENDSYNC):
+            {
+                if( SvXMLUnitConverter::convertEnum( nEnum, aIter.toView(), aAnimations_EnumMap_Endsync ) )
+                    mxNode->setEndSync( Any( nEnum ) );
+            }
+            break;
+            case XML_ELEMENT(PRESENTATION, XML_NODE_TYPE):
+            case XML_ELEMENT(PRESENTATION_SO52, XML_NODE_TYPE):
+            case XML_ELEMENT(PRESENTATION_OOO, XML_NODE_TYPE):
+            case XML_ELEMENT(PRESENTATION_OASIS, XML_NODE_TYPE):
+            {
+                if( SvXMLUnitConverter::convertEnum( nEnum, aIter.toView(), aAnimations_EnumMap_EffectNodeType ) )
+                    aUserData.emplace_back( GetXMLToken( XML_NODE_TYPE ), Any( nEnum ) );
+            }
+            break;
+            case XML_ELEMENT(PRESENTATION, XML_PRESET_ID):
+            case XML_ELEMENT(PRESENTATION_SO52, XML_PRESET_ID):
+            case XML_ELEMENT(PRESENTATION_OOO, XML_PRESET_ID):
+            case XML_ELEMENT(PRESENTATION_OASIS, XML_PRESET_ID):
+            {
+                aUserData.emplace_back( GetXMLToken( XML_PRESET_ID ), Any( aIter.toString() ) );
+            }
+            break;
+            case XML_ELEMENT(PRESENTATION, XML_PRESET_SUB_TYPE):
+            case XML_ELEMENT(PRESENTATION_SO52, XML_PRESET_SUB_TYPE):
+            case XML_ELEMENT(PRESENTATION_OOO, XML_PRESET_SUB_TYPE):
+            case XML_ELEMENT(PRESENTATION_OASIS, XML_PRESET_SUB_TYPE):
+            {
+                aUserData.emplace_back( GetXMLToken( XML_PRESET_SUB_TYPE ), Any( aIter.toString() ) );
+            }
+            break;
+            case XML_ELEMENT(PRESENTATION, XML_PRESET_CLASS):
+            case XML_ELEMENT(PRESENTATION_SO52, XML_PRESET_CLASS):
+            case XML_ELEMENT(PRESENTATION_OOO, XML_PRESET_CLASS):
+            case XML_ELEMENT(PRESENTATION_OASIS, XML_PRESET_CLASS):
+            {
+                if( SvXMLUnitConverter::convertEnum( nEnum, aIter.toView(), aAnimations_EnumMap_EffectPresetClass ) )
+                    aUserData.emplace_back( GetXMLToken( XML_PRESET_CLASS ), Any( nEnum ) );
+            }
+            break;
+            case XML_ELEMENT(PRESENTATION, XML_AFTER_EFFECT):
+            case XML_ELEMENT(PRESENTATION_SO52, XML_AFTER_EFFECT):
+            case XML_ELEMENT(PRESENTATION_OOO, XML_AFTER_EFFECT):
+            {
+                bool bTemp;
+                if (::sax::Converter::convertBool( bTemp, aIter.toView() ))
+                    aUserData.emplace_back( GetXMLToken( XML_AFTER_EFFECT ), Any( bTemp ) );
+            }
+            break;
+            case XML_ELEMENT(XLINK, XML_HREF):
+            {
+                if( nNodeType == AnimationNodeType::AUDIO )
+                {
+                    Reference< XAudio > xAudio( mxNode, UNO_QUERY_THROW );
+                    xAudio->setSource( Any(lcl_GetMediaReference(GetImport(), aIter.toString())) );
+                    break;
+                }
+                [[fallthrough]];
+            }
+            case XML_ELEMENT(SMIL, XML_TARGETELEMENT):
+            case XML_ELEMENT(SMIL_COMPAT, XML_TARGETELEMENT):
+            case XML_ELEMENT(SMIL_SO52, XML_TARGETELEMENT):
+            {
+                Any aTarget( mpHelper->convertTarget( aIter.toString() ) );
+
+                if( xAnimate.is() )
+                {
+                    xAnimate->setTarget( aTarget );
+                }
+                else if( xIter.is() )
+                {
+                    xIter->setTarget( aTarget );
+                }
+                else if( xCommand.is() )
+                {
+                    xCommand->setTarget( aTarget );
+                }
+            }
+            break;
+
+            case XML_ELEMENT(ANIMATION, XML_AUDIO_LEVEL):
+            case XML_ELEMENT(ANIMATION_OOO, XML_AUDIO_LEVEL):
+            {
+                if( nNodeType == AnimationNodeType::AUDIO )
+                {
+                    if( isDouble( aIter.toView() ) )
+                    {
+                        Reference< XAudio > xAudio( mxNode, UNO_QUERY_THROW );
+                        xAudio->setVolume( aIter.toDouble() );
+                    }
+                }
+            }
+            break;
+
+            case XML_ELEMENT(PRESENTATION, XML_MASTER_ELEMENT):
+            case XML_ELEMENT(PRESENTATION_SO52, XML_MASTER_ELEMENT):
+            case XML_ELEMENT(PRESENTATION_OOO, XML_MASTER_ELEMENT):
+            {
+                Reference< XAnimationNode > xMaster( GetImport().getInterfaceToIdentifierMapper().getReference( aIter.toString() ), UNO_QUERY );
+                aUserData.emplace_back( GetXMLToken( XML_MASTER_ELEMENT ), Any( xMaster ) );
+            }
+            break;
+
+            case XML_ELEMENT(ANIMATION, XML_SUB_ITEM):
+            case XML_ELEMENT(ANIMATION_OOO, XML_SUB_ITEM):
+            {
+                if( SvXMLUnitConverter::convertEnum( nEnum, aIter.toView(), aAnimations_EnumMap_SubItem ) )
+                {
+                    if( xAnimate.is() )
+                    {
+                        xAnimate->setSubItem( nEnum );
+                    }
+                    else if( xIter.is() )
+                    {
+                        xIter->setSubItem( nEnum );
+                    }
+                }
+            }
+            break;
+
+            case XML_ELEMENT(SMIL, XML_ATTRIBUTENAME):
+            case XML_ELEMENT(SMIL_COMPAT, XML_ATTRIBUTENAME):
+            case XML_ELEMENT(SMIL_SO52, XML_ATTRIBUTENAME):
+            {
+                if( xAnimate.is() )
+                {
+                    OUString aName( aIter.toString() );
+
+                    const struct ImplAttributeNameConversion* p = getAnimationAttributeNamesConversionList();
+                    while( p->mpAPIName )
+                    {
+                        if( IsXMLToken( aIter, p->meXMLToken ) )
+                        {
+                            aName = OUString::createFromAscii( p->mpAPIName );
+                            meAttributeName = p->meXMLToken;
+                            break;
+                        }
+
+                        p++;
+                    }
+
+                    xAnimate->setAttributeName( aName );
+                }
+            }
+            break;
+
+            case XML_ELEMENT(SMIL, XML_VALUES):
+            case XML_ELEMENT(SMIL_COMPAT, XML_VALUES):
+            case XML_ELEMENT(SMIL_SO52, XML_VALUES):
+            {
+                aValues = aIter.toString();
+            }
+            break;
+
+            case XML_ELEMENT(SMIL, XML_FROM):
+            case XML_ELEMENT(SMIL_COMPAT, XML_FROM):
+            case XML_ELEMENT(SMIL_SO52, XML_FROM):
+            {
+                aFrom = aIter.toString();
+            }
+            break;
+
+            case XML_ELEMENT(SMIL, XML_BY):
+            case XML_ELEMENT(SMIL_COMPAT, XML_BY):
+            case XML_ELEMENT(SMIL_SO52, XML_BY):
+            {
+                aBy = aIter.toString();
+            }
+            break;
+
+            case XML_ELEMENT(SMIL, XML_TO):
+            case XML_ELEMENT(SMIL_COMPAT, XML_TO):
+            case XML_ELEMENT(SMIL_SO52, XML_TO):
+            {
+                aTo = aIter.toString();
+            }
+            break;
+
+            case XML_ELEMENT(SMIL, XML_KEYTIMES):
+            case XML_ELEMENT(SMIL_COMPAT, XML_KEYTIMES):
+            case XML_ELEMENT(SMIL_SO52, XML_KEYTIMES):
+            {
+                if( xAnimate.is() )
+                    xAnimate->setKeyTimes( AnimationsImportHelperImpl::convertKeyTimes( aIter.toView() ) );
+            }
+            break;
+
+            case XML_ELEMENT(ANIMATION, XML_FORMULA):
+            case XML_ELEMENT(ANIMATION_OOO, XML_FORMULA):
+            {
+                if( xAnimate.is() )
+                    xAnimate->setFormula( aIter.toString() );
+            }
+            break;
+
+            case XML_ELEMENT(ANIMATION, XML_ID):
+            case XML_ELEMENT(ANIMATION_OOO, XML_ID):
+            {
+                if (!bHaveXmlId) { sXmlId = aIter.toString(); }
+            }
+            break;
+            case XML_ELEMENT(XML, XML_ID):
+            {
+                sXmlId = aIter.toString();
+                bHaveXmlId = true;
+            }
+            break;
+
+            case XML_ELEMENT(SMIL, XML_CALCMODE):
+            case XML_ELEMENT(SMIL_COMPAT, XML_CALCMODE):
+            case XML_ELEMENT(SMIL_SO52, XML_CALCMODE):
+            {
+                if( xAnimate.is() )
+                {
+                    if( SvXMLUnitConverter::convertEnum( nEnum, aIter.toView(), aAnimations_EnumMap_CalcMode ) )
+                        xAnimate->setCalcMode( nEnum );
+                }
+            }
+            break;
+
+            case XML_ELEMENT(SMIL, XML_ACCUMULATE):
+            case XML_ELEMENT(SMIL_COMPAT, XML_ACCUMULATE):
+            case XML_ELEMENT(SMIL_SO52, XML_ACCUMULATE):
+            {
+                if( xAnimate.is() )
+                    xAnimate->setAccumulate( IsXMLToken( aIter, XML_SUM ) );
+            }
+            break;
+
+            case XML_ELEMENT(PRESENTATION, XML_ADDITIVE):
+            case XML_ELEMENT(PRESENTATION_SO52, XML_ADDITIVE):
+            case XML_ELEMENT(PRESENTATION_OOO, XML_ADDITIVE):
+            case XML_ELEMENT(SMIL, XML_ADDITIVE):
+            case XML_ELEMENT(SMIL_COMPAT, XML_ADDITIVE):
+            case XML_ELEMENT(SMIL_SO52, XML_ADDITIVE):
+            {
+                if( xAnimate.is() )
+                {
+                    if( SvXMLUnitConverter::convertEnum( nEnum, aIter.toView(), aAnimations_EnumMap_AdditiveMode ) )
+                        xAnimate->setAdditive( nEnum );
+                }
+            }
+            break;
+
+            case XML_ELEMENT(SMIL, XML_KEYSPLINES):
+            case XML_ELEMENT(SMIL_COMPAT, XML_KEYSPLINES):
+            case XML_ELEMENT(SMIL_SO52, XML_KEYSPLINES):
+            {
+                if( xAnimate.is() )
+                    xAnimate->setTimeFilter( AnimationsImportHelperImpl::convertTimeFilter( aIter.toView() ) );
+            }
+            break;
+
+            case XML_ELEMENT(SVG, XML_PATH):
+            case XML_ELEMENT(SVG_COMPAT, XML_PATH):
+            {
+                Reference< XAnimateMotion > xAnimateMotion( mxNode, UNO_QUERY );
+                if( xAnimateMotion.is() )
+                    xAnimateMotion->setPath( AnimationsImportHelperImpl::convertPath( aIter.toString() ) );
+            }
+            break;
+
+            case XML_ELEMENT(ANIMATION, XML_PHYSICS_ANIMATION_START_VELOCITY_X):
+            case XML_ELEMENT(ANIMATION_OOO, XML_PHYSICS_ANIMATION_START_VELOCITY_X):
+            case XML_ELEMENT(LO_EXT, XML_PHYSICS_ANIMATION_START_VELOCITY_X):
+            {
+                Reference< XAnimatePhysics > xAnimatePhysics( mxNode, UNO_QUERY );
+                if( xAnimatePhysics.is() )
+                    xAnimatePhysics->setStartVelocityX( Any(aIter.toDouble()) );
+            }
+            break;
+
+            case XML_ELEMENT(ANIMATION, XML_PHYSICS_ANIMATION_START_VELOCITY_Y):
+            case XML_ELEMENT(ANIMATION_OOO, XML_PHYSICS_ANIMATION_START_VELOCITY_Y):
+            case XML_ELEMENT(LO_EXT, XML_PHYSICS_ANIMATION_START_VELOCITY_Y):
+            {
+                Reference< XAnimatePhysics > xAnimatePhysics( mxNode, UNO_QUERY );
+                if( xAnimatePhysics.is() )
+                    xAnimatePhysics->setStartVelocityY( Any(aIter.toDouble()) );
+            }
+            break;
+
+            case XML_ELEMENT(ANIMATION, XML_PHYSICS_ANIMATION_DENSITY):
+            case XML_ELEMENT(ANIMATION_OOO, XML_PHYSICS_ANIMATION_DENSITY):
+            case XML_ELEMENT(LO_EXT, XML_PHYSICS_ANIMATION_DENSITY):
+            {
+                Reference< XAnimatePhysics > xAnimatePhysics( mxNode, UNO_QUERY );
+                if( xAnimatePhysics.is() )
+                    xAnimatePhysics->setDensity( Any(aIter.toDouble()) );
+            }
+            break;
+
+            case XML_ELEMENT(ANIMATION, XML_PHYSICS_ANIMATION_BOUNCINESS):
+            case XML_ELEMENT(ANIMATION_OOO, XML_PHYSICS_ANIMATION_BOUNCINESS):
+            case XML_ELEMENT(LO_EXT, XML_PHYSICS_ANIMATION_BOUNCINESS):
+            {
+                Reference< XAnimatePhysics > xAnimatePhysics( mxNode, UNO_QUERY );
+                if( xAnimatePhysics.is() )
+                    xAnimatePhysics->setBounciness( Any(aIter.toDouble()) );
+            }
+            break;
+
+            case XML_ELEMENT(ANIMATION, XML_COLOR_INTERPOLATION):
+            case XML_ELEMENT(ANIMATION_OOO, XML_COLOR_INTERPOLATION):
+            {
+                Reference< XAnimateColor > xAnimateColor( mxNode, UNO_QUERY );
+                if( xAnimateColor.is() )
+                    xAnimateColor->setColorInterpolation( IsXMLToken( aIter, XML_HSL ) ? AnimationColorSpace::HSL : AnimationColorSpace::RGB );
+            }
+            break;
+
+            case XML_ELEMENT(ANIMATION, XML_COLOR_INTERPOLATION_DIRECTION):
+            case XML_ELEMENT(ANIMATION_OOO, XML_COLOR_INTERPOLATION_DIRECTION):
+            {
+                Reference< XAnimateColor > xAnimateColor( mxNode, UNO_QUERY );
+                if( xAnimateColor.is() )
+                    xAnimateColor->setDirection( IsXMLToken( aIter, XML_CLOCKWISE ) );
+            }
+            break;
+
+            case XML_ELEMENT(SVG, XML_TYPE):
+            case XML_ELEMENT(SVG_COMPAT, XML_TYPE):
+            {
+                Reference< XAnimateTransform > xTransform( mxNode, UNO_QUERY );
+                if( xTransform.is() )
+                {
+                    if( SvXMLUnitConverter::convertEnum( nEnum, aIter.toView(), aAnimations_EnumMap_TransformType ) )
+                    {
+                        xTransform->setTransformType( nEnum );
+                        switch( nEnum )
+                        {
+                        case AnimationTransformType::SCALE: meAttributeName = XML_SCALE; break;
+                        case AnimationTransformType::ROTATE: meAttributeName = XML_ROTATE; break;
+                        case AnimationTransformType::SKEWX: meAttributeName = XML_SKEWX; break;
+                        case AnimationTransformType::SKEWY: meAttributeName = XML_SKEWY; break;
+                        //case AnimationTransformType::TRANSLATE:
+                        default:
+                            meAttributeName = XML_TRANSLATE; break;
+                        }
+                    }
+                }
+            }
+            break;
+
+            case XML_ELEMENT(SMIL, XML_TYPE):
+            case XML_ELEMENT(SMIL_COMPAT, XML_TYPE):
+            case XML_ELEMENT(SMIL_SO52, XML_TYPE):
+            {
+                if( xTransitionFilter.is() )
+                {
+                    if( SvXMLUnitConverter::convertEnum( nEnum, aIter.toView(), aAnimations_EnumMap_TransitionType ) )
+                        xTransitionFilter->setTransition( nEnum );
+                }
+            }
+            break;
+
+            case XML_ELEMENT(SMIL, XML_SUBTYPE):
+            case XML_ELEMENT(SMIL_COMPAT, XML_SUBTYPE):
+            case XML_ELEMENT(SMIL_SO52, XML_SUBTYPE):
+            {
+                if( xTransitionFilter.is() )
+                {
+                    if( SvXMLUnitConverter::convertEnum( nEnum, aIter.toView(), aAnimations_EnumMap_TransitionSubType ) )
+                        xTransitionFilter->setSubtype( nEnum );
+                }
+            }
+            break;
+
+            case XML_ELEMENT(SMIL, XML_MODE):
+            case XML_ELEMENT(SMIL_COMPAT, XML_MODE):
+            case XML_ELEMENT(SMIL_SO52, XML_MODE):
+            {
+                if( xTransitionFilter.is() )
+                    xTransitionFilter->setMode( IsXMLToken( aIter, XML_IN ) );
+            }
+            break;
+
+            case XML_ELEMENT(SMIL, XML_DIRECTION):
+            case XML_ELEMENT(SMIL_COMPAT, XML_DIRECTION):
+            case XML_ELEMENT(SMIL_SO52, XML_DIRECTION):
+            {
+                if( xTransitionFilter.is() )
+                    xTransitionFilter->setDirection( IsXMLToken( aIter, XML_FORWARD ) );
+            }
+            break;
+
+            case XML_ELEMENT(SMIL, XML_FADECOLOR):
+            case XML_ELEMENT(SMIL_COMPAT, XML_FADECOLOR):
+            case XML_ELEMENT(SMIL_SO52, XML_FADECOLOR):
+            {
+                if( xTransitionFilter.is() )
+                {
+                    sal_Int32 nColor(0);
+                    ::sax::Converter::convertColor(nColor, aIter.toView());
+                    xTransitionFilter->setFadeColor(nColor);
+                }
+            }
+            break;
+
+            case XML_ELEMENT(ANIMATION, XML_ITERATE_TYPE):
+            case XML_ELEMENT(ANIMATION_OOO, XML_ITERATE_TYPE):
+            {
+                if( SvXMLUnitConverter::convertEnum( nEnum, aIter.toView(), aAnimations_EnumMap_IterateType ) )
+                {
+                    if( xIter.is() )
+                        xIter->setIterateType( nEnum );
+                }
+            }
+            break;
+
+            case XML_ELEMENT(ANIMATION, XML_ITERATE_INTERVAL):
+            case XML_ELEMENT(ANIMATION_OOO, XML_ITERATE_INTERVAL):
+            {
+                if( xIter.is() )
+                {
+                    OUString rValue = aIter.toString();
+                    double fInterval = 0.0;
+                    if( rValue.match("P") )
+                    {
+                        css::util::Duration aDuration;
+                        if (::sax::Converter::convertDuration(aDuration, rValue))
+                        {
+                            fInterval = ((((aDuration.Hours * 60)
+                                + aDuration.Minutes) * 60) + aDuration.Seconds)
+                              + (aDuration.NanoSeconds / 1000000000.0);
+                        }
+                    }
+                    else
+                    {
+                        fInterval = aIter.toDouble();
+                    }
+
+                    xIter->setIterateInterval( fInterval );
+                }
+            }
+            break;
+
+            case XML_ELEMENT(PRESENTATION, XML_GROUP_ID):
+            case XML_ELEMENT(PRESENTATION_SO52, XML_GROUP_ID):
+            case XML_ELEMENT(PRESENTATION_OOO, XML_GROUP_ID):
+            {
+                aUserData.emplace_back( "group-id", Any( aIter.toInt32() ) );
+            }
+            break;
+
+            case XML_ELEMENT(ANIMATION, XML_COMMAND):
+            case XML_ELEMENT(ANIMATION_OOO, XML_COMMAND):
+            {
+                if( xCommand.is() && nNodeType == AnimationNodeType::COMMAND )
+                {
+                    if( SvXMLUnitConverter::convertEnum( nEnum, aIter.toView(), aAnimations_EnumMap_Command ) )
+                    {
+                        xCommand->setCommand( nEnum );
+                    }
+                }
+            }
+            break;
+
+            default:
+            {
+                // push all unknown attributes within the presentation namespace as user data
+                if (IsTokenInNamespace(nToken, XML_NAMESPACE_PRESENTATION)
+                    || IsTokenInNamespace(nToken, XML_NAMESPACE_PRESENTATION_SO52)
+                    || IsTokenInNamespace(nToken, XML_NAMESPACE_PRESENTATION_OASIS)
+                    || IsTokenInNamespace(nToken, XML_NAMESPACE_PRESENTATION_OOO))
+                {
+                    aUserData.emplace_back( SvXMLImport::getNameFromToken(aIter.getToken()), Any( aIter.toString() ) );
+                }
+                else
+                    XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+            }
+            }
+        }
+
+        if (!sXmlId.isEmpty())
+        {
+            Reference< XInterface > const xRef( mxNode, UNO_QUERY );
+            GetImport().getInterfaceToIdentifierMapper().registerReference(
+                sXmlId, xRef );
+        }
+
+        sal_Int32 nUserDataCount = aUserData.size();
+        if( nUserDataCount )
+        {
+            Sequence< NamedValue > aUnoUserData( nUserDataCount );
+            NamedValue* pData = aUnoUserData.getArray();
+            for (auto const& item : aUserData)
+                *pData++ = item;
+
+            mxNode->setUserData( aUnoUserData );
+        }
+
+        // convert values
+        if( xAnimate.is() )
+        {
+            if( !aFrom.isEmpty() )
+                xAnimate->setFrom( mpHelper->convertValue( meAttributeName, aFrom ) );
+
+            if( !aBy.isEmpty() )
+                xAnimate->setBy( mpHelper->convertValue( meAttributeName, aBy ) );
+
+            if( !aTo.isEmpty() )
+                xAnimate->setTo( mpHelper->convertValue( meAttributeName, aTo ) );
+
+            if( !aValues.isEmpty() )
+                xAnimate->setValues( mpHelper->convertValueSequence( meAttributeName, aValues ) );
+
+            if (xAnimate->getValues().getLength() != xAnimate->getKeyTimes().getLength())
+                throw css::io::WrongFormatException();
+        }
+    }
+    catch (const css::io::WrongFormatException&)
+    {
+        throw;
+    }
+    catch (const RuntimeException&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw", "");
+    }
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler >  AnimationNodeContext::createFastChildContext(sal_Int32 nElement,
+        const css::uno::Reference<css::xml::sax::XFastAttributeList>& xAttrList)
+{
+    if( mxNode.is())
+        return new AnimationNodeContext( mxNode, GetImport(), nElement, xAttrList, mpHelper );
+    return nullptr;
+}
+
+namespace {
+
+class AnimationsImport: public SvXMLImport, public XAnimationNodeSupplier
+{
+public:
+    explicit AnimationsImport( const Reference< XComponentContext > & rxContext );
+
+    SvXMLImportContext* CreateFastContext(sal_Int32 nElement,
+                    const Reference<XFastAttributeList>& xAttrList) override;
+
+    // XInterface
+    virtual Any SAL_CALL queryInterface( const Type& aType ) override;
+    virtual void SAL_CALL acquire() noexcept override;
+    virtual void SAL_CALL release() noexcept override;
+
+    // XAnimationNodeSupplier
+    Reference< XAnimationNode > SAL_CALL getAnimationNode() override;
+
+private:
+    Reference< XAnimationNode > mxRootNode;
+};
+
+}
+
+AnimationsImport::AnimationsImport( const Reference< XComponentContext > & rxContext )
+: SvXMLImport( rxContext, "xmloff::AnimationsImport", SvXMLImportFlags::META )
+    //FIXME: the above "IMPORT_META" used to be a nonsensical "true", question
+    // remains whether this should be IMPORT_META (same numerical value as
+    // true) or default IMPORT_ALL
+{
+    mxRootNode.set( SequenceTimeContainer::create(rxContext), UNO_QUERY_THROW );
+}
+
+// XInterface
+Any SAL_CALL AnimationsImport::queryInterface( const Type& aType )
+{
+    if ( aType == cppu::UnoType<XAnimationNodeSupplier>::get())
+    {
+        return Any( Reference<XAnimationNodeSupplier>( this ) );
+    }
+    else
+    {
+        return SvXMLImport::queryInterface( aType );
+    }
+}
+
+void SAL_CALL AnimationsImport::acquire() noexcept
+{
+    SvXMLImport::acquire();
+}
+
+void SAL_CALL AnimationsImport::release() noexcept
+{
+    SvXMLImport::release();
+}
+
+SvXMLImportContext *AnimationsImport::CreateFastContext(
+        sal_Int32 nElement,
+        const Reference<XFastAttributeList>& xAttrList)
+{
+    SvXMLImportContext* pContext = nullptr;
+
+    if( nElement == XML_ELEMENT(ANIMATION, XML_SEQ) || nElement == XML_ELEMENT(ANIMATION_OOO, XML_SEQ) )
+    {
+         pContext = new AnimationNodeContext( mxRootNode, *this, nElement, xAttrList );
+    }
+
+    return pContext;
+}
+
+// XAnimationNodeSupplier
+Reference< XAnimationNode > SAL_CALL AnimationsImport::getAnimationNode()
+{
+    return mxRootNode;
+}
+
+void AnimationNodeContext::postProcessRootNode( const Reference< XAnimationNode >& xRootNode, Reference< XPropertySet > const & xPageProps )
+{
+    if( !(xRootNode.is() && xPageProps.is()) )
+        return;
+
+    try
+    {
+        Reference< XEnumerationAccess > xEnumerationAccess( xRootNode, UNO_QUERY_THROW );
+        Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_SET_THROW );
+        if( xEnumeration->hasMoreElements() )
+        {
+            Reference< XAnimationNode > xNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
+            if( xNode->getType() == AnimationNodeType::PAR )
+            {
+                Event aEvent;
+                if( (xNode->getBegin() >>= aEvent) && (aEvent.Trigger == EventTrigger::BEGIN_EVENT) )
+                {
+                    // found transition node
+                    Reference< XEnumerationAccess > xChildEnumerationAccess( xNode, UNO_QUERY_THROW );
+                    Reference< XEnumeration > xChildEnumeration( xChildEnumerationAccess->createEnumeration(), UNO_SET_THROW );
+                    while( xChildEnumeration->hasMoreElements() )
+                    {
+                        Reference< XAnimationNode > xChildNode( xChildEnumeration->nextElement(), UNO_QUERY_THROW );
+                        switch( xChildNode->getType() )
+                        {
+                        case AnimationNodeType::TRANSITIONFILTER:
+                        {
+                            Reference< XTransitionFilter > xTransFilter( xChildNode, UNO_QUERY_THROW );
+
+                            xPageProps->setPropertyValue("TransitionType", Any( xTransFilter->getTransition() ) );
+                            xPageProps->setPropertyValue("TransitionSubtype", Any( xTransFilter->getSubtype() ) );
+                            xPageProps->setPropertyValue("TransitionDirection", Any( xTransFilter->getDirection() ) );
+                            xPageProps->setPropertyValue("TransitionFadeColor", Any( xTransFilter->getFadeColor() ) );
+
+                            double fDuration;
+                            if( xTransFilter->getDuration() >>= fDuration )
+                                xPageProps->setPropertyValue("TransitionDuration", Any( fDuration ) );
+
+                        }
+                        break;
+
+                        case AnimationNodeType::COMMAND:
+                        {
+                            Reference< XCommand > xCommand( xChildNode, UNO_QUERY_THROW );
+                            if( xCommand->getCommand() == EffectCommands::STOPAUDIO )
+                            {
+                                xPageProps->setPropertyValue("Sound", Any(true) );
+                            }
+                        }
+                        break;
+
+                        case AnimationNodeType::AUDIO:
+                        {
+                            Reference< XAudio > xAudio( xChildNode, UNO_QUERY_THROW );
+                            OUString sSoundURL;
+                            if( (xAudio->getSource() >>= sSoundURL) && !sSoundURL.isEmpty() )
+                            {
+                                xPageProps->setPropertyValue("Sound", Any(sSoundURL) );
+
+                                Timing eTiming;
+                                if( (xAudio->getRepeatCount() >>= eTiming) && (eTiming == Timing_INDEFINITE) )
+                                    xPageProps->setPropertyValue("LoopSound", Any( true ) );
+                            }
+                        }
+                        break;
+
+                        }
+                    }
+
+                    Reference< XTimeContainer > xRootContainer( xRootNode, UNO_QUERY_THROW );
+                    xRootContainer->removeChild( xNode );
+                }
+            }
+        }
+    }
+    catch (const Exception&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw", "");
+    }
+}
+
+} // namespace xmloff
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Xmloff_AnimationsImport(uno::XComponentContext* pCtx,
+                                          uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(new xmloff::AnimationsImport(pCtx));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/animexp.cxx b/xmloff/source/draw/animexp.cxx
new file mode 100644
index 000000000..f839506db
--- /dev/null
+++ b/xmloff/source/draw/animexp.cxx
@@ -0,0 +1,512 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/drawing/XShape.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/presentation/AnimationSpeed.hpp>
+#include <xmloff/unointerfacetouniqueidentifiermapper.hxx>
+
+#include <sax/tools/converter.hxx>
+#include <sal/log.hxx>
+#include <tools/diagnose_ex.h>
+
+#include <list>
+#include <comphelper/extract.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <anim.hxx>
+
+
+using namespace ::std;
+using namespace ::cppu;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::drawing;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::presentation;
+using namespace ::xmloff::token;
+
+namespace {
+
+struct Effect
+{
+    XMLEffect meKind;
+    XMLEffectDirection meDirection;
+    sal_Int16 mnStartScale;
+    bool mbIn;
+};
+
+}
+
+const Effect AnimationEffectMap[] =
+{
+    { EK_none, ED_none,             -1, true }, // AnimationEffect_NONE
+    { EK_fade, ED_from_left,        -1, true }, // AnimationEffect_FADE_FROM_LEFT
+    { EK_fade, ED_from_top,         -1, true }, // AnimationEffect_FADE_FROM_TOP
+    { EK_fade, ED_from_right,       -1, true }, // AnimationEffect_FADE_FROM_RIGHT
+    { EK_fade, ED_from_bottom,      -1, true }, // AnimationEffect_FADE_FROM_BOTTOM
+    { EK_fade, ED_to_center,        -1, true }, // AnimationEffect_FADE_TO_CENTER
+    { EK_fade, ED_from_center,      -1, true }, // AnimationEffect_FADE_FROM_CENTER
+    { EK_move, ED_from_left,        -1, true }, // AnimationEffect_MOVE_FROM_LEFT
+    { EK_move, ED_from_top,         -1, true }, // AnimationEffect_MOVE_FROM_TOP
+    { EK_move, ED_from_right,       -1, true }, // AnimationEffect_MOVE_FROM_RIGHT
+    { EK_move, ED_from_bottom,      -1, true }, // AnimationEffect_MOVE_FROM_BOTTOM
+    { EK_stripes, ED_vertical,      -1, true }, // AnimationEffect_VERTICAL_STRIPES
+    { EK_stripes, ED_horizontal,    -1, true }, // AnimationEffect_HORIZONTAL_STRIPES
+    { EK_fade, ED_clockwise,        -1, true }, // AnimationEffect_CLOCKWISE
+    { EK_fade, ED_cclockwise,       -1, true }, // AnimationEffect_COUNTERCLOCKWISE
+    { EK_fade, ED_from_upperleft,   -1, true }, // AnimationEffect_FADE_FROM_UPPERLEFT
+    { EK_fade, ED_from_upperright,  -1, true }, // AnimationEffect_FADE_FROM_UPPERRIGHT
+    { EK_fade, ED_from_lowerleft,   -1, true }, // AnimationEffect_FADE_FROM_LOWERLEFT
+    { EK_fade, ED_from_lowerright,  -1, true }, // AnimationEffect_FADE_FROM_LOWERRIGHT
+    { EK_close,ED_vertical,         -1, true }, // AnimationEffect_CLOSE_VERTICAL
+    { EK_close,ED_horizontal,       -1, true }, // AnimationEffect_CLOSE_HORIZONTAL
+    { EK_open, ED_vertical,         -1, true }, // AnimationEffect_OPEN_VERTICAL
+    { EK_open, ED_horizontal,       -1, true }, // AnimationEffect_OPEN_HORIZONTAL
+    { EK_move, ED_path,             -1, true }, // AnimationEffect_PATH
+    { EK_move, ED_to_left,          -1, false },// AnimationEffect_MOVE_TO_LEFT
+    { EK_move, ED_to_top,           -1, false },// AnimationEffect_MOVE_TO_TOP
+    { EK_move, ED_to_right,         -1, false },// AnimationEffect_MOVE_TO_RIGHT
+    { EK_move, ED_to_bottom,        -1, false },// AnimationEffect_MOVE_TO_BOTTOM
+    { EK_fade, ED_spiral_inward_left,   -1, true }, // AnimationEffect_SPIRALIN_LEFT
+    { EK_fade, ED_spiral_inward_right,  -1, true }, // AnimationEffect_SPIRALIN_RIGHT
+    { EK_fade, ED_spiral_outward_left,  -1, true }, // AnimationEffect_SPIRALOUT_LEFT
+    { EK_fade, ED_spiral_outward_right, -1, true }, // AnimationEffect_SPIRALOUT_RIGHT
+    { EK_dissolve, ED_none,         -1, true }, // AnimationEffect_DISSOLVE
+    { EK_wavyline, ED_from_left,    -1, true }, // AnimationEffect_WAVYLINE_FROM_LEFT
+    { EK_wavyline, ED_from_top,     -1, true }, // AnimationEffect_WAVYLINE_FROM_TOP
+    { EK_wavyline, ED_from_right,   -1, true }, // AnimationEffect_WAVYLINE_FROM_RIGHT
+    { EK_wavyline, ED_from_bottom,  -1, true }, // AnimationEffect_WAVYLINE_FROM_BOTTOM
+    { EK_random, ED_none,           -1, true }, // AnimationEffect_RANDOM
+    { EK_lines, ED_vertical,        -1, true }, // AnimationEffect_VERTICAL_LINES
+    { EK_lines, ED_horizontal,      -1, true }, // AnimationEffect_HORIZONTAL_LINES
+    { EK_laser, ED_from_left,       -1, true }, // AnimationEffect_LASER_FROM_LEFT
+    { EK_laser, ED_from_top,        -1, true }, // AnimationEffect_LASER_FROM_TOP
+    { EK_laser, ED_from_right,      -1, true }, // AnimationEffect_LASER_FROM_RIGHT
+    { EK_laser, ED_from_bottom,     -1, true }, // AnimationEffect_LASER_FROM_BOTTOM
+    { EK_laser, ED_from_upperleft,  -1, true }, // AnimationEffect_LASER_FROM_UPPERLEFT
+    { EK_laser, ED_from_upperright, -1, true }, // AnimationEffect_LASER_FROM_UPPERRIGHT
+    { EK_laser, ED_from_lowerleft,  -1, true }, // AnimationEffect_LASER_FROM_LOWERLEFT
+    { EK_laser, ED_from_lowerright, -1, true }, // AnimationEffect_LASER_FROM_LOWERRIGHT
+    { EK_appear,ED_none,            -1, true }, // AnimationEffect_APPEAR
+    { EK_hide,  ED_none,            -1, false },// AnimationEffect_HIDE
+    { EK_move,  ED_from_upperleft,  -1, true }, // AnimationEffect_MOVE_FROM_UPPERLEFT
+    { EK_move,  ED_from_upperright, -1, true }, // AnimationEffect_MOVE_FROM_UPPERRIGHT
+    { EK_move,  ED_from_lowerright, -1, true }, // AnimationEffect_MOVE_FROM_LOWERRIGHT
+    { EK_move,  ED_from_lowerleft,  -1, true }, // AnimationEffect_MOVE_FROM_LOWERLEFT
+    { EK_move,  ED_to_upperleft,    -1, false },// AnimationEffect_MOVE_TO_UPPERLEFT
+    { EK_move,  ED_to_upperright,   -1, false },// AnimationEffect_MOVE_TO_UPPERRIGHT
+    { EK_move,  ED_to_lowerright,   -1, false },// AnimationEffect_MOVE_TO_LOWERRIGHT
+    { EK_move,  ED_to_lowerleft,    -1, false },// AnimationEffect_MOVE_TO_LOWERLEFT
+    { EK_move_short, ED_from_left,  -1, true }, // AnimationEffect_MOVE_SHORT_FROM_LEFT
+    { EK_move_short, ED_from_upperleft, -1, true }, // AnimationEffect_MOVE_SHORT_FROM_UPPERLEFT
+    { EK_move_short, ED_from_top,       -1, true }, // AnimationEffect_MOVE_SHORT_FROM_TOP
+    { EK_move_short, ED_from_upperright,-1, true }, // AnimationEffect_MOVE_SHORT_FROM_UPPERRIGHT
+    { EK_move_short, ED_from_right,     -1, true }, // AnimationEffect_MOVE_SHORT_FROM_RIGHT
+    { EK_move_short, ED_from_lowerright,-1, true }, // AnimationEffect_MOVE_SHORT_FROM_LOWERRIGHT
+    { EK_move_short, ED_from_bottom,    -1, true }, // AnimationEffect_MOVE_SHORT_FROM_BOTTOM
+    { EK_move_short, ED_from_lowerleft, -1, true }, // AnimationEffect_MOVE_SHORT_FROM_LOWERLEFT
+    { EK_move_short, ED_to_left,        -1, false },// AnimationEffect_MOVE_SHORT_TO_LEFT
+    { EK_move_short, ED_to_upperleft,   -1, false },// AnimationEffect_MOVE_SHORT_TO_UPPERLEFT
+    { EK_move_short, ED_to_top,         -1, false },// AnimationEffect_MOVE_SHORT_TO_TOP
+    { EK_move_short, ED_to_upperright,  -1, false },// AnimationEffect_MOVE_SHORT_TO_UPPERRIGHT
+    { EK_move_short, ED_to_right,       -1, false },// AnimationEffect_MOVE_SHORT_TO_RIGHT
+    { EK_move_short, ED_to_lowerright,  -1, false },// AnimationEffect_MOVE_SHORT_TO_LOWERRIGHT
+    { EK_move_short, ED_to_bottom,      -1, false },// AnimationEffect_MOVE_SHORT_TO_BOTTOM
+    { EK_move_short, ED_to_lowerleft,   -1, false },// AnimationEffect_MOVE_SHORT_TO_LOWERLEFT
+    { EK_checkerboard, ED_vertical,     -1, true }, // AnimationEffect_VERTICAL_CHECKERBOARD
+    { EK_checkerboard, ED_horizontal,   -1, true }, // AnimationEffect_HORIZONTAL_CHECKERBOARD
+    { EK_rotate, ED_horizontal,     -1, true }, // AnimationEffect_HORIZONTAL_ROTATE
+    { EK_rotate, ED_vertical,       -1, true }, // AnimationEffect_VERTICAL_ROTATE
+    { EK_stretch,ED_horizontal,     -1, true }, // AnimationEffect_HORIZONTAL_STRETCH
+    { EK_stretch,ED_vertical,       -1, true }, // AnimationEffect_VERTICAL_STRETCH
+    { EK_stretch,ED_from_left,      -1, true }, // AnimationEffect_STRETCH_FROM_LEFT
+    { EK_stretch,ED_from_upperleft, -1, true }, // AnimationEffect_STRETCH_FROM_UPPERLEFT
+    { EK_stretch,ED_from_top,       -1, true }, // AnimationEffect_STRETCH_FROM_TOP
+    { EK_stretch,ED_from_upperright,-1, true }, // AnimationEffect_STRETCH_FROM_UPPERRIGHT
+    { EK_stretch,ED_from_right,     -1, true }, // AnimationEffect_STRETCH_FROM_RIGHT
+    { EK_stretch,ED_from_lowerright,-1, true }, // AnimationEffect_STRETCH_FROM_LOWERRIGHT
+    { EK_stretch,ED_from_bottom,    -1, true }, // AnimationEffect_STRETCH_FROM_BOTTOM
+    { EK_stretch,ED_from_lowerleft, -1, true }, // AnimationEffect_STRETCH_FROM_LOWERLEFT
+    { EK_move,  ED_none,             0, true }, // AnimationEffect_ZOOM_IN
+    { EK_move,  ED_none,            50, true }, // AnimationEffect_ZOOM_IN_SMALL
+    { EK_move,  ED_spiral_inward_left,   0, true }, // AnimationEffect_ZOOM_IN_SPIRAL
+    { EK_move,  ED_none,           400, true }, // AnimationEffect_ZOOM_OUT
+    { EK_move,  ED_none,           200, true }, // AnimationEffect_ZOOM_OUT_SMALL
+    { EK_move,  ED_spiral_inward_left, 400, true }, // AnimationEffect_ZOOM_OUT_SPIRAL
+    { EK_move,  ED_from_left,        0, true }, // AnimationEffect_ZOOM_IN_FROM_LEFT
+    { EK_move,  ED_from_upperleft,   0, true }, // AnimationEffect_ZOOM_IN_FROM_UPPERLEFT
+    { EK_move,  ED_from_top,         0, true }, // AnimationEffect_ZOOM_IN_FROM_TOP
+    { EK_move,  ED_from_upperright,  0, true }, // AnimationEffect_ZOOM_IN_FROM_UPPERRIGHT
+    { EK_move,  ED_from_right,       0, true }, // AnimationEffect_ZOOM_IN_FROM_RIGHT
+    { EK_move,  ED_from_lowerright,  0, true }, // AnimationEffect_ZOOM_IN_FROM_LOWERRIGHT
+    { EK_move,  ED_from_bottom,      0, true }, // AnimationEffect_ZOOM_IN_FROM_BOTTOM
+    { EK_move,  ED_from_lowerleft,   0, true }, // AnimationEffect_ZOOM_IN_FROM_LOWERLEFT
+    { EK_move,  ED_from_center,      0, true }, // AnimationEffect_ZOOM_IN_FROM_CENTER
+    { EK_move,  ED_from_left,      400, true }, // AnimationEffect_ZOOM_OUT_FROM_LEFT
+    { EK_move,  ED_from_upperleft, 400, true }, // AnimationEffect_ZOOM_OUT_FROM_UPPERLEFT
+    { EK_move,  ED_from_top,       400, true }, // AnimationEffect_ZOOM_OUT_FROM_TOP
+    { EK_move,  ED_from_upperright,400, true }, // AnimationEffect_ZOOM_OUT_FROM_UPPERRIGHT
+    { EK_move,  ED_from_right,     400, true }, // AnimationEffect_ZOOM_OUT_FROM_RIGHT
+    { EK_move,  ED_from_lowerright,400, true }, // AnimationEffect_ZOOM_OUT_FROM_LOWERRIGHT
+    { EK_move,  ED_from_bottom,    400, true }, // AnimationEffect_ZOOM_OUT_FROM_BOTTOM
+    { EK_move,  ED_from_lowerleft, 400, true }, // AnimationEffect_ZOOM_OUT_FROM_LOWERLEFT
+    { EK_move,  ED_from_center,    400, true }  // AnimationEffect_ZOOM_OUT_FROM_CENTER
+};
+
+void SdXMLImplSetEffect( AnimationEffect eEffect, XMLEffect& eKind, XMLEffectDirection& eDirection, sal_Int16& nStartScale, bool& bIn )
+{
+    if( eEffect < AnimationEffect_NONE || eEffect > AnimationEffect_ZOOM_OUT_FROM_CENTER )
+    {
+        OSL_FAIL( "unknown animation effect!" );
+        eEffect = AnimationEffect_NONE;
+    }
+
+    const Effect& rEffect = AnimationEffectMap[static_cast<int>(eEffect)];
+    eKind = rEffect.meKind;
+    eDirection = rEffect.meDirection;
+    nStartScale = rEffect.mnStartScale;
+    bIn = rEffect.mbIn;
+}
+
+namespace {
+
+enum XMLActionKind : sal_Int8
+{
+    XMLE_SHOW,
+    XMLE_HIDE,
+    XMLE_DIM,
+    XMLE_PLAY
+};
+
+struct XMLEffectHint
+{
+    Reference<XShape> mxShape;
+    XMLActionKind   meKind;
+    bool            mbTextEffect;
+
+    XMLEffect       meEffect;
+    XMLEffectDirection  meDirection;
+    sal_Int16       mnStartScale;
+
+    AnimationSpeed  meSpeed;
+    OUString        maSoundURL;
+    sal_Int32       maDimColor;
+    sal_Int32       mnPresId;
+    bool        mbPlayFull;
+
+    bool operator<(const XMLEffectHint& rComp) const { return mnPresId < rComp.mnPresId; }
+
+    XMLEffectHint()
+    :   meKind( XMLE_SHOW ), mbTextEffect( false ),
+        meEffect( EK_none ), meDirection( ED_none ), mnStartScale( -1 ),
+        meSpeed( AnimationSpeed_SLOW ), maDimColor(0),
+        mnPresId( 0 ), mbPlayFull( false )
+        {}
+};
+
+}
+
+class AnimExpImpl
+{
+public:
+    list<XMLEffectHint> maEffects;
+
+    static constexpr OUStringLiteral gsDimColor = u"DimColor";
+    static constexpr OUStringLiteral gsDimHide = u"DimHide";
+    static constexpr OUStringLiteral gsDimPrev = u"DimPrevious";
+    static constexpr OUStringLiteral gsEffect = u"Effect";
+    static constexpr OUStringLiteral gsPlayFull = u"PlayFull";
+    static constexpr OUStringLiteral gsPresOrder = u"PresentationOrder";
+    static constexpr OUStringLiteral gsSound = u"Sound";
+    static constexpr OUStringLiteral gsSoundOn = u"SoundOn";
+    static constexpr OUStringLiteral gsSpeed = u"Speed";
+    static constexpr OUStringLiteral gsTextEffect = u"TextEffect";
+    static constexpr OUStringLiteral gsIsAnimation = u"IsAnimation";
+    static constexpr OUStringLiteral gsAnimPath = u"AnimationPath";
+};
+
+XMLAnimationsExporter::XMLAnimationsExporter()
+    : mpImpl( new AnimExpImpl )
+{
+}
+
+XMLAnimationsExporter::~XMLAnimationsExporter()
+{
+}
+
+void XMLAnimationsExporter::prepare( const Reference< XShape >& xShape )
+{
+    try
+    {
+        // check for presentation shape service
+        {
+            Reference< XServiceInfo > xServiceInfo( xShape, UNO_QUERY );
+            if( !xServiceInfo.is() || !xServiceInfo->supportsService("com.sun.star.presentation.Shape") )
+                return;
+        }
+
+        Reference< XPropertySet > xProps( xShape, UNO_QUERY );
+        if( xProps.is() )
+        {
+            AnimationEffect eEffect;
+            xProps->getPropertyValue( AnimExpImpl::gsEffect ) >>= eEffect;
+            if( eEffect == AnimationEffect_PATH )
+            {
+                Reference< XShape > xPath;
+                xProps->getPropertyValue( AnimExpImpl::gsAnimPath ) >>= xPath;
+            }
+        }
+    }
+    catch (const Exception&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw",
+                             "exception caught while collection animation information!");
+    }
+}
+
+void XMLAnimationsExporter::collect( const Reference< XShape >& xShape, SvXMLExport& rExport )
+{
+    try
+    {
+        // check for presentation shape service
+        {
+            Reference< XServiceInfo > xServiceInfo( xShape, UNO_QUERY );
+            if( !xServiceInfo.is() || !xServiceInfo->supportsService("com.sun.star.presentation.Shape") )
+                return;
+        }
+
+        Reference< XPropertySet > xProps( xShape, UNO_QUERY );
+        if( xProps.is() )
+        {
+            XMLEffectHint aEffect;
+
+            if( any2bool( xProps->getPropertyValue( AnimExpImpl::gsSoundOn ) ) )
+            {
+                xProps->getPropertyValue( AnimExpImpl::gsSound ) >>= aEffect.maSoundURL;
+                xProps->getPropertyValue( AnimExpImpl::gsPlayFull ) >>= aEffect.mbPlayFull;
+            }
+
+            xProps->getPropertyValue( AnimExpImpl::gsPresOrder ) >>= aEffect.mnPresId;
+            xProps->getPropertyValue( AnimExpImpl::gsSpeed ) >>= aEffect.meSpeed;
+
+
+            bool bIsAnimation = false;
+            xProps->getPropertyValue( AnimExpImpl::gsIsAnimation ) >>= bIsAnimation;
+            if( bIsAnimation )
+            {
+                aEffect.meKind = XMLE_PLAY;
+
+                if( !aEffect.mxShape.is() )
+                {
+                    rExport.getInterfaceToIdentifierMapper().registerReference( xShape );
+                    aEffect.mxShape = xShape;
+                }
+
+                mpImpl->maEffects.push_back( aEffect );
+            }
+
+            {
+                AnimationEffect eEffect;
+                xProps->getPropertyValue( AnimExpImpl::gsEffect ) >>= eEffect;
+                if( eEffect != AnimationEffect_NONE )
+                {
+                    bool bIn = true;
+                    SdXMLImplSetEffect( eEffect, aEffect.meEffect, aEffect.meDirection, aEffect.mnStartScale, bIn );
+
+                    aEffect.meKind = bIn ? XMLE_SHOW : XMLE_HIDE;
+
+                    if( !aEffect.mxShape.is() )
+                    {
+                        rExport.getInterfaceToIdentifierMapper().registerReference( xShape );
+                        aEffect.mxShape = xShape;
+                    }
+
+                    if( eEffect == AnimationEffect_PATH )
+                    {
+                        Reference< XShape > xPath;
+                        xProps->getPropertyValue( AnimExpImpl::gsAnimPath ) >>= xPath;
+                        if( xPath.is() )
+                        {
+// strip                    mpImpl->mxShapeExp->createShapeId( xPath );
+// strip                    aEffect.mnPathShapeId = mpImpl->mxShapeExp->getShapeId( xPath );
+                        }
+                    }
+                    mpImpl->maEffects.push_back( aEffect );
+
+                    aEffect.maSoundURL.clear();
+                }
+
+                xProps->getPropertyValue( AnimExpImpl::gsTextEffect ) >>= eEffect;
+                if( eEffect != AnimationEffect_NONE )
+                {
+                    bool bIn = true;
+                    SdXMLImplSetEffect( eEffect, aEffect.meEffect, aEffect.meDirection, aEffect.mnStartScale, bIn );
+                    aEffect.meKind = bIn ? XMLE_SHOW : XMLE_HIDE;
+                    aEffect.mbTextEffect = true;
+
+                    if( !aEffect.mxShape.is() )
+                    {
+                        rExport.getInterfaceToIdentifierMapper().registerReference( xShape );
+                        aEffect.mxShape = xShape;
+                    }
+
+                    mpImpl->maEffects.push_back( aEffect );
+                    aEffect.mbTextEffect = false;
+                    aEffect.maSoundURL.clear();
+                }
+
+                bool bDimPrev = false;
+                bool bDimHide = false;
+                xProps->getPropertyValue( AnimExpImpl::gsDimPrev ) >>= bDimPrev;
+                xProps->getPropertyValue( AnimExpImpl::gsDimHide ) >>= bDimHide;
+                if( bDimPrev || bDimHide )
+                {
+                    aEffect.meKind = bDimPrev ? XMLE_DIM : XMLE_HIDE;
+                    aEffect.meEffect = EK_none;
+                    aEffect.meDirection = ED_none;
+                    aEffect.meSpeed = AnimationSpeed_MEDIUM;
+                    if( bDimPrev )
+                    {
+                        xProps->getPropertyValue( AnimExpImpl::gsDimColor )
+                            >>= aEffect.maDimColor;
+                    }
+
+                    if( !aEffect.mxShape.is() )
+                    {
+                        rExport.getInterfaceToIdentifierMapper().registerReference( xShape );
+                        aEffect.mxShape = xShape;
+                    }
+
+                    mpImpl->maEffects.push_back( aEffect );
+                    aEffect.maSoundURL.clear();
+                }
+            }
+        }
+    }
+    catch (const Exception&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw",
+                             "exception caught while collection animation information!");
+    }
+}
+
+void XMLAnimationsExporter::exportAnimations( SvXMLExport& rExport )
+{
+    mpImpl->maEffects.sort();
+
+    OUStringBuffer sTmp;
+
+    if( !mpImpl->maEffects.empty() )
+    {
+        SvXMLElementExport aElement( rExport, XML_NAMESPACE_PRESENTATION, XML_ANIMATIONS, true, true );
+
+        for (const auto& rEffect : mpImpl->maEffects)
+        {
+            SAL_WARN_IF( !rEffect.mxShape.is(), "xmloff", "shape id creation failed for animation effect?" );
+
+            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_SHAPE_ID, rExport.getInterfaceToIdentifierMapper().getIdentifier( rEffect.mxShape ) );
+
+            if( rEffect.meKind == XMLE_DIM )
+            {
+                // export a dim action;
+
+                ::sax::Converter::convertColor( sTmp, rEffect.maDimColor );
+                rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_COLOR, sTmp.makeStringAndClear() );
+
+                SvXMLElementExport aElem( rExport, XML_NAMESPACE_PRESENTATION, XML_DIM, true, true );
+            }
+            else if( rEffect.meKind == XMLE_PLAY )
+            {
+                if( rEffect.meSpeed != AnimationSpeed_MEDIUM )
+                {
+                    SvXMLUnitConverter::convertEnum( sTmp, rEffect.meSpeed, aXML_AnimationSpeed_EnumMap );
+                    rExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_SPEED, sTmp.makeStringAndClear() );
+                }
+
+                SvXMLElementExport aElem( rExport, XML_NAMESPACE_PRESENTATION, XML_PLAY, true, true );
+            }
+            else
+            {
+
+                if( rEffect.meEffect != EK_none )
+                {
+                    SvXMLUnitConverter::convertEnum( sTmp, rEffect.meEffect, aXML_AnimationEffect_EnumMap );
+                    rExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_EFFECT, sTmp.makeStringAndClear() );
+                }
+
+                if( rEffect.meDirection != ED_none )
+                {
+                    SvXMLUnitConverter::convertEnum( sTmp, rEffect.meDirection, aXML_AnimationDirection_EnumMap );
+                    rExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_DIRECTION, sTmp.makeStringAndClear() );
+                }
+
+                if( rEffect.mnStartScale != -1 )
+                {
+                    ::sax::Converter::convertPercent(sTmp, rEffect.mnStartScale);
+                    rExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_START_SCALE, sTmp.makeStringAndClear() );
+                }
+
+                if( rEffect.meSpeed != AnimationSpeed_MEDIUM )
+                {
+                    SvXMLUnitConverter::convertEnum( sTmp, rEffect.meSpeed, aXML_AnimationSpeed_EnumMap );
+                    rExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_SPEED, sTmp.makeStringAndClear() );
+                }
+
+                enum XMLTokenEnum eLocalName;
+                if( rEffect.meKind == XMLE_SHOW )
+                {
+                    if( rEffect.mbTextEffect )
+                        eLocalName = XML_SHOW_TEXT;
+                    else
+                        eLocalName = XML_SHOW_SHAPE;
+                }
+                else
+                {
+                    if( rEffect.mbTextEffect )
+                        eLocalName = XML_HIDE_TEXT;
+                    else
+                        eLocalName = XML_HIDE_SHAPE;
+                }
+
+                SvXMLElementExport aEle( rExport, XML_NAMESPACE_PRESENTATION, eLocalName, true, true );
+                if( !rEffect.maSoundURL.isEmpty() )
+                {
+                    rExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, rExport.GetRelativeReference(rEffect.maSoundURL) );
+                    rExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+                    rExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_NEW );
+                    rExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONREQUEST );
+                    if( rEffect.mbPlayFull )
+                        rExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_PLAY_FULL, XML_TRUE );
+
+                    SvXMLElementExport aElem( rExport, XML_NAMESPACE_PRESENTATION, XML_SOUND, true, true );
+                }
+            }
+        }
+    }
+
+    mpImpl->maEffects.clear();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/animimp.cxx b/xmloff/source/draw/animimp.cxx
new file mode 100644
index 000000000..ffdd3bef7
--- /dev/null
+++ b/xmloff/source/draw/animimp.cxx
@@ -0,0 +1,598 @@
+/* -*- 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 <string_view>
+
+#include <xmloff/unointerfacetouniqueidentifiermapper.hxx>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/presentation/AnimationEffect.hpp>
+#include <com/sun/star/presentation/AnimationSpeed.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/drawing/XShape.hpp>
+#include <com/sun/star/xml/sax/XAttributeList.hpp>
+
+#include <sax/tools/converter.hxx>
+#include <sal/log.hxx>
+#include <tools/diagnose_ex.h>
+
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/namespacemap.hxx>
+#include <anim.hxx>
+#include <animimp.hxx>
+
+using namespace ::std;
+using namespace ::cppu;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::xml;
+using namespace ::com::sun::star::xml::sax;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::drawing;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::presentation;
+using namespace ::xmloff::token;
+
+const SvXMLEnumMapEntry<XMLEffect> aXML_AnimationEffect_EnumMap[] =
+{
+    { XML_NONE,         EK_none },
+    { XML_FADE,         EK_fade },
+    { XML_MOVE,         EK_move },
+    { XML_STRIPES,      EK_stripes },
+    { XML_OPEN,         EK_open },
+    { XML_CLOSE,        EK_close },
+    { XML_DISSOLVE,     EK_dissolve },
+    { XML_WAVYLINE,     EK_wavyline },
+    { XML_RANDOM,       EK_random },
+    { XML_LINES,        EK_lines },
+    { XML_LASER,        EK_laser },
+    { XML_APPEAR,       EK_appear },
+    { XML_HIDE,         EK_hide },
+    { XML_MOVE_SHORT,   EK_move_short },
+    { XML_CHECKERBOARD, EK_checkerboard },
+    { XML_ROTATE,       EK_rotate },
+    { XML_STRETCH,      EK_stretch },
+    { XML_TOKEN_INVALID, XMLEffect(0) }
+};
+
+const SvXMLEnumMapEntry<XMLEffectDirection> aXML_AnimationDirection_EnumMap[] =
+{
+    { XML_NONE,             ED_none },
+    { XML_FROM_LEFT,        ED_from_left },
+    { XML_FROM_TOP,         ED_from_top },
+    { XML_FROM_RIGHT,       ED_from_right },
+    { XML_FROM_BOTTOM,      ED_from_bottom },
+    { XML_FROM_CENTER,      ED_from_center },
+    { XML_FROM_UPPER_LEFT,  ED_from_upperleft },
+    { XML_FROM_UPPER_RIGHT, ED_from_upperright },
+    { XML_FROM_LOWER_LEFT,  ED_from_lowerleft },
+    { XML_FROM_LOWER_RIGHT, ED_from_lowerright },
+    { XML_TO_LEFT,          ED_to_left },
+    { XML_TO_TOP,           ED_to_top },
+    { XML_TO_RIGHT,         ED_to_right },
+    { XML_TO_BOTTOM,        ED_to_bottom },
+    { XML_TO_UPPER_LEFT,    ED_to_upperleft },
+    { XML_TO_UPPER_RIGHT,   ED_to_upperright },
+    { XML_TO_LOWER_RIGHT,   ED_to_lowerright },
+    { XML_TO_LOWER_LEFT,    ED_to_lowerleft },
+    { XML_PATH,             ED_path },
+    { XML_SPIRAL_INWARD_LEFT, ED_spiral_inward_left },
+    { XML_SPIRAL_INWARD_RIGHT,ED_spiral_inward_right },
+    { XML_SPIRAL_OUTWARD_LEFT, ED_spiral_outward_left },
+    { XML_SPIRAL_OUTWARD_RIGHT, ED_spiral_outward_right },
+    { XML_VERTICAL,         ED_vertical },
+    { XML_HORIZONTAL,       ED_horizontal },
+    { XML_TO_CENTER,        ED_to_center },
+    { XML_CLOCKWISE,        ED_clockwise },
+    { XML_COUNTER_CLOCKWISE,ED_cclockwise },
+    { XML_TOKEN_INVALID, XMLEffectDirection(0) }
+};
+
+const SvXMLEnumMapEntry<AnimationSpeed> aXML_AnimationSpeed_EnumMap[] =
+{
+    { XML_SLOW,     AnimationSpeed_SLOW },
+    { XML_MEDIUM,   AnimationSpeed_MEDIUM },
+    { XML_FAST,     AnimationSpeed_FAST },
+    { XML_TOKEN_INVALID, AnimationSpeed(0) }
+};
+
+AnimationEffect ImplSdXMLgetEffect( XMLEffect eKind, XMLEffectDirection eDirection, sal_Int16 nStartScale, bool /*bIn*/ )
+{
+    switch( eKind )
+    {
+    case EK_fade:
+        switch( eDirection )
+        {
+        case ED_from_left:          return AnimationEffect_FADE_FROM_LEFT;
+        case ED_from_top:           return AnimationEffect_FADE_FROM_TOP;
+        case ED_from_right:         return AnimationEffect_FADE_FROM_RIGHT;
+        case ED_from_bottom:        return AnimationEffect_FADE_FROM_BOTTOM;
+        case ED_from_center:        return AnimationEffect_FADE_FROM_CENTER;
+        case ED_from_upperleft:     return AnimationEffect_FADE_FROM_UPPERLEFT;
+        case ED_from_upperright:    return AnimationEffect_FADE_FROM_UPPERRIGHT;
+        case ED_from_lowerleft:     return AnimationEffect_FADE_FROM_LOWERLEFT;
+        case ED_from_lowerright:    return AnimationEffect_FADE_FROM_LOWERRIGHT;
+        case ED_to_center:          return AnimationEffect_FADE_TO_CENTER;
+        case ED_clockwise:          return AnimationEffect_CLOCKWISE;
+        case ED_cclockwise:         return AnimationEffect_COUNTERCLOCKWISE;
+        case ED_spiral_inward_left: return AnimationEffect_SPIRALIN_LEFT;
+        case ED_spiral_inward_right:return AnimationEffect_SPIRALIN_RIGHT;
+        case ED_spiral_outward_left:return AnimationEffect_SPIRALOUT_LEFT;
+        case ED_spiral_outward_right:return AnimationEffect_SPIRALOUT_RIGHT;
+        default:                    return AnimationEffect_FADE_FROM_LEFT;
+        }
+    case EK_move:
+        if( nStartScale == 200 )
+        {
+            return AnimationEffect_ZOOM_OUT_SMALL;
+        }
+        else if( nStartScale == 50 )
+        {
+            return AnimationEffect_ZOOM_IN_SMALL;
+        }
+        else if( nStartScale < 100 )
+        {
+            switch( eDirection )
+            {
+            case ED_from_left:          return AnimationEffect_ZOOM_IN_FROM_LEFT;
+            case ED_from_top:           return AnimationEffect_ZOOM_IN_FROM_TOP;
+            case ED_from_right:         return AnimationEffect_ZOOM_IN_FROM_RIGHT;
+            case ED_from_bottom:        return AnimationEffect_ZOOM_IN_FROM_BOTTOM;
+            case ED_from_upperleft:     return AnimationEffect_ZOOM_IN_FROM_UPPERLEFT;
+            case ED_from_upperright:    return AnimationEffect_ZOOM_IN_FROM_UPPERRIGHT;
+            case ED_from_lowerleft:     return AnimationEffect_ZOOM_IN_FROM_LOWERLEFT;
+            case ED_from_lowerright:    return AnimationEffect_ZOOM_IN_FROM_LOWERRIGHT;
+            case ED_from_center:        return AnimationEffect_ZOOM_IN_FROM_CENTER;
+            case ED_spiral_inward_left: return AnimationEffect_ZOOM_IN_SPIRAL;
+            case ED_to_left:            return AnimationEffect_MOVE_TO_LEFT;
+            case ED_to_top:             return AnimationEffect_MOVE_TO_TOP;
+            case ED_to_right:           return AnimationEffect_MOVE_TO_RIGHT;
+            case ED_to_bottom:          return AnimationEffect_MOVE_TO_BOTTOM;
+            case ED_to_upperleft:       return AnimationEffect_MOVE_TO_UPPERLEFT;
+            case ED_to_upperright:      return AnimationEffect_MOVE_TO_UPPERRIGHT;
+            case ED_to_lowerright:      return AnimationEffect_MOVE_TO_LOWERRIGHT;
+            case ED_to_lowerleft:       return AnimationEffect_MOVE_TO_LOWERLEFT;
+            default:                    return AnimationEffect_ZOOM_IN;
+            }
+        }
+        else if( nStartScale > 100 )
+        {
+            switch( eDirection )
+            {
+            case ED_from_left:          return AnimationEffect_ZOOM_OUT_FROM_LEFT;
+            case ED_from_top:           return AnimationEffect_ZOOM_OUT_FROM_TOP;
+            case ED_from_right:         return AnimationEffect_ZOOM_OUT_FROM_RIGHT;
+            case ED_from_bottom:        return AnimationEffect_ZOOM_OUT_FROM_BOTTOM;
+            case ED_from_upperleft:     return AnimationEffect_ZOOM_OUT_FROM_UPPERLEFT;
+            case ED_from_upperright:    return AnimationEffect_ZOOM_OUT_FROM_UPPERRIGHT;
+            case ED_from_lowerleft:     return AnimationEffect_ZOOM_OUT_FROM_LOWERLEFT;
+            case ED_from_lowerright:    return AnimationEffect_ZOOM_OUT_FROM_LOWERRIGHT;
+            case ED_from_center:        return AnimationEffect_ZOOM_OUT_FROM_CENTER;
+            case ED_spiral_inward_left: return AnimationEffect_ZOOM_OUT_SPIRAL;
+            default:                    return AnimationEffect_ZOOM_OUT;
+            }
+        }
+        else
+        {
+            switch( eDirection )
+            {
+            case ED_from_left:          return AnimationEffect_MOVE_FROM_LEFT;
+            case ED_from_top:           return AnimationEffect_MOVE_FROM_TOP;
+            case ED_from_right:         return AnimationEffect_MOVE_FROM_RIGHT;
+            case ED_from_bottom:        return AnimationEffect_MOVE_FROM_BOTTOM;
+            case ED_from_upperleft:     return AnimationEffect_MOVE_FROM_UPPERLEFT;
+            case ED_from_upperright:    return AnimationEffect_MOVE_FROM_UPPERRIGHT;
+            case ED_from_lowerleft:     return AnimationEffect_MOVE_FROM_LOWERLEFT;
+            case ED_from_lowerright:    return AnimationEffect_MOVE_FROM_LOWERRIGHT;
+            case ED_path:               return AnimationEffect_PATH;
+            case ED_to_top:             return AnimationEffect_MOVE_TO_TOP;
+            case ED_to_right:           return AnimationEffect_MOVE_TO_RIGHT;
+            case ED_to_bottom:          return AnimationEffect_MOVE_TO_BOTTOM;
+            case ED_to_upperleft:       return AnimationEffect_MOVE_TO_UPPERLEFT;
+            case ED_to_upperright:      return AnimationEffect_MOVE_TO_UPPERRIGHT;
+            case ED_to_lowerright:      return AnimationEffect_MOVE_TO_LOWERRIGHT;
+            case ED_to_lowerleft:       return AnimationEffect_MOVE_TO_LOWERLEFT;
+            default:
+                break;
+            }
+        }
+        return AnimationEffect_MOVE_FROM_LEFT;
+    case EK_stripes:
+        if( eDirection == ED_vertical )
+            return AnimationEffect_VERTICAL_STRIPES;
+        else
+            return AnimationEffect_HORIZONTAL_STRIPES;
+    case EK_open:
+        if( eDirection == ED_vertical )
+            return AnimationEffect_OPEN_VERTICAL;
+        else
+            return AnimationEffect_OPEN_HORIZONTAL;
+    case EK_close:
+        if( eDirection == ED_vertical )
+            return AnimationEffect_CLOSE_VERTICAL;
+        else
+            return AnimationEffect_CLOSE_HORIZONTAL;
+    case EK_dissolve:
+        return AnimationEffect_DISSOLVE;
+    case EK_wavyline:
+        switch( eDirection )
+        {
+        case ED_from_left:          return AnimationEffect_WAVYLINE_FROM_LEFT;
+        case ED_from_top:           return AnimationEffect_WAVYLINE_FROM_TOP;
+        case ED_from_right:         return AnimationEffect_WAVYLINE_FROM_RIGHT;
+        case ED_from_bottom:        return AnimationEffect_WAVYLINE_FROM_BOTTOM;
+        default:                    return AnimationEffect_WAVYLINE_FROM_LEFT;
+        }
+    case EK_random:
+        return AnimationEffect_RANDOM;
+    case EK_lines:
+        if( eDirection == ED_vertical )
+            return AnimationEffect_VERTICAL_LINES;
+        else
+            return AnimationEffect_HORIZONTAL_LINES;
+    case EK_laser:
+        switch( eDirection )
+        {
+        case ED_from_left:          return AnimationEffect_LASER_FROM_LEFT;
+        case ED_from_top:           return AnimationEffect_LASER_FROM_TOP;
+        case ED_from_right:         return AnimationEffect_LASER_FROM_RIGHT;
+        case ED_from_bottom:        return AnimationEffect_LASER_FROM_BOTTOM;
+        case ED_from_upperleft:     return AnimationEffect_LASER_FROM_UPPERLEFT;
+        case ED_from_upperright:    return AnimationEffect_LASER_FROM_UPPERRIGHT;
+        case ED_from_lowerleft:     return AnimationEffect_LASER_FROM_LOWERLEFT;
+        case ED_from_lowerright:    return AnimationEffect_LASER_FROM_LOWERRIGHT;
+        default:                    return AnimationEffect_LASER_FROM_LEFT;
+        }
+    case EK_appear:
+        return AnimationEffect_APPEAR;
+    case EK_hide:
+        return AnimationEffect_HIDE;
+    case EK_move_short:
+        switch( eDirection )
+        {
+        case ED_from_left:          return AnimationEffect_MOVE_SHORT_FROM_LEFT;
+        case ED_from_top:           return AnimationEffect_MOVE_SHORT_FROM_TOP;
+        case ED_from_right:         return AnimationEffect_MOVE_SHORT_FROM_RIGHT;
+        case ED_from_bottom:        return AnimationEffect_MOVE_SHORT_FROM_BOTTOM;
+        case ED_from_upperleft:     return AnimationEffect_MOVE_SHORT_FROM_UPPERLEFT;
+        case ED_from_upperright:    return AnimationEffect_MOVE_SHORT_FROM_UPPERRIGHT;
+        case ED_from_lowerleft:     return AnimationEffect_MOVE_SHORT_FROM_LOWERLEFT;
+        case ED_from_lowerright:    return AnimationEffect_MOVE_SHORT_FROM_LOWERRIGHT;
+        case ED_to_left:            return AnimationEffect_MOVE_SHORT_TO_LEFT;
+        case ED_to_upperleft:       return AnimationEffect_MOVE_SHORT_TO_UPPERLEFT;
+        case ED_to_top:             return AnimationEffect_MOVE_SHORT_TO_TOP;
+        case ED_to_upperright:      return AnimationEffect_MOVE_SHORT_TO_UPPERRIGHT;
+        case ED_to_right:           return AnimationEffect_MOVE_SHORT_TO_RIGHT;
+        case ED_to_lowerright:      return AnimationEffect_MOVE_SHORT_TO_LOWERRIGHT;
+        case ED_to_bottom:          return AnimationEffect_MOVE_SHORT_TO_BOTTOM;
+        case ED_to_lowerleft:       return AnimationEffect_MOVE_SHORT_TO_LOWERLEFT;
+        default:                    return AnimationEffect_MOVE_SHORT_FROM_LEFT;
+        }
+    case EK_checkerboard:
+        if( eDirection == ED_vertical )
+            return AnimationEffect_VERTICAL_CHECKERBOARD;
+        else
+            return AnimationEffect_HORIZONTAL_CHECKERBOARD;
+    case EK_rotate:
+        if( eDirection == ED_vertical )
+            return AnimationEffect_VERTICAL_ROTATE;
+        else
+            return AnimationEffect_HORIZONTAL_ROTATE;
+    case EK_stretch:
+        switch( eDirection )
+        {
+        case ED_from_left:          return AnimationEffect_STRETCH_FROM_LEFT;
+        case ED_from_top:           return AnimationEffect_STRETCH_FROM_TOP;
+        case ED_from_right:         return AnimationEffect_STRETCH_FROM_RIGHT;
+        case ED_from_bottom:        return AnimationEffect_STRETCH_FROM_BOTTOM;
+        case ED_from_upperleft:     return AnimationEffect_STRETCH_FROM_UPPERLEFT;
+        case ED_from_upperright:    return AnimationEffect_STRETCH_FROM_UPPERRIGHT;
+        case ED_from_lowerleft:     return AnimationEffect_STRETCH_FROM_LOWERLEFT;
+        case ED_from_lowerright:    return AnimationEffect_STRETCH_FROM_LOWERRIGHT;
+        case ED_vertical:           return AnimationEffect_VERTICAL_STRETCH;
+        case ED_horizontal:         return AnimationEffect_HORIZONTAL_STRETCH;
+        default:
+            break;
+        }
+        return AnimationEffect_STRETCH_FROM_LEFT;
+    default:
+        return AnimationEffect_NONE;
+    }
+}
+
+namespace
+{
+    constexpr OUStringLiteral gsDimColor = u"DimColor";
+    constexpr OUStringLiteral gsDimHide = u"DimHide";
+    constexpr OUStringLiteral gsDimPrev = u"DimPrevious";
+    constexpr OUStringLiteral gsEffect = u"Effect";
+    constexpr OUStringLiteral gsPlayFull = u"PlayFull";
+    constexpr OUStringLiteral gsSound = u"Sound";
+    constexpr OUStringLiteral gsSoundOn = u"SoundOn";
+    constexpr OUStringLiteral gsSpeed = u"Speed";
+    constexpr OUStringLiteral gsTextEffect = u"TextEffect";
+    constexpr OUStringLiteral gsPresShapeService = u"com.sun.star.presentation.Shape";
+    constexpr OUStringLiteral gsAnimPath = u"AnimationPath";
+    constexpr OUStringLiteral gsIsAnimation = u"IsAnimation";
+};
+
+namespace {
+
+enum XMLActionKind
+{
+    XMLE_SHOW,
+    XMLE_HIDE,
+    XMLE_DIM,
+    XMLE_PLAY
+};
+
+class XMLAnimationsEffectContext : public SvXMLImportContext
+{
+public:
+    rtl::Reference<XMLAnimationsContext> mxAnimationsContext;
+
+    XMLActionKind   meKind;
+    bool        mbTextEffect;
+    OUString        maShapeId;
+
+    XMLEffect       meEffect;
+    XMLEffectDirection  meDirection;
+    sal_Int16       mnStartScale;
+
+    AnimationSpeed  meSpeed;
+    sal_Int32       maDimColor;
+    OUString        maSoundURL;
+    bool        mbPlayFull;
+    OUString        maPathShapeId;
+
+public:
+
+    XMLAnimationsEffectContext( SvXMLImport& rImport,
+        sal_Int32 nElement,
+        const Reference< XFastAttributeList >& xAttrList,
+        XMLAnimationsContext& rAnimationsContext);
+
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+};
+
+class XMLAnimationsSoundContext : public SvXMLImportContext
+{
+public:
+
+    XMLAnimationsSoundContext( SvXMLImport& rImport, sal_Int32 nElement, const Reference< XFastAttributeList >& xAttrList, XMLAnimationsEffectContext* pParent );
+};
+
+}
+
+XMLAnimationsSoundContext::XMLAnimationsSoundContext( SvXMLImport& rImport, sal_Int32 nElement, const Reference< XFastAttributeList >& xAttrList, XMLAnimationsEffectContext* pParent )
+: SvXMLImportContext( rImport )
+{
+    if( !pParent || nElement != XML_ELEMENT(PRESENTATION, XML_SOUND) )
+        return;
+
+    for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+    {
+        switch( aIter.getToken() )
+        {
+            case XML_ELEMENT(XLINK, XML_HREF):
+                pParent->maSoundURL = rImport.GetAbsoluteReference(aIter.toString());
+                break;
+            case XML_ELEMENT(PRESENTATION, XML_PLAY_FULL):
+                pParent->mbPlayFull = IsXMLToken( aIter, XML_TRUE );
+                break;
+            default:
+                XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+        }
+    }
+}
+
+XMLAnimationsEffectContext::XMLAnimationsEffectContext( SvXMLImport& rImport,
+    sal_Int32 nElement,
+    const Reference< XFastAttributeList >& xAttrList,
+    XMLAnimationsContext& rAnimationsContext )
+:   SvXMLImportContext(rImport),
+    mxAnimationsContext( &rAnimationsContext ),
+    meKind( XMLE_SHOW ), mbTextEffect( false ),
+    meEffect( EK_none ), meDirection( ED_none ), mnStartScale( 100 ),
+    meSpeed( AnimationSpeed_MEDIUM ), maDimColor(0), mbPlayFull( false )
+{
+    switch(nElement & TOKEN_MASK)
+    {
+        case XML_SHOW_SHAPE:
+            meKind = XMLE_SHOW;
+            break;
+        case XML_SHOW_TEXT:
+            meKind = XMLE_SHOW;
+            mbTextEffect = true;
+            break;
+        case XML_HIDE_SHAPE:
+            meKind = XMLE_HIDE;
+            break;
+        case XML_HIDE_TEXT:
+            meKind = XMLE_HIDE;
+            mbTextEffect = true;
+            break;
+        case XML_DIM:
+            meKind = XMLE_DIM;
+            break;
+        case XML_PLAY:
+            meKind = XMLE_PLAY;
+            break;
+        default:
+            XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+            // unknown action, overread
+            return;
+    }
+
+    for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+    {
+        switch( aIter.getToken() )
+        {
+            case XML_ELEMENT(DRAW, XML_SHAPE_ID):
+                maShapeId = aIter.toString();
+                break;
+            case XML_ELEMENT(DRAW, XML_COLOR):
+                ::sax::Converter::convertColor(maDimColor, aIter.toView());
+                break;
+
+            case XML_ELEMENT(PRESENTATION, XML_EFFECT):
+                SvXMLUnitConverter::convertEnum( meEffect, aIter.toView(), aXML_AnimationEffect_EnumMap );
+                break;
+            case XML_ELEMENT(PRESENTATION, XML_DIRECTION):
+                SvXMLUnitConverter::convertEnum( meDirection, aIter.toView(), aXML_AnimationDirection_EnumMap );
+                break;
+            case XML_ELEMENT(PRESENTATION, XML_START_SCALE):
+            {
+                sal_Int32 nScale;
+                if (::sax::Converter::convertPercent( nScale, aIter.toView() ))
+                    mnStartScale = static_cast<sal_Int16>(nScale);
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_SPEED):
+                SvXMLUnitConverter::convertEnum( meSpeed, aIter.toView(), aXML_AnimationSpeed_EnumMap );
+                break;
+            case XML_ELEMENT(PRESENTATION, XML_PATH_ID):
+                maPathShapeId = aIter.toString();
+                break;
+            default:
+                XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+        }
+    }
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > XMLAnimationsEffectContext::createFastChildContext(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    return new XMLAnimationsSoundContext( GetImport(), nElement, xAttrList, this );
+}
+
+void XMLAnimationsEffectContext::endFastElement(sal_Int32 )
+{
+    // set effect on shape
+
+    try
+    {
+        if( !maShapeId.isEmpty() )
+        {
+            Reference< XPropertySet > xSet;
+            if( mxAnimationsContext->maLastShapeId != maShapeId )
+            {
+                xSet.set( GetImport().getInterfaceToIdentifierMapper().getReference( maShapeId ), UNO_QUERY );
+                if( xSet.is() )
+                {
+                    // check for presentation shape service
+                    {
+                        Reference< XServiceInfo > xServiceInfo( xSet, UNO_QUERY );
+                        if( !xServiceInfo.is() || !xServiceInfo->supportsService( gsPresShapeService ) )
+                            return;
+                    }
+
+                    mxAnimationsContext->maLastShapeId = maShapeId;
+                    mxAnimationsContext->mxLastShape = xSet;
+                }
+            }
+            else
+            {
+                xSet = mxAnimationsContext->mxLastShape;
+            }
+
+            if( xSet.is() )
+            {
+                if( meKind == XMLE_DIM )
+                {
+                    xSet->setPropertyValue( gsDimPrev, Any(true) );
+
+                    xSet->setPropertyValue( gsDimColor, Any(maDimColor) );
+                }
+                else if( meKind == XMLE_PLAY )
+                {
+                    xSet->setPropertyValue( gsIsAnimation, Any(true) );
+
+                    // #i42894# speed is not supported for the old group animation fallback, so no need to set it
+                    // aAny <<= meSpeed;
+                    // xSet->setPropertyValue( mpImpl->msSpeed, aAny );
+                }
+                else
+                {
+                    if( meKind == XMLE_HIDE && !mbTextEffect && meEffect == EK_none )
+                    {
+                        xSet->setPropertyValue( gsDimHide, Any(true) );
+                    }
+                    else
+                    {
+                        const AnimationEffect eEffect = ImplSdXMLgetEffect( meEffect, meDirection, mnStartScale, meKind == XMLE_SHOW );
+
+                        if (mbTextEffect)
+                            xSet->setPropertyValue( gsTextEffect, Any( eEffect ) );
+                        else
+                            xSet->setPropertyValue( gsEffect, Any( eEffect ) );
+                        xSet->setPropertyValue( gsSpeed, Any( meSpeed ) );
+
+                        if( eEffect == AnimationEffect_PATH && !maPathShapeId.isEmpty() )
+                        {
+                            Reference< XShape > xPath( GetImport().getInterfaceToIdentifierMapper().getReference( maPathShapeId ), UNO_QUERY );
+                            if( xPath.is() )
+                                xSet->setPropertyValue( gsAnimPath, Any( xPath ) );
+                        }
+                    }
+                }
+            }
+            if( !maSoundURL.isEmpty() )
+            {
+                if( xSet.is() )
+                {
+                    xSet->setPropertyValue( gsSound, Any(maSoundURL) );
+                    xSet->setPropertyValue( gsPlayFull, Any(mbPlayFull) );
+                    xSet->setPropertyValue( gsSoundOn, Any(true) );
+                }
+                else
+                {
+                    OSL_FAIL("XMLAnimationsEffectContext::EndElement - Sound URL without a XPropertySet!");
+                }
+            }
+        }
+    }
+    catch (const Exception&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw",
+                             "exception caught while importing animation information!");
+    }
+}
+
+
+XMLAnimationsContext::XMLAnimationsContext( SvXMLImport& rImport )
+: SvXMLImportContext(rImport)
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > XMLAnimationsContext::createFastChildContext(
+        sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    return new XMLAnimationsEffectContext( GetImport(), nElement, xAttrList, *this );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/descriptionimp.cxx b/xmloff/source/draw/descriptionimp.cxx
new file mode 100644
index 000000000..738f47dd2
--- /dev/null
+++ b/xmloff/source/draw/descriptionimp.cxx
@@ -0,0 +1,76 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/xml/sax/XAttributeList.hpp>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlimp.hxx>
+
+#include "descriptionimp.hxx"
+
+using namespace ::std;
+using namespace ::cppu;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::xml;
+using namespace ::com::sun::star::xml::sax;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::drawing;
+using namespace ::com::sun::star::beans;
+using namespace ::xmloff::token;
+
+
+SdXMLDescriptionContext::SdXMLDescriptionContext( SvXMLImport& rImport, sal_Int32 nElement, const Reference< XShape >& rxShape)
+: SvXMLImportContext(rImport), mxShape( rxShape ), mnElement(nElement)
+{
+}
+
+SdXMLDescriptionContext::~SdXMLDescriptionContext()
+{
+}
+
+void SdXMLDescriptionContext::endFastElement(sal_Int32 )
+{
+    if( msText.isEmpty() )
+        return;
+
+    try
+    {
+        uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY_THROW);
+        if( (mnElement & TOKEN_MASK) == XML_TITLE)
+        {
+            xPropSet->setPropertyValue("Title", Any(msText));
+        }
+        else
+        {
+            xPropSet->setPropertyValue("Description", Any(msText));
+        }
+    }
+    catch( uno::Exception& )
+    {
+    }
+}
+
+// This method is called for all characters that are contained in the
+// current element. The default is to ignore them.
+void SdXMLDescriptionContext::characters( const OUString& rChars )
+{
+    msText += rChars;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/descriptionimp.hxx b/xmloff/source/draw/descriptionimp.hxx
new file mode 100644
index 000000000..cc9450772
--- /dev/null
+++ b/xmloff/source/draw/descriptionimp.hxx
@@ -0,0 +1,46 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlictxt.hxx>
+#include <com/sun/star/drawing/XShape.hpp>
+
+// office:events inside a shape
+
+class SdXMLDescriptionContext final : public SvXMLImportContext
+{
+private:
+    css::uno::Reference< css::drawing::XShape > mxShape;
+    OUString msText;
+    sal_Int32 mnElement;
+public:
+
+    SdXMLDescriptionContext( SvXMLImport& rImport, sal_Int32 mnElement,
+        const css::uno::Reference< css::drawing::XShape >& rxShape );
+    virtual ~SdXMLDescriptionContext() override;
+
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+
+    // This method is called for all characters that are contained in the
+    // current element. The default is to ignore them.
+    virtual void SAL_CALL characters( const OUString& rChars ) override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/eventimp.cxx b/xmloff/source/draw/eventimp.cxx
new file mode 100644
index 000000000..29fc94fda
--- /dev/null
+++ b/xmloff/source/draw/eventimp.cxx
@@ -0,0 +1,454 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <com/sun/star/document/XEventsSupplier.hpp>
+#include <com/sun/star/container/XNameReplace.hpp>
+#include <com/sun/star/presentation/AnimationSpeed.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <tools/urlobj.hxx>
+#include <osl/diagnose.h>
+#include <sal/log.hxx>
+#include <o3tl/string_view.hxx>
+
+#include <sax/tools/converter.hxx>
+
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/namespacemap.hxx>
+#include "eventimp.hxx"
+
+using namespace ::std;
+using namespace ::cppu;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::xml;
+using namespace ::com::sun::star::xml::sax;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::drawing;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::document;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::presentation;
+using namespace ::xmloff::token;
+
+SvXMLEnumMapEntry<ClickAction> const aXML_EventActions_EnumMap[] =
+{
+    { XML_NONE,             ClickAction_NONE    },
+    { XML_PREVIOUS_PAGE,    ClickAction_PREVPAGE },
+    { XML_NEXT_PAGE,        ClickAction_NEXTPAGE },
+    { XML_FIRST_PAGE,       ClickAction_FIRSTPAGE },
+    { XML_LAST_PAGE,        ClickAction_LASTPAGE },
+    { XML_HIDE,             ClickAction_INVISIBLE },
+    { XML_STOP,             ClickAction_STOPPRESENTATION },
+    { XML_EXECUTE,          ClickAction_PROGRAM },
+    { XML_SHOW,             ClickAction_BOOKMARK },
+    { XML_SHOW,             ClickAction_DOCUMENT },
+    { XML_EXECUTE_MACRO,    ClickAction_MACRO },
+    { XML_VERB,             ClickAction_VERB },
+    { XML_FADE_OUT,         ClickAction_VANISH },
+    { XML_SOUND,            ClickAction_SOUND },
+    { XML_TOKEN_INVALID, ClickAction(0) }
+};
+
+SdXMLEventContextData::SdXMLEventContextData(const Reference< XShape >& rxShape)
+    : mxShape(rxShape), mbValid(false), mbScript(false)
+    , meClickAction(ClickAction_NONE), meEffect(EK_none)
+    , meDirection(ED_none), mnStartScale(100), meSpeed(AnimationSpeed_MEDIUM)
+    , mnVerb(0), mbPlayFull(false)
+{
+}
+
+namespace {
+
+class SdXMLEventContext : public SvXMLImportContext
+{
+public:
+    SdXMLEventContextData maData;
+
+public:
+
+    SdXMLEventContext( SvXMLImport& rImport, sal_Int32 nElement, const Reference< XFastAttributeList>& xAttrList, const Reference< XShape >& rxShape );
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+};
+
+class XMLEventSoundContext : public SvXMLImportContext
+{
+public:
+
+    XMLEventSoundContext( SvXMLImport& rImport, const Reference< XFastAttributeList >& xAttrList, SdXMLEventContext* pParent );
+};
+
+}
+
+XMLEventSoundContext::XMLEventSoundContext( SvXMLImport& rImp, const Reference< XFastAttributeList >& xAttrList, SdXMLEventContext* pParent )
+: SvXMLImportContext( rImp )
+{
+    for( auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList) )
+    {
+        switch( aIter.getToken() )
+        {
+            case XML_ELEMENT(XLINK, XML_HREF):
+                pParent->maData.msSoundURL = rImp.GetAbsoluteReference(aIter.toString());
+                break;
+            case XML_ELEMENT(PRESENTATION, XML_PLAY_FULL):
+                pParent->maData.mbPlayFull = IsXMLToken( aIter, XML_TRUE );
+                break;
+            default:
+                XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+        }
+    }
+}
+
+SdXMLEventContext::SdXMLEventContext( SvXMLImport& rImp,
+    sal_Int32 nElement,
+    const Reference< XFastAttributeList >& xAttrList, const Reference< XShape >& rxShape )
+    : SvXMLImportContext(rImp)
+    , maData(rxShape)
+{
+    if( nElement == XML_ELEMENT(PRESENTATION, XML_EVENT_LISTENER) )
+    {
+        maData.mbValid = true;
+    }
+    else if( nElement == XML_ELEMENT(SCRIPT, XML_EVENT_LISTENER) )
+    {
+        maData.mbScript = true;
+        maData.mbValid = true;
+    }
+    else
+    {
+        return;
+    }
+
+    // read attributes
+    OUString sEventName;
+    for( auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList) )
+    {
+        switch( aIter.getToken() )
+        {
+        case XML_ELEMENT(PRESENTATION, XML_ACTION):
+            SvXMLUnitConverter::convertEnum( maData.meClickAction, aIter.toView(), aXML_EventActions_EnumMap );
+            break;
+        case XML_ELEMENT(PRESENTATION, XML_EFFECT):
+            SvXMLUnitConverter::convertEnum( maData.meEffect, aIter.toView(), aXML_AnimationEffect_EnumMap );
+            break;
+        case XML_ELEMENT(PRESENTATION, XML_DIRECTION):
+            SvXMLUnitConverter::convertEnum( maData.meDirection, aIter.toView(), aXML_AnimationDirection_EnumMap );
+            break;
+        case XML_ELEMENT(PRESENTATION, XML_START_SCALE):
+            {
+                sal_Int32 nScale;
+                if (::sax::Converter::convertPercent( nScale, aIter.toView() ))
+                    maData.mnStartScale = static_cast<sal_Int16>(nScale);
+            }
+            break;
+        case XML_ELEMENT(PRESENTATION, XML_SPEED):
+            SvXMLUnitConverter::convertEnum( maData.meSpeed, aIter.toView(), aXML_AnimationSpeed_EnumMap );
+            break;
+        case XML_ELEMENT(PRESENTATION, XML_VERB):
+            ::sax::Converter::convertNumber( maData.mnVerb, aIter.toView() );
+            break;
+        case XML_ELEMENT(SCRIPT, XML_EVENT_NAME):
+            {
+                sEventName = aIter.toString();
+                sal_uInt16 nScriptPrefix =
+                    GetImport().GetNamespaceMap().GetKeyByAttrValueQName(sEventName, &sEventName);
+                maData.mbValid = XML_NAMESPACE_DOM == nScriptPrefix && sEventName == "click";
+            }
+            break;
+        case XML_ELEMENT(SCRIPT, XML_LANGUAGE):
+            {
+                // language is not evaluated!
+                OUString aScriptLanguage;
+                maData.msLanguage = aIter.toString();
+                sal_uInt16 nScriptPrefix = rImp.GetNamespaceMap().
+                    GetKeyByAttrValueQName(maData.msLanguage, &aScriptLanguage);
+                if( XML_NAMESPACE_OOO == nScriptPrefix )
+                    maData.msLanguage = aScriptLanguage;
+            }
+            break;
+        case XML_ELEMENT(SCRIPT, XML_MACRO_NAME):
+            maData.msMacroName = aIter.toString();
+            break;
+        case XML_ELEMENT(XLINK, XML_HREF):
+            {
+                if ( maData.mbScript )
+                {
+                    maData.msMacroName = aIter.toString();
+                }
+                else
+                {
+                    const OUString &rTmp =
+                        rImp.GetAbsoluteReference(aIter.toString());
+                    INetURLObject::translateToInternal( rTmp, maData.msBookmark,
+                        INetURLObject::DecodeMechanism::Unambiguous );
+                }
+            }
+            break;
+        }
+    }
+
+    if( maData.mbValid )
+        maData.mbValid = !sEventName.isEmpty();
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLEventContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    if( nElement == XML_ELEMENT(PRESENTATION, XML_SOUND) )
+        return new XMLEventSoundContext( GetImport(), xAttrList, this );
+    else
+        XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+    return nullptr;
+}
+
+void SdXMLEventContext::endFastElement(sal_Int32 )
+{
+    GetImport().GetShapeImport()->addShapeEvents(maData);
+}
+
+void SdXMLEventContextData::ApplyProperties()
+{
+    if( !mbValid )
+        return;
+
+    do
+    {
+        Reference< XEventsSupplier > xEventsSupplier( mxShape, UNO_QUERY );
+        if( !xEventsSupplier.is() )
+            break;
+
+        Reference< XNameReplace > xEvents( xEventsSupplier->getEvents() );
+        SAL_WARN_IF( !xEvents.is(), "xmloff", "XEventsSupplier::getEvents() returned NULL" );
+        if( !xEvents.is() )
+            break;
+
+        OUString sAPIEventName;
+        uno::Sequence< beans::PropertyValue > aProperties;
+
+        sAPIEventName = "OnClick";
+
+        if( mbScript )
+            meClickAction = ClickAction_MACRO;
+
+        sal_Int32 nPropertyCount = 2;
+        switch( meClickAction )
+        {
+            case ClickAction_NONE:
+            case ClickAction_PREVPAGE:
+            case ClickAction_NEXTPAGE:
+            case ClickAction_FIRSTPAGE:
+            case ClickAction_LASTPAGE:
+            case ClickAction_INVISIBLE:
+            case ClickAction_STOPPRESENTATION:
+                break;
+            case ClickAction_PROGRAM:
+            case ClickAction_VERB:
+            case ClickAction_BOOKMARK:
+            case ClickAction_DOCUMENT:
+                nPropertyCount += 1;
+                break;
+            case ClickAction_MACRO:
+                if ( msLanguage.equalsIgnoreAsciiCase("starbasic") )
+                    nPropertyCount += 1;
+                break;
+
+            case ClickAction_SOUND:
+                nPropertyCount += 2;
+                break;
+
+            case ClickAction_VANISH:
+                nPropertyCount += 4;
+                break;
+            default:
+                break;
+        }
+
+        aProperties.realloc( nPropertyCount );
+        beans::PropertyValue* pProperties = aProperties.getArray();
+
+        if( ClickAction_MACRO == meClickAction )
+        {
+            if ( msLanguage.equalsIgnoreAsciiCase("starbasic") )
+            {
+                OUString sLibrary;
+                const OUString& rApp = GetXMLToken( XML_APPLICATION );
+                const OUString& rDoc = GetXMLToken( XML_DOCUMENT );
+                if( msMacroName.getLength() > rApp.getLength()+1 &&
+                    o3tl::equalsIgnoreAsciiCase(msMacroName.subView(0,rApp.getLength()), rApp) &&
+                    ':' == msMacroName[rApp.getLength()] )
+                {
+                    sLibrary = "StarOffice";
+                    msMacroName = msMacroName.copy( rApp.getLength()+1 );
+                }
+                else if( msMacroName.getLength() > rDoc.getLength()+1 &&
+                    o3tl::equalsIgnoreAsciiCase(msMacroName.subView(0,rDoc.getLength()), rDoc) &&
+                    ':' == msMacroName[rDoc.getLength()] )
+                {
+                    sLibrary = rDoc;
+                    msMacroName = msMacroName.copy( rDoc.getLength()+1 );
+                }
+
+                pProperties->Name = "EventType";
+                pProperties->Handle = -1;
+                pProperties->Value <<= OUString( "StarBasic" );
+                pProperties->State = beans::PropertyState_DIRECT_VALUE;
+                pProperties++;
+
+                pProperties->Name = "MacroName";
+                pProperties->Handle = -1;
+                pProperties->Value <<= msMacroName;
+                pProperties->State = beans::PropertyState_DIRECT_VALUE;
+                pProperties++;
+
+                pProperties->Name = "Library";
+                pProperties->Handle = -1;
+                pProperties->Value <<= sLibrary;
+                pProperties->State = beans::PropertyState_DIRECT_VALUE;
+            }
+            else
+            {
+                pProperties->Name = "EventType";
+                pProperties->Handle = -1;
+                pProperties->Value <<= OUString( "Script" );
+                pProperties->State = beans::PropertyState_DIRECT_VALUE;
+                pProperties++;
+
+                pProperties->Name = "Script";
+                pProperties->Handle = -1;
+                pProperties->Value <<= msMacroName;
+                pProperties->State = beans::PropertyState_DIRECT_VALUE;
+            }
+        }
+        else
+        {
+            pProperties->Name = "EventType";
+            pProperties->Handle = -1;
+            pProperties->Value <<= OUString( "Presentation" );
+            pProperties->State = beans::PropertyState_DIRECT_VALUE;
+            pProperties++;
+
+            // ClickAction_BOOKMARK and ClickAction_DOCUMENT share the same xml event
+            // so check here if it's really a bookmark or maybe a document
+            if( meClickAction == ClickAction_BOOKMARK )
+            {
+                if( !msBookmark.startsWith( "#" ) )
+                    meClickAction = ClickAction_DOCUMENT;
+            }
+
+            pProperties->Name = "ClickAction";
+            pProperties->Handle = -1;
+            pProperties->Value <<= meClickAction;
+            pProperties->State = beans::PropertyState_DIRECT_VALUE;
+            pProperties++;
+
+            switch( meClickAction )
+            {
+                case ClickAction_NONE:
+                case ClickAction_PREVPAGE:
+                case ClickAction_NEXTPAGE:
+                case ClickAction_FIRSTPAGE:
+                case ClickAction_LASTPAGE:
+                case ClickAction_INVISIBLE:
+                case ClickAction_STOPPRESENTATION:
+                    break;
+
+                case ClickAction_BOOKMARK:
+                    msBookmark = msBookmark.copy(1);
+
+                    [[fallthrough]];
+
+                case ClickAction_DOCUMENT:
+                case ClickAction_PROGRAM:
+                    pProperties->Name = "Bookmark";
+                    pProperties->Handle = -1;
+                    pProperties->Value <<= msBookmark;
+                    pProperties->State = beans::PropertyState_DIRECT_VALUE;
+                    break;
+
+                case ClickAction_VANISH:
+                    pProperties->Name = "Effect";
+                    pProperties->Handle = -1;
+                    pProperties->Value <<= ImplSdXMLgetEffect( meEffect, meDirection, mnStartScale, true );
+                    pProperties->State = beans::PropertyState_DIRECT_VALUE;
+                    pProperties++;
+
+                    pProperties->Name = "Speed";
+                    pProperties->Handle = -1;
+                    pProperties->Value <<= meSpeed;
+                    pProperties->State = beans::PropertyState_DIRECT_VALUE;
+                    pProperties++;
+
+                    [[fallthrough]];
+
+                case ClickAction_SOUND:
+                    pProperties->Name = "SoundURL";
+                    pProperties->Handle = -1;
+                    pProperties->Value <<= msSoundURL;
+                    pProperties->State = beans::PropertyState_DIRECT_VALUE;
+                    pProperties++;
+
+                    pProperties->Name = "PlayFull";
+                    pProperties->Handle = -1;
+                    pProperties->Value <<= mbPlayFull;
+                    pProperties->State = beans::PropertyState_DIRECT_VALUE;
+                    break;
+
+                case ClickAction_VERB:
+                    pProperties->Name = "Verb";
+                    pProperties->Handle = -1;
+                    pProperties->Value <<= mnVerb;
+                    pProperties->State = beans::PropertyState_DIRECT_VALUE;
+                    break;
+                case ClickAction_MACRO:
+                    OSL_FAIL("xmloff::SdXMLEventContext::EndElement(), ClickAction_MACRO must be handled in different if case");
+                    break;
+                default:
+                    break;
+            }
+        }
+        xEvents->replaceByName( sAPIEventName, uno::Any( aProperties ) );
+
+    } while(false);
+}
+
+
+SdXMLEventsContext::SdXMLEventsContext( SvXMLImport& rImport, const Reference< XShape >& rxShape)
+: SvXMLImportContext(rImport), mxShape( rxShape )
+{
+}
+
+SdXMLEventsContext::~SdXMLEventsContext()
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLEventsContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    return new SdXMLEventContext( GetImport(), nElement, xAttrList, mxShape );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/eventimp.hxx b/xmloff/source/draw/eventimp.hxx
new file mode 100644
index 000000000..bb14aea5e
--- /dev/null
+++ b/xmloff/source/draw/eventimp.hxx
@@ -0,0 +1,68 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlictxt.hxx>
+#include <com/sun/star/drawing/XShape.hpp>
+#include <com/sun/star/presentation/ClickAction.hpp>
+#include <com/sun/star/presentation/AnimationSpeed.hpp>
+#include <anim.hxx>
+
+// office:events inside a shape
+
+class SdXMLEventsContext : public SvXMLImportContext
+{
+private:
+    css::uno::Reference< css::drawing::XShape > mxShape;
+
+public:
+
+    SdXMLEventsContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::drawing::XShape >& rxShape );
+    virtual ~SdXMLEventsContext() override;
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+};
+
+struct SdXMLEventContextData
+{
+    SdXMLEventContextData(const css::uno::Reference<css::drawing::XShape>& rxShape);
+    void ApplyProperties();
+
+    css::uno::Reference<css::drawing::XShape> mxShape;
+
+    bool mbValid;
+    bool mbScript;
+    css::presentation::ClickAction meClickAction;
+    XMLEffect meEffect;
+    XMLEffectDirection meDirection;
+    sal_Int16 mnStartScale;
+    css::presentation::AnimationSpeed meSpeed;
+    sal_Int32 mnVerb;
+    OUString msSoundURL;
+    bool mbPlayFull;
+    OUString msMacroName;
+    OUString msBookmark;
+    OUString msLanguage;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/layerexp.cxx b/xmloff/source/draw/layerexp.cxx
new file mode 100644
index 000000000..9ac924e92
--- /dev/null
+++ b/xmloff/source/draw/layerexp.cxx
@@ -0,0 +1,128 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+
+#include <com/sun/star/drawing/XLayerSupplier.hpp>
+#include <com/sun/star/container/XIndexAccess.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmlexp.hxx>
+#include "layerexp.hxx"
+#include <tools/diagnose_ex.h>
+
+using ::com::sun::star::uno::Reference;
+
+using namespace ::cppu;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::drawing;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::container;
+using namespace ::xmloff::token;
+
+void SdXMLayerExporter::exportLayer( SvXMLExport& rExport )
+{
+    Reference< XLayerSupplier > xLayerSupplier( rExport.GetModel(), UNO_QUERY );
+    if( !xLayerSupplier.is() )
+        return;
+
+    Reference< XIndexAccess > xLayerManager( xLayerSupplier->getLayerManager(), UNO_QUERY );
+    if( !xLayerManager.is() )
+        return;
+
+    const sal_Int32 nCount = xLayerManager->getCount();
+    if( nCount == 0 )
+        return;
+
+    static const OUStringLiteral strName( u"Name" );
+    static const OUStringLiteral strTitle( u"Title" );
+    static const OUStringLiteral strDescription( u"Description" );
+    static const OUStringLiteral strIsVisible( u"IsVisible");
+    static const OUStringLiteral strIsPrintable( u"IsPrintable");
+    static const OUStringLiteral strIsLocked( u"IsLocked" );
+
+    OUString sTmp;
+
+
+    SvXMLElementExport aElem( rExport, XML_NAMESPACE_DRAW, XML_LAYER_SET, true, true );
+
+    for( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++ )
+    {
+        try
+        {
+            Reference< XPropertySet> xLayer( xLayerManager->getByIndex( nIndex ), UNO_QUERY_THROW );
+            xLayer->getPropertyValue( strName ) >>= sTmp;
+            if(!sTmp.isEmpty())
+                rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, sTmp );
+
+            bool bTmpVisible( true );
+            bool bTmpPrintable( true );
+            xLayer->getPropertyValue( strIsVisible) >>= bTmpVisible;
+            xLayer->getPropertyValue( strIsPrintable) >>= bTmpPrintable;
+            // only write non-default values, default is "always"
+            if ( bTmpVisible )
+            {
+                if ( !bTmpPrintable )
+                    rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DISPLAY, OUString("screen") );
+            }
+            else
+            {
+                if ( bTmpPrintable)
+                    rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DISPLAY, OUString("printer") );
+                else
+                    rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DISPLAY, OUString("none") );
+            }
+
+            bool bTmpLocked( false );
+            xLayer->getPropertyValue( strIsLocked ) >>= bTmpLocked;
+            // only write non-default value, default is "false"
+            if ( bTmpLocked )
+            {
+                rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_PROTECTED, OUString("true") );
+            }
+
+            SvXMLElementExport aEle( rExport, XML_NAMESPACE_DRAW, XML_LAYER, true, true );
+
+            // title property (as <svg:title> element)
+            xLayer->getPropertyValue(strTitle) >>= sTmp;
+            if(!sTmp.isEmpty())
+            {
+                SvXMLElementExport aEventElemt(rExport, XML_NAMESPACE_SVG, XML_TITLE, true, false);
+                rExport.Characters(sTmp);
+            }
+
+            // description property (as <svg:desc> element)
+            xLayer->getPropertyValue(strDescription) >>= sTmp;
+            if(!sTmp.isEmpty())
+            {
+                SvXMLElementExport aDesc(rExport, XML_NAMESPACE_SVG, XML_DESC, true, false);
+                rExport.Characters(sTmp);
+            }
+        }
+        catch( Exception& )
+        {
+            TOOLS_WARN_EXCEPTION("xmloff.draw", "exception caught during export of one layer!");
+        }
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/layerexp.hxx b/xmloff/source/draw/layerexp.hxx
new file mode 100644
index 000000000..76c04e157
--- /dev/null
+++ b/xmloff/source/draw/layerexp.hxx
@@ -0,0 +1,30 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+class SvXMLExport;
+
+class SdXMLayerExporter
+{
+public:
+    static void exportLayer(SvXMLExport& rExport);
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/layerimp.cxx b/xmloff/source/draw/layerimp.cxx
new file mode 100644
index 000000000..73dab831e
--- /dev/null
+++ b/xmloff/source/draw/layerimp.cxx
@@ -0,0 +1,197 @@
+/* -*- 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 <tools/diagnose_ex.h>
+#include <com/sun/star/drawing/XLayerManager.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/xml/sax/XAttributeList.hpp>
+#include <com/sun/star/drawing/XLayerSupplier.hpp>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/namespacemap.hxx>
+#include "layerimp.hxx"
+
+
+#include <XMLStringBufferImportContext.hxx>
+
+using namespace ::std;
+using namespace ::cppu;
+using namespace ::xmloff::token;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::xml;
+using namespace ::com::sun::star::xml::sax;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::drawing;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::container;
+using ::xmloff::token::IsXMLToken;
+
+namespace {
+
+class SdXMLLayerContext : public SvXMLImportContext
+{
+public:
+    SdXMLLayerContext( SvXMLImport& rImport, const Reference< XFastAttributeList >& xAttrList, const Reference< XNameAccess >& xLayerManager );
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+
+private:
+    css::uno::Reference< css::container::XNameAccess > mxLayerManager;
+    OUString msName;
+    OUStringBuffer sDescriptionBuffer;
+    OUStringBuffer sTitleBuffer;
+    OUString msDisplay;
+    OUString msProtected;
+};
+
+}
+
+SdXMLLayerContext::SdXMLLayerContext( SvXMLImport& rImport, const Reference< XFastAttributeList >& xAttrList, const Reference< XNameAccess >& xLayerManager )
+: SvXMLImportContext(rImport)
+, mxLayerManager( xLayerManager )
+{
+    for( auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList) )
+    {
+        OUString sValue = aIter.toString();
+        switch(aIter.getToken())
+        {
+            case XML_ELEMENT(DRAW, XML_NAME):
+                msName = sValue;
+                break;
+            case XML_ELEMENT(DRAW, XML_DISPLAY):
+                msDisplay = sValue;
+                break;
+            case XML_ELEMENT(DRAW, XML_PROTECTED):
+                msProtected = sValue;
+                break;
+            default:
+                XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+        }
+    }
+
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLLayerContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >&  )
+{
+    if( nElement == XML_ELEMENT(SVG, XML_TITLE) )
+    {
+        return new XMLStringBufferImportContext( GetImport(), sTitleBuffer);
+    }
+    else if( nElement == XML_ELEMENT(SVG, XML_DESC) )
+    {
+        return new XMLStringBufferImportContext( GetImport(), sDescriptionBuffer);
+    }
+    else
+        XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+    return nullptr;
+}
+
+void SdXMLLayerContext::endFastElement(sal_Int32 )
+{
+    SAL_WARN_IF( msName.isEmpty(), "xmloff", "xmloff::SdXMLLayerContext::EndElement(), draw:layer element without draw:name!" );
+    if( msName.isEmpty() )
+        return;
+
+    try
+    {
+        Reference< XPropertySet > xLayer;
+
+        if( mxLayerManager->hasByName( msName ) )
+        {
+            mxLayerManager->getByName( msName ) >>= xLayer;
+            SAL_WARN_IF( !xLayer.is(), "xmloff", "xmloff::SdXMLLayerContext::EndElement(), failed to get existing XLayer!" );
+        }
+        else
+        {
+            Reference< XLayerManager > xLayerManager( mxLayerManager, UNO_QUERY );
+            if( xLayerManager.is() )
+                xLayer = xLayerManager->insertNewByIndex( xLayerManager->getCount() );
+            SAL_WARN_IF( !xLayer.is(), "xmloff", "xmloff::SdXMLLayerContext::EndElement(), failed to create new XLayer!" );
+
+            if( xLayer.is() )
+                xLayer->setPropertyValue("Name", Any( msName ) );
+        }
+
+        if( xLayer.is() )
+        {
+            xLayer->setPropertyValue("Title", Any( sTitleBuffer.makeStringAndClear() ) );
+            xLayer->setPropertyValue("Description", Any( sDescriptionBuffer.makeStringAndClear() ) );
+            bool bIsVisible( true );
+            bool bIsPrintable( true );
+            if ( !msDisplay.isEmpty() )
+            {
+                bIsVisible = (msDisplay == "always") || (msDisplay == "screen");
+                bIsPrintable = (msDisplay == "always") || (msDisplay == "printer");
+            }
+            xLayer->setPropertyValue("IsVisible", Any( bIsVisible ) );
+            xLayer->setPropertyValue("IsPrintable", Any( bIsPrintable ) );
+            bool bIsLocked( false );
+            if ( !msProtected.isEmpty() )
+                bIsLocked = (msProtected == "true");
+            xLayer->setPropertyValue("IsLocked", Any( bIsLocked ) );
+
+            // tdf#129898 repair layer "DrawnInSlideshow", which was wrongly written
+            // in LO 6.2 to 6.4. It should always have ODF defaults.
+            if (msName == "DrawnInSlideshow")
+            {
+                xLayer->setPropertyValue("IsVisible", Any(true));
+                xLayer->setPropertyValue("IsPrintable", Any(true));
+                xLayer->setPropertyValue("IsLocked", Any(false));
+            }
+        }
+    }
+    catch( Exception& )
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw", "");
+    }
+}
+
+
+SdXMLLayerSetContext::SdXMLLayerSetContext( SvXMLImport& rImport )
+: SvXMLImportContext(rImport)
+{
+    Reference< XLayerSupplier > xLayerSupplier( rImport.GetModel(), UNO_QUERY );
+    SAL_WARN_IF( !xLayerSupplier.is(), "xmloff", "xmloff::SdXMLLayerSetContext::SdXMLLayerSetContext(), XModel is not supporting XLayerSupplier!" );
+    if( xLayerSupplier.is() )
+        mxLayerManager = xLayerSupplier->getLayerManager();
+}
+
+SdXMLLayerSetContext::~SdXMLLayerSetContext()
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLLayerSetContext::createFastChildContext(
+    sal_Int32 /*nElement*/,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    return new SdXMLLayerContext( GetImport(), xAttrList, mxLayerManager );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/layerimp.hxx b/xmloff/source/draw/layerimp.hxx
new file mode 100644
index 000000000..4d3b89941
--- /dev/null
+++ b/xmloff/source/draw/layerimp.hxx
@@ -0,0 +1,41 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlictxt.hxx>
+#include <com/sun/star/container/XNameAccess.hpp>
+
+// presentations:animations
+
+class SdXMLLayerSetContext : public SvXMLImportContext
+{
+private:
+    css::uno::Reference< css::container::XNameAccess > mxLayerManager;
+
+public:
+    SdXMLLayerSetContext( SvXMLImport& rImport );
+    virtual ~SdXMLLayerSetContext() override;
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/numithdl.cxx b/xmloff/source/draw/numithdl.cxx
new file mode 100644
index 000000000..078ef4826
--- /dev/null
+++ b/xmloff/source/draw/numithdl.cxx
@@ -0,0 +1,52 @@
+/* -*- 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 "numithdl.hxx"
+
+using namespace ::com::sun::star;
+
+
+
+
+XMLNumRulePropHdl::XMLNumRulePropHdl( css::uno::Reference< css::ucb::XAnyCompare > const & xNumRuleCompare )
+: mxNumRuleCompare( xNumRuleCompare )
+{
+}
+
+XMLNumRulePropHdl::~XMLNumRulePropHdl()
+{
+    // Nothing to do
+}
+
+bool XMLNumRulePropHdl::equals( const uno::Any& r1, const uno::Any& r2 ) const
+{
+    return mxNumRuleCompare.is() && mxNumRuleCompare->compare( r1, r2 ) == 0;
+}
+
+bool XMLNumRulePropHdl::importXML( const OUString& /*rStrImpValue*/, css::uno::Any& /*rValue*/, const SvXMLUnitConverter& /*rUnitConverter*/ ) const
+{
+    return false;
+}
+
+bool XMLNumRulePropHdl::exportXML( OUString& /*rStrExpValue*/, const css::uno::Any& /*rValue*/, const SvXMLUnitConverter& /*rUnitConverter*/ ) const
+{
+    return false;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/numithdl.hxx b/xmloff/source/draw/numithdl.hxx
new file mode 100644
index 000000000..91db9c17e
--- /dev/null
+++ b/xmloff/source/draw/numithdl.hxx
@@ -0,0 +1,43 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <com/sun/star/ucb/XAnyCompare.hpp>
+#include <xmloff/xmlprhdl.hxx>
+
+/**
+    PropertyHandler for the list-style
+*/
+class XMLNumRulePropHdl : public XMLPropertyHandler
+{
+private:
+    css::uno::Reference< css::ucb::XAnyCompare > mxNumRuleCompare;
+public:
+    explicit XMLNumRulePropHdl( css::uno::Reference< css::ucb::XAnyCompare > const & xNumRuleCompare );
+    virtual ~XMLNumRulePropHdl() override;
+
+    virtual bool equals( const css::uno::Any& r1, const css::uno::Any& r2 ) const override;
+
+    /// NumRules will be imported/exported as XML-Elements. So the Import/Export-work must be done at another place.
+    virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+    virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/propimp0.cxx b/xmloff/source/draw/propimp0.cxx
new file mode 100644
index 000000000..961aa406d
--- /dev/null
+++ b/xmloff/source/draw/propimp0.cxx
@@ -0,0 +1,263 @@
+/* -*- 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 <rtl/ustrbuf.hxx>
+#include <sal/log.hxx>
+#include <propimp0.hxx>
+#include <com/sun/star/util/Duration.hpp>
+#include <com/sun/star/uno/Any.hxx>
+
+#include <sax/tools/converter.hxx>
+
+#include <xmloff/xmlexp.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlimp.hxx>
+
+#include <tools/time.hxx>
+
+using namespace ::com::sun::star;
+
+// implementation of graphic property Stroke
+
+// implementation of presentation page property Change
+
+// implementation of an effect duration property handler
+
+XMLDurationPropertyHdl::~XMLDurationPropertyHdl()
+{
+}
+
+bool XMLDurationPropertyHdl::importXML(
+    const OUString& rStrImpValue,
+    css::uno::Any& rValue,
+    const SvXMLUnitConverter& ) const
+{
+    util::Duration aDuration;
+
+    if (::sax::Converter::convertDuration(aDuration,  rStrImpValue))
+    {
+        const double fSeconds = ((aDuration.Days * 24 + aDuration.Hours) * 60
+                                 + aDuration.Minutes) * 60
+                                 + aDuration.Seconds
+                                 + aDuration.NanoSeconds / static_cast<double>(::tools::Time::nanoSecPerSec);
+        rValue <<= fSeconds;
+
+        return true;
+    }
+
+    SAL_WARN_IF(!rStrImpValue.isEmpty(), "xmloff", "Invalid duration: " << rStrImpValue);
+
+    return false;
+}
+
+bool XMLDurationPropertyHdl::exportXML(
+    OUString& rStrExpValue,
+    const css::uno::Any& rValue,
+    const SvXMLUnitConverter& ) const
+{
+    double nVal = 0;
+
+    if(rValue >>= nVal)
+    {
+        util::Duration aDuration;
+        aDuration.Seconds = static_cast<sal_uInt16>(nVal);
+        aDuration.NanoSeconds = static_cast<sal_uInt32>((nVal - aDuration.Seconds) * ::tools::Time::nanoSecPerSec);
+
+        OUStringBuffer aOut;
+        ::sax::Converter::convertDuration(aOut, aDuration);
+        rStrExpValue = aOut.makeStringAndClear();
+        return true;
+    }
+
+    return false;
+}
+
+// implementation of an opacity property handler
+
+XMLOpacityPropertyHdl::XMLOpacityPropertyHdl( SvXMLImport* pImport )
+: mpImport( pImport )
+{
+}
+
+XMLOpacityPropertyHdl::~XMLOpacityPropertyHdl()
+{
+}
+
+bool XMLOpacityPropertyHdl::importXML(
+    const OUString& rStrImpValue,
+    css::uno::Any& rValue,
+    const SvXMLUnitConverter& ) const
+{
+    bool bRet = false;
+    sal_Int32 nValue = 0;
+
+    if( rStrImpValue.indexOf( '%' ) != -1 )
+    {
+        if (::sax::Converter::convertPercent( nValue, rStrImpValue ))
+            bRet = true;
+    }
+    else
+    {
+        nValue = sal_Int32( rStrImpValue.toDouble() * 100.0 );
+        bRet = true;
+    }
+
+    if( bRet )
+    {
+        // check ranges
+        if( nValue < 0 )
+            nValue = 0;
+        if( nValue > 100 )
+            nValue = 100;
+
+        // convert xml opacity to api transparency
+        nValue = 100 - nValue;
+
+        // #i42959#
+        if( mpImport )
+        {
+            sal_Int32 nUPD, nBuild;
+            if( mpImport->getBuildIds( nUPD, nBuild ) )
+            {
+                // correct import of documents written prior to StarOffice 8/OOO 2.0 final
+                if( (nUPD == 680) && (nBuild < 8951) )
+                    nValue = 100 - nValue;
+            }
+        }
+
+        rValue <<= sal_uInt16(nValue);
+    }
+
+    return bRet;
+}
+
+bool XMLOpacityPropertyHdl::exportXML(
+    OUString& rStrExpValue,
+    const css::uno::Any& rValue,
+    const SvXMLUnitConverter& ) const
+{
+    bool bRet = false;
+    sal_uInt16 nVal = sal_uInt16();
+
+    if( rValue >>= nVal )
+    {
+        OUStringBuffer aOut;
+
+        nVal = 100 - nVal;
+        ::sax::Converter::convertPercent( aOut, nVal );
+        rStrExpValue = aOut.makeStringAndClear();
+        bRet = true;
+    }
+
+    return bRet;
+}
+
+// implementation of a text animation step amount
+
+XMLTextAnimationStepPropertyHdl::~XMLTextAnimationStepPropertyHdl()
+{
+}
+
+bool XMLTextAnimationStepPropertyHdl::importXML(
+    const OUString& rStrImpValue,
+    css::uno::Any& rValue,
+    const SvXMLUnitConverter& rUnitConverter ) const
+{
+    bool bRet = false;
+    sal_Int32 nValue = 0;
+
+    sal_Int32 nPos = rStrImpValue.indexOf( "px" );
+    if( nPos != -1 )
+    {
+        if (::sax::Converter::convertNumber(nValue, rStrImpValue.subView(0, nPos)))
+        {
+            rValue <<= sal_Int16( -nValue );
+            bRet = true;
+        }
+    }
+    else
+    {
+        if (rUnitConverter.convertMeasureToCore( nValue, rStrImpValue ))
+        {
+            rValue <<= sal_Int16( nValue );
+            bRet = true;
+        }
+    }
+
+    return bRet;
+}
+
+bool XMLTextAnimationStepPropertyHdl::exportXML(
+    OUString& rStrExpValue,
+    const css::uno::Any& rValue,
+    const SvXMLUnitConverter& rUnitConverter ) const
+{
+    bool bRet = false;
+    sal_Int16 nVal = sal_Int16();
+
+    if( rValue >>= nVal )
+    {
+        OUStringBuffer aOut;
+
+        if( nVal < 0 )
+        {
+            aOut.append( static_cast<sal_Int32>(-nVal) );
+            aOut.append( "px" );
+        }
+        else
+        {
+            rUnitConverter.convertMeasureToXML( aOut, nVal );
+        }
+
+        rStrExpValue = aOut.makeStringAndClear();
+        bRet = true;
+    }
+
+    return bRet;
+}
+
+XMLDateTimeFormatHdl::XMLDateTimeFormatHdl( SvXMLExport* pExport )
+: mpExport( pExport )
+{
+}
+
+XMLDateTimeFormatHdl::~XMLDateTimeFormatHdl()
+{
+}
+
+bool XMLDateTimeFormatHdl::importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+    rValue <<= rStrImpValue;
+    return true;
+}
+
+bool XMLDateTimeFormatHdl::exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+    sal_Int32 nNumberFormat = 0;
+    if( mpExport && (rValue >>= nNumberFormat) )
+    {
+        mpExport->addDataStyle( nNumberFormat );
+        rStrExpValue = mpExport->getDataStyleName( nNumberFormat );
+        return true;
+    }
+
+    return false;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/sdpropls.cxx b/xmloff/source/draw/sdpropls.cxx
new file mode 100644
index 000000000..5e68aa175
--- /dev/null
+++ b/xmloff/source/draw/sdpropls.cxx
@@ -0,0 +1,1883 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <com/sun/star/animations/TransitionType.hpp>
+#include <com/sun/star/ucb/XAnyCompareFactory.hpp>
+#include <com/sun/star/container/XIndexReplace.hpp>
+#include <com/sun/star/drawing/LineStyle.hpp>
+#include <com/sun/star/drawing/LineJoint.hpp>
+#include <com/sun/star/drawing/LineCap.hpp>
+#include <com/sun/star/presentation/AnimationSpeed.hpp>
+#include <com/sun/star/presentation/FadeEffect.hpp>
+
+#include <com/sun/star/text/WritingMode.hpp>
+#include <com/sun/star/text/WritingMode2.hpp>
+#include <xmloff/EnumPropertyHdl.hxx>
+#include <xmloff/NamedBoolPropertyHdl.hxx>
+#include <WordWrapPropertyHdl.hxx>
+#include <enummaps.hxx>
+#include "numithdl.hxx"
+#include <XMLBitmapRepeatOffsetPropertyHandler.hxx>
+#include <XMLFillBitmapSizePropertyHandler.hxx>
+#include <XMLBitmapLogicalSizePropertyHandler.hxx>
+#include <com/sun/star/drawing/TextAnimationKind.hpp>
+#include <com/sun/star/drawing/TextAnimationDirection.hpp>
+#include <com/sun/star/drawing/TextHorizontalAdjust.hpp>
+#include <com/sun/star/drawing/TextVerticalAdjust.hpp>
+#include <com/sun/star/drawing/TextFitToSizeType.hpp>
+#include <com/sun/star/drawing/MeasureTextHorzPos.hpp>
+#include <com/sun/star/drawing/MeasureTextVertPos.hpp>
+#include <xmloff/controlpropertyhdl.hxx>
+#include <xmloff/xmltoken.hxx>
+#include "sdpropls.hxx"
+#include <propimp0.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <com/sun/star/drawing/NormalsKind.hpp>
+#include <com/sun/star/drawing/TextureProjectionMode.hpp>
+#include <com/sun/star/drawing/TextureKind.hpp>
+#include <com/sun/star/drawing/TextureMode.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <xmloff/txtprmap.hxx>
+#include <XMLClipPropertyHandler.hxx>
+#include <XMLIsPercentagePropertyHandler.hxx>
+#include <XMLPercentOrMeasurePropertyHandler.hxx>
+#include <XMLTextColumnsPropertyHandler.hxx>
+#include <animations.hxx>
+#include <sax/tools/converter.hxx>
+#include <xmlsdtypes.hxx>
+
+using ::com::sun::star::uno::Any;
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+#define MAP_(name,prefix,token,type,context)  { name, prefix, token, type, context, SvtSaveOptions::ODFSVER_010, false }
+#define MAPV_(name,prefix,token,type,context,version)  { name, prefix, token, type, context, version, false }
+#define GMAP(name,prefix,token,type,context) MAP_(name,prefix,token,type|XML_TYPE_PROP_GRAPHIC,context)
+#define GMAP_D(name,prefix,token,type,context) MAP_(name,prefix,token,type|XML_TYPE_PROP_GRAPHIC|MID_FLAG_DEFAULT_ITEM_EXPORT,context)
+#define GMAPV(name,prefix,token,type,context,version) MAPV_(name,prefix,token,type|XML_TYPE_PROP_GRAPHIC,context,version)
+#define DPMAP(name,prefix,token,type,context) MAP_(name,prefix,token,type|XML_TYPE_PROP_DRAWING_PAGE,context)
+#define TMAP(name,prefix,token,type,context) MAP_(name,prefix,token,type|XML_TYPE_PROP_TEXT,context)
+#define PMAP(name,prefix,token,type,context) MAP_(name,prefix,token,type|XML_TYPE_PROP_PARAGRAPH,context)
+#define MAP_END() { nullptr, 0, XML_EMPTY, 0 ,0, SvtSaveOptions::ODFSVER_010, false }
+
+// entry list for graphic properties
+
+const XMLPropertyMapEntry aXMLSDProperties[] =
+{
+    // this entry must be first! this is needed for XMLShapeImportHelper::CreateExternalShapePropMapper
+
+    // ^^^though CreateExternalShapePropMapper is gone now, hmm^^^
+    GMAP( "UserDefinedAttributes",          XML_NAMESPACE_TEXT, XML_XMLNS,                  XML_TYPE_ATTRIBUTE_CONTAINER | MID_FLAG_SPECIAL_ITEM, 0 ),
+
+    // stroke attributes
+    GMAP( "LineStyle",                      XML_NAMESPACE_DRAW, XML_STROKE,                 XML_SD_TYPE_STROKE, 0 ),
+    GMAP( "LineDashName",                   XML_NAMESPACE_DRAW, XML_STROKE_DASH,            XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT , CTF_DASHNAME ),
+    GMAP( "LineWidth",                      XML_NAMESPACE_SVG,  XML_STROKE_WIDTH,           XML_TYPE_MEASURE, 0 ),
+    GMAP_D("LineColor",                     XML_NAMESPACE_SVG,  XML_STROKE_COLOR,           XML_TYPE_COLOR, 0),
+    GMAP( "LineStartName",                  XML_NAMESPACE_DRAW, XML_MARKER_START,           XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_LINESTARTNAME ),
+    GMAP( "LineStartWidth",                 XML_NAMESPACE_DRAW, XML_MARKER_START_WIDTH,     XML_TYPE_MEASURE, 0 ),
+    GMAP( "LineStartCenter",                XML_NAMESPACE_DRAW, XML_MARKER_START_CENTER,    XML_TYPE_BOOL, 0 ),
+    GMAP( "LineEndName",                    XML_NAMESPACE_DRAW, XML_MARKER_END,             XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_LINEENDNAME ),
+    GMAP( "LineEndWidth",                   XML_NAMESPACE_DRAW, XML_MARKER_END_WIDTH,       XML_TYPE_MEASURE, 0 ),
+    GMAP( "LineEndCenter",                  XML_NAMESPACE_DRAW, XML_MARKER_END_CENTER,      XML_TYPE_BOOL, 0 ),
+    GMAP( "LineTransparence",               XML_NAMESPACE_SVG,  XML_STROKE_OPACITY,         XML_SD_TYPE_OPACITY, 0 ),
+    GMAP( "LineJoint",                      XML_NAMESPACE_DRAW, XML_STROKE_LINEJOIN,        XML_SD_TYPE_LINEJOIN, 0 ),
+    GMAP( "LineCap",                        XML_NAMESPACE_SVG , XML_STROKE_LINECAP,         XML_SD_TYPE_LINECAP, 0 ),
+
+    // fill attributes
+    GMAP( "FillStyle",                      XML_NAMESPACE_DRAW, XML_FILL,                   XML_SD_TYPE_FILLSTYLE, CTF_FILLSTYLE ),
+    GMAP_D("FillColor",                     XML_NAMESPACE_DRAW, XML_FILL_COLOR,             XML_TYPE_COLOR, CTF_FILLCOLOR ),
+    GMAP_D("FillColor2",                    XML_NAMESPACE_DRAW, XML_SECONDARY_FILL_COLOR,   XML_TYPE_COLOR, 0),
+    GMAPV("FillColorTheme",                 XML_NAMESPACE_LO_EXT, XML_FILL_THEME_COLOR, XML_TYPE_THEME_COLOR, 0, SvtSaveOptions::ODFSVER_FUTURE_EXTENDED),
+    GMAPV("FillColorLumMod",                XML_NAMESPACE_LO_EXT, XML_FILL_COLOR_LUM_MOD, XML_TYPE_PERCENT100, 0, SvtSaveOptions::ODFSVER_FUTURE_EXTENDED),
+    GMAPV("FillColorLumOff",                XML_NAMESPACE_LO_EXT, XML_FILL_COLOR_LUM_OFF, XML_TYPE_PERCENT100, 0, SvtSaveOptions::ODFSVER_FUTURE_EXTENDED),
+    GMAP( "FillGradientName",               XML_NAMESPACE_DRAW, XML_FILL_GRADIENT_NAME,     XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_FILLGRADIENTNAME ),
+    GMAP( "FillGradientStepCount",          XML_NAMESPACE_DRAW, XML_GRADIENT_STEP_COUNT,    XML_TYPE_NUMBER16, 0 ),
+    GMAP( "FillHatchName",                  XML_NAMESPACE_DRAW, XML_FILL_HATCH_NAME,        XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_FILLHATCHNAME ),
+    GMAP( "FillBackground",                 XML_NAMESPACE_DRAW, XML_FILL_HATCH_SOLID,       XML_TYPE_BOOL, 0 ),
+    GMAPV( "FillUseSlideBackground",        XML_NAMESPACE_LO_EXT, XML_FILL_USE_SLIDE_BACKGROUND, XML_TYPE_BOOL, 0, SvtSaveOptions::ODFSVER_FUTURE_EXTENDED),
+    GMAP( "FillBitmapName",                 XML_NAMESPACE_DRAW, XML_FILL_IMAGE_NAME,        XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_FILLBITMAPNAME ),
+    GMAP( "FillTransparence",               XML_NAMESPACE_DRAW, XML_OPACITY,                XML_TYPE_NEG_PERCENT16|MID_FLAG_MULTI_PROPERTY, 0 ),    // exists in SW, too
+    GMAP( "FillTransparenceGradientName",   XML_NAMESPACE_DRAW, XML_OPACITY_NAME,           XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_FILLTRANSNAME ),
+    GMAP( "FillBitmapSizeX",                XML_NAMESPACE_DRAW, XML_FILL_IMAGE_WIDTH,       XML_SD_TYPE_FILLBITMAPSIZE|MID_FLAG_MULTI_PROPERTY, 0 ),
+    GMAP( "FillBitmapLogicalSize",          XML_NAMESPACE_DRAW, XML_FILL_IMAGE_WIDTH,       XML_SD_TYPE_LOGICAL_SIZE|MID_FLAG_MULTI_PROPERTY, 0 ),
+    GMAP( "FillBitmapSizeY",                XML_NAMESPACE_DRAW, XML_FILL_IMAGE_HEIGHT,      XML_SD_TYPE_FILLBITMAPSIZE|MID_FLAG_MULTI_PROPERTY, 0 ),
+    GMAP( "FillBitmapLogicalSize",          XML_NAMESPACE_DRAW, XML_FILL_IMAGE_HEIGHT,      XML_SD_TYPE_LOGICAL_SIZE|MID_FLAG_MULTI_PROPERTY, 0 ),
+    GMAP( "FillBitmapMode",                 XML_NAMESPACE_STYLE,XML_REPEAT,                 XML_SD_TYPE_BITMAP_MODE|MID_FLAG_MULTI_PROPERTY, 0 ),
+    GMAP( "FillBitmapPositionOffsetX",      XML_NAMESPACE_DRAW, XML_FILL_IMAGE_REF_POINT_X, XML_TYPE_PERCENT, 0 ),
+    GMAP( "FillBitmapPositionOffsetY",      XML_NAMESPACE_DRAW, XML_FILL_IMAGE_REF_POINT_Y, XML_TYPE_PERCENT, 0 ),
+    GMAP( "FillBitmapRectanglePoint",       XML_NAMESPACE_DRAW, XML_FILL_IMAGE_REF_POINT,   XML_SD_TYPE_BITMAP_REFPOINT, 0 ),
+    GMAP( "FillBitmapOffsetX",              XML_NAMESPACE_DRAW, XML_TILE_REPEAT_OFFSET,     XML_SD_TYPE_BITMAPREPOFFSETX|MID_FLAG_MULTI_PROPERTY, CTF_REPEAT_OFFSET_X ),
+    GMAP( "FillBitmapOffsetY",              XML_NAMESPACE_DRAW, XML_TILE_REPEAT_OFFSET,     XML_SD_TYPE_BITMAPREPOFFSETY|MID_FLAG_MULTI_PROPERTY, CTF_REPEAT_OFFSET_Y ),
+
+    // text frame attributes
+    GMAP( "TextHorizontalAdjust",           XML_NAMESPACE_DRAW, XML_TEXTAREA_HORIZONTAL_ALIGN,  XML_SD_TYPE_TEXT_ALIGN, 0 ),
+    GMAP( "TextVerticalAdjust",             XML_NAMESPACE_DRAW, XML_TEXTAREA_VERTICAL_ALIGN,    XML_SD_TYPE_VERTICAL_ALIGN, 0 ),
+    GMAP( "TextAutoGrowHeight",             XML_NAMESPACE_DRAW, XML_AUTO_GROW_HEIGHT,       XML_TYPE_BOOL, 0 ),
+    GMAP( "TextAutoGrowWidth",              XML_NAMESPACE_DRAW, XML_AUTO_GROW_WIDTH,        XML_TYPE_BOOL, 0 ),
+    GMAP( "TextFitToSize",                  XML_NAMESPACE_DRAW, XML_FIT_TO_SIZE,            XML_SD_TYPE_FITTOSIZE|MID_FLAG_MERGE_PROPERTY, 0),
+    GMAPV( "TextFitToSize",                 XML_NAMESPACE_STYLE, XML_SHRINK_TO_FIT,         XML_SD_TYPE_FITTOSIZE_AUTOFIT|MID_FLAG_MERGE_PROPERTY, 0, SvtSaveOptions::ODFSVER_012 ),
+    GMAP( "TextContourFrame",               XML_NAMESPACE_DRAW, XML_FIT_TO_CONTOUR,         XML_TYPE_BOOL, 0 ),
+    GMAP( "TextMaximumFrameHeight",         XML_NAMESPACE_FO,   XML_MAX_HEIGHT,             XML_TYPE_MEASURE, 0 ),
+    GMAP( "TextMaximumFrameWidth",          XML_NAMESPACE_FO,   XML_MAX_WIDTH,              XML_TYPE_MEASURE, 0 ),
+    GMAP( "TextMinimumFrameHeight",         XML_NAMESPACE_FO,   XML_MIN_HEIGHT,             XML_TYPE_MEASURE|MID_FLAG_MULTI_PROPERTY, 0 ),  // exists in SW, too
+    GMAP( "TextMinimumFrameWidth",          XML_NAMESPACE_FO,   XML_MIN_WIDTH,              XML_TYPE_MEASURE|MID_FLAG_MULTI_PROPERTY, 0 ),
+    GMAP( "TextUpperDistance",              XML_NAMESPACE_FO,   XML_PADDING_TOP,            XML_TYPE_MEASURE|MID_FLAG_MULTI_PROPERTY, 0 ),  // exists in SW, too
+    GMAP( "TextLowerDistance",              XML_NAMESPACE_FO,   XML_PADDING_BOTTOM,         XML_TYPE_MEASURE|MID_FLAG_MULTI_PROPERTY, 0 ),  // exists in SW, too
+    GMAP( "TextLeftDistance",               XML_NAMESPACE_FO,   XML_PADDING_LEFT,           XML_TYPE_MEASURE|MID_FLAG_MULTI_PROPERTY, 0 ),  // exists in SW, too
+    GMAP( "TextRightDistance",              XML_NAMESPACE_FO,   XML_PADDING_RIGHT,          XML_TYPE_MEASURE|MID_FLAG_MULTI_PROPERTY, 0 ),  // exists in SW, too
+    PMAP( "TextWritingMode",                XML_NAMESPACE_STYLE,XML_WRITING_MODE,           XML_SD_TYPE_WRITINGMODE|MID_FLAG_MULTI_PROPERTY, CTF_WRITINGMODE ),
+    GMAP( "NumberingRules",                 XML_NAMESPACE_TEXT, XML_LIST_STYLE,             XML_SD_TYPE_NUMBULLET|MID_FLAG_ELEMENT_ITEM, CTF_NUMBERINGRULES ),
+    GMAP( "NumberingRules",                 XML_NAMESPACE_TEXT, XML_LIST_STYLE_NAME,        XML_TYPE_STRING, CTF_SD_NUMBERINGRULES_NAME ),
+    GMAP( "TextWordWrap",                   XML_NAMESPACE_FO,   XML_WRAP_OPTION,            XML_TYPE_WRAP_OPTION, 0 ),
+    GMAP( "TextChainNextName",              XML_NAMESPACE_DRAW,   XML_CHAIN_NEXT_NAME,      XML_TYPE_STRING, 0 ),
+
+    GMAP( "TextColumns",                    XML_NAMESPACE_STYLE, XML_COLUMNS, XML_TYPE_TEXT_COLUMNS|MID_FLAG_ELEMENT_ITEM, CTF_TEXTCOLUMNS ),
+
+    // shadow attributes
+    GMAP( "Shadow",                         XML_NAMESPACE_DRAW, XML_SHADOW,                 XML_SD_TYPE_VISIBLE_HIDDEN, 0 ),
+    GMAP( "ShadowXDistance",                    XML_NAMESPACE_DRAW, XML_SHADOW_OFFSET_X,        XML_TYPE_MEASURE, 0 ),
+    GMAP( "ShadowYDistance",                    XML_NAMESPACE_DRAW, XML_SHADOW_OFFSET_Y,        XML_TYPE_MEASURE, 0 ),
+    GMAP( "ShadowColor",                        XML_NAMESPACE_DRAW, XML_SHADOW_COLOR,           XML_TYPE_COLOR, 0 ),
+    GMAP( "ShadowTransparence",             XML_NAMESPACE_DRAW, XML_SHADOW_OPACITY, XML_TYPE_NEG_PERCENT, 0 ),
+    GMAPV( "ShadowBlur",                     XML_NAMESPACE_LO_EXT, XML_SHADOW_BLUR, XML_TYPE_MEASURE, 0, SvtSaveOptions::ODFSVER_FUTURE_EXTENDED),
+
+    // glow attributes
+    GMAPV( "GlowEffectRadius",                 XML_NAMESPACE_LO_EXT, XML_GLOW_RADIUS,          XML_TYPE_MEASURE  , 0, SvtSaveOptions::ODFSVER_FUTURE_EXTENDED),
+    GMAPV( "GlowEffectColor",                  XML_NAMESPACE_LO_EXT, XML_GLOW_COLOR,           XML_TYPE_COLOR    , 0, SvtSaveOptions::ODFSVER_FUTURE_EXTENDED),
+    GMAPV( "GlowEffectTransparency",           XML_NAMESPACE_LO_EXT, XML_GLOW_TRANSPARENCY,    XML_TYPE_PERCENT16, 0, SvtSaveOptions::ODFSVER_FUTURE_EXTENDED),
+
+    // soft edge attributes
+    GMAPV( "SoftEdgeRadius",                XML_NAMESPACE_LO_EXT, XML_SOFTEDGE_RADIUS,      XML_TYPE_MEASURE          , 0, SvtSaveOptions::ODFSVER_FUTURE_EXTENDED),
+
+    // graphic attributes
+    GMAP( "GraphicColorMode",               XML_NAMESPACE_DRAW, XML_COLOR_MODE,             XML_TYPE_COLOR_MODE, 0 ), // exists in SW, too, with same property name
+    GMAP( "AdjustLuminance",                XML_NAMESPACE_DRAW, XML_LUMINANCE,              XML_TYPE_PERCENT16, 0 ), // signed? exists in SW, too, with same property name
+    GMAP( "AdjustContrast",                 XML_NAMESPACE_DRAW, XML_CONTRAST,               XML_TYPE_PERCENT16, 0 ), // signed? exists in SW, too, with same property name
+    GMAP( "Gamma",                          XML_NAMESPACE_DRAW, XML_GAMMA,                  XML_TYPE_DOUBLE_PERCENT, 0 ), // signed? exists in SW, too, with same property name
+    GMAP( "AdjustRed",                      XML_NAMESPACE_DRAW, XML_RED,                    XML_TYPE_PERCENT16, 0 ), // signed? exists in SW, too, with same property name
+    GMAP( "AdjustGreen",                    XML_NAMESPACE_DRAW, XML_GREEN,                  XML_TYPE_PERCENT16, 0 ), // signed? exists in SW, too, with same property name
+    GMAP( "AdjustBlue",                     XML_NAMESPACE_DRAW, XML_BLUE,                   XML_TYPE_PERCENT16, 0 ), // signed? exists in SW, too, with same property name
+    GMAPV( "GraphicCrop",                   XML_NAMESPACE_FO,   XML_CLIP,                   XML_TYPE_TEXT_CLIP, CTF_TEXT_CLIP, SvtSaveOptions::ODFSVER_012), // exists in SW, too, with same property name
+    GMAP( "GraphicCrop",                    XML_NAMESPACE_FO,   XML_CLIP,                   XML_TYPE_TEXT_CLIP11, CTF_TEXT_CLIP11 ), // exists in SW, too, with same property name
+    GMAP( "Transparency",                   XML_NAMESPACE_DRAW, XML_IMAGE_OPACITY,          XML_TYPE_NEG_PERCENT16|MID_FLAG_MULTI_PROPERTY, 0 ), // exists in SW, too, with same property name // #i25616#
+    GMAP( "IsMirrored",                     XML_NAMESPACE_STYLE,    XML_MIRROR,             XML_TYPE_SD_MIRROR|MID_FLAG_MULTI_PROPERTY, 0 ),  // exists in SW, too // #i40214#
+
+    // animation text attributes
+    TMAP( "TextAnimationKind",              XML_NAMESPACE_STYLE,XML_TEXT_BLINKING,          XML_TYPE_TEXT_ANIMATION_BLINKING, CTF_TEXTANIMATION_BLINKING ),
+    GMAP( "TextAnimationKind",              XML_NAMESPACE_TEXT, XML_ANIMATION,              XML_TYPE_TEXT_ANIMATION, CTF_TEXTANIMATION_KIND ),
+    GMAP( "TextAnimationDirection",         XML_NAMESPACE_TEXT, XML_ANIMATION_DIRECTION,    XML_TYPE_TEXT_ANIMATION_DIRECTION, 0 ),
+    GMAP( "TextAnimationStartInside",       XML_NAMESPACE_TEXT, XML_ANIMATION_START_INSIDE, XML_TYPE_BOOL, 0 ),
+    GMAP( "TextAnimationStopInside",            XML_NAMESPACE_TEXT, XML_ANIMATION_STOP_INSIDE,  XML_TYPE_BOOL, 0 ),
+    GMAP( "TextAnimationCount",             XML_NAMESPACE_TEXT, XML_ANIMATION_REPEAT,       XML_TYPE_NUMBER16, 0 ),
+    GMAP( "TextAnimationDelay",             XML_NAMESPACE_TEXT, XML_ANIMATION_DELAY,        XML_TYPE_DURATION16_MS, 0 ),
+    GMAP( "TextAnimationAmount",                XML_NAMESPACE_TEXT, XML_ANIMATION_STEPS,        XML_TYPE_TEXT_ANIMATION_STEPS, 0 ),
+
+    // connector attributes
+    GMAP( "EdgeNode1HorzDist",              XML_NAMESPACE_DRAW, XML_START_LINE_SPACING_HORIZONTAL,  XML_TYPE_MEASURE, 0 ),
+    GMAP( "EdgeNode1VertDist",              XML_NAMESPACE_DRAW, XML_START_LINE_SPACING_VERTICAL,    XML_TYPE_MEASURE, 0 ),
+    GMAP( "EdgeNode2HorzDist",              XML_NAMESPACE_DRAW, XML_END_LINE_SPACING_HORIZONTAL,    XML_TYPE_MEASURE, 0 ),
+    GMAP( "EdgeNode2VertDist",              XML_NAMESPACE_DRAW, XML_END_LINE_SPACING_VERTICAL,      XML_TYPE_MEASURE, 0 ),
+
+    // measure attributes
+    GMAP( "MeasureLineDistance",                XML_NAMESPACE_DRAW, XML_LINE_DISTANCE,          XML_TYPE_MEASURE, 0 ),
+    GMAP( "MeasureHelpLineOverhang",            XML_NAMESPACE_DRAW, XML_GUIDE_OVERHANG,         XML_TYPE_MEASURE, 0 ),
+    GMAP( "MeasureHelpLineDistance",            XML_NAMESPACE_DRAW, XML_GUIDE_DISTANCE,         XML_TYPE_MEASURE, 0 ),
+    GMAP( "MeasureHelpLine1Length",         XML_NAMESPACE_DRAW, XML_START_GUIDE,            XML_TYPE_MEASURE, 0 ),
+    GMAP( "MeasureHelpLine2Length",         XML_NAMESPACE_DRAW, XML_END_GUIDE,              XML_TYPE_MEASURE, 0 ),
+    GMAP( "MeasureTextHorizontalPosition",  XML_NAMESPACE_DRAW, XML_MEASURE_ALIGN,          XML_SD_TYPE_MEASURE_HALIGN, 0 ),
+    GMAP( "MeasureTextVerticalPosition",    XML_NAMESPACE_DRAW, XML_MEASURE_VERTICAL_ALIGN, XML_SD_TYPE_MEASURE_VALIGN, 0 ),
+    GMAP( "MeasureUnit",                        XML_NAMESPACE_DRAW, XML_UNIT,                   XML_SD_TYPE_MEASURE_UNIT, 0 ),
+    GMAP( "MeasureShowUnit",                    XML_NAMESPACE_DRAW, XML_SHOW_UNIT,              XML_TYPE_BOOL, 0 ),
+    GMAP( "MeasureBelowReferenceEdge",      XML_NAMESPACE_DRAW, XML_PLACING,                XML_SD_TYPE_MEASURE_PLACING, 0 ),
+    GMAP( "MeasureTextRotate90",                XML_NAMESPACE_DRAW, XML_PARALLEL,               XML_TYPE_BOOL, 0 ),
+    GMAP( "MeasureDecimalPlaces",           XML_NAMESPACE_DRAW, XML_DECIMAL_PLACES,         XML_TYPE_NUMBER16, 0 ),
+
+    // 3D geometry attributes
+    GMAP( "D3DHorizontalSegments",          XML_NAMESPACE_DR3D, XML_HORIZONTAL_SEGMENTS,    XML_TYPE_NUMBER, 0 ),
+    GMAP( "D3DVerticalSegments",                XML_NAMESPACE_DR3D, XML_VERTICAL_SEGMENTS,      XML_TYPE_NUMBER, 0 ),
+    GMAP( "D3DPercentDiagonal",             XML_NAMESPACE_DR3D, XML_EDGE_ROUNDING,          XML_TYPE_PERCENT, 0 ),
+    GMAP( "D3DBackscale",                   XML_NAMESPACE_DR3D, XML_BACK_SCALE,             XML_TYPE_PERCENT, 0 ),
+    GMAP( "D3DEndAngle",                        XML_NAMESPACE_DR3D, XML_END_ANGLE,              XML_TYPE_NUMBER, 0 ),
+    GMAP( "D3DDepth",                       XML_NAMESPACE_DR3D, XML_DEPTH,                  XML_TYPE_MEASURE, 0 ),
+    GMAP( "D3DDoubleSided",                 XML_NAMESPACE_DR3D, XML_BACKFACE_CULLING,       XML_SD_TYPE_BACKFACE_CULLING, 0 ),
+
+    // #107245# New 3D properties which are possible for lathe and extrude 3d objects
+    GMAP( "D3DCloseFront",                  XML_NAMESPACE_DR3D, XML_CLOSE_FRONT,            XML_TYPE_BOOL, 0 ),
+    GMAP( "D3DCloseBack",                   XML_NAMESPACE_DR3D, XML_CLOSE_BACK,             XML_TYPE_BOOL, 0 ),
+
+    // 3D lighting attributes
+    GMAP( "D3DNormalsKind",                 XML_NAMESPACE_DR3D, XML_NORMALS_KIND,           XML_SD_TYPE_NORMALS_KIND, 0 ),
+    GMAP( "D3DNormalsInvert",               XML_NAMESPACE_DR3D, XML_NORMALS_DIRECTION,      XML_SD_TYPE_NORMALS_DIRECTION, 0 ),
+
+    // 3D texture attributes
+    GMAP( "D3DTextureProjectionX",          XML_NAMESPACE_DR3D, XML_TEX_GENERATION_MODE_X,  XML_SD_TYPE_TEX_GENERATION_MODE_X, 0 ),
+    GMAP( "D3DTextureProjectionY",          XML_NAMESPACE_DR3D, XML_TEX_GENERATION_MODE_Y,  XML_SD_TYPE_TEX_GENERATION_MODE_Y, 0 ),
+    GMAP( "D3DTextureKind",                 XML_NAMESPACE_DR3D, XML_TEX_KIND,               XML_SD_TYPE_TEX_KIND, 0 ),
+    GMAP( "D3DTextureMode",                 XML_NAMESPACE_DR3D, XML_TEX_MODE,               XML_SD_TYPE_TEX_MODE, 0 ),
+    GMAP( "D3DTextureFilter",               XML_NAMESPACE_DR3D, XML_TEX_FILTER,             XML_SD_TYPE_BACKFACE_CULLING, 0 ),
+
+    // 3D material attributes
+    GMAP( "D3DMaterialColor",               XML_NAMESPACE_DR3D, XML_DIFFUSE_COLOR,          XML_TYPE_COLOR, 0 ),
+    GMAP( "D3DMaterialEmission",                XML_NAMESPACE_DR3D, XML_EMISSIVE_COLOR,         XML_TYPE_COLOR, 0 ),
+    GMAP( "D3DMaterialSpecular",                XML_NAMESPACE_DR3D, XML_SPECULAR_COLOR,         XML_TYPE_COLOR, 0 ),
+    GMAP( "D3DMaterialSpecularIntensity",   XML_NAMESPACE_DR3D, XML_SHININESS,              XML_TYPE_PERCENT, 0 ),
+
+    // 3D shadow attributes
+    GMAP( "D3DShadow3D",                        XML_NAMESPACE_DR3D, XML_SHADOW,                 XML_SD_TYPE_VISIBLE_HIDDEN, 0 ),
+
+    // #FontWork# attributes
+    GMAP( "FontWorkStyle",                  XML_NAMESPACE_DRAW, XML_FONTWORK_STYLE,                 XML_SD_TYPE_FONTWORK_STYLE| MID_FLAG_ELEMENT_ITEM_EXPORT, CTF_FONTWORK_STYLE  ),
+    GMAP( "FontWorkAdjust",                 XML_NAMESPACE_DRAW, XML_FONTWORK_ADJUST,                XML_SD_TYPE_FONTWORK_ADJUST | MID_FLAG_ELEMENT_ITEM_EXPORT,CTF_FONTWORK_ADJUST ),
+    GMAP( "FontWorkDistance",               XML_NAMESPACE_DRAW, XML_FONTWORK_DISTANCE,              XML_TYPE_MEASURE | MID_FLAG_ELEMENT_ITEM_EXPORT,           CTF_FONTWORK_DISTANCE   ),
+    GMAP( "FontWorkStart",                  XML_NAMESPACE_DRAW, XML_FONTWORK_START,                 XML_TYPE_MEASURE | MID_FLAG_ELEMENT_ITEM_EXPORT,           CTF_FONTWORK_START  ),
+    GMAP( "FontWorkMirror",                 XML_NAMESPACE_DRAW, XML_FONTWORK_MIRROR,                XML_TYPE_BOOL | MID_FLAG_ELEMENT_ITEM_EXPORT,              CTF_FONTWORK_MIRROR ),
+    GMAP( "FontWorkOutline",                XML_NAMESPACE_DRAW, XML_FONTWORK_OUTLINE,               XML_TYPE_BOOL | MID_FLAG_ELEMENT_ITEM_EXPORT,              CTF_FONTWORK_OUTLINE    ),
+    GMAP( "FontWorkShadow",                 XML_NAMESPACE_DRAW, XML_FONTWORK_SHADOW,                XML_SD_TYPE_FONTWORK_SHADOW | MID_FLAG_ELEMENT_ITEM_EXPORT,CTF_FONTWORK_SHADOW ),
+    GMAP( "FontWorkShadowColor",            XML_NAMESPACE_DRAW, XML_FONTWORK_SHADOW_COLOR,          XML_TYPE_COLOR | MID_FLAG_ELEMENT_ITEM_EXPORT,             CTF_FONTWORK_SHADOWCOLOR    ),
+    GMAP( "FontWorkShadowOffsetX",          XML_NAMESPACE_DRAW, XML_FONTWORK_SHADOW_OFFSET_X,       XML_TYPE_MEASURE | MID_FLAG_ELEMENT_ITEM_EXPORT,           CTF_FONTWORK_SHADOWOFFSETX  ),
+    GMAP( "FontWorkShadowOffsetY",          XML_NAMESPACE_DRAW, XML_FONTWORK_SHADOW_OFFSET_Y,       XML_TYPE_MEASURE | MID_FLAG_ELEMENT_ITEM_EXPORT,           CTF_FONTWORK_SHADOWOFFSETY  ),
+    GMAP( "FontWorkForm",                   XML_NAMESPACE_DRAW, XML_FONTWORK_FORM,                  XML_SD_TYPE_FONTWORK_FORM | MID_FLAG_ELEMENT_ITEM_EXPORT,  CTF_FONTWORK_FORM   ),
+    GMAP( "FontWorkHideForm",               XML_NAMESPACE_DRAW, XML_FONTWORK_HIDE_FORM,             XML_TYPE_BOOL | MID_FLAG_ELEMENT_ITEM_EXPORT,              CTF_FONTWORK_HIDEFORM   ),
+    GMAP( "FontWorkShadowTransparence",     XML_NAMESPACE_DRAW, XML_FONTWORK_SHADOW_TRANSPARENCE,   XML_TYPE_PERCENT | MID_FLAG_ELEMENT_ITEM_EXPORT,           CTF_FONTWORK_SHADOWTRANSPARENCE ),
+
+    // #FontWork# attributes
+    GMAPV("FontWorkStyle",              XML_NAMESPACE_DRAW_EXT, XML_FONTWORK_STYLE,                 XML_SD_TYPE_FONTWORK_STYLE, CTF_FONTWORK_STYLE,         SvtSaveOptions::ODFSVER_FUTURE_EXTENDED),
+    GMAPV("FontWorkAdjust",             XML_NAMESPACE_DRAW_EXT, XML_FONTWORK_ADJUST,                XML_SD_TYPE_FONTWORK_ADJUST,CTF_FONTWORK_ADJUST,        SvtSaveOptions::ODFSVER_FUTURE_EXTENDED),
+    GMAPV("FontWorkDistance",           XML_NAMESPACE_DRAW_EXT, XML_FONTWORK_DISTANCE,              XML_TYPE_MEASURE,           CTF_FONTWORK_DISTANCE,      SvtSaveOptions::ODFSVER_FUTURE_EXTENDED),
+    GMAPV("FontWorkStart",              XML_NAMESPACE_DRAW_EXT, XML_FONTWORK_START,                 XML_TYPE_MEASURE,           CTF_FONTWORK_START,         SvtSaveOptions::ODFSVER_FUTURE_EXTENDED),
+    GMAPV("FontWorkMirror",             XML_NAMESPACE_DRAW_EXT, XML_FONTWORK_MIRROR,                XML_TYPE_BOOL,              CTF_FONTWORK_MIRROR,        SvtSaveOptions::ODFSVER_FUTURE_EXTENDED),
+    GMAPV("FontWorkOutline",            XML_NAMESPACE_DRAW_EXT, XML_FONTWORK_OUTLINE,               XML_TYPE_BOOL,              CTF_FONTWORK_OUTLINE,       SvtSaveOptions::ODFSVER_FUTURE_EXTENDED),
+    GMAPV("FontWorkShadow",             XML_NAMESPACE_DRAW_EXT, XML_FONTWORK_SHADOW,                XML_SD_TYPE_FONTWORK_SHADOW,CTF_FONTWORK_SHADOW,        SvtSaveOptions::ODFSVER_FUTURE_EXTENDED),
+    GMAPV("FontWorkShadowColor",        XML_NAMESPACE_DRAW_EXT, XML_FONTWORK_SHADOW_COLOR,          XML_TYPE_COLOR,             CTF_FONTWORK_SHADOWCOLOR,   SvtSaveOptions::ODFSVER_FUTURE_EXTENDED),
+    GMAPV("FontWorkShadowOffsetX",      XML_NAMESPACE_DRAW_EXT, XML_FONTWORK_SHADOW_OFFSET_X,       XML_TYPE_MEASURE,           CTF_FONTWORK_SHADOWOFFSETX, SvtSaveOptions::ODFSVER_FUTURE_EXTENDED),
+    GMAPV("FontWorkShadowOffsetY",      XML_NAMESPACE_DRAW_EXT, XML_FONTWORK_SHADOW_OFFSET_Y,       XML_TYPE_MEASURE,           CTF_FONTWORK_SHADOWOFFSETY, SvtSaveOptions::ODFSVER_FUTURE_EXTENDED),
+    GMAPV("FontWorkForm",               XML_NAMESPACE_DRAW_EXT, XML_FONTWORK_FORM,                  XML_SD_TYPE_FONTWORK_FORM,  CTF_FONTWORK_FORM,          SvtSaveOptions::ODFSVER_FUTURE_EXTENDED),
+    GMAPV("FontWorkHideForm",           XML_NAMESPACE_DRAW_EXT, XML_FONTWORK_HIDE_FORM,             XML_TYPE_BOOL,              CTF_FONTWORK_HIDEFORM,      SvtSaveOptions::ODFSVER_FUTURE_EXTENDED),
+    GMAPV("FontWorkShadowTransparence", XML_NAMESPACE_DRAW_EXT, XML_FONTWORK_SHADOW_TRANSPARENCE,   XML_TYPE_PERCENT,           CTF_FONTWORK_SHADOWTRANSPARENCE, SvtSaveOptions::ODFSVER_FUTURE_EXTENDED),
+
+    // control attributes (border exists one more time for the text additions of shapes)
+    GMAP( "ControlSymbolColor",             XML_NAMESPACE_DRAW, XML_SYMBOL_COLOR,           XML_TYPE_COLOR, 0 ),
+    GMAP( "ControlBackground",              XML_NAMESPACE_FO,   XML_BACKGROUND_COLOR,       XML_TYPE_COLOR|MID_FLAG_MULTI_PROPERTY, 0 ),
+    GMAP( "ControlBorder",                  XML_NAMESPACE_FO,   XML_BORDER,                 XML_SD_TYPE_CONTROL_BORDER|MID_FLAG_MULTI_PROPERTY|MID_FLAG_MERGE_ATTRIBUTE, 0 ),
+    GMAP( "ControlBorderColor",             XML_NAMESPACE_FO,   XML_BORDER,                 XML_SD_TYPE_CONTROL_BORDER_COLOR|MID_FLAG_MULTI_PROPERTY|MID_FLAG_MERGE_ATTRIBUTE, 0 ),
+    GMAP( "ControlDataStyle",               XML_NAMESPACE_STYLE,XML_DATA_STYLE_NAME,        XML_TYPE_STRING|MID_FLAG_NO_PROPERTY_EXPORT|MID_FLAG_SPECIAL_ITEM, CTF_SD_CONTROL_SHAPE_DATA_STYLE ),
+    GMAP( "ControlTextEmphasis",            XML_NAMESPACE_STYLE,XML_TEXT_EMPHASIZE,         XML_TYPE_CONTROL_TEXT_EMPHASIZE, 0 ),
+    GMAP( "ImageScaleMode",                 XML_NAMESPACE_STYLE,XML_REPEAT,                 XML_SD_TYPE_IMAGE_SCALE_MODE|MID_FLAG_MULTI_PROPERTY, 0 ),
+    GMAP( "ControlWritingMode",             XML_NAMESPACE_STYLE,XML_WRITING_MODE,           XML_TYPE_TEXT_WRITING_MODE_WITH_DEFAULT|MID_FLAG_MULTI_PROPERTY, CTF_CONTROLWRITINGMODE ),
+
+    // special entries for floating frames
+    GMAP( "FrameIsAutoScroll",          XML_NAMESPACE_DRAW, XML_FRAME_DISPLAY_SCROLLBAR,    XML_TYPE_BOOL|MID_FLAG_MULTI_PROPERTY,              CTF_FRAME_DISPLAY_SCROLLBAR ),
+    GMAP( "FrameIsBorder",              XML_NAMESPACE_DRAW, XML_FRAME_DISPLAY_BORDER,       XML_TYPE_BOOL|MID_FLAG_MULTI_PROPERTY,              CTF_FRAME_DISPLAY_BORDER ),
+    GMAP( "FrameMarginWidth",           XML_NAMESPACE_DRAW, XML_FRAME_MARGIN_HORIZONTAL,    XML_TYPE_MEASURE_PX|MID_FLAG_MULTI_PROPERTY,        CTF_FRAME_MARGIN_HORI ),
+    GMAP( "FrameMarginHeight",          XML_NAMESPACE_DRAW, XML_FRAME_MARGIN_VERTICAL,      XML_TYPE_MEASURE_PX|MID_FLAG_MULTI_PROPERTY,        CTF_FRAME_MARGIN_VERT ),
+    GMAP( "VisibleArea",                XML_NAMESPACE_DRAW, XML_VISIBLE_AREA_LEFT,          XML_TYPE_RECTANGLE_LEFT|MID_FLAG_MERGE_PROPERTY|MID_FLAG_MULTI_PROPERTY|MID_FLAG_NO_PROPERTY,   CTF_SD_OLE_VIS_AREA_IMPORT_LEFT ),
+    GMAP( "VisibleArea",                XML_NAMESPACE_DRAW, XML_VISIBLE_AREA_TOP,           XML_TYPE_RECTANGLE_TOP|MID_FLAG_MERGE_PROPERTY|MID_FLAG_MULTI_PROPERTY|MID_FLAG_NO_PROPERTY,    CTF_SD_OLE_VIS_AREA_IMPORT_TOP ),
+    GMAP( "VisibleArea",                XML_NAMESPACE_DRAW, XML_VISIBLE_AREA_WIDTH,         XML_TYPE_RECTANGLE_WIDTH|MID_FLAG_MERGE_PROPERTY|MID_FLAG_MULTI_PROPERTY|MID_FLAG_NO_PROPERTY,  CTF_SD_OLE_VIS_AREA_IMPORT_WIDTH ),
+    GMAP( "VisibleArea",                XML_NAMESPACE_DRAW, XML_VISIBLE_AREA_HEIGHT,        XML_TYPE_RECTANGLE_HEIGHT|MID_FLAG_MERGE_PROPERTY|MID_FLAG_MULTI_PROPERTY|MID_FLAG_NO_PROPERTY, CTF_SD_OLE_VIS_AREA_IMPORT_HEIGHT ),
+    GMAP( "IsInternal",                 XML_NAMESPACE_DRAW, XML__EMPTY,                     XML_TYPE_BUILDIN_CMP_ONLY,                          CTF_SD_OLE_ISINTERNAL ),
+    GMAP( "IsInternal",                 XML_NAMESPACE_DRAW, XML_VISIBLE_AREA_LEFT,          XML_TYPE_RECTANGLE_LEFT|MID_FLAG_MERGE_PROPERTY|MID_FLAG_MULTI_PROPERTY|MID_FLAG_NO_PROPERTY_IMPORT,    CTF_SD_OLE_VIS_AREA_EXPORT_LEFT ),
+    GMAP( "IsInternal",                 XML_NAMESPACE_DRAW, XML_VISIBLE_AREA_TOP,           XML_TYPE_RECTANGLE_TOP|MID_FLAG_MERGE_PROPERTY|MID_FLAG_MULTI_PROPERTY|MID_FLAG_NO_PROPERTY_IMPORT,     CTF_SD_OLE_VIS_AREA_EXPORT_TOP ),
+    GMAP( "IsInternal",                 XML_NAMESPACE_DRAW, XML_VISIBLE_AREA_WIDTH,         XML_TYPE_RECTANGLE_WIDTH|MID_FLAG_MERGE_PROPERTY|MID_FLAG_MULTI_PROPERTY|MID_FLAG_NO_PROPERTY_IMPORT,   CTF_SD_OLE_VIS_AREA_EXPORT_WIDTH ),
+    GMAP( "IsInternal",                 XML_NAMESPACE_DRAW, XML_VISIBLE_AREA_HEIGHT,        XML_TYPE_RECTANGLE_HEIGHT|MID_FLAG_MERGE_PROPERTY|MID_FLAG_MULTI_PROPERTY|MID_FLAG_NO_PROPERTY_IMPORT,  CTF_SD_OLE_VIS_AREA_EXPORT_HEIGHT ),
+
+    GMAP( "Aspect",                     XML_NAMESPACE_DRAW, XML_DRAW_ASPECT,                XML_TYPE_TEXT_DRAW_ASPECT|MID_FLAG_MULTI_PROPERTY,  CTF_SD_OLE_ASPECT ),
+
+    // caption properties
+    GMAP( "CaptionType",                    XML_NAMESPACE_DRAW, XML_CAPTION_TYPE,               XML_SD_TYPE_CAPTION_TYPE, 0 ),
+    GMAP( "CaptionIsFixedAngle",            XML_NAMESPACE_DRAW, XML_CAPTION_ANGLE_TYPE,         XML_SD_TYPE_CAPTION_ANGLE_TYPE, 0 ),
+    GMAP( "CaptionAngle",               XML_NAMESPACE_DRAW, XML_CAPTION_ANGLE,              XML_TYPE_NUMBER, 0 ),
+    GMAP( "CaptionGap",                 XML_NAMESPACE_DRAW, XML_CAPTION_GAP,                XML_TYPE_MEASURE, 0 ),
+    GMAP( "CaptionEscapeDirection",     XML_NAMESPACE_DRAW, XML_CAPTION_ESCAPE_DIRECTION,   XML_SD_TYPE_CAPTION_ESC_DIR, 0 ),
+    GMAP( "CaptionIsEscapeRelative",    XML_NAMESPACE_DRAW, XML_CAPTION_ESCAPE,             XML_SD_TYPE_CAPTION_IS_ESC_REL|MID_FLAG_MULTI_PROPERTY, CTF_CAPTION_ISESCREL ),
+    GMAP( "CaptionEscapeRelative",      XML_NAMESPACE_DRAW, XML_CAPTION_ESCAPE,             XML_SD_TYPE_CAPTION_ESC_REL|MID_FLAG_MULTI_PROPERTY, CTF_CAPTION_ESCREL ),
+    GMAP( "CaptionEscapeAbsolute",      XML_NAMESPACE_DRAW, XML_CAPTION_ESCAPE,             XML_SD_TYPE_CAPTION_ESC_ABS|MID_FLAG_MULTI_PROPERTY, CTF_CAPTION_ESCABS ),
+    GMAP( "CaptionLineLength",          XML_NAMESPACE_DRAW, XML_CAPTION_LINE_LENGTH,        XML_TYPE_MEASURE, 0 ),
+    GMAP( "CaptionIsFitLineLength",     XML_NAMESPACE_DRAW, XML_CAPTION_FIT_LINE_LENGTH,    XML_TYPE_BOOL, 0 ),
+
+    // misc object properties
+    GMAP( "MoveProtect",                    XML_NAMESPACE_STYLE, XML_PROTECT,               XML_SD_TYPE_MOVE_PROTECT|MID_FLAG_MULTI_PROPERTY|MID_FLAG_MERGE_ATTRIBUTE, CTF_SD_MOVE_PROTECT ),
+    GMAP( "SizeProtect",                    XML_NAMESPACE_STYLE, XML_PROTECT,               XML_SD_TYPE_SIZE_PROTECT|MID_FLAG_MULTI_PROPERTY|MID_FLAG_MERGE_ATTRIBUTE, CTF_SD_SIZE_PROTECT ),
+
+    MAP_END()
+};
+
+// entry list for presentation page properties
+
+const XMLPropertyMapEntry aXMLSDPresPageProps[] =
+{
+    DPMAP( "UserDefinedAttributes",     XML_NAMESPACE_TEXT, XML_XMLNS,                  XML_TYPE_ATTRIBUTE_CONTAINER | MID_FLAG_SPECIAL_ITEM, 0 ),
+
+    DPMAP( "Change",                        XML_NAMESPACE_PRESENTATION, XML_TRANSITION_TYPE,    XML_SD_TYPE_PRESPAGE_TYPE, CTF_PAGE_TRANS_TYPE ),
+    DPMAP( "Effect",                        XML_NAMESPACE_PRESENTATION, XML_TRANSITION_STYLE,   XML_SD_TYPE_PRESPAGE_STYLE, CTF_PAGE_TRANS_STYLE ),
+    DPMAP( "Speed",                     XML_NAMESPACE_PRESENTATION, XML_TRANSITION_SPEED,   XML_SD_TYPE_PRESPAGE_SPEED, CTF_PAGE_TRANS_SPEED ),
+    DPMAP( "HighResDuration",           XML_NAMESPACE_PRESENTATION, XML_DURATION,           XML_SD_TYPE_PRESPAGE_DURATION, CTF_PAGE_TRANS_DURATION ),
+    DPMAP( "Visible",                   XML_NAMESPACE_PRESENTATION, XML_VISIBILITY,         XML_SD_TYPE_PRESPAGE_VISIBILITY, CTF_PAGE_VISIBLE ),
+    DPMAP( "Sound",                     XML_NAMESPACE_PRESENTATION, XML_SOUND,              XML_TYPE_STRING|MID_FLAG_ELEMENT_ITEM, CTF_PAGE_SOUND_URL ),
+    DPMAP( "BackgroundFullSize",            XML_NAMESPACE_DRAW,         XML_BACKGROUND_SIZE,    XML_SD_TYPE_PRESPAGE_BACKSIZE, CTF_PAGE_BACKSIZE ),
+
+    DPMAP( "IsBackgroundVisible",       XML_NAMESPACE_PRESENTATION, XML_BACKGROUND_VISIBLE, XML_TYPE_BOOL, 0 ),
+    DPMAP( "IsBackgroundObjectsVisible",    XML_NAMESPACE_PRESENTATION, XML_BACKGROUND_OBJECTS_VISIBLE, XML_TYPE_BOOL, 0 ),
+
+    DPMAP( "FillStyle",                 XML_NAMESPACE_DRAW, XML_FILL,                   XML_SD_TYPE_FILLSTYLE, 0 ),
+    DPMAP( "FillColor",                 XML_NAMESPACE_DRAW, XML_FILL_COLOR,             XML_TYPE_COLOR, 0 ),
+    DPMAP( "FillGradientName",          XML_NAMESPACE_DRAW, XML_FILL_GRADIENT_NAME,     XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_FILLGRADIENTNAME ),
+    DPMAP( "FillGradientStepCount",     XML_NAMESPACE_DRAW, XML_GRADIENT_STEP_COUNT,    XML_TYPE_NUMBER, 0 ),
+    DPMAP( "FillHatchName",             XML_NAMESPACE_DRAW, XML_FILL_HATCH_NAME,        XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_FILLHATCHNAME ),
+    GMAP( "FillBackground",                 XML_NAMESPACE_DRAW, XML_FILL_HATCH_SOLID,       XML_TYPE_BOOL, 0 ),
+    DPMAP( "FillBitmapName",                XML_NAMESPACE_DRAW, XML_FILL_IMAGE_NAME,    XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_FILLBITMAPNAME ),
+    DPMAP( "FillTransparence",              XML_NAMESPACE_DRAW, XML_OPACITY,           XML_TYPE_NEG_PERCENT|MID_FLAG_MULTI_PROPERTY,  0 ),
+    DPMAP( "FillTransparenceGradientName",  XML_NAMESPACE_DRAW, XML_OPACITY_NAME,       XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_FILLTRANSNAME ),
+    DPMAP( "FillBitmapSizeX",           XML_NAMESPACE_DRAW, XML_FILL_IMAGE_WIDTH,       XML_SD_TYPE_FILLBITMAPSIZE|MID_FLAG_MULTI_PROPERTY, 0 ),
+    DPMAP( "FillBitmapLogicalSize",     XML_NAMESPACE_DRAW, XML_FILL_IMAGE_WIDTH,       XML_SD_TYPE_LOGICAL_SIZE|MID_FLAG_MULTI_PROPERTY, 0 ),
+    DPMAP( "FillBitmapSizeY",           XML_NAMESPACE_DRAW, XML_FILL_IMAGE_HEIGHT,      XML_SD_TYPE_FILLBITMAPSIZE|MID_FLAG_MULTI_PROPERTY, 0 ),
+    DPMAP( "FillBitmapLogicalSize",     XML_NAMESPACE_DRAW, XML_FILL_IMAGE_HEIGHT,      XML_SD_TYPE_LOGICAL_SIZE|MID_FLAG_MULTI_PROPERTY, 0 ),
+    DPMAP( "FillBitmapMode",            XML_NAMESPACE_STYLE,XML_REPEAT,                 XML_SD_TYPE_BITMAP_MODE, 0 ),
+    DPMAP( "FillBitmapPositionOffsetX", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_REF_POINT_X, XML_TYPE_PERCENT, 0 ),
+    DPMAP( "FillBitmapPositionOffsetY", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_REF_POINT_Y, XML_TYPE_PERCENT, 0 ),
+    DPMAP( "FillBitmapRectanglePoint",  XML_NAMESPACE_DRAW, XML_FILL_IMAGE_REF_POINT,   XML_SD_TYPE_BITMAP_REFPOINT, 0 ),
+    DPMAP( "FillBitmapOffsetX",         XML_NAMESPACE_DRAW, XML_TILE_REPEAT_OFFSET,     XML_SD_TYPE_BITMAPREPOFFSETX|MID_FLAG_MULTI_PROPERTY, CTF_REPEAT_OFFSET_X ),
+    DPMAP( "FillBitmapOffsetY",         XML_NAMESPACE_DRAW, XML_TILE_REPEAT_OFFSET, XML_SD_TYPE_BITMAPREPOFFSETY|MID_FLAG_MULTI_PROPERTY, CTF_REPEAT_OFFSET_Y ),
+
+    DPMAP( "IsHeaderVisible",           XML_NAMESPACE_PRESENTATION, XML_DISPLAY_HEADER,         XML_SD_TYPE_HEADER_FOOTER_VISIBILITY_TYPE, CTF_HEADER_VISIBLE ),
+    DPMAP( "IsFooterVisible",           XML_NAMESPACE_PRESENTATION, XML_DISPLAY_FOOTER,         XML_SD_TYPE_HEADER_FOOTER_VISIBILITY_TYPE, CTF_FOOTER_VISIBLE ),
+    DPMAP( "IsPageNumberVisible",       XML_NAMESPACE_PRESENTATION, XML_DISPLAY_PAGE_NUMBER,    XML_SD_TYPE_HEADER_FOOTER_VISIBILITY_TYPE, CTF_PAGE_NUMBER_VISIBLE ),
+    DPMAP( "IsDateTimeVisible",         XML_NAMESPACE_PRESENTATION, XML_DISPLAY_DATE_TIME,      XML_SD_TYPE_HEADER_FOOTER_VISIBILITY_TYPE, CTF_DATE_TIME_VISIBLE ),
+
+    DPMAP( "TransitionType",            XML_NAMESPACE_SMIL, XML_TYPE,                   XML_SD_TYPE_TRANSITION_TYPE, CTF_PAGE_TRANSITION_TYPE ),
+    DPMAP( "TransitionSubtype",         XML_NAMESPACE_SMIL, XML_SUBTYPE,                XML_SD_TYPE_TRANSTIION_SUBTYPE, CTF_PAGE_TRANSITION_SUBTYPE ),
+    DPMAP( "TransitionDirection",       XML_NAMESPACE_SMIL, XML_DIRECTION,              XML_SD_TYPE_TRANSTIION_DIRECTION, CTF_PAGE_TRANSITION_DIRECTION ),
+    DPMAP( "TransitionFadeColor",       XML_NAMESPACE_SMIL, XML_FADECOLOR,              XML_TYPE_COLOR, CTF_PAGE_TRANSITION_FADECOLOR ),
+    MAP_END()
+};
+
+/** contains the attribute to property mapping for a drawing layer table
+    WARNING: if attributes are added, SdXMLTableShapeContext::processAttribute needs to be updated!
+*/
+const XMLPropertyMapEntry aXMLTableShapeAttributes[] =
+{
+    MAP_( "UseFirstRowStyle",       XML_NAMESPACE_TABLE, XML_USE_FIRST_ROW_STYLES, XML_TYPE_BOOL, 0 ),
+    MAP_( "UseLastRowStyle",        XML_NAMESPACE_TABLE, XML_USE_LAST_ROW_STYLES, XML_TYPE_BOOL, 0 ),
+    MAP_( "UseFirstColumnStyle",    XML_NAMESPACE_TABLE, XML_USE_FIRST_COLUMN_STYLES, XML_TYPE_BOOL, 0 ),
+    MAP_( "UseLastColumnStyle",     XML_NAMESPACE_TABLE, XML_USE_LAST_COLUMN_STYLES, XML_TYPE_BOOL, 0 ),
+    MAP_( "UseBandingRowStyle",     XML_NAMESPACE_TABLE, XML_USE_BANDING_ROWS_STYLES, XML_TYPE_BOOL, 0 ),
+    MAP_( "UseBandingColumnStyle",  XML_NAMESPACE_TABLE, XML_USE_BANDING_COLUMNS_STYLES, XML_TYPE_BOOL, 0 ),
+    MAP_END()
+};
+
+// implementation of factory for own graphic properties
+
+SvXMLEnumMapEntry<drawing::LineStyle> const aXML_LineStyle_EnumMap[] =
+{
+    { XML_NONE,     drawing::LineStyle_NONE },
+    { XML_SOLID,    drawing::LineStyle_SOLID },
+    { XML_DASH,     drawing::LineStyle_DASH },
+    { XML_TOKEN_INVALID, drawing::LineStyle(0) }
+};
+
+SvXMLEnumMapEntry<drawing::LineJoint> const aXML_LineJoint_EnumMap[] =
+{
+    { XML_NONE,     drawing::LineJoint_NONE },
+    { XML_MITER,    drawing::LineJoint_MITER },
+    { XML_ROUND,    drawing::LineJoint_ROUND },
+    { XML_BEVEL,    drawing::LineJoint_BEVEL },
+    { XML_MIDDLE,   drawing::LineJoint_MIDDLE },
+    { XML_TOKEN_INVALID, drawing::LineJoint(0) }
+};
+
+SvXMLEnumMapEntry<drawing::LineCap> const aXML_LineCap_EnumMap[] =
+{
+    { XML_BUTT, drawing::LineCap_BUTT },
+    { XML_ROUND, drawing::LineCap_ROUND },
+    // use XML_GRADIENTSTYLE_SQUARE as XML_SQUARE, is defined as "square" already
+    { XML_GRADIENTSTYLE_SQUARE, drawing::LineCap_SQUARE },
+    { XML_TOKEN_INVALID, drawing::LineCap(0) }
+};
+
+SvXMLEnumMapEntry<drawing::FillStyle> const aXML_FillStyle_EnumMap[] =
+{
+    { XML_NONE,     drawing::FillStyle_NONE },
+    { XML_SOLID,    drawing::FillStyle_SOLID },
+    { XML_BITMAP,   drawing::FillStyle_BITMAP },
+    { XML_GRADIENT, drawing::FillStyle_GRADIENT },
+    { XML_HATCH,    drawing::FillStyle_HATCH },
+    { XML_TOKEN_INVALID, drawing::FillStyle(0) }
+};
+
+SvXMLEnumMapEntry<sal_Int32> const aXML_PresChange_EnumMap[] =
+{
+    { XML_MANUAL,           0 },
+    { XML_AUTOMATIC,        1 },
+    { XML_SEMI_AUTOMATIC,   2 },
+    { XML_TOKEN_INVALID,    0 }
+};
+
+SvXMLEnumMapEntry<presentation::AnimationSpeed> const aXML_TransSpeed_EnumMap[] =
+{
+    { XML_FAST,     presentation::AnimationSpeed_FAST },
+    { XML_MEDIUM,   presentation::AnimationSpeed_MEDIUM },
+    { XML_SLOW,     presentation::AnimationSpeed_SLOW },
+    { XML_TOKEN_INVALID, presentation::AnimationSpeed(0) }
+};
+
+SvXMLEnumMapEntry<presentation::FadeEffect> const aXML_FadeEffect_EnumMap[] =
+{
+    { XML_NONE,                 presentation::FadeEffect_NONE },
+    { XML_FADE_FROM_LEFT,       presentation::FadeEffect_FADE_FROM_LEFT },
+    { XML_FADE_FROM_TOP,        presentation::FadeEffect_FADE_FROM_TOP },
+    { XML_FADE_FROM_RIGHT,      presentation::FadeEffect_FADE_FROM_RIGHT },
+    { XML_FADE_FROM_BOTTOM,     presentation::FadeEffect_FADE_FROM_BOTTOM },
+    { XML_FADE_TO_CENTER,       presentation::FadeEffect_FADE_TO_CENTER },
+    { XML_FADE_FROM_CENTER,     presentation::FadeEffect_FADE_FROM_CENTER },
+    { XML_MOVE_FROM_LEFT,       presentation::FadeEffect_MOVE_FROM_LEFT },
+    { XML_MOVE_FROM_TOP,        presentation::FadeEffect_MOVE_FROM_TOP },
+    { XML_MOVE_FROM_RIGHT,      presentation::FadeEffect_MOVE_FROM_RIGHT },
+    { XML_MOVE_FROM_BOTTOM,     presentation::FadeEffect_MOVE_FROM_BOTTOM },
+    { XML_ROLL_FROM_TOP,        presentation::FadeEffect_ROLL_FROM_TOP },
+    { XML_ROLL_FROM_LEFT,       presentation::FadeEffect_ROLL_FROM_LEFT },
+    { XML_ROLL_FROM_RIGHT,      presentation::FadeEffect_ROLL_FROM_RIGHT },
+    { XML_ROLL_FROM_BOTTOM,     presentation::FadeEffect_ROLL_FROM_BOTTOM },
+    { XML_VERTICAL_STRIPES,     presentation::FadeEffect_VERTICAL_STRIPES },
+    { XML_HORIZONTAL_STRIPES,   presentation::FadeEffect_HORIZONTAL_STRIPES },
+    { XML_CLOCKWISE,            presentation::FadeEffect_CLOCKWISE },
+    { XML_COUNTERCLOCKWISE,     presentation::FadeEffect_COUNTERCLOCKWISE },
+    { XML_FADE_FROM_UPPERLEFT,  presentation::FadeEffect_FADE_FROM_UPPERLEFT },
+    { XML_FADE_FROM_UPPERRIGHT, presentation::FadeEffect_FADE_FROM_UPPERRIGHT },
+    { XML_FADE_FROM_LOWERLEFT,  presentation::FadeEffect_FADE_FROM_LOWERLEFT },
+    { XML_FADE_FROM_LOWERRIGHT, presentation::FadeEffect_FADE_FROM_LOWERRIGHT },
+    { XML_CLOSE_VERTICAL,       presentation::FadeEffect_CLOSE_VERTICAL },
+    { XML_CLOSE_HORIZONTAL,     presentation::FadeEffect_CLOSE_HORIZONTAL },
+    { XML_OPEN_VERTICAL,        presentation::FadeEffect_OPEN_VERTICAL },
+    { XML_OPEN_HORIZONTAL,      presentation::FadeEffect_OPEN_HORIZONTAL },
+    { XML_SPIRALIN_LEFT,        presentation::FadeEffect_SPIRALIN_LEFT },
+    { XML_SPIRALIN_RIGHT,       presentation::FadeEffect_SPIRALIN_RIGHT },
+    { XML_SPIRALOUT_LEFT,       presentation::FadeEffect_SPIRALOUT_LEFT },
+    { XML_SPIRALOUT_RIGHT,      presentation::FadeEffect_SPIRALOUT_RIGHT },
+    { XML_DISSOLVE,             presentation::FadeEffect_DISSOLVE },
+    { XML_WAVYLINE_FROM_LEFT,   presentation::FadeEffect_WAVYLINE_FROM_LEFT },
+    { XML_WAVYLINE_FROM_TOP,    presentation::FadeEffect_WAVYLINE_FROM_TOP },
+    { XML_WAVYLINE_FROM_RIGHT,  presentation::FadeEffect_WAVYLINE_FROM_RIGHT },
+    { XML_WAVYLINE_FROM_BOTTOM, presentation::FadeEffect_WAVYLINE_FROM_BOTTOM },
+    { XML_RANDOM,               presentation::FadeEffect_RANDOM },
+    { XML_STRETCH_FROM_LEFT,    presentation::FadeEffect_STRETCH_FROM_LEFT },
+    { XML_STRETCH_FROM_TOP,     presentation::FadeEffect_STRETCH_FROM_TOP },
+    { XML_STRETCH_FROM_RIGHT,   presentation::FadeEffect_STRETCH_FROM_RIGHT },
+    { XML_STRETCH_FROM_BOTTOM,  presentation::FadeEffect_STRETCH_FROM_BOTTOM },
+    { XML_VERTICAL_LINES,       presentation::FadeEffect_VERTICAL_LINES },
+    { XML_HORIZONTAL_LINES,     presentation::FadeEffect_HORIZONTAL_LINES },
+    { XML_MOVE_FROM_UPPERLEFT,  presentation::FadeEffect_MOVE_FROM_UPPERLEFT },
+    { XML_MOVE_FROM_UPPERRIGHT, presentation::FadeEffect_MOVE_FROM_UPPERRIGHT },
+    { XML_MOVE_FROM_LOWERRIGHT, presentation::FadeEffect_MOVE_FROM_LOWERRIGHT },
+    { XML_MOVE_FROM_LOWERLEFT,  presentation::FadeEffect_MOVE_FROM_LOWERLEFT },
+    { XML_UNCOVER_TO_LEFT,      presentation::FadeEffect_UNCOVER_TO_LEFT },
+    { XML_UNCOVER_TO_UPPERLEFT, presentation::FadeEffect_UNCOVER_TO_UPPERLEFT },
+    { XML_UNCOVER_TO_TOP,       presentation::FadeEffect_UNCOVER_TO_TOP },
+    { XML_UNCOVER_TO_UPPERRIGHT,presentation::FadeEffect_UNCOVER_TO_UPPERRIGHT },
+    { XML_UNCOVER_TO_RIGHT,     presentation::FadeEffect_UNCOVER_TO_RIGHT },
+    { XML_UNCOVER_TO_LOWERRIGHT,presentation::FadeEffect_UNCOVER_TO_LOWERRIGHT },
+    { XML_UNCOVER_TO_BOTTOM,    presentation::FadeEffect_UNCOVER_TO_BOTTOM },
+    { XML_UNCOVER_TO_LOWERLEFT, presentation::FadeEffect_UNCOVER_TO_LOWERLEFT },
+    { XML_VERTICAL_CHECKERBOARD,presentation::FadeEffect_VERTICAL_CHECKERBOARD },
+    { XML_HORIZONTAL_CHECKERBOARD,presentation::FadeEffect_HORIZONTAL_CHECKERBOARD },
+    { XML_TOKEN_INVALID, presentation::FadeEffect(0) }
+};
+
+SvXMLEnumMapEntry<drawing::ConnectorType> const aXML_ConnectionKind_EnumMap[] =
+{
+    { XML_STANDARD,     drawing::ConnectorType_STANDARD },
+    { XML_CURVE,        drawing::ConnectorType_CURVE },
+    { XML_LINE,         drawing::ConnectorType_LINE },
+    { XML_LINES,        drawing::ConnectorType_LINES },
+    { XML_TOKEN_INVALID, drawing::ConnectorType(0) }
+};
+
+SvXMLEnumMapEntry<drawing::BitmapMode> const aXML_BitmapMode_EnumMap[] =
+{
+    { XML_REPEAT,                   drawing::BitmapMode_REPEAT },
+    { XML_STRETCH,                  drawing::BitmapMode_STRETCH },
+    { XML_BACKGROUND_NO_REPEAT,     drawing::BitmapMode_NO_REPEAT },
+    { XML_TOKEN_INVALID, drawing::BitmapMode(0) }
+};
+
+// 3D EnumMaps
+
+SvXMLEnumMapEntry<drawing::NormalsKind> const  aXML_NormalsKind_EnumMap[] =
+{
+    { XML_OBJECT,       drawing::NormalsKind_SPECIFIC },
+    { XML_FLAT,         drawing::NormalsKind_FLAT },
+    { XML_SPHERE,       drawing::NormalsKind_SPHERE },
+    { XML_TOKEN_INVALID, drawing::NormalsKind(0) }
+};
+
+SvXMLEnumMapEntry<drawing::TextureProjectionMode> const  aXML_TexGenerationX_EnumMap[] =
+{
+    { XML_OBJECT,       drawing::TextureProjectionMode_OBJECTSPECIFIC },
+    { XML_PARALLEL,     drawing::TextureProjectionMode_PARALLEL },
+    { XML_SPHERE,       drawing::TextureProjectionMode_SPHERE },
+    { XML_TOKEN_INVALID, drawing::TextureProjectionMode(0) }
+};
+
+SvXMLEnumMapEntry<drawing::TextureProjectionMode> const  aXML_TexGenerationY_EnumMap[] =
+{
+    { XML_OBJECT,       drawing::TextureProjectionMode_OBJECTSPECIFIC },
+    { XML_PARALLEL,     drawing::TextureProjectionMode_PARALLEL },
+    { XML_SPHERE,       drawing::TextureProjectionMode_SPHERE },
+    { XML_TOKEN_INVALID, drawing::TextureProjectionMode(0) }
+};
+
+SvXMLEnumMapEntry<drawing::TextureKind> const  aXML_TexKind_EnumMap[] =
+{
+    { XML_LUMINANCE,    drawing::TextureKind_LUMINANCE },
+    { XML_COLOR,        drawing::TextureKind_COLOR },
+    { XML_TOKEN_INVALID, drawing::TextureKind(0) }
+};
+
+SvXMLEnumMapEntry<drawing::TextureMode> const  aXML_TexMode_EnumMap[] =
+{
+    { XML_REPLACE,      drawing::TextureMode_REPLACE },
+    { XML_MODULATE,     drawing::TextureMode_MODULATE },
+    { XML_BLEND,        drawing::TextureMode_BLEND },
+    { XML_TOKEN_INVALID, drawing::TextureMode(0) }
+};
+
+SvXMLEnumMapEntry<drawing::RectanglePoint> const aXML_RefPoint_EnumMap[] =
+{
+    { XML_TOP_LEFT,     drawing::RectanglePoint_LEFT_TOP },
+    { XML_TOP,          drawing::RectanglePoint_MIDDLE_TOP },
+    { XML_TOP_RIGHT,    drawing::RectanglePoint_RIGHT_TOP },
+    { XML_LEFT,         drawing::RectanglePoint_LEFT_MIDDLE },
+    { XML_CENTER,       drawing::RectanglePoint_MIDDLE_MIDDLE },
+    { XML_RIGHT,        drawing::RectanglePoint_RIGHT_MIDDLE },
+    { XML_BOTTOM_LEFT,  drawing::RectanglePoint_LEFT_BOTTOM },
+    { XML_BOTTOM,       drawing::RectanglePoint_MIDDLE_BOTTOM },
+    { XML_BOTTOM_RIGHT, drawing::RectanglePoint_RIGHT_BOTTOM },
+    { XML_TOKEN_INVALID, drawing::RectanglePoint(0) }
+};
+
+SvXMLEnumMapEntry<drawing::CircleKind> const aXML_CircleKind_EnumMap[] =
+{
+    { XML_FULL,         drawing::CircleKind_FULL },
+    { XML_SECTION,      drawing::CircleKind_SECTION },
+    { XML_CUT,          drawing::CircleKind_CUT },
+    { XML_ARC,          drawing::CircleKind_ARC },
+    { XML_TOKEN_INVALID, drawing::CircleKind(0) }
+};
+
+SvXMLEnumMapEntry<text::WritingMode> const aXML_WritingMode_EnumMap[] =
+{
+    { XML_TB_RL,        text::WritingMode_TB_RL },
+    { XML_LR_TB,        text::WritingMode_LR_TB },
+    { XML_TOKEN_INVALID, text::WritingMode(0) }
+};
+
+SvXMLEnumMapEntry<drawing::TextAnimationKind> const pXML_TextAnimation_Enum[] =
+{
+    { XML_NONE,         drawing::TextAnimationKind_NONE },
+    { XML_BLINKING,     drawing::TextAnimationKind_BLINK }, // will be filtered
+    { XML_SCROLL,       drawing::TextAnimationKind_SCROLL },
+    { XML_ALTERNATE,    drawing::TextAnimationKind_ALTERNATE },
+    { XML_SLIDE,        drawing::TextAnimationKind_SLIDE },
+    { XML_TOKEN_INVALID, drawing::TextAnimationKind(0) }
+};
+
+SvXMLEnumMapEntry<drawing::TextAnimationKind> const pXML_TextAnimation_Blinking_Enum[] =
+{
+    { XML_FALSE,        drawing::TextAnimationKind_NONE },
+    { XML_TRUE,         drawing::TextAnimationKind_BLINK },
+    { XML_FALSE,        drawing::TextAnimationKind_SCROLL },
+    { XML_FALSE,        drawing::TextAnimationKind_ALTERNATE },
+    { XML_FALSE,        drawing::TextAnimationKind_SLIDE },
+    { XML_TOKEN_INVALID, drawing::TextAnimationKind(0) }
+};
+
+SvXMLEnumMapEntry<drawing::TextAnimationDirection> const pXML_TextAnimationDirection_Enum[] =
+{
+    { XML_LEFT,         drawing::TextAnimationDirection_LEFT },
+    { XML_RIGHT,        drawing::TextAnimationDirection_RIGHT },    // will be filtered
+    { XML_UP,           drawing::TextAnimationDirection_UP },
+    { XML_DOWN,         drawing::TextAnimationDirection_DOWN },
+    { XML_TOKEN_INVALID, drawing::TextAnimationDirection(0) }
+};
+
+SvXMLEnumMapEntry<drawing::TextHorizontalAdjust> const pXML_TextAlign_Enum[] =
+{
+    { XML_LEFT,         drawing::TextHorizontalAdjust_LEFT },
+    { XML_CENTER,       drawing::TextHorizontalAdjust_CENTER },
+    { XML_RIGHT,        drawing::TextHorizontalAdjust_RIGHT },
+    { XML_JUSTIFY,      drawing::TextHorizontalAdjust_BLOCK },
+    { XML_TOKEN_INVALID, drawing::TextHorizontalAdjust(0) }
+};
+
+SvXMLEnumMapEntry<drawing::TextVerticalAdjust> const pXML_VerticalAlign_Enum[] =
+{
+    { XML_TOP,          drawing::TextVerticalAdjust_TOP },
+    { XML_MIDDLE,       drawing::TextVerticalAdjust_CENTER },
+    { XML_BOTTOM,       drawing::TextVerticalAdjust_BOTTOM },
+    { XML_JUSTIFY,      drawing::TextVerticalAdjust_BLOCK },
+    { XML_TOKEN_INVALID, drawing::TextVerticalAdjust(0) }
+};
+
+// note: PROPORTIONAL and ALLLINES are the same thing now!
+SvXMLEnumMapEntry<drawing::TextFitToSizeType> const pXML_FitToSize_Enum_Odf12[] =
+{
+    { XML_FALSE,        drawing::TextFitToSizeType_NONE },
+    { XML_TRUE,         drawing::TextFitToSizeType_PROPORTIONAL },
+    { XML_TRUE,         drawing::TextFitToSizeType_ALLLINES },
+    { XML_FALSE,        drawing::TextFitToSizeType_AUTOFIT },
+    { XML_TOKEN_INVALID, drawing::TextFitToSizeType(0) }
+};
+
+SvXMLEnumMapEntry<drawing::TextFitToSizeType> const pXML_FitToSize_Enum[] =
+{
+    { XML_FALSE,        drawing::TextFitToSizeType_NONE },
+    { XML_TRUE,         drawing::TextFitToSizeType_PROPORTIONAL },
+    { XML_ALL,          drawing::TextFitToSizeType_ALLLINES },
+    { XML_SHRINK_TO_FIT,drawing::TextFitToSizeType_AUTOFIT },
+    { XML_TOKEN_INVALID, drawing::TextFitToSizeType(0) }
+};
+
+SvXMLEnumMapEntry<drawing::TextFitToSizeType> const pXML_ShrinkToFit_Enum[] =
+{
+    { XML_FALSE,        drawing::TextFitToSizeType_NONE },
+    { XML_FALSE,        drawing::TextFitToSizeType_PROPORTIONAL },
+    { XML_FALSE,        drawing::TextFitToSizeType_ALLLINES },
+    { XML_TRUE,         drawing::TextFitToSizeType_AUTOFIT },
+    { XML_TOKEN_INVALID, drawing::TextFitToSizeType(0) }
+};
+
+SvXMLEnumMapEntry<sal_Int32> const pXML_MeasureUnit_Enum[] =
+{
+    { XML_AUTOMATIC,    0 },
+    { XML_MM,           1 },
+    { XML_UNIT_CM,      2 },
+    { XML_UNIT_M,       3 },
+    { XML_KM,           4 },
+    { XML_UNIT_PT,      6 },
+    { XML_UNIT_PC,      7 },
+    { XML_IN,           8 },
+    { XML_UNIT_FOOT,    9 },
+    { XML_MI,           10 },
+    { XML_TOKEN_INVALID,0 }
+};
+
+SvXMLEnumMapEntry<drawing::MeasureTextHorzPos> const pXML_Measure_HAlign_Enum[] =
+{
+    { XML_AUTOMATIC,        drawing::MeasureTextHorzPos_AUTO },
+    { XML_LEFT_OUTSIDE,     drawing::MeasureTextHorzPos_LEFTOUTSIDE },
+    { XML_INSIDE,           drawing::MeasureTextHorzPos_INSIDE },
+    { XML_RIGHT_OUTSIDE,    drawing::MeasureTextHorzPos_RIGHTOUTSIDE},
+    { XML_TOKEN_INVALID, drawing::MeasureTextHorzPos(0) }
+};
+
+SvXMLEnumMapEntry<drawing::MeasureTextVertPos> const pXML_Measure_VAlign_Enum[] =
+{
+    { XML_AUTOMATIC,    drawing::MeasureTextVertPos_AUTO },
+    { XML_ABOVE,        drawing::MeasureTextVertPos_EAST },
+    { XML_BELOW,        drawing::MeasureTextVertPos_WEST },
+    { XML_CENTER,       drawing::MeasureTextVertPos_CENTERED },
+    { XML_TOKEN_INVALID, drawing::MeasureTextVertPos(0) }
+};
+
+// #FontWork#
+SvXMLEnumMapEntry<sal_Int32> const pXML_Fontwork_Style_Enum[] =
+{
+    { XML_ROTATE,       0 }, //XFormTextStyle::Rotate,
+    { XML_UPRIGHT,      1 }, //XFormTextStyle::Upright,
+    { XML_SLANT_X,      2 }, //XFormTextStyle::SlantX,
+    { XML_SLANT_Y,      3 }, //XFormTextStyle::SlantY,
+    { XML_NONE,         4 }, //XFormTextStyle::NONE
+    { XML_TOKEN_INVALID,0 }
+};
+
+SvXMLEnumMapEntry<sal_Int32> const pXML_Fontwork_Adjust_Enum[] =
+{
+    { XML_LEFT,         0 }, //XFormTextAdjust::Left,
+    { XML_RIGHT,        1 }, //XFormTextAdjust::Right,
+    { XML_AUTOSIZE,     2 }, //XFormTextAdjust::AutoSize,
+    { XML_CENTER,       3 }, //XFormTextAdjust::Center
+    { XML_TOKEN_INVALID,0 }
+};
+
+SvXMLEnumMapEntry<sal_Int32> const pXML_Fontwork_Shadow_Enum[] =
+{
+    { XML_NORMAL,       0 }, //XFormTextShadow::Normal,
+    { XML_SLANT,        1 }, //XFormTextShadow::Slant,
+    { XML_NONE,         2 }, //XFormTextShadow::NONE
+    { XML_TOKEN_INVALID,0 }
+};
+
+SvXMLEnumMapEntry<sal_Int32> const pXML_Fontwork_Form_Enum[] =
+{
+    { XML_NONE,             0 }, //XFTFORM_NONE,
+    { XML_TOPCIRCLE,        1 }, //XFTFORM_TOPCIRC,
+    { XML_BOTTOMCIRCLE,     2 }, //XFTFORM_BOTCIRC,
+    { XML_LEFTCIRCLE,       3 }, //XFTFORM_LFTCIRC,
+    { XML_RIGHTCIRCLE,      4 }, //XFTFORM_RGTCIRC,
+    { XML_TOPARC,           5 }, //XFTFORM_TOPARC,
+    { XML_BOTTOMARC,        6 }, //XFTFORM_BOTARC,
+    { XML_LEFTARC,          7 }, //XFTFORM_LFTARC,
+    { XML_RIGHTARC,         8 }, //XFTFORM_RGTARC,
+    { XML_BUTTON1,          9 }, //XFTFORM_BUTTON1,
+    { XML_BUTTON2,          10 }, //XFTFORM_BUTTON2,
+    { XML_BUTTON3,          11 }, //XFTFORM_BUTTON3,
+    { XML_BUTTON4,          12 }, //XFTFORM_BUTTON4
+    { XML_TOKEN_INVALID,0 }
+};
+
+SvXMLEnumMapEntry<sal_Int32> const pXML_Caption_Esc_Dir_Enum[] =
+{
+    { XML_HORIZONTAL,       0 }, //SdrCaptionEscDir::Horizontal,
+    { XML_VERTICAL,         1 }, //SdrCaptionEscDir::Vertical,
+    { XML_AUTO,             2 }, //SdrCaptionEscDir::BestFit,
+    { XML_TOKEN_INVALID,0 }
+};
+
+SvXMLEnumMapEntry<sal_Int32> const pXML_Caption_Type_Enum[] =
+{
+    { XML_STRAIGHT_LINE,            0 }, //SdrCaptionType::Type1,
+    { XML_ANGLED_LINE,              1 }, //SdrCaptionType::Type2,
+    { XML_ANGLED_CONNECTOR_LINE,    2 }, //SdrCaptionType::Type3,
+    { XML_TOKEN_INVALID,0 }
+};
+
+namespace {
+
+class XMLCaptionEscapeRelative : public XMLPropertyHandler
+{
+public:
+    virtual bool importXML(
+            const OUString& rStrImpValue,
+            css::uno::Any& rValue,
+            const SvXMLUnitConverter& rUnitConverter ) const override;
+    virtual bool exportXML(
+            OUString& rStrExpValue,
+            const css::uno::Any& rValue,
+            const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+}
+
+bool XMLCaptionEscapeRelative::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+    sal_Int32 nValue;
+
+    if (!::sax::Converter::convertPercent( nValue, rStrImpValue ))
+        return false;
+
+    nValue *= 100;
+    rValue <<= nValue;
+    return true;
+}
+
+bool XMLCaptionEscapeRelative::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+    sal_Int32 nValue = 0;
+    if( !(rValue >>= nValue ) )
+        return false;
+
+    nValue /= 100;
+    OUStringBuffer aOut;
+    ::sax::Converter::convertPercent( aOut, nValue );
+    rStrExpValue = aOut.makeStringAndClear();
+    return true;
+}
+
+namespace {
+
+class XMLMoveSizeProtectHdl : public XMLPropertyHandler
+{
+public:
+    explicit XMLMoveSizeProtectHdl( sal_Int32 nType ) : mnType( nType ) {}
+
+    virtual bool importXML(
+            const OUString& rStrImpValue,
+            css::uno::Any& rValue,
+            const SvXMLUnitConverter& rUnitConverter ) const override;
+    virtual bool exportXML(
+            OUString& rStrExpValue,
+            const css::uno::Any& rValue,
+            const SvXMLUnitConverter& rUnitConverter ) const override;
+private:
+    const sal_Int32 mnType;
+};
+
+}
+
+bool XMLMoveSizeProtectHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+    const bool bValue = rStrImpValue.indexOf( GetXMLToken( mnType == XML_SD_TYPE_MOVE_PROTECT ? XML_POSITION : XML_SIZE ) ) != -1;
+    rValue <<= bValue;
+    return true;
+}
+
+bool XMLMoveSizeProtectHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+    bool bValue;
+    if( !(rValue >>= bValue ) )
+        return false;
+
+    if( bValue )
+    {
+        if( !rStrExpValue.isEmpty() )
+            rStrExpValue += " ";
+
+        rStrExpValue += GetXMLToken( mnType == XML_SD_TYPE_MOVE_PROTECT ? XML_POSITION : XML_SIZE );
+    }
+
+    return true;
+}
+
+namespace {
+
+class XMLSdHeaderFooterVisibilityTypeHdl : public XMLPropertyHandler
+{
+public:
+    virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+    virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+}
+
+bool XMLSdHeaderFooterVisibilityTypeHdl::importXML(
+        const OUString& rStrImpValue,
+        css::uno::Any& rValue,
+        const SvXMLUnitConverter& ) const
+{
+    // #i38644#
+    // attributes with this type where saved with VISIBLE|HIDDEN prior
+    // to src680m67. So we have to import that correctly
+    const bool bBool = IsXMLToken(rStrImpValue, XML_TRUE) || IsXMLToken(rStrImpValue, XML_VISIBLE);
+    rValue <<= bBool;
+    return bBool || IsXMLToken(rStrImpValue, XML_FALSE) || IsXMLToken(rStrImpValue, XML_HIDDEN);
+}
+
+bool XMLSdHeaderFooterVisibilityTypeHdl::exportXML(
+        OUString& rStrExpValue,
+        const Any& rValue,
+        const SvXMLUnitConverter& ) const
+{
+    bool bRet = false;
+    bool bValue;
+
+    if (rValue >>= bValue)
+    {
+        OUStringBuffer aOut;
+        ::sax::Converter::convertBool( aOut, bValue );
+        rStrExpValue = aOut.makeStringAndClear();
+
+        bRet = true;
+    }
+
+    return bRet;
+}
+
+namespace {
+
+class XMLSdRotationAngleTypeHdl : public XMLPropertyHandler
+{
+public:
+    virtual bool importXML(const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter) const override;
+    virtual bool exportXML(OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter) const override;
+};
+
+}
+
+bool XMLSdRotationAngleTypeHdl::importXML(
+    const OUString& rStrImpValue,
+    css::uno::Any& rValue,
+    const SvXMLUnitConverter&) const
+{
+    sal_Int32 nValue;
+    bool const bRet = ::sax::Converter::convertNumber(nValue, rStrImpValue);
+    if (bRet)
+    {
+        nValue = (nValue % 360);
+        if (nValue < 0)
+            nValue = 360 + nValue;
+        sal_Int32 nAngle;
+        if (nValue < 45 || nValue > 315)
+            nAngle = 0;
+        else if (nValue < 180)
+            nAngle = 9000;
+        else /* if nValue <= 315 ) */
+            nAngle = 27000;
+
+        rValue <<= nAngle;
+    }
+    return bRet;
+}
+
+bool XMLSdRotationAngleTypeHdl::exportXML(
+    OUString& rStrExpValue,
+    const Any& rValue,
+    const SvXMLUnitConverter&) const
+{
+    sal_Int32 nAngle;
+    bool bRet = (rValue >>= nAngle) && nAngle != 0;
+    if (bRet)
+    {
+        rStrExpValue = OUString::number(nAngle / 100);
+    }
+    return bRet;
+}
+
+namespace {
+
+class XMLFitToSizeEnumPropertyHdl : public XMLEnumPropertyHdl
+{
+public:
+    XMLFitToSizeEnumPropertyHdl(
+            const SvXMLEnumMapEntry<drawing::TextFitToSizeType> *const pMap)
+        : XMLEnumPropertyHdl(pMap) {}
+
+    virtual bool importXML(const OUString& rStrImpValue, uno::Any& rValue,
+                           const SvXMLUnitConverter& rUC) const override
+    {
+        // we don't know here what the actual attribute name is -
+        // but we can combine the 2 attributes by just taking the
+        // "largest" result value; this can never result in ALLLINES
+        // so the implementation has to interpret PROPORTIONAL as ALLLINES;
+        // both "true" is invalid anyway.
+        Any any;
+        auto const bRet = XMLEnumPropertyHdl::importXML(rStrImpValue, any, rUC);
+        if (!bRet)
+        {
+            return false;
+        }
+        assert(any.hasValue());
+        if (!rValue.hasValue() ||
+            rValue.get<drawing::TextFitToSizeType>() < any.get<drawing::TextFitToSizeType>())
+        {
+            rValue = any;
+        }
+        return true;
+    }
+};
+
+}
+
+XMLSdPropHdlFactory::XMLSdPropHdlFactory( uno::Reference< frame::XModel > const & xModel, SvXMLImport& rImport )
+: mxModel( xModel ), mpExport(nullptr), mpImport( &rImport )
+{
+}
+
+XMLSdPropHdlFactory::XMLSdPropHdlFactory( uno::Reference< frame::XModel > const & xModel, SvXMLExport& rExport )
+: mxModel( xModel ), mpExport( &rExport ), mpImport(nullptr)
+{
+}
+
+XMLSdPropHdlFactory::~XMLSdPropHdlFactory()
+{
+}
+
+const XMLPropertyHandler* XMLSdPropHdlFactory::GetPropertyHandler( sal_Int32 nType ) const
+{
+    const XMLPropertyHandler* pHdl = XMLPropertyHandlerFactory::GetPropertyHandler( nType );
+    if(!pHdl)
+    {
+        switch(nType)
+        {
+            case XML_SD_TYPE_STROKE :
+            {
+                pHdl = new XMLEnumPropertyHdl( aXML_LineStyle_EnumMap);
+                break;
+            }
+            case XML_SD_TYPE_LINEJOIN :
+            {
+                pHdl = new XMLEnumPropertyHdl( aXML_LineJoint_EnumMap);
+                break;
+            }
+            case XML_SD_TYPE_LINECAP :
+            {
+                pHdl = new XMLEnumPropertyHdl( aXML_LineCap_EnumMap );
+                break;
+            }
+            case XML_SD_TYPE_FILLSTYLE :
+            {
+                pHdl = new XMLEnumPropertyHdl( aXML_FillStyle_EnumMap );
+                break;
+            }
+            case XML_SD_TYPE_PRESPAGE_TYPE :
+            {
+                pHdl = new XMLEnumPropertyHdl( aXML_PresChange_EnumMap );
+                break;
+            }
+            case XML_SD_TYPE_VISIBLE_HIDDEN:
+            {
+                pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken(XML_VISIBLE), GetXMLToken(XML_HIDDEN) );
+                break;
+            }
+            case XML_TYPE_SD_MIRROR:
+            {
+                pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken(XML_HORIZONTAL), GetXMLToken(XML_NONE) );
+                break;
+            }
+            case XML_SD_TYPE_PRESPAGE_STYLE :
+            {
+                pHdl = new XMLEnumPropertyHdl( aXML_FadeEffect_EnumMap );
+                break;
+            }
+            case XML_SD_TYPE_PRESPAGE_SPEED :
+            {
+                pHdl = new XMLEnumPropertyHdl( aXML_TransSpeed_EnumMap );
+                break;
+            }
+            case XML_SD_TYPE_PRESPAGE_DURATION :
+            {
+                pHdl = new XMLDurationPropertyHdl;
+                break;
+            }
+            case XML_SD_TYPE_TEXT_CROSSEDOUT :
+            {
+                pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken(XML_SOLID), GetXMLToken(XML_NONE) );
+                break;
+            }
+            case XML_SD_TYPE_OPACITY :
+            {
+                pHdl = new XMLOpacityPropertyHdl(mpImport);
+                break;
+            }
+            case XML_SD_TYPE_WRITINGMODE :
+            {
+                pHdl = new XMLEnumPropertyHdl( aXML_WritingMode_EnumMap );
+                break;
+            }
+            case XML_SD_TYPE_PRESPAGE_VISIBILITY :
+            {
+                pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken(XML_VISIBLE), GetXMLToken(XML_HIDDEN) );
+                break;
+            }
+            case XML_SD_TYPE_PRESPAGE_BACKSIZE:
+            {
+                pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken(XML_FULL), GetXMLToken(XML_BORDER) );
+                break;
+            }
+
+            // 3D Properties
+
+            case XML_SD_TYPE_BACKFACE_CULLING:
+            {
+                // #87922# DoubleSided -> BackfaceCulling
+                // This sal_Bool needs to be flipped, DoubleSided sal_True -> NO Backface culling
+                // and vice versa.
+                pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken(XML_DISABLED), GetXMLToken(XML_ENABLED) );
+                break;
+            }
+
+            case XML_SD_TYPE_NORMALS_KIND:
+            {
+                pHdl = new XMLEnumPropertyHdl( aXML_NormalsKind_EnumMap );
+                break;
+            }
+            case XML_SD_TYPE_NORMALS_DIRECTION:
+            {
+                pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken(XML_NORMAL), GetXMLToken(XML_INVERSE) );
+                break;
+            }
+            case XML_SD_TYPE_TEX_GENERATION_MODE_X:
+            {
+                pHdl = new XMLEnumPropertyHdl( aXML_TexGenerationX_EnumMap );
+                break;
+            }
+            case XML_SD_TYPE_TEX_GENERATION_MODE_Y:
+            {
+                pHdl = new XMLEnumPropertyHdl( aXML_TexGenerationY_EnumMap );
+                break;
+            }
+            case XML_SD_TYPE_TEX_KIND:
+            {
+                pHdl = new XMLEnumPropertyHdl( aXML_TexKind_EnumMap );
+                break;
+            }
+            case XML_SD_TYPE_TEX_MODE:
+            {
+                pHdl = new XMLEnumPropertyHdl( aXML_TexMode_EnumMap );
+                break;
+            }
+            case XML_SD_TYPE_NUMBULLET:
+            {
+                uno::Reference<ucb::XAnyCompareFactory> xCompareFac( mxModel, uno::UNO_QUERY );
+                uno::Reference<ucb::XAnyCompare> xCompare;
+                if( xCompareFac.is() )
+                    xCompare = xCompareFac->createAnyCompareByName( "NumberingRules" );
+
+                pHdl = new XMLNumRulePropHdl( xCompare );
+                break;
+            }
+            case XML_SD_TYPE_BITMAP_MODE:
+            {
+                pHdl = new XMLEnumPropertyHdl( aXML_BitmapMode_EnumMap );
+                break;
+            }
+            case XML_SD_TYPE_BITMAPREPOFFSETX:
+            case XML_SD_TYPE_BITMAPREPOFFSETY:
+            {
+                pHdl = new XMLBitmapRepeatOffsetPropertyHandler( nType == XML_SD_TYPE_BITMAPREPOFFSETX );
+                break;
+            }
+            case XML_SD_TYPE_FILLBITMAPSIZE:
+            {
+                pHdl = new XMLFillBitmapSizePropertyHandler();
+                break;
+            }
+            case XML_SD_TYPE_LOGICAL_SIZE:
+            {
+                pHdl = new XMLBitmapLogicalSizePropertyHandler();
+                break;
+            }
+            case XML_SD_TYPE_BITMAP_REFPOINT:
+            {
+                pHdl = new XMLEnumPropertyHdl( aXML_RefPoint_EnumMap);
+                break;
+            }
+            case XML_TYPE_TEXT_ANIMATION:
+                pHdl = new XMLEnumPropertyHdl( pXML_TextAnimation_Enum);
+                break;
+            case XML_TYPE_TEXT_ANIMATION_BLINKING:
+                pHdl = new XMLEnumPropertyHdl( pXML_TextAnimation_Blinking_Enum);
+                break;
+            case XML_TYPE_TEXT_ANIMATION_DIRECTION:
+                pHdl = new XMLEnumPropertyHdl( pXML_TextAnimationDirection_Enum);
+                break;
+            case XML_TYPE_TEXT_ANIMATION_STEPS:
+                pHdl = new XMLTextAnimationStepPropertyHdl;
+                break;
+            case XML_SD_TYPE_TEXT_ALIGN:
+                pHdl = new XMLEnumPropertyHdl( pXML_TextAlign_Enum);
+                break;
+            case XML_SD_TYPE_VERTICAL_ALIGN:
+                pHdl = new XMLEnumPropertyHdl( pXML_VerticalAlign_Enum);
+                break;
+            case XML_SD_TYPE_FITTOSIZE:
+                {
+                    if (mpExport
+                        && (mpExport->getSaneDefaultVersion() // tdf#97630
+                                != SvtSaveOptions::ODFSVER_012_EXT_COMPAT))
+                    {
+                        pHdl = new XMLFitToSizeEnumPropertyHdl(pXML_FitToSize_Enum_Odf12);
+                    }
+                    else
+                    {   // import all values written by old LO
+                        pHdl = new XMLFitToSizeEnumPropertyHdl(pXML_FitToSize_Enum);
+                    }
+                }
+                break;
+            case XML_SD_TYPE_FITTOSIZE_AUTOFIT:
+                {
+                    pHdl = new XMLFitToSizeEnumPropertyHdl(pXML_ShrinkToFit_Enum);
+                }
+                break;
+            case XML_SD_TYPE_MEASURE_UNIT:
+                pHdl = new XMLEnumPropertyHdl( pXML_MeasureUnit_Enum );
+                break;
+            case XML_SD_TYPE_MEASURE_HALIGN:
+                pHdl = new XMLEnumPropertyHdl( pXML_Measure_HAlign_Enum);
+                break;
+            case XML_SD_TYPE_MEASURE_VALIGN:
+                pHdl = new XMLEnumPropertyHdl( pXML_Measure_VAlign_Enum);
+                break;
+            case XML_SD_TYPE_MEASURE_PLACING:
+                {
+                    pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken(XML_BELOW), GetXMLToken(XML_ABOVE) );
+                }
+                break;
+            case XML_TYPE_TEXT_CLIP11:
+                pHdl = new XMLClipPropertyHandler( true );
+                break;
+            case XML_TYPE_TEXT_CLIP:
+                pHdl = new XMLClipPropertyHandler( false );
+                break;
+
+            // #FontWork#
+            case XML_SD_TYPE_FONTWORK_STYLE     :
+                pHdl = new XMLEnumPropertyHdl( pXML_Fontwork_Style_Enum );
+                break;
+            case XML_SD_TYPE_FONTWORK_ADJUST        :
+                pHdl = new XMLEnumPropertyHdl( pXML_Fontwork_Adjust_Enum );
+                break;
+            case XML_SD_TYPE_FONTWORK_SHADOW        :
+                pHdl = new XMLEnumPropertyHdl( pXML_Fontwork_Shadow_Enum );
+                break;
+            case XML_SD_TYPE_FONTWORK_FORM      :
+                pHdl = new XMLEnumPropertyHdl( pXML_Fontwork_Form_Enum );
+                break;
+
+            case XML_SD_TYPE_CONTROL_BORDER:
+                pHdl = new ::xmloff::OControlBorderHandler( ::xmloff::OControlBorderHandler::STYLE );
+                break;
+            case XML_SD_TYPE_CONTROL_BORDER_COLOR:
+                pHdl = new ::xmloff::OControlBorderHandler( ::xmloff::OControlBorderHandler::COLOR );
+                break;
+            case XML_SD_TYPE_IMAGE_SCALE_MODE:
+                pHdl = new ::xmloff::ImageScaleModeHandler;
+                break;
+            case XML_TYPE_CONTROL_TEXT_EMPHASIZE:
+                pHdl = new ::xmloff::OControlTextEmphasisHandler;
+                break;
+
+            case XML_SD_TYPE_CAPTION_ANGLE_TYPE:
+            {
+                pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken(XML_FIXED), GetXMLToken(XML_FREE) );
+                break;
+            }
+            case XML_SD_TYPE_CAPTION_IS_ESC_REL:
+                pHdl = new XMLIsPercentagePropertyHandler;
+                break;
+            case XML_SD_TYPE_CAPTION_ESC_REL:
+                pHdl = new XMLCaptionEscapeRelative;
+                break;
+            case XML_SD_TYPE_CAPTION_ESC_ABS:
+                pHdl = new XMLPercentOrMeasurePropertyHandler;
+                break;
+            case XML_SD_TYPE_CAPTION_ESC_DIR:
+                pHdl = new XMLEnumPropertyHdl( pXML_Caption_Esc_Dir_Enum );
+                break;
+            case XML_SD_TYPE_CAPTION_TYPE:
+                pHdl = new XMLEnumPropertyHdl( pXML_Caption_Type_Enum );
+                break;
+            case XML_SD_TYPE_DATETIMEUPDATE:
+                pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken(XML_FIXED), GetXMLToken(XML_VARIABLE) );
+                break;
+            case XML_SD_TYPE_DATETIME_FORMAT:
+                pHdl = new XMLDateTimeFormatHdl( mpExport );
+                break;
+            case XML_SD_TYPE_TRANSITION_TYPE:
+                pHdl = new XMLEnumPropertyHdl( xmloff::aAnimations_EnumMap_TransitionType );
+                break;
+            case XML_SD_TYPE_TRANSTIION_SUBTYPE:
+                pHdl = new XMLEnumPropertyHdl( xmloff::aAnimations_EnumMap_TransitionSubType );
+                break;
+            case XML_SD_TYPE_TRANSTIION_DIRECTION:
+                pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken(XML_FORWARD), GetXMLToken(XML_REVERSE) );
+                break;
+            case XML_TYPE_WRAP_OPTION:
+                pHdl = new XMLWordWrapPropertyHdl( mpImport );
+                break;
+
+            case XML_SD_TYPE_MOVE_PROTECT:
+            case XML_SD_TYPE_SIZE_PROTECT:
+                pHdl = new XMLMoveSizeProtectHdl( nType );
+                break;
+            case XML_SD_TYPE_HEADER_FOOTER_VISIBILITY_TYPE:
+                pHdl = new XMLSdHeaderFooterVisibilityTypeHdl;
+                break;
+            case XML_SD_TYPE_CELL_ROTATION_ANGLE:
+                pHdl = new XMLSdRotationAngleTypeHdl;
+                break;
+            case XML_TYPE_TEXT_COLUMNS:
+                pHdl = new XMLTextColumnsPropertyHandler;
+                break;
+            case XML_TYPE_THEME_COLOR:
+                pHdl = new XMLConstantsPropertyHandler(pXML_ThemeColor_Enum, XML_TOKEN_INVALID);
+                break;
+        }
+
+        if(pHdl)
+            PutHdlCache(nType, pHdl);
+    }
+
+    return pHdl;
+}
+
+XMLShapePropertySetMapper::XMLShapePropertySetMapper(const rtl::Reference< XMLPropertyHandlerFactory >& rFactoryRef,
+        bool bForExport)
+: XMLPropertySetMapper( aXMLSDProperties, rFactoryRef, bForExport )
+{
+}
+
+XMLShapePropertySetMapper::~XMLShapePropertySetMapper()
+{
+}
+
+XMLShapeExportPropertyMapper::XMLShapeExportPropertyMapper( const rtl::Reference< XMLPropertySetMapper >& rMapper, SvXMLExport& rExport )
+: SvXMLExportPropertyMapper( rMapper )
+, maNumRuleExp( rExport )
+, mbIsInAutoStyles( true )
+{
+}
+
+XMLShapeExportPropertyMapper::~XMLShapeExportPropertyMapper()
+{
+}
+
+void XMLShapeExportPropertyMapper::ContextFilter(
+    bool bEnableFoFontFamily,
+    std::vector< XMLPropertyState >& rProperties,
+    const uno::Reference< beans::XPropertySet >& rPropSet ) const
+{
+    XMLPropertyState* pRepeatOffsetX = nullptr;
+    XMLPropertyState* pRepeatOffsetY = nullptr;
+    XMLPropertyState* pTextAnimationBlinking = nullptr;
+    XMLPropertyState* pTextAnimationKind = nullptr;
+
+    // #FontWork#
+    XMLPropertyState* pFontWorkStyle = nullptr;
+    XMLPropertyState* pFontWorkAdjust = nullptr;
+    XMLPropertyState* pFontWorkDistance = nullptr;
+    XMLPropertyState* pFontWorkStart = nullptr;
+    XMLPropertyState* pFontWorkMirror = nullptr;
+    XMLPropertyState* pFontWorkOutline = nullptr;
+    XMLPropertyState* pFontWorkShadow = nullptr;
+    XMLPropertyState* pFontWorkShadowColor = nullptr;
+    XMLPropertyState* pFontWorkShadowOffsetx = nullptr;
+    XMLPropertyState* pFontWorkShadowOffsety = nullptr;
+    XMLPropertyState* pFontWorkForm = nullptr;
+    XMLPropertyState* pFontWorkHideform = nullptr;
+    XMLPropertyState* pFontWorkShadowTransparence = nullptr;
+
+    // OLE
+    XMLPropertyState* pOLEVisAreaLeft = nullptr;
+    XMLPropertyState* pOLEVisAreaTop = nullptr;
+    XMLPropertyState* pOLEVisAreaWidth = nullptr;
+    XMLPropertyState* pOLEVisAreaHeight = nullptr;
+    XMLPropertyState* pOLEIsInternal = nullptr;
+
+    // caption
+    XMLPropertyState* pCaptionIsEscRel = nullptr;
+    XMLPropertyState* pCaptionEscRel = nullptr;
+    XMLPropertyState* pCaptionEscAbs = nullptr;
+
+    // filter fo:clip
+    XMLPropertyState* pClip11State = nullptr;
+    XMLPropertyState* pClipState = nullptr;
+
+    XMLPropertyState* pShapeWritingMode = nullptr;
+    XMLPropertyState* pTextWritingMode = nullptr;
+    XMLPropertyState* pControlWritingMode = nullptr;
+
+    // filter properties
+    for( auto& rProp : rProperties )
+    {
+        XMLPropertyState *property = &rProp;
+        if( property->mnIndex == -1 )
+            continue;
+
+        // find properties with context
+        // to prevent writing this property set mnIndex member to -1
+        switch( getPropertySetMapper()->GetEntryContextId( property->mnIndex ))
+        {
+            case CTF_NUMBERINGRULES:
+                {
+                    if( mbIsInAutoStyles )
+                        property->mnIndex = -1;
+                }
+                break;
+            case CTF_SD_NUMBERINGRULES_NAME:
+                {
+                    // this property is not exported in the style:properties element
+                    // because it's an XIndexAccess and not a string.
+                    // This will be handled in SvXMLAutoStylePoolP::exportStyleAttributes
+                    // This is suboptimal
+                    if( !mbIsInAutoStyles )
+                        property->mnIndex = -1;
+                }
+                break;
+            case CTF_WRITINGMODE:
+                pShapeWritingMode = property;
+                break;
+            case CTF_CONTROLWRITINGMODE:
+                pControlWritingMode = property;
+                break;
+            case CTF_TEXTWRITINGMODE:
+                pTextWritingMode = property;
+                break;
+            case CTF_REPEAT_OFFSET_X:
+                pRepeatOffsetX = property;
+                break;
+
+            case CTF_REPEAT_OFFSET_Y:
+                pRepeatOffsetY = property;
+                break;
+
+            case CTF_DASHNAME:
+            case CTF_FILLGRADIENTNAME:
+            case CTF_FILLHATCHNAME:
+            case CTF_FILLBITMAPNAME:
+                {
+                    OUString aStr;
+                    if( (property->maValue >>= aStr) && aStr.isEmpty() )
+                        property->mnIndex = -1;
+                }
+                break;
+            case CTF_TEXTANIMATION_BLINKING:
+                pTextAnimationBlinking = property;
+                break;
+            case CTF_TEXTANIMATION_KIND:
+                pTextAnimationKind = property;
+                break;
+
+            // #FontWork#
+            case CTF_FONTWORK_STYLE:                pFontWorkStyle = property;              break;
+            case CTF_FONTWORK_ADJUST:               pFontWorkAdjust = property;             break;
+            case CTF_FONTWORK_DISTANCE:             pFontWorkDistance = property;           break;
+            case CTF_FONTWORK_START:                pFontWorkStart = property;              break;
+            case CTF_FONTWORK_MIRROR:               pFontWorkMirror = property;             break;
+            case CTF_FONTWORK_OUTLINE:              pFontWorkOutline = property;            break;
+            case CTF_FONTWORK_SHADOW:               pFontWorkShadow = property;             break;
+            case CTF_FONTWORK_SHADOWCOLOR:          pFontWorkShadowColor = property;        break;
+            case CTF_FONTWORK_SHADOWOFFSETX:        pFontWorkShadowOffsetx = property;      break;
+            case CTF_FONTWORK_SHADOWOFFSETY:        pFontWorkShadowOffsety = property;      break;
+            case CTF_FONTWORK_FORM:                 pFontWorkForm = property;               break;
+            case CTF_FONTWORK_HIDEFORM:             pFontWorkHideform = property;           break;
+            case CTF_FONTWORK_SHADOWTRANSPARENCE:   pFontWorkShadowTransparence = property; break;
+
+            // OLE
+            case CTF_SD_OLE_VIS_AREA_EXPORT_LEFT:           pOLEVisAreaLeft = property;     break;
+            case CTF_SD_OLE_VIS_AREA_EXPORT_TOP:            pOLEVisAreaTop = property;      break;
+            case CTF_SD_OLE_VIS_AREA_EXPORT_WIDTH:          pOLEVisAreaWidth = property;    break;
+            case CTF_SD_OLE_VIS_AREA_EXPORT_HEIGHT:     pOLEVisAreaHeight = property;   break;
+            case CTF_SD_OLE_ISINTERNAL:             pOLEIsInternal = property;      break;
+
+            case CTF_FRAME_DISPLAY_SCROLLBAR:
+                {
+                    if( !property->maValue.hasValue() )
+                        property->mnIndex = -1;
+                }
+                break;
+            case CTF_FRAME_MARGIN_HORI:
+            case CTF_FRAME_MARGIN_VERT:
+                {
+                    sal_Int32 nValue = 0;
+                    if( (property->maValue >>= nValue) && (nValue < 0) )
+                        property->mnIndex = -1;
+                }
+                break;
+
+            case CTF_SD_MOVE_PROTECT:
+                {
+                    bool bProtected;
+                    if( (property->maValue >>= bProtected) && !bProtected )
+                        property->mnIndex = -1;
+                }
+                break;
+            case CTF_SD_SIZE_PROTECT:
+                {
+                    bool bProtected;
+                    if( (property->maValue >>= bProtected) && !bProtected )
+                        property->mnIndex = -1;
+                }
+                break;
+            case CTF_CAPTION_ISESCREL:              pCaptionIsEscRel = property;    break;
+            case CTF_CAPTION_ESCREL:                pCaptionEscRel = property;      break;
+            case CTF_CAPTION_ESCABS:                pCaptionEscAbs = property;      break;
+            case CTF_TEXT_CLIP11:           pClip11State = property; break;
+            case CTF_TEXT_CLIP:             pClipState = property; break;
+        }
+    }
+
+    // check for duplicate writing mode
+    if( pShapeWritingMode && (pTextWritingMode || pControlWritingMode) )
+    {
+        if( pTextWritingMode )
+            pTextWritingMode->mnIndex = -1;
+        if( pControlWritingMode )
+            pControlWritingMode->mnIndex = -1;
+
+        text::WritingMode eWritingMode;
+        if( pShapeWritingMode->maValue >>= eWritingMode )
+        {
+            if( text::WritingMode_LR_TB == eWritingMode )
+            {
+                pShapeWritingMode->mnIndex = -1;
+                pShapeWritingMode = nullptr;
+            }
+        }
+    }
+    else if( pTextWritingMode && pControlWritingMode )
+    {
+        pControlWritingMode->mnIndex = -1;
+
+        sal_Int32 eWritingMode;
+        if (pTextWritingMode->maValue >>= eWritingMode)
+        {
+            if (text::WritingMode2::LR_TB == eWritingMode)
+            {
+                pTextWritingMode->mnIndex = -1;
+                pTextWritingMode = nullptr;
+            }
+        }
+    }
+
+    // do not export visual area for internal ole objects
+    if( pOLEIsInternal )
+    {
+        bool bInternal;
+        if( (pOLEIsInternal->maValue >>= bInternal) && !bInternal )
+        {
+            try
+            {
+                awt::Rectangle aRect;
+                if( rPropSet->getPropertyValue( "VisibleArea" ) >>= aRect )
+                {
+                    if( pOLEVisAreaLeft )
+                    {
+                        pOLEVisAreaLeft->mnIndex = getPropertySetMapper()->FindEntryIndex( CTF_SD_OLE_VIS_AREA_IMPORT_LEFT );
+                        pOLEVisAreaLeft->maValue <<= aRect;
+                    }
+                    if( pOLEVisAreaTop )
+                    {
+                        pOLEVisAreaTop->mnIndex = getPropertySetMapper()->FindEntryIndex( CTF_SD_OLE_VIS_AREA_IMPORT_TOP );
+                        pOLEVisAreaTop->maValue <<=  aRect;
+                    }
+                    if( pOLEVisAreaWidth )
+                    {
+                        pOLEVisAreaWidth->mnIndex = getPropertySetMapper()->FindEntryIndex( CTF_SD_OLE_VIS_AREA_IMPORT_WIDTH );
+                        pOLEVisAreaWidth->maValue <<= aRect;
+                    }
+                    if( pOLEVisAreaHeight )
+                    {
+                        pOLEVisAreaHeight->mnIndex = getPropertySetMapper()->FindEntryIndex( CTF_SD_OLE_VIS_AREA_IMPORT_HEIGHT );
+                        pOLEVisAreaHeight->maValue <<= aRect;
+                    }
+                }
+            }
+            catch( uno::Exception& )
+            {
+            }
+        }
+        else
+        {
+            if( pOLEVisAreaLeft )   pOLEVisAreaLeft->mnIndex = -1;
+            if( pOLEVisAreaTop )    pOLEVisAreaTop->mnIndex = -1;
+            if( pOLEVisAreaWidth )  pOLEVisAreaWidth->mnIndex = -1;
+            if( pOLEVisAreaHeight ) pOLEVisAreaHeight->mnIndex = -1;
+        }
+
+        pOLEIsInternal->mnIndex = -1;
+    }
+
+    if( pTextAnimationBlinking && pTextAnimationKind )
+    {
+        drawing::TextAnimationKind eKind;
+        if( (pTextAnimationKind->maValue >>= eKind) && eKind != drawing::TextAnimationKind_BLINK )
+        {
+            pTextAnimationBlinking->mnIndex = -1;
+        }
+        else
+        {
+            pTextAnimationKind->mnIndex = -1;
+        }
+    }
+
+    if( pRepeatOffsetX && pRepeatOffsetY )
+    {
+        sal_Int32 nOffset = 0;
+        if( ( pRepeatOffsetX->maValue >>= nOffset ) && ( nOffset == 0 ) )
+            pRepeatOffsetX->mnIndex = -1;
+        else
+            pRepeatOffsetY->mnIndex = -1;
+    }
+
+    if(pFontWorkStyle)
+    {
+        // #FontWork#
+        sal_Int32 nStyle = 0;
+
+        if(pFontWorkStyle->maValue >>= nStyle)
+        {
+            if(/*XFormTextStyle::NONE*/4 == nStyle)
+            {
+                pFontWorkStyle->mnIndex = -1;
+                if(pFontWorkAdjust)
+                    pFontWorkAdjust->mnIndex = -1;
+                if(pFontWorkDistance)
+                    pFontWorkDistance->mnIndex = -1;
+                if(pFontWorkStart)
+                    pFontWorkStart->mnIndex = -1;
+                if(pFontWorkMirror)
+                    pFontWorkMirror->mnIndex = -1;
+                if(pFontWorkOutline)
+                    pFontWorkOutline->mnIndex = -1;
+                if(pFontWorkShadow)
+                    pFontWorkShadow->mnIndex = -1;
+                if(pFontWorkShadowColor)
+                    pFontWorkShadowColor->mnIndex = -1;
+                if(pFontWorkShadowOffsetx)
+                    pFontWorkShadowOffsetx->mnIndex = -1;
+                if(pFontWorkShadowOffsety)
+                    pFontWorkShadowOffsety->mnIndex = -1;
+                if(pFontWorkForm)
+                    pFontWorkForm->mnIndex = -1;
+                if(pFontWorkHideform)
+                    pFontWorkHideform->mnIndex = -1;
+                if(pFontWorkShadowTransparence)
+                    pFontWorkShadowTransparence->mnIndex = -1;
+            }
+        }
+    }
+
+    if( pCaptionIsEscRel )
+    {
+        bool bIsRel = false;
+        pCaptionIsEscRel->maValue >>= bIsRel;
+
+        if( bIsRel )
+        {
+            if( pCaptionEscAbs )
+                pCaptionEscAbs->mnIndex = -1;
+        }
+        else
+        {
+            if( pCaptionEscRel )
+                pCaptionEscRel->mnIndex = -1;
+        }
+
+        pCaptionIsEscRel->mnIndex = -1;
+    }
+
+    if( pClipState != nullptr && pClip11State != nullptr  )
+        pClip11State->mnIndex = -1;
+
+    SvXMLExportPropertyMapper::ContextFilter(bEnableFoFontFamily, rProperties, rPropSet);
+}
+
+void XMLShapeExportPropertyMapper::handleSpecialItem(
+        SvXMLAttributeList& rAttrList,
+        const XMLPropertyState& rProperty,
+        const SvXMLUnitConverter& rUnitConverter,
+        const SvXMLNamespaceMap& rNamespaceMap,
+        const ::std::vector< XMLPropertyState > *pProperties,
+        sal_uInt32 nIdx ) const
+{
+    switch( getPropertySetMapper()->GetEntryContextId( rProperty.mnIndex ) )
+    {
+        case CTF_SD_CONTROL_SHAPE_DATA_STYLE:
+            // not to be handled by the base class
+            break;
+
+        default:
+            SvXMLExportPropertyMapper::handleSpecialItem( rAttrList, rProperty, rUnitConverter, rNamespaceMap, pProperties, nIdx );
+            break;
+    }
+}
+
+void XMLShapeExportPropertyMapper::handleElementItem(
+    SvXMLExport& rExport,
+    const XMLPropertyState& rProperty,
+    SvXmlExportFlags nFlags,
+    const ::std::vector< XMLPropertyState > *pProperties,
+    sal_uInt32 nIdx) const
+{
+    switch( getPropertySetMapper()->GetEntryContextId( rProperty.mnIndex ) )
+    {
+        case CTF_NUMBERINGRULES:
+            {
+                // only export list-styles as elements in styles section
+                if( !mbIsInAutoStyles )
+                {
+                    uno::Reference< container::XIndexReplace > xNumRule( rProperty.maValue, uno::UNO_QUERY );
+                    if( xNumRule.is() )
+                        const_cast<XMLShapeExportPropertyMapper*>(this)->maNumRuleExp.exportNumberingRule(GetStyleName(), false, xNumRule);
+                }
+            }
+            break;
+        default:
+            SvXMLExportPropertyMapper::handleElementItem( rExport, rProperty, nFlags, pProperties, nIdx );
+            break;
+    }
+}
+
+XMLPageExportPropertyMapper::XMLPageExportPropertyMapper( const rtl::Reference< XMLPropertySetMapper >& rMapper, SvXMLExport& rExport ) :
+        SvXMLExportPropertyMapper( rMapper ),
+        mrExport( rExport )
+{
+}
+
+XMLPageExportPropertyMapper::~XMLPageExportPropertyMapper()
+{
+}
+
+void XMLPageExportPropertyMapper::ContextFilter(
+    bool bEnableFoFontFamily,
+    std::vector< XMLPropertyState >& rProperties,
+    const uno::Reference< beans::XPropertySet >& rPropSet ) const
+{
+    XMLPropertyState* pRepeatOffsetX = nullptr;
+    XMLPropertyState* pRepeatOffsetY = nullptr;
+    XMLPropertyState* pTransType = nullptr;
+    XMLPropertyState* pTransDuration = nullptr;
+    XMLPropertyState* pDateTimeUpdate = nullptr;
+    XMLPropertyState* pDateTimeFormat = nullptr;
+    XMLPropertyState* pTransitionFadeColor = nullptr;
+
+    sal_Int16 nTransitionType = 0;
+
+    // filter properties
+    for( auto& rProp : rProperties )
+    {
+        XMLPropertyState *property = &rProp;
+        if( property->mnIndex == -1 )
+            continue;
+
+        // find properties with context
+        // to prevent writing this property set mnIndex member to -1
+        switch( getPropertySetMapper()->GetEntryContextId( property->mnIndex ))
+        {
+
+            case CTF_REPEAT_OFFSET_X:
+                pRepeatOffsetX = property;
+                break;
+
+            case CTF_REPEAT_OFFSET_Y:
+                pRepeatOffsetY = property;
+                break;
+            case CTF_PAGE_TRANS_TYPE:
+                pTransType = property;
+                break;
+            case CTF_PAGE_TRANS_STYLE:
+                if( mrExport.getExportFlags() & SvXMLExportFlags::OASIS )
+                    (*property).mnIndex = -1;
+                break;
+            case CTF_PAGE_TRANSITION_TYPE:
+                {
+                    if( (!(mrExport.getExportFlags() & SvXMLExportFlags::OASIS)) ||
+                        (((*property).maValue >>= nTransitionType) && (nTransitionType == 0)) )
+                            (*property).mnIndex = -1;
+                }
+                break;
+            case CTF_PAGE_TRANSITION_SUBTYPE:
+                {
+                    sal_Int16 nTransitionSubtype = sal_Int16();
+                    if( (!(mrExport.getExportFlags() & SvXMLExportFlags::OASIS)) ||
+                        (((*property).maValue >>= nTransitionSubtype) && (nTransitionSubtype == 0)) )
+                            (*property).mnIndex = -1;
+
+                }
+                break;
+            case CTF_PAGE_TRANSITION_DIRECTION:
+                {
+                    bool bDirection;
+                    if( (!(mrExport.getExportFlags() & SvXMLExportFlags::OASIS)) ||
+                        (((*property).maValue >>= bDirection) && bDirection) )
+                            (*property).mnIndex = -1;
+                }
+                break;
+            case CTF_PAGE_TRANSITION_FADECOLOR:
+                if( !(mrExport.getExportFlags() & SvXMLExportFlags::OASIS) )
+                    (*property).mnIndex = -1;
+                else
+                    pTransitionFadeColor = property;
+                break;
+            case CTF_PAGE_TRANS_SPEED:
+                {
+                    presentation::AnimationSpeed aEnum;
+                    if( ((*property).maValue >>= aEnum) && aEnum == presentation::AnimationSpeed_MEDIUM )
+                        (*property).mnIndex = -1;
+                }
+                break;
+            case CTF_PAGE_VISIBLE:
+                {
+                    bool bVisible = false;
+                    (*property).maValue >>= bVisible;
+                    if( bVisible )
+                        (*property).mnIndex = -1;
+                }
+                break;
+            case CTF_PAGE_TRANS_DURATION:
+                pTransDuration = property;
+                break;
+            case CTF_HEADER_TEXT:
+            case CTF_FOOTER_TEXT:
+            case CTF_DATE_TIME_TEXT:
+                {
+                    OUString aValue;
+                    (*property).maValue >>= aValue;
+                    if( aValue.isEmpty() )
+                        (*property).mnIndex = -1;
+                }
+                break;
+
+            case CTF_DATE_TIME_UPDATE:
+                pDateTimeUpdate = property;
+                break;
+
+            case CTF_DATE_TIME_FORMAT:
+                pDateTimeFormat = property;
+                break;
+        }
+    }
+
+    if( pTransitionFadeColor && nTransitionType != css::animations::TransitionType::FADE )
+        pTransitionFadeColor->mnIndex = -1;
+
+    if( pDateTimeFormat && pDateTimeUpdate )
+    {
+        bool bIsFixed = false;
+        pDateTimeUpdate->maValue >>= bIsFixed;
+        if( bIsFixed )
+            pDateTimeFormat->mnIndex = -1;
+    }
+
+    if( pRepeatOffsetX && pRepeatOffsetY )
+    {
+        sal_Int32 nOffset = 0;
+        if( ( pRepeatOffsetX->maValue >>= nOffset ) && ( nOffset == 0 ) )
+            pRepeatOffsetX->mnIndex = -1;
+        else
+            pRepeatOffsetY->mnIndex = -1;
+    }
+
+    if( pTransType && pTransDuration )
+    {
+        sal_Int32 nChange = 0;
+        pTransType->maValue >>= nChange;
+
+        // only export duration for automatic
+        if( nChange != 1 )
+            pTransDuration->mnIndex = -1;
+
+        // do not export default transition change
+        if( nChange == 0 )
+            pTransType->mnIndex = -1;
+    }
+
+    SvXMLExportPropertyMapper::ContextFilter(bEnableFoFontFamily, rProperties, rPropSet);
+}
+
+void XMLPageExportPropertyMapper::handleElementItem(
+    SvXMLExport& rExport,
+    const XMLPropertyState& rProperty,
+    SvXmlExportFlags nFlags,
+    const ::std::vector< XMLPropertyState > *pProperties,
+    sal_uInt32 nIdx) const
+{
+    switch( getPropertySetMapper()->GetEntryContextId( rProperty.mnIndex ) )
+    {
+        case CTF_PAGE_SOUND_URL:
+            {
+                OUString aSoundURL;
+                if( (rProperty.maValue >>= aSoundURL) && !aSoundURL.isEmpty() )
+                {
+                    mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, mrExport.GetRelativeReference(aSoundURL) );
+                    mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+                    mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_NEW );
+                    mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONREQUEST );
+                    SvXMLElementExport aElem( mrExport, XML_NAMESPACE_PRESENTATION, XML_SOUND, true, true );
+                }
+            }
+            break;
+        default:
+            SvXMLExportPropertyMapper::handleElementItem( rExport, rProperty, nFlags, pProperties, nIdx );
+            break;
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/sdpropls.hxx b/xmloff/source/draw/sdpropls.hxx
new file mode 100644
index 000000000..c73de5d61
--- /dev/null
+++ b/xmloff/source/draw/sdpropls.hxx
@@ -0,0 +1,131 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/drawing/ConnectorType.hpp>
+#include <com/sun/star/drawing/CircleKind.hpp>
+#include <xmloff/xmlnume.hxx>
+#include <xmloff/maptype.hxx>
+#include <xmloff/xmlement.hxx>
+#include <xmloff/prhdlfac.hxx>
+#include <xmloff/xmlprmap.hxx>
+#include <xmloff/xmlexppr.hxx>
+
+// entry list for graphic properties
+
+extern const XMLPropertyMapEntry aXMLSDProperties[];
+
+// entry list for presentation page properties
+
+extern const XMLPropertyMapEntry aXMLSDPresPageProps[];
+
+// enum maps for attributes
+
+extern SvXMLEnumMapEntry<css::drawing::ConnectorType> const aXML_ConnectionKind_EnumMap[];
+extern SvXMLEnumMapEntry<css::drawing::CircleKind> const aXML_CircleKind_EnumMap[];
+
+/** contains the attribute to property mapping for a drawing layer table */
+extern const XMLPropertyMapEntry aXMLTableShapeAttributes[];
+
+// factory for own graphic properties
+
+class SvXMLExport;
+class SvXMLImport;
+
+class XMLSdPropHdlFactory : public XMLPropertyHandlerFactory
+{
+private:
+    css::uno::Reference< css::frame::XModel > mxModel;
+    SvXMLExport* mpExport;
+    SvXMLImport* mpImport;
+
+public:
+    XMLSdPropHdlFactory( css::uno::Reference< css::frame::XModel > const & xModel, SvXMLExport& rExport );
+    XMLSdPropHdlFactory( css::uno::Reference< css::frame::XModel > const & xModel, SvXMLImport& rImport );
+    virtual ~XMLSdPropHdlFactory() override;
+    virtual const XMLPropertyHandler* GetPropertyHandler( sal_Int32 nType ) const override;
+};
+
+class XMLShapePropertySetMapper : public XMLPropertySetMapper
+{
+public:
+    XMLShapePropertySetMapper(const rtl::Reference< XMLPropertyHandlerFactory >& rFactoryRef, bool bForExport);
+    virtual ~XMLShapePropertySetMapper() override;
+};
+
+class XMLShapeExportPropertyMapper : public SvXMLExportPropertyMapper
+{
+private:
+    SvxXMLNumRuleExport maNumRuleExp;
+    bool mbIsInAutoStyles;
+
+protected:
+    virtual void ContextFilter(
+        bool bEnableFoFontFamily,
+        ::std::vector< XMLPropertyState >& rProperties,
+        const css::uno::Reference< css::beans::XPropertySet >& rPropSet ) const override;
+public:
+    XMLShapeExportPropertyMapper( const rtl::Reference< XMLPropertySetMapper >& rMapper, SvXMLExport& rExport );
+    virtual ~XMLShapeExportPropertyMapper() override;
+
+    virtual void        handleElementItem(
+                            SvXMLExport& rExport,
+                            const XMLPropertyState& rProperty,
+                            SvXmlExportFlags nFlags,
+                            const ::std::vector< XMLPropertyState >* pProperties,
+                            sal_uInt32 nIdx
+                            ) const override;
+
+    void SetAutoStyles( bool bIsInAutoStyles ) { mbIsInAutoStyles = bIsInAutoStyles; }
+
+    virtual void handleSpecialItem(
+            SvXMLAttributeList& rAttrList,
+            const XMLPropertyState& rProperty,
+            const SvXMLUnitConverter& rUnitConverter,
+            const SvXMLNamespaceMap& rNamespaceMap,
+            const ::std::vector< XMLPropertyState > *pProperties,
+            sal_uInt32 nIdx ) const override;
+};
+
+class XMLPageExportPropertyMapper : public SvXMLExportPropertyMapper
+{
+private:
+    SvXMLExport& mrExport;
+
+protected:
+    virtual void ContextFilter(
+        bool bEnableFoFontFamily,
+        ::std::vector< XMLPropertyState >& rProperties,
+        const css::uno::Reference< css::beans::XPropertySet >& rPropSet ) const override;
+public:
+    XMLPageExportPropertyMapper( const rtl::Reference< XMLPropertySetMapper >& rMapper, SvXMLExport& rExport );
+    virtual ~XMLPageExportPropertyMapper() override;
+
+    virtual void        handleElementItem(
+                            SvXMLExport& rExport,
+                            const XMLPropertyState& rProperty,
+                            SvXmlExportFlags nFlags,
+                            const ::std::vector< XMLPropertyState >* pProperties,
+                            sal_uInt32 nIdx
+                            ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/sdxmlexp.cxx b/xmloff/source/draw/sdxmlexp.cxx
new file mode 100644
index 000000000..50a475381
--- /dev/null
+++ b/xmloff/source/draw/sdxmlexp.cxx
@@ -0,0 +1,2905 @@
+/* -*- 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 <string_view>
+
+#include <xmloff/autolayout.hxx>
+#include <xmloff/unointerfacetouniqueidentifiermapper.hxx>
+#include <xmloff/namespacemap.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/presentation/XPresentationSupplier.hpp>
+#include <com/sun/star/presentation/XCustomPresentationSupplier.hpp>
+#include <com/sun/star/geometry/RealPoint2D.hpp>
+#include <com/sun/star/office/XAnnotationAccess.hpp>
+#include <com/sun/star/uno/Any.hxx>
+#include "sdxmlexp_impl.hxx"
+#include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
+#include <com/sun/star/drawing/XMasterPagesSupplier.hpp>
+#include <com/sun/star/presentation/XHandoutMasterSupplier.hpp>
+#include <com/sun/star/container/XIndexContainer.hpp>
+#include <com/sun/star/view/PaperOrientation.hpp>
+#include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
+
+#include <com/sun/star/form/XFormsSupplier2.hpp>
+#include <com/sun/star/presentation/XPresentationPage.hpp>
+#include <com/sun/star/drawing/XMasterPageTarget.hpp>
+#include <com/sun/star/text/XText.hpp>
+#include <com/sun/star/animations/XAnimationNodeSupplier.hpp>
+#include <com/sun/star/container/XNamed.hpp>
+#include <com/sun/star/util/Duration.hpp>
+#include <com/sun/star/util/MeasureUnit.hpp>
+#include <rtl/ustrbuf.hxx>
+#include <sal/log.hxx>
+#include <tools/diagnose_ex.h>
+#include <tools/gen.hxx>
+#include <sax/tools/converter.hxx>
+#include <xmloff/xmlaustp.hxx>
+#include <xmloff/families.hxx>
+#include <xmloff/styleexp.hxx>
+#include <xmloff/settingsstore.hxx>
+#include <xmloff/table/XMLTableExport.hxx>
+#include <xmloff/ProgressBarHelper.hxx>
+#include "sdpropls.hxx"
+#include <xmloff/xmlexppr.hxx>
+
+#include <PropertySetMerger.hxx>
+#include "layerexp.hxx"
+
+#include "XMLNumberStylesExport.hxx"
+
+#include <xmloff/animationexport.hxx>
+
+#include <com/sun/star/document/XDocumentProperties.hpp>
+#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
+#include <com/sun/star/util/Color.hpp>
+
+#include <comphelper/sequenceashashmap.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::drawing;
+using namespace ::com::sun::star::office;
+using namespace ::com::sun::star::presentation;
+using namespace ::com::sun::star::geometry;
+using namespace ::com::sun::star::text;
+using namespace ::xmloff::token;
+
+class ImpXMLEXPPageMasterInfo
+{
+    sal_Int32                   mnBorderBottom;
+    sal_Int32                   mnBorderLeft;
+    sal_Int32                   mnBorderRight;
+    sal_Int32                   mnBorderTop;
+    sal_Int32                   mnWidth;
+    sal_Int32                   mnHeight;
+    view::PaperOrientation      meOrientation;
+    OUString                    msName;
+    OUString                    msMasterPageName;
+
+public:
+    ImpXMLEXPPageMasterInfo(const SdXMLExport& rExp, const Reference<XDrawPage>& xPage);
+    bool operator==(const ImpXMLEXPPageMasterInfo& rInfo) const;
+    void SetName(const OUString& rStr);
+
+    const OUString& GetName() const { return msName; }
+    const OUString& GetMasterPageName() const { return msMasterPageName; }
+
+    sal_Int32 GetBorderBottom() const { return mnBorderBottom; }
+    sal_Int32 GetBorderLeft() const { return mnBorderLeft; }
+    sal_Int32 GetBorderRight() const { return mnBorderRight; }
+    sal_Int32 GetBorderTop() const { return mnBorderTop; }
+    sal_Int32 GetWidth() const { return mnWidth; }
+    sal_Int32 GetHeight() const { return mnHeight; }
+    view::PaperOrientation GetOrientation() const { return meOrientation; }
+};
+
+ImpXMLEXPPageMasterInfo::ImpXMLEXPPageMasterInfo(
+    const SdXMLExport& rExp,
+    const Reference<XDrawPage>& xPage)
+:   mnBorderBottom(0),
+    mnBorderLeft(0),
+    mnBorderRight(0),
+    mnBorderTop(0),
+    mnWidth(0),
+    mnHeight(0),
+    meOrientation(rExp.IsDraw() ? view::PaperOrientation_PORTRAIT : view::PaperOrientation_LANDSCAPE)
+{
+    Reference <beans::XPropertySet> xPropSet(xPage, UNO_QUERY);
+    if(xPropSet.is())
+    {
+        Any aAny;
+
+        Reference< beans::XPropertySetInfo > xPropsInfo( xPropSet->getPropertySetInfo() );
+        if( xPropsInfo.is() && xPropsInfo->hasPropertyByName("BorderBottom"))
+        {
+            aAny = xPropSet->getPropertyValue("BorderBottom");
+            aAny >>= mnBorderBottom;
+
+            aAny = xPropSet->getPropertyValue("BorderLeft");
+            aAny >>= mnBorderLeft;
+
+            aAny = xPropSet->getPropertyValue("BorderRight");
+            aAny >>= mnBorderRight;
+
+            aAny = xPropSet->getPropertyValue("BorderTop");
+            aAny >>= mnBorderTop;
+        }
+
+        if( xPropsInfo.is() && xPropsInfo->hasPropertyByName("Width"))
+        {
+            aAny = xPropSet->getPropertyValue("Width");
+            aAny >>= mnWidth;
+
+            aAny = xPropSet->getPropertyValue("Height");
+            aAny >>= mnHeight;
+        }
+
+        if( xPropsInfo.is() && xPropsInfo->hasPropertyByName("Orientation"))
+        {
+            aAny = xPropSet->getPropertyValue("Orientation");
+            aAny >>= meOrientation;
+        }
+    }
+
+    Reference <container::XNamed> xMasterNamed(xPage, UNO_QUERY);
+    if(xMasterNamed.is())
+    {
+        msMasterPageName = xMasterNamed->getName();
+    }
+}
+
+bool ImpXMLEXPPageMasterInfo::operator==(const ImpXMLEXPPageMasterInfo& rInfo) const
+{
+    return ((mnBorderBottom == rInfo.mnBorderBottom)
+        && (mnBorderLeft == rInfo.mnBorderLeft)
+        && (mnBorderRight == rInfo.mnBorderRight)
+        && (mnBorderTop == rInfo.mnBorderTop)
+        && (mnWidth == rInfo.mnWidth)
+        && (mnHeight == rInfo.mnHeight)
+        && (meOrientation == rInfo.meOrientation));
+}
+
+void ImpXMLEXPPageMasterInfo::SetName(const OUString& rStr)
+{
+    msName = rStr;
+}
+
+#define IMP_AUTOLAYOUT_INFO_MAX         (35L)
+
+class ImpXMLAutoLayoutInfo
+{
+    sal_uInt16                  mnType;
+    ImpXMLEXPPageMasterInfo*    mpPageMasterInfo;
+    OUString                    msLayoutName;
+    tools::Rectangle            maTitleRect;
+    tools::Rectangle            maPresRect;
+    sal_Int32                   mnGapX;
+    sal_Int32                   mnGapY;
+
+public:
+    ImpXMLAutoLayoutInfo(sal_uInt16 nTyp, ImpXMLEXPPageMasterInfo* pInf);
+
+    sal_uInt16 GetLayoutType() const { return mnType; }
+    ImpXMLEXPPageMasterInfo* GetPageMasterInfo() const { return mpPageMasterInfo; }
+    sal_Int32 GetGapX() const { return mnGapX; }
+    sal_Int32 GetGapY() const { return mnGapY; }
+
+    const OUString& GetLayoutName() const { return msLayoutName; }
+    void SetLayoutName(const OUString& rNew) { msLayoutName = rNew; }
+
+    const tools::Rectangle& GetTitleRectangle() const { return maTitleRect; }
+    const tools::Rectangle& GetPresRectangle() const { return maPresRect; }
+
+    static bool IsCreateNecessary(sal_uInt16 nTyp);
+};
+
+bool ImpXMLAutoLayoutInfo::IsCreateNecessary(sal_uInt16 nTyp)
+{
+    if(nTyp == 5 /* AUTOLAYOUT_ORG */
+        || nTyp == 20 /* AUTOLAYOUT_NONE */
+        || nTyp >= IMP_AUTOLAYOUT_INFO_MAX)
+        return false;
+    return true;
+}
+
+ImpXMLAutoLayoutInfo::ImpXMLAutoLayoutInfo(sal_uInt16 nTyp, ImpXMLEXPPageMasterInfo* pInf)
+    : mnType(nTyp)
+    , mpPageMasterInfo(pInf)
+    , mnGapX(0)
+    , mnGapY(0)
+{
+    // create full info (initialize with typical values)
+    Point aPagePos(0,0);
+    Size aPageSize(28000, 21000);
+    Size aPageInnerSize(28000, 21000);
+
+    if(mpPageMasterInfo)
+    {
+        aPagePos = Point(mpPageMasterInfo->GetBorderLeft(), mpPageMasterInfo->GetBorderTop());
+        aPageSize = Size(mpPageMasterInfo->GetWidth(), mpPageMasterInfo->GetHeight());
+        aPageInnerSize = aPageSize;
+        aPageInnerSize.AdjustWidth(-(mpPageMasterInfo->GetBorderLeft() + mpPageMasterInfo->GetBorderRight()));
+        aPageInnerSize.AdjustHeight(-(mpPageMasterInfo->GetBorderTop() + mpPageMasterInfo->GetBorderBottom()));
+    }
+
+    // title rectangle aligning
+    Point aTitlePos(aPagePos);
+    Size aTitleSize(aPageInnerSize);
+
+    if(mnType == 21 /* AUTOLAYOUT_NOTES */)
+    {
+        aTitleSize.setHeight(static_cast<tools::Long>(aTitleSize.Height() / 2.5));
+        Point aPos = aTitlePos;
+        aPos.AdjustY( tools::Long( aTitleSize.Height() * 0.083 ) );
+        Size aPartArea = aTitleSize;
+        Size aSize;
+
+        // scale handout rectangle using actual page size
+        double fH = static_cast<double>(aPartArea.Width())  / aPageSize.Width();
+        double fV = static_cast<double>(aPartArea.Height()) / aPageSize.Height();
+
+        if ( fH > fV )
+            fH = fV;
+        aSize.setWidth( static_cast<tools::Long>(fH * aPageSize.Width()) );
+        aSize.setHeight( static_cast<tools::Long>(fH * aPageSize.Height()) );
+
+        aPos.AdjustX((aPartArea.Width() - aSize.Width()) / 2);
+        aPos.AdjustY((aPartArea.Height()- aSize.Height())/ 2);
+
+        aTitlePos = aPos;
+        aTitleSize = aSize;
+    }
+    else if(mnType == AUTOLAYOUT_VTITLE_VCONTENT_OVER_VCONTENT || mnType == AUTOLAYOUT_VTITLE_VCONTENT)
+    {
+        Point aClassicTPos(
+            aTitlePos.X() + tools::Long( aTitleSize.Width() * 0.0735 ),
+            aTitlePos.Y() + tools::Long( aTitleSize.Height() * 0.083 ));
+        Size aClassicTSize(
+            tools::Long( aTitleSize.Width() * 0.854 ),
+            tools::Long( aTitleSize.Height() * 0.167 ));
+        Point aLPos(aPagePos);
+        Size aLSize(aPageInnerSize);
+        Point aClassicLPos(
+            aLPos.X() + tools::Long( aLSize.Width() * 0.0735 ),
+            aLPos.Y() + tools::Long( aLSize.Height() * 0.472 ));
+        Size aClassicLSize(
+            tools::Long( aLSize.Width() * 0.854 ),
+            tools::Long( aLSize.Height() * 0.444 ));
+
+        aTitlePos.setX( (aClassicTPos.X() + aClassicTSize.Width()) - aClassicTSize.Height() );
+        aTitlePos.setY( aClassicTPos.Y() );
+        aTitleSize.setWidth( aClassicTSize.Height() );
+        aTitleSize.setHeight( (aClassicLPos.Y() + aClassicLSize.Height()) - aClassicTPos.Y() );
+    }
+    else
+    {
+        aTitlePos.AdjustX( tools::Long( aTitleSize.Width() * 0.0735 ) );
+        aTitlePos.AdjustY( tools::Long( aTitleSize.Height() * 0.083 ) );
+        aTitleSize.setWidth( tools::Long( aTitleSize.Width() * 0.854 ) );
+        aTitleSize.setHeight( tools::Long( aTitleSize.Height() * 0.167 ) );
+    }
+
+    maTitleRect.SetPos(aTitlePos);
+    maTitleRect.SetSize(aTitleSize);
+
+    // layout rectangle aligning
+    Point aLayoutPos(aPagePos);
+    Size aLayoutSize(aPageInnerSize);
+
+    if(mnType == 21 /* AUTOLAYOUT_NOTES */)
+    {
+        aLayoutPos.AdjustX( tools::Long( aLayoutSize.Width() * 0.0735 ) );
+        aLayoutPos.AdjustY( tools::Long( aLayoutSize.Height() * 0.472 ) );
+        aLayoutSize.setWidth( tools::Long( aLayoutSize.Width() * 0.854 ) );
+        aLayoutSize.setHeight( tools::Long( aLayoutSize.Height() * 0.444 ) );
+    }
+    else if((mnType >= 22 && mnType <= 26) || (mnType == 31)) // AUTOLAYOUT_HANDOUT*
+    {
+        // keep info for inner area in maPresRect, put info for gap size
+        // to maTitleRect position
+        mnGapX = (aPageSize.Width() - aPageInnerSize.Width()) / 2;
+        mnGapY = (aPageSize.Height() - aPageInnerSize.Height()) / 2;
+
+        if(!mnGapX)
+            mnGapX = aPageSize.Width() / 10;
+
+        if(!mnGapY)
+            mnGapY = aPageSize.Height() / 10;
+
+        if(mnGapX < aPageInnerSize.Width() / 10)
+            mnGapX = aPageInnerSize.Width() / 10;
+
+        if(mnGapY < aPageInnerSize.Height() / 10)
+            mnGapY = aPageInnerSize.Height() / 10;
+    }
+    else if(mnType == AUTOLAYOUT_VTITLE_VCONTENT_OVER_VCONTENT || mnType == AUTOLAYOUT_VTITLE_VCONTENT)
+    {
+        Point aClassicTPos(
+            aTitlePos.X() + tools::Long( aTitleSize.Width() * 0.0735 ),
+            aTitlePos.Y() + tools::Long( aTitleSize.Height() * 0.083 ));
+        Size aClassicTSize(
+            tools::Long( aTitleSize.Width() * 0.854 ),
+            tools::Long( aTitleSize.Height() * 0.167 ));
+        Point aClassicLPos(
+            aLayoutPos.X() + tools::Long( aLayoutSize.Width() * 0.0735 ),
+            aLayoutPos.Y() + tools::Long( aLayoutSize.Height() * 0.472 ));
+        Size aClassicLSize(
+            tools::Long( aLayoutSize.Width() * 0.854 ),
+            tools::Long( aLayoutSize.Height() * 0.444 ));
+
+        aLayoutPos.setX( aClassicLPos.X() );
+        aLayoutPos.setY( aClassicTPos.Y() );
+        aLayoutSize.setWidth( (aClassicLPos.X() + aClassicLSize.Width())
+            - (aClassicTSize.Height() + (aClassicLPos.Y() - (aClassicTPos.Y() + aClassicTSize.Height()))));
+        aLayoutSize.setHeight( (aClassicLPos.Y() + aClassicLSize.Height()) - aClassicTPos.Y() );
+    }
+    else if( mnType == AUTOLAYOUT_ONLY_TEXT )
+    {
+        aLayoutPos = aTitlePos;
+        aLayoutSize.setWidth( aTitleSize.Width() );
+        aLayoutSize.setHeight( tools::Long( aLayoutSize.Height() * 0.825 ) );
+    }
+    else
+    {
+        aLayoutPos.AdjustX( tools::Long( aLayoutSize.Width() * 0.0735 ) );
+        aLayoutPos.AdjustY( tools::Long( aLayoutSize.Height() * 0.278 ) );
+        aLayoutSize.setWidth( tools::Long( aLayoutSize.Width() * 0.854 ) );
+        aLayoutSize.setHeight( tools::Long( aLayoutSize.Height() * 0.630 ) );
+    }
+
+    maPresRect.SetPos(aLayoutPos);
+    maPresRect.SetSize(aLayoutSize);
+}
+
+constexpr OUStringLiteral gsPageLayoutNames( u"PageLayoutNames" );
+
+SdXMLExport::SdXMLExport(
+    const css::uno::Reference< css::uno::XComponentContext >& xContext,
+    OUString const & implementationName,
+    bool bIsDraw, SvXMLExportFlags nExportFlags )
+:   SvXMLExport( xContext, implementationName, util::MeasureUnit::CM,
+        bIsDraw ? XML_GRAPHICS : XML_PRESENTATION, nExportFlags ),
+    mnDocMasterPageCount(0),
+    mnDocDrawPageCount(0),
+    mnObjectCount(0),
+    mpHandoutPageMaster(nullptr),
+    mbIsDraw(bIsDraw)
+{
+
+}
+
+// XExporter
+void SAL_CALL SdXMLExport::setSourceDocument( const Reference< lang::XComponent >& xDoc )
+{
+    SvXMLExport::setSourceDocument( xDoc );
+
+    // prepare factory parts
+    mpSdPropHdlFactory = new XMLSdPropHdlFactory( GetModel(), *this );
+
+    // construct PropertySetMapper
+    rtl::Reference < XMLPropertySetMapper > xMapper = new XMLShapePropertySetMapper( mpSdPropHdlFactory, true);
+
+    // get or create text paragraph export
+    GetTextParagraphExport();
+    mpPropertySetMapper = new XMLShapeExportPropertyMapper( xMapper, *this );
+
+    // chain text attributes
+    mpPropertySetMapper->ChainExportMapper(XMLTextParagraphExport::CreateParaExtPropMapper(*this));
+
+    // construct PresPagePropsMapper
+    xMapper = new XMLPropertySetMapper(aXMLSDPresPageProps, mpSdPropHdlFactory, true);
+
+    mpPresPagePropsMapper = new XMLPageExportPropertyMapper( xMapper, *this  );
+
+    // add family name
+    GetAutoStylePool()->AddFamily(
+        XmlStyleFamily::SD_GRAPHICS_ID,
+        OUString(XML_STYLE_FAMILY_SD_GRAPHICS_NAME),
+          GetPropertySetMapper(),
+          OUString(XML_STYLE_FAMILY_SD_GRAPHICS_PREFIX));
+    GetAutoStylePool()->AddFamily(
+        XmlStyleFamily::SD_PRESENTATION_ID,
+        OUString(XML_STYLE_FAMILY_SD_PRESENTATION_NAME),
+          GetPropertySetMapper(),
+          OUString(XML_STYLE_FAMILY_SD_PRESENTATION_PREFIX));
+    GetAutoStylePool()->AddFamily(
+        XmlStyleFamily::SD_DRAWINGPAGE_ID,
+        OUString(XML_STYLE_FAMILY_SD_DRAWINGPAGE_NAME),
+          GetPresPagePropsMapper(),
+          OUString(XML_STYLE_FAMILY_SD_DRAWINGPAGE_PREFIX));
+    // prepare access to styles
+    Reference< style::XStyleFamiliesSupplier > xFamSup( GetModel(), UNO_QUERY );
+    if(xFamSup.is())
+    {
+        mxDocStyleFamilies = xFamSup->getStyleFamilies();
+    }
+
+    // prepare access to master pages
+    Reference < drawing::XMasterPagesSupplier > xMasterPagesSupplier(GetModel(), UNO_QUERY);
+    if(xMasterPagesSupplier.is())
+    {
+        mxDocMasterPages = xMasterPagesSupplier->getMasterPages();
+        if(mxDocMasterPages.is())
+        {
+            mnDocMasterPageCount = mxDocMasterPages->getCount();
+            maMasterPagesStyleNames.insert( maMasterPagesStyleNames.begin(), mnDocMasterPageCount, "" );
+        }
+    }
+
+    // prepare access to draw pages
+    Reference <XDrawPagesSupplier> xDrawPagesSupplier(GetModel(), UNO_QUERY);
+    if(xDrawPagesSupplier.is())
+    {
+        mxDocDrawPages = xDrawPagesSupplier->getDrawPages();
+        if(mxDocDrawPages.is())
+        {
+            mnDocDrawPageCount = mxDocDrawPages->getCount();
+            maDrawPagesStyleNames.insert( maDrawPagesStyleNames.begin(), mnDocDrawPageCount, "" );
+            maDrawNotesPagesStyleNames.insert( maDrawNotesPagesStyleNames.begin(), mnDocDrawPageCount, "" );
+            if( !mbIsDraw )
+                maDrawPagesAutoLayoutNames.realloc( mnDocDrawPageCount + 1 );
+
+            HeaderFooterPageSettingsImpl aEmptySettings;
+            maDrawPagesHeaderFooterSettings.insert( maDrawPagesHeaderFooterSettings.begin(), mnDocDrawPageCount, aEmptySettings );
+            maDrawNotesPagesHeaderFooterSettings.insert( maDrawNotesPagesHeaderFooterSettings.begin(), mnDocDrawPageCount, aEmptySettings );
+        }
+    }
+
+    // #82003# count all draw objects for use with progress bar.
+    // #88245# init mnObjectCount once, use counter itself as flag. It
+    // is initialized to 0.
+    if(!mnObjectCount)
+    {
+        if( IsImpress() )
+        {
+             // #91587# add handout master count
+            Reference<presentation::XHandoutMasterSupplier> xHandoutSupp(GetModel(), UNO_QUERY);
+            if(xHandoutSupp.is())
+            {
+                Reference<XDrawPage> xHandoutPage(xHandoutSupp->getHandoutMasterPage());
+                if(xHandoutPage.is() && xHandoutPage->getCount())
+                    mnObjectCount += ImpRecursiveObjectCount(xHandoutPage);
+            }
+        }
+
+        if(mxDocMasterPages.is())
+        {
+            for(sal_Int32 a(0); a < mnDocMasterPageCount; a++)
+            {
+                Any aAny(mxDocMasterPages->getByIndex(a));
+                Reference< drawing::XShapes > xMasterPage;
+
+                if((aAny >>= xMasterPage) && xMasterPage.is())
+                {
+                    mnObjectCount += ImpRecursiveObjectCount(xMasterPage);
+                }
+
+                if( IsImpress() )
+                {
+                    // #91587# take notes pages from master pages into account
+                    Reference<presentation::XPresentationPage> xPresPage;
+                    if((aAny >>= xPresPage) && xPresPage.is())
+                    {
+                        Reference<XDrawPage> xNotesPage(xPresPage->getNotesPage());
+                        if(xNotesPage.is() && xNotesPage->getCount())
+                            mnObjectCount += ImpRecursiveObjectCount(xNotesPage);
+                    }
+                }
+            }
+        }
+
+        if(mxDocDrawPages.is())
+        {
+            for(sal_Int32 a(0); a < mnDocDrawPageCount; a++)
+            {
+                Any aAny(mxDocDrawPages->getByIndex(a));
+                Reference< drawing::XShapes > xPage;
+
+                if((aAny >>= xPage) && xPage.is())
+                {
+                    mnObjectCount += ImpRecursiveObjectCount(xPage);
+                }
+
+                if( IsImpress() )
+                {
+                    // #91587# take notes pages from draw pages into account
+                    Reference<presentation::XPresentationPage> xPresPage;
+                    if((aAny >>= xPresPage) && xPresPage.is())
+                    {
+                        Reference<XDrawPage> xNotesPage(xPresPage->getNotesPage());
+                        if(xNotesPage.is() && xNotesPage->getCount())
+                            mnObjectCount += ImpRecursiveObjectCount(xNotesPage);
+                    }
+                }
+            }
+        }
+
+        // #82003# init progress bar
+        GetProgressBarHelper()->SetReference(mnObjectCount);
+    }
+
+    // add namespaces
+    GetNamespaceMap_().Add(
+        GetXMLToken(XML_NP_PRESENTATION),
+        GetXMLToken(XML_N_PRESENTATION),
+        XML_NAMESPACE_PRESENTATION);
+
+    GetNamespaceMap_().Add(
+        GetXMLToken(XML_NP_SMIL),
+        GetXMLToken(XML_N_SMIL_COMPAT),
+        XML_NAMESPACE_SMIL);
+
+    GetNamespaceMap_().Add(
+        GetXMLToken(XML_NP_ANIMATION),
+        GetXMLToken(XML_N_ANIMATION),
+        XML_NAMESPACE_ANIMATION);
+
+    if (getSaneDefaultVersion() & SvtSaveOptions::ODFSVER_EXTENDED)
+    {
+        GetNamespaceMap_().Add(
+            GetXMLToken(XML_NP_OFFICE_EXT),
+            GetXMLToken(XML_N_OFFICE_EXT),
+            XML_NAMESPACE_OFFICE_EXT);
+    }
+
+    GetShapeExport()->enableLayerExport();
+
+    // #88546# enable progress bar increments
+    GetShapeExport()->enableHandleProgressBar();
+}
+
+// #82003# helper function for recursive object count
+sal_uInt32 SdXMLExport::ImpRecursiveObjectCount(const Reference< drawing::XShapes >& xShapes)
+{
+    sal_uInt32 nRetval(0);
+
+    if(xShapes.is())
+    {
+        sal_Int32 nCount = xShapes->getCount();
+
+        for(sal_Int32 a(0); a < nCount; a++)
+        {
+            Any aAny(xShapes->getByIndex(a));
+            Reference< drawing::XShapes > xGroup;
+
+            if((aAny >>= xGroup) && xGroup.is())
+            {
+                // #93180# count group objects, too.
+                nRetval += 1 + ImpRecursiveObjectCount(xGroup);
+            }
+            else
+            {
+                nRetval++;
+            }
+        }
+    }
+
+    return nRetval;
+}
+
+SdXMLExport::~SdXMLExport()
+{
+    // cleanup factory, decrease refcount. Should lead to destruction.
+    mpSdPropHdlFactory.clear();
+
+    // cleanup mapper, decrease refcount. Should lead to destruction.
+    mpPropertySetMapper.clear();
+
+    // cleanup presPage mapper, decrease refcount. Should lead to destruction.
+    mpPresPagePropsMapper.clear();
+
+    mvPageMasterInfoList.clear();
+
+    // clear auto-layout infos
+    mvAutoLayoutInfoList.clear();
+}
+
+void SdXMLExport::ImpPrepAutoLayoutInfos()
+{
+    if(!IsImpress())
+        return;
+
+    OUString aStr;
+    auto DrawPagesAutoLayoutNamesRange = asNonConstRange(maDrawPagesAutoLayoutNames);
+    Reference< presentation::XHandoutMasterSupplier > xHandoutSupp( GetModel(), UNO_QUERY );
+    if( xHandoutSupp.is() )
+    {
+        Reference< XDrawPage > xHandoutPage( xHandoutSupp->getHandoutMasterPage() );
+        if( xHandoutPage.is() )
+        {
+            if(ImpPrepAutoLayoutInfo(xHandoutPage, aStr))
+                DrawPagesAutoLayoutNamesRange[0] = aStr;
+        }
+    }
+
+    // prepare name creation
+    for (sal_Int32 nCnt = 0; nCnt < mnDocDrawPageCount; nCnt++)
+    {
+        Any aAny(mxDocDrawPages->getByIndex(nCnt));
+        Reference<XDrawPage> xDrawPage;
+
+        if((aAny >>= xDrawPage) && xDrawPage.is())
+        {
+            if(ImpPrepAutoLayoutInfo(xDrawPage, aStr))
+                DrawPagesAutoLayoutNamesRange[nCnt+1] = aStr;
+        }
+    }
+}
+
+bool SdXMLExport::ImpPrepAutoLayoutInfo(const Reference<XDrawPage>& xPage, OUString& rName)
+{
+    rName.clear();
+    bool bRetval(false);
+
+    Reference <beans::XPropertySet> xPropSet(xPage, UNO_QUERY);
+    if(xPropSet.is())
+    {
+        sal_uInt16 nType = sal_uInt16();
+        Any aAny = xPropSet->getPropertyValue("Layout");
+        if(aAny >>= nType)
+        {
+            if(ImpXMLAutoLayoutInfo::IsCreateNecessary(nType))
+            {
+                ImpXMLEXPPageMasterInfo* pInfo = nullptr;
+
+                // get master-page info
+                Reference < drawing::XMasterPageTarget > xMasterPageInt(xPage, UNO_QUERY);
+                if(xMasterPageInt.is())
+                {
+                    Reference<XDrawPage> xUsedMasterPage(xMasterPageInt->getMasterPage());
+                    if(xUsedMasterPage.is())
+                    {
+                        Reference < container::XNamed > xMasterNamed(xUsedMasterPage, UNO_QUERY);
+                        if(xMasterNamed.is())
+                        {
+                            OUString sMasterPageName = xMasterNamed->getName();
+                            pInfo = ImpGetPageMasterInfoByName(sMasterPageName);
+                        }
+                    }
+                }
+
+                // create entry and look for existence
+                ImpXMLAutoLayoutInfo* pNew;
+                auto it = std::find_if(mvAutoLayoutInfoList.begin(), mvAutoLayoutInfoList.end(),
+                            [=](std::unique_ptr<ImpXMLAutoLayoutInfo> const & rInfo) { return nType == rInfo->GetLayoutType() && pInfo == rInfo->GetPageMasterInfo(); });
+                if (it != mvAutoLayoutInfoList.end())
+                {
+                    pNew = it->get();
+                }
+                else
+                {
+                    pNew = new ImpXMLAutoLayoutInfo(nType, pInfo);
+                    mvAutoLayoutInfoList.emplace_back( pNew );
+                    OUString sNewName =
+                        "AL" + OUString::number(mvAutoLayoutInfoList.size() - 1) +
+                        "T" + OUString::number(nType);
+                    pNew->SetLayoutName(sNewName);
+                }
+
+                rName = pNew->GetLayoutName();
+                bRetval = true;
+            }
+        }
+    }
+
+    return bRetval;
+}
+
+void SdXMLExport::ImpWriteAutoLayoutInfos()
+{
+    for(const auto & pInfo : mvAutoLayoutInfoList)
+    {
+        if(pInfo)
+        {
+            // prepare presentation-page layout attributes, style-name
+            AddAttribute(XML_NAMESPACE_STYLE, XML_NAME, pInfo->GetLayoutName());
+
+            // write draw-style attributes
+            SvXMLElementExport aDSE(*this, XML_NAMESPACE_STYLE, XML_PRESENTATION_PAGE_LAYOUT, true, true);
+
+            // write presentation placeholders
+            switch(pInfo->GetLayoutType())
+            {
+                case AUTOLAYOUT_TITLE :
+                {
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderSubtitle, pInfo->GetPresRectangle());
+                    break;
+                }
+                case AUTOLAYOUT_TITLE_CONTENT :
+                {
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderOutline, pInfo->GetPresRectangle());
+                    break;
+                }
+                case AUTOLAYOUT_CHART :
+                {
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderChart, pInfo->GetPresRectangle());
+                    break;
+                }
+                case AUTOLAYOUT_TITLE_2CONTENT :
+                {
+                    tools::Rectangle aLeft(pInfo->GetPresRectangle());
+                    aLeft.setWidth(tools::Long(aLeft.GetWidth() * 0.488));
+                    tools::Rectangle aRight(aLeft);
+                    aRight.SetLeft(tools::Long(aRight.Left() + aRight.GetWidth() * 1.05));
+
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderOutline, aLeft);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderOutline, aRight);
+                    break;
+                }
+                case AUTOLAYOUT_TEXTCHART :
+                {
+                    tools::Rectangle aLeft(pInfo->GetPresRectangle());
+                    aLeft.setWidth(tools::Long(aLeft.GetWidth() * 0.488));
+                    tools::Rectangle aRight(aLeft);
+                    aRight.SetLeft( tools::Long(aRight.Left() + aRight.GetWidth() * 1.05) );
+
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderOutline, aLeft);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderChart, aRight);
+                    break;
+                }
+                case AUTOLAYOUT_TEXTCLIP :
+                {
+                    tools::Rectangle aLeft(pInfo->GetPresRectangle());
+                    aLeft.setWidth(tools::Long(aLeft.GetWidth() * 0.488));
+                    tools::Rectangle aRight(aLeft);
+                    aRight.SetLeft(tools::Long(aRight.Left() + aRight.GetWidth() * 1.05));
+
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderOutline, aLeft);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderGraphic, aRight);
+                    break;
+                }
+                case AUTOLAYOUT_CHARTTEXT :
+                {
+                    tools::Rectangle aLeft(pInfo->GetPresRectangle());
+                    aLeft.setWidth(tools::Long(aLeft.GetWidth() * 0.488));
+                    tools::Rectangle aRight(aLeft);
+                    aRight.SetLeft(tools::Long(aRight.Left() + aRight.GetWidth() * 1.05));
+
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderChart, aLeft);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderOutline, aRight);
+                    break;
+                }
+                case AUTOLAYOUT_TAB :
+                {
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTable, pInfo->GetPresRectangle());
+                    break;
+                }
+                case AUTOLAYOUT_CLIPTEXT :
+                {
+                    tools::Rectangle aLeft(pInfo->GetPresRectangle());
+                    aLeft.setWidth(tools::Long(aLeft.GetWidth() * 0.488));
+                    tools::Rectangle aRight(aLeft);
+                    aRight.SetLeft(tools::Long(aRight.Left() + aRight.GetWidth() * 1.05));
+
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderGraphic, aLeft);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderOutline, aRight);
+                    break;
+                }
+                case AUTOLAYOUT_TEXTOBJ :
+                {
+                    tools::Rectangle aLeft(pInfo->GetPresRectangle());
+                    aLeft.setWidth(tools::Long(aLeft.GetWidth() * 0.488));
+                    tools::Rectangle aRight(aLeft);
+                    aRight.SetLeft(tools::Long(aRight.Left() + aRight.GetWidth() * 1.05));
+
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderOutline, aLeft);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderObject, aRight);
+                    break;
+                }
+                case AUTOLAYOUT_OBJ :
+                {
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderObject, pInfo->GetPresRectangle());
+                    break;
+                }
+                case AUTOLAYOUT_TITLE_CONTENT_2CONTENT :
+                {
+                    tools::Rectangle aLeft(pInfo->GetPresRectangle());
+                    aLeft.setWidth(tools::Long(aLeft.GetWidth() * 0.488));
+                    tools::Rectangle aRightTop(aLeft);
+                    aRightTop.SetLeft(tools::Long(aRightTop.Left() + aRightTop.GetWidth() * 1.05));
+                    aRightTop.setHeight(tools::Long(aRightTop.GetHeight() * 0.477));
+                    tools::Rectangle aRightBottom(aRightTop);
+                    aRightBottom.SetTop(tools::Long(aRightBottom.Top() + aRightBottom.GetHeight() * 1.095));
+
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderOutline, aLeft);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderObject, aRightTop);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderObject, aRightBottom);
+                    break;
+                }
+                case AUTOLAYOUT_OBJTEXT :
+                {
+                    tools::Rectangle aLeft(pInfo->GetPresRectangle());
+                    aLeft.setWidth(tools::Long(aLeft.GetWidth() * 0.488));
+                    tools::Rectangle aRight(aLeft);
+                    aRight.SetLeft(tools::Long(aRight.Left() + aRight.GetWidth() * 1.05));
+
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderObject, aLeft);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderOutline, aRight);
+                    break;
+                }
+                case AUTOLAYOUT_TITLE_CONTENT_OVER_CONTENT :
+                {
+                    tools::Rectangle aTop(pInfo->GetPresRectangle());
+                    aTop.setHeight(tools::Long(aTop.GetHeight() * 0.477));
+                    tools::Rectangle aBottom(aTop);
+                    aBottom.SetTop(tools::Long(aBottom.Top() + aBottom.GetHeight() * 1.095));
+
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderObject, aTop);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderOutline, aBottom);
+                    break;
+                }
+                case AUTOLAYOUT_TITLE_2CONTENT_CONTENT :
+                {
+                    tools::Rectangle aLeftTop(pInfo->GetPresRectangle());
+                    aLeftTop.setWidth(tools::Long(aLeftTop.GetWidth() * 0.488));
+                    tools::Rectangle aRight(aLeftTop);
+                    aRight.SetLeft(tools::Long(aRight.Left() + aRight.GetWidth() * 1.05));
+                    aLeftTop.setHeight(tools::Long(aLeftTop.GetHeight() * 0.477));
+                    tools::Rectangle aLeftBottom(aLeftTop);
+                    aLeftBottom.SetTop(tools::Long(aLeftBottom.Top() + aLeftBottom.GetHeight() * 1.095));
+
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderObject, aLeftTop);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderObject, aLeftBottom);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderOutline, aRight);
+                    break;
+                }
+                case AUTOLAYOUT_TITLE_2CONTENT_OVER_CONTENT :
+                {
+                    tools::Rectangle aTopLeft(pInfo->GetPresRectangle());
+                    aTopLeft.setHeight(tools::Long(aTopLeft.GetHeight() * 0.477));
+                    tools::Rectangle aBottom(aTopLeft);
+                    aBottom.SetTop(tools::Long(aBottom.Top() + aBottom.GetHeight() * 1.095));
+                    aTopLeft.setWidth(tools::Long(aTopLeft.GetWidth() * 0.488));
+                    tools::Rectangle aTopRight(aTopLeft);
+                    aTopRight.SetLeft(tools::Long(aTopRight.Left() + aTopRight.GetWidth() * 1.05));
+
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderObject, aTopLeft);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderObject, aTopRight);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderOutline, aBottom);
+                    break;
+                }
+                case AUTOLAYOUT_TEXTOVEROBJ :
+                {
+                    tools::Rectangle aTop(pInfo->GetPresRectangle());
+                    aTop.setHeight(tools::Long(aTop.GetHeight() * 0.477));
+                    tools::Rectangle aBottom(aTop);
+                    aBottom.SetTop(tools::Long(aBottom.Top() + aBottom.GetHeight() * 1.095));
+
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderOutline, aTop);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderObject, aBottom);
+                    break;
+                }
+                case AUTOLAYOUT_TITLE_4CONTENT :
+                {
+                    tools::Rectangle aTopLeft(pInfo->GetPresRectangle());
+                    aTopLeft.setHeight(tools::Long(aTopLeft.GetHeight() * 0.477));
+                    aTopLeft.setWidth(tools::Long(aTopLeft.GetWidth() * 0.488));
+                    tools::Rectangle aBottomLeft(aTopLeft);
+                    aBottomLeft.SetTop(tools::Long(aBottomLeft.Top() + aBottomLeft.GetHeight() * 1.095));
+                    tools::Rectangle aTopRight(aTopLeft);
+                    aTopRight.SetLeft(tools::Long(aTopRight.Left() + aTopRight.GetWidth() * 1.05));
+                    tools::Rectangle aBottomRight(aTopRight);
+                    aBottomRight.SetTop(tools::Long(aBottomRight.Top() + aBottomRight.GetHeight() * 1.095));
+
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderObject, aTopLeft);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderObject, aTopRight);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderObject, aBottomLeft);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderObject, aBottomRight);
+                    break;
+                }
+                case AUTOLAYOUT_TITLE_ONLY :
+                {
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTitle, pInfo->GetTitleRectangle());
+                    break;
+                }
+                case AUTOLAYOUT_NOTES :
+                {
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderPage, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderNotes, pInfo->GetPresRectangle());
+                    break;
+                }
+                case AUTOLAYOUT_HANDOUT1 :
+                case AUTOLAYOUT_HANDOUT2 :
+                case AUTOLAYOUT_HANDOUT3 :
+                case AUTOLAYOUT_HANDOUT4 :
+                case AUTOLAYOUT_HANDOUT6 :
+                case AUTOLAYOUT_HANDOUT9 :
+                {
+                    sal_Int32 nColCnt, nRowCnt;
+                    sal_Int32 nGapX = pInfo->GetGapX();
+                    sal_Int32 nGapY = pInfo->GetGapY();
+
+                    switch(pInfo->GetLayoutType())
+                    {
+                        case 22 : nColCnt = 1; nRowCnt = 1; break;
+                        case 23 : nColCnt = 1; nRowCnt = 2; break;
+                        case 24 : nColCnt = 1; nRowCnt = 3; break;
+                        case 25 : nColCnt = 2; nRowCnt = 2; break;
+                        case 26 : nColCnt = 3; nRowCnt = 2; break;
+                        case 31 : nColCnt = 3; nRowCnt = 3; break;
+                        default:  nColCnt = 0; nRowCnt = 0; break;  // FIXME - What is correct values?
+                    }
+
+                    Size aPartSize(pInfo->GetTitleRectangle().GetSize());
+                    Point aPartPos(pInfo->GetTitleRectangle().TopLeft());
+
+                    if(aPartSize.Width() > aPartSize.Height())
+                    {
+                        sal_Int32 nZwi(nColCnt);
+                        nColCnt = nRowCnt;
+                        nRowCnt = nZwi;
+                    }
+
+                    if (nColCnt == 0 || nRowCnt == 0)
+                        break;
+
+                    aPartSize.setWidth( (aPartSize.Width() - ((nColCnt - 1) * nGapX)) / nColCnt );
+                    aPartSize.setHeight( (aPartSize.Height() - ((nRowCnt - 1) * nGapY)) / nRowCnt );
+
+                    Point aTmpPos(aPartPos);
+
+                    for (sal_Int32 a = 0; a < nRowCnt; a++)
+                    {
+                        aTmpPos.setX(aPartPos.X());
+
+                        for (sal_Int32 b = 0; b < nColCnt; b++)
+                        {
+                            tools::Rectangle aTmpRect(aTmpPos, aPartSize);
+
+                            ImpWriteAutoLayoutPlaceholder(XmlPlaceholderHandout, aTmpRect);
+                            aTmpPos.AdjustX( aPartSize.Width() + nGapX );
+                        }
+
+                        aTmpPos.AdjustY( aPartSize.Height() + nGapY );
+                    }
+                    break;
+                }
+                case AUTOLAYOUT_VTITLE_VCONTENT_OVER_VCONTENT :
+                {
+                    tools::Rectangle aTop(pInfo->GetPresRectangle());
+                    aTop.setHeight(tools::Long(aTop.GetHeight() * 0.488));
+                    tools::Rectangle aBottom(aTop);
+                    aBottom.SetTop(tools::Long(aBottom.Top() + aBottom.GetHeight() * 1.05));
+
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderVerticalTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderVerticalOutline, aTop);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderChart, aBottom);
+                    break;
+                }
+                case AUTOLAYOUT_VTITLE_VCONTENT :
+                {
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderVerticalTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderVerticalOutline, pInfo->GetPresRectangle());
+                    break;
+                }
+                case AUTOLAYOUT_TITLE_VCONTENT :
+                {
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderVerticalOutline, pInfo->GetPresRectangle());
+                    break;
+                }
+                case AUTOLAYOUT_TITLE_2VTEXT :
+                {
+                    tools::Rectangle aLeft(pInfo->GetPresRectangle());
+                    aLeft.setWidth(tools::Long(aLeft.GetWidth() * 0.488));
+                    tools::Rectangle aRight(aLeft);
+                    aRight.SetLeft(tools::Long(aRight.Left() + aRight.GetWidth() * 1.05));
+
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderGraphic, aLeft);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderVerticalOutline, aRight);
+                    break;
+                }
+                case AUTOLAYOUT_ONLY_TEXT :
+                {
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderSubtitle, pInfo->GetPresRectangle());
+                    break;
+                }
+
+                case AUTOLAYOUT_4CLIPART :
+                {
+                    tools::Rectangle aTopLeft(pInfo->GetPresRectangle());
+                    aTopLeft.setHeight(tools::Long(aTopLeft.GetHeight() * 0.477));
+                    aTopLeft.setWidth(tools::Long(aTopLeft.GetWidth() * 0.488));
+                    tools::Rectangle aBottomLeft(aTopLeft);
+                    aBottomLeft.SetTop(tools::Long(aBottomLeft.Top() + aBottomLeft.GetHeight() * 1.095));
+                    tools::Rectangle aTopRight(aTopLeft);
+                    aTopRight.SetLeft(tools::Long(aTopRight.Left() + aTopRight.GetWidth() * 1.05));
+                    tools::Rectangle aBottomRight(aTopRight);
+                    aBottomRight.SetTop(tools::Long(aBottomRight.Top() + aBottomRight.GetHeight() * 1.095));
+
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderGraphic, aTopLeft);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderGraphic, aTopRight);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderGraphic, aBottomLeft);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderGraphic, aBottomRight);
+                    break;
+                }
+
+                case AUTOLAYOUT_TITLE_6CONTENT :
+                {
+                    tools::Rectangle aTopLeft(pInfo->GetPresRectangle());
+                    aTopLeft.setHeight(tools::Long(aTopLeft.GetHeight() * 0.477));
+                    aTopLeft.setWidth(tools::Long(aTopLeft.GetWidth() * 0.322));
+                    tools::Rectangle aTopCenter(aTopLeft);
+                    aTopCenter.SetLeft(tools::Long(aTopCenter.Left() + aTopCenter.GetWidth() * 1.05));
+                    tools::Rectangle aTopRight(aTopLeft);
+                    aTopRight.SetLeft(tools::Long(aTopRight.Left() + aTopRight.GetWidth() * 2 * 1.05));
+
+                    tools::Rectangle aBottomLeft(aTopLeft);
+                    aBottomLeft.SetTop(tools::Long(aBottomLeft.Top() + aBottomLeft.GetHeight() * 1.095));
+                    tools::Rectangle aBottomCenter(aTopCenter);
+                    aBottomCenter.SetTop(tools::Long(aBottomCenter.Top() + aBottomCenter.GetHeight() * 1.095));
+                    tools::Rectangle aBottomRight(aTopRight);
+                    aBottomRight.SetTop(tools::Long(aBottomRight.Top() + aBottomRight.GetHeight() * 1.095));
+
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderTitle, pInfo->GetTitleRectangle());
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderGraphic, aTopLeft);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderGraphic, aTopCenter);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderGraphic, aTopRight);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderGraphic, aBottomLeft);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderGraphic, aBottomCenter);
+                    ImpWriteAutoLayoutPlaceholder(XmlPlaceholderGraphic, aBottomRight);
+                    break;
+                }
+                default:
+                {
+                    OSL_FAIL("XMLEXP: unknown autolayout export");
+                    break;
+                }
+            }
+        }
+    }
+}
+
+void SdXMLExport::ImpWriteAutoLayoutPlaceholder(XmlPlaceholder ePl, const tools::Rectangle& rRect)
+{
+    OUString aStr;
+    OUStringBuffer sStringBuffer;
+
+    // prepare presentation-placeholder attributes, presentation:object
+    switch(ePl)
+    {
+        case XmlPlaceholderTitle: aStr = "title"; break;
+        case XmlPlaceholderOutline: aStr = "outline"; break;
+        case XmlPlaceholderSubtitle: aStr = "subtitle"; break;
+        case XmlPlaceholderGraphic: aStr = "graphic"; break;
+        case XmlPlaceholderObject: aStr = "object"; break;
+        case XmlPlaceholderChart: aStr = "chart"; break;
+        case XmlPlaceholderTable: aStr = "table"; break;
+        case XmlPlaceholderPage: aStr = "page"; break;
+        case XmlPlaceholderNotes: aStr = "notes"; break;
+        case XmlPlaceholderHandout: aStr = "handout"; break;
+        case XmlPlaceholderVerticalTitle: aStr = "vertical_title"; break;
+        case XmlPlaceholderVerticalOutline: aStr = "vertical_outline"; break;
+    }
+
+    AddAttribute(XML_NAMESPACE_PRESENTATION, XML_OBJECT, aStr);
+
+    // svg:x,y,width,height
+    GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, rRect.Left());
+    aStr = sStringBuffer.makeStringAndClear();
+    AddAttribute(XML_NAMESPACE_SVG, XML_X, aStr);
+
+    GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, rRect.Top());
+    aStr = sStringBuffer.makeStringAndClear();
+    AddAttribute(XML_NAMESPACE_SVG, XML_Y, aStr);
+
+    GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+            rRect.GetWidth());
+    aStr = sStringBuffer.makeStringAndClear();
+    AddAttribute(XML_NAMESPACE_SVG, XML_WIDTH, aStr);
+
+    GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+            rRect.GetHeight());
+    aStr = sStringBuffer.makeStringAndClear();
+    AddAttribute(XML_NAMESPACE_SVG, XML_HEIGHT, aStr);
+
+    // write presentation-placeholder
+    SvXMLElementExport aPPL(*this, XML_NAMESPACE_PRESENTATION, XML_PLACEHOLDER, true, true);
+}
+
+ImpXMLEXPPageMasterInfo* SdXMLExport::ImpGetOrCreatePageMasterInfo( const Reference< XDrawPage >& xMasterPage )
+{
+    bool bDoesExist = false;
+
+    ImpXMLEXPPageMasterInfo* pNewInfo = new ImpXMLEXPPageMasterInfo(*this, xMasterPage);
+
+    // compare with prev page-master infos
+    for( size_t a = 0; !bDoesExist && a < mvPageMasterInfoList.size(); a++)
+    {
+        if (   mvPageMasterInfoList.at(a)
+           && *mvPageMasterInfoList.at(a) == *pNewInfo
+           )
+        {
+            delete pNewInfo;
+            pNewInfo = mvPageMasterInfoList.at(a).get();
+            bDoesExist = true;
+        }
+    }
+    // add entry when not found same page-master infos
+    if(!bDoesExist)
+        mvPageMasterInfoList.emplace_back( pNewInfo );
+
+    return pNewInfo;
+}
+
+void SdXMLExport::ImpPrepPageMasterInfos()
+{
+    if( IsImpress() )
+    {
+        // create page master info for handout master page
+
+        Reference< XHandoutMasterSupplier > xHMS( GetModel(), UNO_QUERY );
+        if( xHMS.is() )
+        {
+            Reference< XDrawPage > xMasterPage( xHMS->getHandoutMasterPage() );
+            if( xMasterPage.is() )
+                mpHandoutPageMaster = ImpGetOrCreatePageMasterInfo(xMasterPage);
+        }
+    }
+
+    // create page master infos for master pages
+    if(!mnDocMasterPageCount)
+        return;
+
+    // look for needed page-masters, create these
+    for (sal_Int32 nMPageId = 0; nMPageId < mnDocMasterPageCount; nMPageId++)
+    {
+        Reference< XDrawPage > xMasterPage( mxDocMasterPages->getByIndex(nMPageId), UNO_QUERY );
+        ImpXMLEXPPageMasterInfo* pNewInfo = nullptr;
+
+        if(xMasterPage.is())
+            pNewInfo = ImpGetOrCreatePageMasterInfo(xMasterPage);
+
+        mvPageMasterUsageList.push_back( pNewInfo );
+
+        // look for page master of handout page
+        if(IsImpress())
+        {
+            pNewInfo = nullptr;
+            Reference< presentation::XPresentationPage > xPresPage(xMasterPage, UNO_QUERY);
+            if(xPresPage.is())
+            {
+                Reference< XDrawPage > xNotesPage(xPresPage->getNotesPage());
+                if(xNotesPage.is())
+                {
+                    pNewInfo = ImpGetOrCreatePageMasterInfo(xNotesPage);
+                }
+            }
+            mvNotesPageMasterUsageList.push_back( pNewInfo );
+        }
+    }
+}
+
+void SdXMLExport::ImpWritePageMasterInfos()
+{
+    // write created page-masters, create names for these
+    for( size_t nCnt = 0; nCnt < mvPageMasterInfoList.size(); nCnt++)
+    {
+        ImpXMLEXPPageMasterInfo* pInfo = mvPageMasterInfoList.at(nCnt).get();
+        if(pInfo)
+        {
+            // create name
+            OUString sNewName = "PM" + OUString::number(nCnt);
+            pInfo->SetName(sNewName);
+
+            // prepare page-master attributes
+            OUString sString;
+            OUStringBuffer sStringBuffer;
+
+            sString = sNewName;
+            AddAttribute(XML_NAMESPACE_STYLE, XML_NAME, sString);
+
+            // write page-layout
+            SvXMLElementExport aPME(*this, XML_NAMESPACE_STYLE, XML_PAGE_LAYOUT, true, true);
+
+            // prepare style:properties inside page-master
+            GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                    pInfo->GetBorderTop());
+            sString = sStringBuffer.makeStringAndClear();
+            AddAttribute(XML_NAMESPACE_FO, XML_MARGIN_TOP, sString);
+
+            GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                    pInfo->GetBorderBottom());
+            sString = sStringBuffer.makeStringAndClear();
+            AddAttribute(XML_NAMESPACE_FO, XML_MARGIN_BOTTOM, sString);
+
+            GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                    pInfo->GetBorderLeft());
+            sString = sStringBuffer.makeStringAndClear();
+            AddAttribute(XML_NAMESPACE_FO, XML_MARGIN_LEFT, sString);
+
+            GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                    pInfo->GetBorderRight());
+            sString = sStringBuffer.makeStringAndClear();
+            AddAttribute(XML_NAMESPACE_FO, XML_MARGIN_RIGHT, sString);
+
+            GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                    pInfo->GetWidth());
+            sString = sStringBuffer.makeStringAndClear();
+            AddAttribute(XML_NAMESPACE_FO, XML_PAGE_WIDTH, sString);
+
+            GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                    pInfo->GetHeight());
+            sString = sStringBuffer.makeStringAndClear();
+            AddAttribute(XML_NAMESPACE_FO, XML_PAGE_HEIGHT, sString);
+
+            if(pInfo->GetOrientation() == view::PaperOrientation_PORTRAIT)
+                AddAttribute(XML_NAMESPACE_STYLE, XML_PRINT_ORIENTATION, XML_PORTRAIT);
+            else
+                AddAttribute(XML_NAMESPACE_STYLE, XML_PRINT_ORIENTATION, XML_LANDSCAPE);
+
+            // write style:properties
+            SvXMLElementExport aPMF(*this, XML_NAMESPACE_STYLE, XML_PAGE_LAYOUT_PROPERTIES, true, true);
+        }
+    }
+}
+
+ImpXMLEXPPageMasterInfo* SdXMLExport::ImpGetPageMasterInfoByName(std::u16string_view rName)
+{
+    if(!rName.empty())
+    {
+        for(const auto & pInfo : mvPageMasterInfoList)
+        {
+            if(pInfo)
+            {
+                if(!pInfo->GetMasterPageName().isEmpty() && rName == pInfo->GetMasterPageName())
+                {
+                    return pInfo.get();
+                }
+            }
+        }
+    }
+    return nullptr;
+}
+
+void SdXMLExport::ImpPrepDrawPageInfos()
+{
+    // create draw:style-name entries for page export
+    // containing presentation page attributes AND background attributes
+    // fixed family for page-styles is "drawing-page" (XML_STYLE_FAMILY_SD_DRAWINGPAGE_NAME)
+
+    sal_Int32 nCnt;
+    for(nCnt = 0; nCnt < mnDocDrawPageCount; nCnt++)
+    {
+        Reference<XDrawPage> xDrawPage;
+        mxDocDrawPages->getByIndex(nCnt) >>= xDrawPage;
+        maDrawPagesStyleNames[nCnt] = ImpCreatePresPageStyleName( xDrawPage );
+
+        Reference< presentation::XPresentationPage > xPresPage(xDrawPage, UNO_QUERY);
+        if(xPresPage.is())
+        {
+            maDrawNotesPagesStyleNames[nCnt] = ImpCreatePresPageStyleName( xPresPage->getNotesPage(), false );
+
+            maDrawPagesHeaderFooterSettings[nCnt] = ImpPrepDrawPageHeaderFooterDecls( xDrawPage );
+            maDrawNotesPagesHeaderFooterSettings[nCnt] = ImpPrepDrawPageHeaderFooterDecls( xPresPage->getNotesPage() );
+        }
+    }
+}
+
+static OUString findOrAppendImpl( std::vector< OUString >& rVector, const OUString& rText, std::u16string_view pPrefix )
+{
+    // search rVector if there is already a string that equals rText
+    auto aIter = std::find(rVector.begin(), rVector.end(), rText);
+    sal_Int32 nIndex = std::distance(rVector.begin(), aIter) + 1;
+
+    // if nothing is found, append the string at the end of rVector
+    if( aIter == rVector.end() )
+        rVector.push_back( rText );
+
+    // create a reference string with pPrefix and the index of the
+    // found or created rText
+    return pPrefix + OUString::number( nIndex );
+}
+
+static OUString findOrAppendImpl( std::vector< DateTimeDeclImpl >& rVector, const OUString& rText, bool bFixed, sal_Int32 nFormat, std::u16string_view pPrefix )
+{
+    // search rVector if there is already a DateTimeDeclImpl with rText,bFixed and nFormat
+    auto aIter = std::find_if(rVector.begin(), rVector.end(),
+        [bFixed, &rText, nFormat](const DateTimeDeclImpl& rDecl) {
+            return (rDecl.mbFixed == bFixed) &&
+                (!bFixed || (rDecl.maStrText == rText)) &&
+                (bFixed || (rDecl.mnFormat == nFormat));
+        });
+    sal_Int32 nIndex = std::distance(rVector.begin(), aIter) + 1;
+
+    // if nothing is found, append a new DateTimeDeclImpl
+    if( aIter == rVector.end() )
+    {
+        DateTimeDeclImpl aDecl;
+        aDecl.maStrText = rText;
+        aDecl.mbFixed = bFixed;
+        aDecl.mnFormat = nFormat;
+        rVector.push_back( aDecl );
+    }
+
+    // create a reference string with pPrefix and the index of the
+    // found or created DateTimeDeclImpl
+    return pPrefix + OUString::number( nIndex );
+}
+
+constexpr OUStringLiteral gpStrHeaderTextPrefix = u"hdr";
+constexpr OUStringLiteral gpStrFooterTextPrefix = u"ftr";
+constexpr OUStringLiteral gpStrDateTimeTextPrefix = u"dtd";
+
+HeaderFooterPageSettingsImpl SdXMLExport::ImpPrepDrawPageHeaderFooterDecls( const Reference<XDrawPage>& xDrawPage )
+{
+    HeaderFooterPageSettingsImpl aSettings;
+
+    if( xDrawPage.is() ) try
+    {
+        Reference< XPropertySet > xSet( xDrawPage, UNO_QUERY_THROW );
+        Reference< XPropertySetInfo > xInfo( xSet->getPropertySetInfo() );
+
+        OUString aStrText;
+
+        static const OUStringLiteral aStrHeaderTextProp( u"HeaderText" );
+        if( xInfo->hasPropertyByName( aStrHeaderTextProp ) )
+        {
+            xSet->getPropertyValue( aStrHeaderTextProp  ) >>= aStrText;
+            if( !aStrText.isEmpty() )
+                aSettings.maStrHeaderDeclName = findOrAppendImpl( maHeaderDeclsVector, aStrText, gpStrHeaderTextPrefix );
+        }
+
+        static const OUStringLiteral aStrFooterTextProp( u"FooterText" );
+        if( xInfo->hasPropertyByName( aStrFooterTextProp ) )
+        {
+            xSet->getPropertyValue( aStrFooterTextProp ) >>= aStrText;
+            if( !aStrText.isEmpty() )
+                aSettings.maStrFooterDeclName = findOrAppendImpl( maFooterDeclsVector, aStrText, gpStrFooterTextPrefix );
+        }
+
+        static const OUStringLiteral aStrDateTimeTextProp( u"DateTimeText" );
+        if( xInfo->hasPropertyByName( aStrDateTimeTextProp ) )
+        {
+            bool bFixed = false;
+            sal_Int32 nFormat = 0;
+            xSet->getPropertyValue( aStrDateTimeTextProp ) >>= aStrText;
+            xSet->getPropertyValue("IsDateTimeFixed") >>= bFixed;
+            xSet->getPropertyValue("DateTimeFormat") >>= nFormat;
+
+            if( !bFixed || !aStrText.isEmpty() )
+            {
+                aSettings.maStrDateTimeDeclName = findOrAppendImpl( maDateTimeDeclsVector, aStrText, bFixed, nFormat, gpStrDateTimeTextPrefix );
+                if( !bFixed )
+                    addDataStyle( nFormat );
+            }
+        }
+    }
+    catch(const Exception&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw", "");
+    }
+
+    return aSettings;
+}
+
+void SdXMLExport::ImpWriteHeaderFooterDecls()
+{
+    OUStringBuffer sBuffer;
+
+    if( !maHeaderDeclsVector.empty() )
+    {
+        // export header decls
+        const OUString aPrefix( gpStrHeaderTextPrefix );
+        sal_Int32 nIndex = 1;
+        for( const auto& rDecl : maHeaderDeclsVector )
+        {
+            sBuffer.append( aPrefix );
+            sBuffer.append( nIndex );
+            AddAttribute(XML_NAMESPACE_PRESENTATION, XML_NAME, sBuffer.makeStringAndClear());
+
+            SvXMLElementExport aElem(*this, XML_NAMESPACE_PRESENTATION, XML_HEADER_DECL, true, true);
+            Characters(rDecl);
+            ++nIndex;
+        }
+    }
+
+    if( !maFooterDeclsVector.empty() )
+    {
+        // export footer decls
+        const OUString aPrefix( gpStrFooterTextPrefix );
+        sal_Int32 nIndex = 1;
+        for( const auto& rDecl : maFooterDeclsVector )
+        {
+            sBuffer.append( aPrefix );
+            sBuffer.append( nIndex );
+            AddAttribute(XML_NAMESPACE_PRESENTATION, XML_NAME, sBuffer.makeStringAndClear());
+
+            SvXMLElementExport aElem(*this, XML_NAMESPACE_PRESENTATION, XML_FOOTER_DECL, false, false);
+            Characters(rDecl);
+            ++nIndex;
+        }
+    }
+
+    if( maDateTimeDeclsVector.empty() )
+        return;
+
+    // export footer decls
+    const OUString aPrefix( gpStrDateTimeTextPrefix );
+    sal_Int32 nIndex = 1;
+    for( const auto& rDecl : maDateTimeDeclsVector )
+    {
+        sBuffer.append( aPrefix );
+        sBuffer.append( nIndex );
+        AddAttribute( XML_NAMESPACE_PRESENTATION, XML_NAME, sBuffer.makeStringAndClear());
+
+        AddAttribute( XML_NAMESPACE_PRESENTATION, XML_SOURCE, rDecl.mbFixed ? XML_FIXED : XML_CURRENT_DATE );
+
+        if( !rDecl.mbFixed )
+            AddAttribute( XML_NAMESPACE_STYLE, XML_DATA_STYLE_NAME, getDataStyleName( rDecl.mnFormat ) );
+
+        SvXMLElementExport aElem(*this, XML_NAMESPACE_PRESENTATION, XML_DATE_TIME_DECL, false, false);
+        if( rDecl.mbFixed )
+            Characters(rDecl.maStrText);
+
+        ++nIndex;
+    }
+}
+
+void SdXMLExport::ImplExportHeaderFooterDeclAttributes( const HeaderFooterPageSettingsImpl& aSettings )
+{
+    if( !aSettings.maStrHeaderDeclName.isEmpty() )
+        AddAttribute( XML_NAMESPACE_PRESENTATION, XML_USE_HEADER_NAME, aSettings.maStrHeaderDeclName );
+
+    if( !aSettings.maStrFooterDeclName.isEmpty() )
+        AddAttribute( XML_NAMESPACE_PRESENTATION, XML_USE_FOOTER_NAME, aSettings.maStrFooterDeclName );
+
+    if( !aSettings.maStrDateTimeDeclName.isEmpty() )
+        AddAttribute( XML_NAMESPACE_PRESENTATION, XML_USE_DATE_TIME_NAME, aSettings.maStrDateTimeDeclName );
+}
+
+OUString SdXMLExport::ImpCreatePresPageStyleName( const Reference<XDrawPage>& xDrawPage, bool bExportBackground /* = true */ )
+{
+    // create name
+    OUString sStyleName;
+
+    // create style for this page and add to auto style pool
+
+    Reference< beans::XPropertySet > xPropSet1(xDrawPage, UNO_QUERY);
+    if(xPropSet1.is())
+    {
+        Reference< beans::XPropertySet > xPropSet;
+
+        if( bExportBackground )
+        {
+            // since the background items are in a different propertyset
+            // which itself is a property of the pages property set
+            // we now merge these two propertysets if possible to simulate
+            // a single propertyset with all draw page properties
+            static const OUStringLiteral aBackground(u"Background");
+            Reference< beans::XPropertySet > xPropSet2;
+            Reference< beans::XPropertySetInfo > xInfo( xPropSet1->getPropertySetInfo() );
+            if( xInfo.is() && xInfo->hasPropertyByName( aBackground ) )
+            {
+                Any aAny( xPropSet1->getPropertyValue( aBackground ) );
+                aAny >>= xPropSet2;
+            }
+
+            if( xPropSet2.is() )
+                xPropSet = PropertySetMerger_CreateInstance( xPropSet1, xPropSet2 );
+            else
+                xPropSet = xPropSet1;
+        }
+        else
+        {
+            xPropSet = xPropSet1;
+        }
+
+        const rtl::Reference< SvXMLExportPropertyMapper > aMapperRef( GetPresPagePropsMapper() );
+
+        std::vector<XMLPropertyState> aPropStates(aMapperRef->Filter(*this, xPropSet));
+
+        if( !aPropStates.empty() )
+        {
+            // there are filtered properties -> hard attributes
+            // try to find this style in AutoStylePool
+            sStyleName = GetAutoStylePool()->Find(XmlStyleFamily::SD_DRAWINGPAGE_ID, sStyleName, aPropStates);
+
+            if(sStyleName.isEmpty())
+            {
+                // Style did not exist, add it to AutoStalePool
+                sStyleName = GetAutoStylePool()->Add(XmlStyleFamily::SD_DRAWINGPAGE_ID, sStyleName, std::move(aPropStates));
+            }
+        }
+    }
+
+    return sStyleName;
+}
+
+void SdXMLExport::ImpPrepMasterPageInfos()
+{
+    // create draw:style-name entries for master page export
+    // containing only background attributes
+    // fixed family for page-styles is "drawing-page" (XML_STYLE_FAMILY_SD_DRAWINGPAGE_NAME)
+
+    sal_Int32 nCnt;
+    for( nCnt = 0; nCnt < mnDocMasterPageCount; nCnt++)
+    {
+        Reference<XDrawPage> xDrawPage;
+        mxDocMasterPages->getByIndex(nCnt) >>= xDrawPage;
+        maMasterPagesStyleNames[nCnt] = ImpCreatePresPageStyleName( xDrawPage );
+    }
+
+    if( !IsImpress() )
+        return;
+
+    Reference< presentation::XHandoutMasterSupplier > xHandoutSupp( GetModel(), UNO_QUERY );
+    if( xHandoutSupp.is() )
+    {
+        Reference< XDrawPage > xHandoutPage( xHandoutSupp->getHandoutMasterPage() );
+        if( xHandoutPage.is() )
+        {
+            maHandoutPageHeaderFooterSettings = ImpPrepDrawPageHeaderFooterDecls( xHandoutPage );
+            maHandoutMasterStyleName = ImpCreatePresPageStyleName( xHandoutPage, false );
+        }
+    }
+}
+
+void SdXMLExport::ImpWritePresentationStyles()
+{
+    if(!IsImpress())
+        return;
+
+    for (sal_Int32 nCnt = 0; nCnt < mnDocMasterPageCount; nCnt++)
+    {
+        Any aAny(mxDocMasterPages->getByIndex(nCnt));
+        Reference<container::XNamed> xNamed;
+
+        if(aAny >>= xNamed)
+        {
+            // write presentation styles (ONLY if presentation)
+            if(IsImpress() && mxDocStyleFamilies.is() && xNamed.is())
+            {
+                rtl::Reference<XMLStyleExport> aStEx(new XMLStyleExport(*this, GetAutoStylePool().get()));
+                const rtl::Reference< SvXMLExportPropertyMapper > aMapperRef( GetPropertySetMapper() );
+
+                OUString aPrefix( xNamed->getName() + "-" );
+
+                aStEx->exportStyleFamily(xNamed->getName(),
+                    OUString(XML_STYLE_FAMILY_SD_PRESENTATION_NAME),
+                    aMapperRef, false,
+                    XmlStyleFamily::SD_PRESENTATION_ID, &aPrefix);
+            }
+        }
+    }
+}
+
+void SdXMLExport::ExportMeta_()
+{
+    uno::Sequence<beans::NamedValue> stats { { "ObjectCount", uno::Any(mnObjectCount) } };
+
+    // update document statistics at the model
+    uno::Reference<document::XDocumentPropertiesSupplier> xPropSup(GetModel(),
+        uno::UNO_QUERY_THROW);
+    uno::Reference<document::XDocumentProperties> xDocProps(
+        xPropSup->getDocumentProperties());
+    if (xDocProps.is()) {
+        xDocProps->setDocumentStatistics(stats);
+    }
+
+    // call parent
+    SvXMLExport::ExportMeta_();
+}
+
+void SdXMLExport::ExportFontDecls_()
+{
+    GetFontAutoStylePool(); // make sure the pool is created
+    SvXMLExport::ExportFontDecls_();
+}
+
+void SdXMLExport::ExportContent_()
+{
+    // export <pres:header-decl>, <pres:footer-decl> and <pres:date-time-decl> elements
+    ImpWriteHeaderFooterDecls();
+
+    // page export
+    for(sal_Int32 nPageInd(0); nPageInd < mnDocDrawPageCount; nPageInd++)
+    {
+        uno::Reference<drawing::XDrawPage> xDrawPage( mxDocDrawPages->getByIndex(nPageInd), uno::UNO_QUERY );
+
+        // set progress view
+        if(GetStatusIndicator().is())
+            GetStatusIndicator()->setValue(((nPageInd + 1) * 100) / mnDocDrawPageCount);
+
+        if(xDrawPage.is())
+        {
+            // prepare page attributes, name of page
+            Reference < container::XNamed > xNamed(xDrawPage, UNO_QUERY);
+            if(xNamed.is())
+                AddAttribute(XML_NAMESPACE_DRAW, XML_NAME, xNamed->getName());
+
+            // draw:style-name (presentation page attributes AND background attributes)
+            if( !maDrawPagesStyleNames[nPageInd].isEmpty() )
+                AddAttribute(XML_NAMESPACE_DRAW, XML_STYLE_NAME,
+                        maDrawPagesStyleNames[nPageInd]);
+
+            // draw:master-page-name
+            Reference < drawing::XMasterPageTarget > xMasterPageInt(xDrawPage, UNO_QUERY);
+            if(xMasterPageInt.is())
+            {
+                Reference<XDrawPage> xUsedMasterPage(xMasterPageInt->getMasterPage());
+                if(xUsedMasterPage.is())
+                {
+                    Reference < container::XNamed > xMasterNamed(xUsedMasterPage, UNO_QUERY);
+                    if(xMasterNamed.is())
+                    {
+                        AddAttribute(XML_NAMESPACE_DRAW, XML_MASTER_PAGE_NAME,
+                            EncodeStyleName( xMasterNamed->getName()) );
+                    }
+                }
+            }
+
+            // presentation:page-layout-name
+            if( IsImpress() && !maDrawPagesAutoLayoutNames[nPageInd+1].isEmpty())
+            {
+                AddAttribute(XML_NAMESPACE_PRESENTATION, XML_PRESENTATION_PAGE_LAYOUT_NAME, maDrawPagesAutoLayoutNames[nPageInd+1] );
+            }
+
+            Reference< beans::XPropertySet > xProps( xDrawPage, UNO_QUERY );
+            if( xProps.is() )
+            {
+                try
+                {
+                    OUString aBookmarkURL;
+                    xProps->getPropertyValue("BookmarkURL") >>= aBookmarkURL;
+
+                    if( !aBookmarkURL.isEmpty() )
+                    {
+                        sal_Int32 nIndex = aBookmarkURL.lastIndexOf( '#' );
+                        if( nIndex != -1 )
+                        {
+                            OUString aFileName( aBookmarkURL.copy( 0, nIndex ) );
+                            std::u16string_view aBookmarkName( aBookmarkURL.subView( nIndex+1 ) );
+
+                            aBookmarkURL = GetRelativeReference( aFileName ) + "#" + aBookmarkName;
+                        }
+
+                        AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, aBookmarkURL);
+                        AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+                        AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_REPLACE );
+                        AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONREQUEST );
+                    }
+                }
+                catch(const Exception&)
+                {
+                    OSL_FAIL(" no \"BookmarkURL\" property at page?" );
+                }
+            }
+
+            if( IsImpress() )
+                ImplExportHeaderFooterDeclAttributes( maDrawPagesHeaderFooterSettings[nPageInd] );
+
+            OUString sNavigationOrder( getNavigationOrder( xDrawPage ) );
+            if( !sNavigationOrder.isEmpty() )
+                AddAttribute ( XML_NAMESPACE_DRAW, XML_NAV_ORDER, sNavigationOrder );
+
+            rtl::Reference< xmloff::AnimationsExporter >  xAnimationsExporter;
+            uno::Reference< css::animations::XAnimationNodeSupplier > xAnimNodeSupplier;
+
+            // prepare animation export
+            if(IsImpress())
+            {
+                if( getExportFlags() & SvXMLExportFlags::OASIS )
+                {
+                    // export new animations for oasis format
+                    xAnimNodeSupplier.set( xDrawPage, UNO_QUERY );
+
+                    // prepare animations exporter if impress
+                    if(xAnimNodeSupplier.is())
+                    {
+                        xAnimationsExporter = new xmloff::AnimationsExporter( *this, xProps );
+                        xAnimationsExporter->prepare( xAnimNodeSupplier->getAnimationNode() );
+                    }
+                }
+                else
+                {
+                    // export old animations for ooo format
+                    rtl::Reference< XMLAnimationsExporter > xAnimExport = new XMLAnimationsExporter();
+                    GetShapeExport()->setAnimationsExporter( xAnimExport );
+                }
+            }
+
+            // write draw:id
+            const OUString aPageId = getInterfaceToIdentifierMapper().getIdentifier( xDrawPage );
+            if( !aPageId.isEmpty() )
+            {
+                AddAttributeIdLegacy(XML_NAMESPACE_DRAW, aPageId);
+            }
+
+            // write page
+            SvXMLElementExport aDPG(*this, XML_NAMESPACE_DRAW, XML_PAGE, true, true);
+
+            // write optional office:forms
+            exportFormsElement( xDrawPage );
+
+            // write graphic objects on this page (if any)
+            if(xDrawPage.is() && xDrawPage->getCount())
+                GetShapeExport()->exportShapes( xDrawPage );
+
+            // write animations and presentation notes (ONLY if presentation)
+            if(IsImpress())
+            {
+                if(xAnimNodeSupplier.is())
+                {
+                    xAnimationsExporter->exportAnimations( xAnimNodeSupplier->getAnimationNode() );
+                }
+                else
+                {
+                    // animations
+                    rtl::Reference< XMLAnimationsExporter > xAnimExport( GetShapeExport()->getAnimationsExporter() );
+                    if( xAnimExport.is() )
+                        xAnimExport->exportAnimations( *this );
+
+                    xAnimExport = nullptr;
+                    GetShapeExport()->setAnimationsExporter( xAnimExport );
+                }
+
+                // presentations
+                Reference< presentation::XPresentationPage > xPresPage(xDrawPage, UNO_QUERY);
+                if(xPresPage.is())
+                {
+                    Reference< XDrawPage > xNotesPage(xPresPage->getNotesPage());
+                    if(xNotesPage.is())
+                    {
+                        if( !maDrawNotesPagesStyleNames[nPageInd].isEmpty() )
+                            AddAttribute(XML_NAMESPACE_DRAW, XML_STYLE_NAME, maDrawNotesPagesStyleNames[nPageInd]);
+
+                        ImplExportHeaderFooterDeclAttributes( maDrawNotesPagesHeaderFooterSettings[nPageInd] );
+
+                        // write presentation notes
+                        SvXMLElementExport aPSY(*this, XML_NAMESPACE_PRESENTATION, XML_NOTES, true, true);
+
+                        // write optional office:forms
+                        exportFormsElement( xNotesPage );
+
+                        // write shapes per se
+                        GetShapeExport()->exportShapes( xNotesPage );
+                    }
+                }
+            }
+
+            exportAnnotations( xDrawPage );
+        }
+    }
+
+    if( IsImpress() )
+        exportPresentationSettings();
+}
+
+void SdXMLExport::exportPresentationSettings()
+{
+    try
+    {
+        Reference< XPresentationSupplier > xPresSupplier( GetModel(), UNO_QUERY );
+        if( !xPresSupplier.is() )
+            return;
+
+        Reference< XPropertySet > xPresProps( xPresSupplier->getPresentation(), UNO_QUERY );
+        if( !xPresProps.is() )
+            return;
+
+        bool bHasAttr = false;
+
+        bool bTemp = false;
+
+        // export range
+        xPresProps->getPropertyValue("IsShowAll") >>= bTemp;
+        if( !bTemp )
+        {
+            OUString aFirstPage;
+            xPresProps->getPropertyValue("FirstPage") >>= aFirstPage;
+            if( !aFirstPage.isEmpty() )
+            {
+                AddAttribute(XML_NAMESPACE_PRESENTATION, XML_START_PAGE, aFirstPage );
+                bHasAttr = true;
+            }
+            else
+            {
+                OUString aCustomShow;
+                xPresProps->getPropertyValue("CustomShow") >>= aCustomShow;
+                if( !aCustomShow.isEmpty() )
+                {
+                    AddAttribute(XML_NAMESPACE_PRESENTATION, XML_SHOW, aCustomShow );
+                    bHasAttr = true;
+                }
+            }
+        }
+
+        xPresProps->getPropertyValue("IsEndless") >>= bTemp;
+        if( bTemp )
+        {
+            AddAttribute(XML_NAMESPACE_PRESENTATION, XML_ENDLESS, XML_TRUE );
+            bHasAttr = true;
+
+            sal_Int32 nPause = 0;
+            xPresProps->getPropertyValue("Pause") >>= nPause;
+
+            util::Duration aDuration;
+            aDuration.Seconds = static_cast<sal_uInt16>(nPause);
+
+            OUStringBuffer aOut;
+            ::sax::Converter::convertDuration(aOut, aDuration);
+            AddAttribute(XML_NAMESPACE_PRESENTATION, XML_PAUSE, aOut.makeStringAndClear() );
+        }
+
+        xPresProps->getPropertyValue("AllowAnimations") >>= bTemp;
+        if( !bTemp )
+        {
+            AddAttribute(XML_NAMESPACE_PRESENTATION, XML_ANIMATIONS, XML_DISABLED );
+            bHasAttr = true;
+        }
+
+        xPresProps->getPropertyValue("IsAlwaysOnTop") >>= bTemp;
+        if( bTemp )
+        {
+            AddAttribute(XML_NAMESPACE_PRESENTATION, XML_STAY_ON_TOP, XML_TRUE );
+            bHasAttr = true;
+        }
+
+        xPresProps->getPropertyValue("IsAutomatic") >>= bTemp;
+        if( bTemp )
+        {
+            AddAttribute(XML_NAMESPACE_PRESENTATION, XML_FORCE_MANUAL, XML_TRUE );
+            bHasAttr = true;
+        }
+
+        xPresProps->getPropertyValue("IsFullScreen") >>= bTemp;
+        if( !bTemp )
+        {
+            AddAttribute(XML_NAMESPACE_PRESENTATION, XML_FULL_SCREEN, XML_FALSE );
+            bHasAttr = true;
+        }
+
+        // We need to always export this attribute, because the import had the wrong default (tdf#108824)
+        xPresProps->getPropertyValue("IsMouseVisible") >>= bTemp;
+        AddAttribute(XML_NAMESPACE_PRESENTATION, XML_MOUSE_VISIBLE, bTemp ? XML_TRUE : XML_FALSE);
+        bHasAttr = true;
+
+        xPresProps->getPropertyValue("StartWithNavigator") >>= bTemp;
+        if( bTemp )
+        {
+            AddAttribute(XML_NAMESPACE_PRESENTATION, XML_START_WITH_NAVIGATOR, XML_TRUE );
+            bHasAttr = true;
+        }
+
+        xPresProps->getPropertyValue("UsePen") >>= bTemp;
+        if( bTemp )
+        {
+            AddAttribute(XML_NAMESPACE_PRESENTATION, XML_MOUSE_AS_PEN, XML_TRUE );
+            bHasAttr = true;
+        }
+
+        xPresProps->getPropertyValue("IsTransitionOnClick") >>= bTemp;
+        if( !bTemp )
+        {
+            AddAttribute(XML_NAMESPACE_PRESENTATION, XML_TRANSITION_ON_CLICK, XML_DISABLED );
+            bHasAttr = true;
+        }
+
+        xPresProps->getPropertyValue("IsShowLogo") >>= bTemp;
+        if( bTemp )
+        {
+            AddAttribute(XML_NAMESPACE_PRESENTATION, XML_SHOW_LOGO, XML_TRUE );
+            bHasAttr = true;
+        }
+
+        Reference< container::XNameContainer > xShows;
+        Sequence< OUString > aShowNames;
+        bool bHasNames = false;
+
+        Reference< XCustomPresentationSupplier > xSup( GetModel(), UNO_QUERY );
+        if( xSup.is() )
+        {
+            xShows = xSup->getCustomPresentations();
+            if( xShows.is() )
+            {
+                aShowNames = xShows->getElementNames();
+                bHasNames = aShowNames.hasElements();
+            }
+        }
+
+        if( bHasAttr || bHasNames )
+        {
+            SvXMLElementExport aSettings(*this, XML_NAMESPACE_PRESENTATION, XML_SETTINGS, true, true);
+
+            if( !bHasNames )
+                return;
+
+            Reference< XIndexContainer > xShow;
+            Reference< XNamed > xPageName;
+
+            OUStringBuffer sTmp;
+
+            for( const auto& rShowName : std::as_const(aShowNames) )
+            {
+                AddAttribute(XML_NAMESPACE_PRESENTATION, XML_NAME, rShowName );
+
+                xShows->getByName( rShowName ) >>= xShow;
+                SAL_WARN_IF( !xShow.is(), "xmloff", "invalid custom show!" );
+                if( !xShow.is() )
+                    continue;
+
+                const sal_Int32 nPageCount = xShow->getCount();
+                for( sal_Int32 nPage = 0; nPage < nPageCount; nPage++ )
+                {
+                    xShow->getByIndex( nPage ) >>= xPageName;
+
+                    if( !xPageName.is() )
+                        continue;
+
+                    if( !sTmp.isEmpty() )
+                        sTmp.append(  ',' );
+                    sTmp.append( xPageName->getName() );
+
+                }
+
+                if( !sTmp.isEmpty() )
+                    AddAttribute(XML_NAMESPACE_PRESENTATION, XML_PAGES, sTmp.makeStringAndClear() );
+
+                SvXMLElementExport aShows(*this, XML_NAMESPACE_PRESENTATION, XML_SHOW, true, true);
+            }
+        }
+    }
+    catch(const uno::Exception&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw", "while exporting <presentation:settings>");
+    }
+}
+
+void SdXMLExport::ExportStyles_(bool bUsed)
+{
+    GetPropertySetMapper()->SetAutoStyles( false );
+
+    // export fill styles
+    SvXMLExport::ExportStyles_( bUsed );
+
+    // write draw:style-name for object graphic-styles
+    GetShapeExport()->ExportGraphicDefaults();
+
+    // do not export in ODF 1.1 or older
+    if (getSaneDefaultVersion() >= SvtSaveOptions::ODFSVER_012)
+        GetShapeExport()->GetShapeTableExport()->exportTableStyles();
+
+    // write presentation styles
+    ImpWritePresentationStyles();
+
+    // prepare draw:auto-layout-name for page export
+    ImpPrepAutoLayoutInfos();
+
+    // write draw:auto-layout-name for page export
+    ImpWriteAutoLayoutInfos();
+
+    Reference< beans::XPropertySet > xInfoSet( getExportInfo() );
+    if( xInfoSet.is() )
+    {
+        Reference< beans::XPropertySetInfo > xInfoSetInfo( xInfoSet->getPropertySetInfo() );
+
+        if( xInfoSetInfo->hasPropertyByName( gsPageLayoutNames ) )
+        {
+            xInfoSet->setPropertyValue( gsPageLayoutNames, Any(maDrawPagesAutoLayoutNames) );
+        }
+    }
+}
+
+void SdXMLExport::collectAutoStyles()
+{
+    SvXMLExport::collectAutoStyles();
+    if (mbAutoStylesCollected)
+        return;
+
+    Reference< beans::XPropertySet > xInfoSet( getExportInfo() );
+    if( xInfoSet.is() )
+    {
+        Reference< beans::XPropertySetInfo > xInfoSetInfo( xInfoSet->getPropertySetInfo() );
+
+        if( xInfoSetInfo->hasPropertyByName( gsPageLayoutNames ) )
+        {
+            xInfoSet->getPropertyValue( gsPageLayoutNames ) >>= maDrawPagesAutoLayoutNames;
+        }
+    }
+
+    GetPropertySetMapper()->SetAutoStyles( true );
+
+    if( getExportFlags() & SvXMLExportFlags::STYLES )
+    {
+        // #80012# PageMaster export moved from _ExportStyles
+        // prepare page-master infos
+        ImpPrepPageMasterInfos();
+
+        // prepare draw:style-name for master page export
+        ImpPrepMasterPageInfos();
+    }
+
+    if( getExportFlags() & SvXMLExportFlags::CONTENT )
+    {
+        // prepare draw:style-name for page export
+        ImpPrepDrawPageInfos();
+    }
+
+    if( getExportFlags() & SvXMLExportFlags::STYLES )
+    {
+        // create auto style infos for shapes on master handout page
+        if( IsImpress() )
+        {
+            Reference< presentation::XHandoutMasterSupplier > xHandoutSupp( GetModel(), UNO_QUERY );
+            if( xHandoutSupp.is() )
+            {
+                Reference< XDrawPage > xHandoutPage( xHandoutSupp->getHandoutMasterPage() );
+                if( xHandoutPage.is() && xHandoutPage->getCount())
+                    GetShapeExport()->collectShapesAutoStyles( xHandoutPage );
+            }
+        }
+
+        // create auto style infos for objects on master pages
+        for(sal_Int32 nMPageId(0); nMPageId < mnDocMasterPageCount; nMPageId++)
+        {
+            Reference< XDrawPage > xMasterPage(mxDocMasterPages->getByIndex(nMPageId), UNO_QUERY );
+
+            if( xMasterPage.is() )
+            {
+                // collect layer information
+                GetFormExport()->examineForms( xMasterPage );
+
+                // get MasterPage Name
+                OUString aMasterPageNamePrefix;
+                Reference < container::XNamed > xNamed(xMasterPage, UNO_QUERY);
+                if(xNamed.is())
+                {
+                    aMasterPageNamePrefix = xNamed->getName();
+                }
+                if(!aMasterPageNamePrefix.isEmpty())
+                {
+                    aMasterPageNamePrefix += "-";
+                }
+                GetShapeExport()->setPresentationStylePrefix( aMasterPageNamePrefix );
+
+                if(xMasterPage.is() && xMasterPage->getCount())
+                    GetShapeExport()->collectShapesAutoStyles( xMasterPage );
+
+                if(IsImpress())
+                {
+                    Reference< presentation::XPresentationPage > xPresPage(xMasterPage, UNO_QUERY);
+                    if(xPresPage.is())
+                    {
+                        Reference< XDrawPage > xNotesPage(xPresPage->getNotesPage());
+                        if(xNotesPage.is())
+                        {
+                            // collect layer information
+                            GetFormExport()->examineForms( xNotesPage );
+
+                            if(xNotesPage->getCount())
+                                GetShapeExport()->collectShapesAutoStyles( xNotesPage );
+                        }
+                    }
+                }
+                collectAnnotationAutoStyles(xMasterPage);
+            }
+        }
+    }
+
+    if( getExportFlags() & SvXMLExportFlags::CONTENT )
+    {
+        // prepare animations exporter if impress
+        if(IsImpress() && (!(getExportFlags() & SvXMLExportFlags::OASIS)) )
+        {
+            rtl::Reference< XMLAnimationsExporter > xAnimExport = new XMLAnimationsExporter();
+            GetShapeExport()->setAnimationsExporter( xAnimExport );
+        }
+
+        // create auto style infos for objects on pages
+        for(sal_Int32 nPageInd(0); nPageInd < mnDocDrawPageCount; nPageInd++)
+        {
+            Reference<XDrawPage> xDrawPage( mxDocDrawPages->getByIndex(nPageInd), UNO_QUERY );
+            if( xDrawPage.is() )
+            {
+                // collect layer information
+                GetFormExport()->examineForms( xDrawPage );
+
+                // get MasterPage Name
+                OUString aMasterPageNamePrefix;
+                Reference < drawing::XMasterPageTarget > xMasterPageInt(xDrawPage, UNO_QUERY);
+                if(xMasterPageInt.is())
+                {
+                    Reference<XDrawPage> xUsedMasterPage(xMasterPageInt->getMasterPage());
+                    if(xUsedMasterPage.is())
+                    {
+                        Reference < container::XNamed > xMasterNamed(xUsedMasterPage, UNO_QUERY);
+                        if(xMasterNamed.is())
+                        {
+                            aMasterPageNamePrefix = xMasterNamed->getName();
+                        }
+                    }
+                }
+                if(!aMasterPageNamePrefix.isEmpty())
+                {
+                    aMasterPageNamePrefix += "-";
+                }
+
+                GetShapeExport()->setPresentationStylePrefix( aMasterPageNamePrefix );
+
+                // prepare object infos
+                if(xDrawPage.is() && xDrawPage->getCount())
+                    GetShapeExport()->collectShapesAutoStyles( xDrawPage );
+
+                // prepare presentation notes page object infos (ONLY if presentation)
+                if(IsImpress())
+                {
+                    Reference< presentation::XPresentationPage > xPresPage(xDrawPage, UNO_QUERY);
+                    if(xPresPage.is())
+                    {
+                        Reference< XDrawPage > xNotesPage(xPresPage->getNotesPage());
+                        if(xNotesPage.is())
+                        {
+                            // collect layer information
+                            GetFormExport()->examineForms( xNotesPage );
+
+                            if(xNotesPage->getCount())
+                                GetShapeExport()->collectShapesAutoStyles( xNotesPage );
+                        }
+                    }
+                }
+
+                collectAnnotationAutoStyles( xDrawPage );
+            }
+        }
+        if (IsImpress())
+        {
+            rtl::Reference< XMLAnimationsExporter > xAnimExport;
+            GetShapeExport()->setAnimationsExporter( xAnimExport );
+        }
+    }
+
+    mbAutoStylesCollected = true;
+}
+
+void SdXMLExport::ExportAutoStyles_()
+{
+    collectAutoStyles();
+
+    if( getExportFlags() & SvXMLExportFlags::STYLES )
+    {
+        // write page-master infos
+        ImpWritePageMasterInfos();
+    }
+
+    // export draw-page styles
+    GetAutoStylePool()->exportXML( XmlStyleFamily::SD_DRAWINGPAGE_ID );
+
+    exportAutoDataStyles();
+
+    GetShapeExport()->exportAutoStyles();
+
+    SvXMLExportFlags nContentAutostyles = SvXMLExportFlags::CONTENT | SvXMLExportFlags::AUTOSTYLES;
+    if ( ( getExportFlags() & nContentAutostyles ) == nContentAutostyles )
+        GetFormExport()->exportAutoStyles( );
+
+    // ...for text
+    GetTextParagraphExport()->exportTextAutoStyles();
+}
+
+void SdXMLExport::ExportMasterStyles_()
+{
+    // export layer
+    SdXMLayerExporter::exportLayer( *this );
+
+    // export handout master page if impress
+    if( IsImpress() )
+    {
+        Reference< presentation::XHandoutMasterSupplier > xHandoutSupp( GetModel(), UNO_QUERY );
+        if( xHandoutSupp.is() )
+        {
+            Reference< XDrawPage > xHandoutPage( xHandoutSupp->getHandoutMasterPage() );
+            if( xHandoutPage.is() )
+            {
+                // presentation:page-layout-name
+                if( IsImpress() && !maDrawPagesAutoLayoutNames[0].isEmpty())
+                {
+                    AddAttribute(XML_NAMESPACE_PRESENTATION, XML_PRESENTATION_PAGE_LAYOUT_NAME, EncodeStyleName( maDrawPagesAutoLayoutNames[0] ));
+                }
+
+                ImpXMLEXPPageMasterInfo* pInfo = mpHandoutPageMaster;
+                if(pInfo)
+                {
+                    const OUString& sString = pInfo->GetName();
+                    AddAttribute(XML_NAMESPACE_STYLE, XML_PAGE_LAYOUT_NAME, sString );
+                }
+
+                // draw:style-name
+                if( !maHandoutMasterStyleName.isEmpty() )
+                    AddAttribute(XML_NAMESPACE_DRAW, XML_STYLE_NAME, maHandoutMasterStyleName);
+
+                ImplExportHeaderFooterDeclAttributes( maHandoutPageHeaderFooterSettings );
+
+                // write masterpage
+                SvXMLElementExport aMPG(*this, XML_NAMESPACE_STYLE, XML_HANDOUT_MASTER, true, true);
+
+                // write graphic objects on this master page (if any)
+                if(xHandoutPage.is() && xHandoutPage->getCount())
+                    GetShapeExport()->exportShapes( xHandoutPage );
+            }
+        }
+    }
+
+    // export MasterPages in master-styles section
+    for (sal_Int32 nMPageId = 0; nMPageId < mnDocMasterPageCount; nMPageId++)
+    {
+        Reference< XDrawPage > xMasterPage( mxDocMasterPages->getByIndex(nMPageId), UNO_QUERY );
+        if(xMasterPage.is())
+        {
+            // prepare masterpage attributes
+            Reference < container::XNamed > xNamed(xMasterPage, UNO_QUERY);
+            if(xNamed.is())
+            {
+                bool bEncoded = false;
+                OUString sMasterPageName = xNamed->getName();
+                AddAttribute(XML_NAMESPACE_STYLE, XML_NAME,
+                    EncodeStyleName( sMasterPageName, &bEncoded ));
+                if( bEncoded )
+                    AddAttribute(
+                        XML_NAMESPACE_STYLE, XML_DISPLAY_NAME,
+                        sMasterPageName );
+            }
+
+            ImpXMLEXPPageMasterInfo* pInfo = mvPageMasterUsageList.at( nMPageId );
+            if(pInfo)
+            {
+                const OUString& sString = pInfo->GetName();
+                AddAttribute(XML_NAMESPACE_STYLE, XML_PAGE_LAYOUT_NAME, sString );
+            }
+
+            // draw:style-name (background attributes)
+            if( !maMasterPagesStyleNames[nMPageId].isEmpty() )
+                AddAttribute(XML_NAMESPACE_DRAW, XML_STYLE_NAME,
+                        maMasterPagesStyleNames[nMPageId]);
+
+            // write masterpage
+            SvXMLElementExport aMPG(*this, XML_NAMESPACE_STYLE, XML_MASTER_PAGE, true, true);
+
+            // write optional office:forms
+            exportFormsElement( xMasterPage );
+
+            // write optional loext:theme
+            if (IsImpress())
+            {
+                ExportThemeElement(xMasterPage);
+            }
+
+            // write graphic objects on this master page (if any)
+            if(xMasterPage.is() && xMasterPage->getCount())
+                GetShapeExport()->exportShapes( xMasterPage );
+
+            // write presentation notes (ONLY if presentation)
+            if(IsImpress())
+            {
+                Reference< presentation::XPresentationPage > xPresPage(xMasterPage, UNO_QUERY);
+                if(xPresPage.is())
+                {
+                    Reference< XDrawPage > xNotesPage(xPresPage->getNotesPage());
+                    if(xNotesPage.is())
+                    {
+                        ImpXMLEXPPageMasterInfo* pMasterInfo = mvNotesPageMasterUsageList.at( nMPageId );
+                        if(pMasterInfo)
+                        {
+                            const OUString& sString = pMasterInfo->GetName();
+                            AddAttribute(XML_NAMESPACE_STYLE, XML_PAGE_LAYOUT_NAME, sString);
+                        }
+
+                        // write presentation notes
+                        SvXMLElementExport aPSY(*this, XML_NAMESPACE_PRESENTATION, XML_NOTES, true, true);
+
+                        // write optional office:forms
+                        exportFormsElement( xNotesPage );
+
+                        // write shapes per se
+                        GetShapeExport()->exportShapes( xNotesPage );
+                    }
+                }
+            }
+            exportAnnotations( xMasterPage );
+        }
+    }
+}
+
+void SdXMLExport::exportFormsElement( const Reference< XDrawPage >& xDrawPage )
+{
+    if( !xDrawPage.is() )
+        return;
+
+    Reference< form::XFormsSupplier2 > xFormsSupplier( xDrawPage, UNO_QUERY );
+    if ( xFormsSupplier.is() && xFormsSupplier->hasForms() )
+    {
+        // write masterpage
+        ::xmloff::OOfficeFormsExport aForms(*this);
+        GetFormExport()->exportForms( xDrawPage );
+    }
+
+    if(! GetFormExport()->seekPage( xDrawPage ) )
+    {
+        OSL_FAIL( "OFormLayerXMLExport::seekPage failed!" );
+    }
+}
+
+void SdXMLExport::ExportThemeElement(const uno::Reference<drawing::XDrawPage>& xDrawPage)
+{
+    uno::Reference<beans::XPropertySet> xPropertySet(xDrawPage, uno::UNO_QUERY);
+    if (!xPropertySet.is())
+        return;
+
+    comphelper::SequenceAsHashMap aMap(xPropertySet->getPropertyValue("Theme"));
+    if (aMap.empty())
+    {
+        return;
+    }
+
+    if ((getSaneDefaultVersion() & SvtSaveOptions::ODFSVER_EXTENDED) == 0)
+    {
+        // Do not export in standard ODF 1.3 or older.
+        return;
+    }
+
+    auto it = aMap.find("Name");
+    if (it != aMap.end())
+    {
+        OUString aName;
+        it->second >>= aName;
+        AddAttribute(XML_NAMESPACE_LO_EXT, XML_NAME, aName);
+    }
+    SvXMLElementExport aTheme(*this, XML_NAMESPACE_LO_EXT, XML_THEME, true, true);
+
+    uno::Sequence<util::Color> aColors;
+    it = aMap.find("ColorScheme");
+    if (it != aMap.end())
+    {
+        it->second >>= aColors;
+    }
+    if (!aColors.hasElements())
+    {
+        return;
+    }
+
+    it = aMap.find("ColorSchemeName");
+    if (it != aMap.end())
+    {
+        OUString aName;
+        it->second >>= aName;
+        AddAttribute(XML_NAMESPACE_LO_EXT, XML_NAME, aName);
+    }
+    SvXMLElementExport aColorTable(*this, XML_NAMESPACE_LO_EXT, XML_COLOR_TABLE, true, true);
+
+    static const XMLTokenEnum aColorTokens[] = {
+        XML_DK1, // Background 1
+        XML_LT1, // Text 1
+        XML_DK2, // Background 2
+        XML_LT2, // Text 2
+        XML_ACCENT1,
+        XML_ACCENT2,
+        XML_ACCENT3,
+        XML_ACCENT4,
+        XML_ACCENT5,
+        XML_ACCENT6,
+        XML_HLINK, // Hyperlink
+        XML_FOLHLINK, // Followed hyperlink
+    };
+    for (size_t nColor = 0; nColor < aColors.size(); ++nColor)
+    {
+        // Import goes via svx::Theme::FromAny(), which sanitizes user input.
+        assert(nColor < SAL_N_ELEMENTS(aColorTokens));
+
+        AddAttribute(XML_NAMESPACE_LO_EXT, XML_NAME, GetXMLToken(aColorTokens[nColor]));
+
+        OUStringBuffer sValue;
+        sax::Converter::convertColor(sValue, aColors[nColor]);
+        AddAttribute(XML_NAMESPACE_LO_EXT, XML_COLOR, sValue.makeStringAndClear());
+
+        SvXMLElementExport aColor(*this, XML_NAMESPACE_LO_EXT, XML_COLOR, true, true);
+    }
+}
+
+void SdXMLExport::GetViewSettings(uno::Sequence<beans::PropertyValue>& rProps)
+{
+    Reference< beans::XPropertySet > xPropSet( GetModel(), UNO_QUERY );
+    if( !xPropSet.is() )
+        return;
+
+    awt::Rectangle aVisArea;
+    xPropSet->getPropertyValue("VisibleArea") >>= aVisArea;
+
+    rProps.realloc(4);
+    beans::PropertyValue* pProps = rProps.getArray();
+
+    pProps[0].Name = "VisibleAreaTop";
+    pProps[0].Value <<= aVisArea.Y;
+    pProps[1].Name = "VisibleAreaLeft";
+    pProps[1].Value <<= aVisArea.X;
+    pProps[2].Name = "VisibleAreaWidth";
+    pProps[2].Value <<= aVisArea.Width;
+    pProps[3].Name = "VisibleAreaHeight";
+    pProps[3].Value <<= aVisArea.Height;
+
+}
+
+void SdXMLExport::GetConfigurationSettings(uno::Sequence<beans::PropertyValue>& rProps)
+{
+    Reference< lang::XMultiServiceFactory > xFac( GetModel(), UNO_QUERY );
+    if( !xFac.is() )
+        return;
+
+    Reference< beans::XPropertySet > xProps( xFac->createInstance("com.sun.star.document.Settings"), UNO_QUERY );
+    if( xProps.is() )
+        SvXMLUnitConverter::convertPropertySet( rProps, xProps );
+    DocumentSettingsSerializer *pFilter(dynamic_cast<DocumentSettingsSerializer *>(xProps.get()));
+    if (!pFilter)
+        return;
+    const uno::Reference< embed::XStorage > xStorage(GetTargetStorage());
+    if (!xStorage.is())
+        return;
+    rProps = pFilter->filterStreamsToStorage(xStorage, rProps);
+}
+
+void SdXMLExport::addDataStyle(const sal_Int32 nNumberFormat, bool bTimeFormat )
+{
+    sal_Int32 nFormat = nNumberFormat;
+    if( (nNumberFormat > 1) && (nNumberFormat <= 0x0f) )
+        nFormat -= 2;
+
+    if( bTimeFormat )
+    {
+        maUsedTimeStyles.insert( nFormat );
+    }
+    else
+    {
+        maUsedDateStyles.insert( nFormat );
+    }
+}
+
+void SdXMLExport::exportDataStyles()
+{
+    // there are no data styles to export in draw/impress yet
+}
+
+void SdXMLExport::exportAutoDataStyles()
+{
+    for( const auto& rUsedDateStyle : maUsedDateStyles )
+        SdXMLNumberStylesExporter::exportDateStyle( *this, rUsedDateStyle );
+
+    for( const auto& rUsedTimeStyle : maUsedTimeStyles )
+        SdXMLNumberStylesExporter::exportTimeStyle( *this, rUsedTimeStyle );
+
+    if(HasFormExport())
+        GetFormExport()->exportAutoControlNumberStyles();
+}
+
+OUString SdXMLExport::getDataStyleName(const sal_Int32 nNumberFormat, bool bTimeFormat ) const
+{
+    if( bTimeFormat )
+    {
+        return SdXMLNumberStylesExporter::getTimeStyleName( nNumberFormat );
+    }
+    else
+    {
+        return SdXMLNumberStylesExporter::getDateStyleName( nNumberFormat );
+    }
+}
+
+OUString SdXMLExport::getNavigationOrder( const Reference< XDrawPage >& xDrawPage )
+{
+    OUStringBuffer sNavOrder;
+    try
+    {
+        Reference< XPropertySet > xSet( xDrawPage, UNO_QUERY_THROW );
+        Reference< XIndexAccess > xNavOrder( xSet->getPropertyValue("NavigationOrder"), UNO_QUERY_THROW );
+
+        Reference< XIndexAccess > xZOrderAccess = xDrawPage;
+
+        // only export navigation order if it is different from the z-order
+        if( (xNavOrder.get() != xZOrderAccess.get()) && (xNavOrder->getCount() == xDrawPage->getCount())  )
+        {
+            sal_Int32 nIndex;
+            const sal_Int32 nCount = xNavOrder->getCount();
+            for( nIndex = 0; nIndex < nCount; ++nIndex )
+            {
+                OUString sId( getInterfaceToIdentifierMapper().registerReference( Reference< XInterface >( xNavOrder->getByIndex( nIndex ), UNO_QUERY ) ) );
+                if( !sId.isEmpty() )
+                {
+                    if( !sNavOrder.isEmpty() )
+                        sNavOrder.append( ' ' );
+                    sNavOrder.append( sId );
+                }
+            }
+        }
+    }
+    catch(const Exception&)
+    {
+    }
+    return sNavOrder.makeStringAndClear();
+}
+
+void SdXMLExport::collectAnnotationAutoStyles( const Reference<XDrawPage>& xDrawPage )
+{
+    Reference< XAnnotationAccess > xAnnotationAccess( xDrawPage, UNO_QUERY );
+    if( !xAnnotationAccess.is() ) return;
+
+    try
+    {
+        Reference< XAnnotationEnumeration > xAnnotationEnumeration( xAnnotationAccess->createAnnotationEnumeration() );
+        if( xAnnotationEnumeration.is() )
+        {
+            while( xAnnotationEnumeration->hasMoreElements() )
+            {
+                Reference< XAnnotation > xAnnotation( xAnnotationEnumeration->nextElement(), UNO_SET_THROW );
+                Reference< XText > xText( xAnnotation->getTextRange() );
+                if(xText.is() && !xText->getString().isEmpty())
+                    GetTextParagraphExport()->collectTextAutoStyles( xText );
+            }
+        }
+    }
+    catch(const Exception&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw",
+                             "exception caught during export of annotation auto styles");
+    }
+}
+
+void SdXMLExport::exportAnnotations( const Reference<XDrawPage>& xDrawPage )
+{
+    // do not export in standard ODF 1.3 or older
+    if ((getSaneDefaultVersion() & SvtSaveOptions::ODFSVER_EXTENDED) == 0)
+    {
+        return;
+    }
+
+    Reference< XAnnotationAccess > xAnnotationAccess( xDrawPage, UNO_QUERY );
+    if( !xAnnotationAccess.is() )
+        return;
+
+    try
+    {
+        Reference< XAnnotationEnumeration > xAnnotationEnumeration( xAnnotationAccess->createAnnotationEnumeration() );
+        if( xAnnotationEnumeration.is() && xAnnotationEnumeration->hasMoreElements() )
+        {
+            bool bRemovePersonalInfo = SvtSecurityOptions::IsOptionSet(
+                SvtSecurityOptions::EOption::DocWarnRemovePersonalInfo );
+
+            OUStringBuffer sStringBuffer;
+            do
+            {
+                Reference< XAnnotation > xAnnotation( xAnnotationEnumeration->nextElement(), UNO_SET_THROW );
+
+                RealPoint2D aPosition( xAnnotation->getPosition() );
+
+                GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                        static_cast<sal_Int32>( aPosition.X * 100 ) );
+                AddAttribute(XML_NAMESPACE_SVG, XML_X, sStringBuffer.makeStringAndClear());
+
+                GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                        static_cast<sal_Int32>( aPosition.Y * 100 ) );
+                AddAttribute(XML_NAMESPACE_SVG, XML_Y, sStringBuffer.makeStringAndClear());
+
+                RealSize2D aSize( xAnnotation->getSize() );
+
+                if( aSize.Width || aSize.Height )
+                {
+                    GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                            static_cast<sal_Int32>( aSize.Width * 100 ) );
+                    AddAttribute(XML_NAMESPACE_SVG, XML_WIDTH, sStringBuffer.makeStringAndClear());
+                    GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                            static_cast<sal_Int32>( aSize.Height * 100 ) );
+                    AddAttribute(XML_NAMESPACE_SVG, XML_HEIGHT, sStringBuffer.makeStringAndClear());
+                }
+
+                // annotation element + content
+                SvXMLElementExport aElem(*this, XML_NAMESPACE_OFFICE_EXT, XML_ANNOTATION, false, true);
+
+                // author
+                OUString aAuthor( xAnnotation->getAuthor() );
+                if( !aAuthor.isEmpty() )
+                {
+                    SvXMLElementExport aCreatorElem( *this, XML_NAMESPACE_DC, XML_CREATOR, true, false );
+                    Characters( bRemovePersonalInfo
+                            ? "Author" + OUString::number( SvXMLExport::GetInfoID(aAuthor) )
+                            : aAuthor );
+                }
+
+                // initials
+                OUString aInitials( xAnnotation->getInitials() );
+                if( !aInitials.isEmpty() )
+                {
+                    // OFFICE-3776 export meta:creator-initials for ODF 1.3
+                    SvXMLElementExport aInitialsElem( *this,
+                            (SvtSaveOptions::ODFSVER_013 <= getSaneDefaultVersion())
+                                ? XML_NAMESPACE_META
+                                : XML_NAMESPACE_LO_EXT,
+                            (SvtSaveOptions::ODFSVER_013 <= getSaneDefaultVersion())
+                                ? XML_CREATOR_INITIALS
+                                : XML_SENDER_INITIALS,
+                            true, false );
+                    Characters( bRemovePersonalInfo
+                            ? OUString::number( SvXMLExport::GetInfoID(aInitials) )
+                            : aInitials );
+                }
+
+                {
+                    // date time
+                    css::util::DateTime aDate( bRemovePersonalInfo
+                            ? css::util::DateTime(0, 0, 0, 0, 1, 1, 1970, true) // Epoch time
+                            : xAnnotation->getDateTime() );
+                    ::sax::Converter::convertDateTime(sStringBuffer, aDate, nullptr, true);
+                    SvXMLElementExport aDateElem( *this, XML_NAMESPACE_DC, XML_DATE, true, false );
+                    Characters( sStringBuffer.makeStringAndClear() );
+                }
+
+                css::uno::Reference < css::text::XText > xText( xAnnotation->getTextRange() );
+                if( xText.is() )
+                    GetTextParagraphExport()->exportText( xText );
+            }
+            while( xAnnotationEnumeration->hasMoreElements() );
+        }
+    }
+    catch(const Exception&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw", "exception caught during export of annotations");
+    }
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Impress_XMLOasisExporter_get_implementation(
+    uno::XComponentContext* pCtx, uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(new SdXMLExport(
+        pCtx, "XMLImpressExportOasis", false,
+        SvXMLExportFlags::OASIS | SvXMLExportFlags::META | SvXMLExportFlags::STYLES
+            | SvXMLExportFlags::MASTERSTYLES | SvXMLExportFlags::AUTOSTYLES
+            | SvXMLExportFlags::CONTENT | SvXMLExportFlags::SCRIPTS | SvXMLExportFlags::SETTINGS
+            | SvXMLExportFlags::FONTDECLS | SvXMLExportFlags::EMBEDDED));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Impress_XMLOasisStylesExporter_get_implementation(
+    uno::XComponentContext* pCtx, uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(new SdXMLExport(
+        pCtx, "XMLImpressStylesExportOasis", false,
+        SvXMLExportFlags::OASIS | SvXMLExportFlags::STYLES | SvXMLExportFlags::MASTERSTYLES
+            | SvXMLExportFlags::AUTOSTYLES | SvXMLExportFlags::FONTDECLS));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Impress_XMLOasisContentExporter_get_implementation(
+    uno::XComponentContext* pCtx, uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(new SdXMLExport(pCtx, "XMLImpressContentExportOasis", false,
+                                         SvXMLExportFlags::OASIS | SvXMLExportFlags::AUTOSTYLES
+                                             | SvXMLExportFlags::CONTENT | SvXMLExportFlags::SCRIPTS
+                                             | SvXMLExportFlags::FONTDECLS));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Impress_XMLOasisMetaExporter_get_implementation(
+    uno::XComponentContext* pCtx, uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(new SdXMLExport(pCtx, "XMLImpressMetaExportOasis", false,
+                                         SvXMLExportFlags::OASIS | SvXMLExportFlags::META));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Impress_XMLOasisSettingsExporter_get_implementation(
+    uno::XComponentContext* pCtx, uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(new SdXMLExport(pCtx, "XMLImpressSettingsExportOasis", false,
+                                         SvXMLExportFlags::OASIS | SvXMLExportFlags::SETTINGS));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Impress_XMLExporter_get_implementation(uno::XComponentContext* pCtx,
+                                                         uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(new SdXMLExport(
+        pCtx, "XMLImpressExportOOO", false,
+        SvXMLExportFlags::META | SvXMLExportFlags::STYLES | SvXMLExportFlags::MASTERSTYLES
+            | SvXMLExportFlags::AUTOSTYLES | SvXMLExportFlags::CONTENT | SvXMLExportFlags::SCRIPTS
+            | SvXMLExportFlags::SETTINGS | SvXMLExportFlags::FONTDECLS
+            | SvXMLExportFlags::EMBEDDED));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Draw_XMLExporter_get_implementation(uno::XComponentContext* pCtx,
+                                                      uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(new SdXMLExport(
+        pCtx, "XMLDrawExportOOO", true,
+        SvXMLExportFlags::META | SvXMLExportFlags::STYLES | SvXMLExportFlags::MASTERSTYLES
+            | SvXMLExportFlags::AUTOSTYLES | SvXMLExportFlags::CONTENT | SvXMLExportFlags::SCRIPTS
+            | SvXMLExportFlags::SETTINGS | SvXMLExportFlags::FONTDECLS
+            | SvXMLExportFlags::EMBEDDED));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Draw_XMLOasisSettingsExporter_get_implementation(
+    uno::XComponentContext* pCtx, uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(new SdXMLExport(pCtx, "XMLDrawSettingsExportOasis", true,
+                                         SvXMLExportFlags::OASIS | SvXMLExportFlags::SETTINGS));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Draw_XMLOasisMetaExporter_get_implementation(
+    uno::XComponentContext* pCtx, uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(new SdXMLExport(pCtx, "XMLDrawMetaExportOasis", true,
+                                         SvXMLExportFlags::OASIS | SvXMLExportFlags::META));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Draw_XMLOasisContentExporter_get_implementation(
+    uno::XComponentContext* pCtx, uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(new SdXMLExport(pCtx, "XMLDrawContentExportOasis", true,
+                                         SvXMLExportFlags::OASIS | SvXMLExportFlags::AUTOSTYLES
+                                             | SvXMLExportFlags::CONTENT | SvXMLExportFlags::SCRIPTS
+                                             | SvXMLExportFlags::FONTDECLS));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Draw_XMLOasisStylesExporter_get_implementation(
+    uno::XComponentContext* pCtx, uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(new SdXMLExport(
+        pCtx, "XMLDrawStylesExportOasis", true,
+        SvXMLExportFlags::OASIS | SvXMLExportFlags::STYLES | SvXMLExportFlags::MASTERSTYLES
+            | SvXMLExportFlags::AUTOSTYLES | SvXMLExportFlags::FONTDECLS));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Draw_XMLOasisExporter_get_implementation(uno::XComponentContext* pCtx,
+                                                           uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(new SdXMLExport(
+        pCtx, "XMLDrawExportOasis", true,
+        SvXMLExportFlags::OASIS | SvXMLExportFlags::META | SvXMLExportFlags::STYLES
+            | SvXMLExportFlags::MASTERSTYLES | SvXMLExportFlags::AUTOSTYLES
+            | SvXMLExportFlags::CONTENT | SvXMLExportFlags::SCRIPTS | SvXMLExportFlags::SETTINGS
+            | SvXMLExportFlags::FONTDECLS | SvXMLExportFlags::EMBEDDED));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_DrawingLayer_XMLExporter_get_implementation(
+    uno::XComponentContext* pCtx, uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(
+        new SdXMLExport(pCtx, "XMLDrawingLayerExport", true,
+                        SvXMLExportFlags::OASIS | SvXMLExportFlags::STYLES
+                            | SvXMLExportFlags::AUTOSTYLES | SvXMLExportFlags::CONTENT
+                            | SvXMLExportFlags::FONTDECLS | SvXMLExportFlags::EMBEDDED));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Impress_XMLClipboardExporter_get_implementation(
+    uno::XComponentContext* pCtx, uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(
+        new SdXMLExport(pCtx, "XMLImpressClipboardExport", /*bIsDraw=*/false,
+                        SvXMLExportFlags::OASIS | SvXMLExportFlags::STYLES
+                            | SvXMLExportFlags::AUTOSTYLES | SvXMLExportFlags::CONTENT
+                            | SvXMLExportFlags::FONTDECLS | SvXMLExportFlags::EMBEDDED));
+}
+
+XMLFontAutoStylePool* SdXMLExport::CreateFontAutoStylePool()
+{
+    bool bEmbedFonts = false;
+    bool bEmbedUsedOnly = false;
+    bool bEmbedLatinScript = true;
+    bool bEmbedAsianScript = true;
+    bool bEmbedComplexScript = true;
+
+    if (getExportFlags() & SvXMLExportFlags::CONTENT)
+    {
+        try
+        {
+            Reference<lang::XMultiServiceFactory> xFactory(GetModel(), UNO_QUERY);
+            Reference<beans::XPropertySet> xProps;
+            Reference<beans::XPropertySetInfo> xInfo;
+
+            if (xFactory.is())
+                xProps.set(xFactory->createInstance("com.sun.star.document.Settings"), UNO_QUERY);
+            if (xProps.is())
+                xInfo =  xProps->getPropertySetInfo();
+            if (xInfo.is() && xProps.is())
+            {
+                if (xInfo->hasPropertyByName("EmbedFonts"))
+                    xProps->getPropertyValue("EmbedFonts") >>= bEmbedFonts;
+                if (xInfo->hasPropertyByName("EmbedOnlyUsedFonts"))
+                    xProps->getPropertyValue("EmbedOnlyUsedFonts") >>= bEmbedUsedOnly;
+                if (xInfo->hasPropertyByName("EmbedLatinScriptFonts"))
+                    xProps->getPropertyValue("EmbedLatinScriptFonts") >>= bEmbedLatinScript;
+                if (xInfo->hasPropertyByName("EmbedAsianScriptFonts"))
+                    xProps->getPropertyValue("EmbedAsianScriptFonts") >>= bEmbedAsianScript;
+                if (xInfo->hasPropertyByName("EmbedComplexScriptFonts"))
+                    xProps->getPropertyValue("EmbedComplexScriptFonts") >>= bEmbedComplexScript;
+            }
+        } catch(...)
+        {
+            // clipboard document doesn't have shell so throws from getPropertyValue
+            // gallery elements may not support com.sun.star.document.Settings so throws from createInstance
+        }
+    }
+
+    XMLFontAutoStylePool *pPool = new XMLFontAutoStylePool( *this, bEmbedFonts );
+    pPool->setEmbedOnlyUsedFonts(bEmbedUsedOnly);
+    pPool->setEmbedFontScripts(bEmbedLatinScript, bEmbedAsianScript, bEmbedComplexScript);
+
+    Reference< beans::XPropertySet > xProps( GetModel(), UNO_QUERY );
+    if ( xProps.is() ) {
+        Sequence<Any> aAnySeq;
+        if( xProps->getPropertyValue("Fonts") >>= aAnySeq )
+        {
+            if( aAnySeq.getLength() % 5 == 0 )
+            {
+                int nLen = aAnySeq.getLength() / 5;
+                int nSeqIndex = 0;
+                for( int i = 0; i < nLen; i++ )
+                {
+                    OUString sFamilyName, sStyleName;
+                    sal_Int16 eFamily(FAMILY_DONTKNOW),
+                        ePitch(PITCH_DONTKNOW),
+                        eCharSet(RTL_TEXTENCODING_DONTKNOW);
+
+                    aAnySeq[nSeqIndex++] >>= sFamilyName;
+                    aAnySeq[nSeqIndex++] >>= sStyleName;
+                    aAnySeq[nSeqIndex++] >>= eFamily;
+                    aAnySeq[nSeqIndex++] >>= ePitch;
+                    aAnySeq[nSeqIndex++] >>= eCharSet;
+
+                    pPool->Add( sFamilyName, sStyleName, FontFamily( eFamily ), FontPitch( ePitch ), rtl_TextEncoding( eCharSet ) );
+                }
+            }
+        }
+    }
+
+    return pPool;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/sdxmlexp_impl.hxx b/xmloff/source/draw/sdxmlexp_impl.hxx
new file mode 100644
index 000000000..9808c7381
--- /dev/null
+++ b/xmloff/source/draw/sdxmlexp_impl.hxx
@@ -0,0 +1,179 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlexp.hxx>
+
+#include <com/sun/star/container/XNameAccess.hpp>
+#include <com/sun/star/drawing/XDrawPage.hpp>
+
+#include <o3tl/sorted_vector.hxx>
+#include <vector>
+
+namespace tools { class Rectangle; }
+
+class ImpXMLEXPPageMasterInfo;
+class ImpXMLAutoLayoutInfo;
+class XMLSdPropHdlFactory;
+class XMLShapeExportPropertyMapper;
+class XMLPageExportPropertyMapper;
+
+typedef ::std::vector< ImpXMLEXPPageMasterInfo* > ImpXMLEXPPageMasterList;
+
+enum XmlPlaceholder
+{
+    XmlPlaceholderTitle,
+    XmlPlaceholderOutline,
+    XmlPlaceholderSubtitle,
+    XmlPlaceholderGraphic,
+    XmlPlaceholderObject,
+    XmlPlaceholderChart,
+    XmlPlaceholderTable,
+    XmlPlaceholderPage,
+    XmlPlaceholderNotes,
+    XmlPlaceholderHandout,
+    XmlPlaceholderVerticalTitle,
+    XmlPlaceholderVerticalOutline
+};
+
+typedef o3tl::sorted_vector<sal_Int32> SdXMLFormatMap;
+
+struct HeaderFooterPageSettingsImpl
+{
+    OUString maStrHeaderDeclName;
+    OUString maStrFooterDeclName;
+    OUString maStrDateTimeDeclName;
+};
+
+struct DateTimeDeclImpl
+{
+    OUString maStrText;
+    bool mbFixed;
+    sal_Int32 mnFormat;
+};
+
+class SdXMLExport : public SvXMLExport
+{
+    css::uno::Reference< css::container::XNameAccess > mxDocStyleFamilies;
+    css::uno::Reference< css::container::XIndexAccess > mxDocMasterPages;
+    css::uno::Reference< css::container::XIndexAccess > mxDocDrawPages;
+    sal_Int32                   mnDocMasterPageCount;
+    sal_Int32                   mnDocDrawPageCount;
+    sal_uInt32                  mnObjectCount;
+
+    // temporary infos
+    std::vector< std::unique_ptr<ImpXMLEXPPageMasterInfo> > mvPageMasterInfoList;
+    ImpXMLEXPPageMasterList     mvPageMasterUsageList;
+    ImpXMLEXPPageMasterList     mvNotesPageMasterUsageList;
+    ImpXMLEXPPageMasterInfo*    mpHandoutPageMaster;
+    std::vector< std::unique_ptr<ImpXMLAutoLayoutInfo> >    mvAutoLayoutInfoList;
+
+    css::uno::Sequence< OUString > maDrawPagesAutoLayoutNames;
+
+    ::std::vector< OUString >        maDrawPagesStyleNames;
+    ::std::vector< OUString >        maDrawNotesPagesStyleNames;
+    ::std::vector< OUString >        maMasterPagesStyleNames;
+    OUString                         maHandoutMasterStyleName;
+    ::std::vector< HeaderFooterPageSettingsImpl >   maDrawPagesHeaderFooterSettings;
+    ::std::vector< HeaderFooterPageSettingsImpl >   maDrawNotesPagesHeaderFooterSettings;
+
+    ::std::vector< OUString >        maHeaderDeclsVector;
+    ::std::vector< OUString >        maFooterDeclsVector;
+    ::std::vector< DateTimeDeclImpl >       maDateTimeDeclsVector;
+
+    HeaderFooterPageSettingsImpl            maHandoutPageHeaderFooterSettings;
+
+    rtl::Reference<XMLSdPropHdlFactory>          mpSdPropHdlFactory;
+    rtl::Reference<XMLShapeExportPropertyMapper> mpPropertySetMapper;
+    rtl::Reference<XMLPageExportPropertyMapper>  mpPresPagePropsMapper;
+
+    SdXMLFormatMap  maUsedDateStyles;           // this is a vector with the used formattings for date fields
+    SdXMLFormatMap  maUsedTimeStyles;           // this is a vector with the used formattings for time fields
+
+    bool            mbIsDraw;
+
+    virtual void ExportStyles_(bool bUsed) override;
+    virtual void ExportAutoStyles_() override;
+    virtual void ExportFontDecls_() override;
+    virtual void ExportMasterStyles_() override;
+    virtual void ExportContent_() override;
+    virtual void ExportMeta_() override;
+
+    ImpXMLEXPPageMasterInfo* ImpGetOrCreatePageMasterInfo( const css::uno::Reference< css::drawing::XDrawPage >& xMasterPage );
+    void ImpPrepPageMasterInfos();
+    void ImpWritePageMasterInfos();
+    void ImpPrepAutoLayoutInfos();
+    HeaderFooterPageSettingsImpl ImpPrepDrawPageHeaderFooterDecls( const css::uno::Reference< css::drawing::XDrawPage >& xDrawPage );
+    ImpXMLEXPPageMasterInfo* ImpGetPageMasterInfoByName(std::u16string_view rName);
+
+    void ImpPrepDrawPageInfos();
+    void ImpPrepMasterPageInfos();
+    void ImpWritePresentationStyles();
+    OUString ImpCreatePresPageStyleName( const css::uno::Reference<css::drawing::XDrawPage>& xDrawPage, bool bExportBackground = true );
+
+    bool ImpPrepAutoLayoutInfo(const css::uno::Reference< css::drawing::XDrawPage >& xPage, OUString& rName);
+    void ImpWriteAutoLayoutInfos();
+    void ImpWriteAutoLayoutPlaceholder(XmlPlaceholder ePl, const tools::Rectangle& rRect);
+    void ImpWriteHeaderFooterDecls();
+    void ImplExportHeaderFooterDeclAttributes( const HeaderFooterPageSettingsImpl& aSettings );
+
+    void exportFormsElement( const css::uno::Reference< css::drawing::XDrawPage >& xDrawPage );
+    void ExportThemeElement(const css::uno::Reference<css::drawing::XDrawPage>& xDrawPage);
+    void exportPresentationSettings();
+
+    // #82003# helper function for recursive object count
+    sal_uInt32 ImpRecursiveObjectCount( const css::uno::Reference< css::drawing::XShapes >& xShapes);
+
+    OUString getNavigationOrder( const css::uno::Reference< css::drawing::XDrawPage >& xDrawPage );
+
+    void collectAnnotationAutoStyles( const css::uno::Reference< css::drawing::XDrawPage >& xDrawPage );
+    void exportAnnotations( const css::uno::Reference< css::drawing::XDrawPage >& xDrawPage );
+
+protected:
+    virtual void GetViewSettings(css::uno::Sequence<css::beans::PropertyValue>& aProps) override;
+    virtual void GetConfigurationSettings(css::uno::Sequence<css::beans::PropertyValue>& aProps) override;
+    virtual XMLFontAutoStylePool* CreateFontAutoStylePool() override;
+
+public:
+    SdXMLExport(
+        const css::uno::Reference< css::uno::XComponentContext >& xContext,
+        OUString const & implementationName,
+        bool bIsDraw, SvXMLExportFlags nExportFlags );
+    virtual ~SdXMLExport() override;
+
+    void collectAutoStyles() override;
+
+    // XExporter
+    virtual void SAL_CALL setSourceDocument( const css::uno::Reference< css::lang::XComponent >& xDoc ) override;
+
+    // get factories and mappers
+    XMLShapeExportPropertyMapper* GetPropertySetMapper() const { return mpPropertySetMapper.get(); }
+    XMLPageExportPropertyMapper* GetPresPagePropsMapper() const { return mpPresPagePropsMapper.get(); }
+
+    bool IsDraw() const { return mbIsDraw; }
+    bool IsImpress() const { return !mbIsDraw; }
+
+    virtual void addDataStyle(const sal_Int32 nNumberFormat, bool bTimeFormat = false ) override;
+    virtual void exportDataStyles() override;
+    virtual void exportAutoDataStyles() override;
+    virtual OUString getDataStyleName(const sal_Int32 nNumberFormat, bool bTimeFormat = false ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/sdxmlimp.cxx b/xmloff/source/draw/sdxmlimp.cxx
new file mode 100644
index 000000000..6ffc71405
--- /dev/null
+++ b/xmloff/source/draw/sdxmlimp.cxx
@@ -0,0 +1,663 @@
+/* -*- 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 <osl/thread.h>
+#include <sal/log.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/sequence.hxx>
+
+#include <xmloff/xmlscripti.hxx>
+#include "sdxmlimp_impl.hxx"
+#include "ximpbody.hxx"
+
+#include <xmloff/xmlmetai.hxx>
+#include "ximpstyl.hxx"
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/DocumentSettingsContext.hxx>
+#include <com/sun/star/awt/Rectangle.hpp>
+#include <com/sun/star/form/XFormsSupplier.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
+#include <com/sun/star/drawing/XMasterPagesSupplier.hpp>
+#include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
+#include <xmloff/settingsstore.hxx>
+#include <xmloff/ProgressBarHelper.hxx>
+
+#include <xmloff/XMLFontStylesContext.hxx>
+
+#include <com/sun/star/document/XDocumentProperties.hpp>
+#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+namespace {
+
+class SdXMLBodyContext_Impl : public SvXMLImportContext
+{
+    SdXMLImport& GetSdImport() { return static_cast<SdXMLImport&>(GetImport()); }
+
+public:
+
+    SdXMLBodyContext_Impl( SdXMLImport& rImport );
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+                sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+};
+
+}
+
+SdXMLBodyContext_Impl::SdXMLBodyContext_Impl( SdXMLImport& rImport ) :
+    SvXMLImportContext( rImport )
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLBodyContext_Impl::createFastChildContext(
+        sal_Int32 /*nElement*/,
+        const uno::Reference< xml::sax::XFastAttributeList > & /*xAttrList*/ )
+{
+    return new SdXMLBodyContext(GetSdImport());
+}
+
+namespace {
+
+// NB: virtually inherit so we can multiply inherit properly
+//     in SdXMLFlatDocContext_Impl
+class SdXMLDocContext_Impl : public virtual SvXMLImportContext
+{
+protected:
+    SdXMLImport& GetSdImport() { return static_cast<SdXMLImport&>(GetImport()); }
+
+public:
+    SdXMLDocContext_Impl( SdXMLImport& rImport );
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+};
+
+}
+
+SdXMLDocContext_Impl::SdXMLDocContext_Impl(
+    SdXMLImport& rImport )
+:   SvXMLImportContext(rImport)
+{
+}
+
+uno::Reference< xml::sax::XFastContextHandler > SAL_CALL SdXMLDocContext_Impl::createFastChildContext(
+    sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& /*xAttrList*/ )
+{
+    switch (nElement)
+    {
+        case XML_ELEMENT(OFFICE, XML_SCRIPTS):
+        {
+            if( GetImport().getImportFlags() & SvXMLImportFlags::SCRIPTS )
+            {
+                // office:script inside office:document
+                return new XMLScriptContext( GetSdImport(), GetSdImport().GetModel() );
+            }
+            break;
+        }
+        case XML_ELEMENT(OFFICE, XML_MASTER_STYLES):
+        {
+            if( GetImport().getImportFlags() & SvXMLImportFlags::MASTERSTYLES )
+            {
+                // office:master-styles inside office:document
+                return GetSdImport().CreateMasterStylesContext();
+            }
+            break;
+        }
+        case XML_ELEMENT(OFFICE, XML_BODY):
+        {
+            if( GetImport().getImportFlags() & SvXMLImportFlags::CONTENT )
+            {
+                // office:body inside office:document
+                return new SdXMLBodyContext_Impl(GetSdImport());
+            }
+            break;
+        }
+        case XML_ELEMENT(OFFICE, XML_SETTINGS):
+        {
+            if( GetImport().getImportFlags() & SvXMLImportFlags::SETTINGS )
+            {
+                return new XMLDocumentSettingsContext(GetImport());
+            }
+            break;
+        }
+        case XML_ELEMENT(OFFICE, XML_STYLES):
+        {
+            if( GetImport().getImportFlags() & SvXMLImportFlags::STYLES )
+            {
+                // office:styles inside office:document
+                return GetSdImport().CreateStylesContext();
+            }
+            break;
+        }
+        case XML_ELEMENT(OFFICE, XML_AUTOMATIC_STYLES):
+        {
+            if( GetImport().getImportFlags() & SvXMLImportFlags::AUTOSTYLES )
+            {
+                // office:automatic-styles inside office:document
+                return GetSdImport().CreateAutoStylesContext();
+            }
+            break;
+        }
+        case XML_ELEMENT(OFFICE, XML_FONT_FACE_DECLS):
+        {
+            return GetSdImport().CreateFontDeclsContext();
+        }
+        case XML_ELEMENT(OFFICE, XML_META):
+        {
+            SAL_INFO("xmloff.draw", "XML_ELEMENT(OFFICE, XML_META): should not have come here, maybe document is invalid?");
+            break;
+        }
+    }
+    return nullptr;
+}
+
+namespace {
+
+// context for flat file xml format
+class SdXMLFlatDocContext_Impl
+    : public SdXMLDocContext_Impl, public SvXMLMetaDocumentContext
+{
+public:
+    SdXMLFlatDocContext_Impl( SdXMLImport& i_rImport,
+        const uno::Reference<document::XDocumentProperties>& i_xDocProps );
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+};
+
+}
+
+SdXMLFlatDocContext_Impl::SdXMLFlatDocContext_Impl( SdXMLImport& i_rImport,
+        const uno::Reference<document::XDocumentProperties>& i_xDocProps) :
+    SvXMLImportContext(i_rImport),
+    SdXMLDocContext_Impl(i_rImport),
+    SvXMLMetaDocumentContext(i_rImport, i_xDocProps)
+{
+}
+
+uno::Reference< xml::sax::XFastContextHandler > SAL_CALL SdXMLFlatDocContext_Impl::createFastChildContext(
+    sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
+{
+    // behave like meta base class iff we encounter office:meta
+    if ( nElement == XML_ELEMENT( OFFICE, XML_META ) ) {
+        return SvXMLMetaDocumentContext::createFastChildContext(
+                    nElement, xAttrList );
+    } else {
+        return SdXMLDocContext_Impl::createFastChildContext(
+                    nElement, xAttrList );
+    }
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Impress_XMLOasisImporter_get_implementation(
+    uno::XComponentContext* pCtx, uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(
+        new SdXMLImport(pCtx, "XMLImpressImportOasis", false, SvXMLImportFlags::ALL));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Draw_XMLOasisImporter_get_implementation(uno::XComponentContext* pCtx,
+                                                           uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(new SdXMLImport(pCtx, "XMLDrawImportOasis", true, SvXMLImportFlags::ALL));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Draw_XMLOasisStylesImporter_get_implementation(uno::XComponentContext* pCtx,
+                                                           uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(new SdXMLImport(pCtx, "XMLDrawStylesImportOasis", true,
+                                         SvXMLImportFlags::STYLES | SvXMLImportFlags::AUTOSTYLES
+                                             | SvXMLImportFlags::MASTERSTYLES));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Draw_XMLOasisContentImporter_get_implementation(
+    uno::XComponentContext* pCtx, uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(new SdXMLImport(pCtx, "XMLDrawContentImportOasis", true,
+                                         SvXMLImportFlags::AUTOSTYLES | SvXMLImportFlags::CONTENT
+                                             | SvXMLImportFlags::SCRIPTS
+                                             | SvXMLImportFlags::FONTDECLS));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Draw_XMLOasisMetaImporter_get_implementation(
+    uno::XComponentContext* pCtx, uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(
+        new SdXMLImport(pCtx, "XMLDrawMetaImportOasis", true, SvXMLImportFlags::META));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Draw_XMLOasisSettingsImporter_get_implementation(
+    uno::XComponentContext* pCtx, uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(
+        new SdXMLImport(pCtx, "XMLDrawSettingsImportOasis", true, SvXMLImportFlags::SETTINGS));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Impress_XMLOasisStylesImporter_get_implementation(
+    uno::XComponentContext* pCtx, uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(new SdXMLImport(pCtx, "XMLImpressStylesImportOasis", false,
+                                         SvXMLImportFlags::STYLES | SvXMLImportFlags::AUTOSTYLES
+                                             | SvXMLImportFlags::MASTERSTYLES));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Impress_XMLOasisContentImporter_get_implementation(
+    uno::XComponentContext* pCtx, uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(new SdXMLImport(pCtx, "XMLImpressContentImportOasis", false,
+                                         SvXMLImportFlags::AUTOSTYLES | SvXMLImportFlags::CONTENT
+                                             | SvXMLImportFlags::SCRIPTS
+                                             | SvXMLImportFlags::FONTDECLS));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Impress_XMLOasisMetaImporter_get_implementation(
+    uno::XComponentContext* pCtx, uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(
+        new SdXMLImport(pCtx, "XMLImpressMetaImportOasis", false, SvXMLImportFlags::META));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Impress_XMLOasisSettingsImporter_get_implementation(
+    uno::XComponentContext* pCtx, uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(
+        new SdXMLImport(pCtx, "XMLImpressSettingsImportOasis", false, SvXMLImportFlags::SETTINGS));
+}
+
+SdXMLImport::SdXMLImport(
+    const css::uno::Reference< css::uno::XComponentContext >& xContext,
+    OUString const & implementationName,
+    bool bIsDraw, SvXMLImportFlags nImportFlags )
+:   SvXMLImport( xContext, implementationName, nImportFlags ),
+    mnNewPageCount(0),
+    mnNewMasterPageCount(0),
+    mbIsDraw(bIsDraw),
+    mbLoadDoc(true),
+    mbPreview(false)
+{
+    // add namespaces
+    GetNamespaceMap().Add(
+        GetXMLToken(XML_NP_PRESENTATION),
+        GetXMLToken(XML_N_PRESENTATION),
+        XML_NAMESPACE_PRESENTATION);
+
+    GetNamespaceMap().Add(
+        GetXMLToken(XML_NP_SMIL),
+        GetXMLToken(XML_N_SMIL_COMPAT),
+        XML_NAMESPACE_SMIL);
+}
+
+// XImporter
+void SAL_CALL SdXMLImport::setTargetDocument( const uno::Reference< lang::XComponent >& xDoc )
+{
+    SvXMLImport::setTargetDocument( xDoc );
+
+    uno::Reference< lang::XServiceInfo > xDocServices( GetModel(), uno::UNO_QUERY );
+    if( !xDocServices.is() )
+        throw lang::IllegalArgumentException();
+
+    mbIsDraw = !xDocServices->supportsService("com.sun.star.presentation.PresentationDocument");
+
+    // prepare access to styles
+    uno::Reference< style::XStyleFamiliesSupplier > xFamSup( GetModel(), uno::UNO_QUERY );
+    if(xFamSup.is())
+        mxDocStyleFamilies = xFamSup->getStyleFamilies();
+
+    // prepare access to master pages
+    uno::Reference < drawing::XMasterPagesSupplier > xMasterPagesSupplier(GetModel(), uno::UNO_QUERY);
+    if(xMasterPagesSupplier.is())
+        mxDocMasterPages = xMasterPagesSupplier->getMasterPages();
+
+    // prepare access to draw pages
+    uno::Reference <drawing::XDrawPagesSupplier> xDrawPagesSupplier(GetModel(), uno::UNO_QUERY);
+    if(!xDrawPagesSupplier.is())
+        throw lang::IllegalArgumentException();
+
+    mxDocDrawPages = xDrawPagesSupplier->getDrawPages();
+    if(!mxDocDrawPages.is())
+        throw lang::IllegalArgumentException();
+
+    if( mxDocDrawPages.is() && mxDocDrawPages->getCount() > 0 )
+    {
+        uno::Reference< form::XFormsSupplier > xFormsSupp;
+        mxDocDrawPages->getByIndex(0) >>= xFormsSupp;
+        mbIsFormsSupported = xFormsSupp.is();
+    }
+
+    // #88546# enable progress bar increments, SdXMLImport is only used for
+    // draw/impress import
+    GetShapeImport()->enableHandleProgressBar();
+
+    uno::Reference< lang::XMultiServiceFactory > xFac( GetModel(), uno::UNO_QUERY );
+    if( xFac.is() )
+    {
+        uno::Sequence< OUString > sSNS( xFac->getAvailableServiceNames() );
+        if (comphelper::findValue(sSNS, "com.sun.star.drawing.TableShape") != -1)
+            mbIsTableShapeSupported = true;
+    }
+}
+
+// XInitialization
+void SAL_CALL SdXMLImport::initialize( const uno::Sequence< uno::Any >& aArguments )
+{
+    SvXMLImport::initialize( aArguments );
+
+    uno::Reference< beans::XPropertySet > xInfoSet( getImportInfo() );
+    if( !xInfoSet.is() )
+        return;
+
+    uno::Reference< beans::XPropertySetInfo > xInfoSetInfo( xInfoSet->getPropertySetInfo() );
+
+    if( xInfoSetInfo->hasPropertyByName( gsPageLayouts ) )
+        xInfoSet->getPropertyValue( gsPageLayouts ) >>= mxPageLayouts;
+
+    if( xInfoSetInfo->hasPropertyByName( gsPreview ) )
+        xInfoSet->getPropertyValue( gsPreview ) >>= mbPreview;
+
+    OUString const sOrganizerMode(
+        "OrganizerMode");
+    if (xInfoSetInfo->hasPropertyByName(sOrganizerMode))
+    {
+        bool bStyleOnly(false);
+        if (xInfoSet->getPropertyValue(sOrganizerMode) >>= bStyleOnly)
+        {
+            mbLoadDoc = !bStyleOnly;
+        }
+    }
+}
+
+SvXMLImportContext *SdXMLImport::CreateFastContext( sal_Int32 nElement,
+        const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
+{
+    SvXMLImportContext* pContext = nullptr;
+
+    switch (nElement)
+    {
+        case XML_ELEMENT( OFFICE, XML_DOCUMENT_STYLES ):
+        case XML_ELEMENT( OFFICE, XML_DOCUMENT_CONTENT ):
+        case XML_ELEMENT( OFFICE, XML_DOCUMENT_SETTINGS ):
+            pContext = new SdXMLDocContext_Impl(*this);
+        break;
+        case XML_ELEMENT( OFFICE, XML_DOCUMENT_META ):
+            pContext = CreateMetaContext(nElement, xAttrList);
+        break;
+        case XML_ELEMENT( OFFICE, XML_DOCUMENT ):
+        {
+            uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
+                GetModel(), uno::UNO_QUERY_THROW);
+            // flat OpenDocument file format
+            pContext = new SdXMLFlatDocContext_Impl( *this, xDPS->getDocumentProperties());
+        }
+        break;
+    }
+    return pContext;
+}
+
+SvXMLImportContext *SdXMLImport::CreateMetaContext(const sal_Int32 /*nElement*/,
+    const uno::Reference<xml::sax::XFastAttributeList>&)
+{
+    SvXMLImportContext* pContext = nullptr;
+
+    if (getImportFlags() & SvXMLImportFlags::META)
+    {
+        uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
+            GetModel(), uno::UNO_QUERY_THROW);
+        uno::Reference<document::XDocumentProperties> const xDocProps(
+            !mbLoadDoc ? nullptr : xDPS->getDocumentProperties());
+        pContext = new SvXMLMetaDocumentContext(*this, xDocProps);
+    }
+
+    return pContext;
+}
+
+SvXMLStylesContext *SdXMLImport::CreateStylesContext()
+{
+    if(GetShapeImport()->GetStylesContext())
+        return GetShapeImport()->GetStylesContext();
+
+    GetShapeImport()->SetStylesContext(new SdXMLStylesContext(
+        *this, false));
+
+    return GetShapeImport()->GetStylesContext();
+}
+
+SvXMLStylesContext *SdXMLImport::CreateAutoStylesContext()
+{
+    if(GetShapeImport()->GetAutoStylesContext())
+        return GetShapeImport()->GetAutoStylesContext();
+
+    GetShapeImport()->SetAutoStylesContext(new SdXMLStylesContext(
+        *this, true));
+
+    return GetShapeImport()->GetAutoStylesContext();
+}
+
+SvXMLImportContext* SdXMLImport::CreateMasterStylesContext()
+{
+    if (!mxMasterStylesContext.is())
+        mxMasterStylesContext.set(new SdXMLMasterStylesContext(*this));
+    return mxMasterStylesContext.get();
+}
+
+SvXMLImportContext *SdXMLImport::CreateFontDeclsContext()
+{
+    XMLFontStylesContext *pFSContext =
+            new XMLFontStylesContext( *this, osl_getThreadTextEncoding() );
+    SetFontDecls( pFSContext );
+    return pFSContext;
+}
+
+void SdXMLImport::SetViewSettings(const css::uno::Sequence<css::beans::PropertyValue>& aViewProps)
+{
+    uno::Reference< beans::XPropertySet > xPropSet( GetModel(), uno::UNO_QUERY );
+    if( !xPropSet.is() )
+        return;
+
+    awt::Rectangle aVisArea( 0,0, 28000, 21000 );
+
+    for( const auto& rViewProp : aViewProps )
+    {
+        const OUString& rName = rViewProp.Name;
+        const uno::Any rValue = rViewProp.Value;
+
+        if ( rName == "VisibleAreaTop" )
+        {
+            rValue >>= aVisArea.Y;
+        }
+        else if ( rName == "VisibleAreaLeft" )
+        {
+            rValue >>= aVisArea.X;
+        }
+        else if ( rName == "VisibleAreaWidth" )
+        {
+            rValue >>= aVisArea.Width;
+        }
+        else if ( rName == "VisibleAreaHeight" )
+        {
+            rValue >>= aVisArea.Height;
+        }
+    }
+
+    try
+    {
+        xPropSet->setPropertyValue("VisibleArea", uno::Any( aVisArea )  );
+    }
+    catch(const css::uno::Exception&)
+    {
+/* #i79978# since old documents may contain invalid view settings, this is nothing to worry the user about.
+        SetError( XMLERROR_FLAG_WARNING | XMLERROR_API, {}, e.Message, NULL );
+*/
+    }
+}
+
+void SdXMLImport::SetConfigurationSettings(const css::uno::Sequence<css::beans::PropertyValue>& aConfigProps)
+{
+    uno::Reference< lang::XMultiServiceFactory > xFac( GetModel(), uno::UNO_QUERY );
+    if( !xFac.is() )
+        return;
+
+    uno::Reference< beans::XPropertySet > xProps( xFac->createInstance("com.sun.star.document.Settings"), uno::UNO_QUERY );
+    if( !xProps.is() )
+        return;
+
+    uno::Reference< beans::XPropertySetInfo > xInfo( xProps->getPropertySetInfo() );
+    if( !xInfo.is() )
+        return;
+
+    const uno::Sequence<beans::PropertyValue>* pValues = &aConfigProps;
+
+    DocumentSettingsSerializer *pFilter;
+    pFilter = dynamic_cast<DocumentSettingsSerializer *>(xProps.get());
+    uno::Sequence<beans::PropertyValue> aFiltered;
+    if( pFilter )
+    {
+        aFiltered = pFilter->filterStreamsFromStorage( GetDocumentBase(), GetSourceStorage(), aConfigProps );
+        pValues = &aFiltered;
+    }
+
+    for( const auto& rValue : *pValues )
+    {
+        try
+        {
+            const OUString& rProperty = rValue.Name;
+            if( xInfo->hasPropertyByName( rProperty ) )
+                xProps->setPropertyValue( rProperty, rValue.Value );
+        }
+        catch(const uno::Exception&)
+        {
+            SAL_INFO("xmloff.draw",  "#SdXMLImport::SetConfigurationSettings: Exception!" );
+        }
+    }
+}
+
+// #80365# override this method to read and use the hint value from the
+// written meta information. If no info is found, guess 10 draw objects
+//void SdXMLImport::SetStatisticAttributes(const uno::Reference<xml::sax::XAttributeList>& xAttrList)
+void SdXMLImport::SetStatistics(
+        const uno::Sequence<beans::NamedValue> & i_rStats)
+{
+    static const char* s_stats[] =
+        { "ObjectCount", nullptr };
+
+    SvXMLImport::SetStatistics(i_rStats);
+
+    sal_uInt32 nCount(10);
+    for (const auto& rStat : i_rStats) {
+        for (const char** pStat = s_stats; *pStat != nullptr; ++pStat) {
+            if (rStat.Name.equalsAscii(*pStat)) {
+                sal_Int32 val = 0;
+                if (rStat.Value >>= val) {
+                    nCount = val;
+                } else {
+                    SAL_WARN("xmloff.draw", "SdXMLImport::SetStatistics: invalid entry");
+                }
+            }
+        }
+    }
+
+    if(nCount)
+    {
+        GetProgressBarHelper()->SetReference(nCount);
+        GetProgressBarHelper()->SetValue(0);
+    }
+}
+
+void SdXMLImport::AddHeaderDecl( const OUString& rName, const OUString& rText )
+{
+    if( !rName.isEmpty() && !rText.isEmpty() )
+        maHeaderDeclsMap[rName] = rText;
+}
+
+void SdXMLImport::AddFooterDecl( const OUString& rName, const OUString& rText )
+{
+    if( !rName.isEmpty() && !rText.isEmpty() )
+        maFooterDeclsMap[rName] = rText;
+}
+
+void SdXMLImport::AddDateTimeDecl( const OUString& rName, const OUString& rText, bool bFixed, const OUString& rDateTimeFormat )
+{
+    if( !rName.isEmpty() && (!rText.isEmpty() || !bFixed) )
+    {
+        DateTimeDeclContextImpl aDecl;
+        aDecl.maStrText = rText;
+        aDecl.mbFixed = bFixed;
+        aDecl.maStrDateTimeFormat = rDateTimeFormat;
+        maDateTimeDeclsMap[rName] = aDecl;
+    }
+}
+
+OUString SdXMLImport::GetHeaderDecl( const OUString& rName ) const
+{
+    OUString aRet;
+    HeaderFooterDeclMap::const_iterator aIter( maHeaderDeclsMap.find( rName ) );
+    if( aIter != maHeaderDeclsMap.end() )
+        aRet = (*aIter).second;
+
+    return aRet;
+}
+
+OUString SdXMLImport::GetFooterDecl( const OUString& rName ) const
+{
+    OUString aRet;
+    HeaderFooterDeclMap::const_iterator aIter( maFooterDeclsMap.find( rName ) );
+    if( aIter != maFooterDeclsMap.end() )
+        aRet = (*aIter).second;
+
+    return aRet;
+}
+
+OUString SdXMLImport::GetDateTimeDecl( const OUString& rName, bool& rbFixed, OUString& rDateTimeFormat )
+{
+    DateTimeDeclContextImpl aDecl;
+
+    DateTimeDeclMap::const_iterator aIter( maDateTimeDeclsMap.find( rName ) );
+    if( aIter != maDateTimeDeclsMap.end() )
+        aDecl = (*aIter).second;
+
+    rbFixed = aDecl.mbFixed;
+    rDateTimeFormat = aDecl.maStrDateTimeFormat;
+    return aDecl.maStrText;
+}
+
+void SdXMLImport::NotifyContainsEmbeddedFont()
+{
+    uno::Reference< lang::XMultiServiceFactory > xFac( GetModel(), uno::UNO_QUERY );
+    if( xFac.is() )
+    {
+        uno::Reference< beans::XPropertySet > xProps( xFac->createInstance("com.sun.star.document.Settings"), uno::UNO_QUERY );
+        if( xProps.is() )
+            xProps->setPropertyValue("EmbedFonts", uno::Any( true ) );
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/sdxmlimp_impl.hxx b/xmloff/source/draw/sdxmlimp_impl.hxx
new file mode 100644
index 000000000..924f46a5e
--- /dev/null
+++ b/xmloff/source/draw/sdxmlimp_impl.hxx
@@ -0,0 +1,135 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <com/sun/star/drawing/XDrawPage.hpp>
+#include <com/sun/star/task/XStatusIndicator.hpp>
+#include <xmloff/xmltkmap.hxx>
+#include <com/sun/star/container/XNameAccess.hpp>
+
+#include <map>
+#include <memory>
+#include <vector>
+#include <xmloff/xmlimp.hxx>
+
+class SvXMLUnitConverter;
+class SvXMLTokenMap;
+class SdXMLMasterStylesContext;
+
+struct DateTimeDeclContextImpl
+{
+    OUString maStrText;
+    bool mbFixed;
+    OUString maStrDateTimeFormat;
+
+    DateTimeDeclContextImpl() : mbFixed(true) {}
+};
+
+typedef std::map<OUString, OUString> HeaderFooterDeclMap;
+typedef std::map<OUString, DateTimeDeclContextImpl> DateTimeDeclMap;
+
+class SdXMLImport: public SvXMLImport
+{
+    css::uno::Reference< css::container::XNameAccess > mxDocStyleFamilies;
+    css::uno::Reference< css::container::XIndexAccess > mxDocMasterPages;
+    css::uno::Reference< css::container::XIndexAccess > mxDocDrawPages;
+    css::uno::Reference< css::container::XNameAccess > mxPageLayouts;
+
+    // contexts for Style and AutoStyle import
+    rtl::Reference<SdXMLMasterStylesContext> mxMasterStylesContext;
+
+    sal_Int32                   mnNewPageCount;
+    sal_Int32                   mnNewMasterPageCount;
+
+    bool                        mbIsDraw;
+    bool                        mbLoadDoc;
+    bool                        mbPreview;
+
+    static constexpr OUStringLiteral gsPageLayouts = u"PageLayouts";
+    static constexpr OUStringLiteral gsPreview = u"Preview";
+
+    HeaderFooterDeclMap         maHeaderDeclsMap;
+    HeaderFooterDeclMap         maFooterDeclsMap;
+    DateTimeDeclMap             maDateTimeDeclsMap;
+
+protected:
+
+    // This method is called after the namespace map has been updated, but
+    // before a context for the current element has been pushed.
+    virtual SvXMLImportContext *CreateFastContext( sal_Int32 nElement,
+        const ::css::uno::Reference< ::css::xml::sax::XFastAttributeList >& xAttrList ) override;
+
+public:
+    SdXMLImport(
+        const css::uno::Reference< css::uno::XComponentContext >& xContext,
+        OUString const & implementationName,
+        bool bIsDraw, SvXMLImportFlags nImportFlags );
+
+    // XImporter
+    virtual void SAL_CALL setTargetDocument( const css::uno::Reference< css::lang::XComponent >& xDoc ) override;
+
+    // XInitialization
+    virtual void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any >& aArguments ) override;
+
+    virtual void SetViewSettings(const css::uno::Sequence<css::beans::PropertyValue>& aViewProps) override;
+    virtual void SetConfigurationSettings(const css::uno::Sequence<css::beans::PropertyValue>& aConfigProps) override;
+
+    // namespace office
+    // NB: in contrast to other CreateFooContexts, this particular one handles
+    //     the root element (i.e. office:document-meta)
+    SvXMLImportContext* CreateMetaContext(const sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList);
+    SvXMLStylesContext* CreateStylesContext();
+    SvXMLStylesContext* CreateAutoStylesContext();
+    SvXMLImportContext* CreateMasterStylesContext();
+    SvXMLImportContext *CreateFontDeclsContext();
+
+    // export local parameters concerning page access and similar
+    const css::uno::Reference< css::container::XNameAccess >& GetLocalDocStyleFamilies() const { return mxDocStyleFamilies; }
+    const css::uno::Reference< css::container::XIndexAccess >& GetLocalMasterPages() const { return mxDocMasterPages; }
+    const css::uno::Reference< css::container::XIndexAccess >& GetLocalDrawPages() const { return mxDocDrawPages; }
+
+    sal_Int32 GetNewPageCount() const { return mnNewPageCount; }
+    void IncrementNewPageCount() { mnNewPageCount++; }
+    sal_Int32 GetNewMasterPageCount() const { return mnNewMasterPageCount; }
+    void IncrementNewMasterPageCount() { mnNewMasterPageCount++; }
+
+    const css::uno::Reference< css::container::XNameAccess >& getPageLayouts() const { return mxPageLayouts; }
+
+    bool IsDraw() const { return mbIsDraw; }
+    bool IsImpress() const { return !mbIsDraw; }
+
+    virtual void SetStatistics(
+        const css::uno::Sequence< css::beans::NamedValue> & i_rStats) override;
+
+    bool IsPreview() const { return mbPreview; }
+
+    void AddHeaderDecl( const OUString& rName, const OUString& rText );
+    void AddFooterDecl( const OUString& rName, const OUString& rText );
+    void AddDateTimeDecl( const OUString& rName, const OUString& rText, bool bFixed, const OUString& rDateTimeFormat );
+
+    OUString GetHeaderDecl( const OUString& rName ) const;
+    OUString GetFooterDecl( const OUString& rName ) const;
+    OUString GetDateTimeDecl( const OUString& rName, bool& rbFixed, OUString& rDateTimeFormat );
+
+    virtual void NotifyContainsEmbeddedFont() override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/shapeexport.cxx b/xmloff/source/draw/shapeexport.cxx
new file mode 100644
index 000000000..836721478
--- /dev/null
+++ b/xmloff/source/draw/shapeexport.cxx
@@ -0,0 +1,5196 @@
+/* -*- 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_wasm_strip.h>
+
+#include <basegfx/matrix/b2dhommatrix.hxx>
+#include <basegfx/matrix/b3dhommatrix.hxx>
+#include <basegfx/polygon/b2dpolypolygon.hxx>
+#include <basegfx/polygon/b2dpolypolygontools.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <basegfx/polygon/b3dpolypolygon.hxx>
+#include <basegfx/polygon/b3dpolypolygontools.hxx>
+#include <basegfx/tuple/b2dtuple.hxx>
+#include <basegfx/vector/b3dvector.hxx>
+
+#include <com/sun/star/beans/XPropertyState.hpp>
+#include <com/sun/star/beans/PropertyValues.hpp>
+#include <com/sun/star/container/XChild.hpp>
+#include <com/sun/star/container/XEnumerationAccess.hpp>
+#include <com/sun/star/container/XIdentifierAccess.hpp>
+#include <com/sun/star/container/XNamed.hpp>
+#include <com/sun/star/document/XEventsSupplier.hpp>
+#include <com/sun/star/drawing/Alignment.hpp>
+#include <com/sun/star/drawing/CameraGeometry.hpp>
+#include <com/sun/star/drawing/CircleKind.hpp>
+#include <com/sun/star/drawing/ConnectorType.hpp>
+#include <com/sun/star/drawing/Direction3D.hpp>
+#include <com/sun/star/drawing/EscapeDirection.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeAdjustmentValue.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeGluePointType.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeParameterPair.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeParameterType.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeMetalType.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeSegment.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeSegmentCommand.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeTextFrame.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeTextPathMode.hpp>
+#include <com/sun/star/drawing/GluePoint2.hpp>
+#include <com/sun/star/drawing/HomogenMatrix.hpp>
+#include <com/sun/star/drawing/HomogenMatrix3.hpp>
+#include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
+#include <com/sun/star/drawing/PolyPolygonShape3D.hpp>
+#include <com/sun/star/drawing/Position3D.hpp>
+#include <com/sun/star/drawing/ProjectionMode.hpp>
+#include <com/sun/star/drawing/ShadeMode.hpp>
+#include <com/sun/star/drawing/XControlShape.hpp>
+#include <com/sun/star/drawing/XCustomShapeEngine.hpp>
+#include <com/sun/star/drawing/XGluePointsSupplier.hpp>
+#include <com/sun/star/drawing/BarCode.hpp>
+#include <com/sun/star/drawing/BarCodeErrorCorrection.hpp>
+#include <com/sun/star/drawing/XShapes3.hpp>
+#include <com/sun/star/embed/ElementModes.hpp>
+#include <com/sun/star/embed/XStorage.hpp>
+#include <com/sun/star/embed/XTransactedObject.hpp>
+#include <com/sun/star/graphic/XGraphic.hpp>
+#include <com/sun/star/graphic/GraphicProvider.hpp>
+#include <com/sun/star/graphic/XGraphicProvider.hpp>
+#include <com/sun/star/io/XSeekableInputStream.hpp>
+#include <com/sun/star/io/XStream.hpp>
+#include <com/sun/star/lang/ServiceNotRegisteredException.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/media/ZoomLevel.hpp>
+#include <com/sun/star/presentation/AnimationSpeed.hpp>
+#include <com/sun/star/presentation/ClickAction.hpp>
+#include <com/sun/star/style/XStyle.hpp>
+#include <com/sun/star/table/XColumnRowRange.hpp>
+#include <com/sun/star/text/XText.hpp>
+
+#include <comphelper/classids.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/propertyvalue.hxx>
+#include <comphelper/storagehelper.hxx>
+#include <officecfg/Office/Common.hxx>
+
+#include <o3tl/any.hxx>
+#include <o3tl/typed_flags_set.hxx>
+#include <o3tl/string_view.hxx>
+
+#include <rtl/math.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <rtl/ustring.hxx>
+#include <sal/log.hxx>
+
+#include <sax/tools/converter.hxx>
+
+#include <tools/debug.hxx>
+#include <tools/globname.hxx>
+#include <tools/helpers.hxx>
+#include <tools/diagnose_ex.h>
+#include <vcl/graph.hxx>
+
+#include <xmloff/contextid.hxx>
+#include <xmloff/families.hxx>
+#include <xmloff/namespacemap.hxx>
+#include <xmloff/shapeexport.hxx>
+#include <xmloff/unointerfacetouniqueidentifiermapper.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/table/XMLTableExport.hxx>
+#include <xmloff/ProgressBarHelper.hxx>
+
+#include <anim.hxx>
+#include <EnhancedCustomShapeToken.hxx>
+#include "sdpropls.hxx"
+#include <xexptran.hxx>
+#include "ximpshap.hxx"
+#include <XMLBase64Export.hxx>
+#include <XMLImageMapExport.hxx>
+#include <memory>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::EnhancedCustomShapeToken;
+using namespace ::xmloff::token;
+
+constexpr OUStringLiteral XML_EMBEDDEDOBJECTGRAPHIC_URL_BASE = u"vnd.sun.star.GraphicObject:";
+
+namespace {
+
+bool supportsText(XmlShapeType eShapeType)
+{
+        return eShapeType != XmlShapeTypePresChartShape &&
+        eShapeType != XmlShapeTypePresOLE2Shape &&
+        eShapeType != XmlShapeTypeDrawSheetShape &&
+        eShapeType != XmlShapeTypePresSheetShape &&
+        eShapeType != XmlShapeTypeDraw3DSceneObject &&
+        eShapeType != XmlShapeTypeDraw3DCubeObject &&
+        eShapeType != XmlShapeTypeDraw3DSphereObject &&
+        eShapeType != XmlShapeTypeDraw3DLatheObject &&
+        eShapeType != XmlShapeTypeDraw3DExtrudeObject &&
+        eShapeType != XmlShapeTypeDrawPageShape &&
+        eShapeType != XmlShapeTypePresPageShape &&
+        eShapeType != XmlShapeTypeDrawGroupShape;
+
+}
+
+}
+
+constexpr OUStringLiteral gsZIndex( u"ZOrder" );
+constexpr OUStringLiteral gsPrintable( u"Printable" );
+constexpr OUStringLiteral gsVisible( u"Visible" );
+constexpr OUStringLiteral gsModel( u"Model" );
+constexpr OUStringLiteral gsStartShape( u"StartShape" );
+constexpr OUStringLiteral gsEndShape( u"EndShape" );
+constexpr OUStringLiteral gsOnClick( u"OnClick" );
+constexpr OUStringLiteral gsEventType( u"EventType" );
+constexpr OUStringLiteral gsPresentation( u"Presentation" );
+constexpr OUStringLiteral gsMacroName( u"MacroName" );
+constexpr OUStringLiteral gsScript( u"Script" );
+constexpr OUStringLiteral gsLibrary( u"Library" );
+constexpr OUStringLiteral gsClickAction( u"ClickAction" );
+constexpr OUStringLiteral gsBookmark( u"Bookmark" );
+constexpr OUStringLiteral gsEffect( u"Effect" );
+constexpr OUStringLiteral gsPlayFull( u"PlayFull" );
+constexpr OUStringLiteral gsVerb( u"Verb" );
+constexpr OUStringLiteral gsSoundURL( u"SoundURL" );
+constexpr OUStringLiteral gsSpeed( u"Speed" );
+constexpr OUStringLiteral gsStarBasic( u"StarBasic" );
+constexpr OUStringLiteral gsHyperlink( u"Hyperlink" );
+
+XMLShapeExport::XMLShapeExport(SvXMLExport& rExp,
+                                SvXMLExportPropertyMapper *pExtMapper )
+:   mrExport( rExp ),
+    maCurrentShapesIter(maShapesInfos.end()),
+    mbExportLayer( false ),
+    // #88546# init to sal_False
+    mbHandleProgressBar( false )
+{
+    // construct PropertySetMapper
+    mxPropertySetMapper = CreateShapePropMapper( mrExport );
+    if( pExtMapper )
+    {
+        rtl::Reference < SvXMLExportPropertyMapper > xExtMapper( pExtMapper );
+        mxPropertySetMapper->ChainExportMapper( xExtMapper );
+    }
+
+/*
+    // chain text attributes
+    xPropertySetMapper->ChainExportMapper(XMLTextParagraphExport::CreateParaExtPropMapper(rExp));
+*/
+
+    mrExport.GetAutoStylePool()->AddFamily(
+        XmlStyleFamily::SD_GRAPHICS_ID,
+        XML_STYLE_FAMILY_SD_GRAPHICS_NAME,
+        GetPropertySetMapper(),
+        XML_STYLE_FAMILY_SD_GRAPHICS_PREFIX);
+    mrExport.GetAutoStylePool()->AddFamily(
+        XmlStyleFamily::SD_PRESENTATION_ID,
+        XML_STYLE_FAMILY_SD_PRESENTATION_NAME,
+        GetPropertySetMapper(),
+        XML_STYLE_FAMILY_SD_PRESENTATION_PREFIX);
+
+    // create table export helper and let him add his families in time
+    GetShapeTableExport();
+}
+
+XMLShapeExport::~XMLShapeExport()
+{
+}
+
+// sj: replacing CustomShapes with standard objects that are also supported in OpenOffice.org format
+uno::Reference< drawing::XShape > XMLShapeExport::checkForCustomShapeReplacement( const uno::Reference< drawing::XShape >& xShape )
+{
+    uno::Reference< drawing::XShape > xCustomShapeReplacement;
+
+    if( !( GetExport().getExportFlags() & SvXMLExportFlags::OASIS ) )
+    {
+        OUString aType( xShape->getShapeType() );
+        if( aType == "com.sun.star.drawing.CustomShape" )
+        {
+            uno::Reference< beans::XPropertySet > xSet( xShape, uno::UNO_QUERY );
+            if( xSet.is() )
+            {
+                OUString aEngine;
+                xSet->getPropertyValue("CustomShapeEngine") >>= aEngine;
+                if ( aEngine.isEmpty() )
+                {
+                    aEngine = "com.sun.star.drawing.EnhancedCustomShapeEngine";
+                }
+                uno::Reference< uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
+
+                if ( !aEngine.isEmpty() )
+                {
+                    uno::Sequence< beans::PropertyValue > aPropValues{
+                        comphelper::makePropertyValue("CustomShape", xShape),
+                        comphelper::makePropertyValue("ForceGroupWithText", true)
+                    };
+                    uno::Sequence< uno::Any > aArgument = { uno::Any(aPropValues) };
+                    uno::Reference< uno::XInterface > xInterface(
+                        xContext->getServiceManager()->createInstanceWithArgumentsAndContext(aEngine, aArgument, xContext) );
+                    if ( xInterface.is() )
+                    {
+                        uno::Reference< drawing::XCustomShapeEngine > xCustomShapeEngine(
+                            uno::Reference< drawing::XCustomShapeEngine >( xInterface, uno::UNO_QUERY ) );
+                        if ( xCustomShapeEngine.is() )
+                            xCustomShapeReplacement = xCustomShapeEngine->render();
+                    }
+                }
+            }
+        }
+    }
+    return xCustomShapeReplacement;
+}
+
+// This method collects all automatic styles for the given XShape
+void XMLShapeExport::collectShapeAutoStyles(const uno::Reference< drawing::XShape >& xShape )
+{
+    if( maCurrentShapesIter == maShapesInfos.end() )
+    {
+        OSL_FAIL( "XMLShapeExport::collectShapeAutoStyles(): no call to seekShapes()!" );
+        return;
+    }
+    sal_Int32 nZIndex = 0;
+    uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if( xPropSet.is() )
+        xPropSet->getPropertyValue(gsZIndex) >>= nZIndex;
+
+    ImplXMLShapeExportInfoVector& aShapeInfoVector = (*maCurrentShapesIter).second;
+
+    if( static_cast<sal_Int32>(aShapeInfoVector.size()) <= nZIndex )
+    {
+        OSL_FAIL( "XMLShapeExport::collectShapeAutoStyles(): no shape info allocated for a given shape" );
+        return;
+    }
+
+    ImplXMLShapeExportInfo& aShapeInfo = aShapeInfoVector[nZIndex];
+
+    uno::Reference< drawing::XShape > xCustomShapeReplacement = checkForCustomShapeReplacement( xShape );
+    if ( xCustomShapeReplacement.is() )
+        aShapeInfo.xCustomShapeReplacement = xCustomShapeReplacement;
+
+    // first compute the shapes type
+    ImpCalcShapeType(xShape, aShapeInfo.meShapeType);
+
+    // #i118485# enabled XmlShapeTypeDrawChartShape and XmlShapeTypeDrawOLE2Shape
+    // to have text
+    const bool bObjSupportsText =
+        supportsText(aShapeInfo.meShapeType);
+
+    const bool bObjSupportsStyle =
+        aShapeInfo.meShapeType != XmlShapeTypeDrawGroupShape;
+
+    bool bIsEmptyPresObj = false;
+
+    if ( aShapeInfo.xCustomShapeReplacement.is() )
+        xPropSet.clear();
+
+    // prep text styles
+    if( xPropSet.is() && bObjSupportsText )
+    {
+        uno::Reference< text::XText > xText(xShape, uno::UNO_QUERY);
+        if (xText.is())
+        {
+            try
+            {
+                // tdf#153161: it seems that the call to XTextRange::getString flushes the changes
+                // for some objects, that otherwise fail to get exported correctly. Maybe at some
+                // point it would make sense to find a better place for more targeted flush.
+                xText->getString();
+            }
+            catch (uno::RuntimeException const&)
+            {
+                // E.g., SwXTextFrame that contains only a table will throw; this is not an error
+            }
+
+            uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
+
+            if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName("IsEmptyPresentationObject") )
+            {
+                uno::Any aAny = xPropSet->getPropertyValue("IsEmptyPresentationObject");
+                aAny >>= bIsEmptyPresObj;
+            }
+
+            if(!bIsEmptyPresObj)
+            {
+                GetExport().GetTextParagraphExport()->collectTextAutoStyles( xText );
+            }
+        }
+    }
+
+    // compute the shape parent style
+    if( xPropSet.is() )
+    {
+        uno::Reference< beans::XPropertySetInfo > xPropertySetInfo( xPropSet->getPropertySetInfo() );
+
+        OUString aParentName;
+        uno::Reference< style::XStyle > xStyle;
+
+        if( bObjSupportsStyle )
+        {
+            if( xPropertySetInfo.is() && xPropertySetInfo->hasPropertyByName("Style") )
+                xPropSet->getPropertyValue("Style") >>= xStyle;
+
+            if(xStyle.is())
+            {
+                // get family ID
+                uno::Reference< beans::XPropertySet > xStylePropSet(xStyle, uno::UNO_QUERY);
+                SAL_WARN_IF( !xStylePropSet.is(), "xmloff", "style without a XPropertySet?" );
+                try
+                {
+                    if(xStylePropSet.is())
+                    {
+                        OUString aFamilyName;
+                        xStylePropSet->getPropertyValue("Family") >>= aFamilyName;
+                        if( !aFamilyName.isEmpty() && aFamilyName != "graphics" )
+                            aShapeInfo.mnFamily = XmlStyleFamily::SD_PRESENTATION_ID;
+                    }
+                }
+                catch(const beans::UnknownPropertyException&)
+                {
+                    // Ignored.
+                    SAL_WARN( "xmloff",
+                        "XMLShapeExport::collectShapeAutoStyles: style has no 'Family' property");
+                }
+
+                // get parent-style name
+                if(XmlStyleFamily::SD_PRESENTATION_ID == aShapeInfo.mnFamily)
+                {
+                    aParentName = msPresentationStylePrefix;
+                }
+
+                aParentName += xStyle->getName();
+            }
+        }
+
+        if (aParentName.isEmpty() && xPropertySetInfo->hasPropertyByName("TextBox") && xPropSet->getPropertyValue("TextBox").hasValue() && xPropSet->getPropertyValue("TextBox").get<bool>())
+        {
+            // Shapes with a Writer TextBox always have a parent style.
+            // If there would be none, then assign the default one.
+            aParentName = "Frame";
+        }
+
+        // filter propset
+        std::vector< XMLPropertyState > aPropStates;
+
+        sal_Int32 nCount = 0;
+        if( !bIsEmptyPresObj || (aShapeInfo.meShapeType != XmlShapeTypePresPageShape) )
+        {
+            aPropStates = GetPropertySetMapper()->Filter(mrExport, xPropSet);
+
+            if (XmlShapeTypeDrawControlShape == aShapeInfo.meShapeType)
+            {
+                // for control shapes, we additionally need the number format style (if any)
+                uno::Reference< drawing::XControlShape > xControl(xShape, uno::UNO_QUERY);
+                DBG_ASSERT(xControl.is(), "XMLShapeExport::collectShapeAutoStyles: ShapeType control, but no XControlShape!");
+                if (xControl.is())
+                {
+                    uno::Reference< beans::XPropertySet > xControlModel(xControl->getControl(), uno::UNO_QUERY);
+                    DBG_ASSERT(xControlModel.is(), "XMLShapeExport::collectShapeAutoStyles: no control model on the control shape!");
+
+                    OUString sNumberStyle = mrExport.GetFormExport()->getControlNumberStyle(xControlModel);
+                    if (!sNumberStyle.isEmpty())
+                    {
+                        sal_Int32 nIndex = GetPropertySetMapper()->getPropertySetMapper()->FindEntryIndex(CTF_SD_CONTROL_SHAPE_DATA_STYLE);
+                            // TODO : this retrieval of the index could be moved into the ctor, holding the index
+                            //          as member, thus saving time.
+                        DBG_ASSERT(-1 != nIndex, "XMLShapeExport::collectShapeAutoStyles: could not obtain the index for our context id!");
+
+                        XMLPropertyState aNewState(nIndex, uno::Any(sNumberStyle));
+                        aPropStates.push_back(aNewState);
+                    }
+                }
+            }
+
+            nCount = std::count_if(aPropStates.cbegin(), aPropStates.cend(),
+                [](const XMLPropertyState& rProp) { return rProp.mnIndex != -1; });
+        }
+
+        if(nCount == 0)
+        {
+            // no hard attributes, use parent style name for export
+            aShapeInfo.msStyleName = aParentName;
+        }
+        else
+        {
+            // there are filtered properties -> hard attributes
+            // try to find this style in AutoStylePool
+            aShapeInfo.msStyleName = mrExport.GetAutoStylePool()->Find(aShapeInfo.mnFamily, aParentName, aPropStates);
+
+            if(aShapeInfo.msStyleName.isEmpty())
+            {
+                // Style did not exist, add it to AutoStalePool
+                aShapeInfo.msStyleName = mrExport.GetAutoStylePool()->Add(aShapeInfo.mnFamily, aParentName, std::move(aPropStates));
+            }
+        }
+
+        // optionally generate auto style for text attributes
+        if( (!bIsEmptyPresObj || (aShapeInfo.meShapeType != XmlShapeTypePresPageShape)) && bObjSupportsText )
+        {
+            aPropStates = GetExport().GetTextParagraphExport()->GetParagraphPropertyMapper()->Filter(mrExport, xPropSet);
+
+            // yet more additionally, we need to care for the ParaAdjust property
+            if ( XmlShapeTypeDrawControlShape == aShapeInfo.meShapeType )
+            {
+                uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
+                uno::Reference< beans::XPropertyState > xPropState( xPropSet, uno::UNO_QUERY );
+                if ( xPropSetInfo.is() && xPropState.is() )
+                {
+                    // this is because:
+                    // * if controls shapes have a ParaAdjust property, then this is the Align property of the control model
+                    // * control models are allowed to have an Align of "void"
+                    // * the Default for control model's Align is TextAlign_LEFT
+                    // * defaults for style properties are not written, but we need to write the "left",
+                    //   because we need to distinguish this "left" from the case where not align attribute
+                    //   is present which means "void"
+                    if  (   xPropSetInfo->hasPropertyByName( "ParaAdjust" )
+                        &&  ( beans::PropertyState_DEFAULT_VALUE == xPropState->getPropertyState( "ParaAdjust" ) )
+                        )
+                    {
+                        sal_Int32 nIndex = GetExport().GetTextParagraphExport()->GetParagraphPropertyMapper()->getPropertySetMapper()->FindEntryIndex( CTF_SD_SHAPE_PARA_ADJUST );
+                            // TODO : this retrieval of the index should be moved into the ctor, holding the index
+                            //          as member, thus saving time.
+                        DBG_ASSERT(-1 != nIndex, "XMLShapeExport::collectShapeAutoStyles: could not obtain the index for the ParaAdjust context id!");
+
+                        uno::Any aParaAdjustValue = xPropSet->getPropertyValue( "ParaAdjust" );
+                        XMLPropertyState aAlignDefaultState( nIndex, aParaAdjustValue );
+
+                        aPropStates.push_back( aAlignDefaultState );
+                    }
+                }
+            }
+
+            nCount = std::count_if(aPropStates.cbegin(), aPropStates.cend(),
+                [](const XMLPropertyState& rProp) { return rProp.mnIndex != -1; });
+
+            if( nCount )
+            {
+                aShapeInfo.msTextStyleName = mrExport.GetAutoStylePool()->Find( XmlStyleFamily::TEXT_PARAGRAPH, "", aPropStates );
+                if(aShapeInfo.msTextStyleName.isEmpty())
+                {
+                    // Style did not exist, add it to AutoStalePool
+                    aShapeInfo.msTextStyleName = mrExport.GetAutoStylePool()->Add(XmlStyleFamily::TEXT_PARAGRAPH, "", std::move(aPropStates));
+                }
+            }
+        }
+    }
+
+    // prepare animation information if needed
+    if( mxAnimationsExporter.is() )
+        XMLAnimationsExporter::prepare( xShape );
+
+    // check for special shapes
+
+    switch( aShapeInfo.meShapeType )
+    {
+        case XmlShapeTypeDrawConnectorShape:
+        {
+            uno::Reference< uno::XInterface > xConnection;
+
+            // create shape ids for export later
+            xPropSet->getPropertyValue( gsStartShape ) >>= xConnection;
+            if( xConnection.is() )
+                mrExport.getInterfaceToIdentifierMapper().registerReference( xConnection );
+
+            xPropSet->getPropertyValue( gsEndShape ) >>= xConnection;
+            if( xConnection.is() )
+                mrExport.getInterfaceToIdentifierMapper().registerReference( xConnection );
+            break;
+        }
+        case XmlShapeTypePresTableShape:
+        case XmlShapeTypeDrawTableShape:
+        {
+            try
+            {
+                uno::Reference< table::XColumnRowRange > xRange( xPropSet->getPropertyValue( gsModel ), uno::UNO_QUERY_THROW );
+                GetShapeTableExport()->collectTableAutoStyles( xRange );
+            }
+            catch(const uno::Exception&)
+            {
+                DBG_UNHANDLED_EXCEPTION( "xmloff", "collecting auto styles for a table" );
+            }
+            break;
+        }
+        default:
+            break;
+    }
+
+    // check for shape collections (group shape or 3d scene)
+    // and collect contained shapes style infos
+    const uno::Reference< drawing::XShape >& xCollection = aShapeInfo.xCustomShapeReplacement.is()
+                                                ? aShapeInfo.xCustomShapeReplacement : xShape;
+    {
+        uno::Reference< drawing::XShapes > xShapes( xCollection, uno::UNO_QUERY );
+        if( xShapes.is() )
+        {
+            collectShapesAutoStyles( xShapes );
+        }
+    }
+}
+
+namespace
+{
+    class NewTextListsHelper
+    {
+        public:
+            explicit NewTextListsHelper( SvXMLExport& rExp )
+                : mrExport( rExp )
+            {
+                mrExport.GetTextParagraphExport()->PushNewTextListsHelper();
+            }
+
+            ~NewTextListsHelper()
+            {
+                mrExport.GetTextParagraphExport()->PopTextListsHelper();
+            }
+
+        private:
+            SvXMLExport& mrExport;
+    };
+}
+// This method exports the given XShape
+void XMLShapeExport::exportShape(const uno::Reference< drawing::XShape >& xShape,
+                                 XMLShapeExportFlags nFeatures /* = SEF_DEFAULT */,
+                                 css::awt::Point* pRefPoint /* = NULL */,
+                                 SvXMLAttributeList* pAttrList /* = NULL */ )
+{
+    SAL_INFO("xmloff", xShape->getShapeType());
+    if( maCurrentShapesIter == maShapesInfos.end() )
+    {
+        SAL_WARN( "xmloff", "XMLShapeExport::exportShape(): no auto styles where collected before export" );
+        return;
+    }
+    sal_Int32 nZIndex = 0;
+    uno::Reference< beans::XPropertySet > xSet( xShape, uno::UNO_QUERY );
+    OUString sHyperlink;
+    try
+    {
+        xSet->getPropertyValue(gsHyperlink) >>= sHyperlink;
+    }
+    catch (beans::UnknownPropertyException)
+    {
+    }
+
+    std::unique_ptr< SvXMLElementExport >  pHyperlinkElement;
+
+    // Need to stash the attributes that are pre-loaded for the shape export
+    // (otherwise they will become attributes of the draw:a element)
+    uno::Reference<xml::sax::XAttributeList> xSaveAttribs(
+        new SvXMLAttributeList(GetExport().GetAttrList()));
+    GetExport().ClearAttrList();
+    if( xSet.is() && (GetExport().GetModelType() == SvtModuleOptions::EFactory::DRAW) )
+    {
+        // export hyperlinks with <a><shape/></a>. Currently only in draw since draw
+        // does not support document events
+        try
+        {
+            presentation::ClickAction eAction = presentation::ClickAction_NONE;
+            xSet->getPropertyValue(gsOnClick) >>= eAction;
+
+            if( (eAction == presentation::ClickAction_DOCUMENT) ||
+                (eAction == presentation::ClickAction_BOOKMARK) )
+            {
+                OUString sURL;
+                xSet->getPropertyValue(gsBookmark) >>= sURL;
+
+                if( !sURL.isEmpty() )
+                {
+                    mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, sURL );
+                    mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+                    mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+                    pHyperlinkElement.reset( new SvXMLElementExport(mrExport, XML_NAMESPACE_DRAW, XML_A, true, true) );
+                }
+            }
+        }
+        catch(const uno::Exception&)
+        {
+            TOOLS_WARN_EXCEPTION("xmloff", "XMLShapeExport::exportShape(): exception during hyperlink export");
+        }
+    }
+    else if (xSet.is() && !sHyperlink.isEmpty())
+    {
+        mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, sHyperlink );
+        mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+        pHyperlinkElement.reset( new SvXMLElementExport(mrExport, XML_NAMESPACE_DRAW, XML_A, true, true) );
+    }
+    // re-add stashed attributes
+    GetExport().AddAttributeList(xSaveAttribs);
+
+    if( xSet.is() )
+        xSet->getPropertyValue(gsZIndex) >>= nZIndex;
+
+    ImplXMLShapeExportInfoVector& aShapeInfoVector = (*maCurrentShapesIter).second;
+
+    if( static_cast<sal_Int32>(aShapeInfoVector.size()) <= nZIndex )
+    {
+        SAL_WARN( "xmloff", "XMLShapeExport::exportShape(): no shape info collected for a given shape" );
+        return;
+    }
+
+    NewTextListsHelper aNewTextListsHelper( mrExport );
+
+    const ImplXMLShapeExportInfo& aShapeInfo = aShapeInfoVector[nZIndex];
+
+#ifdef DBG_UTIL
+    // check if this is the correct ShapesInfo
+    uno::Reference< container::XChild > xChild( xShape, uno::UNO_QUERY );
+    if( xChild.is() )
+    {
+        uno::Reference< drawing::XShapes > xParent( xChild->getParent(), uno::UNO_QUERY );
+        SAL_WARN_IF( !xParent.is() && xParent.get() == (*maCurrentShapesIter).first.get(), "xmloff", "XMLShapeExport::exportShape(): Wrong call to XMLShapeExport::seekShapes()" );
+    }
+
+    // first compute the shapes type
+    {
+        XmlShapeType eShapeType(XmlShapeTypeNotYetSet);
+        ImpCalcShapeType(xShape, eShapeType);
+
+        SAL_WARN_IF( eShapeType != aShapeInfo.meShapeType, "xmloff", "exportShape callings do not correspond to collectShapeAutoStyles calls!: " << xShape->getShapeType() );
+    }
+#endif
+
+    // collect animation information if needed
+    if( mxAnimationsExporter.is() )
+        mxAnimationsExporter->collect( xShape, mrExport );
+
+    /* Export shapes name if he has one (#i51726#)
+       Export of the shape name for text documents only if the OpenDocument
+       file format is written - exceptions are group shapes.
+       Note: Writer documents in OpenOffice.org file format doesn't contain
+             any names for shapes, except for group shapes.
+    */
+    {
+        if ( ( GetExport().GetModelType() != SvtModuleOptions::EFactory::WRITER &&
+               GetExport().GetModelType() != SvtModuleOptions::EFactory::WRITERWEB &&
+               GetExport().GetModelType() != SvtModuleOptions::EFactory::WRITERGLOBAL ) ||
+             ( GetExport().getExportFlags() & SvXMLExportFlags::OASIS ) ||
+             aShapeInfo.meShapeType == XmlShapeTypeDrawGroupShape ||
+             ( aShapeInfo.meShapeType == XmlShapeTypeDrawCustomShape &&
+               aShapeInfo.xCustomShapeReplacement.is() ) )
+        {
+            uno::Reference< container::XNamed > xNamed( xShape, uno::UNO_QUERY );
+            if( xNamed.is() )
+            {
+                const OUString aName( xNamed->getName() );
+                if( !aName.isEmpty() )
+                    mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_NAME, aName );
+            }
+        }
+    }
+
+    // export style name
+    if( !aShapeInfo.msStyleName.isEmpty() )
+    {
+        if(XmlStyleFamily::SD_GRAPHICS_ID == aShapeInfo.mnFamily)
+            mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_STYLE_NAME, mrExport.EncodeStyleName( aShapeInfo.msStyleName) );
+        else
+            mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_STYLE_NAME, mrExport.EncodeStyleName( aShapeInfo.msStyleName) );
+    }
+
+    // export text style name
+    if( !aShapeInfo.msTextStyleName.isEmpty() )
+    {
+        mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_TEXT_STYLE_NAME, aShapeInfo.msTextStyleName );
+    }
+
+    // export shapes id if needed
+    {
+        uno::Reference< uno::XInterface > xRef( xShape, uno::UNO_QUERY );
+        const OUString& rShapeId = mrExport.getInterfaceToIdentifierMapper().getIdentifier( xRef );
+        if( !rShapeId.isEmpty() )
+        {
+            mrExport.AddAttributeIdLegacy(XML_NAMESPACE_DRAW, rShapeId);
+        }
+    }
+
+    // export layer information
+    if( mbExportLayer )
+    {
+        // check for group or scene shape and not export layer if this is one
+        uno::Reference< drawing::XShapes > xShapes( xShape, uno::UNO_QUERY );
+        if( !xShapes.is() )
+        {
+            try
+            {
+                uno::Reference< beans::XPropertySet > xProps( xShape, uno::UNO_QUERY );
+                OUString aLayerName;
+                xProps->getPropertyValue("LayerName") >>= aLayerName;
+                mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_LAYER, aLayerName );
+
+            }
+            catch(const uno::Exception&)
+            {
+                DBG_UNHANDLED_EXCEPTION( "xmloff", "exporting layer name for shape" );
+            }
+        }
+    }
+
+    // export draw:display (do not export in ODF 1.3 or older)
+    if (xSet.is() && (mrExport.getSaneDefaultVersion() & SvtSaveOptions::ODFSVER_EXTENDED))
+    {
+        if( aShapeInfo.meShapeType != XmlShapeTypeDrawPageShape && aShapeInfo.meShapeType != XmlShapeTypePresPageShape &&
+            aShapeInfo.meShapeType != XmlShapeTypeHandoutShape && aShapeInfo.meShapeType != XmlShapeTypeDrawChartShape )
+            try
+            {
+                bool bVisible = true;
+                bool bPrintable = true;
+
+                xSet->getPropertyValue(gsVisible) >>= bVisible;
+                xSet->getPropertyValue(gsPrintable) >>= bPrintable;
+
+                XMLTokenEnum eDisplayToken = XML_TOKEN_INVALID;
+                const unsigned short nDisplay = (bVisible ? 2 : 0) | (bPrintable ? 1 : 0);
+                switch( nDisplay )
+                {
+                case 0: eDisplayToken = XML_NONE; break;
+                case 1: eDisplayToken = XML_PRINTER; break;
+                case 2: eDisplayToken = XML_SCREEN; break;
+                // case 3: eDisplayToken = XML_ALWAYS break; this is the default
+                }
+
+                if( eDisplayToken != XML_TOKEN_INVALID )
+                    mrExport.AddAttribute(XML_NAMESPACE_DRAW_EXT, XML_DISPLAY, eDisplayToken );
+            }
+            catch(const uno::Exception&)
+            {
+                DBG_UNHANDLED_EXCEPTION("xmloff.draw");
+            }
+    }
+
+    // #82003# test export count
+    // #91587# ALWAYS increment since now ALL to be exported shapes are counted.
+    if(mrExport.GetShapeExport()->IsHandleProgressBarEnabled())
+    {
+        mrExport.GetProgressBarHelper()->Increment();
+    }
+
+    onExport( xShape );
+
+    // export shape element
+    switch(aShapeInfo.meShapeType)
+    {
+        case XmlShapeTypeDrawRectangleShape:
+        {
+            ImpExportRectangleShape(xShape, nFeatures, pRefPoint );
+            break;
+        }
+        case XmlShapeTypeDrawEllipseShape:
+        {
+            ImpExportEllipseShape(xShape, nFeatures, pRefPoint );
+            break;
+        }
+        case XmlShapeTypeDrawLineShape:
+        {
+            ImpExportLineShape(xShape, nFeatures, pRefPoint );
+            break;
+        }
+        case XmlShapeTypeDrawPolyPolygonShape:  // closed PolyPolygon
+        case XmlShapeTypeDrawPolyLineShape:     // open PolyPolygon
+        case XmlShapeTypeDrawClosedBezierShape: // closed tools::PolyPolygon containing curves
+        case XmlShapeTypeDrawOpenBezierShape:   // open tools::PolyPolygon containing curves
+        {
+            ImpExportPolygonShape(xShape, aShapeInfo.meShapeType, nFeatures, pRefPoint );
+            break;
+        }
+
+        case XmlShapeTypeDrawTextShape:
+        case XmlShapeTypePresTitleTextShape:
+        case XmlShapeTypePresOutlinerShape:
+        case XmlShapeTypePresSubtitleShape:
+        case XmlShapeTypePresNotesShape:
+        case XmlShapeTypePresHeaderShape:
+        case XmlShapeTypePresFooterShape:
+        case XmlShapeTypePresSlideNumberShape:
+        case XmlShapeTypePresDateTimeShape:
+        {
+            ImpExportTextBoxShape(xShape, aShapeInfo.meShapeType, nFeatures, pRefPoint );
+            break;
+        }
+
+        case XmlShapeTypeDrawGraphicObjectShape:
+        case XmlShapeTypePresGraphicObjectShape:
+        {
+            ImpExportGraphicObjectShape(xShape, aShapeInfo.meShapeType, nFeatures, pRefPoint );
+            break;
+        }
+
+        case XmlShapeTypeDrawChartShape:
+        case XmlShapeTypePresChartShape:
+        {
+            ImpExportChartShape(xShape, aShapeInfo.meShapeType, nFeatures, pRefPoint, pAttrList );
+            break;
+        }
+
+        case XmlShapeTypeDrawControlShape:
+        {
+            ImpExportControlShape(xShape, nFeatures, pRefPoint );
+            break;
+        }
+
+        case XmlShapeTypeDrawConnectorShape:
+        {
+            ImpExportConnectorShape(xShape, nFeatures, pRefPoint );
+            break;
+        }
+
+        case XmlShapeTypeDrawMeasureShape:
+        {
+            ImpExportMeasureShape(xShape, nFeatures, pRefPoint );
+            break;
+        }
+
+        case XmlShapeTypeDrawOLE2Shape:
+        case XmlShapeTypePresOLE2Shape:
+        case XmlShapeTypeDrawSheetShape:
+        case XmlShapeTypePresSheetShape:
+        {
+            ImpExportOLE2Shape(xShape, aShapeInfo.meShapeType, nFeatures, pRefPoint );
+            break;
+        }
+
+        case XmlShapeTypePresTableShape:
+        case XmlShapeTypeDrawTableShape:
+        {
+            ImpExportTableShape( xShape, aShapeInfo.meShapeType, nFeatures, pRefPoint );
+            break;
+        }
+
+        case XmlShapeTypeDrawPageShape:
+        case XmlShapeTypePresPageShape:
+        case XmlShapeTypeHandoutShape:
+        {
+            ImpExportPageShape(xShape, aShapeInfo.meShapeType, nFeatures, pRefPoint );
+            break;
+        }
+
+        case XmlShapeTypeDrawCaptionShape:
+        {
+            ImpExportCaptionShape(xShape, nFeatures, pRefPoint );
+            break;
+        }
+
+        case XmlShapeTypeDraw3DCubeObject:
+        case XmlShapeTypeDraw3DSphereObject:
+        case XmlShapeTypeDraw3DLatheObject:
+        case XmlShapeTypeDraw3DExtrudeObject:
+        {
+            ImpExport3DShape(xShape, aShapeInfo.meShapeType);
+            break;
+        }
+
+        case XmlShapeTypeDraw3DSceneObject:
+        {
+            ImpExport3DSceneShape( xShape, nFeatures, pRefPoint );
+            break;
+        }
+
+        case XmlShapeTypeDrawGroupShape:
+        {
+            // empty group
+            ImpExportGroupShape( xShape, nFeatures, pRefPoint );
+            break;
+        }
+
+        case XmlShapeTypeDrawFrameShape:
+        {
+            ImpExportFrameShape(xShape, nFeatures, pRefPoint );
+            break;
+        }
+
+        case XmlShapeTypeDrawAppletShape:
+        {
+            ImpExportAppletShape(xShape, nFeatures, pRefPoint );
+            break;
+        }
+
+        case XmlShapeTypeDrawPluginShape:
+        {
+            ImpExportPluginShape(xShape, nFeatures, pRefPoint );
+            break;
+        }
+
+        case XmlShapeTypeDrawCustomShape:
+        {
+            if ( aShapeInfo.xCustomShapeReplacement.is() )
+                ImpExportGroupShape( aShapeInfo.xCustomShapeReplacement, nFeatures, pRefPoint );
+            else
+                ImpExportCustomShape( xShape, nFeatures, pRefPoint );
+            break;
+        }
+
+        case XmlShapeTypePresMediaShape:
+        case XmlShapeTypeDrawMediaShape:
+        {
+            ImpExportMediaShape( xShape, aShapeInfo.meShapeType, nFeatures, pRefPoint );
+            break;
+        }
+
+        case XmlShapeTypePresOrgChartShape:
+        case XmlShapeTypeUnknown:
+        case XmlShapeTypeNotYetSet:
+        default:
+        {
+            // this should never happen and is an error
+            OSL_FAIL("XMLEXP: WriteShape: unknown or unexpected type of shape in export!");
+            break;
+        }
+    }
+
+    pHyperlinkElement.reset();
+
+    // #97489# #97111#
+    // if there was an error and no element for the shape was exported
+    // we need to clear the attribute list or the attributes will be
+    // set on the next exported element, which can result in corrupt
+    // xml files due to duplicate attributes
+
+    mrExport.CheckAttrList();   // asserts in non pro if we have attributes left
+    mrExport.ClearAttrList();   // clears the attributes
+}
+
+// This method collects all automatic styles for the shapes inside the given XShapes collection
+void XMLShapeExport::collectShapesAutoStyles( const uno::Reference < drawing::XShapes >& xShapes )
+{
+    ShapesInfos::iterator aOldCurrentShapesIter = maCurrentShapesIter;
+    seekShapes( xShapes );
+
+    uno::Reference< drawing::XShape > xShape;
+    const sal_Int32 nShapeCount(xShapes->getCount());
+    for(sal_Int32 nShapeId = 0; nShapeId < nShapeCount; nShapeId++)
+    {
+        xShapes->getByIndex(nShapeId) >>= xShape;
+        SAL_WARN_IF( !xShape.is(), "xmloff", "Shape without a XShape?" );
+        if(!xShape.is())
+            continue;
+
+        collectShapeAutoStyles( xShape );
+    }
+
+    maCurrentShapesIter = aOldCurrentShapesIter;
+}
+
+// This method exports all XShape inside the given XShapes collection
+void XMLShapeExport::exportShapes( const uno::Reference < drawing::XShapes >& xShapes, XMLShapeExportFlags nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */ )
+{
+    ShapesInfos::iterator aOldCurrentShapesIter = maCurrentShapesIter;
+    seekShapes( xShapes );
+
+    uno::Reference< drawing::XShape > xShape;
+    const sal_Int32 nShapeCount(xShapes->getCount());
+    for(sal_Int32 nShapeId = 0; nShapeId < nShapeCount; nShapeId++)
+    {
+        xShapes->getByIndex(nShapeId) >>= xShape;
+        SAL_WARN_IF( !xShape.is(), "xmloff", "Shape without a XShape?" );
+        if(!xShape.is())
+            continue;
+
+        exportShape( xShape, nFeatures, pRefPoint );
+    }
+
+    maCurrentShapesIter = aOldCurrentShapesIter;
+}
+
+namespace xmloff {
+
+void FixZOrder(uno::Reference<drawing::XShapes> const& xShapes,
+    std::function<unsigned int (uno::Reference<beans::XPropertySet> const&)> const& rGetLayer)
+{
+    uno::Reference<drawing::XShapes3> const xShapes3(xShapes, uno::UNO_QUERY);
+    assert(xShapes3.is());
+    if (!xShapes3.is())
+    {
+        return; // only SvxDrawPage implements this
+    }
+    struct Layer { std::vector<sal_Int32> shapes; sal_Int32 nMin = SAL_MAX_INT32; sal_Int32 nMax = 0; };
+    std::vector<Layer> layers;
+    // shapes are sorted by ZOrder
+    sal_Int32 const nCount(xShapes->getCount());
+    for (sal_Int32 i = 0; i < nCount; ++i)
+    {
+        uno::Reference<beans::XPropertySet> const xShape(xShapes->getByIndex(i), uno::UNO_QUERY);
+        if (!xShape.is())
+        {
+            SAL_WARN("xmloff", "FixZOrder: null shape, cannot sort");
+            return;
+        }
+        unsigned int const nLayer(rGetLayer(xShape));
+        if (layers.size() <= nLayer)
+        {
+            layers.resize(nLayer + 1);
+        }
+        layers[nLayer].shapes.emplace_back(i);
+        if (i < layers[nLayer].nMin)
+        {
+            layers[nLayer].nMin = i;
+        }
+        if (layers[nLayer].nMax < i)
+        {
+            layers[nLayer].nMax = i;
+        }
+    }
+    layers.erase(std::remove_if(layers.begin(), layers.end(),
+                    [](Layer const& rLayer) { return rLayer.shapes.empty(); }),
+        layers.end());
+    bool isSorted(true);
+    for (size_t i = 1; i < layers.size(); ++i)
+    {
+        assert(layers[i].nMin != layers[i-1].nMax); // unique!
+        if (layers[i].nMin < layers[i-1].nMax)
+        {
+            isSorted = false;
+            break;
+        }
+    }
+    if (isSorted)
+    {
+        return; // nothing to do
+    }
+    uno::Sequence<sal_Int32> aNewOrder(nCount);
+    auto iterInsert(aNewOrder.getArray());
+    for (auto const& rLayer : layers)
+    {
+        assert(rLayer.nMin <= rLayer.nMax); // empty layers have been removed
+        iterInsert = std::copy(rLayer.shapes.begin(), rLayer.shapes.end(), iterInsert);
+    }
+    try
+    {
+        xShapes3->sort(aNewOrder);
+    }
+    catch (uno::Exception const&)
+    {
+        SAL_WARN("xmloff", "FixZOrder: exception");
+    }
+}
+
+} // namespace xmloff
+
+void XMLShapeExport::seekShapes( const uno::Reference< drawing::XShapes >& xShapes ) noexcept
+{
+    if( xShapes.is() )
+    {
+        maCurrentShapesIter = maShapesInfos.find( xShapes );
+        if( maCurrentShapesIter == maShapesInfos.end() )
+        {
+            ImplXMLShapeExportInfoVector aNewInfoVector;
+            aNewInfoVector.resize( static_cast<ShapesInfos::size_type>(xShapes->getCount()) );
+            maShapesInfos[ xShapes ] = aNewInfoVector;
+
+            maCurrentShapesIter = maShapesInfos.find( xShapes );
+
+            SAL_WARN_IF( maCurrentShapesIter == maShapesInfos.end(), "xmloff", "XMLShapeExport::seekShapes(): insert into stl::map failed" );
+        }
+
+        SAL_WARN_IF( (*maCurrentShapesIter).second.size() != static_cast<ShapesInfos::size_type>(xShapes->getCount()), "xmloff", "XMLShapeExport::seekShapes(): XShapes size varied between calls" );
+
+    }
+    else
+    {
+        maCurrentShapesIter = maShapesInfos.end();
+    }
+}
+
+void XMLShapeExport::exportAutoStyles()
+{
+    // export all autostyle infos
+
+    // ...for graphic
+    {
+        GetExport().GetAutoStylePool()->exportXML( XmlStyleFamily::SD_GRAPHICS_ID );
+    }
+
+    // ...for presentation
+    {
+        GetExport().GetAutoStylePool()->exportXML( XmlStyleFamily::SD_PRESENTATION_ID );
+    }
+
+    if( mxShapeTableExport.is() )
+        mxShapeTableExport->exportAutoStyles();
+}
+
+/// returns the export property mapper for external chaining
+SvXMLExportPropertyMapper* XMLShapeExport::CreateShapePropMapper(
+    SvXMLExport& rExport )
+{
+    rtl::Reference< XMLPropertyHandlerFactory > xFactory = new XMLSdPropHdlFactory( rExport.GetModel(), rExport );
+    rtl::Reference < XMLPropertySetMapper > xMapper = new XMLShapePropertySetMapper( xFactory, true );
+    rExport.GetTextParagraphExport(); // get or create text paragraph export
+    SvXMLExportPropertyMapper* pResult =
+        new XMLShapeExportPropertyMapper( xMapper, rExport );
+    // chain text attributes
+    return pResult;
+}
+
+void XMLShapeExport::ImpCalcShapeType(const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType& eShapeType)
+{
+    // set in every case, so init here
+    eShapeType = XmlShapeTypeUnknown;
+
+    if(!xShape.is())
+        return;
+
+    OUString aType(xShape->getShapeType());
+
+    if(!aType.match("com.sun.star."))
+        return;
+
+    if(aType.match("drawing.", 13))
+    {
+        // drawing shapes
+        if     (aType.match("Rectangle", 21)) { eShapeType = XmlShapeTypeDrawRectangleShape; }
+
+        // #i72177# Note: Correcting CustomShape, CustomShape->Custom, len from 9 (was wrong anyways) to 6.
+        // As can be seen at the other compares, the appendix "Shape" is left out of the comparison.
+        else if(aType.match("Custom", 21)) { eShapeType = XmlShapeTypeDrawCustomShape; }
+
+        else if(aType.match("Ellipse", 21)) { eShapeType = XmlShapeTypeDrawEllipseShape; }
+        else if(aType.match("Control", 21)) { eShapeType = XmlShapeTypeDrawControlShape; }
+        else if(aType.match("Connector", 21)) { eShapeType = XmlShapeTypeDrawConnectorShape; }
+        else if(aType.match("Measure", 21)) { eShapeType = XmlShapeTypeDrawMeasureShape; }
+        else if(aType.match("Line", 21)) { eShapeType = XmlShapeTypeDrawLineShape; }
+
+        // #i72177# Note: This covers two types by purpose, PolyPolygonShape and PolyPolygonPathShape
+        else if(aType.match("PolyPolygon", 21)) { eShapeType = XmlShapeTypeDrawPolyPolygonShape; }
+
+        // #i72177# Note: This covers two types by purpose, PolyLineShape and PolyLinePathShape
+        else if(aType.match("PolyLine", 21)) { eShapeType = XmlShapeTypeDrawPolyLineShape; }
+
+        else if(aType.match("OpenBezier", 21)) { eShapeType = XmlShapeTypeDrawOpenBezierShape; }
+        else if(aType.match("ClosedBezier", 21)) { eShapeType = XmlShapeTypeDrawClosedBezierShape; }
+
+        // #i72177# FreeHand (opened and closed) now supports the types OpenFreeHandShape and
+        // ClosedFreeHandShape respectively. Represent them as bezier shapes
+        else if(aType.match("OpenFreeHand", 21)) { eShapeType = XmlShapeTypeDrawOpenBezierShape; }
+        else if(aType.match("ClosedFreeHand", 21)) { eShapeType = XmlShapeTypeDrawClosedBezierShape; }
+
+        else if(aType.match("GraphicObject", 21)) { eShapeType = XmlShapeTypeDrawGraphicObjectShape; }
+        else if(aType.match("Group", 21)) { eShapeType = XmlShapeTypeDrawGroupShape; }
+        else if(aType.match("Text", 21)) { eShapeType = XmlShapeTypeDrawTextShape; }
+        else if(aType.match("OLE2", 21))
+        {
+            eShapeType = XmlShapeTypeDrawOLE2Shape;
+
+            // get info about presentation shape
+            uno::Reference <beans::XPropertySet> xPropSet(xShape, uno::UNO_QUERY);
+
+            if(xPropSet.is())
+            {
+                OUString sCLSID;
+                if(xPropSet->getPropertyValue("CLSID") >>= sCLSID)
+                {
+#if !ENABLE_WASM_STRIP_CHART
+                    // WASM_CHART change
+                    // TODO: With Chart extracted this cannot really happen since
+                    // no Chart could've been added at all
+                    if (sCLSID == mrExport.GetChartExport()->getChartCLSID() ||
+#else
+                    if(
+#endif
+                        sCLSID == SvGlobalName( SO3_RPTCH_CLASSID ).GetHexName() )
+                    {
+                        eShapeType = XmlShapeTypeDrawChartShape;
+                    }
+                    else if (sCLSID == SvGlobalName( SO3_SC_CLASSID ).GetHexName() )
+                    {
+                        eShapeType = XmlShapeTypeDrawSheetShape;
+                    }
+                    else
+                    {
+                        // general OLE2 Object
+                    }
+                }
+            }
+        }
+        else if(aType.match("Page", 21)) { eShapeType = XmlShapeTypeDrawPageShape; }
+        else if(aType.match("Frame", 21)) { eShapeType = XmlShapeTypeDrawFrameShape; }
+        else if(aType.match("Caption", 21)) { eShapeType = XmlShapeTypeDrawCaptionShape; }
+        else if(aType.match("Plugin", 21)) { eShapeType = XmlShapeTypeDrawPluginShape; }
+        else if(aType.match("Applet", 21)) { eShapeType = XmlShapeTypeDrawAppletShape; }
+        else if(aType.match("MediaShape", 21)) { eShapeType = XmlShapeTypeDrawMediaShape; }
+        else if(aType.match("TableShape", 21)) { eShapeType = XmlShapeTypeDrawTableShape; }
+
+        // 3D shapes
+        else if(aType.match("Scene", 21 + 7)) { eShapeType = XmlShapeTypeDraw3DSceneObject; }
+        else if(aType.match("Cube", 21 + 7)) { eShapeType = XmlShapeTypeDraw3DCubeObject; }
+        else if(aType.match("Sphere", 21 + 7)) { eShapeType = XmlShapeTypeDraw3DSphereObject; }
+        else if(aType.match("Lathe", 21 + 7)) { eShapeType = XmlShapeTypeDraw3DLatheObject; }
+        else if(aType.match("Extrude", 21 + 7)) { eShapeType = XmlShapeTypeDraw3DExtrudeObject; }
+    }
+    else if(aType.match("presentation.", 13))
+    {
+        // presentation shapes
+        if     (aType.match("TitleText", 26)) { eShapeType = XmlShapeTypePresTitleTextShape; }
+        else if(aType.match("Outliner", 26)) { eShapeType = XmlShapeTypePresOutlinerShape;  }
+        else if(aType.match("Subtitle", 26)) { eShapeType = XmlShapeTypePresSubtitleShape;  }
+        else if(aType.match("GraphicObject", 26)) { eShapeType = XmlShapeTypePresGraphicObjectShape;  }
+        else if(aType.match("Page", 26)) { eShapeType = XmlShapeTypePresPageShape;  }
+        else if(aType.match("OLE2", 26))
+        {
+            eShapeType = XmlShapeTypePresOLE2Shape;
+
+            // get info about presentation shape
+            uno::Reference <beans::XPropertySet> xPropSet(xShape, uno::UNO_QUERY);
+
+            if(xPropSet.is()) try
+            {
+                OUString sCLSID;
+                if(xPropSet->getPropertyValue("CLSID") >>= sCLSID)
+                {
+                    if( sCLSID == SvGlobalName( SO3_SC_CLASSID ).GetHexName() )
+                    {
+                        eShapeType = XmlShapeTypePresSheetShape;
+                    }
+                }
+            }
+            catch(const uno::Exception&)
+            {
+                SAL_WARN( "xmloff", "XMLShapeExport::ImpCalcShapeType(), expected ole shape to have the CLSID property?" );
+            }
+        }
+        else if(aType.match("Chart", 26)) { eShapeType = XmlShapeTypePresChartShape;  }
+        else if(aType.match("OrgChart", 26)) { eShapeType = XmlShapeTypePresOrgChartShape;  }
+        else if(aType.match("CalcShape", 26)) { eShapeType = XmlShapeTypePresSheetShape; }
+        else if(aType.match("TableShape", 26)) { eShapeType = XmlShapeTypePresTableShape; }
+        else if(aType.match("Notes", 26)) { eShapeType = XmlShapeTypePresNotesShape;  }
+        else if(aType.match("HandoutShape", 26)) { eShapeType = XmlShapeTypeHandoutShape; }
+        else if(aType.match("HeaderShape", 26)) { eShapeType = XmlShapeTypePresHeaderShape; }
+        else if(aType.match("FooterShape", 26)) { eShapeType = XmlShapeTypePresFooterShape; }
+        else if(aType.match("SlideNumberShape", 26)) { eShapeType = XmlShapeTypePresSlideNumberShape; }
+        else if(aType.match("DateTimeShape", 26)) { eShapeType = XmlShapeTypePresDateTimeShape; }
+        else if(aType.match("MediaShape", 26)) { eShapeType = XmlShapeTypePresMediaShape; }
+    }
+}
+
+/** exports all user defined gluepoints */
+void XMLShapeExport::ImpExportGluePoints( const uno::Reference< drawing::XShape >& xShape )
+{
+    uno::Reference< drawing::XGluePointsSupplier > xSupplier( xShape, uno::UNO_QUERY );
+    if( !xSupplier.is() )
+        return;
+
+    uno::Reference< container::XIdentifierAccess > xGluePoints( xSupplier->getGluePoints(), uno::UNO_QUERY );
+    if( !xGluePoints.is() )
+        return;
+
+    drawing::GluePoint2 aGluePoint;
+
+    const uno::Sequence< sal_Int32 > aIdSequence( xGluePoints->getIdentifiers() );
+
+    for( const sal_Int32 nIdentifier : aIdSequence )
+    {
+        if( (xGluePoints->getByIdentifier( nIdentifier ) >>= aGluePoint) && aGluePoint.IsUserDefined )
+        {
+            // export only user defined gluepoints
+
+            const OUString sId( OUString::number( nIdentifier ) );
+            mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_ID, sId );
+
+            mrExport.GetMM100UnitConverter().convertMeasureToXML(msBuffer,
+                    aGluePoint.Position.X);
+            mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X, msBuffer.makeStringAndClear());
+
+            mrExport.GetMM100UnitConverter().convertMeasureToXML(msBuffer,
+                    aGluePoint.Position.Y);
+            mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y, msBuffer.makeStringAndClear());
+
+            if( !aGluePoint.IsRelative )
+            {
+                SvXMLUnitConverter::convertEnum( msBuffer, aGluePoint.PositionAlignment, aXML_GlueAlignment_EnumMap );
+                mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_ALIGN, msBuffer.makeStringAndClear() );
+            }
+
+            if( aGluePoint.Escape != drawing::EscapeDirection_SMART )
+            {
+                SvXMLUnitConverter::convertEnum( msBuffer, aGluePoint.Escape, aXML_GlueEscapeDirection_EnumMap );
+                mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_ESCAPE_DIRECTION, msBuffer.makeStringAndClear() );
+            }
+
+            SvXMLElementExport aEventsElemt(mrExport, XML_NAMESPACE_DRAW, XML_GLUE_POINT, true, true);
+        }
+    }
+}
+
+void XMLShapeExport::ImpExportSignatureLine(const uno::Reference<drawing::XShape>& xShape)
+{
+    uno::Reference<beans::XPropertySet> xPropSet(xShape, uno::UNO_QUERY);
+
+    bool bIsSignatureLine = false;
+    xPropSet->getPropertyValue("IsSignatureLine") >>= bIsSignatureLine;
+    if (!bIsSignatureLine)
+        return;
+
+    OUString aSignatureLineId;
+    xPropSet->getPropertyValue("SignatureLineId") >>= aSignatureLineId;
+    mrExport.AddAttribute(XML_NAMESPACE_LO_EXT, XML_ID, aSignatureLineId);
+
+    OUString aSuggestedSignerName;
+    xPropSet->getPropertyValue("SignatureLineSuggestedSignerName") >>= aSuggestedSignerName;
+    if (!aSuggestedSignerName.isEmpty())
+        mrExport.AddAttribute(XML_NAMESPACE_LO_EXT, XML_SUGGESTED_SIGNER_NAME, aSuggestedSignerName);
+
+    OUString aSuggestedSignerTitle;
+    xPropSet->getPropertyValue("SignatureLineSuggestedSignerTitle") >>= aSuggestedSignerTitle;
+    if (!aSuggestedSignerTitle.isEmpty())
+        mrExport.AddAttribute(XML_NAMESPACE_LO_EXT, XML_SUGGESTED_SIGNER_TITLE, aSuggestedSignerTitle);
+
+    OUString aSuggestedSignerEmail;
+    xPropSet->getPropertyValue("SignatureLineSuggestedSignerEmail") >>= aSuggestedSignerEmail;
+    if (!aSuggestedSignerEmail.isEmpty())
+        mrExport.AddAttribute(XML_NAMESPACE_LO_EXT, XML_SUGGESTED_SIGNER_EMAIL, aSuggestedSignerEmail);
+
+    OUString aSigningInstructions;
+    xPropSet->getPropertyValue("SignatureLineSigningInstructions") >>= aSigningInstructions;
+    if (!aSigningInstructions.isEmpty())
+        mrExport.AddAttribute(XML_NAMESPACE_LO_EXT, XML_SIGNING_INSTRUCTIONS, aSigningInstructions);
+
+    bool bShowSignDate = false;
+    xPropSet->getPropertyValue("SignatureLineShowSignDate") >>= bShowSignDate;
+    mrExport.AddAttribute(XML_NAMESPACE_LO_EXT, XML_SHOW_SIGN_DATE,
+                          bShowSignDate ? XML_TRUE : XML_FALSE);
+
+    bool bCanAddComment = false;
+    xPropSet->getPropertyValue("SignatureLineCanAddComment") >>= bCanAddComment;
+    mrExport.AddAttribute(XML_NAMESPACE_LO_EXT, XML_CAN_ADD_COMMENT,
+                          bCanAddComment ? XML_TRUE : XML_FALSE);
+
+    SvXMLElementExport aSignatureLineElement(mrExport, XML_NAMESPACE_LO_EXT, XML_SIGNATURELINE, true,
+                                             true);
+}
+
+void XMLShapeExport::ImpExportQRCode(const uno::Reference<drawing::XShape>& xShape)
+{
+    uno::Reference<beans::XPropertySet> xPropSet(xShape, uno::UNO_QUERY);
+
+    uno::Any aAny = xPropSet->getPropertyValue("BarCodeProperties");
+
+    css::drawing::BarCode aBarCode;
+    if(!(aAny >>= aBarCode))
+        return;
+
+    mrExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_STRING_VALUE, aBarCode.Payload);
+    /* Export QR Code as per customised schema, @see OpenDocument-schema-v1.3+libreoffice */
+    OUString temp;
+    switch(aBarCode.ErrorCorrection){
+        case css::drawing::BarCodeErrorCorrection::LOW :
+            temp = "low";
+            break;
+        case css::drawing::BarCodeErrorCorrection::MEDIUM:
+            temp = "medium";
+            break;
+        case css::drawing::BarCodeErrorCorrection::QUARTILE:
+            temp = "quartile";
+            break;
+        case css::drawing::BarCodeErrorCorrection::HIGH:
+            temp = "high";
+            break;
+    }
+    mrExport.AddAttribute(XML_NAMESPACE_LO_EXT, XML_QRCODE_ERROR_CORRECTION, temp);
+    mrExport.AddAttribute(XML_NAMESPACE_LO_EXT, XML_QRCODE_BORDER, OUStringBuffer(20).append(aBarCode.Border).makeStringAndClear());
+    mrExport.AddAttribute(XML_NAMESPACE_LO_EXT, XML_QRCODE_TYPE, OUStringBuffer(20).append(aBarCode.Type).makeStringAndClear());
+
+    SvXMLElementExport aBarCodeElement(mrExport, XML_NAMESPACE_LO_EXT, XML_QRCODE, true,
+                                            true);
+}
+
+void XMLShapeExport::ExportGraphicDefaults()
+{
+    rtl::Reference<XMLStyleExport> aStEx(new XMLStyleExport(mrExport, mrExport.GetAutoStylePool().get()));
+
+    // construct PropertySetMapper
+    rtl::Reference< SvXMLExportPropertyMapper > xPropertySetMapper( CreateShapePropMapper( mrExport ) );
+    static_cast<XMLShapeExportPropertyMapper*>(xPropertySetMapper.get())->SetAutoStyles( false );
+
+    // chain text attributes
+    xPropertySetMapper->ChainExportMapper(XMLTextParagraphExport::CreateParaExtPropMapper(mrExport));
+
+    // chain special Writer/text frame default attributes
+    xPropertySetMapper->ChainExportMapper(XMLTextParagraphExport::CreateParaDefaultExtPropMapper(mrExport));
+
+    // write graphic family default style
+    uno::Reference< lang::XMultiServiceFactory > xFact( mrExport.GetModel(), uno::UNO_QUERY );
+    if( !xFact.is() )
+        return;
+
+    try
+    {
+        uno::Reference< beans::XPropertySet > xDefaults( xFact->createInstance("com.sun.star.drawing.Defaults"), uno::UNO_QUERY );
+        if( xDefaults.is() )
+        {
+            aStEx->exportDefaultStyle( xDefaults, XML_STYLE_FAMILY_SD_GRAPHICS_NAME, xPropertySetMapper );
+
+            // write graphic family styles
+            aStEx->exportStyleFamily("graphics", OUString(XML_STYLE_FAMILY_SD_GRAPHICS_NAME), xPropertySetMapper, false, XmlStyleFamily::SD_GRAPHICS_ID);
+        }
+    }
+    catch(const lang::ServiceNotRegisteredException&)
+    {
+    }
+}
+
+void XMLShapeExport::onExport( const css::uno::Reference < css::drawing::XShape >& )
+{
+}
+
+const rtl::Reference< XMLTableExport >& XMLShapeExport::GetShapeTableExport()
+{
+    if( !mxShapeTableExport.is() )
+    {
+        rtl::Reference< XMLPropertyHandlerFactory > xFactory( new XMLSdPropHdlFactory( mrExport.GetModel(), mrExport ) );
+        rtl::Reference < XMLPropertySetMapper > xMapper( new XMLShapePropertySetMapper( xFactory, true ) );
+        mrExport.GetTextParagraphExport(); // get or create text paragraph export
+        rtl::Reference< SvXMLExportPropertyMapper > xPropertySetMapper( new XMLShapeExportPropertyMapper( xMapper, mrExport ) );
+        mxShapeTableExport = new XMLTableExport( mrExport, xPropertySetMapper, xFactory );
+    }
+
+    return mxShapeTableExport;
+}
+
+void XMLShapeExport::ImpExportNewTrans(const uno::Reference< beans::XPropertySet >& xPropSet,
+    XMLShapeExportFlags nFeatures, awt::Point* pRefPoint)
+{
+    // get matrix
+    ::basegfx::B2DHomMatrix aMatrix;
+    ImpExportNewTrans_GetB2DHomMatrix(aMatrix, xPropSet);
+
+    // decompose and correct about pRefPoint
+    ::basegfx::B2DTuple aTRScale;
+    double fTRShear(0.0);
+    double fTRRotate(0.0);
+    ::basegfx::B2DTuple aTRTranslate;
+    ImpExportNewTrans_DecomposeAndRefPoint(aMatrix, aTRScale, fTRShear, fTRRotate, aTRTranslate, pRefPoint);
+
+    // use features and write
+    ImpExportNewTrans_FeaturesAndWrite(aTRScale, fTRShear, fTRRotate, aTRTranslate, nFeatures);
+}
+
+void XMLShapeExport::ImpExportNewTrans_GetB2DHomMatrix(::basegfx::B2DHomMatrix& rMatrix,
+    const uno::Reference< beans::XPropertySet >& xPropSet)
+{
+    /* Get <TransformationInHoriL2R>, if it exist
+       and if the document is exported into the OpenOffice.org file format.
+       This property only exists at service css::text::Shape - the
+       Writer UNO service for shapes.
+       This code is needed, because the positioning attributes in the
+       OpenOffice.org file format are given in horizontal left-to-right layout
+       regardless the layout direction the shape is in. In the OASIS Open Office
+       file format the positioning attributes are correctly given in the layout
+       direction the shape is in. Thus, this code provides the conversion from
+       the OASIS Open Office file format to the OpenOffice.org file format. (#i28749#)
+    */
+    uno::Any aAny;
+    if ( !( GetExport().getExportFlags() & SvXMLExportFlags::OASIS ) &&
+         xPropSet->getPropertySetInfo()->hasPropertyByName("TransformationInHoriL2R") )
+    {
+        aAny = xPropSet->getPropertyValue("TransformationInHoriL2R");
+    }
+    else
+    {
+        aAny = xPropSet->getPropertyValue("Transformation");
+    }
+    drawing::HomogenMatrix3 aMatrix;
+    aAny >>= aMatrix;
+
+    rMatrix.set(0, 0, aMatrix.Line1.Column1);
+    rMatrix.set(0, 1, aMatrix.Line1.Column2);
+    rMatrix.set(0, 2, aMatrix.Line1.Column3);
+    rMatrix.set(1, 0, aMatrix.Line2.Column1);
+    rMatrix.set(1, 1, aMatrix.Line2.Column2);
+    rMatrix.set(1, 2, aMatrix.Line2.Column3);
+    rMatrix.set(2, 0, aMatrix.Line3.Column1);
+    rMatrix.set(2, 1, aMatrix.Line3.Column2);
+    rMatrix.set(2, 2, aMatrix.Line3.Column3);
+}
+
+void XMLShapeExport::ImpExportNewTrans_DecomposeAndRefPoint(const ::basegfx::B2DHomMatrix& rMatrix, ::basegfx::B2DTuple& rTRScale,
+    double& fTRShear, double& fTRRotate, ::basegfx::B2DTuple& rTRTranslate, css::awt::Point* pRefPoint)
+{
+    // decompose matrix
+    rMatrix.decompose(rTRScale, rTRTranslate, fTRRotate, fTRShear);
+
+    // correct translation about pRefPoint
+    if(pRefPoint)
+    {
+        rTRTranslate -= ::basegfx::B2DTuple(pRefPoint->X, pRefPoint->Y);
+    }
+}
+
+void XMLShapeExport::ImpExportNewTrans_FeaturesAndWrite(::basegfx::B2DTuple const & rTRScale, double fTRShear,
+    double fTRRotate, ::basegfx::B2DTuple const & rTRTranslate, const XMLShapeExportFlags nFeatures)
+{
+    // always write Size (rTRScale) since this statement carries the union
+    // of the object
+    OUString aStr;
+    OUStringBuffer sStringBuffer;
+    ::basegfx::B2DTuple aTRScale(rTRScale);
+
+    // svg: width
+    if(!(nFeatures & XMLShapeExportFlags::WIDTH))
+    {
+        aTRScale.setX(1.0);
+    }
+    else
+    {
+        if( aTRScale.getX() > 0.0 )
+            aTRScale.setX(aTRScale.getX() - 1.0);
+        else if( aTRScale.getX() < 0.0 )
+            aTRScale.setX(aTRScale.getX() + 1.0);
+    }
+
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+            FRound(aTRScale.getX()));
+    aStr = sStringBuffer.makeStringAndClear();
+    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_WIDTH, aStr);
+
+    // svg: height
+    if(!(nFeatures & XMLShapeExportFlags::HEIGHT))
+    {
+        aTRScale.setY(1.0);
+    }
+    else
+    {
+        if( aTRScale.getY() > 0.0 )
+            aTRScale.setY(aTRScale.getY() - 1.0);
+        else if( aTRScale.getY() < 0.0 )
+            aTRScale.setY(aTRScale.getY() + 1.0);
+    }
+
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+            FRound(aTRScale.getY()));
+    aStr = sStringBuffer.makeStringAndClear();
+    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_HEIGHT, aStr);
+
+    // decide if transformation is necessary
+    bool bTransformationIsNecessary(fTRShear != 0.0 || fTRRotate != 0.0);
+
+    if(bTransformationIsNecessary)
+    {
+        // write transformation, but WITHOUT scale which is exported as size above
+        SdXMLImExTransform2D aTransform;
+
+        aTransform.AddSkewX(atan(fTRShear));
+
+        // #i78696#
+        // fTRRotate is mathematically correct, but due to the error
+        // we export/import it mirrored. Since the API implementation is fixed and
+        // uses the correctly oriented angle, it is necessary for compatibility to
+        // mirror the angle here to stay at the old behaviour. There is a follow-up
+        // task (#i78698#) to fix this in the next ODF FileFormat version
+        aTransform.AddRotate(-fTRRotate);
+
+        aTransform.AddTranslate(rTRTranslate);
+
+        // does transformation need to be exported?
+        if(aTransform.NeedsAction())
+            mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_TRANSFORM, aTransform.GetExportString(mrExport.GetMM100UnitConverter()));
+    }
+    else
+    {
+        // no shear, no rotate; just add object position to export and we are done
+        if(nFeatures & XMLShapeExportFlags::X)
+        {
+            // svg: x
+            mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                    FRound(rTRTranslate.getX()));
+            aStr = sStringBuffer.makeStringAndClear();
+            mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X, aStr);
+        }
+
+        if(nFeatures & XMLShapeExportFlags::Y)
+        {
+            // svg: y
+            mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                    FRound(rTRTranslate.getY()));
+            aStr = sStringBuffer.makeStringAndClear();
+            mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y, aStr);
+        }
+    }
+}
+
+bool XMLShapeExport::ImpExportPresentationAttributes( const uno::Reference< beans::XPropertySet >& xPropSet, const OUString& rClass )
+{
+    bool bIsEmpty = false;
+
+    // write presentation class entry
+    mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_CLASS, rClass);
+
+    if( xPropSet.is() )
+    {
+        uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
+
+
+        // is empty pres. shape?
+        if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName("IsEmptyPresentationObject"))
+        {
+            xPropSet->getPropertyValue("IsEmptyPresentationObject") >>= bIsEmpty;
+            if( bIsEmpty )
+                mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_PLACEHOLDER, XML_TRUE);
+        }
+
+        // is user-transformed?
+        if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName("IsPlaceholderDependent"))
+        {
+            bool bTemp = false;
+            xPropSet->getPropertyValue("IsPlaceholderDependent") >>= bTemp;
+            if(!bTemp)
+                mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_USER_TRANSFORMED, XML_TRUE);
+        }
+    }
+
+    return bIsEmpty;
+}
+
+void XMLShapeExport::ImpExportText( const uno::Reference< drawing::XShape >& xShape, TextPNS eExtensionNS )
+{
+    if (eExtensionNS == TextPNS::EXTENSION)
+    {
+        if ((mrExport.getSaneDefaultVersion() & SvtSaveOptions::ODFSVER_EXTENDED) == 0)
+        {
+            return; // do not export to ODF 1.1/1.2/1.3
+        }
+    }
+    uno::Reference< text::XText > xText( xShape, uno::UNO_QUERY );
+    if( xText.is() )
+    {
+        uno::Reference< container::XEnumerationAccess > xEnumAccess( xShape, uno::UNO_QUERY );
+        if( xEnumAccess.is() && xEnumAccess->hasElements() )
+            mrExport.GetTextParagraphExport()->exportText( xText, false, true, eExtensionNS );
+    }
+}
+
+namespace {
+
+enum class Found {
+    NONE              = 0x0000,
+    CLICKACTION       = 0x0001,
+    BOOKMARK          = 0x0002,
+    EFFECT            = 0x0004,
+    PLAYFULL          = 0x0008,
+    VERB              = 0x0010,
+    SOUNDURL          = 0x0020,
+    SPEED             = 0x0040,
+    CLICKEVENTTYPE    = 0x0080,
+    MACRO             = 0x0100,
+    LIBRARY           = 0x0200,
+};
+
+}
+
+namespace o3tl {
+    template<> struct typed_flags<Found> : is_typed_flags<Found, 0x03ff> {};
+}
+
+void XMLShapeExport::ImpExportEvents( const uno::Reference< drawing::XShape >& xShape )
+{
+    uno::Reference< document::XEventsSupplier > xEventsSupplier( xShape, uno::UNO_QUERY );
+    if( !xEventsSupplier.is() )
+        return;
+
+    uno::Reference< container::XNameAccess > xEvents = xEventsSupplier->getEvents();
+    SAL_WARN_IF( !xEvents.is(), "xmloff", "XEventsSupplier::getEvents() returned NULL" );
+    if( !xEvents.is() )
+        return;
+
+    Found nFound = Found::NONE;
+
+    OUString aClickEventType;
+    presentation::ClickAction eClickAction = presentation::ClickAction_NONE;
+    presentation::AnimationEffect eEffect = presentation::AnimationEffect_NONE;
+    presentation::AnimationSpeed eSpeed = presentation::AnimationSpeed_SLOW;
+    OUString aStrSoundURL;
+    bool bPlayFull = false;
+    sal_Int32 nVerb = 0;
+    OUString aStrMacro;
+    OUString aStrLibrary;
+    OUString aStrBookmark;
+
+    uno::Sequence< beans::PropertyValue > aClickProperties;
+    if( xEvents->hasByName( gsOnClick ) && (xEvents->getByName( gsOnClick ) >>= aClickProperties) )
+    {
+        for( const auto& rProperty : std::as_const(aClickProperties) )
+        {
+            if( !( nFound & Found::CLICKEVENTTYPE ) && rProperty.Name == gsEventType )
+            {
+                if( rProperty.Value >>= aClickEventType )
+                    nFound |= Found::CLICKEVENTTYPE;
+            }
+            else if( !( nFound & Found::CLICKACTION ) && rProperty.Name == gsClickAction )
+            {
+                if( rProperty.Value >>= eClickAction )
+                    nFound |= Found::CLICKACTION;
+            }
+            else if( !( nFound & Found::MACRO ) && ( rProperty.Name == gsMacroName || rProperty.Name == gsScript ) )
+            {
+                if( rProperty.Value >>= aStrMacro )
+                    nFound |= Found::MACRO;
+            }
+            else if( !( nFound & Found::LIBRARY ) && rProperty.Name == gsLibrary )
+            {
+                if( rProperty.Value >>= aStrLibrary )
+                    nFound |= Found::LIBRARY;
+            }
+            else if( !( nFound & Found::EFFECT ) && rProperty.Name == gsEffect )
+            {
+                if( rProperty.Value >>= eEffect )
+                    nFound |= Found::EFFECT;
+            }
+            else if( !( nFound & Found::BOOKMARK ) && rProperty.Name == gsBookmark )
+            {
+                if( rProperty.Value >>= aStrBookmark )
+                    nFound |= Found::BOOKMARK;
+            }
+            else if( !( nFound & Found::SPEED ) && rProperty.Name == gsSpeed )
+            {
+                if( rProperty.Value >>= eSpeed )
+                    nFound |= Found::SPEED;
+            }
+            else if( !( nFound & Found::SOUNDURL ) && rProperty.Name == gsSoundURL )
+            {
+                if( rProperty.Value >>= aStrSoundURL )
+                    nFound |= Found::SOUNDURL;
+            }
+            else if( !( nFound & Found::PLAYFULL ) && rProperty.Name == gsPlayFull )
+            {
+                if( rProperty.Value >>= bPlayFull )
+                    nFound |= Found::PLAYFULL;
+            }
+            else if( !( nFound & Found::VERB ) && rProperty.Name == gsVerb )
+            {
+                if( rProperty.Value >>= nVerb )
+                    nFound |= Found::VERB;
+            }
+        }
+    }
+
+    // create the XML elements
+
+    if( aClickEventType == gsPresentation )
+    {
+        if( !(nFound & Found::CLICKACTION) || (eClickAction == presentation::ClickAction_NONE) )
+            return;
+
+        SvXMLElementExport aEventsElemt(mrExport, XML_NAMESPACE_OFFICE, XML_EVENT_LISTENERS, true, true);
+
+        enum XMLTokenEnum eStrAction;
+
+        switch( eClickAction )
+        {
+            case presentation::ClickAction_PREVPAGE:        eStrAction = XML_PREVIOUS_PAGE; break;
+            case presentation::ClickAction_NEXTPAGE:        eStrAction = XML_NEXT_PAGE; break;
+            case presentation::ClickAction_FIRSTPAGE:       eStrAction = XML_FIRST_PAGE; break;
+            case presentation::ClickAction_LASTPAGE:        eStrAction = XML_LAST_PAGE; break;
+            case presentation::ClickAction_INVISIBLE:       eStrAction = XML_HIDE; break;
+            case presentation::ClickAction_STOPPRESENTATION:eStrAction = XML_STOP; break;
+            case presentation::ClickAction_PROGRAM:         eStrAction = XML_EXECUTE; break;
+            case presentation::ClickAction_BOOKMARK:        eStrAction = XML_SHOW; break;
+            case presentation::ClickAction_DOCUMENT:        eStrAction = XML_SHOW; break;
+            case presentation::ClickAction_MACRO:           eStrAction = XML_EXECUTE_MACRO; break;
+            case presentation::ClickAction_VERB:            eStrAction = XML_VERB; break;
+            case presentation::ClickAction_VANISH:          eStrAction = XML_FADE_OUT; break;
+            case presentation::ClickAction_SOUND:           eStrAction = XML_SOUND; break;
+            default:
+                OSL_FAIL( "unknown presentation::ClickAction found!" );
+                eStrAction = XML_UNKNOWN;
+        }
+
+        OUString aEventQName(
+            mrExport.GetNamespaceMap().GetQNameByKey(
+                    XML_NAMESPACE_DOM, "click" ) );
+        mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_EVENT_NAME, aEventQName );
+        mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_ACTION, eStrAction );
+
+        if( eClickAction == presentation::ClickAction_VANISH )
+        {
+            if( nFound & Found::EFFECT )
+            {
+                XMLEffect eKind;
+                XMLEffectDirection eDirection;
+                sal_Int16 nStartScale;
+                bool bIn;
+
+                SdXMLImplSetEffect( eEffect, eKind, eDirection, nStartScale, bIn );
+
+                if( eKind != EK_none )
+                {
+                    SvXMLUnitConverter::convertEnum( msBuffer, eKind, aXML_AnimationEffect_EnumMap );
+                    mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_EFFECT, msBuffer.makeStringAndClear() );
+                }
+
+                if( eDirection != ED_none )
+                {
+                    SvXMLUnitConverter::convertEnum( msBuffer, eDirection, aXML_AnimationDirection_EnumMap );
+                    mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_DIRECTION, msBuffer.makeStringAndClear() );
+                }
+
+                if( nStartScale != -1 )
+                {
+                    ::sax::Converter::convertPercent( msBuffer, nStartScale );
+                    mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_START_SCALE, msBuffer.makeStringAndClear() );
+                }
+            }
+
+            if( nFound & Found::SPEED && eEffect != presentation::AnimationEffect_NONE )
+            {
+                if( eSpeed != presentation::AnimationSpeed_MEDIUM )
+                {
+                    SvXMLUnitConverter::convertEnum( msBuffer, eSpeed, aXML_AnimationSpeed_EnumMap );
+                    mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_SPEED, msBuffer.makeStringAndClear() );
+                }
+            }
+        }
+
+        if( eClickAction == presentation::ClickAction_PROGRAM ||
+            eClickAction == presentation::ClickAction_BOOKMARK ||
+            eClickAction == presentation::ClickAction_DOCUMENT )
+        {
+            if( eClickAction == presentation::ClickAction_BOOKMARK )
+                msBuffer.append( '#' );
+
+            msBuffer.append( aStrBookmark );
+            mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(msBuffer.makeStringAndClear()) );
+            mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+            mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+            mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONREQUEST );
+        }
+
+        if( ( nFound & Found::VERB ) && eClickAction == presentation::ClickAction_VERB )
+        {
+            msBuffer.append( nVerb );
+            mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_VERB, msBuffer.makeStringAndClear());
+        }
+
+        SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_PRESENTATION, XML_EVENT_LISTENER, true, true);
+
+        if( eClickAction == presentation::ClickAction_VANISH || eClickAction == presentation::ClickAction_SOUND )
+        {
+            if( ( nFound & Found::SOUNDURL ) && !aStrSoundURL.isEmpty() )
+            {
+                mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStrSoundURL) );
+                mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+                mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_NEW );
+                mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONREQUEST );
+                if( nFound & Found::PLAYFULL && bPlayFull )
+                    mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_PLAY_FULL, XML_TRUE );
+
+                SvXMLElementExport aElem( mrExport, XML_NAMESPACE_PRESENTATION, XML_SOUND, true, true );
+            }
+        }
+    }
+    else if( aClickEventType == gsStarBasic )
+    {
+        if( nFound & Found::MACRO )
+        {
+            SvXMLElementExport aEventsElemt(mrExport, XML_NAMESPACE_OFFICE, XML_EVENT_LISTENERS, true, true);
+
+            mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_LANGUAGE,
+                        mrExport.GetNamespaceMap().GetQNameByKey(
+                            XML_NAMESPACE_OOO,
+                            "starbasic" ) );
+            OUString aEventQName(
+                mrExport.GetNamespaceMap().GetQNameByKey(
+                        XML_NAMESPACE_DOM, "click" ) );
+            mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_EVENT_NAME, aEventQName );
+
+            if( nFound & Found::LIBRARY )
+            {
+                const OUString& sLocation( GetXMLToken(
+                    (aStrLibrary.equalsIgnoreAsciiCase("StarOffice") ||
+                     aStrLibrary.equalsIgnoreAsciiCase("application") ) ? XML_APPLICATION
+                                                                       : XML_DOCUMENT ) );
+                mrExport.AddAttribute(XML_NAMESPACE_SCRIPT, XML_MACRO_NAME,
+                    sLocation + ":" + aStrMacro);
+            }
+            else
+            {
+                mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_MACRO_NAME, aStrMacro );
+            }
+
+            SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SCRIPT, XML_EVENT_LISTENER, true, true);
+        }
+    }
+    else if( aClickEventType == gsScript )
+    {
+        if( nFound & Found::MACRO )
+        {
+            SvXMLElementExport aEventsElemt(mrExport, XML_NAMESPACE_OFFICE, XML_EVENT_LISTENERS, true, true);
+
+            mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_LANGUAGE, mrExport.GetNamespaceMap().GetQNameByKey(
+                     XML_NAMESPACE_OOO, GetXMLToken(XML_SCRIPT) ) );
+            OUString aEventQName(
+                mrExport.GetNamespaceMap().GetQNameByKey(
+                        XML_NAMESPACE_DOM, "click" ) );
+            mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_EVENT_NAME, aEventQName );
+            mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, aStrMacro );
+            mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, "simple" );
+
+            SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SCRIPT, XML_EVENT_LISTENER, true, true);
+        }
+    }
+}
+
+/** #i68101# export shape Title and Description */
+void XMLShapeExport::ImpExportDescription( const uno::Reference< drawing::XShape >& xShape )
+{
+    try
+    {
+        OUString aTitle;
+        OUString aDescription;
+
+        uno::Reference< beans::XPropertySet > xProps( xShape, uno::UNO_QUERY_THROW );
+        xProps->getPropertyValue("Title") >>= aTitle;
+        xProps->getPropertyValue("Description") >>= aDescription;
+
+        if(!aTitle.isEmpty())
+        {
+            SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SVG, XML_TITLE, true, false);
+            mrExport.Characters( aTitle );
+        }
+
+        if(!aDescription.isEmpty())
+        {
+            SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SVG, XML_DESC, true, false );
+            mrExport.Characters( aDescription );
+        }
+    }
+    catch( uno::Exception& )
+    {
+        DBG_UNHANDLED_EXCEPTION( "xmloff", "exporting Title and/or Description for shape" );
+    }
+}
+
+void XMLShapeExport::ImpExportGroupShape( const uno::Reference< drawing::XShape >& xShape, XMLShapeExportFlags nFeatures, awt::Point* pRefPoint)
+{
+    uno::Reference< drawing::XShapes > xShapes(xShape, uno::UNO_QUERY);
+    if(!(xShapes.is() && xShapes->getCount()))
+        return;
+
+    // write group shape
+    bool bCreateNewline( (nFeatures & XMLShapeExportFlags::NO_WS) == XMLShapeExportFlags::NONE ); // #86116#/#92210#
+    SvXMLElementExport aPGR(mrExport, XML_NAMESPACE_DRAW, XML_G, bCreateNewline, true);
+
+    ImpExportDescription( xShape ); // #i68101#
+    ImpExportEvents( xShape );
+    ImpExportGluePoints( xShape );
+
+    // #89764# if export of position is suppressed for group shape,
+    // positions of contained objects should be written relative to
+    // the upper left edge of the group.
+    awt::Point aUpperLeft;
+
+    if(!(nFeatures & XMLShapeExportFlags::POSITION))
+    {
+        nFeatures |= XMLShapeExportFlags::POSITION;
+        aUpperLeft = xShape->getPosition();
+        pRefPoint = &aUpperLeft;
+    }
+
+    // write members
+    exportShapes( xShapes, nFeatures, pRefPoint );
+}
+
+void XMLShapeExport::ImpExportTextBoxShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType eShapeType, XMLShapeExportFlags nFeatures, awt::Point* pRefPoint)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(!xPropSet.is())
+        return;
+
+    // presentation attribute (if presentation)
+    bool bIsPresShape(false);
+    bool bIsEmptyPresObj(false);
+    OUString aStr;
+
+    switch(eShapeType)
+    {
+        case XmlShapeTypePresSubtitleShape:
+        {
+            aStr = GetXMLToken(XML_SUBTITLE);
+            bIsPresShape = true;
+            break;
+        }
+        case XmlShapeTypePresTitleTextShape:
+        {
+            aStr = GetXMLToken(XML_TITLE);
+            bIsPresShape = true;
+            break;
+        }
+        case XmlShapeTypePresOutlinerShape:
+        {
+            aStr = GetXMLToken(XML_PRESENTATION_OUTLINE);
+            bIsPresShape = true;
+            break;
+        }
+        case XmlShapeTypePresNotesShape:
+        {
+            aStr = GetXMLToken(XML_NOTES);
+            bIsPresShape = true;
+            break;
+        }
+        case XmlShapeTypePresHeaderShape:
+        {
+            aStr = GetXMLToken(XML_HEADER);
+            bIsPresShape = true;
+            break;
+        }
+        case XmlShapeTypePresFooterShape:
+        {
+            aStr = GetXMLToken(XML_FOOTER);
+            bIsPresShape = true;
+            break;
+        }
+        case XmlShapeTypePresSlideNumberShape:
+        {
+            aStr = GetXMLToken(XML_PAGE_NUMBER);
+            bIsPresShape = true;
+            break;
+        }
+        case XmlShapeTypePresDateTimeShape:
+        {
+            aStr = GetXMLToken(XML_DATE_TIME);
+            bIsPresShape = true;
+            break;
+        }
+        default:
+            break;
+    }
+
+    // Transformation
+    ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+    if(bIsPresShape)
+        bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, aStr );
+
+    bool bCreateNewline( (nFeatures & XMLShapeExportFlags::NO_WS) == XMLShapeExportFlags::NONE ); // #86116#/#92210#
+    SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW,
+                              XML_FRAME, bCreateNewline, true );
+
+    // evtl. corner radius?
+    sal_Int32 nCornerRadius(0);
+    xPropSet->getPropertyValue("CornerRadius") >>= nCornerRadius;
+    if(nCornerRadius)
+    {
+        OUStringBuffer sStringBuffer;
+        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                nCornerRadius);
+        mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CORNER_RADIUS, sStringBuffer.makeStringAndClear());
+    }
+
+    {
+        // write text-box
+        SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_TEXT_BOX, true, true);
+        if(!bIsEmptyPresObj)
+            ImpExportText( xShape );
+    }
+
+    ImpExportDescription( xShape ); // #i68101#
+    ImpExportEvents( xShape );
+    ImpExportGluePoints( xShape );
+
+}
+
+void XMLShapeExport::ImpExportRectangleShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XMLShapeExportFlags nFeatures, css::awt::Point* pRefPoint)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(!xPropSet.is())
+        return;
+
+    // Transformation
+    ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+    // evtl. corner radius?
+    sal_Int32 nCornerRadius(0);
+    xPropSet->getPropertyValue("CornerRadius") >>= nCornerRadius;
+    if(nCornerRadius)
+    {
+        OUStringBuffer sStringBuffer;
+        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                nCornerRadius);
+        mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CORNER_RADIUS, sStringBuffer.makeStringAndClear());
+    }
+
+    // write rectangle
+    bool bCreateNewline( (nFeatures & XMLShapeExportFlags::NO_WS) == XMLShapeExportFlags::NONE ); // #86116#/#92210#
+    SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_RECT, bCreateNewline, true);
+
+    ImpExportDescription( xShape ); // #i68101#
+    ImpExportEvents( xShape );
+    ImpExportGluePoints( xShape );
+    ImpExportText( xShape );
+}
+
+void XMLShapeExport::ImpExportLineShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XMLShapeExportFlags nFeatures, awt::Point* pRefPoint)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(!xPropSet.is())
+        return;
+
+    OUString aStr;
+    OUStringBuffer sStringBuffer;
+    awt::Point aStart(0,0);
+    awt::Point aEnd(1,1);
+
+    // #85920# use 'Geometry' to get the points of the line
+    // since this slot take anchor pos into account.
+
+    // get matrix
+    ::basegfx::B2DHomMatrix aMatrix;
+    ImpExportNewTrans_GetB2DHomMatrix(aMatrix, xPropSet);
+
+    // decompose and correct about pRefPoint
+    ::basegfx::B2DTuple aTRScale;
+    double fTRShear(0.0);
+    double fTRRotate(0.0);
+    ::basegfx::B2DTuple aTRTranslate;
+    ImpExportNewTrans_DecomposeAndRefPoint(aMatrix, aTRScale, fTRShear, fTRRotate, aTRTranslate, pRefPoint);
+
+    // create base position
+    awt::Point aBasePosition(FRound(aTRTranslate.getX()), FRound(aTRTranslate.getY()));
+
+    if (xPropSet->getPropertySetInfo()->hasPropertyByName("Geometry"))
+    {
+        // get the two points
+        uno::Any aAny(xPropSet->getPropertyValue("Geometry"));
+        if (auto pSourcePolyPolygon
+                = o3tl::tryAccess<drawing::PointSequenceSequence>(aAny))
+        {
+            if (pSourcePolyPolygon->getLength() > 0)
+            {
+                const drawing::PointSequence& rInnerSequence = (*pSourcePolyPolygon)[0];
+                if (rInnerSequence.hasElements())
+                {
+                    const awt::Point& rPoint = rInnerSequence[0];
+                    aStart = awt::Point(rPoint.X + aBasePosition.X, rPoint.Y + aBasePosition.Y);
+                }
+                if (rInnerSequence.getLength() > 1)
+                {
+                    const awt::Point& rPoint = rInnerSequence[1];
+                    aEnd = awt::Point(rPoint.X + aBasePosition.X, rPoint.Y + aBasePosition.Y);
+                }
+            }
+        }
+    }
+
+    if( nFeatures & XMLShapeExportFlags::X )
+    {
+        // svg: x1
+        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                aStart.X);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X1, aStr);
+    }
+    else
+    {
+        aEnd.X -= aStart.X;
+    }
+
+    if( nFeatures & XMLShapeExportFlags::Y )
+    {
+        // svg: y1
+        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                aStart.Y);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y1, aStr);
+    }
+    else
+    {
+        aEnd.Y -= aStart.Y;
+    }
+
+    // svg: x2
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+            aEnd.X);
+    aStr = sStringBuffer.makeStringAndClear();
+    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X2, aStr);
+
+    // svg: y2
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+            aEnd.Y);
+    aStr = sStringBuffer.makeStringAndClear();
+    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y2, aStr);
+
+    // write line
+    bool bCreateNewline( (nFeatures & XMLShapeExportFlags::NO_WS) == XMLShapeExportFlags::NONE ); // #86116#/#92210#
+    SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_LINE, bCreateNewline, true);
+
+    ImpExportDescription( xShape ); // #i68101#
+    ImpExportEvents( xShape );
+    ImpExportGluePoints( xShape );
+    ImpExportText( xShape );
+
+}
+
+void XMLShapeExport::ImpExportEllipseShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XMLShapeExportFlags nFeatures, awt::Point* pRefPoint)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(!xPropSet.is())
+        return;
+
+    // get size to decide between Circle and Ellipse
+    awt::Size aSize = xShape->getSize();
+    sal_Int32 nRx((aSize.Width + 1) / 2);
+    sal_Int32 nRy((aSize.Height + 1) / 2);
+    bool bCircle(nRx == nRy);
+
+    // Transformation
+    ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+    drawing::CircleKind eKind = drawing::CircleKind_FULL;
+    xPropSet->getPropertyValue("CircleKind") >>= eKind;
+    if( eKind != drawing::CircleKind_FULL )
+    {
+        OUStringBuffer sStringBuffer;
+        sal_Int32 nStartAngle = 0;
+        sal_Int32 nEndAngle = 0;
+        xPropSet->getPropertyValue("CircleStartAngle") >>= nStartAngle;
+        xPropSet->getPropertyValue("CircleEndAngle") >>= nEndAngle;
+
+        const double dStartAngle = nStartAngle / 100.0;
+        const double dEndAngle = nEndAngle / 100.0;
+
+        // export circle kind
+        SvXMLUnitConverter::convertEnum( sStringBuffer, eKind, aXML_CircleKind_EnumMap );
+        mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_KIND, sStringBuffer.makeStringAndClear() );
+
+        // export start angle
+        ::sax::Converter::convertDouble( sStringBuffer, dStartAngle );
+        mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_START_ANGLE, sStringBuffer.makeStringAndClear() );
+
+        // export end angle
+        ::sax::Converter::convertDouble( sStringBuffer, dEndAngle );
+        mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_END_ANGLE, sStringBuffer.makeStringAndClear() );
+    }
+
+    bool bCreateNewline( (nFeatures & XMLShapeExportFlags::NO_WS) == XMLShapeExportFlags::NONE ); // #86116#/#92210#
+
+    // write ellipse or circle
+    SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW,
+                            bCircle ? XML_CIRCLE : XML_ELLIPSE,
+                            bCreateNewline, true);
+
+    ImpExportDescription( xShape ); // #i68101#
+    ImpExportEvents( xShape );
+    ImpExportGluePoints( xShape );
+    ImpExportText( xShape );
+
+}
+
+void XMLShapeExport::ImpExportPolygonShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType eShapeType, XMLShapeExportFlags nFeatures, awt::Point* pRefPoint)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(!xPropSet.is())
+        return;
+
+    bool bBezier(eShapeType == XmlShapeTypeDrawClosedBezierShape
+        || eShapeType == XmlShapeTypeDrawOpenBezierShape);
+
+    // get matrix
+    ::basegfx::B2DHomMatrix aMatrix;
+    ImpExportNewTrans_GetB2DHomMatrix(aMatrix, xPropSet);
+
+    // decompose and correct about pRefPoint
+    ::basegfx::B2DTuple aTRScale;
+    double fTRShear(0.0);
+    double fTRRotate(0.0);
+    ::basegfx::B2DTuple aTRTranslate;
+    ImpExportNewTrans_DecomposeAndRefPoint(aMatrix, aTRScale, fTRShear, fTRRotate, aTRTranslate, pRefPoint);
+
+    // use features and write
+    ImpExportNewTrans_FeaturesAndWrite(aTRScale, fTRShear, fTRRotate, aTRTranslate, nFeatures);
+
+    // create and export ViewBox
+    awt::Size aSize(FRound(aTRScale.getX()), FRound(aTRScale.getY()));
+    SdXMLImExViewBox aViewBox(0, 0, aSize.Width, aSize.Height);
+    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_VIEWBOX, aViewBox.GetExportString());
+
+    bool bCreateNewline( (nFeatures & XMLShapeExportFlags::NO_WS) == XMLShapeExportFlags::NONE ); // #86116#/#92210#
+
+    // prepare name (with most used)
+    enum ::xmloff::token::XMLTokenEnum eName(XML_PATH);
+
+    if(bBezier)
+    {
+        // get PolygonBezier
+        uno::Any aAny( xPropSet->getPropertyValue("Geometry") );
+        auto pSourcePolyPolygon = o3tl::tryAccess<drawing::PolyPolygonBezierCoords>(aAny);
+        if(pSourcePolyPolygon && pSourcePolyPolygon->Coordinates.getLength())
+        {
+            const basegfx::B2DPolyPolygon aPolyPolygon(
+                basegfx::utils::UnoPolyPolygonBezierCoordsToB2DPolyPolygon(
+                    *pSourcePolyPolygon));
+
+            // complex polygon shape, write as svg:d
+            const OUString aPolygonString(
+                basegfx::utils::exportToSvgD(
+                    aPolyPolygon,
+                    true,       // bUseRelativeCoordinates
+                    false,      // bDetectQuadraticBeziers: not used in old, but maybe activated now
+                    true));     // bHandleRelativeNextPointCompatible
+
+            // write point array
+            mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aPolygonString);
+        }
+    }
+    else
+    {
+        // get non-bezier polygon
+        uno::Any aAny( xPropSet->getPropertyValue("Geometry") );
+        const basegfx::B2DPolyPolygon aPolyPolygon(
+            basegfx::utils::UnoPointSequenceSequenceToB2DPolyPolygon(*o3tl::doAccess<drawing::PointSequenceSequence>(aAny)));
+
+        if(!aPolyPolygon.areControlPointsUsed() && 1 == aPolyPolygon.count())
+        {
+            // simple polygon shape, can be written as svg:points sequence
+            const basegfx::B2DPolygon& aPolygon(aPolyPolygon.getB2DPolygon(0));
+            const OUString aPointString(basegfx::utils::exportToSvgPoints(aPolygon));
+
+            // write point array
+            mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_POINTS, aPointString);
+
+            // set name
+            eName = aPolygon.isClosed() ? XML_POLYGON : XML_POLYLINE;
+        }
+        else
+        {
+            // complex polygon shape, write as svg:d
+            const OUString aPolygonString(
+                basegfx::utils::exportToSvgD(
+                    aPolyPolygon,
+                    true,       // bUseRelativeCoordinates
+                    false,      // bDetectQuadraticBeziers: not used in old, but maybe activated now
+                    true));     // bHandleRelativeNextPointCompatible
+
+            // write point array
+            mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aPolygonString);
+        }
+    }
+
+    // write object, but after attributes are added since this call will
+    // consume all of these added attributes and the destructor will close the
+    // scope. Also before text is added; this may add sub-scopes as needed
+    SvXMLElementExport aOBJ(
+        mrExport,
+        XML_NAMESPACE_DRAW,
+        eName,
+        bCreateNewline,
+        true);
+
+    ImpExportDescription( xShape ); // #i68101#
+    ImpExportEvents( xShape );
+    ImpExportGluePoints( xShape );
+    ImpExportText( xShape );
+
+}
+
+namespace
+{
+
+OUString getNameFromStreamURL(std::u16string_view rURL)
+{
+    static constexpr std::u16string_view sPackageURL(u"vnd.sun.star.Package:");
+
+    OUString sResult;
+
+    if (o3tl::starts_with(rURL, sPackageURL))
+    {
+        std::u16string_view sRequestedName = rURL.substr(sPackageURL.size());
+        size_t nLastIndex = sRequestedName.rfind('/') + 1;
+        if ((nLastIndex > 0) && (nLastIndex < sRequestedName.size()))
+            sRequestedName = sRequestedName.substr(nLastIndex);
+        nLastIndex = sRequestedName.rfind('.');
+        if (nLastIndex != std::u16string_view::npos)
+            sRequestedName = sRequestedName.substr(0, nLastIndex);
+        if (!sRequestedName.empty())
+            sResult = sRequestedName;
+    }
+
+    return sResult;
+}
+
+} // end anonymous namespace
+
+void XMLShapeExport::ImpExportGraphicObjectShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType eShapeType, XMLShapeExportFlags nFeatures, awt::Point* pRefPoint)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(!xPropSet.is())
+        return;
+
+    bool bIsEmptyPresObj = false;
+
+    // Transformation
+    ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+    if(eShapeType == XmlShapeTypePresGraphicObjectShape)
+        bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_GRAPHIC) );
+
+    bool bCreateNewline( (nFeatures & XMLShapeExportFlags::NO_WS) == XMLShapeExportFlags::NONE ); // #86116#/#92210#
+    SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW,
+                              XML_FRAME, bCreateNewline, true );
+
+    if (!bIsEmptyPresObj)
+    {
+        uno::Reference<graphic::XGraphic> xGraphic;
+        OUString sOutMimeType;
+
+        {
+            OUString aStreamURL;
+            xPropSet->getPropertyValue("GraphicStreamURL") >>= aStreamURL;
+            OUString sRequestedName = getNameFromStreamURL(aStreamURL);
+
+            xPropSet->getPropertyValue("Graphic") >>= xGraphic;
+
+            OUString sInternalURL;
+
+            if (xGraphic.is())
+                sInternalURL = mrExport.AddEmbeddedXGraphic(xGraphic, sOutMimeType, sRequestedName);
+
+            if (!sInternalURL.isEmpty())
+            {
+                // apply possible changed stream URL to embedded image object
+                if (!sRequestedName.isEmpty())
+                {
+                    OUString newStreamURL = "vnd.sun.star.Package:";
+                    if (sInternalURL[0] == '#')
+                    {
+                        newStreamURL += sInternalURL.subView(1, sInternalURL.getLength() - 1);
+                    }
+                    else
+                    {
+                        newStreamURL += sInternalURL;
+                    }
+
+                    if (newStreamURL != aStreamURL)
+                    {
+                        xPropSet->setPropertyValue("GraphicStreamURL", uno::Any(newStreamURL));
+                    }
+                }
+
+                mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sInternalURL);
+                mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE);
+                mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED);
+                mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD);
+            }
+        }
+
+        {
+            if (GetExport().getSaneDefaultVersion() > SvtSaveOptions::ODFSVER_012)
+            {
+                if (sOutMimeType.isEmpty())
+                {
+                    GetExport().GetGraphicMimeTypeFromStream(xGraphic, sOutMimeType);
+                }
+                if (!sOutMimeType.isEmpty())
+                {   // ODF 1.3 OFFICE-3943
+                    GetExport().AddAttribute(
+                        SvtSaveOptions::ODFSVER_013 <= GetExport().getSaneDefaultVersion()
+                            ? XML_NAMESPACE_DRAW
+                            : XML_NAMESPACE_LO_EXT,
+                        "mime-type", sOutMimeType);
+                }
+            }
+
+            SvXMLElementExport aElement(mrExport, XML_NAMESPACE_DRAW, XML_IMAGE, true, true);
+
+            // optional office:binary-data
+            if (xGraphic.is())
+            {
+                mrExport.AddEmbeddedXGraphicAsBase64(xGraphic);
+            }
+            if (!bIsEmptyPresObj)
+                ImpExportText(xShape);
+        }
+
+        //Resolves: fdo#62461 put preferred image first above, followed by
+        //fallback here
+        const bool bAddReplacementImages = officecfg::Office::Common::Save::Graphic::AddReplacementImages::get();
+        if( !bIsEmptyPresObj && bAddReplacementImages)
+        {
+            uno::Reference<graphic::XGraphic> xReplacementGraphic;
+            xPropSet->getPropertyValue("ReplacementGraphic") >>= xReplacementGraphic;
+
+            // If there is no url, then the graphic is empty
+            if (xReplacementGraphic.is())
+            {
+                OUString aMimeType;
+                const OUString aHref = mrExport.AddEmbeddedXGraphic(xReplacementGraphic, aMimeType);
+
+                if (aMimeType.isEmpty())
+                    mrExport.GetGraphicMimeTypeFromStream(xReplacementGraphic, aMimeType);
+
+                if (!aHref.isEmpty())
+                {
+                    mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, aHref);
+                    mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+                    mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+                    mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
+                }
+
+                if (!aMimeType.isEmpty() && GetExport().getSaneDefaultVersion() > SvtSaveOptions::ODFSVER_012)
+                {   // ODF 1.3 OFFICE-3943
+                    mrExport.AddAttribute(
+                        SvtSaveOptions::ODFSVER_013 <= GetExport().getSaneDefaultVersion()
+                            ? XML_NAMESPACE_DRAW
+                            : XML_NAMESPACE_LO_EXT,
+                        "mime-type", aMimeType);
+                }
+
+                SvXMLElementExport aElement(mrExport, XML_NAMESPACE_DRAW, XML_IMAGE, true, true);
+
+                // optional office:binary-data
+                mrExport.AddEmbeddedXGraphicAsBase64(xReplacementGraphic);
+            }
+        }
+    }
+
+    ImpExportEvents( xShape );
+    ImpExportGluePoints( xShape );
+
+    // image map
+    GetExport().GetImageMapExport().Export( xPropSet );
+    ImpExportDescription( xShape ); // #i68101#
+
+    // Signature Line, QR Code - needs to be after the images!
+    if (GetExport().getSaneDefaultVersion() & SvtSaveOptions::ODFSVER_EXTENDED)
+    {
+        ImpExportSignatureLine(xShape);
+        ImpExportQRCode(xShape);
+    }
+}
+
+void XMLShapeExport::ImpExportChartShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType eShapeType, XMLShapeExportFlags nFeatures, awt::Point* pRefPoint,
+    SvXMLAttributeList* pAttrList )
+{
+    ImpExportOLE2Shape( xShape, eShapeType, nFeatures, pRefPoint, pAttrList );
+}
+
+void XMLShapeExport::ImpExportControlShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XMLShapeExportFlags nFeatures, awt::Point* pRefPoint)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(xPropSet.is())
+    {
+        // Transformation
+        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+    }
+
+    uno::Reference< drawing::XControlShape > xControl( xShape, uno::UNO_QUERY );
+    SAL_WARN_IF( !xControl.is(), "xmloff", "Control shape is not supporting XControlShape" );
+    if( xControl.is() )
+    {
+        uno::Reference< beans::XPropertySet > xControlModel( xControl->getControl(), uno::UNO_QUERY );
+        SAL_WARN_IF( !xControlModel.is(), "xmloff", "Control shape has not XControlModel" );
+        if( xControlModel.is() )
+        {
+            OUString sControlId = mrExport.GetFormExport()->getControlId( xControlModel );
+            mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CONTROL, sControlId );
+        }
+    }
+
+    bool bCreateNewline( (nFeatures & XMLShapeExportFlags::NO_WS) == XMLShapeExportFlags::NONE ); // #86116#/#92210#
+    SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_CONTROL, bCreateNewline, true);
+
+    ImpExportDescription( xShape ); // #i68101#
+}
+
+void XMLShapeExport::ImpExportConnectorShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XMLShapeExportFlags nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */)
+{
+    uno::Reference< beans::XPropertySet > xProps( xShape, uno::UNO_QUERY );
+
+    OUString aStr;
+    OUStringBuffer sStringBuffer;
+
+    // export connection kind
+    drawing::ConnectorType eType = drawing::ConnectorType_STANDARD;
+    uno::Any aAny = xProps->getPropertyValue("EdgeKind");
+    aAny >>= eType;
+
+    if( eType != drawing::ConnectorType_STANDARD )
+    {
+        SvXMLUnitConverter::convertEnum( sStringBuffer, eType, aXML_ConnectionKind_EnumMap );
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_TYPE, aStr);
+    }
+
+    // export line skew
+    sal_Int32 nDelta1 = 0, nDelta2 = 0, nDelta3 = 0;
+
+    aAny = xProps->getPropertyValue("EdgeLine1Delta");
+    aAny >>= nDelta1;
+    aAny = xProps->getPropertyValue("EdgeLine2Delta");
+    aAny >>= nDelta2;
+    aAny = xProps->getPropertyValue("EdgeLine3Delta");
+    aAny >>= nDelta3;
+
+    if( nDelta1 != 0 || nDelta2 != 0 || nDelta3 != 0 )
+    {
+        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                nDelta1);
+        if( nDelta2 != 0 || nDelta3 != 0 )
+        {
+            sStringBuffer.append( ' ' );
+            mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                    nDelta2);
+            if( nDelta3 != 0 )
+            {
+                sStringBuffer.append( ' ' );
+                mrExport.GetMM100UnitConverter().convertMeasureToXML(
+                        sStringBuffer, nDelta3);
+            }
+        }
+
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_LINE_SKEW, aStr);
+    }
+
+    // export start and end point
+    awt::Point aStart(0,0);
+    awt::Point aEnd(1,1);
+
+    /* Get <StartPositionInHoriL2R> and
+       <EndPositionInHoriL2R>, if they exist and if the document is exported
+       into the OpenOffice.org file format.
+       These properties only exist at service css::text::Shape - the
+       Writer UNO service for shapes.
+       This code is needed, because the positioning attributes in the
+       OpenOffice.org file format are given in horizontal left-to-right layout
+       regardless the layout direction the shape is in. In the OASIS Open Office
+       file format the positioning attributes are correctly given in the layout
+       direction the shape is in. Thus, this code provides the conversion from
+       the OASIS Open Office file format to the OpenOffice.org file format. (#i36248#)
+    */
+    if ( !( GetExport().getExportFlags() & SvXMLExportFlags::OASIS ) &&
+         xProps->getPropertySetInfo()->hasPropertyByName("StartPositionInHoriL2R") &&
+         xProps->getPropertySetInfo()->hasPropertyByName("EndPositionInHoriL2R") )
+    {
+        xProps->getPropertyValue("StartPositionInHoriL2R") >>= aStart;
+        xProps->getPropertyValue("EndPositionInHoriL2R") >>= aEnd;
+    }
+    else
+    {
+        xProps->getPropertyValue("StartPosition") >>= aStart;
+        xProps->getPropertyValue("EndPosition") >>= aEnd;
+    }
+
+    if( pRefPoint )
+    {
+        aStart.X -= pRefPoint->X;
+        aStart.Y -= pRefPoint->Y;
+        aEnd.X -= pRefPoint->X;
+        aEnd.Y -= pRefPoint->Y;
+    }
+
+    if( nFeatures & XMLShapeExportFlags::X )
+    {
+        // svg: x1
+        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                aStart.X);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X1, aStr);
+    }
+    else
+    {
+        aEnd.X -= aStart.X;
+    }
+
+    if( nFeatures & XMLShapeExportFlags::Y )
+    {
+        // svg: y1
+        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                aStart.Y);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y1, aStr);
+    }
+    else
+    {
+        aEnd.Y -= aStart.Y;
+    }
+
+    // svg: x2
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, aEnd.X);
+    aStr = sStringBuffer.makeStringAndClear();
+    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X2, aStr);
+
+    // svg: y2
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, aEnd.Y);
+    aStr = sStringBuffer.makeStringAndClear();
+    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y2, aStr);
+
+    // #i39320#
+    uno::Reference< uno::XInterface > xRefS;
+    uno::Reference< uno::XInterface > xRefE;
+
+    // export start connection
+    xProps->getPropertyValue("StartShape") >>= xRefS;
+    if( xRefS.is() )
+    {
+        const OUString& rShapeId = mrExport.getInterfaceToIdentifierMapper().getIdentifier( xRefS );
+        mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_START_SHAPE, rShapeId);
+
+        aAny = xProps->getPropertyValue("StartGluePointIndex");
+        sal_Int32 nGluePointId = 0;
+        if( aAny >>= nGluePointId )
+        {
+            if( nGluePointId != -1 )
+            {
+                mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_START_GLUE_POINT, OUString::number( nGluePointId ));
+            }
+        }
+    }
+
+    // export end connection
+    xProps->getPropertyValue("EndShape") >>= xRefE;
+    if( xRefE.is() )
+    {
+        const OUString& rShapeId = mrExport.getInterfaceToIdentifierMapper().getIdentifier( xRefE );
+        mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_END_SHAPE, rShapeId);
+
+        aAny = xProps->getPropertyValue("EndGluePointIndex");
+        sal_Int32 nGluePointId = 0;
+        if( aAny >>= nGluePointId )
+        {
+            if( nGluePointId != -1 )
+            {
+                mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_END_GLUE_POINT, OUString::number( nGluePointId ));
+            }
+        }
+    }
+
+    // get PolygonBezier
+    aAny = xProps->getPropertyValue("PolyPolygonBezier");
+    auto pSourcePolyPolygon = o3tl::tryAccess<drawing::PolyPolygonBezierCoords>(aAny);
+    if(pSourcePolyPolygon && pSourcePolyPolygon->Coordinates.getLength())
+    {
+        const basegfx::B2DPolyPolygon aPolyPolygon(
+            basegfx::utils::UnoPolyPolygonBezierCoordsToB2DPolyPolygon(
+                *pSourcePolyPolygon));
+        const OUString aPolygonString(
+            basegfx::utils::exportToSvgD(
+                aPolyPolygon,
+                true,           // bUseRelativeCoordinates
+                false,          // bDetectQuadraticBeziers: not used in old, but maybe activated now
+                true));         // bHandleRelativeNextPointCompatible
+
+        // write point array
+        mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aPolygonString);
+    }
+
+    // get matrix
+    ::basegfx::B2DHomMatrix aMatrix;
+    ImpExportNewTrans_GetB2DHomMatrix(aMatrix, xProps);
+
+    // decompose and correct about pRefPoint
+    ::basegfx::B2DTuple aTRScale;
+    double fTRShear(0.0);
+    double fTRRotate(0.0);
+    ::basegfx::B2DTuple aTRTranslate;
+    ImpExportNewTrans_DecomposeAndRefPoint(aMatrix, aTRScale, fTRShear,
+            fTRRotate, aTRTranslate, pRefPoint);
+
+    // fdo#49678: create and export ViewBox
+    awt::Size aSize(FRound(aTRScale.getX()), FRound(aTRScale.getY()));
+    SdXMLImExViewBox aViewBox(0, 0, aSize.Width, aSize.Height);
+    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_VIEWBOX, aViewBox.GetExportString());
+
+    // write connector shape. Add Export later.
+    bool bCreateNewline( (nFeatures & XMLShapeExportFlags::NO_WS) == XMLShapeExportFlags::NONE ); // #86116#/#92210#
+    SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_CONNECTOR, bCreateNewline, true);
+
+    ImpExportDescription( xShape ); // #i68101#
+    ImpExportEvents( xShape );
+    ImpExportGluePoints( xShape );
+    ImpExportText( xShape );
+}
+
+void XMLShapeExport::ImpExportMeasureShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XMLShapeExportFlags nFeatures /* = SEF_DEFAULT */, awt::Point const * pRefPoint /* = NULL */)
+{
+    uno::Reference< beans::XPropertySet > xProps( xShape, uno::UNO_QUERY );
+
+    OUString aStr;
+    OUStringBuffer sStringBuffer;
+
+    // export start and end point
+    awt::Point aStart(0,0);
+    awt::Point aEnd(1,1);
+
+    /* Get <StartPositionInHoriL2R> and
+       <EndPositionInHoriL2R>, if they exist and if the document is exported
+       into the OpenOffice.org file format.
+       These properties only exist at service css::text::Shape - the
+       Writer UNO service for shapes.
+       This code is needed, because the positioning attributes in the
+       OpenOffice.org file format are given in horizontal left-to-right layout
+       regardless the layout direction the shape is in. In the OASIS Open Office
+       file format the positioning attributes are correctly given in the layout
+       direction the shape is in. Thus, this code provides the conversion from
+       the OASIS Open Office file format to the OpenOffice.org file format. (#i36248#)
+    */
+    if ( !( GetExport().getExportFlags() & SvXMLExportFlags::OASIS ) &&
+         xProps->getPropertySetInfo()->hasPropertyByName("StartPositionInHoriL2R") &&
+         xProps->getPropertySetInfo()->hasPropertyByName("EndPositionInHoriL2R") )
+    {
+        xProps->getPropertyValue("StartPositionInHoriL2R") >>= aStart;
+        xProps->getPropertyValue("EndPositionInHoriL2R") >>= aEnd;
+    }
+    else
+    {
+        xProps->getPropertyValue("StartPosition") >>= aStart;
+        xProps->getPropertyValue("EndPosition") >>= aEnd;
+    }
+
+    if( pRefPoint )
+    {
+        aStart.X -= pRefPoint->X;
+        aStart.Y -= pRefPoint->Y;
+        aEnd.X -= pRefPoint->X;
+        aEnd.Y -= pRefPoint->Y;
+    }
+
+    if( nFeatures & XMLShapeExportFlags::X )
+    {
+        // svg: x1
+        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                aStart.X);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X1, aStr);
+    }
+    else
+    {
+        aEnd.X -= aStart.X;
+    }
+
+    if( nFeatures & XMLShapeExportFlags::Y )
+    {
+        // svg: y1
+        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                aStart.Y);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y1, aStr);
+    }
+    else
+    {
+        aEnd.Y -= aStart.Y;
+    }
+
+    // svg: x2
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, aEnd.X);
+    aStr = sStringBuffer.makeStringAndClear();
+    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X2, aStr);
+
+    // svg: y2
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, aEnd.Y);
+    aStr = sStringBuffer.makeStringAndClear();
+    mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y2, aStr);
+
+    // write measure shape
+    bool bCreateNewline( (nFeatures & XMLShapeExportFlags::NO_WS) == XMLShapeExportFlags::NONE ); // #86116#/#92210#
+    SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_MEASURE, bCreateNewline, true);
+
+    ImpExportDescription( xShape ); // #i68101#
+    ImpExportEvents( xShape );
+    ImpExportGluePoints( xShape );
+
+    uno::Reference< text::XText > xText( xShape, uno::UNO_QUERY );
+    if( xText.is() )
+        mrExport.GetTextParagraphExport()->exportText( xText );
+}
+
+void XMLShapeExport::ImpExportOLE2Shape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType eShapeType, XMLShapeExportFlags nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */,
+    SvXMLAttributeList* pAttrList /* = NULL */ )
+{
+    uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    uno::Reference< container::XNamed > xNamed(xShape, uno::UNO_QUERY);
+
+    SAL_WARN_IF( !xPropSet.is() || !xNamed.is(), "xmloff", "ole shape is not implementing needed interfaces");
+    if(!(xPropSet.is() && xNamed.is()))
+        return;
+
+    // Transformation
+    ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+    bool bIsEmptyPresObj = false;
+
+    // presentation settings
+    if(eShapeType == XmlShapeTypePresOLE2Shape)
+        bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_OBJECT) );
+    else if(eShapeType == XmlShapeTypePresChartShape)
+        bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_CHART) );
+    else if(eShapeType == XmlShapeTypePresSheetShape)
+        bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_TABLE) );
+
+    bool bCreateNewline( (nFeatures & XMLShapeExportFlags::NO_WS) == XMLShapeExportFlags::NONE ); // #86116#/#92210#
+    bool bExportEmbedded(mrExport.getExportFlags() & SvXMLExportFlags::EMBEDDED);
+    OUString sPersistName;
+    SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW,
+                              XML_FRAME, bCreateNewline, true );
+
+    if (!bIsEmptyPresObj)
+    {
+        if (pAttrList)
+        {
+            mrExport.AddAttributeList(pAttrList);
+        }
+
+        OUString sClassId;
+        OUString sURL;
+        bool bInternal = false;
+        xPropSet->getPropertyValue("IsInternal") >>= bInternal;
+
+        {
+
+            if ( bInternal )
+            {
+                // OOo internal links have no storage persistence, URL is stored in the XML file
+                // the result LinkURL is empty in case the object is not a link
+                xPropSet->getPropertyValue("LinkURL") >>= sURL;
+            }
+
+            xPropSet->getPropertyValue("PersistName") >>= sPersistName;
+            if ( sURL.isEmpty() )
+            {
+                if( !sPersistName.isEmpty() )
+                {
+                    sURL = "vnd.sun.star.EmbeddedObject:" + sPersistName;
+                }
+            }
+
+            if( !bInternal )
+                xPropSet->getPropertyValue("CLSID") >>= sClassId;
+
+            if( !sClassId.isEmpty() )
+                mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CLASS_ID, sClassId );
+
+            if(!bExportEmbedded)
+            {
+                // xlink:href
+                if( !sURL.isEmpty() )
+                {
+                    // #96717# in theorie, if we don't have a URL we shouldn't even
+                    // export this OLE shape. But practically it's too risky right now
+                    // to change this so we better dispose this on load
+                    sURL = mrExport.AddEmbeddedObject( sURL );
+
+                    mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sURL );
+                    mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+                    mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+                    mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
+                }
+                else
+                {
+                    // tdf#153179 Export the preview graphic of the object if the object is missing.
+                    uno::Reference<graphic::XGraphic> xGraphic;
+                    xPropSet->getPropertyValue("Graphic") >>= xGraphic;
+
+                    if (xGraphic.is())
+                    {
+                        OUString aMimeType;
+                        const OUString aHref = mrExport.AddEmbeddedXGraphic(xGraphic, aMimeType);
+
+                        if (aMimeType.isEmpty())
+                            mrExport.GetGraphicMimeTypeFromStream(xGraphic, aMimeType);
+
+                        if (!aHref.isEmpty())
+                        {
+                            mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, aHref);
+                            mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE);
+                            mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED);
+                            mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD);
+                        }
+
+                        if (!aMimeType.isEmpty()
+                            && GetExport().getSaneDefaultVersion() > SvtSaveOptions::ODFSVER_012)
+                        { // ODF 1.3 OFFICE-3943
+                            mrExport.AddAttribute(SvtSaveOptions::ODFSVER_013
+                                                          <= GetExport().getSaneDefaultVersion()
+                                                      ? XML_NAMESPACE_DRAW
+                                                      : XML_NAMESPACE_LO_EXT,
+                                                  "mime-type", aMimeType);
+                        }
+
+                        SvXMLElementExport aImageElem(mrExport, XML_NAMESPACE_DRAW, XML_IMAGE, true,
+                                                      true);
+
+                        // optional office:binary-data
+                        mrExport.AddEmbeddedXGraphicAsBase64(xGraphic);
+
+                        ImpExportEvents(xShape);
+                        ImpExportGluePoints(xShape);
+                        ImpExportDescription(xShape);
+
+                        return;
+                    }
+                }
+            }
+        }
+
+        enum XMLTokenEnum eElem = sClassId.isEmpty() ? XML_OBJECT : XML_OBJECT_OLE ;
+        SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, eElem, true, true );
+
+        // tdf#112547 export text as child of draw:object, where import expects it
+        if (!bIsEmptyPresObj && supportsText(eShapeType))
+        {
+            // #i118485# Add text export, the draw OLE shape allows text now
+            ImpExportText( xShape, TextPNS::EXTENSION );
+        }
+
+        if(bExportEmbedded && !bIsEmptyPresObj)
+        {
+            if(bInternal)
+            {
+                // embedded XML
+                uno::Reference< lang::XComponent > xComp;
+                xPropSet->getPropertyValue("Model") >>= xComp;
+                SAL_WARN_IF( !xComp.is(), "xmloff", "no xModel for own OLE format" );
+                mrExport.ExportEmbeddedOwnObject( xComp );
+            }
+            else
+            {
+                // embed as Base64
+                // this is an alien object ( currently MSOLE is the only supported type of such objects )
+                // in case it is not an OASIS format the object should be asked to store replacement image if possible
+
+                OUString sURLRequest( sURL );
+                if ( !( mrExport.getExportFlags() & SvXMLExportFlags::OASIS ) )
+                    sURLRequest +=  "?oasis=false";
+                mrExport.AddEmbeddedObjectAsBase64( sURLRequest );
+            }
+        }
+    }
+    if( !bIsEmptyPresObj )
+    {
+        OUString sURL = XML_EMBEDDEDOBJECTGRAPHIC_URL_BASE + sPersistName;
+        if( !bExportEmbedded )
+        {
+            sURL = GetExport().AddEmbeddedObject( sURL );
+            mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sURL );
+            mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+            mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+            mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
+        }
+
+        SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_DRAW,
+                                  XML_IMAGE, false, true );
+
+        if( bExportEmbedded )
+            GetExport().AddEmbeddedObjectAsBase64( sURL );
+    }
+
+    ImpExportEvents( xShape );
+    ImpExportGluePoints( xShape );
+    ImpExportDescription( xShape ); // #i68101#
+
+}
+
+void XMLShapeExport::ImpExportPageShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType eShapeType, XMLShapeExportFlags nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(!xPropSet.is())
+        return;
+
+    // #86163# Transformation
+    ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+    // export page number used for this page
+    uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
+    static const OUStringLiteral aPageNumberStr(u"PageNumber");
+    if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName(aPageNumberStr))
+    {
+        sal_Int32 nPageNumber = 0;
+        xPropSet->getPropertyValue(aPageNumberStr) >>= nPageNumber;
+        if( nPageNumber )
+            mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_PAGE_NUMBER, OUString::number(nPageNumber));
+    }
+
+    // a presentation page shape, normally used on notes pages only. If
+    // it is used not as presentation shape, it may have been created with
+    // copy-paste exchange between draw and impress (this IS possible...)
+    if(eShapeType == XmlShapeTypePresPageShape)
+    {
+        mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_CLASS,
+                             XML_PAGE);
+    }
+
+    // write Page shape
+    bool bCreateNewline( (nFeatures & XMLShapeExportFlags::NO_WS) == XMLShapeExportFlags::NONE ); // #86116#/#92210#
+    SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PAGE_THUMBNAIL, bCreateNewline, true);
+}
+
+void XMLShapeExport::ImpExportCaptionShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XMLShapeExportFlags nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(!xPropSet.is())
+        return;
+
+    // Transformation
+    ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+    // evtl. corner radius?
+    sal_Int32 nCornerRadius(0);
+    xPropSet->getPropertyValue("CornerRadius") >>= nCornerRadius;
+    if(nCornerRadius)
+    {
+        OUStringBuffer sStringBuffer;
+        mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+                nCornerRadius);
+        mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CORNER_RADIUS, sStringBuffer.makeStringAndClear());
+    }
+
+    awt::Point aCaptionPoint;
+    xPropSet->getPropertyValue("CaptionPoint") >>= aCaptionPoint;
+
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(msBuffer,
+            aCaptionPoint.X);
+    mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CAPTION_POINT_X, msBuffer.makeStringAndClear() );
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(msBuffer,
+            aCaptionPoint.Y);
+    mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CAPTION_POINT_Y, msBuffer.makeStringAndClear() );
+
+    // write Caption shape. Add export later.
+    bool bCreateNewline( (nFeatures & XMLShapeExportFlags::NO_WS) == XMLShapeExportFlags::NONE ); // #86116#/#92210#
+    bool bAnnotation( (nFeatures & XMLShapeExportFlags::ANNOTATION) == XMLShapeExportFlags::ANNOTATION );
+
+    SvXMLElementExport aObj( mrExport,
+                             (bAnnotation ? XML_NAMESPACE_OFFICE
+                                           : XML_NAMESPACE_DRAW),
+                             (bAnnotation ? XML_ANNOTATION : XML_CAPTION),
+                             bCreateNewline, true );
+
+    ImpExportDescription( xShape ); // #i68101#
+    ImpExportEvents( xShape );
+    ImpExportGluePoints( xShape );
+    if( bAnnotation )
+        mrExport.exportAnnotationMeta( xShape );
+    ImpExportText( xShape );
+
+}
+
+void XMLShapeExport::ImpExportFrameShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XMLShapeExportFlags nFeatures, css::awt::Point* pRefPoint)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(!xPropSet.is())
+        return;
+
+    // Transformation
+    ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+    bool bCreateNewline( (nFeatures & XMLShapeExportFlags::NO_WS) == XMLShapeExportFlags::NONE ); // #86116#/#92210#
+    SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW,
+                              XML_FRAME, bCreateNewline, true );
+
+    // export frame url
+    OUString aStr;
+    xPropSet->getPropertyValue("FrameURL") >>= aStr;
+    mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStr) );
+    mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+    mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+    mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
+
+    // export name
+    xPropSet->getPropertyValue("FrameName") >>= aStr;
+    if( !aStr.isEmpty() )
+        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_FRAME_NAME, aStr );
+
+    // write floating frame
+    {
+        SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_FLOATING_FRAME, true, true);
+    }
+
+    ImpExportDescription(xShape);
+}
+
+void XMLShapeExport::ImpExportAppletShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XMLShapeExportFlags nFeatures, css::awt::Point* pRefPoint)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(!xPropSet.is())
+        return;
+
+    // Transformation
+    ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+    bool bCreateNewline( (nFeatures & XMLShapeExportFlags::NO_WS) == XMLShapeExportFlags::NONE ); // #86116#/#92210#
+    SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW,
+                              XML_FRAME, bCreateNewline, true );
+
+    // export frame url
+    OUString aStr;
+    xPropSet->getPropertyValue("AppletCodeBase") >>= aStr;
+    mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStr) );
+    mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+    mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+    mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
+
+    // export draw:applet-name
+    xPropSet->getPropertyValue("AppletName") >>= aStr;
+    if( !aStr.isEmpty() )
+        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_APPLET_NAME, aStr );
+
+    // export draw:code
+    xPropSet->getPropertyValue("AppletCode") >>= aStr;
+    mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CODE, aStr );
+
+    // export draw:may-script
+    bool bIsScript = false;
+    xPropSet->getPropertyValue("AppletIsScript") >>= bIsScript;
+    mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MAY_SCRIPT, bIsScript ? XML_TRUE : XML_FALSE );
+
+    {
+        // write applet
+        SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_APPLET, true, true);
+
+        // export parameters
+        uno::Sequence< beans::PropertyValue > aCommands;
+        xPropSet->getPropertyValue("AppletCommands") >>= aCommands;
+        for( const auto& rCommand : std::as_const(aCommands) )
+        {
+            rCommand.Value >>= aStr;
+            mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, rCommand.Name );
+            mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, aStr );
+            SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, false, true );
+        }
+    }
+
+    ImpExportDescription(xShape);
+}
+
+void XMLShapeExport::ImpExportPluginShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XMLShapeExportFlags nFeatures, css::awt::Point* pRefPoint)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(!xPropSet.is())
+        return;
+
+    // Transformation
+    ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+    bool bCreateNewline( (nFeatures & XMLShapeExportFlags::NO_WS) == XMLShapeExportFlags::NONE ); // #86116#/#92210#
+    SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW,
+                              XML_FRAME, bCreateNewline, true );
+
+    // export plugin url
+    OUString aStr;
+    xPropSet->getPropertyValue("PluginURL") >>= aStr;
+    mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStr) );
+    mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+    mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+    mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
+
+    // export mime-type
+    xPropSet->getPropertyValue("PluginMimeType") >>= aStr;
+    if(!aStr.isEmpty())
+        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIME_TYPE, aStr );
+
+    {
+        // write plugin
+        SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PLUGIN, true, true);
+
+        // export parameters
+        uno::Sequence< beans::PropertyValue > aCommands;
+        xPropSet->getPropertyValue("PluginCommands") >>= aCommands;
+        for( const auto& rCommand : std::as_const(aCommands) )
+        {
+            rCommand.Value >>= aStr;
+            mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, rCommand.Name );
+            mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, aStr );
+            SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, false, true );
+        }
+    }
+
+    ImpExportDescription(xShape);
+}
+
+static void lcl_CopyStream(
+        uno::Reference<io::XInputStream> const& xInStream,
+        uno::Reference<embed::XStorage> const& xTarget,
+        OUString const& rPath, const OUString& rMimeType)
+{
+    ::comphelper::LifecycleProxy proxy;
+    uno::Reference<io::XStream> const xStream(
+        ::comphelper::OStorageHelper::GetStreamAtPackageURL(xTarget, rPath,
+            embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE, proxy));
+    uno::Reference<io::XOutputStream> const xOutStream(
+            (xStream.is()) ? xStream->getOutputStream() : nullptr);
+    if (!xOutStream.is())
+    {
+        SAL_WARN("xmloff", "no output stream");
+        throw uno::Exception("no output stream",nullptr);
+    }
+    uno::Reference< beans::XPropertySet > const xStreamProps(xStream,
+        uno::UNO_QUERY);
+    if (xStreamProps.is()) { // this is NOT supported in FileSystemStorage
+        xStreamProps->setPropertyValue("MediaType",
+            uno::Any(rMimeType));
+        xStreamProps->setPropertyValue( // turn off compression
+            "Compressed",
+            uno::Any(false));
+    }
+    ::comphelper::OStorageHelper::CopyInputToOutput(xInStream, xOutStream);
+    xOutStream->closeOutput();
+    proxy.commitStorages();
+}
+
+static OUString
+lcl_StoreMediaAndGetURL(SvXMLExport & rExport,
+    uno::Reference<beans::XPropertySet> const& xPropSet,
+    OUString const& rURL, const OUString& rMimeType)
+{
+    OUString urlPath;
+    if (rURL.startsWithIgnoreAsciiCase("vnd.sun.star.Package:", &urlPath))
+    {
+        try // video is embedded
+        {
+            uno::Reference<embed::XStorage> const xTarget(
+                    rExport.GetTargetStorage(), uno::UNO_SET_THROW);
+            uno::Reference<io::XInputStream> xInStream;
+            xPropSet->getPropertyValue("PrivateStream")
+                    >>= xInStream;
+
+            if (!xInStream.is())
+            {
+                SAL_WARN("xmloff", "no input stream");
+                return OUString();
+            }
+
+            lcl_CopyStream(xInStream, xTarget, rURL, rMimeType);
+
+            return urlPath;
+        }
+        catch (uno::Exception const&)
+        {
+            TOOLS_INFO_EXCEPTION("xmloff", "exception while storing embedded media");
+        }
+        return OUString();
+    }
+    else
+    {
+        return rExport.GetRelativeReference(rURL); // linked
+    }
+}
+
+void XMLShapeExport::ImpExportMediaShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType eShapeType, XMLShapeExportFlags nFeatures, css::awt::Point* pRefPoint)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(!xPropSet.is())
+        return;
+
+    // Transformation
+    ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+    if(eShapeType == XmlShapeTypePresMediaShape)
+    {
+        (void)ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_OBJECT) );
+    }
+    bool bCreateNewline( (nFeatures & XMLShapeExportFlags::NO_WS) == XMLShapeExportFlags::NONE ); // #86116#/#92210#
+    SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW,
+                              XML_FRAME, bCreateNewline, true );
+
+    // export media url
+    OUString aMediaURL;
+    xPropSet->getPropertyValue("MediaURL") >>= aMediaURL;
+    OUString sMimeType;
+    xPropSet->getPropertyValue("MediaMimeType") >>= sMimeType;
+
+    OUString const persistentURL =
+        lcl_StoreMediaAndGetURL(GetExport(), xPropSet, aMediaURL, sMimeType);
+
+    mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, persistentURL );
+    mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+    mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+    mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
+
+    // export mime-type
+    mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIME_TYPE, sMimeType );
+
+    // write plugin
+    auto pPluginOBJ = std::make_unique<SvXMLElementExport>(mrExport, XML_NAMESPACE_DRAW, XML_PLUGIN, !( nFeatures & XMLShapeExportFlags::NO_WS ), true);
+
+    // export parameters
+    const OUString aFalseStr(  "false"  ), aTrueStr(  "true"  );
+
+    bool bLoop = false;
+    static const OUStringLiteral aLoopStr(  u"Loop"  );
+    xPropSet->getPropertyValue( aLoopStr ) >>= bLoop;
+    mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aLoopStr );
+    mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, bLoop ? aTrueStr : aFalseStr );
+    delete new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, false, true );
+
+    bool bMute = false;
+    static const OUStringLiteral aMuteStr(  u"Mute"  );
+    xPropSet->getPropertyValue( aMuteStr ) >>= bMute;
+    mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aMuteStr );
+    mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, bMute ? aTrueStr : aFalseStr );
+    delete new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, false, true );
+
+    sal_Int16 nVolumeDB = 0;
+    xPropSet->getPropertyValue("VolumeDB") >>= nVolumeDB;
+    mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, "VolumeDB" );
+    mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, OUString::number( nVolumeDB ) );
+    delete new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, false, true );
+
+    media::ZoomLevel eZoom;
+    OUString aZoomValue;
+    xPropSet->getPropertyValue("Zoom") >>= eZoom;
+    switch( eZoom )
+    {
+        case media::ZoomLevel_ZOOM_1_TO_4  : aZoomValue = "25%"; break;
+        case media::ZoomLevel_ZOOM_1_TO_2  : aZoomValue = "50%"; break;
+        case media::ZoomLevel_ORIGINAL     : aZoomValue = "100%"; break;
+        case media::ZoomLevel_ZOOM_2_TO_1  : aZoomValue = "200%"; break;
+        case media::ZoomLevel_ZOOM_4_TO_1  : aZoomValue = "400%"; break;
+        case media::ZoomLevel_FIT_TO_WINDOW: aZoomValue = "fit"; break;
+        case media::ZoomLevel_FIT_TO_WINDOW_FIXED_ASPECT: aZoomValue = "fixedfit"; break;
+        case media::ZoomLevel_FULLSCREEN   : aZoomValue = "fullscreen"; break;
+
+        default:
+        break;
+    }
+
+    if( !aZoomValue.isEmpty() )
+    {
+        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, "Zoom" );
+        mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, aZoomValue );
+        delete new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, false, true );
+    }
+
+    pPluginOBJ.reset();
+
+    uno::Reference<graphic::XGraphic> xGraphic;
+    xPropSet->getPropertyValue("Graphic") >>= xGraphic;
+    Graphic aGraphic(xGraphic);
+    if (!aGraphic.IsNone())
+    {
+        // The media has a preview, export it.
+        uno::Reference<embed::XStorage> xPictureStorage;
+        uno::Reference<embed::XStorage> xStorage;
+        uno::Reference<io::XStream> xPictureStream;
+        OUString sPictureName;
+        xStorage.set(GetExport().GetTargetStorage(), uno::UNO_SET_THROW);
+        xPictureStorage.set(
+            xStorage->openStorageElement("Pictures", embed::ElementModes::READWRITE),
+            uno::UNO_SET_THROW);
+        sal_Int32 nIndex = 0;
+        while (true)
+        {
+            sPictureName = "MediaPreview" + OUString::number(++nIndex) + ".png";
+            if (!xPictureStorage->hasByName(sPictureName))
+            {
+                break;
+            }
+        }
+
+        xPictureStream.set(
+            xPictureStorage->openStreamElement(sPictureName, ::embed::ElementModes::READWRITE),
+            uno::UNO_SET_THROW);
+
+        uno::Reference<uno::XComponentContext> xContext = GetExport().getComponentContext();
+        uno::Reference<graphic::XGraphicProvider> xProvider(
+            graphic::GraphicProvider::create(xContext));
+        uno::Sequence<beans::PropertyValue> aArgs{
+            comphelper::makePropertyValue("MimeType", OUString("image/png")),
+            comphelper::makePropertyValue("OutputStream", xPictureStream->getOutputStream())
+        };
+        xProvider->storeGraphic(xGraphic, aArgs);
+        if (xPictureStorage.is())
+        {
+            uno::Reference<embed::XTransactedObject> xTrans(xPictureStorage, uno::UNO_QUERY);
+            if (xTrans.is())
+                xTrans->commit();
+        }
+        OUString sURL = "Pictures/" + sPictureName;
+        mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sURL);
+        mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE);
+        mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED);
+        mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD);
+        SvXMLElementExport aImageElem(GetExport(), XML_NAMESPACE_DRAW, XML_IMAGE, false, true);
+    }
+
+    ImpExportDescription(xShape);
+}
+
+void XMLShapeExport::ImpExport3DSceneShape( const uno::Reference< drawing::XShape >& xShape, XMLShapeExportFlags nFeatures, awt::Point* pRefPoint)
+{
+    uno::Reference< drawing::XShapes > xShapes(xShape, uno::UNO_QUERY);
+    if(!(xShapes.is() && xShapes->getCount()))
+        return;
+
+    uno::Reference< beans::XPropertySet > xPropSet( xShape, uno::UNO_QUERY );
+    SAL_WARN_IF( !xPropSet.is(), "xmloff", "XMLShapeExport::ImpExport3DSceneShape can't export a scene without a propertyset" );
+    if( !xPropSet.is() )
+        return;
+
+    // Transformation
+    ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+    // 3d attributes
+    export3DSceneAttributes( xPropSet );
+
+    // write 3DScene shape
+    bool bCreateNewline( (nFeatures & XMLShapeExportFlags::NO_WS) == XMLShapeExportFlags::NONE ); // #86116#/#92210#
+    SvXMLElementExport aOBJ( mrExport, XML_NAMESPACE_DR3D, XML_SCENE, bCreateNewline, true);
+
+    ImpExportDescription( xShape ); // #i68101#
+    ImpExportEvents( xShape );
+
+    // write 3DSceneLights
+    export3DLamps( xPropSet );
+
+    // #89764# if export of position is suppressed for group shape,
+    // positions of contained objects should be written relative to
+    // the upper left edge of the group.
+    awt::Point aUpperLeft;
+
+    if(!(nFeatures & XMLShapeExportFlags::POSITION))
+    {
+        nFeatures |= XMLShapeExportFlags::POSITION;
+        aUpperLeft = xShape->getPosition();
+        pRefPoint = &aUpperLeft;
+    }
+
+    // write members
+    exportShapes( xShapes, nFeatures, pRefPoint );
+}
+
+void XMLShapeExport::ImpExport3DShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XmlShapeType eShapeType)
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if(!xPropSet.is())
+        return;
+
+    OUString aStr;
+    OUStringBuffer sStringBuffer;
+
+    // transformation (UNO_NAME_3D_TRANSFORM_MATRIX == "D3DTransformMatrix")
+    uno::Any aAny = xPropSet->getPropertyValue("D3DTransformMatrix");
+    drawing::HomogenMatrix aHomMat;
+    aAny >>= aHomMat;
+    SdXMLImExTransform3D aTransform;
+    aTransform.AddHomogenMatrix(aHomMat);
+    if(aTransform.NeedsAction())
+        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_TRANSFORM, aTransform.GetExportString(mrExport.GetMM100UnitConverter()));
+
+    switch(eShapeType)
+    {
+        case XmlShapeTypeDraw3DCubeObject:
+        {
+            // minEdge
+            aAny = xPropSet->getPropertyValue("D3DPosition");
+            drawing::Position3D aPosition3D;
+            aAny >>= aPosition3D;
+            ::basegfx::B3DVector aPos3D(aPosition3D.PositionX, aPosition3D.PositionY, aPosition3D.PositionZ);
+
+            // maxEdge
+            aAny = xPropSet->getPropertyValue("D3DSize");
+            drawing::Direction3D aDirection3D;
+            aAny >>= aDirection3D;
+            ::basegfx::B3DVector aDir3D(aDirection3D.DirectionX, aDirection3D.DirectionY, aDirection3D.DirectionZ);
+
+            // transform maxEdge from distance to pos
+            aDir3D = aPos3D + aDir3D;
+
+            // write minEdge
+            if(aPos3D != ::basegfx::B3DVector(-2500.0, -2500.0, -2500.0)) // write only when not default
+            {
+                SvXMLUnitConverter::convertB3DVector(sStringBuffer, aPos3D);
+                aStr = sStringBuffer.makeStringAndClear();
+                mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_MIN_EDGE, aStr);
+            }
+
+            // write maxEdge
+            if(aDir3D != ::basegfx::B3DVector(2500.0, 2500.0, 2500.0)) // write only when not default
+            {
+                SvXMLUnitConverter::convertB3DVector(sStringBuffer, aDir3D);
+                aStr = sStringBuffer.makeStringAndClear();
+                mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_MAX_EDGE, aStr);
+            }
+
+            // write 3DCube shape
+            // #i123542# Do this *after* the attributes are added, else these will be lost since opening
+            // the scope will clear the global attribute list at the exporter
+            SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_CUBE, true, true);
+
+            break;
+        }
+        case XmlShapeTypeDraw3DSphereObject:
+        {
+            // Center
+            aAny = xPropSet->getPropertyValue("D3DPosition");
+            drawing::Position3D aPosition3D;
+            aAny >>= aPosition3D;
+            ::basegfx::B3DVector aPos3D(aPosition3D.PositionX, aPosition3D.PositionY, aPosition3D.PositionZ);
+
+            // Size
+            aAny = xPropSet->getPropertyValue("D3DSize");
+            drawing::Direction3D aDirection3D;
+            aAny >>= aDirection3D;
+            ::basegfx::B3DVector aDir3D(aDirection3D.DirectionX, aDirection3D.DirectionY, aDirection3D.DirectionZ);
+
+            // write Center
+            if(aPos3D != ::basegfx::B3DVector(0.0, 0.0, 0.0)) // write only when not default
+            {
+                SvXMLUnitConverter::convertB3DVector(sStringBuffer, aPos3D);
+                aStr = sStringBuffer.makeStringAndClear();
+                mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_CENTER, aStr);
+            }
+
+            // write Size
+            if(aDir3D != ::basegfx::B3DVector(5000.0, 5000.0, 5000.0)) // write only when not default
+            {
+                SvXMLUnitConverter::convertB3DVector(sStringBuffer, aDir3D);
+                aStr = sStringBuffer.makeStringAndClear();
+                mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_SIZE, aStr);
+            }
+
+            // write 3DSphere shape
+            // #i123542# Do this *after* the attributes are added, else these will be lost since opening
+            // the scope will clear the global attribute list at the exporter
+            SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_SPHERE, true, true);
+
+            break;
+        }
+        case XmlShapeTypeDraw3DLatheObject:
+        case XmlShapeTypeDraw3DExtrudeObject:
+        {
+            // write special 3DLathe/3DExtrude attributes, get 3D tools::PolyPolygon as drawing::PolyPolygonShape3D
+            aAny = xPropSet->getPropertyValue("D3DPolyPolygon3D");
+            drawing::PolyPolygonShape3D aUnoPolyPolygon3D;
+            aAny >>= aUnoPolyPolygon3D;
+
+            // convert to 3D PolyPolygon
+            const basegfx::B3DPolyPolygon aPolyPolygon3D(
+                basegfx::utils::UnoPolyPolygonShape3DToB3DPolyPolygon(
+                    aUnoPolyPolygon3D));
+
+            // convert to 2D tools::PolyPolygon using identity 3D transformation (just grep X and Y)
+            const basegfx::B3DHomMatrix aB3DHomMatrixFor2DConversion;
+            const basegfx::B2DPolyPolygon aPolyPolygon(
+                basegfx::utils::createB2DPolyPolygonFromB3DPolyPolygon(
+                    aPolyPolygon3D,
+                    aB3DHomMatrixFor2DConversion));
+
+            // get 2D range of it
+            const basegfx::B2DRange aPolyPolygonRange(aPolyPolygon.getB2DRange());
+
+            // export ViewBox
+            SdXMLImExViewBox aViewBox(
+                aPolyPolygonRange.getMinX(),
+                aPolyPolygonRange.getMinY(),
+                aPolyPolygonRange.getWidth(),
+                aPolyPolygonRange.getHeight());
+
+            mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_VIEWBOX, aViewBox.GetExportString());
+
+            // prepare svg:d string
+            const OUString aPolygonString(
+                basegfx::utils::exportToSvgD(
+                    aPolyPolygon,
+                    true,           // bUseRelativeCoordinates
+                    false,          // bDetectQuadraticBeziers TTTT: not used in old, but maybe activated now
+                    true));         // bHandleRelativeNextPointCompatible
+
+            // write point array
+            mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aPolygonString);
+
+            if(eShapeType == XmlShapeTypeDraw3DLatheObject)
+            {
+                // write 3DLathe shape
+                SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_ROTATE, true, true);
+            }
+            else
+            {
+                // write 3DExtrude shape
+                SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_EXTRUDE, true, true);
+            }
+            break;
+        }
+        default:
+            break;
+    }
+}
+
+/** helper for chart that adds all attributes of a 3d scene element to the export */
+void XMLShapeExport::export3DSceneAttributes( const css::uno::Reference< css::beans::XPropertySet >& xPropSet )
+{
+    OUString aStr;
+    OUStringBuffer sStringBuffer;
+
+    // world transformation (UNO_NAME_3D_TRANSFORM_MATRIX == "D3DTransformMatrix")
+    uno::Any aAny = xPropSet->getPropertyValue("D3DTransformMatrix");
+    drawing::HomogenMatrix aHomMat;
+    aAny >>= aHomMat;
+    SdXMLImExTransform3D aTransform;
+    aTransform.AddHomogenMatrix(aHomMat);
+    if(aTransform.NeedsAction())
+        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_TRANSFORM, aTransform.GetExportString(mrExport.GetMM100UnitConverter()));
+
+    // VRP, VPN, VUP
+    aAny = xPropSet->getPropertyValue("D3DCameraGeometry");
+    drawing::CameraGeometry aCamGeo;
+    aAny >>= aCamGeo;
+
+    ::basegfx::B3DVector aVRP(aCamGeo.vrp.PositionX, aCamGeo.vrp.PositionY, aCamGeo.vrp.PositionZ);
+    if(aVRP != ::basegfx::B3DVector(0.0, 0.0, 1.0)) // write only when not default
+    {
+        SvXMLUnitConverter::convertB3DVector(sStringBuffer, aVRP);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_VRP, aStr);
+    }
+
+    ::basegfx::B3DVector aVPN(aCamGeo.vpn.DirectionX, aCamGeo.vpn.DirectionY, aCamGeo.vpn.DirectionZ);
+    if(aVPN != ::basegfx::B3DVector(0.0, 0.0, 1.0)) // write only when not default
+    {
+        SvXMLUnitConverter::convertB3DVector(sStringBuffer, aVPN);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_VPN, aStr);
+    }
+
+    ::basegfx::B3DVector aVUP(aCamGeo.vup.DirectionX, aCamGeo.vup.DirectionY, aCamGeo.vup.DirectionZ);
+    if(aVUP != ::basegfx::B3DVector(0.0, 1.0, 0.0)) // write only when not default
+    {
+        SvXMLUnitConverter::convertB3DVector(sStringBuffer, aVUP);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_VUP, aStr);
+    }
+
+    // projection "D3DScenePerspective" drawing::ProjectionMode
+    aAny = xPropSet->getPropertyValue("D3DScenePerspective");
+    drawing::ProjectionMode aPrjMode;
+    aAny >>= aPrjMode;
+    if(aPrjMode == drawing::ProjectionMode_PARALLEL)
+        aStr = GetXMLToken(XML_PARALLEL);
+    else
+        aStr = GetXMLToken(XML_PERSPECTIVE);
+    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_PROJECTION, aStr);
+
+    // distance
+    aAny = xPropSet->getPropertyValue("D3DSceneDistance");
+    sal_Int32 nDistance = 0;
+    aAny >>= nDistance;
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+            nDistance);
+    aStr = sStringBuffer.makeStringAndClear();
+    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_DISTANCE, aStr);
+
+    // focalLength
+    aAny = xPropSet->getPropertyValue("D3DSceneFocalLength");
+    sal_Int32 nFocalLength = 0;
+    aAny >>= nFocalLength;
+    mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer,
+            nFocalLength);
+    aStr = sStringBuffer.makeStringAndClear();
+    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_FOCAL_LENGTH, aStr);
+
+    // shadowSlant
+    aAny = xPropSet->getPropertyValue("D3DSceneShadowSlant");
+    sal_Int16 nShadowSlant = 0;
+    aAny >>= nShadowSlant;
+    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_SHADOW_SLANT, OUString::number(static_cast<sal_Int32>(nShadowSlant)));
+
+    // shadeMode
+    aAny = xPropSet->getPropertyValue("D3DSceneShadeMode");
+    drawing::ShadeMode aShadeMode;
+    if(aAny >>= aShadeMode)
+    {
+        if(aShadeMode == drawing::ShadeMode_FLAT)
+            aStr = GetXMLToken(XML_FLAT);
+        else if(aShadeMode == drawing::ShadeMode_PHONG)
+            aStr = GetXMLToken(XML_PHONG);
+        else if(aShadeMode == drawing::ShadeMode_SMOOTH)
+            aStr = GetXMLToken(XML_GOURAUD);
+        else
+            aStr = GetXMLToken(XML_DRAFT);
+    }
+    else
+    {
+        // ShadeMode enum not there, write default
+        aStr = GetXMLToken(XML_GOURAUD);
+    }
+    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_SHADE_MODE, aStr);
+
+    // ambientColor
+    aAny = xPropSet->getPropertyValue("D3DSceneAmbientColor");
+    sal_Int32 nAmbientColor = 0;
+    aAny >>= nAmbientColor;
+    ::sax::Converter::convertColor(sStringBuffer, nAmbientColor);
+    aStr = sStringBuffer.makeStringAndClear();
+    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_AMBIENT_COLOR, aStr);
+
+    // lightingMode
+    aAny = xPropSet->getPropertyValue("D3DSceneTwoSidedLighting");
+    bool bTwoSidedLighting = false;
+    aAny >>= bTwoSidedLighting;
+    ::sax::Converter::convertBool(sStringBuffer, bTwoSidedLighting);
+    aStr = sStringBuffer.makeStringAndClear();
+    mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_LIGHTING_MODE, aStr);
+}
+
+/** helper for chart that exports all lamps from the propertyset */
+void XMLShapeExport::export3DLamps( const css::uno::Reference< css::beans::XPropertySet >& xPropSet )
+{
+    // write lamps 1..8 as content
+    OUString aStr;
+    OUStringBuffer sStringBuffer;
+
+    static const OUStringLiteral aColorPropName(u"D3DSceneLightColor");
+    static const OUStringLiteral aDirectionPropName(u"D3DSceneLightDirection");
+    static const OUStringLiteral aLightOnPropName(u"D3DSceneLightOn");
+
+    ::basegfx::B3DVector aLightDirection;
+    drawing::Direction3D aLightDir;
+    bool bLightOnOff = false;
+    for(sal_Int32 nLamp = 1; nLamp <= 8; nLamp++)
+    {
+        OUString aIndexStr = OUString::number( nLamp );
+
+        // lightcolor
+        OUString aPropName = aColorPropName + aIndexStr;
+        sal_Int32 nLightColor = 0;
+        xPropSet->getPropertyValue( aPropName ) >>= nLightColor;
+        ::sax::Converter::convertColor(sStringBuffer, nLightColor);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_DIFFUSE_COLOR, aStr);
+
+        // lightdirection
+        aPropName = aDirectionPropName + aIndexStr;
+        xPropSet->getPropertyValue(aPropName) >>= aLightDir;
+        aLightDirection = ::basegfx::B3DVector(aLightDir.DirectionX, aLightDir.DirectionY, aLightDir.DirectionZ);
+        SvXMLUnitConverter::convertB3DVector(sStringBuffer, aLightDirection);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_DIRECTION, aStr);
+
+        // lighton
+        aPropName = aLightOnPropName + aIndexStr;
+        xPropSet->getPropertyValue(aPropName) >>= bLightOnOff;
+        ::sax::Converter::convertBool(sStringBuffer, bLightOnOff);
+        aStr = sStringBuffer.makeStringAndClear();
+        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_ENABLED, aStr);
+
+        // specular
+        mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_SPECULAR,
+            nLamp == 1 ? XML_TRUE : XML_FALSE);
+
+        // write light entry
+        SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_LIGHT, true, true);
+    }
+}
+
+
+// using namespace css::io;
+// using namespace ::xmloff::EnhancedCustomShapeToken;
+
+
+static void ExportParameter( OUStringBuffer& rStrBuffer, const css::drawing::EnhancedCustomShapeParameter& rParameter )
+{
+    if ( !rStrBuffer.isEmpty() )
+        rStrBuffer.append( ' ' );
+    if ( rParameter.Value.getValueTypeClass() == uno::TypeClass_DOUBLE )
+    {
+        double fNumber = 0.0;
+        rParameter.Value >>= fNumber;
+        ::rtl::math::doubleToUStringBuffer( rStrBuffer, fNumber, rtl_math_StringFormat_Automatic, rtl_math_DecimalPlaces_Max, '.', true );
+    }
+    else
+    {
+        sal_Int32 nValue = 0;
+        rParameter.Value >>= nValue;
+
+        switch( rParameter.Type )
+        {
+            case css::drawing::EnhancedCustomShapeParameterType::EQUATION :
+            {
+                rStrBuffer.append( "?f" + OUString::number( nValue ) );
+            }
+            break;
+
+            case css::drawing::EnhancedCustomShapeParameterType::ADJUSTMENT :
+            {
+                rStrBuffer.append( '$' );
+                rStrBuffer.append( nValue );
+            }
+            break;
+
+            case css::drawing::EnhancedCustomShapeParameterType::BOTTOM :
+                rStrBuffer.append( GetXMLToken( XML_BOTTOM ) ); break;
+            case css::drawing::EnhancedCustomShapeParameterType::RIGHT :
+                rStrBuffer.append( GetXMLToken( XML_RIGHT ) ); break;
+            case css::drawing::EnhancedCustomShapeParameterType::TOP :
+                rStrBuffer.append( GetXMLToken( XML_TOP ) ); break;
+            case css::drawing::EnhancedCustomShapeParameterType::LEFT :
+                rStrBuffer.append( GetXMLToken( XML_LEFT ) ); break;
+            case css::drawing::EnhancedCustomShapeParameterType::XSTRETCH :
+                rStrBuffer.append( GetXMLToken( XML_XSTRETCH ) ); break;
+            case css::drawing::EnhancedCustomShapeParameterType::YSTRETCH :
+                rStrBuffer.append( GetXMLToken( XML_YSTRETCH ) ); break;
+            case css::drawing::EnhancedCustomShapeParameterType::HASSTROKE :
+                rStrBuffer.append( GetXMLToken( XML_HASSTROKE ) ); break;
+            case css::drawing::EnhancedCustomShapeParameterType::HASFILL :
+                rStrBuffer.append( GetXMLToken( XML_HASFILL ) ); break;
+            case css::drawing::EnhancedCustomShapeParameterType::WIDTH :
+                rStrBuffer.append( GetXMLToken( XML_WIDTH ) ); break;
+            case css::drawing::EnhancedCustomShapeParameterType::HEIGHT :
+                rStrBuffer.append( GetXMLToken( XML_HEIGHT ) ); break;
+            case css::drawing::EnhancedCustomShapeParameterType::LOGWIDTH :
+                rStrBuffer.append( GetXMLToken( XML_LOGWIDTH ) ); break;
+            case css::drawing::EnhancedCustomShapeParameterType::LOGHEIGHT :
+                rStrBuffer.append( GetXMLToken( XML_LOGHEIGHT ) ); break;
+            default :
+                rStrBuffer.append( nValue );
+        }
+    }
+}
+
+static void ImpExportEquations( SvXMLExport& rExport, const uno::Sequence< OUString >& rEquations )
+{
+    sal_Int32 i;
+    for ( i = 0; i < rEquations.getLength(); i++ )
+    {
+        OUString aStr= "f" + OUString::number( i );
+        rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aStr );
+
+        aStr = rEquations[ i ];
+        sal_Int32 nIndex = 0;
+        do
+        {
+            nIndex = aStr.indexOf( '?', nIndex );
+            if ( nIndex != -1 )
+            {
+                aStr = OUString::Concat(aStr.subView(0, nIndex + 1)) + "f"
+                    + aStr.subView(nIndex + 1, aStr.getLength() - nIndex - 1);
+                nIndex++;
+            }
+        } while( nIndex != -1 );
+        rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_FORMULA, aStr );
+        SvXMLElementExport aOBJ( rExport, XML_NAMESPACE_DRAW, XML_EQUATION, true, true );
+    }
+}
+
+static void ImpExportHandles( SvXMLExport& rExport, const uno::Sequence< beans::PropertyValues >& rHandles )
+{
+    if ( !rHandles.hasElements() )
+        return;
+
+    OUString       aStr;
+    OUStringBuffer aStrBuffer;
+
+    for ( const uno::Sequence< beans::PropertyValue >& rPropSeq : rHandles )
+    {
+        bool bPosition = false;
+        for ( const beans::PropertyValue& rPropVal : rPropSeq )
+        {
+            switch( EASGet( rPropVal.Name ) )
+            {
+                case EAS_Position :
+                {
+                    css::drawing::EnhancedCustomShapeParameterPair aPosition;
+                    if ( rPropVal.Value >>= aPosition )
+                    {
+                        ExportParameter( aStrBuffer, aPosition.First );
+                        ExportParameter( aStrBuffer, aPosition.Second );
+                        aStr = aStrBuffer.makeStringAndClear();
+                        rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_POSITION, aStr );
+                        bPosition = true;
+                    }
+                }
+                break;
+                case EAS_MirroredX :
+                {
+                    bool bMirroredX;
+                    if ( rPropVal.Value >>= bMirroredX )
+                        rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_MIRROR_HORIZONTAL,
+                            bMirroredX ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                }
+                break;
+                case EAS_MirroredY :
+                {
+                    bool bMirroredY;
+                    if ( rPropVal.Value >>= bMirroredY )
+                        rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_MIRROR_VERTICAL,
+                            bMirroredY ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                }
+                break;
+                case EAS_Switched :
+                {
+                    bool bSwitched;
+                    if ( rPropVal.Value >>= bSwitched )
+                        rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_SWITCHED,
+                            bSwitched ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                }
+                break;
+                case EAS_Polar :
+                {
+                    css::drawing::EnhancedCustomShapeParameterPair aPolar;
+                    if ( rPropVal.Value >>= aPolar )
+                    {
+                        ExportParameter( aStrBuffer, aPolar.First );
+                        ExportParameter( aStrBuffer, aPolar.Second );
+                        aStr = aStrBuffer.makeStringAndClear();
+                        rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_POLAR, aStr );
+                    }
+                }
+                break;
+                case EAS_RadiusRangeMinimum :
+                {
+                    css::drawing::EnhancedCustomShapeParameter aRadiusRangeMinimum;
+                    if ( rPropVal.Value >>= aRadiusRangeMinimum )
+                    {
+                        ExportParameter( aStrBuffer, aRadiusRangeMinimum );
+                        aStr = aStrBuffer.makeStringAndClear();
+                        rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RADIUS_RANGE_MINIMUM, aStr );
+                    }
+                }
+                break;
+                case EAS_RadiusRangeMaximum :
+                {
+                    css::drawing::EnhancedCustomShapeParameter aRadiusRangeMaximum;
+                    if ( rPropVal.Value >>= aRadiusRangeMaximum )
+                    {
+                        ExportParameter( aStrBuffer, aRadiusRangeMaximum );
+                        aStr = aStrBuffer.makeStringAndClear();
+                        rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RADIUS_RANGE_MAXIMUM, aStr );
+                    }
+                }
+                break;
+                case EAS_RangeXMinimum :
+                {
+                    css::drawing::EnhancedCustomShapeParameter aXRangeMinimum;
+                    if ( rPropVal.Value >>= aXRangeMinimum )
+                    {
+                        ExportParameter( aStrBuffer, aXRangeMinimum );
+                        aStr = aStrBuffer.makeStringAndClear();
+                        rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_X_MINIMUM, aStr );
+                    }
+                }
+                break;
+                case EAS_RangeXMaximum :
+                {
+                    css::drawing::EnhancedCustomShapeParameter aXRangeMaximum;
+                    if ( rPropVal.Value >>= aXRangeMaximum )
+                    {
+                        ExportParameter( aStrBuffer, aXRangeMaximum );
+                        aStr = aStrBuffer.makeStringAndClear();
+                        rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_X_MAXIMUM, aStr );
+                    }
+                }
+                break;
+                case EAS_RangeYMinimum :
+                {
+                    css::drawing::EnhancedCustomShapeParameter aYRangeMinimum;
+                    if ( rPropVal.Value >>= aYRangeMinimum )
+                    {
+                        ExportParameter( aStrBuffer, aYRangeMinimum );
+                        aStr = aStrBuffer.makeStringAndClear();
+                        rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_Y_MINIMUM, aStr );
+                    }
+                }
+                break;
+                case EAS_RangeYMaximum :
+                {
+                    css::drawing::EnhancedCustomShapeParameter aYRangeMaximum;
+                    if ( rPropVal.Value >>= aYRangeMaximum )
+                    {
+                        ExportParameter( aStrBuffer, aYRangeMaximum );
+                        aStr = aStrBuffer.makeStringAndClear();
+                        rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_Y_MAXIMUM, aStr );
+                    }
+                }
+                break;
+                default:
+                    break;
+            }
+        }
+        if ( bPosition )
+            SvXMLElementExport aOBJ( rExport, XML_NAMESPACE_DRAW, XML_HANDLE, true, true );
+        else
+            rExport.ClearAttrList();
+    }
+}
+
+static void ImpExportEnhancedPath( SvXMLExport& rExport,
+                            const uno::Sequence< css::drawing::EnhancedCustomShapeParameterPair >& rCoordinates,
+                            const uno::Sequence< css::drawing::EnhancedCustomShapeSegment >& rSegments,
+                            bool bExtended = false )
+{
+
+    OUString       aStr;
+    OUStringBuffer aStrBuffer;
+    bool bNeedExtended = false;
+
+    sal_Int32 i, j, k, l;
+
+    sal_Int32 nCoords = rCoordinates.getLength();
+    sal_Int32 nSegments = rSegments.getLength();
+    bool bSimpleSegments = nSegments == 0;
+    if ( bSimpleSegments )
+        nSegments = 4;
+    for ( j = i = 0; j < nSegments; j++ )
+    {
+        css::drawing::EnhancedCustomShapeSegment aSegment;
+        if ( bSimpleSegments )
+        {
+            // if there are not enough segments we will default them
+            switch( j )
+            {
+                case 0 :
+                {
+                    aSegment.Count = 1;
+                    aSegment.Command = css::drawing::EnhancedCustomShapeSegmentCommand::MOVETO;
+                }
+                break;
+                case 1 :
+                {
+                    aSegment.Count = static_cast<sal_Int16>(std::min( nCoords - 1, sal_Int32(32767) ));
+                    aSegment.Command = css::drawing::EnhancedCustomShapeSegmentCommand::LINETO;
+                }
+                break;
+                case 2 :
+                {
+                    aSegment.Count = 1;
+                    aSegment.Command = css::drawing::EnhancedCustomShapeSegmentCommand::CLOSESUBPATH;
+                }
+                break;
+                case 3 :
+                {
+                    aSegment.Count = 1;
+                    aSegment.Command = css::drawing::EnhancedCustomShapeSegmentCommand::ENDSUBPATH;
+                }
+                break;
+            }
+        }
+        else
+            aSegment = rSegments[ j ];
+
+        if ( !aStrBuffer.isEmpty() )
+            aStrBuffer.append( ' ' );
+
+        sal_Int32 nParameter = 0;
+        switch( aSegment.Command )
+        {
+            case css::drawing::EnhancedCustomShapeSegmentCommand::CLOSESUBPATH :
+                aStrBuffer.append( 'Z' ); break;
+            case css::drawing::EnhancedCustomShapeSegmentCommand::ENDSUBPATH :
+                aStrBuffer.append( 'N' ); break;
+            case css::drawing::EnhancedCustomShapeSegmentCommand::NOFILL :
+                aStrBuffer.append( 'F' ); break;
+            case css::drawing::EnhancedCustomShapeSegmentCommand::NOSTROKE :
+                aStrBuffer.append( 'S' ); break;
+
+            case css::drawing::EnhancedCustomShapeSegmentCommand::MOVETO :
+                aStrBuffer.append( 'M' ); nParameter = 1; break;
+            case css::drawing::EnhancedCustomShapeSegmentCommand::LINETO :
+                aStrBuffer.append( 'L' ); nParameter = 1; break;
+            case css::drawing::EnhancedCustomShapeSegmentCommand::CURVETO :
+                aStrBuffer.append( 'C' ); nParameter = 3; break;
+            case css::drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSETO :
+                aStrBuffer.append( 'T' ); nParameter = 3; break;
+            case css::drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSE :
+                aStrBuffer.append( 'U' ); nParameter = 3; break;
+            case css::drawing::EnhancedCustomShapeSegmentCommand::ARCTO :
+                aStrBuffer.append( 'A' ); nParameter = 4; break;
+            case css::drawing::EnhancedCustomShapeSegmentCommand::ARC :
+                aStrBuffer.append( 'B' ); nParameter = 4; break;
+            case css::drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARCTO :
+                aStrBuffer.append( 'W' ); nParameter = 4; break;
+            case css::drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARC :
+                aStrBuffer.append( 'V' ); nParameter = 4; break;
+            case css::drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTX :
+                aStrBuffer.append( 'X' ); nParameter = 1; break;
+            case css::drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTY :
+                aStrBuffer.append( 'Y' ); nParameter = 1; break;
+            case css::drawing::EnhancedCustomShapeSegmentCommand::QUADRATICCURVETO :
+                aStrBuffer.append( 'Q' ); nParameter = 2; break;
+            case css::drawing::EnhancedCustomShapeSegmentCommand::ARCANGLETO :
+                if ( bExtended ) {
+                    aStrBuffer.append( 'G' );
+                    nParameter = 2;
+                } else {
+                    aStrBuffer.setLength( aStrBuffer.getLength() - 1);
+                    bNeedExtended = true;
+                    i += 2;
+                }
+                break;
+            case css::drawing::EnhancedCustomShapeSegmentCommand::DARKEN :
+                if ( bExtended )
+                    aStrBuffer.append( 'H' );
+                else
+                    bNeedExtended = true;
+                break;
+            case css::drawing::EnhancedCustomShapeSegmentCommand::DARKENLESS :
+                if ( bExtended )
+                    aStrBuffer.append( 'I' );
+                else
+                    bNeedExtended = true;
+                break;
+            case css::drawing::EnhancedCustomShapeSegmentCommand::LIGHTEN :
+                if ( bExtended )
+                    aStrBuffer.append( 'J' );
+                else
+                    bNeedExtended = true;
+                break;
+            case css::drawing::EnhancedCustomShapeSegmentCommand::LIGHTENLESS :
+                if ( bExtended )
+                    aStrBuffer.append( 'K' );
+                else
+                    bNeedExtended = true;
+                break;
+            default : // ups, seems to be something wrong
+            {
+                aSegment.Count = 1;
+                aSegment.Command = css::drawing::EnhancedCustomShapeSegmentCommand::LINETO;
+            }
+            break;
+        }
+        if ( nParameter )
+        {
+            for ( k = 0; k < aSegment.Count; k++ )
+            {
+                if ( ( i + nParameter ) <= nCoords )
+                {
+                    for ( l = 0; l < nParameter; l++ )
+                    {
+                        ExportParameter( aStrBuffer, rCoordinates[ i ].First );
+                        ExportParameter( aStrBuffer, rCoordinates[ i++ ].Second );
+                    }
+                }
+                else
+                {
+                    j = nSegments;  // error -> exiting
+                    break;
+                }
+            }
+        }
+    }
+    aStr = aStrBuffer.makeStringAndClear();
+    rExport.AddAttribute( bExtended ? XML_NAMESPACE_DRAW_EXT : XML_NAMESPACE_DRAW, XML_ENHANCED_PATH, aStr );
+    if (!bExtended && bNeedExtended && (rExport.getSaneDefaultVersion() & SvtSaveOptions::ODFSVER_EXTENDED))
+        ImpExportEnhancedPath( rExport, rCoordinates, rSegments, true );
+}
+
+static void ImpExportEnhancedGeometry( SvXMLExport& rExport, const uno::Reference< beans::XPropertySet >& xPropSet )
+{
+    bool bEquations = false;
+    uno::Sequence< OUString > aEquations;
+
+    bool bHandles = false;
+    uno::Sequence< beans::PropertyValues > aHandles;
+
+    uno::Sequence< css::drawing::EnhancedCustomShapeSegment > aSegments;
+    uno::Sequence< css::drawing::EnhancedCustomShapeParameterPair > aCoordinates;
+
+    uno::Sequence< css::drawing::EnhancedCustomShapeAdjustmentValue > aAdjustmentValues;
+
+    OUString       aStr;
+    OUStringBuffer aStrBuffer;
+    SvXMLUnitConverter& rUnitConverter = rExport.GetMM100UnitConverter();
+
+    uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
+
+    // geometry
+    static const OUStringLiteral sCustomShapeGeometry( u"CustomShapeGeometry" );
+    if ( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName( sCustomShapeGeometry ) )
+    {
+        uno::Any aGeoPropSet( xPropSet->getPropertyValue( sCustomShapeGeometry ) );
+        uno::Sequence< beans::PropertyValue > aGeoPropSeq;
+
+        if ( aGeoPropSet >>= aGeoPropSeq )
+        {
+            bool bCoordinates = false;
+            OUString aCustomShapeType( "non-primitive" );
+
+            for ( const beans::PropertyValue& rGeoProp : std::as_const(aGeoPropSeq) )
+            {
+                switch( EASGet( rGeoProp.Name ) )
+                {
+                    case EAS_Type :
+                    {
+                        rGeoProp.Value >>= aCustomShapeType;
+                    }
+                    break;
+                    case EAS_MirroredX :
+                    {
+                        bool bMirroredX;
+                        if ( rGeoProp.Value >>= bMirroredX )
+                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIRROR_HORIZONTAL,
+                                bMirroredX ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                    }
+                    break;
+                    case EAS_MirroredY :
+                    {
+                        bool bMirroredY;
+                        if ( rGeoProp.Value >>= bMirroredY )
+                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIRROR_VERTICAL,
+                                bMirroredY ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                    }
+                    break;
+                    case EAS_ViewBox :
+                    {
+                        awt::Rectangle aRect;
+                        if ( rGeoProp.Value >>= aRect )
+                        {
+                            SdXMLImExViewBox aViewBox( aRect.X, aRect.Y, aRect.Width, aRect.Height );
+                            rExport.AddAttribute( XML_NAMESPACE_SVG, XML_VIEWBOX, aViewBox.GetExportString() );
+                        }
+                    }
+                    break;
+                    case EAS_TextPreRotateAngle :
+                    case EAS_TextRotateAngle :
+                    {
+                        double fTextRotateAngle = 0;
+                        if ( ( rGeoProp.Value >>= fTextRotateAngle ) && fTextRotateAngle != 0 )
+                        {
+                            ::sax::Converter::convertDouble(
+                                    aStrBuffer, fTextRotateAngle );
+                            aStr = aStrBuffer.makeStringAndClear();
+                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_ROTATE_ANGLE, aStr );
+                        }
+                    }
+                    break;
+                    case EAS_Extrusion :
+                    {
+                        uno::Sequence< beans::PropertyValue > aExtrusionPropSeq;
+                        if ( rGeoProp.Value >>= aExtrusionPropSeq )
+                        {
+                            bool bSkewValuesProvided = false;
+                            for ( const beans::PropertyValue& rProp : std::as_const(aExtrusionPropSeq) )
+                            {
+                                switch( EASGet( rProp.Name ) )
+                                {
+                                    case EAS_Extrusion :
+                                    {
+                                        bool bExtrusionOn;
+                                        if ( rProp.Value >>= bExtrusionOn )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION,
+                                                bExtrusionOn ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                                    }
+                                    break;
+                                    case EAS_Brightness :
+                                    {
+                                        double fExtrusionBrightness = 0;
+                                        if ( rProp.Value >>= fExtrusionBrightness )
+                                        {
+                                            ::sax::Converter::convertDouble(
+                                                aStrBuffer,
+                                                fExtrusionBrightness,
+                                                false,
+                                                util::MeasureUnit::PERCENT,
+                                                util::MeasureUnit::PERCENT);
+                                            aStrBuffer.append( '%' );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_BRIGHTNESS, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_Depth :
+                                    {
+                                        css::drawing::EnhancedCustomShapeParameterPair aDepthParaPair;
+                                        if ( rProp.Value >>= aDepthParaPair )
+                                        {
+                                            double fDepth = 0;
+                                            if ( aDepthParaPair.First.Value >>= fDepth )
+                                            {
+                                                rExport.GetMM100UnitConverter().convertDouble( aStrBuffer, fDepth );
+                                                ExportParameter( aStrBuffer, aDepthParaPair.Second );
+                                                aStr = aStrBuffer.makeStringAndClear();
+                                                rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_DEPTH, aStr );
+                                            }
+                                        }
+                                    }
+                                    break;
+                                    case EAS_Diffusion :
+                                    {
+                                        double fExtrusionDiffusion = 0;
+                                        if ( rProp.Value >>= fExtrusionDiffusion )
+                                        {
+                                            ::sax::Converter::convertDouble(
+                                                aStrBuffer,
+                                                fExtrusionDiffusion,
+                                                false,
+                                                util::MeasureUnit::PERCENT,
+                                                util::MeasureUnit::PERCENT);
+                                            aStrBuffer.append( '%' );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_DIFFUSION, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_NumberOfLineSegments :
+                                    {
+                                        sal_Int32 nExtrusionNumberOfLineSegments = 0;
+                                        if ( rProp.Value >>= nExtrusionNumberOfLineSegments )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_NUMBER_OF_LINE_SEGMENTS, OUString::number( nExtrusionNumberOfLineSegments ) );
+                                    }
+                                    break;
+                                    case EAS_LightFace :
+                                    {
+                                        bool bExtrusionLightFace;
+                                        if ( rProp.Value >>= bExtrusionLightFace )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_LIGHT_FACE,
+                                                bExtrusionLightFace ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                                    }
+                                    break;
+                                    case EAS_FirstLightHarsh :
+                                    {
+                                        bool bExtrusionFirstLightHarsh;
+                                        if ( rProp.Value >>= bExtrusionFirstLightHarsh )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_FIRST_LIGHT_HARSH,
+                                                bExtrusionFirstLightHarsh ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                                    }
+                                    break;
+                                    case EAS_SecondLightHarsh :
+                                    {
+                                        bool bExtrusionSecondLightHarsh;
+                                        if ( rProp.Value >>= bExtrusionSecondLightHarsh )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SECOND_LIGHT_HARSH,
+                                                bExtrusionSecondLightHarsh ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                                    }
+                                    break;
+                                    case EAS_FirstLightLevel :
+                                    {
+                                        double fExtrusionFirstLightLevel = 0;
+                                        if ( rProp.Value >>= fExtrusionFirstLightLevel )
+                                        {
+                                            ::sax::Converter::convertDouble(
+                                                aStrBuffer,
+                                                fExtrusionFirstLightLevel,
+                                                false,
+                                                util::MeasureUnit::PERCENT,
+                                                util::MeasureUnit::PERCENT);
+                                            aStrBuffer.append( '%' );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_FIRST_LIGHT_LEVEL, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_SecondLightLevel :
+                                    {
+                                        double fExtrusionSecondLightLevel = 0;
+                                        if ( rProp.Value >>= fExtrusionSecondLightLevel )
+                                        {
+                                            ::sax::Converter::convertDouble(
+                                                aStrBuffer,
+                                                fExtrusionSecondLightLevel,
+                                                false,
+                                                util::MeasureUnit::PERCENT,
+                                                util::MeasureUnit::PERCENT);
+                                            aStrBuffer.append( '%' );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SECOND_LIGHT_LEVEL, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_FirstLightDirection :
+                                    {
+                                        drawing::Direction3D aExtrusionFirstLightDirection;
+                                        if ( rProp.Value >>= aExtrusionFirstLightDirection )
+                                        {
+                                            ::basegfx::B3DVector aVec3D( aExtrusionFirstLightDirection.DirectionX, aExtrusionFirstLightDirection.DirectionY,
+                                                aExtrusionFirstLightDirection.DirectionZ );
+                                            SvXMLUnitConverter::convertB3DVector( aStrBuffer, aVec3D );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_FIRST_LIGHT_DIRECTION, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_SecondLightDirection :
+                                    {
+                                        drawing::Direction3D aExtrusionSecondLightDirection;
+                                        if ( rProp.Value >>= aExtrusionSecondLightDirection )
+                                        {
+                                            ::basegfx::B3DVector aVec3D( aExtrusionSecondLightDirection.DirectionX, aExtrusionSecondLightDirection.DirectionY,
+                                                aExtrusionSecondLightDirection.DirectionZ );
+                                            SvXMLUnitConverter::convertB3DVector( aStrBuffer, aVec3D );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SECOND_LIGHT_DIRECTION, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_Metal :
+                                    {
+                                        bool bExtrusionMetal;
+                                        if ( rProp.Value >>= bExtrusionMetal )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_METAL,
+                                                bExtrusionMetal ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                                    }
+                                    break;
+                                    case EAS_MetalType :
+                                    {
+                                        // export only if ODF extensions are enabled
+                                        sal_Int16 eMetalType;
+                                        if (rProp.Value >>= eMetalType)
+                                        {
+                                            SvtSaveOptions::ODFSaneDefaultVersion eVersion = rExport.getSaneDefaultVersion();
+                                            if (eVersion > SvtSaveOptions::ODFSVER_013
+                                                && (eVersion & SvtSaveOptions::ODFSVER_EXTENDED))
+                                            {
+                                                if (eMetalType == drawing::EnhancedCustomShapeMetalType::MetalMSCompatible)
+                                                    aStr = "loext:MetalMSCompatible";
+                                                else
+                                                    aStr = "draw:MetalODF";
+                                                rExport.AddAttribute(XML_NAMESPACE_LO_EXT, XML_EXTRUSION_METAL_TYPE, aStr);
+                                            }
+                                        }
+                                    }
+                                    break;
+                                    case EAS_ShadeMode :
+                                    {
+                                        // shadeMode
+                                        drawing::ShadeMode eShadeMode;
+                                        if( rProp.Value >>= eShadeMode )
+                                        {
+                                            if( eShadeMode == drawing::ShadeMode_FLAT )
+                                                aStr = GetXMLToken( XML_FLAT );
+                                            else if( eShadeMode == drawing::ShadeMode_PHONG )
+                                                aStr = GetXMLToken( XML_PHONG );
+                                            else if( eShadeMode == drawing::ShadeMode_SMOOTH )
+                                                aStr = GetXMLToken( XML_GOURAUD );
+                                            else
+                                                aStr = GetXMLToken( XML_DRAFT );
+                                        }
+                                        else
+                                        {
+                                            // ShadeMode enum not there, write default
+                                            aStr = GetXMLToken( XML_FLAT);
+                                        }
+                                        rExport.AddAttribute( XML_NAMESPACE_DR3D, XML_SHADE_MODE, aStr );
+                                    }
+                                    break;
+                                    case EAS_RotateAngle :
+                                    {
+                                        css::drawing::EnhancedCustomShapeParameterPair aRotateAngleParaPair;
+                                        if ( rProp.Value >>= aRotateAngleParaPair )
+                                        {
+                                            ExportParameter( aStrBuffer, aRotateAngleParaPair.First );
+                                            ExportParameter( aStrBuffer, aRotateAngleParaPair.Second );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ROTATION_ANGLE, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_RotationCenter :
+                                    {
+                                        drawing::Direction3D aExtrusionRotationCenter;
+                                        if ( rProp.Value >>= aExtrusionRotationCenter )
+                                        {
+                                            ::basegfx::B3DVector aVec3D( aExtrusionRotationCenter.DirectionX, aExtrusionRotationCenter.DirectionY,
+                                                aExtrusionRotationCenter.DirectionZ );
+                                            SvXMLUnitConverter::convertB3DVector( aStrBuffer, aVec3D );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ROTATION_CENTER, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_Shininess :
+                                    {
+                                        double fExtrusionShininess = 0;
+                                        if ( rProp.Value >>= fExtrusionShininess )
+                                        {
+                                            ::sax::Converter::convertDouble(
+                                                aStrBuffer,
+                                                fExtrusionShininess,
+                                                false,
+                                                util::MeasureUnit::PERCENT,
+                                                util::MeasureUnit::PERCENT);
+                                            aStrBuffer.append( '%' );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SHININESS, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_Skew :
+                                    {
+                                        css::drawing::EnhancedCustomShapeParameterPair aSkewParaPair;
+                                        if ( rProp.Value >>= aSkewParaPair )
+                                        {
+                                            bSkewValuesProvided = true;
+                                            ExportParameter( aStrBuffer, aSkewParaPair.First );
+                                            ExportParameter( aStrBuffer, aSkewParaPair.Second );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SKEW, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_Specularity :
+                                    {
+                                        double fExtrusionSpecularity = 0;
+                                        if ( rProp.Value >>= fExtrusionSpecularity )
+                                        {
+                                            SvtSaveOptions::ODFSaneDefaultVersion eVersion = rExport.getSaneDefaultVersion();
+                                            if (fExtrusionSpecularity > 100.0 && eVersion >= SvtSaveOptions::ODFSVER_012
+                                                && (eVersion & SvtSaveOptions::ODFSVER_EXTENDED))
+                                            {
+                                                // tdf#147580 write values > 100% in loext
+                                                ::sax::Converter::convertDouble(
+                                                    aStrBuffer,
+                                                    fExtrusionSpecularity,
+                                                    false,
+                                                    util::MeasureUnit::PERCENT,
+                                                    util::MeasureUnit::PERCENT);
+                                                aStrBuffer.append( '%' );
+                                                aStr = aStrBuffer.makeStringAndClear();
+                                                rExport.AddAttribute( XML_NAMESPACE_LO_EXT, XML_EXTRUSION_SPECULARITY_LOEXT, aStr );
+                                            }
+                                            // tdf#147580 ODF 1 allows arbitrary percent, later versions not
+                                            if (eVersion >= SvtSaveOptions::ODFSVER_012)
+                                            {
+                                                fExtrusionSpecularity = std::clamp<double>(fExtrusionSpecularity, 0.0, 100.0);
+                                            }
+                                            ::sax::Converter::convertDouble(
+                                                aStrBuffer,
+                                                fExtrusionSpecularity,
+                                                false,
+                                                util::MeasureUnit::PERCENT,
+                                                util::MeasureUnit::PERCENT);
+                                            aStrBuffer.append( '%' );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SPECULARITY, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_ProjectionMode :
+                                    {
+                                        drawing::ProjectionMode eProjectionMode;
+                                        if ( rProp.Value >>= eProjectionMode )
+                                            rExport.AddAttribute( XML_NAMESPACE_DR3D, XML_PROJECTION,
+                                                eProjectionMode == drawing::ProjectionMode_PARALLEL ? GetXMLToken( XML_PARALLEL ) : GetXMLToken( XML_PERSPECTIVE ) );
+                                    }
+                                    break;
+                                    case EAS_ViewPoint :
+                                    {
+                                        drawing::Position3D aExtrusionViewPoint;
+                                        if ( rProp.Value >>= aExtrusionViewPoint )
+                                        {
+                                            rUnitConverter.convertPosition3D( aStrBuffer, aExtrusionViewPoint );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_VIEWPOINT, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_Origin :
+                                    {
+                                        css::drawing::EnhancedCustomShapeParameterPair aOriginParaPair;
+                                        if ( rProp.Value >>= aOriginParaPair )
+                                        {
+                                            ExportParameter( aStrBuffer, aOriginParaPair.First );
+                                            ExportParameter( aStrBuffer, aOriginParaPair.Second );
+                                            aStr = aStrBuffer.makeStringAndClear();
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ORIGIN, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_Color :
+                                    {
+                                        bool bExtrusionColor;
+                                        if ( rProp.Value >>= bExtrusionColor )
+                                        {
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_COLOR,
+                                                bExtrusionColor ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                                        }
+                                    }
+                                    break;
+                                    default:
+                                        break;
+                                }
+                            }
+                            // tdf#141301: no specific skew values provided
+                            if (!bSkewValuesProvided)
+                            {
+                                // so we need to export default values explicitly
+                                rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SKEW, "50 -135");
+                            }
+                        }
+                    }
+                    break;
+                    case EAS_TextPath :
+                    {
+                        uno::Sequence< beans::PropertyValue > aTextPathPropSeq;
+                        if ( rGeoProp.Value >>= aTextPathPropSeq )
+                        {
+                            for ( const beans::PropertyValue& rProp : std::as_const(aTextPathPropSeq) )
+                            {
+                                switch( EASGet( rProp.Name ) )
+                                {
+                                    case EAS_TextPath :
+                                    {
+                                        bool bTextPathOn;
+                                        if ( rProp.Value >>= bTextPathOn )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH,
+                                                bTextPathOn ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                                    }
+                                    break;
+                                    case EAS_TextPathMode :
+                                    {
+                                        css::drawing::EnhancedCustomShapeTextPathMode eTextPathMode;
+                                        if ( rProp.Value >>= eTextPathMode )
+                                        {
+                                            switch ( eTextPathMode )
+                                            {
+                                                case css::drawing::EnhancedCustomShapeTextPathMode_NORMAL: aStr = GetXMLToken( XML_NORMAL ); break;
+                                                case css::drawing::EnhancedCustomShapeTextPathMode_PATH  : aStr = GetXMLToken( XML_PATH );   break;
+                                                case css::drawing::EnhancedCustomShapeTextPathMode_SHAPE : aStr = GetXMLToken( XML_SHAPE );  break;
+                                                default:
+                                                    break;
+                                            }
+                                            if ( !aStr.isEmpty() )
+                                                rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_MODE, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_ScaleX :
+                                    {
+                                        bool bScaleX;
+                                        if ( rProp.Value >>= bScaleX )
+                                        {
+                                            aStr = bScaleX ? GetXMLToken( XML_SHAPE ) : GetXMLToken( XML_PATH );
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_SCALE, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_SameLetterHeights :
+                                    {
+                                        bool bSameLetterHeights;
+                                        if ( rProp.Value >>= bSameLetterHeights )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_SAME_LETTER_HEIGHTS,
+                                                bSameLetterHeights ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                                    }
+                                    break;
+                                    default:
+                                        break;
+                                }
+                            }
+                        }
+                    }
+                    break;
+                    case EAS_Path :
+                    {
+                        uno::Sequence< beans::PropertyValue > aPathPropSeq;
+                        if ( rGeoProp.Value >>= aPathPropSeq )
+                        {
+                            for ( const beans::PropertyValue& rProp : std::as_const(aPathPropSeq) )
+                            {
+                                switch( EASGet( rProp.Name ) )
+                                {
+                                    case EAS_SubViewSize:
+                                    {
+                                        // export draw:sub-view-size (do not export in ODF 1.3 or older)
+                                        if ((rExport.getSaneDefaultVersion() & SvtSaveOptions::ODFSVER_EXTENDED) == 0)
+                                        {
+                                            continue;
+                                        }
+                                        uno::Sequence< awt::Size > aSubViewSizes;
+                                        rProp.Value >>= aSubViewSizes;
+
+                                        for ( int nIdx = 0; nIdx < aSubViewSizes.getLength(); nIdx++ )
+                                        {
+                                            if ( nIdx )
+                                                aStrBuffer.append(' ');
+                                            aStrBuffer.append( aSubViewSizes[nIdx].Width );
+                                            aStrBuffer.append(' ');
+                                            aStrBuffer.append( aSubViewSizes[nIdx].Height );
+                                        }
+                                        aStr = aStrBuffer.makeStringAndClear();
+                                        rExport.AddAttribute( XML_NAMESPACE_DRAW_EXT, XML_SUB_VIEW_SIZE, aStr );
+                                    }
+                                    break;
+                                    case EAS_ExtrusionAllowed :
+                                    {
+                                        bool bExtrusionAllowed;
+                                        if ( rProp.Value >>= bExtrusionAllowed )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ALLOWED,
+                                                bExtrusionAllowed ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                                    }
+                                    break;
+                                    case EAS_ConcentricGradientFillAllowed :
+                                    {
+                                        bool bConcentricGradientFillAllowed;
+                                        if ( rProp.Value >>= bConcentricGradientFillAllowed )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CONCENTRIC_GRADIENT_FILL_ALLOWED,
+                                                bConcentricGradientFillAllowed ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                                    }
+                                    break;
+                                    case EAS_TextPathAllowed  :
+                                    {
+                                        bool bTextPathAllowed;
+                                        if ( rProp.Value >>= bTextPathAllowed )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_ALLOWED,
+                                                bTextPathAllowed ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
+                                    }
+                                    break;
+                                    case EAS_GluePoints :
+                                    {
+                                        css::uno::Sequence< css::drawing::EnhancedCustomShapeParameterPair> aGluePoints;
+                                        if ( rProp.Value >>= aGluePoints )
+                                        {
+                                            if ( aGluePoints.hasElements() )
+                                            {
+                                                for( const auto& rGluePoint : std::as_const(aGluePoints) )
+                                                {
+                                                    ExportParameter( aStrBuffer, rGluePoint.First );
+                                                    ExportParameter( aStrBuffer, rGluePoint.Second );
+                                                }
+                                                aStr = aStrBuffer.makeStringAndClear();
+                                            }
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_GLUE_POINTS, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_GluePointType :
+                                    {
+                                        sal_Int16 nGluePointType = sal_Int16();
+                                        if ( rProp.Value >>= nGluePointType )
+                                        {
+                                            switch ( nGluePointType )
+                                            {
+                                                case css::drawing::EnhancedCustomShapeGluePointType::NONE     : aStr = GetXMLToken( XML_NONE );    break;
+                                                case css::drawing::EnhancedCustomShapeGluePointType::SEGMENTS : aStr = GetXMLToken( XML_SEGMENTS ); break;
+                                                case css::drawing::EnhancedCustomShapeGluePointType::RECT     : aStr = GetXMLToken( XML_RECTANGLE ); break;
+                                            }
+                                            if ( !aStr.isEmpty() )
+                                                rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_GLUE_POINT_TYPE, aStr );
+                                        }
+                                    }
+                                    break;
+                                    case EAS_Coordinates :
+                                    {
+                                        bCoordinates = ( rProp.Value >>= aCoordinates );
+                                    }
+                                    break;
+                                    case EAS_Segments :
+                                    {
+                                        rProp.Value >>= aSegments;
+                                    }
+                                    break;
+                                    case EAS_StretchX :
+                                    {
+                                        sal_Int32 nStretchPoint = 0;
+                                        if ( rProp.Value >>= nStretchPoint )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_PATH_STRETCHPOINT_X, OUString::number( nStretchPoint ) );
+                                    }
+                                    break;
+                                    case EAS_StretchY :
+                                    {
+                                        sal_Int32 nStretchPoint = 0;
+                                        if ( rProp.Value >>= nStretchPoint )
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_PATH_STRETCHPOINT_Y, OUString::number( nStretchPoint ) );
+                                    }
+                                    break;
+                                    case EAS_TextFrames :
+                                    {
+                                        css::uno::Sequence< css::drawing::EnhancedCustomShapeTextFrame > aPathTextFrames;
+                                        if ( rProp.Value >>= aPathTextFrames )
+                                        {
+                                            if ( aPathTextFrames.hasElements() )
+                                            {
+                                                for ( const auto& rPathTextFrame : std::as_const(aPathTextFrames) )
+                                                {
+                                                    ExportParameter( aStrBuffer, rPathTextFrame.TopLeft.First );
+                                                    ExportParameter( aStrBuffer, rPathTextFrame.TopLeft.Second );
+                                                    ExportParameter( aStrBuffer, rPathTextFrame.BottomRight.First );
+                                                    ExportParameter( aStrBuffer, rPathTextFrame.BottomRight.Second );
+                                                }
+                                                aStr = aStrBuffer.makeStringAndClear();
+                                            }
+                                            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_AREAS, aStr );
+                                        }
+                                    }
+                                    break;
+                                    default:
+                                        break;
+                                }
+                            }
+                        }
+                    }
+                    break;
+                    case EAS_Equations :
+                    {
+                        bEquations = ( rGeoProp.Value >>= aEquations );
+                    }
+                    break;
+                    case EAS_Handles :
+                    {
+                        bHandles = ( rGeoProp.Value >>= aHandles );
+                    }
+                    break;
+                    case EAS_AdjustmentValues :
+                    {
+                        rGeoProp.Value >>= aAdjustmentValues;
+                    }
+                    break;
+                    default:
+                        break;
+                }
+            }   // for
+            rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TYPE, aCustomShapeType );
+
+            // adjustments
+            sal_Int32 nAdjustmentValues = aAdjustmentValues.getLength();
+            if ( nAdjustmentValues )
+            {
+                sal_Int32 i, nValue = 0;
+                for ( i = 0; i < nAdjustmentValues; i++ )
+                {
+                    if ( i )
+                        aStrBuffer.append( ' ' );
+
+                    const css::drawing::EnhancedCustomShapeAdjustmentValue& rAdj = aAdjustmentValues[ i ];
+                    if ( rAdj.State == beans::PropertyState_DIRECT_VALUE )
+                    {
+                        if ( rAdj.Value.getValueTypeClass() == uno::TypeClass_DOUBLE )
+                        {
+                            double fValue = 0.0;
+                            rAdj.Value >>= fValue;
+                            ::sax::Converter::convertDouble(aStrBuffer, fValue);
+                        }
+                        else
+                        {
+                            rAdj.Value >>= nValue;
+                            aStrBuffer.append(nValue);
+                        }
+                    }
+                    else
+                    {
+                        // this should not be, but better than setting nothing
+                        aStrBuffer.append("0");
+                    }
+                }
+                aStr = aStrBuffer.makeStringAndClear();
+                rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MODIFIERS, aStr );
+            }
+            if ( bCoordinates )
+                ImpExportEnhancedPath( rExport, aCoordinates, aSegments );
+        }
+    }
+    SvXMLElementExport aOBJ( rExport, XML_NAMESPACE_DRAW, XML_ENHANCED_GEOMETRY, true, true );
+    if ( bEquations )
+        ImpExportEquations( rExport, aEquations );
+    if ( bHandles )
+        ImpExportHandles( rExport, aHandles );
+}
+
+void XMLShapeExport::ImpExportCustomShape(
+    const uno::Reference< drawing::XShape >& xShape,
+    XMLShapeExportFlags nFeatures, css::awt::Point* pRefPoint )
+{
+    const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    if ( !xPropSet.is() )
+        return;
+
+    uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
+
+    // Transformation
+    ImpExportNewTrans( xPropSet, nFeatures, pRefPoint );
+
+    if ( xPropSetInfo.is() )
+    {
+        OUString aStr;
+        if ( xPropSetInfo->hasPropertyByName( "CustomShapeEngine" ) )
+        {
+            uno::Any aEngine( xPropSet->getPropertyValue( "CustomShapeEngine" ) );
+            if ( ( aEngine >>= aStr ) && !aStr.isEmpty() )
+                mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_ENGINE, aStr );
+        }
+        if ( xPropSetInfo->hasPropertyByName( "CustomShapeData" ) )
+        {
+            uno::Any aData( xPropSet->getPropertyValue( "CustomShapeData" ) );
+            if ( ( aData >>= aStr ) && !aStr.isEmpty() )
+                mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DATA, aStr );
+        }
+    }
+    bool bCreateNewline( (nFeatures & XMLShapeExportFlags::NO_WS) == XMLShapeExportFlags::NONE ); // #86116#/#92210#
+    SvXMLElementExport aOBJ( mrExport, XML_NAMESPACE_DRAW, XML_CUSTOM_SHAPE, bCreateNewline, true );
+    ImpExportDescription( xShape ); // #i68101#
+    ImpExportEvents( xShape );
+    ImpExportGluePoints( xShape );
+    ImpExportText( xShape );
+    ImpExportEnhancedGeometry( mrExport, xPropSet );
+
+}
+
+void XMLShapeExport::ImpExportTableShape( const uno::Reference< drawing::XShape >& xShape, XmlShapeType eShapeType, XMLShapeExportFlags nFeatures, css::awt::Point* pRefPoint )
+{
+    uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
+    uno::Reference< container::XNamed > xNamed(xShape, uno::UNO_QUERY);
+
+    SAL_WARN_IF( !xPropSet.is() || !xNamed.is(), "xmloff", "xmloff::XMLShapeExport::ImpExportTableShape(), table shape is not implementing needed interfaces");
+    if(!(xPropSet.is() && xNamed.is()))
+        return;
+
+    try
+    {
+        // Transformation
+        ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
+
+        bool bIsEmptyPresObj = false;
+
+        // presentation settings
+        if(eShapeType == XmlShapeTypePresTableShape)
+            bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_TABLE) );
+
+        const bool bCreateNewline( (nFeatures & XMLShapeExportFlags::NO_WS) == XMLShapeExportFlags::NONE );
+        const bool bExportEmbedded(mrExport.getExportFlags() & SvXMLExportFlags::EMBEDDED);
+
+        SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW, XML_FRAME, bCreateNewline, true );
+
+        // do not export in ODF 1.1 or older
+        if (mrExport.getSaneDefaultVersion() >= SvtSaveOptions::ODFSVER_012)
+        {
+            if( !bIsEmptyPresObj )
+            {
+                uno::Reference< container::XNamed > xTemplate( xPropSet->getPropertyValue("TableTemplate"), uno::UNO_QUERY );
+                if( xTemplate.is() )
+                {
+                    const OUString sTemplate( xTemplate->getName() );
+                    if( !sTemplate.isEmpty() )
+                    {
+                        mrExport.AddAttribute(XML_NAMESPACE_TABLE, XML_TEMPLATE_NAME, sTemplate );
+
+                        for( const XMLPropertyMapEntry* pEntry = &aXMLTableShapeAttributes[0]; pEntry->msApiName; pEntry++ )
+                        {
+                            try
+                            {
+                                bool bBool = false;
+                                const OUString sAPIPropertyName( pEntry->msApiName, pEntry->nApiNameLength, RTL_TEXTENCODING_ASCII_US );
+
+                                xPropSet->getPropertyValue( sAPIPropertyName ) >>= bBool;
+                                if( bBool )
+                                    mrExport.AddAttribute(pEntry->mnNameSpace, pEntry->meXMLName, XML_TRUE );
+                            }
+                            catch( uno::Exception& )
+                            {
+                                DBG_UNHANDLED_EXCEPTION("xmloff.draw");
+                            }
+                        }
+                    }
+                }
+
+                uno::Reference< table::XColumnRowRange > xRange( xPropSet->getPropertyValue( gsModel ), uno::UNO_QUERY_THROW );
+                GetShapeTableExport()->exportTable( xRange );
+            }
+        }
+
+        if( !bIsEmptyPresObj )
+        {
+            uno::Reference< graphic::XGraphic > xGraphic( xPropSet->getPropertyValue("ReplacementGraphic"), uno::UNO_QUERY );
+            if( xGraphic.is() ) try
+            {
+                uno::Reference< uno::XComponentContext > xContext = GetExport().getComponentContext();
+
+                uno::Reference< embed::XStorage > xPictureStorage;
+                uno::Reference< embed::XStorage > xStorage;
+                uno::Reference< io::XStream > xPictureStream;
+
+                OUString sPictureName;
+                if( bExportEmbedded )
+                {
+                    xPictureStream.set( xContext->getServiceManager()->createInstanceWithContext( "com.sun.star.comp.MemoryStream", xContext), uno::UNO_QUERY_THROW );
+                }
+                else
+                {
+                    xStorage.set( GetExport().GetTargetStorage(), uno::UNO_SET_THROW );
+
+                    xPictureStorage.set( xStorage->openStorageElement( "Pictures" , ::embed::ElementModes::READWRITE ), uno::UNO_SET_THROW );
+
+                    sal_Int32 nIndex = 0;
+                    do
+                    {
+                        sPictureName = "TablePreview" + OUString::number( ++nIndex ) + ".svm";
+                    }
+                    while( xPictureStorage->hasByName( sPictureName ) );
+
+                    xPictureStream.set( xPictureStorage->openStreamElement( sPictureName, ::embed::ElementModes::READWRITE ), uno::UNO_SET_THROW );
+                }
+
+                uno::Reference< graphic::XGraphicProvider > xProvider( graphic::GraphicProvider::create(xContext) );
+                uno::Sequence< beans::PropertyValue > aArgs{
+                    comphelper::makePropertyValue("MimeType", OUString( "image/x-vclgraphic" )),
+                    comphelper::makePropertyValue("OutputStream", xPictureStream->getOutputStream())
+                };
+                xProvider->storeGraphic( xGraphic, aArgs );
+
+                if( xPictureStorage.is() )
+                {
+                    uno::Reference< embed::XTransactedObject > xTrans( xPictureStorage, uno::UNO_QUERY );
+                    if( xTrans.is() )
+                        xTrans->commit();
+                }
+
+                if( !bExportEmbedded )
+                {
+                    OUString sURL = "Pictures/" + sPictureName;
+                    mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, sURL );
+                    mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+                    mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+                    mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
+                }
+
+                SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_DRAW, XML_IMAGE, false, true );
+
+                if( bExportEmbedded )
+                {
+                    uno::Reference< io::XSeekableInputStream > xSeekable( xPictureStream, uno::UNO_QUERY_THROW );
+                    xSeekable->seek(0);
+
+                    XMLBase64Export aBase64Exp( GetExport() );
+                    aBase64Exp.exportOfficeBinaryDataElement( uno::Reference < io::XInputStream >( xPictureStream, uno::UNO_QUERY_THROW ) );
+                }
+            }
+            catch( uno::Exception const & )
+            {
+                DBG_UNHANDLED_EXCEPTION("xmloff.draw");
+            }
+        }
+
+        ImpExportEvents( xShape );
+        ImpExportGluePoints( xShape );
+        ImpExportDescription( xShape ); // #i68101#
+    }
+    catch( uno::Exception const & )
+    {
+        DBG_UNHANDLED_EXCEPTION("xmloff.draw");
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/shapeimport.cxx b/xmloff/source/draw/shapeimport.cxx
new file mode 100644
index 000000000..930051b2a
--- /dev/null
+++ b/xmloff/source/draw/shapeimport.cxx
@@ -0,0 +1,950 @@
+/* -*- 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 <tools/debug.hxx>
+#include <tools/diagnose_ex.h>
+#include <sal/log.hxx>
+#include <comphelper/attributelist.hxx>
+
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/text/PositionLayoutDir.hpp>
+#include <com/sun/star/drawing/XShapes3.hpp>
+
+#include <utility>
+#include <xmloff/unointerfacetouniqueidentifiermapper.hxx>
+
+#include <xmloff/shapeimport.hxx>
+#include <xmloff/xmlstyle.hxx>
+#include <xmloff/xmltkmap.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/table/XMLTableImport.hxx>
+#include <xmloff/attrlist.hxx>
+#include "eventimp.hxx"
+#include "ximpshap.hxx"
+#include "sdpropls.hxx"
+#include <xmloff/xmlprmap.hxx>
+#include "ximp3dscene.hxx"
+#include "ximp3dobject.hxx"
+#include "ximpgrp.hxx"
+#include "ximplink.hxx"
+
+#include <unordered_map>
+#include <string_view>
+#include <vector>
+
+namespace {
+
+class ShapeGroupContext;
+
+}
+
+using namespace ::std;
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+namespace {
+
+struct ConnectionHint
+{
+    css::uno::Reference< css::drawing::XShape > mxConnector;
+    OUString  aDestShapeId;
+    sal_Int32 nDestGlueId;
+    bool      bStart;
+};
+
+}
+
+/** this map store all gluepoint id mappings for shapes that had user defined gluepoints. This
+    is needed because on insertion the gluepoints will get a new and unique id */
+typedef std::map<sal_Int32,sal_Int32> GluePointIdMap;
+typedef std::unordered_map< css::uno::Reference < css::drawing::XShape >, GluePointIdMap > ShapeGluePointsMap;
+
+/** this struct is created for each startPage() call and stores information that is needed during
+    import of shapes for one page. Since pages could be nested ( notes pages inside impress ) there
+    is a pointer so one can build up a stack of this structs */
+struct XMLShapeImportPageContextImpl
+{
+    ShapeGluePointsMap      maShapeGluePointsMap;
+
+    uno::Reference < drawing::XShapes > mxShapes;
+
+    std::shared_ptr<XMLShapeImportPageContextImpl> mpNext;
+};
+
+/** this class is to enable adding members to the XMLShapeImportHelper without getting incompatible */
+struct XMLShapeImportHelperImpl
+{
+    // context for sorting shapes
+    std::shared_ptr<ShapeGroupContext> mpGroupContext;
+
+    std::vector<ConnectionHint> maConnections;
+
+    // #88546# possibility to switch progress bar handling on/off
+    bool                        mbHandleProgressBar;
+
+    // stores the capability of the current model to create presentation shapes
+    bool                        mbIsPresentationShapesSupported;
+};
+
+constexpr OUStringLiteral gsStartShape(u"StartShape");
+constexpr OUStringLiteral gsEndShape(u"EndShape");
+constexpr OUStringLiteral gsStartGluePointIndex(u"StartGluePointIndex");
+constexpr OUStringLiteral gsEndGluePointIndex(u"EndGluePointIndex");
+
+XMLShapeImportHelper::XMLShapeImportHelper(
+        SvXMLImport& rImporter,
+        const uno::Reference< frame::XModel>& rModel,
+        SvXMLImportPropertyMapper *pExtMapper )
+:   mpImpl( new XMLShapeImportHelperImpl ),
+    mrImporter( rImporter )
+{
+    mpImpl->mpGroupContext = nullptr;
+
+    // #88546# init to sal_False
+    mpImpl->mbHandleProgressBar = false;
+
+    mpSdPropHdlFactory = new XMLSdPropHdlFactory( rModel, rImporter );
+
+    // construct PropertySetMapper
+    rtl::Reference < XMLPropertySetMapper > xMapper = new XMLShapePropertySetMapper(mpSdPropHdlFactory, false);
+    mpPropertySetMapper = new SvXMLImportPropertyMapper( xMapper, rImporter );
+
+    if( pExtMapper )
+    {
+        rtl::Reference < SvXMLImportPropertyMapper > xExtMapper( pExtMapper );
+        mpPropertySetMapper->ChainImportMapper( xExtMapper );
+    }
+
+    // chain text attributes
+    mpPropertySetMapper->ChainImportMapper(XMLTextImportHelper::CreateParaExtPropMapper(rImporter));
+    mpPropertySetMapper->ChainImportMapper(XMLTextImportHelper::CreateParaDefaultExtPropMapper(rImporter));
+
+    // construct PresPagePropsMapper
+    xMapper = new XMLPropertySetMapper(aXMLSDPresPageProps, mpSdPropHdlFactory, false);
+    mpPresPagePropsMapper = new SvXMLImportPropertyMapper( xMapper, rImporter );
+
+    uno::Reference< lang::XServiceInfo > xInfo( rImporter.GetModel(), uno::UNO_QUERY );
+    mpImpl->mbIsPresentationShapesSupported = xInfo.is() && xInfo->supportsService( "com.sun.star.presentation.PresentationDocument" );
+}
+
+XMLShapeImportHelper::~XMLShapeImportHelper()
+{
+    SAL_WARN_IF( !mpImpl->maConnections.empty(), "xmloff", "XMLShapeImportHelper::restoreConnections() was not called!" );
+
+    // cleanup factory, decrease refcount. Should lead to destruction.
+    mpSdPropHdlFactory.clear();
+
+    // cleanup mapper, decrease refcount. Should lead to destruction.
+    mpPropertySetMapper.clear();
+
+    // cleanup presPage mapper, decrease refcount. Should lead to destruction.
+    mpPresPagePropsMapper.clear();
+
+    // Styles or AutoStyles context?
+    if(mxStylesContext.is())
+        mxStylesContext->dispose();
+
+    if(mxAutoStylesContext.is())
+        mxAutoStylesContext->dispose();
+}
+
+
+SvXMLShapeContext* XMLShapeImportHelper::Create3DSceneChildContext(
+    SvXMLImport& rImport,
+    sal_Int32 nElement,
+    const uno::Reference< xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes)
+{
+    SdXMLShapeContext *pContext = nullptr;
+
+    if(rShapes.is())
+    {
+        switch(nElement)
+        {
+            case XML_ELEMENT(DR3D, XML_SCENE):
+            {
+                // dr3d:3dscene inside dr3d:3dscene context
+                pContext = new SdXML3DSceneShapeContext( rImport, xAttrList, rShapes, false);
+                break;
+            }
+            case XML_ELEMENT(DR3D, XML_CUBE):
+            {
+                // dr3d:3dcube inside dr3d:3dscene context
+                pContext = new SdXML3DCubeObjectShapeContext( rImport, xAttrList, rShapes);
+                break;
+            }
+            case XML_ELEMENT(DR3D, XML_SPHERE):
+            {
+                // dr3d:3dsphere inside dr3d:3dscene context
+                pContext = new SdXML3DSphereObjectShapeContext( rImport, xAttrList, rShapes);
+                break;
+            }
+            case XML_ELEMENT(DR3D, XML_ROTATE):
+            {
+                // dr3d:3dlathe inside dr3d:3dscene context
+                pContext = new SdXML3DLatheObjectShapeContext( rImport, xAttrList, rShapes);
+                break;
+            }
+            case XML_ELEMENT(DR3D, XML_EXTRUDE):
+            {
+                // dr3d:3dextrude inside dr3d:3dscene context
+                pContext = new SdXML3DExtrudeObjectShapeContext( rImport, xAttrList, rShapes);
+                break;
+            }
+            default:
+                XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+        }
+    }
+
+    if (!pContext)
+        return nullptr;
+
+    // now parse the attribute list and call the child context for each unknown attribute
+    for(auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList))
+    {
+        if (!pContext->processAttribute( aIter ))
+            XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+
+    }
+
+    return pContext;
+}
+
+void XMLShapeImportHelper::SetStylesContext(SvXMLStylesContext* pNew)
+{
+    mxStylesContext.set(pNew);
+}
+
+void XMLShapeImportHelper::SetAutoStylesContext(SvXMLStylesContext* pNew)
+{
+    mxAutoStylesContext.set(pNew);
+}
+
+SvXMLShapeContext* XMLShapeImportHelper::CreateGroupChildContext(
+    SvXMLImport& rImport,
+    sal_Int32 nElement,
+    const uno::Reference< xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes,
+    bool bTemporaryShape)
+{
+    SdXMLShapeContext *pContext = nullptr;
+    switch (nElement)
+    {
+        case XML_ELEMENT(DRAW, XML_G):
+            // draw:g inside group context (RECURSIVE)
+            pContext = new SdXMLGroupShapeContext( rImport, xAttrList, rShapes, bTemporaryShape);
+            break;
+        case XML_ELEMENT(DR3D, XML_SCENE):
+        {
+            // dr3d:3dscene inside group context
+            pContext = new SdXML3DSceneShapeContext( rImport, xAttrList, rShapes, bTemporaryShape);
+            break;
+        }
+        case XML_ELEMENT(DRAW, XML_RECT):
+        {
+            // draw:rect inside group context
+            pContext = new SdXMLRectShapeContext( rImport, xAttrList, rShapes, bTemporaryShape );
+            break;
+        }
+        case XML_ELEMENT(DRAW, XML_LINE):
+        {
+            // draw:line inside group context
+            pContext = new SdXMLLineShapeContext( rImport, xAttrList, rShapes, bTemporaryShape );
+            break;
+        }
+        case XML_ELEMENT(DRAW, XML_CIRCLE):
+        case XML_ELEMENT(DRAW, XML_ELLIPSE):
+        {
+            // draw:circle or draw:ellipse inside group context
+            pContext = new SdXMLEllipseShapeContext( rImport, xAttrList, rShapes, bTemporaryShape );
+            break;
+        }
+        case XML_ELEMENT(DRAW, XML_POLYGON):
+        case XML_ELEMENT(DRAW, XML_POLYLINE):
+        {
+            // draw:polygon or draw:polyline inside group context
+            pContext = new SdXMLPolygonShapeContext( rImport, xAttrList, rShapes,
+                           nElement == XML_ELEMENT(DRAW, XML_POLYGON), bTemporaryShape );
+            break;
+        }
+        case XML_ELEMENT(DRAW, XML_PATH):
+        {
+            // draw:path inside group context
+            pContext = new SdXMLPathShapeContext( rImport, xAttrList, rShapes, bTemporaryShape);
+            break;
+        }
+        case XML_ELEMENT(DRAW, XML_FRAME):
+        {
+            // text:text-box inside group context
+            pContext = new SdXMLFrameShapeContext( rImport, xAttrList, rShapes, bTemporaryShape );
+            break;
+        }
+        case XML_ELEMENT(DRAW, XML_CONTROL):
+        {
+            // draw:control inside group context
+            pContext = new SdXMLControlShapeContext( rImport, xAttrList, rShapes, bTemporaryShape );
+            break;
+        }
+        case XML_ELEMENT(DRAW, XML_CONNECTOR):
+        {
+            // draw:connector inside group context
+            pContext = new SdXMLConnectorShapeContext( rImport, xAttrList, rShapes, bTemporaryShape );
+            break;
+        }
+        case XML_ELEMENT(DRAW, XML_MEASURE):
+        {
+            // draw:measure inside group context
+            pContext = new SdXMLMeasureShapeContext( rImport, xAttrList, rShapes, bTemporaryShape );
+            break;
+        }
+        case XML_ELEMENT(DRAW, XML_PAGE_THUMBNAIL):
+        {
+            // draw:page inside group context
+            pContext = new SdXMLPageShapeContext( rImport, xAttrList, rShapes, bTemporaryShape );
+            break;
+        }
+        case XML_ELEMENT(DRAW, XML_CAPTION):
+        case XML_ELEMENT(OFFICE, XML_ANNOTATION):
+        {
+            // draw:caption inside group context
+            pContext = new SdXMLCaptionShapeContext( rImport, xAttrList, rShapes, bTemporaryShape );
+            break;
+        }
+        case XML_ELEMENT(CHART, XML_CHART):
+        {
+            // chart:chart inside group context
+            pContext = new SdXMLChartShapeContext( rImport, xAttrList, rShapes, bTemporaryShape );
+            break;
+        }
+        case XML_ELEMENT(DRAW, XML_CUSTOM_SHAPE):
+        {
+            // draw:customshape
+            pContext = new SdXMLCustomShapeContext( rImport, xAttrList, rShapes );
+            break;
+        }
+        case XML_ELEMENT(DRAW, XML_A):
+            return new SdXMLShapeLinkContext( rImport, xAttrList, rShapes );
+        // add other shapes here...
+        default:
+            XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+            return new SvXMLShapeContext( rImport, bTemporaryShape );
+    }
+
+    // now parse the attribute list and call the child context for each unknown attribute
+    for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+    {
+        if (!pContext->processAttribute( aIter ))
+            XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+    }
+    return pContext;
+}
+
+// This method is called from SdXMLFrameShapeContext to create children of draw:frame
+SvXMLShapeContext* XMLShapeImportHelper::CreateFrameChildContext(
+    SvXMLImport& rImport,
+    sal_Int32 nElement,
+    const uno::Reference< xml::sax::XFastAttributeList>& rAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes,
+    const uno::Reference< xml::sax::XFastAttributeList>& rFrameAttrList)
+{
+    SdXMLShapeContext *pContext = nullptr;
+
+    rtl::Reference<sax_fastparser::FastAttributeList> xCombinedAttrList = new sax_fastparser::FastAttributeList(rAttrList);
+    if( rFrameAttrList.is() )
+        xCombinedAttrList->add(rFrameAttrList);
+
+    switch(nElement)
+    {
+        case XML_ELEMENT(DRAW, XML_TEXT_BOX):
+        {
+            // text:text-box inside group context
+            pContext = new SdXMLTextBoxShapeContext( rImport, xCombinedAttrList, rShapes );
+            break;
+        }
+        case XML_ELEMENT(DRAW, XML_IMAGE):
+        {
+            // office:image inside group context
+            pContext = new SdXMLGraphicObjectShapeContext( rImport, xCombinedAttrList, rShapes );
+            break;
+        }
+        case XML_ELEMENT(DRAW, XML_OBJECT):
+        case XML_ELEMENT(DRAW, XML_OBJECT_OLE):
+        {
+            // draw:object or draw:object_ole
+            pContext = new SdXMLObjectShapeContext( rImport, xCombinedAttrList, rShapes );
+            break;
+        }
+        case XML_ELEMENT(TABLE, XML_TABLE):
+        {
+            // draw:object or draw:object_ole
+            if( rImport.IsTableShapeSupported() )
+                pContext = new SdXMLTableShapeContext( rImport, xCombinedAttrList, rShapes );
+            break;
+
+        }
+        case XML_ELEMENT(DRAW, XML_PLUGIN):
+        {
+            // draw:plugin
+            pContext = new SdXMLPluginShapeContext( rImport, xCombinedAttrList, rShapes );
+            break;
+        }
+        case XML_ELEMENT(DRAW, XML_FLOATING_FRAME):
+        {
+            // draw:floating-frame
+            pContext = new SdXMLFloatingFrameShapeContext( rImport, xCombinedAttrList, rShapes );
+            break;
+        }
+        case XML_ELEMENT(DRAW, XML_APPLET):
+        {
+            // draw:applet
+            pContext = new SdXMLAppletShapeContext( rImport, xCombinedAttrList, rShapes );
+            break;
+        }
+        // add other shapes here...
+        default:
+            SAL_INFO("xmloff", "unknown element " << SvXMLImport::getPrefixAndNameFromToken(nElement));
+            break;
+    }
+
+    if( pContext )
+    {
+        // now parse the attribute list and call the child context for each unknown attribute
+        for(auto& aIter : *xCombinedAttrList)
+        {
+            if (!pContext->processAttribute( aIter ))
+                SAL_INFO("xmloff", "unknown attribute " << SvXMLImport::getPrefixAndNameFromToken(aIter.getToken()) << " value=" << aIter.toString());
+        }
+    }
+
+    return pContext;
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > XMLShapeImportHelper::CreateFrameChildContext(
+    SvXMLImportContext *pThisContext,
+    sal_Int32 nElement,
+    const uno::Reference< xml::sax::XFastAttributeList>& xAttrList )
+{
+    css::uno::Reference< css::xml::sax::XFastContextHandler > xContext;
+    SdXMLFrameShapeContext *pFrameContext = dynamic_cast<SdXMLFrameShapeContext*>( pThisContext  );
+    if (pFrameContext)
+        xContext = pFrameContext->createFastChildContext( nElement, xAttrList );
+
+    if (!xContext)
+        XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+    return xContext;
+}
+
+/** this function is called whenever the implementation classes like to add this new
+    shape to the given XShapes.
+*/
+void XMLShapeImportHelper::addShape( uno::Reference< drawing::XShape >& rShape,
+                                     const uno::Reference< xml::sax::XFastAttributeList >&,
+                                     uno::Reference< drawing::XShapes >& rShapes)
+{
+    if( rShape.is() && rShapes.is() )
+    {
+        // add new shape to parent
+        rShapes->add( rShape );
+
+        uno::Reference<beans::XPropertySet> xPropertySet(rShape, uno::UNO_QUERY);
+        if (xPropertySet.is())
+        {
+            xPropertySet->setPropertyValue("HandlePathObjScale", uno::Any(true));
+        }
+    }
+}
+
+/** this function is called whenever the implementation classes have finished importing
+    a shape to the given XShapes. The shape is already inserted into its XShapes and
+    all properties and styles are set.
+*/
+void XMLShapeImportHelper::finishShape(
+        css::uno::Reference< css::drawing::XShape >& rShape,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >&,
+        css::uno::Reference< css::drawing::XShapes >&)
+{
+    /* Set property <PositionLayoutDir>
+       to <PositionInHoriL2R>, if it exists and the import states that
+       the shape positioning attributes are in horizontal left-to-right
+       layout. This is the case for the OpenOffice.org file format.
+       This setting is done for Writer documents, because the property
+       only exists at service css::text::Shape - the Writer
+       UNO service for shapes.
+       The value indicates that the positioning attributes are given
+       in horizontal left-to-right layout. The property is evaluated
+       during the first positioning of the shape in order to convert
+       the shape position given in the OpenOffice.org file format to
+       the one for the OASIS Open Office file format. (#i28749#, #i36248#)
+    */
+    uno::Reference< beans::XPropertySet > xPropSet(rShape, uno::UNO_QUERY);
+    if ( xPropSet.is() )
+    {
+        if ( mrImporter.IsShapePositionInHoriL2R() &&
+             xPropSet->getPropertySetInfo()->hasPropertyByName(
+                "PositionLayoutDir") )
+        {
+            uno::Any aPosLayoutDir;
+            aPosLayoutDir <<= text::PositionLayoutDir::PositionInHoriL2R;
+            xPropSet->setPropertyValue( "PositionLayoutDir", aPosLayoutDir );
+        }
+    }
+}
+
+namespace {
+
+// helper functions for z-order sorting
+struct ZOrderHint
+{
+    sal_Int32 nIs;
+    sal_Int32 nShould;
+    /// The hint is for this shape.
+    uno::Reference<drawing::XShape> xShape;
+
+    bool operator<(const ZOrderHint& rComp) const { return nShould < rComp.nShould; }
+};
+
+// a) handle z-order of group contents after it has been imported
+// b) apply group events over group contents after it has been imported
+class ShapeGroupContext
+{
+public:
+    uno::Reference< drawing::XShapes > mxShapes;
+    std::vector<SdXMLEventContextData> maEventData;
+    vector<ZOrderHint>              maZOrderList;
+    vector<ZOrderHint>              maUnsortedList;
+
+    sal_Int32                       mnCurrentZ;
+    std::shared_ptr<ShapeGroupContext> mpParentContext;
+
+    ShapeGroupContext( uno::Reference< drawing::XShapes > const & rShapes, std::shared_ptr<ShapeGroupContext> pParentContext );
+
+    void popGroupAndPostProcess();
+private:
+    void moveShape( sal_Int32 nSourcePos, sal_Int32 nDestPos );
+};
+
+}
+
+ShapeGroupContext::ShapeGroupContext( uno::Reference< drawing::XShapes > const & rShapes, std::shared_ptr<ShapeGroupContext> pParentContext )
+:   mxShapes( rShapes ), mnCurrentZ( 0 ), mpParentContext( std::move(pParentContext) )
+{
+}
+
+void ShapeGroupContext::moveShape( sal_Int32 nSourcePos, sal_Int32 nDestPos )
+{
+    uno::Any aAny( mxShapes->getByIndex( nSourcePos ) );
+    uno::Reference< beans::XPropertySet > xPropSet;
+    aAny >>= xPropSet;
+
+    if( !(xPropSet.is() && xPropSet->getPropertySetInfo()->hasPropertyByName( "ZOrder" )) )
+        return;
+
+    xPropSet->setPropertyValue( "ZOrder", uno::Any(nDestPos) );
+
+    for( ZOrderHint& rHint : maZOrderList )
+    {
+        if( rHint.nIs < nSourcePos )
+        {
+            DBG_ASSERT(rHint.nIs >= nDestPos, "Shape sorting failed" );
+            rHint.nIs++;
+        }
+    }
+
+    for( ZOrderHint& rHint : maUnsortedList )
+    {
+        if( rHint.nIs < nSourcePos )
+        {
+            SAL_WARN_IF( rHint.nIs < nDestPos, "xmloff", "shape sorting failed" );
+            rHint.nIs++;
+        }
+    }
+}
+
+// sort shapes
+void ShapeGroupContext::popGroupAndPostProcess()
+{
+    if (!maEventData.empty())
+    {
+        // tdf#127791 wait until a group is popped to set its event data
+        for (auto& event : maEventData)
+            event.ApplyProperties();
+        maEventData.clear();
+    }
+
+    // only do something if we have shapes to sort
+    if( maZOrderList.empty() )
+        return;
+
+    // check if there are more shapes than inserted with ::shapeWithZIndexAdded()
+    // This can happen if there where already shapes on the page before import
+    // Since the writer may delete some of this shapes during import, we need
+    // to do this here and not in our c'tor anymore
+
+    // check if we have more shapes than we know of
+    sal_Int32 nCount = mxShapes->getCount();
+
+    nCount -= maZOrderList.size();
+    nCount -= maUnsortedList.size();
+
+    if( nCount > 0 )
+    {
+        // first update offsets of added shapes
+        for (ZOrderHint& rHint : maZOrderList)
+            rHint.nIs += nCount;
+        for (ZOrderHint& rHint : maUnsortedList)
+            rHint.nIs += nCount;
+
+        // second add the already existing shapes in the unsorted list
+        ZOrderHint aNewHint;
+        do
+        {
+            nCount--;
+
+            aNewHint.nIs = nCount;
+            aNewHint.nShould = -1;
+
+            maUnsortedList.insert(maUnsortedList.begin(), aNewHint);
+        }
+        while( nCount );
+    }
+
+    bool bSorted = std::is_sorted(maZOrderList.begin(), maZOrderList.end(),
+                       [](const ZOrderHint& rLeft, const ZOrderHint& rRight)
+                       { return rLeft.nShould < rRight.nShould; } );
+
+    if (bSorted)
+        return; // nothin' to do
+
+    // sort z-ordered shapes by nShould field
+    std::sort(maZOrderList.begin(), maZOrderList.end());
+
+    uno::Reference<drawing::XShapes3> xShapes3(mxShapes, uno::UNO_QUERY);
+    if( xShapes3.is())
+    {
+        uno::Sequence<sal_Int32> aNewOrder(maZOrderList.size() + maUnsortedList.size());
+        auto pNewOrder = aNewOrder.getArray();
+        sal_Int32 nIndex = 0;
+
+        for (const ZOrderHint& rHint : maZOrderList)
+        {
+            // fill in the gaps from unordered list
+            for (vector<ZOrderHint>::iterator aIt = maUnsortedList.begin(); aIt != maUnsortedList.end() && nIndex < rHint.nShould; )
+            {
+                pNewOrder[nIndex++] = (*aIt).nIs;
+                aIt = maUnsortedList.erase(aIt);
+            }
+
+            pNewOrder[nIndex] = rHint.nIs;
+            nIndex++;
+        }
+
+        try
+        {
+            xShapes3->sort(aNewOrder);
+            maZOrderList.clear();
+            return;
+        }
+        catch (const css::lang::IllegalArgumentException& /*e*/)
+        {}
+    }
+
+    // this is the current index, all shapes before that
+    // index are finished
+    sal_Int32 nIndex = 0;
+    for (const ZOrderHint& rHint : maZOrderList)
+    {
+        for (vector<ZOrderHint>::iterator aIt = maUnsortedList.begin(); aIt != maUnsortedList.end() && nIndex < rHint.nShould; )
+        {
+            moveShape( (*aIt).nIs, nIndex++ );
+            aIt = maUnsortedList.erase(aIt);
+
+        }
+
+        if(rHint.nIs != nIndex )
+            moveShape( rHint.nIs, nIndex );
+
+        nIndex++;
+    }
+    maZOrderList.clear();
+}
+
+void XMLShapeImportHelper::pushGroupForPostProcessing( uno::Reference< drawing::XShapes >& rShapes )
+{
+    mpImpl->mpGroupContext = std::make_shared<ShapeGroupContext>( rShapes, mpImpl->mpGroupContext );
+}
+
+void XMLShapeImportHelper::addShapeEvents(SdXMLEventContextData& rData)
+{
+    if (mpImpl->mpGroupContext && mpImpl->mpGroupContext->mxShapes == rData.mxShape)
+    {
+        // tdf#127791 wait until a group is popped to set its event data so
+        // that the events are applied to all its children, which are not available
+        // at the start of the group tag
+        mpImpl->mpGroupContext->maEventData.push_back(rData);
+    }
+    else
+        rData.ApplyProperties();
+}
+
+void XMLShapeImportHelper::popGroupAndPostProcess()
+{
+    SAL_WARN_IF( !mpImpl->mpGroupContext, "xmloff", "No context to sort!" );
+    if( !mpImpl->mpGroupContext )
+        return;
+
+    try
+    {
+        mpImpl->mpGroupContext->popGroupAndPostProcess();
+    }
+    catch( const uno::Exception& )
+    {
+        DBG_UNHANDLED_EXCEPTION("xmloff", "exception while sorting shapes, sorting failed");
+    }
+
+    // put parent on top and drop current context, we are done
+    mpImpl->mpGroupContext = mpImpl->mpGroupContext->mpParentContext;
+}
+
+void XMLShapeImportHelper::shapeWithZIndexAdded( css::uno::Reference< css::drawing::XShape > const & xShape, sal_Int32 nZIndex )
+{
+    if( !mpImpl->mpGroupContext)
+        return;
+
+    ZOrderHint aNewHint;
+    aNewHint.nIs = mpImpl->mpGroupContext->mnCurrentZ++;
+    aNewHint.nShould = nZIndex;
+    aNewHint.xShape = xShape;
+
+    if( nZIndex == -1 )
+    {
+        // don't care, so add to unsorted list
+        mpImpl->mpGroupContext->maUnsortedList.push_back(aNewHint);
+    }
+    else
+    {
+        // insert into sort list
+        mpImpl->mpGroupContext->maZOrderList.push_back(aNewHint);
+    }
+}
+
+void XMLShapeImportHelper::shapeRemoved(const uno::Reference<drawing::XShape>& xShape)
+{
+    auto it = std::find_if(mpImpl->mpGroupContext->maZOrderList.begin(), mpImpl->mpGroupContext->maZOrderList.end(), [&xShape](const ZOrderHint& rHint)
+    {
+        return rHint.xShape == xShape;
+    });
+    if (it == mpImpl->mpGroupContext->maZOrderList.end())
+        // Part of the unsorted list, nothing to do.
+        return;
+
+    sal_Int32 nZIndex = it->nIs;
+
+    for (it = mpImpl->mpGroupContext->maZOrderList.begin(); it != mpImpl->mpGroupContext->maZOrderList.end();)
+    {
+        if (it->nIs == nZIndex)
+        {
+            // This is xShape: remove it and adjust the max of indexes
+            // accordingly.
+            it = mpImpl->mpGroupContext->maZOrderList.erase(it);
+            mpImpl->mpGroupContext->mnCurrentZ--;
+            continue;
+        }
+        else if (it->nIs > nZIndex)
+            // On top of xShape: adjust actual index to reflect removal.
+            it->nIs--;
+
+        // On top of or below xShape.
+        ++it;
+    }
+}
+
+void XMLShapeImportHelper::addShapeConnection( css::uno::Reference< css::drawing::XShape > const & rConnectorShape,
+                         bool bStart,
+                         const OUString& rDestShapeId,
+                         sal_Int32 nDestGlueId )
+{
+    ConnectionHint aHint;
+    aHint.mxConnector = rConnectorShape;
+    aHint.bStart = bStart;
+    aHint.aDestShapeId = rDestShapeId;
+    aHint.nDestGlueId = nDestGlueId;
+
+    mpImpl->maConnections.push_back( aHint );
+}
+
+void XMLShapeImportHelper::restoreConnections()
+{
+    const vector<ConnectionHint>::size_type nCount = mpImpl->maConnections.size();
+    for( vector<ConnectionHint>::size_type i = 0; i < nCount; i++ )
+    {
+        ConnectionHint& rHint = mpImpl->maConnections[i];
+        uno::Reference< beans::XPropertySet > xConnector( rHint.mxConnector, uno::UNO_QUERY );
+        if( xConnector.is() )
+        {
+            // #86637# remember line deltas
+            uno::Any aLine1Delta;
+            uno::Any aLine2Delta;
+            uno::Any aLine3Delta;
+            OUString aStr1("EdgeLine1Delta");
+            OUString aStr2("EdgeLine2Delta");
+            OUString aStr3("EdgeLine3Delta");
+            aLine1Delta = xConnector->getPropertyValue(aStr1);
+            aLine2Delta = xConnector->getPropertyValue(aStr2);
+            aLine3Delta = xConnector->getPropertyValue(aStr3);
+
+            // #86637# simply setting these values WILL force the connector to do
+            // a new layout promptly. So the line delta values have to be rescued
+            // and restored around connector changes.
+            uno::Reference< drawing::XShape > xShape(
+                mrImporter.getInterfaceToIdentifierMapper().getReference( rHint.aDestShapeId ), uno::UNO_QUERY );
+            if( xShape.is() )
+            {
+                if (rHint.bStart)
+                    xConnector->setPropertyValue( gsStartShape, uno::Any(xShape) );
+                else
+                    xConnector->setPropertyValue( gsEndShape, uno::Any(xShape) );
+
+                sal_Int32 nGlueId = rHint.nDestGlueId < 4 ? rHint.nDestGlueId : getGluePointId( xShape, rHint.nDestGlueId );
+                if(rHint.bStart)
+                    xConnector->setPropertyValue( gsStartGluePointIndex, uno::Any(nGlueId) );
+                else
+                    xConnector->setPropertyValue( gsEndGluePointIndex, uno::Any(nGlueId) );
+            }
+
+            // #86637# restore line deltas
+            xConnector->setPropertyValue(aStr1, aLine1Delta );
+            xConnector->setPropertyValue(aStr2, aLine2Delta );
+            xConnector->setPropertyValue(aStr3, aLine3Delta );
+        }
+    }
+    mpImpl->maConnections.clear();
+}
+
+SvXMLImportPropertyMapper* XMLShapeImportHelper::CreateShapePropMapper( const uno::Reference< frame::XModel>& rModel, SvXMLImport& rImport )
+{
+    rtl::Reference< XMLPropertyHandlerFactory > xFactory = new XMLSdPropHdlFactory( rModel, rImport );
+    rtl::Reference < XMLPropertySetMapper > xMapper = new XMLShapePropertySetMapper( xFactory, false );
+    SvXMLImportPropertyMapper* pResult = new SvXMLImportPropertyMapper( xMapper, rImport );
+
+    // chain text attributes
+    pResult->ChainImportMapper( XMLTextImportHelper::CreateParaExtPropMapper( rImport ) );
+    return pResult;
+}
+
+/** adds a mapping for a gluepoint identifier from an xml file to the identifier created after inserting
+    the new gluepoint into the core. The saved mappings can be retrieved by getGluePointId() */
+void XMLShapeImportHelper::addGluePointMapping( css::uno::Reference< css::drawing::XShape > const & xShape,
+                          sal_Int32 nSourceId, sal_Int32 nDestinnationId )
+{
+    if( mpPageContext )
+        mpPageContext->maShapeGluePointsMap[xShape][nSourceId] = nDestinnationId;
+}
+
+/** moves all current DestinationId's by n */
+void XMLShapeImportHelper::moveGluePointMapping( const css::uno::Reference< css::drawing::XShape >& xShape, const sal_Int32 n )
+{
+    if( mpPageContext )
+    {
+        ShapeGluePointsMap::iterator aShapeIter( mpPageContext->maShapeGluePointsMap.find( xShape ) );
+        if( aShapeIter != mpPageContext->maShapeGluePointsMap.end() )
+        {
+            for ( auto& rShapeId : (*aShapeIter).second )
+            {
+                if ( rShapeId.second != -1 )
+                    rShapeId.second += n;
+            }
+        }
+    }
+}
+
+/** retrieves a mapping for a gluepoint identifier from the current xml file to the identifier created after
+    inserting the new gluepoint into the core. The mapping must be initialized first with addGluePointMapping() */
+sal_Int32 XMLShapeImportHelper::getGluePointId( const css::uno::Reference< css::drawing::XShape >& xShape, sal_Int32 nSourceId )
+{
+    if( mpPageContext )
+    {
+        ShapeGluePointsMap::iterator aShapeIter( mpPageContext->maShapeGluePointsMap.find( xShape ) );
+        if( aShapeIter != mpPageContext->maShapeGluePointsMap.end() )
+        {
+            GluePointIdMap::iterator aIdIter = (*aShapeIter).second.find(nSourceId);
+            if( aIdIter != (*aShapeIter).second.end() )
+                return (*aIdIter).second;
+        }
+    }
+
+    return -1;
+}
+
+/** this method must be calling before the first shape is imported for the given page */
+void XMLShapeImportHelper::startPage( css::uno::Reference< css::drawing::XShapes > const & rShapes )
+{
+    const std::shared_ptr<XMLShapeImportPageContextImpl> pOldContext = mpPageContext;
+    mpPageContext = std::make_shared<XMLShapeImportPageContextImpl>();
+    mpPageContext->mpNext = pOldContext;
+    mpPageContext->mxShapes = rShapes;
+}
+
+/** this method must be calling after the last shape is imported for the given page */
+void XMLShapeImportHelper::endPage( css::uno::Reference< css::drawing::XShapes > const & rShapes )
+{
+    SAL_WARN_IF( !mpPageContext || (mpPageContext->mxShapes != rShapes), "xmloff", "wrong call to endPage(), no startPage called or wrong page" );
+    if( nullptr == mpPageContext )
+        return;
+
+    restoreConnections();
+
+    mpPageContext = mpPageContext->mpNext;
+}
+
+/** defines if the import should increment the progress bar or not */
+void XMLShapeImportHelper::enableHandleProgressBar()
+{
+    mpImpl->mbHandleProgressBar = true;
+}
+
+bool XMLShapeImportHelper::IsHandleProgressBarEnabled() const
+{
+    return mpImpl->mbHandleProgressBar;
+}
+
+/** queries the capability of the current model to create presentation shapes */
+bool XMLShapeImportHelper::IsPresentationShapesSupported() const
+{
+    return mpImpl->mbIsPresentationShapesSupported;
+}
+
+const rtl::Reference< XMLTableImport >& XMLShapeImportHelper::GetShapeTableImport()
+{
+    if( !mxShapeTableImport.is() )
+    {
+        rtl::Reference< XMLPropertyHandlerFactory > xFactory( new XMLSdPropHdlFactory( mrImporter.GetModel(), mrImporter ) );
+        rtl::Reference< XMLPropertySetMapper > xPropertySetMapper( new XMLShapePropertySetMapper( xFactory, false ) );
+        mxShapeTableImport = new XMLTableImport( mrImporter, xPropertySetMapper, xFactory );
+    }
+
+    return mxShapeTableImport;
+}
+
+void SvXMLShapeContext::setHyperlink( const OUString& rHyperlink )
+{
+    msHyperlink = rHyperlink;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/xexptran.cxx b/xmloff/source/draw/xexptran.cxx
new file mode 100644
index 000000000..776401fb2
--- /dev/null
+++ b/xmloff/source/draw/xexptran.cxx
@@ -0,0 +1,1057 @@
+/* -*- 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 <string_view>
+
+#include <xexptran.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <osl/diagnose.h>
+#include <sax/tools/converter.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <basegfx/matrix/b2dhommatrix.hxx>
+#include <basegfx/tuple/b2dtuple.hxx>
+#include <basegfx/tuple/b3dtuple.hxx>
+#include <basegfx/matrix/b3dhommatrix.hxx>
+#include <basegfx/numeric/ftools.hxx>
+#include <basegfx/matrix/b3dhommatrixtools.hxx>
+
+using namespace ::com::sun::star;
+
+using std::make_unique;
+
+// parsing help functions for simple chars
+static void Imp_SkipSpaces(std::u16string_view rStr, sal_Int32& rPos, const sal_Int32 nLen)
+{
+    while(rPos < nLen
+        && ' ' == rStr[rPos])
+        rPos++;
+}
+
+static void Imp_SkipSpacesAndOpeningBraces(std::u16string_view rStr, sal_Int32& rPos, const sal_Int32 nLen)
+{
+    while(rPos < nLen
+        && (' ' == rStr[rPos] || '(' == rStr[rPos]))
+        rPos++;
+}
+
+static void Imp_SkipSpacesAndCommas(std::u16string_view rStr, sal_Int32& rPos, const sal_Int32 nLen)
+{
+    while(rPos < nLen
+        && (' ' == rStr[rPos] || ',' == rStr[rPos]))
+        rPos++;
+}
+
+static void Imp_SkipSpacesAndClosingBraces(std::u16string_view rStr, sal_Int32& rPos, const sal_Int32 nLen)
+{
+    while(rPos < nLen
+        && (' ' == rStr[rPos] || ')' == rStr[rPos]))
+        rPos++;
+}
+
+// parsing help functions for integer numbers
+
+static bool Imp_IsOnUnitChar(std::u16string_view rStr, const sal_Int32 nPos)
+{
+    sal_Unicode aChar(rStr[nPos]);
+
+    return ('a' <= aChar && 'z' >= aChar)
+        || ('A' <= aChar && 'Z' >= aChar)
+        || '%' == aChar;
+}
+
+static double Imp_GetDoubleChar(std::u16string_view rStr, sal_Int32& rPos, const sal_Int32 nLen,
+    const SvXMLUnitConverter& rConv, double fRetval, bool bLookForUnits = false)
+{
+    sal_Unicode aChar(rStr[rPos]);
+    OUStringBuffer sNumberString(32);
+
+    if('+' == aChar || '-' == aChar)
+    {
+        sNumberString.append(rStr[rPos]);
+        ++rPos;
+        aChar = rPos >= nLen ? 0 : rStr[rPos];
+    }
+
+    while(('0' <= aChar && '9' >= aChar)
+        || '.' == aChar)
+    {
+        sNumberString.append(rStr[rPos]);
+        ++rPos;
+        aChar = rPos >= nLen ? 0 : rStr[rPos];
+    }
+
+    if('e' == aChar || 'E' == aChar)
+    {
+        sNumberString.append(rStr[rPos]);
+        ++rPos;
+        aChar = rPos >= nLen ? 0 : rStr[rPos];
+
+        if('+' == aChar || '-' == aChar)
+        {
+            sNumberString.append(rStr[rPos]);
+            ++rPos;
+            aChar = rPos >= nLen ? 0 : rStr[rPos];
+        }
+
+        while('0' <= aChar && '9' >= aChar)
+        {
+            sNumberString.append(rStr[rPos]);
+            ++rPos;
+            aChar = rPos >= nLen ? 0 : rStr[rPos];
+        }
+    }
+
+    if(bLookForUnits)
+    {
+        Imp_SkipSpaces(rStr, rPos, nLen);
+        while(rPos < nLen && Imp_IsOnUnitChar(rStr, rPos))
+            sNumberString.append(rStr[rPos++]);
+    }
+
+    if(!sNumberString.isEmpty())
+    {
+        if(bLookForUnits)
+            rConv.convertDouble(fRetval, sNumberString);
+        else
+        {
+            ::sax::Converter::convertDouble(fRetval, sNumberString);
+        }
+    }
+
+    return fRetval;
+}
+
+static void Imp_PutDoubleChar(OUString& rStr, double fValue)
+{
+    OUStringBuffer sStringBuffer;
+    ::sax::Converter::convertDouble(sStringBuffer, fValue);
+    rStr += sStringBuffer;
+}
+
+static void Imp_PutDoubleChar(OUStringBuffer& rStr, const SvXMLUnitConverter& rConv, double fValue,
+    bool bConvertUnits = false)
+{
+    OUStringBuffer sStringBuffer;
+
+    if(bConvertUnits)
+        rConv.convertDouble(sStringBuffer, fValue);
+    else
+    {
+        ::sax::Converter::convertDouble(sStringBuffer, fValue);
+    }
+
+    rStr.append(sStringBuffer);
+}
+
+// base class of all 2D transform objects
+
+struct ImpSdXMLExpTransObj2DBase
+{
+    sal_uInt16                  mnType;
+    explicit ImpSdXMLExpTransObj2DBase(sal_uInt16 nType)
+    :   mnType(nType) {}
+};
+
+// possible object types for 2D
+
+#define IMP_SDXMLEXP_TRANSOBJ2D_ROTATE          0x0000
+#define IMP_SDXMLEXP_TRANSOBJ2D_SCALE           0x0001
+#define IMP_SDXMLEXP_TRANSOBJ2D_TRANSLATE       0x0002
+#define IMP_SDXMLEXP_TRANSOBJ2D_SKEWX           0x0003
+#define IMP_SDXMLEXP_TRANSOBJ2D_SKEWY           0x0004
+#define IMP_SDXMLEXP_TRANSOBJ2D_MATRIX          0x0005
+
+// classes of objects, different sizes
+
+namespace {
+
+struct ImpSdXMLExpTransObj2DRotate : public ImpSdXMLExpTransObj2DBase
+{
+    double                      mfRotate;
+    explicit ImpSdXMLExpTransObj2DRotate(double fVal)
+    :   ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_ROTATE), mfRotate(fVal) {}
+};
+struct ImpSdXMLExpTransObj2DScale : public ImpSdXMLExpTransObj2DBase
+{
+    ::basegfx::B2DTuple         maScale;
+    explicit ImpSdXMLExpTransObj2DScale(const ::basegfx::B2DTuple& rNew)
+    :   ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_SCALE), maScale(rNew) {}
+};
+struct ImpSdXMLExpTransObj2DTranslate : public ImpSdXMLExpTransObj2DBase
+{
+    ::basegfx::B2DTuple         maTranslate;
+    explicit ImpSdXMLExpTransObj2DTranslate(const ::basegfx::B2DTuple& rNew)
+    :   ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_TRANSLATE), maTranslate(rNew) {}
+};
+struct ImpSdXMLExpTransObj2DSkewX : public ImpSdXMLExpTransObj2DBase
+{
+    double                      mfSkewX;
+    explicit ImpSdXMLExpTransObj2DSkewX(double fVal)
+    :   ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_SKEWX), mfSkewX(fVal) {}
+};
+struct ImpSdXMLExpTransObj2DSkewY : public ImpSdXMLExpTransObj2DBase
+{
+    double                      mfSkewY;
+    explicit ImpSdXMLExpTransObj2DSkewY(double fVal)
+    :   ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_SKEWY), mfSkewY(fVal) {}
+};
+struct ImpSdXMLExpTransObj2DMatrix : public ImpSdXMLExpTransObj2DBase
+{
+    ::basegfx::B2DHomMatrix     maMatrix;
+    explicit ImpSdXMLExpTransObj2DMatrix(const ::basegfx::B2DHomMatrix& rNew)
+    :   ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_MATRIX), maMatrix(rNew) {}
+};
+
+}
+
+// add members
+
+void SdXMLImExTransform2D::AddRotate(double fNew)
+{
+    if(fNew != 0.0)
+        maList.push_back(std::make_shared<ImpSdXMLExpTransObj2DRotate>(fNew));
+}
+
+void SdXMLImExTransform2D::AddTranslate(const ::basegfx::B2DTuple& rNew)
+{
+    if(!rNew.equalZero())
+        maList.push_back(std::make_shared<ImpSdXMLExpTransObj2DTranslate>(rNew));
+}
+
+void SdXMLImExTransform2D::AddSkewX(double fNew)
+{
+    if(fNew != 0.0)
+        maList.push_back(std::make_shared<ImpSdXMLExpTransObj2DSkewX>(fNew));
+}
+
+// gen string for export
+const OUString& SdXMLImExTransform2D::GetExportString(const SvXMLUnitConverter& rConv)
+{
+    OUStringBuffer aNewString;
+    OUString aClosingBrace(")");
+    OUString aEmptySpace(" ");
+
+    const sal_uInt32 nCount = maList.size();
+    for(sal_uInt32 a(0); a < nCount; a++)
+    {
+        ImpSdXMLExpTransObj2DBase* pObj = maList[a].get();
+        switch(pObj->mnType)
+        {
+            case IMP_SDXMLEXP_TRANSOBJ2D_ROTATE :
+            {
+                aNewString.append("rotate (");
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DRotate*>(pObj)->mfRotate);
+                aNewString.append(aClosingBrace);
+                break;
+            }
+            case IMP_SDXMLEXP_TRANSOBJ2D_SCALE      :
+            {
+                aNewString.append("scale (");
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DScale*>(pObj)->maScale.getX());
+                aNewString.append(aEmptySpace);
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DScale*>(pObj)->maScale.getY());
+                aNewString.append(aClosingBrace);
+                break;
+            }
+            case IMP_SDXMLEXP_TRANSOBJ2D_TRANSLATE  :
+            {
+                aNewString.append("translate (");
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DTranslate*>(pObj)->maTranslate.getX(), true);
+                aNewString.append(aEmptySpace);
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DTranslate*>(pObj)->maTranslate.getY(), true);
+                aNewString.append(aClosingBrace);
+                break;
+            }
+            case IMP_SDXMLEXP_TRANSOBJ2D_SKEWX      :
+            {
+                aNewString.append("skewX (");
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DSkewX*>(pObj)->mfSkewX);
+                aNewString.append(aClosingBrace);
+                break;
+            }
+            case IMP_SDXMLEXP_TRANSOBJ2D_SKEWY      :
+            {
+                aNewString.append("skewY (");
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DSkewY*>(pObj)->mfSkewY);
+                aNewString.append(aClosingBrace);
+                break;
+            }
+            case IMP_SDXMLEXP_TRANSOBJ2D_MATRIX :
+            {
+                aNewString.append("matrix (");
+
+                // a
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DMatrix*>(pObj)->maMatrix.get(0, 0));
+                aNewString.append(aEmptySpace);
+
+                // b
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DMatrix*>(pObj)->maMatrix.get(1, 0));
+                aNewString.append(aEmptySpace);
+
+                // c
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DMatrix*>(pObj)->maMatrix.get(0, 1));
+                aNewString.append(aEmptySpace);
+
+                // d
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DMatrix*>(pObj)->maMatrix.get(1, 1));
+                aNewString.append(aEmptySpace);
+
+                // e
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DMatrix*>(pObj)->maMatrix.get(0, 2), true);
+                aNewString.append(aEmptySpace);
+
+                // f
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DMatrix*>(pObj)->maMatrix.get(1, 2), true);
+
+                aNewString.append(aClosingBrace);
+                break;
+            }
+            default :
+            {
+                OSL_FAIL("SdXMLImExTransform2D: impossible entry!");
+                break;
+            }
+        }
+
+        // if not the last entry, add one space to next tag
+        if(a + 1 != maList.size())
+        {
+            aNewString.append(aEmptySpace);
+        }
+    }
+
+    // fill string form OUString
+    msString = aNewString.makeStringAndClear();
+
+    return msString;
+}
+
+// sets new string, parses it and generates entries
+void SdXMLImExTransform2D::SetString(const OUString& rNew, const SvXMLUnitConverter& rConv)
+{
+    msString = rNew;
+    maList.clear();
+
+    if(msString.isEmpty())
+        return;
+
+    const OUString aStr = msString;
+    const sal_Int32 nLen(aStr.getLength());
+
+    static const OUStringLiteral aString_rotate( u"rotate" );
+    static const OUStringLiteral aString_scale( u"scale" );
+    static const OUStringLiteral aString_translate( u"translate" );
+    static const OUStringLiteral aString_skewX( u"skewX" );
+    static const OUStringLiteral aString_skewY( u"skewY" );
+    static const OUStringLiteral aString_matrix( u"matrix" );
+
+    sal_Int32 nPos(0);
+
+    while(nPos < nLen)
+    {
+        // skip spaces
+        Imp_SkipSpaces(aStr, nPos, nLen);
+
+        // look for tag
+        if(nPos < nLen)
+        {
+            if(nPos == aStr.indexOf(aString_rotate, nPos))
+            {
+                double fValue(0.0);
+                nPos += 6;
+                Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
+                fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
+                if(fValue != 0.0)
+                    maList.push_back(std::make_shared<ImpSdXMLExpTransObj2DRotate>(fValue));
+
+                Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
+            }
+            else if(nPos == aStr.indexOf(aString_scale, nPos))
+            {
+                ::basegfx::B2DTuple aValue(1.0, 1.0);
+                nPos += 5;
+                Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
+                aValue.setX(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getX()));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+                aValue.setY(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getY()));
+
+                if(aValue.getX() != 1.0 || aValue.getY() != 1.0)
+                    maList.push_back(std::make_shared<ImpSdXMLExpTransObj2DScale>(aValue));
+
+                Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
+            }
+            else if(nPos == aStr.indexOf(aString_translate, nPos))
+            {
+                ::basegfx::B2DTuple aValue;
+                nPos += 9;
+                Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
+                aValue.setX(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getX(), true));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+                aValue.setY(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getY(), true));
+
+                if(!aValue.equalZero())
+                    maList.push_back(std::make_shared<ImpSdXMLExpTransObj2DTranslate>(aValue));
+
+                Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
+            }
+            else if(nPos == aStr.indexOf(aString_skewX, nPos))
+            {
+                double fValue(0.0);
+                nPos += 5;
+                Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
+                fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
+                if(fValue != 0.0)
+                    maList.push_back(std::make_shared<ImpSdXMLExpTransObj2DSkewX>(fValue));
+
+                Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
+            }
+            else if(nPos == aStr.indexOf(aString_skewY, nPos))
+            {
+                double fValue(0.0);
+                nPos += 5;
+                Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
+                fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
+                if(fValue != 0.0)
+                    maList.push_back(std::make_shared<ImpSdXMLExpTransObj2DSkewY>(fValue));
+
+                Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
+            }
+            else if(nPos == aStr.indexOf(aString_matrix, nPos))
+            {
+                ::basegfx::B2DHomMatrix aValue;
+
+                nPos += 6;
+                Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
+
+                // a
+                aValue.set(0, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 0)));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+
+                // b
+                aValue.set(1, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 0)));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+
+                // c
+                aValue.set(0, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 1)));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+
+                // d
+                aValue.set(1, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 1)));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+
+                // e
+                aValue.set(0, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 2), true));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+
+                // f
+                aValue.set(1, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 2), true));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+
+                if(!aValue.isIdentity())
+                    maList.push_back(std::make_shared<ImpSdXMLExpTransObj2DMatrix>(aValue));
+
+                Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
+            }
+            else
+            {
+                nPos++;
+            }
+        }
+    }
+}
+
+void SdXMLImExTransform2D::GetFullTransform(::basegfx::B2DHomMatrix& rFullTrans)
+{
+    rFullTrans.identity();
+
+    const sal_uInt32 nCount = maList.size();
+    for(sal_uInt32 a(0); a < nCount; a++)
+    {
+        ImpSdXMLExpTransObj2DBase* pObj = maList[a].get();
+        switch(pObj->mnType)
+        {
+            case IMP_SDXMLEXP_TRANSOBJ2D_ROTATE     :
+            {
+                // #i78696#
+                // mfRotate is mathematically wrong oriented since we export/import the angle
+                // values mirrored. This error is fixed in the API, but not yet in the FileFormat.
+                // For the FileFormat there is a follow-up task (#i78698#) to fix this in the next
+                // ODF FileFormat version. For now - to emulate the old behaviour - it is necessary
+                // to mirror the value here
+                rFullTrans.rotate(static_cast<ImpSdXMLExpTransObj2DRotate*>(pObj)->mfRotate * -1.0);
+                break;
+            }
+            case IMP_SDXMLEXP_TRANSOBJ2D_SCALE      :
+            {
+                const ::basegfx::B2DTuple& rScale = static_cast<ImpSdXMLExpTransObj2DScale*>(pObj)->maScale;
+                rFullTrans.scale(rScale.getX(), rScale.getY());
+                break;
+            }
+            case IMP_SDXMLEXP_TRANSOBJ2D_TRANSLATE  :
+            {
+                const ::basegfx::B2DTuple& rTranslate = static_cast<ImpSdXMLExpTransObj2DTranslate*>(pObj)->maTranslate;
+                rFullTrans.translate(rTranslate.getX(), rTranslate.getY());
+                break;
+            }
+            case IMP_SDXMLEXP_TRANSOBJ2D_SKEWX      :
+            {
+                // For to get a mathematical correct matrix from already existing documents,
+                // mirror the value here. ODF spec is unclear about direction.
+                rFullTrans.shearX(-tan(static_cast<ImpSdXMLExpTransObj2DSkewX*>(pObj)->mfSkewX));
+                break;
+            }
+            case IMP_SDXMLEXP_TRANSOBJ2D_SKEWY      :
+            {
+                // LibreOffice does not write skewY, OOo neither. Such files are foreign documents
+                // or manually set transformations. OOo had used the value as -tan(value) before
+                // errors were introduced, Scribus 1.5.4 uses it as -tan(value) too, MS Office does
+                // not shear at all. ODF spec is unclear about direction.
+                rFullTrans.shearY(-tan(static_cast<ImpSdXMLExpTransObj2DSkewY*>(pObj)->mfSkewY));
+                break;
+            }
+            case IMP_SDXMLEXP_TRANSOBJ2D_MATRIX     :
+            {
+                rFullTrans *= static_cast<ImpSdXMLExpTransObj2DMatrix*>(pObj)->maMatrix;
+                break;
+            }
+            default :
+            {
+                OSL_FAIL("SdXMLImExTransform2D: impossible entry!");
+                break;
+            }
+        }
+    }
+}
+
+// base class of all 3D transform objects
+
+struct ImpSdXMLExpTransObj3DBase
+{
+    sal_uInt16                  mnType;
+    explicit ImpSdXMLExpTransObj3DBase(sal_uInt16 nType)
+    :   mnType(nType) {}
+};
+
+// possible object types for 3D
+
+#define IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_X        0x0000
+#define IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Y        0x0001
+#define IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Z        0x0002
+#define IMP_SDXMLEXP_TRANSOBJ3D_SCALE           0x0003
+#define IMP_SDXMLEXP_TRANSOBJ3D_TRANSLATE       0x0004
+#define IMP_SDXMLEXP_TRANSOBJ3D_MATRIX          0x0005
+
+// classes of objects, different sizes
+
+namespace {
+
+struct ImpSdXMLExpTransObj3DRotateX : public ImpSdXMLExpTransObj3DBase
+{
+    double                      mfRotateX;
+    explicit ImpSdXMLExpTransObj3DRotateX(double fVal)
+    :   ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_X), mfRotateX(fVal) {}
+};
+struct ImpSdXMLExpTransObj3DRotateY : public ImpSdXMLExpTransObj3DBase
+{
+    double                      mfRotateY;
+    explicit ImpSdXMLExpTransObj3DRotateY(double fVal)
+    :   ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Y), mfRotateY(fVal) {}
+};
+struct ImpSdXMLExpTransObj3DRotateZ : public ImpSdXMLExpTransObj3DBase
+{
+    double                      mfRotateZ;
+    explicit ImpSdXMLExpTransObj3DRotateZ(double fVal)
+    :   ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Z), mfRotateZ(fVal) {}
+};
+struct ImpSdXMLExpTransObj3DScale : public ImpSdXMLExpTransObj3DBase
+{
+    ::basegfx::B3DTuple         maScale;
+    explicit ImpSdXMLExpTransObj3DScale(const ::basegfx::B3DTuple& rNew)
+    :   ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_SCALE), maScale(rNew) {}
+};
+struct ImpSdXMLExpTransObj3DTranslate : public ImpSdXMLExpTransObj3DBase
+{
+    ::basegfx::B3DTuple         maTranslate;
+    explicit ImpSdXMLExpTransObj3DTranslate(const ::basegfx::B3DTuple& rNew)
+    :   ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_TRANSLATE), maTranslate(rNew) {}
+};
+struct ImpSdXMLExpTransObj3DMatrix : public ImpSdXMLExpTransObj3DBase
+{
+    ::basegfx::B3DHomMatrix     maMatrix;
+    explicit ImpSdXMLExpTransObj3DMatrix(const ::basegfx::B3DHomMatrix& rNew)
+    :   ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_MATRIX), maMatrix(rNew) {}
+};
+
+}
+
+// add members
+
+void SdXMLImExTransform3D::AddMatrix(const ::basegfx::B3DHomMatrix& rNew)
+{
+    if(!rNew.isIdentity())
+        maList.push_back(std::make_shared<ImpSdXMLExpTransObj3DMatrix>(rNew));
+}
+
+void SdXMLImExTransform3D::AddHomogenMatrix(const drawing::HomogenMatrix& xHomMat)
+{
+    AddMatrix(basegfx::utils::UnoHomogenMatrixToB3DHomMatrix(xHomMat));
+}
+
+// gen string for export
+const OUString& SdXMLImExTransform3D::GetExportString(const SvXMLUnitConverter& rConv)
+{
+    OUStringBuffer aNewString;
+    OUString aClosingBrace(")");
+    OUString aEmptySpace(" ");
+
+    const sal_uInt32 nCount = maList.size();
+    for(sal_uInt32 a(0); a < nCount; a++)
+    {
+        ImpSdXMLExpTransObj3DBase* pObj = maList[a].get();
+        switch(pObj->mnType)
+        {
+            case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_X   :
+            {
+                aNewString.append("rotatex (");
+                Imp_PutDoubleChar(aNewString, rConv, basegfx::rad2deg( static_cast<ImpSdXMLExpTransObj3DRotateX*>(pObj)->mfRotateX) );
+                aNewString.append(aClosingBrace);
+                break;
+            }
+            case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Y   :
+            {
+                aNewString.append("rotatey (");
+                Imp_PutDoubleChar(aNewString, rConv, basegfx::rad2deg( static_cast<ImpSdXMLExpTransObj3DRotateY*>(pObj)->mfRotateY) );
+                aNewString.append(aClosingBrace);
+                break;
+            }
+            case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Z   :
+            {
+                aNewString.append("rotatez (");
+                Imp_PutDoubleChar(aNewString, rConv, basegfx::rad2deg( static_cast<ImpSdXMLExpTransObj3DRotateZ*>(pObj)->mfRotateZ) );
+                aNewString.append(aClosingBrace);
+                break;
+            }
+            case IMP_SDXMLEXP_TRANSOBJ3D_SCALE      :
+            {
+                aNewString.append("scale (");
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DScale*>(pObj)->maScale.getX());
+                aNewString.append(aEmptySpace);
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DScale*>(pObj)->maScale.getY());
+                aNewString.append(aEmptySpace);
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DScale*>(pObj)->maScale.getZ());
+                aNewString.append(aClosingBrace);
+                break;
+            }
+            case IMP_SDXMLEXP_TRANSOBJ3D_TRANSLATE  :
+            {
+                aNewString.append("translate (");
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DTranslate*>(pObj)->maTranslate.getX(), true);
+                aNewString.append(aEmptySpace);
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DTranslate*>(pObj)->maTranslate.getY(), true);
+                aNewString.append(aEmptySpace);
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DTranslate*>(pObj)->maTranslate.getZ(), true);
+                aNewString.append(aClosingBrace);
+                break;
+            }
+            case IMP_SDXMLEXP_TRANSOBJ3D_MATRIX :
+            {
+                aNewString.append("matrix (");
+
+                // a
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(0, 0));
+                aNewString.append(aEmptySpace);
+
+                // b
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(1, 0));
+                aNewString.append(aEmptySpace);
+
+                // c
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(2, 0));
+                aNewString.append(aEmptySpace);
+
+                // d
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(0, 1));
+                aNewString.append(aEmptySpace);
+
+                // e
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(1, 1));
+                aNewString.append(aEmptySpace);
+
+                // f
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(2, 1));
+                aNewString.append(aEmptySpace);
+
+                // g
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(0, 2));
+                aNewString.append(aEmptySpace);
+
+                // h
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(1, 2));
+                aNewString.append(aEmptySpace);
+
+                // i
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(2, 2));
+                aNewString.append(aEmptySpace);
+
+                // j
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(0, 3), true);
+                aNewString.append(aEmptySpace);
+
+                // k
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(1, 3), true);
+                aNewString.append(aEmptySpace);
+
+                // l
+                Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(2, 3), true);
+
+                aNewString.append(aClosingBrace);
+                break;
+            }
+            default :
+            {
+                OSL_FAIL("SdXMLImExTransform3D: impossible entry!");
+                break;
+            }
+        }
+
+        // if not the last entry, add one space to next tag
+        if(a + 1 != maList.size())
+        {
+            aNewString.append(aEmptySpace);
+        }
+    }
+
+    // fill string form OUString
+    msString = aNewString.makeStringAndClear();
+
+    return msString;
+}
+
+// for Import: constructor with string, parses it and generates entries
+SdXMLImExTransform3D::SdXMLImExTransform3D(const OUString& rNew, const SvXMLUnitConverter& rConv)
+{
+    SetString(rNew, rConv);
+}
+
+// sets new string, parses it and generates entries
+void SdXMLImExTransform3D::SetString(const OUString& rNew, const SvXMLUnitConverter& rConv)
+{
+    msString = rNew;
+    maList.clear();
+
+    if(msString.isEmpty())
+        return;
+
+    const OUString aStr = msString;
+    const sal_Int32 nLen(aStr.getLength());
+
+    static const OUStringLiteral aString_rotatex( u"rotatex" );
+    static const OUStringLiteral aString_rotatey( u"rotatey" );
+    static const OUStringLiteral aString_rotatez( u"rotatez" );
+    static const OUStringLiteral aString_scale( u"scale" );
+    static const OUStringLiteral aString_translate( u"translate" );
+    static const OUStringLiteral aString_matrix( u"matrix" );
+
+    sal_Int32 nPos(0);
+
+    while(nPos < nLen)
+    {
+        // skip spaces
+        Imp_SkipSpaces(aStr, nPos, nLen);
+
+        // look for tag
+        if(nPos < nLen)
+        {
+            if(nPos == aStr.indexOf(aString_rotatex, nPos))
+            {
+                double fValue(0.0);
+
+                nPos += 7;
+                Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
+                fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
+                if(fValue != 0.0)
+                    maList.push_back(std::make_shared<ImpSdXMLExpTransObj3DRotateX>(basegfx::deg2rad(fValue)));
+
+                Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
+            }
+            else if(nPos == aStr.indexOf(aString_rotatey, nPos))
+            {
+                double fValue(0.0);
+
+                nPos += 7;
+                Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
+                fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
+                if(fValue != 0.0)
+                    maList.push_back(std::make_shared<ImpSdXMLExpTransObj3DRotateY>(basegfx::deg2rad(fValue)));
+
+                Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
+            }
+            else if(nPos == aStr.indexOf(aString_rotatez, nPos))
+            {
+                double fValue(0.0);
+
+                nPos += 7;
+                Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
+                fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
+                if(fValue != 0.0)
+                    maList.push_back(std::make_shared<ImpSdXMLExpTransObj3DRotateZ>(basegfx::deg2rad(fValue)));
+
+                Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
+            }
+            else if(nPos == aStr.indexOf(aString_scale, nPos))
+            {
+                ::basegfx::B3DTuple aValue(1.0, 1.0, 1.0);
+
+                nPos += 5;
+                Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
+                aValue.setX(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getX()));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+                aValue.setY(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getY()));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+                aValue.setZ(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getZ()));
+
+                if(1.0 != aValue.getX() || 1.0 != aValue.getY() || 1.0 != aValue.getZ())
+                    maList.push_back(std::make_shared<ImpSdXMLExpTransObj3DScale>(aValue));
+
+                Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
+            }
+            else if(nPos == aStr.indexOf(aString_translate, nPos))
+            {
+                ::basegfx::B3DTuple aValue;
+
+                nPos += 9;
+                Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
+                aValue.setX(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getX(), true));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+                aValue.setY(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getY(), true));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+                aValue.setZ(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getZ(), true));
+
+                if(!aValue.equalZero())
+                    maList.push_back(std::make_shared<ImpSdXMLExpTransObj3DTranslate>(aValue));
+
+                Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
+            }
+            else if(nPos == aStr.indexOf(aString_matrix, nPos))
+            {
+                ::basegfx::B3DHomMatrix aValue;
+
+                nPos += 6;
+                Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
+
+                // a
+                aValue.set(0, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 0)));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+
+                // b
+                aValue.set(1, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 0)));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+
+                // c
+                aValue.set(2, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(2, 0)));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+
+                // d
+                aValue.set(0, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 1)));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+
+                // e
+                aValue.set(1, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 1)));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+
+                // f
+                aValue.set(2, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(2, 1)));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+
+                // g
+                aValue.set(0, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 2)));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+
+                // h
+                aValue.set(1, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 2)));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+
+                // i
+                aValue.set(2, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(2, 2)));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+
+                // j
+                aValue.set(0, 3, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 3), true));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+
+                // k
+                aValue.set(1, 3, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 3), true));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+
+                // l
+                aValue.set(2, 3, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(2, 3), true));
+                Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+
+                if(!aValue.isIdentity())
+                    maList.push_back(std::make_shared<ImpSdXMLExpTransObj3DMatrix>(aValue));
+
+                Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
+            }
+            else
+            {
+                nPos++;
+            }
+        }
+    }
+}
+
+bool SdXMLImExTransform3D::GetFullHomogenTransform(css::drawing::HomogenMatrix& xHomMat)
+{
+    ::basegfx::B3DHomMatrix aFullTransform;
+    GetFullTransform(aFullTransform);
+
+    if(!aFullTransform.isIdentity())
+    {
+        basegfx::utils::B3DHomMatrixToUnoHomogenMatrix(aFullTransform, xHomMat);
+        return true;
+    }
+
+    return false;
+}
+
+void SdXMLImExTransform3D::GetFullTransform(::basegfx::B3DHomMatrix& rFullTrans)
+{
+    rFullTrans.identity();
+
+    const sal_uInt32 nCount = maList.size();
+    for(sal_uInt32 a(0); a < nCount; a++)
+    {
+        ImpSdXMLExpTransObj3DBase* pObj = maList[a].get();
+        switch(pObj->mnType)
+        {
+            case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_X   :
+            {
+                rFullTrans.rotate(static_cast<ImpSdXMLExpTransObj3DRotateX*>(pObj)->mfRotateX, 0.0, 0.0);
+                break;
+            }
+            case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Y   :
+            {
+                rFullTrans.rotate(0.0, static_cast<ImpSdXMLExpTransObj3DRotateY*>(pObj)->mfRotateY, 0.0);
+                break;
+            }
+            case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Z   :
+            {
+                rFullTrans.rotate(0.0, 0.0, static_cast<ImpSdXMLExpTransObj3DRotateZ*>(pObj)->mfRotateZ);
+                break;
+            }
+            case IMP_SDXMLEXP_TRANSOBJ3D_SCALE      :
+            {
+                const ::basegfx::B3DTuple& rScale = static_cast<ImpSdXMLExpTransObj3DScale*>(pObj)->maScale;
+                rFullTrans.scale(rScale.getX(), rScale.getY(), rScale.getZ());
+                break;
+            }
+            case IMP_SDXMLEXP_TRANSOBJ3D_TRANSLATE  :
+            {
+                const ::basegfx::B3DTuple& rTranslate = static_cast<ImpSdXMLExpTransObj3DTranslate*>(pObj)->maTranslate;
+                rFullTrans.translate(rTranslate.getX(), rTranslate.getY(), rTranslate.getZ());
+                break;
+            }
+            case IMP_SDXMLEXP_TRANSOBJ3D_MATRIX     :
+            {
+                rFullTrans *= static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix;
+                break;
+            }
+            default :
+            {
+                OSL_FAIL("SdXMLImExTransform3D: impossible entry!");
+                break;
+            }
+        }
+    }
+}
+
+SdXMLImExViewBox::SdXMLImExViewBox(double fX, double fY, double fW, double fH)
+:   mfX( fX ),
+    mfY( fY ),
+    mfW( fW ),
+    mfH( fH )
+{
+}
+
+// #100617# Asked vincent hardy: svg:viewBox values may be double precision.
+SdXMLImExViewBox::SdXMLImExViewBox(const OUString& rNew, const SvXMLUnitConverter& rConv)
+:   msString(rNew),
+    mfX( 0.0 ),
+    mfY( 0.0 ),
+    mfW( 1000.0 ),
+    mfH( 1000.0 )
+{
+    if(msString.isEmpty())
+        return;
+
+    const OUString aStr = msString;
+    const sal_Int32 nLen(aStr.getLength());
+    sal_Int32 nPos(0);
+
+    // skip starting spaces
+    Imp_SkipSpaces(aStr, nPos, nLen);
+
+    // get mX, #100617# be prepared for doubles
+    mfX = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, mfX);
+
+    // skip spaces and commas
+    Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+
+    // get mY, #100617# be prepared for doubles
+    mfY = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, mfY);
+
+    // skip spaces and commas
+    Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+
+    // get mW, #100617# be prepared for doubles
+    mfW = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, mfW);
+
+    // skip spaces and commas
+    Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
+
+    // get mH, #100617# be prepared for doubles
+    mfH = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, mfH);
+
+}
+
+const OUString& SdXMLImExViewBox::GetExportString()
+{
+    OUString aNewString;
+    OUString aEmptySpace(" ");
+
+    Imp_PutDoubleChar(aNewString, mfX);
+    aNewString += aEmptySpace;
+
+    Imp_PutDoubleChar(aNewString, mfY);
+    aNewString += aEmptySpace;
+
+    Imp_PutDoubleChar(aNewString, mfW);
+    aNewString += aEmptySpace;
+
+    Imp_PutDoubleChar(aNewString, mfH);
+
+    // set new string
+    msString = aNewString;
+
+    return msString;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/ximp3dobject.cxx b/xmloff/source/draw/ximp3dobject.cxx
new file mode 100644
index 000000000..c17defc24
--- /dev/null
+++ b/xmloff/source/draw/ximp3dobject.cxx
@@ -0,0 +1,369 @@
+/* -*- 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 "ximp3dobject.hxx"
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <xexptran.hxx>
+#include <com/sun/star/drawing/PolyPolygonShape3D.hpp>
+#include <com/sun/star/drawing/Direction3D.hpp>
+#include <com/sun/star/drawing/Position3D.hpp>
+#include <sal/log.hxx>
+#include <osl/diagnose.h>
+#include <basegfx/polygon/b2dpolypolygon.hxx>
+#include <basegfx/polygon/b2dpolypolygontools.hxx>
+#include <basegfx/polygon/b3dpolypolygontools.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+
+SdXML3DObjectContext::SdXML3DObjectContext(
+    SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes)
+:   SdXMLShapeContext( rImport, xAttrList, rShapes, false/*bTemporaryShape*/ ),
+    mbSetTransform( false )
+{
+    for(auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList))
+    {
+        const OUString sValue = aIter.toString();
+        switch(aIter.getToken())
+        {
+            case XML_ELEMENT(DRAW, XML_STYLE_NAME):
+            {
+                maDrawStyleName = sValue;
+                break;
+            }
+            case XML_ELEMENT(DR3D, XML_TRANSFORM):
+            {
+                SdXMLImExTransform3D aTransform(sValue, GetImport().GetMM100UnitConverter());
+                if(aTransform.NeedsAction())
+                    mbSetTransform = aTransform.GetFullHomogenTransform(mxHomMat);
+                break;
+            }
+            default:
+                XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+        }
+    }
+}
+
+SdXML3DObjectContext::~SdXML3DObjectContext()
+{
+}
+
+void SdXML3DObjectContext::startFastElement(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
+    if(xPropSet.is())
+    {
+        // set parameters
+        if(mbSetTransform)
+        {
+            xPropSet->setPropertyValue("D3DTransformMatrix", uno::Any(mxHomMat));
+        }
+
+        // call parent
+        SdXMLShapeContext::startFastElement(nElement, xAttrList);
+    }
+}
+
+SdXML3DCubeObjectShapeContext::SdXML3DCubeObjectShapeContext(
+    SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes)
+:   SdXML3DObjectContext( rImport, xAttrList, rShapes ),
+    maMinEdge(-2500.0, -2500.0, -2500.0),
+    maMaxEdge(2500.0, 2500.0, 2500.0)
+{
+    for(auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList))
+    {
+        switch(aIter.getToken())
+        {
+            case XML_ELEMENT(DR3D, XML_MIN_EDGE):
+            {
+                ::basegfx::B3DVector aNewVec;
+                SvXMLUnitConverter::convertB3DVector(aNewVec, aIter.toView());
+
+                if(aNewVec != maMinEdge)
+                    maMinEdge = aNewVec;
+                break;
+            }
+            case XML_ELEMENT(DR3D, XML_MAX_EDGE):
+            {
+                ::basegfx::B3DVector aNewVec;
+                SvXMLUnitConverter::convertB3DVector(aNewVec, aIter.toView());
+
+                if(aNewVec != maMaxEdge)
+                    maMaxEdge = aNewVec;
+                break;
+            }
+            default:
+                XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+        }
+    }
+}
+
+SdXML3DCubeObjectShapeContext::~SdXML3DCubeObjectShapeContext()
+{
+}
+
+void SdXML3DCubeObjectShapeContext::startFastElement(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    // create shape
+    AddShape( "com.sun.star.drawing.Shape3DCubeObject" );
+    if(!mxShape.is())
+        return;
+
+    // add, set style and properties from base shape
+    SetStyle();
+    SdXML3DObjectContext::startFastElement(nElement, xAttrList);
+
+    // set local parameters on shape
+    uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
+    if(!xPropSet.is())
+        return;
+
+    // set parameters
+    drawing::Position3D aPosition3D;
+    drawing::Direction3D aDirection3D;
+
+    // convert from min, max to size to be set
+    maMaxEdge = maMaxEdge - maMinEdge;
+
+    aPosition3D.PositionX = maMinEdge.getX();
+    aPosition3D.PositionY = maMinEdge.getY();
+    aPosition3D.PositionZ = maMinEdge.getZ();
+
+    aDirection3D.DirectionX = maMaxEdge.getX();
+    aDirection3D.DirectionY = maMaxEdge.getY();
+    aDirection3D.DirectionZ = maMaxEdge.getZ();
+
+    xPropSet->setPropertyValue("D3DPosition", uno::Any(aPosition3D));
+    xPropSet->setPropertyValue("D3DSize", uno::Any(aDirection3D));
+}
+
+SdXML3DSphereObjectShapeContext::SdXML3DSphereObjectShapeContext(
+    SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes)
+:   SdXML3DObjectContext( rImport, xAttrList, rShapes ),
+    maCenter(0.0, 0.0, 0.0),
+    maSphereSize(5000.0, 5000.0, 5000.0)
+{
+    for(auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList))
+    {
+        switch(aIter.getToken())
+        {
+            case XML_ELEMENT(DR3D, XML_CENTER):
+            {
+                ::basegfx::B3DVector aNewVec;
+                SvXMLUnitConverter::convertB3DVector(aNewVec, aIter.toView());
+
+                if(aNewVec != maCenter)
+                    maCenter = aNewVec;
+                break;
+            }
+            case XML_ELEMENT(DR3D, XML_SIZE):
+            {
+                ::basegfx::B3DVector aNewVec;
+                SvXMLUnitConverter::convertB3DVector(aNewVec, aIter.toView());
+
+                if(aNewVec != maSphereSize)
+                    maSphereSize = aNewVec;
+                break;
+            }
+            default:
+                XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+        }
+    }
+}
+
+SdXML3DSphereObjectShapeContext::~SdXML3DSphereObjectShapeContext()
+{
+}
+
+void SdXML3DSphereObjectShapeContext::startFastElement(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    // create shape
+    AddShape( "com.sun.star.drawing.Shape3DSphereObject" );
+    if(!mxShape.is())
+        return;
+
+    // add, set style and properties from base shape
+    SetStyle();
+    SdXML3DObjectContext::startFastElement(nElement, xAttrList);
+
+    // set local parameters on shape
+    uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
+    if(!xPropSet.is())
+        return;
+
+    // set parameters
+    drawing::Position3D aPosition3D;
+    drawing::Direction3D aDirection3D;
+
+    aPosition3D.PositionX = maCenter.getX();
+    aPosition3D.PositionY = maCenter.getY();
+    aPosition3D.PositionZ = maCenter.getZ();
+
+    aDirection3D.DirectionX = maSphereSize.getX();
+    aDirection3D.DirectionY = maSphereSize.getY();
+    aDirection3D.DirectionZ = maSphereSize.getZ();
+
+    xPropSet->setPropertyValue("D3DPosition", uno::Any(aPosition3D));
+    xPropSet->setPropertyValue("D3DSize", uno::Any(aDirection3D));
+}
+
+SdXML3DPolygonBasedShapeContext::SdXML3DPolygonBasedShapeContext(
+    SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes)
+:   SdXML3DObjectContext( rImport, xAttrList, rShapes )
+{
+    for(auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList))
+    {
+        OUString sValue = aIter.toString();
+
+        switch(aIter.getToken())
+        {
+            case XML_ELEMENT(SVG, XML_VIEWBOX):
+            case XML_ELEMENT(SVG_COMPAT, XML_VIEWBOX):
+            {
+                maViewBox = sValue;
+                break;
+            }
+            case XML_ELEMENT(SVG, XML_D):
+            case XML_ELEMENT(SVG_COMPAT, XML_D):
+            {
+                maPoints = sValue;
+                break;
+            }
+            default:
+                XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+        }
+    }
+}
+
+SdXML3DPolygonBasedShapeContext::~SdXML3DPolygonBasedShapeContext()
+{
+}
+
+void SdXML3DPolygonBasedShapeContext::startFastElement(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
+
+    if(!xPropSet.is())
+        return;
+
+    // set parameters
+    if(!maPoints.isEmpty() && !maViewBox.isEmpty())
+    {
+        // import 2d tools::PolyPolygon from svg:d
+        basegfx::B2DPolyPolygon aPolyPolygon;
+
+        if(basegfx::utils::importFromSvgD(aPolyPolygon, maPoints, GetImport().needFixPositionAfterZ(), nullptr))
+        {
+            // convert to 3D PolyPolygon
+            const basegfx::B3DPolyPolygon aB3DPolyPolygon(
+                basegfx::utils::createB3DPolyPolygonFromB2DPolyPolygon(
+                    aPolyPolygon));
+
+            // convert to UNO API class PolyPolygonShape3D
+            drawing::PolyPolygonShape3D aPolyPolygon3D;
+            basegfx::utils::B3DPolyPolygonToUnoPolyPolygonShape3D(
+                aB3DPolyPolygon,
+                aPolyPolygon3D);
+
+            // set polygon data
+            xPropSet->setPropertyValue("D3DPolyPolygon3D", uno::Any(aPolyPolygon3D));
+        }
+        else
+        {
+            OSL_ENSURE(false, "Error on importing svg:d for 3D tools::PolyPolygon (!)");
+        }
+    }
+
+    // call parent
+    SdXML3DObjectContext::startFastElement(nElement, xAttrList);
+}
+
+
+SdXML3DLatheObjectShapeContext::SdXML3DLatheObjectShapeContext(
+    SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes)
+:   SdXML3DPolygonBasedShapeContext( rImport, xAttrList, rShapes )
+{
+}
+
+SdXML3DLatheObjectShapeContext::~SdXML3DLatheObjectShapeContext()
+{
+}
+
+void SdXML3DLatheObjectShapeContext::startFastElement(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    // create shape
+    AddShape( "com.sun.star.drawing.Shape3DLatheObject" );
+    if(mxShape.is())
+    {
+        // add, set style and properties from base shape
+        SetStyle();
+        SdXML3DPolygonBasedShapeContext::startFastElement(nElement, xAttrList);
+    }
+}
+
+SdXML3DExtrudeObjectShapeContext::SdXML3DExtrudeObjectShapeContext(
+    SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes)
+:   SdXML3DPolygonBasedShapeContext( rImport, xAttrList, rShapes )
+{
+}
+
+SdXML3DExtrudeObjectShapeContext::~SdXML3DExtrudeObjectShapeContext()
+{
+}
+
+void SdXML3DExtrudeObjectShapeContext::startFastElement(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    AddShape( "com.sun.star.drawing.Shape3DExtrudeObject" );
+    if(mxShape.is())
+    {
+        // add, set style and properties from base shape
+        SetStyle();
+        SdXML3DPolygonBasedShapeContext::startFastElement(nElement, xAttrList);
+    }
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/ximp3dobject.hxx b/xmloff/source/draw/ximp3dobject.hxx
new file mode 100644
index 000000000..2862d094d
--- /dev/null
+++ b/xmloff/source/draw/ximp3dobject.hxx
@@ -0,0 +1,136 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <com/sun/star/drawing/XShapes.hpp>
+#include <com/sun/star/drawing/HomogenMatrix.hpp>
+#include "ximpshap.hxx"
+
+// common shape context
+
+class SdXML3DObjectContext : public SdXMLShapeContext
+{
+    // the shape group this object should be created inside
+
+    css::drawing::HomogenMatrix mxHomMat;
+    bool                        mbSetTransform;
+
+public:
+
+    SdXML3DObjectContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes);
+    virtual ~SdXML3DObjectContext() override;
+
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+};
+
+// dr3d:3dcube context
+
+class SdXML3DCubeObjectShapeContext : public SdXML3DObjectContext
+{
+    ::basegfx::B3DVector    maMinEdge;
+    ::basegfx::B3DVector    maMaxEdge;
+
+public:
+
+    SdXML3DCubeObjectShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes);
+    virtual ~SdXML3DCubeObjectShapeContext() override;
+
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+};
+
+// dr3d:3dsphere context
+
+class SdXML3DSphereObjectShapeContext : public SdXML3DObjectContext
+{
+    ::basegfx::B3DVector    maCenter;
+    ::basegfx::B3DVector    maSphereSize;
+
+public:
+
+    SdXML3DSphereObjectShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes);
+    virtual ~SdXML3DSphereObjectShapeContext() override;
+
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+};
+
+// polygonbased context
+
+class SdXML3DPolygonBasedShapeContext : public SdXML3DObjectContext
+{
+    OUString               maPoints;
+    OUString               maViewBox;
+
+public:
+
+    SdXML3DPolygonBasedShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes);
+    virtual ~SdXML3DPolygonBasedShapeContext() override;
+
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+};
+
+// dr3d:3dlathe context
+
+class SdXML3DLatheObjectShapeContext : public SdXML3DPolygonBasedShapeContext
+{
+public:
+
+    SdXML3DLatheObjectShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes);
+    virtual ~SdXML3DLatheObjectShapeContext() override;
+
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+};
+
+// dr3d:3dextrude context
+
+class SdXML3DExtrudeObjectShapeContext : public SdXML3DPolygonBasedShapeContext
+{
+public:
+
+    SdXML3DExtrudeObjectShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes);
+    virtual ~SdXML3DExtrudeObjectShapeContext() override;
+
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/ximp3dscene.cxx b/xmloff/source/draw/ximp3dscene.cxx
new file mode 100644
index 000000000..31da3652e
--- /dev/null
+++ b/xmloff/source/draw/ximp3dscene.cxx
@@ -0,0 +1,441 @@
+/* -*- 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 <sax/tools/converter.hxx>
+#include <rtl/math.hxx>
+#include <sal/log.hxx>
+
+#include "ximp3dscene.hxx"
+#include <xmloff/xmluconv.hxx>
+#include <xexptran.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/drawing/Direction3D.hpp>
+#include <com/sun/star/drawing/CameraGeometry.hpp>
+#include "eventimp.hxx"
+#include "descriptionimp.hxx"
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+// dr3d:3dlight context
+
+SdXML3DLightContext::SdXML3DLightContext(
+    SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
+:   SvXMLImportContext( rImport ),
+    maDiffuseColor(0x00000000),
+    maDirection(0.0, 0.0, 1.0),
+    mbEnabled(false),
+    mbSpecular(false)
+{
+    // read attributes for the 3DScene
+    for( auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList) )
+    {
+        switch(aIter.getToken())
+        {
+            case XML_ELEMENT(DR3D, XML_DIFFUSE_COLOR):
+            {
+                ::sax::Converter::convertColor(maDiffuseColor, aIter.toView());
+                break;
+            }
+            case XML_ELEMENT(DR3D, XML_DIRECTION):
+            {
+                ::basegfx::B3DVector aVal;
+                SvXMLUnitConverter::convertB3DVector(aVal, aIter.toView());
+                if (!std::isnan(aVal.getX()) && !std::isnan(aVal.getY()) && !std::isnan(aVal.getZ()))
+                {
+                    maDirection = aVal;
+                }
+                else
+                {
+                    SAL_WARN("xmloff", "NaNs found in light direction: " << aIter.toString());
+                }
+                break;
+            }
+            case XML_ELEMENT(DR3D, XML_ENABLED):
+            {
+                (void)::sax::Converter::convertBool(mbEnabled, aIter.toView());
+                break;
+            }
+            case XML_ELEMENT(DR3D, XML_SPECULAR):
+            {
+                (void)::sax::Converter::convertBool(mbSpecular, aIter.toView());
+                break;
+            }
+            default:
+                XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+        }
+    }
+}
+
+SdXML3DLightContext::~SdXML3DLightContext()
+{
+}
+
+
+SdXML3DSceneShapeContext::SdXML3DSceneShapeContext(
+    SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes,
+    bool bTemporaryShapes)
+:   SdXMLShapeContext( rImport, xAttrList, rShapes, bTemporaryShapes ), SdXML3DSceneAttributesHelper( rImport )
+{
+}
+
+SdXML3DSceneShapeContext::~SdXML3DSceneShapeContext()
+{
+}
+
+void SdXML3DSceneShapeContext::startFastElement(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    // create new 3DScene shape and add it to rShapes, use it
+    // as base for the new 3DScene import
+    AddShape( "com.sun.star.drawing.Shape3DSceneObject" );
+    if( mxShape.is() )
+    {
+        SetStyle();
+
+        mxChildren.set( mxShape, uno::UNO_QUERY );
+        if( mxChildren.is() )
+            GetImport().GetShapeImport()->pushGroupForPostProcessing( mxChildren );
+
+        SetLayer();
+
+        // set pos, size, shear and rotate
+        SetTransformation();
+    }
+
+    // read attributes for the 3DScene
+    for( auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList) )
+        processSceneAttribute( aIter );
+
+    // #91047# call parent function is missing here, added it
+    if(mxShape.is())
+    {
+        // call parent
+        SdXMLShapeContext::startFastElement(nElement, xAttrList);
+    }
+}
+
+void SdXML3DSceneShapeContext::endFastElement(sal_Int32 nElement)
+{
+    if(!mxShape.is())
+        return;
+
+    uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
+    if(xPropSet.is())
+    {
+        setSceneAttributes( xPropSet );
+    }
+
+    if( mxChildren.is() )
+        GetImport().GetShapeImport()->popGroupAndPostProcess();
+
+    // call parent
+    SdXMLShapeContext::endFastElement(nElement);
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXML3DSceneShapeContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    SvXMLImportContextRef xContext;
+    switch (nElement)
+    {
+        // #i68101#
+        case XML_ELEMENT(SVG, XML_TITLE):
+        case XML_ELEMENT(SVG_COMPAT, XML_TITLE):
+        case XML_ELEMENT(SVG, XML_DESC):
+        case XML_ELEMENT(SVG_COMPAT, XML_DESC):
+            xContext = new SdXMLDescriptionContext( GetImport(), nElement, mxShape );
+            break;
+        case XML_ELEMENT(OFFICE, XML_EVENT_LISTENERS):
+            xContext = new SdXMLEventsContext( GetImport(), mxShape );
+            break;
+        // look for local light context first
+        case XML_ELEMENT(DR3D, XML_LIGHT):
+            // dr3d:light inside dr3d:scene context
+            xContext = create3DLightContext( xAttrList );
+            break;
+        default:
+            // call GroupChildContext function at common ShapeImport
+            return XMLShapeImportHelper::Create3DSceneChildContext(
+                GetImport(), nElement, xAttrList, mxChildren);
+    }
+    return xContext;
+}
+
+SdXML3DSceneAttributesHelper::SdXML3DSceneAttributesHelper( SvXMLImport& rImporter )
+:   mrImport( rImporter ),
+    mbSetTransform( false ),
+    mxPrjMode(drawing::ProjectionMode_PERSPECTIVE),
+    mnDistance(1000),
+    mnFocalLength(1000),
+    mnShadowSlant(0),
+    mxShadeMode(drawing::ShadeMode_SMOOTH),
+    maAmbientColor(0x00666666),
+    mbLightingMode(false),
+    maVRP(0.0, 0.0, 1.0),
+    maVPN(0.0, 0.0, 1.0),
+    maVUP(0.0, 1.0, 0.0),
+    mbVRPUsed(false)
+{
+}
+
+/** creates a 3d light context and adds it to the internal list for later processing */
+SvXMLImportContext * SdXML3DSceneAttributesHelper::create3DLightContext( const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
+{
+    const rtl::Reference<SdXML3DLightContext> xContext{new SdXML3DLightContext(mrImport, xAttrList)};
+
+    // remember SdXML3DLightContext for later evaluation
+    maList.push_back(xContext);
+
+    return xContext.get();
+}
+
+/** this should be called for each scene attribute */
+void SdXML3DSceneAttributesHelper::processSceneAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & aIter )
+{
+    auto nAttributeToken = aIter.getToken();
+    if( !IsTokenInNamespace(nAttributeToken, XML_NAMESPACE_DR3D) )
+        return;
+
+    switch(nAttributeToken & TOKEN_MASK)
+    {
+        case XML_TRANSFORM:
+        {
+            SdXMLImExTransform3D aTransform(aIter.toString(), mrImport.GetMM100UnitConverter());
+            if(aTransform.NeedsAction())
+                mbSetTransform = aTransform.GetFullHomogenTransform(mxHomMat);
+            return;
+        }
+        case XML_VRP:
+        {
+            ::basegfx::B3DVector aNewVec;
+            SvXMLUnitConverter::convertB3DVector(aNewVec, aIter.toView());
+
+            if(aNewVec != maVRP)
+            {
+                maVRP = aNewVec;
+                mbVRPUsed = true;
+            }
+            return;
+        }
+        case XML_VPN:
+        {
+            ::basegfx::B3DVector aNewVec;
+            SvXMLUnitConverter::convertB3DVector(aNewVec, aIter.toView());
+
+            if(aNewVec != maVPN)
+            {
+                maVPN = aNewVec;
+            }
+            return;
+        }
+        case XML_VUP:
+        {
+            ::basegfx::B3DVector aNewVec;
+            SvXMLUnitConverter::convertB3DVector(aNewVec, aIter.toView());
+
+            if(aNewVec != maVUP)
+            {
+                maVUP = aNewVec;
+            }
+            return;
+        }
+        case XML_PROJECTION:
+        {
+            if( IsXMLToken( aIter, XML_PARALLEL ) )
+                mxPrjMode = drawing::ProjectionMode_PARALLEL;
+            else
+                mxPrjMode = drawing::ProjectionMode_PERSPECTIVE;
+            return;
+        }
+        case XML_DISTANCE:
+        {
+            mrImport.GetMM100UnitConverter().convertMeasureToCore(mnDistance,
+                    aIter.toView());
+            return;
+        }
+        case XML_FOCAL_LENGTH:
+        {
+            mrImport.GetMM100UnitConverter().convertMeasureToCore(mnFocalLength,
+                    aIter.toView());
+            return;
+        }
+        case XML_SHADOW_SLANT:
+        {
+            ::sax::Converter::convertNumber(mnShadowSlant, aIter.toView());
+            return;
+        }
+        case XML_SHADE_MODE:
+        {
+            if( IsXMLToken( aIter, XML_FLAT ) )
+                mxShadeMode = drawing::ShadeMode_FLAT;
+            else if( IsXMLToken( aIter, XML_PHONG ) )
+                mxShadeMode = drawing::ShadeMode_PHONG;
+            else if( IsXMLToken( aIter, XML_GOURAUD ) )
+                mxShadeMode = drawing::ShadeMode_SMOOTH;
+            else
+                mxShadeMode = drawing::ShadeMode_DRAFT;
+            return;
+        }
+        case XML_AMBIENT_COLOR:
+        {
+            ::sax::Converter::convertColor(maAmbientColor, aIter.toView());
+            return;
+        }
+        case XML_LIGHTING_MODE:
+        {
+            (void)::sax::Converter::convertBool(mbLightingMode, aIter.toView());
+            return;
+        }
+        default:
+            XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+    }
+}
+
+/** this sets the scene attributes at this propertyset */
+void SdXML3DSceneAttributesHelper::setSceneAttributes( const css::uno::Reference< css::beans::XPropertySet >& xPropSet )
+{
+    uno::Any aAny;
+
+    // world transformation
+    if(mbSetTransform)
+    {
+        xPropSet->setPropertyValue("D3DTransformMatrix", uno::Any(mxHomMat));
+    }
+
+    // distance
+    xPropSet->setPropertyValue("D3DSceneDistance", uno::Any(mnDistance));
+    // focalLength
+    xPropSet->setPropertyValue("D3DSceneFocalLength", uno::Any(mnFocalLength));
+    // shadowSlant
+    xPropSet->setPropertyValue("D3DSceneShadowSlant", uno::Any(static_cast<sal_Int16>(mnShadowSlant)));
+    // shadeMode
+    xPropSet->setPropertyValue("D3DSceneShadeMode", uno::Any(mxShadeMode));
+    // ambientColor
+    xPropSet->setPropertyValue("D3DSceneAmbientColor", uno::Any(maAmbientColor));
+    // lightingMode
+    xPropSet->setPropertyValue("D3DSceneTwoSidedLighting", uno::Any(mbLightingMode));
+
+    if( !maList.empty() )
+    {
+        uno::Any aAny2;
+        uno::Any aAny3;
+
+        // set lights
+        for( size_t a = 0; a < maList.size(); a++)
+        {
+            SdXML3DLightContext* pCtx = maList[ a ].get();
+
+            // set anys
+            aAny <<= pCtx->GetDiffuseColor();
+            drawing::Direction3D aLightDir;
+            aLightDir.DirectionX = pCtx->GetDirection().getX();
+            aLightDir.DirectionY = pCtx->GetDirection().getY();
+            aLightDir.DirectionZ = pCtx->GetDirection().getZ();
+            aAny2 <<= aLightDir;
+            aAny3 <<= pCtx->GetEnabled();
+
+            switch(a)
+            {
+                case 0:
+                {
+                    xPropSet->setPropertyValue("D3DSceneLightColor1", aAny);
+                    xPropSet->setPropertyValue("D3DSceneLightDirection1", aAny2);
+                    xPropSet->setPropertyValue("D3DSceneLightOn1", aAny3);
+                    break;
+                }
+                case 1:
+                {
+                    xPropSet->setPropertyValue("D3DSceneLightColor2", aAny);
+                    xPropSet->setPropertyValue("D3DSceneLightDirection2", aAny2);
+                    xPropSet->setPropertyValue("D3DSceneLightOn2", aAny3);
+                    break;
+                }
+                case 2:
+                {
+                    xPropSet->setPropertyValue("D3DSceneLightColor3", aAny);
+                    xPropSet->setPropertyValue("D3DSceneLightDirection3", aAny2);
+                    xPropSet->setPropertyValue("D3DSceneLightOn3", aAny3);
+                    break;
+                }
+                case 3:
+                {
+                    xPropSet->setPropertyValue("D3DSceneLightColor4", aAny);
+                    xPropSet->setPropertyValue("D3DSceneLightDirection4", aAny2);
+                    xPropSet->setPropertyValue("D3DSceneLightOn4", aAny3);
+                    break;
+                }
+                case 4:
+                {
+                    xPropSet->setPropertyValue("D3DSceneLightColor5", aAny);
+                    xPropSet->setPropertyValue("D3DSceneLightDirection5", aAny2);
+                    xPropSet->setPropertyValue("D3DSceneLightOn5", aAny3);
+                    break;
+                }
+                case 5:
+                {
+                    xPropSet->setPropertyValue("D3DSceneLightColor6", aAny);
+                    xPropSet->setPropertyValue("D3DSceneLightDirection6", aAny2);
+                    xPropSet->setPropertyValue("D3DSceneLightOn6", aAny3);
+                    break;
+                }
+                case 6:
+                {
+                    xPropSet->setPropertyValue("D3DSceneLightColor7", aAny);
+                    xPropSet->setPropertyValue("D3DSceneLightDirection7", aAny2);
+                    xPropSet->setPropertyValue("D3DSceneLightOn7", aAny3);
+                    break;
+                }
+                case 7:
+                {
+                    xPropSet->setPropertyValue("D3DSceneLightColor8", aAny);
+                    xPropSet->setPropertyValue("D3DSceneLightDirection8", aAny2);
+                    xPropSet->setPropertyValue("D3DSceneLightOn8", aAny3);
+                    break;
+                }
+            }
+        }
+    }
+
+    // CameraGeometry and camera settings
+    drawing::CameraGeometry aCamGeo;
+    aCamGeo.vrp.PositionX = maVRP.getX();
+    aCamGeo.vrp.PositionY = maVRP.getY();
+    aCamGeo.vrp.PositionZ = maVRP.getZ();
+    aCamGeo.vpn.DirectionX = maVPN.getX();
+    aCamGeo.vpn.DirectionY = maVPN.getY();
+    aCamGeo.vpn.DirectionZ = maVPN.getZ();
+    aCamGeo.vup.DirectionX = maVUP.getX();
+    aCamGeo.vup.DirectionY = maVUP.getY();
+    aCamGeo.vup.DirectionZ = maVUP.getZ();
+    xPropSet->setPropertyValue("D3DCameraGeometry", uno::Any(aCamGeo));
+
+    // #91047# set drawing::ProjectionMode AFTER camera geometry is set
+    // projection "D3DScenePerspective" drawing::ProjectionMode
+    xPropSet->setPropertyValue("D3DScenePerspective", uno::Any(mxPrjMode));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/ximp3dscene.hxx b/xmloff/source/draw/ximp3dscene.hxx
new file mode 100644
index 000000000..b0155591e
--- /dev/null
+++ b/xmloff/source/draw/ximp3dscene.hxx
@@ -0,0 +1,52 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlictxt.hxx>
+#include <com/sun/star/drawing/XShapes.hpp>
+#include "ximpshap.hxx"
+
+// dr3d:3dscene context
+
+class SdXML3DSceneShapeContext : public SdXMLShapeContext, public SdXML3DSceneAttributesHelper
+{
+    // the shape group this group is working on
+    // this is the scene at the same time
+    css::uno::Reference< css::drawing::XShapes > mxChildren;
+
+public:
+
+    SdXML3DSceneShapeContext(
+        SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes,
+        bool bTemporaryShape);
+    virtual ~SdXML3DSceneShapeContext() override;
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/ximpbody.cxx b/xmloff/source/draw/ximpbody.cxx
new file mode 100644
index 000000000..198503eab
--- /dev/null
+++ b/xmloff/source/draw/ximpbody.cxx
@@ -0,0 +1,346 @@
+/* -*- 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 "ximpbody.hxx"
+#include <xmloff/xmlnamespace.hxx>
+#include "ximpnote.hxx"
+#include <com/sun/star/drawing/XDrawPage.hpp>
+#include <com/sun/star/drawing/XDrawPages.hpp>
+#include <com/sun/star/container/XNamed.hpp>
+#include <com/sun/star/presentation/XPresentationPage.hpp>
+#include "ximpstyl.hxx"
+#include <com/sun/star/drawing/XMasterPageTarget.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/animations/XAnimationNodeSupplier.hpp>
+
+#include <xmloff/unointerfacetouniqueidentifiermapper.hxx>
+#include <xmloff/families.hxx>
+#include "ximpshow.hxx"
+#include "layerimp.hxx"
+#include <animationimport.hxx>
+#include <sal/log.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+SdXMLDrawPageContext::SdXMLDrawPageContext( SdXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes)
+:   SdXMLGenericPageContext( rImport, xAttrList, rShapes )
+,   mbHadSMILNodes( false )
+{
+    bool bHaveXmlId( false );
+    OUString sXmlId, sStyleName, sContextName, sMasterPageName, sHREF;
+
+    for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+    {
+        OUString sValue = aIter.toString();
+        switch(aIter.getToken())
+        {
+            case XML_ELEMENT(DRAW, XML_NAME):
+            {
+                sContextName = sValue;
+                break;
+            }
+            case XML_ELEMENT(DRAW, XML_STYLE_NAME):
+            {
+                sStyleName = sValue;
+                break;
+            }
+            case XML_ELEMENT(DRAW, XML_MASTER_PAGE_NAME):
+            {
+                sMasterPageName = sValue;
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_PRESENTATION_PAGE_LAYOUT_NAME):
+            case XML_ELEMENT(PRESENTATION_SO52, XML_PRESENTATION_PAGE_LAYOUT_NAME):
+            case XML_ELEMENT(PRESENTATION_OOO, XML_PRESENTATION_PAGE_LAYOUT_NAME):
+            {
+                maPageLayoutName =  sValue;
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_USE_HEADER_NAME):
+            case XML_ELEMENT(PRESENTATION_SO52, XML_USE_HEADER_NAME):
+            case XML_ELEMENT(PRESENTATION_OOO, XML_USE_HEADER_NAME):
+            {
+                maUseHeaderDeclName =  sValue;
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_USE_FOOTER_NAME):
+            case XML_ELEMENT(PRESENTATION_SO52, XML_USE_FOOTER_NAME):
+            case XML_ELEMENT(PRESENTATION_OOO, XML_USE_FOOTER_NAME):
+            {
+                maUseFooterDeclName =  sValue;
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_USE_DATE_TIME_NAME):
+            case XML_ELEMENT(PRESENTATION_SO52, XML_USE_DATE_TIME_NAME):
+            case XML_ELEMENT(PRESENTATION_OOO, XML_USE_DATE_TIME_NAME):
+            {
+                maUseDateTimeDeclName =  sValue;
+                break;
+            }
+            case XML_ELEMENT(DRAW, XML_ID):
+            {
+                if (!bHaveXmlId) { sXmlId = sValue; }
+            }
+            break;
+            case XML_ELEMENT(XML, XML_ID):
+            {
+                sXmlId = sValue;
+                bHaveXmlId = true;
+            }
+            break;
+            case XML_ELEMENT(XLINK, XML_HREF):
+            {
+                sHREF = sValue;
+                break;
+            }
+        }
+    }
+
+    if (!sXmlId.isEmpty())
+    {
+        uno::Reference< uno::XInterface > const xRef( rShapes );
+        GetImport().getInterfaceToIdentifierMapper().registerReference(
+            sXmlId, xRef );
+    }
+    GetImport().GetShapeImport()->startPage( rShapes );
+
+    uno::Reference< drawing::XDrawPage > xShapeDrawPage(rShapes, uno::UNO_QUERY);
+
+    // set PageName?
+    if(!sContextName.isEmpty())
+    {
+        if(xShapeDrawPage.is())
+        {
+            uno::Reference < container::XNamed > xNamed(xShapeDrawPage, uno::UNO_QUERY);
+            if(xNamed.is())
+                xNamed->setName(sContextName);
+        }
+    }
+
+    // set MasterPage?
+    if(!sMasterPageName.isEmpty())
+    {
+        // #85906# Code for setting masterpage needs complete rework
+        // since GetSdImport().GetMasterStylesContext() gives always ZERO
+        // because of content/style file split. Now the mechanism is to
+        // compare the wanted masterpage-name with the existing masterpages
+        // which were loaded and created in the styles section loading.
+        uno::Reference< drawing::XDrawPages > xMasterPages(GetSdImport().GetLocalMasterPages(), uno::UNO_QUERY);
+        uno::Reference < drawing::XMasterPageTarget > xDrawPage(rShapes, uno::UNO_QUERY);
+        uno::Reference< drawing::XDrawPage > xMasterPage;
+
+        if(xDrawPage.is() && xMasterPages.is())
+        {
+            bool bDone(false);
+            OUString sDisplayName( rImport.GetStyleDisplayName(
+                            XmlStyleFamily::MASTER_PAGE, sMasterPageName ) );
+
+            for(sal_Int32 a = 0; !bDone && a < xMasterPages->getCount(); a++)
+            {
+                uno::Any aAny(xMasterPages->getByIndex(a));
+                aAny >>= xMasterPage;
+
+                if(xMasterPage.is())
+                {
+                    uno::Reference < container::XNamed > xMasterNamed(xMasterPage, uno::UNO_QUERY);
+                    if(xMasterNamed.is())
+                    {
+                        OUString sLoopMasterPageName = xMasterNamed->getName();
+
+                        if(!sLoopMasterPageName.isEmpty() && sLoopMasterPageName == sDisplayName)
+                        {
+                            xDrawPage->setMasterPage(xMasterPage);
+                            bDone = true;
+                        }
+                    }
+                }
+            }
+
+            SAL_WARN_IF( !bDone, "xmloff", "xmloff::SdXMLDrawPageContext::SdXMLDrawPageContext(), could not find a master slide!" );
+        }
+    }
+
+    SetStyle( sStyleName );
+
+    if( !sHREF.isEmpty() )
+    {
+        uno::Reference< beans::XPropertySet > xProps( xShapeDrawPage, uno::UNO_QUERY );
+        if( xProps.is() )
+        {
+            sal_Int32 nIndex = sHREF.lastIndexOf( '#' );
+            if( nIndex != -1 )
+            {
+                OUString aFileName( sHREF.copy( 0, nIndex ) );
+                std::u16string_view aBookmarkName( sHREF.subView( nIndex+1 ) );
+
+                sHREF = GetImport().GetAbsoluteReference( aFileName ) + "#"
+                    + aBookmarkName;
+            }
+
+            xProps->setPropertyValue("BookmarkURL", uno::Any( sHREF ) );
+        }
+    }
+
+    SetLayout();
+
+    DeleteAllShapes();
+}
+
+SdXMLDrawPageContext::~SdXMLDrawPageContext()
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler >  SdXMLDrawPageContext::createFastChildContext(sal_Int32 nElement,
+        const css::uno::Reference<css::xml::sax::XFastAttributeList>& xAttrList)
+{
+    // some special objects inside draw:page context
+    switch(nElement)
+    {
+        case XML_ELEMENT(PRESENTATION, XML_NOTES):
+        case XML_ELEMENT(PRESENTATION_SO52, XML_NOTES):
+        case XML_ELEMENT(PRESENTATION_OOO, XML_NOTES):
+        {
+            if( GetSdImport().IsImpress() )
+            {
+                // get notes page
+                uno::Reference< presentation::XPresentationPage > xPresPage(GetLocalShapesContext(), uno::UNO_QUERY);
+                if(xPresPage.is())
+                {
+                    uno::Reference< drawing::XDrawPage > xNotesDrawPage = xPresPage->getNotesPage();
+                    if(xNotesDrawPage.is())
+                    {
+                        // presentation:notes inside draw:page context
+                        return new SdXMLNotesContext( GetSdImport(), xAttrList, xNotesDrawPage);
+                    }
+                }
+            }
+            break;
+        }
+        case XML_ELEMENT(ANIMATION, XML_PAR):
+        case XML_ELEMENT(ANIMATION_OOO, XML_PAR):
+        case XML_ELEMENT(ANIMATION, XML_SEQ):
+        case XML_ELEMENT(ANIMATION_OOO, XML_SEQ):
+        {
+            if( GetSdImport().IsImpress() )
+            {
+                uno::Reference< animations::XAnimationNodeSupplier > xNodeSupplier(GetLocalShapesContext(), uno::UNO_QUERY);
+                if(xNodeSupplier.is())
+                {
+                    mbHadSMILNodes = true;
+                    return new xmloff::AnimationNodeContext( xNodeSupplier->getAnimationNode(), GetSdImport(), nElement, xAttrList );
+                }
+            }
+            break;
+        }
+        case XML_ELEMENT(DRAW, XML_LAYER_SET):
+        {
+            return new SdXMLLayerSetContext( GetSdImport() );
+        }
+    }
+
+    // call parent when no own context was created
+    return SdXMLGenericPageContext::createFastChildContext(nElement, xAttrList);
+}
+
+void SdXMLDrawPageContext::endFastElement(sal_Int32 nElement)
+{
+    SdXMLGenericPageContext::endFastElement(nElement);
+    GetImport().GetShapeImport()->endPage(GetLocalShapesContext());
+
+    if( mbHadSMILNodes )
+    {
+        uno::Reference< animations::XAnimationNodeSupplier > xNodeSupplier(GetLocalShapesContext(), uno::UNO_QUERY);
+        uno::Reference< beans::XPropertySet > xPageProps( GetLocalShapesContext(), uno::UNO_QUERY );
+        if(xNodeSupplier.is())
+            xmloff::AnimationNodeContext::postProcessRootNode( xNodeSupplier->getAnimationNode(), xPageProps );
+    }
+}
+
+SdXMLBodyContext::SdXMLBodyContext( SdXMLImport& rImport )
+:   SvXMLImportContext( rImport )
+{
+}
+
+SdXMLBodyContext::~SdXMLBodyContext()
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLBodyContext::createFastChildContext(
+     sal_Int32 nElement,
+     const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    switch (nElement)
+    {
+        case XML_ELEMENT(PRESENTATION, XML_SETTINGS):
+        case XML_ELEMENT(PRESENTATION_SO52, XML_SETTINGS):
+        case XML_ELEMENT(PRESENTATION_OOO, XML_SETTINGS):
+        {
+            return new SdXMLShowsContext( GetSdImport(), xAttrList );
+        }
+        case XML_ELEMENT(DRAW, XML_PAGE):
+        {
+            // only read the first page in preview mode
+            if( (GetSdImport().GetNewPageCount() == 0) || !GetSdImport().IsPreview() )
+            {
+                // import this page
+                uno::Reference< drawing::XDrawPage > xNewDrawPage;
+                uno::Reference< drawing::XDrawPages > xDrawPages(GetSdImport().GetLocalDrawPages(), uno::UNO_QUERY);
+
+                if( !xDrawPages.is() )
+                    break;
+
+                if(GetSdImport().GetNewPageCount() + 1 > xDrawPages->getCount())
+                {
+                    // new page, create and insert
+                    xNewDrawPage = xDrawPages->insertNewByIndex(xDrawPages->getCount());
+                }
+                else
+                {
+                    // existing page, use it
+                    uno::Any aAny(xDrawPages->getByIndex(GetSdImport().GetNewPageCount()));
+                    aAny >>= xNewDrawPage;
+                }
+
+                // increment global import page counter
+                GetSdImport().IncrementNewPageCount();
+
+                if(xNewDrawPage.is())
+                {
+                    // draw:page inside office:body context
+                    return new SdXMLDrawPageContext(GetSdImport(), xAttrList, xNewDrawPage);
+                }
+            }
+            break;
+        }
+        case XML_ELEMENT(PRESENTATION, XML_HEADER_DECL):
+        case XML_ELEMENT(PRESENTATION, XML_FOOTER_DECL):
+        case XML_ELEMENT(PRESENTATION, XML_DATE_TIME_DECL):
+        {
+            return new SdXMLHeaderFooterDeclContext( GetImport(), xAttrList );
+        }
+        default:
+            XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+    }
+    return nullptr;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/ximpbody.hxx b/xmloff/source/draw/ximpbody.hxx
new file mode 100644
index 000000000..95d411385
--- /dev/null
+++ b/xmloff/source/draw/ximpbody.hxx
@@ -0,0 +1,59 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlictxt.hxx>
+#include "sdxmlimp_impl.hxx"
+#include "ximppage.hxx"
+
+// draw:page context
+
+class SdXMLDrawPageContext : public SdXMLGenericPageContext
+{
+    bool                   mbHadSMILNodes;
+
+public:
+    SdXMLDrawPageContext( SdXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes);
+    virtual ~SdXMLDrawPageContext() override;
+
+    virtual css::uno::Reference< XFastContextHandler >  SAL_CALL createFastChildContext(sal_Int32 Element,
+        const css::uno::Reference<css::xml::sax::XFastAttributeList>& Attribs) override;
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+
+};
+
+// office:body context
+
+class SdXMLBodyContext : public SvXMLImportContext
+{
+    const SdXMLImport& GetSdImport() const { return static_cast<const SdXMLImport&>(GetImport()); }
+    SdXMLImport& GetSdImport() { return static_cast<SdXMLImport&>(GetImport()); }
+
+public:
+    SdXMLBodyContext( SdXMLImport& rImport );
+    virtual ~SdXMLBodyContext() override;
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+                sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/ximpcustomshape.cxx b/xmloff/source/draw/ximpcustomshape.cxx
new file mode 100644
index 000000000..fbc32e53e
--- /dev/null
+++ b/xmloff/source/draw/ximpcustomshape.cxx
@@ -0,0 +1,1421 @@
+/* -*- 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 "ximpcustomshape.hxx"
+#include <o3tl/any.hxx>
+#include <rtl/math.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <rtl/ustring.hxx>
+#include <com/sun/star/uno/Reference.h>
+#include <com/sun/star/awt/Rectangle.hpp>
+#include <com/sun/star/xml/sax/XAttributeList.hpp>
+#include <xmloff/xmltoken.hxx>
+#include <EnhancedCustomShapeToken.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/namespacemap.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlement.hxx>
+#include <xexptran.hxx>
+#include <com/sun/star/drawing/Direction3D.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeParameterPair.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeParameterType.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeTextFrame.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeAdjustmentValue.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeSegment.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeSegmentCommand.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeTextPathMode.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeMetalType.hpp>
+#include <com/sun/star/drawing/ProjectionMode.hpp>
+#include <com/sun/star/drawing/Position3D.hpp>
+#include <sax/tools/converter.hxx>
+#include <comphelper/sequence.hxx>
+#include <o3tl/string_view.hxx>
+#include <memory>
+#include <string_view>
+#include <unordered_map>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+using namespace ::xmloff::EnhancedCustomShapeToken;
+
+
+XMLEnhancedCustomShapeContext::XMLEnhancedCustomShapeContext( SvXMLImport& rImport,
+            css::uno::Reference< css::drawing::XShape >& rxShape,
+            std::vector< css::beans::PropertyValue >& rCustomShapeGeometry ) :
+        SvXMLImportContext( rImport ),
+        mrUnitConverter( rImport.GetMM100UnitConverter() ),
+        mrxShape( rxShape ),
+        mrCustomShapeGeometry( rCustomShapeGeometry )
+{
+}
+
+const SvXMLEnumMapEntry<sal_uInt16> aXML_GluePointEnumMap[] =
+{
+    { XML_NONE,         0 },
+    { XML_SEGMENTS,     1 },
+    { XML_NONE,         2 },
+    { XML_RECTANGLE,    3 },
+    { XML_TOKEN_INVALID, 0 }
+};
+static void GetBool( std::vector< css::beans::PropertyValue >& rDest,
+                        std::string_view rValue, const EnhancedCustomShapeTokenEnum eDestProp )
+{
+    bool bAttrBool;
+    if (::sax::Converter::convertBool( bAttrBool, rValue ))
+    {
+        beans::PropertyValue aProp;
+        aProp.Name = EASGet( eDestProp );
+        aProp.Value <<= bAttrBool;
+        rDest.push_back( aProp );
+    }
+}
+
+static void GetInt32( std::vector< css::beans::PropertyValue >& rDest,
+                        std::string_view rValue, const EnhancedCustomShapeTokenEnum eDestProp )
+{
+    sal_Int32 nAttrNumber;
+    if (::sax::Converter::convertNumber( nAttrNumber, rValue ))
+    {
+        beans::PropertyValue aProp;
+        aProp.Name = EASGet( eDestProp );
+        aProp.Value <<= nAttrNumber;
+        rDest.push_back( aProp );
+    }
+}
+
+static void GetDouble( std::vector< css::beans::PropertyValue >& rDest,
+                        std::string_view rValue, const EnhancedCustomShapeTokenEnum eDestProp )
+{
+    double fAttrDouble;
+    if (::sax::Converter::convertDouble( fAttrDouble, rValue ))
+    {
+        beans::PropertyValue aProp;
+        aProp.Name = EASGet( eDestProp );
+        aProp.Value <<= fAttrDouble;
+        rDest.push_back( aProp );
+    }
+}
+
+static void GetString( std::vector< css::beans::PropertyValue >& rDest,
+                        const OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
+{
+    beans::PropertyValue aProp;
+    aProp.Name = EASGet( eDestProp );
+    aProp.Value <<= rValue;
+    rDest.push_back( aProp );
+}
+
+template<typename EnumT>
+static void GetEnum( std::vector< css::beans::PropertyValue >& rDest,
+                         std::string_view rValue, const EnhancedCustomShapeTokenEnum eDestProp,
+                        const SvXMLEnumMapEntry<EnumT>& rMap )
+{
+    EnumT eKind;
+    if( SvXMLUnitConverter::convertEnum( eKind, rValue, &rMap ) )
+    {
+        beans::PropertyValue aProp;
+        aProp.Name = EASGet( eDestProp );
+        aProp.Value <<= static_cast<sal_Int16>(eKind);
+        rDest.push_back( aProp );
+    }
+}
+
+static void GetDoublePercentage( std::vector< css::beans::PropertyValue >& rDest,
+                         std::string_view rValue, const EnhancedCustomShapeTokenEnum eDestProp )
+{
+    sal_Int16 const eSrcUnit = ::sax::Converter::GetUnitFromString(
+            rValue, util::MeasureUnit::MM_100TH);
+    if (util::MeasureUnit::PERCENT != eSrcUnit)
+        return;
+
+    rtl_math_ConversionStatus eStatus;
+    double fAttrDouble = rtl_math_stringToDouble(rValue.data(),
+                                             rValue.data() + rValue.size(),
+                                             '.', ',', &eStatus, nullptr);
+    if ( eStatus == rtl_math_ConversionStatus_Ok )
+    {
+        beans::PropertyValue aProp;
+        aProp.Name = EASGet( eDestProp );
+        aProp.Value <<= fAttrDouble;
+        rDest.push_back( aProp );
+    }
+}
+
+static void GetB3DVector( std::vector< css::beans::PropertyValue >& rDest,
+                         std::string_view rValue, const EnhancedCustomShapeTokenEnum eDestProp )
+{
+    ::basegfx::B3DVector aB3DVector;
+    if ( SvXMLUnitConverter::convertB3DVector( aB3DVector, rValue ) )
+    {
+        drawing::Direction3D aDirection3D( aB3DVector.getX(), aB3DVector.getY(), aB3DVector.getZ() );
+        beans::PropertyValue aProp;
+        aProp.Name = EASGet( eDestProp );
+        aProp.Value <<= aDirection3D;
+        rDest.push_back( aProp );
+    }
+}
+
+static bool GetEquationName( const OUString& rEquation, const sal_Int32 nStart, OUString& rEquationName )
+{
+    sal_Int32 nIndex = nStart;
+    while( nIndex < rEquation.getLength() )
+    {
+        sal_Unicode nChar = rEquation[ nIndex ];
+        if (
+            ( ( nChar >= 'a' ) && ( nChar <= 'z' ) )
+            || ( ( nChar >= 'A' ) && ( nChar <= 'Z' ) )
+            || ( ( nChar >= '0' ) && ( nChar <= '9' ) )
+            )
+        {
+            nIndex++;
+        }
+        else
+            break;
+    }
+    bool bValid = ( nIndex - nStart ) != 0;
+    if ( bValid )
+        rEquationName = rEquation.copy( nStart, nIndex - nStart );
+    return bValid;
+}
+
+static bool GetNextParameter( css::drawing::EnhancedCustomShapeParameter& rParameter, sal_Int32& nIndex, const OUString& rParaString )
+{
+    if ( nIndex >= rParaString.getLength() )
+        return false;
+
+    bool bValid = true;
+    bool bNumberRequired = true;
+    bool bMustBePositiveWholeNumbered = false;
+
+    rParameter.Type = css::drawing::EnhancedCustomShapeParameterType::NORMAL;
+    if ( rParaString[ nIndex ] == '$' )
+    {
+        rParameter.Type = css::drawing::EnhancedCustomShapeParameterType::ADJUSTMENT;
+        bMustBePositiveWholeNumbered = true;
+        nIndex++;
+    }
+    else if ( rParaString[ nIndex ] == '?' )
+    {
+        nIndex++;
+        bNumberRequired = false;
+        OUString aEquationName;
+        bValid = GetEquationName( rParaString, nIndex, aEquationName );
+        if ( bValid )
+        {
+            rParameter.Type = css::drawing::EnhancedCustomShapeParameterType::EQUATION;
+            rParameter.Value <<= aEquationName;
+            nIndex += aEquationName.getLength();
+        }
+    }
+    else if ( rParaString[ nIndex ] > '9' )
+    {
+        bNumberRequired = false;
+        if ( rParaString.matchIgnoreAsciiCase( "left", nIndex ) )
+        {
+            rParameter.Type = css::drawing::EnhancedCustomShapeParameterType::LEFT;
+            nIndex += 4;
+        }
+        else if ( rParaString.matchIgnoreAsciiCase( "top", nIndex ) )
+        {
+            rParameter.Type = css::drawing::EnhancedCustomShapeParameterType::TOP;
+            nIndex += 3;
+        }
+        else if ( rParaString.matchIgnoreAsciiCase( "right", nIndex ) )
+        {
+            rParameter.Type = css::drawing::EnhancedCustomShapeParameterType::RIGHT;
+            nIndex += 5;
+        }
+        else if ( rParaString.matchIgnoreAsciiCase( "bottom", nIndex ) )
+        {
+            rParameter.Type = css::drawing::EnhancedCustomShapeParameterType::BOTTOM;
+            nIndex += 6;
+        }
+        else if ( rParaString.matchIgnoreAsciiCase( "xstretch", nIndex ) )
+        {
+            rParameter.Type = css::drawing::EnhancedCustomShapeParameterType::XSTRETCH;
+            nIndex += 8;
+        }
+        else if ( rParaString.matchIgnoreAsciiCase( "ystretch", nIndex ) )
+        {
+            rParameter.Type = css::drawing::EnhancedCustomShapeParameterType::YSTRETCH;
+            nIndex += 8;
+        }
+        else if ( rParaString.matchIgnoreAsciiCase( "hasstroke", nIndex ) )
+        {
+            rParameter.Type = css::drawing::EnhancedCustomShapeParameterType::HASSTROKE;
+            nIndex += 9;
+        }
+        else if ( rParaString.matchIgnoreAsciiCase( "hasfill", nIndex ) )
+        {
+            rParameter.Type = css::drawing::EnhancedCustomShapeParameterType::HASFILL;
+            nIndex += 7;
+        }
+        else if ( rParaString.matchIgnoreAsciiCase( "width", nIndex ) )
+        {
+            rParameter.Type = css::drawing::EnhancedCustomShapeParameterType::WIDTH;
+            nIndex += 5;
+        }
+        else if ( rParaString.matchIgnoreAsciiCase( "height", nIndex ) )
+        {
+            rParameter.Type = css::drawing::EnhancedCustomShapeParameterType::HEIGHT;
+            nIndex += 6;
+        }
+        else if ( rParaString.matchIgnoreAsciiCase( "logwidth", nIndex ) )
+        {
+            rParameter.Type = css::drawing::EnhancedCustomShapeParameterType::LOGWIDTH;
+            nIndex += 8;
+        }
+        else if ( rParaString.matchIgnoreAsciiCase( "logheight", nIndex ) )
+        {
+            rParameter.Type = css::drawing::EnhancedCustomShapeParameterType::LOGHEIGHT;
+            nIndex += 9;
+        }
+        else
+            bValid = false;
+    }
+    if ( bValid )
+    {
+        if ( bNumberRequired )
+        {
+            sal_Int32 nStartIndex = nIndex;
+            sal_Int32 nEIndex = 0;  // index of "E" in double
+
+            bool bE = false;    // set if a double is including a "E" statement
+            bool bENum = false; // there is at least one number after "E"
+            bool bDot = false;  // set if there is a dot included
+            bool bEnd = false;  // set for each value that can not be part of a double/integer
+
+            while( ( nIndex < rParaString.getLength() ) && bValid )
+            {
+                switch( rParaString[ nIndex ] )
+                {
+                    case '.' :
+                    {
+                        if ( bMustBePositiveWholeNumbered )
+                            bValid = false;
+                        else
+                        {
+                            if ( bDot )
+                                bValid = false;
+                            else
+                                bDot = true;
+                        }
+                    }
+                    break;
+                    case '-' :
+                    {
+                        if ( bMustBePositiveWholeNumbered )
+                            bValid = false;
+                        else
+                        {
+                            if ( nStartIndex == nIndex )
+                               bValid = true;
+                            else if ( bE )
+                            {
+                                if ( nEIndex + 1 == nIndex )
+                                    bValid = true;
+                                else if ( bENum )
+                                    bEnd = true;
+                                else
+                                    bValid = false;
+                            }
+                        }
+                    }
+                    break;
+
+                    case 'e' :
+                    case 'E' :
+                    {
+                        if ( bMustBePositiveWholeNumbered )
+                            bEnd = true;
+                        else
+                        {
+                            if ( !bE )
+                            {
+                                bE = true;
+                                nEIndex = nIndex;
+                            }
+                            else
+                                bEnd = true;
+                        }
+                    }
+                    break;
+                    case '0' :
+                    case '1' :
+                    case '2' :
+                    case '3' :
+                    case '4' :
+                    case '5' :
+                    case '6' :
+                    case '7' :
+                    case '8' :
+                    case '9' :
+                    {
+                        if ( bE && ! bENum )
+                            bENum = true;
+                    }
+                    break;
+                    default:
+                        bEnd = true;
+                }
+                if ( !bEnd )
+                    nIndex++;
+                else
+                    break;
+            }
+            if ( nIndex == nStartIndex )
+                bValid = false;
+            if ( bValid )
+            {
+                std::u16string_view aNumber( rParaString.subView( nStartIndex, nIndex - nStartIndex ) );
+                if ( bE || bDot )
+                {
+                    double fAttrDouble;
+                    if (::sax::Converter::convertDouble(fAttrDouble, aNumber))
+                        rParameter.Value <<= fAttrDouble;
+                    else
+                        bValid = false;
+                }
+                else
+                {
+                    sal_Int32 nValue;
+                    if (::sax::Converter::convertNumber(nValue, aNumber))
+                        rParameter.Value <<= nValue;
+                    else
+                        bValid = false;
+                }
+            }
+        }
+    }
+    if ( bValid )
+    {
+        // skipping white spaces and commas (#i121507#)
+        const sal_Unicode aSpace(' ');
+        const sal_Unicode aCommata(',');
+
+        while(nIndex < rParaString.getLength())
+        {
+            const sal_Unicode aCandidate(rParaString[nIndex]);
+
+            if(aSpace == aCandidate || aCommata == aCandidate)
+            {
+                nIndex++;
+            }
+            else
+            {
+                break;
+            }
+        }
+    }
+    return bValid;
+}
+
+static void GetPosition3D( std::vector< css::beans::PropertyValue >& rDest,                     // e.g. draw:extrusion-viewpoint
+                        std::string_view rValue, const EnhancedCustomShapeTokenEnum eDestProp,
+                        const SvXMLUnitConverter& rUnitConverter )
+{
+    drawing::Position3D aPosition3D;
+    if ( rUnitConverter.convertPosition3D( aPosition3D, rValue ) )
+    {
+        beans::PropertyValue aProp;
+        aProp.Name = EASGet( eDestProp );
+        aProp.Value <<= aPosition3D;
+        rDest.push_back( aProp );
+    }
+}
+
+static void GetDoubleSequence( std::vector< css::beans::PropertyValue >& rDest,                 // e.g. draw:glue-point-leaving-directions
+                        std::string_view rValue, const EnhancedCustomShapeTokenEnum eDestProp )
+{
+    std::vector< double > vDirection;
+    sal_Int32 nIndex = 0;
+    do
+    {
+        double fAttrDouble;
+        std::string_view aToken( o3tl::getToken(rValue, 0, ',', nIndex ) );
+        if (!::sax::Converter::convertDouble( fAttrDouble, aToken ))
+            break;
+        else
+            vDirection.push_back( fAttrDouble );
+    }
+    while ( nIndex >= 0 );
+
+    if ( !vDirection.empty() )
+    {
+        beans::PropertyValue aProp;
+        aProp.Name = EASGet( eDestProp );
+        aProp.Value <<= comphelper::containerToSequence(vDirection);
+        rDest.push_back( aProp );
+    }
+}
+
+static void GetSizeSequence( std::vector< css::beans::PropertyValue >& rDest,
+                      std::string_view rValue, const EnhancedCustomShapeTokenEnum eDestProp )
+{
+    std::vector< sal_Int32 > vNum;
+    sal_Int32 nIndex = 0;
+    do
+    {
+        sal_Int32 n;
+        std::string_view aToken( o3tl::getToken(rValue, 0, ' ', nIndex ) );
+        if (!::sax::Converter::convertNumber( n, aToken ))
+            break;
+        else
+            vNum.push_back( n );
+    }
+    while ( nIndex >= 0 );
+
+    if ( vNum.empty() )
+        return;
+
+    uno::Sequence< awt::Size > aSizeSeq((vNum.size() + 1) / 2);
+    std::vector< sal_Int32 >::const_iterator aIter = vNum.begin();
+    std::vector< sal_Int32 >::const_iterator aEnd = vNum.end();
+    awt::Size* pValues = aSizeSeq.getArray();
+
+    while ( aIter != aEnd ) {
+        pValues->Width = *aIter++;
+        if ( aIter != aEnd )
+            pValues->Height = *aIter++;
+        pValues ++;
+    }
+
+    beans::PropertyValue aProp;
+    aProp.Name = EASGet( eDestProp );
+    aProp.Value <<= aSizeSeq;
+    rDest.push_back( aProp );
+}
+
+static void GetEnhancedParameter( std::vector< css::beans::PropertyValue >& rDest,              // e.g. draw:handle-position
+                        const OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
+{
+    sal_Int32 nIndex = 0;
+    css::drawing::EnhancedCustomShapeParameter aParameter;
+    if ( GetNextParameter( aParameter, nIndex, rValue ) )
+    {
+        beans::PropertyValue aProp;
+        aProp.Name = EASGet( eDestProp );
+        aProp.Value <<= aParameter;
+        rDest.push_back( aProp );
+    }
+}
+
+static void GetEnhancedParameterPair( std::vector< css::beans::PropertyValue >& rDest,          // e.g. draw:handle-position
+                        const OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
+{
+    sal_Int32 nIndex = 0;
+    css::drawing::EnhancedCustomShapeParameterPair aParameterPair;
+    if ( GetNextParameter( aParameterPair.First, nIndex, rValue )
+        && GetNextParameter( aParameterPair.Second, nIndex, rValue ) )
+    {
+        beans::PropertyValue aProp;
+        aProp.Name = EASGet( eDestProp );
+        aProp.Value <<= aParameterPair;
+        rDest.push_back( aProp );
+    }
+}
+
+static sal_Int32 GetEnhancedParameterPairSequence( std::vector< css::beans::PropertyValue >& rDest,     // e.g. draw:glue-points
+                        const OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
+{
+    std::vector< css::drawing::EnhancedCustomShapeParameterPair > vParameter;
+    css::drawing::EnhancedCustomShapeParameterPair aParameter;
+
+    sal_Int32 nIndex = 0;
+    while ( GetNextParameter( aParameter.First, nIndex, rValue )
+            && GetNextParameter( aParameter.Second, nIndex, rValue ) )
+    {
+        vParameter.push_back( aParameter );
+    }
+    if ( !vParameter.empty() )
+    {
+        beans::PropertyValue aProp;
+        aProp.Name = EASGet( eDestProp );
+        aProp.Value <<= comphelper::containerToSequence(vParameter);
+        rDest.push_back( aProp );
+    }
+    return vParameter.size();
+}
+
+static void GetEnhancedRectangleSequence( std::vector< css::beans::PropertyValue >& rDest,      // e.g. draw:text-areas
+                        const OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
+{
+    std::vector< css::drawing::EnhancedCustomShapeTextFrame > vTextFrame;
+    css::drawing::EnhancedCustomShapeTextFrame aParameter;
+
+    sal_Int32 nIndex = 0;
+
+    while ( GetNextParameter( aParameter.TopLeft.First, nIndex, rValue )
+            && GetNextParameter( aParameter.TopLeft.Second, nIndex, rValue )
+            && GetNextParameter( aParameter.BottomRight.First, nIndex, rValue )
+            && GetNextParameter( aParameter.BottomRight.Second, nIndex, rValue ) )
+    {
+        vTextFrame.push_back( aParameter );
+    }
+    if ( !vTextFrame.empty() )
+    {
+        beans::PropertyValue aProp;
+        aProp.Name = EASGet( eDestProp );
+        aProp.Value <<= comphelper::containerToSequence(vTextFrame);
+        rDest.push_back( aProp );
+    }
+}
+
+static void
+GetEnhancedPath(std::vector<css::beans::PropertyValue>& rDest, // e.g. draw:enhanced-path
+                const OUString& rValue, std::u16string_view rType)
+{
+    std::vector< css::drawing::EnhancedCustomShapeParameterPair >    vCoordinates;
+    std::vector< css::drawing::EnhancedCustomShapeSegment >      vSegments;
+
+    sal_Int32 nIndex = 0;
+    sal_Int32 nParameterCount = 0;
+
+    sal_Int32 nParametersNeeded = 1;
+    sal_Int16 nLatestSegmentCommand = css::drawing::EnhancedCustomShapeSegmentCommand::MOVETO;
+
+    bool bValid = true;
+
+    while( bValid && ( nIndex < rValue.getLength() ) )
+    {
+        switch( rValue[ nIndex ] )
+        {
+            case 'M' :
+            {
+                nLatestSegmentCommand = css::drawing::EnhancedCustomShapeSegmentCommand::MOVETO;
+                nParametersNeeded = 1;
+                nIndex++;
+            }
+            break;
+            case 'L' :
+            {
+                nLatestSegmentCommand = css::drawing::EnhancedCustomShapeSegmentCommand::LINETO;
+                nParametersNeeded = 1;
+                nIndex++;
+            }
+            break;
+            case 'C' :
+            {
+                nLatestSegmentCommand = css::drawing::EnhancedCustomShapeSegmentCommand::CURVETO;
+                nParametersNeeded = 3;
+                nIndex++;
+            }
+            break;
+            case 'Z' :
+            {
+                nLatestSegmentCommand = css::drawing::EnhancedCustomShapeSegmentCommand::CLOSESUBPATH;
+                nParametersNeeded = 0;
+                nIndex++;
+            }
+            break;
+            case 'N' :
+            {
+                nLatestSegmentCommand = css::drawing::EnhancedCustomShapeSegmentCommand::ENDSUBPATH;
+                nParametersNeeded = 0;
+                nIndex++;
+            }
+            break;
+            case 'F' :
+            {
+                nLatestSegmentCommand = css::drawing::EnhancedCustomShapeSegmentCommand::NOFILL;
+                nParametersNeeded = 0;
+                nIndex++;
+            }
+            break;
+            case 'S' :
+            {
+                nLatestSegmentCommand = css::drawing::EnhancedCustomShapeSegmentCommand::NOSTROKE;
+                nParametersNeeded = 0;
+                nIndex++;
+            }
+            break;
+            case 'T' :
+            {
+                nLatestSegmentCommand = css::drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSETO;
+                nParametersNeeded = 3;
+                nIndex++;
+            }
+            break;
+            case 'U' :
+            {
+                nLatestSegmentCommand = css::drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSE;
+                nParametersNeeded = 3;
+                nIndex++;
+            }
+            break;
+            case 'A' :
+            {
+                nLatestSegmentCommand = css::drawing::EnhancedCustomShapeSegmentCommand::ARCTO;
+                nParametersNeeded = 4;
+                nIndex++;
+            }
+            break;
+            case 'B' :
+            {
+                nLatestSegmentCommand = css::drawing::EnhancedCustomShapeSegmentCommand::ARC;
+                nParametersNeeded = 4;
+                nIndex++;
+            }
+            break;
+            case 'G' :
+            {
+                nLatestSegmentCommand = css::drawing::EnhancedCustomShapeSegmentCommand::ARCANGLETO;
+                nParametersNeeded = 2;
+                nIndex++;
+            }
+            break;
+            case 'H' :
+            {
+                nLatestSegmentCommand = css::drawing::EnhancedCustomShapeSegmentCommand::DARKEN;
+                nParametersNeeded = 0;
+                nIndex++;
+            }
+            break;
+            case 'I' :
+            {
+                nLatestSegmentCommand = css::drawing::EnhancedCustomShapeSegmentCommand::DARKENLESS;
+                nParametersNeeded = 0;
+                nIndex++;
+            }
+            break;
+            case 'J' :
+            {
+                nLatestSegmentCommand = css::drawing::EnhancedCustomShapeSegmentCommand::LIGHTEN;
+                nParametersNeeded = 0;
+                nIndex++;
+            }
+            break;
+            case 'K' :
+            {
+                nLatestSegmentCommand = css::drawing::EnhancedCustomShapeSegmentCommand::LIGHTENLESS;
+                nParametersNeeded = 0;
+                nIndex++;
+            }
+            break;
+            case 'W' :
+            {
+                nLatestSegmentCommand = css::drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARCTO;
+                nParametersNeeded = 4;
+                nIndex++;
+            }
+            break;
+            case 'V' :
+            {
+                nLatestSegmentCommand = css::drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARC;
+                nParametersNeeded = 4;
+                nIndex++;
+            }
+            break;
+            case 'X' :
+            {
+                nLatestSegmentCommand = css::drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTX;
+                nParametersNeeded = 1;
+                nIndex++;
+            }
+            break;
+            case 'Y' :
+            {
+                nLatestSegmentCommand = css::drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTY;
+                nParametersNeeded = 1;
+                nIndex++;
+            }
+            break;
+            case 'Q' :
+            {
+                nLatestSegmentCommand = css::drawing::EnhancedCustomShapeSegmentCommand::QUADRATICCURVETO;
+                nParametersNeeded = 2;
+                nIndex++;
+            }
+            break;
+            case ' ' :
+            {
+                nIndex++;
+            }
+            break;
+
+            case '$' :
+            case '?' :
+            case '0' :
+            case '1' :
+            case '2' :
+            case '3' :
+            case '4' :
+            case '5' :
+            case '6' :
+            case '7' :
+            case '8' :
+            case '9' :
+            case '.' :
+            case '-' :
+            {
+                css::drawing::EnhancedCustomShapeParameterPair aPair;
+                if ( GetNextParameter( aPair.First, nIndex, rValue ) &&
+                        GetNextParameter( aPair.Second, nIndex, rValue ) )
+                {
+                    vCoordinates.push_back( aPair );
+                    nParameterCount++;
+                }
+                else
+                    bValid = false;
+            }
+            break;
+            default:
+                nIndex++;
+            break;
+        }
+        if ( !nParameterCount && !nParametersNeeded )
+        {
+            css::drawing::EnhancedCustomShapeSegment aSegment;
+            aSegment.Command = nLatestSegmentCommand;
+            aSegment.Count = 0;
+            vSegments.push_back( aSegment );
+            nParametersNeeded = 0x7fffffff;
+        }
+        else if ( nParameterCount >= nParametersNeeded )
+        {
+            // Special rule for moveto in ODF 1.2 section 19.145
+            // "If a moveto is followed by multiple pairs of coordinates, they are treated as lineto."
+            if ( nLatestSegmentCommand == css::drawing::EnhancedCustomShapeSegmentCommand::MOVETO )
+            {
+                css::drawing::EnhancedCustomShapeSegment aSegment;
+                aSegment.Command = css::drawing::EnhancedCustomShapeSegmentCommand::MOVETO;
+                aSegment.Count = 1;
+                vSegments.push_back( aSegment );
+                nIndex--;
+                nLatestSegmentCommand = css::drawing::EnhancedCustomShapeSegmentCommand::LINETO;
+                nParametersNeeded = 1;
+            }
+            else
+            {
+                // General rule in ODF 1.2. section 19.145
+                // "If a command is repeated multiple times, all repeated command characters
+                // except the first one may be omitted." Thus check if the last command is identical,
+                // if so, we just need to increment the count
+                if ( !vSegments.empty() && ( vSegments[ vSegments.size() - 1 ].Command == nLatestSegmentCommand ) )
+                    vSegments[ vSegments.size() -1 ].Count++;
+                else
+                {
+                    css::drawing::EnhancedCustomShapeSegment aSegment;
+                    aSegment.Command = nLatestSegmentCommand;
+                    aSegment.Count = 1;
+                    vSegments.push_back( aSegment );
+                }
+            }
+            nParameterCount = 0;
+        }
+    }
+
+    // Corrections for wrong paths in curvedArrow shapes written by older LO versions
+    if (!vSegments.empty()
+        && (rType == u"mso-spt102" || rType == u"mso-spt103" || rType == u"mso-spt104"
+            || rType == u"mso-spt105")
+        && vSegments[0].Count == 2)
+    {
+        vSegments[0].Count = 1;
+        css::drawing::EnhancedCustomShapeSegment aSegment;
+        aSegment.Count = 1;
+        aSegment.Command
+            = vSegments[0].Command == css::drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARC
+                  ? css::drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARCTO
+                  : css::drawing::EnhancedCustomShapeSegmentCommand::ARCTO;
+        vSegments.insert(vSegments.begin() + 1, aSegment);
+    }
+
+    // adding the Coordinates property
+    beans::PropertyValue aProp;
+    aProp.Name = EASGet( EAS_Coordinates );
+    aProp.Value <<= comphelper::containerToSequence(vCoordinates);
+    rDest.push_back( aProp );
+
+    // adding the Segments property
+    aProp.Name = EASGet( EAS_Segments );
+    aProp.Value <<= comphelper::containerToSequence(vSegments);
+    rDest.push_back( aProp );
+}
+
+static void GetAdjustmentValues( std::vector< css::beans::PropertyValue >& rDest,               // draw:adjustments
+                        const OUString& rValue )
+{
+    std::vector< css::drawing::EnhancedCustomShapeAdjustmentValue > vAdjustmentValue;
+    css::drawing::EnhancedCustomShapeParameter aParameter;
+    sal_Int32 nIndex = 0;
+    while ( GetNextParameter( aParameter, nIndex, rValue ) )
+    {
+        css::drawing::EnhancedCustomShapeAdjustmentValue aAdj;
+        if ( aParameter.Type == css::drawing::EnhancedCustomShapeParameterType::NORMAL )
+        {
+            aAdj.Value = aParameter.Value;
+            aAdj.State = beans::PropertyState_DIRECT_VALUE;
+        }
+        else
+            aAdj.State = beans::PropertyState_DEFAULT_VALUE;    // this should not be, but better than setting nothing
+
+        vAdjustmentValue.push_back( aAdj );
+    }
+
+    sal_Int32 nAdjustmentValues = vAdjustmentValue.size();
+    if ( nAdjustmentValues )
+    {
+        beans::PropertyValue aProp;
+        aProp.Name = EASGet( EAS_AdjustmentValues );
+        aProp.Value <<= comphelper::containerToSequence(vAdjustmentValue);
+        rDest.push_back( aProp );
+    }
+}
+
+void XMLEnhancedCustomShapeContext::startFastElement(
+    sal_Int32 /*nElement*/,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    sal_Int32               nAttrNumber;
+    std::optional<std::string_view> oSpecularityValue; // for postpone extrusion-specularity
+    std::optional<OUString> oPathValue; // for postpone GetEnhancedPath;
+    OUString sType("non-primitive"); // default in ODF
+    for( auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList) )
+    {
+        switch( EASGet( aIter.getToken() ) )
+        {
+            case EAS_type :
+            {
+                sType = aIter.toString();
+                GetString( mrCustomShapeGeometry, sType, EAS_Type );
+            }
+            break;
+            case EAS_mirror_horizontal :
+                GetBool( mrCustomShapeGeometry, aIter.toView(), EAS_MirroredX );
+            break;
+            case EAS_mirror_vertical :
+                GetBool( mrCustomShapeGeometry, aIter.toView(), EAS_MirroredY );
+            break;
+            case EAS_viewBox :
+            {
+                SdXMLImExViewBox aViewBox( aIter.toString(), GetImport().GetMM100UnitConverter() );
+                awt::Rectangle aRect( aViewBox.GetX(), aViewBox.GetY(), aViewBox.GetWidth(), aViewBox.GetHeight() );
+                beans::PropertyValue aProp;
+                aProp.Name = EASGet( EAS_ViewBox );
+                aProp.Value <<= aRect;
+                mrCustomShapeGeometry.push_back( aProp );
+            }
+            break;
+            case EAS_sub_view_size:
+                GetSizeSequence( maPath, aIter.toView(), EAS_SubViewSize );
+            break;
+            case EAS_text_rotate_angle :
+                GetDouble( mrCustomShapeGeometry, aIter.toView(), EAS_TextRotateAngle );
+            break;
+            case EAS_extrusion_allowed :
+                GetBool( maPath, aIter.toView(), EAS_ExtrusionAllowed );
+            break;
+            case EAS_text_path_allowed :
+                GetBool( maPath, aIter.toView(), EAS_TextPathAllowed );
+            break;
+            case EAS_concentric_gradient_fill_allowed :
+                GetBool( maPath, aIter.toView(), EAS_ConcentricGradientFillAllowed );
+            break;
+            case EAS_extrusion :
+                GetBool( maExtrusion, aIter.toView(), EAS_Extrusion );
+            break;
+            case EAS_extrusion_brightness :
+                GetDoublePercentage( maExtrusion, aIter.toView(), EAS_Brightness );
+            break;
+            case EAS_extrusion_depth :
+            {
+                OUString rValue = aIter.toString();
+                sal_Int32 nIndex = 0;
+                css::drawing::EnhancedCustomShapeParameterPair aParameterPair;
+                css::drawing::EnhancedCustomShapeParameter& rDepth = aParameterPair.First;
+                if ( GetNextParameter( rDepth, nIndex, rValue ) )
+                {
+                    css::drawing::EnhancedCustomShapeParameter& rFraction = aParameterPair.Second;
+                    // try to catch the unit for the depth
+                    sal_Int16 const eSrcUnit(
+                        ::sax::Converter::GetUnitFromString(
+                            rValue, util::MeasureUnit::MM_100TH));
+
+                    OUStringBuffer aUnitStr;
+                    double fFactor = ::sax::Converter::GetConversionFactor(
+                        aUnitStr, util::MeasureUnit::MM_100TH, eSrcUnit);
+                    if ( ( fFactor != 1.0 ) && ( fFactor != 0.0 ) )
+                    {
+                        double fDepth(0.0);
+                        if ( rDepth.Value >>= fDepth )
+                        {
+                            fDepth /= fFactor;
+                            rDepth.Value <<= fDepth;
+                        }
+                    }
+                    if ( rValue.matchIgnoreAsciiCase( aUnitStr, nIndex ) )
+                        nIndex += aUnitStr.getLength();
+
+                    // skipping white spaces
+                    while( ( nIndex < rValue.getLength() ) && rValue[ nIndex ] == ' ' )
+                        nIndex++;
+
+                    if ( GetNextParameter( rFraction, nIndex, rValue ) )
+                    {
+                        beans::PropertyValue aProp;
+                        aProp.Name = EASGet( EAS_Depth );
+                        aProp.Value <<= aParameterPair;
+                        maExtrusion.push_back( aProp );
+                    }
+                }
+            }
+            break;
+            case EAS_extrusion_diffusion :
+                GetDoublePercentage( maExtrusion, aIter.toView(), EAS_Diffusion );
+            break;
+            case EAS_extrusion_number_of_line_segments :
+                GetInt32( maExtrusion, aIter.toView(), EAS_NumberOfLineSegments );
+            break;
+            case EAS_extrusion_light_face :
+                GetBool( maExtrusion, aIter.toView(), EAS_LightFace );
+            break;
+            case EAS_extrusion_first_light_harsh :
+                GetBool( maExtrusion, aIter.toView(), EAS_FirstLightHarsh );
+            break;
+            case EAS_extrusion_second_light_harsh :
+                GetBool( maExtrusion, aIter.toView(), EAS_SecondLightHarsh );
+            break;
+            case EAS_extrusion_first_light_level :
+                GetDoublePercentage( maExtrusion, aIter.toView(), EAS_FirstLightLevel );
+            break;
+            case EAS_extrusion_second_light_level :
+                GetDoublePercentage( maExtrusion, aIter.toView(), EAS_SecondLightLevel );
+            break;
+            case EAS_extrusion_first_light_direction :
+                GetB3DVector( maExtrusion, aIter.toView(), EAS_FirstLightDirection );
+            break;
+            case EAS_extrusion_second_light_direction :
+                GetB3DVector( maExtrusion, aIter.toView(), EAS_SecondLightDirection );
+            break;
+            case EAS_extrusion_metal :
+                GetBool( maExtrusion, aIter.toView(), EAS_Metal );
+            break;
+            case EAS_extrusion_metal_type :
+            {
+                OUString rValue = aIter.toString();
+                sal_Int16 eMetalType(drawing::EnhancedCustomShapeMetalType::MetalODF);
+                if (rValue == "loext:MetalMSCompatible")
+                    eMetalType = drawing::EnhancedCustomShapeMetalType::MetalMSCompatible;
+                beans::PropertyValue aProp;
+                aProp.Name = EASGet(EAS_MetalType);
+                aProp.Value <<= eMetalType;
+                maExtrusion.push_back(aProp);
+            }
+            break;
+            case EAS_shade_mode :
+            {
+                drawing::ShadeMode eShadeMode( drawing::ShadeMode_FLAT );
+                if( IsXMLToken( aIter, XML_PHONG ) )
+                    eShadeMode = drawing::ShadeMode_PHONG;
+                else if ( IsXMLToken( aIter, XML_GOURAUD ) )
+                    eShadeMode = drawing::ShadeMode_SMOOTH;
+                else if ( IsXMLToken( aIter, XML_DRAFT ) )
+                    eShadeMode = drawing::ShadeMode_DRAFT;
+
+                beans::PropertyValue aProp;
+                aProp.Name = EASGet( EAS_ShadeMode );
+                aProp.Value <<= eShadeMode;
+                maExtrusion.push_back( aProp );
+            }
+            break;
+            case EAS_extrusion_rotation_angle :
+                GetEnhancedParameterPair( maExtrusion, aIter.toString(), EAS_RotateAngle );
+            break;
+            case EAS_extrusion_rotation_center :
+                GetB3DVector( maExtrusion, aIter.toView(), EAS_RotationCenter );
+            break;
+            case EAS_extrusion_shininess :
+                GetDoublePercentage( maExtrusion, aIter.toView(), EAS_Shininess );
+            break;
+            case EAS_extrusion_skew :
+                GetEnhancedParameterPair( maExtrusion, aIter.toString(), EAS_Skew );
+            break;
+            case EAS_extrusion_specularity :
+                if (!oSpecularityValue)
+                    oSpecularityValue = aIter.toView();
+            break;
+            case EAS_extrusion_specularity_loext :
+                oSpecularityValue = aIter.toView();
+            break;
+            case EAS_projection :
+            {
+                drawing::ProjectionMode eProjectionMode( drawing::ProjectionMode_PERSPECTIVE );
+                if( IsXMLToken( aIter, XML_PARALLEL ) )
+                    eProjectionMode = drawing::ProjectionMode_PARALLEL;
+
+                beans::PropertyValue aProp;
+                aProp.Name = EASGet( EAS_ProjectionMode );
+                aProp.Value <<= eProjectionMode;
+                maExtrusion.push_back( aProp );
+            }
+            break;
+            case EAS_extrusion_viewpoint :
+                GetPosition3D( maExtrusion, aIter.toView(), EAS_ViewPoint, mrUnitConverter );
+            break;
+            case EAS_extrusion_origin :
+                GetEnhancedParameterPair( maExtrusion, aIter.toString(), EAS_Origin );
+            break;
+            case EAS_extrusion_color :
+                GetBool( maExtrusion, aIter.toView(), EAS_Color );
+            break;
+            case EAS_enhanced_path :
+                oPathValue = aIter.toString();
+            break;
+            case EAS_path_stretchpoint_x :
+            {
+                if (::sax::Converter::convertNumber(nAttrNumber, aIter.toView()))
+                {
+                    beans::PropertyValue aProp;
+                    aProp.Name = EASGet( EAS_StretchX );
+                    aProp.Value <<= nAttrNumber;
+                    maPath.push_back( aProp );
+                }
+            }
+            break;
+            case EAS_path_stretchpoint_y :
+            {
+                if (::sax::Converter::convertNumber(nAttrNumber, aIter.toView()))
+                {
+                    beans::PropertyValue aProp;
+                    aProp.Name = EASGet( EAS_StretchY );
+                    aProp.Value <<= nAttrNumber;
+                    maPath.push_back( aProp );
+                }
+            }
+            break;
+            case EAS_text_areas :
+                GetEnhancedRectangleSequence( maPath, aIter.toString(), EAS_TextFrames );
+            break;
+            case EAS_glue_points :
+            {
+                sal_Int32 i, nPairs = GetEnhancedParameterPairSequence( maPath, aIter.toString(), EAS_GluePoints );
+                GetImport().GetShapeImport()->moveGluePointMapping( mrxShape, nPairs );
+                for ( i = 0; i < nPairs; i++ )
+                    GetImport().GetShapeImport()->addGluePointMapping( mrxShape, i + 4, i + 4 );
+            }
+            break;
+            case EAS_glue_point_type :
+                GetEnum( maPath, aIter.toView(), EAS_GluePointType, *aXML_GluePointEnumMap );
+            break;
+            case EAS_glue_point_leaving_directions :
+                GetDoubleSequence( maPath, aIter.toView(), EAS_GluePointLeavingDirections );
+            break;
+            case EAS_text_path :
+                GetBool( maTextPath, aIter.toView(), EAS_TextPath );
+            break;
+            case EAS_text_path_mode :
+            {
+                css::drawing::EnhancedCustomShapeTextPathMode eTextPathMode( css::drawing::EnhancedCustomShapeTextPathMode_NORMAL );
+                if( IsXMLToken( aIter, XML_PATH ) )
+                    eTextPathMode = css::drawing::EnhancedCustomShapeTextPathMode_PATH;
+                else if ( IsXMLToken( aIter, XML_SHAPE ) )
+                    eTextPathMode = css::drawing::EnhancedCustomShapeTextPathMode_SHAPE;
+
+                beans::PropertyValue aProp;
+                aProp.Name = EASGet( EAS_TextPathMode );
+                aProp.Value <<= eTextPathMode;
+                maTextPath.push_back( aProp );
+            }
+            break;
+            case EAS_text_path_scale :
+            {
+                bool bScaleX = IsXMLToken( aIter, XML_SHAPE );
+                beans::PropertyValue aProp;
+                aProp.Name = EASGet( EAS_ScaleX );
+                aProp.Value <<= bScaleX;
+                maTextPath.push_back( aProp );
+            }
+            break;
+            case EAS_text_path_same_letter_heights :
+                GetBool( maTextPath, aIter.toView(), EAS_SameLetterHeights );
+            break;
+            case EAS_modifiers :
+                GetAdjustmentValues( mrCustomShapeGeometry, aIter.toString() );
+            break;
+            default:
+                break;
+        }
+    }
+    if (oSpecularityValue)
+        GetDoublePercentage( maExtrusion, *oSpecularityValue, EAS_Specularity );
+    if (oPathValue)
+        GetEnhancedPath(maPath, *oPathValue, sType);
+}
+
+static void SdXMLCustomShapePropertyMerge( std::vector< css::beans::PropertyValue >& rPropVec,
+                                    const std::vector< beans::PropertyValues >& rElement,
+                                        const OUString& rElementName )
+{
+    if ( !rElement.empty() )
+    {
+        beans::PropertyValue aProp;
+        aProp.Name = rElementName;
+        aProp.Value <<= comphelper::containerToSequence(rElement);
+        rPropVec.push_back( aProp );
+    }
+}
+
+static void SdXMLCustomShapePropertyMerge( std::vector< css::beans::PropertyValue >& rPropVec,
+                                    const std::vector< OUString >& rElement,
+                                        const OUString& rElementName )
+{
+    if ( !rElement.empty() )
+    {
+        beans::PropertyValue aProp;
+        aProp.Name = rElementName;
+        aProp.Value <<= comphelper::containerToSequence(rElement);
+        rPropVec.push_back( aProp );
+    }
+}
+
+static void SdXMLCustomShapePropertyMerge( std::vector< css::beans::PropertyValue >& rPropVec,
+                                    const std::vector< css::beans::PropertyValue >& rElement,
+                                        const OUString& rElementName )
+{
+    if ( !rElement.empty() )
+    {
+        beans::PropertyValue aProp;
+        aProp.Name = rElementName;
+        aProp.Value <<= comphelper::containerToSequence(rElement);
+        rPropVec.push_back( aProp );
+    }
+}
+
+typedef std::unordered_map< OUString, sal_Int32 > EquationHashMap;
+
+/* if rPara.Type is from type EnhancedCustomShapeParameterType::EQUATION, the name of the equation
+   will be converted from OUString to index */
+static void CheckAndResolveEquationParameter( css::drawing::EnhancedCustomShapeParameter& rPara, EquationHashMap* pH )
+{
+    if ( rPara.Type == css::drawing::EnhancedCustomShapeParameterType::EQUATION )
+    {
+        OUString aEquationName;
+        if ( rPara.Value >>= aEquationName )
+        {
+            sal_Int32 nIndex = 0;
+            EquationHashMap::iterator aHashIter( pH->find( aEquationName ) );
+            if ( aHashIter != pH->end() )
+                nIndex = (*aHashIter).second;
+            rPara.Value <<= nIndex;
+        }
+    }
+}
+
+void XMLEnhancedCustomShapeContext::endFastElement(sal_Int32 )
+{
+    // resolve properties that are indexing an Equation
+    if ( !maEquations.empty() )
+    {
+        // creating hash map containing the name and index of each equation
+        EquationHashMap aH;
+        std::vector< OUString >::iterator aEquationNameIter = maEquationNames.begin();
+        std::vector< OUString >::iterator aEquationNameEnd  = maEquationNames.end();
+        while( aEquationNameIter != aEquationNameEnd )
+        {
+            aH[ *aEquationNameIter ] = static_cast<sal_Int32>( aEquationNameIter - maEquationNames.begin() );
+            ++aEquationNameIter;
+        }
+
+        // resolve equation
+        for( auto& rEquation : maEquations )
+        {
+            sal_Int32 nIndexOf = 0;
+            do
+            {
+                nIndexOf = rEquation.indexOf( '?', nIndexOf );
+                if ( nIndexOf != -1 )
+                {
+                    OUString aEquationName;
+                    if ( GetEquationName( rEquation, nIndexOf + 1, aEquationName ) )
+                    {
+                        // copying first characters inclusive '?'
+                        sal_Int32 nIndex = 0;
+                        EquationHashMap::iterator aHashIter( aH.find( aEquationName ) );
+                        if ( aHashIter != aH.end() )
+                            nIndex = (*aHashIter).second;
+                        OUString aNew = rEquation.subView( 0, nIndexOf + 1 ) +
+                            OUString::number( nIndex ) +
+                            rEquation.subView( nIndexOf + aEquationName.getLength() + 1 );
+                        rEquation = aNew;
+                    }
+                    nIndexOf++;
+                }
+            }
+            while( nIndexOf != -1 );
+        }
+
+        // Path
+        for ( const beans::PropertyValue& rPathItem : maPath )
+        {
+            switch( EASGet( rPathItem.Name ) )
+            {
+                case EAS_Coordinates :
+                case EAS_GluePoints :
+                {
+                    uno::Sequence< css::drawing::EnhancedCustomShapeParameterPair > const & rSeq =
+                        *o3tl::doAccess<uno::Sequence< css::drawing::EnhancedCustomShapeParameterPair > >(
+                            rPathItem.Value);
+                    for ( const auto& rElem : rSeq )
+                    {
+                        CheckAndResolveEquationParameter( const_cast<css::drawing::EnhancedCustomShapeParameter &>(rElem.First), &aH );
+                        CheckAndResolveEquationParameter( const_cast<css::drawing::EnhancedCustomShapeParameter &>(rElem.Second), &aH );
+                    }
+                }
+                break;
+                case EAS_TextFrames :
+                {
+                    uno::Sequence< css::drawing::EnhancedCustomShapeTextFrame > const & rSeq =
+                        *o3tl::doAccess<uno::Sequence< css::drawing::EnhancedCustomShapeTextFrame > >(
+                            rPathItem.Value);
+                    for ( const auto& rElem : rSeq )
+                    {
+                        CheckAndResolveEquationParameter( const_cast<css::drawing::EnhancedCustomShapeParameter &>(rElem.TopLeft.First), &aH );
+                        CheckAndResolveEquationParameter( const_cast<css::drawing::EnhancedCustomShapeParameter &>(rElem.TopLeft.Second), &aH );
+                        CheckAndResolveEquationParameter( const_cast<css::drawing::EnhancedCustomShapeParameter &>(rElem.BottomRight.First), &aH );
+                        CheckAndResolveEquationParameter( const_cast<css::drawing::EnhancedCustomShapeParameter &>(rElem.BottomRight.Second), &aH );
+                    }
+                }
+                break;
+                default:
+                    break;
+            }
+        }
+        for ( css::beans::PropertyValues const & aHandle : maHandles )
+        {
+            for ( beans::PropertyValue const & propValue : aHandle )
+            {
+                switch( EASGet( propValue.Name ) )
+                {
+                    case EAS_RangeYMinimum :
+                    case EAS_RangeYMaximum :
+                    case EAS_RangeXMinimum :
+                    case EAS_RangeXMaximum :
+                    case EAS_RadiusRangeMinimum :
+                    case EAS_RadiusRangeMaximum :
+                    {
+                        CheckAndResolveEquationParameter( const_cast<css::drawing::EnhancedCustomShapeParameter &>(*o3tl::doAccess<css::drawing::EnhancedCustomShapeParameter>(
+                            propValue.Value)), &aH );
+                    }
+                    break;
+
+                    case EAS_Position :
+                    case EAS_Polar :
+                    {
+                        CheckAndResolveEquationParameter( const_cast<css::drawing::EnhancedCustomShapeParameter &>((*o3tl::doAccess<css::drawing::EnhancedCustomShapeParameterPair>(
+                            propValue.Value)).First), &aH );
+                        CheckAndResolveEquationParameter( const_cast<css::drawing::EnhancedCustomShapeParameter &>((*o3tl::doAccess<css::drawing::EnhancedCustomShapeParameterPair>(
+                            propValue.Value)).Second), &aH );
+                    }
+                    break;
+                    default:
+                        break;
+                }
+            }
+        }
+    }
+
+    SdXMLCustomShapePropertyMerge( mrCustomShapeGeometry, maExtrusion, EASGet( EAS_Extrusion ) );
+    SdXMLCustomShapePropertyMerge( mrCustomShapeGeometry, maPath,      EASGet( EAS_Path ) );
+    SdXMLCustomShapePropertyMerge( mrCustomShapeGeometry, maTextPath,  EASGet( EAS_TextPath ) );
+    SdXMLCustomShapePropertyMerge( mrCustomShapeGeometry, maEquations, EASGet( EAS_Equations ) );
+    if  ( !maHandles.empty() )
+        SdXMLCustomShapePropertyMerge( mrCustomShapeGeometry, maHandles, EASGet( EAS_Handles ) );
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > XMLEnhancedCustomShapeContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    EnhancedCustomShapeTokenEnum aTokenEnum = EASGet( nElement );
+    if ( aTokenEnum == EAS_equation )
+    {
+        OUString aFormula;
+        OUString aFormulaName;
+        for( auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList) )
+        {
+            OUString sValue = aIter.toString();
+            switch( EASGet( aIter.getToken() ) )
+            {
+                case EAS_formula :
+                    aFormula = sValue;
+                break;
+                case EAS_name :
+                    aFormulaName = sValue;
+                break;
+                default:
+                    break;
+            }
+        }
+        if ( !aFormulaName.isEmpty() || !aFormula.isEmpty() )
+        {
+            maEquations.push_back( aFormula );
+            maEquationNames.push_back( aFormulaName );
+        }
+    }
+    else if ( aTokenEnum == EAS_handle )
+    {
+        std::vector< css::beans::PropertyValue > aHandle;
+        for( auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList) )
+        {
+            switch( EASGet( aIter.getToken() ) )
+            {
+                case EAS_handle_mirror_vertical :
+                    GetBool( aHandle, aIter.toView(), EAS_MirroredY );
+                break;
+                case EAS_handle_mirror_horizontal :
+                    GetBool( aHandle, aIter.toView(), EAS_MirroredX );
+                break;
+                case EAS_handle_switched :
+                    GetBool( aHandle, aIter.toView(), EAS_Switched );
+                break;
+                case EAS_handle_position :
+                    GetEnhancedParameterPair( aHandle, aIter.toString(), EAS_Position );
+                break;
+                case EAS_handle_range_x_minimum :
+                    GetEnhancedParameter( aHandle, aIter.toString(), EAS_RangeXMinimum );
+                break;
+                case EAS_handle_range_x_maximum :
+                    GetEnhancedParameter( aHandle, aIter.toString(), EAS_RangeXMaximum );
+                break;
+                case EAS_handle_range_y_minimum :
+                    GetEnhancedParameter( aHandle, aIter.toString(), EAS_RangeYMinimum );
+                break;
+                case EAS_handle_range_y_maximum :
+                    GetEnhancedParameter( aHandle, aIter.toString(), EAS_RangeYMaximum );
+                break;
+                case EAS_handle_polar :
+                    GetEnhancedParameterPair( aHandle, aIter.toString(), EAS_Polar );
+                break;
+                case EAS_handle_radius_range_minimum :
+                    GetEnhancedParameter( aHandle, aIter.toString(), EAS_RadiusRangeMinimum );
+                break;
+                case EAS_handle_radius_range_maximum :
+                    GetEnhancedParameter( aHandle, aIter.toString(), EAS_RadiusRangeMaximum );
+                break;
+                default:
+                    break;
+            }
+        }
+        maHandles.push_back( comphelper::containerToSequence(aHandle) );
+    }
+    return nullptr;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/ximpcustomshape.hxx b/xmloff/source/draw/ximpcustomshape.hxx
new file mode 100644
index 000000000..f7e14765a
--- /dev/null
+++ b/xmloff/source/draw/ximpcustomshape.hxx
@@ -0,0 +1,66 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlictxt.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <rtl/ustring.hxx>
+#include <vector>
+#include <com/sun/star/uno/Reference.h>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/beans/PropertyValues.hpp>
+#include <com/sun/star/drawing/XShape.hpp>
+
+namespace com::sun::star {
+    namespace container { class XIndexContainer; }
+    namespace beans { class XPropertySet; }
+    namespace xml::sax { class XAttributeList; }
+}
+
+class XMLEnhancedCustomShapeContext : public SvXMLImportContext
+{
+    SvXMLUnitConverter& mrUnitConverter;
+    css::uno::Reference< css::drawing::XShape >& mrxShape;
+    std::vector< css::beans::PropertyValue >& mrCustomShapeGeometry;
+
+    std::vector< css::beans::PropertyValue > maExtrusion;
+    std::vector< css::beans::PropertyValue > maPath;
+    std::vector< css::beans::PropertyValue > maTextPath;
+    std::vector< css::beans::PropertyValues > maHandles;
+    std::vector< OUString > maEquations;
+    std::vector< OUString > maEquationNames;
+
+public:
+
+
+    XMLEnhancedCustomShapeContext( SvXMLImport& rImport, css::uno::Reference< css::drawing::XShape > &,
+        std::vector< css::beans::PropertyValue >& rCustomShapeGeometry );
+
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/ximpgrp.cxx b/xmloff/source/draw/ximpgrp.cxx
new file mode 100644
index 000000000..c9cf7e218
--- /dev/null
+++ b/xmloff/source/draw/ximpgrp.cxx
@@ -0,0 +1,100 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include<xmloff/xmlnamespace.hxx>
+#include "ximpgrp.hxx"
+#include <xmloff/xmltoken.hxx>
+#include "ximpshap.hxx"
+#include "eventimp.hxx"
+#include "descriptionimp.hxx"
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+
+SdXMLGroupShapeContext::SdXMLGroupShapeContext(
+    SvXMLImport& rImport,
+    const uno::Reference< xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes,
+    bool bTemporaryShape)
+:   SdXMLShapeContext( rImport, xAttrList, rShapes, bTemporaryShape )
+{
+}
+
+SdXMLGroupShapeContext::~SdXMLGroupShapeContext()
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLGroupShapeContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    // #i68101#
+    if( nElement == XML_ELEMENT(SVG, XML_TITLE) ||
+        nElement == XML_ELEMENT(SVG, XML_DESC ) ||
+        nElement == XML_ELEMENT(SVG_COMPAT, XML_TITLE) ||
+        nElement == XML_ELEMENT(SVG_COMPAT, XML_DESC ) )
+    {
+        return new SdXMLDescriptionContext( GetImport(), nElement, mxShape );
+    }
+    else if( nElement == XML_ELEMENT(OFFICE, XML_EVENT_LISTENERS) )
+    {
+        return new SdXMLEventsContext( GetImport(), mxShape );
+    }
+    else if( nElement == XML_ELEMENT(DRAW, XML_GLUE_POINT) )
+    {
+        addGluePoint( xAttrList );
+    }
+    else
+    {
+        // call GroupChildContext function at common ShapeImport
+        return XMLShapeImportHelper::CreateGroupChildContext(
+            GetImport(), nElement, xAttrList, mxChildren);
+    }
+    return nullptr;
+}
+
+void SdXMLGroupShapeContext::startFastElement (sal_Int32 /*nElement*/,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& /*xAttrList*/)
+{
+    // create new group shape and add it to rShapes, use it
+    // as base for the new group import
+    AddShape( "com.sun.star.drawing.GroupShape" );
+
+    if(mxShape.is())
+    {
+        SetStyle( false );
+
+        mxChildren.set( mxShape, uno::UNO_QUERY );
+        if( mxChildren.is() )
+            GetImport().GetShapeImport()->pushGroupForPostProcessing( mxChildren );
+    }
+
+    GetImport().GetShapeImport()->finishShape( mxShape, mxAttrList, mxShapes );
+}
+
+void SdXMLGroupShapeContext::endFastElement(sal_Int32 nElement)
+{
+    if( mxChildren.is() )
+        GetImport().GetShapeImport()->popGroupAndPostProcess();
+
+    SdXMLShapeContext::endFastElement(nElement);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/ximpgrp.hxx b/xmloff/source/draw/ximpgrp.hxx
new file mode 100644
index 000000000..8dda1b9ba
--- /dev/null
+++ b/xmloff/source/draw/ximpgrp.hxx
@@ -0,0 +1,49 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlictxt.hxx>
+#include <com/sun/star/drawing/XShapes.hpp>
+#include "ximpshap.hxx"
+
+// draw:g context (RECURSIVE)
+
+class SdXMLGroupShapeContext : public SdXMLShapeContext
+{
+    // the shape group this group is working on
+    css::uno::Reference< css::drawing::XShapes > mxChildren;
+
+public:
+
+    SdXMLGroupShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes,
+        bool bTemporaryShape);
+    virtual ~SdXMLGroupShapeContext() override;
+
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/ximplink.cxx b/xmloff/source/draw/ximplink.cxx
new file mode 100644
index 000000000..41b236cc8
--- /dev/null
+++ b/xmloff/source/draw/ximplink.cxx
@@ -0,0 +1,66 @@
+/* -*- 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/log.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include "ximplink.hxx"
+#include <xmloff/xmltoken.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+
+SdXMLShapeLinkContext::SdXMLShapeLinkContext( SvXMLImport& rImport, const uno::Reference< xml::sax::XFastAttributeList>& xAttrList, uno::Reference< drawing::XShapes > const & rShapes)
+: SvXMLShapeContext( rImport, false )
+, mxParent( rShapes )
+{
+    for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+    {
+        if( aIter.getToken() == XML_ELEMENT(XLINK, XML_HREF) )
+        {
+            assert(msHyperlink.pData);
+            msHyperlink = aIter.toString();
+        }
+        else
+            XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+    }
+}
+
+SdXMLShapeLinkContext::~SdXMLShapeLinkContext()
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLShapeLinkContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    SvXMLShapeContext* pContext = XMLShapeImportHelper::CreateGroupChildContext( GetImport(), nElement, xAttrList, mxParent);
+
+    if( pContext )
+    {
+        pContext->setHyperlink( msHyperlink );
+        return pContext;
+    }
+
+    return nullptr;
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/ximplink.hxx b/xmloff/source/draw/ximplink.hxx
new file mode 100644
index 000000000..cd5259154
--- /dev/null
+++ b/xmloff/source/draw/ximplink.hxx
@@ -0,0 +1,47 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlictxt.hxx>
+#include <xmloff/shapeimport.hxx>
+#include <com/sun/star/drawing/XShapes.hpp>
+
+// draw:a context
+
+// this should have been a SvXMLImportContext but CreateGroupChildContext() returns
+// an unneeded derivation. Should be changed sometime during refactoring.
+
+class SdXMLShapeLinkContext : public SvXMLShapeContext
+{
+    // the parent shape group this link is placed in
+    css::uno::Reference< css::drawing::XShapes > mxParent;
+
+public:
+
+    SdXMLShapeLinkContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes);
+    virtual ~SdXMLShapeLinkContext() override;
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/ximpnote.cxx b/xmloff/source/draw/ximpnote.cxx
new file mode 100644
index 000000000..d855e85bf
--- /dev/null
+++ b/xmloff/source/draw/ximpnote.cxx
@@ -0,0 +1,92 @@
+/* -*- 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 "ximpnote.hxx"
+#include <xmloff/xmlnamespace.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+SdXMLNotesContext::SdXMLNotesContext(
+    SdXMLImport& rImport, const css::uno::Reference<css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference<drawing::XShapes> const& rShapes)
+    : SdXMLGenericPageContext(rImport, xAttrList, rShapes)
+{
+    OUString sStyleName, sPageMasterName;
+
+    for (auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList))
+    {
+        OUString sValue = aIter.toString();
+        switch (aIter.getToken())
+        {
+            case XML_ELEMENT(STYLE, XML_PAGE_LAYOUT_NAME):
+            {
+                sPageMasterName = sValue;
+                break;
+            }
+            case XML_ELEMENT(DRAW, XML_STYLE_NAME):
+            {
+                sStyleName = sValue;
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_USE_HEADER_NAME):
+            case XML_ELEMENT(PRESENTATION_SO52, XML_USE_HEADER_NAME):
+            case XML_ELEMENT(PRESENTATION_OOO, XML_USE_HEADER_NAME):
+            {
+                maUseHeaderDeclName = sValue;
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_USE_FOOTER_NAME):
+            case XML_ELEMENT(PRESENTATION_SO52, XML_USE_FOOTER_NAME):
+            case XML_ELEMENT(PRESENTATION_OOO, XML_USE_FOOTER_NAME):
+            {
+                maUseFooterDeclName = sValue;
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_USE_DATE_TIME_NAME):
+            case XML_ELEMENT(PRESENTATION_SO52, XML_USE_DATE_TIME_NAME):
+            case XML_ELEMENT(PRESENTATION_OOO, XML_USE_DATE_TIME_NAME):
+            {
+                maUseDateTimeDeclName = sValue;
+                break;
+            }
+        }
+    }
+
+    SetStyle(sStyleName);
+
+    // now delete all up-to-now contained shapes from this notes page
+    uno::Reference<drawing::XShape> xShape;
+    while (rShapes->getCount())
+    {
+        rShapes->getByIndex(0) >>= xShape;
+        if (xShape.is())
+            rShapes->remove(xShape);
+    }
+
+    // set page-master?
+    if (!sPageMasterName.isEmpty())
+    {
+        SetPageMaster(sPageMasterName);
+    }
+}
+
+SdXMLNotesContext::~SdXMLNotesContext() {}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/ximpnote.hxx b/xmloff/source/draw/ximpnote.hxx
new file mode 100644
index 000000000..d7fe276b8
--- /dev/null
+++ b/xmloff/source/draw/ximpnote.hxx
@@ -0,0 +1,36 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include "sdxmlimp_impl.hxx"
+#include "ximppage.hxx"
+
+// presentation:notes context
+
+class SdXMLNotesContext : public SdXMLGenericPageContext
+{
+public:
+    SdXMLNotesContext( SdXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes);
+    virtual ~SdXMLNotesContext() override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/ximppage.cxx b/xmloff/source/draw/ximppage.cxx
new file mode 100644
index 000000000..3d5cdf006
--- /dev/null
+++ b/xmloff/source/draw/ximppage.cxx
@@ -0,0 +1,600 @@
+/* -*- 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 <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/geometry/RealPoint2D.hpp>
+#include <com/sun/star/text/XTextCursor.hpp>
+#include <com/sun/star/util/DateTime.hpp>
+#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <cppuhelper/implbase.hxx>
+#include <sax/tools/converter.hxx>
+#include <XMLNumberStylesImport.hxx>
+#include <xmloff/xmlstyle.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include "ximppage.hxx"
+#include <animimp.hxx>
+#include <XMLStringBufferImportContext.hxx>
+#include <xmloff/xmlictxt.hxx>
+#include "ximpstyl.hxx"
+#include <xmloff/prstylei.hxx>
+#include <PropertySetMerger.hxx>
+#include <sal/log.hxx>
+#include <tools/diagnose_ex.h>
+
+#include <xmloff/unointerfacetouniqueidentifiermapper.hxx>
+#include <xmloff/xmluconv.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::text;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::drawing;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::office;
+using namespace ::com::sun::star::xml::sax;
+using namespace ::com::sun::star::geometry;
+
+namespace {
+
+class DrawAnnotationContext : public SvXMLImportContext
+{
+
+public:
+    DrawAnnotationContext( SvXMLImport& rImport, const Reference< xml::sax::XFastAttributeList>& xAttrList, const Reference< XAnnotationAccess >& xAnnotationAccess );
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+
+private:
+    Reference< XAnnotation > mxAnnotation;
+    Reference< XTextCursor > mxCursor;
+
+    OUStringBuffer maAuthorBuffer;
+    OUStringBuffer maInitialsBuffer;
+    OUStringBuffer maDateBuffer;
+};
+
+}
+
+DrawAnnotationContext::DrawAnnotationContext( SvXMLImport& rImport, const Reference< xml::sax::XFastAttributeList>& xAttrList, const Reference< XAnnotationAccess >& xAnnotationAccess )
+: SvXMLImportContext( rImport )
+, mxAnnotation( xAnnotationAccess->createAndInsertAnnotation() )
+{
+    if( !mxAnnotation.is() )
+        return;
+
+    RealPoint2D aPosition;
+    RealSize2D aSize;
+
+    for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+    {
+        switch( aIter.getToken() )
+        {
+            case XML_ELEMENT(SVG, XML_X):
+            case XML_ELEMENT(SVG_COMPAT, XML_X):
+            {
+                sal_Int32 x;
+                GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                        x, aIter.toView());
+                aPosition.X = static_cast<double>(x) / 100.0;
+                break;
+            }
+            case XML_ELEMENT(SVG, XML_Y):
+            case XML_ELEMENT(SVG_COMPAT, XML_Y):
+            {
+                sal_Int32 y;
+                GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                        y, aIter.toView());
+                aPosition.Y = static_cast<double>(y) / 100.0;
+                break;
+            }
+            case XML_ELEMENT(SVG, XML_WIDTH):
+            case XML_ELEMENT(SVG_COMPAT, XML_WIDTH):
+            {
+                sal_Int32 w;
+                GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                        w, aIter.toView());
+                aSize.Width = static_cast<double>(w) / 100.0;
+                break;
+            }
+            case XML_ELEMENT(SVG, XML_HEIGHT):
+            case XML_ELEMENT(SVG_COMPAT, XML_HEIGHT):
+            {
+                sal_Int32 h;
+                GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                        h, aIter.toView());
+                aSize.Height = static_cast<double>(h) / 100.0;
+            }
+            break;
+            default:
+                XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+        }
+    }
+
+    mxAnnotation->setPosition( aPosition );
+    mxAnnotation->setSize( aSize );
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > DrawAnnotationContext::createFastChildContext(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    if( mxAnnotation.is() )
+    {
+        if (nElement == XML_ELEMENT(DC, XML_CREATOR) )
+            return new XMLStringBufferImportContext(GetImport(), maAuthorBuffer);
+        else if( nElement == XML_ELEMENT(DC, XML_DATE) )
+            return new XMLStringBufferImportContext(GetImport(), maDateBuffer);
+        else if ( nElement == XML_ELEMENT(TEXT, XML_SENDER_INITIALS)
+                || nElement == XML_ELEMENT(LO_EXT, XML_SENDER_INITIALS)
+                || nElement == XML_ELEMENT(META, XML_CREATOR_INITIALS))
+        {
+            return new XMLStringBufferImportContext(GetImport(), maInitialsBuffer);
+        }
+        else
+        {
+            // create text cursor on demand
+            if( !mxCursor.is() )
+            {
+                uno::Reference< text::XText > xText( mxAnnotation->getTextRange() );
+                if( xText.is() )
+                {
+                    rtl::Reference < XMLTextImportHelper > xTxtImport = GetImport().GetTextImport();
+                    mxCursor = xText->createTextCursor();
+                    if( mxCursor.is() )
+                        xTxtImport->SetCursor( mxCursor );
+                }
+            }
+
+            // if we have a text cursor, lets  try to import some text
+            if( mxCursor.is() )
+            {
+                auto p = GetImport().GetTextImport()->CreateTextChildContext( GetImport(), nElement, xAttrList );
+                if (p)
+                    return p;
+            }
+        }
+    }
+    XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+    return nullptr;
+}
+
+void DrawAnnotationContext::endFastElement(sal_Int32)
+{
+    if(mxCursor.is())
+    {
+        // delete addition newline
+        mxCursor->gotoEnd( false );
+        mxCursor->goLeft( 1, true );
+        mxCursor->setString( "" );
+
+        // reset cursor
+        GetImport().GetTextImport()->ResetCursor();
+    }
+
+    if( mxAnnotation.is() )
+    {
+        mxAnnotation->setAuthor( maAuthorBuffer.makeStringAndClear() );
+        mxAnnotation->setInitials( maInitialsBuffer.makeStringAndClear() );
+
+        util::DateTime aDateTime;
+        if (::sax::Converter::parseDateTime(aDateTime, maDateBuffer))
+        {
+            mxAnnotation->setDateTime(aDateTime);
+        }
+        maDateBuffer.setLength(0);
+    }
+}
+
+
+SdXMLGenericPageContext::SdXMLGenericPageContext(
+    SvXMLImport& rImport,
+    const Reference< xml::sax::XFastAttributeList>& xAttrList,
+    Reference< drawing::XShapes > const & rShapes)
+: SvXMLImportContext( rImport )
+, mxShapes( rShapes )
+, mxAnnotationAccess( rShapes, UNO_QUERY )
+{
+    for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+    {
+        if( aIter.getToken() == XML_ELEMENT(DRAW, XML_NAV_ORDER) )
+        {
+            msNavOrder = aIter.toString();
+            break;
+        }
+    }
+}
+
+SdXMLGenericPageContext::~SdXMLGenericPageContext()
+{
+}
+
+void SdXMLGenericPageContext::startFastElement( sal_Int32 /*nElement*/, const Reference< css::xml::sax::XFastAttributeList >& )
+{
+    GetImport().GetShapeImport()->pushGroupForPostProcessing( mxShapes );
+
+    if( GetImport().IsFormsSupported() )
+        GetImport().GetFormImport()->startPage( Reference< drawing::XDrawPage >::query( mxShapes ) );
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLGenericPageContext::createFastChildContext(
+    sal_Int32 nElement,
+    const Reference< xml::sax::XFastAttributeList>& xAttrList )
+{
+    if( nElement == XML_ELEMENT(PRESENTATION, XML_ANIMATIONS) )
+    {
+        return new XMLAnimationsContext( GetImport() );
+    }
+    else if( nElement == XML_ELEMENT(OFFICE, XML_FORMS) )
+    {
+        if( GetImport().IsFormsSupported() )
+            return xmloff::OFormLayerXMLImport::createOfficeFormsContext( GetImport() );
+    }
+    else if( nElement == XML_ELEMENT(OFFICE, XML_ANNOTATION) || nElement == XML_ELEMENT(OFFICE_EXT, XML_ANNOTATION) )
+    {
+        if( mxAnnotationAccess.is() )
+            return new DrawAnnotationContext( GetImport(), xAttrList, mxAnnotationAccess );
+    }
+    else
+    {
+        // call GroupChildContext function at common ShapeImport
+        auto p = XMLShapeImportHelper::CreateGroupChildContext(GetImport(), nElement, xAttrList, mxShapes);
+        if (p)
+            return p;
+    }
+    XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+    return nullptr;
+}
+
+void SdXMLGenericPageContext::endFastElement(sal_Int32 )
+{
+    GetImport().GetShapeImport()->popGroupAndPostProcess();
+
+    if( GetImport().IsFormsSupported() )
+        GetImport().GetFormImport()->endPage();
+
+    if( !maUseHeaderDeclName.isEmpty() || !maUseFooterDeclName.isEmpty() || !maUseDateTimeDeclName.isEmpty() )
+    {
+        try
+        {
+            Reference <beans::XPropertySet> xSet(mxShapes, uno::UNO_QUERY_THROW );
+            Reference< beans::XPropertySetInfo > xInfo( xSet->getPropertySetInfo() );
+
+            if( !maUseHeaderDeclName.isEmpty() )
+            {
+                static const OUStringLiteral aStrHeaderTextProp( u"HeaderText" );
+                if( xInfo->hasPropertyByName( aStrHeaderTextProp ) )
+                    xSet->setPropertyValue( aStrHeaderTextProp,
+                                            Any( GetSdImport().GetHeaderDecl( maUseHeaderDeclName ) ) );
+            }
+
+            if( !maUseFooterDeclName.isEmpty() )
+            {
+                static const OUStringLiteral aStrFooterTextProp( u"FooterText" );
+                if( xInfo->hasPropertyByName( aStrFooterTextProp ) )
+                    xSet->setPropertyValue( aStrFooterTextProp,
+                                        Any( GetSdImport().GetFooterDecl( maUseFooterDeclName ) ) );
+            }
+
+            if( !maUseDateTimeDeclName.isEmpty() )
+            {
+                static const OUStringLiteral aStrDateTimeTextProp( u"DateTimeText" );
+                if( xInfo->hasPropertyByName( aStrDateTimeTextProp ) )
+                {
+                    bool bFixed;
+                    OUString aDateTimeFormat;
+                    const OUString aText( GetSdImport().GetDateTimeDecl( maUseDateTimeDeclName, bFixed, aDateTimeFormat ) );
+
+                    xSet->setPropertyValue("IsDateTimeFixed",
+                                        Any( bFixed ) );
+
+                    if( bFixed )
+                    {
+                        xSet->setPropertyValue( aStrDateTimeTextProp, Any( aText ) );
+                    }
+                    else if( !aDateTimeFormat.isEmpty() )
+                    {
+                        const SdXMLStylesContext* pStyles = dynamic_cast< const SdXMLStylesContext* >( GetSdImport().GetShapeImport()->GetStylesContext() );
+                        if( !pStyles )
+                            pStyles = dynamic_cast< const SdXMLStylesContext* >( GetSdImport().GetShapeImport()->GetAutoStylesContext() );
+
+                        if( pStyles )
+                        {
+                            const SdXMLNumberFormatImportContext* pSdNumStyle =
+                                dynamic_cast< const SdXMLNumberFormatImportContext* >( pStyles->FindStyleChildContext( XmlStyleFamily::DATA_STYLE, aDateTimeFormat, true ) );
+
+                            if( pSdNumStyle )
+                            {
+                                xSet->setPropertyValue("DateTimeFormat",
+                                                                    Any( pSdNumStyle->GetDrawKey() ) );
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch(const uno::Exception&)
+        {
+            TOOLS_WARN_EXCEPTION("xmloff.draw", "");
+        }
+    }
+
+    SetNavigationOrder();
+}
+
+void SdXMLGenericPageContext::SetStyle( OUString const & rStyleName )
+{
+    // set PageProperties?
+    if(rStyleName.isEmpty())
+        return;
+
+    try
+    {
+        const SvXMLImportContext* pContext = GetSdImport().GetShapeImport()->GetAutoStylesContext();
+
+        if (const SdXMLStylesContext* pStyles = dynamic_cast<const SdXMLStylesContext *>(pContext))
+        {
+            const SvXMLStyleContext* pStyle = pStyles->FindStyleChildContext(
+                XmlStyleFamily::SD_DRAWINGPAGE_ID, rStyleName);
+
+            if (const XMLPropStyleContext* pPropStyle = dynamic_cast<const XMLPropStyleContext*>(pStyle))
+            {
+                Reference <beans::XPropertySet> xPropSet1(mxShapes, uno::UNO_QUERY);
+                if(xPropSet1.is())
+                {
+                    Reference< beans::XPropertySet > xPropSet( xPropSet1 );
+                    Reference< beans::XPropertySet > xBackgroundSet;
+
+                    static const OUStringLiteral aBackground(u"Background");
+                    if( xPropSet1->getPropertySetInfo()->hasPropertyByName( aBackground ) )
+                    {
+                        Reference< beans::XPropertySetInfo > xInfo( xPropSet1->getPropertySetInfo() );
+                        if( xInfo.is() && xInfo->hasPropertyByName( aBackground ) )
+                        {
+                            Reference< lang::XMultiServiceFactory > xServiceFact(GetSdImport().GetModel(), uno::UNO_QUERY);
+                            if(xServiceFact.is())
+                            {
+                                xBackgroundSet.set(xServiceFact->createInstance("com.sun.star.drawing.Background"), UNO_QUERY);
+                            }
+                        }
+
+                        if( xBackgroundSet.is() )
+                            xPropSet = PropertySetMerger_CreateInstance( xPropSet1, xBackgroundSet );
+                    }
+
+                    if(xPropSet.is())
+                    {
+                        const_cast<XMLPropStyleContext*>(pPropStyle)->FillPropertySet(xPropSet);
+
+                        if( xBackgroundSet.is() )
+                            xPropSet1->setPropertyValue( aBackground, uno::Any( xBackgroundSet ) );
+                    }
+                }
+            }
+        }
+    }
+    catch (const uno::Exception&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw", "");
+    }
+}
+
+void SdXMLGenericPageContext::SetLayout()
+{
+    // set PresentationPageLayout?
+    if(!GetSdImport().IsImpress() || maPageLayoutName.isEmpty())
+        return;
+
+    sal_Int32 nType = -1;
+
+    const SvXMLImportContext* pContext = GetSdImport().GetShapeImport()->GetStylesContext();
+
+    if (const SdXMLStylesContext* pStyles = dynamic_cast<const SdXMLStylesContext *>(pContext))
+    {
+        const SvXMLStyleContext* pStyle = pStyles->FindStyleChildContext( XmlStyleFamily::SD_PRESENTATIONPAGELAYOUT_ID, maPageLayoutName);
+
+        if (const SdXMLPresentationPageLayoutContext* pLayout = dynamic_cast<const SdXMLPresentationPageLayoutContext*>(pStyle))
+        {
+            nType = pLayout->GetTypeId();
+        }
+    }
+
+    if( -1 == nType )
+    {
+        Reference< container::XNameAccess > xPageLayouts( GetSdImport().getPageLayouts() );
+        if( xPageLayouts.is() )
+        {
+            if( xPageLayouts->hasByName( maPageLayoutName ) )
+                xPageLayouts->getByName( maPageLayoutName ) >>= nType;
+        }
+
+    }
+
+    if( -1 != nType )
+    {
+        Reference <beans::XPropertySet> xPropSet(mxShapes, uno::UNO_QUERY);
+        if(xPropSet.is())
+        {
+            OUString aPropName("Layout");
+            Reference< beans::XPropertySetInfo > xInfo( xPropSet->getPropertySetInfo() );
+            if( xInfo.is() && xInfo->hasPropertyByName( aPropName ) )
+                xPropSet->setPropertyValue(aPropName, uno::Any( static_cast<sal_Int16>(nType) ) );
+        }
+    }
+}
+
+void SdXMLGenericPageContext::DeleteAllShapes()
+{
+    // now delete all up-to-now contained shapes; they have been created
+    // when setting the presentation page layout.
+    while(mxShapes->getCount())
+    {
+        Reference< drawing::XShape > xShape;
+        uno::Any aAny(mxShapes->getByIndex(0));
+
+        aAny >>= xShape;
+
+        if(xShape.is())
+        {
+            mxShapes->remove(xShape);
+        }
+    }
+}
+
+void SdXMLGenericPageContext::SetPageMaster( OUString const & rsPageMasterName )
+{
+    if (!GetSdImport().GetShapeImport()->GetStylesContext())
+        return;
+
+    // look for PageMaster with this name
+
+    // #80012# GetStylesContext() replaced with GetAutoStylesContext()
+    const SvXMLStylesContext* pAutoStyles = GetSdImport().GetShapeImport()->GetAutoStylesContext();
+
+    const SvXMLStyleContext* pStyle = pAutoStyles ? pAutoStyles->FindStyleChildContext(XmlStyleFamily::SD_PAGEMASTERCONTEXT_ID, rsPageMasterName) : nullptr;
+
+    const SdXMLPageMasterContext* pPageMaster = dynamic_cast<const SdXMLPageMasterContext*>(pStyle);
+    if (!pPageMaster)
+        return;
+
+    const SdXMLPageMasterStyleContext* pPageMasterContext = pPageMaster->GetPageMasterStyle();
+
+    if (!pPageMasterContext)
+        return;
+
+    Reference< drawing::XDrawPage > xMasterPage(GetLocalShapesContext(), uno::UNO_QUERY);
+    if (!xMasterPage.is())
+        return;
+
+    // set sizes for this masterpage
+    Reference <beans::XPropertySet> xPropSet(xMasterPage, uno::UNO_QUERY);
+    if (xPropSet.is())
+    {
+        xPropSet->setPropertyValue("BorderBottom", Any(pPageMasterContext->GetBorderBottom()));
+        xPropSet->setPropertyValue("BorderLeft", Any(pPageMasterContext->GetBorderLeft()));
+        xPropSet->setPropertyValue("BorderRight", Any(pPageMasterContext->GetBorderRight()));
+        xPropSet->setPropertyValue("BorderTop", Any(pPageMasterContext->GetBorderTop()));
+        xPropSet->setPropertyValue("Width", Any(pPageMasterContext->GetWidth()));
+        xPropSet->setPropertyValue("Height", Any(pPageMasterContext->GetHeight()));
+        xPropSet->setPropertyValue("Orientation", Any(pPageMasterContext->GetOrientation()));
+    }
+}
+
+namespace {
+
+class XoNavigationOrderAccess : public ::cppu::WeakImplHelper< XIndexAccess >
+{
+public:
+    explicit XoNavigationOrderAccess( std::vector< Reference< XShape > >& rShapes );
+
+    // XIndexAccess
+    virtual sal_Int32 SAL_CALL getCount(  ) override;
+    virtual Any SAL_CALL getByIndex( sal_Int32 Index ) override;
+
+    // XElementAccess
+    virtual Type SAL_CALL getElementType(  ) override;
+    virtual sal_Bool SAL_CALL hasElements(  ) override;
+
+private:
+    std::vector< Reference< XShape > > maShapes;
+};
+
+}
+
+XoNavigationOrderAccess::XoNavigationOrderAccess( std::vector< Reference< XShape > >& rShapes )
+{
+    maShapes.swap( rShapes );
+}
+
+// XIndexAccess
+sal_Int32 SAL_CALL XoNavigationOrderAccess::getCount(  )
+{
+    return static_cast< sal_Int32 >( maShapes.size() );
+}
+
+Any SAL_CALL XoNavigationOrderAccess::getByIndex( sal_Int32 Index )
+{
+    if( (Index < 0) || (Index > getCount()) )
+        throw IndexOutOfBoundsException();
+
+    return Any( maShapes[Index] );
+}
+
+// XElementAccess
+Type SAL_CALL XoNavigationOrderAccess::getElementType(  )
+{
+    return cppu::UnoType<XShape>::get();
+}
+
+sal_Bool SAL_CALL XoNavigationOrderAccess::hasElements(  )
+{
+    return !maShapes.empty();
+}
+
+void SdXMLGenericPageContext::SetNavigationOrder()
+{
+    if( msNavOrder.isEmpty() )
+        return;
+
+    try
+    {
+        sal_uInt32 nIndex;
+        const sal_uInt32 nCount = static_cast< sal_uInt32 >( mxShapes->getCount() );
+        std::vector< Reference< XShape > > aShapes( nCount );
+
+        ::comphelper::UnoInterfaceToUniqueIdentifierMapper& rIdMapper = GetSdImport().getInterfaceToIdentifierMapper();
+        SvXMLTokenEnumerator aEnumerator( msNavOrder );
+        std::u16string_view sId;
+        for( nIndex = 0; nIndex < nCount; ++nIndex )
+        {
+            if( !aEnumerator.getNextToken(sId) )
+                break;
+
+            aShapes[nIndex].set( rIdMapper.getReference( OUString(sId) ), UNO_QUERY );
+        }
+
+        for( nIndex = 0; nIndex < nCount; ++nIndex )
+        {
+            if( !aShapes[nIndex].is() )
+            {
+                OSL_FAIL("xmloff::SdXMLGenericPageContext::SetNavigationOrder(), draw:nav-order attribute incomplete!");
+                // todo: warning?
+                return;
+            }
+        }
+
+        Reference< XPropertySet > xSet( mxShapes, UNO_QUERY_THROW );
+        xSet->setPropertyValue("NavigationOrder", Any( Reference< XIndexAccess >( new XoNavigationOrderAccess( aShapes ) ) ) );
+    }
+    catch(const uno::Exception&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw",
+                             "unexpected exception caught while importing shape navigation order!");
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/ximppage.hxx b/xmloff/source/draw/ximppage.hxx
new file mode 100644
index 000000000..5303458dd
--- /dev/null
+++ b/xmloff/source/draw/ximppage.hxx
@@ -0,0 +1,77 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlictxt.hxx>
+#include "sdxmlimp_impl.hxx"
+#include <com/sun/star/drawing/XShapes.hpp>
+#include <com/sun/star/office/XAnnotationAccess.hpp>
+
+// draw:g context (RECURSIVE)
+
+class SdXMLGenericPageContext : public SvXMLImportContext
+{
+    // the shape group this group is working on
+    css::uno::Reference< css::drawing::XShapes > mxShapes;
+    css::uno::Reference< css::office::XAnnotationAccess > mxAnnotationAccess;
+
+protected:
+    OUString               maPageLayoutName;
+    OUString               maUseHeaderDeclName;
+    OUString               maUseFooterDeclName;
+    OUString               maUseDateTimeDeclName;
+    OUString               msNavOrder;
+
+    /** sets the page style on this page */
+    void SetStyle( OUString const & rStyleName );
+
+    /** sets the presentation layout at this page. It is used for drawing pages and for the handout master */
+    void SetLayout();
+
+    /** deletes all shapes on this drawing page */
+    void DeleteAllShapes();
+
+    const SdXMLImport& GetSdImport() const { return static_cast<const SdXMLImport&>(GetImport()); }
+    SdXMLImport& GetSdImport() { return static_cast<SdXMLImport&>(GetImport()); }
+
+    /** sets the properties from a page master style with the given name on this contexts page */
+    void SetPageMaster( OUString const & rsPageMasterName );
+
+    void SetNavigationOrder();
+
+public:
+
+    SdXMLGenericPageContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes);
+    virtual ~SdXMLGenericPageContext() override;
+
+    virtual void SAL_CALL startFastElement( sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+
+    const css::uno::Reference< css::drawing::XShapes >& GetLocalShapesContext() const
+        { return mxShapes; }
+    css::uno::Reference< css::drawing::XShapes >& GetLocalShapesContext()
+        { return mxShapes; }
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/ximpshap.cxx b/xmloff/source/draw/ximpshap.cxx
new file mode 100644
index 000000000..02fef6949
--- /dev/null
+++ b/xmloff/source/draw/ximpshap.cxx
@@ -0,0 +1,3940 @@
+/* -*- 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_wasm_strip.h>
+
+#include <cassert>
+
+#include <sal/log.hxx>
+#include <com/sun/star/document/XEventsSupplier.hpp>
+#include <com/sun/star/container/XNameReplace.hpp>
+#include <com/sun/star/presentation/ClickAction.hpp>
+#include <com/sun/star/drawing/FillStyle.hpp>
+#include <com/sun/star/drawing/LineStyle.hpp>
+#include <xmloff/unointerfacetouniqueidentifiermapper.hxx>
+#include <com/sun/star/drawing/XGluePointsSupplier.hpp>
+#include <com/sun/star/drawing/GluePoint2.hpp>
+#include <com/sun/star/drawing/Alignment.hpp>
+#include <com/sun/star/drawing/EscapeDirection.hpp>
+#include <com/sun/star/media/ZoomLevel.hpp>
+#include <com/sun/star/awt/Rectangle.hpp>
+#include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
+#include <com/sun/star/container/XNameAccess.hpp>
+#include "ximpshap.hxx"
+#include <xmloff/XMLBase64ImportContext.hxx>
+#include <xmloff/XMLShapeStyleContext.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <com/sun/star/container/XNamed.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/awt/XControlModel.hpp>
+#include <com/sun/star/drawing/XControlShape.hpp>
+#include <com/sun/star/drawing/PointSequenceSequence.hpp>
+#include <com/sun/star/drawing/PointSequence.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/util/XCloneable.hpp>
+#include <com/sun/star/beans/XMultiPropertyStates.hpp>
+#include <xexptran.hxx>
+#include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
+#include <com/sun/star/beans/XPropertySetInfo.hpp>
+#include <com/sun/star/drawing/HomogenMatrix3.hpp>
+#include <com/sun/star/graphic/XGraphic.hpp>
+#include <com/sun/star/style/XStyle.hpp>
+
+#include <sax/tools/converter.hxx>
+#include <comphelper/sequence.hxx>
+#include <tools/diagnose_ex.h>
+
+#include <xmloff/families.hxx>
+#include<xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <EnhancedCustomShapeToken.hxx>
+#include <XMLReplacementImageContext.hxx>
+#include <XMLImageMapContext.hxx>
+#include "sdpropls.hxx"
+#include "eventimp.hxx"
+#include "descriptionimp.hxx"
+#include "SignatureLineContext.hxx"
+#include "QRCodeContext.hxx"
+#include "ximpcustomshape.hxx"
+#include <XMLEmbeddedObjectImportContext.hxx>
+#include <xmloff/xmlerror.hxx>
+#include <xmloff/table/XMLTableImport.hxx>
+#include <xmloff/ProgressBarHelper.hxx>
+#include <xmloff/attrlist.hxx>
+#include <basegfx/matrix/b2dhommatrix.hxx>
+#include <com/sun/star/drawing/XEnhancedCustomShapeDefaulter.hpp>
+#include <com/sun/star/container/XChild.hpp>
+#include <com/sun/star/text/XTextDocument.hpp>
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
+#include <basegfx/point/b2dpoint.hxx>
+#include <basegfx/polygon/b2dpolygon.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <basegfx/polygon/b2dpolypolygon.hxx>
+#include <basegfx/polygon/b2dpolypolygontools.hxx>
+#include <basegfx/vector/b2dvector.hxx>
+#include <tools/urlobj.hxx>
+#include <o3tl/any.hxx>
+#include <o3tl/safeint.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::drawing;
+using namespace ::com::sun::star::style;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::document;
+using namespace ::xmloff::token;
+using namespace ::xmloff::EnhancedCustomShapeToken;
+
+SvXMLEnumMapEntry<drawing::Alignment> const aXML_GlueAlignment_EnumMap[] =
+{
+    { XML_TOP_LEFT,     drawing::Alignment_TOP_LEFT },
+    { XML_TOP,          drawing::Alignment_TOP },
+    { XML_TOP_RIGHT,    drawing::Alignment_TOP_RIGHT },
+    { XML_LEFT,         drawing::Alignment_LEFT },
+    { XML_CENTER,       drawing::Alignment_CENTER },
+    { XML_RIGHT,        drawing::Alignment_RIGHT },
+    { XML_BOTTOM_LEFT,  drawing::Alignment_BOTTOM_LEFT },
+    { XML_BOTTOM,       drawing::Alignment_BOTTOM },
+    { XML_BOTTOM_RIGHT, drawing::Alignment_BOTTOM_RIGHT },
+    { XML_TOKEN_INVALID, drawing::Alignment(0) }
+};
+
+SvXMLEnumMapEntry<drawing::EscapeDirection> const aXML_GlueEscapeDirection_EnumMap[] =
+{
+    { XML_AUTO,         drawing::EscapeDirection_SMART },
+    { XML_LEFT,         drawing::EscapeDirection_LEFT },
+    { XML_RIGHT,        drawing::EscapeDirection_RIGHT },
+    { XML_UP,           drawing::EscapeDirection_UP },
+    { XML_DOWN,         drawing::EscapeDirection_DOWN },
+    { XML_HORIZONTAL,   drawing::EscapeDirection_HORIZONTAL },
+    { XML_VERTICAL,     drawing::EscapeDirection_VERTICAL },
+    { XML_TOKEN_INVALID, drawing::EscapeDirection(0) }
+};
+
+static bool ImpIsEmptyURL( std::u16string_view rURL )
+{
+    if( rURL.empty() )
+        return true;
+
+    // #i13140# Also compare against 'toplevel' URLs. which also
+    // result in empty filename strings.
+    if( rURL == u"#./" )
+        return true;
+
+    return false;
+}
+
+
+SdXMLShapeContext::SdXMLShapeContext(
+    SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes,
+    bool bTemporaryShape)
+    : SvXMLShapeContext( rImport, bTemporaryShape )
+    , mxShapes( rShapes )
+    , mxAttrList(xAttrList)
+    , mbListContextPushed( false )
+    , mnStyleFamily(XmlStyleFamily::SD_GRAPHICS_ID)
+    , mbIsPlaceholder(false)
+    , mbClearDefaultAttributes( true )
+    , mbIsUserTransformed(false)
+    , mnZOrder(-1)
+    , maSize(1, 1)
+    , mnRelWidth(0)
+    , mnRelHeight(0)
+    , maPosition(0, 0)
+    , mbVisible(true)
+    , mbPrintable(true)
+    , mbHaveXmlId(false)
+    , mbTextBox(false)
+{
+}
+
+SdXMLShapeContext::~SdXMLShapeContext()
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLShapeContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    SvXMLImportContextRef xContext;
+    // #i68101#
+    if( nElement == XML_ELEMENT(SVG, XML_TITLE) || nElement == XML_ELEMENT(SVG, XML_DESC)
+        || nElement == XML_ELEMENT(SVG_COMPAT, XML_TITLE) || nElement == XML_ELEMENT(SVG_COMPAT, XML_DESC) )
+    {
+        xContext = new SdXMLDescriptionContext( GetImport(), nElement, mxShape );
+    }
+    else if( nElement == XML_ELEMENT(LO_EXT, XML_SIGNATURELINE) )
+    {
+        xContext = new SignatureLineContext( GetImport(), nElement, xAttrList, mxShape );
+    }
+    else if( nElement == XML_ELEMENT(LO_EXT, XML_QRCODE) )
+    {
+        xContext = new QRCodeContext( GetImport(), nElement, xAttrList, mxShape );
+    }
+    else if( nElement == XML_ELEMENT(OFFICE, XML_EVENT_LISTENERS) )
+    {
+        xContext = new SdXMLEventsContext( GetImport(), mxShape );
+    }
+    else if( nElement == XML_ELEMENT(DRAW, XML_GLUE_POINT) )
+    {
+        addGluePoint( xAttrList );
+    }
+    else if( nElement == XML_ELEMENT(DRAW, XML_THUMBNAIL) )
+    {
+        // search attributes for xlink:href
+        maThumbnailURL = xAttrList->getOptionalValue(XML_ELEMENT(XLINK, XML_HREF));
+    }
+    else
+    {
+        // create text cursor on demand
+        if( !mxCursor.is() )
+        {
+            uno::Reference< text::XText > xText( mxShape, uno::UNO_QUERY );
+            if( xText.is() )
+            {
+                rtl::Reference < XMLTextImportHelper > xTxtImport =
+                    GetImport().GetTextImport();
+                mxOldCursor = xTxtImport->GetCursor();
+                mxCursor = xText->createTextCursor();
+                if( mxCursor.is() )
+                {
+                    xTxtImport->SetCursor( mxCursor );
+                }
+
+                // remember old list item and block (#91964#) and reset them
+                // for the text frame
+                xTxtImport->PushListContext();
+                mbListContextPushed = true;
+            }
+        }
+
+        // if we have a text cursor, lets  try to import some text
+        if( mxCursor.is() )
+        {
+            xContext = GetImport().GetTextImport()->CreateTextChildContext(
+                GetImport(), nElement, xAttrList,
+                ( mbTextBox ? XMLTextType::TextBox : XMLTextType::Shape ) );
+        }
+    }
+
+    if (!xContext)
+        XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+
+    return xContext;
+}
+
+void SdXMLShapeContext::addGluePoint( const uno::Reference< xml::sax::XFastAttributeList>& xAttrList )
+{
+    // get the gluepoints container for this shape if it's not already there
+    if( !mxGluePoints.is() )
+    {
+        uno::Reference< drawing::XGluePointsSupplier > xSupplier( mxShape, uno::UNO_QUERY );
+        if( !xSupplier.is() )
+            return;
+
+        mxGluePoints.set( xSupplier->getGluePoints(), UNO_QUERY );
+
+        if( !mxGluePoints.is() )
+            return;
+    }
+
+    drawing::GluePoint2 aGluePoint;
+    aGluePoint.IsUserDefined = true;
+    aGluePoint.Position.X = 0;
+    aGluePoint.Position.Y = 0;
+    aGluePoint.Escape = drawing::EscapeDirection_SMART;
+    aGluePoint.PositionAlignment = drawing::Alignment_CENTER;
+    aGluePoint.IsRelative = true;
+
+    sal_Int32 nId = -1;
+
+    // read attributes for the 3DScene
+    for( auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList) )
+    {
+        switch(aIter.getToken())
+        {
+            case XML_ELEMENT(SVG, XML_X):
+            case XML_ELEMENT(SVG_COMPAT, XML_X):
+                GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                        aGluePoint.Position.X, aIter.toView());
+                break;
+            case XML_ELEMENT(SVG, XML_Y):
+            case XML_ELEMENT(SVG_COMPAT, XML_Y):
+                GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                        aGluePoint.Position.Y, aIter.toView());
+                break;
+            case XML_ELEMENT(DRAW, XML_ID):
+                nId = aIter.toInt32();
+                break;
+            case XML_ELEMENT(DRAW, XML_ALIGN):
+            {
+                drawing::Alignment eKind;
+                if( SvXMLUnitConverter::convertEnum( eKind, aIter.toView(), aXML_GlueAlignment_EnumMap ) )
+                {
+                    aGluePoint.PositionAlignment = eKind;
+                    aGluePoint.IsRelative = false;
+                }
+                break;
+            }
+            case XML_ELEMENT(DRAW, XML_ESCAPE_DIRECTION):
+            {
+                SvXMLUnitConverter::convertEnum( aGluePoint.Escape, aIter.toView(), aXML_GlueEscapeDirection_EnumMap );
+                break;
+            }
+            default:
+                XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+        }
+    }
+
+    if( nId != -1 )
+    {
+        try
+        {
+            sal_Int32 nInternalId = mxGluePoints->insert( uno::Any( aGluePoint ) );
+            GetImport().GetShapeImport()->addGluePointMapping( mxShape, nId, nInternalId );
+        }
+        catch(const uno::Exception&)
+        {
+            DBG_UNHANDLED_EXCEPTION( "xmloff", "during setting of gluepoints");
+        }
+    }
+}
+
+void SdXMLShapeContext::startFastElement (sal_Int32 /*nElement*/,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& /*xAttrList*/)
+{
+    GetImport().GetShapeImport()->finishShape( mxShape, mxAttrList, mxShapes );
+}
+
+void SdXMLShapeContext::endFastElement(sal_Int32 )
+{
+    if(mxCursor.is())
+    {
+        // tdf#72776 force UpdateData in the EditSource so we will not override text in SdrOutliner
+        if( mxLockable.is() )
+        {
+            mxLockable->removeActionLock();
+            mxLockable->addActionLock();
+        }
+
+        // delete addition newline
+        mxCursor->gotoEnd( false );
+        mxCursor->goLeft( 1, true );
+        mxCursor->setString( "" );
+
+        // reset cursor
+        GetImport().GetTextImport()->ResetCursor();
+    }
+
+    if(mxOldCursor.is())
+        GetImport().GetTextImport()->SetCursor( mxOldCursor );
+
+    // reinstall old list item (if necessary) #91964#
+    if (mbListContextPushed) {
+        GetImport().GetTextImport()->PopListContext();
+    }
+
+    if( !msHyperlink.isEmpty() ) try
+    {
+        uno::Reference< beans::XPropertySet > xProp( mxShape, uno::UNO_QUERY );
+
+        if ( xProp.is() && xProp->getPropertySetInfo()->hasPropertyByName( "Hyperlink" ) )
+            xProp->setPropertyValue( "Hyperlink", uno::Any( msHyperlink ) );
+        Reference< XEventsSupplier > xEventsSupplier( mxShape, UNO_QUERY );
+
+        if( xEventsSupplier.is() )
+        {
+            Reference< XNameReplace > xEvents( xEventsSupplier->getEvents(), UNO_SET_THROW );
+
+            uno::Sequence< beans::PropertyValue > aProperties{
+                { /* Name   */ "EventType",
+                  /* Handle */ -1,
+                  /* Value  */ uno::Any(OUString( "Presentation" )),
+                  /* State  */ beans::PropertyState_DIRECT_VALUE },
+
+                { /* Name   */ "ClickAction",
+                  /* Handle */ -1,
+                  /* Value  */ uno::Any(css::presentation::ClickAction_DOCUMENT),
+                  /* State  */ beans::PropertyState_DIRECT_VALUE },
+
+                { /* Name   */ "Bookmark",
+                  /* Handle */ -1,
+                  /* Value  */ uno::Any(msHyperlink),
+                  /* State  */ beans::PropertyState_DIRECT_VALUE }
+            };
+
+            xEvents->replaceByName( "OnClick", Any( aProperties ) );
+        }
+        else
+        {
+            // in draw use the Bookmark property
+            Reference< beans::XPropertySet > xSet( mxShape, UNO_QUERY_THROW );
+            xSet->setPropertyValue( "Bookmark", Any( msHyperlink ) );
+            xSet->setPropertyValue("OnClick", Any( css::presentation::ClickAction_DOCUMENT ) );
+        }
+    }
+    catch(const Exception&)
+    {
+        DBG_UNHANDLED_EXCEPTION("xmloff", "while setting hyperlink");
+    }
+
+    if( mxLockable.is() )
+        mxLockable->removeActionLock();
+}
+
+void SdXMLShapeContext::AddShape(uno::Reference< drawing::XShape >& xShape)
+{
+    if(xShape.is())
+    {
+        // set shape local
+        mxShape = xShape;
+
+        if(!maShapeName.isEmpty())
+        {
+            uno::Reference< container::XNamed > xNamed( mxShape, uno::UNO_QUERY );
+            if( xNamed.is() )
+                xNamed->setName( maShapeName );
+        }
+
+        rtl::Reference< XMLShapeImportHelper > xImp( GetImport().GetShapeImport() );
+        xImp->addShape( xShape, mxAttrList, mxShapes );
+
+        if( mbClearDefaultAttributes )
+        {
+            uno::Reference<beans::XMultiPropertyStates> xMultiPropertyStates(xShape, uno::UNO_QUERY );
+            if (xMultiPropertyStates.is())
+                xMultiPropertyStates->setAllPropertiesToDefault();
+        }
+
+        if( !mbVisible || !mbPrintable ) try
+        {
+            uno::Reference< beans::XPropertySet > xSet( xShape, uno::UNO_QUERY_THROW );
+            if( !mbVisible )
+                xSet->setPropertyValue("Visible", uno::Any( false ) );
+
+            if( !mbPrintable )
+                xSet->setPropertyValue("Printable", uno::Any( false ) );
+        }
+        catch(const Exception&)
+        {
+            DBG_UNHANDLED_EXCEPTION( "xmloff", "while setting visible or printable" );
+        }
+
+        if(!mbTemporaryShape && (!GetImport().HasTextImport()
+            || !GetImport().GetTextImport()->IsInsideDeleteContext()))
+        {
+            xImp->shapeWithZIndexAdded( xShape, mnZOrder );
+        }
+
+        if (mnRelWidth || mnRelHeight)
+        {
+            uno::Reference<beans::XPropertySet> xPropertySet(xShape, uno::UNO_QUERY);
+            uno::Reference<beans::XPropertySetInfo> xPropertySetInfo = xPropertySet->getPropertySetInfo();
+            if (mnRelWidth && xPropertySetInfo->hasPropertyByName("RelativeWidth"))
+                xPropertySet->setPropertyValue("RelativeWidth", uno::Any(mnRelWidth));
+            if (mnRelHeight && xPropertySetInfo->hasPropertyByName("RelativeHeight"))
+                xPropertySet->setPropertyValue("RelativeHeight", uno::Any(mnRelHeight));
+        }
+
+        if( !maShapeId.isEmpty() )
+        {
+            uno::Reference< uno::XInterface > xRef( static_cast<uno::XInterface *>(xShape.get()) );
+            GetImport().getInterfaceToIdentifierMapper().registerReference( maShapeId, xRef );
+        }
+
+        // #91065# count only if counting for shape import is enabled
+        if(GetImport().GetShapeImport()->IsHandleProgressBarEnabled())
+        {
+            // #80365# increment progress bar at load once for each draw object
+            GetImport().GetProgressBarHelper()->Increment();
+        }
+    }
+
+    mxLockable.set( xShape, UNO_QUERY );
+
+    if( mxLockable.is() )
+        mxLockable->addActionLock();
+
+}
+
+void SdXMLShapeContext::AddShape(OUString const & serviceName)
+{
+    uno::Reference< lang::XMultiServiceFactory > xServiceFact(GetImport().GetModel(), uno::UNO_QUERY);
+    if(!xServiceFact.is())
+        return;
+
+    try
+    {
+        /* Since fix for issue i33294 the Writer model doesn't support
+           com.sun.star.drawing.OLE2Shape anymore.
+           To handle Draw OLE objects it's decided to import these
+           objects as com.sun.star.drawing.OLE2Shape and convert these
+           objects after the import into com.sun.star.drawing.GraphicObjectShape.
+        */
+        uno::Reference< drawing::XShape > xShape;
+        if ( serviceName == "com.sun.star.drawing.OLE2Shape" &&
+             uno::Reference< text::XTextDocument >(GetImport().GetModel(), uno::UNO_QUERY).is() )
+        {
+            xShape.set(xServiceFact->createInstance("com.sun.star.drawing.temporaryForXMLImportOLE2Shape"), uno::UNO_QUERY);
+        }
+        else if (serviceName == "com.sun.star.drawing.GraphicObjectShape"
+                 || serviceName == "com.sun.star.drawing.MediaShape"
+                 || serviceName == "com.sun.star.presentation.MediaShape")
+        {
+            xShape.set( xServiceFact->createInstanceWithArguments(serviceName, { css::uno::Any(GetImport().GetDocumentBase()) }),
+                        css::uno::UNO_QUERY);
+        }
+        else
+        {
+            xShape.set(xServiceFact->createInstance(serviceName), uno::UNO_QUERY);
+        }
+        if( xShape.is() )
+            AddShape( xShape );
+    }
+    catch(const uno::Exception& e)
+    {
+        uno::Sequence<OUString> aSeq { serviceName };
+        GetImport().SetError( XMLERROR_FLAG_ERROR | XMLERROR_API,
+                              aSeq, e.Message, nullptr );
+    }
+}
+
+void SdXMLShapeContext::SetTransformation()
+{
+    if(!mxShape.is())
+        return;
+
+    uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
+    if(!xPropSet.is())
+        return;
+
+    maUsedTransformation.identity();
+
+    if(maSize.Width != 1 || maSize.Height != 1)
+    {
+        // take care there are no zeros used by error
+        if(0 == maSize.Width)
+            maSize.Width = 1;
+        if(0 == maSize.Height)
+            maSize.Height = 1;
+
+        // set global size. This should always be used.
+        maUsedTransformation.scale(maSize.Width, maSize.Height);
+    }
+
+    if(maPosition.X != 0 || maPosition.Y != 0)
+    {
+        // if global position is used, add it to transformation
+        maUsedTransformation.translate(maPosition.X, maPosition.Y);
+    }
+
+    if(mnTransform.NeedsAction())
+    {
+        // transformation is used, apply to object.
+        // NOTICE: The transformation is applied AFTER evtl. used
+        // global positioning and scaling is used, so any shear or
+        // rotate used herein is applied around the (0,0) position
+        // of the PAGE object !!!
+        ::basegfx::B2DHomMatrix aMat;
+        mnTransform.GetFullTransform(aMat);
+
+        // now add to transformation
+        maUsedTransformation *= aMat;
+    }
+
+    // now set transformation for this object
+
+    // maUsedTransformtion contains the mathematical correct matrix, which if
+    // applied to a unit square would generate the transformed shape. But the property
+    // "Transformation" contains a matrix, which can be used in TRSetBaseGeometry
+    // and would be created by TRGetBaseGeometry. And those use a mathematically wrong
+    // sign for the shearing angle. So we need to adapt the matrix here.
+    basegfx::B2DTuple aScale;
+    basegfx::B2DTuple aTranslate;
+    double fRotate;
+    double fShearX;
+    maUsedTransformation.decompose(aScale, aTranslate, fRotate, fShearX);
+    basegfx::B2DHomMatrix aB2DHomMatrix;
+    aB2DHomMatrix = basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix(
+                                aScale,
+                                basegfx::fTools::equalZero(fShearX) ? 0.0 : -fShearX,
+                                basegfx::fTools::equalZero(fRotate) ? 0.0 : fRotate,
+                            aTranslate);
+    drawing::HomogenMatrix3 aUnoMatrix;
+
+    aUnoMatrix.Line1.Column1 = aB2DHomMatrix.get(0, 0);
+    aUnoMatrix.Line1.Column2 = aB2DHomMatrix.get(0, 1);
+    aUnoMatrix.Line1.Column3 = aB2DHomMatrix.get(0, 2);
+
+    aUnoMatrix.Line2.Column1 = aB2DHomMatrix.get(1, 0);
+    aUnoMatrix.Line2.Column2 = aB2DHomMatrix.get(1, 1);
+    aUnoMatrix.Line2.Column3 = aB2DHomMatrix.get(1, 2);
+
+    aUnoMatrix.Line3.Column1 = aB2DHomMatrix.get(2, 0);
+    aUnoMatrix.Line3.Column2 = aB2DHomMatrix.get(2, 1);
+    aUnoMatrix.Line3.Column3 = aB2DHomMatrix.get(2, 2);
+
+    xPropSet->setPropertyValue("Transformation", Any(aUnoMatrix));
+}
+
+void SdXMLShapeContext::SetStyle( bool bSupportsStyle /* = true */)
+{
+    try
+    {
+        uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
+        if( !xPropSet.is() )
+            return;
+
+        do
+        {
+            // set style on shape
+            if(maDrawStyleName.isEmpty())
+                break;
+
+            const SvXMLStyleContext* pStyle = nullptr;
+            bool bAutoStyle(false);
+
+            if(GetImport().GetShapeImport()->GetAutoStylesContext())
+                pStyle = GetImport().GetShapeImport()->GetAutoStylesContext()->FindStyleChildContext(mnStyleFamily, maDrawStyleName);
+
+            if(pStyle)
+                bAutoStyle = true;
+
+            if(!pStyle && GetImport().GetShapeImport()->GetStylesContext())
+                pStyle = GetImport().GetShapeImport()->GetStylesContext()->FindStyleChildContext(mnStyleFamily, maDrawStyleName);
+
+            OUString aStyleName = maDrawStyleName;
+            uno::Reference< style::XStyle > xStyle;
+
+            XMLPropStyleContext* pDocStyle
+                = dynamic_cast<XMLShapeStyleContext*>(const_cast<SvXMLStyleContext*>(pStyle));
+            if (pDocStyle)
+            {
+                if( pDocStyle->GetStyle().is() )
+                {
+                    xStyle = pDocStyle->GetStyle();
+                }
+                else
+                {
+                    aStyleName = pDocStyle->GetParentName();
+                }
+            }
+
+            if( !xStyle.is() && !aStyleName.isEmpty() )
+            {
+                try
+                {
+
+                    uno::Reference< style::XStyleFamiliesSupplier > xFamiliesSupplier( GetImport().GetModel(), uno::UNO_QUERY );
+
+                    if( xFamiliesSupplier.is() )
+                    {
+                        uno::Reference< container::XNameAccess > xFamilies( xFamiliesSupplier->getStyleFamilies() );
+                        if( xFamilies.is() )
+                        {
+
+                            uno::Reference< container::XNameAccess > xFamily;
+
+                            if( XmlStyleFamily::SD_PRESENTATION_ID == mnStyleFamily )
+                            {
+                                aStyleName = GetImport().GetStyleDisplayName(
+                                    XmlStyleFamily::SD_PRESENTATION_ID,
+                                    aStyleName );
+                                sal_Int32 nPos = aStyleName.lastIndexOf( '-' );
+                                if( -1 != nPos )
+                                {
+                                    OUString aFamily( aStyleName.copy( 0, nPos ) );
+
+                                    xFamilies->getByName( aFamily ) >>= xFamily;
+                                    aStyleName = aStyleName.copy( nPos + 1 );
+                                }
+                            }
+                            else
+                            {
+                                // get graphics family
+                                xFamilies->getByName("graphics") >>= xFamily;
+                                aStyleName = GetImport().GetStyleDisplayName(
+                                    XmlStyleFamily::SD_GRAPHICS_ID,
+                                    aStyleName );
+                            }
+
+                            if( xFamily.is() )
+                                xFamily->getByName( aStyleName ) >>= xStyle;
+                        }
+                    }
+                }
+                catch(const uno::Exception&)
+                {
+                    DBG_UNHANDLED_EXCEPTION( "xmloff", "finding style for shape" );
+                }
+            }
+
+            if( bSupportsStyle && xStyle.is() )
+            {
+                try
+                {
+                    // set style on object
+                    xPropSet->setPropertyValue("Style", Any(xStyle));
+                }
+                catch(const uno::Exception&)
+                {
+                    DBG_UNHANDLED_EXCEPTION( "xmloff", "setting style for shape" );
+                }
+            }
+
+            // Writer shapes: if this one has a TextBox, set it here. We need to do it before
+            // pDocStyle->FillPropertySet, because setting some properties depend on the format
+            // having RES_CNTNT attribute (e.g., UNO_NAME_TEXT_(LEFT|RIGHT|UPPER|LOWER)DIST; see
+            // SwTextBoxHelper::syncProperty, which indirectly calls SwTextBoxHelper::isTextBox)
+            uno::Reference<beans::XPropertySetInfo> xPropertySetInfo
+                = xPropSet->getPropertySetInfo();
+            if (xPropertySetInfo->hasPropertyByName("TextBox"))
+                xPropSet->setPropertyValue("TextBox", uno::Any(mbTextBox));
+
+            // if this is an auto style, set its properties
+            if(bAutoStyle && pDocStyle)
+            {
+                // set PropertySet on object
+                pDocStyle->FillPropertySet(xPropSet);
+            }
+
+        } while(false);
+
+        // try to set text auto style
+        do
+        {
+            // set style on shape
+            if( maTextStyleName.isEmpty() )
+                break;
+
+            if( nullptr == GetImport().GetShapeImport()->GetAutoStylesContext())
+                break;
+
+            const SvXMLStyleContext* pTempStyle = GetImport().GetShapeImport()->GetAutoStylesContext()->FindStyleChildContext(XmlStyleFamily::TEXT_PARAGRAPH, maTextStyleName);
+            XMLPropStyleContext* pStyle = const_cast<XMLPropStyleContext*>(dynamic_cast<const XMLPropStyleContext*>( pTempStyle ) ); // use temp var, PTR_CAST is a bad macro, FindStyleChildContext will be called twice
+            if( pStyle == nullptr )
+                break;
+
+            // set PropertySet on object
+            pStyle->FillPropertySet(xPropSet);
+
+        } while(false);
+    }
+    catch(const uno::Exception&)
+    {
+    }
+}
+
+void SdXMLShapeContext::SetLayer()
+{
+    if( maLayerName.isEmpty() )
+        return;
+
+    try
+    {
+        uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
+        if(xPropSet.is() )
+        {
+            xPropSet->setPropertyValue("LayerName", Any(maLayerName));
+            return;
+        }
+    }
+    catch(const uno::Exception&)
+    {
+    }
+}
+
+void SdXMLShapeContext::SetThumbnail()
+{
+    if( maThumbnailURL.isEmpty() )
+        return;
+
+    try
+    {
+        uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
+        if( !xPropSet.is() )
+            return;
+
+        uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
+        if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName( "ThumbnailGraphic" ) )
+        {
+            // load the thumbnail graphic and export it to a wmf stream so we can set
+            // it at the api
+
+            uno::Reference<graphic::XGraphic> xGraphic = GetImport().loadGraphicByURL(maThumbnailURL);
+            xPropSet->setPropertyValue("ThumbnailGraphic", uno::Any(xGraphic));
+        }
+    }
+    catch(const uno::Exception&)
+    {
+    }
+}
+
+// this is called from the parent group for each unparsed attribute in the attribute list
+bool SdXMLShapeContext::processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & aIter )
+{
+    sal_Int32 nTmp;
+    switch (aIter.getToken())
+    {
+        case XML_ELEMENT(DRAW, XML_ZINDEX):
+        case XML_ELEMENT(DRAW_EXT, XML_ZINDEX):
+            mnZOrder = aIter.toInt32();
+            break;
+        case XML_ELEMENT(DRAW, XML_ID):
+        case XML_ELEMENT(DRAW_EXT, XML_ID):
+            if (!mbHaveXmlId) { maShapeId = aIter.toString(); }
+            break;
+        case XML_ELEMENT(DRAW, XML_NAME):
+        case XML_ELEMENT(DRAW_EXT, XML_NAME):
+            maShapeName = aIter.toString();
+            break;
+        case XML_ELEMENT(DRAW, XML_STYLE_NAME):
+        case XML_ELEMENT(DRAW_EXT, XML_STYLE_NAME):
+            maDrawStyleName = aIter.toString();
+            break;
+        case XML_ELEMENT(DRAW, XML_TEXT_STYLE_NAME):
+        case XML_ELEMENT(DRAW_EXT, XML_TEXT_STYLE_NAME):
+            maTextStyleName = aIter.toString();
+            break;
+        case XML_ELEMENT(DRAW, XML_LAYER):
+        case XML_ELEMENT(DRAW_EXT, XML_LAYER):
+            maLayerName = aIter.toString();
+            break;
+        case XML_ELEMENT(DRAW, XML_TRANSFORM):
+        case XML_ELEMENT(DRAW_EXT, XML_TRANSFORM):
+            mnTransform.SetString(aIter.toString(), GetImport().GetMM100UnitConverter());
+            break;
+        case XML_ELEMENT(DRAW, XML_DISPLAY):
+        case XML_ELEMENT(DRAW_EXT, XML_DISPLAY):
+            mbVisible = IsXMLToken( aIter, XML_ALWAYS ) || IsXMLToken( aIter, XML_SCREEN );
+            mbPrintable = IsXMLToken( aIter, XML_ALWAYS ) || IsXMLToken( aIter, XML_PRINTER );
+            break;
+        case XML_ELEMENT(PRESENTATION, XML_USER_TRANSFORMED):
+            mbIsUserTransformed = IsXMLToken( aIter, XML_TRUE );
+            break;
+        case XML_ELEMENT(PRESENTATION, XML_PLACEHOLDER):
+            mbIsPlaceholder = IsXMLToken( aIter, XML_TRUE );
+            if( mbIsPlaceholder )
+                mbClearDefaultAttributes = false;
+            break;
+        case XML_ELEMENT(PRESENTATION, XML_CLASS):
+            maPresentationClass = aIter.toString();
+            break;
+        case XML_ELEMENT(PRESENTATION, XML_STYLE_NAME):
+            maDrawStyleName = aIter.toString();
+            mnStyleFamily = XmlStyleFamily::SD_PRESENTATION_ID;
+            break;
+        case XML_ELEMENT(SVG, XML_X):
+        case XML_ELEMENT(SVG_COMPAT, XML_X):
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    maPosition.X, aIter.toView());
+            break;
+        case XML_ELEMENT(SVG, XML_Y):
+        case XML_ELEMENT(SVG_COMPAT, XML_Y):
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    maPosition.Y, aIter.toView());
+            break;
+        case XML_ELEMENT(SVG, XML_WIDTH):
+        case XML_ELEMENT(SVG_COMPAT, XML_WIDTH):
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    maSize.Width, aIter.toView());
+            if (maSize.Width > 0)
+                maSize.Width = o3tl::saturating_add<sal_Int32>(maSize.Width, 1);
+            else if (maSize.Width < 0)
+                maSize.Width = o3tl::saturating_add<sal_Int32>(maSize.Width, -1);
+            break;
+        case XML_ELEMENT(SVG, XML_HEIGHT):
+        case XML_ELEMENT(SVG_COMPAT, XML_HEIGHT):
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    maSize.Height, aIter.toView());
+            if (maSize.Height > 0)
+                maSize.Height = o3tl::saturating_add<sal_Int32>(maSize.Height, 1);
+            else if (maSize.Height < 0)
+                maSize.Height = o3tl::saturating_add<sal_Int32>(maSize.Height, -1);
+            break;
+        case XML_ELEMENT(SVG, XML_TRANSFORM):
+        case XML_ELEMENT(SVG_COMPAT, XML_TRANSFORM):
+            // because of #85127# take svg:transform into account and handle like
+            // draw:transform for compatibility
+            mnTransform.SetString(aIter.toString(), GetImport().GetMM100UnitConverter());
+            break;
+        case XML_ELEMENT(STYLE, XML_REL_WIDTH):
+            if (sax::Converter::convertPercent(nTmp, aIter.toView()))
+                mnRelWidth = static_cast<sal_Int16>(nTmp);
+            break;
+        case XML_ELEMENT(STYLE, XML_REL_HEIGHT):
+            if (sax::Converter::convertPercent(nTmp, aIter.toView()))
+                mnRelHeight = static_cast<sal_Int16>(nTmp);
+            break;
+        case XML_ELEMENT(NONE, XML_ID):
+        case XML_ELEMENT(XML, XML_ID):
+            maShapeId = aIter.toString();
+            mbHaveXmlId = true;
+            break;
+        default:
+            return false;
+    }
+    return true;
+}
+
+bool SdXMLShapeContext::isPresentationShape() const
+{
+    if( !maPresentationClass.isEmpty() && const_cast<SdXMLShapeContext*>(this)->GetImport().GetShapeImport()->IsPresentationShapesSupported() )
+    {
+        if(XmlStyleFamily::SD_PRESENTATION_ID == mnStyleFamily)
+        {
+            return true;
+        }
+
+        if( IsXMLToken( maPresentationClass, XML_HEADER ) || IsXMLToken( maPresentationClass, XML_FOOTER ) ||
+            IsXMLToken( maPresentationClass, XML_PAGE_NUMBER ) || IsXMLToken( maPresentationClass, XML_DATE_TIME ) )
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+SdXMLRectShapeContext::SdXMLRectShapeContext(
+    SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes,
+    bool bTemporaryShape)
+:   SdXMLShapeContext( rImport, xAttrList, rShapes, bTemporaryShape ),
+    mnRadius( 0 )
+{
+}
+
+SdXMLRectShapeContext::~SdXMLRectShapeContext()
+{
+}
+
+// this is called from the parent group for each unparsed attribute in the attribute list
+bool SdXMLRectShapeContext::processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & aIter )
+{
+    switch (aIter.getToken())
+    {
+        case XML_ELEMENT(DRAW, XML_CORNER_RADIUS):
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    mnRadius, aIter.toView());
+            break;
+        default:
+            return SdXMLShapeContext::processAttribute( aIter );
+    }
+    return true;
+}
+
+void SdXMLRectShapeContext::startFastElement (sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
+{
+    // create rectangle shape
+    AddShape("com.sun.star.drawing.RectangleShape");
+    if(!mxShape.is())
+        return;
+
+    // Add, set Style and properties from base shape
+    SetStyle();
+    SetLayer();
+
+    // set pos, size, shear and rotate
+    SetTransformation();
+
+    if(mnRadius)
+    {
+        uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
+        if(xPropSet.is())
+        {
+            try
+            {
+                xPropSet->setPropertyValue("CornerRadius", uno::Any( mnRadius ) );
+            }
+            catch(const uno::Exception&)
+            {
+                DBG_UNHANDLED_EXCEPTION( "xmloff", "setting corner radius");
+            }
+        }
+    }
+    SdXMLShapeContext::startFastElement(nElement, xAttrList);
+}
+
+
+SdXMLLineShapeContext::SdXMLLineShapeContext(
+    SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes,
+    bool bTemporaryShape)
+:   SdXMLShapeContext( rImport, xAttrList, rShapes, bTemporaryShape ),
+    mnX1( 0 ),
+    mnY1( 0 ),
+    mnX2( 1 ),
+    mnY2( 1 )
+{
+}
+
+SdXMLLineShapeContext::~SdXMLLineShapeContext()
+{
+}
+
+// this is called from the parent group for each unparsed attribute in the attribute list
+bool SdXMLLineShapeContext::processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & aIter )
+{
+    switch (aIter.getToken())
+    {
+        case XML_ELEMENT(SVG, XML_X1):
+        case XML_ELEMENT(SVG_COMPAT, XML_X1):
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    mnX1, aIter.toView());
+            break;
+        case XML_ELEMENT(SVG, XML_Y1):
+        case XML_ELEMENT(SVG_COMPAT, XML_Y1):
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    mnY1, aIter.toView());
+            break;
+        case XML_ELEMENT(SVG, XML_X2):
+        case XML_ELEMENT(SVG_COMPAT, XML_X2):
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    mnX2, aIter.toView());
+            break;
+        case XML_ELEMENT(SVG, XML_Y2):
+        case XML_ELEMENT(SVG_COMPAT, XML_Y2):
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    mnY2, aIter.toView());
+            break;
+        default:
+            return SdXMLShapeContext::processAttribute( aIter );
+    }
+    return true;
+}
+
+void SdXMLLineShapeContext::startFastElement (sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
+{
+    // #85920# use SetTransformation() to handle import of simple lines.
+    // This is necessary to take into account all anchor positions and
+    // other things. All shape imports use the same import schemata now.
+    // create necessary shape (Line Shape)
+    AddShape("com.sun.star.drawing.PolyLineShape");
+
+    if(!mxShape.is())
+        return;
+
+    // Add, set Style and properties from base shape
+    SetStyle();
+    SetLayer();
+
+    // get sizes and offsets
+    awt::Point aTopLeft(mnX1, mnY1);
+    awt::Point aBottomRight(mnX2, mnY2);
+
+    if(mnX1 > mnX2)
+    {
+        aTopLeft.X = mnX2;
+        aBottomRight.X = mnX1;
+    }
+
+    if(mnY1 > mnY2)
+    {
+        aTopLeft.Y = mnY2;
+        aBottomRight.Y = mnY1;
+    }
+
+    // set local parameters on shape
+    uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
+    if(xPropSet.is())
+    {
+        drawing::PointSequenceSequence aPolyPoly(1);
+        drawing::PointSequence* pOuterSequence = aPolyPoly.getArray();
+        pOuterSequence->realloc(2);
+        awt::Point* pInnerSequence = pOuterSequence->getArray();
+
+        *pInnerSequence = awt::Point(o3tl::saturating_sub(mnX1, aTopLeft.X), o3tl::saturating_sub(mnY1, aTopLeft.Y));
+        pInnerSequence++;
+        *pInnerSequence = awt::Point(o3tl::saturating_sub(mnX2, aTopLeft.X), o3tl::saturating_sub(mnY2, aTopLeft.Y));
+
+        xPropSet->setPropertyValue("Geometry", Any(aPolyPoly));
+    }
+
+    // Size is included in point coordinates
+    maSize.Width = 1;
+    maSize.Height = 1;
+    maPosition.X = aTopLeft.X;
+    maPosition.Y = aTopLeft.Y;
+
+    // set pos, size, shear and rotate and get copy of matrix
+    SetTransformation();
+
+    SdXMLShapeContext::startFastElement(nElement, xAttrList);
+}
+
+
+SdXMLEllipseShapeContext::SdXMLEllipseShapeContext(
+    SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes,
+    bool bTemporaryShape)
+:   SdXMLShapeContext( rImport, xAttrList, rShapes, bTemporaryShape ),
+    mnCX( 0 ),
+    mnCY( 0 ),
+    mnRX( 1 ),
+    mnRY( 1 ),
+    meKind( drawing::CircleKind_FULL ),
+    mnStartAngle( 0 ),
+    mnEndAngle( 0 )
+{
+}
+
+SdXMLEllipseShapeContext::~SdXMLEllipseShapeContext()
+{
+}
+
+// this is called from the parent group for each unparsed attribute in the attribute list
+bool SdXMLEllipseShapeContext::processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & aIter )
+{
+    switch (aIter.getToken())
+    {
+        case XML_ELEMENT(SVG, XML_RX):
+        case XML_ELEMENT(SVG_COMPAT, XML_RX):
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    mnRX, aIter.toView());
+            break;
+        case XML_ELEMENT(SVG, XML_RY):
+        case XML_ELEMENT(SVG_COMPAT, XML_RY):
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    mnRY, aIter.toView());
+            break;
+        case XML_ELEMENT(SVG, XML_CX):
+        case XML_ELEMENT(SVG_COMPAT, XML_CX):
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    mnCX, aIter.toView());
+            break;
+        case XML_ELEMENT(SVG, XML_CY):
+        case XML_ELEMENT(SVG_COMPAT, XML_CY):
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    mnCY, aIter.toView());
+            break;
+        case XML_ELEMENT(SVG, XML_R):
+        case XML_ELEMENT(SVG_COMPAT, XML_R):
+            // single radius, it's a circle and both radii are the same
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    mnRX, aIter.toView());
+            mnRY = mnRX;
+            break;
+        case XML_ELEMENT(DRAW, XML_KIND):
+            SvXMLUnitConverter::convertEnum( meKind, aIter.toView(), aXML_CircleKind_EnumMap );
+            break;
+        case XML_ELEMENT(DRAW, XML_START_ANGLE):
+        {
+            double dStartAngle;
+            if (::sax::Converter::convertDouble( dStartAngle, aIter.toView() ))
+                mnStartAngle = static_cast<sal_Int32>(dStartAngle * 100.0);
+            break;
+        }
+        case XML_ELEMENT(DRAW, XML_END_ANGLE):
+        {
+            double dEndAngle;
+            if (::sax::Converter::convertDouble( dEndAngle, aIter.toView() ))
+                mnEndAngle = static_cast<sal_Int32>(dEndAngle * 100.0);
+            break;
+        }
+        default:
+            return SdXMLShapeContext::processAttribute( aIter );
+    }
+    return true;
+}
+
+void SdXMLEllipseShapeContext::startFastElement (sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
+{
+    // create rectangle shape
+    AddShape("com.sun.star.drawing.EllipseShape");
+    if(!mxShape.is())
+        return;
+
+    // Add, set Style and properties from base shape
+    SetStyle();
+    SetLayer();
+
+    if(mnCX != 0 || mnCY != 0 || mnRX != 1 || mnRY != 1)
+    {
+        // #i121972# center/radius is used, put to pos and size
+        maSize.Width = 2 * mnRX;
+        maSize.Height = 2 * mnRY;
+        maPosition.X = mnCX - mnRX;
+        maPosition.Y = mnCY - mnRY;
+    }
+    // set pos, size, shear and rotate
+    SetTransformation();
+
+    if( meKind != drawing::CircleKind_FULL )
+    {
+        uno::Reference< beans::XPropertySet > xPropSet( mxShape, uno::UNO_QUERY );
+        if( xPropSet.is() )
+        {
+            // calculate the correct start and end angle
+            sal_Int32 mnOldStartAngle = mnStartAngle;
+            sal_Int32 mnOldEndAngle = mnEndAngle;
+            basegfx::B2DTuple aScale;
+            basegfx::B2DTuple aTranslate;
+            double fRotate;
+            double fShearX;
+            maUsedTransformation.decompose(aScale, aTranslate, fRotate, fShearX);
+            if (aScale.getX() < 0 || aScale.getY() < 0)
+            {
+                // The angle for a horizontal flip is the same as the angle for a
+                // vertical flip because a vertical flip is treated as a horizontal
+                // flip plus a rotation.
+
+                // To perform the flip, the start and end angle are switched and we
+                // use the fact performing a horizontal flip on a shape will change
+                // the angle that a radius makes with the origin to 180 degrees
+                // minus that angle (we use 54000 hundredths of a degree to get the
+                // modulus operation to give a value between 0 and 36000).
+
+                mnStartAngle = (54000 - mnOldEndAngle) % 36000;
+                mnEndAngle = (54000 - mnOldStartAngle) % 36000;
+            }
+
+            xPropSet->setPropertyValue("CircleKind", Any( meKind) );
+            xPropSet->setPropertyValue("CircleStartAngle", Any(mnStartAngle) );
+            xPropSet->setPropertyValue("CircleEndAngle", Any(mnEndAngle) );
+        }
+    }
+
+    SdXMLShapeContext::startFastElement(nElement, xAttrList);
+}
+
+
+SdXMLPolygonShapeContext::SdXMLPolygonShapeContext(
+    SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes, bool bClosed, bool bTemporaryShape)
+:   SdXMLShapeContext( rImport, xAttrList, rShapes, bTemporaryShape ),
+    mbClosed( bClosed )
+{
+}
+
+// this is called from the parent group for each unparsed attribute in the attribute list
+bool SdXMLPolygonShapeContext::processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & aIter )
+{
+    switch (aIter.getToken())
+    {
+        case XML_ELEMENT(SVG, XML_VIEWBOX):
+        case XML_ELEMENT(SVG_COMPAT, XML_VIEWBOX):
+            maViewBox = aIter.toString();
+            break;
+        case XML_ELEMENT(DRAW, XML_POINTS):
+            maPoints = aIter.toString();
+            break;
+        default:
+            return SdXMLShapeContext::processAttribute( aIter);
+    }
+    return true;
+}
+
+SdXMLPolygonShapeContext::~SdXMLPolygonShapeContext()
+{
+}
+
+void SdXMLPolygonShapeContext::startFastElement (sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
+{
+    // Add, set Style and properties from base shape
+    if(mbClosed)
+        AddShape("com.sun.star.drawing.PolyPolygonShape");
+    else
+        AddShape("com.sun.star.drawing.PolyLineShape");
+
+    if( !mxShape.is() )
+        return;
+
+    SetStyle();
+    SetLayer();
+
+    // set local parameters on shape
+    uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
+    if(xPropSet.is())
+    {
+        // set polygon
+        if(!maPoints.isEmpty() && !maViewBox.isEmpty())
+        {
+            const SdXMLImExViewBox aViewBox(maViewBox, GetImport().GetMM100UnitConverter());
+            basegfx::B2DVector aSize(aViewBox.GetWidth(), aViewBox.GetHeight());
+
+            // Is this correct? It overrides ViewBox stuff; OTOH it makes no
+            // sense to have the geometry content size different from object size
+            if(maSize.Width != 0 && maSize.Height != 0)
+            {
+                aSize = basegfx::B2DVector(maSize.Width, maSize.Height);
+            }
+
+            basegfx::B2DPolygon aPolygon;
+
+            if(basegfx::utils::importFromSvgPoints(aPolygon, maPoints))
+            {
+                if(aPolygon.count())
+                {
+                    const basegfx::B2DRange aSourceRange(
+                        aViewBox.GetX(), aViewBox.GetY(),
+                        aViewBox.GetX() + aViewBox.GetWidth(), aViewBox.GetY() + aViewBox.GetHeight());
+                    const basegfx::B2DRange aTargetRange(
+                        aViewBox.GetX(), aViewBox.GetY(),
+                        aViewBox.GetX() + aSize.getX(), aViewBox.GetY() + aSize.getY());
+
+                    if(!aSourceRange.equal(aTargetRange))
+                    {
+                        aPolygon.transform(
+                            basegfx::utils::createSourceRangeTargetRangeTransform(
+                                aSourceRange,
+                                aTargetRange));
+                    }
+
+                    css::drawing::PointSequenceSequence aPointSequenceSequence;
+                    basegfx::utils::B2DPolyPolygonToUnoPointSequenceSequence(basegfx::B2DPolyPolygon(aPolygon), aPointSequenceSequence);
+                    xPropSet->setPropertyValue("Geometry", Any(aPointSequenceSequence));
+                    // Size is now contained in the point coordinates, adapt maSize for
+                    // to use the correct transformation matrix in SetTransformation()
+                    maSize.Width = 1;
+                    maSize.Height = 1;
+                }
+            }
+        }
+    }
+
+    // set pos, size, shear and rotate and get copy of matrix
+    SetTransformation();
+
+    SdXMLShapeContext::startFastElement(nElement, xAttrList);
+}
+
+
+SdXMLPathShapeContext::SdXMLPathShapeContext(
+    SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes,
+    bool bTemporaryShape)
+:   SdXMLShapeContext( rImport, xAttrList, rShapes, bTemporaryShape )
+{
+}
+
+SdXMLPathShapeContext::~SdXMLPathShapeContext()
+{
+}
+
+// this is called from the parent group for each unparsed attribute in the attribute list
+bool SdXMLPathShapeContext::processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & aIter )
+{
+    switch (aIter.getToken())
+    {
+        case XML_ELEMENT(SVG, XML_VIEWBOX):
+        case XML_ELEMENT(SVG_COMPAT, XML_VIEWBOX):
+            maViewBox = aIter.toString();
+            break;
+        case XML_ELEMENT(SVG, XML_D):
+        case XML_ELEMENT(SVG_COMPAT, XML_D):
+            maD = aIter.toString();
+            break;
+        default:
+            return SdXMLShapeContext::processAttribute( aIter );
+    }
+    return true;
+}
+
+void SdXMLPathShapeContext::startFastElement (sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
+{
+    // create polygon shape
+    if(maD.isEmpty())
+        return;
+
+    const SdXMLImExViewBox aViewBox(maViewBox, GetImport().GetMM100UnitConverter());
+    basegfx::B2DVector aSize(aViewBox.GetWidth(), aViewBox.GetHeight());
+
+    // Is this correct? It overrides ViewBox stuff; OTOH it makes no
+    // sense to have the geometry content size different from object size
+    if(maSize.Width != 0 && maSize.Height != 0)
+    {
+        aSize = basegfx::B2DVector(maSize.Width, maSize.Height);
+    }
+
+    basegfx::B2DPolyPolygon aPolyPolygon;
+
+    if(!basegfx::utils::importFromSvgD(aPolyPolygon, maD, GetImport().needFixPositionAfterZ(), nullptr))
+        return;
+
+    if(!aPolyPolygon.count())
+        return;
+
+    const basegfx::B2DRange aSourceRange(
+        aViewBox.GetX(), aViewBox.GetY(),
+        aViewBox.GetX() + aViewBox.GetWidth(), aViewBox.GetY() + aViewBox.GetHeight());
+    const basegfx::B2DRange aTargetRange(
+        aViewBox.GetX(), aViewBox.GetY(),
+        aViewBox.GetX() + aSize.getX(), aViewBox.GetY() + aSize.getY());
+
+    if(!aSourceRange.equal(aTargetRange))
+    {
+        aPolyPolygon.transform(
+            basegfx::utils::createSourceRangeTargetRangeTransform(
+                aSourceRange,
+                aTargetRange));
+    }
+
+    // create shape
+    OUString service;
+
+    if(aPolyPolygon.areControlPointsUsed())
+    {
+        if(aPolyPolygon.isClosed())
+        {
+            service = "com.sun.star.drawing.ClosedBezierShape";
+        }
+        else
+        {
+            service = "com.sun.star.drawing.OpenBezierShape";
+        }
+    }
+    else
+    {
+        if(aPolyPolygon.isClosed())
+        {
+            service = "com.sun.star.drawing.PolyPolygonShape";
+        }
+        else
+        {
+            service = "com.sun.star.drawing.PolyLineShape";
+        }
+    }
+
+    // Add, set Style and properties from base shape
+    AddShape(service);
+
+    // #89344# test for mxShape.is() and not for mxShapes.is() to support
+    // shape import helper classes WITHOUT XShapes (member mxShapes). This
+    // is used by the writer.
+    if( !mxShape.is() )
+        return;
+
+    SetStyle();
+    SetLayer();
+
+    // set local parameters on shape
+    uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
+
+    if(xPropSet.is())
+    {
+        uno::Any aAny;
+
+        // set polygon data
+        if(aPolyPolygon.areControlPointsUsed())
+        {
+            drawing::PolyPolygonBezierCoords aSourcePolyPolygon;
+
+            basegfx::utils::B2DPolyPolygonToUnoPolyPolygonBezierCoords(
+                aPolyPolygon,
+                aSourcePolyPolygon);
+            aAny <<= aSourcePolyPolygon;
+        }
+        else
+        {
+            drawing::PointSequenceSequence aSourcePolyPolygon;
+
+            basegfx::utils::B2DPolyPolygonToUnoPointSequenceSequence(
+                aPolyPolygon,
+                aSourcePolyPolygon);
+            aAny <<= aSourcePolyPolygon;
+        }
+
+        xPropSet->setPropertyValue("Geometry", aAny);
+        // Size is now contained in the point coordinates, adapt maSize for
+        // to use the correct transformation matrix in SetTransformation()
+        maSize.Width = 1;
+        maSize.Height = 1;
+    }
+
+    // set pos, size, shear and rotate
+    SetTransformation();
+
+    SdXMLShapeContext::startFastElement(nElement, xAttrList);
+}
+
+
+SdXMLTextBoxShapeContext::SdXMLTextBoxShapeContext(
+    SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes)
+:   SdXMLShapeContext( rImport, xAttrList, rShapes, false/*bTemporaryShape*/ ),
+    mnRadius(0),
+    maChainNextName("")
+{
+}
+
+SdXMLTextBoxShapeContext::~SdXMLTextBoxShapeContext()
+{
+}
+
+// this is called from the parent group for each unparsed attribute in the attribute list
+bool SdXMLTextBoxShapeContext::processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & aIter )
+{
+    switch (aIter.getToken())
+    {
+        case XML_ELEMENT(DRAW, XML_CORNER_RADIUS):
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    mnRadius, aIter.toView());
+            break;
+        case XML_ELEMENT(DRAW, XML_CHAIN_NEXT_NAME):
+            maChainNextName = aIter.toString();
+            break;
+        default:
+            return SdXMLShapeContext::processAttribute( aIter );
+    }
+    return true;
+}
+
+void SdXMLTextBoxShapeContext::startFastElement (sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
+{
+    // create textbox shape
+    bool bIsPresShape = false;
+    bool bClearText = false;
+
+    OUString service;
+
+    if( isPresentationShape() )
+    {
+        // check if the current document supports presentation shapes
+        if( GetImport().GetShapeImport()->IsPresentationShapesSupported() )
+        {
+            if( IsXMLToken( maPresentationClass, XML_SUBTITLE ))
+            {
+                // XmlShapeTypePresSubtitleShape
+                service = "com.sun.star.presentation.SubtitleShape";
+            }
+            else if( IsXMLToken( maPresentationClass, XML_PRESENTATION_OUTLINE ) )
+            {
+                // XmlShapeTypePresOutlinerShape
+                service = "com.sun.star.presentation.OutlinerShape";
+            }
+            else if( IsXMLToken( maPresentationClass, XML_NOTES ) )
+            {
+                // XmlShapeTypePresNotesShape
+                service = "com.sun.star.presentation.NotesShape";
+            }
+            else if( IsXMLToken( maPresentationClass, XML_HEADER ) )
+            {
+                // XmlShapeTypePresHeaderShape
+                service = "com.sun.star.presentation.HeaderShape";
+                bClearText = true;
+            }
+            else if( IsXMLToken( maPresentationClass, XML_FOOTER ) )
+            {
+                // XmlShapeTypePresFooterShape
+                service = "com.sun.star.presentation.FooterShape";
+                bClearText = true;
+            }
+            else if( IsXMLToken( maPresentationClass, XML_PAGE_NUMBER ) )
+            {
+                // XmlShapeTypePresSlideNumberShape
+                service = "com.sun.star.presentation.SlideNumberShape";
+                bClearText = true;
+            }
+            else if( IsXMLToken( maPresentationClass, XML_DATE_TIME ) )
+            {
+                // XmlShapeTypePresDateTimeShape
+                service = "com.sun.star.presentation.DateTimeShape";
+                bClearText = true;
+            }
+            else //  IsXMLToken( maPresentationClass, XML_TITLE ) )
+            {
+                // XmlShapeTypePresTitleTextShape
+                service = "com.sun.star.presentation.TitleTextShape";
+            }
+            bIsPresShape = true;
+        }
+    }
+
+    if( service.isEmpty() )
+    {
+        // normal text shape
+        service = "com.sun.star.drawing.TextShape";
+    }
+
+    // Add, set Style and properties from base shape
+    AddShape(service);
+
+    if( !mxShape.is() )
+        return;
+
+    SetStyle();
+    SetLayer();
+
+    if(bIsPresShape)
+    {
+        uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY);
+        if(xProps.is())
+        {
+            uno::Reference< beans::XPropertySetInfo > xPropsInfo( xProps->getPropertySetInfo() );
+            if( xPropsInfo.is() )
+            {
+                if( !mbIsPlaceholder && xPropsInfo->hasPropertyByName("IsEmptyPresentationObject"))
+                    xProps->setPropertyValue("IsEmptyPresentationObject", css::uno::Any(false) );
+
+                if( mbIsUserTransformed && xPropsInfo->hasPropertyByName("IsPlaceholderDependent"))
+                    xProps->setPropertyValue("IsPlaceholderDependent", css::uno::Any(false) );
+            }
+        }
+    }
+
+    if( bClearText )
+    {
+        uno::Reference< text::XText > xText( mxShape, uno::UNO_QUERY );
+        xText->setString( "" );
+    }
+
+    // set parameters on shape
+//A AW->CL: Eventually You need to strip scale and translate from the transformation
+//A to reach the same goal again.
+//A     if(!bIsPresShape || mbIsUserTransformed)
+//A     {
+//A         // set pos and size on shape, this should remove binding
+//A         // to pres object on masterpage
+//A         SetSizeAndPosition();
+//A     }
+
+    // set pos, size, shear and rotate
+    SetTransformation();
+
+    if(mnRadius)
+    {
+        uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
+        if(xPropSet.is())
+        {
+            try
+            {
+                xPropSet->setPropertyValue("CornerRadius", uno::Any( mnRadius ) );
+            }
+            catch(const uno::Exception&)
+            {
+                DBG_UNHANDLED_EXCEPTION( "xmloff", "setting corner radius");
+            }
+        }
+    }
+
+    if(!maChainNextName.isEmpty())
+    {
+        uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
+        if(xPropSet.is())
+        {
+            try
+            {
+                xPropSet->setPropertyValue("TextChainNextName",
+                                           uno::Any( maChainNextName ) );
+            }
+            catch(const uno::Exception&)
+            {
+                DBG_UNHANDLED_EXCEPTION( "xmloff", "setting name of next chain link");
+            }
+        }
+    }
+
+    SdXMLShapeContext::startFastElement(nElement, xAttrList);
+}
+
+
+SdXMLControlShapeContext::SdXMLControlShapeContext(
+    SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes,
+    bool bTemporaryShape)
+:   SdXMLShapeContext( rImport, xAttrList, rShapes, bTemporaryShape )
+{
+}
+
+SdXMLControlShapeContext::~SdXMLControlShapeContext()
+{
+}
+
+// this is called from the parent group for each unparsed attribute in the attribute list
+bool SdXMLControlShapeContext::processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & aIter )
+{
+    switch (aIter.getToken())
+    {
+        case XML_ELEMENT(DRAW, XML_CONTROL):
+            maFormId = aIter.toString();
+            break;
+        default:
+            return SdXMLShapeContext::processAttribute( aIter );
+    }
+    return true;
+}
+
+void SdXMLControlShapeContext::startFastElement (sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
+{
+    // create Control shape
+    // add, set style and properties from base shape
+    AddShape("com.sun.star.drawing.ControlShape");
+    if( !mxShape.is() )
+        return;
+
+    SAL_WARN_IF( !!maFormId.isEmpty(), "xmloff", "draw:control without a form:id attribute!" );
+    if( !maFormId.isEmpty() )
+    {
+        if( GetImport().IsFormsSupported() )
+        {
+            uno::Reference< awt::XControlModel > xControlModel( GetImport().GetFormImport()->lookupControl( maFormId ), uno::UNO_QUERY );
+            if( xControlModel.is() )
+            {
+                uno::Reference< drawing::XControlShape > xControl( mxShape, uno::UNO_QUERY );
+                if( xControl.is() )
+                    xControl->setControl(  xControlModel );
+
+            }
+        }
+    }
+
+    SetStyle();
+    SetLayer();
+
+    // set pos, size, shear and rotate
+    SetTransformation();
+
+    SdXMLShapeContext::startFastElement(nElement, xAttrList);
+}
+
+
+SdXMLConnectorShapeContext::SdXMLConnectorShapeContext(
+    SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes,
+    bool bTemporaryShape)
+:   SdXMLShapeContext( rImport, xAttrList, rShapes, bTemporaryShape ),
+    maStart(0,0),
+    maEnd(1,1),
+    mnType( drawing::ConnectorType_STANDARD ),
+    mnStartGlueId(-1),
+    mnEndGlueId(-1),
+    mnDelta1(0),
+    mnDelta2(0),
+    mnDelta3(0)
+{
+}
+
+SdXMLConnectorShapeContext::~SdXMLConnectorShapeContext()
+{
+}
+
+bool SvXMLImport::needFixPositionAfterZ() const
+{
+    bool bWrongPositionAfterZ( false );
+    sal_Int32 nUPD( 0 );
+    sal_Int32 nBuildId( 0 );
+    if ( getBuildIds( nUPD, nBuildId ) && // test OOo and old versions of LibO and AOO
+       ( ( ( nUPD == 641 ) || ( nUPD == 645 ) || ( nUPD == 680 ) || ( nUPD == 300 ) ||
+           ( nUPD == 310 ) || ( nUPD == 320 ) || ( nUPD == 330 ) || ( nUPD == 340 ) ||
+           ( nUPD == 350 && nBuildId < 202 ) )
+       || (getGeneratorVersion() == SvXMLImport::AOO_40x))) // test if AOO 4.0.x
+           // apparently bug was fixed in AOO by i#123433 f15874d8f976f3874bdbcb53429eeefa65c28841
+    {
+        bWrongPositionAfterZ = true;
+    }
+    return bWrongPositionAfterZ;
+}
+
+
+// this is called from the parent group for each unparsed attribute in the attribute list
+bool SdXMLConnectorShapeContext::processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & aIter )
+{
+    switch( aIter.getToken() )
+    {
+        case XML_ELEMENT(DRAW, XML_START_SHAPE):
+            maStartShapeId = aIter.toString();
+            break;
+        case XML_ELEMENT(DRAW, XML_START_GLUE_POINT):
+            mnStartGlueId = aIter.toInt32();
+            break;
+        case XML_ELEMENT(DRAW, XML_END_SHAPE):
+            maEndShapeId = aIter.toString();
+            break;
+        case XML_ELEMENT(DRAW, XML_END_GLUE_POINT):
+            mnEndGlueId = aIter.toInt32();
+            break;
+        case XML_ELEMENT(DRAW, XML_LINE_SKEW):
+        {
+            OUString sValue = aIter.toString();
+            SvXMLTokenEnumerator aTokenEnum( sValue );
+            std::u16string_view aToken;
+            if( aTokenEnum.getNextToken( aToken ) )
+            {
+                GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                        mnDelta1, aToken);
+                if( aTokenEnum.getNextToken( aToken ) )
+                {
+                    GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                            mnDelta2, aToken);
+                    if( aTokenEnum.getNextToken( aToken ) )
+                    {
+                        GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                                mnDelta3, aToken);
+                    }
+                }
+            }
+            break;
+        }
+        case XML_ELEMENT(DRAW, XML_TYPE):
+        {
+            (void)SvXMLUnitConverter::convertEnum( mnType, aIter.toView(), aXML_ConnectionKind_EnumMap );
+            break;
+        }
+        // #121965# draw:transform may be used in ODF1.2, e.g. exports from MS seem to use these
+        case XML_ELEMENT(DRAW, XML_TRANSFORM):
+            mnTransform.SetString(aIter.toString(), GetImport().GetMM100UnitConverter());
+            break;
+
+        case XML_ELEMENT(SVG, XML_X1):
+        case XML_ELEMENT(SVG_COMPAT, XML_X1):
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    maStart.X, aIter.toView());
+            break;
+        case XML_ELEMENT(SVG, XML_Y1):
+        case XML_ELEMENT(SVG_COMPAT, XML_Y1):
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    maStart.Y, aIter.toView());
+            break;
+        case XML_ELEMENT(SVG, XML_X2):
+        case XML_ELEMENT(SVG_COMPAT, XML_X2):
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    maEnd.X, aIter.toView());
+            break;
+        case XML_ELEMENT(SVG, XML_Y2):
+        case XML_ELEMENT(SVG_COMPAT, XML_Y2):
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    maEnd.Y, aIter.toView());
+            break;
+        case XML_ELEMENT(SVG, XML_D):
+        case XML_ELEMENT(SVG_COMPAT, XML_D):
+        {
+            basegfx::B2DPolyPolygon aPolyPolygon;
+
+            if(basegfx::utils::importFromSvgD(aPolyPolygon, aIter.toString(), GetImport().needFixPositionAfterZ(), nullptr))
+            {
+                if(aPolyPolygon.count())
+                {
+                    drawing::PolyPolygonBezierCoords aSourcePolyPolygon;
+
+                    basegfx::utils::B2DPolyPolygonToUnoPolyPolygonBezierCoords(
+                        aPolyPolygon,
+                        aSourcePolyPolygon);
+                    maPath <<= aSourcePolyPolygon;
+                }
+            }
+            break;
+        }
+        default:
+            return SdXMLShapeContext::processAttribute( aIter );
+    }
+    return true;
+}
+
+void SdXMLConnectorShapeContext::startFastElement (sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
+{
+    // For security reasons, do not add empty connectors. There may have been an error in EA2
+    // that created empty, far set off connectors (e.g. 63 meters below top of document). This
+    // is not guaranteed, but it's definitely safe to not add empty connectors.
+    bool bDoAdd(true);
+
+    if(    maStartShapeId.isEmpty()
+        && maEndShapeId.isEmpty()
+        && maStart.X == maEnd.X
+        && maStart.Y == maEnd.Y
+        && 0 == mnDelta1
+        && 0 == mnDelta2
+        && 0 == mnDelta3
+        )
+    {
+        bDoAdd = false;
+    }
+
+    if(!bDoAdd)
+        return;
+
+    // create Connector shape
+    // add, set style and properties from base shape
+    AddShape("com.sun.star.drawing.ConnectorShape");
+    if(!mxShape.is())
+        return;
+
+    // #121965# if draw:transform is used, apply directly to the start
+    // and end positions before using these
+    if(mnTransform.NeedsAction())
+    {
+        // transformation is used, apply to object.
+        ::basegfx::B2DHomMatrix aMat;
+        mnTransform.GetFullTransform(aMat);
+
+        if(!aMat.isIdentity())
+        {
+            basegfx::B2DPoint aStart(maStart.X, maStart.Y);
+            basegfx::B2DPoint aEnd(maEnd.X, maEnd.Y);
+
+            aStart = aMat * aStart;
+            aEnd = aMat * aEnd;
+
+            maStart.X = basegfx::fround(aStart.getX());
+            maStart.Y = basegfx::fround(aStart.getY());
+            maEnd.X = basegfx::fround(aEnd.getX());
+            maEnd.Y = basegfx::fround(aEnd.getY());
+        }
+    }
+
+    // add connection ids
+    if( !maStartShapeId.isEmpty() )
+        GetImport().GetShapeImport()->addShapeConnection( mxShape, true, maStartShapeId, mnStartGlueId );
+    if( !maEndShapeId.isEmpty() )
+        GetImport().GetShapeImport()->addShapeConnection( mxShape, false, maEndShapeId, mnEndGlueId );
+
+    uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY );
+    if( xProps.is() )
+    {
+        xProps->setPropertyValue("StartPosition", Any(maStart));
+        xProps->setPropertyValue("EndPosition", Any(maEnd) );
+        xProps->setPropertyValue("EdgeKind", Any(mnType) );
+        xProps->setPropertyValue("EdgeLine1Delta", Any(mnDelta1) );
+        xProps->setPropertyValue("EdgeLine2Delta", Any(mnDelta2) );
+        xProps->setPropertyValue("EdgeLine3Delta", Any(mnDelta3) );
+    }
+    SetStyle();
+    SetLayer();
+
+    if ( maPath.hasValue() )
+    {
+        // #i115492#
+        // Ignore svg:d attribute for text documents created by OpenOffice.org
+        // versions before OOo 3.3, because these OOo versions are storing
+        // svg:d values not using the correct unit.
+        bool bApplySVGD( true );
+        if ( uno::Reference< text::XTextDocument >(GetImport().GetModel(), uno::UNO_QUERY).is() )
+        {
+            sal_Int32 nUPD( 0 );
+            sal_Int32 nBuild( 0 );
+            const bool bBuildIdFound = GetImport().getBuildIds( nUPD, nBuild );
+            if ( GetImport().IsTextDocInOOoFileFormat() ||
+                 ( bBuildIdFound &&
+                   ( ( nUPD == 641 ) || ( nUPD == 645 ) ||  // prior OOo 2.0
+                     ( nUPD == 680 ) ||                     // OOo 2.x
+                     ( nUPD == 300 ) ||                     // OOo 3.0 - OOo 3.0.1
+                     ( nUPD == 310 ) ||                     // OOo 3.1 - OOo 3.1.1
+                     ( nUPD == 320 ) ) ) )                  // OOo 3.2 - OOo 3.2.1
+            {
+                bApplySVGD = false;
+            }
+        }
+
+        if ( bApplySVGD )
+        {
+            // tdf#83360 use path data only when redundant data of start and end point coordinates of
+            // path start/end and connector start/end is equal. This is to avoid using erraneous
+            // or inconsistent path data at import of foreign formats. Office itself always
+            // writes out a consistent data set. Not using it when there is inconsistency
+            // is okay since the path data is redundant, buffered data just to avoid recalculation
+            // of the connector's layout at load time, no real information would be lost.
+            // A 'connected' end has prio to direct coordinate data in Start/EndPosition
+            // to the path data (which should have the start/end redundant in the path)
+            const drawing::PolyPolygonBezierCoords* pSource = static_cast< const drawing::PolyPolygonBezierCoords* >(maPath.getValue());
+            const sal_uInt32 nSequenceCount(pSource->Coordinates.getLength());
+            bool bStartEqual(false);
+            bool bEndEqual(false);
+
+            if(nSequenceCount)
+            {
+                const drawing::PointSequence& rStartSeq = pSource->Coordinates[0];
+                const sal_uInt32 nStartCount = rStartSeq.getLength();
+
+                if(nStartCount)
+                {
+                    const awt::Point& rStartPoint = rStartSeq.getConstArray()[0];
+
+                    if(rStartPoint.X == maStart.X && rStartPoint.Y == maStart.Y)
+                    {
+                        bStartEqual = true;
+                    }
+                }
+
+                const drawing::PointSequence& rEndSeq = pSource->Coordinates[nSequenceCount - 1];
+                const sal_uInt32 nEndCount = rEndSeq.getLength();
+
+                if(nEndCount)
+                {
+                    const awt::Point& rEndPoint = rEndSeq.getConstArray()[nEndCount - 1];
+
+                    if(rEndPoint.X == maEnd.X && rEndPoint.Y == maEnd.Y)
+                    {
+                        bEndEqual = true;
+                    }
+                }
+            }
+
+            if(!bStartEqual || !bEndEqual)
+            {
+                bApplySVGD = false;
+            }
+        }
+
+        if ( bApplySVGD )
+        {
+            assert(maPath.getValueType() == cppu::UnoType<drawing::PolyPolygonBezierCoords>::get());
+            xProps->setPropertyValue("PolyPolygonBezier", maPath);
+        }
+    }
+
+    SdXMLShapeContext::startFastElement(nElement, xAttrList);
+}
+
+
+SdXMLMeasureShapeContext::SdXMLMeasureShapeContext(
+    SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes,
+    bool bTemporaryShape)
+:   SdXMLShapeContext( rImport, xAttrList, rShapes, bTemporaryShape ),
+    maStart(0,0),
+    maEnd(1,1)
+{
+}
+
+SdXMLMeasureShapeContext::~SdXMLMeasureShapeContext()
+{
+}
+
+// this is called from the parent group for each unparsed attribute in the attribute list
+bool SdXMLMeasureShapeContext::processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & aIter )
+{
+    switch( aIter.getToken() )
+    {
+        case XML_ELEMENT(SVG, XML_X1):
+        case XML_ELEMENT(SVG_COMPAT, XML_X1):
+        {
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    maStart.X, aIter.toView());
+            break;
+        }
+        case XML_ELEMENT(SVG, XML_Y1):
+        case XML_ELEMENT(SVG_COMPAT, XML_Y1):
+        {
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    maStart.Y, aIter.toView());
+            break;
+        }
+        case XML_ELEMENT(SVG, XML_X2):
+        case XML_ELEMENT(SVG_COMPAT, XML_X2):
+        {
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    maEnd.X, aIter.toView());
+            break;
+        }
+        case XML_ELEMENT(SVG, XML_Y2):
+        case XML_ELEMENT(SVG_COMPAT, XML_Y2):
+        {
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    maEnd.Y, aIter.toView());
+            break;
+        }
+        default:
+            return SdXMLShapeContext::processAttribute( aIter );
+    }
+    return true;
+}
+
+void SdXMLMeasureShapeContext::startFastElement (sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
+{
+    // create Measure shape
+    // add, set style and properties from base shape
+    AddShape("com.sun.star.drawing.MeasureShape");
+    if(!mxShape.is())
+        return;
+
+    SetStyle();
+    SetLayer();
+
+    uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY );
+    if( xProps.is() )
+    {
+        xProps->setPropertyValue("StartPosition", Any(maStart));
+        xProps->setPropertyValue("EndPosition", Any(maEnd) );
+    }
+
+    // delete pre created fields
+    uno::Reference< text::XText > xText( mxShape, uno::UNO_QUERY );
+    if( xText.is() )
+    {
+        xText->setString( " " );
+    }
+
+    SdXMLShapeContext::startFastElement(nElement, xAttrList);
+}
+
+void SdXMLMeasureShapeContext::endFastElement(sal_Int32 nElement)
+{
+    do
+    {
+        // delete pre created fields
+        uno::Reference< text::XText > xText( mxShape, uno::UNO_QUERY );
+        if( !xText.is() )
+            break;
+
+        uno::Reference< text::XTextCursor > xCursor( xText->createTextCursor() );
+        if( !xCursor.is() )
+            break;
+
+        xCursor->collapseToStart();
+        xCursor->goRight( 1, true );
+        xCursor->setString( "" );
+    }
+    while(false);
+
+    SdXMLShapeContext::endFastElement(nElement);
+}
+
+
+SdXMLPageShapeContext::SdXMLPageShapeContext(
+    SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes,
+    bool bTemporaryShape)
+:   SdXMLShapeContext( rImport, xAttrList, rShapes, bTemporaryShape ), mnPageNumber(0)
+{
+    mbClearDefaultAttributes = false;
+}
+
+SdXMLPageShapeContext::~SdXMLPageShapeContext()
+{
+}
+
+// this is called from the parent group for each unparsed attribute in the attribute list
+bool SdXMLPageShapeContext::processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & aIter )
+{
+    if( aIter.getToken() == XML_ELEMENT(DRAW, XML_PAGE_NUMBER) )
+        mnPageNumber = aIter.toInt32();
+    else
+        return SdXMLShapeContext::processAttribute( aIter );
+    return true;
+}
+
+void SdXMLPageShapeContext::startFastElement (sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
+{
+    // create Page shape
+    // add, set style and properties from base shape
+
+    // #86163# take into account which type of PageShape needs to
+    // be constructed. It's a pres shape if presentation:XML_CLASS == XML_PAGE.
+    bool bIsPresentation = !maPresentationClass.isEmpty() &&
+           GetImport().GetShapeImport()->IsPresentationShapesSupported();
+
+    uno::Reference< lang::XServiceInfo > xInfo( mxShapes, uno::UNO_QUERY );
+    const bool bIsOnHandoutPage = xInfo.is() && xInfo->supportsService("com.sun.star.presentation.HandoutMasterPage");
+
+    if( bIsOnHandoutPage )
+    {
+        AddShape("com.sun.star.presentation.HandoutShape");
+    }
+    else
+    {
+        if(bIsPresentation && !IsXMLToken( maPresentationClass, XML_PAGE ) )
+        {
+            bIsPresentation = false;
+        }
+
+        if(bIsPresentation)
+        {
+            AddShape("com.sun.star.presentation.PageShape");
+        }
+        else
+        {
+            AddShape("com.sun.star.drawing.PageShape");
+        }
+    }
+
+    if(!mxShape.is())
+        return;
+
+    SetStyle();
+    SetLayer();
+
+    // set pos, size, shear and rotate
+    SetTransformation();
+
+    uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
+    if(xPropSet.is())
+    {
+        uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
+        static const OUStringLiteral aPageNumberStr(u"PageNumber");
+        if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName(aPageNumberStr))
+            xPropSet->setPropertyValue(aPageNumberStr, uno::Any( mnPageNumber ));
+    }
+
+    SdXMLShapeContext::startFastElement(nElement, xAttrList);
+}
+
+
+SdXMLCaptionShapeContext::SdXMLCaptionShapeContext(
+    SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes,
+    bool bTemporaryShape)
+:   SdXMLShapeContext( rImport, xAttrList, rShapes, bTemporaryShape ),
+    // #86616# for correct edge rounding import mnRadius needs to be initialized
+    mnRadius( 0 )
+{
+}
+
+SdXMLCaptionShapeContext::~SdXMLCaptionShapeContext()
+{
+}
+
+void SdXMLCaptionShapeContext::startFastElement (sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
+{
+    // create Caption shape
+    // add, set style and properties from base shape
+    AddShape("com.sun.star.drawing.CaptionShape");
+    if( !mxShape.is() )
+        return;
+
+    SetStyle();
+    SetLayer();
+
+    uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY );
+
+    // SJ: If AutoGrowWidthItem is set, SetTransformation will lead to the wrong SnapRect
+    // because NbcAdjustTextFrameWidthAndHeight() is called (text is set later and center alignment
+    // is the default setting, so the top left reference point that is used by the caption point is
+    // no longer correct) There are two ways to solve this problem, temporarily disabling the
+    // autogrowwidth as we are doing here or to apply the CaptionPoint after setting text
+    bool bIsAutoGrowWidth = false;
+    if ( xProps.is() )
+    {
+        uno::Any aAny( xProps->getPropertyValue("TextAutoGrowWidth") );
+        aAny >>= bIsAutoGrowWidth;
+
+        if ( bIsAutoGrowWidth )
+            xProps->setPropertyValue("TextAutoGrowWidth", uno::Any( false ) );
+    }
+
+    // set pos, size, shear and rotate
+    SetTransformation();
+    if( xProps.is() )
+        xProps->setPropertyValue("CaptionPoint", uno::Any( maCaptionPoint ) );
+
+    if ( bIsAutoGrowWidth )
+        xProps->setPropertyValue("TextAutoGrowWidth", uno::Any( true ) );
+
+    if(mnRadius)
+    {
+        uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
+        if(xPropSet.is())
+        {
+            try
+            {
+                xPropSet->setPropertyValue("CornerRadius", uno::Any( mnRadius ) );
+            }
+            catch(const uno::Exception&)
+            {
+                DBG_UNHANDLED_EXCEPTION( "xmloff", "setting corner radius");
+            }
+        }
+    }
+
+    SdXMLShapeContext::startFastElement(nElement, xAttrList);
+}
+
+// this is called from the parent group for each unparsed attribute in the attribute list
+bool SdXMLCaptionShapeContext::processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & aIter )
+{
+    switch (aIter.getToken())
+    {
+        case XML_ELEMENT(DRAW, XML_CAPTION_POINT_X):
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    maCaptionPoint.X, aIter.toView());
+            break;
+        case XML_ELEMENT(DRAW, XML_CAPTION_POINT_Y):
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    maCaptionPoint.Y, aIter.toView());
+            break;
+        case XML_ELEMENT(DRAW, XML_CORNER_RADIUS):
+            GetImport().GetMM100UnitConverter().convertMeasureToCore(
+                    mnRadius, aIter.toView());
+            break;
+        default:
+            return SdXMLShapeContext::processAttribute( aIter );
+    }
+    return true;
+}
+
+
+SdXMLGraphicObjectShapeContext::SdXMLGraphicObjectShapeContext(
+    SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes)
+:   SdXMLShapeContext( rImport, xAttrList, rShapes, false/*bTemporaryShape*/ )
+{
+}
+
+// this is called from the parent group for each unparsed attribute in the attribute list
+bool SdXMLGraphicObjectShapeContext::processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & aIter )
+{
+    if( aIter.getToken() == XML_ELEMENT(XLINK, XML_HREF) )
+        maURL = aIter.toString();
+    else
+        return SdXMLShapeContext::processAttribute( aIter );
+    return true;
+}
+
+void SdXMLGraphicObjectShapeContext::startFastElement (sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
+{
+    // create graphic object shape
+    OUString service;
+
+    if( IsXMLToken( maPresentationClass, XML_GRAPHIC ) && GetImport().GetShapeImport()->IsPresentationShapesSupported() )
+    {
+        service = "com.sun.star.presentation.GraphicObjectShape";
+    }
+    else
+    {
+        service = "com.sun.star.drawing.GraphicObjectShape";
+    }
+
+    AddShape(service);
+
+    if(!mxShape.is())
+        return;
+
+    SetStyle();
+    SetLayer();
+
+    uno::Reference< beans::XPropertySet > xPropset(mxShape, uno::UNO_QUERY);
+    if(xPropset.is())
+    {
+        // since OOo 1.x had no line or fill style for graphics, but may create
+        // documents with them, we have to override them here
+        sal_Int32 nUPD, nBuildId;
+        if( GetImport().getBuildIds( nUPD, nBuildId ) && (nUPD == 645) ) try
+        {
+            xPropset->setPropertyValue("FillStyle", Any( FillStyle_NONE ) );
+            xPropset->setPropertyValue("LineStyle", Any( LineStyle_NONE ) );
+        }
+        catch(const Exception&)
+        {
+        }
+
+        uno::Reference< beans::XPropertySetInfo > xPropsInfo( xPropset->getPropertySetInfo() );
+        if( xPropsInfo.is() && xPropsInfo->hasPropertyByName("IsEmptyPresentationObject"))
+            xPropset->setPropertyValue("IsEmptyPresentationObject", css::uno::Any( mbIsPlaceholder ) );
+
+        if( !mbIsPlaceholder )
+        {
+            if( !maURL.isEmpty() )
+            {
+                uno::Reference<graphic::XGraphic> xGraphic = GetImport().loadGraphicByURL(maURL);
+                if (xGraphic.is())
+                {
+                    xPropset->setPropertyValue("Graphic", uno::Any(xGraphic));
+                }
+            }
+        }
+    }
+
+    if(mbIsUserTransformed)
+    {
+        uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY);
+        if(xProps.is())
+        {
+            uno::Reference< beans::XPropertySetInfo > xPropsInfo( xProps->getPropertySetInfo() );
+            if( xPropsInfo.is() )
+            {
+                if( xPropsInfo->hasPropertyByName("IsPlaceholderDependent"))
+                    xProps->setPropertyValue("IsPlaceholderDependent", css::uno::Any(false) );
+            }
+        }
+    }
+
+    // set pos, size, shear and rotate
+    SetTransformation();
+
+    SdXMLShapeContext::startFastElement(nElement, xAttrList);
+}
+
+void SdXMLGraphicObjectShapeContext::endFastElement(sal_Int32 nElement)
+{
+    if (mxBase64Stream.is())
+    {
+        uno::Reference<graphic::XGraphic> xGraphic(GetImport().loadGraphicFromBase64(mxBase64Stream));
+        if (xGraphic.is())
+        {
+            uno::Reference<beans::XPropertySet> xProperties(mxShape, uno::UNO_QUERY);
+            if (xProperties.is())
+            {
+                xProperties->setPropertyValue("Graphic", uno::Any(xGraphic));
+            }
+        }
+    }
+
+    SdXMLShapeContext::endFastElement(nElement);
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLGraphicObjectShapeContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    css::uno::Reference< css::xml::sax::XFastContextHandler > xContext;
+
+    if( nElement == XML_ELEMENT(OFFICE, XML_BINARY_DATA) )
+    {
+        if( maURL.isEmpty() && !mxBase64Stream.is() )
+        {
+            mxBase64Stream = GetImport().GetStreamForGraphicObjectURLFromBase64();
+            if( mxBase64Stream.is() )
+                xContext = new XMLBase64ImportContext( GetImport(),
+                                                    mxBase64Stream );
+        }
+    }
+
+    // delegate to parent class if no context could be created
+    if (!xContext)
+        xContext = SdXMLShapeContext::createFastChildContext(nElement,
+                                                         xAttrList);
+
+    if (!xContext)
+        XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+
+    return xContext;
+}
+
+SdXMLGraphicObjectShapeContext::~SdXMLGraphicObjectShapeContext()
+{
+
+}
+
+
+SdXMLChartShapeContext::SdXMLChartShapeContext(
+    SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes,
+    bool bTemporaryShape)
+:   SdXMLShapeContext( rImport, xAttrList, rShapes, bTemporaryShape )
+{
+}
+
+void SdXMLChartShapeContext::startFastElement (sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
+{
+    const bool bIsPresentation = isPresentationShape();
+
+    AddShape(
+        bIsPresentation
+        ? OUString("com.sun.star.presentation.ChartShape")
+        : OUString("com.sun.star.drawing.OLE2Shape"));
+
+    if(!mxShape.is())
+        return;
+
+    SetStyle();
+    SetLayer();
+
+    if( !mbIsPlaceholder )
+    {
+        uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY);
+        if(xProps.is())
+        {
+            uno::Reference< beans::XPropertySetInfo > xPropsInfo( xProps->getPropertySetInfo() );
+            if( xPropsInfo.is() && xPropsInfo->hasPropertyByName("IsEmptyPresentationObject"))
+                xProps->setPropertyValue("IsEmptyPresentationObject", css::uno::Any(false) );
+
+            uno::Any aAny;
+
+            xProps->setPropertyValue("CLSID", Any(OUString("12DCAE26-281F-416F-a234-c3086127382e")) );
+
+            aAny = xProps->getPropertyValue("Model");
+            uno::Reference< frame::XModel > xChartModel;
+            if( aAny >>= xChartModel )
+            {
+#if !ENABLE_WASM_STRIP_CHART
+                // WASM_CHART change
+                // TODO: Maybe use SdXMLGraphicObjectShapeContext completely instead
+                // or try to create as mbIsPlaceholder object adding a Chart visualization
+                // that should be available somehow
+                mxChartContext.set( GetImport().GetChartImport()->CreateChartContext( GetImport(), xChartModel ) );
+#endif
+            }
+        }
+    }
+
+    if(mbIsUserTransformed)
+    {
+        uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY);
+        if(xProps.is())
+        {
+            uno::Reference< beans::XPropertySetInfo > xPropsInfo( xProps->getPropertySetInfo() );
+            if( xPropsInfo.is() )
+            {
+                if( xPropsInfo->hasPropertyByName("IsPlaceholderDependent"))
+                    xProps->setPropertyValue("IsPlaceholderDependent", css::uno::Any(false) );
+            }
+        }
+    }
+
+    // set pos, size, shear and rotate
+    SetTransformation();
+
+    SdXMLShapeContext::startFastElement(nElement, xAttrList);
+
+    if( mxChartContext.is() )
+        mxChartContext->startFastElement( nElement, xAttrList );
+}
+
+void SdXMLChartShapeContext::endFastElement(sal_Int32 nElement)
+{
+    if( mxChartContext.is() )
+        mxChartContext->endFastElement(nElement);
+
+    SdXMLShapeContext::endFastElement(nElement);
+}
+
+void SdXMLChartShapeContext::characters( const OUString& rChars )
+{
+    if( mxChartContext.is() )
+        mxChartContext->characters( rChars );
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLChartShapeContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    if( mxChartContext.is() )
+        return mxChartContext->createFastChildContext( nElement, xAttrList );
+
+    return nullptr;
+}
+
+
+SdXMLObjectShapeContext::SdXMLObjectShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes)
+: SdXMLShapeContext( rImport, xAttrList, rShapes, false/*bTemporaryShape*/ )
+{
+}
+
+SdXMLObjectShapeContext::~SdXMLObjectShapeContext()
+{
+}
+
+void SdXMLObjectShapeContext::startFastElement (sal_Int32 /*nElement*/,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& /*xAttrList*/)
+{
+    // #96717# in theorie, if we don't have a URL we shouldn't even
+    // export this OLE shape. But practically it's too risky right now
+    // to change this so we better dispose this on load
+    //if( !mbIsPlaceholder && ImpIsEmptyURL(maHref) )
+    //  return;
+
+    // #100592# this BugFix prevents that a shape is created. CL
+    // is thinking about an alternative.
+    // #i13140# Check for more than empty string in maHref, there are
+    // other possibilities that maHref results in empty container
+    // storage names
+    if( !(GetImport().getImportFlags() & SvXMLImportFlags::EMBEDDED) && !mbIsPlaceholder && ImpIsEmptyURL(maHref) )
+        return;
+
+    OUString service("com.sun.star.drawing.OLE2Shape");
+
+    bool bIsPresShape = !maPresentationClass.isEmpty() && GetImport().GetShapeImport()->IsPresentationShapesSupported();
+
+    if( bIsPresShape )
+    {
+        if( IsXMLToken( maPresentationClass, XML_CHART ) )
+        {
+            service = "com.sun.star.presentation.ChartShape";
+        }
+        else if( IsXMLToken( maPresentationClass, XML_TABLE ) )
+        {
+            service = "com.sun.star.presentation.CalcShape";
+        }
+        else if( IsXMLToken( maPresentationClass, XML_OBJECT ) )
+        {
+            service = "com.sun.star.presentation.OLE2Shape";
+        }
+    }
+
+    AddShape(service);
+
+    if( !mxShape.is() )
+        return;
+
+    SetLayer();
+
+    if(bIsPresShape)
+    {
+        uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY);
+        if(xProps.is())
+        {
+            uno::Reference< beans::XPropertySetInfo > xPropsInfo( xProps->getPropertySetInfo() );
+            if( xPropsInfo.is() )
+            {
+                if( !mbIsPlaceholder && xPropsInfo->hasPropertyByName("IsEmptyPresentationObject"))
+                    xProps->setPropertyValue("IsEmptyPresentationObject", css::uno::Any(false) );
+
+                if( mbIsUserTransformed && xPropsInfo->hasPropertyByName("IsPlaceholderDependent"))
+                    xProps->setPropertyValue("IsPlaceholderDependent", css::uno::Any(false) );
+            }
+        }
+    }
+
+    if( !mbIsPlaceholder && !maHref.isEmpty() )
+    {
+        uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY );
+
+        if( xProps.is() )
+        {
+            OUString aPersistName = GetImport().ResolveEmbeddedObjectURL( maHref, maCLSID );
+
+            if ( GetImport().IsPackageURL( maHref ) )
+            {
+                static const OUStringLiteral  sURL( u"vnd.sun.star.EmbeddedObject:" );
+
+                if ( aPersistName.startsWith( sURL ) )
+                    aPersistName = aPersistName.copy( sURL.getLength() );
+
+                xProps->setPropertyValue("PersistName",
+                                          uno::Any( aPersistName ) );
+            }
+            else
+            {
+                // this is OOo link object
+                xProps->setPropertyValue("LinkURL",
+                                          uno::Any( aPersistName ) );
+            }
+        }
+    }
+
+    // set pos, size, shear and rotate
+    SetTransformation();
+
+    SetStyle();
+
+    GetImport().GetShapeImport()->finishShape( mxShape, mxAttrList, mxShapes );
+}
+
+void SdXMLObjectShapeContext::endFastElement(sal_Int32 nElement)
+{
+    if (GetImport().isGeneratorVersionOlderThan(
+                SvXMLImport::OOo_34x, SvXMLImport::LO_41x)) // < LO 4.0
+    {
+        // #i118485#
+        // If it's an old file from us written before OOo3.4, we need to correct
+        // FillStyle and LineStyle for OLE2 objects. The error was that the old paint
+        // implementations just ignored added fill/linestyles completely, thus
+        // those objects need to be corrected to not show blue and hairline which
+        // always was the default, but would be shown now
+        uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY);
+
+        if( xProps.is() )
+        {
+            xProps->setPropertyValue("FillStyle", uno::Any(drawing::FillStyle_NONE));
+            xProps->setPropertyValue("LineStyle", uno::Any(drawing::LineStyle_NONE));
+        }
+    }
+
+    if( mxBase64Stream.is() )
+    {
+        OUString aPersistName( GetImport().ResolveEmbeddedObjectURLFromBase64() );
+        static const OUStringLiteral  sURL( u"vnd.sun.star.EmbeddedObject:" );
+
+        aPersistName = aPersistName.copy( sURL.getLength() );
+
+        uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY);
+        if( xProps.is() )
+            xProps->setPropertyValue("PersistName", uno::Any( aPersistName ) );
+    }
+
+    SdXMLShapeContext::endFastElement(nElement);
+}
+
+// this is called from the parent group for each unparsed attribute in the attribute list
+bool SdXMLObjectShapeContext::processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & aIter )
+{
+    switch( aIter.getToken() )
+    {
+        case XML_ELEMENT(DRAW, XML_CLASS_ID):
+            maCLSID = aIter.toString();
+            break;
+        case XML_ELEMENT(XLINK, XML_HREF):
+            maHref = aIter.toString();
+            break;
+        default:
+            return SdXMLShapeContext::processAttribute( aIter );
+    }
+    return true;
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLObjectShapeContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    if(nElement == XML_ELEMENT(OFFICE, XML_BINARY_DATA))
+    {
+        mxBase64Stream = GetImport().GetStreamForEmbeddedObjectURLFromBase64();
+        if( mxBase64Stream.is() )
+            return new XMLBase64ImportContext( GetImport(), mxBase64Stream );
+    }
+    else if( nElement == XML_ELEMENT(OFFICE, XML_DOCUMENT) ||
+             nElement == XML_ELEMENT(MATH, XML_MATH) )
+    {
+        rtl::Reference<XMLEmbeddedObjectImportContext> xEContext(
+            new XMLEmbeddedObjectImportContext(GetImport(), nElement, xAttrList));
+        maCLSID = xEContext->GetFilterCLSID();
+        if( !maCLSID.isEmpty() )
+        {
+            uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
+            if( xPropSet.is() )
+            {
+                xPropSet->setPropertyValue("CLSID", uno::Any( maCLSID ) );
+
+                uno::Reference< lang::XComponent > xComp;
+                xPropSet->getPropertyValue("Model") >>= xComp;
+                SAL_WARN_IF( !xComp.is(), "xmloff", "no xModel for own OLE format" );
+                xEContext->SetComponent(xComp);
+            }
+        }
+        return xEContext;
+    }
+
+    // delegate to parent class if no context could be created
+    return SdXMLShapeContext::createFastChildContext(nElement, xAttrList);
+}
+
+SdXMLAppletShapeContext::SdXMLAppletShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes)
+: SdXMLShapeContext( rImport, xAttrList, rShapes, false/*bTemporaryShape*/ ),
+  mbIsScript( false )
+{
+}
+
+SdXMLAppletShapeContext::~SdXMLAppletShapeContext()
+{
+}
+
+void SdXMLAppletShapeContext::startFastElement (sal_Int32 /*nElement*/,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& /*xAttrList*/)
+{
+    AddShape("com.sun.star.drawing.AppletShape");
+
+    if( mxShape.is() )
+    {
+        SetLayer();
+
+        // set pos, size, shear and rotate
+        SetTransformation();
+        GetImport().GetShapeImport()->finishShape( mxShape, mxAttrList, mxShapes );
+    }
+}
+
+// this is called from the parent group for each unparsed attribute in the attribute list
+bool SdXMLAppletShapeContext::processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & aIter )
+{
+    switch( aIter.getToken() )
+    {
+        case XML_ELEMENT(DRAW, XML_APPLET_NAME):
+            maAppletName = aIter.toString();
+            break;
+        case XML_ELEMENT(DRAW, XML_CODE):
+            maAppletCode = aIter.toString();
+            break;
+        case XML_ELEMENT(DRAW, XML_MAY_SCRIPT):
+            mbIsScript = IsXMLToken( aIter, XML_TRUE );
+            break;
+        case XML_ELEMENT(XLINK, XML_HREF):
+            maHref = GetImport().GetAbsoluteReference(aIter.toString());
+            break;
+        default:
+            return SdXMLShapeContext::processAttribute( aIter );
+    }
+    return true;
+}
+
+void SdXMLAppletShapeContext::endFastElement(sal_Int32 nElement)
+{
+    uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY );
+    if( xProps.is() )
+    {
+        if ( maSize.Width && maSize.Height )
+        {
+            // the visual area for applet must be set on loading
+            awt::Rectangle aRect( 0, 0, maSize.Width, maSize.Height );
+            xProps->setPropertyValue("VisibleArea", Any(aRect) );
+        }
+
+        if( maParams.hasElements() )
+        {
+            xProps->setPropertyValue("AppletCommands", Any(maParams) );
+        }
+
+        if( !maHref.isEmpty() )
+        {
+            xProps->setPropertyValue("AppletCodeBase", Any(maHref) );
+        }
+
+        if( !maAppletName.isEmpty() )
+        {
+            xProps->setPropertyValue("AppletName", Any(maAppletName) );
+        }
+
+        if( mbIsScript )
+        {
+            xProps->setPropertyValue("AppletIsScript", Any(mbIsScript) );
+
+        }
+
+        if( !maAppletCode.isEmpty() )
+        {
+            xProps->setPropertyValue("AppletCode", Any(maAppletCode) );
+        }
+
+        xProps->setPropertyValue("AppletDocBase", Any(GetImport().GetDocumentBase()) );
+
+        SetThumbnail();
+    }
+
+    SdXMLShapeContext::endFastElement(nElement);
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLAppletShapeContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    if( nElement == XML_ELEMENT(DRAW, XML_PARAM) )
+    {
+        OUString aParamName, aParamValue;
+        // now parse the attribute list and look for draw:name and draw:value
+        for( auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList) )
+        {
+            if( aIter.getToken() == XML_ELEMENT(DRAW, XML_NAME) )
+                aParamName = aIter.toString();
+            if( aIter.getToken() == XML_ELEMENT(DRAW, XML_VALUE) )
+                aParamValue = aIter.toString();
+        }
+
+        if( !aParamName.isEmpty() )
+        {
+            sal_Int32 nIndex = maParams.getLength();
+            maParams.realloc( nIndex + 1 );
+            auto pParams = maParams.getArray();
+            pParams[nIndex].Name = aParamName;
+            pParams[nIndex].Handle = -1;
+            pParams[nIndex].Value <<= aParamValue;
+            pParams[nIndex].State = beans::PropertyState_DIRECT_VALUE;
+        }
+
+        return new SvXMLImportContext( GetImport() );
+    }
+
+    return SdXMLShapeContext::createFastChildContext( nElement, xAttrList );
+}
+
+
+SdXMLPluginShapeContext::SdXMLPluginShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes) :
+SdXMLShapeContext( rImport, xAttrList, rShapes, false/*bTemporaryShape*/ ),
+mbMedia( false )
+{
+}
+
+SdXMLPluginShapeContext::~SdXMLPluginShapeContext()
+{
+}
+
+void SdXMLPluginShapeContext::startFastElement (sal_Int32 /*nElement*/,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
+{
+
+    // watch for MimeType attribute to see if we have a media object
+    for( auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList) )
+    {
+        if( aIter.getToken() == XML_ELEMENT(DRAW, XML_MIME_TYPE) )
+        {
+            if( aIter.toView() == "application/vnd.sun.star.media" )
+                mbMedia = true;
+            // leave this loop
+            break;
+        }
+    }
+
+    OUString service;
+
+    bool bIsPresShape = false;
+
+    if( mbMedia )
+    {
+        service = "com.sun.star.drawing.MediaShape";
+
+        bIsPresShape = !maPresentationClass.isEmpty() && GetImport().GetShapeImport()->IsPresentationShapesSupported();
+        if( bIsPresShape )
+        {
+            if( IsXMLToken( maPresentationClass, XML_OBJECT ) )
+            {
+                service = "com.sun.star.presentation.MediaShape";
+            }
+        }
+    }
+    else
+        service = "com.sun.star.drawing.PluginShape";
+
+    AddShape(service);
+
+    if( !mxShape.is() )
+        return;
+
+    if (mbMedia)
+    {
+        // The media may have a crop, apply it.
+        SetStyle(/*bSupportsStyle=*/false);
+    }
+
+    SetLayer();
+
+    if(bIsPresShape)
+    {
+        uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY );
+        if(xProps.is())
+        {
+            uno::Reference< beans::XPropertySetInfo > xPropsInfo( xProps->getPropertySetInfo() );
+            if( xPropsInfo.is() )
+            {
+                if( !mbIsPlaceholder && xPropsInfo->hasPropertyByName("IsEmptyPresentationObject"))
+                    xProps->setPropertyValue("IsEmptyPresentationObject", css::uno::Any(false) );
+
+                if( mbIsUserTransformed && xPropsInfo->hasPropertyByName("IsPlaceholderDependent"))
+                    xProps->setPropertyValue("IsPlaceholderDependent", css::uno::Any(false) );
+            }
+        }
+    }
+
+    // set pos, size, shear and rotate
+    SetTransformation();
+    GetImport().GetShapeImport()->finishShape( mxShape, mxAttrList, mxShapes );
+}
+
+static OUString
+lcl_GetMediaReference(SvXMLImport const& rImport, OUString const& rURL)
+{
+    if (rImport.IsPackageURL(rURL))
+    {
+        return "vnd.sun.star.Package:" + rURL;
+    }
+    else
+    {
+        return rImport.GetAbsoluteReference(rURL);
+    }
+}
+
+// this is called from the parent group for each unparsed attribute in the attribute list
+bool SdXMLPluginShapeContext::processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & aIter )
+{
+    switch( aIter.getToken() )
+    {
+        case XML_ELEMENT(DRAW, XML_MIME_TYPE):
+            maMimeType = aIter.toString();
+            break;
+        case XML_ELEMENT(XLINK, XML_HREF):
+            maHref = lcl_GetMediaReference(GetImport(), aIter.toString());
+            break;
+        default:
+            return SdXMLShapeContext::processAttribute( aIter );
+    }
+    return true;
+}
+
+void SdXMLPluginShapeContext::endFastElement(sal_Int32 nElement)
+{
+    uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY );
+
+    if( xProps.is() )
+    {
+        if ( maSize.Width && maSize.Height )
+        {
+            static const OUStringLiteral sVisibleArea(  u"VisibleArea"  );
+            uno::Reference< beans::XPropertySetInfo > aXPropSetInfo( xProps->getPropertySetInfo() );
+            if ( !aXPropSetInfo.is() || aXPropSetInfo->hasPropertyByName( sVisibleArea ) )
+            {
+                // the visual area for a plugin must be set on loading
+                awt::Rectangle aRect( 0, 0, maSize.Width, maSize.Height );
+                xProps->setPropertyValue( sVisibleArea, Any(aRect) );
+            }
+        }
+
+        if( !mbMedia )
+        {
+            // in case we have a plugin object
+            if( maParams.hasElements() )
+            {
+                xProps->setPropertyValue("PluginCommands", Any(maParams) );
+            }
+
+            if( !maMimeType.isEmpty() )
+            {
+                xProps->setPropertyValue("PluginMimeType", Any(maMimeType) );
+            }
+
+            if( !maHref.isEmpty() )
+            {
+                xProps->setPropertyValue("PluginURL", Any(maHref) );
+            }
+        }
+        else
+        {
+            // in case we have a media object
+            xProps->setPropertyValue( "MediaURL", uno::Any(maHref));
+
+            xProps->setPropertyValue("MediaMimeType", uno::Any(maMimeType) );
+
+            for( const auto& rParam : std::as_const(maParams) )
+            {
+                const OUString& rName = rParam.Name;
+
+                if( rName == "Loop" )
+                {
+                    OUString aValueStr;
+                    rParam.Value >>= aValueStr;
+                    xProps->setPropertyValue("Loop",
+                        uno::Any( aValueStr == "true" ) );
+                }
+                else if( rName == "Mute" )
+                {
+                    OUString aValueStr;
+                    rParam.Value >>= aValueStr;
+                    xProps->setPropertyValue("Mute",
+                        uno::Any( aValueStr == "true" ) );
+                }
+                else if( rName == "VolumeDB" )
+                {
+                    OUString aValueStr;
+                    rParam.Value >>= aValueStr;
+                    xProps->setPropertyValue("VolumeDB",
+                                                uno::Any( static_cast< sal_Int16 >( aValueStr.toInt32() ) ) );
+                }
+                else if( rName == "Zoom" )
+                {
+                    OUString            aZoomStr;
+                    media::ZoomLevel    eZoomLevel;
+
+                    rParam.Value >>= aZoomStr;
+
+                    if( aZoomStr == "25%" )
+                        eZoomLevel = media::ZoomLevel_ZOOM_1_TO_4;
+                    else if( aZoomStr == "50%" )
+                        eZoomLevel = media::ZoomLevel_ZOOM_1_TO_2;
+                    else if( aZoomStr == "100%" )
+                        eZoomLevel = media::ZoomLevel_ORIGINAL;
+                    else if( aZoomStr == "200%" )
+                        eZoomLevel = media::ZoomLevel_ZOOM_2_TO_1;
+                    else if( aZoomStr == "400%" )
+                        eZoomLevel = media::ZoomLevel_ZOOM_4_TO_1;
+                    else if( aZoomStr == "fit" )
+                        eZoomLevel = media::ZoomLevel_FIT_TO_WINDOW;
+                    else if( aZoomStr == "fixedfit" )
+                        eZoomLevel = media::ZoomLevel_FIT_TO_WINDOW_FIXED_ASPECT;
+                    else if( aZoomStr == "fullscreen" )
+                        eZoomLevel = media::ZoomLevel_FULLSCREEN;
+                    else
+                        eZoomLevel = media::ZoomLevel_NOT_AVAILABLE;
+
+                    xProps->setPropertyValue("Zoom", uno::Any( eZoomLevel ) );
+                }
+            }
+        }
+
+        SetThumbnail();
+    }
+
+    SdXMLShapeContext::endFastElement(nElement);
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLPluginShapeContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    if( nElement == XML_ELEMENT(DRAW, XML_PARAM) )
+    {
+        OUString aParamName, aParamValue;
+        // now parse the attribute list and look for draw:name and draw:value
+        for( auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList) )
+        {
+            if( aIter.getToken() == XML_ELEMENT(DRAW, XML_NAME) )
+                aParamName = aIter.toString();
+            else if( aIter.getToken() == XML_ELEMENT(DRAW, XML_VALUE) )
+                aParamValue = aIter.toString();
+        }
+
+        if( !aParamName.isEmpty() )
+        {
+            sal_Int32 nIndex = maParams.getLength();
+            maParams.realloc( nIndex + 1 );
+            auto pParams = maParams.getArray();
+            pParams[nIndex].Name = aParamName;
+            pParams[nIndex].Handle = -1;
+            pParams[nIndex].Value <<= aParamValue;
+            pParams[nIndex].State = beans::PropertyState_DIRECT_VALUE;
+        }
+
+        return new SvXMLImportContext( GetImport() );
+    }
+
+    return SdXMLShapeContext::createFastChildContext( nElement, xAttrList );
+}
+
+
+SdXMLFloatingFrameShapeContext::SdXMLFloatingFrameShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes)
+: SdXMLShapeContext( rImport, xAttrList, rShapes, false/*bTemporaryShape*/ )
+{
+}
+
+SdXMLFloatingFrameShapeContext::~SdXMLFloatingFrameShapeContext()
+{
+}
+
+uno::Reference<drawing::XShape> SdXMLFloatingFrameShapeContext::CreateFloatingFrameShape() const
+{
+    uno::Reference<lang::XMultiServiceFactory> xServiceFact(GetImport().GetModel(), uno::UNO_QUERY);
+    if (!xServiceFact.is())
+        return nullptr;
+    uno::Reference<drawing::XShape> xShape(
+            xServiceFact->createInstance("com.sun.star.drawing.FrameShape"), uno::UNO_QUERY);
+    return xShape;
+}
+
+void SdXMLFloatingFrameShapeContext::startFastElement (sal_Int32 /*nElement*/,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& /*xAttrList*/)
+{
+    uno::Reference<drawing::XShape> xShape(SdXMLFloatingFrameShapeContext::CreateFloatingFrameShape());
+
+    uno::Reference< beans::XPropertySet > xProps(xShape, uno::UNO_QUERY);
+    // set FrameURL before AddShape, we have to do it again later because it
+    // gets cleared when the SdrOle2Obj is attached to the XShape.  But we want
+    // FrameURL to exist when AddShape triggers SetPersistName which itself
+    // triggers SdrOle2Obj::CheckFileLink_Impl and at that point we want to
+    // know what URL will end up being used. So bodge this by setting FrameURL
+    // to the temp pre-SdrOle2Obj attached properties and we can smuggle it
+    // eventually into SdrOle2Obj::SetPersistName at the right point after
+    // PersistName is set but before SdrOle2Obj::CheckFileLink_Impl is called
+    // in order to inform the link manager that this is an IFrame that links to
+    // a URL
+    if (xProps && !maHref.isEmpty())
+        xProps->setPropertyValue("FrameURL", Any(maHref));
+
+    AddShape(xShape);
+
+    if( !mxShape.is() )
+        return;
+
+    SetLayer();
+
+    // set pos, size, shear and rotate
+    SetTransformation();
+
+    if( xProps.is() )
+    {
+        if( !maFrameName.isEmpty() )
+        {
+            xProps->setPropertyValue("FrameName", Any(maFrameName) );
+        }
+
+        if( !maHref.isEmpty() )
+        {
+            if (INetURLObject(maHref).GetProtocol() == INetProtocol::Macro)
+                GetImport().NotifyMacroEventRead();
+
+            xProps->setPropertyValue("FrameURL", Any(maHref) );
+        }
+    }
+
+    SetStyle();
+
+    GetImport().GetShapeImport()->finishShape( mxShape, mxAttrList, mxShapes );
+}
+
+// this is called from the parent group for each unparsed attribute in the attribute list
+bool SdXMLFloatingFrameShapeContext::processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & aIter )
+{
+    switch( aIter.getToken() )
+    {
+        case XML_ELEMENT(DRAW, XML_FRAME_NAME):
+            maFrameName = aIter.toString();
+            break;
+        case XML_ELEMENT(XLINK, XML_HREF):
+            maHref = GetImport().GetAbsoluteReference(aIter.toString());
+            break;
+        default:
+            return SdXMLShapeContext::processAttribute( aIter );
+    }
+    return true;
+}
+
+void SdXMLFloatingFrameShapeContext::endFastElement(sal_Int32 nElement)
+{
+    uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY );
+
+    if( xProps.is() )
+    {
+        if ( maSize.Width && maSize.Height )
+        {
+            // the visual area for a floating frame must be set on loading
+            awt::Rectangle aRect( 0, 0, maSize.Width, maSize.Height );
+            xProps->setPropertyValue("VisibleArea", Any(aRect) );
+        }
+    }
+
+    SetThumbnail();
+    SdXMLShapeContext::endFastElement(nElement);
+}
+
+
+SdXMLFrameShapeContext::SdXMLFrameShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes,
+        bool bTemporaryShape)
+: SdXMLShapeContext( rImport, xAttrList, rShapes, bTemporaryShape ),
+    mbSupportsReplacement( false )
+{
+    uno::Reference < util::XCloneable > xClone( xAttrList, uno::UNO_QUERY );
+    if( xClone.is() )
+        mxAttrList.set( xClone->createClone(), uno::UNO_QUERY );
+    else
+        mxAttrList = new sax_fastparser::FastAttributeList(xAttrList);
+}
+
+SdXMLFrameShapeContext::~SdXMLFrameShapeContext()
+{
+}
+
+void SdXMLFrameShapeContext::removeGraphicFromImportContext(const SvXMLImportContext& rContext)
+{
+    const SdXMLGraphicObjectShapeContext* pSdXMLGraphicObjectShapeContext = dynamic_cast< const SdXMLGraphicObjectShapeContext* >(&rContext);
+
+    if(!pSdXMLGraphicObjectShapeContext)
+        return;
+
+    try
+    {
+        uno::Reference< container::XChild > xChild(pSdXMLGraphicObjectShapeContext->getShape(), uno::UNO_QUERY_THROW);
+
+        uno::Reference< drawing::XShapes > xParent(xChild->getParent(), uno::UNO_QUERY_THROW);
+
+        // remove from parent
+        xParent->remove(pSdXMLGraphicObjectShapeContext->getShape());
+
+        // dispose
+        uno::Reference< lang::XComponent > xComp(pSdXMLGraphicObjectShapeContext->getShape(), UNO_QUERY);
+
+        if(xComp.is())
+        {
+            xComp->dispose();
+        }
+    }
+    catch( uno::Exception& )
+    {
+        DBG_UNHANDLED_EXCEPTION( "xmloff", "Error in cleanup of multiple graphic object import." );
+    }
+}
+
+namespace
+{
+uno::Reference<beans::XPropertySet> getGraphicPropertySetFromImportContext(const SvXMLImportContext& rContext)
+{
+    uno::Reference<beans::XPropertySet> aPropertySet;
+    const SdXMLGraphicObjectShapeContext* pSdXMLGraphicObjectShapeContext = dynamic_cast<const SdXMLGraphicObjectShapeContext*>(&rContext);
+
+    if (pSdXMLGraphicObjectShapeContext)
+        aPropertySet.set(pSdXMLGraphicObjectShapeContext->getShape(), uno::UNO_QUERY);
+
+    return aPropertySet;
+}
+
+} // end anonymous namespace
+
+uno::Reference<graphic::XGraphic> SdXMLFrameShapeContext::getGraphicFromImportContext(const SvXMLImportContext& rContext) const
+{
+    uno::Reference<graphic::XGraphic> xGraphic;
+    try
+    {
+        const uno::Reference<beans::XPropertySet> xPropertySet = getGraphicPropertySetFromImportContext(rContext);
+
+        if (xPropertySet.is())
+        {
+            xPropertySet->getPropertyValue("Graphic") >>= xGraphic;
+        }
+    }
+    catch( uno::Exception& )
+    {
+        DBG_UNHANDLED_EXCEPTION("xmloff", "Error in cleanup of multiple graphic object import.");
+    }
+
+    return xGraphic;
+}
+
+OUString SdXMLFrameShapeContext::getGraphicPackageURLFromImportContext(const SvXMLImportContext& rContext) const
+{
+    OUString aRetval;
+    const SdXMLGraphicObjectShapeContext* pSdXMLGraphicObjectShapeContext = dynamic_cast< const SdXMLGraphicObjectShapeContext* >(&rContext);
+
+    if(pSdXMLGraphicObjectShapeContext)
+    {
+        try
+        {
+            const uno::Reference< beans::XPropertySet > xPropSet(pSdXMLGraphicObjectShapeContext->getShape(), uno::UNO_QUERY_THROW);
+
+            xPropSet->getPropertyValue("GraphicStreamURL") >>= aRetval;
+        }
+        catch( uno::Exception& )
+        {
+            DBG_UNHANDLED_EXCEPTION( "xmloff", "Error in cleanup of multiple graphic object import." );
+        }
+    }
+
+    return aRetval;
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLFrameShapeContext::createFastChildContext(
+    sal_Int32 nElement,
+    const uno::Reference< xml::sax::XFastAttributeList>& xAttrList )
+{
+    SvXMLImportContextRef xContext;
+    if( !mxImplContext.is() )
+    {
+        SvXMLShapeContext* pShapeContext = XMLShapeImportHelper::CreateFrameChildContext(
+                        GetImport(), nElement, xAttrList, mxShapes, mxAttrList );
+
+        xContext = pShapeContext;
+
+        // propagate the hyperlink to child context
+        if ( !msHyperlink.isEmpty() )
+            pShapeContext->setHyperlink( msHyperlink );
+
+        auto nToken = nElement & TOKEN_MASK;
+        bool bMedia = false;
+        // Ignore gltf model if necessary and so the fallback image will be imported
+        if( nToken == XML_PLUGIN )
+        {
+            SdXMLPluginShapeContext* pPluginContext = dynamic_cast<SdXMLPluginShapeContext*>(pShapeContext);
+            if( pPluginContext && pPluginContext->getMimeType() == "model/vnd.gltf+json" )
+            {
+                mxImplContext = nullptr;
+                return new SvXMLImportContext(GetImport());
+            }
+            else if (pPluginContext && pPluginContext->getMimeType() == "application/vnd.sun.star.media")
+            {
+                // The media may have a preview, import it.
+                bMedia = true;
+            }
+        }
+
+        mxImplContext = xContext;
+        mbSupportsReplacement = (nToken == XML_OBJECT ) || (nToken == XML_OBJECT_OLE) || bMedia;
+        setSupportsMultipleContents(nToken == XML_IMAGE);
+
+        if(getSupportsMultipleContents() && dynamic_cast< SdXMLGraphicObjectShapeContext* >(xContext.get()))
+        {
+            if ( !maShapeId.isEmpty() )
+                GetImport().getInterfaceToIdentifierMapper().reserveIdentifier( maShapeId );
+
+            addContent(*mxImplContext);
+        }
+    }
+    else if(getSupportsMultipleContents() && nElement == XML_ELEMENT(DRAW, XML_IMAGE))
+    {
+        // read another image
+        xContext = XMLShapeImportHelper::CreateFrameChildContext(
+            GetImport(), nElement, xAttrList, mxShapes, mxAttrList);
+        mxImplContext = xContext;
+
+        if(dynamic_cast< SdXMLGraphicObjectShapeContext* >(xContext.get()))
+        {
+            addContent(*mxImplContext);
+        }
+    }
+    else if( mbSupportsReplacement && !mxReplImplContext.is() &&
+             nElement == XML_ELEMENT(DRAW, XML_IMAGE) )
+    {
+        // read replacement image
+        SvXMLImportContext *pImplContext = mxImplContext.get();
+        SdXMLShapeContext *pSContext =
+            dynamic_cast<SdXMLShapeContext*>( pImplContext  );
+        if( pSContext )
+        {
+            uno::Reference < beans::XPropertySet > xPropSet(
+                    pSContext->getShape(), uno::UNO_QUERY );
+            if( xPropSet.is() )
+            {
+                xContext = new XMLReplacementImageContext( GetImport(),
+                                    nElement, xAttrList, xPropSet );
+                mxReplImplContext = xContext;
+            }
+        }
+    }
+    else if( nElement == XML_ELEMENT(SVG, XML_TITLE) || // #i68101#
+             nElement == XML_ELEMENT(SVG_COMPAT, XML_TITLE) ||
+             nElement == XML_ELEMENT(SVG, XML_DESC) ||
+             nElement == XML_ELEMENT(SVG_COMPAT, XML_DESC) ||
+             nElement == XML_ELEMENT(OFFICE, XML_EVENT_LISTENERS) ||
+             nElement == XML_ELEMENT(DRAW, XML_GLUE_POINT) ||
+             nElement == XML_ELEMENT(DRAW, XML_THUMBNAIL) )
+    {
+        if (getSupportsMultipleContents())
+        {   // tdf#103567 ensure props are set on surviving shape
+            // note: no more draw:image can be added once we get here
+            mxImplContext = solveMultipleImages();
+        }
+        SvXMLImportContext *pImplContext = mxImplContext.get();
+        xContext = static_cast<SvXMLImportContext*>(dynamic_cast<SdXMLShapeContext&>(*pImplContext).createFastChildContext( nElement,
+                                                                        xAttrList ).get());
+    }
+    else if ( nElement == XML_ELEMENT(DRAW, XML_IMAGE_MAP) )
+    {
+        if (getSupportsMultipleContents())
+        {   // tdf#103567 ensure props are set on surviving shape
+            // note: no more draw:image can be added once we get here
+            mxImplContext = solveMultipleImages();
+        }
+        SdXMLShapeContext *pSContext = dynamic_cast< SdXMLShapeContext* >( mxImplContext.get() );
+        if( pSContext )
+        {
+            uno::Reference < beans::XPropertySet > xPropSet( pSContext->getShape(), uno::UNO_QUERY );
+            if (xPropSet.is())
+            {
+                xContext = new XMLImageMapContext(GetImport(), xPropSet);
+            }
+        }
+    }
+    else if ( nElement == XML_ELEMENT(LO_EXT, XML_SIGNATURELINE) )
+    {
+        SdXMLShapeContext* pSContext = dynamic_cast<SdXMLShapeContext*>(mxImplContext.get());
+        if (pSContext)
+        {
+            uno::Reference<beans::XPropertySet> xPropSet(pSContext->getShape(), uno::UNO_QUERY);
+            if (xPropSet.is())
+            {
+                xContext = new SignatureLineContext(GetImport(), nElement, xAttrList,
+                                                    pSContext->getShape());
+            }
+        }
+    }
+    else if ( nElement == XML_ELEMENT(LO_EXT, XML_QRCODE))
+    {
+        SdXMLShapeContext* pSContext = dynamic_cast<SdXMLShapeContext*>(mxImplContext.get());
+        if (pSContext)
+        {
+            uno::Reference<beans::XPropertySet> xPropSet(pSContext->getShape(), uno::UNO_QUERY);
+            if (xPropSet.is())
+            {
+                xContext = new QRCodeContext(GetImport(), nElement, xAttrList,
+                                                    pSContext->getShape());
+            }
+        }
+    }
+
+    return xContext;
+}
+
+void SdXMLFrameShapeContext::startFastElement (sal_Int32 /*nElement*/,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& /*xAttrList*/)
+{
+    // ignore
+}
+
+void SdXMLFrameShapeContext::endFastElement(sal_Int32 nElement)
+{
+    // solve if multiple image child contexts were imported
+    SvXMLImportContextRef const pSelectedContext(solveMultipleImages());
+    const SdXMLGraphicObjectShapeContext* pShapeContext(
+        dynamic_cast<const SdXMLGraphicObjectShapeContext*>(pSelectedContext.get()));
+    if ( pShapeContext )
+    {
+        assert( mxImplContext.is() );
+        const uno::Reference< uno::XInterface > xShape( pShapeContext->getShape() );
+        GetImport().getInterfaceToIdentifierMapper().registerReservedReference( maShapeId, xShape );
+    }
+
+    if( !mxImplContext.is() )
+    {
+        // now check if this is an empty presentation object
+        for( auto& aIter : sax_fastparser::castToFastAttributeList(mxAttrList) )
+        {
+            switch (aIter.getToken())
+            {
+                case XML_ELEMENT(PRESENTATION, XML_PLACEHOLDER):
+                    mbIsPlaceholder = IsXMLToken( aIter, XML_TRUE );
+                    break;
+                case XML_ELEMENT(PRESENTATION, XML_CLASS):
+                    maPresentationClass = aIter.toString();
+                    break;
+                default:;
+            }
+        }
+
+        if( (!maPresentationClass.isEmpty()) && mbIsPlaceholder )
+        {
+            uno::Reference< xml::sax::XFastAttributeList> xEmpty;
+
+            enum XMLTokenEnum eToken = XML_TEXT_BOX;
+
+            if( IsXMLToken( maPresentationClass, XML_GRAPHIC ) )
+            {
+                eToken = XML_IMAGE;
+
+            }
+            else if( IsXMLToken( maPresentationClass, XML_PAGE ) )
+            {
+                eToken = XML_PAGE_THUMBNAIL;
+            }
+            else if( IsXMLToken( maPresentationClass, XML_CHART ) ||
+                     IsXMLToken( maPresentationClass, XML_TABLE ) ||
+                     IsXMLToken( maPresentationClass, XML_OBJECT ) )
+            {
+                eToken = XML_OBJECT;
+            }
+
+            auto x = XML_ELEMENT(DRAW, eToken);
+            mxImplContext = XMLShapeImportHelper::CreateFrameChildContext(
+                    GetImport(), x, mxAttrList, mxShapes, xEmpty );
+
+            if( mxImplContext.is() )
+            {
+                mxImplContext->startFastElement( x, mxAttrList );
+                mxImplContext->endFastElement(x);
+            }
+        }
+    }
+
+    mxImplContext = nullptr;
+    SdXMLShapeContext::endFastElement(nElement);
+}
+
+bool SdXMLFrameShapeContext::processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & aIter )
+{
+    bool bId( false );
+
+    switch ( aIter.getToken() )
+    {
+        case XML_ELEMENT(DRAW, XML_ID):
+        case XML_ELEMENT(DRAW_EXT, XML_ID):
+        case XML_ELEMENT(NONE, XML_ID):
+        case XML_ELEMENT(XML, XML_ID) :
+            bId = true;
+            break;
+        default:;
+    }
+
+    if ( bId )
+        return SdXMLShapeContext::processAttribute( aIter );
+    return true; // deliberately ignoring other attributes
+}
+
+
+SdXMLCustomShapeContext::SdXMLCustomShapeContext(
+    SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes)
+:   SdXMLShapeContext( rImport, xAttrList, rShapes, false/*bTemporaryShape*/ )
+{
+    // See the XMLTextFrameContext ctor, a frame has Writer content (and not
+    // editeng) if its autostyle has a parent style. Do the same for shapes as well.
+    for( auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList) )
+    {
+        if (aIter.getToken() == XML_ELEMENT(DRAW, XML_STYLE_NAME))
+        {
+            OUString aStyleName = aIter.toString();
+            if(!aStyleName.isEmpty())
+            {
+                rtl::Reference<XMLTextImportHelper> xTxtImport = GetImport().GetTextImport();
+                XMLPropStyleContext* pStyle = xTxtImport->FindAutoFrameStyle(aStyleName);
+                // Note that this an API name, so intentionally not localized.
+                // Also allow other Frame styles with the same prefix, we just want to reject
+                // Graphics after all.
+                if (pStyle && pStyle->GetParentName().startsWith("Frame"))
+                {
+                    mbTextBox = true;
+                    break;
+                }
+            }
+        }
+    }
+}
+
+SdXMLCustomShapeContext::~SdXMLCustomShapeContext()
+{
+}
+
+// this is called from the parent group for each unparsed attribute in the attribute list
+bool SdXMLCustomShapeContext::processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & aIter )
+{
+    if( aIter.getToken() == XML_ELEMENT(DRAW, XML_ENGINE) )
+    {
+        maCustomShapeEngine = aIter.toString();
+    }
+    else if (aIter.getToken() == XML_ELEMENT(DRAW, XML_DATA) )
+    {
+        maCustomShapeData = aIter.toString();
+    }
+    else
+        return SdXMLShapeContext::processAttribute( aIter );
+    return true;
+}
+
+void SdXMLCustomShapeContext::startFastElement (sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
+{
+    // create rectangle shape
+    AddShape("com.sun.star.drawing.CustomShape");
+    if ( !mxShape.is() )
+        return;
+
+    // Add, set Style and properties from base shape
+    SetStyle();
+    SetLayer();
+
+    // set pos, size, shear and rotate
+    SetTransformation();
+
+    try
+    {
+        uno::Reference< beans::XPropertySet > xPropSet( mxShape, uno::UNO_QUERY );
+        if( xPropSet.is() )
+        {
+            if ( !maCustomShapeEngine.isEmpty() )
+            {
+                xPropSet->setPropertyValue( EASGet( EAS_CustomShapeEngine ), Any(maCustomShapeEngine) );
+            }
+            if ( !maCustomShapeData.isEmpty() )
+            {
+                xPropSet->setPropertyValue( EASGet( EAS_CustomShapeData ), Any(maCustomShapeData) );
+            }
+        }
+    }
+    catch(const uno::Exception&)
+    {
+        DBG_UNHANDLED_EXCEPTION( "xmloff", "setting enhanced customshape geometry" );
+    }
+    SdXMLShapeContext::startFastElement(nElement, xAttrList);
+}
+
+void SdXMLCustomShapeContext::endFastElement(sal_Int32 nElement)
+{
+    // Customshapes remember mirror state in its enhanced geometry.
+    // SetTransformation() in StartElement() may have applied mirroring, but that is not yet
+    // contained. Merge that information here before writing the property.
+    if(!maUsedTransformation.isIdentity())
+    {
+        basegfx::B2DVector aScale, aTranslate;
+        double fRotate, fShearX;
+
+        maUsedTransformation.decompose(aScale, aTranslate, fRotate, fShearX);
+
+        if (aScale.getX() < 0.0)
+        {
+            static const OUStringLiteral sName(u"MirroredX");
+            //fdo#84043 Merge, if property exists, otherwise append it
+            auto aI = std::find_if(maCustomShapeGeometry.begin(), maCustomShapeGeometry.end(),
+                [](beans::PropertyValue& rValue) { return rValue.Name == sName; });
+            if (aI != maCustomShapeGeometry.end())
+            {
+                beans::PropertyValue& rItem = *aI;
+                bool bMirroredX = *o3tl::doAccess<bool>(rItem.Value);
+                rItem.Value <<= !bMirroredX;
+                rItem.Handle = -1;
+                rItem.State = beans::PropertyState_DIRECT_VALUE;
+            }
+            else
+            {
+                beans::PropertyValue* pItem;
+                maCustomShapeGeometry.emplace_back();
+                pItem = &maCustomShapeGeometry.back();
+                pItem->Name = sName;
+                pItem->Handle = -1;
+                pItem->Value <<= true;
+                pItem->State = beans::PropertyState_DIRECT_VALUE;
+            }
+        }
+
+        if (aScale.getY() < 0.0)
+        {
+            static const OUStringLiteral sName(u"MirroredY");
+            //fdo#84043 Merge, if property exists, otherwise append it
+            auto aI = std::find_if(maCustomShapeGeometry.begin(), maCustomShapeGeometry.end(),
+                [](beans::PropertyValue& rValue) { return rValue.Name == sName; });
+            if (aI != maCustomShapeGeometry.end())
+            {
+                beans::PropertyValue& rItem = *aI;
+                bool bMirroredY = *o3tl::doAccess<bool>(rItem.Value);
+                rItem.Value <<= !bMirroredY;
+                rItem.Handle = -1;
+                rItem.State = beans::PropertyState_DIRECT_VALUE;
+            }
+            else
+            {
+                beans::PropertyValue* pItem;
+                maCustomShapeGeometry.emplace_back();
+                pItem = &maCustomShapeGeometry.back();
+                pItem->Name = sName;
+                pItem->Handle = -1;
+                pItem->Value <<= true;
+                pItem->State = beans::PropertyState_DIRECT_VALUE;
+            }
+        }
+    }
+
+    if ( !maCustomShapeGeometry.empty() )
+    {
+        // converting the vector to a sequence
+        uno::Sequence< beans::PropertyValue > aSeq( comphelper::containerToSequence(maCustomShapeGeometry) );
+
+        try
+        {
+            uno::Reference< beans::XPropertySet > xPropSet( mxShape, uno::UNO_QUERY );
+            if( xPropSet.is() )
+            {
+                xPropSet->setPropertyValue( "CustomShapeGeometry", Any(aSeq) );
+            }
+        }
+        catch(const uno::Exception&)
+        {
+            DBG_UNHANDLED_EXCEPTION( "xmloff", "setting enhanced customshape geometry" );
+        }
+
+        sal_Int32 nUPD;
+        sal_Int32 nBuild;
+        if (GetImport().getBuildIds(nUPD, nBuild))
+        {
+            if( ((nUPD >= 640 && nUPD <= 645) || (nUPD == 680)) && (nBuild <= 9221) )
+            {
+                Reference< drawing::XEnhancedCustomShapeDefaulter > xDefaulter( mxShape, UNO_QUERY );
+                if( xDefaulter.is() )
+                {
+                    xDefaulter->createCustomShapeDefaults( "" );
+                }
+            }
+        }
+    }
+
+    SdXMLShapeContext::endFastElement(nElement);
+
+    // tdf#98163 call a custom slot to be able to reset the UNO API
+    // implementations held on the SdrObjects of type
+    // SdrObjCustomShape - those tend to linger until the entire file
+    // is loaded. For large files with a lot of these, 32bit systems
+    // may crash due to being out of resources after ca. 4200
+    // Outliners and VirtualDevices used there as RefDevice
+    try
+    {
+        uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
+
+        if(xPropSet.is())
+        {
+            xPropSet->setPropertyValue(
+                "FlushCustomShapeUnoApiObjects", css::uno::Any(true));
+        }
+    }
+    catch(const uno::Exception&)
+    {
+        DBG_UNHANDLED_EXCEPTION("xmloff", "flushing after load");
+    }
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLCustomShapeContext::createFastChildContext(
+    sal_Int32 nElement,
+    const uno::Reference< xml::sax::XFastAttributeList>& xAttrList )
+{
+    css::uno::Reference< css::xml::sax::XFastContextHandler > xContext;
+    if ( nElement == XML_ELEMENT(DRAW, XML_ENHANCED_GEOMETRY) )
+    {
+        uno::Reference< beans::XPropertySet > xPropSet( mxShape,uno::UNO_QUERY );
+        if ( xPropSet.is() )
+            xContext = new XMLEnhancedCustomShapeContext( GetImport(), mxShape, maCustomShapeGeometry );
+    }
+    // delegate to parent class if no context could be created
+    if (!xContext)
+        xContext = SdXMLShapeContext::createFastChildContext( nElement,
+                                                         xAttrList);
+    return xContext;
+}
+
+SdXMLTableShapeContext::SdXMLTableShapeContext( SvXMLImport& rImport, const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList, css::uno::Reference< css::drawing::XShapes > const & rShapes )
+: SdXMLShapeContext( rImport, xAttrList, rShapes, false )
+{
+}
+
+SdXMLTableShapeContext::~SdXMLTableShapeContext()
+{
+}
+
+void SdXMLTableShapeContext::startFastElement (sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
+{
+    OUString service("com.sun.star.drawing.TableShape");
+
+    bool bIsPresShape = !maPresentationClass.isEmpty() && GetImport().GetShapeImport()->IsPresentationShapesSupported();
+    if( bIsPresShape )
+    {
+        if( IsXMLToken( maPresentationClass, XML_TABLE ) )
+        {
+            service = "com.sun.star.presentation.TableShape";
+        }
+    }
+
+    AddShape(service);
+
+    if( !mxShape.is() )
+        return;
+
+    SetLayer();
+
+    uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY);
+
+    if(bIsPresShape && xProps.is())
+    {
+        uno::Reference< beans::XPropertySetInfo > xPropsInfo( xProps->getPropertySetInfo() );
+        if( xPropsInfo.is() )
+        {
+            if( !mbIsPlaceholder && xPropsInfo->hasPropertyByName("IsEmptyPresentationObject"))
+                xProps->setPropertyValue("IsEmptyPresentationObject", css::uno::Any(false) );
+
+            if( mbIsUserTransformed && xPropsInfo->hasPropertyByName("IsPlaceholderDependent"))
+                xProps->setPropertyValue("IsPlaceholderDependent", css::uno::Any(false) );
+        }
+    }
+
+    SetStyle();
+
+    if( xProps.is() )
+    {
+        if( !msTemplateStyleName.isEmpty() ) try
+        {
+            Reference< XStyleFamiliesSupplier > xFamiliesSupp( GetImport().GetModel(), UNO_QUERY_THROW );
+            Reference< XNameAccess > xFamilies( xFamiliesSupp->getStyleFamilies() );
+            Reference< XNameAccess > xTableFamily( xFamilies->getByName( "table" ), UNO_QUERY_THROW );
+            Reference< XStyle > xTableStyle( xTableFamily->getByName( msTemplateStyleName ), UNO_QUERY_THROW );
+            xProps->setPropertyValue("TableTemplate", Any( xTableStyle ) );
+        }
+        catch(const Exception&)
+        {
+            DBG_UNHANDLED_EXCEPTION("xmloff.draw");
+        }
+
+        const XMLPropertyMapEntry* pEntry = &aXMLTableShapeAttributes[0];
+        for( int i = 0; pEntry->msApiName && (i < 6); i++, pEntry++ )
+        {
+            try
+            {
+                const OUString sAPIPropertyName( pEntry->msApiName, pEntry->nApiNameLength, RTL_TEXTENCODING_ASCII_US );
+                xProps->setPropertyValue( sAPIPropertyName, Any( maTemplateStylesUsed[i] ) );
+            }
+            catch(const Exception&)
+            {
+                DBG_UNHANDLED_EXCEPTION("xmloff.draw");
+            }
+        }
+    }
+
+    GetImport().GetShapeImport()->finishShape( mxShape, mxAttrList, mxShapes );
+
+    const rtl::Reference< XMLTableImport >& xTableImport( GetImport().GetShapeImport()->GetShapeTableImport() );
+    if( xTableImport.is() && xProps.is() )
+    {
+        uno::Reference< table::XColumnRowRange > xColumnRowRange(
+            xProps->getPropertyValue("Model"), uno::UNO_QUERY );
+
+        if( xColumnRowRange.is() )
+            mxTableImportContext = xTableImport->CreateTableContext( xColumnRowRange );
+
+        if( mxTableImportContext.is() )
+            mxTableImportContext->startFastElement( nElement, xAttrList );
+    }
+}
+
+void SdXMLTableShapeContext::endFastElement(sal_Int32 nElement)
+{
+    if( mxTableImportContext.is() )
+        mxTableImportContext->endFastElement(nElement);
+
+    SdXMLShapeContext::endFastElement(nElement);
+
+    if( mxShape.is() )
+    {
+        // set pos, size, shear and rotate
+        SetTransformation();
+    }
+}
+
+// this is called from the parent group for each unparsed attribute in the attribute list
+bool SdXMLTableShapeContext::processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & aIter )
+{
+    auto nElement = aIter.getToken();
+    if( IsTokenInNamespace(nElement, XML_NAMESPACE_TABLE) )
+    {
+        if( (nElement & TOKEN_MASK) == XML_TEMPLATE_NAME )
+        {
+            msTemplateStyleName = aIter.toString();
+        }
+        else
+        {
+            int i = 0;
+            const XMLPropertyMapEntry* pEntry = &aXMLTableShapeAttributes[0];
+            while( pEntry->msApiName && (i < 6) )
+            {
+                if( (nElement & TOKEN_MASK) == pEntry->meXMLName )
+                {
+                    if( IsXMLToken( aIter, XML_TRUE ) )
+                        maTemplateStylesUsed[i] = true;
+                    break;
+                }
+                pEntry++;
+                i++;
+            }
+        }
+    }
+    return SdXMLShapeContext::processAttribute( aIter );
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLTableShapeContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    if( mxTableImportContext.is() && IsTokenInNamespace(nElement, XML_NAMESPACE_TABLE) )
+        return mxTableImportContext->createFastChildContext(nElement, xAttrList);
+    return SdXMLShapeContext::createFastChildContext(nElement, xAttrList);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/ximpshap.hxx b/xmloff/source/draw/ximpshap.hxx
new file mode 100644
index 000000000..e11f1688e
--- /dev/null
+++ b/xmloff/source/draw/ximpshap.hxx
@@ -0,0 +1,640 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <com/sun/star/io/XOutputStream.hpp>
+#include <com/sun/star/document/XActionLockable.hpp>
+#include <com/sun/star/drawing/Alignment.hpp>
+#include <com/sun/star/drawing/CircleKind.hpp>
+#include <com/sun/star/drawing/ConnectorType.hpp>
+#include <com/sun/star/drawing/EscapeDirection.hpp>
+#include <com/sun/star/container/XIdentifierContainer.hpp>
+#include <xmloff/xmlictxt.hxx>
+#include <com/sun/star/drawing/XShapes.hpp>
+#include <com/sun/star/text/XTextCursor.hpp>
+#include <com/sun/star/awt/Point.hpp>
+#include <xexptran.hxx>
+#include <vector>
+#include <xmloff/shapeimport.hxx>
+#include <xmlmultiimagehelper.hxx>
+#include <basegfx/matrix/b2dhommatrix.hxx>
+
+template<typename EnumT> struct SvXMLEnumMapEntry;
+
+// common shape context
+
+class SdXMLShapeContext : public SvXMLShapeContext
+{
+protected:
+    // the shape group this object should be created inside
+    css::uno::Reference< css::drawing::XShapes >  mxShapes;
+    css::uno::Reference< css::text::XTextCursor > mxCursor;
+    css::uno::Reference< css::text::XTextCursor > mxOldCursor;
+    css::uno::Reference< css::xml::sax::XFastAttributeList> mxAttrList;
+    css::uno::Reference< css::container::XIdentifierContainer > mxGluePoints;
+    css::uno::Reference< css::document::XActionLockable > mxLockable;
+
+    OUString               maDrawStyleName;
+    OUString               maTextStyleName;
+    OUString               maPresentationClass;
+    OUString               maShapeName;
+    OUString               maThumbnailURL;
+
+    /// whether to restore list context (#91964#)
+    bool                        mbListContextPushed;
+
+    XmlStyleFamily              mnStyleFamily;
+    bool                    mbIsPlaceholder;
+    bool                        mbClearDefaultAttributes;
+    bool                    mbIsUserTransformed;
+    sal_Int32                   mnZOrder;
+    OUString               maShapeId;
+    OUString               maLayerName;
+
+    SdXMLImExTransform2D        mnTransform;
+    css::awt::Size              maSize;
+    sal_Int16                   mnRelWidth;
+    sal_Int16                   mnRelHeight;
+    css::awt::Point             maPosition;
+    basegfx::B2DHomMatrix       maUsedTransformation;
+
+    bool                        mbVisible;
+    bool                        mbPrintable;
+    bool mbHaveXmlId;
+    bool mbTextBox; ///< If the text of this shape is handled by a Writer TextFrame.
+
+    /** if bSupportsStyle is false, auto styles will be set but not a style */
+    void SetStyle( bool bSupportsStyle = true );
+    void SetLayer();
+    void SetThumbnail();
+
+    void AddShape(css::uno::Reference< css::drawing::XShape >& xShape);
+    void AddShape(OUString const & serviceName);
+    void SetTransformation();
+
+    using SvXMLImportContext::GetImport;
+
+    void addGluePoint( const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList );
+
+    bool isPresentationShape() const;
+
+public:
+
+    SdXMLShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes,
+        bool bTemporaryShape);
+    virtual ~SdXMLShapeContext() override;
+
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+
+    // this is called from the parent group for each unparsed attribute in the attribute list
+    virtual bool processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & );
+
+};
+
+// draw:rect context
+
+class SdXMLRectShapeContext : public SdXMLShapeContext
+{
+    sal_Int32                   mnRadius;
+
+public:
+
+    SdXMLRectShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes,
+        bool bTemporaryShape);
+    virtual ~SdXMLRectShapeContext() override;
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+
+    // this is called from the parent group for each unparsed attribute in the attribute list
+    virtual bool processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & ) override;
+};
+
+// draw:line context
+
+class SdXMLLineShapeContext : public SdXMLShapeContext
+{
+    sal_Int32                   mnX1;
+    sal_Int32                   mnY1;
+    sal_Int32                   mnX2;
+    sal_Int32                   mnY2;
+
+public:
+
+    SdXMLLineShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes,
+        bool bTemporaryShape);
+    virtual ~SdXMLLineShapeContext() override;
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+
+    // this is called from the parent group for each unparsed attribute in the attribute list
+    virtual bool processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & ) override;
+};
+
+// draw:ellipse and draw:circle context
+
+class SdXMLEllipseShapeContext : public SdXMLShapeContext
+{
+    sal_Int32                   mnCX;
+    sal_Int32                   mnCY;
+    sal_Int32                   mnRX;
+    sal_Int32                   mnRY;
+
+    css::drawing::CircleKind    meKind;
+    sal_Int32                   mnStartAngle;
+    sal_Int32                   mnEndAngle;
+public:
+
+    SdXMLEllipseShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes,
+        bool bTemporaryShape);
+    virtual ~SdXMLEllipseShapeContext() override;
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+
+    // this is called from the parent group for each unparsed attribute in the attribute list
+    virtual bool processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & ) override;
+};
+
+// draw:polyline and draw:polygon context
+
+class SdXMLPolygonShapeContext : public SdXMLShapeContext
+{
+    OUString               maPoints;
+    OUString               maViewBox;
+    bool                   mbClosed;
+
+public:
+
+    SdXMLPolygonShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes, bool bClosed, bool bTemporaryShape);
+    virtual ~SdXMLPolygonShapeContext() override;
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+
+    // this is called from the parent group for each unparsed attribute in the attribute list
+    virtual bool processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & ) override;
+};
+
+// draw:path context
+
+class SdXMLPathShapeContext : public SdXMLShapeContext
+{
+    OUString               maD;
+    OUString               maViewBox;
+
+public:
+
+    SdXMLPathShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes,
+        bool bTemporaryShape);
+    virtual ~SdXMLPathShapeContext() override;
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+
+    // this is called from the parent group for each unparsed attribute in the attribute list
+    virtual bool processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & ) override;
+};
+
+// draw:text-box context
+
+class SdXMLTextBoxShapeContext : public SdXMLShapeContext
+{
+    sal_Int32                   mnRadius;
+    OUString                    maChainNextName;
+
+public:
+
+    SdXMLTextBoxShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes);
+    virtual ~SdXMLTextBoxShapeContext() override;
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+
+    // this is called from the parent group for each unparsed attribute in the attribute list
+    virtual bool processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & ) override;
+};
+
+// draw:control context
+
+class SdXMLControlShapeContext : public SdXMLShapeContext
+{
+private:
+    OUString maFormId;
+
+public:
+
+    SdXMLControlShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes,
+        bool bTemporaryShape);
+    virtual ~SdXMLControlShapeContext() override;
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+
+    // this is called from the parent group for each unparsed attribute in the attribute list
+    virtual bool processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & ) override;
+};
+
+// draw:connector context
+
+class SdXMLConnectorShapeContext : public SdXMLShapeContext
+{
+private:
+    css::awt::Point maStart;
+    css::awt::Point maEnd;
+
+    css::drawing::ConnectorType
+                    mnType;
+
+    OUString        maStartShapeId;
+    sal_Int32       mnStartGlueId;
+    OUString        maEndShapeId;
+    sal_Int32       mnEndGlueId;
+
+    sal_Int32   mnDelta1;
+    sal_Int32   mnDelta2;
+    sal_Int32   mnDelta3;
+
+    css::uno::Any maPath;
+
+public:
+
+    SdXMLConnectorShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes,
+        bool bTemporaryShape);
+    virtual ~SdXMLConnectorShapeContext() override;
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+
+    // this is called from the parent group for each unparsed attribute in the attribute list
+    virtual bool processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & ) override;
+};
+
+// draw:measure context
+
+class SdXMLMeasureShapeContext : public SdXMLShapeContext
+{
+private:
+    css::awt::Point maStart;
+    css::awt::Point maEnd;
+
+public:
+
+    SdXMLMeasureShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes,
+        bool bTemporaryShape);
+    virtual ~SdXMLMeasureShapeContext() override;
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+
+    // this is called from the parent group for each unparsed attribute in the attribute list
+    virtual bool processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & ) override;
+};
+
+// draw:page context
+
+class SdXMLPageShapeContext : public SdXMLShapeContext
+{
+private:
+    sal_Int32   mnPageNumber;
+public:
+
+    SdXMLPageShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes,
+        bool bTemporaryShape);
+    virtual ~SdXMLPageShapeContext() override;
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+
+    // this is called from the parent group for each unparsed attribute in the attribute list
+    virtual bool processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & ) override;
+};
+
+// draw:caption context
+
+class SdXMLCaptionShapeContext : public SdXMLShapeContext
+{
+private:
+    css::awt::Point maCaptionPoint;
+    sal_Int32 mnRadius;
+
+public:
+
+    SdXMLCaptionShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes,
+        bool bTemporaryShape);
+    virtual ~SdXMLCaptionShapeContext() override;
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+
+    // this is called from the parent group for each unparsed attribute in the attribute list
+    virtual bool processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & ) override;
+};
+
+// office:image context
+
+class SdXMLGraphicObjectShapeContext : public SdXMLShapeContext
+{
+private:
+    OUString maURL;
+    css::uno::Reference < css::io::XOutputStream > mxBase64Stream;
+
+public:
+
+    SdXMLGraphicObjectShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes);
+    virtual ~SdXMLGraphicObjectShapeContext() override;
+
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+
+    // this is called from the parent group for each unparsed attribute in the attribute list
+    virtual bool processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & ) override;
+};
+
+// chart:chart context
+
+class SdXMLChartShapeContext : public SdXMLShapeContext
+{
+    SvXMLImportContextRef mxChartContext;
+
+public:
+
+    SdXMLChartShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes,
+        bool bTemporaryShape);
+
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+    virtual void SAL_CALL characters( const OUString& rChars ) override;
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+};
+
+// draw:object and draw:object_ole context
+
+class SdXMLObjectShapeContext : public SdXMLShapeContext
+{
+private:
+    OUString maCLSID;
+    OUString maHref;
+
+    css::uno::Reference < css::io::XOutputStream > mxBase64Stream;
+
+public:
+
+    SdXMLObjectShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes);
+    virtual ~SdXMLObjectShapeContext() override;
+
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+
+    // this is called from the parent group for each unparsed attribute in the attribute list
+    virtual bool processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & ) override;
+};
+
+// draw:applet
+
+class SdXMLAppletShapeContext : public SdXMLShapeContext
+{
+private:
+    OUString maAppletName;
+    OUString maAppletCode;
+    OUString maHref;
+    bool mbIsScript;
+
+    css::uno::Sequence< css::beans::PropertyValue > maParams;
+
+public:
+
+    SdXMLAppletShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes);
+    virtual ~SdXMLAppletShapeContext() override;
+
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+
+    // this is called from the parent group for each unparsed attribute in the attribute list
+    virtual bool processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & ) override;
+};
+
+// draw:plugin
+
+class SdXMLPluginShapeContext : public SdXMLShapeContext
+{
+private:
+    OUString   maMimeType;
+    OUString   maHref;
+    bool            mbMedia;
+
+    css::uno::Sequence< css::beans::PropertyValue > maParams;
+
+public:
+
+    SdXMLPluginShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes);
+    virtual ~SdXMLPluginShapeContext() override;
+
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+
+    // this is called from the parent group for each unparsed attribute in the attribute list
+    virtual bool processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & ) override;
+
+    const OUString& getMimeType() const { return maMimeType; }
+};
+
+// draw:floating-frame
+
+class SdXMLFloatingFrameShapeContext : public SdXMLShapeContext
+{
+private:
+    OUString maFrameName;
+    OUString maHref;
+
+    css::uno::Reference<css::drawing::XShape> CreateFloatingFrameShape() const;
+
+public:
+
+    SdXMLFloatingFrameShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes);
+    virtual ~SdXMLFloatingFrameShapeContext() override;
+
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+
+    // this is called from the parent group for each unparsed attribute in the attribute list
+    virtual bool processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & ) override;
+};
+
+// draw:-frame
+
+class SdXMLFrameShapeContext : public SdXMLShapeContext, public MultiImageImportHelper
+{
+private:
+    bool mbSupportsReplacement;
+    SvXMLImportContextRef mxImplContext;
+    SvXMLImportContextRef mxReplImplContext;
+
+protected:
+    /// helper to get the created xShape instance, needs to be overridden
+    void removeGraphicFromImportContext(const SvXMLImportContext& rContext) override;
+    OUString getGraphicPackageURLFromImportContext(const SvXMLImportContext& rContext) const override;
+    css::uno::Reference<css::graphic::XGraphic> getGraphicFromImportContext(const SvXMLImportContext& rContext) const override;
+
+public:
+
+    SdXMLFrameShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes,
+        bool bTemporaryShape);
+    virtual ~SdXMLFrameShapeContext() override;
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+
+    virtual bool processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & ) override;
+};
+
+class SdXMLCustomShapeContext : public SdXMLShapeContext
+{
+    OUString maCustomShapeEngine;
+    OUString maCustomShapeData;
+
+    std::vector< css::beans::PropertyValue > maCustomShapeGeometry;
+
+public:
+
+
+    SdXMLCustomShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes);
+    virtual ~SdXMLCustomShapeContext() override;
+
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+
+    // this is called from the parent group for each unparsed attribute in the attribute list
+    virtual bool processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & ) override;
+};
+
+// draw:table
+
+class SdXMLTableShapeContext : public SdXMLShapeContext
+{
+public:
+
+    SdXMLTableShapeContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes );
+    virtual ~SdXMLTableShapeContext() override;
+
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+
+    // this is called from the parent group for each unparsed attribute in the attribute list
+    virtual bool processAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & ) override;
+
+private:
+    SvXMLImportContextRef mxTableImportContext;
+    OUString msTemplateStyleName;
+    bool maTemplateStylesUsed[6] = {};
+};
+
+extern SvXMLEnumMapEntry<css::drawing::Alignment> const aXML_GlueAlignment_EnumMap[];
+extern SvXMLEnumMapEntry<css::drawing::EscapeDirection> const aXML_GlueEscapeDirection_EnumMap[];
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/ximpshow.cxx b/xmloff/source/draw/ximpshow.cxx
new file mode 100644
index 000000000..f89d4d9fb
--- /dev/null
+++ b/xmloff/source/draw/ximpshow.cxx
@@ -0,0 +1,244 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/util/Duration.hpp>
+#include <com/sun/star/xml/sax/XAttributeList.hpp>
+#include <com/sun/star/presentation/XCustomPresentationSupplier.hpp>
+#include <com/sun/star/presentation/XPresentationSupplier.hpp>
+#include <com/sun/star/container/XIndexContainer.hpp>
+#include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
+#include <sax/tools/converter.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/namespacemap.hxx>
+#include <xmloff/xmluconv.hxx>
+#include "ximpshow.hxx"
+
+using namespace ::std;
+using namespace ::cppu;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::xml;
+using namespace ::com::sun::star::xml::sax;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::drawing;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::presentation;
+using namespace ::xmloff::token;
+
+SdXMLShowsContext::SdXMLShowsContext( SdXMLImport& rImport, const Reference< XFastAttributeList >& xAttrList )
+:   SvXMLImportContext(rImport)
+{
+
+    Reference< XCustomPresentationSupplier > xShowsSupplier( rImport.GetModel(), UNO_QUERY );
+    if( xShowsSupplier.is() )
+    {
+        mxShows = xShowsSupplier->getCustomPresentations();
+        mxShowFactory.set( mxShows, UNO_QUERY );
+    }
+
+    Reference< XDrawPagesSupplier > xDrawPagesSupplier( rImport.GetModel(), UNO_QUERY );
+    if( xDrawPagesSupplier.is() )
+        mxPages.set( xDrawPagesSupplier->getDrawPages(), UNO_QUERY );
+
+    Reference< XPresentationSupplier > xPresentationSupplier( rImport.GetModel(), UNO_QUERY );
+    if( xPresentationSupplier.is() )
+        mxPresProps.set( xPresentationSupplier->getPresentation(), UNO_QUERY );
+
+    if( !mxPresProps.is() )
+        return;
+
+    bool bAll = true;
+    uno::Any aAny;
+    // Per ODF this is default, but we did it wrong before LO 6.0 (tdf#108824)
+    bool bIsMouseVisible = true;
+    if (rImport.getGeneratorVersion() < SvXMLImport::LO_6x)
+        bIsMouseVisible = false;
+
+    // read attributes
+    for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+    {
+        switch( aIter.getToken() )
+        {
+            case XML_ELEMENT(PRESENTATION, XML_START_PAGE):
+            {
+                mxPresProps->setPropertyValue("FirstPage", Any(aIter.toString()) );
+                bAll = false;
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_SHOW):
+            {
+                maCustomShowName = aIter.toString();
+                bAll = false;
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_PAUSE):
+            {
+                Duration aDuration;
+                if (!::sax::Converter::convertDuration(aDuration, aIter.toView()))
+                    continue;
+
+                const sal_Int32 nMS = (aDuration.Hours * 60 +
+                        aDuration.Minutes) * 60 + aDuration.Seconds;
+                mxPresProps->setPropertyValue("Pause", Any(nMS) );
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_ANIMATIONS):
+            {
+                aAny <<= IsXMLToken( aIter, XML_ENABLED );
+                mxPresProps->setPropertyValue("AllowAnimations", aAny );
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_STAY_ON_TOP):
+            {
+                aAny <<= IsXMLToken( aIter, XML_TRUE );
+                mxPresProps->setPropertyValue("IsAlwaysOnTop", aAny );
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_FORCE_MANUAL):
+            {
+                aAny <<= IsXMLToken( aIter, XML_TRUE );
+                mxPresProps->setPropertyValue("IsAutomatic", aAny );
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_ENDLESS):
+            {
+                aAny <<= IsXMLToken( aIter, XML_TRUE );
+                mxPresProps->setPropertyValue("IsEndless", aAny );
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_FULL_SCREEN):
+            {
+                aAny <<= IsXMLToken( aIter, XML_TRUE );
+                mxPresProps->setPropertyValue("IsFullScreen", aAny );
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_MOUSE_VISIBLE):
+            {
+                bIsMouseVisible = IsXMLToken( aIter, XML_TRUE );
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_START_WITH_NAVIGATOR):
+            {
+                aAny <<= IsXMLToken( aIter, XML_TRUE );
+                mxPresProps->setPropertyValue("StartWithNavigator", aAny );
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_MOUSE_AS_PEN):
+            {
+                aAny <<= IsXMLToken( aIter, XML_TRUE );
+                mxPresProps->setPropertyValue("UsePen", aAny );
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_TRANSITION_ON_CLICK):
+            {
+                aAny <<= IsXMLToken( aIter, XML_ENABLED );
+                mxPresProps->setPropertyValue("IsTransitionOnClick", aAny );
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_SHOW_LOGO):
+            {
+                aAny <<= IsXMLToken( aIter, XML_TRUE );
+                mxPresProps->setPropertyValue("IsShowLogo", aAny );
+                break;
+            }
+        }
+    }
+    mxPresProps->setPropertyValue("IsShowAll", Any(bAll) );
+    mxPresProps->setPropertyValue("IsMouseVisible", Any(bIsMouseVisible) );
+}
+
+SdXMLShowsContext::~SdXMLShowsContext()
+{
+    if( !maCustomShowName.isEmpty() )
+    {
+        uno::Any aAny;
+        aAny <<= maCustomShowName;
+        mxPresProps->setPropertyValue("CustomShow", aAny );
+    }
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLShowsContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    if( nElement == XML_ELEMENT(PRESENTATION, XML_SHOW) )
+    {
+        OUString aName;
+        OUString aPages;
+
+        // read attributes
+        for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+        {
+            OUString sValue = aIter.toString();
+
+            switch( aIter.getToken() )
+            {
+                case XML_ELEMENT(PRESENTATION, XML_NAME):
+                    aName = sValue;
+                    break;
+                case XML_ELEMENT(PRESENTATION, XML_PAGES):
+                    aPages = sValue;
+                    break;
+            }
+        }
+
+        if( !aName.isEmpty() && !aPages.isEmpty() )
+        {
+            Reference< XIndexContainer > xShow( mxShowFactory->createInstance(), UNO_QUERY );
+            if( xShow.is() )
+            {
+                SvXMLTokenEnumerator aPageNames( aPages, ',' );
+                std::u16string_view sPageNameView;
+
+                while( aPageNames.getNextToken( sPageNameView ) )
+                {
+                    OUString sPageName(sPageNameView);
+                    if( !mxPages->hasByName( sPageName ) )
+                        continue;
+
+                    Reference< XDrawPage > xPage;
+                    mxPages->getByName( sPageName ) >>= xPage;
+                    if( xPage.is() )
+                    {
+                        xShow->insertByIndex( xShow->getCount(), Any(xPage) );
+                    }
+                }
+
+                Any aAny;
+                aAny <<= xShow;
+                if( mxShows->hasByName( aName ) )
+                {
+                    mxShows->replaceByName( aName, aAny );
+                }
+                else
+                {
+                    mxShows->insertByName( aName, aAny );
+                }
+            }
+        }
+    }
+
+    return nullptr;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/ximpshow.hxx b/xmloff/source/draw/ximpshow.hxx
new file mode 100644
index 000000000..33948c3a6
--- /dev/null
+++ b/xmloff/source/draw/ximpshow.hxx
@@ -0,0 +1,49 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlictxt.hxx>
+#include "sdxmlimp_impl.hxx"
+#include <memory>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/lang/XSingleServiceFactory.hpp>
+#include <com/sun/star/container/XNameContainer.hpp>
+
+// presentations:animations
+
+class SdXMLShowsContext : public SvXMLImportContext
+{
+public:
+
+    SdXMLShowsContext( SdXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList);
+    virtual ~SdXMLShowsContext() override;
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+                sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+private:
+    css::uno::Reference< css::lang::XSingleServiceFactory > mxShowFactory;
+    css::uno::Reference< css::container::XNameContainer > mxShows;
+    css::uno::Reference< css::beans::XPropertySet > mxPresProps;
+    css::uno::Reference< css::container::XNameAccess > mxPages;
+    OUString maCustomShowName;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/ximpstyl.cxx b/xmloff/source/draw/ximpstyl.cxx
new file mode 100644
index 000000000..4befbb008
--- /dev/null
+++ b/xmloff/source/draw/ximpstyl.cxx
@@ -0,0 +1,1600 @@
+/* -*- 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 "ximpstyl.hxx"
+#include <xmloff/maptype.hxx>
+#include <xmloff/XMLDrawingPageStyleContext.hxx>
+#include <xmloff/XMLShapeStyleContext.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmlprmap.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include "ximpnote.hxx"
+#include <xmlsdtypes.hxx>
+#include <tools/debug.hxx>
+#include <sal/log.hxx>
+#include <tools/diagnose_ex.h>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/style/XStyle.hpp>
+#include <com/sun/star/lang/XSingleServiceFactory.hpp>
+#include <com/sun/star/presentation/XPresentationPage.hpp>
+#include <com/sun/star/drawing/FillStyle.hpp>
+#include <com/sun/star/drawing/XDrawPages.hpp>
+#include <com/sun/star/container/XNamed.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/beans/XPropertyState.hpp>
+#include <com/sun/star/presentation/XHandoutMasterSupplier.hpp>
+#include <com/sun/star/util/Color.hpp>
+#include <comphelper/namecontainer.hxx>
+#include <xmloff/autolayout.hxx>
+#include <xmloff/xmlprcon.hxx>
+#include <xmloff/families.hxx>
+#include <com/sun/star/container/XNameContainer.hpp>
+#include <svl/numformat.hxx>
+#include <svl/zforlist.hxx>
+#include "layerimp.hxx"
+#include <xmloff/XMLGraphicsDefaultStyle.hxx>
+#include <XMLNumberStylesImport.hxx>
+#include <unotools/configmgr.hxx>
+#include <xmloff/xmlerror.hxx>
+#include <xmloff/table/XMLTableImport.hxx>
+#include <comphelper/sequenceashashmap.hxx>
+#include <sax/tools/converter.hxx>
+#include <comphelper/sequence.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::xml::sax;
+using namespace ::xmloff::token;
+
+namespace {
+
+class SdXMLDrawingPagePropertySetContext : public SvXMLPropertySetContext
+{
+public:
+
+    SdXMLDrawingPagePropertySetContext( SvXMLImport& rImport, sal_Int32 nElement,
+                 const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList,
+                 ::std::vector< XMLPropertyState > &rProps,
+                 const rtl::Reference < SvXMLImportPropertyMapper > &rMap );
+
+    using SvXMLPropertySetContext::createFastChildContext;
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > createFastChildContext(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList,
+        ::std::vector< XMLPropertyState > &rProperties,
+        const XMLPropertyState& rProp ) override;
+};
+
+/// Imports <loext:theme>.
+class XMLThemeContext : public SvXMLImportContext
+{
+    uno::Reference<beans::XPropertySet> m_xMasterPage;
+    comphelper::SequenceAsHashMap m_aTheme;
+
+public:
+    XMLThemeContext(SvXMLImport& rImport,
+                    const uno::Reference<xml::sax::XFastAttributeList>& xAttrList,
+                    const uno::Reference<beans::XPropertySet>& xMasterPage);
+    ~XMLThemeContext();
+
+    uno::Reference<xml::sax::XFastContextHandler> SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttribs) override;
+};
+
+/// Imports <loext:color-table> inside <loext:theme>.
+class XMLColorTableContext : public SvXMLImportContext
+{
+    comphelper::SequenceAsHashMap& m_rTheme;
+    std::vector<util::Color> m_aColorScheme;
+
+public:
+    XMLColorTableContext(SvXMLImport& rImport,
+                         const uno::Reference<xml::sax::XFastAttributeList>& xAttrList,
+                         comphelper::SequenceAsHashMap& rTheme);
+    ~XMLColorTableContext();
+
+    uno::Reference<xml::sax::XFastContextHandler> SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttribs) override;
+};
+
+/// Imports <loext:color> inside <loext:color-table>.
+class XMLColorContext : public SvXMLImportContext
+{
+public:
+    XMLColorContext(SvXMLImport& rImport,
+                    const uno::Reference<xml::sax::XFastAttributeList>& xAttrList,
+                    std::vector<util::Color>& rColorScheme);
+};
+}
+
+SdXMLDrawingPagePropertySetContext::SdXMLDrawingPagePropertySetContext(
+                 SvXMLImport& rImport, sal_Int32 nElement,
+                 const uno::Reference< xml::sax::XFastAttributeList > & xAttrList,
+                 ::std::vector< XMLPropertyState > &rProps,
+                 const rtl::Reference < SvXMLImportPropertyMapper > &rMap ) :
+    SvXMLPropertySetContext( rImport, nElement, xAttrList,
+                             XML_TYPE_PROP_DRAWING_PAGE, rProps, rMap )
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLDrawingPagePropertySetContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList,
+    ::std::vector< XMLPropertyState > &rProperties,
+    const XMLPropertyState& rProp )
+{
+    switch( mxMapper->getPropertySetMapper()->GetEntryContextId( rProp.mnIndex ) )
+    {
+    case CTF_PAGE_SOUND_URL:
+    {
+        for (auto &aIter : sax_fastparser::castToFastAttributeList(xAttrList))
+        {
+            if( aIter.getToken() == XML_ELEMENT(XLINK, XML_HREF) )
+            {
+                uno::Any aAny( GetImport().GetAbsoluteReference( aIter.toString() ) );
+                XMLPropertyState aPropState( rProp.mnIndex, aAny );
+                rProperties.push_back( aPropState );
+            }
+            else
+                XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+        }
+        break;
+    }
+    }
+
+    return SvXMLPropertySetContext::createFastChildContext( nElement,
+                                                            xAttrList,
+                                                            rProperties, rProp );
+}
+
+namespace {
+
+
+class SdXMLDrawingPageStyleContext : public XMLDrawingPageStyleContext
+{
+public:
+
+    SdXMLDrawingPageStyleContext(
+        SvXMLImport& rImport,
+        SvXMLStylesContext& rStyles);
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+
+    virtual void Finish( bool bOverwrite ) override;
+};
+
+const sal_uInt16 MAX_SPECIAL_DRAW_STYLES = 7;
+ContextID_Index_Pair const g_ContextIDs[MAX_SPECIAL_DRAW_STYLES+1] =
+{
+    { CTF_DASHNAME,         -1, drawing::FillStyle::FillStyle_MAKE_FIXED_SIZE },
+    { CTF_LINESTARTNAME,    -1, drawing::FillStyle::FillStyle_MAKE_FIXED_SIZE },
+    { CTF_LINEENDNAME,      -1, drawing::FillStyle::FillStyle_MAKE_FIXED_SIZE },
+    { CTF_FILLGRADIENTNAME, -1, drawing::FillStyle::FillStyle_GRADIENT},
+    { CTF_FILLTRANSNAME,    -1, drawing::FillStyle::FillStyle_MAKE_FIXED_SIZE },
+    { CTF_FILLHATCHNAME,    -1, drawing::FillStyle::FillStyle_HATCH },
+    { CTF_FILLBITMAPNAME,   -1, drawing::FillStyle::FillStyle_BITMAP },
+    { -1, -1, drawing::FillStyle::FillStyle_MAKE_FIXED_SIZE }
+};
+XmlStyleFamily const g_Families[MAX_SPECIAL_DRAW_STYLES] =
+{
+    XmlStyleFamily::SD_STROKE_DASH_ID,
+    XmlStyleFamily::SD_MARKER_ID,
+    XmlStyleFamily::SD_MARKER_ID,
+    XmlStyleFamily::SD_GRADIENT_ID,
+    XmlStyleFamily::SD_GRADIENT_ID,
+    XmlStyleFamily::SD_HATCH_ID,
+    XmlStyleFamily::SD_FILL_IMAGE_ID
+};
+
+}
+
+XMLDrawingPageStyleContext::XMLDrawingPageStyleContext(
+    SvXMLImport& rImport,
+    SvXMLStylesContext& rStyles,
+    ContextID_Index_Pair const pContextIDs[],
+    XmlStyleFamily const pFamilies[])
+    : XMLPropStyleContext(rImport, rStyles, XmlStyleFamily::SD_DRAWINGPAGE_ID)
+    , m_pFamilies(pFamilies)
+{
+    size_t size(1); // for the -1 entry
+    for (ContextID_Index_Pair const* pTemp(pContextIDs); pTemp->nContextID != -1; ++size, ++pTemp);
+    m_pContextIDs.reset(new ContextID_Index_Pair[size]);
+    std::memcpy(m_pContextIDs.get(), pContextIDs, size * sizeof(ContextID_Index_Pair));
+}
+
+SdXMLDrawingPageStyleContext::SdXMLDrawingPageStyleContext(
+    SvXMLImport& rImport,
+    SvXMLStylesContext& rStyles)
+    : XMLDrawingPageStyleContext(rImport, rStyles, g_ContextIDs, g_Families)
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLDrawingPageStyleContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    if( nElement == XML_ELEMENT(STYLE, XML_DRAWING_PAGE_PROPERTIES) )
+    {
+        rtl::Reference < SvXMLImportPropertyMapper > xImpPrMap =
+            GetStyles()->GetImportPropertyMapper( GetFamily() );
+        if( xImpPrMap.is() )
+            return new SdXMLDrawingPagePropertySetContext( GetImport(), nElement,
+                                                    xAttrList,
+                                                    GetProperties(),
+                                                    xImpPrMap );
+    }
+
+    return XMLPropStyleContext::createFastChildContext( nElement, xAttrList );
+}
+
+void SdXMLDrawingPageStyleContext::Finish( bool bOverwrite )
+{
+    XMLPropStyleContext::Finish( bOverwrite );
+
+    ::std::vector< XMLPropertyState > &rProperties = GetProperties();
+
+    const rtl::Reference< XMLPropertySetMapper >& rImpPrMap = GetStyles()->GetImportPropertyMapper( GetFamily() )->getPropertySetMapper();
+
+    for(auto& property : rProperties)
+    {
+        if( property.mnIndex == -1 )
+            continue;
+
+        sal_Int16 nContextID = rImpPrMap->GetEntryContextId(property.mnIndex);
+        switch( nContextID )
+        {
+            case CTF_DATE_TIME_FORMAT:
+            {
+                OUString sStyleName;
+                property.maValue >>= sStyleName;
+
+                sal_Int32 nStyle = 0;
+
+                const SdXMLNumberFormatImportContext* pSdNumStyle =
+                    dynamic_cast< const SdXMLNumberFormatImportContext*> (
+                        GetStyles()->FindStyleChildContext( XmlStyleFamily::DATA_STYLE, sStyleName, true ) );
+
+                if( pSdNumStyle )
+                    nStyle = pSdNumStyle->GetDrawKey();
+
+                property.maValue <<= nStyle;
+            }
+            break;
+        }
+    }
+
+}
+
+
+// #i35918#
+void XMLDrawingPageStyleContext::FillPropertySet(
+    const Reference< beans::XPropertySet > & rPropSet )
+{
+    rtl::Reference < SvXMLImportPropertyMapper > xImpPrMap =
+        GetStyles()->GetImportPropertyMapper( GetFamily() );
+    SAL_WARN_IF( !xImpPrMap.is(), "xmloff", "There is the import prop mapper" );
+    if( xImpPrMap.is() )
+        xImpPrMap->FillPropertySet(GetProperties(), rPropSet, m_pContextIDs.get());
+
+    Reference< beans::XPropertySetInfo > xInfo;
+    for (size_t i=0; m_pContextIDs[i].nContextID != -1; ++i)
+    {
+        sal_Int32 nIndex = m_pContextIDs[i].nIndex;
+        if( nIndex != -1 )
+        {
+            struct XMLPropertyState& rState = GetProperties()[nIndex];
+            OUString sStyleName;
+            rState.maValue >>= sStyleName;
+
+            if (::xmloff::IsIgnoreFillStyleNamedItem(rPropSet, m_pContextIDs[i].nExpectedFillStyle))
+            {
+                SAL_INFO("xmloff.style", "XMLDrawingPageStyleContext: dropping fill named item: " << sStyleName);
+                break; // ignore it, it's not used
+            }
+
+            sStyleName = GetImport().GetStyleDisplayName( m_pFamilies[i],
+                                                          sStyleName );
+            // get property set mapper
+            rtl::Reference<XMLPropertySetMapper> rPropMapper =
+                                        xImpPrMap->getPropertySetMapper();
+
+            // set property
+            const OUString& rPropertyName =
+                    rPropMapper->GetEntryAPIName(rState.mnIndex);
+            if( !xInfo.is() )
+                xInfo = rPropSet->getPropertySetInfo();
+            if ( xInfo->hasPropertyByName( rPropertyName ) )
+            {
+                rPropSet->setPropertyValue( rPropertyName, Any( sStyleName ) );
+            }
+        }
+    }
+}
+
+
+SdXMLPageMasterStyleContext::SdXMLPageMasterStyleContext(
+    SdXMLImport& rImport,
+    sal_Int32 /*nElement*/,
+    const uno::Reference< xml::sax::XFastAttributeList>& xAttrList)
+:   SvXMLStyleContext(rImport, XmlStyleFamily::SD_PAGEMASTERSTYLECONTEXT_ID),
+    mnBorderBottom( 0 ),
+    mnBorderLeft( 0 ),
+    mnBorderRight( 0 ),
+    mnBorderTop( 0 ),
+    mnWidth( 0 ),
+    mnHeight( 0 ),
+    meOrientation(GetSdImport().IsDraw() ? view::PaperOrientation_PORTRAIT : view::PaperOrientation_LANDSCAPE)
+{
+    // set family to something special at SvXMLStyleContext
+    // for differences in search-methods
+
+    for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+    {
+        switch(aIter.getToken())
+        {
+            case XML_ELEMENT(FO, XML_MARGIN_TOP):
+            case XML_ELEMENT(FO_COMPAT, XML_MARGIN_TOP):
+            {
+                GetSdImport().GetMM100UnitConverter().convertMeasureToCore(
+                        mnBorderTop, aIter.toView());
+                break;
+            }
+            case XML_ELEMENT(FO, XML_MARGIN_BOTTOM):
+            case XML_ELEMENT(FO_COMPAT, XML_MARGIN_BOTTOM):
+            {
+                GetSdImport().GetMM100UnitConverter().convertMeasureToCore(
+                        mnBorderBottom, aIter.toView());
+                break;
+            }
+            case XML_ELEMENT(FO, XML_MARGIN_LEFT):
+            case XML_ELEMENT(FO_COMPAT, XML_MARGIN_LEFT):
+            {
+                GetSdImport().GetMM100UnitConverter().convertMeasureToCore(
+                        mnBorderLeft, aIter.toView());
+                break;
+            }
+            case XML_ELEMENT(FO, XML_MARGIN_RIGHT):
+            case XML_ELEMENT(FO_COMPAT, XML_MARGIN_RIGHT):
+            {
+                GetSdImport().GetMM100UnitConverter().convertMeasureToCore(
+                        mnBorderRight, aIter.toView());
+                break;
+            }
+            case XML_ELEMENT(FO, XML_PAGE_WIDTH):
+            case XML_ELEMENT(FO_COMPAT, XML_PAGE_WIDTH):
+            {
+                GetSdImport().GetMM100UnitConverter().convertMeasureToCore(
+                        mnWidth, aIter.toView());
+                break;
+            }
+            case XML_ELEMENT(FO, XML_PAGE_HEIGHT):
+            case XML_ELEMENT(FO_COMPAT, XML_PAGE_HEIGHT):
+            {
+                GetSdImport().GetMM100UnitConverter().convertMeasureToCore(
+                        mnHeight, aIter.toView());
+                break;
+            }
+            case XML_ELEMENT(STYLE, XML_PRINT_ORIENTATION):
+            {
+                if( IsXMLToken( aIter, XML_PORTRAIT ) )
+                    meOrientation = view::PaperOrientation_PORTRAIT;
+                else
+                    meOrientation = view::PaperOrientation_LANDSCAPE;
+                break;
+            }
+            default:
+                XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+        }
+    }
+}
+
+SdXMLPageMasterStyleContext::~SdXMLPageMasterStyleContext()
+{
+}
+
+
+SdXMLPageMasterContext::SdXMLPageMasterContext(
+    SdXMLImport& rImport,
+    sal_Int32 /*nElement*/,
+    const uno::Reference< xml::sax::XFastAttributeList>& /*xAttrList*/)
+:   SvXMLStyleContext(rImport, XmlStyleFamily::SD_PAGEMASTERCONTEXT_ID)
+{
+    // set family to something special at SvXMLStyleContext
+    // for differences in search-methods
+
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLPageMasterContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    if(nElement == XML_ELEMENT(STYLE, XML_PAGE_LAYOUT_PROPERTIES))
+    {
+        DBG_ASSERT(!mxPageMasterStyle.is(), "PageMasterStyle is set, there seem to be two of them (!)");
+        mxPageMasterStyle.set(new SdXMLPageMasterStyleContext(GetSdImport(), nElement, xAttrList));
+        return mxPageMasterStyle;
+    }
+    else
+        XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+
+    return nullptr;
+}
+
+SdXMLPresentationPageLayoutContext::SdXMLPresentationPageLayoutContext(
+    SdXMLImport& rImport,
+    sal_Int32 /*nElement*/,
+    const uno::Reference< xml::sax::XFastAttributeList >& /*xAttrList*/)
+:   SvXMLStyleContext(rImport, XmlStyleFamily::SD_PRESENTATIONPAGELAYOUT_ID),
+    mnTypeId( AUTOLAYOUT_NONE )
+{
+    // set family to something special at SvXMLStyleContext
+    // for differences in search-methods
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLPresentationPageLayoutContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    SvXMLImportContextRef xContext;
+
+    if(nElement == XML_ELEMENT(PRESENTATION, XML_PLACEHOLDER))
+    {
+        const rtl::Reference< SdXMLPresentationPlaceholderContext > xLclContext{
+            new SdXMLPresentationPlaceholderContext(GetSdImport(), nElement, xAttrList)};
+        // presentation:placeholder inside style:presentation-page-layout context
+        xContext = xLclContext.get();
+
+        // remember SdXMLPresentationPlaceholderContext for later evaluation
+        maList.push_back(xLclContext);
+    }
+    else
+        XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+
+    return xContext;
+}
+
+void SdXMLPresentationPageLayoutContext::endFastElement(sal_Int32 )
+{
+    // build presentation page layout type here
+    // calc mnTpeId due to content of maList
+    // at the moment only use number of types used there
+    if( maList.empty() )
+        return;
+
+    SdXMLPresentationPlaceholderContext* pObj0 = maList[ 0 ].get();
+    if( pObj0->GetName() == "handout" )
+    {
+        switch( maList.size() )
+        {
+        case 1:
+            mnTypeId = AUTOLAYOUT_HANDOUT1;
+            break;
+        case 2:
+            mnTypeId = AUTOLAYOUT_HANDOUT2;
+            break;
+        case 3:
+            mnTypeId = AUTOLAYOUT_HANDOUT3;
+            break;
+        case 4:
+            mnTypeId = AUTOLAYOUT_HANDOUT4;
+            break;
+        case 9:
+            mnTypeId = AUTOLAYOUT_HANDOUT9;
+            break;
+        default:
+            mnTypeId = AUTOLAYOUT_HANDOUT6;
+        }
+    }
+    else
+    {
+        switch( maList.size() )
+        {
+            case 1:
+            {
+                if( pObj0->GetName() == "title" )
+                {
+                    mnTypeId = AUTOLAYOUT_TITLE_ONLY;
+                }
+                else
+                {
+                    mnTypeId = AUTOLAYOUT_ONLY_TEXT;
+                }
+                break;
+            }
+            case 2:
+            {
+                SdXMLPresentationPlaceholderContext* pObj1 = maList[ 1 ].get();
+
+                if( pObj1->GetName() == "subtitle" )
+                {
+                    mnTypeId = AUTOLAYOUT_TITLE;
+                }
+                else if( pObj1->GetName() == "outline" )
+                {
+                    mnTypeId = AUTOLAYOUT_TITLE_CONTENT;
+                }
+                else if( pObj1->GetName() == "chart" )
+                {
+                    mnTypeId = AUTOLAYOUT_CHART;
+                }
+                else if( pObj1->GetName() == "table" )
+                {
+                    mnTypeId = AUTOLAYOUT_TAB;
+                }
+                else if( pObj1->GetName() == "object" )
+                {
+                    mnTypeId = AUTOLAYOUT_OBJ;
+                }
+                else if( pObj1->GetName() == "vertical_outline" )
+                {
+                    if( pObj0->GetName() == "vertical_title" )
+                    {
+                        mnTypeId = AUTOLAYOUT_VTITLE_VCONTENT;
+                    }
+                    else
+                    {
+                        mnTypeId = AUTOLAYOUT_TITLE_VCONTENT;
+                    }
+                }
+                else
+                {
+                    mnTypeId = AUTOLAYOUT_NOTES;
+                }
+                break;
+            }
+            case 3:
+            {
+                SdXMLPresentationPlaceholderContext* pObj1 = maList[ 1 ].get();
+                SdXMLPresentationPlaceholderContext* pObj2 = maList[ 2 ].get();
+
+                if( pObj1->GetName() == "outline" )
+                {
+                    if( pObj2->GetName() == "outline" )
+                    {
+                        mnTypeId = AUTOLAYOUT_TITLE_2CONTENT;
+                    }
+                    else if( pObj2->GetName() == "chart" )
+                    {
+                        mnTypeId = AUTOLAYOUT_TEXTCHART;
+                    }
+                    else if( pObj2->GetName() == "graphic" )
+                    {
+                        mnTypeId = AUTOLAYOUT_TEXTCLIP;
+                    }
+                    else
+                    {
+                        if(pObj1->GetX() < pObj2->GetX())
+                        {
+                            mnTypeId = AUTOLAYOUT_TEXTOBJ; // outline left, object right
+                        }
+                        else
+                        {
+                            mnTypeId = AUTOLAYOUT_TEXTOVEROBJ; // outline top, object right
+                        }
+                    }
+                }
+                else if( pObj1->GetName() == "chart" )
+                {
+                    mnTypeId = AUTOLAYOUT_CHARTTEXT;
+                }
+                else if( pObj1->GetName() == "graphic" )
+                {
+                    if( pObj2->GetName() == "vertical_outline" )
+                    {
+                        mnTypeId = AUTOLAYOUT_TITLE_2VTEXT;
+                    }
+                    else
+                    {
+                        mnTypeId = AUTOLAYOUT_CLIPTEXT;
+                    }
+                }
+                else if( pObj1->GetName() == "vertical_outline" )
+                {
+                    mnTypeId = AUTOLAYOUT_VTITLE_VCONTENT_OVER_VCONTENT;
+                }
+                else
+                {
+                    if(pObj1->GetX() < pObj2->GetX())
+                    {
+                        mnTypeId = AUTOLAYOUT_OBJTEXT; // left, right
+                    }
+                    else
+                    {
+                        mnTypeId = AUTOLAYOUT_TITLE_CONTENT_OVER_CONTENT; // top, bottom
+                    }
+                }
+                break;
+            }
+            case 4:
+            {
+                SdXMLPresentationPlaceholderContext* pObj1 = maList[ 1 ].get();
+                SdXMLPresentationPlaceholderContext* pObj2 = maList[ 2 ].get();
+
+                if( pObj1->GetName() == "object" )
+                {
+                    if(pObj1->GetX() < pObj2->GetX())
+                    {
+                        mnTypeId = AUTOLAYOUT_TITLE_2CONTENT_OVER_CONTENT;
+                    }
+                    else
+                    {
+                        mnTypeId = AUTOLAYOUT_TITLE_2CONTENT_CONTENT;
+                    }
+                }
+                else
+                {
+                    mnTypeId = AUTOLAYOUT_TITLE_CONTENT_2CONTENT;
+                }
+                break;
+            }
+            case 5:
+            {
+                SdXMLPresentationPlaceholderContext* pObj1 = maList[ 1 ].get();
+
+                if( pObj1->GetName() == "object" )
+                {
+                    mnTypeId = AUTOLAYOUT_TITLE_4CONTENT;
+                }
+                else
+                {
+                    mnTypeId = AUTOLAYOUT_4CLIPART;
+                }
+                break;
+
+            }
+            case 7:
+            {
+                mnTypeId = AUTOLAYOUT_TITLE_6CONTENT; // tdf#141978: Apply 6content layout
+                break;
+            }
+            default:
+            {
+                mnTypeId = AUTOLAYOUT_NONE;
+                break;
+            }
+        }
+    }
+
+    // release remembered contexts, they are no longer needed
+    maList.clear();
+}
+
+SdXMLPresentationPlaceholderContext::SdXMLPresentationPlaceholderContext(
+    SdXMLImport& rImport,
+    sal_Int32 /*nElement*/,
+    const uno::Reference< xml::sax::XFastAttributeList>& xAttrList)
+:   SvXMLImportContext( rImport ),
+    mnX(0)
+{
+    for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+    {
+        switch(aIter.getToken())
+        {
+            case XML_ELEMENT(PRESENTATION, XML_OBJECT):
+            {
+                msName = aIter.toString();
+                break;
+            }
+            case XML_ELEMENT(SVG, XML_X):
+            case XML_ELEMENT(SVG_COMPAT, XML_X):
+            {
+                GetSdImport().GetMM100UnitConverter().convertMeasureToCore(
+                        mnX, aIter.toView());
+                break;
+            }
+            case XML_ELEMENT(SVG, XML_Y):
+            case XML_ELEMENT(SVG_COMPAT, XML_Y):
+            {
+                break;
+            }
+            case XML_ELEMENT(SVG, XML_WIDTH):
+            case XML_ELEMENT(SVG_COMPAT, XML_WIDTH):
+            {
+                break;
+            }
+            case XML_ELEMENT(SVG, XML_HEIGHT):
+            case XML_ELEMENT(SVG_COMPAT, XML_HEIGHT):
+            {
+                break;
+            }
+            default:
+                XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+        }
+    }
+}
+
+SdXMLPresentationPlaceholderContext::~SdXMLPresentationPlaceholderContext()
+{
+}
+
+
+SdXMLMasterPageContext::SdXMLMasterPageContext(
+    SdXMLImport& rImport,
+    sal_Int32 nElement,
+    const uno::Reference< xml::sax::XFastAttributeList>& xAttrList,
+    uno::Reference< drawing::XShapes > const & rShapes)
+:   SdXMLGenericPageContext( rImport, xAttrList, rShapes )
+{
+    const bool bHandoutMaster = (nElement & TOKEN_MASK) == XML_HANDOUT_MASTER;
+    OUString sStyleName, sPageMasterName;
+
+    for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+    {
+        const OUString sValue = aIter.toString();
+        switch(aIter.getToken())
+        {
+            case XML_ELEMENT(STYLE, XML_NAME):
+            {
+                msName = sValue;
+                break;
+            }
+            case XML_ELEMENT(STYLE, XML_DISPLAY_NAME):
+            {
+                msDisplayName = sValue;
+                break;
+            }
+            case XML_ELEMENT(STYLE, XML_PAGE_LAYOUT_NAME):
+            {
+                sPageMasterName = sValue;
+                break;
+            }
+            case XML_ELEMENT(DRAW, XML_STYLE_NAME):
+            {
+                sStyleName = sValue;
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_PRESENTATION_PAGE_LAYOUT_NAME):
+            {
+                maPageLayoutName = sValue;
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_USE_HEADER_NAME):
+            {
+                maUseHeaderDeclName =  sValue;
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_USE_FOOTER_NAME):
+            {
+                maUseFooterDeclName =  sValue;
+                break;
+            }
+            case XML_ELEMENT(PRESENTATION, XML_USE_DATE_TIME_NAME):
+            {
+                maUseDateTimeDeclName =  sValue;
+                break;
+            }
+            default:
+                XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+        }
+    }
+
+    if( msDisplayName.isEmpty() )
+        msDisplayName = msName;
+    else if( msDisplayName != msName )
+        GetImport().AddStyleDisplayName( XmlStyleFamily::MASTER_PAGE, msName, msDisplayName );
+
+    GetImport().GetShapeImport()->startPage( GetLocalShapesContext() );
+
+    // set page name?
+    if(!bHandoutMaster && !msDisplayName.isEmpty() && GetLocalShapesContext().is())
+    {
+        uno::Reference < container::XNamed > xNamed(GetLocalShapesContext(), uno::UNO_QUERY);
+        if(xNamed.is())
+            xNamed->setName(msDisplayName);
+    }
+
+    // set page-master?
+    if(!sPageMasterName.isEmpty())
+    {
+        SetPageMaster( sPageMasterName );
+    }
+
+    SetStyle( sStyleName );
+
+    SetLayout();
+
+    DeleteAllShapes();
+}
+
+SdXMLMasterPageContext::~SdXMLMasterPageContext()
+{
+}
+
+void SdXMLMasterPageContext::endFastElement(sal_Int32 nElement)
+{
+    // set styles on master-page
+    if(!msName.isEmpty() && GetSdImport().GetShapeImport()->GetStylesContext())
+    {
+        SvXMLImportContext* pContext = GetSdImport().GetShapeImport()->GetStylesContext();
+        if (SdXMLStylesContext* pSdContext = dynamic_cast<SdXMLStylesContext*>(pContext))
+            pSdContext->SetMasterPageStyles(*this);
+    }
+
+    SdXMLGenericPageContext::endFastElement(nElement);
+    GetImport().GetShapeImport()->endPage(GetLocalShapesContext());
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLMasterPageContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    switch (nElement)
+    {
+        // some special objects inside style:masterpage context
+        case XML_ELEMENT(STYLE, XML_STYLE):
+        {
+            if(GetSdImport().GetShapeImport()->GetStylesContext())
+            {
+                // style:style inside master-page context -> presentation style
+                XMLShapeStyleContext* pNew = new XMLShapeStyleContext(
+                    GetSdImport(),
+                    *GetSdImport().GetShapeImport()->GetStylesContext(),
+                    XmlStyleFamily::SD_PRESENTATION_ID);
+
+                // add this style to the outer StylesContext class for later processing
+                GetSdImport().GetShapeImport()->GetStylesContext()->AddStyle(*pNew);
+                return pNew;
+            }
+            break;
+        }
+        case XML_ELEMENT(PRESENTATION, XML_NOTES):
+        {
+            if( GetSdImport().IsImpress() )
+            {
+                // get notes page
+                uno::Reference< presentation::XPresentationPage > xPresPage(GetLocalShapesContext(), uno::UNO_QUERY);
+                if(xPresPage.is())
+                {
+                    uno::Reference< drawing::XDrawPage > xNotesDrawPage = xPresPage->getNotesPage();
+                    if(xNotesDrawPage.is())
+                    {
+                        // presentation:notes inside master-page context
+                        return new SdXMLNotesContext( GetSdImport(),  xAttrList, xNotesDrawPage);
+                    }
+                }
+            }
+            break;
+        }
+        case XML_ELEMENT(LO_EXT, XML_THEME):
+        {
+            if (GetSdImport().IsImpress())
+            {
+                uno::Reference<beans::XPropertySet> xMasterPage(GetLocalShapesContext(),
+                                                                uno::UNO_QUERY);
+                return new XMLThemeContext(GetSdImport(), xAttrList, xMasterPage);
+            }
+            break;
+        }
+    }
+    return SdXMLGenericPageContext::createFastChildContext(nElement, xAttrList);
+}
+
+SdXMLStylesContext::SdXMLStylesContext(
+    SdXMLImport& rImport,
+    bool bIsAutoStyle)
+:   SvXMLStylesContext(rImport),
+    mbIsAutoStyle(bIsAutoStyle)
+{
+    Reference< uno::XComponentContext > xContext = rImport.GetComponentContext();
+    mpNumFormatter = std::make_unique<SvNumberFormatter>( xContext, LANGUAGE_SYSTEM );
+    mpNumFmtHelper = std::make_unique<SvXMLNumFmtHelper>( mpNumFormatter.get(), xContext );
+}
+
+SvXMLStyleContext* SdXMLStylesContext::CreateStyleChildContext(
+    sal_Int32 nElement,
+    const uno::Reference< xml::sax::XFastAttributeList >& xAttrList)
+{
+    switch (nElement)
+    {
+        case XML_ELEMENT(TABLE, XML_TABLE_TEMPLATE):
+        {
+            auto pContext = GetImport().GetShapeImport()->GetShapeTableImport()->CreateTableTemplateContext(nElement, xAttrList );
+            if (pContext)
+                return pContext;
+            break;
+        }
+        case XML_ELEMENT(STYLE, XML_PAGE_LAYOUT):
+            // style:page-master inside office:styles context
+            return new SdXMLPageMasterContext(GetSdImport(), nElement, xAttrList);
+        case XML_ELEMENT(STYLE, XML_PRESENTATION_PAGE_LAYOUT):
+            // style:presentation-page-layout inside office:styles context
+            return new SdXMLPresentationPageLayoutContext(GetSdImport(), nElement, xAttrList);
+        case XML_ELEMENT(NUMBER, XML_DATE_STYLE):
+            // number:date-style or number:time-style
+            return new SdXMLNumberFormatImportContext( GetSdImport(), nElement, mpNumFmtHelper->getData(), SvXMLStylesTokens::DATE_STYLE, xAttrList, *this );
+        case XML_ELEMENT(NUMBER, XML_TIME_STYLE):
+            // number:date-style or number:time-style
+            return new SdXMLNumberFormatImportContext( GetSdImport(), nElement, mpNumFmtHelper->getData(), SvXMLStylesTokens::TIME_STYLE, xAttrList, *this );
+        case XML_ELEMENT(NUMBER, XML_NUMBER_STYLE):
+            return new SvXMLNumFormatContext( GetSdImport(), nElement,
+                                            mpNumFmtHelper->getData(), SvXMLStylesTokens::NUMBER_STYLE, xAttrList, *this );
+        case XML_ELEMENT(NUMBER, XML_CURRENCY_STYLE):
+            return new SvXMLNumFormatContext( GetSdImport(), nElement,
+                                            mpNumFmtHelper->getData(), SvXMLStylesTokens::CURRENCY_STYLE, xAttrList, *this );
+        case XML_ELEMENT(NUMBER, XML_PERCENTAGE_STYLE):
+            return new SvXMLNumFormatContext( GetSdImport(), nElement,
+                                            mpNumFmtHelper->getData(), SvXMLStylesTokens::PERCENTAGE_STYLE, xAttrList, *this );
+        case XML_ELEMENT(NUMBER, XML_BOOLEAN_STYLE):
+            return new SvXMLNumFormatContext( GetSdImport(), nElement,
+                                            mpNumFmtHelper->getData(), SvXMLStylesTokens::BOOLEAN_STYLE, xAttrList, *this );
+        case XML_ELEMENT(NUMBER, XML_TEXT_STYLE):
+            return new SvXMLNumFormatContext( GetSdImport(), nElement,
+                                            mpNumFmtHelper->getData(), SvXMLStylesTokens::TEXT_STYLE, xAttrList, *this );
+        case XML_ELEMENT(PRESENTATION, XML_HEADER_DECL):
+        case XML_ELEMENT(PRESENTATION, XML_FOOTER_DECL):
+        case XML_ELEMENT(PRESENTATION, XML_DATE_TIME_DECL):
+            return new SdXMLHeaderFooterDeclContext( GetImport(), xAttrList );
+        case XML_ELEMENT(STYLE, XML_STYLE):
+            break; // ignore
+        default:
+            XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+    }
+
+    // call base class
+    return SvXMLStylesContext::CreateStyleChildContext(nElement, xAttrList);
+}
+
+SvXMLStyleContext* SdXMLStylesContext::CreateStyleStyleChildContext(
+    XmlStyleFamily nFamily,
+    sal_Int32 nElement,
+    const uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
+{
+    switch( nFamily )
+    {
+    case XmlStyleFamily::SD_DRAWINGPAGE_ID:
+        return new SdXMLDrawingPageStyleContext(GetSdImport(), *this );
+    case XmlStyleFamily::TABLE_CELL:
+    case XmlStyleFamily::TABLE_COLUMN:
+    case XmlStyleFamily::TABLE_ROW:
+        return new XMLShapeStyleContext( GetSdImport(), *this, nFamily );
+    default: break;
+    }
+
+    // call base class
+    return SvXMLStylesContext::CreateStyleStyleChildContext(nFamily, nElement, xAttrList);
+}
+
+SvXMLStyleContext* SdXMLStylesContext::CreateDefaultStyleStyleChildContext(
+    XmlStyleFamily nFamily,
+    sal_Int32  nElement,
+    const Reference< XFastAttributeList > & xAttrList )
+{
+    switch( nFamily )
+    {
+    case XmlStyleFamily::SD_GRAPHICS_ID:
+        return new XMLGraphicsDefaultStyle(GetSdImport(), *this );
+    default: break;
+    }
+
+    // call base class
+    return SvXMLStylesContext::CreateDefaultStyleStyleChildContext(nFamily, nElement, xAttrList);
+}
+
+rtl::Reference< SvXMLImportPropertyMapper > SdXMLStylesContext::GetImportPropertyMapper(
+    XmlStyleFamily nFamily) const
+{
+    rtl::Reference < SvXMLImportPropertyMapper > xMapper;
+
+    switch( nFamily )
+    {
+    case XmlStyleFamily::SD_DRAWINGPAGE_ID:
+    {
+        if(!xPresImpPropMapper.is())
+        {
+            rtl::Reference< XMLShapeImportHelper > aImpHelper = const_cast<SvXMLImport&>(GetImport()).GetShapeImport();
+            const_cast<SdXMLStylesContext*>(this)->xPresImpPropMapper =
+                aImpHelper->GetPresPagePropsMapper();
+        }
+        xMapper = xPresImpPropMapper;
+        break;
+    }
+
+    case XmlStyleFamily::TABLE_COLUMN:
+    case XmlStyleFamily::TABLE_ROW:
+    case XmlStyleFamily::TABLE_CELL:
+    {
+        const rtl::Reference< XMLTableImport >& xTableImport( const_cast< SvXMLImport& >( GetImport() ).GetShapeImport()->GetShapeTableImport() );
+
+        switch( nFamily )
+        {
+        case XmlStyleFamily::TABLE_COLUMN: xMapper = xTableImport->GetColumnImportPropertySetMapper().get(); break;
+        case XmlStyleFamily::TABLE_ROW: xMapper = xTableImport->GetRowImportPropertySetMapper().get(); break;
+        case XmlStyleFamily::TABLE_CELL: xMapper = xTableImport->GetCellImportPropertySetMapper().get(); break;
+        default: break;
+        }
+        break;
+    }
+    default: break;
+    }
+
+    // call base class
+    if( !xMapper.is() )
+        xMapper = SvXMLStylesContext::GetImportPropertyMapper(nFamily);
+    return xMapper;
+}
+
+// Process all style and object info
+
+void SdXMLStylesContext::endFastElement(sal_Int32 )
+{
+    if(mbIsAutoStyle)
+    {
+        // AutoStyles for text import
+        GetImport().GetTextImport()->SetAutoStyles( this );
+
+        // AutoStyles for chart
+        GetImport().GetChartImport()->SetAutoStylesContext( this );
+
+        // AutoStyles for forms
+        GetImport().GetFormImport()->setAutoStyleContext( this );
+
+        // associate AutoStyles with styles in preparation to setting Styles on shapes
+        for(sal_uInt32 a(0); a < GetStyleCount(); a++)
+        {
+            const SvXMLStyleContext* pStyle = GetStyle(a);
+            if (const XMLShapeStyleContext* pDocStyle = dynamic_cast<const XMLShapeStyleContext*>(pStyle))
+            {
+                SvXMLStylesContext* pStylesContext = GetSdImport().GetShapeImport()->GetStylesContext();
+                if (pStylesContext)
+                {
+                    pStyle = pStylesContext->FindStyleChildContext(pStyle->GetFamily(), pStyle->GetParentName());
+
+                    if (const XMLShapeStyleContext* pParentStyle = dynamic_cast<const XMLShapeStyleContext*>(pStyle))
+                    {
+                        if(pParentStyle->GetStyle().is())
+                        {
+                            const_cast<XMLShapeStyleContext*>(pDocStyle)->SetStyle(pParentStyle->GetStyle());
+                        }
+                    }
+                }
+            }
+        }
+
+        FinishStyles( false );
+    }
+    else
+    {
+        // Process styles list
+        ImpSetGraphicStyles();
+        ImpSetCellStyles();
+        GetImport().GetShapeImport()->GetShapeTableImport()->finishStyles();
+
+        // put style infos in the info set for other components ( content import f.e. )
+        uno::Reference< beans::XPropertySet > xInfoSet( GetImport().getImportInfo() );
+        if( xInfoSet.is() )
+        {
+            uno::Reference< beans::XPropertySetInfo > xInfoSetInfo( xInfoSet->getPropertySetInfo() );
+
+            if( xInfoSetInfo->hasPropertyByName("PageLayouts") )
+                xInfoSet->setPropertyValue("PageLayouts", uno::Any( getPageLayouts() ) );
+        }
+
+    }
+}
+
+// set master-page styles (all with family="presentation" and a special
+// prefix) on given master-page.
+
+void SdXMLStylesContext::SetMasterPageStyles(SdXMLMasterPageContext const & rMaster) const
+{
+    const uno::Reference<container::XNameAccess>& rStyleFamilies =
+        GetSdImport().GetLocalDocStyleFamilies();
+
+    if (!rStyleFamilies.is())
+        return;
+
+    if (!rStyleFamilies->hasByName(rMaster.GetDisplayName()))
+        return;
+
+    try
+    {
+        uno::Reference< container::XNameAccess > xMasterPageStyles( rStyleFamilies->getByName(rMaster.GetDisplayName()), UNO_QUERY_THROW );
+        OUString sPrefix(rMaster.GetDisplayName() + "-");
+        ImpSetGraphicStyles(xMasterPageStyles, XmlStyleFamily::SD_PRESENTATION_ID, sPrefix);
+    }
+    catch (const uno::Exception&)
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw", "");
+    }
+}
+
+// Process styles list:
+// set graphic styles (all with family="graphics"). Remember xStyle at list element.
+
+void SdXMLStylesContext::ImpSetGraphicStyles() const
+{
+    if(GetSdImport().GetLocalDocStyleFamilies().is()) try
+    {
+        uno::Reference< container::XNameAccess > xGraphicPageStyles( GetSdImport().GetLocalDocStyleFamilies()->getByName("graphics"), uno::UNO_QUERY_THROW );
+
+        ImpSetGraphicStyles(xGraphicPageStyles, XmlStyleFamily::SD_GRAPHICS_ID, OUString());
+    }
+    catch( uno::Exception& )
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw", "");
+    }
+}
+
+void SdXMLStylesContext::ImpSetCellStyles() const
+{
+    if(GetSdImport().GetLocalDocStyleFamilies().is()) try
+    {
+        uno::Reference< container::XNameAccess > xGraphicPageStyles( GetSdImport().GetLocalDocStyleFamilies()->getByName("cell"), uno::UNO_QUERY_THROW );
+
+        ImpSetGraphicStyles(xGraphicPageStyles, XmlStyleFamily::TABLE_CELL, OUString());
+    }
+    catch( uno::Exception& )
+    {
+        TOOLS_WARN_EXCEPTION("xmloff.draw", "");
+    }
+}
+
+//Resolves: fdo#34987 if the style's auto height before and after is the same
+//then don't reset it back to the underlying default of true for the small
+//period before it's going to be reset to false again. Doing this avoids the
+//master page shapes from resizing themselves due to autoheight becoming
+//enabled before having autoheight turned off again and getting stuck on that
+//autosized height
+static bool canSkipReset(std::u16string_view rName, const XMLPropStyleContext* pPropStyle,
+    const uno::Reference< beans::XPropertySet > &rPropSet, const rtl::Reference < XMLPropertySetMapper >& rPrMap)
+{
+    bool bCanSkipReset = false;
+    if (pPropStyle && rName == u"TextAutoGrowHeight")
+    {
+        bool bOldStyleTextAutoGrowHeight(false);
+        rPropSet->getPropertyValue("TextAutoGrowHeight") >>= bOldStyleTextAutoGrowHeight;
+
+        sal_Int32 nIndexStyle = rPrMap->GetEntryIndex(XML_NAMESPACE_DRAW, u"auto-grow-height", 0);
+        if (nIndexStyle != -1)
+        {
+            const ::std::vector< XMLPropertyState > &rProperties = pPropStyle->GetProperties();
+            auto property = std::find_if(rProperties.cbegin(), rProperties.cend(),
+                [nIndexStyle](const XMLPropertyState& rProp) { return rProp.mnIndex == nIndexStyle; });
+            if (property != rProperties.cend())
+            {
+                bool bNewStyleTextAutoGrowHeight(false);
+                property->maValue >>= bNewStyleTextAutoGrowHeight;
+                bCanSkipReset = (bNewStyleTextAutoGrowHeight == bOldStyleTextAutoGrowHeight);
+            }
+        }
+    }
+    return bCanSkipReset;
+}
+
+// help function used by ImpSetGraphicStyles() and ImpSetMasterPageStyles()
+
+void SdXMLStylesContext::ImpSetGraphicStyles( uno::Reference< container::XNameAccess > const & xPageStyles,  XmlStyleFamily nFamily,  const OUString& rPrefix) const
+{
+    sal_Int32 nPrefLen(rPrefix.getLength());
+
+    sal_uInt32 a;
+
+    // set defaults
+    for( a = 0; a < GetStyleCount(); a++)
+    {
+        const SvXMLStyleContext* pStyle = GetStyle(a);
+
+        if(nFamily == pStyle->GetFamily() && pStyle->IsDefaultStyle())
+        {
+            const_cast<SvXMLStyleContext*>(pStyle)->SetDefaults();
+        }
+    }
+
+    // create all styles and set properties
+    for( a = 0; a < GetStyleCount(); a++)
+    {
+        try
+        {
+            const SvXMLStyleContext* pStyle = GetStyle(a);
+            if(nFamily == pStyle->GetFamily() && !pStyle->IsDefaultStyle())
+            {
+                OUString aStyleName(pStyle->GetDisplayName());
+
+                if( nPrefLen )
+                {
+                    sal_Int32 nStylePrefLen = aStyleName.lastIndexOf( '-' ) + 1;
+                    if( (nPrefLen != nStylePrefLen) || !aStyleName.startsWith(rPrefix) )
+                        continue;
+
+                    aStyleName = aStyleName.copy( nPrefLen );
+                }
+
+                XMLPropStyleContext* pPropStyle = dynamic_cast< XMLPropStyleContext* >(const_cast< SvXMLStyleContext* >( pStyle ) );
+
+                uno::Reference< style::XStyle > xStyle;
+                if(xPageStyles->hasByName(aStyleName))
+                {
+                    xPageStyles->getByName(aStyleName) >>= xStyle;
+
+                    // set properties of existing styles to default
+                    uno::Reference< beans::XPropertySet > xPropSet( xStyle, uno::UNO_QUERY );
+                    uno::Reference< beans::XPropertySetInfo > xPropSetInfo;
+                    if( xPropSet.is() )
+                        xPropSetInfo = xPropSet->getPropertySetInfo();
+
+                    uno::Reference< beans::XPropertyState > xPropState( xStyle, uno::UNO_QUERY );
+
+                    if( xPropState.is() )
+                    {
+                        rtl::Reference < XMLPropertySetMapper > xPrMap;
+                        rtl::Reference < SvXMLImportPropertyMapper > xImpPrMap = GetImportPropertyMapper( nFamily );
+                        SAL_WARN_IF( !xImpPrMap.is(), "xmloff", "There is the import prop mapper" );
+                        if( xImpPrMap.is() )
+                            xPrMap = xImpPrMap->getPropertySetMapper();
+                        if( xPrMap.is() )
+                        {
+                            const sal_Int32 nCount = xPrMap->GetEntryCount();
+                            for( sal_Int32 i = 0; i < nCount; i++ )
+                            {
+                                const OUString& rName = xPrMap->GetEntryAPIName( i );
+                                if( xPropSetInfo->hasPropertyByName( rName ) && beans::PropertyState_DIRECT_VALUE == xPropState->getPropertyState( rName ) )
+                                {
+                                    bool bCanSkipReset = canSkipReset(rName, pPropStyle, xPropSet, xPrMap);
+                                    if (bCanSkipReset)
+                                        continue;
+                                    xPropState->setPropertyToDefault( rName );
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    // graphics style does not exist, create and add it
+                    uno::Reference< lang::XSingleServiceFactory > xServiceFact(xPageStyles, uno::UNO_QUERY);
+                    if(xServiceFact.is())
+                    {
+                        uno::Reference< style::XStyle > xNewStyle( xServiceFact->createInstance(), uno::UNO_QUERY);
+
+                        if(xNewStyle.is())
+                        {
+                            // remember style
+                            xStyle = xNewStyle;
+
+                            // add new style to graphics style pool
+                            uno::Reference< container::XNameContainer > xInsertContainer(xPageStyles, uno::UNO_QUERY);
+                            if(xInsertContainer.is())
+                                xInsertContainer->insertByName(aStyleName, uno::Any( xStyle ) );
+                        }
+                    }
+                }
+
+                if(xStyle.is())
+                {
+                    // set properties at style
+                    uno::Reference< beans::XPropertySet > xPropSet(xStyle, uno::UNO_QUERY);
+                    if(xPropSet.is() && pPropStyle)
+                    {
+                        pPropStyle->FillPropertySet(xPropSet);
+                        pPropStyle->SetStyle(xStyle);
+                    }
+                }
+            }
+        }
+        catch(const Exception& e)
+        {
+            const_cast<SdXMLImport*>(&GetSdImport())->SetError( XMLERROR_FLAG_WARNING | XMLERROR_API, {}, e.Message, nullptr );
+        }
+    }
+
+    // now set parents for all styles (when necessary)
+    for(a = 0; a < GetStyleCount(); a++)
+    {
+        const SvXMLStyleContext* pStyle = GetStyle(a);
+
+        if(pStyle && !pStyle->GetDisplayName().isEmpty() && (nFamily == pStyle->GetFamily())) try
+        {
+            OUString aStyleName(pStyle->GetDisplayName());
+            if( nPrefLen )
+            {
+                sal_Int32 nStylePrefLen = aStyleName.lastIndexOf( '-' ) + 1;
+                if( (nPrefLen != nStylePrefLen) || !aStyleName.startsWith( rPrefix ) )
+                    continue;
+
+                aStyleName = aStyleName.copy( nPrefLen );
+            }
+
+            uno::Reference< style::XStyle > xStyle( xPageStyles->getByName(aStyleName), UNO_QUERY );
+            if(xStyle.is())
+            {
+                // set parent style name
+                OUString sParentStyleDisplayName( GetImport().GetStyleDisplayName( pStyle->GetFamily(), pStyle->GetParentName() ) );
+                if( nPrefLen )
+                {
+                    sal_Int32 nStylePrefLen = sParentStyleDisplayName.lastIndexOf( '-' ) + 1;
+                    if( (nPrefLen != nStylePrefLen) || !sParentStyleDisplayName.startsWith( rPrefix ) )
+                        continue;
+
+                    sParentStyleDisplayName = sParentStyleDisplayName.copy( nPrefLen );
+                }
+                xStyle->setParentStyle( sParentStyleDisplayName );
+            }
+        }
+        catch( const Exception& e )
+        {
+            const_cast<SdXMLImport*>(&GetSdImport())->SetError( XMLERROR_FLAG_WARNING | XMLERROR_API, {}, e.Message, nullptr );
+        }
+    }
+}
+
+// helper function to create the uno component that hold the mappings from
+// xml auto layout name to internal autolayout id
+
+uno::Reference< container::XNameAccess > SdXMLStylesContext::getPageLayouts() const
+{
+    uno::Reference< container::XNameContainer > xLayouts( comphelper::NameContainer_createInstance( ::cppu::UnoType<sal_Int32>::get()) );
+
+    for(sal_uInt32 a(0); a < GetStyleCount(); a++)
+    {
+        const SvXMLStyleContext* pStyle = GetStyle(a);
+        if (const SdXMLPresentationPageLayoutContext* pContext = dynamic_cast<const SdXMLPresentationPageLayoutContext*>(pStyle))
+        {
+            xLayouts->insertByName(pStyle->GetName(), uno::Any(static_cast<sal_Int32>(pContext->GetTypeId())));
+        }
+    }
+
+    return xLayouts;
+}
+
+
+SdXMLMasterStylesContext::SdXMLMasterStylesContext(
+    SdXMLImport& rImport)
+:   SvXMLImportContext( rImport )
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLMasterStylesContext::createFastChildContext(
+    sal_Int32 nElement,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+    if( nElement == XML_ELEMENT(DRAW, XML_LAYER_SET) )
+    {
+        return new SdXMLLayerSetContext( GetImport() );
+    }
+    else if( nElement == XML_ELEMENT(STYLE, XML_MASTER_PAGE) )
+    {
+        // style:masterpage inside office:styles context
+        uno::Reference< drawing::XDrawPage > xNewMasterPage;
+        uno::Reference< drawing::XDrawPages > xMasterPages(GetSdImport().GetLocalMasterPages(), uno::UNO_QUERY);
+
+        if( xMasterPages.is() )
+        {
+            sal_Int32 nNewMasterPageCount = GetSdImport().GetNewMasterPageCount();
+            sal_Int32 nMasterPageCount = xMasterPages->getCount();
+            if (nNewMasterPageCount + 1 > nMasterPageCount)
+            {
+                // arbitrary limit to master pages when fuzzing to avoid deadend timeouts
+                if (nMasterPageCount >= 64 && utl::ConfigManager::IsFuzzing())
+                    return nullptr;
+
+                // new page, create and insert
+                xNewMasterPage = xMasterPages->insertNewByIndex(nMasterPageCount);
+            }
+            else
+            {
+                // existing page, use it
+                xMasterPages->getByIndex(nNewMasterPageCount) >>= xNewMasterPage;
+            }
+
+            // increment global import page counter
+            GetSdImport().IncrementNewMasterPageCount();
+
+            if(xNewMasterPage.is())
+            {
+                if(GetSdImport().GetShapeImport()->GetStylesContext())
+                {
+                    const rtl::Reference<SdXMLMasterPageContext> xLclContext{
+                        new SdXMLMasterPageContext(GetSdImport(),
+                            nElement, xAttrList, xNewMasterPage)};
+                    maMasterPageList.push_back(xLclContext);
+                    return xLclContext;
+                }
+            }
+        }
+    }
+    else if( nElement == XML_ELEMENT(STYLE, XML_HANDOUT_MASTER) )
+    {
+        uno::Reference< presentation::XHandoutMasterSupplier > xHandoutSupp( GetSdImport().GetModel(), uno::UNO_QUERY );
+        if( xHandoutSupp.is() )
+        {
+            uno::Reference< drawing::XShapes > xHandoutPage = xHandoutSupp->getHandoutMasterPage();
+            if(xHandoutPage.is() && GetSdImport().GetShapeImport()->GetStylesContext())
+            {
+                return new SdXMLMasterPageContext(GetSdImport(),
+                    nElement, xAttrList, xHandoutPage);
+            }
+        }
+    }
+    else
+        XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+    return nullptr;
+}
+
+SdXMLHeaderFooterDeclContext::SdXMLHeaderFooterDeclContext(SvXMLImport& rImport,
+    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
+    : SvXMLStyleContext( rImport )
+    , mbFixed(false)
+{
+    for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+    {
+        if( aIter.getToken() == XML_ELEMENT(PRESENTATION, XML_NAME) )
+        {
+            maStrName = aIter.toString();
+        }
+        else if( aIter.getToken() == XML_ELEMENT(PRESENTATION, XML_SOURCE) )
+        {
+            mbFixed = IsXMLToken( aIter, XML_FIXED );
+        }
+        else if( aIter.getToken() == XML_ELEMENT(STYLE, XML_DATA_STYLE_NAME) )
+        {
+            maStrDateTimeFormat = aIter.toString();
+        }
+        else
+        {
+            XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+        }
+    }
+}
+
+bool SdXMLHeaderFooterDeclContext::IsTransient() const
+{
+    return true;
+}
+
+void SdXMLHeaderFooterDeclContext::endFastElement(sal_Int32 nToken)
+{
+    SdXMLImport& rImport = dynamic_cast<SdXMLImport&>(GetImport());
+    auto nElement = nToken & TOKEN_MASK;
+    if( nElement == XML_HEADER_DECL )
+    {
+        rImport.AddHeaderDecl( maStrName, maStrText );
+    }
+    else if( nElement == XML_FOOTER_DECL )
+    {
+        rImport.AddFooterDecl( maStrName, maStrText );
+    }
+    else if( nElement == XML_DATE_TIME_DECL )
+    {
+        rImport.AddDateTimeDecl( maStrName, maStrText, mbFixed, maStrDateTimeFormat );
+    }
+    else
+    {
+        XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nToken);
+    }
+}
+
+void SdXMLHeaderFooterDeclContext::characters( const OUString& rChars )
+{
+    maStrText += rChars;
+}
+
+XMLThemeContext::XMLThemeContext(SvXMLImport& rImport,
+                                 const uno::Reference<xml::sax::XFastAttributeList>& xAttrList,
+                                 const uno::Reference<beans::XPropertySet>& xMasterPage)
+    : SvXMLImportContext(rImport)
+    , m_xMasterPage(xMasterPage)
+{
+    for (const auto& rAttribute : sax_fastparser::castToFastAttributeList(xAttrList))
+    {
+        switch (rAttribute.getToken())
+        {
+            case XML_ELEMENT(LO_EXT, XML_NAME):
+            {
+                m_aTheme["Name"] <<= rAttribute.toString();
+                break;
+            }
+        }
+    }
+}
+
+XMLThemeContext::~XMLThemeContext()
+{
+    uno::Any aTheme(m_aTheme.getAsConstPropertyValueList());
+    m_xMasterPage->setPropertyValue("Theme", aTheme);
+}
+
+uno::Reference<xml::sax::XFastContextHandler> SAL_CALL XMLThemeContext::createFastChildContext(
+    sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttribs)
+{
+    if (nElement == XML_ELEMENT(LO_EXT, XML_COLOR_TABLE))
+    {
+        return new XMLColorTableContext(GetImport(), xAttribs, m_aTheme);
+    }
+
+    return nullptr;
+}
+
+XMLColorTableContext::XMLColorTableContext(
+    SvXMLImport& rImport, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList,
+    comphelper::SequenceAsHashMap& rTheme)
+    : SvXMLImportContext(rImport)
+    , m_rTheme(rTheme)
+{
+    for (const auto& rAttribute : sax_fastparser::castToFastAttributeList(xAttrList))
+    {
+        switch (rAttribute.getToken())
+        {
+            case XML_ELEMENT(LO_EXT, XML_NAME):
+            {
+                m_rTheme["ColorSchemeName"] <<= rAttribute.toString();
+                break;
+            }
+        }
+    }
+}
+
+XMLColorTableContext::~XMLColorTableContext()
+{
+    m_rTheme["ColorScheme"] <<= comphelper::containerToSequence(m_aColorScheme);
+}
+
+uno::Reference<xml::sax::XFastContextHandler> SAL_CALL XMLColorTableContext::createFastChildContext(
+    sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttribs)
+{
+    if (nElement == XML_ELEMENT(LO_EXT, XML_COLOR))
+    {
+        return new XMLColorContext(GetImport(), xAttribs, m_aColorScheme);
+    }
+
+    return nullptr;
+}
+
+XMLColorContext::XMLColorContext(SvXMLImport& rImport,
+                                 const uno::Reference<xml::sax::XFastAttributeList>& xAttrList,
+                                 std::vector<util::Color>& rColorScheme)
+    : SvXMLImportContext(rImport)
+{
+    for (const auto& rAttribute : sax_fastparser::castToFastAttributeList(xAttrList))
+    {
+        switch (rAttribute.getToken())
+        {
+            case XML_ELEMENT(LO_EXT, XML_COLOR):
+            {
+                util::Color nColor;
+                sax::Converter::convertColor(nColor, rAttribute.toView());
+                rColorScheme.push_back(nColor);
+                break;
+            }
+        }
+    }
+}
+
+namespace xmloff {
+
+bool IsIgnoreFillStyleNamedItem(
+        css::uno::Reference<css::beans::XPropertySet> const& xProps,
+        drawing::FillStyle const nExpectedFillStyle)
+{
+    assert(xProps.is());
+    if (nExpectedFillStyle == drawing::FillStyle::FillStyle_MAKE_FIXED_SIZE)
+    {
+        return false;
+    }
+
+    // note: the caller must have called FillPropertySet() previously
+    drawing::FillStyle fillStyle{drawing::FillStyle_NONE};
+    xProps->getPropertyValue("FillStyle") >>= fillStyle;
+    return fillStyle != nExpectedFillStyle;
+}
+
+} // namespace xmloff
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/draw/ximpstyl.hxx b/xmloff/source/draw/ximpstyl.hxx
new file mode 100644
index 000000000..00f032e4c
--- /dev/null
+++ b/xmloff/source/draw/ximpstyl.hxx
@@ -0,0 +1,247 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <svl/zforlist.hxx>
+#include <xmloff/xmlictxt.hxx>
+#include <xmloff/xmlimppr.hxx>
+#include <xmloff/xmlnumfi.hxx>
+#include "sdxmlimp_impl.hxx"
+#include "ximppage.hxx"
+#include <xmloff/xmlstyle.hxx>
+#include <com/sun/star/view/PaperOrientation.hpp>
+#include <memory>
+#include <vector>
+
+class SvNumberFormatter;
+class SvXMLNumFmtHelper;
+
+// special style:style context inside style:page-master context
+
+class SdXMLPageMasterStyleContext: public SvXMLStyleContext
+{
+    sal_Int32                   mnBorderBottom;
+    sal_Int32                   mnBorderLeft;
+    sal_Int32                   mnBorderRight;
+    sal_Int32                   mnBorderTop;
+    sal_Int32                   mnWidth;
+    sal_Int32                   mnHeight;
+    css::view::PaperOrientation meOrientation;
+
+    const SdXMLImport& GetSdImport() const { return static_cast<const SdXMLImport&>(GetImport()); }
+    SdXMLImport& GetSdImport() { return static_cast<SdXMLImport&>(GetImport()); }
+
+public:
+
+    SdXMLPageMasterStyleContext(
+        SdXMLImport& rImport,
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList);
+    virtual ~SdXMLPageMasterStyleContext() override;
+
+    sal_Int32 GetBorderBottom() const { return mnBorderBottom; }
+    sal_Int32 GetBorderLeft() const { return mnBorderLeft; }
+    sal_Int32 GetBorderRight() const { return mnBorderRight; }
+    sal_Int32 GetBorderTop() const { return mnBorderTop; }
+    sal_Int32 GetWidth() const { return mnWidth; }
+    sal_Int32 GetHeight() const { return mnHeight; }
+    css::view::PaperOrientation GetOrientation() const { return meOrientation; }
+};
+
+// style:page-master context
+
+class SdXMLPageMasterContext: public SvXMLStyleContext
+{
+    rtl::Reference<SdXMLPageMasterStyleContext> mxPageMasterStyle;
+
+    const SdXMLImport& GetSdImport() const { return static_cast<const SdXMLImport&>(GetImport()); }
+    SdXMLImport& GetSdImport() { return static_cast<SdXMLImport&>(GetImport()); }
+
+public:
+
+    SdXMLPageMasterContext(
+        SdXMLImport& rImport,
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList);
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+
+    const SdXMLPageMasterStyleContext* GetPageMasterStyle() const { return mxPageMasterStyle.get(); }
+};
+
+// style:masterpage context
+
+class SdXMLMasterPageContext: public SdXMLGenericPageContext
+{
+    OUString               msName;
+    OUString               msDisplayName;
+
+public:
+
+    SdXMLMasterPageContext(
+        SdXMLImport& rImport,
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList,
+        css::uno::Reference< css::drawing::XShapes > const & rShapes);
+    virtual ~SdXMLMasterPageContext() override;
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+
+    const OUString& GetDisplayName() const { return msDisplayName; }
+
+};
+
+// presentation:placeholder context
+
+class SdXMLPresentationPlaceholderContext: public SvXMLImportContext
+{
+    OUString               msName;
+    sal_Int32                   mnX;
+
+    const SdXMLImport& GetSdImport() const { return static_cast<const SdXMLImport&>(GetImport()); }
+    SdXMLImport& GetSdImport() { return static_cast<SdXMLImport&>(GetImport()); }
+
+public:
+    SdXMLPresentationPlaceholderContext(
+        SdXMLImport& rImport,
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList);
+    virtual ~SdXMLPresentationPlaceholderContext() override;
+
+    const OUString& GetName() const { return msName; }
+    sal_Int32 GetX() const { return mnX; }
+};
+
+// style:presentation-page-layout context
+
+class SdXMLPresentationPageLayoutContext: public SvXMLStyleContext
+{
+    std::vector< rtl::Reference< SdXMLPresentationPlaceholderContext > >
+                           maList;
+    sal_uInt16             mnTypeId;
+
+    const SdXMLImport& GetSdImport() const { return static_cast<const SdXMLImport&>(GetImport()); }
+    SdXMLImport& GetSdImport() { return static_cast<SdXMLImport&>(GetImport()); }
+
+public:
+
+    SdXMLPresentationPageLayoutContext(
+        SdXMLImport& rImport,
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList);
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+
+    sal_uInt16 GetTypeId() const { return mnTypeId; }
+};
+
+// office:styles context
+
+class SdXMLStylesContext : public SvXMLStylesContext
+{
+    rtl::Reference< SvXMLImportPropertyMapper > xPresImpPropMapper;
+    bool                    mbIsAutoStyle;
+    std::unique_ptr<SvXMLNumFmtHelper> mpNumFmtHelper;
+    std::unique_ptr<SvNumberFormatter> mpNumFormatter;
+
+    const SdXMLImport& GetSdImport() const { return static_cast<const SdXMLImport&>(GetImport()); }
+    SdXMLImport& GetSdImport() { return static_cast<SdXMLImport&>(GetImport()); }
+
+    void ImpSetGraphicStyles() const;
+    void ImpSetCellStyles() const;
+    void ImpSetGraphicStyles( css::uno::Reference< css::container::XNameAccess > const & xPageStyles,
+        XmlStyleFamily nFamily, const OUString& rPrefix) const;
+
+protected:
+    using SvXMLStylesContext::CreateStyleChildContext;
+    virtual SvXMLStyleContext* CreateStyleChildContext(
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList) override;
+
+    using SvXMLStylesContext::CreateStyleStyleChildContext;
+    virtual SvXMLStyleContext *CreateStyleStyleChildContext(
+        XmlStyleFamily nFamily,
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList) override;
+
+    using SvXMLStylesContext::CreateDefaultStyleStyleChildContext;
+    virtual SvXMLStyleContext *CreateDefaultStyleStyleChildContext(
+        XmlStyleFamily nFamily,
+        sal_Int32 nElement,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList) override;
+public:
+
+    SdXMLStylesContext(
+        SdXMLImport& rImport,
+        bool bIsAutoStyle);
+
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+    virtual rtl::Reference< SvXMLImportPropertyMapper > GetImportPropertyMapper(XmlStyleFamily nFamily) const override;
+
+    void SetMasterPageStyles(SdXMLMasterPageContext const & rMaster) const;
+
+    css::uno::Reference< css::container::XNameAccess > getPageLayouts() const;
+};
+
+// office:master-styles context
+
+class SdXMLMasterStylesContext : public SvXMLImportContext
+{
+    std::vector< rtl::Reference< SdXMLMasterPageContext > > maMasterPageList;
+
+    const SdXMLImport& GetSdImport() const { return static_cast<const SdXMLImport&>(GetImport()); }
+    SdXMLImport& GetSdImport() { return static_cast<SdXMLImport&>(GetImport()); }
+
+public:
+
+    SdXMLMasterStylesContext(SdXMLImport& rImport);
+
+    virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+                sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+};
+
+// <pres:header-decl>, <pres:footer-decl> and <pres:date-time-decl>
+
+class SdXMLHeaderFooterDeclContext : public SvXMLStyleContext
+{
+public:
+    SdXMLHeaderFooterDeclContext( SvXMLImport& rImport,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList );
+
+    virtual bool IsTransient() const override;
+    virtual void SAL_CALL endFastElement(sal_Int32 ) override;
+    virtual void SAL_CALL characters( const OUString& rChars ) override;
+
+private:
+    OUString maStrName;
+    OUString maStrText;
+    OUString maStrDateTimeFormat;
+    bool        mbFixed;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */