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 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 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 196 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 1774 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 1818 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 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 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