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, 982 insertions, 0 deletions

diff --git a/oox/source/shape/WpsContext.cxx b/oox/source/shape/WpsContext.cxx
new file mode 100644
index 0000000000..fae7048563
--- /dev/null
+++ b/oox/source/shape/WpsContext.cxx
@@ -0,0 +1,982 @@
+/* -*- 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/.
+ */
+
+#include "WpsContext.hxx"
+#include "WpgContext.hxx"
+#include "WordprocessingCanvasContext.hxx"
+#include <basegfx/matrix/b2dhommatrix.hxx>
+#include <basegfx/tuple/b2dtuple.hxx>
+#include <comphelper/propertyvalue.hxx>
+#include <comphelper/sequence.hxx>
+#include <comphelper/sequenceashashmap.hxx>
+#include <drawingml/customshapegeometry.hxx>
+#include <drawingml/customshapeproperties.hxx>
+#include <drawingml/fontworkhelpers.hxx>
+#include <drawingml/textbody.hxx>
+#include <drawingml/textbodyproperties.hxx>
+#include <oox/drawingml/color.hxx>
+#include <oox/drawingml/connectorshapecontext.hxx>
+#include <oox/drawingml/drawingmltypes.hxx>
+#include <oox/drawingml/shape.hxx>
+#include <oox/drawingml/shapepropertymap.hxx>
+#include <oox/helper/attributelist.hxx>
+#include <oox/token/namespaces.hxx>
+#include <oox/token/tokens.hxx>
+#include <svx/svdoashp.hxx>
+
+#include <com/sun/star/beans/PropertyAttribute.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/beans/XPropertySetInfo.hpp>
+#include <com/sun/star/beans/XPropertyState.hpp>
+#include <com/sun/star/container/XEnumerationAccess.hpp>
+#include <com/sun/star/drawing/HomogenMatrix3.hpp>
+#include <com/sun/star/drawing/TextHorizontalAdjust.hpp>
+#include <com/sun/star/geometry/IntegerRectangle2D.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/text/XText.hpp>
+#include <com/sun/star/text/XTextCursor.hpp>
+#include <com/sun/star/text/WritingMode.hpp>
+#include <com/sun/star/text/WritingMode2.hpp>
+
+#include <optional>
+
+using namespace com::sun::star;
+
+namespace
+{
+bool lcl_getTextPropsFromFrameText(const uno::Reference<text::XText>& xText,
+                                   std::vector<beans::PropertyValue>& rTextPropVec)
+{
+    if (!xText.is())
+        return false;
+    uno::Reference<text::XTextCursor> xTextCursor = xText->createTextCursor();
+    xTextCursor->gotoStart(false);
+    xTextCursor->gotoEnd(true);
+    uno::Reference<container::XEnumerationAccess> paraEnumAccess(xText, uno::UNO_QUERY);
+    if (!paraEnumAccess.is())
+        return false;
+    uno::Reference<container::XEnumeration> paraEnum(paraEnumAccess->createEnumeration());
+    while (paraEnum->hasMoreElements())
+    {
+        uno::Reference<text::XTextRange> xParagraph(paraEnum->nextElement(), uno::UNO_QUERY);
+        uno::Reference<container::XEnumerationAccess> runEnumAccess(xParagraph, uno::UNO_QUERY);
+        if (!runEnumAccess.is())
+            continue;
+        uno::Reference<container::XEnumeration> runEnum = runEnumAccess->createEnumeration();
+        while (runEnum->hasMoreElements())
+        {
+            uno::Reference<text::XTextRange> xRun(runEnum->nextElement(), uno::UNO_QUERY);
+            if (xRun->getString().isEmpty())
+                continue;
+            uno::Reference<beans::XPropertySet> xRunPropSet(xRun, uno::UNO_QUERY);
+            if (!xRunPropSet.is())
+                continue;
+            auto xRunPropSetInfo = xRunPropSet->getPropertySetInfo();
+            if (!xRunPropSetInfo.is())
+                continue;
+
+            // We have found a non-empty run. Collect its properties.
+            auto aRunPropInfoSequence = xRunPropSetInfo->getProperties();
+            for (const beans::Property& aProp : aRunPropInfoSequence)
+            {
+                rTextPropVec.push_back(comphelper::makePropertyValue(
+                    aProp.Name, xRunPropSet->getPropertyValue(aProp.Name)));
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+// CharInteropGrabBag puts all attributes of an element into a property with Name="attributes" and
+// Value being a sequence of the attributes. This methods finds the value of an individual rName
+// attribute and puts it into rValue parameter. If it does not find it, rValue is unchanged and
+// the method returns false, otherwise it returns true.
+bool lcl_getAttributeAsString(const uno::Sequence<beans::PropertyValue>& aPropertyValueAsSeq,
+                              const OUString& rName, OUString& rValue)
+{
+    comphelper::SequenceAsHashMap aPropertyValueAsMap(aPropertyValueAsSeq);
+    uno::Sequence<beans::PropertyValue> aAttributesSeq;
+    if (!((aPropertyValueAsMap.getValue("attributes") >>= aAttributesSeq)
+          && aAttributesSeq.hasElements()))
+        return false;
+    comphelper::SequenceAsHashMap aAttributesMap(aAttributesSeq);
+    OUString sRet;
+    if (!(aAttributesMap.getValue(rName) >>= sRet))
+        return false;
+    rValue = sRet;
+    return true;
+}
+
+// Same as above for a number as attribute value
+bool lcl_getAttributeAsNumber(const uno::Sequence<beans::PropertyValue>& rPropertyValueAsSeq,
+                              const OUString& rName, sal_Int32& rValue)
+{
+    comphelper::SequenceAsHashMap aPropertyValueAsMap(rPropertyValueAsSeq);
+    uno::Sequence<beans::PropertyValue> aAttributesSeq;
+    if (!((aPropertyValueAsMap.getValue("attributes") >>= aAttributesSeq)
+          && aAttributesSeq.hasElements()))
+        return false;
+    comphelper::SequenceAsHashMap aAttributesMap(aAttributesSeq);
+    sal_Int32 nRet;
+    if (!(aAttributesMap.getValue(rName) >>= nRet))
+        return false;
+    rValue = nRet;
+    return true;
+}
+
+void lcl_getColorTransformationsFromPropSeq(const uno::Sequence<beans::PropertyValue>& rPropSeq,
+                                            oox::drawingml::Color& rColor)
+{
+    auto isValidPropName = [](const OUString& rName) -> bool {
+        return rName == u"tint" || rName == u"shade" || rName == u"alpha" || rName == u"hueMod"
+               || rName == u"sat" || rName == u"satOff" || rName == u"satMod" || rName == u"lum"
+               || rName == u"lumOff" || rName == u"lumMod";
+    };
+    for (auto it = rPropSeq.begin(); it < rPropSeq.end(); ++it)
+    {
+        if (isValidPropName((*it).Name))
+        {
+            uno::Sequence<beans::PropertyValue> aValueSeq;
+            sal_Int32 nNumber(0); // dummy value to make compiler happy, "val" should exist
+            if (((*it).Value >>= aValueSeq)
+                && lcl_getAttributeAsNumber(aValueSeq, u"val"_ustr, nNumber))
+            {
+                // char w14:alpha contains transparency, whereas shape fill a:alpha contains opacity.
+                if ((*it).Name == u"alpha")
+                    rColor.addTransformation(
+                        oox::NMSP_dml | oox::AttributeConversion::decodeToken((*it).Name),
+                        oox::drawingml::MAX_PERCENT - nNumber);
+                else
+                    rColor.addTransformation(
+                        oox::NMSP_w14 | oox::AttributeConversion::decodeToken((*it).Name), nNumber);
+            }
+        }
+    }
+}
+
+// Expected: rPropSeq contains a property "schemeClr" or a property "srgbClr".
+bool lcl_getColorFromPropSeq(const uno::Sequence<beans::PropertyValue>& rPropSeq,
+                             oox::drawingml::Color& rColor)
+{
+    bool bColorFound = false;
+    comphelper::SequenceAsHashMap aPropMap(rPropSeq);
+    uno::Sequence<beans::PropertyValue> aColorDetailSeq;
+    if (aPropMap.getValue(u"schemeClr"_ustr) >>= aColorDetailSeq)
+    {
+        OUString sColorString;
+        bColorFound = lcl_getAttributeAsString(aColorDetailSeq, u"val"_ustr, sColorString);
+        if (bColorFound)
+        {
+            sal_Int32 nColorToken = oox::AttributeConversion::decodeToken(sColorString);
+            rColor.setSchemeClr(nColorToken);
+            rColor.setSchemeName(sColorString);
+        }
+    }
+    if (!bColorFound && (aPropMap.getValue(u"srgbClr"_ustr) >>= aColorDetailSeq))
+    {
+        OUString sColorString;
+        bColorFound = lcl_getAttributeAsString(aColorDetailSeq, u"val"_ustr, sColorString);
+        if (bColorFound)
+        {
+            sal_Int32 nColor = oox::AttributeConversion::decodeIntegerHex(sColorString);
+            rColor.setSrgbClr(nColor);
+        }
+    }
+    // Without color, color transformations are pointless.
+    if (bColorFound)
+        lcl_getColorTransformationsFromPropSeq(aColorDetailSeq, rColor);
+    return bColorFound;
+}
+
+void lcl_getFillDetailsFromPropSeq(const uno::Sequence<beans::PropertyValue>& rTextFillSeq,
+                                   oox::drawingml::FillProperties& rFillProperties)
+{
+    // rTextFillSeq should have an item containing either "noFill" or "solidFill" or "gradFill"
+    // property.
+    if (!rTextFillSeq.hasElements())
+        return;
+    comphelper::SequenceAsHashMap aTextFillMap(rTextFillSeq);
+    if (aTextFillMap.find(u"noFill"_ustr) != aTextFillMap.end())
+    {
+        rFillProperties.moFillType = oox::XML_noFill;
+        return;
+    }
+
+    uno::Sequence<beans::PropertyValue> aPropSeq;
+    if ((aTextFillMap.getValue(u"solidFill"_ustr) >>= aPropSeq) && aPropSeq.hasElements())
+    {
+        rFillProperties.moFillType = oox::XML_solidFill;
+        lcl_getColorFromPropSeq(aPropSeq, rFillProperties.maFillColor);
+        return;
+    }
+
+    if ((aTextFillMap.getValue(u"gradFill"_ustr) >>= aPropSeq) && aPropSeq.hasElements())
+    {
+        rFillProperties.moFillType = oox::XML_gradFill;
+        // aPropSeq should have two items. One is "gsLst" for the stop colors, the other is
+        // either "lin" or "path" for the kind of gradient.
+        // First get stop colors
+        comphelper::SequenceAsHashMap aPropMap(aPropSeq);
+        uno::Sequence<beans::PropertyValue> aGsLstSeq;
+        if (aPropMap.getValue("gsLst") >>= aGsLstSeq)
+        {
+            for (auto it = aGsLstSeq.begin(); it < aGsLstSeq.end(); ++it)
+            {
+                // (*it) is a bean::PropertyValue with Name="gs". Its Value is a property sequence.
+                uno::Sequence<beans::PropertyValue> aColorStopSeq;
+                if ((*it).Value >>= aColorStopSeq)
+                {
+                    // aColorStopSeq should have an item for the color and an item for the position
+                    sal_Int32 nPos;
+                    oox::drawingml::Color aColor;
+                    if (lcl_getAttributeAsNumber(aColorStopSeq, u"pos"_ustr, nPos)
+                        && lcl_getColorFromPropSeq(aColorStopSeq, aColor))
+                    {
+                        // The position in maGradientStops is relative, thus in range [0.0;1.0].
+                        double fPos = nPos / 100000.0;
+                        rFillProperties.maGradientProps.maGradientStops.insert({ fPos, aColor });
+                    }
+                }
+            }
+        }
+        // Now determine kind of gradient.
+        uno::Sequence<beans::PropertyValue> aKindSeq;
+        if (aPropMap.getValue("lin") >>= aKindSeq)
+        {
+            // aKindSeq contains the attributes "ang" and "scaled"
+            sal_Int32 nAngle; // in 1/60000 deg
+            if (lcl_getAttributeAsNumber(aKindSeq, "ang", nAngle))
+                rFillProperties.maGradientProps.moShadeAngle = nAngle;
+            OUString sScaledString;
+            if (lcl_getAttributeAsString(aKindSeq, "scaled", sScaledString))
+                rFillProperties.maGradientProps.moShadeScaled
+                    = sScaledString == u"1" || sScaledString == u"true";
+            return;
+        }
+        if (aPropMap.getValue("path") >>= aKindSeq)
+        {
+            // aKindSeq contains the attribute "path" for the kind of path and a property "fillToRect"
+            // which defines the center rectangle of the gradient. The property "a:tileRect" known from
+            // fill of shapes does not exist in w14 namespace.
+            OUString sKind;
+            if (lcl_getAttributeAsString(aKindSeq, "path", sKind))
+                rFillProperties.maGradientProps.moGradientPath
+                    = oox::AttributeConversion::decodeToken(sKind);
+            comphelper::SequenceAsHashMap aKindMap(aKindSeq);
+            uno::Sequence<beans::PropertyValue> aFillToRectSeq;
+            if (aKindMap.getValue("fillToRect") >>= aFillToRectSeq)
+            {
+                // The values l, t, r and b are not coordinates, but determine an offset from the
+                // edge of the bounding box of the shape. This unusual meaning of X1, Y1, X2 and
+                // Y2 is needed for method pushToPropMap() of FillProperties.
+                geometry::IntegerRectangle2D aRect;
+                if (!lcl_getAttributeAsNumber(aFillToRectSeq, u"l"_ustr, aRect.X1))
+                    aRect.X1 = 0;
+                if (!lcl_getAttributeAsNumber(aFillToRectSeq, u"t"_ustr, aRect.Y1))
+                    aRect.Y1 = 0;
+                if (!lcl_getAttributeAsNumber(aFillToRectSeq, u"r"_ustr, aRect.X2))
+                    aRect.X2 = 0;
+                if (!lcl_getAttributeAsNumber(aFillToRectSeq, u"b"_ustr, aRect.Y2))
+                    aRect.Y2 = 0;
+                rFillProperties.maGradientProps.moFillToRect = aRect;
+            }
+        }
+        return;
+    }
+}
+
+void lcl_getLineDetailsFromPropSeq(const uno::Sequence<beans::PropertyValue>& rTextOutlineSeq,
+                                   oox::drawingml::LineProperties& rLineProperties)
+{
+    if (!rTextOutlineSeq.hasElements())
+    {
+        rLineProperties.maLineFill.moFillType = oox::XML_noFill; // MS Office default
+        return;
+    }
+    // aTextOulineSeq contains e.g. "attributes" {w, cap, cmpd, ctr}, either
+    // "solidFill" or "gradFill or "noFill", and "prstDash" and "lineJoint" properties.
+
+    // Fill
+    lcl_getFillDetailsFromPropSeq(rTextOutlineSeq, rLineProperties.maLineFill);
+
+    // LineJoint
+    comphelper::SequenceAsHashMap aTextOutlineMap(rTextOutlineSeq);
+    if (aTextOutlineMap.find(u"bevel"_ustr) != aTextOutlineMap.end())
+        rLineProperties.moLineJoint = oox::XML_bevel;
+    else if (aTextOutlineMap.find(u"round"_ustr) != aTextOutlineMap.end())
+        rLineProperties.moLineJoint = oox::XML_round;
+    else if (aTextOutlineMap.find(u"miter"_ustr) != aTextOutlineMap.end())
+    {
+        // LineProperties has no member to store a miter limit. Therefore some heuristic is
+        // added here. 0 is default for attribute "lim" in MS Office. It is rendered same as bevel.
+        sal_Int32 nMiterLimit = aTextOutlineMap.getUnpackedValueOrDefault("lim", sal_Int32(0));
+        if (nMiterLimit == 0)
+            rLineProperties.moLineJoint = oox::XML_bevel;
+        else
+            rLineProperties.moLineJoint = oox::XML_miter;
+    }
+
+    // Dash
+    uno::Sequence<beans::PropertyValue> aDashSeq;
+    if (aTextOutlineMap.getValue(u"prstDash"_ustr) >>= aDashSeq)
+    {
+        // aDashSeq contains the attribute "val" with the kind of dash, e.g. "sysDot"
+        OUString sDashKind;
+        if (lcl_getAttributeAsString(aDashSeq, u"val"_ustr, sDashKind))
+            rLineProperties.moPresetDash = oox::AttributeConversion::decodeToken(sDashKind);
+    }
+    OUString sCapKind;
+    if (lcl_getAttributeAsString(rTextOutlineSeq, u"cap"_ustr, sCapKind))
+        rLineProperties.moLineCap = oox::AttributeConversion::decodeToken(sCapKind);
+
+    // Width
+    sal_Int32 nWidth; // EMU
+    if (lcl_getAttributeAsNumber(rTextOutlineSeq, u"w"_ustr, nWidth))
+        rLineProperties.moLineWidth = nWidth;
+
+    // Compound. LineProperties has a member for it, however Fontwork can currently only render "sng".
+    OUString sCompoundKind;
+    if (lcl_getAttributeAsString(rTextOutlineSeq, u"cmpd"_ustr, sCompoundKind))
+        rLineProperties.moLineCompound = oox::AttributeConversion::decodeToken(sCompoundKind);
+
+    // Align. LineProperties has no member for attribute "algn".
+
+    return;
+}
+
+oox::drawingml::LineProperties
+lcl_generateLinePropertiesFromTextProps(const comphelper::SequenceAsHashMap& aTextPropMap)
+{
+    oox::drawingml::LineProperties aLineProperties;
+    aLineProperties.maLineFill.moFillType = oox::XML_noFill; // default
+
+    // Get property "textOutline" from aTextPropMap
+    uno::Sequence<beans::PropertyValue> aCharInteropGrabBagSeq;
+    if (!(aTextPropMap.getValue(u"CharInteropGrabBag"_ustr) >>= aCharInteropGrabBagSeq))
+        return aLineProperties;
+    if (!aCharInteropGrabBagSeq.hasElements())
+        return aLineProperties;
+    comphelper::SequenceAsHashMap aCharInteropGrabBagMap(aCharInteropGrabBagSeq);
+    beans::PropertyValue aProp;
+    if (!(aCharInteropGrabBagMap.getValue(u"CharTextOutlineTextEffect"_ustr) >>= aProp))
+        return aLineProperties;
+    uno::Sequence<beans::PropertyValue> aTextOutlineSeq;
+    if (!(aProp.Name == "textOutline" && (aProp.Value >>= aTextOutlineSeq)
+          && aTextOutlineSeq.hasElements()))
+        return aLineProperties;
+
+    // Copy line properties from aTextOutlineSeq to aLineProperties
+    lcl_getLineDetailsFromPropSeq(aTextOutlineSeq, aLineProperties);
+    return aLineProperties;
+}
+
+oox::drawingml::FillProperties
+lcl_generateFillPropertiesFromTextProps(const comphelper::SequenceAsHashMap& rTextPropMap)
+{
+    oox::drawingml::FillProperties aFillProperties;
+    aFillProperties.moFillType = oox::XML_solidFill; // default
+    // Theme color supersedes direct color. textFill supersedes theme color. Theme color and textFill
+    // are in CharInteropGrabBag.
+    uno::Sequence<beans::PropertyValue> aCharInteropGrabBagSeq;
+    if ((rTextPropMap.getValue(u"CharInteropGrabBag"_ustr) >>= aCharInteropGrabBagSeq)
+        && aCharInteropGrabBagSeq.hasElements())
+    {
+        // Handle case textFill
+        comphelper::SequenceAsHashMap aCharInteropGrabBagMap(aCharInteropGrabBagSeq);
+        beans::PropertyValue aProp;
+        if (aCharInteropGrabBagMap.getValue(u"CharTextFillTextEffect"_ustr) >>= aProp)
+        {
+            uno::Sequence<beans::PropertyValue> aTextFillSeq;
+            if (aProp.Name == "textFill" && (aProp.Value >>= aTextFillSeq)
+                && aTextFillSeq.hasElements())
+            {
+                // Copy fill properties from aTextFillSeq to aFillProperties
+                lcl_getFillDetailsFromPropSeq(aTextFillSeq, aFillProperties);
+                return aFillProperties;
+            }
+        }
+
+        // no textFill, look for theme color, tint and shade
+        bool bColorFound(false);
+        OUString sColorString;
+        if (aCharInteropGrabBagMap.getValue("CharThemeOriginalColor") >>= sColorString)
+        {
+            sal_Int32 nThemeOrigColor = oox::AttributeConversion::decodeIntegerHex(sColorString);
+            aFillProperties.maFillColor.setSrgbClr(nThemeOrigColor);
+            bColorFound = true;
+        }
+        if (aCharInteropGrabBagMap.getValue("CharThemeColor") >>= sColorString)
+        {
+            sal_Int32 nColorToken = oox::AttributeConversion::decodeToken(sColorString);
+            aFillProperties.maFillColor.setSchemeClr(nColorToken);
+            aFillProperties.maFillColor.setSchemeName(sColorString);
+            bColorFound = true;
+            // A character color has shade or tint, a shape color has lumMod and lumOff.
+            OUString sTransformString;
+            if (aCharInteropGrabBagMap.getValue("CharThemeColorTint") >>= sTransformString)
+            {
+                double fTint = oox::AttributeConversion::decodeIntegerHex(sTransformString);
+                fTint = fTint / 255.0 * oox::drawingml::MAX_PERCENT;
+                aFillProperties.maFillColor.addTransformation(OOX_TOKEN(w14, lumMod),
+                                                              static_cast<sal_Int32>(fTint + 0.5));
+                double fOff = oox::drawingml::MAX_PERCENT - fTint;
+                aFillProperties.maFillColor.addTransformation(OOX_TOKEN(w14, lumOff),
+                                                              static_cast<sal_Int32>(fOff + 0.5));
+            }
+            else if (aCharInteropGrabBagMap.getValue("CharThemeColorShade") >>= sTransformString)
+            {
+                double fShade = oox::AttributeConversion::decodeIntegerHex(sTransformString);
+                fShade = fShade / 255.0 * oox::drawingml::MAX_PERCENT;
+                aFillProperties.maFillColor.addTransformation(OOX_TOKEN(w14, lumMod),
+                                                              static_cast<sal_Int32>(fShade + 0.5));
+            }
+        }
+        if (bColorFound)
+            return aFillProperties;
+    }
+
+    // Neither textFill nor theme color. Look for direct color.
+    sal_Int32 aCharColor = 0;
+    if (rTextPropMap.getValue(u"CharColor"_ustr) >>= aCharColor)
+        aFillProperties.maFillColor.setSrgbClr(aCharColor);
+    else
+        aFillProperties.maFillColor.setUnused();
+    return aFillProperties;
+}
+
+void lcl_applyShapePropsToShape(const uno::Reference<beans::XPropertySet>& xShapePropertySet,
+                                const oox::drawingml::ShapePropertyMap& rShapeProps)
+{
+    for (const auto& rProp : rShapeProps.makePropertyValueSequence())
+    {
+        xShapePropertySet->setPropertyValue(rProp.Name, rProp.Value);
+    }
+}
+
+void lcl_setTextAnchorFromTextProps(const uno::Reference<beans::XPropertySet>& xShapePropertySet,
+                                    const comphelper::SequenceAsHashMap& aTextPropMap)
+{
+    // Fontwork does not evaluate paragraph alignment but uses text anchor instead
+    auto eHorzAdjust(drawing::TextHorizontalAdjust_CENTER);
+    sal_Int16 nParaAlign = sal_Int16(drawing::TextHorizontalAdjust_CENTER);
+    aTextPropMap.getValue("ParaAdjust") >>= nParaAlign;
+    switch (nParaAlign)
+    {
+        case sal_Int16(style::ParagraphAdjust_LEFT):
+            eHorzAdjust = drawing::TextHorizontalAdjust_LEFT;
+            break;
+        case sal_Int16(style::ParagraphAdjust_RIGHT):
+            eHorzAdjust = drawing::TextHorizontalAdjust_RIGHT;
+            break;
+        default:
+            eHorzAdjust = drawing::TextHorizontalAdjust_CENTER;
+    }
+    xShapePropertySet->setPropertyValue("TextHorizontalAdjust", uno::Any(eHorzAdjust));
+    xShapePropertySet->setPropertyValue("TextVerticalAdjust",
+                                        uno::Any(drawing::TextVerticalAdjust_TOP));
+}
+
+void lcl_setTextPropsToShape(const uno::Reference<beans::XPropertySet>& xShapePropertySet,
+                             std::vector<beans::PropertyValue>& aTextPropVec)
+{
+    auto xShapePropertySetInfo = xShapePropertySet->getPropertySetInfo();
+    if (!xShapePropertySetInfo.is())
+        return;
+    for (size_t i = 0; i < aTextPropVec.size(); ++i)
+    {
+        if (xShapePropertySetInfo->hasPropertyByName(aTextPropVec[i].Name)
+            && !(xShapePropertySetInfo->getPropertyByName(aTextPropVec[i].Name).Attributes
+                 & beans::PropertyAttribute::READONLY)
+            && aTextPropVec[i].Name != u"CharInteropGrabBag")
+        {
+            xShapePropertySet->setPropertyValue(aTextPropVec[i].Name, aTextPropVec[i].Value);
+        }
+    }
+}
+
+void lcl_applyUsedTextPropsToAllTextRuns(uno::Reference<text::XText>& xText,
+                                         const std::vector<beans::PropertyValue>& aTextPropVec)
+{
+    if (!xText.is())
+        return;
+    uno::Reference<text::XTextCursor> xTextCursor = xText->createTextCursor();
+    xTextCursor->gotoStart(false);
+    xTextCursor->gotoEnd(true);
+    uno::Reference<container::XEnumerationAccess> paraEnumAccess(xText, uno::UNO_QUERY);
+    if (!paraEnumAccess.is())
+        return;
+    uno::Reference<container::XEnumeration> paraEnum(paraEnumAccess->createEnumeration());
+    while (paraEnum->hasMoreElements())
+    {
+        uno::Reference<text::XTextRange> xParagraph(paraEnum->nextElement(), uno::UNO_QUERY);
+        uno::Reference<container::XEnumerationAccess> runEnumAccess(xParagraph, uno::UNO_QUERY);
+        if (!runEnumAccess.is())
+            continue;
+        uno::Reference<container::XEnumeration> runEnum = runEnumAccess->createEnumeration();
+        while (runEnum->hasMoreElements())
+        {
+            uno::Reference<text::XTextRange> xRun(runEnum->nextElement(), uno::UNO_QUERY);
+            if (xRun->getString().isEmpty())
+                continue;
+            uno::Reference<beans::XPropertySet> xRunPropSet(xRun, uno::UNO_QUERY);
+            if (!xRunPropSet.is())
+                continue;
+            auto xRunPropSetInfo = xRunPropSet->getPropertySetInfo();
+            if (!xRunPropSetInfo.is())
+                continue;
+
+            for (size_t i = 0; i < aTextPropVec.size(); ++i)
+            {
+                if (xRunPropSetInfo->hasPropertyByName(aTextPropVec[i].Name)
+                    && !(xRunPropSetInfo->getPropertyByName(aTextPropVec[i].Name).Attributes
+                         & beans::PropertyAttribute::READONLY))
+                    xRunPropSet->setPropertyValue(aTextPropVec[i].Name, aTextPropVec[i].Value);
+            }
+        }
+    }
+}
+} // anonymous namespace
+
+namespace oox::shape
+{
+WpsContext::WpsContext(ContextHandler2Helper const& rParent, uno::Reference<drawing::XShape> xShape,
+                       const drawingml::ShapePtr& pMasterShapePtr,
+                       const drawingml::ShapePtr& pShapePtr)
+    : ShapeContext(rParent, pMasterShapePtr, pShapePtr)
+    , mxShape(std::move(xShape))
+{
+    if (mpShapePtr)
+        mpShapePtr->setWps(true);
+
+    if (const auto pParent = dynamic_cast<const WpgContext*>(&rParent))
+        m_bHasWPGParent = pParent->isFullWPGSupport();
+    else if (dynamic_cast<const WordprocessingCanvasContext*>(&rParent))
+        m_bHasWPGParent = true;
+    else
+        m_bHasWPGParent = false;
+
+    if ((pMasterShapePtr && pMasterShapePtr->isInWordprocessingCanvas())
+        || dynamic_cast<const WordprocessingCanvasContext*>(&rParent) != nullptr)
+        pShapePtr->setWordprocessingCanvas(true);
+}
+
+WpsContext::~WpsContext() = default;
+
+oox::core::ContextHandlerRef WpsContext::onCreateContext(sal_Int32 nElementToken,
+                                                         const oox::AttributeList& rAttribs)
+{
+    switch (getBaseToken(nElementToken))
+    {
+        case XML_wsp:
+            break;
+        case XML_cNvCnPr:
+        {
+            // It might be a connector shape in a wordprocessing canvas
+            // Replace the custom shape with a connector shape.
+            if (!mpShapePtr || !mpShapePtr->isInWordprocessingCanvas() || !mpMasterShapePtr)
+                break;
+            // Generate new shape
+            oox::drawingml::ShapePtr pShape = std::make_shared<oox::drawingml::Shape>(
+                "com.sun.star.drawing.ConnectorShape", false);
+            pShape->setConnectorShape(true);
+            pShape->setWps(true);
+            pShape->setWordprocessingCanvas(true);
+            // ToDo: Can only copy infos from mpShapePtr to pShape for which getter available.
+            pShape->setName(mpShapePtr->getName());
+            pShape->setId(mpShapePtr->getId());
+            pShape->setWPGChild(mpShapePtr->isWPGChild());
+            // And actually replace the shape.
+            mpShapePtr = pShape;
+            mpMasterShapePtr->getChildren().pop_back();
+            mpMasterShapePtr->getChildren().push_back(pShape);
+            return new oox::drawingml::ConnectorShapePropertiesContext(
+                *this, mpShapePtr, mpShapePtr->getConnectorShapeProperties());
+        }
+        case XML_bodyPr:
+            if (mxShape.is())
+            {
+                // no evaluation of attribute XML_rot, because Word ignores it, as of 2022-07.
+
+                uno::Reference<lang::XServiceInfo> xServiceInfo(mxShape, uno::UNO_QUERY);
+                uno::Reference<beans::XPropertySet> xPropertySet(mxShape, uno::UNO_QUERY);
+                sal_Int32 nVert = rAttribs.getToken(XML_vert, XML_horz);
+                // Values 'wordArtVert' and 'wordArtVertRtl' are not implemented.
+                // Map them to other vert values.
+                if (nVert == XML_eaVert || nVert == XML_wordArtVertRtl)
+                {
+                    xPropertySet->setPropertyValue("TextWritingMode",
+                                                   uno::Any(text::WritingMode_TB_RL));
+                    xPropertySet->setPropertyValue("WritingMode",
+                                                   uno::Any(text::WritingMode2::TB_RL));
+                }
+                else if (nVert == XML_mongolianVert || nVert == XML_wordArtVert)
+                {
+                    xPropertySet->setPropertyValue("WritingMode",
+                                                   uno::Any(text::WritingMode2::TB_LR));
+                }
+                else if (nVert != XML_horz) // cases XML_vert and XML_vert270
+                {
+                    // Hack to get same rendering as after the fix for tdf#87924. If shape rotation
+                    // plus text direction results in upright text, use horizontal text direction.
+                    // Remove hack when frame is able to rotate.
+
+                    // Need transformation matrix since RotateAngle does not contain flip.
+                    drawing::HomogenMatrix3 aMatrix;
+                    xPropertySet->getPropertyValue("Transformation") >>= aMatrix;
+                    basegfx::B2DHomMatrix aTransformation;
+                    aTransformation.set(0, 0, aMatrix.Line1.Column1);
+                    aTransformation.set(0, 1, aMatrix.Line1.Column2);
+                    aTransformation.set(0, 2, aMatrix.Line1.Column3);
+                    aTransformation.set(1, 0, aMatrix.Line2.Column1);
+                    aTransformation.set(1, 1, aMatrix.Line2.Column2);
+                    aTransformation.set(1, 2, aMatrix.Line2.Column3);
+                    // For this to be a valid 2D transform matrix, the last row must be [0,0,1]
+                    assert(aMatrix.Line3.Column1 == 0);
+                    assert(aMatrix.Line3.Column2 == 0);
+                    assert(aMatrix.Line3.Column3 == 1);
+                    basegfx::B2DTuple aScale;
+                    basegfx::B2DTuple aTranslate;
+                    double fRotate = 0;
+                    double fShearX = 0;
+                    aTransformation.decompose(aScale, aTranslate, fRotate, fShearX);
+                    auto nRotate(static_cast<sal_uInt16>(NormAngle360(basegfx::rad2deg(fRotate))));
+                    if ((nVert == XML_vert && nRotate == 270)
+                        || (nVert == XML_vert270 && nRotate == 90))
+                    {
+                        xPropertySet->setPropertyValue("WritingMode",
+                                                       uno::Any(text::WritingMode2::LR_TB));
+                        // ToDo: Remember original vert value and remove hack on export.
+                    }
+                    else if (nVert == XML_vert)
+                        xPropertySet->setPropertyValue("WritingMode",
+                                                       uno::Any(text::WritingMode2::TB_RL90));
+                    else // nVert == XML_vert270
+                        xPropertySet->setPropertyValue("WritingMode",
+                                                       uno::Any(text::WritingMode2::BT_LR));
+                }
+
+                if (bool bUpright = rAttribs.getBool(XML_upright, false))
+                {
+                    uno::Sequence<beans::PropertyValue> aGrabBag;
+                    xPropertySet->getPropertyValue("InteropGrabBag") >>= aGrabBag;
+                    sal_Int32 length = aGrabBag.getLength();
+                    aGrabBag.realloc(length + 1);
+                    auto pGrabBag = aGrabBag.getArray();
+                    pGrabBag[length].Name = "Upright";
+                    pGrabBag[length].Value <<= bUpright;
+                    xPropertySet->setPropertyValue("InteropGrabBag", uno::Any(aGrabBag));
+                }
+
+                if (xServiceInfo.is())
+                {
+                    // Handle inset attributes for Writer textframes.
+                    sal_Int32 aInsets[] = { XML_lIns, XML_tIns, XML_rIns, XML_bIns };
+                    std::optional<sal_Int32> oInsets[4];
+                    for (std::size_t i = 0; i < SAL_N_ELEMENTS(aInsets); ++i)
+                    {
+                        std::optional<OUString> oValue = rAttribs.getString(aInsets[i]);
+                        if (oValue.has_value())
+                            oInsets[i] = oox::drawingml::GetCoordinate(oValue.value());
+                        else
+                            // Defaults from the spec: left/right: 91440 EMU, top/bottom: 45720 EMU
+                            oInsets[i]
+                                = (aInsets[i] == XML_lIns || aInsets[i] == XML_rIns) ? 254 : 127;
+                    }
+                    const OUString aShapeProps[]
+                        = { OUString("TextLeftDistance"), OUString("TextUpperDistance"),
+                            OUString("TextRightDistance"), OUString("TextLowerDistance") };
+                    for (std::size_t i = 0; i < SAL_N_ELEMENTS(aShapeProps); ++i)
+                        if (oInsets[i])
+                            xPropertySet->setPropertyValue(aShapeProps[i], uno::Any(*oInsets[i]));
+                }
+
+                // Handle text vertical adjustment inside a text frame
+                if (rAttribs.hasAttribute(XML_anchor))
+                {
+                    drawing::TextVerticalAdjust eAdjust
+                        = drawingml::GetTextVerticalAdjust(rAttribs.getToken(XML_anchor, XML_t));
+                    xPropertySet->setPropertyValue("TextVerticalAdjust", uno::Any(eAdjust));
+                }
+
+                // Apply character color of the shape to the shape's textbox.
+                uno::Reference<text::XText> xText(mxShape, uno::UNO_QUERY);
+                uno::Any xCharColor = xPropertySet->getPropertyValue("CharColor");
+                Color aColor = COL_AUTO;
+                if ((xCharColor >>= aColor) && aColor != COL_AUTO)
+                {
+                    // tdf#135923 Apply character color of the shape to the textrun
+                    //            when the character color of the textrun is default.
+                    // tdf#153791 But only if the run has no background color (shd element in OOXML)
+                    if (uno::Reference<container::XEnumerationAccess> paraEnumAccess{
+                            xText, uno::UNO_QUERY })
+                    {
+                        uno::Reference<container::XEnumeration> paraEnum(
+                            paraEnumAccess->createEnumeration());
+
+                        while (paraEnum->hasMoreElements())
+                        {
+                            uno::Reference<text::XTextRange> xParagraph(paraEnum->nextElement(),
+                                                                        uno::UNO_QUERY);
+                            uno::Reference<container::XEnumerationAccess> runEnumAccess(
+                                xParagraph, uno::UNO_QUERY);
+                            if (!runEnumAccess.is())
+                                continue;
+                            if (uno::Reference<beans::XPropertySet> xParaPropSet{ xParagraph,
+                                                                                  uno::UNO_QUERY })
+                                if ((xParaPropSet->getPropertyValue("ParaBackColor") >>= aColor)
+                                    && aColor != COL_AUTO)
+                                    continue;
+
+                            uno::Reference<container::XEnumeration> runEnum
+                                = runEnumAccess->createEnumeration();
+
+                            while (runEnum->hasMoreElements())
+                            {
+                                uno::Reference<text::XTextRange> xRun(runEnum->nextElement(),
+                                                                      uno::UNO_QUERY);
+                                const uno::Reference<beans::XPropertyState> xRunState(
+                                    xRun, uno::UNO_QUERY);
+                                if (!xRunState
+                                    || xRunState->getPropertyState("CharColor")
+                                           == beans::PropertyState_DEFAULT_VALUE)
+                                {
+                                    uno::Reference<beans::XPropertySet> xRunPropSet(xRun,
+                                                                                    uno::UNO_QUERY);
+                                    if (!xRunPropSet)
+                                        continue;
+                                    if ((xRunPropSet->getPropertyValue("CharBackColor") >>= aColor)
+                                        && aColor != COL_AUTO)
+                                        continue;
+                                    if (!(xRunPropSet->getPropertyValue("CharColor") >>= aColor)
+                                        || aColor == COL_AUTO)
+                                        xRunPropSet->setPropertyValue("CharColor", xCharColor);
+                                }
+                            }
+                        }
+                    }
+                }
+
+                auto nWrappingType = rAttribs.getToken(XML_wrap, XML_square);
+                xPropertySet->setPropertyValue("TextWordWrap",
+                                               uno::Any(nWrappingType == XML_square));
+
+                return this;
+            }
+            else if (m_bHasWPGParent && mpShapePtr)
+            {
+                // this WPS context has to be inside a WPG shape, so the <BodyPr> element
+                // cannot be applied to mxShape member, use mpShape instead, and after the
+                // the parent shape finished, apply it for its children.
+                mpShapePtr->setWPGChild(true);
+                oox::drawingml::TextBodyPtr pTextBody;
+                pTextBody.reset(new oox::drawingml::TextBody());
+
+                if (rAttribs.hasAttribute(XML_anchor))
+                {
+                    drawing::TextVerticalAdjust eAdjust
+                        = drawingml::GetTextVerticalAdjust(rAttribs.getToken(XML_anchor, XML_t));
+                    pTextBody->getTextProperties().meVA = eAdjust;
+                }
+
+                sal_Int32 aInsets[] = { XML_lIns, XML_tIns, XML_rIns, XML_bIns };
+                for (int i = 0; i < 4; ++i)
+                {
+                    if (rAttribs.hasAttribute(XML_lIns))
+                    {
+                        std::optional<OUString> oValue = rAttribs.getString(aInsets[i]);
+                        if (oValue.has_value())
+                            pTextBody->getTextProperties().moInsets[i]
+                                = oox::drawingml::GetCoordinate(oValue.value());
+                        else
+                            // Defaults from the spec: left/right: 91440 EMU, top/bottom: 45720 EMU
+                            pTextBody->getTextProperties().moInsets[i]
+                                = (aInsets[i] == XML_lIns || aInsets[i] == XML_rIns) ? 254 : 127;
+                    }
+                }
+
+                mpShapePtr->setTextBody(pTextBody);
+            }
+            break;
+        case XML_noAutofit:
+        case XML_spAutoFit:
+        {
+            uno::Reference<lang::XServiceInfo> xServiceInfo(mxShape, uno::UNO_QUERY);
+            // We can't use oox::drawingml::TextBodyPropertiesContext here, as this
+            // is a child context of bodyPr, so the shape is already sent: we need
+            // to alter the XShape directly.
+            uno::Reference<beans::XPropertySet> xPropertySet(mxShape, uno::UNO_QUERY);
+            if (xPropertySet.is())
+            {
+                if (xServiceInfo->supportsService("com.sun.star.text.TextFrame"))
+                    xPropertySet->setPropertyValue(
+                        "FrameIsAutomaticHeight",
+                        uno::Any(getBaseToken(nElementToken) == XML_spAutoFit));
+                else
+                    xPropertySet->setPropertyValue(
+                        "TextAutoGrowHeight",
+                        uno::Any(getBaseToken(nElementToken) == XML_spAutoFit));
+            }
+        }
+        break;
+        case XML_prstTxWarp:
+            if (rAttribs.hasAttribute(XML_prst))
+            {
+                uno::Reference<beans::XPropertySet> xPropertySet(mxShape, uno::UNO_QUERY);
+                if (xPropertySet.is())
+                {
+                    std::optional<OUString> presetShapeName = rAttribs.getString(XML_prst);
+                    const OUString& preset = presetShapeName.value();
+                    comphelper::SequenceAsHashMap aCustomShapeGeometry(
+                        xPropertySet->getPropertyValue("CustomShapeGeometry"));
+                    aCustomShapeGeometry["PresetTextWarp"] <<= preset;
+                    xPropertySet->setPropertyValue(
+                        "CustomShapeGeometry",
+                        uno::Any(aCustomShapeGeometry.getAsConstPropertyValueList()));
+                }
+            }
+            return new oox::drawingml::PresetTextShapeContext(
+                *this, rAttribs, *(getShape()->getCustomShapeProperties()));
+        case XML_txbx:
+        {
+            mpShapePtr->getCustomShapeProperties()->setShapeTypeOverride(true);
+            mpShapePtr->setTextBox(true);
+            //in case if the textbox is linked, save the attributes
+            //for further processing.
+            if (rAttribs.hasAttribute(XML_id))
+            {
+                std::optional<OUString> id = rAttribs.getString(XML_id);
+                if (id.has_value())
+                {
+                    oox::drawingml::LinkedTxbxAttr linkedTxtBoxAttr;
+                    linkedTxtBoxAttr.id = id.value().toInt32();
+                    mpShapePtr->setTxbxHasLinkedTxtBox(true);
+                    mpShapePtr->setLinkedTxbxAttributes(linkedTxtBoxAttr);
+                }
+            }
+            return this;
+        }
+        break;
+        case XML_linkedTxbx:
+        {
+            //in case if the textbox is linked, save the attributes
+            //for further processing.
+            mpShapePtr->getCustomShapeProperties()->setShapeTypeOverride(true);
+            mpShapePtr->setTextBox(true);
+            std::optional<OUString> id = rAttribs.getString(XML_id);
+            std::optional<OUString> seq = rAttribs.getString(XML_seq);
+            if (id.has_value() && seq.has_value())
+            {
+                oox::drawingml::LinkedTxbxAttr linkedTxtBoxAttr;
+                linkedTxtBoxAttr.id = id.value().toInt32();
+                linkedTxtBoxAttr.seq = seq.value().toInt32();
+                mpShapePtr->setTxbxHasLinkedTxtBox(true);
+                mpShapePtr->setLinkedTxbxAttributes(linkedTxtBoxAttr);
+            }
+        }
+        break;
+        default:
+            return ShapeContext::onCreateContext(nElementToken, rAttribs);
+    }
+    return nullptr;
+}
+
+void WpsContext::onEndElement()
+{
+    // Convert shape to Fontwork shape if necessary and meaningful.
+    // Only at end of bodyPr all needed info is available.
+
+    if (getBaseToken(getCurrentElement()) != XML_bodyPr)
+        return;
+
+    // Make sure all needed parts are available
+    auto* pCustomShape
+        = dynamic_cast<SdrObjCustomShape*>(SdrObject::getSdrObjectFromXShape(mxShape));
+    if (!pCustomShape || !mpShapePtr || !mxShape.is())
+        return;
+    uno::Reference<beans::XPropertySet> xShapePropertySet(mxShape, uno::UNO_QUERY);
+    if (!xShapePropertySet.is())
+        return;
+    // This is the text in the frame, associated with the shape
+    uno::Reference<text::XText> xText(mxShape, uno::UNO_QUERY);
+    if (!xText.is())
+        return;
+
+    OUString sMSPresetType;
+    comphelper::SequenceAsHashMap aCustomShapeGeometry(
+        xShapePropertySet->getPropertyValue("CustomShapeGeometry"));
+    aCustomShapeGeometry["PresetTextWarp"] >>= sMSPresetType;
+    if (sMSPresetType.isEmpty() || sMSPresetType == u"textNoShape")
+        return;
+
+    // Word can combine its "abc Transform" with a lot of shape types. LibreOffice can only render
+    // the old kind WordArt, which is based on a rectangle. In case of non rectangular shape we keep
+    // the shape and do not convert the text to Fontwork.
+    OUString sType;
+    aCustomShapeGeometry["Type"] >>= sType;
+    if (sType != u"ooxml-rect")
+        return;
+
+    // Copy properties from frame text to have them available after the frame is removed.
+    std::vector<beans::PropertyValue> aTextPropVec;
+    if (!lcl_getTextPropsFromFrameText(xText, aTextPropVec))
+        return;
+    comphelper::SequenceAsHashMap aTextPropMap(comphelper::containerToSequence(aTextPropVec));
+
+    // Copy text content from frame to shape. Since Fontwork uses simple text anyway, we can use
+    // a string.
+    OUString sFrameContent(xText->getString());
+    pCustomShape->NbcSetText(sFrameContent);
+
+    // Setting the property "TextBox" to false includes removing the attached frame from the shape.
+    xShapePropertySet->setPropertyValue("TextBox", uno::Any(false));
+
+    // Set the shape into text path mode, so that the text is drawn as Fontwork. Word renders a legacy
+    // "text on path" without the legacy stretching, therefore use false for bFromWordArt.
+    mpShapePtr->getCustomShapeProperties()->setShapeTypeOverride(true);
+    FontworkHelpers::putCustomShapeIntoTextPathMode(mxShape, getShape()->getCustomShapeProperties(),
+                                                    sMSPresetType, /*bFromWordArt*/ false);
+
+    // Apply the text props to the fontwork shape
+    lcl_setTextPropsToShape(xShapePropertySet, aTextPropVec); // includes e.g. FontName
+    lcl_setTextAnchorFromTextProps(xShapePropertySet, aTextPropMap);
+
+    // Fontwork in LO uses fill and stroke of the shape and cannot style text portions individually.
+    // "abc Transform" in Word uses fill and outline of the characters.
+    // We need to copy the properties from a run to the shape.
+    oox::drawingml::ShapePropertyMap aStrokeShapeProps(getFilter().getModelObjectHelper());
+    oox::drawingml::LineProperties aCreatedLineProperties
+        = lcl_generateLinePropertiesFromTextProps(aTextPropMap);
+    aCreatedLineProperties.pushToPropMap(aStrokeShapeProps, getFilter().getGraphicHelper());
+    lcl_applyShapePropsToShape(xShapePropertySet, aStrokeShapeProps);
+
+    oox::drawingml::ShapePropertyMap aFillShapeProps(getFilter().getModelObjectHelper());
+    oox::drawingml::FillProperties aCreatedFillProperties
+        = lcl_generateFillPropertiesFromTextProps(aTextPropMap);
+    aCreatedFillProperties.pushToPropMap(aFillShapeProps, getFilter().getGraphicHelper(),
+                                         /*nShapeRotation*/ 0,
+                                         /*nPhClr*/ API_RGB_TRANSPARENT,
+                                         /*aShapeSize*/ css::awt::Size(0, 0), /*nPhClrTheme*/ -1,
+                                         pCustomShape->IsMirroredX(), pCustomShape->IsMirroredY(),
+                                         /*bIsCustomShape*/ true);
+    lcl_applyShapePropsToShape(xShapePropertySet, aFillShapeProps);
+
+    // Copying the text content from frame to shape as string has lost the styles. Apply the used text
+    // properties back to all runs in the text.
+    uno::Reference<text::XText> xNewText(pCustomShape->getUnoShape(), uno::UNO_QUERY);
+    if (xNewText.is())
+        lcl_applyUsedTextPropsToAllTextRuns(xNewText, aTextPropVec);
+
+    // Fontwork stretches the text to the given path. So adapt shape size to text is nonsensical.
+    xShapePropertySet->setPropertyValue("TextAutoGrowHeight", uno::Any(false));
+    xShapePropertySet->setPropertyValue("TextAutoGrowWidth", uno::Any(false));
+}
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */