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