LCOV - code coverage report
Current view: top level - xmloff/source/text - XMLSectionExport.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 530 696 76.1 %
Date: 2014-11-03 Functions: 25 28 89.3 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10