| /************************************************************** | |
| * | |
| * 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 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_xmloff.hxx" | |
| #include "XMLSectionExport.hxx" | |
| #include <rtl/ustring.hxx> | |
| #include <rtl/ustrbuf.hxx> | |
| #include <vector> | |
| #include <com/sun/star/lang/XServiceInfo.hpp> | |
| #include <com/sun/star/lang/Locale.hpp> | |
| #include <com/sun/star/container/XIndexReplace.hpp> | |
| #include <com/sun/star/beans/XPropertySet.hpp> | |
| #include <com/sun/star/beans/PropertyValue.hpp> | |
| #include <com/sun/star/beans/PropertyValues.hpp> | |
| #include <com/sun/star/beans/PropertyState.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/uno/XInterface.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> //i90246 | |
| #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" | |
| #include <svl/PasswordHelper.hxx> | |
| #include <unotools/saveopt.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 ::rtl::OUString; | |
| using ::rtl::OUStringBuffer; | |
| using ::com::sun::star::beans::XPropertySet; | |
| using ::com::sun::star::beans::PropertyValue; | |
| using ::com::sun::star::beans::PropertyValues; | |
| using ::com::sun::star::beans::PropertyState; | |
| using ::com::sun::star::container::XIndexReplace; | |
| using ::com::sun::star::container::XNameAccess; | |
| using ::com::sun::star::container::XNamed; | |
| using ::com::sun::star::lang::XServiceInfo; | |
| using ::com::sun::star::lang::Locale; | |
| using ::com::sun::star::uno::XInterface; | |
| XMLSectionExport::XMLSectionExport( | |
| SvXMLExport& rExp, | |
| XMLTextParagraphExport& rParaExp) | |
| : sCondition(RTL_CONSTASCII_USTRINGPARAM("Condition")) | |
| , sCreateFromChapter(RTL_CONSTASCII_USTRINGPARAM("CreateFromChapter")) | |
| , sCreateFromEmbeddedObjects(RTL_CONSTASCII_USTRINGPARAM("CreateFromEmbeddedObjects")) | |
| , sCreateFromGraphicObjects(RTL_CONSTASCII_USTRINGPARAM("CreateFromGraphicObjects")) | |
| , sCreateFromLabels(RTL_CONSTASCII_USTRINGPARAM("CreateFromLabels")) | |
| , sCreateFromMarks(RTL_CONSTASCII_USTRINGPARAM("CreateFromMarks")) | |
| , sCreateFromOtherEmbeddedObjects(RTL_CONSTASCII_USTRINGPARAM("CreateFromOtherEmbeddedObjects")) | |
| , sCreateFromOutline(RTL_CONSTASCII_USTRINGPARAM("CreateFromOutline")) | |
| , sCreateFromStarCalc(RTL_CONSTASCII_USTRINGPARAM("CreateFromStarCalc")) | |
| , sCreateFromStarChart(RTL_CONSTASCII_USTRINGPARAM("CreateFromStarChart")) | |
| , sCreateFromStarDraw(RTL_CONSTASCII_USTRINGPARAM("CreateFromStarDraw")) | |
| , sCreateFromStarImage(RTL_CONSTASCII_USTRINGPARAM("CreateFromStarImage")) | |
| , sCreateFromStarMath(RTL_CONSTASCII_USTRINGPARAM("CreateFromStarMath")) | |
| , sCreateFromTables(RTL_CONSTASCII_USTRINGPARAM("CreateFromTables")) | |
| , sCreateFromTextFrames(RTL_CONSTASCII_USTRINGPARAM("CreateFromTextFrames")) | |
| , sDdeCommandElement(RTL_CONSTASCII_USTRINGPARAM("DDECommandElement")) | |
| , sDdeCommandFile(RTL_CONSTASCII_USTRINGPARAM("DDECommandFile")) | |
| , sDdeCommandType(RTL_CONSTASCII_USTRINGPARAM("DDECommandType")) | |
| , sFileLink(RTL_CONSTASCII_USTRINGPARAM("FileLink")) | |
| , sIsCaseSensitive(RTL_CONSTASCII_USTRINGPARAM("IsCaseSensitive")) | |
| , sIsProtected(RTL_CONSTASCII_USTRINGPARAM("IsProtected")) | |
| , sIsVisible(RTL_CONSTASCII_USTRINGPARAM("IsVisible")) | |
| , sLabelCategory(RTL_CONSTASCII_USTRINGPARAM("LabelCategory")) | |
| , sLabelDisplayType(RTL_CONSTASCII_USTRINGPARAM("LabelDisplayType")) | |
| , sLevel(RTL_CONSTASCII_USTRINGPARAM("Level")) | |
| , sLevelFormat(RTL_CONSTASCII_USTRINGPARAM("LevelFormat")) | |
| , sLevelParagraphStyles(RTL_CONSTASCII_USTRINGPARAM("LevelParagraphStyles")) | |
| , sLinkRegion(RTL_CONSTASCII_USTRINGPARAM("LinkRegion")) | |
| , sMainEntryCharacterStyleName(RTL_CONSTASCII_USTRINGPARAM("MainEntryCharacterStyleName")) | |
| , sParaStyleHeading(RTL_CONSTASCII_USTRINGPARAM("ParaStyleHeading")) | |
| , sParaStyleLevel(RTL_CONSTASCII_USTRINGPARAM("ParaStyleLevel")) | |
| , sTitle(RTL_CONSTASCII_USTRINGPARAM("Title")) | |
| , sName(RTL_CONSTASCII_USTRINGPARAM("Name")) | |
| , sUseAlphabeticalSeparators(RTL_CONSTASCII_USTRINGPARAM("UseAlphabeticalSeparators")) | |
| , sUseCombinedEntries(RTL_CONSTASCII_USTRINGPARAM("UseCombinedEntries")) | |
| , sUseDash(RTL_CONSTASCII_USTRINGPARAM("UseDash")) | |
| , sUseKeyAsEntry(RTL_CONSTASCII_USTRINGPARAM("UseKeyAsEntry")) | |
| , sUseLevelFromSource(RTL_CONSTASCII_USTRINGPARAM("UseLevelFromSource")) | |
| , sUsePP(RTL_CONSTASCII_USTRINGPARAM("UsePP")) | |
| , sUseUpperCase(RTL_CONSTASCII_USTRINGPARAM("UseUpperCase")) | |
| , sIsCommaSeparated(RTL_CONSTASCII_USTRINGPARAM("IsCommaSeparated")) | |
| , sIsAutomaticUpdate(RTL_CONSTASCII_USTRINGPARAM("IsAutomaticUpdate")) | |
| , sIsRelativeTabstops(RTL_CONSTASCII_USTRINGPARAM("IsRelativeTabstops")) | |
| , sCreateFromLevelParagraphStyles(RTL_CONSTASCII_USTRINGPARAM("CreateFromLevelParagraphStyles")) | |
| , sDocumentIndex(RTL_CONSTASCII_USTRINGPARAM("DocumentIndex")) | |
| , sContentSection(RTL_CONSTASCII_USTRINGPARAM("ContentSection")) | |
| , sHeaderSection(RTL_CONSTASCII_USTRINGPARAM("HeaderSection")) | |
| , sTextSection(RTL_CONSTASCII_USTRINGPARAM("TextSection")) | |
| , sIsGlobalDocumentSection(RTL_CONSTASCII_USTRINGPARAM("IsGlobalDocumentSection")) | |
| , sProtectionKey(RTL_CONSTASCII_USTRINGPARAM("ProtectionKey")) | |
| , sSortAlgorithm(RTL_CONSTASCII_USTRINGPARAM("SortAlgorithm")) | |
| , sLocale(RTL_CONSTASCII_USTRINGPARAM("Locale")) | |
| , sUserIndexName(RTL_CONSTASCII_USTRINGPARAM("UserIndexName")) | |
| , sIsCurrentlyVisible(RTL_CONSTASCII_USTRINGPARAM("IsCurrentlyVisible")) | |
| , sHeadingStyleName(RTL_CONSTASCII_USTRINGPARAM("HeadingStyleName")) | |
| , rExport(rExp) | |
| , rParaExport(rParaExp) | |
| , bHeadingDummiesExported( sal_False ) | |
| { | |
| } | |
| void XMLSectionExport::ExportSectionStart( | |
| const Reference<XTextSection> & rSection, | |
| sal_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, sEmpty ) ); | |
| // 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); | |
| } | |
| } | |
| } | |
| sal_Bool XMLSectionExport::GetIndex( | |
| const Reference<XTextSection> & rSection, | |
| Reference<XDocumentIndex> & rIndex) const | |
| { | |
| // first, reset result | |
| sal_Bool bRet = sal_False; | |
| rIndex = NULL; | |
| // 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 = sal_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 = sal_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, | |
| sal_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, | |
| sal_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_ENSURE(false, "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, sal_True); | |
| GetExport().IgnorableWhitespace(); | |
| } | |
| else | |
| { | |
| OSL_ENSURE(false, "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_ENSURE(false, "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, sal_True ); | |
| GetExport().IgnorableWhitespace(); | |
| } | |
| SvXMLEnumStringMapEntry __READONLY_DATA 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; | |
| // strict ODF 1.2 has no form for the condition of a visible section (display="condition" means hidden) | |
| const sal_Bool bStrict = SvtSaveOptions::IsODFStrict( GetExport().getDefaultVersion() ); | |
| const sal_Bool bIsVisible = *(sal_Bool*)xPropSet->getPropertyValue(sIsVisible).getValue(); | |
| if (sCond.getLength() > 0 && !( bStrict && bIsVisible )) | |
| { | |
| OUString sQValue = | |
| GetExport().GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OOOW, | |
| sCond, sal_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 (!bStrict && ! *(sal_Bool*)aAny.getValue()) | |
| { | |
| GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_IS_HIDDEN, | |
| XML_TRUE); | |
| } | |
| } | |
| else | |
| { | |
| eDisplay = XML_NONE; | |
| } | |
| aAny = xPropSet->getPropertyValue(sIsVisible); | |
| if (! *(sal_Bool*)aAny.getValue()) | |
| { | |
| GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_DISPLAY, eDisplay); | |
| } | |
| // protect + protection key | |
| aAny = xPropSet->getPropertyValue(sIsProtected); | |
| if (*(sal_Bool*)aAny.getValue()) | |
| { | |
| GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_PROTECTED, XML_TRUE); | |
| } | |
| Sequence<sal_Int8> aPassword; | |
| xPropSet->getPropertyValue(sProtectionKey) >>= aPassword; | |
| if (aPassword.getLength() > 0) | |
| { | |
| OUStringBuffer aBuffer; | |
| SvXMLUnitConverter::encodeBase64(aBuffer, aPassword); | |
| GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_PROTECTION_KEY, | |
| aBuffer.makeStringAndClear()); | |
| // ODF 1.2 19.851; without the attribute the key is read as SHA-1 | |
| const OUString aDigest( SvPasswordHelper::GetDigestAlgorithmIRI( aPassword ) ); | |
| if (aDigest.getLength() && | |
| GetExport().getDefaultVersion() >= SvtSaveOptions::ODFVER_012) | |
| { | |
| GetExport().AddAttribute(XML_NAMESPACE_TEXT, | |
| XML_PROTECTION_KEY_DIGEST_ALGORITHM, aDigest); | |
| } | |
| } | |
| // export element | |
| GetExport().IgnorableWhitespace(); | |
| GetExport().StartElement( XML_NAMESPACE_TEXT, XML_SECTION, sal_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.getLength() > 0) || | |
| (aFileLink.FilterName.getLength() > 0) || | |
| (sRegionName.getLength() > 0) ) | |
| { | |
| if (aFileLink.FileURL.getLength() > 0) | |
| { | |
| GetExport().AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE); | |
| GetExport().AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, | |
| GetExport().GetRelativeReference( aFileLink.FileURL) ); | |
| } | |
| if (aFileLink.FilterName.getLength() > 0) | |
| { | |
| GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_FILTER_NAME, | |
| aFileLink.FilterName); | |
| } | |
| if (sRegionName.getLength() > 0) | |
| { | |
| GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_SECTION_NAME, | |
| sRegionName); | |
| } | |
| SvXMLElementExport aElem(GetExport(), | |
| XML_NAMESPACE_TEXT, XML_SECTION_SOURCE, | |
| sal_True, sal_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.getLength() > 0) || | |
| (sTopic.getLength() > 0) || | |
| (sItem.getLength() > 0 ) ) | |
| { | |
| 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 (*(sal_Bool*)aAny.getValue()) | |
| { | |
| GetExport().AddAttribute(XML_NAMESPACE_OFFICE, | |
| XML_AUTOMATIC_UPDATE, XML_TRUE); | |
| } | |
| SvXMLElementExport aElem(GetExport(), | |
| XML_NAMESPACE_OFFICE, | |
| XML_DDE_SOURCE, sal_True, sal_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 | |
| { | |
| Any aAny; | |
| // TOC specific index source attributes: | |
| // outline-level: 1..10 | |
| sal_Int16 nLevel = sal_Int16(); | |
| if( rPropertySet->getPropertyValue(sLevel) >>= nLevel ) | |
| { | |
| OUStringBuffer sBuffer; | |
| SvXMLUnitConverter::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, sal_True); | |
| // use index marks | |
| ExportBoolean(rPropertySet, sCreateFromMarks, | |
| XML_USE_INDEX_MARKS, sal_True); | |
| // use level styles | |
| ExportBoolean(rPropertySet, sCreateFromLevelParagraphStyles, | |
| XML_USE_INDEX_SOURCE_STYLES, sal_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, sal_False); | |
| ExportBoolean(rPropertySet, sCreateFromStarCalc, | |
| XML_USE_SPREADSHEET_OBJECTS, sal_False); | |
| ExportBoolean(rPropertySet, sCreateFromStarChart, | |
| XML_USE_CHART_OBJECTS, sal_False); | |
| ExportBoolean(rPropertySet, sCreateFromStarDraw, | |
| XML_USE_DRAW_OBJECTS, sal_False); | |
| ExportBoolean(rPropertySet, sCreateFromStarMath, | |
| XML_USE_MATH_OBJECTS, sal_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.getLength()) | |
| { | |
| GetExport().AddAttribute(XML_NAMESPACE_TEXT, | |
| XML_MAIN_ENTRY_STYLE_NAME, | |
| GetExport().EncodeStyleName( sStyleName )); | |
| } | |
| // other (boolean) attributes | |
| ExportBoolean(rPropertySet, sIsCaseSensitive, XML_IGNORE_CASE, | |
| sal_False, sal_True); | |
| ExportBoolean(rPropertySet, sUseAlphabeticalSeparators, | |
| XML_ALPHABETICAL_SEPARATORS, sal_False); | |
| ExportBoolean(rPropertySet, sUseCombinedEntries, XML_COMBINE_ENTRIES, | |
| sal_True); | |
| ExportBoolean(rPropertySet, sUseDash, XML_COMBINE_ENTRIES_WITH_DASH, | |
| sal_False); | |
| ExportBoolean(rPropertySet, sUseKeyAsEntry, XML_USE_KEYS_AS_ENTRIES, | |
| sal_False); | |
| ExportBoolean(rPropertySet, sUsePP, XML_COMBINE_ENTRIES_WITH_PP, | |
| sal_True); | |
| ExportBoolean(rPropertySet, sUseUpperCase, XML_CAPITALIZE_ENTRIES, | |
| sal_False); | |
| ExportBoolean(rPropertySet, sIsCommaSeparated, XML_COMMA_SEPARATED, | |
| sal_False); | |
| // sort algorithm | |
| aAny = rPropertySet->getPropertyValue(sSortAlgorithm); | |
| OUString sAlgorithm; | |
| aAny >>= sAlgorithm; | |
| if (sAlgorithm.getLength() > 0) | |
| { | |
| GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_SORT_ALGORITHM, | |
| sAlgorithm ); | |
| } | |
| // locale | |
| aAny = rPropertySet->getPropertyValue(sLocale); | |
| Locale aLocale; | |
| aAny >>= aLocale; | |
| GetExport().AddAttribute(XML_NAMESPACE_FO, XML_LANGUAGE, | |
| aLocale.Language); | |
| GetExport().AddAttribute(XML_NAMESPACE_FO, XML_COUNTRY, | |
| aLocale.Country); | |
| 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, sal_False); | |
| ExportBoolean(rPropertySet, sCreateFromGraphicObjects, | |
| XML_USE_GRAPHICS, sal_False); | |
| ExportBoolean(rPropertySet, sCreateFromMarks, | |
| XML_USE_INDEX_MARKS, sal_False); | |
| ExportBoolean(rPropertySet, sCreateFromTables, | |
| XML_USE_TABLES, sal_False); | |
| ExportBoolean(rPropertySet, sCreateFromTextFrames, | |
| XML_USE_FLOATING_FRAMES, sal_False); | |
| ExportBoolean(rPropertySet, sUseLevelFromSource, | |
| XML_COPY_OUTLINE_LEVELS, sal_False); | |
| ExportBoolean(rPropertySet, sCreateFromLevelParagraphStyles, | |
| XML_USE_INDEX_SOURCE_STYLES, sal_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 (*(sal_Bool*)aAny.getValue()) | |
| { | |
| GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_PROTECTED, XML_TRUE); | |
| } | |
| // index name | |
| OUString sIndexName; | |
| rPropertySet->getPropertyValue(sName) >>= sIndexName; | |
| if ( sIndexName.getLength() > 0 ) | |
| { | |
| GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_NAME, sIndexName); | |
| } | |
| // index Element start | |
| GetExport().IgnorableWhitespace(); | |
| GetExport().StartElement( XML_NAMESPACE_TEXT, eElement, sal_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 (*(sal_Bool*)aAny.getValue()) | |
| { | |
| GetExport().AddAttribute(XML_NAMESPACE_TEXT, | |
| XML_INDEX_SCOPE, XML_CHAPTER); | |
| } | |
| // tab-stops relative to margin? | |
| aAny = rPropertySet->getPropertyValue(sIsRelativeTabstops); | |
| if (! *(sal_Bool*)aAny.getValue()) | |
| { | |
| 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]), | |
| sal_True, sal_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, | |
| sal_True, sal_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#) | |
| sal_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 | |
| #if OSL_DEBUG_LEVEL > 0 | |
| eType | |
| #endif | |
| , | |
| 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, sal_True ); | |
| } | |
| void XMLSectionExport::ExportTableAndIllustrationIndexSourceAttributes( | |
| const Reference<XPropertySet> & rPropertySet) | |
| { | |
| // use caption | |
| Any aAny = rPropertySet->getPropertyValue(sCreateFromLabels); | |
| if (! *(sal_Bool*)aAny.getValue()) | |
| { | |
| 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[] = | |
| { NULL, "ParaStyleLevel1", "ParaStyleLevel2", "ParaStyleLevel3", | |
| "ParaStyleLevel4", "ParaStyleLevel5", "ParaStyleLevel6", | |
| "ParaStyleLevel7", "ParaStyleLevel8", "ParaStyleLevel9", | |
| "ParaStyleLevel10", NULL }; | |
| static const sal_Char* aLevelStylePropNameTableMap[] = | |
| { NULL, "ParaStyleLevel1", NULL }; | |
| static const sal_Char* aLevelStylePropNameAlphaMap[] = | |
| { NULL, "ParaStyleSeparator", "ParaStyleLevel1", "ParaStyleLevel2", | |
| "ParaStyleLevel3", NULL }; | |
| static const sal_Char* aLevelStylePropNameBibliographyMap[] = | |
| // TODO: replace with real property names, when available | |
| { NULL, "ParaStyleLevel1", "ParaStyleLevel1", "ParaStyleLevel1", | |
| "ParaStyleLevel1", "ParaStyleLevel1", "ParaStyleLevel1", | |
| "ParaStyleLevel1", "ParaStyleLevel1", "ParaStyleLevel1", | |
| "ParaStyleLevel1", "ParaStyleLevel1", "ParaStyleLevel1", | |
| "ParaStyleLevel1", "ParaStyleLevel1", "ParaStyleLevel1", | |
| "ParaStyleLevel1", "ParaStyleLevel1", "ParaStyleLevel1", | |
| "ParaStyleLevel1", "ParaStyleLevel1", "ParaStyleLevel1", | |
| "ParaStyleLevel1", | |
| NULL }; | |
| 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 | |
| }; | |
| sal_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 sal_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(NULL != pPropName, "can't find property name"); | |
| if (NULL != 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), | |
| sal_True, sal_True); | |
| // export sequence | |
| sal_Int32 nTemplateCount = rValues.getLength(); | |
| for(sal_Int32 nTemplateNo = 0; | |
| nTemplateNo < nTemplateCount; | |
| nTemplateNo++) | |
| { | |
| ExportIndexTemplateElement( | |
| eType, //i90246 | |
| rValues[nTemplateNo]); | |
| } | |
| } | |
| return sal_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 __READONLY_DATA 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 __READONLY_DATA 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 __READONLY_DATA 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; | |
| sal_Bool bCharStyleOK = sal_False; | |
| // text | |
| OUString sText; | |
| sal_Bool bTextOK = sal_False; | |
| // tab position | |
| sal_Bool bRightAligned = sal_False; | |
| sal_Bool bRightAlignedOK = sal_False; | |
| // tab position | |
| sal_Int32 nTabPosition = 0; | |
| sal_Bool bTabPositionOK = sal_False; | |
| // fill character | |
| OUString sFillChar; | |
| sal_Bool bFillCharOK = sal_False; | |
| // chapter format | |
| sal_Int16 nChapterFormat = 0; | |
| sal_Bool bChapterFormatOK = sal_False; | |
| // outline max level | |
| sal_Int16 nLevel = 0; | |
| sal_Bool bLevelOK = sal_False; | |
| // Bibliography Data | |
| sal_Int16 nBibliographyData = 0; | |
| sal_Bool bBibliographyDataOK = sal_False; | |
| // With Tab Stop #i21237# | |
| sal_Bool bWithTabStop = sal_False; | |
| sal_Bool bWithTabStopOK = sal_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.getLength() > 0; | |
| break; | |
| case TOK_TPARAM_TEXT: | |
| rValues[i].Value >>= sText; | |
| bTextOK = sal_True; | |
| break; | |
| case TOK_TPARAM_TAB_RIGHT_ALIGNED: | |
| bRightAligned = | |
| *(sal_Bool *)rValues[i].Value.getValue(); | |
| bRightAlignedOK = sal_True; | |
| break; | |
| case TOK_TPARAM_TAB_POSITION: | |
| rValues[i].Value >>= nTabPosition; | |
| bTabPositionOK = sal_True; | |
| break; | |
| // #i21237# | |
| case TOK_TPARAM_TAB_WITH_TAB: | |
| bWithTabStop = *(sal_Bool *)rValues[i].Value.getValue(); | |
| bWithTabStopOK = sal_True; | |
| break; | |
| case TOK_TPARAM_TAB_FILL_CHAR: | |
| rValues[i].Value >>= sFillChar; | |
| bFillCharOK = sal_True; | |
| break; | |
| case TOK_TPARAM_CHAPTER_FORMAT: | |
| rValues[i].Value >>= nChapterFormat; | |
| bChapterFormatOK = sal_True; | |
| break; | |
| //---> i53420 | |
| case TOK_TPARAM_CHAPTER_LEVEL: | |
| rValues[i].Value >>= nLevel; | |
| bLevelOK = sal_True; | |
| break; | |
| //<--- | |
| case TOK_TPARAM_BIBLIOGRAPHY_DATA: | |
| rValues[i].Value >>= nBibliographyData; | |
| bBibliographyDataOK = sal_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: | |
| // strict ODF 1.2 allows the link tokens in table-of-content templates only, ODF 1.3 also in the table, illustration, object and user index templates | |
| if ( !SvtSaveOptions::IsODFStrict( aODFVersion ) || TEXT_SECTION_TYPE_TOC == eType | |
| || ( aODFVersion >= SvtSaveOptions::ODFVER_013 && ( TEXT_SECTION_TYPE_TABLE == eType | |
| || TEXT_SECTION_TYPE_ILLUSTRATION == eType || TEXT_SECTION_TYPE_OBJECT == eType || TEXT_SECTION_TYPE_USER == eType ) ) ) | |
| eElement = XML_INDEX_ENTRY_LINK_START; | |
| break; | |
| case TOK_TTYPE_HYPERLINK_END: | |
| if ( !SvtSaveOptions::IsODFStrict( aODFVersion ) || TEXT_SECTION_TYPE_TOC == eType | |
| || ( aODFVersion >= SvtSaveOptions::ODFVER_013 && ( TEXT_SECTION_TYPE_TABLE == eType | |
| || TEXT_SECTION_TYPE_ILLUSTRATION == eType || TEXT_SECTION_TYPE_OBJECT == eType || TEXT_SECTION_TYPE_USER == eType ) ) ) | |
| 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 = sal_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 = sal_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().convertMeasure(sBuf, | |
| nTabPosition); | |
| GetExport().AddAttribute(XML_NAMESPACE_STYLE, | |
| XML_POSITION, | |
| sBuf.makeStringAndClear()); | |
| } | |
| // fill char ("leader char") | |
| if (bFillCharOK && (sFillChar.getLength() > 0)) | |
| { | |
| GetExport().AddAttribute(XML_NAMESPACE_STYLE, | |
| XML_LEADER_CHAR, sFillChar); | |
| } | |
| // #i21237# | |
| if (bWithTabStopOK && ! bWithTabStop && !SvtSaveOptions::IsODFStrict( aODFVersion )) | |
| { | |
| 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::valueOf((sal_Int32)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::valueOf((sal_Int32)nLevel)); | |
| } | |
| //<--- | |
| // export template | |
| SvXMLElementExport aTemplateElement(GetExport(), XML_NAMESPACE_TEXT, | |
| GetXMLToken(eElement), | |
| sal_True, sal_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; | |
| SvXMLUnitConverter::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, | |
| sal_True, sal_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, | |
| sal_True, sal_False); | |
| } | |
| } | |
| } | |
| } | |
| void XMLSectionExport::ExportBoolean( | |
| const Reference<XPropertySet> & rPropSet, | |
| const OUString& sPropertyName, | |
| enum XMLTokenEnum eAttributeName, | |
| sal_Bool bDefault, | |
| sal_Bool bInvert) | |
| { | |
| OSL_ENSURE(eAttributeName != XML_TOKEN_INVALID, "Need attribute name"); | |
| Any aAny = rPropSet->getPropertyValue(sPropertyName); | |
| sal_Bool bTmp = *(sal_Bool*)aAny.getValue(); | |
| // value = value ^ bInvert | |
| // omit if value == default | |
| // negate forces sal_Bool to 0/1, making them comparable | |
| 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"; | |
| const sal_Char sAPI_SortKey[] = "SortKey"; | |
| const sal_Char sAPI_IsSortAscending[] = "IsSortAscending"; | |
| 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( | |
| RTL_CONSTASCII_USTRINGPARAM(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( | |
| RTL_CONSTASCII_USTRINGPARAM("BracketBefore")); | |
| const OUString sBracketAfter( | |
| RTL_CONSTASCII_USTRINGPARAM("BracketAfter")); | |
| const OUString sIsNumberEntries( | |
| RTL_CONSTASCII_USTRINGPARAM("IsNumberEntries")); | |
| const OUString sIsSortByPosition( | |
| RTL_CONSTASCII_USTRINGPARAM("IsSortByPosition")); | |
| const OUString sSortKeys( | |
| RTL_CONSTASCII_USTRINGPARAM("SortKeys")); | |
| const OUString sSortAlgorithm( | |
| RTL_CONSTASCII_USTRINGPARAM("SortAlgorithm")); | |
| const OUString sLocale( | |
| RTL_CONSTASCII_USTRINGPARAM("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 (*(sal_Bool*)aAny.getValue()) | |
| { | |
| rExport.AddAttribute(XML_NAMESPACE_TEXT, | |
| XML_NUMBERED_ENTRIES, XML_TRUE); | |
| } | |
| aAny = xPropSet->getPropertyValue(sIsSortByPosition); | |
| if (! *(sal_Bool*)aAny.getValue()) | |
| { | |
| rExport.AddAttribute(XML_NAMESPACE_TEXT, | |
| XML_SORT_BY_POSITION, XML_FALSE); | |
| } | |
| // sort algorithm | |
| aAny = xPropSet->getPropertyValue(sSortAlgorithm); | |
| OUString sAlgorithm; | |
| aAny >>= sAlgorithm; | |
| if( sAlgorithm.getLength() > 0 ) | |
| { | |
| rExport.AddAttribute( XML_NAMESPACE_TEXT, | |
| XML_SORT_ALGORITHM, sAlgorithm ); | |
| } | |
| // locale | |
| aAny = xPropSet->getPropertyValue(sLocale); | |
| Locale aLocale; | |
| aAny >>= aLocale; | |
| rExport.AddAttribute(XML_NAMESPACE_FO, XML_LANGUAGE, | |
| aLocale.Language); | |
| rExport.AddAttribute(XML_NAMESPACE_FO, XML_COUNTRY, | |
| aLocale.Country); | |
| // configuration element | |
| SvXMLElementExport aElement(rExport, XML_NAMESPACE_TEXT, | |
| XML_BIBLIOGRAPHY_CONFIGURATION, | |
| sal_True, sal_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.equalsAsciiL(sAPI_SortKey, | |
| sizeof(sAPI_SortKey)-1)) | |
| { | |
| 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.equalsAsciiL(sAPI_IsSortAscending, | |
| sizeof(sAPI_IsSortAscending)-1)) | |
| { | |
| sal_Bool bTmp = *(sal_Bool*)rValue.Value.getValue(); | |
| rExport.AddAttribute(XML_NAMESPACE_TEXT, | |
| XML_SORT_ASCENDING, | |
| bTmp ? XML_TRUE : XML_FALSE); | |
| } | |
| } | |
| SvXMLElementExport aKeyElem(rExport, | |
| XML_NAMESPACE_TEXT, XML_SORT_KEY, | |
| sal_True, sal_True); | |
| } | |
| } | |
| } | |
| } | |
| sal_Bool XMLSectionExport::IsMuteSection( | |
| const Reference<XTextSection> & rSection) const | |
| { | |
| sal_Bool bRet = sal_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 ( *(sal_Bool*)aAny.getValue() ) | |
| { | |
| Reference<XDocumentIndex> xIndex; | |
| if (! GetIndex(rSection, xIndex)) | |
| { | |
| bRet = sal_True; | |
| // early out if result is known | |
| break; | |
| } | |
| } | |
| } | |
| // section has no properties: ignore | |
| } | |
| } | |
| // else: no section, or always save sections: default (false) | |
| return bRet; | |
| } | |
| sal_Bool XMLSectionExport::IsMuteSection( | |
| const Reference<XTextContent> & rSection, | |
| sal_Bool bDefault) const | |
| { | |
| // default: like default argument | |
| sal_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; | |
| } | |
| sal_Bool XMLSectionExport::IsInSection( | |
| const Reference<XTextSection> & rEnclosingSection, | |
| const Reference<XTextContent> & rContent, | |
| sal_Bool bDefault) | |
| { | |
| // default: like default argument | |
| sal_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 = sal_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.getLength() > 0 ) | |
| { | |
| GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_STYLE_NAME, | |
| GetExport().EncodeStyleName( sStyle ) ); | |
| OUStringBuffer sTmp; | |
| sTmp.append( nLevel + 1 ); | |
| GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_OUTLINE_LEVEL, | |
| sTmp.makeStringAndClear() ); | |
| SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_TEXT, XML_H, | |
| sal_True, sal_False ); | |
| } | |
| } | |
| bHeadingDummiesExported = sal_True; | |
| } |