/* -*- 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 "XMLSectionExport.hxx"

#include <o3tl/any.hxx>

#include <rtl/ustring.hxx>

#include <rtl/ustrbuf.hxx>

#include <osl/diagnose.h>

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

#include <com/sun/star/lang/Locale.hpp>

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

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

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

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

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

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

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

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

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

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

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

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

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

#include <comphelper/base64.hxx>

#include <xmloff/xmltoken.hxx>

#include <xmloff/xmlnamespace.hxx>

#include <xmloff/families.hxx>

#include <xmloff/xmluconv.hxx>

#include <xmloff/namespacemap.hxx>

#include <xmloff/xmlexp.hxx>

#include <xmloff/xmlement.hxx>

#include <txtflde.hxx>

using namespace ::com::sun::star;

using namespace ::com::sun::star::text;

using namespace ::com::sun::star::uno;

using namespace ::xmloff::token;

using ::com::sun::star::beans::XPropertySet;

using ::com::sun::star::beans::PropertyValue;

using ::com::sun::star::beans::PropertyValues;

using ::com::sun::star::container::XIndexReplace;

using ::com::sun::star::container::XNameAccess;

using ::com::sun::star::container::XNamed;

using ::com::sun::star::lang::Locale;

XMLSectionExport::XMLSectionExport(

    SvXMLExport& rExp,

    XMLTextParagraphExport& rParaExp)

:   rExport(rExp)

,   rParaExport(rParaExp)

,   bHeadingDummiesExported( false )

{

}

void XMLSectionExport::ExportSectionStart(

    const Reference<XTextSection> & rSection,

    bool bAutoStyles)

{

    Reference<XPropertySet> xPropertySet(rSection, UNO_QUERY);

    // always export section (auto) style

    if (bAutoStyles)

    {

        // get PropertySet and add section style

        GetParaExport().Add( XmlStyleFamily::TEXT_SECTION, xPropertySet );

    }

    else

    {

        // always export section style

        GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_STYLE_NAME,

                                     GetParaExport().Find(

                                     XmlStyleFamily::TEXT_SECTION,

                                     xPropertySet, u""_ustr ) );

        // xml:id for RDF metadata

        GetExport().AddAttributeXmlId(rSection);

        // export index or regular section

        Reference<XDocumentIndex> xIndex;

        if (GetIndex(rSection, xIndex))

        {

            if (xIndex.is())

            {

                // we are an index

                ExportIndexStart(xIndex);

            }

            else

            {

                // we are an index header

                ExportIndexHeaderStart(rSection);

            }

        }

        else

        {

            // we are not an index

            ExportRegularSectionStart(rSection);

        }

    }

}

bool XMLSectionExport::GetIndex(

    const Reference<XTextSection> & rSection,

    Reference<XDocumentIndex> & rIndex)

{

    // first, reset result

    bool bRet = false;

    rIndex = nullptr;

    // get section Properties

    Reference<XPropertySet> xSectionPropSet(rSection, UNO_QUERY);

    // then check if this section happens to be inside an index

    if (xSectionPropSet->getPropertySetInfo()->

                                    hasPropertyByName(u"DocumentIndex"_ustr))

    {

        Any aAny = xSectionPropSet->getPropertyValue(u"DocumentIndex"_ustr);

        Reference<XDocumentIndex> xDocumentIndex;

        aAny >>= xDocumentIndex;

        // OK, are we inside of an index

        if (xDocumentIndex.is())

        {

            // is the enclosing index identical with "our" section?

            Reference<XPropertySet> xIndexPropSet(xDocumentIndex, UNO_QUERY);

            aAny = xIndexPropSet->getPropertyValue(u"ContentSection"_ustr);

            Reference<XTextSection> xEnclosingSection;

            aAny >>= xEnclosingSection;

            // if the enclosing section is "our" section, then we are an index!

            if (rSection == xEnclosingSection)

            {

                rIndex = std::move(xDocumentIndex);

                bRet = true;

            }

            // else: index header or regular section

            // is the enclosing index identical with the header section?

            aAny = xIndexPropSet->getPropertyValue(u"HeaderSection"_ustr);

            // now mis-named: contains header section

            aAny >>= xEnclosingSection;

            // if the enclosing section is "our" section, then we are an index!

            if (rSection == xEnclosingSection)

            {

                bRet = true;

            }

            // else: regular section

        }

        // else: we aren't even inside of an index

    }

    // else: we don't even know what an index is.

    return bRet;

}

void XMLSectionExport::ExportSectionEnd(

    const Reference<XTextSection> & rSection,

    bool bAutoStyles)

{

    // no end section for styles

    if (bAutoStyles)

        return;

    enum XMLTokenEnum eElement = XML_TOKEN_INVALID;

    // export index or regular section end

    Reference<XDocumentIndex> xIndex;

    if (GetIndex(rSection, xIndex))

    {

        if (xIndex.is())

        {

            // index end: close index body element

            GetExport().EndElement( XML_NAMESPACE_TEXT, XML_INDEX_BODY,

                                    true );

            GetExport().IgnorableWhitespace();

            switch (MapSectionType(xIndex->getServiceName()))

            {

                case TEXT_SECTION_TYPE_TOC:

                    eElement = XML_TABLE_OF_CONTENT;

                    break;

                case TEXT_SECTION_TYPE_ILLUSTRATION:

                    eElement = XML_ILLUSTRATION_INDEX;

                    break;

                case TEXT_SECTION_TYPE_ALPHABETICAL:

                    eElement = XML_ALPHABETICAL_INDEX;

                    break;

                case TEXT_SECTION_TYPE_TABLE:

                    eElement = XML_TABLE_INDEX;

                    break;

                case TEXT_SECTION_TYPE_OBJECT:

                    eElement = XML_OBJECT_INDEX;

                    break;

                case TEXT_SECTION_TYPE_USER:

                    eElement = XML_USER_INDEX;

                    break;

                case TEXT_SECTION_TYPE_BIBLIOGRAPHY:

                    eElement = XML_BIBLIOGRAPHY;

                    break;

                default:

                    OSL_FAIL("unknown index type");

                    // default: skip index!

                    break;

            }

        }

        else

        {

            eElement = XML_INDEX_TITLE;

        }

    }

    else

    {

        eElement = XML_SECTION;

    }

    if (XML_TOKEN_INVALID != eElement)

    {

        // any old attributes?

        GetExport().CheckAttrList();

        // element surrounded by whitespace

        GetExport().EndElement( XML_NAMESPACE_TEXT, eElement, true);

        GetExport().IgnorableWhitespace();

    }

    else

    {

        OSL_FAIL("Need element name!");

    }

    // else: autostyles -> ignore

}

void XMLSectionExport::ExportIndexStart(

    const Reference<XDocumentIndex> & rIndex)

{

    // get PropertySet

    Reference<XPropertySet> xPropertySet(rIndex, UNO_QUERY);

    switch (MapSectionType(rIndex->getServiceName()))

    {

        case TEXT_SECTION_TYPE_TOC:

            ExportTableOfContentStart(xPropertySet);

            break;

        case TEXT_SECTION_TYPE_ILLUSTRATION:

            ExportIllustrationIndexStart(xPropertySet);

            break;

        case TEXT_SECTION_TYPE_ALPHABETICAL:

            ExportAlphabeticalIndexStart(xPropertySet);

            break;

        case TEXT_SECTION_TYPE_TABLE:

            ExportTableIndexStart(xPropertySet);

            break;

        case TEXT_SECTION_TYPE_OBJECT:

            ExportObjectIndexStart(xPropertySet);

            break;

        case TEXT_SECTION_TYPE_USER:

            ExportUserIndexStart(xPropertySet);

            break;

        case TEXT_SECTION_TYPE_BIBLIOGRAPHY:

            ExportBibliographyStart(xPropertySet);

            break;

        default:

            // skip index

            OSL_FAIL("unknown index type");

            break;

    }

}

void XMLSectionExport::ExportIndexHeaderStart(

    const Reference<XTextSection> & rSection)

{

    // export name, dammit!

    Reference<XNamed> xName(rSection, UNO_QUERY);

    GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_NAME, xName->getName());

    Reference<XPropertySet> xPropSet(rSection, UNO_QUERY);

    Any aAny = xPropSet->getPropertyValue(u"IsProtected"_ustr);

    if (*o3tl::doAccess<bool>(aAny))

    {

        GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_PROTECTED, XML_TRUE);

    }

    // format already handled -> export only start element

    GetExport().StartElement( XML_NAMESPACE_TEXT, XML_INDEX_TITLE, true );

    GetExport().IgnorableWhitespace();

}

SvXMLEnumStringMapEntry<SectionTypeEnum> const aIndexTypeMap[] =

{

    ENUM_STRING_MAP_ENTRY( "com.sun.star.text.ContentIndex", TEXT_SECTION_TYPE_TOC ),

    ENUM_STRING_MAP_ENTRY( "com.sun.star.text.DocumentIndex", TEXT_SECTION_TYPE_ALPHABETICAL ),

    ENUM_STRING_MAP_ENTRY( "com.sun.star.text.TableIndex", TEXT_SECTION_TYPE_TABLE ),

    ENUM_STRING_MAP_ENTRY( "com.sun.star.text.ObjectIndex", TEXT_SECTION_TYPE_OBJECT ),

    ENUM_STRING_MAP_ENTRY( "com.sun.star.text.Bibliography", TEXT_SECTION_TYPE_BIBLIOGRAPHY ),

    ENUM_STRING_MAP_ENTRY( "com.sun.star.text.UserIndex", TEXT_SECTION_TYPE_USER ),

    ENUM_STRING_MAP_ENTRY( "com.sun.star.text.IllustrationsIndex", TEXT_SECTION_TYPE_ILLUSTRATION ),

    { nullptr, 0, SectionTypeEnum(0) }

};

enum SectionTypeEnum XMLSectionExport::MapSectionType(

    std::u16string_view rServiceName)

{

    enum SectionTypeEnum eType = TEXT_SECTION_TYPE_UNKNOWN;

    SvXMLUnitConverter::convertEnum(eType, rServiceName, aIndexTypeMap);

    // TODO: index header section types, etc.

    return eType;

}

void XMLSectionExport::ExportRegularSectionStart(

    const Reference<XTextSection> & rSection)

{

    // style name already handled in ExportSectionStart(...)

    Reference<XNamed> xName(rSection, UNO_QUERY);

    GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_NAME, xName->getName());

    // get XPropertySet for other values

    Reference<XPropertySet> xPropSet(rSection, UNO_QUERY);

    // condition and display

    Any aAny = xPropSet->getPropertyValue(u"Condition"_ustr);

    OUString sCond;

    aAny >>= sCond;

    enum XMLTokenEnum eDisplay = XML_TOKEN_INVALID;

    if (!sCond.isEmpty())

    {

        OUString sQValue =

            GetExport().GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OOOW,

                                                         sCond, false );

        GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_CONDITION, sQValue);

        eDisplay = XML_CONDITION;

        // #97450# store hidden-status (of conditional sections only)

        aAny = xPropSet->getPropertyValue(u"IsCurrentlyVisible"_ustr);

        if (! *o3tl::doAccess<bool>(aAny))

        {

            GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_IS_HIDDEN,

                                     XML_TRUE);

        }

    }

    else

    {

        eDisplay = XML_NONE;

    }

    aAny = xPropSet->getPropertyValue(u"IsVisible"_ustr);

    if (! *o3tl::doAccess<bool>(aAny))

    {

        GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_DISPLAY, eDisplay);

    }

    // protect + protection key

    aAny = xPropSet->getPropertyValue(u"IsProtected"_ustr);

    if (*o3tl::doAccess<bool>(aAny))

    {

        GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_PROTECTED, XML_TRUE);

    }

    Sequence<sal_Int8> aPassword;

    xPropSet->getPropertyValue(u"ProtectionKey"_ustr) >>= aPassword;

    if (aPassword.hasElements())

    {

        OUStringBuffer aBuffer;

        ::comphelper::Base64::encode(aBuffer, aPassword);

        // in ODF 1.0/1.1 the algorithm was left unspecified so we can write anything

        GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_PROTECTION_KEY,

                                 aBuffer.makeStringAndClear());

        if (aPassword.getLength() == 32 && GetExport().getSaneDefaultVersion() >= SvtSaveOptions::ODFSVER_012)

        {

            // attribute exists in ODF 1.2 or later; default is SHA1 so no need to write that

            GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_PROTECTION_KEY_DIGEST_ALGORITHM,

                    // write the URL from ODF 1.2, not the W3C one

                    u"http://www.w3.org/2000/09/xmldsig#sha256"_ustr);

        }

    }

    // export element

    GetExport().IgnorableWhitespace();

    GetExport().StartElement( XML_NAMESPACE_TEXT, XML_SECTION, true );

    // data source

    // unfortunately, we have to test all relevant strings for non-zero length

    aAny = xPropSet->getPropertyValue(u"FileLink"_ustr);

    SectionFileLink aFileLink;

    aAny >>= aFileLink;

    aAny = xPropSet->getPropertyValue(u"LinkRegion"_ustr);

    OUString sRegionName;

    aAny >>= sRegionName;

    if ( !aFileLink.FileURL.isEmpty() ||

         !aFileLink.FilterName.isEmpty() ||

         !sRegionName.isEmpty())

    {

        if (!aFileLink.FileURL.isEmpty())

        {

            GetExport().AddAttribute(XML_NAMESPACE_XLINK, XML_HREF,

                                     GetExport().GetRelativeReference( aFileLink.FileURL) );

        }

        if (!aFileLink.FilterName.isEmpty())

        {

            GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_FILTER_NAME,

                                     aFileLink.FilterName);

        }

        if (!sRegionName.isEmpty())

        {

            GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_SECTION_NAME,

                                     sRegionName);

        }

        SvXMLElementExport aElem(GetExport(),

                                 XML_NAMESPACE_TEXT, XML_SECTION_SOURCE,

                                 true, true);

    }

    else

    {

        // check for DDE first

        if (xPropSet->getPropertySetInfo()->hasPropertyByName(u"DDECommandFile"_ustr))

        {

            // data source DDE

            // unfortunately, we have to test all relevant strings for

            // non-zero length

            aAny = xPropSet->getPropertyValue(u"DDECommandFile"_ustr);

            OUString sApplication;

            aAny >>= sApplication;

            aAny = xPropSet->getPropertyValue(u"DDECommandType"_ustr);

            OUString sTopic;

            aAny >>= sTopic;

            aAny = xPropSet->getPropertyValue(u"DDECommandElement"_ustr);

            OUString sItem;

            aAny >>= sItem;

            if ( !sApplication.isEmpty() ||

                 !sTopic.isEmpty() ||

                 !sItem.isEmpty())

            {

                GetExport().AddAttribute(XML_NAMESPACE_OFFICE,

                                         XML_DDE_APPLICATION, sApplication);

                GetExport().AddAttribute(XML_NAMESPACE_OFFICE, XML_DDE_TOPIC,

                                         sTopic);

                GetExport().AddAttribute(XML_NAMESPACE_OFFICE, XML_DDE_ITEM,

                                         sItem);

                aAny = xPropSet->getPropertyValue(u"IsAutomaticUpdate"_ustr);

                if (*o3tl::doAccess<bool>(aAny))

                {

                    GetExport().AddAttribute(XML_NAMESPACE_OFFICE,

                                             XML_AUTOMATIC_UPDATE, XML_TRUE);

                }

                SvXMLElementExport aElem(GetExport(),

                                         XML_NAMESPACE_OFFICE,

                                         XML_DDE_SOURCE, true, true);

            }

            // else: no DDE data source

        }

        // else: no DDE on this system

    }

}

void XMLSectionExport::ExportTableOfContentStart(

    const Reference<XPropertySet> & rPropertySet)

{

    // export TOC element start

    ExportBaseIndexStart(XML_TABLE_OF_CONTENT, rPropertySet);

    // scope for table-of-content-source element

    {

        // TOC specific index source attributes:

        // outline-level: 1..10

        sal_Int16 nLevel = sal_Int16();

        if( rPropertySet->getPropertyValue(u"Level"_ustr) >>= nLevel )

        {

            GetExport().AddAttribute(XML_NAMESPACE_TEXT,

                                     XML_OUTLINE_LEVEL,

                                     OUString::number(nLevel));

        }

        // use outline level

        ExportBoolean(rPropertySet, u"CreateFromOutline"_ustr,

                          XML_USE_OUTLINE_LEVEL, true);

        // use index marks

        ExportBoolean(rPropertySet, u"CreateFromMarks"_ustr,

                      XML_USE_INDEX_MARKS, true);

        // use level styles

        ExportBoolean(rPropertySet, u"CreateFromLevelParagraphStyles"_ustr,

                      XML_USE_INDEX_SOURCE_STYLES, false);

        ExportBaseIndexSource(TEXT_SECTION_TYPE_TOC, rPropertySet);

    }

    ExportBaseIndexBody(TEXT_SECTION_TYPE_TOC, rPropertySet);

}

void XMLSectionExport::ExportObjectIndexStart(

    const Reference<XPropertySet> & rPropertySet)

{

    // export index start

    ExportBaseIndexStart(XML_OBJECT_INDEX, rPropertySet);

    // scope for index source element

    {

        ExportBoolean(rPropertySet, u"CreateFromOtherEmbeddedObjects"_ustr,

                      XML_USE_OTHER_OBJECTS, false);

        ExportBoolean(rPropertySet, u"CreateFromStarCalc"_ustr,

                      XML_USE_SPREADSHEET_OBJECTS, false);

        ExportBoolean(rPropertySet, u"CreateFromStarChart"_ustr,

                      XML_USE_CHART_OBJECTS, false);

        ExportBoolean(rPropertySet, u"CreateFromStarDraw"_ustr,

                      XML_USE_DRAW_OBJECTS, false);

        ExportBoolean(rPropertySet, u"CreateFromStarMath"_ustr,

                      XML_USE_MATH_OBJECTS, false);

        ExportBaseIndexSource(TEXT_SECTION_TYPE_OBJECT, rPropertySet);

    }

    ExportBaseIndexBody(TEXT_SECTION_TYPE_OBJECT, rPropertySet);

}

void XMLSectionExport::ExportIllustrationIndexStart(

    const Reference<XPropertySet> & rPropertySet)

{

    // export index start

    ExportBaseIndexStart(XML_ILLUSTRATION_INDEX, rPropertySet);

    // scope for index source element

    {

        // export common attributes for illustration and table indices

        ExportTableAndIllustrationIndexSourceAttributes(rPropertySet);

        ExportBaseIndexSource(TEXT_SECTION_TYPE_ILLUSTRATION, rPropertySet);

    }

    ExportBaseIndexBody(TEXT_SECTION_TYPE_ILLUSTRATION, rPropertySet);

}

void XMLSectionExport::ExportTableIndexStart(

    const Reference<XPropertySet> & rPropertySet)

{

    // export index start

    ExportBaseIndexStart(XML_TABLE_INDEX, rPropertySet);

    // scope for index source element

    {

        // export common attributes for illustration and table indices

        ExportTableAndIllustrationIndexSourceAttributes(rPropertySet);

        ExportBaseIndexSource(TEXT_SECTION_TYPE_TABLE, rPropertySet);

    }

    ExportBaseIndexBody(TEXT_SECTION_TYPE_TABLE, rPropertySet);

}

void XMLSectionExport::ExportAlphabeticalIndexStart(

    const Reference<XPropertySet> & rPropertySet)

{

    // export TOC element start

    ExportBaseIndexStart(XML_ALPHABETICAL_INDEX, rPropertySet);

    // scope for table-of-content-source element

    {

        // style name (if present)

        Any aAny = rPropertySet->getPropertyValue(u"MainEntryCharacterStyleName"_ustr);

        OUString sStyleName;

        aAny >>= sStyleName;

        if (!sStyleName.isEmpty())

        {

            GetExport().AddAttribute(XML_NAMESPACE_TEXT,

                                     XML_MAIN_ENTRY_STYLE_NAME,

                                     GetExport().EncodeStyleName( sStyleName ));

        }

        // other (boolean) attributes

        ExportBoolean(rPropertySet, u"IsCaseSensitive"_ustr, XML_IGNORE_CASE,

                      false, true);

        ExportBoolean(rPropertySet, u"UseAlphabeticalSeparators"_ustr,

                      XML_ALPHABETICAL_SEPARATORS, false);

        ExportBoolean(rPropertySet, u"UseCombinedEntries"_ustr, XML_COMBINE_ENTRIES,

                      true);

        ExportBoolean(rPropertySet, u"UseDash"_ustr, XML_COMBINE_ENTRIES_WITH_DASH,

                      false);

        ExportBoolean(rPropertySet, u"UseKeyAsEntry"_ustr, XML_USE_KEYS_AS_ENTRIES,

                      false);

        ExportBoolean(rPropertySet, u"UsePP"_ustr, XML_COMBINE_ENTRIES_WITH_PP,

                      true);

        ExportBoolean(rPropertySet, u"UseUpperCase"_ustr, XML_CAPITALIZE_ENTRIES,

                      false);

        ExportBoolean(rPropertySet, u"IsCommaSeparated"_ustr, XML_COMMA_SEPARATED,

                      false);

        // sort algorithm

        aAny = rPropertySet->getPropertyValue(u"SortAlgorithm"_ustr);

        OUString sAlgorithm;

        aAny >>= sAlgorithm;

        if (!sAlgorithm.isEmpty())

        {

            GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_SORT_ALGORITHM,

                                      sAlgorithm );

        }

        // locale

        aAny = rPropertySet->getPropertyValue(u"Locale"_ustr);

        Locale aLocale;

        aAny >>= aLocale;

        GetExport().AddLanguageTagAttributes( XML_NAMESPACE_FO, XML_NAMESPACE_STYLE, aLocale, true);

        ExportBaseIndexSource(TEXT_SECTION_TYPE_ALPHABETICAL, rPropertySet);

    }

    ExportBaseIndexBody(TEXT_SECTION_TYPE_ALPHABETICAL, rPropertySet);

}

void XMLSectionExport::ExportUserIndexStart(

    const Reference<XPropertySet> & rPropertySet)

{

    // export TOC element start

    ExportBaseIndexStart(XML_USER_INDEX, rPropertySet);

    // scope for table-of-content-source element

    {

        // bool attributes

        ExportBoolean(rPropertySet, u"CreateFromEmbeddedObjects"_ustr,

                      XML_USE_OBJECTS, false);

        ExportBoolean(rPropertySet, u"CreateFromGraphicObjects"_ustr,

                      XML_USE_GRAPHICS, false);

        ExportBoolean(rPropertySet, u"CreateFromMarks"_ustr,

                      XML_USE_INDEX_MARKS, false);

        ExportBoolean(rPropertySet, u"CreateFromTables"_ustr,

                      XML_USE_TABLES, false);

        ExportBoolean(rPropertySet, u"CreateFromTextFrames"_ustr,

                      XML_USE_FLOATING_FRAMES, false);

        ExportBoolean(rPropertySet, u"UseLevelFromSource"_ustr,

                      XML_COPY_OUTLINE_LEVELS, false);

        ExportBoolean(rPropertySet, u"CreateFromLevelParagraphStyles"_ustr,

                      XML_USE_INDEX_SOURCE_STYLES, false);

        Any aAny = rPropertySet->getPropertyValue( u"UserIndexName"_ustr );

        OUString sIndexName;

        aAny >>= sIndexName;

        GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_INDEX_NAME,

                                 sIndexName);

        ExportBaseIndexSource(TEXT_SECTION_TYPE_USER, rPropertySet);

    }

    ExportBaseIndexBody(TEXT_SECTION_TYPE_USER, rPropertySet);

}

void XMLSectionExport::ExportBibliographyStart(

    const Reference<XPropertySet> & rPropertySet)

{

    // export TOC element start

    ExportBaseIndexStart(XML_BIBLIOGRAPHY, rPropertySet);

    // scope for table-of-content-source element

    {

        // No attributes. Fine.

        ExportBaseIndexSource(TEXT_SECTION_TYPE_BIBLIOGRAPHY, rPropertySet);

    }

    ExportBaseIndexBody(TEXT_SECTION_TYPE_BIBLIOGRAPHY, rPropertySet);

}

void XMLSectionExport::ExportBaseIndexStart(

    XMLTokenEnum eElement,

    const Reference<XPropertySet> & rPropertySet)

{

    // protect + protection key

    Any aAny = rPropertySet->getPropertyValue(u"IsProtected"_ustr);

    if (*o3tl::doAccess<bool>(aAny))

    {

        GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_PROTECTED, XML_TRUE);

    }

    // index name

    OUString sIndexName;

    rPropertySet->getPropertyValue(u"Name"_ustr) >>= sIndexName;

    if ( !sIndexName.isEmpty() )

    {

        GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_NAME, sIndexName);

    }

    // index  Element start

    GetExport().IgnorableWhitespace();

    GetExport().StartElement( XML_NAMESPACE_TEXT, eElement, false );

}

const XMLTokenEnum aTypeSourceElementNameMap[] =

{

    XML_TABLE_OF_CONTENT_SOURCE,        // TOC

    XML_TABLE_INDEX_SOURCE,         // table index

    XML_ILLUSTRATION_INDEX_SOURCE,      // illustration index

    XML_OBJECT_INDEX_SOURCE,            // object index

    XML_USER_INDEX_SOURCE,              // user index

    XML_ALPHABETICAL_INDEX_SOURCE,      // alphabetical index

    XML_BIBLIOGRAPHY_SOURCE         // bibliography

};

void XMLSectionExport::ExportBaseIndexSource(

    SectionTypeEnum eType,

    const Reference<XPropertySet> & rPropertySet)

{

    // check type

    OSL_ENSURE(eType >= TEXT_SECTION_TYPE_TOC, "illegal index type");

    OSL_ENSURE(eType <= TEXT_SECTION_TYPE_BIBLIOGRAPHY, "illegal index type");

    Any aAny;

    // common attributes; not supported by bibliography

    if (eType != TEXT_SECTION_TYPE_BIBLIOGRAPHY)

    {

        // document or chapter index?

        aAny = rPropertySet->getPropertyValue(u"CreateFromChapter"_ustr);

        if (*o3tl::doAccess<bool>(aAny))

        {

            GetExport().AddAttribute(XML_NAMESPACE_TEXT,

                                     XML_INDEX_SCOPE, XML_CHAPTER);

        }

        // tab-stops relative to margin?

        aAny = rPropertySet->getPropertyValue(u"IsRelativeTabstops"_ustr);

        if (! *o3tl::doAccess<bool>(aAny))

        {

            GetExport().AddAttribute(XML_NAMESPACE_TEXT,

                                     XML_RELATIVE_TAB_STOP_POSITION,

                                     XML_FALSE);

        }

    }

    // the index source element (all indices)

    SvXMLElementExport aElem(GetExport(),

                             XML_NAMESPACE_TEXT,

                             GetXMLToken(

                                 aTypeSourceElementNameMap[

                                    eType - TEXT_SECTION_TYPE_TOC]),

                             true, true);

    // scope for title template (all indices)

    {

        // header style name

        aAny = rPropertySet->getPropertyValue(u"ParaStyleHeading"_ustr);

        OUString sStyleName;

        aAny >>= sStyleName;

        GetExport().AddAttribute(XML_NAMESPACE_TEXT,

                                 XML_STYLE_NAME,

                                 GetExport().EncodeStyleName( sStyleName ));

        // title template

        SvXMLElementExport aHeaderTemplate(GetExport(),

                                           XML_NAMESPACE_TEXT,

                                           XML_INDEX_TITLE_TEMPLATE,

                                           true, false);

        // title as element content

        aAny = rPropertySet->getPropertyValue(u"Title"_ustr);

        OUString sTitleString;

        aAny >>= sTitleString;

        GetExport().Characters(sTitleString);

    }

    // export level templates (all indices)

    aAny = rPropertySet->getPropertyValue(u"LevelFormat"_ustr);

    Reference<XIndexReplace> xLevelTemplates;

    aAny >>= xLevelTemplates;

    // iterate over level formats;

    // skip element 0 (empty template for title)

    sal_Int32 nLevelCount = xLevelTemplates->getCount();

    for(sal_Int32 i = 1; i<nLevelCount; i++)

    {

        // get sequence

        Sequence<PropertyValues> aTemplateSequence;

        aAny = xLevelTemplates->getByIndex(i);

        aAny >>= aTemplateSequence;

        // export the sequence (abort export if an error occurred; #91214#)

        bool bResult =

            ExportIndexTemplate(eType, i, rPropertySet, aTemplateSequence);

        if ( !bResult )

            break;

    }

    // only TOC and user index:

    // styles from which to build the index (LevelParagraphStyles)

    if ( (TEXT_SECTION_TYPE_TOC == eType) ||

         (TEXT_SECTION_TYPE_USER == eType)   )

    {

        aAny = rPropertySet->getPropertyValue(u"LevelParagraphStyles"_ustr);

        Reference<XIndexReplace> xLevelParagraphStyles;

        aAny >>= xLevelParagraphStyles;

        ExportLevelParagraphStyles(xLevelParagraphStyles);

    }

    else if (TEXT_SECTION_TYPE_ILLUSTRATION == eType

            || TEXT_SECTION_TYPE_OBJECT == eType

            || TEXT_SECTION_TYPE_TABLE == eType)

    {

        Any const any(rPropertySet->getPropertyValue(u"CreateFromParagraphStyle"_ustr));

        if (any.hasValue() &&

            (rExport.getSaneDefaultVersion() & SvtSaveOptions::ODFSVER_EXTENDED))

        {

            OUString const styleName(any.get<OUString>());

            GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_STYLE_NAME,

                         GetExport().EncodeStyleName(styleName));

            SvXMLElementExport const e(GetExport(),

                XML_NAMESPACE_LO_EXT, XML_INDEX_SOURCE_STYLE, true, false);

        }

    }

}

void XMLSectionExport::ExportBaseIndexBody(

    SectionTypeEnum eType,

    const Reference<XPropertySet> &)

{

    // type not used; checked anyway.

    OSL_ENSURE(eType >= TEXT_SECTION_TYPE_TOC, "illegal index type");

    OSL_ENSURE(eType <= TEXT_SECTION_TYPE_BIBLIOGRAPHY, "illegal index type");

    // export start only

    // any old attributes?

    GetExport().CheckAttrList();

    // start surrounded by whitespace

    GetExport().IgnorableWhitespace();

    GetExport().StartElement( XML_NAMESPACE_TEXT, XML_INDEX_BODY, true );

}

void XMLSectionExport::ExportTableAndIllustrationIndexSourceAttributes(

    const Reference<XPropertySet> & rPropertySet)

{

    // use caption

    Any aAny = rPropertySet->getPropertyValue(u"CreateFromLabels"_ustr);

    if (! *o3tl::doAccess<bool>(aAny))

    {

        GetExport().AddAttribute(XML_NAMESPACE_TEXT,

                                 XML_USE_CAPTION, XML_FALSE);

    }

    // sequence name

    aAny = rPropertySet->getPropertyValue(u"LabelCategory"_ustr);

    OUString sSequenceName;

    aAny >>= sSequenceName;

    GetExport().AddAttribute(XML_NAMESPACE_TEXT,

                             XML_CAPTION_SEQUENCE_NAME,

                             sSequenceName);

    // caption format

    aAny = rPropertySet->getPropertyValue(u"LabelDisplayType"_ustr);

    sal_Int16 nType = 0;

    aAny >>= nType;

    GetExport().AddAttribute(XML_NAMESPACE_TEXT,

                             XML_CAPTION_SEQUENCE_FORMAT,

                             XMLTextFieldExport::MapReferenceType(nType));

}

// map index of LevelFormats to attribute value;

// level 0 is always the header

const XMLTokenEnum aLevelNameTOCMap[] =

    { XML_TOKEN_INVALID, XML_1, XML_2, XML_3, XML_4, XML_5, XML_6, XML_7,

          XML_8, XML_9, XML_10, XML_TOKEN_INVALID };

const XMLTokenEnum aLevelNameTableMap[] =

    { XML_TOKEN_INVALID, XML__EMPTY, XML_TOKEN_INVALID };

const XMLTokenEnum aLevelNameAlphaMap[] =

    { XML_TOKEN_INVALID, XML_SEPARATOR, XML_1, XML_2, XML_3, XML_TOKEN_INVALID };

const XMLTokenEnum aLevelNameBibliographyMap[] =

    { XML_TOKEN_INVALID, XML_ARTICLE, XML_BOOK, XML_BOOKLET, XML_CONFERENCE,

          XML_CUSTOM1, XML_CUSTOM2, XML_CUSTOM3, XML_CUSTOM4,

          XML_CUSTOM5, XML_EMAIL, XML_INBOOK, XML_INCOLLECTION,

          XML_INPROCEEDINGS, XML_JOURNAL,

          XML_MANUAL, XML_MASTERSTHESIS, XML_MISC, XML_PHDTHESIS,

          XML_PROCEEDINGS, XML_TECHREPORT, XML_UNPUBLISHED, XML_WWW,

          XML_TOKEN_INVALID };

const XMLTokenEnum* const aTypeLevelNameMap[] =

{

    aLevelNameTOCMap,           // TOC

    aLevelNameTableMap,         // table index

    aLevelNameTableMap,         // illustration index

    aLevelNameTableMap,         // object index

    aLevelNameTOCMap,           // user index

    aLevelNameAlphaMap,         // alphabetical index

    aLevelNameBibliographyMap   // bibliography

};

constexpr OUString aLevelStylePropNameTOCMap[] =

    { u""_ustr, u"ParaStyleLevel1"_ustr, u"ParaStyleLevel2"_ustr, u"ParaStyleLevel3"_ustr,

          u"ParaStyleLevel4"_ustr, u"ParaStyleLevel5"_ustr, u"ParaStyleLevel6"_ustr,

          u"ParaStyleLevel7"_ustr, u"ParaStyleLevel8"_ustr, u"ParaStyleLevel9"_ustr,

          u"ParaStyleLevel10"_ustr, u""_ustr };

constexpr OUString aLevelStylePropNameTableMap[] =

    { u""_ustr, u"ParaStyleLevel1"_ustr, u""_ustr };

constexpr OUString aLevelStylePropNameAlphaMap[] =