/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * This file is part of the LibreOffice project.

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 * This file incorporates work covered by the following license notice:

 *

 *   Licensed to the Apache Software Foundation (ASF) under one or more

 *   contributor license agreements. See the NOTICE file distributed

 *   with this work for additional information regarding copyright

 *   ownership. The ASF licenses this file to you under the Apache

 *   License, Version 2.0 (the "License"); you may not use this file

 *   except in compliance with the License. You may obtain a copy of

 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .

 */

#include <config_wasm_strip.h>

#include <sal/config.h>

#include <sal/log.hxx>

#include <filter/msfilter/util.hxx>

#include <o3tl/string_view.hxx>

#include <o3tl/any.hxx>

#include <oox/core/xmlfilterbase.hxx>

#include <oox/export/shapes.hxx>

#include <oox/export/utils.hxx>

#include <oox/token/namespaces.hxx>

#include <oox/token/relationship.hxx>

#include <oox/token/tokens.hxx>

#include <initializer_list>

#include <string_view>

#include <com/sun/star/beans/PropertyValues.hpp>

#include <com/sun/star/beans/XPropertySet.hpp>

#include <com/sun/star/beans/XPropertySetInfo.hpp>

#include <com/sun/star/beans/XPropertyState.hpp>

#include <com/sun/star/container/XChild.hpp>

#include <com/sun/star/document/XExporter.hpp>

#include <com/sun/star/document/XStorageBasedDocument.hpp>

#include <com/sun/star/drawing/CircleKind.hpp>

#include <com/sun/star/drawing/FillStyle.hpp>

#include <com/sun/star/drawing/ConnectorType.hpp>

#include <com/sun/star/drawing/EnhancedCustomShapeParameterPair.hpp>

#include <com/sun/star/drawing/EnhancedCustomShapeParameterType.hpp>

#include <com/sun/star/embed/Aspects.hpp>

#include <com/sun/star/embed/EmbedStates.hpp>

#include <com/sun/star/embed/XEmbeddedObject.hpp>

#include <com/sun/star/embed/XEmbedPersist.hpp>

#include <com/sun/star/embed/WrongStateException.hpp>

#include <com/sun/star/frame/XStorable.hpp>

#include <com/sun/star/graphic/XGraphic.hpp>

#include <com/sun/star/i18n/ScriptType.hpp>

#include <com/sun/star/io/XOutputStream.hpp>

#include <com/sun/star/text/XSimpleText.hpp>

#include <com/sun/star/text/XText.hpp>

#include <com/sun/star/table/XTable.hpp>

#include <com/sun/star/table/XMergeableCell.hpp>

#include <com/sun/star/chart2/XChartDocument.hpp>

#include <com/sun/star/frame/XModel.hpp>

#include <com/sun/star/uno/XComponentContext.hpp>

#include <com/sun/star/drawing/XDrawPages.hpp>

#include <com/sun/star/drawing/XDrawPagesSupplier.hpp>

#include <com/sun/star/presentation/ClickAction.hpp>

#include <com/sun/star/drawing/XGluePointsSupplier.hpp>

#include <com/sun/star/container/XIdentifierAccess.hpp>

#include <com/sun/star/table/BorderLineStyle.hpp>

#include <tools/globname.hxx>

#include <comphelper/classids.hxx>

#include <comphelper/propertysequence.hxx>

#include <comphelper/storagehelper.hxx>

#include <comphelper/memorystream.hxx>

#include <sot/exchange.hxx>

#include <utility>

#include <vcl/graph.hxx>

#include <vcl/outdev.hxx>

#include <filter/msfilter/escherex.hxx>

#include <svtools/embedhlp.hxx>

#include <svx/svdoashp.hxx>

#include <svx/svdoole2.hxx>

#include <comphelper/diagnose_ex.hxx>

#include <oox/export/chartexport.hxx>

#include <oox/mathml/imexport.hxx>

#include <basegfx/numeric/ftools.hxx>

#include <oox/export/DMLPresetShapeExport.hxx>

#include <frozen/bits/defines.h>

#include <frozen/bits/elsa_std.h>

#include <frozen/set.h>

#include <frozen/unordered_map.h>

#include <sax/fastattribs.hxx>

#include <tools/fract.hxx>

using namespace ::css;

using namespace ::css::beans;

using namespace ::css::uno;

using namespace ::css::drawing;

using namespace ::css::table;

using namespace ::css::container;

using namespace ::css::document;

using namespace ::css::text;

using ::css::io::XOutputStream;

using ::css::chart2::XChartDocument;

using ::css::frame::XModel;

using ::oox::core::XmlFilterBase;

using ::sax_fastparser::FSHelperPtr;

namespace oox {

static void lcl_ConvertProgID(std::u16string_view rProgID,

    OUString & o_rMediaType, OUString & o_rRelationType, OUString & o_rFileExtension)

{

    if (rProgID == u"Excel.Sheet.12")

    {

        o_rMediaType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";

        o_rRelationType = oox::getRelationship(Relationship::PACKAGE);

        o_rFileExtension = "xlsx";

    }

    else if (o3tl::starts_with(rProgID, u"Excel.SheetBinaryMacroEnabled.12") )

    {

        o_rMediaType = "application/vnd.ms-excel.sheet.binary.macroEnabled.12";

        o_rRelationType = oox::getRelationship(Relationship::PACKAGE);

        o_rFileExtension = "xlsb";

    }

    else if (o3tl::starts_with(rProgID, u"Excel.SheetMacroEnabled.12"))

    {

        o_rMediaType = "application/vnd.ms-excel.sheet.macroEnabled.12";

        o_rRelationType = oox::getRelationship(Relationship::PACKAGE);

        o_rFileExtension = "xlsm";

    }

    else if (o3tl::starts_with(rProgID, u"Excel.Sheet"))

    {

        o_rMediaType = "application/vnd.ms-excel";

        o_rRelationType = oox::getRelationship(Relationship::OLEOBJECT);

        o_rFileExtension = "xls";

    }

    else if (rProgID == u"PowerPoint.Show.12")

    {

        o_rMediaType = "application/vnd.openxmlformats-officedocument.presentationml.presentation";

        o_rRelationType = oox::getRelationship(Relationship::PACKAGE);

        o_rFileExtension = "pptx";

    }

    else if (rProgID == u"PowerPoint.ShowMacroEnabled.12")

    {

        o_rMediaType = "application/vnd.ms-powerpoint.presentation.macroEnabled.12";

        o_rRelationType = oox::getRelationship(Relationship::PACKAGE);

        o_rFileExtension = "pptm";

    }

    else if (o3tl::starts_with(rProgID, u"PowerPoint.Show"))

    {

        o_rMediaType = "application/vnd.ms-powerpoint";

        o_rRelationType = oox::getRelationship(Relationship::OLEOBJECT);

        o_rFileExtension = "ppt";

    }

    else if (o3tl::starts_with(rProgID, u"PowerPoint.Slide.12"))

    {

       o_rMediaType = "application/vnd.openxmlformats-officedocument.presentationml.slide";

       o_rRelationType = oox::getRelationship(Relationship::PACKAGE);

       o_rFileExtension = "sldx";

    }

    else if (rProgID == u"PowerPoint.SlideMacroEnabled.12")

    {

       o_rMediaType = "application/vnd.ms-powerpoint.slide.macroEnabled.12";

       o_rRelationType = oox::getRelationship(Relationship::PACKAGE);

       o_rFileExtension = "sldm";

    }

    else if (rProgID == u"Word.DocumentMacroEnabled.12")

    {

        o_rMediaType = "application/vnd.ms-word.document.macroEnabled.12";

        o_rRelationType = oox::getRelationship(Relationship::PACKAGE);

        o_rFileExtension = "docm";

    }

    else if (rProgID == u"Word.Document.12")

    {

        o_rMediaType = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";

        o_rRelationType = oox::getRelationship(Relationship::PACKAGE);

        o_rFileExtension = "docx";

    }

    else if (rProgID == u"Word.Document.8")

    {

        o_rMediaType = "application/msword";

        o_rRelationType = oox::getRelationship(Relationship::OLEOBJECT);

        o_rFileExtension = "doc";

    }

    else if (rProgID == u"Excel.Chart.8")

    {

        o_rMediaType = "application/vnd.ms-excel";

        o_rRelationType = oox::getRelationship(Relationship::OLEOBJECT);

        o_rFileExtension = "xls";

    }

    else if (rProgID == u"AcroExch.Document.11")

    {

        o_rMediaType = "application/pdf";

        o_rRelationType = oox::getRelationship(Relationship::OLEOBJECT);

        o_rFileExtension = "pdf";

    }

    else

    {

        o_rMediaType = "application/vnd.openxmlformats-officedocument.oleObject";

        o_rRelationType = oox::getRelationship(Relationship::OLEOBJECT);

        o_rFileExtension = "bin";

    }

}

static uno::Reference<io::XInputStream> lcl_StoreOwnAsOOXML(

    uno::Reference<embed::XEmbeddedObject> const& xObj,

    char const*& o_rpProgID,

    OUString & o_rMediaType, OUString & o_rRelationType, OUString & o_rSuffix)

{

    static struct {

        struct {

            sal_uInt32 n1;

            sal_uInt16 n2, n3;

            sal_uInt8 b8, b9, b10, b11, b12, b13, b14, b15;

        } ClassId;

        char const* pFilterName;

        char const* pMediaType;

        char const* pProgID;

        char const* pSuffix;

    } const s_Mapping[] = {

        { {SO3_SW_CLASSID_60}, "MS Word 2007 XML", "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "Word.Document.12", "docx" },

        { {SO3_SC_CLASSID_60}, "Calc MS Excel 2007 XML", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Excel.Sheet.12", "xlsx" },

        { {SO3_SIMPRESS_CLASSID_60}, "Impress MS PowerPoint 2007 XML", "application/vnd.openxmlformats-officedocument.presentationml.presentation", "PowerPoint.Show.12", "pptx" },

        { {SO3_SDRAW_CLASSID}, "draw8", "application/vnd.oasis.opendocument.graphics", "LibreOffice.DrawDocument.1", "odg" },

        { {SO3_SCH_CLASSID_60}, "unused", "", "", "" },

        { {SO3_SM_CLASSID_60}, "unused", "", "", "" },

    };

    const char * pFilterName(nullptr);

    SvGlobalName const classId(xObj->getClassID());

    for (auto & i : s_Mapping)

    {

        auto const& rId(i.ClassId);

        SvGlobalName const temp(rId.n1, rId.n2, rId.n3, rId.b8, rId.b9, rId.b10, rId.b11, rId.b12, rId.b13, rId.b14, rId.b15);

        if (temp == classId)

        {

            assert(SvGlobalName(SO3_SCH_CLASSID_60) != classId); // chart should be written elsewhere!

            assert(SvGlobalName(SO3_SM_CLASSID_60) != classId); // formula should be written elsewhere!

            pFilterName = i.pFilterName;

            o_rMediaType = OUString::createFromAscii(i.pMediaType);

            o_rpProgID = i.pProgID;

            o_rSuffix = OUString::createFromAscii(i.pSuffix);

            o_rRelationType = oox::getRelationship(Relationship::PACKAGE);

            break;

        }

    }

    if (!pFilterName)

    {

        SAL_WARN("oox.shape", "oox::GetOLEObjectStream: unknown ClassId " << classId.GetHexName());

        return nullptr;

    }

    if (embed::EmbedStates::LOADED == xObj->getCurrentState())

    {

        xObj->changeState(embed::EmbedStates::RUNNING);

    }

    // use a temp stream - while it would work to store directly to a

    // fragment stream, an error during export means we'd have to delete it

    rtl::Reference< comphelper::UNOMemoryStream > xTempStream = new comphelper::UNOMemoryStream();

    uno::Sequence<beans::PropertyValue> args( comphelper::InitPropertySequence({

            { "OutputStream", Any(xTempStream->getOutputStream()) },

            { "FilterName", Any(OUString::createFromAscii(pFilterName)) }

        }));

    uno::Reference<frame::XStorable> xStorable(xObj->getComponent(), uno::UNO_QUERY);

    try

    {

        xStorable->storeToURL(u"private:stream"_ustr, args);

    }

    catch (uno::Exception const&)

    {

        TOOLS_WARN_EXCEPTION("oox.shape", "oox::GetOLEObjectStream");

        return nullptr;

    }

    xTempStream->getOutputStream()->closeOutput();

    return xTempStream->getInputStream();

}

uno::Reference<io::XInputStream> GetOLEObjectStream(

        uno::Reference<embed::XEmbeddedObject> const& xObj,

        std::u16string_view i_rProgID,

        OUString & o_rMediaType,

        OUString & o_rRelationType,

        OUString & o_rSuffix,

        const char *& o_rpProgID)

{

    uno::Reference<io::XInputStream> xInStream;

    try

    {

        uno::Reference<document::XStorageBasedDocument> const xParent(

            uno::Reference<container::XChild>(xObj, uno::UNO_QUERY_THROW)->getParent(),

            uno::UNO_QUERY_THROW);

        uno::Reference<embed::XStorage> const xParentStorage(xParent->getDocumentStorage());

        OUString const entryName(

            uno::Reference<embed::XEmbedPersist>(xObj, uno::UNO_QUERY_THROW)->getEntryName());

        if (xParentStorage->isStreamElement(entryName))

        {

            lcl_ConvertProgID(i_rProgID, o_rMediaType, o_rRelationType, o_rSuffix);

            xInStream = xParentStorage->cloneStreamElement(entryName)->getInputStream();

            // TODO: make it possible to take the sMediaType from the stream

        }

        else // the object is ODF - either the whole document is

        {    // ODF, or the OLE was edited so it was converted to ODF

            xInStream = lcl_StoreOwnAsOOXML(xObj,

                    o_rpProgID, o_rMediaType, o_rRelationType, o_rSuffix);

        }

    }

    catch (uno::Exception const&)

    {

        TOOLS_WARN_EXCEPTION("oox.shape", "oox::GetOLEObjectStream");

    }

    return xInStream;

}

} // namespace oox

namespace oox::drawingml {

ShapeExport::ShapeExport( sal_Int32 nXmlNamespace, FSHelperPtr pFS, ShapeHashMap* pShapeMap, XmlFilterBase* pFB, DocumentType eDocumentType, DMLTextExport* pTextExport, bool bUserShapes )

    : DrawingML( std::move(pFS), pFB, eDocumentType, pTextExport )

    , mnShapeIdMax( 1 )

    , mbUserShapes( bUserShapes )

    , mnXmlNamespace( nXmlNamespace )

    , maMapModeSrc( MapUnit::Map100thMM )

    , maMapModeDest( MapUnit::MapInch, Point(), 1.0 / 576, 1.0 / 576 )

    , mpShapeMap( pShapeMap ? pShapeMap : &maShapeMap )

{

    mpURLTransformer = std::make_shared<URLTransformer>();

}

void ShapeExport::SetURLTranslator(const std::shared_ptr<URLTransformer>& pTransformer)

{

    mpURLTransformer = pTransformer;

}

awt::Size ShapeExport::MapSize( const awt::Size& rSize ) const

{

    Size aRetSize( OutputDevice::LogicToLogic( Size( rSize.Width, rSize.Height ), maMapModeSrc, maMapModeDest ) );

    if ( !aRetSize.Width() )

        aRetSize.AdjustWidth( 1 );

    if ( !aRetSize.Height() )

        aRetSize.AdjustHeight( 1 );

    return awt::Size( aRetSize.Width(), aRetSize.Height() );

}

static bool IsNonEmptySimpleText(const Reference<XInterface>& xIface)

{

    if (Reference<XSimpleText> xText{ xIface, UNO_QUERY })

        return xText->getString().getLength();

    return false;

}

bool ShapeExport::NonEmptyText( const Reference< XInterface >& xIface )

{

    Reference< XPropertySet > xPropSet( xIface, UNO_QUERY );

    if( xPropSet.is() )

    {

        Reference< XPropertySetInfo > xPropSetInfo = xPropSet->getPropertySetInfo();

        if ( xPropSetInfo.is() )

        {

            if ( xPropSetInfo->hasPropertyByName( u"IsEmptyPresentationObject"_ustr ) )

            {

                bool bIsEmptyPresObj = false;

                if ( xPropSet->getPropertyValue( u"IsEmptyPresentationObject"_ustr ) >>= bIsEmptyPresObj )

                {

                    SAL_INFO("oox.shape", "empty presentation object " << bIsEmptyPresObj << " , props:");

                    if( bIsEmptyPresObj )

                       return true;

                }

            }

            if ( xPropSetInfo->hasPropertyByName( u"IsPresentationObject"_ustr ) )

            {

                bool bIsPresObj = false;

                if ( xPropSet->getPropertyValue( u"IsPresentationObject"_ustr ) >>= bIsPresObj )

                {

                    SAL_INFO("oox.shape", "presentation object " << bIsPresObj << ", props:");

                    if( bIsPresObj )

                       return true;

                }

            }

        }

    }

    return IsNonEmptySimpleText(xIface);

}

static void AddExtLst(FSHelperPtr const& pFS, Reference<XPropertySet> const& xShape)

{

    if (xShape->getPropertySetInfo()->hasPropertyByName(u"Decorative"_ustr)

        && xShape->getPropertyValue(u"Decorative"_ustr).get<bool>())

    {

        pFS->startElementNS(XML_a, XML_extLst);

//            FSNS(XML_xmlns, XML_a), GetExport().GetFilter().getNamespaceURL(OOX_NS(dml)));

        pFS->startElementNS(XML_a, XML_ext,

            // MSO uses this "URI" which is obviously not a URI

            XML_uri, "{C183D7F6-B498-43B3-948B-1728B52AA6E4}");

        pFS->singleElementNS(XML_adec, XML_decorative,

            FSNS(XML_xmlns, XML_adec), "http://schemas.microsoft.com/office/drawing/2017/decorative",

            XML_val, "1");

        pFS->endElementNS(XML_a, XML_ext);

        pFS->endElementNS(XML_a, XML_extLst);

    }

}

ShapeExport& ShapeExport::WritePolyPolygonShape( const Reference< XShape >& xShape, const bool bClosed )

{

    SAL_INFO("oox.shape", "write polypolygon shape");

    FSHelperPtr pFS = GetFS();

    pFS->startElementNS(mnXmlNamespace, (GetDocumentType() != DOCUMENT_DOCX || mbUserShapes ? XML_sp : XML_wsp));

    awt::Point aPos = xShape->getPosition();

    // Position is relative to group for child elements in Word, but absolute in API.

    if (GetDocumentType() == DOCUMENT_DOCX && !mbUserShapes && m_xParent.is())

    {

        awt::Point aParentPos = m_xParent->getPosition();

        aPos.X -= aParentPos.X;

        aPos.Y -= aParentPos.Y;

    }

    awt::Size aSize = xShape->getSize();

    tools::Rectangle aRect(Point(aPos.X, aPos.Y), Size(aSize.Width, aSize.Height));

#if OSL_DEBUG_LEVEL > 0

    tools::PolyPolygon aPolyPolygon = EscherPropertyContainer::GetPolyPolygon(xShape);

    awt::Size size = MapSize( awt::Size( aRect.GetWidth(), aRect.GetHeight() ) );

    SAL_INFO("oox.shape", "poly count " << aPolyPolygon.Count());

    SAL_INFO("oox.shape", "size: " << size.Width << " x " << size.Height);

#endif

    Reference<XPropertySet> const xProps(xShape, UNO_QUERY);

    // non visual shape properties

    if (GetDocumentType() != DOCUMENT_DOCX || mbUserShapes)

    {

        pFS->startElementNS(mnXmlNamespace, XML_nvSpPr);

        pFS->startElementNS(mnXmlNamespace, XML_cNvPr,

                              XML_id, OString::number(GetNewShapeID(xShape)),

                              XML_name, GetShapeName(xShape));

        AddExtLst(pFS, xProps);

        pFS->endElementNS(mnXmlNamespace, XML_cNvPr);

    }

    pFS->singleElementNS(mnXmlNamespace, XML_cNvSpPr);

    if (GetDocumentType() != DOCUMENT_DOCX || mbUserShapes)

    {

        WriteNonVisualProperties( xShape );

        pFS->endElementNS( mnXmlNamespace, XML_nvSpPr );

    }

    // visual shape properties

    pFS->startElementNS(mnXmlNamespace, XML_spPr);

    WriteTransformation( xShape, aRect, XML_a );

    WritePolyPolygon(xShape, bClosed);

    if( xProps.is() ) {

        if( bClosed )

            WriteFill(xProps, aSize);

        WriteOutline( xProps );

    }

    pFS->endElementNS( mnXmlNamespace, XML_spPr );

    // write text

    WriteTextBox( xShape, mnXmlNamespace );

    pFS->endElementNS( mnXmlNamespace, (GetDocumentType() != DOCUMENT_DOCX || mbUserShapes ? XML_sp : XML_wsp) );

    return *this;

}

ShapeExport& ShapeExport::WriteClosedPolyPolygonShape( const Reference< XShape >& xShape )

{

    return WritePolyPolygonShape( xShape, true );

}

ShapeExport& ShapeExport::WriteOpenPolyPolygonShape( const Reference< XShape >& xShape )

{

    return WritePolyPolygonShape( xShape, false );

}

ShapeExport& ShapeExport::WriteGroupShape(const uno::Reference<drawing::XShape>& xShape)

{

    FSHelperPtr pFS = GetFS();

    sal_Int32 nGroupShapeToken = XML_grpSp;

    if (GetDocumentType() == DOCUMENT_DOCX && !mbUserShapes)

    {

        if (!m_xParent.is())

            nGroupShapeToken = XML_wgp; // toplevel

        else

            mnXmlNamespace = XML_wpg;

    }

    pFS->startElementNS(mnXmlNamespace, nGroupShapeToken);

    // non visual properties

    if (GetDocumentType() != DOCUMENT_DOCX || mbUserShapes)

    {

        pFS->startElementNS(mnXmlNamespace, XML_nvGrpSpPr);

        pFS->startElementNS(mnXmlNamespace, XML_cNvPr,

                XML_id, OString::number(GetNewShapeID(xShape)),

                XML_name, GetShapeName(xShape));

        uno::Reference<beans::XPropertySet> const xShapeProps(xShape, uno::UNO_QUERY_THROW);

        AddExtLst(pFS, xShapeProps);

        pFS->endElementNS(mnXmlNamespace, XML_cNvPr);

        pFS->singleElementNS(mnXmlNamespace, XML_cNvGrpSpPr);

        WriteNonVisualProperties(xShape );

        pFS->endElementNS(mnXmlNamespace, XML_nvGrpSpPr);

    }

    else

        pFS->singleElementNS(mnXmlNamespace, XML_cNvGrpSpPr);

    // visual properties

    pFS->startElementNS(mnXmlNamespace, XML_grpSpPr);

    WriteShapeTransformation(xShape, XML_a, false, false, true);

    pFS->endElementNS(mnXmlNamespace, XML_grpSpPr);

    uno::Reference<drawing::XShapes> xGroupShape(xShape, uno::UNO_QUERY_THROW);

    uno::Reference<drawing::XShape> xParent = m_xParent;

    m_xParent = xShape;

    for (sal_Int32 i = 0; i < xGroupShape->getCount(); ++i)

    {

        uno::Reference<drawing::XShape> xChild(xGroupShape->getByIndex(i), uno::UNO_QUERY_THROW);

        sal_Int32 nSavedNamespace = mnXmlNamespace;

        uno::Reference<lang::XServiceInfo> xServiceInfo(xChild, uno::UNO_QUERY_THROW);

        if (GetDocumentType() == DOCUMENT_DOCX && !mbUserShapes)

        {

            // tdf#128820: WriteGraphicObjectShapePart calls WriteTextShape for non-empty simple

            // text objects, which needs writing into wps::wsp element, so make sure to use wps

            // namespace for those objects

            if (xServiceInfo->supportsService(u"com.sun.star.drawing.GraphicObjectShape"_ustr)

                && !IsNonEmptySimpleText(xChild))

                mnXmlNamespace = XML_pic;

            else

                mnXmlNamespace = XML_wps;

        }

        WriteShape(xChild);

        mnXmlNamespace = nSavedNamespace;

    }

    m_xParent = std::move(xParent);

    pFS->endElementNS(mnXmlNamespace, nGroupShapeToken);

    return *this;

}

namespace

{

constexpr frozen::set<std::u16string_view, 57> constDenySet(

{

    u"block-arc",

    u"rectangle",

    u"ellipse",

    u"ring",

    u"can",

    u"cube",

    u"paper",

    u"frame",

    u"forbidden",

    u"smiley",

    u"sun",

    u"flower",

    u"bracket-pair",

    u"brace-pair",

    u"quad-bevel",

    u"round-rectangular-callout",

    u"rectangular-callout",

    u"round-callout",

    u"cloud-callout",

    u"line-callout-1",

    u"line-callout-2",

    u"line-callout-3",

    u"paper",

    u"vertical-scroll",

    u"horizontal-scroll",

    u"mso-spt34",

    u"mso-spt75",

    u"mso-spt164",

    u"mso-spt180",

    u"flowchart-process",

    u"flowchart-alternate-process",

    u"flowchart-decision",

    u"flowchart-data",

    u"flowchart-predefined-process",

    u"flowchart-internal-storage",

    u"flowchart-document",

    u"flowchart-multidocument",

    u"flowchart-terminator",

    u"flowchart-preparation",

    u"flowchart-manual-input",

    u"flowchart-manual-operation",

    u"flowchart-connector",

    u"flowchart-off-page-connector",

    u"flowchart-card",

    u"flowchart-punched-tape",

    u"flowchart-summing-junction",

    u"flowchart-or",

    u"flowchart-collate",

    u"flowchart-sort",

    u"flowchart-extract",

    u"flowchart-merge",

    u"flowchart-stored-data",

    u"flowchart-delay",

    u"flowchart-sequential-access",

    u"flowchart-magnetic-disk",

    u"flowchart-direct-access-storage",

    u"flowchart-display"

});

constexpr frozen::set<std::u16string_view, 6> constAllowSet(

{

    u"heart",

    u"puzzle",

    u"col-60da8460",

    u"col-502ad400",

    u"sinusoid",

    u"mso-spt100"

});

} // end anonymous namespace

static bool lcl_IsOnDenylist(OUString const & rShapeType)

{

    return constDenySet.find(rShapeType) != constDenySet.end();

}

static bool lcl_IsOnAllowlist(OUString const & rShapeType)

{

    return constAllowSet.find(rShapeType) != constAllowSet.end();

}

static bool lcl_GetHandlePosition( sal_Int32 &nValue, const EnhancedCustomShapeParameter &rParam, const Sequence< EnhancedCustomShapeAdjustmentValue > &rSeq)

{

    bool bAdj = false;

    if ( rParam.Value.getValueTypeClass() == TypeClass_DOUBLE )

    {

        double fValue(0.0);

        if ( rParam.Value >>= fValue )

            nValue = static_cast<sal_Int32>(fValue);

    }

    else

        rParam.Value >>= nValue;

    if ( rParam.Type == EnhancedCustomShapeParameterType::ADJUSTMENT)

    {

        bAdj = true;

        sal_Int32 nIdx = nValue;

        if ( nIdx < rSeq.getLength() )

        {

            if ( rSeq[ nIdx ] .Value.getValueTypeClass() == TypeClass_DOUBLE )

            {

                double fValue(0.0);

                rSeq[ nIdx ].Value >>= fValue;

                nValue = fValue;

            }

            else

            {

                rSeq[ nIdx ].Value >>= nValue;

            }

        }

    }

    return bAdj;

}

static void lcl_AnalyzeHandles( const uno::Sequence<beans::PropertyValues> & rHandles,

        std::vector< std::pair< sal_Int32, sal_Int32> > &rHandlePositionList,

        const Sequence< EnhancedCustomShapeAdjustmentValue > &rSeq)

{

    for ( const Sequence< PropertyValue >& rPropSeq : rHandles )

    {

        static constexpr OUStringLiteral sPosition( u"Position"  );

        bool bPosition = false;

        EnhancedCustomShapeParameterPair aPosition;

        for ( const PropertyValue& rPropVal: rPropSeq )

        {

            if ( rPropVal.Name == sPosition )

            {

                if ( rPropVal.Value >>= aPosition )

                    bPosition = true;

            }

        }

        if ( bPosition )

        {

            sal_Int32 nXPosition = 0;

            sal_Int32 nYPosition = 0;

            // For polar handles, nXPosition is radius and nYPosition is angle

            lcl_GetHandlePosition( nXPosition, aPosition.First , rSeq );

            lcl_GetHandlePosition( nYPosition, aPosition.Second, rSeq );

            rHandlePositionList.emplace_back( nXPosition, nYPosition );

        }

    }

}

static void lcl_AppendAdjustmentValue( std::vector< std::pair< sal_Int32, sal_Int32> > &rAvList, sal_Int32 nAdjIdx, sal_Int32 nValue )

{

    rAvList.emplace_back( nAdjIdx , nValue );

}

static sal_Int32 lcl_NormalizeAngle( sal_Int32 nAngle )

{

    nAngle = nAngle % 360;

    return nAngle < 0 ? ( nAngle + 360 ) : nAngle ;

}

static sal_Int32 lcl_CircleAngle2CustomShapeEllipseAngleOOX(const sal_Int32 nInternAngle, const sal_Int32 nWidth, const sal_Int32 nHeight)

{

    if (nWidth != 0 || nHeight != 0)

    {

        double fAngle = basegfx::deg2rad<100>(nInternAngle); // intern 1/100 deg to rad

        fAngle = atan2(nHeight * sin(fAngle), nWidth * cos(fAngle)); // circle to ellipse

        fAngle = basegfx::rad2deg<60000>(fAngle); // rad to OOXML angle unit

        sal_Int32 nAngle = basegfx::fround(fAngle); // normalize

        nAngle = nAngle % 21600000;

        return nAngle < 0 ? (nAngle + 21600000) : nAngle;

    }

    else // should be handled by caller, dummy value

        return 0;

}

static OUString lcl_GetTarget(const css::uno::Reference<css::frame::XModel>& xModel,

                              std::u16string_view rURL)

{

    Reference<drawing::XDrawPagesSupplier> xDPS(xModel, uno::UNO_QUERY_THROW);

    Reference<drawing::XDrawPages> xDrawPages(xDPS->getDrawPages(), uno::UNO_SET_THROW);

    sal_uInt32 nPageCount = xDrawPages->getCount();

    OUString sTarget;

    for (sal_uInt32 i = 0; i < nPageCount; ++i)

    {

        Reference<XDrawPage> xDrawPage;

        xDrawPages->getByIndex(i) >>= xDrawPage;

        Reference<container::XNamed> xNamed(xDrawPage, UNO_QUERY);

        if (!xNamed)

            continue;

        OUString sSlideName = "#" + xNamed->getName();

        OUString sApiName = "#page" + OUString::number(i + 1);

        if (rURL == sSlideName || rURL == sApiName)

        {

            sTarget = "slide" + OUString::number(i + 1) + ".xml";

            break;

        }

        else // If URL is linked to a shape, assign it's slide as target

        {

            Reference<XShapes> xShapes = xDrawPage;

            sal_uInt32 nShapes = xShapes->getCount();

            for (sal_uInt32 j = 0; j < nShapes; j++)

            {

                Reference<XShape> xShape;

                xShapes->getByIndex(j) >>= xShape;

                Reference<container::XNamed> xName(xShape, UNO_QUERY);

                if (!xName)

                    continue;

                OUString sShapeName = "#" + xName->getName();

                if (rURL == sShapeName)

                {

                    sTarget = "slide" + OUString::number(i + 1) + ".xml";

                    break;

                }

            }

        }

    }

    return sTarget;

}

ShapeExport& ShapeExport::WriteCustomShape( const Reference< XShape >& xShape )

{

    SAL_INFO("oox.shape", "write custom shape");

    Reference< XPropertySet > rXPropSet( xShape, UNO_QUERY );

    // First check, if this is a Fontwork-shape. For DrawingML, such a shape is a

    // TextBox shape with body property prstTxWarp.

    if (IsFontworkShape(rXPropSet))

    {

        ShapeExport::WriteTextShape(xShape); // qualifier to prevent PowerPointShapeExport

        return *this;

    }

    bool bHasGeometrySeq(false);

    Sequence< PropertyValue > aGeometrySeq;

    OUString sShapeType(u"non-primitive"_ustr); // default in ODF

    if (GetProperty(rXPropSet, u"CustomShapeGeometry"_ustr))

    {

        SAL_INFO("oox.shape", "got custom shape geometry");

        if (mAny >>= aGeometrySeq)

        {

            bHasGeometrySeq = true;

            SAL_INFO("oox.shape", "got custom shape geometry sequence");

            for (const PropertyValue& rProp : aGeometrySeq)

            {

                SAL_INFO("oox.shape", "geometry property: " << rProp.Name);

                if (rProp.Name == "Type")

                    rProp.Value >>= sShapeType;

            }

        }

    }

    bool bPredefinedHandlesUsed = true;

    bool bHasHandles = false;

    ShapeFlag nMirrorFlags = ShapeFlag::NONE;

    MSO_SPT eShapeType = EscherPropertyContainer::GetCustomShapeType( xShape, nMirrorFlags, sShapeType );

    assert(dynamic_cast< SdrObjCustomShape* >(SdrObject::getSdrObjectFromXShape(xShape)) && "Not a SdrObjCustomShape (!)");

    SdrObjCustomShape& rSdrObjCustomShape(static_cast< SdrObjCustomShape& >(*SdrObject::getSdrObjectFromXShape(xShape)));

    const bool bIsDefaultObject(

        EscherPropertyContainer::IsDefaultObject(

            rSdrObjCustomShape,

            eShapeType));

    OString sPresetShape = msfilter::util::GetOOXMLPresetGeometry(sShapeType);

    SAL_INFO("oox.shape", "custom shape type: " << sShapeType << " ==> " << sPresetShape);

    sal_Int32 nAdjustmentValuesIndex = -1;

    awt::Rectangle aViewBox;

    uno::Sequence<beans::PropertyValues> aHandles;

    bool bFlipH = false;

    bool bFlipV = false;

    if (bHasGeometrySeq)

    {

        for (int i = 0; i < aGeometrySeq.getLength(); i++)

        {

                const PropertyValue& rProp = aGeometrySeq[ i ];

                SAL_INFO("oox.shape", "geometry property: " << rProp.Name);

                if ( rProp.Name == "MirroredX" )

                    rProp.Value >>= bFlipH;

                if ( rProp.Name == "MirroredY" )

                    rProp.Value >>= bFlipV;

                if ( rProp.Name == "AdjustmentValues" )

                    nAdjustmentValuesIndex = i;

                else if ( rProp.Name == "Handles" )

                {

                    rProp.Value >>= aHandles;

                    if ( aHandles.hasElements() )

                        bHasHandles = true;

                    if( !bIsDefaultObject )

                        bPredefinedHandlesUsed = false;

                    // TODO: update nAdjustmentsWhichNeedsToBeConverted here

                }

                else if ( rProp.Name == "ViewBox" )

                    rProp.Value >>= aViewBox;

        }

    }

    FSHelperPtr pFS = GetFS();

    // non visual shape properties

    if (GetDocumentType() != DOCUMENT_DOCX || mbUserShapes)

    {

        // get InteropGrabBag to export attributes stored in the grabbag

        uno::Sequence<beans::PropertyValue> aGrabBagProps;

        rXPropSet->getPropertyValue(u"InteropGrabBag"_ustr) >>= aGrabBagProps;

        bool bUseBackground = false;

        if (GetProperty(rXPropSet, u"FillUseSlideBackground"_ustr))

            mAny >>= bUseBackground;

        if (bUseBackground)

            mpFS->startElementNS(mnXmlNamespace, XML_sp, XML_useBgFill, "1");

        else

        {

            rtl::Reference<sax_fastparser::FastAttributeList> pAttrListSp

                = sax_fastparser::FastSerializerHelper::createAttrList();

            for (auto const& it : aGrabBagProps)

            {

                // export macro attribute of <sp> element

                if (it.Name == u"mso-sp-macro"_ustr)

                {

                    OUString sMacro;

                    it.Value >>= sMacro;

                    if (!sMacro.isEmpty())

                        pAttrListSp->add(XML_macro, sMacro);

                }

                // export textlink attribute of <sp> element

                if (it.Name == u"mso-sp-textlink"_ustr)

                {

                    OUString sTextLink;

                    it.Value >>= sTextLink;

                    if (!sTextLink.isEmpty())

                        pAttrListSp->add(XML_textlink, sTextLink);

                }

                // export fLocksText attribute of <sp> element

                if (it.Name == u"mso-sp-fLocksText"_ustr)

                {

                    bool bFLocksText = true; // default="true"

                    it.Value >>= bFLocksText;

                    pAttrListSp->add(XML_fLocksText, ToPsz10(bFLocksText));

                }

                // export fPublished attribute of <sp> element

                if (it.Name == u"mso-sp-fPublished"_ustr)