xmloff/source/text/XMLSectionExport.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "XMLSectionExport.hxx"
  21 #include <o3tl/any.hxx>
  22 #include <rtl/ustring.hxx>
  23 #include <rtl/ustrbuf.hxx>
  24 #include <osl/diagnose.h>
  25 #include <com/sun/star/frame/XModel.hpp>
  26 #include <com/sun/star/lang/Locale.hpp>
  27 #include <com/sun/star/container/XIndexReplace.hpp>
  28 #include <com/sun/star/beans/XPropertySet.hpp>
  29 #include <com/sun/star/beans/PropertyValue.hpp>
  30 #include <com/sun/star/beans/PropertyValues.hpp>
  31 #include <com/sun/star/text/XTextSection.hpp>
  32 #include <com/sun/star/text/SectionFileLink.hpp>
  33 #include <com/sun/star/container/XNamed.hpp>
  34 #include <com/sun/star/container/XNameAccess.hpp>
  35 #include <com/sun/star/text/XDocumentIndex.hpp>
  36 #include <com/sun/star/text/BibliographyDataField.hpp>
  37 #include <com/sun/star/text/XTextFieldsSupplier.hpp>
  38 #include <com/sun/star/text/XChapterNumberingSupplier.hpp>
  39 #include <com/sun/star/text/ChapterFormat.hpp>
  40
  41 #include <comphelper/base64.hxx>
  42
  43 #include <xmloff/xmltoken.hxx>
  44 #include <xmloff/xmlnamespace.hxx>
  45 #include <xmloff/families.hxx>
  46 #include <xmloff/xmluconv.hxx>
  47 #include <xmloff/namespacemap.hxx>
  48 #include <xmloff/xmlexp.hxx>
  49 #include <xmloff/xmlement.hxx>
  50 #include <txtflde.hxx>
  51
  52
  53 using namespace ::com::sun::star;
  54 using namespace ::com::sun::star::text;
  55 using namespace ::com::sun::star::uno;
  56 using namespace ::xmloff::token;
  57
  58 using ::com::sun::star::beans::XPropertySet;
  59 using ::com::sun::star::beans::PropertyValue;
  60 using ::com::sun::star::beans::PropertyValues;
  61 using ::com::sun::star::container::XIndexReplace;
  62 using ::com::sun::star::container::XNameAccess;
  63 using ::com::sun::star::container::XNamed;
  64 using ::com::sun::star::lang::Locale;
  65
  66
  67 XMLSectionExport::XMLSectionExport(
  68     SvXMLExport& rExp,
  69     XMLTextParagraphExport& rParaExp)
  70 :   rExport(rExp)
  71 ,   rParaExport(rParaExp)
  72 ,   bHeadingDummiesExported( false )
  73 {
  74 }
  75
  76
  77 void XMLSectionExport::ExportSectionStart(
  78     const Reference<XTextSection> & rSection,
  79     bool bAutoStyles)
  80 {
  81     Reference<XPropertySet> xPropertySet(rSection, UNO_QUERY);
  82
  83     // always export section (auto) style
  84     if (bAutoStyles)
  85     {
  86         // get PropertySet and add section style
  87         GetParaExport().Add( XmlStyleFamily::TEXT_SECTION, xPropertySet );
  88     }
  89     else
  90     {
  91         // always export section style
  92         GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_STYLE_NAME,
  93                                      GetParaExport().Find(
  94                                      XmlStyleFamily::TEXT_SECTION,
  95                                      xPropertySet, "" ) );
  96
  97         // xml:id for RDF metadata
  98         GetExport().AddAttributeXmlId(rSection);
  99
 100         // export index or regular section
 101         Reference<XDocumentIndex> xIndex;
 102         if (GetIndex(rSection, xIndex))
 103         {
 104             if (xIndex.is())
 105             {
 106                 // we are an index
 107                 ExportIndexStart(xIndex);
 108             }
 109             else
 110             {
 111                 // we are an index header
 112                 ExportIndexHeaderStart(rSection);
 113             }
 114         }
 115         else
 116         {
 117             // we are not an index
 118             ExportRegularSectionStart(rSection);
 119         }
 120     }
 121 }
 122
 123 bool XMLSectionExport::GetIndex(
 124     const Reference<XTextSection> & rSection,
 125     Reference<XDocumentIndex> & rIndex)
 126 {
 127     // first, reset result
 128     bool bRet = false;
 129     rIndex = nullptr;
 130
 131     // get section Properties
 132     Reference<XPropertySet> xSectionPropSet(rSection, UNO_QUERY);
 133
 134     // then check if this section happens to be inside an index
 135     if (xSectionPropSet->getPropertySetInfo()->
 136                                     hasPropertyByName("DocumentIndex"))
 137     {
 138         Any aAny = xSectionPropSet->getPropertyValue("DocumentIndex");
 139         Reference<XDocumentIndex> xDocumentIndex;
 140         aAny >>= xDocumentIndex;
 141
 142         // OK, are we inside of an index
 143         if (xDocumentIndex.is())
 144         {
 145             // is the enclosing index identical with "our" section?
 146             Reference<XPropertySet> xIndexPropSet(xDocumentIndex, UNO_QUERY);
 147             aAny = xIndexPropSet->getPropertyValue("ContentSection");
 148             Reference<XTextSection> xEnclosingSection;
 149             aAny >>= xEnclosingSection;
 150
 151             // if the enclosing section is "our" section, then we are an index!
 152             if (rSection == xEnclosingSection)
 153             {
 154                 rIndex = xDocumentIndex;
 155                 bRet = true;
 156             }
 157             // else: index header or regular section
 158
 159             // is the enclosing index identical with the header section?
 160             aAny = xIndexPropSet->getPropertyValue("HeaderSection");
 161             // now mis-named: contains header section
 162             aAny >>= xEnclosingSection;
 163
 164             // if the enclosing section is "our" section, then we are an index!
 165             if (rSection == xEnclosingSection)
 166             {
 167                 bRet = true;
 168             }
 169             // else: regular section
 170         }
 171         // else: we aren't even inside of an index
 172     }
 173     // else: we don't even know what an index is.
 174
 175     return bRet;
 176 }
 177
 178
 179 void XMLSectionExport::ExportSectionEnd(
 180     const Reference<XTextSection> & rSection,
 181     bool bAutoStyles)
 182 {
 183     // no end section for styles
 184     if (bAutoStyles)
 185         return;
 186
 187     enum XMLTokenEnum eElement = XML_TOKEN_INVALID;
 188
 189     // export index or regular section end
 190     Reference<XDocumentIndex> xIndex;
 191     if (GetIndex(rSection, xIndex))
 192     {
 193         if (xIndex.is())
 194         {
 195             // index end: close index body element
 196             GetExport().EndElement( XML_NAMESPACE_TEXT, XML_INDEX_BODY,
 197                                     true );
 198             GetExport().IgnorableWhitespace();
 199
 200             switch (MapSectionType(xIndex->getServiceName()))
 201             {
 202                 case TEXT_SECTION_TYPE_TOC:
 203                     eElement = XML_TABLE_OF_CONTENT;
 204                     break;
 205
 206                 case TEXT_SECTION_TYPE_ILLUSTRATION:
 207                     eElement = XML_ILLUSTRATION_INDEX;
 208                     break;
 209
 210                 case TEXT_SECTION_TYPE_ALPHABETICAL:
 211                     eElement = XML_ALPHABETICAL_INDEX;
 212                     break;
 213
 214                 case TEXT_SECTION_TYPE_TABLE:
 215                     eElement = XML_TABLE_INDEX;
 216                     break;
 217
 218                 case TEXT_SECTION_TYPE_OBJECT:
 219                     eElement = XML_OBJECT_INDEX;
 220                     break;
 221
 222                 case TEXT_SECTION_TYPE_USER:
 223                     eElement = XML_USER_INDEX;
 224                     break;
 225
 226                 case TEXT_SECTION_TYPE_BIBLIOGRAPHY:
 227                     eElement = XML_BIBLIOGRAPHY;
 228                     break;
 229
 230                 default:
 231                     OSL_FAIL("unknown index type");
 232                     // default: skip index!
 233                     break;
 234             }
 235         }
 236         else
 237         {
 238             eElement = XML_INDEX_TITLE;
 239         }
 240     }
 241     else
 242     {
 243         eElement = XML_SECTION;
 244     }
 245
 246     if (XML_TOKEN_INVALID != eElement)
 247     {
 248         // any old attributes?
 249         GetExport().CheckAttrList();
 250
 251         // element surrounded by whitespace
 252         GetExport().EndElement( XML_NAMESPACE_TEXT, eElement, true);
 253         GetExport().IgnorableWhitespace();
 254     }
 255     else
 256     {
 257         OSL_FAIL("Need element name!");
 258     }
 259     // else: autostyles -> ignore
 260 }
 261
 262 void XMLSectionExport::ExportIndexStart(
 263     const Reference<XDocumentIndex> & rIndex)
 264 {
 265     // get PropertySet
 266     Reference<XPropertySet> xPropertySet(rIndex, UNO_QUERY);
 267
 268     switch (MapSectionType(rIndex->getServiceName()))
 269     {
 270         case TEXT_SECTION_TYPE_TOC:
 271             ExportTableOfContentStart(xPropertySet);
 272             break;
 273
 274         case TEXT_SECTION_TYPE_ILLUSTRATION:
 275             ExportIllustrationIndexStart(xPropertySet);
 276             break;
 277
 278         case TEXT_SECTION_TYPE_ALPHABETICAL:
 279             ExportAlphabeticalIndexStart(xPropertySet);
 280             break;
 281
 282         case TEXT_SECTION_TYPE_TABLE:
 283             ExportTableIndexStart(xPropertySet);
 284             break;
 285
 286         case TEXT_SECTION_TYPE_OBJECT:
 287             ExportObjectIndexStart(xPropertySet);
 288             break;
 289
 290         case TEXT_SECTION_TYPE_USER:
 291             ExportUserIndexStart(xPropertySet);
 292             break;
 293
 294         case TEXT_SECTION_TYPE_BIBLIOGRAPHY:
 295             ExportBibliographyStart(xPropertySet);
 296             break;
 297
 298         default:
 299             // skip index
 300             OSL_FAIL("unknown index type");
 301             break;
 302     }
 303 }
 304
 305 void XMLSectionExport::ExportIndexHeaderStart(
 306     const Reference<XTextSection> & rSection)
 307 {
 308     // export name, dammit!
 309     Reference<XNamed> xName(rSection, UNO_QUERY);
 310     GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_NAME, xName->getName());
 311     Reference<XPropertySet> xPropSet(rSection, UNO_QUERY);
 312     Any aAny = xPropSet->getPropertyValue("IsProtected");
 313     if (*o3tl::doAccess<bool>(aAny))
 314     {
 315         GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_PROTECTED, XML_TRUE);
 316     }
 317
 318     // format already handled -> export only start element
 319     GetExport().StartElement( XML_NAMESPACE_TEXT, XML_INDEX_TITLE, true );
 320     GetExport().IgnorableWhitespace();
 321 }
 322
 323
 324 SvXMLEnumStringMapEntry<SectionTypeEnum> const aIndexTypeMap[] =
 325 {
 326     ENUM_STRING_MAP_ENTRY( "com.sun.star.text.ContentIndex", TEXT_SECTION_TYPE_TOC ),
 327     ENUM_STRING_MAP_ENTRY( "com.sun.star.text.DocumentIndex", TEXT_SECTION_TYPE_ALPHABETICAL ),
 328     ENUM_STRING_MAP_ENTRY( "com.sun.star.text.TableIndex", TEXT_SECTION_TYPE_TABLE ),
 329     ENUM_STRING_MAP_ENTRY( "com.sun.star.text.ObjectIndex", TEXT_SECTION_TYPE_OBJECT ),
 330     ENUM_STRING_MAP_ENTRY( "com.sun.star.text.Bibliography", TEXT_SECTION_TYPE_BIBLIOGRAPHY ),
 331     ENUM_STRING_MAP_ENTRY( "com.sun.star.text.UserIndex", TEXT_SECTION_TYPE_USER ),
 332     ENUM_STRING_MAP_ENTRY( "com.sun.star.text.IllustrationsIndex", TEXT_SECTION_TYPE_ILLUSTRATION ),
 333     { nullptr, 0, SectionTypeEnum(0) }
 334 };
 335
 336 enum SectionTypeEnum XMLSectionExport::MapSectionType(
 337     std::u16string_view rServiceName)
 338 {
 339     enum SectionTypeEnum eType = TEXT_SECTION_TYPE_UNKNOWN;
 340
 341     SvXMLUnitConverter::convertEnum(eType, rServiceName, aIndexTypeMap);
 342
 343     // TODO: index header section types, etc.
 344
 345     return eType;
 346 }
 347
 348 void XMLSectionExport::ExportRegularSectionStart(
 349     const Reference<XTextSection> & rSection)
 350 {
 351     // style name already handled in ExportSectionStart(...)
 352
 353     Reference<XNamed> xName(rSection, UNO_QUERY);
 354     GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_NAME, xName->getName());
 355
 356     // get XPropertySet for other values
 357     Reference<XPropertySet> xPropSet(rSection, UNO_QUERY);
 358
 359     // condition and display
 360     Any aAny = xPropSet->getPropertyValue("Condition");
 361     OUString sCond;
 362     aAny >>= sCond;
 363     enum XMLTokenEnum eDisplay = XML_TOKEN_INVALID;
 364     if (!sCond.isEmpty())
 365     {
 366         OUString sQValue =
 367             GetExport().GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OOOW,
 368                                                          sCond, false );
 369         GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_CONDITION, sQValue);
 370         eDisplay = XML_CONDITION;
 371
 372         // #97450# store hidden-status (of conditional sections only)
 373         aAny = xPropSet->getPropertyValue("IsCurrentlyVisible");
 374         if (! *o3tl::doAccess<bool>(aAny))
 375         {
 376             GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_IS_HIDDEN,
 377                                      XML_TRUE);
 378         }
 379     }
 380     else
 381     {
 382         eDisplay = XML_NONE;
 383     }
 384     aAny = xPropSet->getPropertyValue("IsVisible");
 385     if (! *o3tl::doAccess<bool>(aAny))
 386     {
 387         GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_DISPLAY, eDisplay);
 388     }
 389
 390     // protect + protection key
 391     aAny = xPropSet->getPropertyValue("IsProtected");
 392     if (*o3tl::doAccess<bool>(aAny))
 393     {
 394         GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_PROTECTED, XML_TRUE);
 395     }
 396     Sequence<sal_Int8> aPassword;
 397     xPropSet->getPropertyValue("ProtectionKey") >>= aPassword;
 398     if (aPassword.hasElements())
 399     {
 400         OUStringBuffer aBuffer;
 401         ::comphelper::Base64::encode(aBuffer, aPassword);
 402         // in ODF 1.0/1.1 the algorithm was left unspecified so we can write anything
 403         GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_PROTECTION_KEY,
 404                                  aBuffer.makeStringAndClear());
 405         if (aPassword.getLength() == 32 && GetExport().getSaneDefaultVersion() >= SvtSaveOptions::ODFSVER_012)
 406         {
 407             // attribute exists in ODF 1.2 or later; default is SHA1 so no need to write that
 408             GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_PROTECTION_KEY_DIGEST_ALGORITHM,
 409                     // write the URL from ODF 1.2, not the W3C one
 410                     "http://www.w3.org/2000/09/xmldsig#sha256");
 411         }
 412     }
 413
 414     // export element
 415     GetExport().IgnorableWhitespace();
 416     GetExport().StartElement( XML_NAMESPACE_TEXT, XML_SECTION, true );
 417
 418     // data source
 419     // unfortunately, we have to test all relevant strings for non-zero length
 420     aAny = xPropSet->getPropertyValue("FileLink");
 421     SectionFileLink aFileLink;
 422     aAny >>= aFileLink;
 423
 424     aAny = xPropSet->getPropertyValue("LinkRegion");
 425     OUString sRegionName;
 426     aAny >>= sRegionName;
 427
 428     if ( !aFileLink.FileURL.isEmpty() ||
 429          !aFileLink.FilterName.isEmpty() ||
 430          !sRegionName.isEmpty())
 431     {
 432         if (!aFileLink.FileURL.isEmpty())
 433         {
 434             GetExport().AddAttribute(XML_NAMESPACE_XLINK, XML_HREF,
 435                                      GetExport().GetRelativeReference( aFileLink.FileURL) );
 436         }
 437
 438         if (!aFileLink.FilterName.isEmpty())
 439         {
 440             GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_FILTER_NAME,
 441                                      aFileLink.FilterName);
 442         }
 443
 444         if (!sRegionName.isEmpty())
 445         {
 446             GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_SECTION_NAME,
 447                                      sRegionName);
 448         }
 449
 450         SvXMLElementExport aElem(GetExport(),
 451                                  XML_NAMESPACE_TEXT, XML_SECTION_SOURCE,
 452                                  true, true);
 453     }
 454     else
 455     {
 456         // check for DDE first
 457         if (xPropSet->getPropertySetInfo()->hasPropertyByName("DDECommandFile"))
 458         {
 459             // data source DDE
 460             // unfortunately, we have to test all relevant strings for
 461             // non-zero length
 462             aAny = xPropSet->getPropertyValue("DDECommandFile");
 463             OUString sApplication;
 464             aAny >>= sApplication;
 465             aAny = xPropSet->getPropertyValue("DDECommandType");
 466             OUString sTopic;
 467             aAny >>= sTopic;
 468             aAny = xPropSet->getPropertyValue("DDECommandElement");
 469             OUString sItem;
 470             aAny >>= sItem;
 471
 472             if ( !sApplication.isEmpty() ||
 473                  !sTopic.isEmpty() ||
 474                  !sItem.isEmpty())
 475             {
 476                 GetExport().AddAttribute(XML_NAMESPACE_OFFICE,
 477                                          XML_DDE_APPLICATION, sApplication);
 478                 GetExport().AddAttribute(XML_NAMESPACE_OFFICE, XML_DDE_TOPIC,
 479                                          sTopic);
 480                 GetExport().AddAttribute(XML_NAMESPACE_OFFICE, XML_DDE_ITEM,
 481                                          sItem);
 482
 483                 aAny = xPropSet->getPropertyValue("IsAutomaticUpdate");
 484                 if (*o3tl::doAccess<bool>(aAny))
 485                 {
 486                     GetExport().AddAttribute(XML_NAMESPACE_OFFICE,
 487                                              XML_AUTOMATIC_UPDATE, XML_TRUE);
 488                 }
 489
 490                 SvXMLElementExport aElem(GetExport(),
 491                                          XML_NAMESPACE_OFFICE,
 492                                          XML_DDE_SOURCE, true, true);
 493             }
 494             // else: no DDE data source
 495         }
 496         // else: no DDE on this system
 497     }
 498 }
 499
 500 void XMLSectionExport::ExportTableOfContentStart(
 501     const Reference<XPropertySet> & rPropertySet)
 502 {
 503     // export TOC element start
 504     ExportBaseIndexStart(XML_TABLE_OF_CONTENT, rPropertySet);
 505
 506     // scope for table-of-content-source element
 507     {
 508         // TOC specific index source attributes:
 509
 510         // outline-level: 1..10
 511         sal_Int16 nLevel = sal_Int16();
 512         if( rPropertySet->getPropertyValue("Level") >>= nLevel )
 513         {
 514             GetExport().AddAttribute(XML_NAMESPACE_TEXT,
 515                                      XML_OUTLINE_LEVEL,
 516                                      OUString::number(nLevel));
 517         }
 518
 519         // use outline level
 520         ExportBoolean(rPropertySet, "CreateFromOutline",
 521                           XML_USE_OUTLINE_LEVEL, true);
 522
 523         // use index marks
 524         ExportBoolean(rPropertySet, "CreateFromMarks",
 525                       XML_USE_INDEX_MARKS, true);
 526
 527         // use level styles
 528         ExportBoolean(rPropertySet, "CreateFromLevelParagraphStyles",
 529                       XML_USE_INDEX_SOURCE_STYLES, false);
 530
 531         ExportBaseIndexSource(TEXT_SECTION_TYPE_TOC, rPropertySet);
 532     }
 533
 534     ExportBaseIndexBody(TEXT_SECTION_TYPE_TOC, rPropertySet);
 535 }
 536
 537 void XMLSectionExport::ExportObjectIndexStart(
 538     const Reference<XPropertySet> & rPropertySet)
 539 {
 540     // export index start
 541     ExportBaseIndexStart(XML_OBJECT_INDEX, rPropertySet);
 542
 543     // scope for index source element
 544     {
 545         ExportBoolean(rPropertySet, "CreateFromOtherEmbeddedObjects",
 546                       XML_USE_OTHER_OBJECTS, false);
 547         ExportBoolean(rPropertySet, "CreateFromStarCalc",
 548                       XML_USE_SPREADSHEET_OBJECTS, false);
 549         ExportBoolean(rPropertySet, "CreateFromStarChart",
 550                       XML_USE_CHART_OBJECTS, false);
 551         ExportBoolean(rPropertySet, "CreateFromStarDraw",
 552                       XML_USE_DRAW_OBJECTS, false);
 553         ExportBoolean(rPropertySet, "CreateFromStarMath",
 554                       XML_USE_MATH_OBJECTS, false);
 555
 556         ExportBaseIndexSource(TEXT_SECTION_TYPE_OBJECT, rPropertySet);
 557     }
 558
 559     ExportBaseIndexBody(TEXT_SECTION_TYPE_OBJECT, rPropertySet);
 560 }
 561
 562 void XMLSectionExport::ExportIllustrationIndexStart(
 563     const Reference<XPropertySet> & rPropertySet)
 564 {
 565     // export index start
 566     ExportBaseIndexStart(XML_ILLUSTRATION_INDEX, rPropertySet);
 567
 568     // scope for index source element
 569     {
 570         // export common attributes for illustration and table indices
 571         ExportTableAndIllustrationIndexSourceAttributes(rPropertySet);
 572
 573         ExportBaseIndexSource(TEXT_SECTION_TYPE_ILLUSTRATION, rPropertySet);
 574     }
 575
 576     ExportBaseIndexBody(TEXT_SECTION_TYPE_ILLUSTRATION, rPropertySet);
 577 }
 578
 579 void XMLSectionExport::ExportTableIndexStart(
 580     const Reference<XPropertySet> & rPropertySet)
 581 {
 582     // export index start
 583     ExportBaseIndexStart(XML_TABLE_INDEX, rPropertySet);
 584
 585     // scope for index source element
 586     {
 587         // export common attributes for illustration and table indices
 588         ExportTableAndIllustrationIndexSourceAttributes(rPropertySet);
 589
 590         ExportBaseIndexSource(TEXT_SECTION_TYPE_TABLE, rPropertySet);
 591     }
 592
 593     ExportBaseIndexBody(TEXT_SECTION_TYPE_TABLE, rPropertySet);
 594 }
 595
 596 void XMLSectionExport::ExportAlphabeticalIndexStart(
 597     const Reference<XPropertySet> & rPropertySet)
 598 {
 599     // export TOC element start
 600     ExportBaseIndexStart(XML_ALPHABETICAL_INDEX, rPropertySet);
 601
 602     // scope for table-of-content-source element
 603     {
 604
 605         // style name (if present)
 606         Any aAny = rPropertySet->getPropertyValue("MainEntryCharacterStyleName");
 607         OUString sStyleName;
 608         aAny >>= sStyleName;
 609         if (!sStyleName.isEmpty())
 610         {
 611             GetExport().AddAttribute(XML_NAMESPACE_TEXT,
 612                                      XML_MAIN_ENTRY_STYLE_NAME,
 613                                      GetExport().EncodeStyleName( sStyleName ));
 614         }
 615
 616         // other (boolean) attributes
 617         ExportBoolean(rPropertySet, "IsCaseSensitive", XML_IGNORE_CASE,
 618                       false, true);
 619         ExportBoolean(rPropertySet, "UseAlphabeticalSeparators",
 620                       XML_ALPHABETICAL_SEPARATORS, false);
 621         ExportBoolean(rPropertySet, "UseCombinedEntries", XML_COMBINE_ENTRIES,
 622                       true);
 623         ExportBoolean(rPropertySet, "UseDash", XML_COMBINE_ENTRIES_WITH_DASH,
 624                       false);
 625         ExportBoolean(rPropertySet, "UseKeyAsEntry", XML_USE_KEYS_AS_ENTRIES,
 626                       false);
 627         ExportBoolean(rPropertySet, "UsePP", XML_COMBINE_ENTRIES_WITH_PP,
 628                       true);
 629         ExportBoolean(rPropertySet, "UseUpperCase", XML_CAPITALIZE_ENTRIES,
 630                       false);
 631         ExportBoolean(rPropertySet, "IsCommaSeparated", XML_COMMA_SEPARATED,
 632                       false);
 633
 634         // sort algorithm
 635         aAny = rPropertySet->getPropertyValue("SortAlgorithm");
 636         OUString sAlgorithm;
 637         aAny >>= sAlgorithm;
 638         if (!sAlgorithm.isEmpty())
 639         {
 640             GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_SORT_ALGORITHM,
 641                                       sAlgorithm );
 642         }
 643
 644         // locale
 645         aAny = rPropertySet->getPropertyValue("Locale");
 646         Locale aLocale;
 647         aAny >>= aLocale;
 648         GetExport().AddLanguageTagAttributes( XML_NAMESPACE_FO, XML_NAMESPACE_STYLE, aLocale, true);
 649
 650         ExportBaseIndexSource(TEXT_SECTION_TYPE_ALPHABETICAL, rPropertySet);
 651     }
 652
 653     ExportBaseIndexBody(TEXT_SECTION_TYPE_ALPHABETICAL, rPropertySet);
 654 }
 655
 656 void XMLSectionExport::ExportUserIndexStart(
 657     const Reference<XPropertySet> & rPropertySet)
 658 {
 659     // export TOC element start
 660     ExportBaseIndexStart(XML_USER_INDEX, rPropertySet);
 661
 662     // scope for table-of-content-source element
 663     {
 664         // bool attributes
 665         ExportBoolean(rPropertySet, "CreateFromEmbeddedObjects",
 666                       XML_USE_OBJECTS, false);
 667         ExportBoolean(rPropertySet, "CreateFromGraphicObjects",
 668                       XML_USE_GRAPHICS, false);
 669         ExportBoolean(rPropertySet, "CreateFromMarks",
 670                       XML_USE_INDEX_MARKS, false);
 671         ExportBoolean(rPropertySet, "CreateFromTables",
 672                       XML_USE_TABLES, false);
 673         ExportBoolean(rPropertySet, "CreateFromTextFrames",
 674                       XML_USE_FLOATING_FRAMES, false);
 675         ExportBoolean(rPropertySet, "UseLevelFromSource",
 676                       XML_COPY_OUTLINE_LEVELS, false);
 677         ExportBoolean(rPropertySet, "CreateFromLevelParagraphStyles",
 678                       XML_USE_INDEX_SOURCE_STYLES, false);
 679
 680         Any aAny = rPropertySet->getPropertyValue( "UserIndexName" );
 681         OUString sIndexName;
 682         aAny >>= sIndexName;
 683         GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_INDEX_NAME,
 684                                  sIndexName);
 685
 686         ExportBaseIndexSource(TEXT_SECTION_TYPE_USER, rPropertySet);
 687     }
 688
 689     ExportBaseIndexBody(TEXT_SECTION_TYPE_USER, rPropertySet);
 690 }
 691
 692 void XMLSectionExport::ExportBibliographyStart(
 693     const Reference<XPropertySet> & rPropertySet)
 694 {
 695     // export TOC element start
 696     ExportBaseIndexStart(XML_BIBLIOGRAPHY, rPropertySet);
 697
 698     // scope for table-of-content-source element
 699     {
 700         // No attributes. Fine.
 701
 702         ExportBaseIndexSource(TEXT_SECTION_TYPE_BIBLIOGRAPHY, rPropertySet);
 703     }
 704
 705     ExportBaseIndexBody(TEXT_SECTION_TYPE_BIBLIOGRAPHY, rPropertySet);
 706 }
 707
 708
 709 void XMLSectionExport::ExportBaseIndexStart(
 710     XMLTokenEnum eElement,
 711     const Reference<XPropertySet> & rPropertySet)
 712 {
 713     // protect + protection key
 714     Any aAny = rPropertySet->getPropertyValue("IsProtected");
 715     if (*o3tl::doAccess<bool>(aAny))
 716     {
 717         GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_PROTECTED, XML_TRUE);
 718     }
 719
 720     // index name
 721     OUString sIndexName;
 722     rPropertySet->getPropertyValue("Name") >>= sIndexName;
 723     if ( !sIndexName.isEmpty() )
 724     {
 725         GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_NAME, sIndexName);
 726     }
 727
 728     // index  Element start
 729     GetExport().IgnorableWhitespace();
 730     GetExport().StartElement( XML_NAMESPACE_TEXT, eElement, false );
 731 }
 732
 733 const XMLTokenEnum aTypeSourceElementNameMap[] =
 734 {
 735     XML_TABLE_OF_CONTENT_SOURCE,        // TOC
 736     XML_TABLE_INDEX_SOURCE,         // table index
 737     XML_ILLUSTRATION_INDEX_SOURCE,      // illustration index
 738     XML_OBJECT_INDEX_SOURCE,            // object index
 739     XML_USER_INDEX_SOURCE,              // user index
 740     XML_ALPHABETICAL_INDEX_SOURCE,      // alphabetical index
 741     XML_BIBLIOGRAPHY_SOURCE         // bibliography
 742 };
 743
 744 void XMLSectionExport::ExportBaseIndexSource(
 745     SectionTypeEnum eType,
 746     const Reference<XPropertySet> & rPropertySet)
 747 {
 748     // check type
 749     OSL_ENSURE(eType >= TEXT_SECTION_TYPE_TOC, "illegal index type");
 750     OSL_ENSURE(eType <= TEXT_SECTION_TYPE_BIBLIOGRAPHY, "illegal index type");
 751
 752     Any aAny;
 753
 754     // common attributes; not supported by bibliography
 755     if (eType != TEXT_SECTION_TYPE_BIBLIOGRAPHY)
 756     {
 757         // document or chapter index?
 758         aAny = rPropertySet->getPropertyValue("CreateFromChapter");
 759         if (*o3tl::doAccess<bool>(aAny))
 760         {
 761             GetExport().AddAttribute(XML_NAMESPACE_TEXT,
 762                                      XML_INDEX_SCOPE, XML_CHAPTER);
 763         }
 764
 765         // tab-stops relative to margin?
 766         aAny = rPropertySet->getPropertyValue("IsRelativeTabstops");
 767         if (! *o3tl::doAccess<bool>(aAny))
 768         {
 769             GetExport().AddAttribute(XML_NAMESPACE_TEXT,
 770                                      XML_RELATIVE_TAB_STOP_POSITION,
 771                                      XML_FALSE);
 772         }
 773     }
 774
 775     // the index source element (all indices)
 776     SvXMLElementExport aElem(GetExport(),
 777                              XML_NAMESPACE_TEXT,
 778                              GetXMLToken(
 779                                  aTypeSourceElementNameMap[
 780                                     eType - TEXT_SECTION_TYPE_TOC]),
 781                              true, true);
 782
 783     // scope for title template (all indices)
 784     {
 785         // header style name
 786         aAny = rPropertySet->getPropertyValue("ParaStyleHeading");
 787         OUString sStyleName;
 788         aAny >>= sStyleName;
 789         GetExport().AddAttribute(XML_NAMESPACE_TEXT,
 790                                  XML_STYLE_NAME,
 791                                  GetExport().EncodeStyleName( sStyleName ));
 792
 793         // title template
 794         SvXMLElementExport aHeaderTemplate(GetExport(),
 795                                            XML_NAMESPACE_TEXT,
 796                                            XML_INDEX_TITLE_TEMPLATE,
 797                                            true, false);
 798
 799         // title as element content
 800         aAny = rPropertySet->getPropertyValue("Title");
 801         OUString sTitleString;
 802         aAny >>= sTitleString;
 803         GetExport().Characters(sTitleString);
 804     }
 805
 806     // export level templates (all indices)
 807     aAny = rPropertySet->getPropertyValue("LevelFormat");
 808     Reference<XIndexReplace> xLevelTemplates;
 809     aAny >>= xLevelTemplates;
 810
 811     // iterate over level formats;
 812     // skip element 0 (empty template for title)
 813     sal_Int32 nLevelCount = xLevelTemplates->getCount();
 814     for(sal_Int32 i = 1; i<nLevelCount; i++)
 815     {
 816         // get sequence
 817         Sequence<PropertyValues> aTemplateSequence;
 818         aAny = xLevelTemplates->getByIndex(i);
 819         aAny >>= aTemplateSequence;
 820
 821         // export the sequence (abort export if an error occurred; #91214#)
 822         bool bResult =
 823             ExportIndexTemplate(eType, i, rPropertySet, aTemplateSequence);
 824         if ( !bResult )
 825             break;
 826     }
 827
 828     // only TOC and user index:
 829     // styles from which to build the index (LevelParagraphStyles)
 830     if ( (TEXT_SECTION_TYPE_TOC == eType) ||
 831          (TEXT_SECTION_TYPE_USER == eType)   )
 832     {
 833         aAny = rPropertySet->getPropertyValue("LevelParagraphStyles");
 834         Reference<XIndexReplace> xLevelParagraphStyles;
 835         aAny >>= xLevelParagraphStyles;
 836         ExportLevelParagraphStyles(xLevelParagraphStyles);
 837     }
 838     else if (TEXT_SECTION_TYPE_ILLUSTRATION == eType
 839             || TEXT_SECTION_TYPE_OBJECT == eType
 840             || TEXT_SECTION_TYPE_TABLE == eType)
 841     {
 842         Any const any(rPropertySet->getPropertyValue("CreateFromParagraphStyle"));
 843         if (any.hasValue() &&
 844             (rExport.getSaneDefaultVersion() & SvtSaveOptions::ODFSVER_EXTENDED))
 845         {
 846             OUString const styleName(any.get<OUString>());
 847             GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_STYLE_NAME,
 848                          GetExport().EncodeStyleName(styleName));
 849
 850             SvXMLElementExport const e(GetExport(),
 851                 XML_NAMESPACE_LO_EXT, XML_INDEX_SOURCE_STYLE, true, false);
 852         }
 853     }
 854 }
 855
 856
 857 void XMLSectionExport::ExportBaseIndexBody(
 858     SectionTypeEnum eType,
 859     const Reference<XPropertySet> &)
 860 {
 861     // type not used; checked anyway.
 862     OSL_ENSURE(eType >= TEXT_SECTION_TYPE_TOC, "illegal index type");
 863     OSL_ENSURE(eType <= TEXT_SECTION_TYPE_BIBLIOGRAPHY, "illegal index type");
 864
 865     // export start only
 866
 867     // any old attributes?
 868     GetExport().CheckAttrList();
 869
 870     // start surrounded by whitespace
 871     GetExport().IgnorableWhitespace();
 872     GetExport().StartElement( XML_NAMESPACE_TEXT, XML_INDEX_BODY, true );
 873 }
 874
 875 void XMLSectionExport::ExportTableAndIllustrationIndexSourceAttributes(
 876     const Reference<XPropertySet> & rPropertySet)
 877 {
 878     // use caption
 879     Any aAny = rPropertySet->getPropertyValue("CreateFromLabels");
 880     if (! *o3tl::doAccess<bool>(aAny))
 881     {
 882         GetExport().AddAttribute(XML_NAMESPACE_TEXT,
 883                                  XML_USE_CAPTION, XML_FALSE);
 884     }
 885
 886     // sequence name
 887     aAny = rPropertySet->getPropertyValue("LabelCategory");
 888     OUString sSequenceName;
 889     aAny >>= sSequenceName;
 890     GetExport().AddAttribute(XML_NAMESPACE_TEXT,
 891                              XML_CAPTION_SEQUENCE_NAME,
 892                              sSequenceName);
 893
 894     // caption format
 895     aAny = rPropertySet->getPropertyValue("LabelDisplayType");
 896     sal_Int16 nType = 0;
 897     aAny >>= nType;
 898     GetExport().AddAttribute(XML_NAMESPACE_TEXT,
 899                              XML_CAPTION_SEQUENCE_FORMAT,
 900                              XMLTextFieldExport::MapReferenceType(nType));
 901 }
 902
 903
 904 // map index of LevelFormats to attribute value;
 905 // level 0 is always the header
 906 const XMLTokenEnum aLevelNameTOCMap[] =
 907     { XML_TOKEN_INVALID, XML_1, XML_2, XML_3, XML_4, XML_5, XML_6, XML_7,
 908           XML_8, XML_9, XML_10, XML_TOKEN_INVALID };
 909 const XMLTokenEnum aLevelNameTableMap[] =
 910     { XML_TOKEN_INVALID, XML__EMPTY, XML_TOKEN_INVALID };
 911 const XMLTokenEnum aLevelNameAlphaMap[] =
 912     { XML_TOKEN_INVALID, XML_SEPARATOR, XML_1, XML_2, XML_3, XML_TOKEN_INVALID };
 913 const XMLTokenEnum aLevelNameBibliographyMap[] =
 914     { XML_TOKEN_INVALID, XML_ARTICLE, XML_BOOK, XML_BOOKLET, XML_CONFERENCE,
 915           XML_CUSTOM1, XML_CUSTOM2, XML_CUSTOM3, XML_CUSTOM4,
 916           XML_CUSTOM5, XML_EMAIL, XML_INBOOK, XML_INCOLLECTION,
 917           XML_INPROCEEDINGS, XML_JOURNAL,
 918           XML_MANUAL, XML_MASTERSTHESIS, XML_MISC, XML_PHDTHESIS,
 919           XML_PROCEEDINGS, XML_TECHREPORT, XML_UNPUBLISHED, XML_WWW,
 920           XML_TOKEN_INVALID };
 921
 922 static const XMLTokenEnum* aTypeLevelNameMap[] =
 923 {
 924     aLevelNameTOCMap,           // TOC
 925     aLevelNameTableMap,         // table index
 926     aLevelNameTableMap,         // illustration index
 927     aLevelNameTableMap,         // object index
 928     aLevelNameTOCMap,           // user index
 929     aLevelNameAlphaMap,         // alphabetical index
 930     aLevelNameBibliographyMap   // bibliography
 931 };
 932
 933 static const char* aLevelStylePropNameTOCMap[] =
 934     { nullptr, "ParaStyleLevel1", "ParaStyleLevel2", "ParaStyleLevel3",
 935           "ParaStyleLevel4", "ParaStyleLevel5", "ParaStyleLevel6",
 936           "ParaStyleLevel7", "ParaStyleLevel8", "ParaStyleLevel9",
 937           "ParaStyleLevel10", nullptr };
 938 static const char* aLevelStylePropNameTableMap[] =
 939     { nullptr, "ParaStyleLevel1", nullptr };
 940 static const char* aLevelStylePropNameAlphaMap[] =
 941     { nullptr, "ParaStyleSeparator", "ParaStyleLevel1", "ParaStyleLevel2",
 942           "ParaStyleLevel3", nullptr };
 943 static const char* aLevelStylePropNameBibliographyMap[] =
 944           // TODO: replace with real property names, when available
 945     { nullptr, "ParaStyleLevel1", "ParaStyleLevel1", "ParaStyleLevel1",
 946           "ParaStyleLevel1", "ParaStyleLevel1", "ParaStyleLevel1",
 947           "ParaStyleLevel1", "ParaStyleLevel1", "ParaStyleLevel1",
 948           "ParaStyleLevel1", "ParaStyleLevel1", "ParaStyleLevel1",
 949           "ParaStyleLevel1", "ParaStyleLevel1", "ParaStyleLevel1",
 950           "ParaStyleLevel1", "ParaStyleLevel1", "ParaStyleLevel1",
 951           "ParaStyleLevel1", "ParaStyleLevel1", "ParaStyleLevel1",
 952           "ParaStyleLevel1",
 953           nullptr };
 954
 955 static const char** aTypeLevelStylePropNameMap[] =
 956 {
 957     aLevelStylePropNameTOCMap,          // TOC
 958     aLevelStylePropNameTableMap,        // table index
 959     aLevelStylePropNameTableMap,        // illustration index
 960     aLevelStylePropNameTableMap,        // object index
 961     aLevelStylePropNameTOCMap,          // user index
 962     aLevelStylePropNameAlphaMap,        // alphabetical index
 963     aLevelStylePropNameBibliographyMap  // bibliography
 964 };
 965
 966 const XMLTokenEnum aTypeLevelAttrMap[] =
 967 {
 968     XML_OUTLINE_LEVEL,      // TOC
 969     XML_TOKEN_INVALID,      // table index
 970     XML_TOKEN_INVALID,      // illustration index
 971     XML_TOKEN_INVALID,      // object index
 972     XML_OUTLINE_LEVEL,      // user index
 973     XML_OUTLINE_LEVEL,      // alphabetical index
 974     XML_BIBLIOGRAPHY_TYPE   // bibliography
 975 };
 976
 977 const XMLTokenEnum aTypeElementNameMap[] =
 978 {
 979     XML_TABLE_OF_CONTENT_ENTRY_TEMPLATE,    // TOC
 980     XML_TABLE_INDEX_ENTRY_TEMPLATE,     // table index
 981     XML_ILLUSTRATION_INDEX_ENTRY_TEMPLATE,  // illustration index
 982     XML_OBJECT_INDEX_ENTRY_TEMPLATE,        // object index
 983     XML_USER_INDEX_ENTRY_TEMPLATE,          // user index
 984     XML_ALPHABETICAL_INDEX_ENTRY_TEMPLATE,  // alphabetical index
 985     XML_BIBLIOGRAPHY_ENTRY_TEMPLATE     // bibliography
 986 };
 987
 988
 989 bool XMLSectionExport::ExportIndexTemplate(
 990     SectionTypeEnum eType,
 991     sal_Int32 nOutlineLevel,
 992     const Reference<XPropertySet> & rPropertySet,
 993     const Sequence<Sequence<PropertyValue> > & rValues)
 994 {
 995     OSL_ENSURE(eType >= TEXT_SECTION_TYPE_TOC, "illegal index type");
 996     OSL_ENSURE(eType <= TEXT_SECTION_TYPE_BIBLIOGRAPHY, "illegal index type");
 997     OSL_ENSURE(nOutlineLevel >= 0, "illegal outline level");
 998
 999     if ( (eType >= TEXT_SECTION_TYPE_TOC) &&
1000          (eType <= TEXT_SECTION_TYPE_BIBLIOGRAPHY) &&
1001          (nOutlineLevel >= 0) )
1002     {
1003         // get level name and level attribute name from aLevelNameMap;
1004         const XMLTokenEnum eLevelAttrName(
1005             aTypeLevelAttrMap[eType-TEXT_SECTION_TYPE_TOC]);
1006         const XMLTokenEnum eLevelName(
1007             aTypeLevelNameMap[eType-TEXT_SECTION_TYPE_TOC][nOutlineLevel]);
1008
1009         // #92124#: some old documents may be broken, then they have
1010         // too many template levels; we need to recognize this and
1011         // export only as many as is legal for the respective index
1012         // type. To do this, we simply return an error flag, which
1013         // will then abort further template level exports.
1014         OSL_ENSURE(XML_TOKEN_INVALID != eLevelName, "can't find level name");
1015         if ( XML_TOKEN_INVALID == eLevelName )
1016         {
1017             // output level not found? Then end of templates! #91214#
1018             return false;
1019         }
1020
1021         // output level name
1022         if ((XML_TOKEN_INVALID != eLevelName) && (XML_TOKEN_INVALID != eLevelAttrName))
1023         {
1024             GetExport().AddAttribute(XML_NAMESPACE_TEXT,
1025                                           GetXMLToken(eLevelAttrName),
1026                                           GetXMLToken(eLevelName));
1027         }
1028
1029         // paragraph level style name
1030         const char* pPropName(
1031             aTypeLevelStylePropNameMap[eType-TEXT_SECTION_TYPE_TOC][nOutlineLevel]);
1032         OSL_ENSURE(nullptr != pPropName, "can't find property name");
1033         if (nullptr != pPropName)
1034         {
1035             Any aAny = rPropertySet->getPropertyValue(
1036                 OUString::createFromAscii(pPropName));
1037             OUString sParaStyleName;
1038             aAny >>= sParaStyleName;
1039             GetExport().AddAttribute(XML_NAMESPACE_TEXT,
1040                                      XML_STYLE_NAME,
1041                                      GetExport().EncodeStyleName( sParaStyleName ));
1042         }
1043
1044         // template element
1045         const XMLTokenEnum eElementName(
1046             aTypeElementNameMap[eType - TEXT_SECTION_TYPE_TOC]);
1047         SvXMLElementExport aLevelTemplate(GetExport(),
1048                                           XML_NAMESPACE_TEXT,
1049                                           GetXMLToken(eElementName),
1050                                           true, true);
1051
1052         // export sequence
1053         for(auto& rValue : rValues)
1054         {
1055             ExportIndexTemplateElement(
1056                 eType,  //i90246
1057                 rValue);
1058         }
1059     }
1060
1061     return true;
1062 }
1063
1064 namespace {
1065
1066 enum TemplateTypeEnum
1067 {
1068     TOK_TTYPE_ENTRY_NUMBER,
1069     TOK_TTYPE_ENTRY_TEXT,
1070     TOK_TTYPE_TAB_STOP,
1071     TOK_TTYPE_TEXT,
1072     TOK_TTYPE_PAGE_NUMBER,
1073     TOK_TTYPE_CHAPTER_INFO,
1074     TOK_TTYPE_HYPERLINK_START,
1075     TOK_TTYPE_HYPERLINK_END,
1076     TOK_TTYPE_BIBLIOGRAPHY,
1077     TOK_TTYPE_INVALID
1078 };
1079
1080 enum TemplateParamEnum
1081 {
1082     TOK_TPARAM_TOKEN_TYPE,
1083     TOK_TPARAM_CHAR_STYLE,
1084     TOK_TPARAM_TAB_RIGHT_ALIGNED,
1085     TOK_TPARAM_TAB_POSITION,
1086     TOK_TPARAM_TAB_WITH_TAB, // #i21237#
1087     TOK_TPARAM_TAB_FILL_CHAR,
1088     TOK_TPARAM_TEXT,
1089     TOK_TPARAM_CHAPTER_FORMAT,
1090     TOK_TPARAM_CHAPTER_LEVEL,//i53420
1091     TOK_TPARAM_BIBLIOGRAPHY_DATA
1092 };
1093
1094 }
1095
1096 SvXMLEnumStringMapEntry<TemplateTypeEnum> const aTemplateTypeMap[] =
1097 {
1098     ENUM_STRING_MAP_ENTRY( "TokenEntryNumber",  TOK_TTYPE_ENTRY_NUMBER ),
1099     ENUM_STRING_MAP_ENTRY( "TokenEntryText",    TOK_TTYPE_ENTRY_TEXT ),
1100     ENUM_STRING_MAP_ENTRY( "TokenTabStop",      TOK_TTYPE_TAB_STOP ),
1101     ENUM_STRING_MAP_ENTRY( "TokenText",         TOK_TTYPE_TEXT ),
1102     ENUM_STRING_MAP_ENTRY( "TokenPageNumber",   TOK_TTYPE_PAGE_NUMBER ),
1103     ENUM_STRING_MAP_ENTRY( "TokenChapterInfo",  TOK_TTYPE_CHAPTER_INFO ),
1104     ENUM_STRING_MAP_ENTRY( "TokenHyperlinkStart", TOK_TTYPE_HYPERLINK_START ),
1105     ENUM_STRING_MAP_ENTRY( "TokenHyperlinkEnd", TOK_TTYPE_HYPERLINK_END ),
1106     ENUM_STRING_MAP_ENTRY( "TokenBibliographyDataField", TOK_TTYPE_BIBLIOGRAPHY ),
1107     { nullptr, 0, TemplateTypeEnum(0)}
1108 };
1109
1110 SvXMLEnumStringMapEntry<TemplateParamEnum> const aTemplateParamMap[] =
1111 {
1112     ENUM_STRING_MAP_ENTRY( "TokenType",             TOK_TPARAM_TOKEN_TYPE ),
1113     ENUM_STRING_MAP_ENTRY( "CharacterStyleName",    TOK_TPARAM_CHAR_STYLE ),
1114     ENUM_STRING_MAP_ENTRY( "TabStopRightAligned",   TOK_TPARAM_TAB_RIGHT_ALIGNED ),
1115     ENUM_STRING_MAP_ENTRY( "TabStopPosition",       TOK_TPARAM_TAB_POSITION ),
1116     ENUM_STRING_MAP_ENTRY( "TabStopFillCharacter",  TOK_TPARAM_TAB_FILL_CHAR ),
1117     // #i21237#
1118     ENUM_STRING_MAP_ENTRY( "WithTab",               TOK_TPARAM_TAB_WITH_TAB ),
1119     ENUM_STRING_MAP_ENTRY( "Text",                  TOK_TPARAM_TEXT ),
1120     ENUM_STRING_MAP_ENTRY( "ChapterFormat",         TOK_TPARAM_CHAPTER_FORMAT ),
1121     ENUM_STRING_MAP_ENTRY( "ChapterLevel",          TOK_TPARAM_CHAPTER_LEVEL ),//i53420
1122     ENUM_STRING_MAP_ENTRY( "BibliographyDataField", TOK_TPARAM_BIBLIOGRAPHY_DATA ),
1123     { nullptr, 0, TemplateParamEnum(0)}
1124 };
1125
1126 SvXMLEnumMapEntry<sal_Int16> const aBibliographyDataFieldMap[] =
1127 {
1128     { XML_ADDRESS,              BibliographyDataField::ADDRESS },
1129     { XML_ANNOTE,               BibliographyDataField::ANNOTE },
1130     { XML_AUTHOR,               BibliographyDataField::AUTHOR },
1131     { XML_BIBLIOGRAPHY_TYPE,    BibliographyDataField::BIBILIOGRAPHIC_TYPE },
1132     { XML_BOOKTITLE,            BibliographyDataField::BOOKTITLE },
1133     { XML_CHAPTER,              BibliographyDataField::CHAPTER },
1134     { XML_CUSTOM1,              BibliographyDataField::CUSTOM1 },
1135     { XML_CUSTOM2,              BibliographyDataField::CUSTOM2 },
1136     { XML_CUSTOM3,              BibliographyDataField::CUSTOM3 },
1137     { XML_CUSTOM4,              BibliographyDataField::CUSTOM4 },
1138     { XML_CUSTOM5,              BibliographyDataField::CUSTOM5 },
1139     { XML_EDITION,              BibliographyDataField::EDITION },
1140     { XML_EDITOR,               BibliographyDataField::EDITOR },
1141     { XML_HOWPUBLISHED,         BibliographyDataField::HOWPUBLISHED },
1142     { XML_IDENTIFIER,           BibliographyDataField::IDENTIFIER },
1143     { XML_INSTITUTION,          BibliographyDataField::INSTITUTION },
1144     { XML_ISBN,                 BibliographyDataField::ISBN },
1145     { XML_JOURNAL,              BibliographyDataField::JOURNAL },
1146     { XML_MONTH,                BibliographyDataField::MONTH },
1147     { XML_NOTE,                 BibliographyDataField::NOTE },
1148     { XML_NUMBER,               BibliographyDataField::NUMBER },
1149     { XML_ORGANIZATIONS,        BibliographyDataField::ORGANIZATIONS },
1150     { XML_PAGES,                BibliographyDataField::PAGES },
1151     { XML_PUBLISHER,            BibliographyDataField::PUBLISHER },
1152     { XML_REPORT_TYPE,          BibliographyDataField::REPORT_TYPE },
1153     { XML_SCHOOL,               BibliographyDataField::SCHOOL },
1154     { XML_SERIES,               BibliographyDataField::SERIES },
1155     { XML_TITLE,                BibliographyDataField::TITLE },
1156     { XML_URL,                  BibliographyDataField::URL },
1157     { XML_VOLUME,               BibliographyDataField::VOLUME },
1158     { XML_YEAR,                 BibliographyDataField::YEAR },
1159     { XML_TOKEN_INVALID, 0 }
1160 };
1161
1162 void XMLSectionExport::ExportIndexTemplateElement(
1163     SectionTypeEnum eType,  //i90246
1164     const Sequence<PropertyValue> & rValues)
1165 {
1166     // variables for template values
1167
1168     // char style
1169     OUString sCharStyle;
1170     bool bCharStyleOK = false;
1171
1172     // text
1173     OUString sText;
1174     bool bTextOK = false;
1175
1176     // tab position
1177     bool bRightAligned = false;
1178
1179     // tab position
1180     sal_Int32 nTabPosition = 0;
1181     bool bTabPositionOK = false;
1182
1183     // fill character
1184     OUString sFillChar;
1185     bool bFillCharOK = false;
1186
1187     // chapter format
1188     sal_Int16 nChapterFormat = 0;
1189     bool bChapterFormatOK = false;
1190
1191     // outline max level
1192     sal_Int16 nLevel = 0;
1193     bool bLevelOK = false;
1194
1195     // Bibliography Data
1196     sal_Int16 nBibliographyData = 0;
1197     bool bBibliographyDataOK = false;
1198
1199     // With Tab Stop #i21237#
1200     bool bWithTabStop = false;
1201     bool bWithTabStopOK = false;
1202
1203     //i90246, the ODF version being written to is:
1204     const SvtSaveOptions::ODFSaneDefaultVersion aODFVersion = rExport.getSaneDefaultVersion();
1205     //the above version cannot be used for old OOo (OOo 1.0) formats!
1206
1207     // token type
1208     enum TemplateTypeEnum nTokenType = TOK_TTYPE_INVALID;
1209
1210     for(const auto& rValue : rValues)
1211     {
1212         TemplateParamEnum nToken;
1213         if ( SvXMLUnitConverter::convertEnum( nToken, rValue.Name,
1214                                               aTemplateParamMap ) )
1215         {
1216             // Only use direct and default values.
1217             // Wrong. no property states, so ignore.
1218             // if ( (beans::PropertyState_DIRECT_VALUE == rValues[i].State) ||
1219             //      (beans::PropertyState_DEFAULT_VALUE == rValues[i].State)  )
1220
1221             switch (nToken)
1222             {
1223                 case TOK_TPARAM_TOKEN_TYPE:
1224                 {
1225                     OUString sVal;
1226                     rValue.Value >>= sVal;
1227                     SvXMLUnitConverter::convertEnum( nTokenType, sVal, aTemplateTypeMap);
1228                     break;
1229                 }
1230
1231                 case TOK_TPARAM_CHAR_STYLE:
1232                     // only valid, if not empty
1233                     rValue.Value >>= sCharStyle;
1234                     bCharStyleOK = !sCharStyle.isEmpty();
1235                     break;
1236
1237                 case TOK_TPARAM_TEXT:
1238                     rValue.Value >>= sText;
1239                     bTextOK = true;
1240                     break;
1241
1242                 case TOK_TPARAM_TAB_RIGHT_ALIGNED:
1243                     bRightAligned =
1244                         *o3tl::doAccess<bool>(rValue.Value);
1245                     break;
1246
1247                 case TOK_TPARAM_TAB_POSITION:
1248                     rValue.Value >>= nTabPosition;
1249                     bTabPositionOK = true;
1250                     break;
1251
1252                 // #i21237#
1253                 case TOK_TPARAM_TAB_WITH_TAB:
1254                     bWithTabStop = *o3tl::doAccess<bool>(rValue.Value);
1255                     bWithTabStopOK = true;
1256                     break;
1257
1258                 case TOK_TPARAM_TAB_FILL_CHAR:
1259                     rValue.Value >>= sFillChar;
1260                     bFillCharOK = true;
1261                     break;
1262
1263                 case TOK_TPARAM_CHAPTER_FORMAT:
1264                     rValue.Value >>= nChapterFormat;
1265                     bChapterFormatOK = true;
1266                     break;
1267 //---> i53420
1268                 case TOK_TPARAM_CHAPTER_LEVEL:
1269                     rValue.Value >>= nLevel;
1270                     bLevelOK = true;
1271                     break;
1272                 case TOK_TPARAM_BIBLIOGRAPHY_DATA:
1273                     rValue.Value >>= nBibliographyData;
1274                     bBibliographyDataOK = true;
1275                     break;
1276             }
1277         }
1278     }
1279
1280     // convert type to token (and check validity) ...
1281     XMLTokenEnum eElement(XML_TOKEN_INVALID);
1282     sal_uInt16 nNamespace(XML_NAMESPACE_TEXT);
1283     switch(nTokenType)
1284     {
1285         case TOK_TTYPE_ENTRY_TEXT:
1286             eElement = XML_INDEX_ENTRY_TEXT;
1287             break;
1288         case TOK_TTYPE_TAB_STOP:
1289             // test validity
1290             if ( bRightAligned || bTabPositionOK || bFillCharOK )
1291             {
1292                 eElement = XML_INDEX_ENTRY_TAB_STOP;
1293             }
1294             break;
1295         case TOK_TTYPE_TEXT:
1296             // test validity
1297             if (bTextOK)
1298             {
1299                 eElement = XML_INDEX_ENTRY_SPAN;
1300             }
1301             break;
1302         case TOK_TTYPE_PAGE_NUMBER:
1303             eElement = XML_INDEX_ENTRY_PAGE_NUMBER;
1304             break;
1305         case TOK_TTYPE_CHAPTER_INFO:    // keyword index
1306             eElement = XML_INDEX_ENTRY_CHAPTER;
1307             break;
1308         case TOK_TTYPE_ENTRY_NUMBER:    // table of content
1309             eElement = XML_INDEX_ENTRY_CHAPTER;
1310             break;
1311         case TOK_TTYPE_HYPERLINK_START:
1312             eElement = XML_INDEX_ENTRY_LINK_START;
1313             break;
1314         case TOK_TTYPE_HYPERLINK_END:
1315             eElement = XML_INDEX_ENTRY_LINK_END;
1316             break;
1317         case TOK_TTYPE_BIBLIOGRAPHY:
1318             if (bBibliographyDataOK)
1319             {
1320                 eElement = XML_INDEX_ENTRY_BIBLIOGRAPHY;
1321             }
1322             break;
1323         default:
1324             ; // unknown/unimplemented template
1325             break;
1326     }
1327
1328     if (eType != TEXT_SECTION_TYPE_TOC)
1329     {
1330         switch (nTokenType)
1331         {
1332             case TOK_TTYPE_HYPERLINK_START:
1333             case TOK_TTYPE_HYPERLINK_END:
1334                 if (SvtSaveOptions::ODFSVER_012 < aODFVersion)
1335                 {
1336                     assert(eType == TEXT_SECTION_TYPE_ILLUSTRATION
1337                         || eType == TEXT_SECTION_TYPE_OBJECT
1338                         || eType == TEXT_SECTION_TYPE_TABLE
1339                         || eType == TEXT_SECTION_TYPE_USER);
1340                     // ODF 1.3 OFFICE-3941
1341                     nNamespace = (SvtSaveOptions::ODFSVER_013 <= aODFVersion)
1342                         ? XML_NAMESPACE_TEXT
1343                         : XML_NAMESPACE_LO_EXT;
1344                 }
1345                 else
1346                 {
1347                     eElement = XML_TOKEN_INVALID; // not allowed in ODF <= 1.2
1348                 }
1349                 break;
1350             default:
1351                 break;
1352         }
1353     }
1354
1355     //--->i90246
1356     //check the ODF version being exported
1357     if (aODFVersion == SvtSaveOptions::ODFSVER_011
1358         || aODFVersion == SvtSaveOptions::ODFSVER_010)
1359     {
1360         bLevelOK = false;
1361         if (TOK_TTYPE_CHAPTER_INFO == nTokenType)
1362         {
1363             //if we are emitting for ODF 1.1 or 1.0, this information can be used for alphabetical index only
1364             //it's not permitted in other indexes
1365             if (eType != TEXT_SECTION_TYPE_ALPHABETICAL)
1366             {
1367                 eElement = XML_TOKEN_INVALID; //not permitted, invalidate the element
1368             }
1369             else //maps format for 1.1 & 1.0
1370             {
1371                 // a few word here: OOo up to 2.4 uses the field chapter info in Alphabetical index
1372                 // in a way different from the ODF 1.1/1.0 specification:
1373
1374                 // ODF1.1/1.0         OOo display in chapter info                       ODF1.2
1375                 //                    (used in alphabetical index only
1376
1377                 // number             chapter number without pre/postfix                plain-number
1378                 // number-and-name    chapter number without pre/postfix plus title     plain-number-and-name
1379
1380                 // with issue i89791 the reading of ODF 1.1 and 1.0 was corrected
1381                 // this one corrects the writing back from ODF 1.2 to ODF 1.1/1.0
1382                 // unfortunately if there is another application which interprets correctly ODF1.1/1.0,
1383                 // the resulting alphabetical index will be rendered wrong by OOo 2.4 version
1384
1385                 switch( nChapterFormat )
1386                 {
1387                 case ChapterFormat::DIGIT:
1388                     nChapterFormat = ChapterFormat::NUMBER;
1389                     break;
1390                 case ChapterFormat::NO_PREFIX_SUFFIX:
1391                     nChapterFormat = ChapterFormat::NAME_NUMBER;
1392                     break;
1393                 }
1394             }
1395         }
1396         else if (TOK_TTYPE_ENTRY_NUMBER == nTokenType)
1397         {
1398             //in case of ODF 1.1 or 1.0 the only allowed number format is "number"
1399             //so, force it...
1400             // The only expected 'foreign' nChapterFormat is
1401             // ' ChapterFormat::DIGIT', forced to 'none, since the
1402             // 'value allowed in ODF 1.1 and 1.0 is 'number' the default
1403             // this can be obtained by simply disabling the chapter format
1404             bChapterFormatOK = false;
1405         }
1406     }
1407
1408     // ... and write Element
1409     if (eElement == XML_TOKEN_INVALID)
1410         return;
1411
1412     // character style (for most templates)
1413     if (bCharStyleOK)
1414     {
1415         switch (nTokenType)
1416         {
1417             case TOK_TTYPE_ENTRY_TEXT:
1418             case TOK_TTYPE_TEXT:
1419             case TOK_TTYPE_PAGE_NUMBER:
1420             case TOK_TTYPE_ENTRY_NUMBER:
1421             case TOK_TTYPE_HYPERLINK_START:
1422             case TOK_TTYPE_HYPERLINK_END:
1423             case TOK_TTYPE_BIBLIOGRAPHY:
1424             case TOK_TTYPE_CHAPTER_INFO:
1425             case TOK_TTYPE_TAB_STOP:
1426                 GetExport().AddAttribute(XML_NAMESPACE_TEXT,
1427                                          XML_STYLE_NAME,
1428                              GetExport().EncodeStyleName( sCharStyle) );
1429                 break;
1430             default:
1431                 ; // nothing: no character style
1432                 break;
1433         }
1434     }
1435
1436     // tab properties
1437     if (TOK_TTYPE_TAB_STOP == nTokenType)
1438     {
1439         // tab type
1440         GetExport().AddAttribute(XML_NAMESPACE_STYLE, XML_TYPE,
1441                                  bRightAligned ? XML_RIGHT : XML_LEFT);
1442
1443         if (bTabPositionOK && (! bRightAligned))
1444         {
1445             // position for left tabs (convert to measure)
1446             OUStringBuffer sBuf;
1447             GetExport().GetMM100UnitConverter().convertMeasureToXML(sBuf,
1448                                                              nTabPosition);
1449             GetExport().AddAttribute(XML_NAMESPACE_STYLE,
1450                                      XML_POSITION,
1451                                      sBuf.makeStringAndClear());
1452         }
1453
1454         // fill char ("leader char")
1455         if (bFillCharOK && !sFillChar.isEmpty())
1456         {
1457             GetExport().AddAttribute(XML_NAMESPACE_STYLE,
1458                                      XML_LEADER_CHAR, sFillChar);
1459         }
1460
1461         // #i21237#
1462         if (bWithTabStopOK && ! bWithTabStop)
1463         {
1464                GetExport().AddAttribute(XML_NAMESPACE_STYLE,
1465                                      XML_WITH_TAB,
1466                                      XML_FALSE);
1467         }
1468     }
1469
1470     // bibliography data
1471     if (TOK_TTYPE_BIBLIOGRAPHY == nTokenType)
1472     {
1473         OSL_ENSURE(bBibliographyDataOK, "need bibl data");
1474         OUStringBuffer sBuf;
1475         if (SvXMLUnitConverter::convertEnum( sBuf, nBibliographyData,
1476                                              aBibliographyDataFieldMap ) )
1477         {
1478             GetExport().AddAttribute(XML_NAMESPACE_TEXT,
1479                                      XML_BIBLIOGRAPHY_DATA_FIELD,
1480                                      sBuf.makeStringAndClear());
1481         }
1482     }
1483
1484     // chapter info
1485     if (TOK_TTYPE_CHAPTER_INFO == nTokenType)
1486     {
1487         OSL_ENSURE(bChapterFormatOK, "need chapter info");
1488         GetExport().AddAttribute(
1489             XML_NAMESPACE_TEXT, XML_DISPLAY,
1490             XMLTextFieldExport::MapChapterDisplayFormat(nChapterFormat));
1491 //---> i53420
1492         if (bLevelOK)
1493             GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_OUTLINE_LEVEL,
1494                                  OUString::number(nLevel));
1495     }
1496
1497 //--->i53420
1498     if (TOK_TTYPE_ENTRY_NUMBER == nTokenType)
1499     {
1500         if (bChapterFormatOK)
1501             GetExport().AddAttribute(
1502                 XML_NAMESPACE_TEXT, XML_DISPLAY,
1503                 XMLTextFieldExport::MapChapterDisplayFormat(nChapterFormat));
1504
1505         if (bLevelOK)
1506             GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_OUTLINE_LEVEL,
1507                                  OUString::number(nLevel));
1508     }
1509     // export template
1510     SvXMLElementExport aTemplateElement(GetExport(), nNamespace,
1511                                         GetXMLToken(eElement),
1512                                         true, false)
1513         ;
1514
1515     // entry text or span element: write text
1516     if (TOK_TTYPE_TEXT == nTokenType)
1517     {
1518         GetExport().Characters(sText);
1519     }
1520 }
1521
1522 void XMLSectionExport::ExportLevelParagraphStyles(
1523     Reference<XIndexReplace> const & xLevelParagraphStyles)
1524 {
1525     // iterate over levels
1526     sal_Int32 nPLevelCount = xLevelParagraphStyles->getCount();
1527     for(sal_Int32 nLevel = 0; nLevel < nPLevelCount; nLevel++)
1528     {
1529         Any aAny = xLevelParagraphStyles->getByIndex(nLevel);
1530         Sequence<OUString> aStyleNames;
1531         aAny >>= aStyleNames;
1532
1533         // export only if at least one style is contained
1534         if (aStyleNames.hasElements())
1535         {
1536             // level attribute; we count 1..10; API 0..9
1537             sal_Int32 nLevelPlusOne = nLevel + 1;
1538             GetExport().AddAttribute(XML_NAMESPACE_TEXT,
1539                                      XML_OUTLINE_LEVEL,
1540                                      OUString::number(nLevelPlusOne));
1541
1542             // source styles element
1543             SvXMLElementExport aParaStyles(GetExport(),
1544                                            XML_NAMESPACE_TEXT,
1545                                            XML_INDEX_SOURCE_STYLES,
1546                                            true, true);
1547
1548             // iterate over styles in this level
1549             for(const auto& rStyleName : std::as_const(aStyleNames))
1550             {
1551                 // stylename attribute
1552                 GetExport().AddAttribute(XML_NAMESPACE_TEXT,
1553                                          XML_STYLE_NAME,
1554                              GetExport().EncodeStyleName(rStyleName) );
1555
1556                 // element
1557                 SvXMLElementExport aParaStyle(GetExport(),
1558                                               XML_NAMESPACE_TEXT,
1559                                               XML_INDEX_SOURCE_STYLE,
1560                                               true, false);
1561             }
1562         }
1563     }
1564 }
1565
1566 void XMLSectionExport::ExportBoolean(
1567     const Reference<XPropertySet> & rPropSet,
1568     const OUString& sPropertyName,
1569     enum XMLTokenEnum eAttributeName,
1570     bool bDefault,
1571     bool bInvert)
1572 {
1573     OSL_ENSURE(eAttributeName != XML_TOKEN_INVALID, "Need attribute name");
1574
1575     Any aAny = rPropSet->getPropertyValue(sPropertyName);
1576     bool bTmp = *o3tl::doAccess<bool>(aAny);
1577
1578     // value = value ^ bInvert
1579     // omit if value == default
1580     if ( (bTmp != bInvert) != bDefault )
1581     {
1582         // export non-default value (since default is omitted)
1583         GetExport().AddAttribute(XML_NAMESPACE_TEXT,
1584                                  eAttributeName,
1585                                  bDefault ? XML_FALSE : XML_TRUE);
1586     }
1587 }
1588
1589 void XMLSectionExport::ExportBibliographyConfiguration(SvXMLExport& rExport)
1590 {
1591     // first: get field master (via text field supplier)
1592     Reference<XTextFieldsSupplier> xTextFieldsSupp( rExport.GetModel(),
1593                                                     UNO_QUERY );
1594     if ( !xTextFieldsSupp.is() )
1595         return;
1596
1597     static constexpr OUString sFieldMaster_Bibliography(u"com.sun.star.text.FieldMaster.Bibliography"_ustr);
1598
1599     // get bibliography field master
1600     Reference<XNameAccess> xMasters =
1601         xTextFieldsSupp->getTextFieldMasters();
1602     if ( !xMasters->hasByName(sFieldMaster_Bibliography) )
1603         return;
1604
1605     Any aAny =
1606         xMasters->getByName(sFieldMaster_Bibliography);
1607     Reference<XPropertySet> xPropSet;
1608     aAny >>= xPropSet;
1609
1610     OSL_ENSURE( xPropSet.is(), "field master must have XPropSet" );
1611
1612     OUString sTmp;
1613
1614     aAny = xPropSet->getPropertyValue("BracketBefore");
1615     aAny >>= sTmp;
1616     rExport.AddAttribute(XML_NAMESPACE_TEXT, XML_PREFIX, sTmp);
1617
1618     aAny = xPropSet->getPropertyValue("BracketAfter");
1619     aAny >>= sTmp;
1620     rExport.AddAttribute(XML_NAMESPACE_TEXT, XML_SUFFIX, sTmp);
1621
1622     aAny = xPropSet->getPropertyValue("IsNumberEntries");
1623     if (*o3tl::doAccess<bool>(aAny))
1624     {
1625         rExport.AddAttribute(XML_NAMESPACE_TEXT,
1626                              XML_NUMBERED_ENTRIES, XML_TRUE);
1627     }
1628
1629     aAny = xPropSet->getPropertyValue("IsSortByPosition");
1630     if (! *o3tl::doAccess<bool>(aAny))
1631     {
1632         rExport.AddAttribute(XML_NAMESPACE_TEXT,
1633                              XML_SORT_BY_POSITION, XML_FALSE);
1634     }
1635
1636     // sort algorithm
1637     aAny = xPropSet->getPropertyValue("SortAlgorithm");
1638     OUString sAlgorithm;
1639     aAny >>= sAlgorithm;
1640     if( !sAlgorithm.isEmpty() )
1641     {
1642         rExport.AddAttribute( XML_NAMESPACE_TEXT,
1643                               XML_SORT_ALGORITHM, sAlgorithm );
1644     }
1645
1646     // locale
1647     aAny = xPropSet->getPropertyValue("Locale");
1648     Locale aLocale;
1649     aAny >>= aLocale;
1650     rExport.AddLanguageTagAttributes( XML_NAMESPACE_FO, XML_NAMESPACE_STYLE, aLocale, true);
1651
1652     // configuration element
1653     SvXMLElementExport aElement(rExport, XML_NAMESPACE_TEXT,
1654                                 XML_BIBLIOGRAPHY_CONFIGURATION,
1655                                 true, true);
1656
1657     // sort keys
1658     aAny = xPropSet->getPropertyValue("SortKeys");
1659     Sequence<Sequence<PropertyValue> > aKeys;
1660     aAny >>= aKeys;
1661     for(const Sequence<PropertyValue> & rKey : std::as_const(aKeys))
1662     {
1663         for(const PropertyValue& rValue : rKey)
1664         {
1665             if (rValue.Name == "SortKey")
1666             {
1667                 sal_Int16 nKey = 0;
1668                 rValue.Value >>= nKey;
1669                 OUStringBuffer sBuf;
1670                 if (SvXMLUnitConverter::convertEnum( sBuf, nKey,
1671                                          aBibliographyDataFieldMap ) )
1672                 {
1673                     rExport.AddAttribute(XML_NAMESPACE_TEXT, XML_KEY,
1674                                          sBuf.makeStringAndClear());
1675                 }
1676             }
1677             else if (rValue.Name == "IsSortAscending")
1678             {
1679                 bool bTmp = *o3tl::doAccess<bool>(rValue.Value);
1680                 rExport.AddAttribute(XML_NAMESPACE_TEXT,
1681                                      XML_SORT_ASCENDING,
1682                                      bTmp ? XML_TRUE : XML_FALSE);
1683             }
1684         }
1685
1686         SvXMLElementExport aKeyElem(rExport,
1687                                     XML_NAMESPACE_TEXT, XML_SORT_KEY,
1688                                     true, true);
1689     }
1690 }
1691
1692
1693 bool XMLSectionExport::IsMuteSection(
1694     const Reference<XTextSection> & rSection) const
1695 {
1696     bool bRet = false;
1697
1698     // a section is mute if
1699     // 1) it exists
1700     // 2) the SaveLinkedSections flag (at the export) is false
1701     // 3) the IsGlobalDocumentSection property is true
1702     // 4) it is not an Index
1703
1704     if ( (!rExport.IsSaveLinkedSections()) && rSection.is() )
1705     {
1706         // walk the section chain and set bRet if any is linked
1707         for(Reference<XTextSection> aSection(rSection);
1708             aSection.is();
1709             aSection = aSection->getParentSection())
1710         {
1711             // check if it is a global document section (linked or index)
1712             Reference<XPropertySet> xPropSet(aSection, UNO_QUERY);
1713             if (xPropSet.is())
1714             {
1715                 Any aAny = xPropSet->getPropertyValue("IsGlobalDocumentSection");
1716
1717                 if ( *o3tl::doAccess<bool>(aAny) )
1718                 {
1719                     Reference<XDocumentIndex> xIndex;
1720                     if (! GetIndex(rSection, xIndex))
1721                     {
1722                         bRet = true;
1723
1724                         // early out if result is known
1725                         break;
1726                     }
1727                 }
1728             }
1729             // section has no properties: ignore
1730         }
1731     }
1732     // else: no section, or always save sections: default (false)
1733
1734     return bRet;
1735 }
1736
1737 bool XMLSectionExport::IsMuteSection(
1738     const Reference<XTextContent> & rSection,
1739     bool bDefault) const
1740 {
1741     // default: like default argument
1742     bool bRet = bDefault;
1743
1744     Reference<XPropertySet> xPropSet(rSection->getAnchor(), UNO_QUERY);
1745     if (xPropSet.is())
1746     {
1747         if (xPropSet->getPropertySetInfo()->hasPropertyByName("TextSection"))
1748         {
1749             Any aAny = xPropSet->getPropertyValue("TextSection");
1750             Reference<XTextSection> xSection;
1751             aAny >>= xSection;
1752
1753             bRet = IsMuteSection(xSection);
1754         }
1755         // else: return default
1756     }
1757     // else: return default
1758
1759     return bRet;
1760 }
1761
1762 bool XMLSectionExport::IsInSection(
1763     const Reference<XTextSection> & rEnclosingSection,
1764     const Reference<XTextContent> & rContent,
1765     bool bDefault)
1766 {
1767     // default: like default argument
1768     bool bRet = bDefault;
1769     OSL_ENSURE(rEnclosingSection.is(), "enclosing section expected");
1770
1771     Reference<XPropertySet> xPropSet(rContent, UNO_QUERY);
1772     if (xPropSet.is())
1773     {
1774         if (xPropSet->getPropertySetInfo()->hasPropertyByName("TextSection"))
1775         {
1776             Any aAny = xPropSet->getPropertyValue("TextSection");
1777             Reference<XTextSection> xSection;
1778             aAny >>= xSection;
1779
1780             // now walk chain of text sections (if we have one)
1781             if (xSection.is())
1782             {
1783                 do
1784                 {
1785                     bRet = (rEnclosingSection == xSection);
1786                     xSection = xSection->getParentSection();
1787                 }
1788                 while (!bRet && xSection.is());
1789             }
1790             else
1791                 bRet = false;   // no section -> can't be inside
1792         }
1793         // else: no TextSection property -> return default
1794     }
1795     // else: no XPropertySet -> return default
1796
1797     return bRet;
1798 }
1799
1800
1801 void XMLSectionExport::ExportMasterDocHeadingDummies()
1802 {
1803     if( bHeadingDummiesExported )
1804         return;
1805
1806     Reference< XChapterNumberingSupplier > xCNSupplier( rExport.GetModel(),
1807                                                         UNO_QUERY );
1808
1809     Reference< XIndexReplace > xChapterNumbering;
1810     if( xCNSupplier.is() )
1811         xChapterNumbering = xCNSupplier->getChapterNumberingRules();
1812
1813     if( !xChapterNumbering.is() )
1814         return;
1815
1816     sal_Int32 nCount = xChapterNumbering->getCount();
1817     for( sal_Int32 nLevel = 0; nLevel < nCount; nLevel++ )
1818     {
1819         OUString sStyle;
1820         Sequence<PropertyValue> aProperties;
1821         xChapterNumbering->getByIndex( nLevel ) >>= aProperties;
1822         auto pProp = std::find_if(std::cbegin(aProperties), std::cend(aProperties),
1823             [](const PropertyValue& rProp) { return rProp.Name == "HeadingStyleName"; });
1824         if (pProp != std::cend(aProperties))
1825             pProp->Value >>= sStyle;
1826
1827         if( !sStyle.isEmpty() )
1828         {
1829             GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_STYLE_NAME,
1830                                       GetExport().EncodeStyleName( sStyle ) );
1831
1832             GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_LEVEL,
1833                                         OUString::number( nLevel + 1 ) );
1834             SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_TEXT, XML_H,
1835                                         true, false );
1836         }
1837     }
1838
1839     bHeadingDummiesExported  = true;
1840 }
1841
1842 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */