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 27 /** @#file 28 * 29 * Import of all text fields except those from txtvfldi.cxx 30 * (variable related text fields and database display fields) 31 */ 32 #include "txtfldi.hxx" 33 #include "txtvfldi.hxx" 34 #include <xmloff/xmlimp.hxx> 35 #include <xmloff/xmlnumi.hxx> 36 #include <xmloff/txtimp.hxx> 37 #include "xmloff/xmlnmspe.hxx" 38 #include <xmloff/nmspmap.hxx> 39 #include <xmloff/xmltoken.hxx> 40 #include <xmloff/xmluconv.hxx> 41 #include <xmloff/xmlement.hxx> 42 #include "XMLStringBufferImportContext.hxx" 43 #include <xmloff/XMLEventsImportContext.hxx> 44 #include <com/sun/star/xml/sax/XAttributeList.hpp> 45 #include <com/sun/star/text/UserDataPart.hpp> 46 #include <com/sun/star/style/NumberingType.hpp> 47 #include <com/sun/star/text/PlaceholderType.hpp> 48 #include <com/sun/star/text/ReferenceFieldPart.hpp> 49 #include <com/sun/star/text/ReferenceFieldSource.hpp> 50 #include <com/sun/star/text/XTextField.hpp> 51 #include <com/sun/star/text/XTextContent.hpp> 52 #include <com/sun/star/beans/XPropertySet.hpp> 53 #include <com/sun/star/beans/XPropertySetInfo.hpp> 54 #include <com/sun/star/lang/XMultiServiceFactory.hpp> 55 #include <com/sun/star/text/XTextFieldsSupplier.hpp> 56 #include <com/sun/star/text/XDependentTextField.hpp> 57 #include <com/sun/star/text/SetVariableType.hpp> 58 #include <com/sun/star/text/FilenameDisplayFormat.hpp> 59 #include <com/sun/star/text/ChapterFormat.hpp> 60 #include <com/sun/star/text/TemplateDisplayFormat.hpp> 61 #include <com/sun/star/beans/PropertyValue.hpp> 62 #include <com/sun/star/text/BibliographyDataType.hpp> 63 #include <com/sun/star/text/BibliographyDataField.hpp> 64 #include <com/sun/star/util/XUpdatable.hpp> 65 #include <com/sun/star/sdb/CommandType.hpp> 66 67 #include <rtl/ustring.hxx> 68 #include <rtl/ustrbuf.hxx> 69 #include <rtl/math.hxx> 70 #include <tools/debug.hxx> 71 72 73 using ::rtl::OUString; 74 using ::rtl::OUStringBuffer; 75 76 using namespace ::com::sun::star; 77 using namespace ::com::sun::star::uno; 78 using namespace ::com::sun::star::text; 79 using namespace ::com::sun::star::lang; 80 using namespace ::com::sun::star::beans; 81 using namespace ::com::sun::star::document; 82 using namespace ::com::sun::star::util; 83 using namespace ::com::sun::star::xml::sax; 84 using namespace ::xmloff::token; 85 86 87 // 88 // SO API string constants 89 // 90 91 // service prefix and service anems 92 const sal_Char sAPI_textfield_prefix[] = "com.sun.star.text.TextField."; 93 const sal_Char sAPI_fieldmaster_prefix[] = "com.sun.star.text.FieldMaster."; 94 const sal_Char sAPI_presentation_prefix[] = "com.sun.star.presentation.TextField."; 95 96 const sal_Char sAPI_extended_user[] = "ExtendedUser"; 97 const sal_Char sAPI_user_data_type[] = "UserDataType"; 98 const sal_Char sAPI_jump_edit[] = "JumpEdit"; 99 const sal_Char sAPI_get_expression[] = "GetExpression"; 100 const sal_Char sAPI_set_expression[] = "SetExpression"; 101 const sal_Char sAPI_user[] = "User"; 102 const sal_Char sAPI_date_time[] = "DateTime"; 103 const sal_Char sAPI_page_number[] = "PageNumber"; 104 const sal_Char sAPI_database_next[] = "DatabaseNextSet"; 105 const sal_Char sAPI_database_select[] = "DatabaseNumberOfSet"; 106 const sal_Char sAPI_database_number[] = "DatabaseSetNumber"; 107 const sal_Char sAPI_database[] = "Database"; 108 const sal_Char sAPI_database_name[] = "DatabaseName"; 109 const sal_Char sAPI_docinfo_change_author[] = "DocInfo.ChangeAuthor"; 110 const sal_Char sAPI_docinfo_change_date_time[] = "DocInfo.ChangeDateTime"; 111 const sal_Char sAPI_docinfo_edit_time[] = "DocInfo.EditTime"; 112 const sal_Char sAPI_docinfo_description[] = "DocInfo.Description"; 113 const sal_Char sAPI_docinfo_create_author[] = "DocInfo.CreateAuthor"; 114 const sal_Char sAPI_docinfo_create_date_time[] = "DocInfo.CreateDateTime"; 115 const sal_Char sAPI_docinfo_custom[] = "DocInfo.Custom"; 116 const sal_Char sAPI_docinfo_print_author[] = "DocInfo.PrintAuthor"; 117 const sal_Char sAPI_docinfo_print_date_time[] = "DocInfo.PrintDateTime"; 118 const sal_Char sAPI_docinfo_keywords[] = "DocInfo.KeyWords"; 119 const sal_Char sAPI_docinfo_subject[] = "DocInfo.Subject"; 120 const sal_Char sAPI_docinfo_title[] = "DocInfo.Title"; 121 const sal_Char sAPI_docinfo_revision[] = "DocInfo.Revision"; 122 const sal_Char sAPI_hidden_paragraph[] = "HiddenParagraph"; 123 const sal_Char sAPI_hidden_text[] = "HiddenText"; 124 const sal_Char sAPI_conditional_text[] = "ConditionalText"; 125 const sal_Char sAPI_file_name[] = "FileName"; 126 const sal_Char sAPI_chapter[] = "Chapter"; 127 const sal_Char sAPI_template_name[] = "TemplateName"; 128 const sal_Char sAPI_page_count[] = "PageCount"; 129 const sal_Char sAPI_paragraph_count[] = "ParagraphCount"; 130 const sal_Char sAPI_word_count[] = "WordCount"; 131 const sal_Char sAPI_character_count[] = "CharacterCount"; 132 const sal_Char sAPI_table_count[] = "TableCount"; 133 const sal_Char sAPI_graphic_object_count[] = "GraphicObjectCount"; 134 const sal_Char sAPI_embedded_object_count[] = "EmbeddedObjectCount"; 135 const sal_Char sAPI_reference_page_set[] = "ReferencePageSet"; 136 const sal_Char sAPI_reference_page_get[] = "ReferencePageGet"; 137 const sal_Char sAPI_macro[] = "Macro"; 138 const sal_Char sAPI_dde[] = "DDE"; 139 const sal_Char sAPI_get_reference[] = "GetReference"; 140 const sal_Char sAPI_sheet_name[] = "SheetName"; 141 const sal_Char sAPI_url[] = "URL"; 142 const sal_Char sAPI_bibliography[] = "Bibliography"; 143 const sal_Char sAPI_annotation[] = "Annotation"; 144 const sal_Char sAPI_script[] = "Script"; 145 const sal_Char sAPI_measure[] = "Measure"; 146 const sal_Char sAPI_drop_down[] = "DropDown"; 147 const sal_Char sAPI_header[] = "Header"; 148 const sal_Char sAPI_footer[] = "Footer"; 149 const sal_Char sAPI_datetime[] = "DateTime"; 150 151 // property names 152 const sal_Char sAPI_is_fixed[] = "IsFixed"; 153 const sal_Char sAPI_content[] = "Content"; 154 const sal_Char sAPI_value[] = "Value"; 155 const sal_Char sAPI_author[] = "Author"; 156 const sal_Char sAPI_initials[] = "Initials"; 157 const sal_Char sAPI_full_name[] = "FullName"; 158 const sal_Char sAPI_place_holder_type[] = "PlaceHolderType"; 159 const sal_Char sAPI_place_holder[] = "PlaceHolder"; 160 const sal_Char sAPI_hint[] = "Hint"; 161 const sal_Char sAPI_variable_name[] = "VariableName"; 162 const sal_Char sAPI_name[] = "Name"; 163 const sal_Char sAPI_sub_type[] = "SubType"; 164 const sal_Char sAPI_numbering_separator[] = "NumberingSeparator"; 165 const sal_Char sAPI_chapter_numbering_level[] = "ChapterNumberingLevel"; 166 const sal_Char sAPI_variable_subtype[] = "VariableSubtype"; 167 const sal_Char sAPI_formula[] = "Formula"; 168 const sal_Char sAPI_date_time_value[] = "DateTimeValue"; 169 const sal_Char sAPI_number_format[] = "NumberFormat"; 170 const sal_Char sAPI_user_text[] = "UserText"; 171 const sal_Char sAPI_numbering_type[] = "NumberingType"; 172 const sal_Char sAPI_offset[] = "Offset"; 173 const sal_Char sAPI_data_base_name[] = "DataBaseName"; 174 const sal_Char sAPI_data_base_u_r_l[] = "DataBaseURL"; 175 const sal_Char sAPI_data_table_name[] = "DataTableName"; 176 const sal_Char sAPI_condition[] = "Condition"; 177 const sal_Char sAPI_set_number[] = "SetNumber"; 178 const sal_Char sAPI_is_data_base_format[] = "DataBaseFormat"; 179 const sal_Char sAPI_true_content[] = "TrueContent"; 180 const sal_Char sAPI_false_content[] = "FalseContent"; 181 const sal_Char sAPI_revision[] = "Revision"; 182 const sal_Char sAPI_file_format[] = "FileFormat"; 183 const sal_Char sAPI_chapter_format[] = "ChapterFormat"; 184 const sal_Char sAPI_level[] = "Level"; 185 const sal_Char sAPI_is_date[] = "IsDate"; 186 const sal_Char sAPI_adjust[] = "Adjust"; 187 const sal_Char sAPI_on[] = "On"; 188 const sal_Char sAPI_is_automatic_update[] = "IsAutomaticUpdate"; 189 const sal_Char sAPI_source_name[] = "SourceName"; 190 const sal_Char sAPI_current_presentation[] = "CurrentPresentation"; 191 const sal_Char sAPI_reference_field_part[] = "ReferenceFieldPart"; 192 const sal_Char sAPI_reference_field_source[] = "ReferenceFieldSource"; 193 const sal_Char sAPI_dde_command_type[] = "DDECommandType"; 194 const sal_Char sAPI_dde_command_file[] = "DDECommandFile"; 195 const sal_Char sAPI_dde_command_element[] = "DDECommandElement"; 196 // sAPI_url: also used as service name 197 const sal_Char sAPI_target_frame[] = "TargetFrame"; 198 const sal_Char sAPI_representation[] = "Representation"; 199 const sal_Char sAPI_date[] = "Date"; 200 const sal_Char sAPI_url_content[] = "URLContent"; 201 const sal_Char sAPI_script_type[] = "ScriptType"; 202 const sal_Char sAPI_is_hidden[] = "IsHidden"; 203 const sal_Char sAPI_is_condition_true[] = "IsConditionTrue"; 204 const sal_Char sAPI_data_command_type[] = "DataCommandType"; 205 const sal_Char sAPI_is_fixed_language[] = "IsFixedLanguage"; 206 const sal_Char sAPI_is_visible[] = "IsVisible"; 207 const sal_Char sAPI_TextRange[] = "TextRange"; 208 209 const sal_Char sAPI_true[] = "sal_True"; 210 211 212 TYPEINIT1( XMLTextFieldImportContext, SvXMLImportContext); 213 214 XMLTextFieldImportContext::XMLTextFieldImportContext( 215 SvXMLImport& rImport, XMLTextImportHelper& rHlp, 216 const sal_Char* pService, 217 sal_uInt16 nPrefix, const OUString& rElementName) 218 : SvXMLImportContext( rImport, nPrefix, rElementName ) 219 , sIsFixed(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed)) 220 , rTextImportHelper(rHlp) 221 , sServicePrefix(RTL_CONSTASCII_USTRINGPARAM(sAPI_textfield_prefix)) 222 , bValid(sal_False) 223 { 224 DBG_ASSERT(NULL != pService, "Need service name!"); 225 sServiceName = OUString::createFromAscii(pService); 226 } 227 228 void XMLTextFieldImportContext::StartElement( 229 const Reference<XAttributeList> & xAttrList) 230 { 231 // process attributes 232 sal_Int16 nLength = xAttrList->getLength(); 233 for(sal_Int16 i=0; i<nLength; i++) { 234 235 OUString sLocalName; 236 sal_uInt16 nPrefix = GetImport().GetNamespaceMap(). 237 GetKeyByAttrName( xAttrList->getNameByIndex(i), &sLocalName ); 238 239 ProcessAttribute(rTextImportHelper.GetTextFieldAttrTokenMap(). 240 Get(nPrefix, sLocalName), 241 xAttrList->getValueByIndex(i) ); 242 } 243 } 244 245 XMLTextFieldImportContext::~XMLTextFieldImportContext() { 246 } 247 248 OUString XMLTextFieldImportContext::GetContent() 249 { 250 if (sContent.getLength()==0) 251 { 252 sContent = sContentBuffer.makeStringAndClear(); 253 } 254 255 return sContent; 256 } 257 258 void XMLTextFieldImportContext::EndElement() 259 { 260 DBG_ASSERT(GetServiceName().getLength()>0, "no service name for element!"); 261 if (bValid) 262 { 263 264 // create field/Service 265 Reference<XPropertySet> xPropSet; 266 if (CreateField(xPropSet, sServicePrefix + GetServiceName())) 267 { 268 // set field properties 269 PrepareField(xPropSet); 270 271 // attach field to document 272 Reference<XTextContent> xTextContent(xPropSet, UNO_QUERY); 273 274 // workaround for #80606# 275 try 276 { 277 rTextImportHelper.InsertTextContent(xTextContent); 278 } 279 catch (lang::IllegalArgumentException e) 280 { 281 // ignore 282 } 283 return; 284 } 285 } 286 287 // in case of error: write element content 288 rTextImportHelper.InsertString(GetContent()); 289 } 290 291 void XMLTextFieldImportContext::Characters(const OUString& rContent) 292 { 293 sContentBuffer.append(rContent); 294 } 295 296 sal_Bool XMLTextFieldImportContext::CreateField( 297 Reference<XPropertySet> & xField, 298 const OUString& rServiceName) 299 { 300 // instantiate new XTextField: 301 // ask import for model, model is factory, ask factory to create service 302 303 Reference<XMultiServiceFactory> xFactory(GetImport().GetModel(),UNO_QUERY); 304 if( xFactory.is() ) 305 { 306 Reference<XInterface> xIfc = xFactory->createInstance(rServiceName); 307 if( xIfc.is() ) 308 { 309 Reference<XPropertySet> xTmp( xIfc, UNO_QUERY ); 310 311 xField = xTmp; 312 } else { 313 return sal_False; // can't create instance 314 } 315 } else { 316 return sal_False; // can't get MultiServiceFactory 317 } 318 319 return sal_True; 320 } 321 322 /// create the appropriate field context from 323 XMLTextFieldImportContext* 324 XMLTextFieldImportContext::CreateTextFieldImportContext( 325 SvXMLImport& rImport, 326 XMLTextImportHelper& rHlp, 327 sal_uInt16 nPrefix, 328 const OUString& rName, 329 sal_uInt16 nToken) 330 { 331 XMLTextFieldImportContext* pContext = NULL; 332 333 switch (nToken) 334 { 335 case XML_TOK_TEXT_SENDER_FIRSTNAME: 336 case XML_TOK_TEXT_SENDER_LASTNAME: 337 case XML_TOK_TEXT_SENDER_INITIALS: 338 case XML_TOK_TEXT_SENDER_TITLE: 339 case XML_TOK_TEXT_SENDER_POSITION: 340 case XML_TOK_TEXT_SENDER_EMAIL: 341 case XML_TOK_TEXT_SENDER_PHONE_PRIVATE: 342 case XML_TOK_TEXT_SENDER_FAX: 343 case XML_TOK_TEXT_SENDER_COMPANY: 344 case XML_TOK_TEXT_SENDER_PHONE_WORK: 345 case XML_TOK_TEXT_SENDER_STREET: 346 case XML_TOK_TEXT_SENDER_CITY: 347 case XML_TOK_TEXT_SENDER_POSTAL_CODE: 348 case XML_TOK_TEXT_SENDER_COUNTRY: 349 case XML_TOK_TEXT_SENDER_STATE_OR_PROVINCE: 350 pContext = 351 new XMLSenderFieldImportContext( rImport, rHlp, 352 nPrefix, rName, nToken ); 353 break; 354 355 case XML_TOK_TEXT_AUTHOR_NAME: 356 case XML_TOK_TEXT_AUTHOR_INITIALS: 357 pContext = 358 new XMLAuthorFieldImportContext( rImport, rHlp, 359 nPrefix, rName, nToken ); 360 break; 361 362 case XML_TOK_TEXT_PLACEHOLDER: 363 pContext = 364 new XMLPlaceholderFieldImportContext( rImport, rHlp, 365 nPrefix, rName); 366 break; 367 case XML_TOK_TEXT_SEQUENCE: 368 pContext = 369 new XMLSequenceFieldImportContext( rImport, rHlp, 370 nPrefix, rName ); 371 break; 372 case XML_TOK_TEXT_TEXT_INPUT: 373 pContext = 374 new XMLTextInputFieldImportContext( rImport, rHlp, 375 nPrefix, rName ); 376 break; 377 case XML_TOK_TEXT_EXPRESSION: 378 pContext = 379 new XMLExpressionFieldImportContext( rImport, rHlp, 380 nPrefix, rName ); 381 break; 382 case XML_TOK_TEXT_VARIABLE_SET: 383 pContext = 384 new XMLVariableSetFieldImportContext( rImport, rHlp, 385 nPrefix, rName ); 386 break; 387 case XML_TOK_TEXT_VARIABLE_INPUT: 388 pContext = 389 new XMLVariableInputFieldImportContext( rImport, rHlp, 390 nPrefix, rName ); 391 break; 392 case XML_TOK_TEXT_VARIABLE_GET: 393 pContext = 394 new XMLVariableGetFieldImportContext( rImport, rHlp, 395 nPrefix, rName ); 396 break; 397 case XML_TOK_TEXT_USER_FIELD_GET: 398 pContext = new XMLUserFieldImportContext( rImport, rHlp, 399 nPrefix, rName ); 400 break; 401 case XML_TOK_TEXT_USER_FIELD_INPUT: 402 pContext = new XMLUserFieldInputImportContext( rImport, rHlp, 403 nPrefix, rName ); 404 break; 405 case XML_TOK_TEXT_TIME: 406 pContext = new XMLTimeFieldImportContext( rImport, rHlp, 407 nPrefix, rName ); 408 break; 409 case XML_TOK_TEXT_PAGE_CONTINUATION_STRING: 410 case XML_TOK_TEXT_PAGE_CONTINUATION: 411 pContext = new XMLPageContinuationImportContext( rImport, rHlp, 412 nPrefix, rName ); 413 break; 414 415 case XML_TOK_TEXT_PAGE_NUMBER: 416 pContext = new XMLPageNumberImportContext( rImport, rHlp, 417 nPrefix, rName ); 418 break; 419 420 case XML_TOK_TEXT_DATE: 421 pContext = new XMLDateFieldImportContext( rImport, rHlp, 422 nPrefix, rName ); 423 break; 424 425 case XML_TOK_TEXT_DATABASE_NAME: 426 pContext = new XMLDatabaseNameImportContext( rImport, rHlp, 427 nPrefix, rName ); 428 break; 429 case XML_TOK_TEXT_DATABASE_NEXT: 430 pContext = new XMLDatabaseNextImportContext( rImport, rHlp, 431 nPrefix, rName ); 432 break; 433 case XML_TOK_TEXT_DATABASE_SELECT: 434 pContext = new XMLDatabaseSelectImportContext( rImport, rHlp, 435 nPrefix, rName ); 436 break; 437 case XML_TOK_TEXT_DATABASE_ROW_NUMBER: 438 pContext = new XMLDatabaseNumberImportContext( rImport, rHlp, 439 nPrefix, rName ); 440 break; 441 case XML_TOK_TEXT_DATABASE_DISPLAY: 442 pContext = new XMLDatabaseDisplayImportContext( rImport, rHlp, 443 nPrefix, rName ); 444 break; 445 case XML_TOK_TEXT_CONDITIONAL_TEXT: 446 pContext = new XMLConditionalTextImportContext( rImport, rHlp, 447 nPrefix, rName ); 448 break; 449 case XML_TOK_TEXT_HIDDEN_TEXT: 450 pContext = new XMLHiddenTextImportContext( rImport, rHlp, 451 nPrefix, rName ); 452 break; 453 case XML_TOK_TEXT_HIDDEN_PARAGRAPH: 454 pContext = new XMLHiddenParagraphImportContext( rImport, rHlp, 455 nPrefix, rName ); 456 break; 457 case XML_TOK_TEXT_DOCUMENT_DESCRIPTION: 458 case XML_TOK_TEXT_DOCUMENT_TITLE: 459 case XML_TOK_TEXT_DOCUMENT_SUBJECT: 460 case XML_TOK_TEXT_DOCUMENT_KEYWORDS: 461 pContext = new XMLSimpleDocInfoImportContext( rImport, rHlp, 462 nPrefix, rName, 463 nToken, sal_True, 464 sal_False ); 465 break; 466 case XML_TOK_TEXT_DOCUMENT_CREATION_AUTHOR: 467 case XML_TOK_TEXT_DOCUMENT_PRINT_AUTHOR: 468 case XML_TOK_TEXT_DOCUMENT_SAVE_AUTHOR: 469 pContext = new XMLSimpleDocInfoImportContext( rImport, rHlp, 470 nPrefix, rName, 471 nToken, sal_False, 472 sal_True ); 473 break; 474 475 case XML_TOK_TEXT_DOCUMENT_CREATION_DATE: 476 case XML_TOK_TEXT_DOCUMENT_CREATION_TIME: 477 case XML_TOK_TEXT_DOCUMENT_PRINT_DATE: 478 case XML_TOK_TEXT_DOCUMENT_PRINT_TIME: 479 case XML_TOK_TEXT_DOCUMENT_SAVE_DATE: 480 case XML_TOK_TEXT_DOCUMENT_SAVE_TIME: 481 case XML_TOK_TEXT_DOCUMENT_EDIT_DURATION: 482 pContext = new XMLDateTimeDocInfoImportContext( rImport, rHlp, 483 nPrefix, rName, 484 nToken ); 485 break; 486 487 case XML_TOK_TEXT_DOCUMENT_REVISION: 488 pContext = new XMLRevisionDocInfoImportContext( rImport, rHlp, 489 nPrefix, rName, 490 nToken ); 491 break; 492 493 case XML_TOK_TEXT_DOCUMENT_USER_DEFINED: 494 pContext = new XMLUserDocInfoImportContext( rImport, rHlp, 495 nPrefix, rName, 496 nToken ); 497 break; 498 499 case XML_TOK_TEXT_FILENAME: 500 pContext = new XMLFileNameImportContext( rImport, rHlp, 501 nPrefix, rName ); 502 break; 503 504 case XML_TOK_TEXT_CHAPTER: 505 pContext = new XMLChapterImportContext( rImport, rHlp, 506 nPrefix, rName ); 507 break; 508 509 case XML_TOK_TEXT_TEMPLATENAME: 510 pContext = new XMLTemplateNameImportContext( rImport, rHlp, 511 nPrefix, rName ); 512 break; 513 514 case XML_TOK_TEXT_WORD_COUNT: 515 case XML_TOK_TEXT_PARAGRAPH_COUNT: 516 case XML_TOK_TEXT_TABLE_COUNT: 517 case XML_TOK_TEXT_CHARACTER_COUNT: 518 case XML_TOK_TEXT_IMAGE_COUNT: 519 case XML_TOK_TEXT_OBJECT_COUNT: 520 case XML_TOK_TEXT_PAGE_COUNT: 521 pContext = new XMLCountFieldImportContext( rImport, rHlp, 522 nPrefix, rName, nToken); 523 break; 524 525 case XML_TOK_TEXT_GET_PAGE_VAR: 526 pContext = new XMLPageVarGetFieldImportContext( rImport, rHlp, 527 nPrefix, rName ); 528 break; 529 530 case XML_TOK_TEXT_SET_PAGE_VAR: 531 pContext = new XMLPageVarSetFieldImportContext( rImport, rHlp, 532 nPrefix, rName ); 533 break; 534 535 case XML_TOK_TEXT_MACRO: 536 pContext = new XMLMacroFieldImportContext( rImport, rHlp, 537 nPrefix, rName ); 538 break; 539 540 case XML_TOK_TEXT_DDE: 541 pContext = new XMLDdeFieldImportContext( rImport, rHlp, 542 nPrefix, rName ); 543 break; 544 545 case XML_TOK_TEXT_REFERENCE_REF: 546 case XML_TOK_TEXT_BOOKMARK_REF: 547 case XML_TOK_TEXT_NOTE_REF: 548 case XML_TOK_TEXT_SEQUENCE_REF: 549 pContext = new XMLReferenceFieldImportContext( rImport, rHlp, 550 nToken, 551 nPrefix, rName ); 552 break; 553 554 case XML_TOK_TEXT_SHEET_NAME: 555 pContext = new XMLSheetNameImportContext( rImport, rHlp, 556 nPrefix, rName ); 557 break; 558 559 case XML_TOK_TEXT_BIBLIOGRAPHY_MARK: 560 pContext = new XMLBibliographyFieldImportContext( rImport, rHlp, 561 nPrefix, rName ); 562 break; 563 564 case XML_TOK_TEXT_ANNOTATION: 565 case XML_TOK_TEXT_ANNOTATION_END: 566 pContext = 567 new XMLAnnotationImportContext( rImport, rHlp, nToken, nPrefix, rName); 568 break; 569 570 case XML_TOK_TEXT_SCRIPT: 571 pContext = new XMLScriptImportContext( rImport, rHlp, 572 nPrefix, rName); 573 break; 574 575 case XML_TOK_TEXT_MEASURE: 576 pContext = new XMLMeasureFieldImportContext( rImport, rHlp, 577 nPrefix, rName ); 578 break; 579 580 case XML_TOK_TEXT_TABLE_FORMULA: 581 pContext = new XMLTableFormulaImportContext( rImport, rHlp, 582 nPrefix, rName ); 583 break; 584 case XML_TOK_TEXT_DROPDOWN: 585 pContext = new XMLDropDownFieldImportContext( rImport, rHlp, 586 nPrefix, rName ); 587 break; 588 case XML_TOK_DRAW_HEADER: 589 pContext = new XMLHeaderFieldImportContext( rImport, rHlp, 590 nPrefix, rName ); 591 break; 592 case XML_TOK_DRAW_FOOTER: 593 pContext = new XMLFooterFieldImportContext( rImport, rHlp, 594 nPrefix, rName ); 595 break; 596 case XML_TOK_DRAW_DATE_TIME: 597 pContext = new XMLDateTimeFieldImportContext( rImport, rHlp, 598 nPrefix, rName ); 599 break; 600 601 default: 602 // ignore! May not even be a textfield. 603 // (Reminder: This method is called inside default:-branch) 604 pContext = NULL; 605 break; 606 } 607 608 return pContext; 609 } 610 611 612 void XMLTextFieldImportContext::ForceUpdate( 613 const Reference<XPropertySet> & rPropertySet) 614 { 615 // force update 616 Reference<XUpdatable> xUpdate(rPropertySet, UNO_QUERY); 617 if (xUpdate.is()) 618 { 619 xUpdate->update(); 620 } 621 else 622 { 623 DBG_ERROR("Expected XUpdatable support!"); 624 } 625 } 626 627 628 629 // 630 // XMLSenderFieldImportContext 631 // 632 633 TYPEINIT1( XMLSenderFieldImportContext, XMLTextFieldImportContext); 634 635 XMLSenderFieldImportContext::XMLSenderFieldImportContext( 636 SvXMLImport& rImport, XMLTextImportHelper& rHlp, 637 sal_uInt16 nPrfx, const OUString& sLocalName, 638 sal_uInt16 nToken) 639 : XMLTextFieldImportContext(rImport, rHlp, sAPI_extended_user,nPrfx, sLocalName) 640 , sPropertyFixed(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed)) 641 , sPropertyFieldSubType(RTL_CONSTASCII_USTRINGPARAM(sAPI_user_data_type)) 642 , sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content)) 643 , bFixed(sal_True) 644 , nElementToken(nToken) 645 { 646 } 647 648 void XMLSenderFieldImportContext::StartElement( 649 const Reference<XAttributeList> & xAttrList) 650 { 651 bValid = sal_True; 652 switch (nElementToken) { 653 case XML_TOK_TEXT_SENDER_FIRSTNAME: 654 nSubType = UserDataPart::FIRSTNAME; 655 break; 656 case XML_TOK_TEXT_SENDER_LASTNAME: 657 nSubType = UserDataPart::NAME; 658 break; 659 case XML_TOK_TEXT_SENDER_INITIALS: 660 nSubType = UserDataPart::SHORTCUT; 661 break; 662 case XML_TOK_TEXT_SENDER_TITLE: 663 nSubType = UserDataPart::TITLE; 664 break; 665 case XML_TOK_TEXT_SENDER_POSITION: 666 nSubType = UserDataPart::POSITION; 667 break; 668 case XML_TOK_TEXT_SENDER_EMAIL: 669 nSubType = UserDataPart::EMAIL; 670 break; 671 case XML_TOK_TEXT_SENDER_PHONE_PRIVATE: 672 nSubType = UserDataPart::PHONE_PRIVATE; 673 break; 674 case XML_TOK_TEXT_SENDER_FAX: 675 nSubType = UserDataPart::FAX; 676 break; 677 case XML_TOK_TEXT_SENDER_COMPANY: 678 nSubType = UserDataPart::COMPANY; 679 break; 680 case XML_TOK_TEXT_SENDER_PHONE_WORK: 681 nSubType = UserDataPart::PHONE_COMPANY; 682 break; 683 case XML_TOK_TEXT_SENDER_STREET: 684 nSubType = UserDataPart::STREET; 685 break; 686 case XML_TOK_TEXT_SENDER_CITY: 687 nSubType = UserDataPart::CITY; 688 break; 689 case XML_TOK_TEXT_SENDER_POSTAL_CODE: 690 nSubType = UserDataPart::ZIP; 691 break; 692 case XML_TOK_TEXT_SENDER_COUNTRY: 693 nSubType = UserDataPart::COUNTRY; 694 break; 695 case XML_TOK_TEXT_SENDER_STATE_OR_PROVINCE: 696 nSubType = UserDataPart::STATE; 697 break; 698 default: 699 bValid = sal_False; 700 break; 701 } 702 703 // process Attributes 704 XMLTextFieldImportContext::StartElement(xAttrList); 705 } 706 707 void XMLSenderFieldImportContext::ProcessAttribute( 708 sal_uInt16 nAttrToken, 709 const OUString& sAttrValue) 710 { 711 if (XML_TOK_TEXTFIELD_FIXED == nAttrToken) { 712 713 // set bVal 714 sal_Bool bVal; 715 sal_Bool bRet = GetImport().GetMM100UnitConverter(). 716 convertBool(bVal, sAttrValue); 717 718 // set bFixed if successfull 719 if (bRet) { 720 bFixed = bVal; 721 } 722 } 723 } 724 725 void XMLSenderFieldImportContext::PrepareField( 726 const Reference<XPropertySet> & rPropSet) 727 { 728 // set members 729 Any aAny; 730 aAny <<= nSubType; 731 rPropSet->setPropertyValue(sPropertyFieldSubType, aAny); 732 733 // set fixed 734 aAny.setValue( &bFixed, ::getBooleanCppuType() ); 735 rPropSet->setPropertyValue(sPropertyFixed, aAny); 736 737 // set content if fixed 738 if (bFixed) 739 { 740 // in organizer or styles-only mode: force update 741 if (GetImport().GetTextImport()->IsOrganizerMode() || 742 GetImport().GetTextImport()->IsStylesOnlyMode() ) 743 { 744 ForceUpdate(rPropSet); 745 } 746 else 747 { 748 aAny <<= GetContent(); 749 rPropSet->setPropertyValue(sPropertyContent, aAny); 750 } 751 } 752 } 753 754 755 756 // 757 // XMLAuthorFieldImportContext 758 // 759 760 TYPEINIT1( XMLAuthorFieldImportContext, XMLSenderFieldImportContext); 761 762 XMLAuthorFieldImportContext::XMLAuthorFieldImportContext( 763 SvXMLImport& rImport, XMLTextImportHelper& rHlp, 764 sal_uInt16 nPrfx, const OUString& sLocalName, 765 sal_uInt16 nToken) 766 : XMLSenderFieldImportContext(rImport, rHlp, nPrfx, sLocalName, nToken) 767 , bAuthorFullName(sal_True) 768 , sServiceAuthor(RTL_CONSTASCII_USTRINGPARAM(sAPI_author)) 769 , sPropertyAuthorFullName(RTL_CONSTASCII_USTRINGPARAM(sAPI_full_name)) 770 , sPropertyFixed(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed)) 771 , sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content)) 772 { 773 // overwrite service name from XMLSenderFieldImportContext 774 SetServiceName(sServiceAuthor); 775 } 776 777 void XMLAuthorFieldImportContext::StartElement( 778 const Reference<XAttributeList> & xAttrList) { 779 780 bAuthorFullName = (XML_TOK_TEXT_AUTHOR_INITIALS != nElementToken); 781 bValid = sal_True; 782 783 // process Attributes 784 XMLTextFieldImportContext::StartElement(xAttrList); 785 } 786 787 void XMLAuthorFieldImportContext::PrepareField( 788 const Reference<XPropertySet> & rPropSet) 789 { 790 // set members 791 Any aAny; 792 aAny.setValue( &bAuthorFullName, ::getBooleanCppuType() ); 793 rPropSet->setPropertyValue(sPropertyAuthorFullName, aAny); 794 795 aAny.setValue( &bFixed, ::getBooleanCppuType() ); 796 rPropSet->setPropertyValue(sPropertyFixed, aAny); 797 798 // set content if fixed 799 if (bFixed) 800 { 801 // organizer or styles-only mode: force update 802 if (GetImport().GetTextImport()->IsOrganizerMode() || 803 GetImport().GetTextImport()->IsStylesOnlyMode() ) 804 { 805 ForceUpdate(rPropSet); 806 } 807 else 808 { 809 aAny <<= GetContent(); 810 rPropSet->setPropertyValue(sPropertyContent, aAny); 811 } 812 } 813 } 814 815 816 // 817 // page continuation string 818 // 819 820 TYPEINIT1( XMLPageContinuationImportContext, XMLTextFieldImportContext ); 821 822 static SvXMLEnumMapEntry __READONLY_DATA lcl_aSelectPageAttrMap[] = 823 { 824 { XML_PREVIOUS, PageNumberType_PREV }, 825 { XML_CURRENT, PageNumberType_CURRENT }, 826 { XML_NEXT, PageNumberType_NEXT }, 827 { XML_TOKEN_INVALID, 0 }, 828 }; 829 830 XMLPageContinuationImportContext::XMLPageContinuationImportContext( 831 SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, 832 const OUString& sLocalName) 833 : XMLTextFieldImportContext(rImport, rHlp, sAPI_page_number, nPrfx, sLocalName) 834 , sPropertySubType(RTL_CONSTASCII_USTRINGPARAM(sAPI_sub_type)) 835 , sPropertyUserText(RTL_CONSTASCII_USTRINGPARAM(sAPI_user_text)) 836 , sPropertyNumberingType(RTL_CONSTASCII_USTRINGPARAM(sAPI_numbering_type)) 837 , eSelectPage(PageNumberType_CURRENT) 838 , sStringOK(sal_False) 839 { 840 bValid = sal_True; 841 } 842 843 void XMLPageContinuationImportContext::ProcessAttribute( 844 sal_uInt16 nAttrToken, const OUString& sAttrValue ) 845 { 846 switch(nAttrToken) 847 { 848 case XML_TOK_TEXTFIELD_SELECT_PAGE: 849 { 850 sal_uInt16 nTmp; 851 if (SvXMLUnitConverter::convertEnum(nTmp, sAttrValue, 852 lcl_aSelectPageAttrMap) 853 && (PageNumberType_CURRENT != nTmp) ) 854 { 855 eSelectPage = (PageNumberType)nTmp; 856 } 857 break; 858 } 859 case XML_TOK_TEXTFIELD_STRING_VALUE: 860 sString = sAttrValue; 861 sStringOK = sal_True; 862 break; 863 } 864 } 865 866 void XMLPageContinuationImportContext::PrepareField( 867 const Reference<XPropertySet> & xPropertySet) 868 { 869 Any aAny; 870 871 aAny <<= eSelectPage; 872 xPropertySet->setPropertyValue(sPropertySubType, aAny); 873 874 aAny <<= (sStringOK ? sString : GetContent()); 875 xPropertySet->setPropertyValue(sPropertyUserText, aAny); 876 877 aAny <<= style::NumberingType::CHAR_SPECIAL; 878 xPropertySet->setPropertyValue(sPropertyNumberingType, aAny); 879 } 880 881 882 883 // 884 // page number field 885 // 886 887 TYPEINIT1( XMLPageNumberImportContext, XMLTextFieldImportContext ); 888 889 XMLPageNumberImportContext::XMLPageNumberImportContext( 890 SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, 891 const OUString& sLocalName) 892 : XMLTextFieldImportContext(rImport, rHlp, sAPI_page_number, nPrfx, sLocalName) 893 , sPropertySubType(RTL_CONSTASCII_USTRINGPARAM(sAPI_sub_type)) 894 , sPropertyNumberingType(RTL_CONSTASCII_USTRINGPARAM(sAPI_numbering_type)) 895 , sPropertyOffset(RTL_CONSTASCII_USTRINGPARAM(sAPI_offset)) 896 , sNumberSync(GetXMLToken(XML_FALSE)) 897 , nPageAdjust(0) 898 , eSelectPage(PageNumberType_CURRENT) 899 , sNumberFormatOK(sal_False) 900 { 901 bValid = sal_True; 902 } 903 904 void XMLPageNumberImportContext::ProcessAttribute( 905 sal_uInt16 nAttrToken, 906 const OUString& sAttrValue ) 907 { 908 switch (nAttrToken) 909 { 910 case XML_TOK_TEXTFIELD_NUM_FORMAT: 911 sNumberFormat = sAttrValue; 912 sNumberFormatOK = sal_True; 913 break; 914 case XML_TOK_TEXTFIELD_NUM_LETTER_SYNC: 915 sNumberSync = sAttrValue; 916 break; 917 case XML_TOK_TEXTFIELD_SELECT_PAGE: 918 { 919 sal_uInt16 nTmp; 920 if (SvXMLUnitConverter::convertEnum(nTmp, sAttrValue, 921 lcl_aSelectPageAttrMap)) 922 { 923 eSelectPage = (PageNumberType)nTmp; 924 } 925 break; 926 } 927 case XML_TOK_TEXTFIELD_PAGE_ADJUST: 928 { 929 sal_Int32 nTmp; 930 if (SvXMLUnitConverter::convertNumber(nTmp, sAttrValue)) 931 { 932 nPageAdjust = (sal_Int16)nTmp; 933 } 934 break; 935 } 936 } 937 } 938 939 void XMLPageNumberImportContext::PrepareField( 940 const Reference<XPropertySet> & xPropertySet) 941 { 942 Any aAny; 943 944 // all properties are optional 945 Reference<XPropertySetInfo> xPropertySetInfo( 946 xPropertySet->getPropertySetInfo()); 947 948 if (xPropertySetInfo->hasPropertyByName(sPropertyNumberingType)) 949 { 950 sal_Int16 nNumType; 951 if( sNumberFormatOK ) 952 { 953 nNumType= style::NumberingType::ARABIC; 954 GetImport().GetMM100UnitConverter().convertNumFormat( nNumType, 955 sNumberFormat, 956 sNumberSync ); 957 } 958 else 959 nNumType = style::NumberingType::PAGE_DESCRIPTOR; 960 961 aAny <<= nNumType; 962 xPropertySet->setPropertyValue(sPropertyNumberingType, aAny); 963 } 964 965 if (xPropertySetInfo->hasPropertyByName(sPropertyOffset)) 966 { 967 // adjust offset 968 switch (eSelectPage) 969 { 970 case PageNumberType_PREV: 971 nPageAdjust--; 972 break; 973 case PageNumberType_CURRENT: 974 break; 975 case PageNumberType_NEXT: 976 nPageAdjust++; 977 break; 978 default: 979 DBG_WARNING("unknown page number type"); 980 } 981 aAny <<= nPageAdjust; 982 xPropertySet->setPropertyValue(sPropertyOffset, aAny); 983 } 984 985 if (xPropertySetInfo->hasPropertyByName(sPropertySubType)) 986 { 987 aAny <<= eSelectPage; 988 xPropertySet->setPropertyValue(sPropertySubType, aAny); 989 } 990 } 991 992 993 994 // 995 // Placeholder 996 // 997 998 TYPEINIT1( XMLPlaceholderFieldImportContext, XMLTextFieldImportContext); 999 1000 XMLPlaceholderFieldImportContext::XMLPlaceholderFieldImportContext( 1001 SvXMLImport& rImport, XMLTextImportHelper& rHlp, 1002 sal_uInt16 nPrfx, const OUString& sLocalName) 1003 : XMLTextFieldImportContext(rImport, rHlp, sAPI_jump_edit,nPrfx, sLocalName) 1004 , sPropertyPlaceholderType(RTL_CONSTASCII_USTRINGPARAM(sAPI_place_holder_type)) 1005 , sPropertyPlaceholder(RTL_CONSTASCII_USTRINGPARAM(sAPI_place_holder)) 1006 , sPropertyHint(RTL_CONSTASCII_USTRINGPARAM(sAPI_hint)) 1007 { 1008 } 1009 1010 /// process attribute values 1011 void XMLPlaceholderFieldImportContext::ProcessAttribute( 1012 sal_uInt16 nAttrToken, const OUString& sAttrValue ) 1013 { 1014 switch (nAttrToken) { 1015 case XML_TOK_TEXTFIELD_DESCRIPTION: 1016 sDescription = sAttrValue; 1017 break; 1018 1019 case XML_TOK_TEXTFIELD_PLACEHOLDER_TYPE: 1020 bValid = sal_True; 1021 if (IsXMLToken(sAttrValue, XML_TABLE)) 1022 { 1023 nPlaceholderType = PlaceholderType::TABLE; 1024 } 1025 else if (IsXMLToken(sAttrValue, XML_TEXT)) 1026 { 1027 nPlaceholderType = PlaceholderType::TEXT; 1028 } 1029 else if (IsXMLToken(sAttrValue, XML_TEXT_BOX)) 1030 { 1031 nPlaceholderType = PlaceholderType::TEXTFRAME; 1032 } 1033 else if (IsXMLToken(sAttrValue, XML_IMAGE)) 1034 { 1035 nPlaceholderType = PlaceholderType::GRAPHIC; 1036 } 1037 else if (IsXMLToken(sAttrValue, XML_OBJECT)) 1038 { 1039 nPlaceholderType = PlaceholderType::OBJECT; 1040 } 1041 else 1042 { 1043 bValid = sal_False; 1044 } 1045 break; 1046 1047 default: 1048 ; // ignore 1049 } 1050 } 1051 1052 void XMLPlaceholderFieldImportContext::PrepareField( 1053 const Reference<XPropertySet> & xPropertySet) { 1054 1055 Any aAny; 1056 aAny <<= sDescription; 1057 xPropertySet->setPropertyValue(sPropertyHint, aAny); 1058 1059 // remove <...> around content (if present) 1060 OUString aContent = GetContent(); 1061 sal_Int32 nStart = 0; 1062 sal_Int32 nLength = aContent.getLength(); 1063 if ((nLength > 0) && (aContent.getStr()[0] == '<')) 1064 { 1065 --nLength; 1066 ++nStart; 1067 } 1068 if ((nLength > 0) && (aContent.getStr()[aContent.getLength()-1] == '>')) 1069 { 1070 --nLength; 1071 } 1072 aAny <<= aContent.copy(nStart, nLength); 1073 xPropertySet->setPropertyValue(sPropertyPlaceholder, aAny); 1074 1075 aAny <<= nPlaceholderType; 1076 xPropertySet->setPropertyValue(sPropertyPlaceholderType, aAny); 1077 } 1078 1079 1080 // 1081 // time field 1082 // 1083 1084 TYPEINIT1( XMLTimeFieldImportContext, XMLTextFieldImportContext); 1085 1086 XMLTimeFieldImportContext::XMLTimeFieldImportContext( 1087 SvXMLImport& rImport, XMLTextImportHelper& rHlp, 1088 sal_uInt16 nPrfx, const OUString& sLocalName) 1089 : XMLTextFieldImportContext(rImport, rHlp, sAPI_date_time, nPrfx, sLocalName) 1090 , sPropertyNumberFormat(RTL_CONSTASCII_USTRINGPARAM(sAPI_number_format)) 1091 , sPropertyFixed(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed)) 1092 , sPropertyDateTimeValue(RTL_CONSTASCII_USTRINGPARAM(sAPI_date_time_value)) 1093 , sPropertyDateTime(RTL_CONSTASCII_USTRINGPARAM(sAPI_date_time)) 1094 , sPropertyAdjust(RTL_CONSTASCII_USTRINGPARAM(sAPI_adjust)) 1095 , sPropertyIsDate(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_date)) 1096 , sPropertyIsFixedLanguage(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed_language)) 1097 , fTimeValue(0.0) 1098 , nAdjust(0) 1099 , nFormatKey(0) 1100 , bTimeOK(sal_False) 1101 , bFormatOK(sal_False) 1102 , bFixed(sal_False) 1103 , bIsDate(sal_False) 1104 , bIsDefaultLanguage( sal_True ) 1105 { 1106 bValid = sal_True; // always valid! 1107 } 1108 1109 void XMLTimeFieldImportContext::ProcessAttribute( 1110 sal_uInt16 nAttrToken, const OUString& sAttrValue ) 1111 { 1112 switch (nAttrToken) 1113 { 1114 case XML_TOK_TEXTFIELD_TIME_VALUE: 1115 { 1116 double fTmp; 1117 if (GetImport().GetMM100UnitConverter(). 1118 convertDateTime(fTmp, sAttrValue)) 1119 { 1120 fTimeValue = fTmp; 1121 bTimeOK = sal_True; 1122 } 1123 1124 if (GetImport().GetMM100UnitConverter(). 1125 convertDateTime(aDateTimeValue, sAttrValue )) 1126 { 1127 bTimeOK = sal_True; 1128 } 1129 break; 1130 } 1131 case XML_TOK_TEXTFIELD_FIXED: 1132 { 1133 sal_Bool bTmp; 1134 if (SvXMLUnitConverter::convertBool(bTmp, sAttrValue)) 1135 { 1136 bFixed = bTmp; 1137 } 1138 break; 1139 } 1140 case XML_TOK_TEXTFIELD_DATA_STYLE_NAME: 1141 { 1142 sal_Int32 nKey = GetImportHelper().GetDataStyleKey( 1143 sAttrValue, &bIsDefaultLanguage); 1144 if (-1 != nKey) 1145 { 1146 nFormatKey = nKey; 1147 bFormatOK = sal_True; 1148 } 1149 break; 1150 } 1151 case XML_TOK_TEXTFIELD_TIME_ADJUST: 1152 { 1153 double fTmp; 1154 1155 if (SvXMLUnitConverter::convertTime(fTmp, sAttrValue)) 1156 { 1157 // convert to minutes 1158 nAdjust = (sal_Int32)::rtl::math::approxFloor(fTmp * 60 * 24); 1159 } 1160 break; 1161 } 1162 } 1163 } 1164 1165 void XMLTimeFieldImportContext::PrepareField( 1166 const Reference<XPropertySet> & rPropertySet) 1167 { 1168 Any aAny; 1169 1170 // all properties are optional (except IsDate) 1171 Reference<XPropertySetInfo> xPropertySetInfo( 1172 rPropertySet->getPropertySetInfo()); 1173 1174 if (xPropertySetInfo->hasPropertyByName(sPropertyFixed)) 1175 { 1176 aAny.setValue( &bFixed, ::getBooleanCppuType() ); 1177 rPropertySet->setPropertyValue(sPropertyFixed, aAny); 1178 } 1179 1180 aAny.setValue( &bIsDate, ::getBooleanCppuType() ); 1181 rPropertySet->setPropertyValue(sPropertyIsDate, aAny); 1182 1183 if (xPropertySetInfo->hasPropertyByName(sPropertyAdjust)) 1184 { 1185 aAny <<= nAdjust; 1186 rPropertySet->setPropertyValue(sPropertyAdjust, aAny); 1187 } 1188 1189 // set value 1190 if (bFixed) 1191 { 1192 // organizer or styles-only mode: force update 1193 if (GetImport().GetTextImport()->IsOrganizerMode() || 1194 GetImport().GetTextImport()->IsStylesOnlyMode() ) 1195 { 1196 ForceUpdate(rPropertySet); 1197 } 1198 else 1199 { 1200 // normal mode: set value (if present) 1201 if (bTimeOK) 1202 { 1203 if (xPropertySetInfo->hasPropertyByName(sPropertyDateTimeValue)) 1204 { 1205 aAny <<= aDateTimeValue; 1206 rPropertySet->setPropertyValue(sPropertyDateTimeValue,aAny); 1207 } 1208 else if (xPropertySetInfo->hasPropertyByName(sPropertyDateTime)) 1209 { 1210 aAny <<= aDateTimeValue; 1211 rPropertySet->setPropertyValue(sPropertyDateTime, aAny); 1212 } 1213 } 1214 } 1215 } 1216 1217 if (bFormatOK && 1218 xPropertySetInfo->hasPropertyByName(sPropertyNumberFormat)) 1219 { 1220 aAny <<= nFormatKey; 1221 rPropertySet->setPropertyValue(sPropertyNumberFormat, aAny); 1222 1223 if( xPropertySetInfo->hasPropertyByName( sPropertyIsFixedLanguage ) ) 1224 { 1225 sal_Bool bIsFixedLanguage = ! bIsDefaultLanguage; 1226 aAny.setValue( &bIsFixedLanguage, ::getBooleanCppuType() ); 1227 rPropertySet->setPropertyValue( sPropertyIsFixedLanguage, aAny ); 1228 } 1229 } 1230 } 1231 1232 1233 1234 // 1235 // date field 1236 // 1237 1238 TYPEINIT1( XMLDateFieldImportContext, XMLTimeFieldImportContext ); 1239 1240 XMLDateFieldImportContext::XMLDateFieldImportContext( 1241 SvXMLImport& rImport, XMLTextImportHelper& rHlp, 1242 sal_uInt16 nPrfx, const OUString& sLocalName) : 1243 XMLTimeFieldImportContext(rImport, rHlp, nPrfx, sLocalName) 1244 { 1245 bIsDate = sal_True; // always a date! 1246 } 1247 1248 void XMLDateFieldImportContext::ProcessAttribute( 1249 sal_uInt16 nAttrToken, 1250 const ::rtl::OUString& sAttrValue ) 1251 { 1252 switch (nAttrToken) 1253 { 1254 case XML_TOK_TEXTFIELD_DATE_VALUE: 1255 { 1256 double fTmp; 1257 1258 if (GetImport().GetMM100UnitConverter(). 1259 convertDateTime(fTmp, sAttrValue)) 1260 { 1261 // #96457#: don't truncate in order to read date+time 1262 fTimeValue = fTmp; 1263 bTimeOK = sal_True; 1264 } 1265 1266 if (GetImport().GetMM100UnitConverter(). 1267 convertDateTime(aDateTimeValue, sAttrValue )) 1268 { 1269 bTimeOK = sal_True; 1270 } 1271 break; 1272 } 1273 case XML_TOK_TEXTFIELD_DATE_ADJUST: 1274 // delegate to superclass, pretending it was a time-adjust attr. 1275 XMLTimeFieldImportContext::ProcessAttribute( 1276 XML_TOK_TEXTFIELD_TIME_ADJUST, 1277 sAttrValue); 1278 break; 1279 case XML_TOK_TEXTFIELD_TIME_VALUE: 1280 case XML_TOK_TEXTFIELD_TIME_ADJUST: 1281 ; // ignore time-adjust and time-value attributes 1282 break; 1283 default: 1284 // all others: delegate to super-class 1285 XMLTimeFieldImportContext::ProcessAttribute(nAttrToken, 1286 sAttrValue); 1287 break; 1288 } 1289 } 1290 1291 1292 1293 1294 // 1295 // database field superclass 1296 // 1297 1298 TYPEINIT1( XMLDatabaseFieldImportContext, XMLTextFieldImportContext ); 1299 1300 XMLDatabaseFieldImportContext::XMLDatabaseFieldImportContext( 1301 SvXMLImport& rImport, XMLTextImportHelper& rHlp, 1302 const sal_Char* pServiceName, sal_uInt16 nPrfx, 1303 const OUString& sLocalName, bool bUseDisply) 1304 : XMLTextFieldImportContext(rImport, rHlp, pServiceName, nPrfx, sLocalName) 1305 , sPropertyDataBaseName(RTL_CONSTASCII_USTRINGPARAM(sAPI_data_base_name)) 1306 , sPropertyDataBaseURL(RTL_CONSTASCII_USTRINGPARAM(sAPI_data_base_u_r_l)) 1307 , sPropertyTableName(RTL_CONSTASCII_USTRINGPARAM(sAPI_data_table_name)) 1308 , sPropertyDataCommandType(RTL_CONSTASCII_USTRINGPARAM(sAPI_data_command_type)) 1309 , sPropertyIsVisible(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_visible)) 1310 , nCommandType( sdb::CommandType::TABLE ) 1311 , bCommandTypeOK(sal_False) 1312 , bDisplay( sal_True ) 1313 , bDisplayOK( false ) 1314 , bUseDisplay( bUseDisply ) 1315 , bDatabaseOK(sal_False) 1316 , bDatabaseNameOK(sal_False) 1317 , bDatabaseURLOK(sal_False) 1318 , bTableOK(sal_False) 1319 { 1320 } 1321 1322 void XMLDatabaseFieldImportContext::ProcessAttribute( 1323 sal_uInt16 nAttrToken, const OUString& sAttrValue ) 1324 { 1325 switch (nAttrToken) 1326 { 1327 case XML_TOK_TEXTFIELD_DATABASE_NAME: 1328 sDatabaseName = sAttrValue; 1329 bDatabaseOK = sal_True; 1330 bDatabaseNameOK = sal_True; 1331 break; 1332 case XML_TOK_TEXTFIELD_TABLE_NAME: 1333 sTableName = sAttrValue; 1334 bTableOK = sal_True; 1335 break; 1336 case XML_TOK_TEXTFIELD_TABLE_TYPE: 1337 if( IsXMLToken( sAttrValue, XML_TABLE ) ) 1338 { 1339 nCommandType = sdb::CommandType::TABLE; 1340 bCommandTypeOK = sal_True; 1341 } 1342 else if( IsXMLToken( sAttrValue, XML_QUERY ) ) 1343 { 1344 nCommandType = sdb::CommandType::QUERY; 1345 bCommandTypeOK = sal_True; 1346 } 1347 else if( IsXMLToken( sAttrValue, XML_COMMAND ) ) 1348 { 1349 nCommandType = sdb::CommandType::COMMAND; 1350 bCommandTypeOK = sal_True; 1351 } 1352 break; 1353 case XML_TOK_TEXTFIELD_DISPLAY: 1354 if( IsXMLToken( sAttrValue, XML_NONE ) ) 1355 { 1356 bDisplay = sal_False; 1357 bDisplayOK = true; 1358 } 1359 else if( IsXMLToken( sAttrValue, XML_VALUE ) ) 1360 { 1361 bDisplay = sal_True; 1362 bDisplayOK = true; 1363 } 1364 break; 1365 } 1366 } 1367 1368 SvXMLImportContext* XMLDatabaseFieldImportContext::CreateChildContext( 1369 sal_uInt16 p_nPrefix, 1370 const OUString& rLocalName, 1371 const Reference<XAttributeList>& xAttrList ) 1372 { 1373 if( ( p_nPrefix == XML_NAMESPACE_FORM ) && 1374 IsXMLToken( rLocalName, XML_CONNECTION_RESOURCE ) ) 1375 { 1376 // process attribute list directly 1377 sal_Int16 nLength = xAttrList->getLength(); 1378 for( sal_Int16 n = 0; n < nLength; n++ ) 1379 { 1380 OUString sLocalName; 1381 sal_uInt16 nPrefix = GetImport().GetNamespaceMap(). 1382 GetKeyByAttrName( xAttrList->getNameByIndex(n), &sLocalName ); 1383 1384 if( ( nPrefix == XML_NAMESPACE_XLINK ) && 1385 IsXMLToken( sLocalName, XML_HREF ) ) 1386 { 1387 sDatabaseURL = xAttrList->getValueByIndex(n); 1388 bDatabaseOK = sal_True; 1389 bDatabaseURLOK = sal_True; 1390 } 1391 } 1392 1393 // we call ProcessAttribute in order to set bValid appropriatly 1394 ProcessAttribute( XML_TOKEN_INVALID, OUString() ); 1395 } 1396 1397 return SvXMLImportContext::CreateChildContext(p_nPrefix, rLocalName, 1398 xAttrList); 1399 } 1400 1401 1402 void XMLDatabaseFieldImportContext::PrepareField( 1403 const Reference<XPropertySet> & xPropertySet) 1404 { 1405 Any aAny; 1406 1407 aAny <<= sTableName; 1408 xPropertySet->setPropertyValue(sPropertyTableName, aAny); 1409 1410 if( bDatabaseNameOK ) 1411 { 1412 aAny <<= sDatabaseName; 1413 xPropertySet->setPropertyValue(sPropertyDataBaseName, aAny); 1414 } 1415 else if( bDatabaseURLOK ) 1416 { 1417 aAny <<= sDatabaseURL; 1418 xPropertySet->setPropertyValue(sPropertyDataBaseURL, aAny); 1419 } 1420 1421 // #99980# load/save command type for all fields; also load 1422 // old documents without command type 1423 if( bCommandTypeOK ) 1424 { 1425 aAny <<= nCommandType; 1426 xPropertySet->setPropertyValue( sPropertyDataCommandType, aAny ); 1427 } 1428 1429 if( bUseDisplay && bDisplayOK ) 1430 { 1431 aAny.setValue( &bDisplay, ::getBooleanCppuType() ); 1432 xPropertySet->setPropertyValue( sPropertyIsVisible, aAny ); 1433 } 1434 } 1435 1436 1437 1438 // 1439 // database name field 1440 // 1441 1442 TYPEINIT1( XMLDatabaseNameImportContext, XMLDatabaseFieldImportContext ); 1443 1444 XMLDatabaseNameImportContext::XMLDatabaseNameImportContext( 1445 SvXMLImport& rImport, XMLTextImportHelper& rHlp, 1446 sal_uInt16 nPrfx, const OUString& sLocalName) : 1447 XMLDatabaseFieldImportContext(rImport, rHlp, sAPI_database_name, 1448 nPrfx, sLocalName, true) 1449 { 1450 } 1451 1452 void XMLDatabaseNameImportContext::ProcessAttribute( 1453 sal_uInt16 nAttrToken, const OUString& sAttrValue ) 1454 { 1455 // delegate to superclass and check for success 1456 XMLDatabaseFieldImportContext::ProcessAttribute(nAttrToken, sAttrValue); 1457 bValid = bDatabaseOK && bTableOK; 1458 } 1459 1460 1461 1462 // 1463 // database next field 1464 // 1465 1466 TYPEINIT1( XMLDatabaseNextImportContext, XMLDatabaseFieldImportContext ); 1467 1468 XMLDatabaseNextImportContext::XMLDatabaseNextImportContext( 1469 SvXMLImport& rImport, XMLTextImportHelper& rHlp, 1470 const sal_Char* pServiceName, sal_uInt16 nPrfx, 1471 const OUString& sLocalName) : 1472 XMLDatabaseFieldImportContext(rImport, rHlp, pServiceName, 1473 nPrfx, sLocalName, false), 1474 sPropertyCondition(RTL_CONSTASCII_USTRINGPARAM(sAPI_condition)), 1475 sTrue(RTL_CONSTASCII_USTRINGPARAM(sAPI_true)), 1476 sCondition(), 1477 bConditionOK(sal_False) 1478 { 1479 } 1480 1481 XMLDatabaseNextImportContext::XMLDatabaseNextImportContext( 1482 SvXMLImport& rImport, XMLTextImportHelper& rHlp, 1483 sal_uInt16 nPrfx, const OUString& sLocalName) 1484 : XMLDatabaseFieldImportContext(rImport, rHlp, sAPI_database_next, nPrfx, sLocalName, false) 1485 , sPropertyCondition(RTL_CONSTASCII_USTRINGPARAM(sAPI_condition)) 1486 , sTrue(RTL_CONSTASCII_USTRINGPARAM(sAPI_true)) 1487 , bConditionOK(sal_False) 1488 { 1489 } 1490 1491 void XMLDatabaseNextImportContext::ProcessAttribute( 1492 sal_uInt16 nAttrToken, const OUString& sAttrValue ) 1493 { 1494 if (XML_TOK_TEXTFIELD_CONDITION == nAttrToken) 1495 { 1496 OUString sTmp; 1497 sal_uInt16 nPrefix = GetImport().GetNamespaceMap()._GetKeyByAttrName( 1498 sAttrValue, &sTmp, sal_False ); 1499 if( XML_NAMESPACE_OOOW == nPrefix ) 1500 { 1501 sCondition = sTmp; 1502 bConditionOK = sal_True; 1503 } 1504 else 1505 sCondition = sAttrValue; 1506 } 1507 else 1508 { 1509 XMLDatabaseFieldImportContext::ProcessAttribute(nAttrToken, 1510 sAttrValue); 1511 } 1512 1513 bValid = bDatabaseOK && bTableOK; 1514 } 1515 1516 void XMLDatabaseNextImportContext::PrepareField( 1517 const Reference<XPropertySet> & xPropertySet) 1518 { 1519 Any aAny; 1520 1521 aAny <<= bConditionOK ? sCondition : sTrue; 1522 xPropertySet->setPropertyValue(sPropertyCondition, aAny); 1523 1524 XMLDatabaseFieldImportContext::PrepareField(xPropertySet); 1525 } 1526 1527 1528 1529 // 1530 // database select field 1531 // 1532 1533 TYPEINIT1( XMLDatabaseSelectImportContext, XMLDatabaseNextImportContext ); 1534 1535 XMLDatabaseSelectImportContext::XMLDatabaseSelectImportContext( 1536 SvXMLImport& rImport, XMLTextImportHelper& rHlp, 1537 sal_uInt16 nPrfx, const ::rtl::OUString& sLocalName) : 1538 XMLDatabaseNextImportContext(rImport, rHlp, sAPI_database_select, 1539 nPrfx, sLocalName), 1540 sPropertySetNumber(RTL_CONSTASCII_USTRINGPARAM(sAPI_set_number)), 1541 nNumber(0), 1542 bNumberOK(sal_False) 1543 { 1544 } 1545 1546 void XMLDatabaseSelectImportContext::ProcessAttribute( 1547 sal_uInt16 nAttrToken, 1548 const ::rtl::OUString& sAttrValue ) 1549 { 1550 if (XML_TOK_TEXTFIELD_ROW_NUMBER == nAttrToken) 1551 { 1552 sal_Int32 nTmp; 1553 if (SvXMLUnitConverter::convertNumber( nTmp, sAttrValue 1554 /* , nMin, nMax ??? */ )) 1555 { 1556 nNumber = nTmp; 1557 bNumberOK = sal_True; 1558 } 1559 } 1560 else 1561 { 1562 XMLDatabaseNextImportContext::ProcessAttribute(nAttrToken, sAttrValue); 1563 } 1564 1565 bValid = bTableOK && bDatabaseOK && bNumberOK; 1566 } 1567 1568 void XMLDatabaseSelectImportContext::PrepareField( 1569 const Reference<XPropertySet> & xPropertySet) 1570 { 1571 Any aAny; 1572 1573 aAny <<= nNumber; 1574 xPropertySet->setPropertyValue(sPropertySetNumber, aAny); 1575 1576 XMLDatabaseNextImportContext::PrepareField(xPropertySet); 1577 } 1578 1579 1580 1581 // 1582 // database display row number field 1583 // 1584 1585 TYPEINIT1( XMLDatabaseNumberImportContext, XMLDatabaseFieldImportContext ); 1586 1587 XMLDatabaseNumberImportContext::XMLDatabaseNumberImportContext( 1588 SvXMLImport& rImport, XMLTextImportHelper& rHlp, 1589 sal_uInt16 nPrfx, const OUString& sLocalName) : 1590 XMLDatabaseFieldImportContext(rImport, rHlp, sAPI_database_number, 1591 nPrfx, sLocalName, true), 1592 sPropertyNumberingType( 1593 RTL_CONSTASCII_USTRINGPARAM(sAPI_numbering_type)), 1594 sPropertySetNumber(RTL_CONSTASCII_USTRINGPARAM(sAPI_set_number)), 1595 sNumberFormat(RTL_CONSTASCII_USTRINGPARAM("1")), 1596 sNumberSync(GetXMLToken(XML_FALSE)), 1597 nValue(0), 1598 bValueOK(sal_False) 1599 { 1600 } 1601 1602 void XMLDatabaseNumberImportContext::ProcessAttribute( 1603 sal_uInt16 nAttrToken, 1604 const OUString& sAttrValue ) 1605 { 1606 switch (nAttrToken) 1607 { 1608 case XML_TOK_TEXTFIELD_NUM_FORMAT: 1609 sNumberFormat = sAttrValue; 1610 break; 1611 case XML_TOK_TEXTFIELD_NUM_LETTER_SYNC: 1612 sNumberSync = sAttrValue; 1613 break; 1614 case XML_TOK_TEXTFIELD_VALUE: 1615 { 1616 sal_Int32 nTmp; 1617 if (SvXMLUnitConverter::convertNumber( nTmp, sAttrValue )) 1618 { 1619 nValue = nTmp; 1620 bValueOK = sal_True; 1621 } 1622 break; 1623 } 1624 default: 1625 XMLDatabaseFieldImportContext::ProcessAttribute(nAttrToken, 1626 sAttrValue); 1627 break; 1628 } 1629 1630 bValid = bTableOK && bDatabaseOK; 1631 } 1632 1633 void XMLDatabaseNumberImportContext::PrepareField( 1634 const Reference<XPropertySet> & xPropertySet) 1635 { 1636 Any aAny; 1637 1638 sal_Int16 nNumType = style::NumberingType::ARABIC; 1639 GetImport().GetMM100UnitConverter().convertNumFormat( nNumType, 1640 sNumberFormat, 1641 sNumberSync ); 1642 aAny <<= nNumType; 1643 xPropertySet->setPropertyValue(sPropertyNumberingType, aAny); 1644 1645 if (bValueOK) 1646 { 1647 aAny <<= nValue; 1648 xPropertySet->setPropertyValue(sPropertySetNumber, aAny); 1649 } 1650 1651 XMLDatabaseFieldImportContext::PrepareField(xPropertySet); 1652 } 1653 1654 1655 1656 // 1657 // Simple doc info fields 1658 // 1659 1660 TYPEINIT1( XMLSimpleDocInfoImportContext, XMLTextFieldImportContext ); 1661 1662 XMLSimpleDocInfoImportContext::XMLSimpleDocInfoImportContext( 1663 SvXMLImport& rImport, XMLTextImportHelper& rHlp, 1664 sal_uInt16 nPrfx, const OUString& sLocalName, sal_uInt16 nToken, 1665 sal_Bool bContent, sal_Bool bAuthor) 1666 : XMLTextFieldImportContext(rImport, rHlp, MapTokenToServiceName(nToken),nPrfx, sLocalName) 1667 , sPropertyFixed(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed)) 1668 , sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content)) 1669 , sPropertyAuthor(RTL_CONSTASCII_USTRINGPARAM(sAPI_author)) 1670 , sPropertyCurrentPresentation(RTL_CONSTASCII_USTRINGPARAM(sAPI_current_presentation)) 1671 , bFixed(sal_False) 1672 , bHasAuthor(bAuthor) 1673 , bHasContent(bContent) 1674 { 1675 bValid = sal_True; 1676 } 1677 1678 void XMLSimpleDocInfoImportContext::ProcessAttribute( 1679 sal_uInt16 nAttrToken, 1680 const OUString& sAttrValue ) 1681 { 1682 if (XML_TOK_TEXTFIELD_FIXED == nAttrToken) 1683 { 1684 sal_Bool bTmp; 1685 if (SvXMLUnitConverter::convertBool(bTmp, sAttrValue)) 1686 { 1687 bFixed = bTmp; 1688 } 1689 } 1690 } 1691 1692 void XMLSimpleDocInfoImportContext::PrepareField( 1693 const Reference<XPropertySet> & rPropertySet) 1694 { 1695 // title field in Calc has no Fixed property 1696 Reference<XPropertySetInfo> xPropertySetInfo(rPropertySet->getPropertySetInfo()); 1697 if (xPropertySetInfo->hasPropertyByName(sPropertyFixed)) 1698 { 1699 Any aAny; 1700 aAny.setValue(&bFixed, ::getBooleanCppuType() ); 1701 rPropertySet->setPropertyValue(sPropertyFixed, aAny); 1702 1703 // set Content and CurrentPresentation (if fixed) 1704 if (bFixed) 1705 { 1706 // in organizer-mode or styles-only-mode, only force update 1707 if (GetImport().GetTextImport()->IsOrganizerMode() || 1708 GetImport().GetTextImport()->IsStylesOnlyMode() ) 1709 { 1710 ForceUpdate(rPropertySet); 1711 } 1712 else 1713 { 1714 // set content (author, if that's the name) and current 1715 // presentation 1716 aAny <<= GetContent(); 1717 1718 if (bFixed && bHasAuthor) 1719 { 1720 rPropertySet->setPropertyValue(sPropertyAuthor, aAny); 1721 } 1722 1723 if (bFixed && bHasContent) 1724 { 1725 rPropertySet->setPropertyValue(sPropertyContent, aAny); 1726 } 1727 1728 rPropertySet->setPropertyValue(sPropertyCurrentPresentation, aAny); 1729 } 1730 } 1731 } 1732 } 1733 1734 const sal_Char* XMLSimpleDocInfoImportContext::MapTokenToServiceName( 1735 sal_uInt16 nToken) 1736 { 1737 const sal_Char* pServiceName = NULL; 1738 1739 switch(nToken) 1740 { 1741 case XML_TOK_TEXT_DOCUMENT_CREATION_AUTHOR: 1742 pServiceName = sAPI_docinfo_create_author; 1743 break; 1744 case XML_TOK_TEXT_DOCUMENT_CREATION_DATE: 1745 pServiceName = sAPI_docinfo_create_date_time; 1746 break; 1747 case XML_TOK_TEXT_DOCUMENT_CREATION_TIME: 1748 pServiceName = sAPI_docinfo_create_date_time; 1749 break; 1750 case XML_TOK_TEXT_DOCUMENT_DESCRIPTION: 1751 pServiceName = sAPI_docinfo_description; 1752 break; 1753 case XML_TOK_TEXT_DOCUMENT_EDIT_DURATION: 1754 pServiceName = sAPI_docinfo_edit_time; 1755 break; 1756 case XML_TOK_TEXT_DOCUMENT_USER_DEFINED: 1757 pServiceName = sAPI_docinfo_custom; 1758 break; 1759 case XML_TOK_TEXT_DOCUMENT_PRINT_AUTHOR: 1760 pServiceName = sAPI_docinfo_print_author; 1761 break; 1762 case XML_TOK_TEXT_DOCUMENT_PRINT_DATE: 1763 pServiceName = sAPI_docinfo_print_date_time; 1764 break; 1765 case XML_TOK_TEXT_DOCUMENT_PRINT_TIME: 1766 pServiceName = sAPI_docinfo_print_date_time; 1767 break; 1768 case XML_TOK_TEXT_DOCUMENT_KEYWORDS: 1769 pServiceName = sAPI_docinfo_keywords; 1770 break; 1771 case XML_TOK_TEXT_DOCUMENT_SUBJECT: 1772 pServiceName = sAPI_docinfo_subject; 1773 break; 1774 case XML_TOK_TEXT_DOCUMENT_REVISION: 1775 pServiceName = sAPI_docinfo_revision; 1776 break; 1777 case XML_TOK_TEXT_DOCUMENT_SAVE_AUTHOR: 1778 pServiceName = sAPI_docinfo_change_author; 1779 break; 1780 case XML_TOK_TEXT_DOCUMENT_SAVE_DATE: 1781 pServiceName = sAPI_docinfo_change_date_time; 1782 break; 1783 case XML_TOK_TEXT_DOCUMENT_SAVE_TIME: 1784 pServiceName = sAPI_docinfo_change_date_time; 1785 break; 1786 case XML_TOK_TEXT_DOCUMENT_TITLE: 1787 pServiceName = sAPI_docinfo_title; 1788 break; 1789 1790 default: 1791 DBG_ERROR("no docinfo field token"); 1792 pServiceName = NULL; 1793 break; 1794 } 1795 1796 return pServiceName; 1797 } 1798 1799 1800 // 1801 // revision field 1802 // 1803 1804 TYPEINIT1( XMLRevisionDocInfoImportContext, XMLSimpleDocInfoImportContext ); 1805 1806 XMLRevisionDocInfoImportContext::XMLRevisionDocInfoImportContext( 1807 SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, 1808 const OUString& sLocalName, sal_uInt16 nToken) : 1809 XMLSimpleDocInfoImportContext(rImport, rHlp, nPrfx, sLocalName, 1810 nToken, sal_False, sal_False), 1811 sPropertyRevision(RTL_CONSTASCII_USTRINGPARAM(sAPI_revision)) 1812 { 1813 bValid = sal_True; 1814 } 1815 1816 void XMLRevisionDocInfoImportContext::PrepareField( 1817 const Reference<XPropertySet> & rPropertySet) 1818 { 1819 XMLSimpleDocInfoImportContext::PrepareField(rPropertySet); 1820 1821 // set revision number 1822 // if fixed, if not in organizer-mode, if not in styles-only-mode 1823 if (bFixed) 1824 { 1825 if ( GetImport().GetTextImport()->IsOrganizerMode() || 1826 GetImport().GetTextImport()->IsStylesOnlyMode() ) 1827 { 1828 ForceUpdate(rPropertySet); 1829 } 1830 else 1831 { 1832 sal_Int32 nTmp; 1833 if (SvXMLUnitConverter::convertNumber(nTmp, GetContent())) 1834 { 1835 Any aAny; 1836 aAny <<= nTmp; 1837 rPropertySet->setPropertyValue(sPropertyRevision, aAny); 1838 } 1839 } 1840 } 1841 } 1842 1843 1844 1845 // 1846 // DocInfo fields with date/time attributes 1847 // 1848 1849 TYPEINIT1( XMLDateTimeDocInfoImportContext, XMLSimpleDocInfoImportContext ); 1850 1851 XMLDateTimeDocInfoImportContext::XMLDateTimeDocInfoImportContext( 1852 SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, 1853 const OUString& sLocalName, sal_uInt16 nToken) 1854 : XMLSimpleDocInfoImportContext(rImport, rHlp, nPrfx, sLocalName,nToken, sal_False, sal_False) 1855 , sPropertyNumberFormat(RTL_CONSTASCII_USTRINGPARAM(sAPI_number_format)) 1856 , sPropertyIsDate(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_date)) 1857 , sPropertyIsFixedLanguage(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed_language)) 1858 , nFormat(0) 1859 , bFormatOK(sal_False) 1860 , bIsDefaultLanguage(sal_True) 1861 { 1862 // we allow processing of EDIT_DURATION here, because import of actual 1863 // is not supported anyway. If it was, we'd need an extra import class 1864 // because times and time durations are presented differently! 1865 1866 bValid = sal_True; 1867 switch (nToken) 1868 { 1869 case XML_TOK_TEXT_DOCUMENT_CREATION_DATE: 1870 case XML_TOK_TEXT_DOCUMENT_PRINT_DATE: 1871 case XML_TOK_TEXT_DOCUMENT_SAVE_DATE: 1872 bIsDate = sal_True; 1873 bHasDateTime = sal_True; 1874 break; 1875 case XML_TOK_TEXT_DOCUMENT_CREATION_TIME: 1876 case XML_TOK_TEXT_DOCUMENT_PRINT_TIME: 1877 case XML_TOK_TEXT_DOCUMENT_SAVE_TIME: 1878 bIsDate = sal_False; 1879 bHasDateTime = sal_True; 1880 break; 1881 case XML_TOK_TEXT_DOCUMENT_EDIT_DURATION: 1882 bIsDate = sal_False; 1883 bHasDateTime = sal_False; 1884 break; 1885 default: 1886 DBG_ERROR( 1887 "XMLDateTimeDocInfoImportContext needs date/time doc. fields"); 1888 bValid = sal_False; 1889 break; 1890 } 1891 } 1892 1893 void XMLDateTimeDocInfoImportContext::ProcessAttribute( 1894 sal_uInt16 nAttrToken, 1895 const OUString& sAttrValue ) 1896 { 1897 switch (nAttrToken) 1898 { 1899 case XML_TOK_TEXTFIELD_DATA_STYLE_NAME: 1900 { 1901 sal_Int32 nKey = GetImportHelper().GetDataStyleKey( 1902 sAttrValue, &bIsDefaultLanguage); 1903 if (-1 != nKey) 1904 { 1905 nFormat = nKey; 1906 bFormatOK = sal_True; 1907 } 1908 break; 1909 } 1910 case XML_TOK_TEXTFIELD_FIXED: 1911 XMLSimpleDocInfoImportContext::ProcessAttribute(nAttrToken, 1912 sAttrValue); 1913 break; 1914 default: 1915 // ignore -> we can't set date/time value anyway! 1916 break; 1917 } 1918 } 1919 1920 void XMLDateTimeDocInfoImportContext::PrepareField( 1921 const Reference<XPropertySet> & xPropertySet) 1922 { 1923 // process fixed and presentation 1924 XMLSimpleDocInfoImportContext::PrepareField(xPropertySet); 1925 1926 Any aAny; 1927 1928 if (bHasDateTime) 1929 { 1930 aAny.setValue( &bIsDate, ::getBooleanCppuType()); 1931 xPropertySet->setPropertyValue(sPropertyIsDate, aAny); 1932 } 1933 1934 if (bFormatOK) 1935 { 1936 aAny <<= nFormat; 1937 xPropertySet->setPropertyValue(sPropertyNumberFormat, aAny); 1938 1939 if( xPropertySet->getPropertySetInfo()-> 1940 hasPropertyByName( sPropertyIsFixedLanguage ) ) 1941 { 1942 sal_Bool bIsFixedLanguage = ! bIsDefaultLanguage; 1943 aAny.setValue( &bIsFixedLanguage, ::getBooleanCppuType() ); 1944 xPropertySet->setPropertyValue( sPropertyIsFixedLanguage, aAny ); 1945 } 1946 } 1947 1948 // can't set date/time/duration value! Sorry. 1949 } 1950 1951 1952 // 1953 // user defined docinfo fields 1954 // 1955 1956 TYPEINIT1( XMLUserDocInfoImportContext, XMLSimpleDocInfoImportContext ); 1957 1958 XMLUserDocInfoImportContext::XMLUserDocInfoImportContext( 1959 SvXMLImport& rImport, XMLTextImportHelper& rHlp, 1960 sal_uInt16 nPrfx, const OUString& sLocalName, sal_uInt16 nToken) : 1961 XMLSimpleDocInfoImportContext(rImport, rHlp, nPrfx, 1962 sLocalName, nToken, 1963 sal_False, sal_False) 1964 , sPropertyName(RTL_CONSTASCII_USTRINGPARAM(sAPI_name)) 1965 , sPropertyNumberFormat(RTL_CONSTASCII_USTRINGPARAM(sAPI_number_format)) 1966 , sPropertyIsFixedLanguage(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed_language)) 1967 , nFormat(0) 1968 , bFormatOK(sal_False) 1969 , bIsDefaultLanguage( sal_True ) 1970 { 1971 bValid = sal_False; 1972 } 1973 1974 void XMLUserDocInfoImportContext::ProcessAttribute( 1975 sal_uInt16 nAttrToken, 1976 const OUString& sAttrValue ) 1977 { 1978 switch (nAttrToken) 1979 { 1980 case XML_TOK_TEXTFIELD_DATA_STYLE_NAME: 1981 { 1982 sal_Int32 nKey = GetImportHelper().GetDataStyleKey( 1983 sAttrValue, &bIsDefaultLanguage); 1984 if (-1 != nKey) 1985 { 1986 nFormat = nKey; 1987 bFormatOK = sal_True; 1988 } 1989 break; 1990 } 1991 case XML_TOK_TEXTFIELD_NAME: 1992 { 1993 if (!bValid) 1994 { 1995 SetServiceName(OUString::createFromAscii( sAPI_docinfo_custom ) ); 1996 aName = sAttrValue; 1997 bValid = sal_True; 1998 } 1999 break; 2000 } 2001 2002 default: 2003 XMLSimpleDocInfoImportContext::ProcessAttribute(nAttrToken, 2004 sAttrValue); 2005 break; 2006 } 2007 } 2008 2009 void XMLUserDocInfoImportContext::PrepareField( 2010 const ::com::sun::star::uno::Reference< 2011 ::com::sun::star::beans::XPropertySet> & xPropertySet) 2012 { 2013 uno::Any aAny; 2014 if ( aName.getLength() ) 2015 { 2016 aAny <<= aName; 2017 xPropertySet->setPropertyValue(sPropertyName, aAny); 2018 } 2019 Reference<XPropertySetInfo> xPropertySetInfo( 2020 xPropertySet->getPropertySetInfo()); 2021 if (bFormatOK && 2022 xPropertySetInfo->hasPropertyByName(sPropertyNumberFormat)) 2023 { 2024 aAny <<= nFormat; 2025 xPropertySet->setPropertyValue(sPropertyNumberFormat, aAny); 2026 2027 if( xPropertySetInfo->hasPropertyByName( sPropertyIsFixedLanguage ) ) 2028 { 2029 sal_Bool bIsFixedLanguage = ! bIsDefaultLanguage; 2030 aAny.setValue( &bIsFixedLanguage, ::getBooleanCppuType() ); 2031 xPropertySet->setPropertyValue( sPropertyIsFixedLanguage, aAny ); 2032 } 2033 } 2034 2035 // call superclass to handle "fixed" 2036 XMLSimpleDocInfoImportContext::PrepareField(xPropertySet); 2037 } 2038 2039 2040 // 2041 // import hidden paragraph fields 2042 // 2043 2044 TYPEINIT1( XMLHiddenParagraphImportContext, XMLTextFieldImportContext ); 2045 2046 XMLHiddenParagraphImportContext::XMLHiddenParagraphImportContext( 2047 SvXMLImport& rImport, XMLTextImportHelper& rHlp, 2048 sal_uInt16 nPrfx, const OUString& sLocalName) : 2049 XMLTextFieldImportContext(rImport, rHlp, sAPI_hidden_paragraph, 2050 nPrfx, sLocalName), 2051 sPropertyCondition(RTL_CONSTASCII_USTRINGPARAM(sAPI_condition)), 2052 sPropertyIsHidden(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_hidden)), 2053 sCondition(), 2054 bIsHidden(sal_False) 2055 { 2056 } 2057 2058 void XMLHiddenParagraphImportContext::ProcessAttribute( 2059 sal_uInt16 nAttrToken, 2060 const OUString& sAttrValue ) 2061 { 2062 if (XML_TOK_TEXTFIELD_CONDITION == nAttrToken) 2063 { 2064 OUString sTmp; 2065 sal_uInt16 nPrefix = GetImport().GetNamespaceMap()._GetKeyByAttrName( 2066 sAttrValue, &sTmp, sal_False ); 2067 if( XML_NAMESPACE_OOOW == nPrefix ) 2068 { 2069 sCondition = sTmp; 2070 bValid = sal_True; 2071 } 2072 else 2073 sCondition = sAttrValue; 2074 } 2075 else if (XML_TOK_TEXTFIELD_IS_HIDDEN == nAttrToken) 2076 { 2077 sal_Bool bTmp; 2078 if (SvXMLUnitConverter::convertBool(bTmp, sAttrValue)) 2079 { 2080 bIsHidden = bTmp; 2081 } 2082 } 2083 } 2084 2085 void XMLHiddenParagraphImportContext::PrepareField( 2086 const Reference<XPropertySet> & xPropertySet) 2087 { 2088 Any aAny; 2089 aAny <<= sCondition; 2090 xPropertySet->setPropertyValue(sPropertyCondition, aAny); 2091 2092 aAny.setValue( &bIsHidden, ::getBooleanCppuType() ); 2093 xPropertySet->setPropertyValue(sPropertyIsHidden, aAny); 2094 } 2095 2096 2097 2098 // 2099 // import conditional text (<text:conditional-text>) 2100 // 2101 2102 TYPEINIT1( XMLConditionalTextImportContext, XMLTextFieldImportContext ); 2103 2104 XMLConditionalTextImportContext::XMLConditionalTextImportContext( 2105 SvXMLImport& rImport, XMLTextImportHelper& rHlp, 2106 sal_uInt16 nPrfx, const OUString& sLocalName) : 2107 XMLTextFieldImportContext(rImport, rHlp, sAPI_conditional_text, 2108 nPrfx, sLocalName), 2109 sPropertyCondition(RTL_CONSTASCII_USTRINGPARAM(sAPI_condition)), 2110 sPropertyTrueContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_true_content)), 2111 sPropertyFalseContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_false_content)), 2112 sPropertyIsConditionTrue(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_condition_true)), 2113 sPropertyCurrentPresentation(RTL_CONSTASCII_USTRINGPARAM(sAPI_current_presentation)), 2114 bConditionOK(sal_False), 2115 bTrueOK(sal_False), 2116 bFalseOK(sal_False), 2117 bCurrentValue(sal_False) 2118 { 2119 } 2120 2121 void XMLConditionalTextImportContext::ProcessAttribute( 2122 sal_uInt16 nAttrToken, 2123 const OUString& sAttrValue ) 2124 { 2125 switch (nAttrToken) 2126 { 2127 case XML_TOK_TEXTFIELD_CONDITION: 2128 { 2129 OUString sTmp; 2130 sal_uInt16 nPrefix = GetImport().GetNamespaceMap(). 2131 _GetKeyByAttrName( sAttrValue, &sTmp, sal_False ); 2132 if( XML_NAMESPACE_OOOW == nPrefix ) 2133 { 2134 sCondition = sTmp; 2135 bConditionOK = sal_True; 2136 } 2137 else 2138 sCondition = sAttrValue; 2139 } 2140 break; 2141 case XML_TOK_TEXTFIELD_STRING_VALUE_IF_FALSE: 2142 sFalseContent = sAttrValue; 2143 bFalseOK = sal_True; 2144 break; 2145 case XML_TOK_TEXTFIELD_STRING_VALUE_IF_TRUE: 2146 sTrueContent = sAttrValue; 2147 bTrueOK = sal_True; 2148 break; 2149 case XML_TOK_TEXTFIELD_CURRENT_VALUE: 2150 { 2151 sal_Bool bTmp; 2152 if (SvXMLUnitConverter::convertBool(bTmp, sAttrValue)) 2153 { 2154 bCurrentValue = bTmp; 2155 } 2156 break; 2157 } 2158 } 2159 2160 bValid = bConditionOK && bFalseOK && bTrueOK; 2161 } 2162 2163 void XMLConditionalTextImportContext::PrepareField( 2164 const Reference<XPropertySet> & xPropertySet) 2165 { 2166 Any aAny; 2167 2168 aAny <<= sCondition; 2169 xPropertySet->setPropertyValue(sPropertyCondition, aAny); 2170 2171 aAny <<= sFalseContent; 2172 xPropertySet->setPropertyValue(sPropertyFalseContent, aAny); 2173 2174 aAny <<= sTrueContent; 2175 xPropertySet->setPropertyValue(sPropertyTrueContent, aAny); 2176 2177 aAny.setValue( &bCurrentValue, ::getBooleanCppuType() ); 2178 xPropertySet->setPropertyValue(sPropertyIsConditionTrue, aAny); 2179 2180 aAny <<= GetContent(); 2181 xPropertySet->setPropertyValue(sPropertyCurrentPresentation, aAny); 2182 } 2183 2184 2185 2186 // 2187 // hidden text 2188 // 2189 2190 TYPEINIT1( XMLHiddenTextImportContext, XMLTextFieldImportContext); 2191 2192 XMLHiddenTextImportContext::XMLHiddenTextImportContext( 2193 SvXMLImport& rImport, XMLTextImportHelper& rHlp, 2194 sal_uInt16 nPrfx, const OUString& sLocalName) : 2195 XMLTextFieldImportContext(rImport, rHlp, sAPI_hidden_text, 2196 nPrfx, sLocalName), 2197 sPropertyCondition(RTL_CONSTASCII_USTRINGPARAM(sAPI_condition)), 2198 sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content)), 2199 sPropertyIsHidden(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_hidden)), 2200 bConditionOK(sal_False), 2201 bStringOK(sal_False), 2202 bIsHidden(sal_False) 2203 { 2204 } 2205 2206 void XMLHiddenTextImportContext::ProcessAttribute( 2207 sal_uInt16 nAttrToken, 2208 const OUString& sAttrValue ) 2209 { 2210 switch (nAttrToken) 2211 { 2212 case XML_TOK_TEXTFIELD_CONDITION: 2213 { 2214 OUString sTmp; 2215 sal_uInt16 nPrefix = GetImport().GetNamespaceMap(). 2216 _GetKeyByAttrName( sAttrValue, &sTmp, sal_False ); 2217 if( XML_NAMESPACE_OOOW == nPrefix ) 2218 { 2219 sCondition = sTmp; 2220 bConditionOK = sal_True; 2221 } 2222 else 2223 sCondition = sAttrValue; 2224 } 2225 break; 2226 case XML_TOK_TEXTFIELD_STRING_VALUE: 2227 sString = sAttrValue; 2228 bStringOK = sal_True; 2229 break; 2230 case XML_TOK_TEXTFIELD_IS_HIDDEN: 2231 { 2232 sal_Bool bTmp; 2233 if (SvXMLUnitConverter::convertBool(bTmp, sAttrValue)) 2234 { 2235 bIsHidden = bTmp; 2236 } 2237 break; 2238 } 2239 } 2240 2241 bValid = bConditionOK && bStringOK; 2242 } 2243 2244 void XMLHiddenTextImportContext::PrepareField( 2245 const Reference<XPropertySet> & xPropertySet) 2246 { 2247 Any aAny; 2248 2249 aAny <<= sCondition; 2250 xPropertySet->setPropertyValue(sPropertyCondition, aAny); 2251 2252 aAny <<= sString; 2253 xPropertySet->setPropertyValue(sPropertyContent, aAny); 2254 2255 aAny.setValue( &bIsHidden, ::getBooleanCppuType() ); 2256 xPropertySet->setPropertyValue(sPropertyIsHidden, aAny); 2257 } 2258 2259 2260 2261 // 2262 // file name fields 2263 // 2264 2265 TYPEINIT1( XMLFileNameImportContext, XMLTextFieldImportContext ); 2266 2267 static const SvXMLEnumMapEntry aFilenameDisplayMap[] = 2268 { 2269 { XML_PATH, FilenameDisplayFormat::PATH }, 2270 { XML_NAME, FilenameDisplayFormat::NAME }, 2271 { XML_NAME_AND_EXTENSION, FilenameDisplayFormat::NAME_AND_EXT }, 2272 { XML_FULL, FilenameDisplayFormat::FULL }, 2273 { XML_TOKEN_INVALID, 0 } 2274 }; 2275 2276 XMLFileNameImportContext::XMLFileNameImportContext( 2277 SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, 2278 const OUString& sLocalName) : 2279 XMLTextFieldImportContext(rImport, rHlp, sAPI_file_name, 2280 nPrfx, sLocalName), 2281 sPropertyFixed(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed)), 2282 sPropertyFileFormat(RTL_CONSTASCII_USTRINGPARAM(sAPI_file_format)), 2283 sPropertyCurrentPresentation( 2284 RTL_CONSTASCII_USTRINGPARAM(sAPI_current_presentation)), 2285 nFormat(FilenameDisplayFormat::FULL), 2286 bFixed(sal_False) 2287 { 2288 bValid = sal_True; 2289 } 2290 2291 void XMLFileNameImportContext::ProcessAttribute( 2292 sal_uInt16 nAttrToken, 2293 const ::rtl::OUString& sAttrValue ) 2294 { 2295 switch (nAttrToken) 2296 { 2297 case XML_TOK_TEXTFIELD_FIXED: 2298 { 2299 sal_Bool bTmp; 2300 if (SvXMLUnitConverter::convertBool(bTmp, sAttrValue)) 2301 { 2302 bFixed = bTmp; 2303 } 2304 break; 2305 } 2306 case XML_TOK_TEXTFIELD_DISPLAY: 2307 { 2308 sal_uInt16 nTmp; 2309 if (SvXMLUnitConverter::convertEnum(nTmp, sAttrValue, 2310 aFilenameDisplayMap)) 2311 { 2312 nFormat = (sal_uInt16)nTmp; 2313 } 2314 break; 2315 } 2316 default: 2317 ; // unkown attribute: ignore 2318 break; 2319 } 2320 } 2321 2322 void XMLFileNameImportContext::PrepareField( 2323 const Reference<XPropertySet> & xPropertySet) 2324 { 2325 Any aAny; 2326 2327 // properties are optional 2328 Reference<XPropertySetInfo> xPropertySetInfo( 2329 xPropertySet->getPropertySetInfo()); 2330 2331 if (xPropertySetInfo->hasPropertyByName(sPropertyFixed)) 2332 { 2333 aAny <<= bFixed; 2334 xPropertySet->setPropertyValue(sPropertyFixed, aAny); 2335 } 2336 2337 if (xPropertySetInfo->hasPropertyByName(sPropertyFileFormat)) 2338 { 2339 aAny <<= nFormat; 2340 xPropertySet->setPropertyValue(sPropertyFileFormat, aAny); 2341 } 2342 2343 if (xPropertySetInfo->hasPropertyByName(sPropertyCurrentPresentation)) 2344 { 2345 aAny <<= GetContent(); 2346 xPropertySet->setPropertyValue(sPropertyCurrentPresentation, aAny); 2347 } 2348 } 2349 2350 2351 // 2352 // template name field 2353 // 2354 2355 static const SvXMLEnumMapEntry aTemplateDisplayMap[] = 2356 { 2357 { XML_FULL, TemplateDisplayFormat::FULL }, 2358 { XML_PATH, TemplateDisplayFormat::PATH }, 2359 { XML_NAME, TemplateDisplayFormat::NAME }, 2360 { XML_NAME_AND_EXTENSION, TemplateDisplayFormat::NAME_AND_EXT }, 2361 { XML_AREA, TemplateDisplayFormat::AREA }, 2362 { XML_TITLE, TemplateDisplayFormat::TITLE }, 2363 { XML_TOKEN_INVALID, 0 } 2364 }; 2365 2366 TYPEINIT1( XMLTemplateNameImportContext, XMLTextFieldImportContext ); 2367 2368 XMLTemplateNameImportContext::XMLTemplateNameImportContext( 2369 SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, 2370 const OUString& sLocalName) : 2371 XMLTextFieldImportContext(rImport, rHlp, sAPI_template_name, 2372 nPrfx, sLocalName), 2373 sPropertyFileFormat(RTL_CONSTASCII_USTRINGPARAM(sAPI_file_format)), 2374 nFormat(TemplateDisplayFormat::FULL) 2375 { 2376 bValid = sal_True; 2377 } 2378 2379 void XMLTemplateNameImportContext::ProcessAttribute( 2380 sal_uInt16 nAttrToken, 2381 const OUString& sAttrValue ) 2382 { 2383 switch (nAttrToken) 2384 { 2385 case XML_TOK_TEXTFIELD_DISPLAY: 2386 { 2387 sal_uInt16 nTmp; 2388 if (SvXMLUnitConverter::convertEnum(nTmp, sAttrValue, 2389 aTemplateDisplayMap)) 2390 { 2391 nFormat = (sal_uInt16)nTmp; 2392 } 2393 break; 2394 } 2395 default: 2396 ; // unknown attribute: ignore 2397 break; 2398 } 2399 } 2400 2401 void XMLTemplateNameImportContext::PrepareField( 2402 const Reference<XPropertySet> & xPropertySet) 2403 { 2404 Any aAny; 2405 2406 aAny <<= nFormat; 2407 xPropertySet->setPropertyValue(sPropertyFileFormat, aAny); 2408 } 2409 2410 2411 // 2412 // import chapter fields 2413 // 2414 2415 TYPEINIT1( XMLChapterImportContext, XMLTextFieldImportContext ); 2416 2417 static const SvXMLEnumMapEntry aChapterDisplayMap[] = 2418 { 2419 { XML_NAME, ChapterFormat::NAME }, 2420 { XML_NUMBER, ChapterFormat::NUMBER }, 2421 { XML_NUMBER_AND_NAME, ChapterFormat::NAME_NUMBER }, 2422 { XML_PLAIN_NUMBER_AND_NAME, ChapterFormat::NO_PREFIX_SUFFIX }, 2423 { XML_PLAIN_NUMBER, ChapterFormat::DIGIT }, 2424 { XML_TOKEN_INVALID, 0 } 2425 }; 2426 2427 XMLChapterImportContext::XMLChapterImportContext( 2428 SvXMLImport& rImport, XMLTextImportHelper& rHlp, 2429 sal_uInt16 nPrfx, const OUString& sLocalName) : 2430 XMLTextFieldImportContext(rImport, rHlp, sAPI_chapter, 2431 nPrfx, sLocalName), 2432 sPropertyChapterFormat( 2433 RTL_CONSTASCII_USTRINGPARAM(sAPI_chapter_format)), 2434 sPropertyLevel(RTL_CONSTASCII_USTRINGPARAM(sAPI_level)), 2435 nFormat(ChapterFormat::NAME_NUMBER), 2436 nLevel(0) 2437 { 2438 bValid = sal_True; 2439 } 2440 2441 void XMLChapterImportContext::ProcessAttribute( 2442 sal_uInt16 nAttrToken, 2443 const OUString& sAttrValue ) 2444 { 2445 switch (nAttrToken) 2446 { 2447 case XML_TOK_TEXTFIELD_DISPLAY: 2448 { 2449 sal_uInt16 nTmp; 2450 if (SvXMLUnitConverter::convertEnum(nTmp, sAttrValue, 2451 aChapterDisplayMap)) 2452 { 2453 nFormat = (sal_Int16)nTmp; 2454 } 2455 break; 2456 } 2457 case XML_TOK_TEXTFIELD_OUTLINE_LEVEL: 2458 { 2459 sal_Int32 nTmp; 2460 if (SvXMLUnitConverter::convertNumber( 2461 nTmp, sAttrValue, 1, 2462 GetImport().GetTextImport()->GetChapterNumbering()->getCount() 2463 )) 2464 { 2465 // API numbers 0..9, we number 1..10 2466 nLevel = (sal_Int8)nTmp; 2467 nLevel--; 2468 } 2469 break; 2470 } 2471 default: 2472 ; // unknown attribute: ignore 2473 break; 2474 } 2475 } 2476 2477 void XMLChapterImportContext::PrepareField( 2478 const Reference<XPropertySet> & xPropertySet) 2479 { 2480 Any aAny; 2481 2482 aAny <<= nFormat; 2483 xPropertySet->setPropertyValue(sPropertyChapterFormat, aAny); 2484 2485 aAny <<= nLevel; 2486 xPropertySet->setPropertyValue(sPropertyLevel, aAny); 2487 } 2488 2489 2490 // 2491 // counting fields 2492 // 2493 2494 TYPEINIT1( XMLCountFieldImportContext, XMLTextFieldImportContext ); 2495 2496 XMLCountFieldImportContext::XMLCountFieldImportContext( 2497 SvXMLImport& rImport, XMLTextImportHelper& rHlp, 2498 sal_uInt16 nPrfx, const OUString& sLocalName, sal_uInt16 nToken) : 2499 XMLTextFieldImportContext(rImport, rHlp, MapTokenToServiceName(nToken), 2500 nPrfx, sLocalName), 2501 sPropertyNumberingType( 2502 RTL_CONSTASCII_USTRINGPARAM(sAPI_numbering_type)), 2503 sNumberFormat(), 2504 sLetterSync(), 2505 bNumberFormatOK(sal_False) 2506 { 2507 bValid = sal_True; 2508 } 2509 2510 void XMLCountFieldImportContext::ProcessAttribute( 2511 sal_uInt16 nAttrToken, 2512 const OUString& sAttrValue ) 2513 { 2514 switch (nAttrToken) 2515 { 2516 case XML_TOK_TEXTFIELD_NUM_FORMAT: 2517 sNumberFormat = sAttrValue; 2518 bNumberFormatOK = sal_True; 2519 break; 2520 case XML_TOK_TEXTFIELD_NUM_LETTER_SYNC: 2521 sLetterSync = sAttrValue; 2522 break; 2523 } 2524 } 2525 2526 void XMLCountFieldImportContext::PrepareField( 2527 const Reference<XPropertySet> & xPropertySet) 2528 { 2529 Any aAny; 2530 2531 // properties optional 2532 // (only page count, but do for all to save common implementation) 2533 2534 if (xPropertySet->getPropertySetInfo()-> 2535 hasPropertyByName(sPropertyNumberingType)) 2536 { 2537 sal_Int16 nNumType; 2538 if( bNumberFormatOK ) 2539 { 2540 nNumType= style::NumberingType::ARABIC; 2541 GetImport().GetMM100UnitConverter().convertNumFormat( nNumType, 2542 sNumberFormat, 2543 sLetterSync ); 2544 } 2545 else 2546 nNumType = style::NumberingType::PAGE_DESCRIPTOR; 2547 aAny <<= nNumType; 2548 xPropertySet->setPropertyValue(sPropertyNumberingType, aAny); 2549 } 2550 } 2551 2552 const sal_Char* XMLCountFieldImportContext::MapTokenToServiceName( 2553 sal_uInt16 nToken) 2554 { 2555 const sal_Char* pServiceName = NULL; 2556 2557 switch (nToken) 2558 { 2559 case XML_TOK_TEXT_WORD_COUNT: 2560 pServiceName = sAPI_word_count; 2561 break; 2562 case XML_TOK_TEXT_PARAGRAPH_COUNT: 2563 pServiceName = sAPI_paragraph_count; 2564 break; 2565 case XML_TOK_TEXT_TABLE_COUNT: 2566 pServiceName = sAPI_table_count; 2567 break; 2568 case XML_TOK_TEXT_CHARACTER_COUNT: 2569 pServiceName = sAPI_character_count; 2570 break; 2571 case XML_TOK_TEXT_IMAGE_COUNT: 2572 pServiceName = sAPI_graphic_object_count; 2573 break; 2574 case XML_TOK_TEXT_OBJECT_COUNT: 2575 pServiceName = sAPI_embedded_object_count; 2576 break; 2577 case XML_TOK_TEXT_PAGE_COUNT: 2578 pServiceName = sAPI_page_count; 2579 break; 2580 default: 2581 pServiceName = NULL; 2582 DBG_ERROR("unknown count field!"); 2583 break; 2584 } 2585 2586 return pServiceName; 2587 } 2588 2589 2590 2591 // 2592 // page variable import 2593 // 2594 2595 TYPEINIT1( XMLPageVarGetFieldImportContext, XMLTextFieldImportContext ); 2596 2597 XMLPageVarGetFieldImportContext::XMLPageVarGetFieldImportContext( 2598 SvXMLImport& rImport, XMLTextImportHelper& rHlp, 2599 sal_uInt16 nPrfx, const OUString& sLocalName) : 2600 XMLTextFieldImportContext(rImport, rHlp, sAPI_reference_page_get, 2601 nPrfx, sLocalName), 2602 sPropertyNumberingType( 2603 RTL_CONSTASCII_USTRINGPARAM(sAPI_numbering_type)), 2604 sNumberFormat(), 2605 sLetterSync(), 2606 bNumberFormatOK(sal_False) 2607 { 2608 bValid = sal_True; 2609 } 2610 2611 void XMLPageVarGetFieldImportContext::ProcessAttribute( 2612 sal_uInt16 nAttrToken, 2613 const OUString& sAttrValue ) 2614 { 2615 switch (nAttrToken) 2616 { 2617 case XML_TOK_TEXTFIELD_NUM_FORMAT: 2618 sNumberFormat = sAttrValue; 2619 bNumberFormatOK = sal_True; 2620 break; 2621 case XML_TOK_TEXTFIELD_NUM_LETTER_SYNC: 2622 sLetterSync = sAttrValue; 2623 break; 2624 } 2625 } 2626 2627 void XMLPageVarGetFieldImportContext::PrepareField( 2628 const Reference<XPropertySet> & xPropertySet) 2629 { 2630 Any aAny; 2631 2632 sal_Int16 nNumType; 2633 if( bNumberFormatOK ) 2634 { 2635 nNumType= style::NumberingType::ARABIC; 2636 GetImport().GetMM100UnitConverter().convertNumFormat( nNumType, 2637 sNumberFormat, 2638 sLetterSync ); 2639 } 2640 else 2641 nNumType = style::NumberingType::PAGE_DESCRIPTOR; 2642 aAny <<= nNumType; 2643 xPropertySet->setPropertyValue(sPropertyNumberingType, aAny); 2644 2645 // display old content (#96657#) 2646 aAny <<= GetContent(); 2647 xPropertySet->setPropertyValue( 2648 OUString(RTL_CONSTASCII_USTRINGPARAM(sAPI_current_presentation)), 2649 aAny ); 2650 } 2651 2652 2653 2654 // 2655 // page variable set fields 2656 // 2657 2658 TYPEINIT1(XMLPageVarSetFieldImportContext, XMLTextFieldImportContext); 2659 2660 XMLPageVarSetFieldImportContext::XMLPageVarSetFieldImportContext( 2661 SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, 2662 const OUString& sLocalName) : 2663 XMLTextFieldImportContext(rImport, rHlp, sAPI_reference_page_set, 2664 nPrfx, sLocalName), 2665 sPropertyOn(RTL_CONSTASCII_USTRINGPARAM(sAPI_on)), 2666 sPropertyOffset(RTL_CONSTASCII_USTRINGPARAM(sAPI_offset)), 2667 nAdjust(0), 2668 bActive(sal_True) 2669 { 2670 bValid = sal_True; 2671 } 2672 2673 void XMLPageVarSetFieldImportContext::ProcessAttribute( 2674 sal_uInt16 nAttrToken, 2675 const ::rtl::OUString& sAttrValue ) 2676 { 2677 switch (nAttrToken) 2678 { 2679 case XML_TOK_TEXTFIELD_ACTIVE: 2680 { 2681 sal_Bool bTmp; 2682 if (SvXMLUnitConverter::convertBool(bTmp, sAttrValue)) 2683 { 2684 bActive = bTmp; 2685 } 2686 } 2687 case XML_TOK_TEXTFIELD_PAGE_ADJUST: 2688 { 2689 sal_Int32 nTmp; 2690 if (SvXMLUnitConverter::convertNumber(nTmp, sAttrValue)) 2691 { 2692 nAdjust = (sal_Int16)nTmp; 2693 } 2694 } 2695 } 2696 } 2697 2698 void XMLPageVarSetFieldImportContext::PrepareField( 2699 const Reference<XPropertySet> & xPropertySet) 2700 { 2701 Any aAny; 2702 2703 aAny.setValue(&bActive, ::getBooleanCppuType()); 2704 xPropertySet->setPropertyValue(sPropertyOn, aAny); 2705 2706 aAny <<= nAdjust; 2707 xPropertySet->setPropertyValue(sPropertyOffset, aAny); 2708 } 2709 2710 2711 2712 // 2713 // macro fields 2714 // 2715 2716 TYPEINIT1( XMLMacroFieldImportContext, XMLTextFieldImportContext ); 2717 2718 XMLMacroFieldImportContext::XMLMacroFieldImportContext( 2719 SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, 2720 const OUString& sLocalName) : 2721 XMLTextFieldImportContext(rImport, rHlp, sAPI_macro, 2722 nPrfx, sLocalName), 2723 sPropertyHint(RTL_CONSTASCII_USTRINGPARAM(sAPI_hint)), 2724 sPropertyMacroName(RTL_CONSTASCII_USTRINGPARAM("MacroName")), 2725 sPropertyScriptURL(RTL_CONSTASCII_USTRINGPARAM("ScriptURL")), 2726 bDescriptionOK(sal_False) 2727 { 2728 } 2729 2730 SvXMLImportContext* XMLMacroFieldImportContext::CreateChildContext( 2731 sal_uInt16 nPrefix, 2732 const OUString& rLocalName, 2733 const Reference<XAttributeList> & xAttrList ) 2734 { 2735 SvXMLImportContext* pContext = NULL; 2736 2737 if ( (nPrefix == XML_NAMESPACE_OFFICE) && 2738 IsXMLToken( rLocalName, XML_EVENT_LISTENERS ) ) 2739 { 2740 // create events context and remember it! 2741 pContext = new XMLEventsImportContext( 2742 GetImport(), nPrefix, rLocalName ); 2743 xEventContext = pContext; 2744 bValid = sal_True; 2745 } 2746 else 2747 pContext = SvXMLImportContext::CreateChildContext( 2748 nPrefix, rLocalName, xAttrList); 2749 2750 return pContext; 2751 } 2752 2753 2754 void XMLMacroFieldImportContext::ProcessAttribute( 2755 sal_uInt16 nAttrToken, 2756 const OUString& sAttrValue ) 2757 { 2758 switch (nAttrToken) 2759 { 2760 case XML_TOK_TEXTFIELD_DESCRIPTION: 2761 sDescription = sAttrValue; 2762 bDescriptionOK = sal_True; 2763 break; 2764 case XML_TOK_TEXTFIELD_NAME: 2765 sMacro = sAttrValue; 2766 bValid = sal_True; 2767 break; 2768 } 2769 } 2770 2771 void XMLMacroFieldImportContext::PrepareField( 2772 const Reference<XPropertySet> & xPropertySet) 2773 { 2774 Any aAny; 2775 2776 OUString sOnClick(RTL_CONSTASCII_USTRINGPARAM("OnClick")); 2777 OUString sPropertyMacroLibrary(RTL_CONSTASCII_USTRINGPARAM("MacroLibrary")); 2778 2779 aAny <<= (bDescriptionOK ? sDescription : GetContent()); 2780 xPropertySet->setPropertyValue(sPropertyHint, aAny); 2781 2782 // if we have an events child element, we'll look for the OnClick 2783 // event if not, it may be an old (pre-638i) document. Then, we'll 2784 // have to look at the name attribute. 2785 OUString sMacroName; 2786 OUString sLibraryName; 2787 OUString sScriptURL; 2788 2789 if ( xEventContext.Is() ) 2790 { 2791 // get event sequence 2792 XMLEventsImportContext* pEvents = 2793 (XMLEventsImportContext*)&xEventContext; 2794 Sequence<PropertyValue> aValues; 2795 pEvents->GetEventSequence( sOnClick, aValues ); 2796 2797 sal_Int32 nLength = aValues.getLength(); 2798 for( sal_Int32 i = 0; i < nLength; i++ ) 2799 { 2800 if ( aValues[i].Name.equalsAsciiL( "ScriptType", 2801 sizeof("ScriptType")-1 ) ) 2802 { 2803 // ignore ScriptType 2804 } 2805 else if ( aValues[i].Name.equalsAsciiL( "Library", 2806 sizeof("Library")-1 ) ) 2807 { 2808 aValues[i].Value >>= sLibraryName; 2809 } 2810 else if ( aValues[i].Name.equalsAsciiL( "MacroName", 2811 sizeof("MacroName")-1 ) ) 2812 { 2813 aValues[i].Value >>= sMacroName; 2814 } 2815 if ( aValues[i].Name.equalsAsciiL( "Script", 2816 sizeof("Script")-1 ) ) 2817 { 2818 aValues[i].Value >>= sScriptURL; 2819 } 2820 } 2821 } 2822 else 2823 { 2824 // disassemble old-style macro-name: Everything before the 2825 // third-last dot is the library 2826 sal_Int32 nPos = sMacro.getLength() + 1; // the loop starts with nPos-- 2827 const sal_Unicode* pBuf = sMacro.getStr(); 2828 for( sal_Int32 i = 0; (i < 3) && (nPos > 0); i++ ) 2829 { 2830 nPos--; 2831 while ( (pBuf[nPos] != '.') && (nPos > 0) ) 2832 nPos--; 2833 } 2834 2835 if (nPos > 0) 2836 { 2837 sLibraryName = sMacro.copy(0, nPos); 2838 sMacroName = sMacro.copy(nPos+1); 2839 } 2840 else 2841 sMacroName = sMacro; 2842 } 2843 2844 aAny <<= sScriptURL; 2845 xPropertySet->setPropertyValue(sPropertyScriptURL, aAny); 2846 2847 aAny <<= sMacroName; 2848 xPropertySet->setPropertyValue(sPropertyMacroName, aAny); 2849 2850 aAny <<= sLibraryName; 2851 xPropertySet->setPropertyValue(sPropertyMacroLibrary, aAny); 2852 } 2853 2854 2855 2856 // 2857 // reference field import 2858 // 2859 2860 TYPEINIT1( XMLReferenceFieldImportContext, XMLTextFieldImportContext ); 2861 2862 XMLReferenceFieldImportContext::XMLReferenceFieldImportContext( 2863 SvXMLImport& rImport, XMLTextImportHelper& rHlp, 2864 sal_uInt16 nToken, sal_uInt16 nPrfx, const OUString& sLocalName) 2865 : XMLTextFieldImportContext(rImport, rHlp, sAPI_get_reference, nPrfx, sLocalName) 2866 , sPropertyReferenceFieldPart(RTL_CONSTASCII_USTRINGPARAM(sAPI_reference_field_part)) 2867 , sPropertyReferenceFieldSource(RTL_CONSTASCII_USTRINGPARAM(sAPI_reference_field_source)) 2868 , sPropertySourceName(RTL_CONSTASCII_USTRINGPARAM(sAPI_source_name)) 2869 , sPropertyCurrentPresentation(RTL_CONSTASCII_USTRINGPARAM(sAPI_current_presentation)) 2870 , nElementToken(nToken) 2871 , nType(ReferenceFieldPart::PAGE_DESC) 2872 , bNameOK(sal_False) 2873 , bTypeOK(sal_False) 2874 , bSeqNumberOK(sal_False) 2875 { 2876 } 2877 2878 static SvXMLEnumMapEntry __READONLY_DATA lcl_aReferenceTypeTokenMap[] = 2879 { 2880 { XML_PAGE, ReferenceFieldPart::PAGE}, 2881 { XML_CHAPTER, ReferenceFieldPart::CHAPTER }, 2882 { XML_TEXT, ReferenceFieldPart::TEXT }, 2883 { XML_DIRECTION, ReferenceFieldPart::UP_DOWN }, 2884 { XML_CATEGORY_AND_VALUE, ReferenceFieldPart::CATEGORY_AND_NUMBER }, 2885 { XML_CAPTION, ReferenceFieldPart::ONLY_CAPTION }, 2886 { XML_VALUE, ReferenceFieldPart::ONLY_SEQUENCE_NUMBER }, 2887 // --> OD 2007-09-14 #i81002# 2888 { XML_NUMBER, ReferenceFieldPart::NUMBER }, 2889 { XML_NUMBER_NO_SUPERIOR, ReferenceFieldPart::NUMBER_NO_CONTEXT }, 2890 { XML_NUMBER_ALL_SUPERIOR, ReferenceFieldPart::NUMBER_FULL_CONTEXT }, 2891 // <-- 2892 { XML_TOKEN_INVALID, 0 } 2893 }; 2894 2895 void XMLReferenceFieldImportContext::StartElement( 2896 const Reference<XAttributeList> & xAttrList) 2897 { 2898 bTypeOK = sal_True; 2899 switch (nElementToken) 2900 { 2901 case XML_TOK_TEXT_REFERENCE_REF: 2902 nSource = ReferenceFieldSource::REFERENCE_MARK; 2903 break; 2904 case XML_TOK_TEXT_BOOKMARK_REF: 2905 nSource = ReferenceFieldSource::BOOKMARK; 2906 break; 2907 case XML_TOK_TEXT_NOTE_REF: 2908 nSource = ReferenceFieldSource::FOOTNOTE; 2909 break; 2910 case XML_TOK_TEXT_SEQUENCE_REF: 2911 nSource = ReferenceFieldSource::SEQUENCE_FIELD; 2912 break; 2913 default: 2914 bTypeOK = sal_False; 2915 DBG_ERROR("unknown reference field"); 2916 break; 2917 } 2918 2919 XMLTextFieldImportContext::StartElement(xAttrList); 2920 } 2921 2922 2923 void XMLReferenceFieldImportContext::ProcessAttribute( 2924 sal_uInt16 nAttrToken, 2925 const OUString& sAttrValue ) 2926 { 2927 switch (nAttrToken) 2928 { 2929 case XML_TOK_TEXTFIELD_NOTE_CLASS: 2930 if( IsXMLToken( sAttrValue, XML_ENDNOTE ) ) 2931 nSource = ReferenceFieldSource::ENDNOTE; 2932 break; 2933 case XML_TOK_TEXTFIELD_REF_NAME: 2934 sName = sAttrValue; 2935 bNameOK = sal_True; 2936 break; 2937 case XML_TOK_TEXTFIELD_REFERENCE_FORMAT: 2938 { 2939 sal_uInt16 nToken; 2940 if (SvXMLUnitConverter::convertEnum(nToken, sAttrValue, 2941 lcl_aReferenceTypeTokenMap)) 2942 { 2943 nType = nToken; 2944 } 2945 2946 // check for sequence-only-attributes 2947 if ( (XML_TOK_TEXT_SEQUENCE_REF != nElementToken) && 2948 ( (nType == ReferenceFieldPart::CATEGORY_AND_NUMBER) || 2949 (nType == ReferenceFieldPart::ONLY_CAPTION) || 2950 (nType == ReferenceFieldPart::ONLY_SEQUENCE_NUMBER) ) ) 2951 { 2952 nType = ReferenceFieldPart::PAGE_DESC; 2953 } 2954 2955 break; 2956 } 2957 } 2958 2959 // bValid: we need proper element type and name 2960 bValid = bTypeOK && bNameOK; 2961 } 2962 2963 void XMLReferenceFieldImportContext::PrepareField( 2964 const Reference<XPropertySet> & xPropertySet) 2965 { 2966 Any aAny; 2967 2968 aAny <<= nType; 2969 xPropertySet->setPropertyValue(sPropertyReferenceFieldPart, aAny); 2970 2971 aAny <<= nSource; 2972 xPropertySet->setPropertyValue(sPropertyReferenceFieldSource, aAny); 2973 2974 switch (nElementToken) 2975 { 2976 case XML_TOK_TEXT_REFERENCE_REF: 2977 case XML_TOK_TEXT_BOOKMARK_REF: 2978 aAny <<= sName; 2979 xPropertySet->setPropertyValue(sPropertySourceName, aAny); 2980 break; 2981 2982 case XML_TOK_TEXT_NOTE_REF: 2983 GetImportHelper().ProcessFootnoteReference(sName, xPropertySet); 2984 break; 2985 2986 case XML_TOK_TEXT_SEQUENCE_REF: 2987 GetImportHelper().ProcessSequenceReference(sName, xPropertySet); 2988 break; 2989 } 2990 2991 aAny <<= GetContent(); 2992 xPropertySet->setPropertyValue(sPropertyCurrentPresentation, aAny); 2993 } 2994 2995 2996 2997 // 2998 // field declarations container 2999 // 3000 3001 enum DdeFieldDeclAttrs 3002 { 3003 XML_TOK_DDEFIELD_NAME, 3004 XML_TOK_DDEFIELD_APPLICATION, 3005 XML_TOK_DDEFIELD_TOPIC, 3006 XML_TOK_DDEFIELD_ITEM, 3007 XML_TOK_DDEFIELD_UPDATE 3008 }; 3009 3010 static __FAR_DATA SvXMLTokenMapEntry aDdeDeclAttrTokenMap[] = 3011 { 3012 { XML_NAMESPACE_OFFICE, XML_NAME, XML_TOK_DDEFIELD_NAME }, 3013 { XML_NAMESPACE_OFFICE, XML_DDE_APPLICATION, XML_TOK_DDEFIELD_APPLICATION }, 3014 { XML_NAMESPACE_OFFICE, XML_DDE_TOPIC, XML_TOK_DDEFIELD_TOPIC }, 3015 { XML_NAMESPACE_OFFICE, XML_DDE_ITEM, XML_TOK_DDEFIELD_ITEM }, 3016 { XML_NAMESPACE_OFFICE, XML_AUTOMATIC_UPDATE, XML_TOK_DDEFIELD_UPDATE }, 3017 XML_TOKEN_MAP_END 3018 }; 3019 3020 TYPEINIT1( XMLDdeFieldDeclsImportContext, SvXMLImportContext ); 3021 3022 XMLDdeFieldDeclsImportContext::XMLDdeFieldDeclsImportContext( 3023 SvXMLImport& rImport, sal_uInt16 nPrfx, const OUString& sLocalName) : 3024 SvXMLImportContext(rImport, nPrfx, sLocalName), 3025 aTokenMap(aDdeDeclAttrTokenMap) 3026 { 3027 } 3028 3029 SvXMLImportContext * XMLDdeFieldDeclsImportContext::CreateChildContext( 3030 sal_uInt16 nPrefix, 3031 const OUString& rLocalName, 3032 const Reference<XAttributeList> & xAttrList ) 3033 { 3034 if ( (XML_NAMESPACE_TEXT == nPrefix) && 3035 (IsXMLToken(rLocalName, XML_DDE_CONNECTION_DECL)) ) 3036 { 3037 return new XMLDdeFieldDeclImportContext(GetImport(), nPrefix, 3038 rLocalName, aTokenMap); 3039 } 3040 else 3041 { 3042 return SvXMLImportContext::CreateChildContext(nPrefix, 3043 rLocalName, 3044 xAttrList); 3045 } 3046 } 3047 3048 3049 3050 // 3051 // import dde field declaration 3052 // 3053 3054 TYPEINIT1( XMLDdeFieldDeclImportContext, SvXMLImportContext ); 3055 3056 XMLDdeFieldDeclImportContext::XMLDdeFieldDeclImportContext( 3057 SvXMLImport& rImport, sal_uInt16 nPrfx, 3058 const OUString& sLocalName, const SvXMLTokenMap& rMap) 3059 : SvXMLImportContext(rImport, nPrfx, sLocalName) 3060 , sPropertyIsAutomaticUpdate(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_automatic_update)) 3061 , sPropertyName(RTL_CONSTASCII_USTRINGPARAM(sAPI_name)) 3062 , sPropertyDDECommandType(RTL_CONSTASCII_USTRINGPARAM(sAPI_dde_command_type)) 3063 , sPropertyDDECommandFile(RTL_CONSTASCII_USTRINGPARAM(sAPI_dde_command_file)) 3064 , sPropertyDDECommandElement(RTL_CONSTASCII_USTRINGPARAM(sAPI_dde_command_element)) 3065 , rTokenMap(rMap) 3066 { 3067 DBG_ASSERT(XML_NAMESPACE_TEXT == nPrfx, "wrong prefix"); 3068 DBG_ASSERT(IsXMLToken(sLocalName, XML_DDE_CONNECTION_DECL), "wrong name"); 3069 } 3070 3071 void XMLDdeFieldDeclImportContext::StartElement( 3072 const Reference<XAttributeList> & xAttrList) 3073 { 3074 OUString sName; 3075 OUString sCommandApplication; 3076 OUString sCommandTopic; 3077 OUString sCommandItem; 3078 3079 sal_Bool bUpdate = sal_False; 3080 sal_Bool bNameOK = sal_False; 3081 sal_Bool bCommandApplicationOK = sal_False; 3082 sal_Bool bCommandTopicOK = sal_False; 3083 sal_Bool bCommandItemOK = sal_False; 3084 3085 // process attributes 3086 sal_Int16 nLength = xAttrList->getLength(); 3087 for(sal_Int16 i=0; i<nLength; i++) 3088 { 3089 3090 OUString sLocalName; 3091 sal_uInt16 nPrefix = GetImport().GetNamespaceMap(). 3092 GetKeyByAttrName( xAttrList->getNameByIndex(i), &sLocalName ); 3093 3094 switch (rTokenMap.Get(nPrefix, sLocalName)) 3095 { 3096 case XML_TOK_DDEFIELD_NAME: 3097 sName = xAttrList->getValueByIndex(i); 3098 bNameOK = sal_True; 3099 break; 3100 case XML_TOK_DDEFIELD_APPLICATION: 3101 sCommandApplication = xAttrList->getValueByIndex(i); 3102 bCommandApplicationOK = sal_True; 3103 break; 3104 case XML_TOK_DDEFIELD_TOPIC: 3105 sCommandTopic = xAttrList->getValueByIndex(i); 3106 bCommandTopicOK = sal_True; 3107 break; 3108 case XML_TOK_DDEFIELD_ITEM: 3109 sCommandItem = xAttrList->getValueByIndex(i); 3110 bCommandItemOK = sal_True; 3111 break; 3112 case XML_TOK_DDEFIELD_UPDATE: 3113 { 3114 sal_Bool bTmp; 3115 if ( SvXMLUnitConverter::convertBool( 3116 bTmp, xAttrList->getValueByIndex(i)) ) 3117 { 3118 bUpdate = bTmp; 3119 } 3120 break; 3121 } 3122 } 3123 } 3124 3125 // valid data? 3126 if (bNameOK && bCommandApplicationOK && bCommandTopicOK && bCommandItemOK) 3127 { 3128 // make service name 3129 OUStringBuffer sBuf; 3130 sBuf.appendAscii(sAPI_fieldmaster_prefix); 3131 sBuf.appendAscii(sAPI_dde); 3132 3133 // create DDE TextFieldMaster 3134 Reference<XMultiServiceFactory> xFactory(GetImport().GetModel(), 3135 UNO_QUERY); 3136 if( xFactory.is() ) 3137 { 3138 /* #i6432# There might be multiple occurances of one DDE 3139 declaration if it is used in more than one of 3140 header/footer/body. createInstance will throw an exception if we 3141 try to create the second, third, etc. instance of such a 3142 declaration. Thus we ignore the exception. Otherwise this will 3143 lead to an unloadable document. */ 3144 try 3145 { 3146 Reference<XInterface> xIfc = 3147 xFactory->createInstance(sBuf.makeStringAndClear()); 3148 if( xIfc.is() ) 3149 { 3150 Reference<XPropertySet> xPropSet( xIfc, UNO_QUERY ); 3151 if (xPropSet.is() && 3152 xPropSet->getPropertySetInfo()->hasPropertyByName( 3153 sPropertyDDECommandType)) 3154 { 3155 Any aAny; 3156 3157 aAny <<= sName; 3158 xPropSet->setPropertyValue(sPropertyName, aAny); 3159 3160 aAny <<= sCommandApplication; 3161 xPropSet->setPropertyValue(sPropertyDDECommandType, aAny); 3162 3163 aAny <<= sCommandTopic; 3164 xPropSet->setPropertyValue(sPropertyDDECommandFile, aAny); 3165 3166 aAny <<= sCommandItem; 3167 xPropSet->setPropertyValue(sPropertyDDECommandElement, 3168 aAny); 3169 3170 aAny.setValue(&bUpdate, ::getBooleanCppuType()); 3171 xPropSet->setPropertyValue(sPropertyIsAutomaticUpdate, 3172 aAny); 3173 } 3174 // else: ignore (can't get XPropertySet, or DDE 3175 // properties are not supported) 3176 } 3177 // else: ignore 3178 } 3179 catch ( const Exception& ) 3180 { 3181 //ignore 3182 } 3183 } 3184 // else: ignore 3185 } 3186 // else: ignore 3187 } 3188 3189 3190 3191 // 3192 // DDE field import 3193 // 3194 3195 TYPEINIT1( XMLDdeFieldImportContext, XMLTextFieldImportContext ); 3196 3197 XMLDdeFieldImportContext::XMLDdeFieldImportContext( 3198 SvXMLImport& rImport, XMLTextImportHelper& rHlp, 3199 sal_uInt16 nPrfx, const OUString& sLocalName) : 3200 XMLTextFieldImportContext(rImport, rHlp, sAPI_dde, 3201 nPrfx, sLocalName), 3202 sName() 3203 ,sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content)) 3204 { 3205 } 3206 3207 void XMLDdeFieldImportContext::ProcessAttribute( 3208 sal_uInt16 nAttrToken, 3209 const ::rtl::OUString& sAttrValue ) 3210 { 3211 if (XML_TOK_TEXTFIELD_CONNECTION_NAME == nAttrToken) 3212 { 3213 sName = sAttrValue; 3214 bValid = sal_True; 3215 } 3216 } 3217 3218 void XMLDdeFieldImportContext::EndElement() 3219 { 3220 if (bValid) 3221 { 3222 // find master 3223 OUStringBuffer sBuf; 3224 sBuf.appendAscii(sAPI_fieldmaster_prefix); 3225 sBuf.appendAscii(sAPI_dde); 3226 sBuf.append(sal_Unicode('.')); 3227 sBuf.append(sName); 3228 OUString sMasterName = sBuf.makeStringAndClear(); 3229 3230 Reference<XTextFieldsSupplier> xTextFieldsSupp(GetImport().GetModel(), 3231 UNO_QUERY); 3232 Reference<container::XNameAccess> xFieldMasterNameAccess( 3233 xTextFieldsSupp->getTextFieldMasters(), UNO_QUERY); 3234 3235 if (xFieldMasterNameAccess->hasByName(sMasterName)) 3236 { 3237 Reference<XPropertySet> xMaster; 3238 Any aAny = xFieldMasterNameAccess->getByName(sMasterName); 3239 aAny >>= xMaster; 3240 //apply the content to the master 3241 xMaster->setPropertyValue( sPropertyContent, uno::makeAny( GetContent())); 3242 // master exists: create text field and attach 3243 Reference<XPropertySet> xField; 3244 sBuf.appendAscii(sAPI_textfield_prefix); 3245 sBuf.appendAscii(sAPI_dde); 3246 if (CreateField(xField, sBuf.makeStringAndClear())) 3247 { 3248 Reference<XDependentTextField> xDepTextField(xField,UNO_QUERY); 3249 xDepTextField->attachTextFieldMaster(xMaster); 3250 3251 // attach field to document 3252 Reference<XTextContent> xTextContent(xField, UNO_QUERY); 3253 if (xTextContent.is()) 3254 { 3255 GetImportHelper().InsertTextContent(xTextContent); 3256 3257 // we're lucky. nothing else to prepare. 3258 } 3259 // else: fail, because text content could not be created 3260 } 3261 // else: fail, because field could not be created 3262 } 3263 // else: fail, because no master was found (faulty document?!) 3264 } 3265 // not valid: ignore 3266 } 3267 3268 void XMLDdeFieldImportContext::PrepareField( 3269 const Reference<XPropertySet> &) 3270 { 3271 // empty, since not needed. 3272 } 3273 3274 3275 // 3276 // sheet name fields 3277 // 3278 3279 TYPEINIT1(XMLSheetNameImportContext, XMLTextFieldImportContext); 3280 3281 XMLSheetNameImportContext::XMLSheetNameImportContext( 3282 SvXMLImport& rImport, 3283 XMLTextImportHelper& rHlp, 3284 sal_uInt16 nPrfx, 3285 const OUString& sLocalName) : 3286 XMLTextFieldImportContext(rImport, rHlp, sAPI_sheet_name, 3287 nPrfx, sLocalName) 3288 { 3289 bValid = sal_True; // always valid! 3290 } 3291 3292 void XMLSheetNameImportContext::ProcessAttribute( 3293 sal_uInt16, 3294 const ::rtl::OUString& ) 3295 { 3296 // no attributes -> nothing to be done 3297 } 3298 3299 void XMLSheetNameImportContext::PrepareField( 3300 const Reference<XPropertySet> &) 3301 { 3302 // no attributes -> nothing to be done 3303 } 3304 3305 3306 // 3307 // URL fields (Calc, Impress, Draw) 3308 // 3309 3310 TYPEINIT1(XMLUrlFieldImportContext, XMLTextFieldImportContext); 3311 3312 XMLUrlFieldImportContext::XMLUrlFieldImportContext( 3313 SvXMLImport& rImport, 3314 XMLTextImportHelper& rHlp, 3315 sal_uInt16 nPrfx, 3316 const OUString& sLocalName) : 3317 XMLTextFieldImportContext(rImport, rHlp, sAPI_url, 3318 nPrfx, sLocalName), 3319 sPropertyURL(RTL_CONSTASCII_USTRINGPARAM(sAPI_url)), 3320 sPropertyTargetFrame(RTL_CONSTASCII_USTRINGPARAM(sAPI_target_frame)), 3321 sPropertyRepresentation(RTL_CONSTASCII_USTRINGPARAM( 3322 sAPI_representation)), 3323 bFrameOK(sal_False) 3324 { 3325 } 3326 3327 void XMLUrlFieldImportContext::ProcessAttribute( 3328 sal_uInt16 nAttrToken, 3329 const OUString& sAttrValue ) 3330 { 3331 switch (nAttrToken) 3332 { 3333 case XML_TOK_TEXTFIELD_HREF: 3334 sURL = GetImport().GetAbsoluteReference( sAttrValue ); 3335 bValid = sal_True; 3336 break; 3337 case XML_TOK_TEXTFIELD_TARGET_FRAME: 3338 sFrame = sAttrValue; 3339 bFrameOK = sal_True; 3340 break; 3341 default: 3342 // ignore 3343 break; 3344 } 3345 } 3346 3347 void XMLUrlFieldImportContext::PrepareField( 3348 const Reference<XPropertySet> & xPropertySet) 3349 { 3350 Any aAny; 3351 3352 aAny <<= sURL; 3353 xPropertySet->setPropertyValue(sPropertyURL, aAny); 3354 3355 if (bFrameOK) 3356 { 3357 aAny <<= sFrame; 3358 xPropertySet->setPropertyValue(sPropertyTargetFrame, aAny); 3359 } 3360 3361 aAny <<= GetContent(); 3362 xPropertySet->setPropertyValue(sPropertyRepresentation, aAny); 3363 } 3364 3365 3366 TYPEINIT1(XMLBibliographyFieldImportContext, XMLTextFieldImportContext); 3367 3368 3369 XMLBibliographyFieldImportContext::XMLBibliographyFieldImportContext( 3370 SvXMLImport& rImport, 3371 XMLTextImportHelper& rHlp, 3372 sal_uInt16 nPrfx, 3373 const OUString& sLocalName) : 3374 XMLTextFieldImportContext(rImport, rHlp, sAPI_bibliography, 3375 nPrfx, sLocalName), 3376 sPropertyFields(RTL_CONSTASCII_USTRINGPARAM("Fields")), 3377 aValues() 3378 { 3379 bValid = sal_True; 3380 } 3381 3382 // TODO: this is the same map as is used in the text field export 3383 SvXMLEnumMapEntry __READONLY_DATA aBibliographyDataTypeMap[] = 3384 { 3385 { XML_ARTICLE, BibliographyDataType::ARTICLE }, 3386 { XML_BOOK, BibliographyDataType::BOOK }, 3387 { XML_BOOKLET, BibliographyDataType::BOOKLET }, 3388 { XML_CONFERENCE, BibliographyDataType::CONFERENCE }, 3389 { XML_CUSTOM1, BibliographyDataType::CUSTOM1 }, 3390 { XML_CUSTOM2, BibliographyDataType::CUSTOM2 }, 3391 { XML_CUSTOM3, BibliographyDataType::CUSTOM3 }, 3392 { XML_CUSTOM4, BibliographyDataType::CUSTOM4 }, 3393 { XML_CUSTOM5, BibliographyDataType::CUSTOM5 }, 3394 { XML_EMAIL, BibliographyDataType::EMAIL }, 3395 { XML_INBOOK, BibliographyDataType::INBOOK }, 3396 { XML_INCOLLECTION, BibliographyDataType::INCOLLECTION }, 3397 { XML_INPROCEEDINGS, BibliographyDataType::INPROCEEDINGS }, 3398 { XML_JOURNAL, BibliographyDataType::JOURNAL }, 3399 { XML_MANUAL, BibliographyDataType::MANUAL }, 3400 { XML_MASTERSTHESIS, BibliographyDataType::MASTERSTHESIS }, 3401 { XML_MISC, BibliographyDataType::MISC }, 3402 { XML_PHDTHESIS, BibliographyDataType::PHDTHESIS }, 3403 { XML_PROCEEDINGS, BibliographyDataType::PROCEEDINGS }, 3404 { XML_TECHREPORT, BibliographyDataType::TECHREPORT }, 3405 { XML_UNPUBLISHED, BibliographyDataType::UNPUBLISHED }, 3406 { XML_WWW, BibliographyDataType::WWW }, 3407 { XML_TOKEN_INVALID, 0 } 3408 }; 3409 3410 3411 // we'll process attributes on our own and forfit the standard 3412 // tecfield mechanism, because our attributes have zero overlp with 3413 // all the oher textfields. 3414 void XMLBibliographyFieldImportContext::StartElement( 3415 const Reference<XAttributeList> & xAttrList) 3416 { 3417 // iterate over attributes 3418 sal_Int16 nLength = xAttrList->getLength(); 3419 for(sal_Int16 i=0; i<nLength; i++) { 3420 3421 OUString sLocalName; 3422 sal_uInt16 nPrefix = GetImport().GetNamespaceMap(). 3423 GetKeyByAttrName( xAttrList->getNameByIndex(i), &sLocalName ); 3424 3425 if (nPrefix == XML_NAMESPACE_TEXT) 3426 { 3427 PropertyValue aValue; 3428 aValue.Name = OUString::createFromAscii( 3429 MapBibliographyFieldName(sLocalName)); 3430 Any aAny; 3431 3432 // special treatment for bibliography type 3433 // biblio vs bibilio: #96658#; also read old documents 3434 if (IsXMLToken(sLocalName, XML_BIBILIOGRAPHIC_TYPE) || 3435 IsXMLToken(sLocalName, XML_BIBLIOGRAPHY_TYPE) ) 3436 { 3437 sal_uInt16 nTmp; 3438 if (SvXMLUnitConverter::convertEnum( 3439 nTmp, xAttrList->getValueByIndex(i), 3440 aBibliographyDataTypeMap)) 3441 { 3442 aAny <<= (sal_Int16)nTmp; 3443 aValue.Value = aAny; 3444 3445 aValues.push_back(aValue); 3446 } 3447 } 3448 else 3449 { 3450 aAny <<= xAttrList->getValueByIndex(i); 3451 aValue.Value = aAny; 3452 3453 aValues.push_back(aValue); 3454 } 3455 } 3456 // else: unknown namespace -> ignore 3457 } 3458 } 3459 3460 void XMLBibliographyFieldImportContext::ProcessAttribute( 3461 sal_uInt16, 3462 const OUString& ) 3463 { 3464 // attributes are handled in StartElement 3465 DBG_ERROR("This should not have happened."); 3466 } 3467 3468 3469 void XMLBibliographyFieldImportContext::PrepareField( 3470 const Reference<XPropertySet> & xPropertySet) 3471 { 3472 // convert vector into sequence 3473 sal_Int32 nCount = aValues.size(); 3474 Sequence<PropertyValue> aValueSequence(nCount); 3475 for(sal_Int32 i = 0; i < nCount; i++) 3476 { 3477 aValueSequence[i] = aValues[i]; 3478 } 3479 3480 // set sequence 3481 Any aAny; 3482 aAny <<= aValueSequence; 3483 xPropertySet->setPropertyValue(sPropertyFields, aAny); 3484 } 3485 3486 const sal_Char* XMLBibliographyFieldImportContext::MapBibliographyFieldName( 3487 OUString sName) 3488 { 3489 const sal_Char* pName = NULL; 3490 3491 if (IsXMLToken(sName, XML_IDENTIFIER)) 3492 { 3493 pName = "Identifier"; 3494 } 3495 else if (IsXMLToken(sName, XML_BIBILIOGRAPHIC_TYPE) || 3496 IsXMLToken(sName, XML_BIBLIOGRAPHY_TYPE) ) 3497 { 3498 // biblio... vs bibilio...: #96658#: also read old documents 3499 pName = "BibiliographicType"; 3500 } 3501 else if (IsXMLToken(sName, XML_ADDRESS)) 3502 { 3503 pName = "Address"; 3504 } 3505 else if (IsXMLToken(sName, XML_ANNOTE)) 3506 { 3507 pName = "Annote"; 3508 } 3509 else if (IsXMLToken(sName, XML_AUTHOR)) 3510 { 3511 pName = "Author"; 3512 } 3513 else if (IsXMLToken(sName, XML_BOOKTITLE)) 3514 { 3515 pName = "Booktitle"; 3516 } 3517 else if (IsXMLToken(sName, XML_CHAPTER)) 3518 { 3519 pName = "Chapter"; 3520 } 3521 else if (IsXMLToken(sName, XML_EDITION)) 3522 { 3523 pName = "Edition"; 3524 } 3525 else if (IsXMLToken(sName, XML_EDITOR)) 3526 { 3527 pName = "Editor"; 3528 } 3529 else if (IsXMLToken(sName, XML_HOWPUBLISHED)) 3530 { 3531 pName = "Howpublished"; 3532 } 3533 else if (IsXMLToken(sName, XML_INSTITUTION)) 3534 { 3535 pName = "Institution"; 3536 } 3537 else if (IsXMLToken(sName, XML_JOURNAL)) 3538 { 3539 pName = "Journal"; 3540 } 3541 else if (IsXMLToken(sName, XML_MONTH)) 3542 { 3543 pName = "Month"; 3544 } 3545 else if (IsXMLToken(sName, XML_NOTE)) 3546 { 3547 pName = "Note"; 3548 } 3549 else if (IsXMLToken(sName, XML_NUMBER)) 3550 { 3551 pName = "Number"; 3552 } 3553 else if (IsXMLToken(sName, XML_ORGANIZATIONS)) 3554 { 3555 pName = "Organizations"; 3556 } 3557 else if (IsXMLToken(sName, XML_PAGES)) 3558 { 3559 pName = "Pages"; 3560 } 3561 else if (IsXMLToken(sName, XML_PUBLISHER)) 3562 { 3563 pName = "Publisher"; 3564 } 3565 else if (IsXMLToken(sName, XML_SCHOOL)) 3566 { 3567 pName = "School"; 3568 } 3569 else if (IsXMLToken(sName, XML_SERIES)) 3570 { 3571 pName = "Series"; 3572 } 3573 else if (IsXMLToken(sName, XML_TITLE)) 3574 { 3575 pName = "Title"; 3576 } 3577 else if (IsXMLToken(sName, XML_REPORT_TYPE)) 3578 { 3579 pName = "Report_Type"; 3580 } 3581 else if (IsXMLToken(sName, XML_VOLUME)) 3582 { 3583 pName = "Volume"; 3584 } 3585 else if (IsXMLToken(sName, XML_YEAR)) 3586 { 3587 pName = "Year"; 3588 } 3589 else if (IsXMLToken(sName, XML_URL)) 3590 { 3591 pName = "URL"; 3592 } 3593 else if (IsXMLToken(sName, XML_CUSTOM1)) 3594 { 3595 pName = "Custom1"; 3596 } 3597 else if (IsXMLToken(sName, XML_CUSTOM2)) 3598 { 3599 pName = "Custom2"; 3600 } 3601 else if (IsXMLToken(sName, XML_CUSTOM3)) 3602 { 3603 pName = "Custom3"; 3604 } 3605 else if (IsXMLToken(sName, XML_CUSTOM4)) 3606 { 3607 pName = "Custom4"; 3608 } 3609 else if (IsXMLToken(sName, XML_CUSTOM5)) 3610 { 3611 pName = "Custom5"; 3612 } 3613 else if (IsXMLToken(sName, XML_ISBN)) 3614 { 3615 pName = "ISBN"; 3616 } 3617 else 3618 { 3619 DBG_ERROR("Unknown bibliography info data"); 3620 pName = NULL; 3621 } 3622 3623 return pName; 3624 } 3625 3626 3627 // 3628 // Annotation Field 3629 // 3630 3631 TYPEINIT1(XMLAnnotationImportContext, XMLTextFieldImportContext); 3632 3633 XMLAnnotationImportContext::XMLAnnotationImportContext( 3634 SvXMLImport& rImport, 3635 XMLTextImportHelper& rHlp, 3636 sal_uInt16 nToken, 3637 sal_uInt16 nPrfx, 3638 const OUString& sLocalName) 3639 : XMLTextFieldImportContext(rImport, rHlp, sAPI_annotation, nPrfx, sLocalName) 3640 , sPropertyName(RTL_CONSTASCII_USTRINGPARAM(sAPI_name)) 3641 , sPropertyAuthor(RTL_CONSTASCII_USTRINGPARAM(sAPI_author)) 3642 , sPropertyInitials(RTL_CONSTASCII_USTRINGPARAM(sAPI_initials)) 3643 , sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content)) 3644 , sPropertyDate(RTL_CONSTASCII_USTRINGPARAM(sAPI_date_time_value)) 3645 , sPropertyTextRange(RTL_CONSTASCII_USTRINGPARAM(sAPI_TextRange)) 3646 , m_nToken( nToken ) 3647 { 3648 bValid = sal_True; 3649 3650 // remember old list item and block (#91964#) and reset them 3651 // for the text frame 3652 // do this in the constructor, not in CreateChildContext (#i93392#) 3653 GetImport().GetTextImport()->PushListContext(); 3654 } 3655 3656 void XMLAnnotationImportContext::ProcessAttribute( 3657 sal_uInt16 nToken, 3658 const OUString& rValue ) 3659 { 3660 if ( nToken == XML_TOK_TEXT_NAME ) 3661 { 3662 aName = rValue; 3663 } 3664 } 3665 3666 SvXMLImportContext* XMLAnnotationImportContext::CreateChildContext( 3667 sal_uInt16 nPrefix, 3668 const OUString& rLocalName, 3669 const Reference<XAttributeList >& xAttrList ) 3670 { 3671 SvXMLImportContext *pContext = 0; 3672 if( XML_NAMESPACE_DC == nPrefix ) 3673 { 3674 if( IsXMLToken( rLocalName, XML_CREATOR ) ) 3675 { 3676 pContext = 3677 new XMLStringBufferImportContext( GetImport(), nPrefix, rLocalName, aAuthorBuffer); 3678 } 3679 else if( IsXMLToken( rLocalName, XML_DATE ) ) 3680 { 3681 pContext = 3682 new XMLStringBufferImportContext( GetImport(), nPrefix, rLocalName, aDateBuffer); 3683 } 3684 } 3685 else if ( XML_NAMESPACE_TEXT == nPrefix ) 3686 { 3687 if( IsXMLToken( rLocalName, XML_SENDER_INITIALS ) ) 3688 { 3689 pContext = 3690 new XMLStringBufferImportContext( GetImport(), nPrefix, rLocalName, aInitialsBuffer); 3691 } 3692 } 3693 3694 if( !pContext ) 3695 { 3696 try 3697 { 3698 if ( !mxField.is() ) 3699 CreateField( mxField, sServicePrefix + GetServiceName() ); 3700 Any aAny = mxField->getPropertyValue( sPropertyTextRange ); 3701 Reference< XText > xText; 3702 aAny >>= xText; 3703 if( xText.is() ) 3704 { 3705 UniReference < XMLTextImportHelper > xTxtImport = GetImport().GetTextImport(); 3706 if( !mxCursor.is() ) 3707 { 3708 mxOldCursor = xTxtImport->GetCursor(); 3709 mxCursor = xText->createTextCursor(); 3710 } 3711 3712 if( mxCursor.is() ) 3713 { 3714 xTxtImport->SetCursor( mxCursor ); 3715 pContext = xTxtImport->CreateTextChildContext( GetImport(), nPrefix, rLocalName, xAttrList ); 3716 } 3717 } 3718 } 3719 catch ( Exception& ) 3720 {} 3721 3722 if( !pContext ) 3723 pContext = new XMLStringBufferImportContext(GetImport(), nPrefix, rLocalName, aTextBuffer); 3724 } 3725 3726 return pContext; 3727 } 3728 3729 void XMLAnnotationImportContext::EndElement() 3730 { 3731 DBG_ASSERT(GetServiceName().getLength()>0, "no service name for element!"); 3732 if( mxCursor.is() ) 3733 { 3734 // delete addition newline 3735 const OUString aEmpty; 3736 mxCursor->gotoEnd( sal_False ); 3737 mxCursor->goLeft( 1, sal_True ); 3738 mxCursor->setString( aEmpty ); 3739 3740 // reset cursor 3741 GetImport().GetTextImport()->ResetCursor(); 3742 } 3743 3744 if( mxOldCursor.is() ) 3745 GetImport().GetTextImport()->SetCursor( mxOldCursor ); 3746 3747 // reinstall old list item #91964# 3748 GetImport().GetTextImport()->PopListContext(); 3749 3750 if ( bValid ) 3751 { 3752 if ( mxField.is() || CreateField( mxField, sServicePrefix + GetServiceName() ) ) 3753 { 3754 // set field properties 3755 PrepareField( mxField ); 3756 3757 // attach field to document 3758 Reference < XTextContent > xTextContent( mxField, UNO_QUERY ); 3759 3760 // workaround for #80606# 3761 try 3762 { 3763 if ( m_nToken == XML_TOK_TEXT_ANNOTATION_END 3764 && m_xStart.is() ) 3765 { 3766 // So we are ending a previous annotation, 3767 // let's create a text range covering the start and the current position. 3768 uno::Reference<text::XText> xText = GetImportHelper().GetText(); 3769 uno::Reference<text::XTextCursor> xCursor = xText->createTextCursorByRange(m_xStart->getAnchor()); 3770 xCursor->gotoRange(GetImportHelper().GetCursorAsRange(), true); 3771 uno::Reference<text::XTextRange> xTextRange(xCursor, uno::UNO_QUERY); 3772 xText->insertTextContent( xTextRange, xTextContent, !xCursor->isCollapsed() ); 3773 3774 // Now we can delete the annotation at the start position. 3775 uno::Reference<lang::XComponent>(m_xStart, uno::UNO_QUERY)->dispose(); 3776 } 3777 else 3778 { 3779 GetImportHelper().InsertTextContent( xTextContent ); 3780 } 3781 } 3782 catch (lang::IllegalArgumentException) 3783 { 3784 // ignore 3785 } 3786 } 3787 } 3788 else 3789 GetImportHelper().InsertString(GetContent()); 3790 } 3791 3792 void XMLAnnotationImportContext::PrepareField( 3793 const Reference<XPropertySet> & xPropertySet) 3794 { 3795 if ( m_nToken == XML_TOK_TEXT_ANNOTATION_END 3796 && aName.getLength() > 0 ) 3797 { 3798 // Search for a previous annotation with the same name. 3799 Reference<XTextFieldsSupplier> xTextFieldsSupplier(GetImport().GetModel(), UNO_QUERY); 3800 uno::Reference<container::XEnumerationAccess> xFieldsAccess(xTextFieldsSupplier->getTextFields()); 3801 uno::Reference<container::XEnumeration> xFields(xFieldsAccess->createEnumeration()); 3802 uno::Reference<beans::XPropertySet> xPrevField; 3803 while (xFields->hasMoreElements()) 3804 { 3805 uno::Reference<beans::XPropertySet> xCurrField(xFields->nextElement(), uno::UNO_QUERY); 3806 OUString aFieldName; 3807 xCurrField->getPropertyValue(sPropertyName) >>= aFieldName; 3808 if ( aFieldName == aName ) 3809 { 3810 xPrevField = xCurrField; 3811 break; 3812 } 3813 } 3814 if (xPrevField.is()) 3815 { 3816 // copy over the properties. 3817 xPropertySet->setPropertyValue(sPropertyAuthor, xPrevField->getPropertyValue(sPropertyAuthor)); 3818 xPropertySet->setPropertyValue(sPropertyInitials, xPrevField->getPropertyValue(sPropertyInitials)); 3819 xPropertySet->setPropertyValue(sPropertyDate, xPrevField->getPropertyValue(sPropertyDate)); 3820 xPropertySet->setPropertyValue(sPropertyName, xPrevField->getPropertyValue(sPropertyName)); 3821 xPropertySet->setPropertyValue(sPropertyContent, xPrevField->getPropertyValue(sPropertyContent)); 3822 3823 // And save a reference to it, so we can delete it later. 3824 m_xStart.set(xPrevField, uno::UNO_QUERY); 3825 return; 3826 } 3827 } 3828 3829 // import (possibly empty) author 3830 OUString sAuthor( aAuthorBuffer.makeStringAndClear() ); 3831 xPropertySet->setPropertyValue(sPropertyAuthor, makeAny(sAuthor)); 3832 3833 // import (possibly empty) initials 3834 OUString sInitials( aInitialsBuffer.makeStringAndClear() ); 3835 xPropertySet->setPropertyValue(sPropertyInitials, makeAny(sInitials)); 3836 3837 DateTime aDateTime; 3838 if (SvXMLUnitConverter::convertDateTime(aDateTime, 3839 aDateBuffer.makeStringAndClear())) 3840 { 3841 /* 3842 Date aDate; 3843 aDate.Year = aDateTime.Year; 3844 aDate.Month = aDateTime.Month; 3845 aDate.Day = aDateTime.Day; 3846 xPropertySet->setPropertyValue(sPropertyDate, makeAny(aDate)); 3847 */ 3848 xPropertySet->setPropertyValue(sPropertyDate, makeAny(aDateTime)); 3849 } 3850 3851 OUString sBuffer = aTextBuffer.makeStringAndClear(); 3852 if ( sBuffer.getLength() > 0 ) 3853 { 3854 // delete last paragraph mark (if necessary) 3855 if (sal_Char(0x0a) == sBuffer.getStr()[sBuffer.getLength()-1]) 3856 sBuffer = sBuffer.copy(0, sBuffer.getLength()-1); 3857 xPropertySet->setPropertyValue(sPropertyContent, makeAny(sBuffer)); 3858 } 3859 3860 if ( aName.getLength() > 0 ) 3861 { 3862 xPropertySet->setPropertyValue(sPropertyName, makeAny(aName)); 3863 } 3864 } 3865 3866 3867 3868 // 3869 // script field 3870 // 3871 3872 TYPEINIT1(XMLScriptImportContext, XMLTextFieldImportContext); 3873 3874 XMLScriptImportContext::XMLScriptImportContext( 3875 SvXMLImport& rImport, 3876 XMLTextImportHelper& rHlp, 3877 sal_uInt16 nPrfx, 3878 const OUString& sLocalName) 3879 : XMLTextFieldImportContext(rImport, rHlp, sAPI_script, nPrfx, sLocalName) 3880 , sPropertyScriptType(RTL_CONSTASCII_USTRINGPARAM(sAPI_script_type)) 3881 , sPropertyURLContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_url_content)) 3882 , sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content)) 3883 , bContentOK(sal_False) 3884 , bScriptTypeOK(sal_False) 3885 , bUrlContent(sal_False) 3886 { 3887 } 3888 3889 void XMLScriptImportContext::ProcessAttribute( 3890 sal_uInt16 nAttrToken, 3891 const OUString& sAttrValue ) 3892 { 3893 switch (nAttrToken) 3894 { 3895 case XML_TOK_TEXTFIELD_HREF: 3896 sContent = GetImport().GetAbsoluteReference( sAttrValue ); 3897 bContentOK = sal_True; 3898 break; 3899 3900 case XML_TOK_TEXTFIELD_LANGUAGE: 3901 sScriptType = sAttrValue; 3902 bScriptTypeOK = sal_True; 3903 break; 3904 3905 default: 3906 // ignore 3907 break; 3908 } 3909 3910 // always valid (even without ScriptType; cf- #96531#) 3911 bValid = sal_True; 3912 } 3913 3914 void XMLScriptImportContext::PrepareField( 3915 const Reference<XPropertySet> & xPropertySet) 3916 { 3917 Any aAny; 3918 3919 // if href attribute was present, we use it. Else we use element content 3920 if (! bContentOK) 3921 { 3922 sContent = GetContent(); 3923 } 3924 aAny <<= sContent; 3925 xPropertySet->setPropertyValue(sPropertyContent, aAny); 3926 3927 // URL or script text? We use URL if we have an href-attribute 3928 aAny.setValue(&bContentOK, ::getBooleanCppuType()); 3929 xPropertySet->setPropertyValue(sPropertyURLContent, aAny); 3930 3931 aAny <<= sScriptType; 3932 xPropertySet->setPropertyValue(sPropertyScriptType, aAny); 3933 } 3934 3935 // 3936 // measure field 3937 // 3938 3939 TYPEINIT1(XMLMeasureFieldImportContext, XMLTextFieldImportContext); 3940 3941 XMLMeasureFieldImportContext::XMLMeasureFieldImportContext( 3942 SvXMLImport& rImport, 3943 XMLTextImportHelper& rHlp, 3944 sal_uInt16 nPrfx, 3945 const OUString& sLocalName) : 3946 XMLTextFieldImportContext(rImport, rHlp, sAPI_measure, 3947 nPrfx, sLocalName), 3948 mnKind( 0 ) 3949 { 3950 } 3951 3952 void XMLMeasureFieldImportContext::ProcessAttribute( 3953 sal_uInt16 nAttrToken, 3954 const OUString& sAttrValue ) 3955 { 3956 switch (nAttrToken) 3957 { 3958 case XML_TOK_TEXTFIELD_MEASURE_KIND: 3959 if( IsXMLToken( sAttrValue, XML_VALUE ) ) 3960 { 3961 mnKind = 0; bValid = sal_True; 3962 } 3963 else if( IsXMLToken( sAttrValue, XML_UNIT ) ) 3964 { 3965 mnKind = 1; bValid = sal_True; 3966 } 3967 else if( IsXMLToken( sAttrValue, XML_GAP ) ) 3968 { 3969 mnKind = 2; bValid = sal_True; 3970 } 3971 break; 3972 } 3973 } 3974 3975 void XMLMeasureFieldImportContext::PrepareField( 3976 const Reference<XPropertySet> & xPropertySet) 3977 { 3978 Any aAny; 3979 aAny <<= mnKind; 3980 xPropertySet->setPropertyValue(OUString::createFromAscii("Kind"), aAny); 3981 } 3982 3983 3984 3985 // 3986 // dropdown field 3987 // 3988 3989 3990 TYPEINIT1( XMLDropDownFieldImportContext, XMLTextFieldImportContext ); 3991 3992 XMLDropDownFieldImportContext::XMLDropDownFieldImportContext( 3993 SvXMLImport& rImport, 3994 XMLTextImportHelper& rHlp, 3995 sal_uInt16 nPrfx, 3996 const ::rtl::OUString& sLocalName) : 3997 XMLTextFieldImportContext( rImport, rHlp, sAPI_drop_down, 3998 nPrfx, sLocalName ), 3999 aLabels(), 4000 sName(), 4001 nSelected( -1 ), 4002 bNameOK( false ), 4003 bHelpOK(false), 4004 bHintOK(false), 4005 sPropertyItems( RTL_CONSTASCII_USTRINGPARAM( "Items" ) ), 4006 sPropertySelectedItem( RTL_CONSTASCII_USTRINGPARAM( "SelectedItem" ) ), 4007 sPropertyName( RTL_CONSTASCII_USTRINGPARAM( "Name" ) ), 4008 sPropertyHelp( RTL_CONSTASCII_USTRINGPARAM( "Help" ) ), 4009 sPropertyToolTip( RTL_CONSTASCII_USTRINGPARAM( "Tooltip" ) ) 4010 { 4011 bValid = sal_True; 4012 } 4013 4014 bool lcl_ProcessLabel( const SvXMLImport& rImport, 4015 const Reference<XAttributeList>& xAttrList, 4016 OUString& rLabel, 4017 bool& rIsSelected ) 4018 { 4019 bool bValid = false; 4020 sal_Int16 nLength = xAttrList->getLength(); 4021 for( sal_Int16 n = 0; n < nLength; n++ ) 4022 { 4023 OUString sLocalName; 4024 sal_uInt16 nPrefix = rImport.GetNamespaceMap(). 4025 GetKeyByAttrName( xAttrList->getNameByIndex(n), &sLocalName ); 4026 OUString sValue = xAttrList->getValueByIndex(n); 4027 4028 if( nPrefix == XML_NAMESPACE_TEXT ) 4029 { 4030 if( IsXMLToken( sLocalName, XML_VALUE ) ) 4031 { 4032 rLabel = sValue; 4033 bValid = true; 4034 } 4035 else if( IsXMLToken( sLocalName, XML_CURRENT_SELECTED ) ) 4036 { 4037 sal_Bool bTmp; 4038 if( SvXMLUnitConverter::convertBool( bTmp, sValue ) ) 4039 rIsSelected = bTmp; 4040 } 4041 } 4042 } 4043 return bValid; 4044 } 4045 4046 SvXMLImportContext* XMLDropDownFieldImportContext::CreateChildContext( 4047 sal_uInt16 nPrefix, 4048 const OUString& rLocalName, 4049 const Reference<XAttributeList>& xAttrList ) 4050 { 4051 if( nPrefix == XML_NAMESPACE_TEXT && 4052 IsXMLToken( rLocalName, XML_LABEL ) ) 4053 { 4054 OUString sLabel; 4055 bool bIsSelected = sal_False; 4056 if( lcl_ProcessLabel( GetImport(), xAttrList, sLabel, bIsSelected ) ) 4057 { 4058 if( bIsSelected ) 4059 nSelected = static_cast<sal_Int32>( aLabels.size() ); 4060 aLabels.push_back( sLabel ); 4061 } 4062 } 4063 return new SvXMLImportContext( GetImport(), nPrefix, rLocalName ); 4064 } 4065 4066 void XMLDropDownFieldImportContext::ProcessAttribute( 4067 sal_uInt16 nAttrToken, 4068 const ::rtl::OUString& sAttrValue ) 4069 { 4070 if( nAttrToken == XML_TOK_TEXTFIELD_NAME ) 4071 { 4072 sName = sAttrValue; 4073 bNameOK = true; 4074 } 4075 else if (nAttrToken == XML_TOK_TEXTFIELD_HELP) 4076 { 4077 sHelp = sAttrValue; 4078 bHelpOK = true; 4079 } 4080 else if (nAttrToken == XML_TOK_TEXTFIELD_HINT) 4081 { 4082 sHint = sAttrValue; 4083 bHintOK = true; 4084 } 4085 } 4086 4087 void XMLDropDownFieldImportContext::PrepareField( 4088 const Reference<XPropertySet>& xPropertySet) 4089 { 4090 // create sequence 4091 sal_Int32 nLength = static_cast<sal_Int32>( aLabels.size() ); 4092 Sequence<OUString> aSequence( nLength ); 4093 OUString* pSequence = aSequence.getArray(); 4094 for( sal_Int32 n = 0; n < nLength; n++ ) 4095 pSequence[n] = aLabels[n]; 4096 4097 // now set values: 4098 Any aAny; 4099 4100 aAny <<= aSequence; 4101 xPropertySet->setPropertyValue( sPropertyItems, aAny ); 4102 4103 if( nSelected >= 0 && nSelected < nLength ) 4104 { 4105 aAny <<= pSequence[nSelected]; 4106 xPropertySet->setPropertyValue( sPropertySelectedItem, aAny ); 4107 } 4108 4109 // set name 4110 if( bNameOK ) 4111 { 4112 aAny <<= sName; 4113 xPropertySet->setPropertyValue( sPropertyName, aAny ); 4114 } 4115 // set help 4116 if( bHelpOK ) 4117 { 4118 aAny <<= sHelp; 4119 xPropertySet->setPropertyValue( sPropertyHelp, aAny ); 4120 } 4121 // set hint 4122 if( bHintOK ) 4123 { 4124 aAny <<= sHint; 4125 xPropertySet->setPropertyValue( sPropertyToolTip, aAny ); 4126 } 4127 4128 } 4129 4130 /** import header fields (<draw:header>) */ 4131 TYPEINIT1( XMLHeaderFieldImportContext, XMLTextFieldImportContext ); 4132 4133 XMLHeaderFieldImportContext::XMLHeaderFieldImportContext( 4134 SvXMLImport& rImport, /// XML Import 4135 XMLTextImportHelper& rHlp, /// Text import helper 4136 sal_uInt16 nPrfx, /// namespace prefix 4137 const ::rtl::OUString& sLocalName) /// element name w/o prefix 4138 : XMLTextFieldImportContext(rImport, rHlp, sAPI_header, nPrfx, sLocalName ) 4139 { 4140 sServicePrefix = OUString::createFromAscii( sAPI_presentation_prefix ); 4141 bValid = sal_True; 4142 } 4143 4144 /// process attribute values 4145 void XMLHeaderFieldImportContext::ProcessAttribute( sal_uInt16, const ::rtl::OUString& ) 4146 { 4147 } 4148 4149 /// prepare XTextField for insertion into document 4150 void XMLHeaderFieldImportContext::PrepareField(const Reference<XPropertySet> &) 4151 { 4152 } 4153 4154 /** import footer fields (<draw:footer>) */ 4155 TYPEINIT1( XMLFooterFieldImportContext, XMLTextFieldImportContext ); 4156 4157 XMLFooterFieldImportContext::XMLFooterFieldImportContext( 4158 SvXMLImport& rImport, /// XML Import 4159 XMLTextImportHelper& rHlp, /// Text import helper 4160 sal_uInt16 nPrfx, /// namespace prefix 4161 const ::rtl::OUString& sLocalName) /// element name w/o prefix 4162 : XMLTextFieldImportContext(rImport, rHlp, sAPI_footer, nPrfx, sLocalName ) 4163 { 4164 sServicePrefix = OUString::createFromAscii( sAPI_presentation_prefix ); 4165 bValid = sal_True; 4166 } 4167 4168 /// process attribute values 4169 void XMLFooterFieldImportContext::ProcessAttribute( sal_uInt16, const ::rtl::OUString& ) 4170 { 4171 } 4172 4173 /// prepare XTextField for insertion into document 4174 void XMLFooterFieldImportContext::PrepareField(const Reference<XPropertySet> &) 4175 { 4176 } 4177 4178 4179 /** import footer fields (<draw:date-and-time>) */ 4180 TYPEINIT1( XMLDateTimeFieldImportContext, XMLTextFieldImportContext ); 4181 4182 XMLDateTimeFieldImportContext::XMLDateTimeFieldImportContext( 4183 SvXMLImport& rImport, /// XML Import 4184 XMLTextImportHelper& rHlp, /// Text import helper 4185 sal_uInt16 nPrfx, /// namespace prefix 4186 const ::rtl::OUString& sLocalName) /// element name w/o prefix 4187 : XMLTextFieldImportContext(rImport, rHlp, sAPI_datetime, nPrfx, sLocalName ) 4188 { 4189 sServicePrefix = OUString::createFromAscii( sAPI_presentation_prefix ); 4190 bValid = sal_True; 4191 } 4192 4193 /// process attribute values 4194 void XMLDateTimeFieldImportContext::ProcessAttribute( sal_uInt16, 4195 const ::rtl::OUString& ) 4196 { 4197 } 4198 4199 /// prepare XTextField for insertion into document 4200 void XMLDateTimeFieldImportContext::PrepareField( 4201 const ::com::sun::star::uno::Reference< 4202 ::com::sun::star::beans::XPropertySet> &) 4203 { 4204 } 4205