mir/libreoffice
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ecece54942a8e5f20ae6dc69f25a2499d38c78bd
libreoffice/xmloff/source/text/XMLSectionExport.cxx
Stephan Bergmann 0d7c582312 New o3tl::try/doGet to obtain value from Any 
...in an attempt to reduce usage of type-unsafe

  void const * css::uno::Any::getValue()

These new functions are often more convenient to use than the existing ">>=" and
Any::get<T>.  Note how they are careful to provide a pointer directly into the
given Any, instead of creating temporaries.

As an example, replaced most calls of getValue across xmloff:

* Cases that first check for a specific type (via getValueType etc.) and then
  call getValue can instead call tryGet.  (But beware that tryGet supports some
  conversions, which a check for a specific type may have missed---either
  intentionally or by accident.  Also beware the somewhat common idiom of
  checking for TypeClass_ENUM and then using getValue to obtain a sal_Int32;
  this cannot be replaced with a call to tryGet.)

* Cases that seem confident that the Any is of the correct type when calling
  getValue (but apparently are confident due to some higher-layer protocol, as
  the surrounding code does not do any checking via getValueType or similar) can
  instead call doGet.  It throws an exception if it turns out the confidence
  wasn't warranted.  (Many of the existing calls that directly dereferenced the
  return value of getValue as sal_Bool look suspicious, in that the author might
  have thought the given code would also cover a VOID Any---which technically it
  even would have happened to do.  If any RuntimeExceptions thrown from these
  doGet calls start to crop up, these changes need to be revisited.  Some may
  even be rewritten as uses of ">>=".  But at least "make check" did not show
  any such problems.  Also note that casting the value obtained from getValue to
  any css::uno::Reference<X> with X being anything but the base
  css::uno::XInterface was always prone to producing a bad pointer, in case the
  interface actually stored in the Any derived from X via multiple inheritance.)

* Should there ever be cases where an Any is known to be of the requested type,
  some additional forceGet could be introduced (which would assert instead of
  throwing an exception).

Change-Id: I2d8739e86314eff73abfcafe01d806f5bc5c34db
2016-06-02 15:33:59 +02:00

1884 lines
66 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#include "XMLSectionExport.hxx"
#include <o3tl/any.hxx>
#include <rtl/ustring.hxx>
#include <rtl/ustrbuf.hxx>
#include <vector>
#include <com/sun/star/lang/Locale.hpp>
#include <com/sun/star/container/XIndexReplace.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/beans/PropertyValue.hpp>
#include <com/sun/star/beans/PropertyValues.hpp>
#include <com/sun/star/text/XText.hpp>
#include <com/sun/star/text/XTextSection.hpp>
#include <com/sun/star/text/SectionFileLink.hpp>
#include <com/sun/star/container/XNamed.hpp>
#include <com/sun/star/container/XNameAccess.hpp>
#include <com/sun/star/text/XDocumentIndex.hpp>
#include <com/sun/star/text/BibliographyDataField.hpp>
#include <com/sun/star/text/XTextFieldsSupplier.hpp>
#include <com/sun/star/text/XChapterNumberingSupplier.hpp>
#include <com/sun/star/text/ChapterFormat.hpp>
#include <sax/tools/converter.hxx>
#include <xmloff/xmltoken.hxx>
#include <xmloff/xmlnmspe.hxx>
#include <xmloff/families.hxx>
#include <xmloff/xmluconv.hxx>
#include <xmloff/nmspmap.hxx>
#include <xmloff/xmlexp.hxx>
#include <xmloff/xmltkmap.hxx>
#include "txtflde.hxx"
using namespace ::com::sun::star;
using namespace ::com::sun::star::text;
using namespace ::com::sun::star::uno;
using namespace ::std;
using namespace ::xmloff::token;
using ::com::sun::star::beans::XPropertySet;
using ::com::sun::star::beans::PropertyValue;
using ::com::sun::star::beans::PropertyValues;
using ::com::sun::star::container::XIndexReplace;
using ::com::sun::star::container::XNameAccess;
using ::com::sun::star::container::XNamed;
using ::com::sun::star::lang::Locale;
XMLSectionExport::XMLSectionExport(
SvXMLExport& rExp,
XMLTextParagraphExport& rParaExp)
: sCondition("Condition")
, sCreateFromChapter("CreateFromChapter")
, sCreateFromEmbeddedObjects("CreateFromEmbeddedObjects")
, sCreateFromGraphicObjects("CreateFromGraphicObjects")
, sCreateFromLabels("CreateFromLabels")
, sCreateFromMarks("CreateFromMarks")
, sCreateFromOtherEmbeddedObjects("CreateFromOtherEmbeddedObjects")
, sCreateFromOutline("CreateFromOutline")
, sCreateFromStarCalc("CreateFromStarCalc")
, sCreateFromStarChart("CreateFromStarChart")
, sCreateFromStarDraw("CreateFromStarDraw")
, sCreateFromStarMath("CreateFromStarMath")
, sCreateFromTables("CreateFromTables")
, sCreateFromTextFrames("CreateFromTextFrames")
, sDdeCommandElement("DDECommandElement")
, sDdeCommandFile("DDECommandFile")
, sDdeCommandType("DDECommandType")
, sFileLink("FileLink")
, sIsCaseSensitive("IsCaseSensitive")
, sIsProtected("IsProtected")
, sIsVisible("IsVisible")
, sLabelCategory("LabelCategory")
, sLabelDisplayType("LabelDisplayType")
, sLevel("Level")
, sLevelFormat("LevelFormat")
, sLevelParagraphStyles("LevelParagraphStyles")
, sLinkRegion("LinkRegion")
, sMainEntryCharacterStyleName("MainEntryCharacterStyleName")
, sParaStyleHeading("ParaStyleHeading")
, sTitle("Title")
, sName("Name")
, sUseAlphabeticalSeparators("UseAlphabeticalSeparators")
, sUseCombinedEntries("UseCombinedEntries")
, sUseDash("UseDash")
, sUseKeyAsEntry("UseKeyAsEntry")
, sUseLevelFromSource("UseLevelFromSource")
, sUsePP("UsePP")
, sUseUpperCase("UseUpperCase")
, sIsCommaSeparated("IsCommaSeparated")
, sIsAutomaticUpdate("IsAutomaticUpdate")
, sIsRelativeTabstops("IsRelativeTabstops")
, sCreateFromLevelParagraphStyles("CreateFromLevelParagraphStyles")
, sDocumentIndex("DocumentIndex")
, sContentSection("ContentSection")
, sHeaderSection("HeaderSection")
, sTextSection("TextSection")
, sIsGlobalDocumentSection("IsGlobalDocumentSection")
, sProtectionKey("ProtectionKey")
, sSortAlgorithm("SortAlgorithm")
, sLocale("Locale")
, sUserIndexName("UserIndexName")
, sIsCurrentlyVisible("IsCurrentlyVisible")
, sHeadingStyleName("HeadingStyleName")
, rExport(rExp)
, rParaExport(rParaExp)
, bHeadingDummiesExported( false )
{
}
void XMLSectionExport::ExportSectionStart(
const Reference<XTextSection> & rSection,
bool bAutoStyles)
{
Reference<XPropertySet> xPropertySet(rSection, UNO_QUERY);
// always export section (auto) style
if (bAutoStyles)
{
// get PropertySet and add section style
GetParaExport().Add( XML_STYLE_FAMILY_TEXT_SECTION, xPropertySet );
}
else
{
// always export section style
GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_STYLE_NAME,
GetParaExport().Find(
XML_STYLE_FAMILY_TEXT_SECTION,
xPropertySet, "" ) );
// xml:id for RDF metadata
GetExport().AddAttributeXmlId(rSection);
// export index or regular section
Reference<XDocumentIndex> xIndex;
if (GetIndex(rSection, xIndex))
{
if (xIndex.is())
{
// we are an index
ExportIndexStart(xIndex);
}
else
{
// we are an index header
ExportIndexHeaderStart(rSection);
}
}
else
{
// we are not an index
ExportRegularSectionStart(rSection);
}
}
}
bool XMLSectionExport::GetIndex(
const Reference<XTextSection> & rSection,
Reference<XDocumentIndex> & rIndex) const
{
// first, reset result
bool bRet = false;
rIndex = nullptr;
// get section Properties
Reference<XPropertySet> xSectionPropSet(rSection, UNO_QUERY);
// then check if this section happens to be inside an index
if (xSectionPropSet->getPropertySetInfo()->
hasPropertyByName(sDocumentIndex))
{
Any aAny = xSectionPropSet->getPropertyValue(sDocumentIndex);
Reference<XDocumentIndex> xDocumentIndex;
aAny >>= xDocumentIndex;
// OK, are we inside of an index
if (xDocumentIndex.is())
{
// is the enclosing index identical with "our" section?
Reference<XPropertySet> xIndexPropSet(xDocumentIndex, UNO_QUERY);
aAny = xIndexPropSet->getPropertyValue(sContentSection);
Reference<XTextSection> xEnclosingSection;
aAny >>= xEnclosingSection;
// if the enclosing section is "our" section, then we are an index!
if (rSection == xEnclosingSection)
{
rIndex = xDocumentIndex;
bRet = true;
}
// else: index header or regular section
// is the enclosing index identical with the header section?
aAny = xIndexPropSet->getPropertyValue(sHeaderSection);
// now mis-named: contains header section
aAny >>= xEnclosingSection;
// if the enclosing section is "our" section, then we are an index!
if (rSection == xEnclosingSection)
{
bRet = true;
}
// else: regular section
}
// else: we aren't even inside of an index
}
// else: we don't even know what an index is.
return bRet;
}
void XMLSectionExport::ExportSectionEnd(
const Reference<XTextSection> & rSection,
bool bAutoStyles)
{
// no end section for styles
if (!bAutoStyles)
{
enum XMLTokenEnum eElement = XML_TOKEN_INVALID;
// export index or regular section end
Reference<XDocumentIndex> xIndex;
if (GetIndex(rSection, xIndex))
{
if (xIndex.is())
{
// index end: close index body element
GetExport().EndElement( XML_NAMESPACE_TEXT, XML_INDEX_BODY,
true );
GetExport().IgnorableWhitespace();
switch (MapSectionType(xIndex->getServiceName()))
{
case TEXT_SECTION_TYPE_TOC:
eElement = XML_TABLE_OF_CONTENT;
break;
case TEXT_SECTION_TYPE_ILLUSTRATION:
eElement = XML_ILLUSTRATION_INDEX;
break;
case TEXT_SECTION_TYPE_ALPHABETICAL:
eElement = XML_ALPHABETICAL_INDEX;
break;
case TEXT_SECTION_TYPE_TABLE:
eElement = XML_TABLE_INDEX;
break;
case TEXT_SECTION_TYPE_OBJECT:
eElement = XML_OBJECT_INDEX;
break;
case TEXT_SECTION_TYPE_USER:
eElement = XML_USER_INDEX;
break;
case TEXT_SECTION_TYPE_BIBLIOGRAPHY:
eElement = XML_BIBLIOGRAPHY;
break;
default:
OSL_FAIL("unknown index type");
// default: skip index!
break;
}
}
else
{
eElement = XML_INDEX_TITLE;
}
}
else
{
eElement = XML_SECTION;
}
if (XML_TOKEN_INVALID != eElement)
{
// any old attributes?
GetExport().CheckAttrList();
// element surrounded by whitespace
GetExport().EndElement( XML_NAMESPACE_TEXT, eElement, true);
GetExport().IgnorableWhitespace();
}
else
{
OSL_FAIL("Need element name!");
}
}
// else: autostyles -> ignore
}
void XMLSectionExport::ExportIndexStart(
const Reference<XDocumentIndex> & rIndex)
{
// get PropertySet
Reference<XPropertySet> xPropertySet(rIndex, UNO_QUERY);
switch (MapSectionType(rIndex->getServiceName()))
{
case TEXT_SECTION_TYPE_TOC:
ExportTableOfContentStart(xPropertySet);
break;
case TEXT_SECTION_TYPE_ILLUSTRATION:
ExportIllustrationIndexStart(xPropertySet);
break;
case TEXT_SECTION_TYPE_ALPHABETICAL:
ExportAlphabeticalIndexStart(xPropertySet);
break;
case TEXT_SECTION_TYPE_TABLE:
ExportTableIndexStart(xPropertySet);
break;
case TEXT_SECTION_TYPE_OBJECT:
ExportObjectIndexStart(xPropertySet);
break;
case TEXT_SECTION_TYPE_USER:
ExportUserIndexStart(xPropertySet);
break;
case TEXT_SECTION_TYPE_BIBLIOGRAPHY:
ExportBibliographyStart(xPropertySet);
break;
default:
// skip index
OSL_FAIL("unknown index type");
break;
}
}
void XMLSectionExport::ExportIndexHeaderStart(
const Reference<XTextSection> & rSection)
{
// export name, dammit!
Reference<XNamed> xName(rSection, UNO_QUERY);
GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_NAME, xName->getName());
// format already handled -> export only start element
GetExport().StartElement( XML_NAMESPACE_TEXT, XML_INDEX_TITLE, true );
GetExport().IgnorableWhitespace();
}
SvXMLEnumStringMapEntry const aIndexTypeMap[] =
{
ENUM_STRING_MAP_ENTRY( "com.sun.star.text.ContentIndex", TEXT_SECTION_TYPE_TOC ),
ENUM_STRING_MAP_ENTRY( "com.sun.star.text.DocumentIndex", TEXT_SECTION_TYPE_ALPHABETICAL ),
ENUM_STRING_MAP_ENTRY( "com.sun.star.text.TableIndex", TEXT_SECTION_TYPE_TABLE ),
ENUM_STRING_MAP_ENTRY( "com.sun.star.text.ObjectIndex", TEXT_SECTION_TYPE_OBJECT ),
ENUM_STRING_MAP_ENTRY( "com.sun.star.text.Bibliography", TEXT_SECTION_TYPE_BIBLIOGRAPHY ),
ENUM_STRING_MAP_ENTRY( "com.sun.star.text.UserIndex", TEXT_SECTION_TYPE_USER ),
ENUM_STRING_MAP_ENTRY( "com.sun.star.text.IllustrationsIndex", TEXT_SECTION_TYPE_ILLUSTRATION ),
ENUM_STRING_MAP_END()
};
enum SectionTypeEnum XMLSectionExport::MapSectionType(
const OUString& rServiceName)
{
enum SectionTypeEnum eType = TEXT_SECTION_TYPE_UNKNOWN;
sal_uInt16 nTmp;
if (SvXMLUnitConverter::convertEnum(nTmp, rServiceName, aIndexTypeMap))
{
eType = (enum SectionTypeEnum)nTmp;
}
// TODO: index header section types, etc.
return eType;
}
void XMLSectionExport::ExportRegularSectionStart(
const Reference<XTextSection> & rSection)
{
// style name already handled in ExportSectionStart(...)
Reference<XNamed> xName(rSection, UNO_QUERY);
GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_NAME, xName->getName());
// get XPropertySet for other values
Reference<XPropertySet> xPropSet(rSection, UNO_QUERY);
Any aAny;
// condition and display
aAny = xPropSet->getPropertyValue(sCondition);
OUString sCond;
aAny >>= sCond;
enum XMLTokenEnum eDisplay = XML_TOKEN_INVALID;
if (!sCond.isEmpty())
{
OUString sQValue =
GetExport().GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OOOW,
sCond, false );
GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_CONDITION, sQValue);
eDisplay = XML_CONDITION;
// #97450# store hidden-status (of conditional sections only)
aAny = xPropSet->getPropertyValue(sIsCurrentlyVisible);
if (! *o3tl::doGet<bool>(aAny))
{
GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_IS_HIDDEN,
XML_TRUE);
}
}
else
{
eDisplay = XML_NONE;
}
aAny = xPropSet->getPropertyValue(sIsVisible);
if (! *o3tl::doGet<bool>(aAny))
{
GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_DISPLAY, eDisplay);
}
// protect + protection key
aAny = xPropSet->getPropertyValue(sIsProtected);
if (*o3tl::doGet<bool>(aAny))
{
GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_PROTECTED, XML_TRUE);
}
Sequence<sal_Int8> aPassword;
xPropSet->getPropertyValue(sProtectionKey) >>= aPassword;
if (aPassword.getLength() > 0)
{
OUStringBuffer aBuffer;
::sax::Converter::encodeBase64(aBuffer, aPassword);
GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_PROTECTION_KEY,
aBuffer.makeStringAndClear());
}
// export element
GetExport().IgnorableWhitespace();
GetExport().StartElement( XML_NAMESPACE_TEXT, XML_SECTION, true );
// data source
// unfortunately, we have to test all relevant strings for non-zero length
aAny = xPropSet->getPropertyValue(sFileLink);
SectionFileLink aFileLink;
aAny >>= aFileLink;
aAny = xPropSet->getPropertyValue(sLinkRegion);
OUString sRegionName;
aAny >>= sRegionName;
if ( !aFileLink.FileURL.isEmpty() ||
!aFileLink.FilterName.isEmpty() ||
!sRegionName.isEmpty())
{
if (!aFileLink.FileURL.isEmpty())
{
GetExport().AddAttribute(XML_NAMESPACE_XLINK, XML_HREF,
GetExport().GetRelativeReference( aFileLink.FileURL) );
}
if (!aFileLink.FilterName.isEmpty())
{
GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_FILTER_NAME,
aFileLink.FilterName);
}
if (!sRegionName.isEmpty())
{
GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_SECTION_NAME,
sRegionName);
}
SvXMLElementExport aElem(GetExport(),
XML_NAMESPACE_TEXT, XML_SECTION_SOURCE,
true, true);
}
else
{
// check for DDE first
if (xPropSet->getPropertySetInfo()->hasPropertyByName(sDdeCommandFile))
{
// data source DDE
// unfortunately, we have to test all relevant strings for
// non-zero length
aAny = xPropSet->getPropertyValue(sDdeCommandFile);
OUString sApplication;
aAny >>= sApplication;
aAny = xPropSet->getPropertyValue(sDdeCommandType);
OUString sTopic;
aAny >>= sTopic;
aAny = xPropSet->getPropertyValue(sDdeCommandElement);
OUString sItem;
aAny >>= sItem;
if ( !sApplication.isEmpty() ||
!sTopic.isEmpty() ||
!sItem.isEmpty())
{
GetExport().AddAttribute(XML_NAMESPACE_OFFICE,
XML_DDE_APPLICATION, sApplication);
GetExport().AddAttribute(XML_NAMESPACE_OFFICE, XML_DDE_TOPIC,
sTopic);
GetExport().AddAttribute(XML_NAMESPACE_OFFICE, XML_DDE_ITEM,
sItem);
aAny = xPropSet->getPropertyValue(sIsAutomaticUpdate);
if (*o3tl::doGet<bool>(aAny))
{
GetExport().AddAttribute(XML_NAMESPACE_OFFICE,
XML_AUTOMATIC_UPDATE, XML_TRUE);
}
SvXMLElementExport aElem(GetExport(),
XML_NAMESPACE_OFFICE,
XML_DDE_SOURCE, true, true);
}
// else: no DDE data source
}
// else: no DDE on this system
}
}
void XMLSectionExport::ExportTableOfContentStart(
const Reference<XPropertySet> & rPropertySet)
{
// export TOC element start
ExportBaseIndexStart(XML_TABLE_OF_CONTENT, rPropertySet);
// scope for table-of-content-source element
{
// TOC specific index source attributes:
// outline-level: 1..10
sal_Int16 nLevel = sal_Int16();
if( rPropertySet->getPropertyValue(sLevel) >>= nLevel )
{
OUStringBuffer sBuffer;
::sax::Converter::convertNumber(sBuffer, (sal_Int32)nLevel);
GetExport().AddAttribute(XML_NAMESPACE_TEXT,
XML_OUTLINE_LEVEL,
sBuffer.makeStringAndClear());
}
// use outline level
ExportBoolean(rPropertySet, sCreateFromOutline,
XML_USE_OUTLINE_LEVEL, true);
// use index marks
ExportBoolean(rPropertySet, sCreateFromMarks,
XML_USE_INDEX_MARKS, true);
// use level styles
ExportBoolean(rPropertySet, sCreateFromLevelParagraphStyles,
XML_USE_INDEX_SOURCE_STYLES, false);
ExportBaseIndexSource(TEXT_SECTION_TYPE_TOC, rPropertySet);
}
ExportBaseIndexBody(TEXT_SECTION_TYPE_TOC, rPropertySet);
}
void XMLSectionExport::ExportObjectIndexStart(
const Reference<XPropertySet> & rPropertySet)
{
// export index start
ExportBaseIndexStart(XML_OBJECT_INDEX, rPropertySet);
// scope for index source element
{
ExportBoolean(rPropertySet, sCreateFromOtherEmbeddedObjects,
XML_USE_OTHER_OBJECTS, false);
ExportBoolean(rPropertySet, sCreateFromStarCalc,
XML_USE_SPREADSHEET_OBJECTS, false);
ExportBoolean(rPropertySet, sCreateFromStarChart,
XML_USE_CHART_OBJECTS, false);
ExportBoolean(rPropertySet, sCreateFromStarDraw,
XML_USE_DRAW_OBJECTS, false);
ExportBoolean(rPropertySet, sCreateFromStarMath,
XML_USE_MATH_OBJECTS, false);
ExportBaseIndexSource(TEXT_SECTION_TYPE_OBJECT, rPropertySet);
}
ExportBaseIndexBody(TEXT_SECTION_TYPE_OBJECT, rPropertySet);
}
void XMLSectionExport::ExportIllustrationIndexStart(
const Reference<XPropertySet> & rPropertySet)
{
// export index start
ExportBaseIndexStart(XML_ILLUSTRATION_INDEX, rPropertySet);
// scope for index source element
{
// export common attributes for illustration and table indices
ExportTableAndIllustrationIndexSourceAttributes(rPropertySet);
ExportBaseIndexSource(TEXT_SECTION_TYPE_ILLUSTRATION, rPropertySet);
}
ExportBaseIndexBody(TEXT_SECTION_TYPE_ILLUSTRATION, rPropertySet);
}
void XMLSectionExport::ExportTableIndexStart(
const Reference<XPropertySet> & rPropertySet)
{
// export index start
ExportBaseIndexStart(XML_TABLE_INDEX, rPropertySet);
// scope for index source element
{
// export common attributes for illustration and table indices
ExportTableAndIllustrationIndexSourceAttributes(rPropertySet);
ExportBaseIndexSource(TEXT_SECTION_TYPE_TABLE, rPropertySet);
}
ExportBaseIndexBody(TEXT_SECTION_TYPE_TABLE, rPropertySet);
}
void XMLSectionExport::ExportAlphabeticalIndexStart(
const Reference<XPropertySet> & rPropertySet)
{
// export TOC element start
ExportBaseIndexStart(XML_ALPHABETICAL_INDEX, rPropertySet);
// scope for table-of-content-source element
{
// style name (if present)
Any aAny;
aAny = rPropertySet->getPropertyValue(sMainEntryCharacterStyleName);
OUString sStyleName;
aAny >>= sStyleName;
if (!sStyleName.isEmpty())
{
GetExport().AddAttribute(XML_NAMESPACE_TEXT,
XML_MAIN_ENTRY_STYLE_NAME,
GetExport().EncodeStyleName( sStyleName ));
}
// other (boolean) attributes
ExportBoolean(rPropertySet, sIsCaseSensitive, XML_IGNORE_CASE,
false, true);
ExportBoolean(rPropertySet, sUseAlphabeticalSeparators,
XML_ALPHABETICAL_SEPARATORS, false);
ExportBoolean(rPropertySet, sUseCombinedEntries, XML_COMBINE_ENTRIES,
true);
ExportBoolean(rPropertySet, sUseDash, XML_COMBINE_ENTRIES_WITH_DASH,
false);
ExportBoolean(rPropertySet, sUseKeyAsEntry, XML_USE_KEYS_AS_ENTRIES,
false);
ExportBoolean(rPropertySet, sUsePP, XML_COMBINE_ENTRIES_WITH_PP,
true);
ExportBoolean(rPropertySet, sUseUpperCase, XML_CAPITALIZE_ENTRIES,
false);
ExportBoolean(rPropertySet, sIsCommaSeparated, XML_COMMA_SEPARATED,
false);
// sort algorithm
aAny = rPropertySet->getPropertyValue(sSortAlgorithm);
OUString sAlgorithm;
aAny >>= sAlgorithm;
if (!sAlgorithm.isEmpty())
{
GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_SORT_ALGORITHM,
sAlgorithm );
}
// locale
aAny = rPropertySet->getPropertyValue(sLocale);
Locale aLocale;
aAny >>= aLocale;
GetExport().AddLanguageTagAttributes( XML_NAMESPACE_FO, XML_NAMESPACE_STYLE, aLocale, true);
ExportBaseIndexSource(TEXT_SECTION_TYPE_ALPHABETICAL, rPropertySet);
}
ExportBaseIndexBody(TEXT_SECTION_TYPE_ALPHABETICAL, rPropertySet);
}
void XMLSectionExport::ExportUserIndexStart(
const Reference<XPropertySet> & rPropertySet)
{
// export TOC element start
ExportBaseIndexStart(XML_USER_INDEX, rPropertySet);
// scope for table-of-content-source element
{
// bool attributes
ExportBoolean(rPropertySet, sCreateFromEmbeddedObjects,
XML_USE_OBJECTS, false);
ExportBoolean(rPropertySet, sCreateFromGraphicObjects,
XML_USE_GRAPHICS, false);
ExportBoolean(rPropertySet, sCreateFromMarks,
XML_USE_INDEX_MARKS, false);
ExportBoolean(rPropertySet, sCreateFromTables,
XML_USE_TABLES, false);
ExportBoolean(rPropertySet, sCreateFromTextFrames,
XML_USE_FLOATING_FRAMES, false);
ExportBoolean(rPropertySet, sUseLevelFromSource,
XML_COPY_OUTLINE_LEVELS, false);
ExportBoolean(rPropertySet, sCreateFromLevelParagraphStyles,
XML_USE_INDEX_SOURCE_STYLES, false);
Any aAny = rPropertySet->getPropertyValue( sUserIndexName );
OUString sIndexName;
aAny >>= sIndexName;
GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_INDEX_NAME,
sIndexName);
ExportBaseIndexSource(TEXT_SECTION_TYPE_USER, rPropertySet);
}
ExportBaseIndexBody(TEXT_SECTION_TYPE_USER, rPropertySet);
}
void XMLSectionExport::ExportBibliographyStart(
const Reference<XPropertySet> & rPropertySet)
{
// export TOC element start
ExportBaseIndexStart(XML_BIBLIOGRAPHY, rPropertySet);
// scope for table-of-content-source element
{
// No attributes. Fine.
ExportBaseIndexSource(TEXT_SECTION_TYPE_BIBLIOGRAPHY, rPropertySet);
}
ExportBaseIndexBody(TEXT_SECTION_TYPE_BIBLIOGRAPHY, rPropertySet);
}
void XMLSectionExport::ExportBaseIndexStart(
XMLTokenEnum eElement,
const Reference<XPropertySet> & rPropertySet)
{
// protect + protection key
Any aAny = rPropertySet->getPropertyValue(sIsProtected);
if (*o3tl::doGet<bool>(aAny))
{
GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_PROTECTED, XML_TRUE);
}
// index name
OUString sIndexName;
rPropertySet->getPropertyValue(sName) >>= sIndexName;
if ( !sIndexName.isEmpty() )
{
GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_NAME, sIndexName);
}
// index Element start
GetExport().IgnorableWhitespace();
GetExport().StartElement( XML_NAMESPACE_TEXT, eElement, false );
}
static const XMLTokenEnum aTypeSourceElementNameMap[] =
{
XML_TABLE_OF_CONTENT_SOURCE, // TOC
XML_TABLE_INDEX_SOURCE, // table index
XML_ILLUSTRATION_INDEX_SOURCE, // illustration index
XML_OBJECT_INDEX_SOURCE, // object index
XML_USER_INDEX_SOURCE, // user index
XML_ALPHABETICAL_INDEX_SOURCE, // alphabetical index
XML_BIBLIOGRAPHY_SOURCE // bibliography
};
void XMLSectionExport::ExportBaseIndexSource(
SectionTypeEnum eType,
const Reference<XPropertySet> & rPropertySet)
{
// check type
OSL_ENSURE(eType >= TEXT_SECTION_TYPE_TOC, "illegal index type");
OSL_ENSURE(eType <= TEXT_SECTION_TYPE_BIBLIOGRAPHY, "illegal index type");
Any aAny;
// common attributes; not supported by bibliography
if (eType != TEXT_SECTION_TYPE_BIBLIOGRAPHY)
{
// document or chapter index?
aAny = rPropertySet->getPropertyValue(sCreateFromChapter);
if (*o3tl::doGet<bool>(aAny))
{
GetExport().AddAttribute(XML_NAMESPACE_TEXT,
XML_INDEX_SCOPE, XML_CHAPTER);
}
// tab-stops relative to margin?
aAny = rPropertySet->getPropertyValue(sIsRelativeTabstops);
if (! *o3tl::doGet<bool>(aAny))
{
GetExport().AddAttribute(XML_NAMESPACE_TEXT,
XML_RELATIVE_TAB_STOP_POSITION,
XML_FALSE);
}
}
// the index source element (all indices)
SvXMLElementExport aElem(GetExport(),
XML_NAMESPACE_TEXT,
GetXMLToken(
aTypeSourceElementNameMap[
eType - TEXT_SECTION_TYPE_TOC]),
true, true);
// scope for title template (all indices)
{
// header style name
aAny = rPropertySet->getPropertyValue(sParaStyleHeading);
OUString sStyleName;
aAny >>= sStyleName;
GetExport().AddAttribute(XML_NAMESPACE_TEXT,
XML_STYLE_NAME,
GetExport().EncodeStyleName( sStyleName ));
// title template
SvXMLElementExport aHeaderTemplate(GetExport(),
XML_NAMESPACE_TEXT,
XML_INDEX_TITLE_TEMPLATE,
true, false);
// title as element content
aAny = rPropertySet->getPropertyValue(sTitle);
OUString sTitleString;
aAny >>= sTitleString;
GetExport().Characters(sTitleString);
}
// export level templates (all indices)
aAny = rPropertySet->getPropertyValue(sLevelFormat);
Reference<XIndexReplace> xLevelTemplates;
aAny >>= xLevelTemplates;
// iterate over level formats;
// skip element 0 (empty template for title)
sal_Int32 nLevelCount = xLevelTemplates->getCount();
for(sal_Int32 i = 1; i<nLevelCount; i++)
{
// get sequence
Sequence<PropertyValues> aTemplateSequence;
aAny = xLevelTemplates->getByIndex(i);
aAny >>= aTemplateSequence;
// export the sequence (abort export if an error occurred; #91214#)
bool bResult =
ExportIndexTemplate(eType, i, rPropertySet, aTemplateSequence);
if ( !bResult )
break;
}
// only TOC and user index:
// styles from which to build the index (LevelParagraphStyles)
if ( (TEXT_SECTION_TYPE_TOC == eType) ||
(TEXT_SECTION_TYPE_USER == eType) )
{
aAny = rPropertySet->getPropertyValue(sLevelParagraphStyles);
Reference<XIndexReplace> xLevelParagraphStyles;
aAny >>= xLevelParagraphStyles;
ExportLevelParagraphStyles(xLevelParagraphStyles);
}
}
void XMLSectionExport::ExportBaseIndexBody(
SectionTypeEnum eType,
const Reference<XPropertySet> &)
{
// type not used; checked anyway.
OSL_ENSURE(eType >= TEXT_SECTION_TYPE_TOC, "illegal index type");
OSL_ENSURE(eType <= TEXT_SECTION_TYPE_BIBLIOGRAPHY, "illegal index type");
// export start only
// any old attributes?
GetExport().CheckAttrList();
// start surrounded by whitespace
GetExport().IgnorableWhitespace();
GetExport().StartElement( XML_NAMESPACE_TEXT, XML_INDEX_BODY, true );
}
void XMLSectionExport::ExportTableAndIllustrationIndexSourceAttributes(
const Reference<XPropertySet> & rPropertySet)
{
// use caption
Any aAny = rPropertySet->getPropertyValue(sCreateFromLabels);
if (! *o3tl::doGet<bool>(aAny))
{
GetExport().AddAttribute(XML_NAMESPACE_TEXT,
XML_USE_CAPTION, XML_FALSE);
}
// sequence name
aAny = rPropertySet->getPropertyValue(sLabelCategory);
OUString sSequenceName;
aAny >>= sSequenceName;
GetExport().AddAttribute(XML_NAMESPACE_TEXT,
XML_CAPTION_SEQUENCE_NAME,
sSequenceName);
// caption format
aAny = rPropertySet->getPropertyValue(sLabelDisplayType);
sal_Int16 nType = 0;
aAny >>= nType;
GetExport().AddAttribute(XML_NAMESPACE_TEXT,
XML_CAPTION_SEQUENCE_FORMAT,
XMLTextFieldExport::MapReferenceType(nType));
}
// map index of LevelFormats to attribute value;
// level 0 is always the header
static const XMLTokenEnum aLevelNameTOCMap[] =
{ XML_TOKEN_INVALID, XML_1, XML_2, XML_3, XML_4, XML_5, XML_6, XML_7,
XML_8, XML_9, XML_10, XML_TOKEN_INVALID };
static const XMLTokenEnum aLevelNameTableMap[] =
{ XML_TOKEN_INVALID, XML__EMPTY, XML_TOKEN_INVALID };
static const XMLTokenEnum aLevelNameAlphaMap[] =
{ XML_TOKEN_INVALID, XML_SEPARATOR, XML_1, XML_2, XML_3, XML_TOKEN_INVALID };
static const XMLTokenEnum aLevelNameBibliographyMap[] =
{ XML_TOKEN_INVALID, XML_ARTICLE, XML_BOOK, XML_BOOKLET, XML_CONFERENCE,
XML_CUSTOM1, XML_CUSTOM2, XML_CUSTOM3, XML_CUSTOM4,
XML_CUSTOM5, XML_EMAIL, XML_INBOOK, XML_INCOLLECTION,
XML_INPROCEEDINGS, XML_JOURNAL,
XML_MANUAL, XML_MASTERSTHESIS, XML_MISC, XML_PHDTHESIS,
XML_PROCEEDINGS, XML_TECHREPORT, XML_UNPUBLISHED, XML_WWW,
XML_TOKEN_INVALID };
static const XMLTokenEnum* aTypeLevelNameMap[] =
{
aLevelNameTOCMap, // TOC
aLevelNameTableMap, // table index
aLevelNameTableMap, // illustration index
aLevelNameTableMap, // object index
aLevelNameTOCMap, // user index
aLevelNameAlphaMap, // alphabetical index
aLevelNameBibliographyMap // bibliography
};
static const sal_Char* aLevelStylePropNameTOCMap[] =
{ nullptr, "ParaStyleLevel1", "ParaStyleLevel2", "ParaStyleLevel3",
"ParaStyleLevel4", "ParaStyleLevel5", "ParaStyleLevel6",
"ParaStyleLevel7", "ParaStyleLevel8", "ParaStyleLevel9",
"ParaStyleLevel10", nullptr };
static const sal_Char* aLevelStylePropNameTableMap[] =
{ nullptr, "ParaStyleLevel1", nullptr };
static const sal_Char* aLevelStylePropNameAlphaMap[] =
{ nullptr, "ParaStyleSeparator", "ParaStyleLevel1", "ParaStyleLevel2",
"ParaStyleLevel3", nullptr };
static const sal_Char* aLevelStylePropNameBibliographyMap[] =
// TODO: replace with real property names, when available
{ nullptr, "ParaStyleLevel1", "ParaStyleLevel1", "ParaStyleLevel1",
"ParaStyleLevel1", "ParaStyleLevel1", "ParaStyleLevel1",
"ParaStyleLevel1", "ParaStyleLevel1", "ParaStyleLevel1",
"ParaStyleLevel1", "ParaStyleLevel1", "ParaStyleLevel1",
"ParaStyleLevel1", "ParaStyleLevel1", "ParaStyleLevel1",
"ParaStyleLevel1", "ParaStyleLevel1", "ParaStyleLevel1",
"ParaStyleLevel1", "ParaStyleLevel1", "ParaStyleLevel1",
"ParaStyleLevel1",
nullptr };
static const sal_Char** aTypeLevelStylePropNameMap[] =
{
aLevelStylePropNameTOCMap, // TOC
aLevelStylePropNameTableMap, // table index
aLevelStylePropNameTableMap, // illustration index
aLevelStylePropNameTableMap, // object index
aLevelStylePropNameTOCMap, // user index
aLevelStylePropNameAlphaMap, // alphabetical index
aLevelStylePropNameBibliographyMap // bibliography
};
static const XMLTokenEnum aTypeLevelAttrMap[] =
{
XML_OUTLINE_LEVEL, // TOC
XML_TOKEN_INVALID, // table index
XML_TOKEN_INVALID, // illustration index
XML_TOKEN_INVALID, // object index
XML_OUTLINE_LEVEL, // user index
XML_OUTLINE_LEVEL, // alphabetical index
XML_BIBLIOGRAPHY_TYPE // bibliography
};
static const XMLTokenEnum aTypeElementNameMap[] =
{
XML_TABLE_OF_CONTENT_ENTRY_TEMPLATE, // TOC
XML_TABLE_INDEX_ENTRY_TEMPLATE, // table index
XML_ILLUSTRATION_INDEX_ENTRY_TEMPLATE, // illustration index
XML_OBJECT_INDEX_ENTRY_TEMPLATE, // object index
XML_USER_INDEX_ENTRY_TEMPLATE, // user index
XML_ALPHABETICAL_INDEX_ENTRY_TEMPLATE, // alphabetical index
XML_BIBLIOGRAPHY_ENTRY_TEMPLATE // bibliography
};
bool XMLSectionExport::ExportIndexTemplate(
SectionTypeEnum eType,
sal_Int32 nOutlineLevel,
const Reference<XPropertySet> & rPropertySet,
Sequence<Sequence<PropertyValue> > & rValues)
{
OSL_ENSURE(eType >= TEXT_SECTION_TYPE_TOC, "illegal index type");
OSL_ENSURE(eType <= TEXT_SECTION_TYPE_BIBLIOGRAPHY, "illegal index type");
OSL_ENSURE(nOutlineLevel >= 0, "illegal outline level");
if ( (eType >= TEXT_SECTION_TYPE_TOC) &&
(eType <= TEXT_SECTION_TYPE_BIBLIOGRAPHY) &&
(nOutlineLevel >= 0) )
{
// get level name and level attribute name from aLevelNameMap;
const XMLTokenEnum eLevelAttrName(
aTypeLevelAttrMap[eType-TEXT_SECTION_TYPE_TOC]);
const XMLTokenEnum eLevelName(
aTypeLevelNameMap[eType-TEXT_SECTION_TYPE_TOC][nOutlineLevel]);
// #92124#: some old documents may be broken, then they have
// too many template levels; we need to recognize this and
// export only as many as is legal for the respective index
// type. To do this, we simply return an error flag, which
// will then abort further template level exports.
OSL_ENSURE(XML_TOKEN_INVALID != eLevelName, "can't find level name");
if ( XML_TOKEN_INVALID == eLevelName )
{
// output level not found? Then end of templates! #91214#
return false;
}
// output level name
if ((XML_TOKEN_INVALID != eLevelName) && (XML_TOKEN_INVALID != eLevelAttrName))
{
GetExport().AddAttribute(XML_NAMESPACE_TEXT,
GetXMLToken(eLevelAttrName),
GetXMLToken(eLevelName));
}
// paragraph level style name
const sal_Char* pPropName(
aTypeLevelStylePropNameMap[eType-TEXT_SECTION_TYPE_TOC][nOutlineLevel]);
OSL_ENSURE(nullptr != pPropName, "can't find property name");
if (nullptr != pPropName)
{
Any aAny = rPropertySet->getPropertyValue(
OUString::createFromAscii(pPropName));
OUString sParaStyleName;
aAny >>= sParaStyleName;
GetExport().AddAttribute(XML_NAMESPACE_TEXT,
XML_STYLE_NAME,
GetExport().EncodeStyleName( sParaStyleName ));
}
// template element
const XMLTokenEnum eElementName(
aTypeElementNameMap[eType - TEXT_SECTION_TYPE_TOC]);
SvXMLElementExport aLevelTemplate(GetExport(),
XML_NAMESPACE_TEXT,
GetXMLToken(eElementName),
true, true);
// export sequence
sal_Int32 nTemplateCount = rValues.getLength();
for(sal_Int32 nTemplateNo = 0;
nTemplateNo < nTemplateCount;
nTemplateNo++)
{
ExportIndexTemplateElement(
eType, //i90246
rValues[nTemplateNo]);
}
}
return true;
}
enum TemplateTypeEnum
{
TOK_TTYPE_ENTRY_NUMBER,
TOK_TTYPE_ENTRY_TEXT,
TOK_TTYPE_TAB_STOP,
TOK_TTYPE_TEXT,
TOK_TTYPE_PAGE_NUMBER,
TOK_TTYPE_CHAPTER_INFO,
TOK_TTYPE_HYPERLINK_START,
TOK_TTYPE_HYPERLINK_END,
TOK_TTYPE_BIBLIOGRAPHY,
TOK_TTYPE_INVALID
};
enum TemplateParamEnum
{
TOK_TPARAM_TOKEN_TYPE,
TOK_TPARAM_CHAR_STYLE,
TOK_TPARAM_TAB_RIGHT_ALIGNED,
TOK_TPARAM_TAB_POSITION,
TOK_TPARAM_TAB_WITH_TAB, // #i21237#
TOK_TPARAM_TAB_FILL_CHAR,
TOK_TPARAM_TEXT,
TOK_TPARAM_CHAPTER_FORMAT,
TOK_TPARAM_CHAPTER_LEVEL,//i53420
TOK_TPARAM_BIBLIOGRAPHY_DATA
};
SvXMLEnumStringMapEntry const aTemplateTypeMap[] =
{
ENUM_STRING_MAP_ENTRY( "TokenEntryNumber", TOK_TTYPE_ENTRY_NUMBER ),
ENUM_STRING_MAP_ENTRY( "TokenEntryText", TOK_TTYPE_ENTRY_TEXT ),
ENUM_STRING_MAP_ENTRY( "TokenTabStop", TOK_TTYPE_TAB_STOP ),
ENUM_STRING_MAP_ENTRY( "TokenText", TOK_TTYPE_TEXT ),
ENUM_STRING_MAP_ENTRY( "TokenPageNumber", TOK_TTYPE_PAGE_NUMBER ),
ENUM_STRING_MAP_ENTRY( "TokenChapterInfo", TOK_TTYPE_CHAPTER_INFO ),
ENUM_STRING_MAP_ENTRY( "TokenHyperlinkStart", TOK_TTYPE_HYPERLINK_START ),
ENUM_STRING_MAP_ENTRY( "TokenHyperlinkEnd", TOK_TTYPE_HYPERLINK_END ),
ENUM_STRING_MAP_ENTRY( "TokenBibliographyDataField", TOK_TTYPE_BIBLIOGRAPHY ),
ENUM_STRING_MAP_END()
};
SvXMLEnumStringMapEntry const aTemplateParamMap[] =
{
ENUM_STRING_MAP_ENTRY( "TokenType", TOK_TPARAM_TOKEN_TYPE ),
ENUM_STRING_MAP_ENTRY( "CharacterStyleName", TOK_TPARAM_CHAR_STYLE ),
ENUM_STRING_MAP_ENTRY( "TabStopRightAligned", TOK_TPARAM_TAB_RIGHT_ALIGNED ),
ENUM_STRING_MAP_ENTRY( "TabStopPosition", TOK_TPARAM_TAB_POSITION ),
ENUM_STRING_MAP_ENTRY( "TabStopFillCharacter", TOK_TPARAM_TAB_FILL_CHAR ),
// #i21237#
ENUM_STRING_MAP_ENTRY( "WithTab", TOK_TPARAM_TAB_WITH_TAB ),
ENUM_STRING_MAP_ENTRY( "Text", TOK_TPARAM_TEXT ),
ENUM_STRING_MAP_ENTRY( "ChapterFormat", TOK_TPARAM_CHAPTER_FORMAT ),
ENUM_STRING_MAP_ENTRY( "ChapterLevel", TOK_TPARAM_CHAPTER_LEVEL ),//i53420
ENUM_STRING_MAP_ENTRY( "BibliographyDataField", TOK_TPARAM_BIBLIOGRAPHY_DATA ),
ENUM_STRING_MAP_END()
};
SvXMLEnumMapEntry const aBibliographyDataFieldMap[] =
{
{ XML_ADDRESS, BibliographyDataField::ADDRESS },
{ XML_ANNOTE, BibliographyDataField::ANNOTE },
{ XML_AUTHOR, BibliographyDataField::AUTHOR },
{ XML_BIBLIOGRAPHY_TYPE, BibliographyDataField::BIBILIOGRAPHIC_TYPE },
{ XML_BOOKTITLE, BibliographyDataField::BOOKTITLE },
{ XML_CHAPTER, BibliographyDataField::CHAPTER },
{ XML_CUSTOM1, BibliographyDataField::CUSTOM1 },
{ XML_CUSTOM2, BibliographyDataField::CUSTOM2 },
{ XML_CUSTOM3, BibliographyDataField::CUSTOM3 },
{ XML_CUSTOM4, BibliographyDataField::CUSTOM4 },
{ XML_CUSTOM5, BibliographyDataField::CUSTOM5 },
{ XML_EDITION, BibliographyDataField::EDITION },
{ XML_EDITOR, BibliographyDataField::EDITOR },
{ XML_HOWPUBLISHED, BibliographyDataField::HOWPUBLISHED },
{ XML_IDENTIFIER, BibliographyDataField::IDENTIFIER },
{ XML_INSTITUTION, BibliographyDataField::INSTITUTION },
{ XML_ISBN, BibliographyDataField::ISBN },
{ XML_JOURNAL, BibliographyDataField::JOURNAL },
{ XML_MONTH, BibliographyDataField::MONTH },
{ XML_NOTE, BibliographyDataField::NOTE },
{ XML_NUMBER, BibliographyDataField::NUMBER },
{ XML_ORGANIZATIONS, BibliographyDataField::ORGANIZATIONS },
{ XML_PAGES, BibliographyDataField::PAGES },
{ XML_PUBLISHER, BibliographyDataField::PUBLISHER },
{ XML_REPORT_TYPE, BibliographyDataField::REPORT_TYPE },
{ XML_SCHOOL, BibliographyDataField::SCHOOL },
{ XML_SERIES, BibliographyDataField::SERIES },
{ XML_TITLE, BibliographyDataField::TITLE },
{ XML_URL, BibliographyDataField::URL },
{ XML_VOLUME, BibliographyDataField::VOLUME },
{ XML_YEAR, BibliographyDataField::YEAR },
{ XML_TOKEN_INVALID, 0 }
};
void XMLSectionExport::ExportIndexTemplateElement(
SectionTypeEnum eType, //i90246
Sequence<PropertyValue> & rValues)
{
// variables for template values
// char style
OUString sCharStyle;
bool bCharStyleOK = false;
// text
OUString sText;
bool bTextOK = false;
// tab position
bool bRightAligned = false;
// tab position
sal_Int32 nTabPosition = 0;
bool bTabPositionOK = false;
// fill character
OUString sFillChar;
bool bFillCharOK = false;
// chapter format
sal_Int16 nChapterFormat = 0;
bool bChapterFormatOK = false;
// outline max level
sal_Int16 nLevel = 0;
bool bLevelOK = false;
// Bibliography Data
sal_Int16 nBibliographyData = 0;
bool bBibliographyDataOK = false;
// With Tab Stop #i21237#
bool bWithTabStop = false;
bool bWithTabStopOK = false;
//i90246, the ODF version being written to is:
const SvtSaveOptions::ODFDefaultVersion aODFVersion = rExport.getDefaultVersion();
//the above version cannot be used for old OOo (OOo 1.0) formats!
// token type
enum TemplateTypeEnum nTokenType = TOK_TTYPE_INVALID;
sal_Int32 nCount = rValues.getLength();
for(sal_Int32 i = 0; i<nCount; i++)
{
sal_uInt16 nToken;
if ( SvXMLUnitConverter::convertEnum( nToken, rValues[i].Name,
aTemplateParamMap ) )
{
// Only use direct and default values.
// Wrong. no property states, so ignore.
// if ( (beans::PropertyState_DIRECT_VALUE == rValues[i].State) ||
// (beans::PropertyState_DEFAULT_VALUE == rValues[i].State) )
switch (nToken)
{
case TOK_TPARAM_TOKEN_TYPE:
{
sal_uInt16 nTmp;
OUString sVal;
rValues[i].Value >>= sVal;
if (SvXMLUnitConverter::convertEnum( nTmp, sVal,
aTemplateTypeMap))
{
nTokenType = (enum TemplateTypeEnum)nTmp;
}
break;
}
case TOK_TPARAM_CHAR_STYLE:
// only valid, if not empty
rValues[i].Value >>= sCharStyle;
bCharStyleOK = !sCharStyle.isEmpty();
break;
case TOK_TPARAM_TEXT:
rValues[i].Value >>= sText;
bTextOK = true;
break;
case TOK_TPARAM_TAB_RIGHT_ALIGNED:
bRightAligned =
*o3tl::doGet<bool>(rValues[i].Value);
break;
case TOK_TPARAM_TAB_POSITION:
rValues[i].Value >>= nTabPosition;
bTabPositionOK = true;
break;
// #i21237#
case TOK_TPARAM_TAB_WITH_TAB:
bWithTabStop = *o3tl::doGet<bool>(rValues[i].Value);
bWithTabStopOK = true;
break;
case TOK_TPARAM_TAB_FILL_CHAR:
rValues[i].Value >>= sFillChar;
bFillCharOK = true;
break;
case TOK_TPARAM_CHAPTER_FORMAT:
rValues[i].Value >>= nChapterFormat;
bChapterFormatOK = true;
break;
//---> i53420
case TOK_TPARAM_CHAPTER_LEVEL:
rValues[i].Value >>= nLevel;
bLevelOK = true;
break;
case TOK_TPARAM_BIBLIOGRAPHY_DATA:
rValues[i].Value >>= nBibliographyData;
bBibliographyDataOK = true;
break;
}
}
}
// convert type to token (and check validity) ...
XMLTokenEnum eElement(XML_TOKEN_INVALID);
switch(nTokenType)
{
case TOK_TTYPE_ENTRY_TEXT:
eElement = XML_INDEX_ENTRY_TEXT;
break;
case TOK_TTYPE_TAB_STOP:
// test validity
if ( bRightAligned || bTabPositionOK || bFillCharOK )
{
eElement = XML_INDEX_ENTRY_TAB_STOP;
}
break;
case TOK_TTYPE_TEXT:
// test validity
if (bTextOK)
{
eElement = XML_INDEX_ENTRY_SPAN;
}
break;
case TOK_TTYPE_PAGE_NUMBER:
eElement = XML_INDEX_ENTRY_PAGE_NUMBER;
break;
case TOK_TTYPE_CHAPTER_INFO: // keyword index
eElement = XML_INDEX_ENTRY_CHAPTER;
break;
case TOK_TTYPE_ENTRY_NUMBER: // table of content
eElement = XML_INDEX_ENTRY_CHAPTER;
break;
case TOK_TTYPE_HYPERLINK_START:
eElement = XML_INDEX_ENTRY_LINK_START;
break;
case TOK_TTYPE_HYPERLINK_END:
eElement = XML_INDEX_ENTRY_LINK_END;
break;
case TOK_TTYPE_BIBLIOGRAPHY:
if (bBibliographyDataOK)
{
eElement = XML_INDEX_ENTRY_BIBLIOGRAPHY;
}
break;
default:
; // unknown/unimplemented template
break;
}
//--->i90246
//check the ODF version being exported
if( aODFVersion == SvtSaveOptions::ODFVER_011
|| aODFVersion == SvtSaveOptions::ODFVER_010)
{
bLevelOK = false;
if (TOK_TTYPE_CHAPTER_INFO == nTokenType)
{
//if we are emitting for ODF 1.1 or 1.0, this information can be used for alphabetical index only
//it's not permitted in other indexes
if (eType != TEXT_SECTION_TYPE_ALPHABETICAL)
{
eElement = XML_TOKEN_INVALID; //not permitted, invalidate the element
}
else //maps format for 1.1 & 1.0
{
// a few word here: OOo up to 2.4 uses the field chapter info in Alphabetical index
// in a way different from the ODF 1.1/1.0 specification:
// ODF1.1/1.0 OOo display in chapter info ODF1.2
// (used in alphabetical index only
// number chapter number without pre/postfix plain-number
// number-and-name chapter number without pre/postfix plus title plain-number-and-name
// with issue i89791 the reading of ODF 1.1 and 1.0 was corrected
// this one corrects the writing back from ODF 1.2 to ODF 1.1/1.0
// unfortunately if there is another application which interprets correctly ODF1.1/1.0,
// the resulting alphabetical index will be rendered wrong by OOo 2.4 version
switch( nChapterFormat )
{
case ChapterFormat::DIGIT:
nChapterFormat = ChapterFormat::NUMBER;
break;
case ChapterFormat::NO_PREFIX_SUFFIX:
nChapterFormat = ChapterFormat::NAME_NUMBER;
break;
}
}
}
else if (TOK_TTYPE_ENTRY_NUMBER == nTokenType)
{
//in case of ODF 1.1 or 1.0 the only allowed number format is "number"
//so, force it...
// The only expected 'foreign' nChapterFormat is
// ' ChapterFormat::DIGIT', forced to 'none, since the
// 'value allowed in ODF 1.1 and 1.0 is 'number' the default
// this can be obtained by simply disabling the chapter format
bChapterFormatOK = false;
}
}
// ... and write Element
if (eElement != XML_TOKEN_INVALID)
{
// character style (for most templates)
if (bCharStyleOK)
{
switch (nTokenType)
{
case TOK_TTYPE_ENTRY_TEXT:
case TOK_TTYPE_TEXT:
case TOK_TTYPE_PAGE_NUMBER:
case TOK_TTYPE_ENTRY_NUMBER:
case TOK_TTYPE_HYPERLINK_START:
case TOK_TTYPE_HYPERLINK_END:
case TOK_TTYPE_BIBLIOGRAPHY:
case TOK_TTYPE_CHAPTER_INFO:
case TOK_TTYPE_TAB_STOP:
GetExport().AddAttribute(XML_NAMESPACE_TEXT,
XML_STYLE_NAME,
GetExport().EncodeStyleName( sCharStyle) );
break;
default:
; // nothing: no character style
break;
}
}
// tab properties
if (TOK_TTYPE_TAB_STOP == nTokenType)
{
// tab type
GetExport().AddAttribute(XML_NAMESPACE_STYLE, XML_TYPE,
bRightAligned ? XML_RIGHT : XML_LEFT);
if (bTabPositionOK && (! bRightAligned))
{
// position for left tabs (convert to measure)
OUStringBuffer sBuf;
GetExport().GetMM100UnitConverter().convertMeasureToXML(sBuf,
nTabPosition);
GetExport().AddAttribute(XML_NAMESPACE_STYLE,
XML_POSITION,
sBuf.makeStringAndClear());
}
// fill char ("leader char")
if (bFillCharOK && !sFillChar.isEmpty())
{
GetExport().AddAttribute(XML_NAMESPACE_STYLE,
XML_LEADER_CHAR, sFillChar);
}
// #i21237#
if (bWithTabStopOK && ! bWithTabStop)
{
GetExport().AddAttribute(XML_NAMESPACE_STYLE,
XML_WITH_TAB,
XML_FALSE);
}
}
// bibliography data
if (TOK_TTYPE_BIBLIOGRAPHY == nTokenType)
{
OSL_ENSURE(bBibliographyDataOK, "need bibl data");
OUStringBuffer sBuf;
if (SvXMLUnitConverter::convertEnum( sBuf, nBibliographyData,
aBibliographyDataFieldMap ) )
{
GetExport().AddAttribute(XML_NAMESPACE_TEXT,
XML_BIBLIOGRAPHY_DATA_FIELD,
sBuf.makeStringAndClear());
}
}
// chapter info
if (TOK_TTYPE_CHAPTER_INFO == nTokenType)
{
OSL_ENSURE(bChapterFormatOK, "need chapter info");
GetExport().AddAttribute(
XML_NAMESPACE_TEXT, XML_DISPLAY,
XMLTextFieldExport::MapChapterDisplayFormat(nChapterFormat));
//---> i53420
if (bLevelOK)
GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_OUTLINE_LEVEL,
OUString::number(nLevel));
}
//--->i53420
if (TOK_TTYPE_ENTRY_NUMBER == nTokenType)
{
if (bChapterFormatOK)
GetExport().AddAttribute(
XML_NAMESPACE_TEXT, XML_DISPLAY,
XMLTextFieldExport::MapChapterDisplayFormat(nChapterFormat));
if (bLevelOK)
GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_OUTLINE_LEVEL,
OUString::number(nLevel));
}
// export template
SvXMLElementExport aTemplateElement(GetExport(), XML_NAMESPACE_TEXT,
GetXMLToken(eElement),
true, false)
;
// entry text or span element: write text
if (TOK_TTYPE_TEXT == nTokenType)
{
GetExport().Characters(sText);
}
}
}
void XMLSectionExport::ExportLevelParagraphStyles(
Reference<XIndexReplace> & xLevelParagraphStyles)
{
// iterate over levels
sal_Int32 nPLevelCount = xLevelParagraphStyles->getCount();
for(sal_Int32 nLevel = 0; nLevel < nPLevelCount; nLevel++)
{
Any aAny = xLevelParagraphStyles->getByIndex(nLevel);
Sequence<OUString> aStyleNames;
aAny >>= aStyleNames;
// export only if at least one style is contained
sal_Int32 nNamesCount = aStyleNames.getLength();
if (nNamesCount > 0)
{
// level attribute; we count 1..10; API 0..9
OUStringBuffer sBuf;
sal_Int32 nLevelPlusOne = nLevel + 1;
::sax::Converter::convertNumber(sBuf, nLevelPlusOne);
GetExport().AddAttribute(XML_NAMESPACE_TEXT,
XML_OUTLINE_LEVEL,
sBuf.makeStringAndClear());
// source styles element
SvXMLElementExport aParaStyles(GetExport(),
XML_NAMESPACE_TEXT,
XML_INDEX_SOURCE_STYLES,
true, true);
// iterate over styles in this level
for(sal_Int32 nName = 0; nName < nNamesCount; nName++)
{
// stylename attribute
GetExport().AddAttribute(XML_NAMESPACE_TEXT,
XML_STYLE_NAME,
GetExport().EncodeStyleName( aStyleNames[nName]) );
// element
SvXMLElementExport aParaStyle(GetExport(),
XML_NAMESPACE_TEXT,
XML_INDEX_SOURCE_STYLE,
true, false);
}
}
}
}
void XMLSectionExport::ExportBoolean(
const Reference<XPropertySet> & rPropSet,
const OUString& sPropertyName,
enum XMLTokenEnum eAttributeName,
bool bDefault,
bool bInvert)
{
OSL_ENSURE(eAttributeName != XML_TOKEN_INVALID, "Need attribute name");
Any aAny = rPropSet->getPropertyValue(sPropertyName);
bool bTmp = *o3tl::doGet<bool>(aAny);
// value = value ^ bInvert
// omit if value == default
if ( (bTmp != bInvert) != bDefault )
{
// export non-default value (since default is omitted)
GetExport().AddAttribute(XML_NAMESPACE_TEXT,
eAttributeName,
bDefault ? XML_FALSE : XML_TRUE);
}
}
const sal_Char sAPI_FieldMaster_Bibliography[] =
"com.sun.star.text.FieldMaster.Bibliography";
void XMLSectionExport::ExportBibliographyConfiguration(SvXMLExport& rExport)
{
// first: get field master (via text field supplier)
Reference<XTextFieldsSupplier> xTextFieldsSupp( rExport.GetModel(),
UNO_QUERY );
if ( xTextFieldsSupp.is() )
{
const OUString sFieldMaster_Bibliography(sAPI_FieldMaster_Bibliography);
// get bibliography field master
Reference<XNameAccess> xMasters =
xTextFieldsSupp->getTextFieldMasters();
if ( xMasters->hasByName(sFieldMaster_Bibliography) )
{
Any aAny =
xMasters->getByName(sFieldMaster_Bibliography);
Reference<XPropertySet> xPropSet;
aAny >>= xPropSet;
OSL_ENSURE( xPropSet.is(), "field master must have XPropSet" );
const OUString sBracketBefore("BracketBefore");
const OUString sBracketAfter("BracketAfter");
const OUString sIsNumberEntries("IsNumberEntries");
const OUString sIsSortByPosition("IsSortByPosition");
const OUString sSortKeys("SortKeys");
const OUString sSortAlgorithm("SortAlgorithm");
const OUString sLocale("Locale");
OUString sTmp;
aAny = xPropSet->getPropertyValue(sBracketBefore);
aAny >>= sTmp;
rExport.AddAttribute(XML_NAMESPACE_TEXT, XML_PREFIX, sTmp);
aAny = xPropSet->getPropertyValue(sBracketAfter);
aAny >>= sTmp;
rExport.AddAttribute(XML_NAMESPACE_TEXT, XML_SUFFIX, sTmp);
aAny = xPropSet->getPropertyValue(sIsNumberEntries);
if (*o3tl::doGet<bool>(aAny))
{
rExport.AddAttribute(XML_NAMESPACE_TEXT,
XML_NUMBERED_ENTRIES, XML_TRUE);
}
aAny = xPropSet->getPropertyValue(sIsSortByPosition);
if (! *o3tl::doGet<bool>(aAny))
{
rExport.AddAttribute(XML_NAMESPACE_TEXT,
XML_SORT_BY_POSITION, XML_FALSE);
}
// sort algorithm
aAny = xPropSet->getPropertyValue(sSortAlgorithm);
OUString sAlgorithm;
aAny >>= sAlgorithm;
if( !sAlgorithm.isEmpty() )
{
rExport.AddAttribute( XML_NAMESPACE_TEXT,
XML_SORT_ALGORITHM, sAlgorithm );
}
// locale
aAny = xPropSet->getPropertyValue(sLocale);
Locale aLocale;
aAny >>= aLocale;
rExport.AddLanguageTagAttributes( XML_NAMESPACE_FO, XML_NAMESPACE_STYLE, aLocale, true);
// configuration element
SvXMLElementExport aElement(rExport, XML_NAMESPACE_TEXT,
XML_BIBLIOGRAPHY_CONFIGURATION,
true, true);
// sort keys
aAny = xPropSet->getPropertyValue(sSortKeys);
Sequence<Sequence<PropertyValue> > aKeys;
aAny >>= aKeys;
sal_Int32 nKeysCount = aKeys.getLength();
for(sal_Int32 nKeys = 0; nKeys < nKeysCount; nKeys++)
{
Sequence<PropertyValue> & rKey = aKeys[nKeys];
sal_Int32 nKeyCount = rKey.getLength();
for(sal_Int32 nPropertyKey = 0; nPropertyKey < nKeyCount; nPropertyKey++)
{
PropertyValue& rValue = rKey[nPropertyKey];
if (rValue.Name == "SortKey")
{
sal_Int16 nKey = 0;
rValue.Value >>= nKey;
OUStringBuffer sBuf;
if (SvXMLUnitConverter::convertEnum( sBuf, nKey,
aBibliographyDataFieldMap ) )
{
rExport.AddAttribute(XML_NAMESPACE_TEXT, XML_KEY,
sBuf.makeStringAndClear());
}
}
else if (rValue.Name == "IsSortAscending")
{
bool bTmp = *o3tl::doGet<bool>(rValue.Value);
rExport.AddAttribute(XML_NAMESPACE_TEXT,
XML_SORT_ASCENDING,
bTmp ? XML_TRUE : XML_FALSE);
}
}
SvXMLElementExport aKeyElem(rExport,
XML_NAMESPACE_TEXT, XML_SORT_KEY,
true, true);
}
}
}
}
bool XMLSectionExport::IsMuteSection(
const Reference<XTextSection> & rSection) const
{
bool bRet = false;
// a section is mute if
// 1) it exists
// 2) the SaveLinkedSections flag (at the export) is false
// 3) the IsGlobalDocumentSection property is true
// 4) it is not an Index
if ( (!rExport.IsSaveLinkedSections()) && rSection.is() )
{
// walk the section chain and set bRet if any is linked
for(Reference<XTextSection> aSection(rSection);
aSection.is();
aSection = aSection->getParentSection())
{
// check if it is a global document section (linked or index)
Reference<XPropertySet> xPropSet(aSection, UNO_QUERY);
if (xPropSet.is())
{
Any aAny = xPropSet->getPropertyValue(sIsGlobalDocumentSection);
if ( *o3tl::doGet<bool>(aAny) )
{
Reference<XDocumentIndex> xIndex;
if (! GetIndex(rSection, xIndex))
{
bRet = true;
// early out if result is known
break;
}
}
}
// section has no properties: ignore
}
}
// else: no section, or always save sections: default (false)
return bRet;
}
bool XMLSectionExport::IsMuteSection(
const Reference<XTextContent> & rSection,
bool bDefault) const
{
// default: like default argument
bool bRet = bDefault;
Reference<XPropertySet> xPropSet(rSection->getAnchor(), UNO_QUERY);
if (xPropSet.is())
{
if (xPropSet->getPropertySetInfo()->hasPropertyByName(sTextSection))
{
Any aAny = xPropSet->getPropertyValue(sTextSection);
Reference<XTextSection> xSection;
aAny >>= xSection;
bRet = IsMuteSection(xSection);
}
// else: return default
}
// else: return default
return bRet;
}
bool XMLSectionExport::IsInSection(
const Reference<XTextSection> & rEnclosingSection,
const Reference<XTextContent> & rContent,
bool bDefault)
{
// default: like default argument
bool bRet = bDefault;
OSL_ENSURE(rEnclosingSection.is(), "enclosing section expected");
Reference<XPropertySet> xPropSet(rContent, UNO_QUERY);
if (xPropSet.is())
{
if (xPropSet->getPropertySetInfo()->hasPropertyByName(sTextSection))
{
Any aAny = xPropSet->getPropertyValue(sTextSection);
Reference<XTextSection> xSection;
aAny >>= xSection;
// now walk chain of text sections (if we have one)
if (xSection.is())
{
do
{
bRet = (rEnclosingSection == xSection);
xSection = xSection->getParentSection();
}
while (!bRet && xSection.is());
}
else
bRet = false; // no section -> can't be inside
}
// else: no TextSection property -> return default
}
// else: no XPropertySet -> return default
return bRet;
}
void XMLSectionExport::ExportMasterDocHeadingDummies()
{
if( bHeadingDummiesExported )
return;
Reference< XChapterNumberingSupplier > xCNSupplier( rExport.GetModel(),
UNO_QUERY );
Reference< XIndexReplace > xChapterNumbering;
if( xCNSupplier.is() )
xChapterNumbering = xCNSupplier->getChapterNumberingRules();
if( !xChapterNumbering.is() )
return;
sal_Int32 nCount = xChapterNumbering->getCount();
for( sal_Int32 nLevel = 0; nLevel < nCount; nLevel++ )
{
OUString sStyle;
Sequence<PropertyValue> aProperties;
xChapterNumbering->getByIndex( nLevel ) >>= aProperties;
for( sal_Int32 i = 0; i < aProperties.getLength(); i++ )
{
if( aProperties[i].Name == sHeadingStyleName )
{
aProperties[i].Value >>= sStyle;
break;
}
}
if( !sStyle.isEmpty() )
{
GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_STYLE_NAME,
GetExport().EncodeStyleName( sStyle ) );
OUStringBuffer sTmp;
sTmp.append( nLevel + 1 );
GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_LEVEL,
sTmp.makeStringAndClear() );
SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_TEXT, XML_H,
true, false );
}
}
bHeadingDummiesExported = true;
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Reference in New Issue View Git Blame Copy Permalink