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