| /************************************************************** |
| * |
| * 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" |
| |
| |
| |
| 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; |
| if (sCond.getLength() > 0) |
| { |
| 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 (! *(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()); |
| } |
| |
| // 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_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: |
| 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 = 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) |
| { |
| 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_LEVEL, |
| sTmp.makeStringAndClear() ); |
| SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_TEXT, XML_H, |
| sal_True, sal_False ); |
| } |
| } |
| |
| bHeadingDummiesExported = sal_True; |
| } |