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

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

1 files changed, 1296 insertions, 0 deletions

diff --git a/oox/source/drawingml/customshapegeometry.cxx b/oox/source/drawingml/customshapegeometry.cxx
new file mode 100644
index 0000000000..01b86b4eea
--- /dev/null
+++ b/oox/source/drawingml/customshapegeometry.cxx
@@ -0,0 +1,1296 @@
+/* -*- 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 <drawingml/customshapegeometry.hxx>
+#include <drawingml/customshapeproperties.hxx>
+
+#include <com/sun/star/drawing/EnhancedCustomShapeParameterType.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeSegmentCommand.hpp>
+#include <com/sun/star/xml/sax/FastToken.hpp>
+#include <osl/diagnose.h>
+#include <sal/log.hxx>
+#include <o3tl/string_view.hxx>
+#include <oox/helper/helper.hxx>
+#include <oox/helper/attributelist.hxx>
+#include <oox/token/namespaces.hxx>
+#include <oox/token/tokens.hxx>
+#include <unordered_map>
+
+using namespace ::oox::core;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::drawing;
+using namespace ::com::sun::star::xml::sax;
+
+namespace oox::drawingml {
+
+namespace {
+
+enum FormulaCommand
+{
+    FC_MULDIV = 0,
+    FC_PLUSMINUS,
+    FC_PLUSDIV,
+    FC_IFELSE,
+    FC_IFELSE1,
+    FC_ABS,
+    FC_AT2,
+    FC_CAT2,
+    FC_COS,
+    FC_MAX,
+    FC_MIN,
+    FC_MOD,
+    FC_PIN,
+    FC_SAT2,
+    FC_SIN,
+    FC_SQRT,
+    FC_TAN,
+    FC_VAL
+};
+
+struct FormulaCommandNameTable
+{
+    const char*     pS;
+    FormulaCommand pE;
+};
+
+}
+
+const FormulaCommandNameTable pFormulaCommandNameTable[] =
+{
+    { "*/",     FC_MULDIV },
+    { "+-",     FC_PLUSMINUS },
+    { "+/",     FC_PLUSDIV },
+    { "ifelse", FC_IFELSE },
+    { "?:",     FC_IFELSE1 },
+    { "abs",    FC_ABS },
+    { "at2",    FC_AT2 },
+    { "cat2",   FC_CAT2 },
+    { "cos",    FC_COS },
+    { "max",    FC_MAX },
+    { "min",    FC_MIN },
+    { "mod",    FC_MOD },
+    { "pin",    FC_PIN },
+    { "sat2",   FC_SAT2 },
+    { "sin",    FC_SIN },
+    { "sqrt",   FC_SQRT },
+    { "tan",    FC_TAN },
+    { "val",    FC_VAL }
+
+};
+typedef std::unordered_map< OUString, FormulaCommand > FormulaCommandHMap;
+
+static const FormulaCommandHMap* pCommandHashMap;
+
+static OUString GetFormulaParameter( const EnhancedCustomShapeParameter& rParameter )
+{
+    OUString aRet;
+    switch( rParameter.Type )
+    {
+        case EnhancedCustomShapeParameterType::NORMAL :
+        {
+            if ( rParameter.Value.getValueTypeClass() == TypeClass_DOUBLE )
+            {
+                double fValue = 0.0;
+                if ( rParameter.Value >>= fValue )
+                    aRet = OUString::number( fValue );
+            }
+            else
+            {
+                sal_Int32 nValue = 0;
+                if ( rParameter.Value >>= nValue )
+                    aRet = OUString::number( nValue );
+            }
+        }
+        break;
+        case EnhancedCustomShapeParameterType::EQUATION :
+        {
+            if ( rParameter.Value.getValueTypeClass() == TypeClass_LONG )
+            {
+                sal_Int32 nFormulaIndex;
+                if ( rParameter.Value >>= nFormulaIndex )
+                {
+                    aRet = "?"
+                        + OUString::number( nFormulaIndex )
+                            + " ";
+                }
+            }
+            else
+            {
+                // ups... we should have an index here and not the formula name
+            }
+        }
+        break;
+        case EnhancedCustomShapeParameterType::ADJUSTMENT :
+        {
+            if ( rParameter.Value.getValueTypeClass() == TypeClass_LONG )
+            {
+                sal_Int32 nAdjustmentIndex;
+                if ( rParameter.Value >>= nAdjustmentIndex )
+                {
+                    aRet = "$"
+                        + OUString::number( nAdjustmentIndex )
+                            + " ";
+                }
+            }
+            else
+            {
+                // ups... we should have an index here and not the formula name
+            }
+        }
+        break;
+        case EnhancedCustomShapeParameterType::LEFT :
+            aRet = "left";
+        break;
+        case EnhancedCustomShapeParameterType::TOP :
+            aRet = "top";
+        break;
+        case EnhancedCustomShapeParameterType::RIGHT :
+            aRet = "right";
+        break;
+        case EnhancedCustomShapeParameterType::BOTTOM :
+            aRet = "bottom";
+        break;
+        case EnhancedCustomShapeParameterType::XSTRETCH :
+            aRet = "xstretch";
+        break;
+        case EnhancedCustomShapeParameterType::YSTRETCH :
+            aRet = "ystretch";
+        break;
+        case EnhancedCustomShapeParameterType::HASSTROKE :
+            aRet = "hasstroke";
+        break;
+        case EnhancedCustomShapeParameterType::HASFILL :
+            aRet = "hasfill";
+        break;
+        case EnhancedCustomShapeParameterType::WIDTH :
+            aRet = "width";
+        break;
+        case EnhancedCustomShapeParameterType::HEIGHT :
+            aRet = "height";
+        break;
+        case EnhancedCustomShapeParameterType::LOGWIDTH :
+            aRet = "logwidth";
+        break;
+        case EnhancedCustomShapeParameterType::LOGHEIGHT :
+            aRet = "logheight";
+        break;
+    }
+    return aRet;
+}
+
+static EnhancedCustomShapeParameter GetAdjCoordinate( CustomShapeProperties& rCustomShapeProperties, const OUString& rValue, bool bNoSymbols = true )
+{
+    css::drawing::EnhancedCustomShapeParameter aRet;
+    if ( !rValue.isEmpty() )
+    {
+        bool        bConstant = true;
+        sal_Int32   nConstant = -1;
+        sal_Int32   nIntVal = 0;
+
+        // first check if it's a constant value
+        switch( AttributeConversion::decodeToken( rValue ) )
+        {
+            case XML_3cd4 : nConstant = 270 * 60000; break;
+            case XML_3cd8 : nConstant = 135 * 60000; break;
+            case XML_5cd8 : nConstant = 225 * 60000; break;
+            case XML_7cd8 : nConstant = 315 * 60000; break;
+            case XML_cd2  : nConstant = 180 * 60000; break;
+            case XML_cd3  : nConstant = 120 * 60000; break;
+            case XML_cd4  : nConstant =  90 * 60000; break;
+            case XML_cd8  : nConstant =  45 * 60000; break;
+
+            case XML_b :    // variable height of the shape defined in spPr
+            case XML_h :
+            {
+                if ( bNoSymbols )
+                {
+                    CustomShapeGuide aGuide;
+                    aGuide.maName = rValue;
+                    aGuide.maFormula = "logheight" ;
+
+                    aRet.Value <<= CustomShapeProperties::SetCustomShapeGuideValue( rCustomShapeProperties.getGuideList(), aGuide );
+                    aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
+                }
+                else
+                    aRet.Type = EnhancedCustomShapeParameterType::LOGHEIGHT;   // TODO: HEIGHT needs to be implemented
+            }
+            break;
+
+            case XML_hd10 :
+                nIntVal += 2; // */ h 1.0 10.0
+                [[fallthrough]];
+            case XML_hd8 :    // */ h 1.0 8.0
+                nIntVal += 2;
+                [[fallthrough]];
+            case XML_hd6 :    // */ h 1.0 6.0
+                nIntVal++;
+                [[fallthrough]];
+            case XML_hd5 :    // */ h 1.0 5.0
+                nIntVal++;
+                [[fallthrough]];
+            case XML_hd4 :    // */ h 1.0 4.0
+                nIntVal++;
+                [[fallthrough]];
+            case XML_hd3 :    // */ h 1.0 3.0
+                nIntVal++;
+                [[fallthrough]];
+            case XML_hd2 :    // */ h 1.0 2.0
+            case XML_vc :     // */ h 1.0 2.0
+            {
+                nIntVal += 2;
+
+                CustomShapeGuide aGuide;
+                aGuide.maName = rValue;
+                aGuide.maFormula = "logheight/" + OUString::number( nIntVal );
+
+                aRet.Value <<= CustomShapeProperties::SetCustomShapeGuideValue( rCustomShapeProperties.getGuideList(), aGuide );
+                aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
+            }
+            break;
+
+            case XML_t :
+            case XML_l :
+            {
+                nConstant = 0;
+                aRet.Type = EnhancedCustomShapeParameterType::NORMAL;
+            }
+            break;
+
+            case XML_ls :   // longest side: max w h
+            {
+                CustomShapeGuide aGuide;
+                aGuide.maName = rValue;
+                aGuide.maFormula = "max(logwidth,logheight)";
+
+                aRet.Value <<= CustomShapeProperties::SetCustomShapeGuideValue( rCustomShapeProperties.getGuideList(), aGuide );
+                aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
+            }
+            break;
+            case XML_ss :   // shortest side: min w h
+            {
+                CustomShapeGuide aGuide;
+                aGuide.maName = rValue;
+                aGuide.maFormula = "min(logwidth,logheight)";
+
+                aRet.Value <<= CustomShapeProperties::SetCustomShapeGuideValue( rCustomShapeProperties.getGuideList(), aGuide );
+                aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
+            }
+            break;
+            case XML_ssd32 : // */ ss 1.0 32.0
+                nIntVal += 16;
+                [[fallthrough]];
+            case XML_ssd16 : // */ ss 1.0 16.0
+                nIntVal += 8;
+                [[fallthrough]];
+            case XML_ssd8 :  // */ ss 1.0 8.0
+                nIntVal += 2;
+                [[fallthrough]];
+            case XML_ssd6 :  // */ ss 1.0 6.0
+                nIntVal += 2;
+                [[fallthrough]];
+            case XML_ssd4 :  // */ ss 1.0 4.0
+                nIntVal += 2;
+                [[fallthrough]];
+            case XML_ssd2 :  // */ ss 1.0 2.0
+            {
+                nIntVal += 2;
+
+                CustomShapeGuide aGuide;
+                aGuide.maName = rValue;
+                aGuide.maFormula = "min(logwidth,logheight)/" + OUString::number( nIntVal );
+
+                aRet.Value <<= CustomShapeProperties::SetCustomShapeGuideValue( rCustomShapeProperties.getGuideList(), aGuide );
+                aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
+            }
+            break;
+
+            case XML_r :    // variable width of the shape defined in spPr
+            case XML_w :
+            {
+                if ( bNoSymbols )
+                {
+                    CustomShapeGuide aGuide;
+                    aGuide.maName = rValue;
+                    aGuide.maFormula = "logwidth" ;
+
+                    aRet.Value <<= CustomShapeProperties::SetCustomShapeGuideValue( rCustomShapeProperties.getGuideList(), aGuide );
+                    aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
+                }
+                else
+                    aRet.Type = EnhancedCustomShapeParameterType::LOGWIDTH;
+            }
+            break;
+
+            case XML_wd32 : // */ w 1.0 32.0
+                nIntVal += 20;
+                [[fallthrough]];
+            case XML_wd12 : // */ w 1.0 12.0
+                nIntVal += 2;
+                [[fallthrough]];
+            case XML_wd10 : // */ w 1.0 10.0
+                nIntVal += 2;
+                [[fallthrough]];
+            case XML_wd8 :  // */ w 1.0 8.0
+                nIntVal += 2;
+                [[fallthrough]];
+            case XML_wd6 :  // */ w 1.0 6.0
+                nIntVal++;
+                [[fallthrough]];
+            case XML_wd5 :  // */ w 1.0 5.0
+                nIntVal++;
+                [[fallthrough]];
+            case XML_wd4 :  // */ w 1.0 4.0
+                nIntVal++;
+                [[fallthrough]];
+            case XML_wd3 :  // */ w 1.0 3.0
+                nIntVal++;
+                [[fallthrough]];
+            case XML_hc :   // */ w 1.0 2.0
+            case XML_wd2 :  // */ w 1.0 2.0
+            {
+                nIntVal += 2;
+
+                CustomShapeGuide aGuide;
+                aGuide.maName = rValue;
+                aGuide.maFormula = "logwidth/" + OUString::number( nIntVal );
+
+                aRet.Value <<= CustomShapeProperties::SetCustomShapeGuideValue( rCustomShapeProperties.getGuideList(), aGuide );
+                aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
+            }
+            break;
+
+            default:
+                bConstant = false;
+            break;
+        }
+        if ( bConstant )
+        {
+            if (nConstant != -1) {
+                aRet.Value <<= nConstant;
+                aRet.Type = EnhancedCustomShapeParameterType::NORMAL;
+            }
+        }
+        else
+        {
+            sal_Unicode n = rValue[ 0 ];
+            if ( ( n == '+' ) || ( n == '-' ) )
+            {
+                if ( rValue.getLength() > 1 )
+                    n = rValue[ 1 ];
+            }
+            if ( ( n >= '0' ) && ( n <= '9' ) )
+            {   // seems to be a ST_Coordinate
+                aRet.Value <<= rValue.toInt32();
+                aRet.Type = EnhancedCustomShapeParameterType::NORMAL;
+            }
+            else
+            {
+                sal_Int32 nGuideIndex = CustomShapeProperties::GetCustomShapeGuideValue( rCustomShapeProperties.getAdjustmentGuideList(), rValue );
+                if ( nGuideIndex >= 0 )
+                {
+                    aRet.Value <<= nGuideIndex;
+                    aRet.Type = EnhancedCustomShapeParameterType::ADJUSTMENT;
+                }
+                else
+                {
+                    nGuideIndex = CustomShapeProperties::GetCustomShapeGuideValue( rCustomShapeProperties.getGuideList(), rValue );
+                    if ( nGuideIndex >= 0 )
+                    {
+                        aRet.Value <<= nGuideIndex;
+                        aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
+                    }
+                    else
+                    {
+                        SAL_WARN("oox", "error: unhandled value " << rValue);
+                        aRet.Value <<= rValue;
+                    }
+                }
+            }
+        }
+    }
+    return aRet;
+}
+
+namespace {
+
+// CT_GeomGuideList
+class GeomGuideListContext : public ContextHandler2
+{
+public:
+    GeomGuideListContext( ContextHandler2Helper const & rParent, CustomShapeProperties& rCustomShapeProperties, std::vector< CustomShapeGuide >& rGuideList );
+    virtual ::oox::core::ContextHandlerRef onCreateContext( sal_Int32 aElementToken, const ::oox::AttributeList& rAttribs ) override;
+
+protected:
+    std::vector< CustomShapeGuide >&    mrGuideList;
+    CustomShapeProperties&              mrCustomShapeProperties;
+};
+
+}
+
+GeomGuideListContext::GeomGuideListContext( ContextHandler2Helper const & rParent, CustomShapeProperties& rCustomShapeProperties, std::vector< CustomShapeGuide >& rGuideList )
+: ContextHandler2( rParent )
+, mrGuideList( rGuideList )
+, mrCustomShapeProperties( rCustomShapeProperties )
+{
+}
+
+static OUString convertToOOEquation( CustomShapeProperties& rCustomShapeProperties, std::u16string_view rSource )
+{
+    if ( !pCommandHashMap )
+    {
+        FormulaCommandHMap* pHM = new FormulaCommandHMap;
+        for(const FormulaCommandNameTable& i : pFormulaCommandNameTable)
+            (*pHM)[ OUString::createFromAscii( i.pS ) ] =  i.pE;
+        pCommandHashMap = pHM;
+    }
+
+    std::vector< OUString > aTokens;
+    sal_Int32 nIndex = 0;
+    do
+    {
+        OUString aToken( o3tl::getToken(rSource, 0, ' ', nIndex ) );
+        if ( !aToken.isEmpty() )
+            aTokens.push_back( aToken );
+    }
+    while ( nIndex >= 0 );
+
+    OUString aEquation;
+    if ( !aTokens.empty() )
+    {
+        sal_Int32 i, nParameters = aTokens.size() - 1;
+        if ( nParameters > 3 )
+            nParameters = 3;
+
+        OUString sParameters[ 3 ];
+
+        for ( i = 0; i < nParameters; i++ )
+            sParameters[ i ] = GetFormulaParameter( GetAdjCoordinate( rCustomShapeProperties, aTokens[ i + 1 ], false ) );
+
+        const FormulaCommandHMap::const_iterator aIter( pCommandHashMap->find( aTokens[ 0 ] ) );
+        if ( aIter != pCommandHashMap->end() )
+        {
+            switch( aIter->second )
+            {
+                case FC_MULDIV :
+                {
+                    if ( nParameters == 3 )
+                        aEquation = sParameters[ 0 ] + "*" + sParameters[ 1 ]
+                            + "/" + sParameters[ 2 ];
+                }
+                break;
+                case FC_PLUSMINUS :
+                {
+                    if ( nParameters == 3 )
+                        aEquation = sParameters[ 0 ] + "+" + sParameters[ 1 ]
+                            + "-" + sParameters[ 2 ];
+                }
+                break;
+                case FC_PLUSDIV :
+                {
+                    if ( nParameters == 3 )
+                        aEquation = "(" + sParameters[ 0 ] + "+"
+                            + sParameters[ 1 ] + ")/" + sParameters[ 2 ];
+                }
+                break;
+                case FC_IFELSE :
+                case FC_IFELSE1 :
+                {
+                    if ( nParameters == 3 )
+                        aEquation = "if(" + sParameters[ 0 ] + ","
+                            + sParameters[ 1 ] + "," + sParameters[ 2 ] + ")";
+                }
+                break;
+                case FC_ABS :
+                {
+                    if ( nParameters == 1 )
+                        aEquation = "abs(" + sParameters[ 0 ] + ")";
+                }
+                break;
+                case FC_AT2 :
+                {
+                    if ( nParameters == 2 )
+                        aEquation = "(10800000*atan2(" + sParameters[ 1 ] + ","
+                        + sParameters[ 0 ] + "))/pi";
+                }
+                break;
+                case FC_CAT2 :
+                {
+                    if ( nParameters == 3 )
+                        aEquation = sParameters[ 0 ] + "*(cos(atan2(" +
+                            sParameters[ 2 ] + "," + sParameters[ 1 ] + ")))";
+                }
+                break;
+                case FC_COS :
+                {
+                    if ( nParameters == 2 )
+                        aEquation = sParameters[ 0 ] + "*cos(pi*(" +
+                        sParameters[ 1 ] + ")/10800000)";
+                }
+                break;
+                case FC_MAX :
+                {
+                    if ( nParameters == 2 )
+                        aEquation = "max(" + sParameters[ 0 ] + "," +
+                            sParameters[ 1 ] + ")";
+                }
+                break;
+                case FC_MIN :
+                {
+                    if ( nParameters == 2 )
+                        aEquation = "min(" + sParameters[ 0 ] + "," +
+                            sParameters[ 1 ] + ")";
+                }
+                break;
+                case FC_MOD :
+                {
+                    if ( nParameters == 3 )
+                        aEquation = "sqrt("
+                            + sParameters[ 0 ] + "*" + sParameters[ 0 ] + "+"
+                            + sParameters[ 1 ] + "*" + sParameters[ 1 ] + "+"
+                            + sParameters[ 2 ] + "*" + sParameters[ 2 ] + ")";
+                }
+                break;
+                case FC_PIN :
+                {
+                    if ( nParameters == 3 ) // if(x-y,x,if(y-z,z,y))
+                        aEquation = "if(" + sParameters[ 0 ] + "-" + sParameters[ 1 ]
+                            + "," + sParameters[ 0 ] + ",if(" + sParameters[ 2 ]
+                            + "-" + sParameters[ 1 ] + "," + sParameters[ 1 ]
+                            + "," + sParameters[ 2 ] + "))";
+                }
+                break;
+                case FC_SAT2 :
+                {
+                    if ( nParameters == 3 )
+                        aEquation = sParameters[ 0 ] + "*(sin(atan2(" +
+                            sParameters[ 2 ] + "," + sParameters[ 1 ] + ")))";
+                }
+                break;
+                case FC_SIN :
+                {
+                    if ( nParameters == 2 )
+                        aEquation = sParameters[ 0 ] + "*sin(pi*(" +
+                        sParameters[ 1 ] + ")/10800000)";
+                }
+                break;
+                case FC_SQRT :
+                {
+                    if ( nParameters == 1 )
+                        aEquation = "sqrt(" + sParameters[ 0 ] + ")";
+                }
+                break;
+                case FC_TAN :
+                {
+                    if ( nParameters == 2 )
+                        aEquation = sParameters[ 0 ] + "*tan(pi*(" +
+                        sParameters[ 1 ] + ")/10800000)";
+                }
+                break;
+                case FC_VAL :
+                {
+                    if ( nParameters == 1 )
+                        aEquation = sParameters[ 0 ];
+                }
+                break;
+                default :
+                    break;
+            }
+        }
+    }
+    return aEquation;
+}
+
+ContextHandlerRef GeomGuideListContext::onCreateContext( sal_Int32 aElementToken, const AttributeList& rAttribs )
+{
+    if ( aElementToken == A_TOKEN( gd ) )   // CT_GeomGuide
+    {
+        CustomShapeGuide aGuide;
+        aGuide.maName = rAttribs.getStringDefaulted( XML_name );
+        aGuide.maFormula = convertToOOEquation( mrCustomShapeProperties, rAttribs.getStringDefaulted( XML_fmla ) );
+        mrGuideList.push_back( aGuide );
+    }
+    return this;
+}
+
+static const OUString& GetGeomGuideName( const OUString& rValue )
+{
+    return rValue;
+}
+
+namespace {
+
+// CT_AdjPoint2D
+class AdjPoint2DContext : public ContextHandler2
+{
+public:
+    AdjPoint2DContext( ContextHandler2Helper const & rParent, const AttributeList& rAttribs, CustomShapeProperties& rCustomShapeProperties, EnhancedCustomShapeParameterPair& rAdjPoint2D );
+};
+
+}
+
+AdjPoint2DContext::AdjPoint2DContext( ContextHandler2Helper const & rParent, const AttributeList& rAttribs, CustomShapeProperties& rCustomShapeProperties, EnhancedCustomShapeParameterPair& rAdjPoint2D )
+: ContextHandler2( rParent )
+{
+    rAdjPoint2D.First = GetAdjCoordinate( rCustomShapeProperties, rAttribs.getStringDefaulted( XML_x ) );
+    rAdjPoint2D.Second = GetAdjCoordinate( rCustomShapeProperties, rAttribs.getStringDefaulted( XML_y ) );
+}
+
+namespace {
+
+// CT_XYAdjustHandle
+class XYAdjustHandleContext : public ContextHandler2
+{
+public:
+    XYAdjustHandleContext( ContextHandler2Helper const & rParent, const AttributeList& rAttribs, CustomShapeProperties& rCustomShapeProperties, AdjustHandle& rAdjustHandle );
+    virtual ::oox::core::ContextHandlerRef onCreateContext( sal_Int32 aElementToken, const ::oox::AttributeList& rAttribs ) override;
+
+protected:
+    AdjustHandle& mrAdjustHandle;
+    CustomShapeProperties& mrCustomShapeProperties;
+};
+
+}
+
+XYAdjustHandleContext::XYAdjustHandleContext( ContextHandler2Helper const & rParent, const AttributeList& rAttribs, CustomShapeProperties& rCustomShapeProperties, AdjustHandle& rAdjustHandle )
+: ContextHandler2( rParent )
+, mrAdjustHandle( rAdjustHandle )
+, mrCustomShapeProperties( rCustomShapeProperties )
+{
+    if ( rAttribs.hasAttribute( XML_gdRefX ) )
+    {
+        mrAdjustHandle.gdRef1 = GetGeomGuideName( rAttribs.getStringDefaulted( XML_gdRefX) );
+    }
+    if ( rAttribs.hasAttribute( XML_minX ) )
+    {
+        mrAdjustHandle.min1 = GetAdjCoordinate( mrCustomShapeProperties, rAttribs.getStringDefaulted( XML_minX) );
+    }
+    if ( rAttribs.hasAttribute( XML_maxX ) )
+    {
+        mrAdjustHandle.max1 = GetAdjCoordinate( mrCustomShapeProperties, rAttribs.getStringDefaulted( XML_maxX) );
+    }
+    if ( rAttribs.hasAttribute( XML_gdRefY ) )
+    {
+        mrAdjustHandle.gdRef2 = GetGeomGuideName( rAttribs.getStringDefaulted( XML_gdRefY) );
+    }
+    if ( rAttribs.hasAttribute( XML_minY ) )
+    {
+        mrAdjustHandle.min2 = GetAdjCoordinate( mrCustomShapeProperties, rAttribs.getStringDefaulted( XML_minY) );
+    }
+    if ( rAttribs.hasAttribute( XML_maxY ) )
+    {
+        mrAdjustHandle.max2 = GetAdjCoordinate( mrCustomShapeProperties, rAttribs.getStringDefaulted( XML_maxY) );
+    }
+}
+
+ContextHandlerRef XYAdjustHandleContext::onCreateContext( sal_Int32 aElementToken, const AttributeList& rAttribs )
+{
+    if ( aElementToken == A_TOKEN( pos ) )
+        return new AdjPoint2DContext( *this, rAttribs, mrCustomShapeProperties, mrAdjustHandle.pos );   // CT_AdjPoint2D
+    return nullptr;
+}
+
+namespace {
+
+// CT_PolarAdjustHandle
+class PolarAdjustHandleContext : public ContextHandler2
+{
+public:
+    PolarAdjustHandleContext( ContextHandler2Helper const & rParent, const AttributeList& rAttribs, CustomShapeProperties& rCustomShapeProperties, AdjustHandle& rAdjustHandle );
+    virtual ::oox::core::ContextHandlerRef onCreateContext( sal_Int32 aElementToken, const ::oox::AttributeList& rAttribs ) override;
+
+protected:
+    AdjustHandle& mrAdjustHandle;
+    CustomShapeProperties& mrCustomShapeProperties;
+};
+
+}
+
+PolarAdjustHandleContext::PolarAdjustHandleContext( ContextHandler2Helper const & rParent, const AttributeList& rAttribs, CustomShapeProperties& rCustomShapeProperties, AdjustHandle& rAdjustHandle )
+: ContextHandler2( rParent )
+, mrAdjustHandle( rAdjustHandle )
+, mrCustomShapeProperties( rCustomShapeProperties )
+{
+    if ( rAttribs.hasAttribute( XML_gdRefR ) )
+    {
+        mrAdjustHandle.polar = true ;
+        mrAdjustHandle.gdRef1 = GetGeomGuideName( rAttribs.getStringDefaulted( XML_gdRefR) );
+    }
+    if ( rAttribs.hasAttribute( XML_minR ) )
+    {
+        mrAdjustHandle.min1 = GetAdjCoordinate( mrCustomShapeProperties, rAttribs.getStringDefaulted( XML_minR) );
+    }
+    if ( rAttribs.hasAttribute( XML_maxR ) )
+    {
+        mrAdjustHandle.max1 = GetAdjCoordinate( mrCustomShapeProperties, rAttribs.getStringDefaulted( XML_maxR) );
+    }
+    if ( rAttribs.hasAttribute( XML_gdRefAng ) )
+    {
+        mrAdjustHandle.polar = true ;
+        mrAdjustHandle.gdRef2 = GetGeomGuideName( rAttribs.getStringDefaulted( XML_gdRefAng) );
+    }
+    if ( rAttribs.hasAttribute( XML_minAng ) )
+    {
+        mrAdjustHandle.min2 = GetAdjCoordinate( mrCustomShapeProperties, rAttribs.getStringDefaulted( XML_minAng) );
+    }
+    if ( rAttribs.hasAttribute( XML_maxAng ) )
+    {
+        mrAdjustHandle.max2 = GetAdjCoordinate( mrCustomShapeProperties, rAttribs.getStringDefaulted( XML_maxAng) );
+    }
+}
+
+ContextHandlerRef PolarAdjustHandleContext::onCreateContext( sal_Int32 aElementToken, const AttributeList& rAttribs )
+{
+    // mrAdjustHandle.pos uses planar coordinates.
+    if ( aElementToken == A_TOKEN( pos ) )
+        return new AdjPoint2DContext( *this, rAttribs, mrCustomShapeProperties, mrAdjustHandle.pos );   // CT_AdjPoint2D
+    return nullptr;
+}
+
+namespace {
+
+// CT_AdjustHandleList
+class AdjustHandleListContext : public ContextHandler2
+{
+public:
+    AdjustHandleListContext( ContextHandler2Helper const & rParent, CustomShapeProperties& rCustomShapeProperties, std::vector< AdjustHandle >& rAdjustHandleList );
+    virtual ::oox::core::ContextHandlerRef onCreateContext( sal_Int32 aElementToken, const ::oox::AttributeList& rAttribs ) override;
+
+protected:
+    std::vector< AdjustHandle >& mrAdjustHandleList;
+    CustomShapeProperties& mrCustomShapeProperties;
+};
+
+}
+
+AdjustHandleListContext::AdjustHandleListContext( ContextHandler2Helper const & rParent, CustomShapeProperties& rCustomShapeProperties, std::vector< AdjustHandle >& rAdjustHandleList )
+: ContextHandler2( rParent )
+, mrAdjustHandleList( rAdjustHandleList )
+, mrCustomShapeProperties( rCustomShapeProperties )
+{
+}
+
+ContextHandlerRef AdjustHandleListContext::onCreateContext( sal_Int32 aElementToken, const AttributeList& rAttribs )
+{
+    if ( aElementToken == A_TOKEN( ahXY ) )         // CT_XYAdjustHandle
+    {
+        AdjustHandle aAdjustHandle( false );
+        mrAdjustHandleList.push_back( aAdjustHandle );
+        return new XYAdjustHandleContext( *this, rAttribs, mrCustomShapeProperties, mrAdjustHandleList.back() );
+    }
+    else if ( aElementToken == A_TOKEN( ahPolar ) ) // CT_PolarAdjustHandle
+    {
+        AdjustHandle aAdjustHandle( true );
+        mrAdjustHandleList.push_back( aAdjustHandle );
+        return new PolarAdjustHandleContext( *this, rAttribs, mrCustomShapeProperties, mrAdjustHandleList.back() );
+    }
+    return nullptr;
+}
+
+namespace {
+
+// CT_ConnectionSite
+class ConnectionSiteContext : public ContextHandler2
+{
+public:
+    ConnectionSiteContext( ContextHandler2Helper const & rParent, const AttributeList& rAttribs, CustomShapeProperties& rCustomShapeProperties, ConnectionSite& rConnectionSite );
+    virtual ::oox::core::ContextHandlerRef onCreateContext( sal_Int32 aElementToken, const ::oox::AttributeList& rAttribs ) override;
+
+protected:
+    ConnectionSite& mrConnectionSite;
+    CustomShapeProperties& mrCustomShapeProperties;
+};
+
+}
+
+ConnectionSiteContext::ConnectionSiteContext( ContextHandler2Helper const & rParent, const AttributeList& rAttribs, CustomShapeProperties& rCustomShapeProperties, ConnectionSite& rConnectionSite )
+: ContextHandler2( rParent )
+, mrConnectionSite( rConnectionSite )
+, mrCustomShapeProperties( rCustomShapeProperties )
+{
+    mrConnectionSite.ang = GetAdjCoordinate( mrCustomShapeProperties, rAttribs.getStringDefaulted( XML_ang ) );
+}
+
+ContextHandlerRef ConnectionSiteContext::onCreateContext( sal_Int32 aElementToken, const AttributeList& rAttribs )
+{
+    if ( aElementToken == A_TOKEN( pos ) )
+        return new AdjPoint2DContext( *this, rAttribs, mrCustomShapeProperties, mrConnectionSite.pos ); // CT_AdjPoint2D
+    return nullptr;
+}
+
+namespace {
+
+// CT_Path2DMoveTo
+class Path2DMoveToContext : public ContextHandler2
+{
+public:
+    Path2DMoveToContext( ContextHandler2Helper const & rParent, CustomShapeProperties& rCustomShapeProperties, EnhancedCustomShapeParameterPair& rAdjPoint2D );
+    virtual ::oox::core::ContextHandlerRef onCreateContext( sal_Int32 aElementToken, const ::oox::AttributeList& rAttribs ) override;
+
+protected:
+    EnhancedCustomShapeParameterPair& mrAdjPoint2D;
+    CustomShapeProperties& mrCustomShapeProperties;
+};
+
+}
+
+Path2DMoveToContext::Path2DMoveToContext( ContextHandler2Helper const & rParent, CustomShapeProperties& rCustomShapeProperties, EnhancedCustomShapeParameterPair& rAdjPoint2D )
+: ContextHandler2( rParent )
+, mrAdjPoint2D( rAdjPoint2D )
+, mrCustomShapeProperties( rCustomShapeProperties )
+{
+}
+
+ContextHandlerRef Path2DMoveToContext::onCreateContext( sal_Int32 aElementToken, const AttributeList& rAttribs )
+{
+    if ( aElementToken == A_TOKEN( pt ) )
+        return new AdjPoint2DContext( *this, rAttribs, mrCustomShapeProperties, mrAdjPoint2D );     // CT_AdjPoint2D
+    return nullptr;
+}
+
+namespace {
+
+// CT_Path2DLineTo
+class Path2DLineToContext : public ContextHandler2
+{
+public:
+    Path2DLineToContext( ContextHandler2Helper const & rParent, CustomShapeProperties& rCustomShapeProperties, EnhancedCustomShapeParameterPair& rAdjPoint2D );
+    virtual ::oox::core::ContextHandlerRef onCreateContext( sal_Int32 aElementToken, const ::oox::AttributeList& rAttribs ) override;
+
+protected:
+    EnhancedCustomShapeParameterPair& mrAdjPoint2D;
+    CustomShapeProperties& mrCustomShapeProperties;
+};
+
+}
+
+Path2DLineToContext::Path2DLineToContext( ContextHandler2Helper const & rParent, CustomShapeProperties& rCustomShapeProperties, EnhancedCustomShapeParameterPair& rAdjPoint2D )
+: ContextHandler2( rParent )
+, mrAdjPoint2D( rAdjPoint2D )
+, mrCustomShapeProperties( rCustomShapeProperties )
+{
+}
+
+ContextHandlerRef Path2DLineToContext::onCreateContext( sal_Int32 aElementToken, const AttributeList& rAttribs )
+{
+    if ( aElementToken == A_TOKEN( pt ) )
+        return new AdjPoint2DContext( *this, rAttribs, mrCustomShapeProperties, mrAdjPoint2D );     // CT_AdjPoint2D
+    return nullptr;
+}
+
+namespace {
+
+// CT_Path2DQuadBezierTo
+class Path2DQuadBezierToContext : public ContextHandler2
+{
+public:
+    Path2DQuadBezierToContext( ContextHandler2Helper const & rParent, CustomShapeProperties& rCustomShapeProperties, EnhancedCustomShapeParameterPair& rPt1, EnhancedCustomShapeParameterPair& rPt2 );
+    virtual ::oox::core::ContextHandlerRef onCreateContext( sal_Int32 aElementToken, const ::oox::AttributeList& rAttribs ) override;
+
+protected:
+    EnhancedCustomShapeParameterPair& mrPt1;
+    EnhancedCustomShapeParameterPair& mrPt2;
+    int nCount;
+    CustomShapeProperties& mrCustomShapeProperties;
+};
+
+}
+
+Path2DQuadBezierToContext::Path2DQuadBezierToContext( ContextHandler2Helper const & rParent,
+    CustomShapeProperties& rCustomShapeProperties,
+        EnhancedCustomShapeParameterPair& rPt1,
+            EnhancedCustomShapeParameterPair& rPt2 )
+: ContextHandler2( rParent )
+, mrPt1( rPt1 )
+, mrPt2( rPt2 )
+, nCount( 0 )
+, mrCustomShapeProperties( rCustomShapeProperties )
+{
+}
+
+ContextHandlerRef Path2DQuadBezierToContext::onCreateContext( sal_Int32 aElementToken, const AttributeList& rAttribs )
+{
+    if ( aElementToken == A_TOKEN( pt ) )
+        return new AdjPoint2DContext( *this, rAttribs, mrCustomShapeProperties, nCount++ ? mrPt2 : mrPt1 ); // CT_AdjPoint2D
+    return nullptr;
+}
+
+namespace {
+
+// CT_Path2DCubicBezierTo
+class Path2DCubicBezierToContext : public ContextHandler2
+{
+public:
+    Path2DCubicBezierToContext( ContextHandler2Helper const & rParent, CustomShapeProperties& rCustomShapeProperties,
+        EnhancedCustomShapeParameterPair&, EnhancedCustomShapeParameterPair&, EnhancedCustomShapeParameterPair& );
+    virtual ::oox::core::ContextHandlerRef onCreateContext( sal_Int32 aElementToken, const ::oox::AttributeList& rAttribs ) override;
+
+protected:
+    CustomShapeProperties& mrCustomShapeProperties;
+    EnhancedCustomShapeParameterPair& mrControlPt1;
+    EnhancedCustomShapeParameterPair& mrControlPt2;
+    EnhancedCustomShapeParameterPair& mrEndPt;
+    int nCount;
+};
+
+}
+
+Path2DCubicBezierToContext::Path2DCubicBezierToContext( ContextHandler2Helper const & rParent, CustomShapeProperties& rCustomShapeProperties,
+    EnhancedCustomShapeParameterPair& rControlPt1,
+        EnhancedCustomShapeParameterPair& rControlPt2,
+            EnhancedCustomShapeParameterPair& rEndPt )
+: ContextHandler2( rParent )
+, mrCustomShapeProperties( rCustomShapeProperties )
+, mrControlPt1( rControlPt1 )
+, mrControlPt2( rControlPt2 )
+, mrEndPt( rEndPt )
+, nCount( 0 )
+{
+}
+
+ContextHandlerRef Path2DCubicBezierToContext::onCreateContext( sal_Int32 aElementToken, const AttributeList& rAttribs )
+{
+    if ( aElementToken == A_TOKEN( pt ) )
+        return new AdjPoint2DContext( *this, rAttribs, mrCustomShapeProperties,
+            nCount++ ? nCount == 2 ? mrControlPt2 : mrEndPt : mrControlPt1 );   // CT_AdjPoint2D
+    return nullptr;
+}
+
+namespace {
+
+// CT_Path2DContext
+class Path2DContext : public ContextHandler2
+{
+public:
+    Path2DContext( ContextHandler2Helper const & rParent, const AttributeList& rAttribs, CustomShapeProperties& rCustomShapeProperties, std::vector< css::drawing::EnhancedCustomShapeSegment >& rSegments, Path2D& rPath2D );
+    virtual void onEndElement() override;
+    virtual ::oox::core::ContextHandlerRef
+        onCreateContext( sal_Int32 aElementToken, const ::oox::AttributeList& rAttribs ) override;
+
+protected:
+    Path2D& mrPath2D;
+    std::vector< css::drawing::EnhancedCustomShapeSegment >& mrSegments;
+    CustomShapeProperties& mrCustomShapeProperties;
+};
+
+}
+
+Path2DContext::Path2DContext( ContextHandler2Helper const & rParent, const AttributeList& rAttribs, CustomShapeProperties& rCustomShapeProperties, std::vector< css::drawing::EnhancedCustomShapeSegment >& rSegments, Path2D& rPath2D )
+: ContextHandler2( rParent )
+, mrPath2D( rPath2D )
+, mrSegments( rSegments )
+, mrCustomShapeProperties( rCustomShapeProperties )
+{
+    rPath2D.w = rAttribs.getHyper( XML_w, 0 );
+    rPath2D.h = rAttribs.getHyper( XML_h, 0 );
+    rPath2D.fill = rAttribs.getToken( XML_fill, XML_norm );
+    rPath2D.stroke = rAttribs.getBool( XML_stroke, true );
+    rPath2D.extrusionOk = rAttribs.getBool( XML_extrusionOk, true );
+}
+
+void Path2DContext::onEndElement()
+{
+    EnhancedCustomShapeSegment aNewSegment;
+    switch ( mrPath2D.fill )
+    {
+        case XML_none:
+            aNewSegment.Command = EnhancedCustomShapeSegmentCommand::NOFILL;
+            break;
+        case XML_darken:
+            aNewSegment.Command = EnhancedCustomShapeSegmentCommand::DARKEN;
+            break;
+        case XML_darkenLess:
+            aNewSegment.Command = EnhancedCustomShapeSegmentCommand::DARKENLESS;
+            break;
+        case XML_lighten:
+            aNewSegment.Command = EnhancedCustomShapeSegmentCommand::LIGHTEN;
+            break;
+        case XML_lightenLess:
+            aNewSegment.Command = EnhancedCustomShapeSegmentCommand::LIGHTENLESS;
+            break;
+    }
+    if (mrPath2D.fill != XML_norm) {
+        aNewSegment.Count = 0;
+        mrSegments.push_back( aNewSegment );
+    }
+    if ( !mrPath2D.stroke )
+    {
+        aNewSegment.Command = EnhancedCustomShapeSegmentCommand::NOSTROKE;
+        aNewSegment.Count = 0;
+        mrSegments.push_back( aNewSegment );
+    }
+    aNewSegment.Command = EnhancedCustomShapeSegmentCommand::ENDSUBPATH;
+    aNewSegment.Count = 0;
+    mrSegments.push_back( aNewSegment );
+}
+
+
+ContextHandlerRef Path2DContext::onCreateContext( sal_Int32 aElementToken,
+    const AttributeList& rAttribs )
+{
+    switch( aElementToken )
+    {
+        case A_TOKEN( close ) :
+        {
+            // ignore close after move to (ppt does seems to do the same, see accentCallout2 preset for example)
+            if ( mrSegments.empty() || ( mrSegments.back().Command != EnhancedCustomShapeSegmentCommand::MOVETO ) ) {
+                EnhancedCustomShapeSegment aNewSegment;
+                aNewSegment.Command = EnhancedCustomShapeSegmentCommand::CLOSESUBPATH;
+                aNewSegment.Count = 0;
+                mrSegments.push_back( aNewSegment );
+            }
+        }
+        break;
+        case A_TOKEN( moveTo ) :
+        {
+            EnhancedCustomShapeSegment aNewSegment;
+            aNewSegment.Command = EnhancedCustomShapeSegmentCommand::MOVETO;
+            aNewSegment.Count = 1;
+            mrSegments.push_back( aNewSegment );
+
+            EnhancedCustomShapeParameterPair aAdjPoint2D;
+            mrPath2D.parameter.push_back( aAdjPoint2D );
+            return new Path2DMoveToContext( *this, mrCustomShapeProperties, mrPath2D.parameter.back() );
+        }
+        break;
+        case A_TOKEN( lnTo ) :
+        {
+            if ( !mrSegments.empty() && ( mrSegments.back().Command == EnhancedCustomShapeSegmentCommand::LINETO ) )
+                mrSegments.back().Count++;
+            else
+            {
+                EnhancedCustomShapeSegment aSegment;
+                aSegment.Command = EnhancedCustomShapeSegmentCommand::LINETO;
+                aSegment.Count = 1;
+                mrSegments.push_back( aSegment );
+            }
+            EnhancedCustomShapeParameterPair aAdjPoint2D;
+            mrPath2D.parameter.push_back( aAdjPoint2D );
+            return new Path2DLineToContext( *this, mrCustomShapeProperties, mrPath2D.parameter.back() );
+        }
+        break;
+        case A_TOKEN( arcTo ) : // CT_Path2DArcTo
+        {
+            if ( !mrSegments.empty() && ( mrSegments.back().Command == EnhancedCustomShapeSegmentCommand::ARCANGLETO ) )
+                mrSegments.back().Count++;
+            else
+            {
+                EnhancedCustomShapeSegment aSegment;
+                aSegment.Command = EnhancedCustomShapeSegmentCommand::ARCANGLETO;
+                aSegment.Count = 1;
+                mrSegments.push_back( aSegment );
+            }
+
+            EnhancedCustomShapeParameterPair aScale;
+            EnhancedCustomShapeParameterPair aAngles;
+
+            aScale.First = GetAdjCoordinate( mrCustomShapeProperties, rAttribs.getStringDefaulted( XML_wR ) );
+            aScale.Second = GetAdjCoordinate( mrCustomShapeProperties, rAttribs.getStringDefaulted( XML_hR ) );
+
+            CustomShapeGuide aGuide;
+            sal_Int32 nArcNum = mrCustomShapeProperties.getArcNum();
+
+            // start angle
+            aGuide.maName = "arctosa" + OUString::number( nArcNum );
+            aGuide.maFormula = "("
+                + GetFormulaParameter( GetAdjCoordinate( mrCustomShapeProperties, rAttribs.getStringDefaulted( XML_stAng ) ) )
+                + ")/60000.0";
+            aAngles.First.Value <<= CustomShapeProperties::SetCustomShapeGuideValue( mrCustomShapeProperties.getGuideList(), aGuide );
+            aAngles.First.Type = EnhancedCustomShapeParameterType::EQUATION;
+
+            // swing angle
+            aGuide.maName = "arctosw" + OUString::number( nArcNum );
+            aGuide.maFormula = "("
+                + GetFormulaParameter( GetAdjCoordinate( mrCustomShapeProperties, rAttribs.getStringDefaulted( XML_swAng ) ) )
+                + ")/60000.0";
+            aAngles.Second.Value <<= CustomShapeProperties::SetCustomShapeGuideValue( mrCustomShapeProperties.getGuideList(), aGuide );
+            aAngles.Second.Type = EnhancedCustomShapeParameterType::EQUATION;
+
+            mrPath2D.parameter.push_back( aScale );
+            mrPath2D.parameter.push_back( aAngles );
+        }
+        break;
+        case A_TOKEN( quadBezTo ) :
+        {
+            if ( !mrSegments.empty() && ( mrSegments.back().Command == EnhancedCustomShapeSegmentCommand::QUADRATICCURVETO ) )
+                mrSegments.back().Count++;
+            else
+            {
+                EnhancedCustomShapeSegment aSegment;
+                aSegment.Command = EnhancedCustomShapeSegmentCommand::QUADRATICCURVETO;
+                aSegment.Count = 1;
+                mrSegments.push_back( aSegment );
+            }
+            EnhancedCustomShapeParameterPair aPt1;
+            EnhancedCustomShapeParameterPair aPt2;
+            mrPath2D.parameter.push_back( aPt1 );
+            mrPath2D.parameter.push_back( aPt2 );
+            return new Path2DQuadBezierToContext( *this, mrCustomShapeProperties,
+                            mrPath2D.parameter[ mrPath2D.parameter.size() - 2 ],
+                                mrPath2D.parameter.back() );
+        }
+        break;
+        case A_TOKEN( cubicBezTo ) :
+        {
+            if ( !mrSegments.empty() && ( mrSegments.back().Command == EnhancedCustomShapeSegmentCommand::CURVETO ) )
+                mrSegments.back().Count++;
+            else
+            {
+                EnhancedCustomShapeSegment aSegment;
+                aSegment.Command = EnhancedCustomShapeSegmentCommand::CURVETO;
+                aSegment.Count = 1;
+                mrSegments.push_back( aSegment );
+            }
+            EnhancedCustomShapeParameterPair aControlPt1;
+            EnhancedCustomShapeParameterPair aControlPt2;
+            EnhancedCustomShapeParameterPair aEndPt;
+            mrPath2D.parameter.push_back( aControlPt1 );
+            mrPath2D.parameter.push_back( aControlPt2 );
+            mrPath2D.parameter.push_back( aEndPt );
+            return new Path2DCubicBezierToContext( *this, mrCustomShapeProperties,
+                            mrPath2D.parameter[ mrPath2D.parameter.size() - 3 ],
+                                mrPath2D.parameter[ mrPath2D.parameter.size() - 2 ],
+                                    mrPath2D.parameter.back() );
+        }
+        break;
+    }
+    return nullptr;
+}
+
+namespace {
+
+// CT_Path2DList
+class Path2DListContext : public ContextHandler2
+{
+public:
+    Path2DListContext( ContextHandler2Helper const & rParent, CustomShapeProperties & rCustomShapeProperties, std::vector< EnhancedCustomShapeSegment >& rSegments,
+        std::vector< Path2D >& rPath2DList );
+
+    virtual ::oox::core::ContextHandlerRef onCreateContext( sal_Int32 aElementToken, const ::oox::AttributeList& rAttribs ) override;
+
+protected:
+
+    CustomShapeProperties& mrCustomShapeProperties;
+    std::vector< css::drawing::EnhancedCustomShapeSegment >& mrSegments;
+    std::vector< Path2D >& mrPath2DList;
+};
+
+}
+
+Path2DListContext:: Path2DListContext( ContextHandler2Helper const & rParent, CustomShapeProperties& rCustomShapeProperties, std::vector< EnhancedCustomShapeSegment >& rSegments,
+                                        std::vector< Path2D >& rPath2DList )
+: ContextHandler2( rParent )
+, mrCustomShapeProperties( rCustomShapeProperties )
+, mrSegments( rSegments )
+, mrPath2DList( rPath2DList )
+{
+}
+
+ContextHandlerRef Path2DListContext::onCreateContext( sal_Int32 aElementToken, const AttributeList& rAttribs )
+{
+    if ( aElementToken == A_TOKEN( path ) )
+    {
+        Path2D aPath2D;
+        mrPath2DList.push_back( aPath2D );
+        return new Path2DContext( *this, rAttribs, mrCustomShapeProperties,  mrSegments, mrPath2DList.back() );
+    }
+    return nullptr;
+}
+
+// CT_CustomGeometry2D
+CustomShapeGeometryContext::CustomShapeGeometryContext( ContextHandler2Helper const & rParent, CustomShapeProperties& rCustomShapeProperties )
+: ContextHandler2( rParent )
+, mrCustomShapeProperties( rCustomShapeProperties )
+{
+}
+
+ContextHandlerRef CustomShapeGeometryContext::onCreateContext( sal_Int32 aElementToken, const AttributeList& rAttribs )
+{
+    switch( aElementToken )
+    {
+        case A_TOKEN( avLst ):          // CT_GeomGuideList adjust value list
+            return new GeomGuideListContext( *this, mrCustomShapeProperties, mrCustomShapeProperties.getAdjustmentGuideList() );
+        case A_TOKEN( gdLst ):          // CT_GeomGuideList guide list
+            return new GeomGuideListContext( *this, mrCustomShapeProperties, mrCustomShapeProperties.getGuideList() );
+        case A_TOKEN( ahLst ):          // CT_AdjustHandleList adjust handle list
+            return new AdjustHandleListContext( *this, mrCustomShapeProperties, mrCustomShapeProperties.getAdjustHandleList() );
+        case A_TOKEN( cxnLst ):         // CT_ConnectionSiteList connection site list
+            return this;
+        case A_TOKEN( rect ):           // CT_GeomRectList geometry rect list
+        {
+            GeomRect aGeomRect;
+            aGeomRect.l = GetAdjCoordinate( mrCustomShapeProperties, rAttribs.getStringDefaulted( XML_l ) );
+            aGeomRect.t = GetAdjCoordinate( mrCustomShapeProperties, rAttribs.getStringDefaulted( XML_t ) );
+            aGeomRect.r = GetAdjCoordinate( mrCustomShapeProperties, rAttribs.getStringDefaulted( XML_r ) );
+            aGeomRect.b = GetAdjCoordinate( mrCustomShapeProperties, rAttribs.getStringDefaulted( XML_b ) );
+            mrCustomShapeProperties.getTextRect() = aGeomRect;
+        }
+        break;
+        case A_TOKEN( pathLst ):        // CT_Path2DList 2d path list
+            return new Path2DListContext( *this, mrCustomShapeProperties, mrCustomShapeProperties.getSegments(), mrCustomShapeProperties.getPath2DList() );
+
+        // from cxnLst:
+        case A_TOKEN( cxn ):                // CT_ConnectionSite
+        {
+            ConnectionSite aConnectionSite;
+            mrCustomShapeProperties.getConnectionSiteList().push_back( aConnectionSite );
+            return new ConnectionSiteContext( *this, rAttribs, mrCustomShapeProperties, mrCustomShapeProperties.getConnectionSiteList().back() );
+        }
+    }
+    return nullptr;
+}
+
+// CT_PresetGeometry2D
+PresetShapeGeometryContext::PresetShapeGeometryContext( ContextHandler2Helper const & rParent, const AttributeList& rAttribs, CustomShapeProperties& rCustomShapeProperties )
+: ContextHandler2( rParent )
+, mrCustomShapeProperties( rCustomShapeProperties )
+{
+    sal_Int32 nShapeType = rAttribs.getToken( XML_prst, FastToken::DONTKNOW );
+    OSL_ENSURE( nShapeType != FastToken::DONTKNOW, "oox::drawingml::CustomShapeCustomGeometryContext::CustomShapeCustomGeometryContext(), unknown shape type" );
+    mrCustomShapeProperties.setShapePresetType( nShapeType );
+}
+
+ContextHandlerRef PresetShapeGeometryContext::onCreateContext( sal_Int32 aElementToken, const AttributeList& )
+{
+    if ( aElementToken == A_TOKEN( avLst ) )
+        return new GeomGuideListContext( *this, mrCustomShapeProperties, mrCustomShapeProperties.getAdjustmentGuideList() );
+    else
+        return this;
+}
+
+// CT_PresetTextShape
+PresetTextShapeContext::PresetTextShapeContext( ContextHandler2Helper const & rParent, const AttributeList& rAttribs, CustomShapeProperties& rCustomShapeProperties )
+: ContextHandler2( rParent )
+, mrCustomShapeProperties( rCustomShapeProperties )
+{
+    sal_Int32 nShapeType = rAttribs.getToken( XML_prst, FastToken::DONTKNOW );
+    OSL_ENSURE( nShapeType != FastToken::DONTKNOW, "oox::drawingml::CustomShapeCustomGeometryContext::CustomShapeCustomGeometryContext(), unknown shape type" );
+    mrCustomShapeProperties.setShapePresetType( nShapeType );
+}
+
+ContextHandlerRef PresetTextShapeContext::onCreateContext( sal_Int32 aElementToken, const AttributeList& )
+{
+    if ( aElementToken == A_TOKEN( avLst ) )
+        return new GeomGuideListContext( *this, mrCustomShapeProperties, mrCustomShapeProperties.getAdjustmentGuideList() );
+    else
+        return this;
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */