/************************************************************** * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_xmloff.hxx" /** @#file * * Import of all text fields except those from txtvfldi.cxx * (variable related text fields and database display fields) */ #include "txtfldi.hxx" #include "txtvfldi.hxx" #include #include #include #include "xmloff/xmlnmspe.hxx" #include #include #include #include #include "XMLStringBufferImportContext.hxx" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using ::rtl::OUString; using ::rtl::OUStringBuffer; using namespace ::com::sun::star; using namespace ::com::sun::star::uno; using namespace ::com::sun::star::text; using namespace ::com::sun::star::lang; using namespace ::com::sun::star::beans; using namespace ::com::sun::star::document; using namespace ::com::sun::star::util; using namespace ::com::sun::star::xml::sax; using namespace ::xmloff::token; // // SO API string constants // // service prefix and service anems const sal_Char sAPI_textfield_prefix[] = "com.sun.star.text.TextField."; const sal_Char sAPI_fieldmaster_prefix[] = "com.sun.star.text.FieldMaster."; const sal_Char sAPI_presentation_prefix[] = "com.sun.star.presentation.TextField."; const sal_Char sAPI_extended_user[] = "ExtendedUser"; const sal_Char sAPI_user_data_type[] = "UserDataType"; const sal_Char sAPI_jump_edit[] = "JumpEdit"; const sal_Char sAPI_get_expression[] = "GetExpression"; const sal_Char sAPI_set_expression[] = "SetExpression"; const sal_Char sAPI_user[] = "User"; const sal_Char sAPI_date_time[] = "DateTime"; const sal_Char sAPI_page_number[] = "PageNumber"; const sal_Char sAPI_database_next[] = "DatabaseNextSet"; const sal_Char sAPI_database_select[] = "DatabaseNumberOfSet"; const sal_Char sAPI_database_number[] = "DatabaseSetNumber"; const sal_Char sAPI_database[] = "Database"; const sal_Char sAPI_database_name[] = "DatabaseName"; const sal_Char sAPI_docinfo_change_author[] = "DocInfo.ChangeAuthor"; const sal_Char sAPI_docinfo_change_date_time[] = "DocInfo.ChangeDateTime"; const sal_Char sAPI_docinfo_edit_time[] = "DocInfo.EditTime"; const sal_Char sAPI_docinfo_description[] = "DocInfo.Description"; const sal_Char sAPI_docinfo_create_author[] = "DocInfo.CreateAuthor"; const sal_Char sAPI_docinfo_create_date_time[] = "DocInfo.CreateDateTime"; const sal_Char sAPI_docinfo_custom[] = "DocInfo.Custom"; const sal_Char sAPI_docinfo_print_author[] = "DocInfo.PrintAuthor"; const sal_Char sAPI_docinfo_print_date_time[] = "DocInfo.PrintDateTime"; const sal_Char sAPI_docinfo_keywords[] = "DocInfo.KeyWords"; const sal_Char sAPI_docinfo_subject[] = "DocInfo.Subject"; const sal_Char sAPI_docinfo_title[] = "DocInfo.Title"; const sal_Char sAPI_docinfo_revision[] = "DocInfo.Revision"; const sal_Char sAPI_hidden_paragraph[] = "HiddenParagraph"; const sal_Char sAPI_hidden_text[] = "HiddenText"; const sal_Char sAPI_conditional_text[] = "ConditionalText"; const sal_Char sAPI_file_name[] = "FileName"; const sal_Char sAPI_chapter[] = "Chapter"; const sal_Char sAPI_template_name[] = "TemplateName"; const sal_Char sAPI_page_count[] = "PageCount"; const sal_Char sAPI_paragraph_count[] = "ParagraphCount"; const sal_Char sAPI_word_count[] = "WordCount"; const sal_Char sAPI_character_count[] = "CharacterCount"; const sal_Char sAPI_table_count[] = "TableCount"; const sal_Char sAPI_graphic_object_count[] = "GraphicObjectCount"; const sal_Char sAPI_embedded_object_count[] = "EmbeddedObjectCount"; const sal_Char sAPI_reference_page_set[] = "ReferencePageSet"; const sal_Char sAPI_reference_page_get[] = "ReferencePageGet"; const sal_Char sAPI_macro[] = "Macro"; const sal_Char sAPI_dde[] = "DDE"; const sal_Char sAPI_get_reference[] = "GetReference"; const sal_Char sAPI_sheet_name[] = "SheetName"; const sal_Char sAPI_url[] = "URL"; const sal_Char sAPI_bibliography[] = "Bibliography"; const sal_Char sAPI_annotation[] = "Annotation"; const sal_Char sAPI_script[] = "Script"; const sal_Char sAPI_measure[] = "Measure"; const sal_Char sAPI_drop_down[] = "DropDown"; const sal_Char sAPI_header[] = "Header"; const sal_Char sAPI_footer[] = "Footer"; const sal_Char sAPI_datetime[] = "DateTime"; // property names const sal_Char sAPI_is_fixed[] = "IsFixed"; const sal_Char sAPI_content[] = "Content"; const sal_Char sAPI_value[] = "Value"; const sal_Char sAPI_author[] = "Author"; const sal_Char sAPI_initials[] = "Initials"; const sal_Char sAPI_full_name[] = "FullName"; const sal_Char sAPI_place_holder_type[] = "PlaceHolderType"; const sal_Char sAPI_place_holder[] = "PlaceHolder"; const sal_Char sAPI_hint[] = "Hint"; const sal_Char sAPI_variable_name[] = "VariableName"; const sal_Char sAPI_name[] = "Name"; const sal_Char sAPI_sub_type[] = "SubType"; const sal_Char sAPI_numbering_separator[] = "NumberingSeparator"; const sal_Char sAPI_chapter_numbering_level[] = "ChapterNumberingLevel"; const sal_Char sAPI_variable_subtype[] = "VariableSubtype"; const sal_Char sAPI_formula[] = "Formula"; const sal_Char sAPI_date_time_value[] = "DateTimeValue"; const sal_Char sAPI_number_format[] = "NumberFormat"; const sal_Char sAPI_user_text[] = "UserText"; const sal_Char sAPI_numbering_type[] = "NumberingType"; const sal_Char sAPI_offset[] = "Offset"; const sal_Char sAPI_data_base_name[] = "DataBaseName"; const sal_Char sAPI_data_base_u_r_l[] = "DataBaseURL"; const sal_Char sAPI_data_table_name[] = "DataTableName"; const sal_Char sAPI_condition[] = "Condition"; const sal_Char sAPI_set_number[] = "SetNumber"; const sal_Char sAPI_is_data_base_format[] = "DataBaseFormat"; const sal_Char sAPI_true_content[] = "TrueContent"; const sal_Char sAPI_false_content[] = "FalseContent"; const sal_Char sAPI_revision[] = "Revision"; const sal_Char sAPI_file_format[] = "FileFormat"; const sal_Char sAPI_chapter_format[] = "ChapterFormat"; const sal_Char sAPI_level[] = "Level"; const sal_Char sAPI_is_date[] = "IsDate"; const sal_Char sAPI_adjust[] = "Adjust"; const sal_Char sAPI_on[] = "On"; const sal_Char sAPI_is_automatic_update[] = "IsAutomaticUpdate"; const sal_Char sAPI_source_name[] = "SourceName"; const sal_Char sAPI_current_presentation[] = "CurrentPresentation"; const sal_Char sAPI_reference_field_part[] = "ReferenceFieldPart"; const sal_Char sAPI_reference_field_source[] = "ReferenceFieldSource"; const sal_Char sAPI_dde_command_type[] = "DDECommandType"; const sal_Char sAPI_dde_command_file[] = "DDECommandFile"; const sal_Char sAPI_dde_command_element[] = "DDECommandElement"; // sAPI_url: also used as service name const sal_Char sAPI_target_frame[] = "TargetFrame"; const sal_Char sAPI_representation[] = "Representation"; const sal_Char sAPI_date[] = "Date"; const sal_Char sAPI_url_content[] = "URLContent"; const sal_Char sAPI_script_type[] = "ScriptType"; const sal_Char sAPI_is_hidden[] = "IsHidden"; const sal_Char sAPI_is_condition_true[] = "IsConditionTrue"; const sal_Char sAPI_data_command_type[] = "DataCommandType"; const sal_Char sAPI_is_fixed_language[] = "IsFixedLanguage"; const sal_Char sAPI_is_visible[] = "IsVisible"; const sal_Char sAPI_TextRange[] = "TextRange"; const sal_Char sAPI_true[] = "sal_True"; TYPEINIT1( XMLTextFieldImportContext, SvXMLImportContext); XMLTextFieldImportContext::XMLTextFieldImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, const sal_Char* pService, sal_uInt16 nPrefix, const OUString& rElementName) : SvXMLImportContext( rImport, nPrefix, rElementName ) , sIsFixed(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed)) , rTextImportHelper(rHlp) , sServicePrefix(RTL_CONSTASCII_USTRINGPARAM(sAPI_textfield_prefix)) , bValid(sal_False) { DBG_ASSERT(NULL != pService, "Need service name!"); sServiceName = OUString::createFromAscii(pService); } void XMLTextFieldImportContext::StartElement( const Reference & xAttrList) { // process attributes sal_Int16 nLength = xAttrList->getLength(); for(sal_Int16 i=0; igetNameByIndex(i), &sLocalName ); ProcessAttribute(rTextImportHelper.GetTextFieldAttrTokenMap(). Get(nPrefix, sLocalName), xAttrList->getValueByIndex(i) ); } } XMLTextFieldImportContext::~XMLTextFieldImportContext() { } OUString XMLTextFieldImportContext::GetContent() { if (sContent.getLength()==0) { sContent = sContentBuffer.makeStringAndClear(); } return sContent; } void XMLTextFieldImportContext::EndElement() { DBG_ASSERT(GetServiceName().getLength()>0, "no service name for element!"); if (bValid) { // create field/Service Reference xPropSet; if (CreateField(xPropSet, sServicePrefix + GetServiceName())) { // set field properties PrepareField(xPropSet); // attach field to document Reference xTextContent(xPropSet, UNO_QUERY); // workaround for #80606# try { rTextImportHelper.InsertTextContent(xTextContent); } catch (lang::IllegalArgumentException e) { // ignore } return; } } // in case of error: write element content rTextImportHelper.InsertString(GetContent()); } void XMLTextFieldImportContext::Characters(const OUString& rContent) { sContentBuffer.append(rContent); } sal_Bool XMLTextFieldImportContext::CreateField( Reference & xField, const OUString& rServiceName) { // instantiate new XTextField: // ask import for model, model is factory, ask factory to create service Reference xFactory(GetImport().GetModel(),UNO_QUERY); if( xFactory.is() ) { Reference xIfc = xFactory->createInstance(rServiceName); if( xIfc.is() ) { Reference xTmp( xIfc, UNO_QUERY ); xField = xTmp; } else { return sal_False; // can't create instance } } else { return sal_False; // can't get MultiServiceFactory } return sal_True; } /// create the appropriate field context from XMLTextFieldImportContext* XMLTextFieldImportContext::CreateTextFieldImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrefix, const OUString& rName, sal_uInt16 nToken) { XMLTextFieldImportContext* pContext = NULL; switch (nToken) { case XML_TOK_TEXT_SENDER_FIRSTNAME: case XML_TOK_TEXT_SENDER_LASTNAME: case XML_TOK_TEXT_SENDER_INITIALS: case XML_TOK_TEXT_SENDER_TITLE: case XML_TOK_TEXT_SENDER_POSITION: case XML_TOK_TEXT_SENDER_EMAIL: case XML_TOK_TEXT_SENDER_PHONE_PRIVATE: case XML_TOK_TEXT_SENDER_FAX: case XML_TOK_TEXT_SENDER_COMPANY: case XML_TOK_TEXT_SENDER_PHONE_WORK: case XML_TOK_TEXT_SENDER_STREET: case XML_TOK_TEXT_SENDER_CITY: case XML_TOK_TEXT_SENDER_POSTAL_CODE: case XML_TOK_TEXT_SENDER_COUNTRY: case XML_TOK_TEXT_SENDER_STATE_OR_PROVINCE: pContext = new XMLSenderFieldImportContext( rImport, rHlp, nPrefix, rName, nToken ); break; case XML_TOK_TEXT_AUTHOR_NAME: case XML_TOK_TEXT_AUTHOR_INITIALS: pContext = new XMLAuthorFieldImportContext( rImport, rHlp, nPrefix, rName, nToken ); break; case XML_TOK_TEXT_PLACEHOLDER: pContext = new XMLPlaceholderFieldImportContext( rImport, rHlp, nPrefix, rName); break; case XML_TOK_TEXT_SEQUENCE: pContext = new XMLSequenceFieldImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_TEXT_INPUT: pContext = new XMLTextInputFieldImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_EXPRESSION: pContext = new XMLExpressionFieldImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_VARIABLE_SET: pContext = new XMLVariableSetFieldImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_VARIABLE_INPUT: pContext = new XMLVariableInputFieldImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_VARIABLE_GET: pContext = new XMLVariableGetFieldImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_USER_FIELD_GET: pContext = new XMLUserFieldImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_USER_FIELD_INPUT: pContext = new XMLUserFieldInputImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_TIME: pContext = new XMLTimeFieldImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_PAGE_CONTINUATION_STRING: case XML_TOK_TEXT_PAGE_CONTINUATION: pContext = new XMLPageContinuationImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_PAGE_NUMBER: pContext = new XMLPageNumberImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_DATE: pContext = new XMLDateFieldImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_DATABASE_NAME: pContext = new XMLDatabaseNameImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_DATABASE_NEXT: pContext = new XMLDatabaseNextImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_DATABASE_SELECT: pContext = new XMLDatabaseSelectImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_DATABASE_ROW_NUMBER: pContext = new XMLDatabaseNumberImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_DATABASE_DISPLAY: pContext = new XMLDatabaseDisplayImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_CONDITIONAL_TEXT: pContext = new XMLConditionalTextImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_HIDDEN_TEXT: pContext = new XMLHiddenTextImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_HIDDEN_PARAGRAPH: pContext = new XMLHiddenParagraphImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_DOCUMENT_DESCRIPTION: case XML_TOK_TEXT_DOCUMENT_TITLE: case XML_TOK_TEXT_DOCUMENT_SUBJECT: case XML_TOK_TEXT_DOCUMENT_KEYWORDS: pContext = new XMLSimpleDocInfoImportContext( rImport, rHlp, nPrefix, rName, nToken, sal_True, sal_False ); break; case XML_TOK_TEXT_DOCUMENT_CREATION_AUTHOR: case XML_TOK_TEXT_DOCUMENT_PRINT_AUTHOR: case XML_TOK_TEXT_DOCUMENT_SAVE_AUTHOR: pContext = new XMLSimpleDocInfoImportContext( rImport, rHlp, nPrefix, rName, nToken, sal_False, sal_True ); break; case XML_TOK_TEXT_DOCUMENT_CREATION_DATE: case XML_TOK_TEXT_DOCUMENT_CREATION_TIME: case XML_TOK_TEXT_DOCUMENT_PRINT_DATE: case XML_TOK_TEXT_DOCUMENT_PRINT_TIME: case XML_TOK_TEXT_DOCUMENT_SAVE_DATE: case XML_TOK_TEXT_DOCUMENT_SAVE_TIME: case XML_TOK_TEXT_DOCUMENT_EDIT_DURATION: pContext = new XMLDateTimeDocInfoImportContext( rImport, rHlp, nPrefix, rName, nToken ); break; case XML_TOK_TEXT_DOCUMENT_REVISION: pContext = new XMLRevisionDocInfoImportContext( rImport, rHlp, nPrefix, rName, nToken ); break; case XML_TOK_TEXT_DOCUMENT_USER_DEFINED: pContext = new XMLUserDocInfoImportContext( rImport, rHlp, nPrefix, rName, nToken ); break; case XML_TOK_TEXT_FILENAME: pContext = new XMLFileNameImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_CHAPTER: pContext = new XMLChapterImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_TEMPLATENAME: pContext = new XMLTemplateNameImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_WORD_COUNT: case XML_TOK_TEXT_PARAGRAPH_COUNT: case XML_TOK_TEXT_TABLE_COUNT: case XML_TOK_TEXT_CHARACTER_COUNT: case XML_TOK_TEXT_IMAGE_COUNT: case XML_TOK_TEXT_OBJECT_COUNT: case XML_TOK_TEXT_PAGE_COUNT: pContext = new XMLCountFieldImportContext( rImport, rHlp, nPrefix, rName, nToken); break; case XML_TOK_TEXT_GET_PAGE_VAR: pContext = new XMLPageVarGetFieldImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_SET_PAGE_VAR: pContext = new XMLPageVarSetFieldImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_MACRO: pContext = new XMLMacroFieldImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_DDE: pContext = new XMLDdeFieldImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_REFERENCE_REF: case XML_TOK_TEXT_BOOKMARK_REF: case XML_TOK_TEXT_NOTE_REF: case XML_TOK_TEXT_SEQUENCE_REF: pContext = new XMLReferenceFieldImportContext( rImport, rHlp, nToken, nPrefix, rName ); break; case XML_TOK_TEXT_SHEET_NAME: pContext = new XMLSheetNameImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_BIBLIOGRAPHY_MARK: pContext = new XMLBibliographyFieldImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_ANNOTATION: case XML_TOK_TEXT_ANNOTATION_END: pContext = new XMLAnnotationImportContext( rImport, rHlp, nToken, nPrefix, rName); break; case XML_TOK_TEXT_SCRIPT: pContext = new XMLScriptImportContext( rImport, rHlp, nPrefix, rName); break; case XML_TOK_TEXT_MEASURE: pContext = new XMLMeasureFieldImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_TABLE_FORMULA: pContext = new XMLTableFormulaImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_TEXT_DROPDOWN: pContext = new XMLDropDownFieldImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_DRAW_HEADER: pContext = new XMLHeaderFieldImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_DRAW_FOOTER: pContext = new XMLFooterFieldImportContext( rImport, rHlp, nPrefix, rName ); break; case XML_TOK_DRAW_DATE_TIME: pContext = new XMLDateTimeFieldImportContext( rImport, rHlp, nPrefix, rName ); break; default: // ignore! May not even be a textfield. // (Reminder: This method is called inside default:-branch) pContext = NULL; break; } return pContext; } void XMLTextFieldImportContext::ForceUpdate( const Reference & rPropertySet) { // force update Reference xUpdate(rPropertySet, UNO_QUERY); if (xUpdate.is()) { xUpdate->update(); } else { DBG_ERROR("Expected XUpdatable support!"); } } // // XMLSenderFieldImportContext // TYPEINIT1( XMLSenderFieldImportContext, XMLTextFieldImportContext); XMLSenderFieldImportContext::XMLSenderFieldImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName, sal_uInt16 nToken) : XMLTextFieldImportContext(rImport, rHlp, sAPI_extended_user,nPrfx, sLocalName) , sPropertyFixed(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed)) , sPropertyFieldSubType(RTL_CONSTASCII_USTRINGPARAM(sAPI_user_data_type)) , sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content)) , bFixed(sal_True) , nElementToken(nToken) { } void XMLSenderFieldImportContext::StartElement( const Reference & xAttrList) { bValid = sal_True; switch (nElementToken) { case XML_TOK_TEXT_SENDER_FIRSTNAME: nSubType = UserDataPart::FIRSTNAME; break; case XML_TOK_TEXT_SENDER_LASTNAME: nSubType = UserDataPart::NAME; break; case XML_TOK_TEXT_SENDER_INITIALS: nSubType = UserDataPart::SHORTCUT; break; case XML_TOK_TEXT_SENDER_TITLE: nSubType = UserDataPart::TITLE; break; case XML_TOK_TEXT_SENDER_POSITION: nSubType = UserDataPart::POSITION; break; case XML_TOK_TEXT_SENDER_EMAIL: nSubType = UserDataPart::EMAIL; break; case XML_TOK_TEXT_SENDER_PHONE_PRIVATE: nSubType = UserDataPart::PHONE_PRIVATE; break; case XML_TOK_TEXT_SENDER_FAX: nSubType = UserDataPart::FAX; break; case XML_TOK_TEXT_SENDER_COMPANY: nSubType = UserDataPart::COMPANY; break; case XML_TOK_TEXT_SENDER_PHONE_WORK: nSubType = UserDataPart::PHONE_COMPANY; break; case XML_TOK_TEXT_SENDER_STREET: nSubType = UserDataPart::STREET; break; case XML_TOK_TEXT_SENDER_CITY: nSubType = UserDataPart::CITY; break; case XML_TOK_TEXT_SENDER_POSTAL_CODE: nSubType = UserDataPart::ZIP; break; case XML_TOK_TEXT_SENDER_COUNTRY: nSubType = UserDataPart::COUNTRY; break; case XML_TOK_TEXT_SENDER_STATE_OR_PROVINCE: nSubType = UserDataPart::STATE; break; default: bValid = sal_False; break; } // process Attributes XMLTextFieldImportContext::StartElement(xAttrList); } void XMLSenderFieldImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue) { if (XML_TOK_TEXTFIELD_FIXED == nAttrToken) { // set bVal sal_Bool bVal; sal_Bool bRet = GetImport().GetMM100UnitConverter(). convertBool(bVal, sAttrValue); // set bFixed if successfull if (bRet) { bFixed = bVal; } } } void XMLSenderFieldImportContext::PrepareField( const Reference & rPropSet) { // set members Any aAny; aAny <<= nSubType; rPropSet->setPropertyValue(sPropertyFieldSubType, aAny); // set fixed aAny.setValue( &bFixed, ::getBooleanCppuType() ); rPropSet->setPropertyValue(sPropertyFixed, aAny); // set content if fixed if (bFixed) { // in organizer or styles-only mode: force update if (GetImport().GetTextImport()->IsOrganizerMode() || GetImport().GetTextImport()->IsStylesOnlyMode() ) { ForceUpdate(rPropSet); } else { aAny <<= GetContent(); rPropSet->setPropertyValue(sPropertyContent, aAny); } } } // // XMLAuthorFieldImportContext // TYPEINIT1( XMLAuthorFieldImportContext, XMLSenderFieldImportContext); XMLAuthorFieldImportContext::XMLAuthorFieldImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName, sal_uInt16 nToken) : XMLSenderFieldImportContext(rImport, rHlp, nPrfx, sLocalName, nToken) , bAuthorFullName(sal_True) , sServiceAuthor(RTL_CONSTASCII_USTRINGPARAM(sAPI_author)) , sPropertyAuthorFullName(RTL_CONSTASCII_USTRINGPARAM(sAPI_full_name)) , sPropertyFixed(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed)) , sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content)) { // overwrite service name from XMLSenderFieldImportContext SetServiceName(sServiceAuthor); } void XMLAuthorFieldImportContext::StartElement( const Reference & xAttrList) { bAuthorFullName = (XML_TOK_TEXT_AUTHOR_INITIALS != nElementToken); bValid = sal_True; // process Attributes XMLTextFieldImportContext::StartElement(xAttrList); } void XMLAuthorFieldImportContext::PrepareField( const Reference & rPropSet) { // set members Any aAny; aAny.setValue( &bAuthorFullName, ::getBooleanCppuType() ); rPropSet->setPropertyValue(sPropertyAuthorFullName, aAny); aAny.setValue( &bFixed, ::getBooleanCppuType() ); rPropSet->setPropertyValue(sPropertyFixed, aAny); // set content if fixed if (bFixed) { // organizer or styles-only mode: force update if (GetImport().GetTextImport()->IsOrganizerMode() || GetImport().GetTextImport()->IsStylesOnlyMode() ) { ForceUpdate(rPropSet); } else { aAny <<= GetContent(); rPropSet->setPropertyValue(sPropertyContent, aAny); } } } // // page continuation string // TYPEINIT1( XMLPageContinuationImportContext, XMLTextFieldImportContext ); static SvXMLEnumMapEntry __READONLY_DATA lcl_aSelectPageAttrMap[] = { { XML_PREVIOUS, PageNumberType_PREV }, { XML_CURRENT, PageNumberType_CURRENT }, { XML_NEXT, PageNumberType_NEXT }, { XML_TOKEN_INVALID, 0 }, }; XMLPageContinuationImportContext::XMLPageContinuationImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLTextFieldImportContext(rImport, rHlp, sAPI_page_number, nPrfx, sLocalName) , sPropertySubType(RTL_CONSTASCII_USTRINGPARAM(sAPI_sub_type)) , sPropertyUserText(RTL_CONSTASCII_USTRINGPARAM(sAPI_user_text)) , sPropertyNumberingType(RTL_CONSTASCII_USTRINGPARAM(sAPI_numbering_type)) , eSelectPage(PageNumberType_CURRENT) , sStringOK(sal_False) { bValid = sal_True; } void XMLPageContinuationImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue ) { switch(nAttrToken) { case XML_TOK_TEXTFIELD_SELECT_PAGE: { sal_uInt16 nTmp; if (SvXMLUnitConverter::convertEnum(nTmp, sAttrValue, lcl_aSelectPageAttrMap) && (PageNumberType_CURRENT != nTmp) ) { eSelectPage = (PageNumberType)nTmp; } break; } case XML_TOK_TEXTFIELD_STRING_VALUE: sString = sAttrValue; sStringOK = sal_True; break; } } void XMLPageContinuationImportContext::PrepareField( const Reference & xPropertySet) { Any aAny; aAny <<= eSelectPage; xPropertySet->setPropertyValue(sPropertySubType, aAny); aAny <<= (sStringOK ? sString : GetContent()); xPropertySet->setPropertyValue(sPropertyUserText, aAny); aAny <<= style::NumberingType::CHAR_SPECIAL; xPropertySet->setPropertyValue(sPropertyNumberingType, aAny); } // // page number field // TYPEINIT1( XMLPageNumberImportContext, XMLTextFieldImportContext ); XMLPageNumberImportContext::XMLPageNumberImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLTextFieldImportContext(rImport, rHlp, sAPI_page_number, nPrfx, sLocalName) , sPropertySubType(RTL_CONSTASCII_USTRINGPARAM(sAPI_sub_type)) , sPropertyNumberingType(RTL_CONSTASCII_USTRINGPARAM(sAPI_numbering_type)) , sPropertyOffset(RTL_CONSTASCII_USTRINGPARAM(sAPI_offset)) , sNumberSync(GetXMLToken(XML_FALSE)) , nPageAdjust(0) , eSelectPage(PageNumberType_CURRENT) , sNumberFormatOK(sal_False) { bValid = sal_True; } void XMLPageNumberImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue ) { switch (nAttrToken) { case XML_TOK_TEXTFIELD_NUM_FORMAT: sNumberFormat = sAttrValue; sNumberFormatOK = sal_True; break; case XML_TOK_TEXTFIELD_NUM_LETTER_SYNC: sNumberSync = sAttrValue; break; case XML_TOK_TEXTFIELD_SELECT_PAGE: { sal_uInt16 nTmp; if (SvXMLUnitConverter::convertEnum(nTmp, sAttrValue, lcl_aSelectPageAttrMap)) { eSelectPage = (PageNumberType)nTmp; } break; } case XML_TOK_TEXTFIELD_PAGE_ADJUST: { sal_Int32 nTmp; if (SvXMLUnitConverter::convertNumber(nTmp, sAttrValue)) { nPageAdjust = (sal_Int16)nTmp; } break; } } } void XMLPageNumberImportContext::PrepareField( const Reference & xPropertySet) { Any aAny; // all properties are optional Reference xPropertySetInfo( xPropertySet->getPropertySetInfo()); if (xPropertySetInfo->hasPropertyByName(sPropertyNumberingType)) { sal_Int16 nNumType; if( sNumberFormatOK ) { nNumType= style::NumberingType::ARABIC; GetImport().GetMM100UnitConverter().convertNumFormat( nNumType, sNumberFormat, sNumberSync ); } else nNumType = style::NumberingType::PAGE_DESCRIPTOR; aAny <<= nNumType; xPropertySet->setPropertyValue(sPropertyNumberingType, aAny); } if (xPropertySetInfo->hasPropertyByName(sPropertyOffset)) { // adjust offset switch (eSelectPage) { case PageNumberType_PREV: nPageAdjust--; break; case PageNumberType_CURRENT: break; case PageNumberType_NEXT: nPageAdjust++; break; default: DBG_WARNING("unknown page number type"); } aAny <<= nPageAdjust; xPropertySet->setPropertyValue(sPropertyOffset, aAny); } if (xPropertySetInfo->hasPropertyByName(sPropertySubType)) { aAny <<= eSelectPage; xPropertySet->setPropertyValue(sPropertySubType, aAny); } } // // Placeholder // TYPEINIT1( XMLPlaceholderFieldImportContext, XMLTextFieldImportContext); XMLPlaceholderFieldImportContext::XMLPlaceholderFieldImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLTextFieldImportContext(rImport, rHlp, sAPI_jump_edit,nPrfx, sLocalName) , sPropertyPlaceholderType(RTL_CONSTASCII_USTRINGPARAM(sAPI_place_holder_type)) , sPropertyPlaceholder(RTL_CONSTASCII_USTRINGPARAM(sAPI_place_holder)) , sPropertyHint(RTL_CONSTASCII_USTRINGPARAM(sAPI_hint)) { } /// process attribute values void XMLPlaceholderFieldImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue ) { switch (nAttrToken) { case XML_TOK_TEXTFIELD_DESCRIPTION: sDescription = sAttrValue; break; case XML_TOK_TEXTFIELD_PLACEHOLDER_TYPE: bValid = sal_True; if (IsXMLToken(sAttrValue, XML_TABLE)) { nPlaceholderType = PlaceholderType::TABLE; } else if (IsXMLToken(sAttrValue, XML_TEXT)) { nPlaceholderType = PlaceholderType::TEXT; } else if (IsXMLToken(sAttrValue, XML_TEXT_BOX)) { nPlaceholderType = PlaceholderType::TEXTFRAME; } else if (IsXMLToken(sAttrValue, XML_IMAGE)) { nPlaceholderType = PlaceholderType::GRAPHIC; } else if (IsXMLToken(sAttrValue, XML_OBJECT)) { nPlaceholderType = PlaceholderType::OBJECT; } else { bValid = sal_False; } break; default: ; // ignore } } void XMLPlaceholderFieldImportContext::PrepareField( const Reference & xPropertySet) { Any aAny; aAny <<= sDescription; xPropertySet->setPropertyValue(sPropertyHint, aAny); // remove <...> around content (if present) OUString aContent = GetContent(); sal_Int32 nStart = 0; sal_Int32 nLength = aContent.getLength(); if ((nLength > 0) && (aContent.getStr()[0] == '<')) { --nLength; ++nStart; } if ((nLength > 0) && (aContent.getStr()[aContent.getLength()-1] == '>')) { --nLength; } aAny <<= aContent.copy(nStart, nLength); xPropertySet->setPropertyValue(sPropertyPlaceholder, aAny); aAny <<= nPlaceholderType; xPropertySet->setPropertyValue(sPropertyPlaceholderType, aAny); } // // time field // TYPEINIT1( XMLTimeFieldImportContext, XMLTextFieldImportContext); XMLTimeFieldImportContext::XMLTimeFieldImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLTextFieldImportContext(rImport, rHlp, sAPI_date_time, nPrfx, sLocalName) , sPropertyNumberFormat(RTL_CONSTASCII_USTRINGPARAM(sAPI_number_format)) , sPropertyFixed(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed)) , sPropertyDateTimeValue(RTL_CONSTASCII_USTRINGPARAM(sAPI_date_time_value)) , sPropertyDateTime(RTL_CONSTASCII_USTRINGPARAM(sAPI_date_time)) , sPropertyAdjust(RTL_CONSTASCII_USTRINGPARAM(sAPI_adjust)) , sPropertyIsDate(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_date)) , sPropertyIsFixedLanguage(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed_language)) , fTimeValue(0.0) , nAdjust(0) , nFormatKey(0) , bTimeOK(sal_False) , bFormatOK(sal_False) , bFixed(sal_False) , bIsDate(sal_False) , bIsDefaultLanguage( sal_True ) { bValid = sal_True; // always valid! } void XMLTimeFieldImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue ) { switch (nAttrToken) { case XML_TOK_TEXTFIELD_TIME_VALUE: { double fTmp; if (GetImport().GetMM100UnitConverter(). convertDateTime(fTmp, sAttrValue)) { fTimeValue = fTmp; bTimeOK = sal_True; } if (GetImport().GetMM100UnitConverter(). convertDateTime(aDateTimeValue, sAttrValue )) { bTimeOK = sal_True; } break; } case XML_TOK_TEXTFIELD_FIXED: { sal_Bool bTmp; if (SvXMLUnitConverter::convertBool(bTmp, sAttrValue)) { bFixed = bTmp; } break; } case XML_TOK_TEXTFIELD_DATA_STYLE_NAME: { sal_Int32 nKey = GetImportHelper().GetDataStyleKey( sAttrValue, &bIsDefaultLanguage); if (-1 != nKey) { nFormatKey = nKey; bFormatOK = sal_True; } break; } case XML_TOK_TEXTFIELD_TIME_ADJUST: { double fTmp; if (SvXMLUnitConverter::convertTime(fTmp, sAttrValue)) { // convert to minutes nAdjust = (sal_Int32)::rtl::math::approxFloor(fTmp * 60 * 24); } break; } } } void XMLTimeFieldImportContext::PrepareField( const Reference & rPropertySet) { Any aAny; // all properties are optional (except IsDate) Reference xPropertySetInfo( rPropertySet->getPropertySetInfo()); if (xPropertySetInfo->hasPropertyByName(sPropertyFixed)) { aAny.setValue( &bFixed, ::getBooleanCppuType() ); rPropertySet->setPropertyValue(sPropertyFixed, aAny); } aAny.setValue( &bIsDate, ::getBooleanCppuType() ); rPropertySet->setPropertyValue(sPropertyIsDate, aAny); if (xPropertySetInfo->hasPropertyByName(sPropertyAdjust)) { aAny <<= nAdjust; rPropertySet->setPropertyValue(sPropertyAdjust, aAny); } // set value if (bFixed) { // organizer or styles-only mode: force update if (GetImport().GetTextImport()->IsOrganizerMode() || GetImport().GetTextImport()->IsStylesOnlyMode() ) { ForceUpdate(rPropertySet); } else { // normal mode: set value (if present) if (bTimeOK) { if (xPropertySetInfo->hasPropertyByName(sPropertyDateTimeValue)) { aAny <<= aDateTimeValue; rPropertySet->setPropertyValue(sPropertyDateTimeValue,aAny); } else if (xPropertySetInfo->hasPropertyByName(sPropertyDateTime)) { aAny <<= aDateTimeValue; rPropertySet->setPropertyValue(sPropertyDateTime, aAny); } } } } if (bFormatOK && xPropertySetInfo->hasPropertyByName(sPropertyNumberFormat)) { aAny <<= nFormatKey; rPropertySet->setPropertyValue(sPropertyNumberFormat, aAny); if( xPropertySetInfo->hasPropertyByName( sPropertyIsFixedLanguage ) ) { sal_Bool bIsFixedLanguage = ! bIsDefaultLanguage; aAny.setValue( &bIsFixedLanguage, ::getBooleanCppuType() ); rPropertySet->setPropertyValue( sPropertyIsFixedLanguage, aAny ); } } } // // date field // TYPEINIT1( XMLDateFieldImportContext, XMLTimeFieldImportContext ); XMLDateFieldImportContext::XMLDateFieldImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLTimeFieldImportContext(rImport, rHlp, nPrfx, sLocalName) { bIsDate = sal_True; // always a date! } void XMLDateFieldImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const ::rtl::OUString& sAttrValue ) { switch (nAttrToken) { case XML_TOK_TEXTFIELD_DATE_VALUE: { double fTmp; if (GetImport().GetMM100UnitConverter(). convertDateTime(fTmp, sAttrValue)) { // #96457#: don't truncate in order to read date+time fTimeValue = fTmp; bTimeOK = sal_True; } if (GetImport().GetMM100UnitConverter(). convertDateTime(aDateTimeValue, sAttrValue )) { bTimeOK = sal_True; } break; } case XML_TOK_TEXTFIELD_DATE_ADJUST: // delegate to superclass, pretending it was a time-adjust attr. XMLTimeFieldImportContext::ProcessAttribute( XML_TOK_TEXTFIELD_TIME_ADJUST, sAttrValue); break; case XML_TOK_TEXTFIELD_TIME_VALUE: case XML_TOK_TEXTFIELD_TIME_ADJUST: ; // ignore time-adjust and time-value attributes break; default: // all others: delegate to super-class XMLTimeFieldImportContext::ProcessAttribute(nAttrToken, sAttrValue); break; } } // // database field superclass // TYPEINIT1( XMLDatabaseFieldImportContext, XMLTextFieldImportContext ); XMLDatabaseFieldImportContext::XMLDatabaseFieldImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, const sal_Char* pServiceName, sal_uInt16 nPrfx, const OUString& sLocalName, bool bUseDisply) : XMLTextFieldImportContext(rImport, rHlp, pServiceName, nPrfx, sLocalName) , sPropertyDataBaseName(RTL_CONSTASCII_USTRINGPARAM(sAPI_data_base_name)) , sPropertyDataBaseURL(RTL_CONSTASCII_USTRINGPARAM(sAPI_data_base_u_r_l)) , sPropertyTableName(RTL_CONSTASCII_USTRINGPARAM(sAPI_data_table_name)) , sPropertyDataCommandType(RTL_CONSTASCII_USTRINGPARAM(sAPI_data_command_type)) , sPropertyIsVisible(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_visible)) , nCommandType( sdb::CommandType::TABLE ) , bCommandTypeOK(sal_False) , bDisplay( sal_True ) , bDisplayOK( false ) , bUseDisplay( bUseDisply ) , bDatabaseOK(sal_False) , bDatabaseNameOK(sal_False) , bDatabaseURLOK(sal_False) , bTableOK(sal_False) { } void XMLDatabaseFieldImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue ) { switch (nAttrToken) { case XML_TOK_TEXTFIELD_DATABASE_NAME: sDatabaseName = sAttrValue; bDatabaseOK = sal_True; bDatabaseNameOK = sal_True; break; case XML_TOK_TEXTFIELD_TABLE_NAME: sTableName = sAttrValue; bTableOK = sal_True; break; case XML_TOK_TEXTFIELD_TABLE_TYPE: if( IsXMLToken( sAttrValue, XML_TABLE ) ) { nCommandType = sdb::CommandType::TABLE; bCommandTypeOK = sal_True; } else if( IsXMLToken( sAttrValue, XML_QUERY ) ) { nCommandType = sdb::CommandType::QUERY; bCommandTypeOK = sal_True; } else if( IsXMLToken( sAttrValue, XML_COMMAND ) ) { nCommandType = sdb::CommandType::COMMAND; bCommandTypeOK = sal_True; } break; case XML_TOK_TEXTFIELD_DISPLAY: if( IsXMLToken( sAttrValue, XML_NONE ) ) { bDisplay = sal_False; bDisplayOK = true; } else if( IsXMLToken( sAttrValue, XML_VALUE ) ) { bDisplay = sal_True; bDisplayOK = true; } break; } } SvXMLImportContext* XMLDatabaseFieldImportContext::CreateChildContext( sal_uInt16 p_nPrefix, const OUString& rLocalName, const Reference& xAttrList ) { if( ( p_nPrefix == XML_NAMESPACE_FORM ) && IsXMLToken( rLocalName, XML_CONNECTION_RESOURCE ) ) { // process attribute list directly sal_Int16 nLength = xAttrList->getLength(); for( sal_Int16 n = 0; n < nLength; n++ ) { OUString sLocalName; sal_uInt16 nPrefix = GetImport().GetNamespaceMap(). GetKeyByAttrName( xAttrList->getNameByIndex(n), &sLocalName ); if( ( nPrefix == XML_NAMESPACE_XLINK ) && IsXMLToken( sLocalName, XML_HREF ) ) { sDatabaseURL = xAttrList->getValueByIndex(n); bDatabaseOK = sal_True; bDatabaseURLOK = sal_True; } } // we call ProcessAttribute in order to set bValid appropriatly ProcessAttribute( XML_TOKEN_INVALID, OUString() ); } return SvXMLImportContext::CreateChildContext(p_nPrefix, rLocalName, xAttrList); } void XMLDatabaseFieldImportContext::PrepareField( const Reference & xPropertySet) { Any aAny; aAny <<= sTableName; xPropertySet->setPropertyValue(sPropertyTableName, aAny); if( bDatabaseNameOK ) { aAny <<= sDatabaseName; xPropertySet->setPropertyValue(sPropertyDataBaseName, aAny); } else if( bDatabaseURLOK ) { aAny <<= sDatabaseURL; xPropertySet->setPropertyValue(sPropertyDataBaseURL, aAny); } // #99980# load/save command type for all fields; also load // old documents without command type if( bCommandTypeOK ) { aAny <<= nCommandType; xPropertySet->setPropertyValue( sPropertyDataCommandType, aAny ); } if( bUseDisplay && bDisplayOK ) { aAny.setValue( &bDisplay, ::getBooleanCppuType() ); xPropertySet->setPropertyValue( sPropertyIsVisible, aAny ); } } // // database name field // TYPEINIT1( XMLDatabaseNameImportContext, XMLDatabaseFieldImportContext ); XMLDatabaseNameImportContext::XMLDatabaseNameImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLDatabaseFieldImportContext(rImport, rHlp, sAPI_database_name, nPrfx, sLocalName, true) { } void XMLDatabaseNameImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue ) { // delegate to superclass and check for success XMLDatabaseFieldImportContext::ProcessAttribute(nAttrToken, sAttrValue); bValid = bDatabaseOK && bTableOK; } // // database next field // TYPEINIT1( XMLDatabaseNextImportContext, XMLDatabaseFieldImportContext ); XMLDatabaseNextImportContext::XMLDatabaseNextImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, const sal_Char* pServiceName, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLDatabaseFieldImportContext(rImport, rHlp, pServiceName, nPrfx, sLocalName, false), sPropertyCondition(RTL_CONSTASCII_USTRINGPARAM(sAPI_condition)), sTrue(RTL_CONSTASCII_USTRINGPARAM(sAPI_true)), sCondition(), bConditionOK(sal_False) { } XMLDatabaseNextImportContext::XMLDatabaseNextImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLDatabaseFieldImportContext(rImport, rHlp, sAPI_database_next, nPrfx, sLocalName, false) , sPropertyCondition(RTL_CONSTASCII_USTRINGPARAM(sAPI_condition)) , sTrue(RTL_CONSTASCII_USTRINGPARAM(sAPI_true)) , bConditionOK(sal_False) { } void XMLDatabaseNextImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue ) { if (XML_TOK_TEXTFIELD_CONDITION == nAttrToken) { OUString sTmp; sal_uInt16 nPrefix = GetImport().GetNamespaceMap()._GetKeyByAttrName( sAttrValue, &sTmp, sal_False ); if( XML_NAMESPACE_OOOW == nPrefix ) { sCondition = sTmp; bConditionOK = sal_True; } else sCondition = sAttrValue; } else { XMLDatabaseFieldImportContext::ProcessAttribute(nAttrToken, sAttrValue); } bValid = bDatabaseOK && bTableOK; } void XMLDatabaseNextImportContext::PrepareField( const Reference & xPropertySet) { Any aAny; aAny <<= bConditionOK ? sCondition : sTrue; xPropertySet->setPropertyValue(sPropertyCondition, aAny); XMLDatabaseFieldImportContext::PrepareField(xPropertySet); } // // database select field // TYPEINIT1( XMLDatabaseSelectImportContext, XMLDatabaseNextImportContext ); XMLDatabaseSelectImportContext::XMLDatabaseSelectImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const ::rtl::OUString& sLocalName) : XMLDatabaseNextImportContext(rImport, rHlp, sAPI_database_select, nPrfx, sLocalName), sPropertySetNumber(RTL_CONSTASCII_USTRINGPARAM(sAPI_set_number)), nNumber(0), bNumberOK(sal_False) { } void XMLDatabaseSelectImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const ::rtl::OUString& sAttrValue ) { if (XML_TOK_TEXTFIELD_ROW_NUMBER == nAttrToken) { sal_Int32 nTmp; if (SvXMLUnitConverter::convertNumber( nTmp, sAttrValue /* , nMin, nMax ??? */ )) { nNumber = nTmp; bNumberOK = sal_True; } } else { XMLDatabaseNextImportContext::ProcessAttribute(nAttrToken, sAttrValue); } bValid = bTableOK && bDatabaseOK && bNumberOK; } void XMLDatabaseSelectImportContext::PrepareField( const Reference & xPropertySet) { Any aAny; aAny <<= nNumber; xPropertySet->setPropertyValue(sPropertySetNumber, aAny); XMLDatabaseNextImportContext::PrepareField(xPropertySet); } // // database display row number field // TYPEINIT1( XMLDatabaseNumberImportContext, XMLDatabaseFieldImportContext ); XMLDatabaseNumberImportContext::XMLDatabaseNumberImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLDatabaseFieldImportContext(rImport, rHlp, sAPI_database_number, nPrfx, sLocalName, true), sPropertyNumberingType( RTL_CONSTASCII_USTRINGPARAM(sAPI_numbering_type)), sPropertySetNumber(RTL_CONSTASCII_USTRINGPARAM(sAPI_set_number)), sNumberFormat(RTL_CONSTASCII_USTRINGPARAM("1")), sNumberSync(GetXMLToken(XML_FALSE)), nValue(0), bValueOK(sal_False) { } void XMLDatabaseNumberImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue ) { switch (nAttrToken) { case XML_TOK_TEXTFIELD_NUM_FORMAT: sNumberFormat = sAttrValue; break; case XML_TOK_TEXTFIELD_NUM_LETTER_SYNC: sNumberSync = sAttrValue; break; case XML_TOK_TEXTFIELD_VALUE: { sal_Int32 nTmp; if (SvXMLUnitConverter::convertNumber( nTmp, sAttrValue )) { nValue = nTmp; bValueOK = sal_True; } break; } default: XMLDatabaseFieldImportContext::ProcessAttribute(nAttrToken, sAttrValue); break; } bValid = bTableOK && bDatabaseOK; } void XMLDatabaseNumberImportContext::PrepareField( const Reference & xPropertySet) { Any aAny; sal_Int16 nNumType = style::NumberingType::ARABIC; GetImport().GetMM100UnitConverter().convertNumFormat( nNumType, sNumberFormat, sNumberSync ); aAny <<= nNumType; xPropertySet->setPropertyValue(sPropertyNumberingType, aAny); if (bValueOK) { aAny <<= nValue; xPropertySet->setPropertyValue(sPropertySetNumber, aAny); } XMLDatabaseFieldImportContext::PrepareField(xPropertySet); } // // Simple doc info fields // TYPEINIT1( XMLSimpleDocInfoImportContext, XMLTextFieldImportContext ); XMLSimpleDocInfoImportContext::XMLSimpleDocInfoImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName, sal_uInt16 nToken, sal_Bool bContent, sal_Bool bAuthor) : XMLTextFieldImportContext(rImport, rHlp, MapTokenToServiceName(nToken),nPrfx, sLocalName) , sPropertyFixed(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed)) , sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content)) , sPropertyAuthor(RTL_CONSTASCII_USTRINGPARAM(sAPI_author)) , sPropertyCurrentPresentation(RTL_CONSTASCII_USTRINGPARAM(sAPI_current_presentation)) , bFixed(sal_False) , bHasAuthor(bAuthor) , bHasContent(bContent) { bValid = sal_True; } void XMLSimpleDocInfoImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue ) { if (XML_TOK_TEXTFIELD_FIXED == nAttrToken) { sal_Bool bTmp; if (SvXMLUnitConverter::convertBool(bTmp, sAttrValue)) { bFixed = bTmp; } } } void XMLSimpleDocInfoImportContext::PrepareField( const Reference & rPropertySet) { // title field in Calc has no Fixed property Reference xPropertySetInfo(rPropertySet->getPropertySetInfo()); if (xPropertySetInfo->hasPropertyByName(sPropertyFixed)) { Any aAny; aAny.setValue(&bFixed, ::getBooleanCppuType() ); rPropertySet->setPropertyValue(sPropertyFixed, aAny); // set Content and CurrentPresentation (if fixed) if (bFixed) { // in organizer-mode or styles-only-mode, only force update if (GetImport().GetTextImport()->IsOrganizerMode() || GetImport().GetTextImport()->IsStylesOnlyMode() ) { ForceUpdate(rPropertySet); } else { // set content (author, if that's the name) and current // presentation aAny <<= GetContent(); if (bFixed && bHasAuthor) { rPropertySet->setPropertyValue(sPropertyAuthor, aAny); } if (bFixed && bHasContent) { rPropertySet->setPropertyValue(sPropertyContent, aAny); } rPropertySet->setPropertyValue(sPropertyCurrentPresentation, aAny); } } } } const sal_Char* XMLSimpleDocInfoImportContext::MapTokenToServiceName( sal_uInt16 nToken) { const sal_Char* pServiceName = NULL; switch(nToken) { case XML_TOK_TEXT_DOCUMENT_CREATION_AUTHOR: pServiceName = sAPI_docinfo_create_author; break; case XML_TOK_TEXT_DOCUMENT_CREATION_DATE: pServiceName = sAPI_docinfo_create_date_time; break; case XML_TOK_TEXT_DOCUMENT_CREATION_TIME: pServiceName = sAPI_docinfo_create_date_time; break; case XML_TOK_TEXT_DOCUMENT_DESCRIPTION: pServiceName = sAPI_docinfo_description; break; case XML_TOK_TEXT_DOCUMENT_EDIT_DURATION: pServiceName = sAPI_docinfo_edit_time; break; case XML_TOK_TEXT_DOCUMENT_USER_DEFINED: pServiceName = sAPI_docinfo_custom; break; case XML_TOK_TEXT_DOCUMENT_PRINT_AUTHOR: pServiceName = sAPI_docinfo_print_author; break; case XML_TOK_TEXT_DOCUMENT_PRINT_DATE: pServiceName = sAPI_docinfo_print_date_time; break; case XML_TOK_TEXT_DOCUMENT_PRINT_TIME: pServiceName = sAPI_docinfo_print_date_time; break; case XML_TOK_TEXT_DOCUMENT_KEYWORDS: pServiceName = sAPI_docinfo_keywords; break; case XML_TOK_TEXT_DOCUMENT_SUBJECT: pServiceName = sAPI_docinfo_subject; break; case XML_TOK_TEXT_DOCUMENT_REVISION: pServiceName = sAPI_docinfo_revision; break; case XML_TOK_TEXT_DOCUMENT_SAVE_AUTHOR: pServiceName = sAPI_docinfo_change_author; break; case XML_TOK_TEXT_DOCUMENT_SAVE_DATE: pServiceName = sAPI_docinfo_change_date_time; break; case XML_TOK_TEXT_DOCUMENT_SAVE_TIME: pServiceName = sAPI_docinfo_change_date_time; break; case XML_TOK_TEXT_DOCUMENT_TITLE: pServiceName = sAPI_docinfo_title; break; default: DBG_ERROR("no docinfo field token"); pServiceName = NULL; break; } return pServiceName; } // // revision field // TYPEINIT1( XMLRevisionDocInfoImportContext, XMLSimpleDocInfoImportContext ); XMLRevisionDocInfoImportContext::XMLRevisionDocInfoImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName, sal_uInt16 nToken) : XMLSimpleDocInfoImportContext(rImport, rHlp, nPrfx, sLocalName, nToken, sal_False, sal_False), sPropertyRevision(RTL_CONSTASCII_USTRINGPARAM(sAPI_revision)) { bValid = sal_True; } void XMLRevisionDocInfoImportContext::PrepareField( const Reference & rPropertySet) { XMLSimpleDocInfoImportContext::PrepareField(rPropertySet); // set revision number // if fixed, if not in organizer-mode, if not in styles-only-mode if (bFixed) { if ( GetImport().GetTextImport()->IsOrganizerMode() || GetImport().GetTextImport()->IsStylesOnlyMode() ) { ForceUpdate(rPropertySet); } else { sal_Int32 nTmp; if (SvXMLUnitConverter::convertNumber(nTmp, GetContent())) { Any aAny; aAny <<= nTmp; rPropertySet->setPropertyValue(sPropertyRevision, aAny); } } } } // // DocInfo fields with date/time attributes // TYPEINIT1( XMLDateTimeDocInfoImportContext, XMLSimpleDocInfoImportContext ); XMLDateTimeDocInfoImportContext::XMLDateTimeDocInfoImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName, sal_uInt16 nToken) : XMLSimpleDocInfoImportContext(rImport, rHlp, nPrfx, sLocalName,nToken, sal_False, sal_False) , sPropertyNumberFormat(RTL_CONSTASCII_USTRINGPARAM(sAPI_number_format)) , sPropertyIsDate(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_date)) , sPropertyIsFixedLanguage(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed_language)) , nFormat(0) , bFormatOK(sal_False) , bIsDefaultLanguage(sal_True) { // we allow processing of EDIT_DURATION here, because import of actual // is not supported anyway. If it was, we'd need an extra import class // because times and time durations are presented differently! bValid = sal_True; switch (nToken) { case XML_TOK_TEXT_DOCUMENT_CREATION_DATE: case XML_TOK_TEXT_DOCUMENT_PRINT_DATE: case XML_TOK_TEXT_DOCUMENT_SAVE_DATE: bIsDate = sal_True; bHasDateTime = sal_True; break; case XML_TOK_TEXT_DOCUMENT_CREATION_TIME: case XML_TOK_TEXT_DOCUMENT_PRINT_TIME: case XML_TOK_TEXT_DOCUMENT_SAVE_TIME: bIsDate = sal_False; bHasDateTime = sal_True; break; case XML_TOK_TEXT_DOCUMENT_EDIT_DURATION: bIsDate = sal_False; bHasDateTime = sal_False; break; default: DBG_ERROR( "XMLDateTimeDocInfoImportContext needs date/time doc. fields"); bValid = sal_False; break; } } void XMLDateTimeDocInfoImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue ) { switch (nAttrToken) { case XML_TOK_TEXTFIELD_DATA_STYLE_NAME: { sal_Int32 nKey = GetImportHelper().GetDataStyleKey( sAttrValue, &bIsDefaultLanguage); if (-1 != nKey) { nFormat = nKey; bFormatOK = sal_True; } break; } case XML_TOK_TEXTFIELD_FIXED: XMLSimpleDocInfoImportContext::ProcessAttribute(nAttrToken, sAttrValue); break; default: // ignore -> we can't set date/time value anyway! break; } } void XMLDateTimeDocInfoImportContext::PrepareField( const Reference & xPropertySet) { // process fixed and presentation XMLSimpleDocInfoImportContext::PrepareField(xPropertySet); Any aAny; if (bHasDateTime) { aAny.setValue( &bIsDate, ::getBooleanCppuType()); xPropertySet->setPropertyValue(sPropertyIsDate, aAny); } if (bFormatOK) { aAny <<= nFormat; xPropertySet->setPropertyValue(sPropertyNumberFormat, aAny); if( xPropertySet->getPropertySetInfo()-> hasPropertyByName( sPropertyIsFixedLanguage ) ) { sal_Bool bIsFixedLanguage = ! bIsDefaultLanguage; aAny.setValue( &bIsFixedLanguage, ::getBooleanCppuType() ); xPropertySet->setPropertyValue( sPropertyIsFixedLanguage, aAny ); } } // can't set date/time/duration value! Sorry. } // // user defined docinfo fields // TYPEINIT1( XMLUserDocInfoImportContext, XMLSimpleDocInfoImportContext ); XMLUserDocInfoImportContext::XMLUserDocInfoImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName, sal_uInt16 nToken) : XMLSimpleDocInfoImportContext(rImport, rHlp, nPrfx, sLocalName, nToken, sal_False, sal_False) , sPropertyName(RTL_CONSTASCII_USTRINGPARAM(sAPI_name)) , sPropertyNumberFormat(RTL_CONSTASCII_USTRINGPARAM(sAPI_number_format)) , sPropertyIsFixedLanguage(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed_language)) , nFormat(0) , bFormatOK(sal_False) , bIsDefaultLanguage( sal_True ) { bValid = sal_False; } void XMLUserDocInfoImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue ) { switch (nAttrToken) { case XML_TOK_TEXTFIELD_DATA_STYLE_NAME: { sal_Int32 nKey = GetImportHelper().GetDataStyleKey( sAttrValue, &bIsDefaultLanguage); if (-1 != nKey) { nFormat = nKey; bFormatOK = sal_True; } break; } case XML_TOK_TEXTFIELD_NAME: { if (!bValid) { SetServiceName(OUString::createFromAscii( sAPI_docinfo_custom ) ); aName = sAttrValue; bValid = sal_True; } break; } default: XMLSimpleDocInfoImportContext::ProcessAttribute(nAttrToken, sAttrValue); break; } } void XMLUserDocInfoImportContext::PrepareField( const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet> & xPropertySet) { uno::Any aAny; if ( aName.getLength() ) { aAny <<= aName; xPropertySet->setPropertyValue(sPropertyName, aAny); } Reference xPropertySetInfo( xPropertySet->getPropertySetInfo()); if (bFormatOK && xPropertySetInfo->hasPropertyByName(sPropertyNumberFormat)) { aAny <<= nFormat; xPropertySet->setPropertyValue(sPropertyNumberFormat, aAny); if( xPropertySetInfo->hasPropertyByName( sPropertyIsFixedLanguage ) ) { sal_Bool bIsFixedLanguage = ! bIsDefaultLanguage; aAny.setValue( &bIsFixedLanguage, ::getBooleanCppuType() ); xPropertySet->setPropertyValue( sPropertyIsFixedLanguage, aAny ); } } // call superclass to handle "fixed" XMLSimpleDocInfoImportContext::PrepareField(xPropertySet); } // // import hidden paragraph fields // TYPEINIT1( XMLHiddenParagraphImportContext, XMLTextFieldImportContext ); XMLHiddenParagraphImportContext::XMLHiddenParagraphImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLTextFieldImportContext(rImport, rHlp, sAPI_hidden_paragraph, nPrfx, sLocalName), sPropertyCondition(RTL_CONSTASCII_USTRINGPARAM(sAPI_condition)), sPropertyIsHidden(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_hidden)), sCondition(), bIsHidden(sal_False) { } void XMLHiddenParagraphImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue ) { if (XML_TOK_TEXTFIELD_CONDITION == nAttrToken) { OUString sTmp; sal_uInt16 nPrefix = GetImport().GetNamespaceMap()._GetKeyByAttrName( sAttrValue, &sTmp, sal_False ); if( XML_NAMESPACE_OOOW == nPrefix ) { sCondition = sTmp; bValid = sal_True; } else sCondition = sAttrValue; } else if (XML_TOK_TEXTFIELD_IS_HIDDEN == nAttrToken) { sal_Bool bTmp; if (SvXMLUnitConverter::convertBool(bTmp, sAttrValue)) { bIsHidden = bTmp; } } } void XMLHiddenParagraphImportContext::PrepareField( const Reference & xPropertySet) { Any aAny; aAny <<= sCondition; xPropertySet->setPropertyValue(sPropertyCondition, aAny); aAny.setValue( &bIsHidden, ::getBooleanCppuType() ); xPropertySet->setPropertyValue(sPropertyIsHidden, aAny); } // // import conditional text () // TYPEINIT1( XMLConditionalTextImportContext, XMLTextFieldImportContext ); XMLConditionalTextImportContext::XMLConditionalTextImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLTextFieldImportContext(rImport, rHlp, sAPI_conditional_text, nPrfx, sLocalName), sPropertyCondition(RTL_CONSTASCII_USTRINGPARAM(sAPI_condition)), sPropertyTrueContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_true_content)), sPropertyFalseContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_false_content)), sPropertyIsConditionTrue(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_condition_true)), sPropertyCurrentPresentation(RTL_CONSTASCII_USTRINGPARAM(sAPI_current_presentation)), bConditionOK(sal_False), bTrueOK(sal_False), bFalseOK(sal_False), bCurrentValue(sal_False) { } void XMLConditionalTextImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue ) { switch (nAttrToken) { case XML_TOK_TEXTFIELD_CONDITION: { OUString sTmp; sal_uInt16 nPrefix = GetImport().GetNamespaceMap(). _GetKeyByAttrName( sAttrValue, &sTmp, sal_False ); if( XML_NAMESPACE_OOOW == nPrefix ) { sCondition = sTmp; bConditionOK = sal_True; } else sCondition = sAttrValue; } break; case XML_TOK_TEXTFIELD_STRING_VALUE_IF_FALSE: sFalseContent = sAttrValue; bFalseOK = sal_True; break; case XML_TOK_TEXTFIELD_STRING_VALUE_IF_TRUE: sTrueContent = sAttrValue; bTrueOK = sal_True; break; case XML_TOK_TEXTFIELD_CURRENT_VALUE: { sal_Bool bTmp; if (SvXMLUnitConverter::convertBool(bTmp, sAttrValue)) { bCurrentValue = bTmp; } break; } } bValid = bConditionOK && bFalseOK && bTrueOK; } void XMLConditionalTextImportContext::PrepareField( const Reference & xPropertySet) { Any aAny; aAny <<= sCondition; xPropertySet->setPropertyValue(sPropertyCondition, aAny); aAny <<= sFalseContent; xPropertySet->setPropertyValue(sPropertyFalseContent, aAny); aAny <<= sTrueContent; xPropertySet->setPropertyValue(sPropertyTrueContent, aAny); aAny.setValue( &bCurrentValue, ::getBooleanCppuType() ); xPropertySet->setPropertyValue(sPropertyIsConditionTrue, aAny); aAny <<= GetContent(); xPropertySet->setPropertyValue(sPropertyCurrentPresentation, aAny); } // // hidden text // TYPEINIT1( XMLHiddenTextImportContext, XMLTextFieldImportContext); XMLHiddenTextImportContext::XMLHiddenTextImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLTextFieldImportContext(rImport, rHlp, sAPI_hidden_text, nPrfx, sLocalName), sPropertyCondition(RTL_CONSTASCII_USTRINGPARAM(sAPI_condition)), sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content)), sPropertyIsHidden(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_hidden)), bConditionOK(sal_False), bStringOK(sal_False), bIsHidden(sal_False) { } void XMLHiddenTextImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue ) { switch (nAttrToken) { case XML_TOK_TEXTFIELD_CONDITION: { OUString sTmp; sal_uInt16 nPrefix = GetImport().GetNamespaceMap(). _GetKeyByAttrName( sAttrValue, &sTmp, sal_False ); if( XML_NAMESPACE_OOOW == nPrefix ) { sCondition = sTmp; bConditionOK = sal_True; } else sCondition = sAttrValue; } break; case XML_TOK_TEXTFIELD_STRING_VALUE: sString = sAttrValue; bStringOK = sal_True; break; case XML_TOK_TEXTFIELD_IS_HIDDEN: { sal_Bool bTmp; if (SvXMLUnitConverter::convertBool(bTmp, sAttrValue)) { bIsHidden = bTmp; } break; } } bValid = bConditionOK && bStringOK; } void XMLHiddenTextImportContext::PrepareField( const Reference & xPropertySet) { Any aAny; aAny <<= sCondition; xPropertySet->setPropertyValue(sPropertyCondition, aAny); aAny <<= sString; xPropertySet->setPropertyValue(sPropertyContent, aAny); aAny.setValue( &bIsHidden, ::getBooleanCppuType() ); xPropertySet->setPropertyValue(sPropertyIsHidden, aAny); } // // file name fields // TYPEINIT1( XMLFileNameImportContext, XMLTextFieldImportContext ); static const SvXMLEnumMapEntry aFilenameDisplayMap[] = { { XML_PATH, FilenameDisplayFormat::PATH }, { XML_NAME, FilenameDisplayFormat::NAME }, { XML_NAME_AND_EXTENSION, FilenameDisplayFormat::NAME_AND_EXT }, { XML_FULL, FilenameDisplayFormat::FULL }, { XML_TOKEN_INVALID, 0 } }; XMLFileNameImportContext::XMLFileNameImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLTextFieldImportContext(rImport, rHlp, sAPI_file_name, nPrfx, sLocalName), sPropertyFixed(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed)), sPropertyFileFormat(RTL_CONSTASCII_USTRINGPARAM(sAPI_file_format)), sPropertyCurrentPresentation( RTL_CONSTASCII_USTRINGPARAM(sAPI_current_presentation)), nFormat(FilenameDisplayFormat::FULL), bFixed(sal_False) { bValid = sal_True; } void XMLFileNameImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const ::rtl::OUString& sAttrValue ) { switch (nAttrToken) { case XML_TOK_TEXTFIELD_FIXED: { sal_Bool bTmp; if (SvXMLUnitConverter::convertBool(bTmp, sAttrValue)) { bFixed = bTmp; } break; } case XML_TOK_TEXTFIELD_DISPLAY: { sal_uInt16 nTmp; if (SvXMLUnitConverter::convertEnum(nTmp, sAttrValue, aFilenameDisplayMap)) { nFormat = (sal_uInt16)nTmp; } break; } default: ; // unkown attribute: ignore break; } } void XMLFileNameImportContext::PrepareField( const Reference & xPropertySet) { Any aAny; // properties are optional Reference xPropertySetInfo( xPropertySet->getPropertySetInfo()); if (xPropertySetInfo->hasPropertyByName(sPropertyFixed)) { aAny <<= bFixed; xPropertySet->setPropertyValue(sPropertyFixed, aAny); } if (xPropertySetInfo->hasPropertyByName(sPropertyFileFormat)) { aAny <<= nFormat; xPropertySet->setPropertyValue(sPropertyFileFormat, aAny); } if (xPropertySetInfo->hasPropertyByName(sPropertyCurrentPresentation)) { aAny <<= GetContent(); xPropertySet->setPropertyValue(sPropertyCurrentPresentation, aAny); } } // // template name field // static const SvXMLEnumMapEntry aTemplateDisplayMap[] = { { XML_FULL, TemplateDisplayFormat::FULL }, { XML_PATH, TemplateDisplayFormat::PATH }, { XML_NAME, TemplateDisplayFormat::NAME }, { XML_NAME_AND_EXTENSION, TemplateDisplayFormat::NAME_AND_EXT }, { XML_AREA, TemplateDisplayFormat::AREA }, { XML_TITLE, TemplateDisplayFormat::TITLE }, { XML_TOKEN_INVALID, 0 } }; TYPEINIT1( XMLTemplateNameImportContext, XMLTextFieldImportContext ); XMLTemplateNameImportContext::XMLTemplateNameImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLTextFieldImportContext(rImport, rHlp, sAPI_template_name, nPrfx, sLocalName), sPropertyFileFormat(RTL_CONSTASCII_USTRINGPARAM(sAPI_file_format)), nFormat(TemplateDisplayFormat::FULL) { bValid = sal_True; } void XMLTemplateNameImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue ) { switch (nAttrToken) { case XML_TOK_TEXTFIELD_DISPLAY: { sal_uInt16 nTmp; if (SvXMLUnitConverter::convertEnum(nTmp, sAttrValue, aTemplateDisplayMap)) { nFormat = (sal_uInt16)nTmp; } break; } default: ; // unknown attribute: ignore break; } } void XMLTemplateNameImportContext::PrepareField( const Reference & xPropertySet) { Any aAny; aAny <<= nFormat; xPropertySet->setPropertyValue(sPropertyFileFormat, aAny); } // // import chapter fields // TYPEINIT1( XMLChapterImportContext, XMLTextFieldImportContext ); static const SvXMLEnumMapEntry aChapterDisplayMap[] = { { XML_NAME, ChapterFormat::NAME }, { XML_NUMBER, ChapterFormat::NUMBER }, { XML_NUMBER_AND_NAME, ChapterFormat::NAME_NUMBER }, { XML_PLAIN_NUMBER_AND_NAME, ChapterFormat::NO_PREFIX_SUFFIX }, { XML_PLAIN_NUMBER, ChapterFormat::DIGIT }, { XML_TOKEN_INVALID, 0 } }; XMLChapterImportContext::XMLChapterImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLTextFieldImportContext(rImport, rHlp, sAPI_chapter, nPrfx, sLocalName), sPropertyChapterFormat( RTL_CONSTASCII_USTRINGPARAM(sAPI_chapter_format)), sPropertyLevel(RTL_CONSTASCII_USTRINGPARAM(sAPI_level)), nFormat(ChapterFormat::NAME_NUMBER), nLevel(0) { bValid = sal_True; } void XMLChapterImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue ) { switch (nAttrToken) { case XML_TOK_TEXTFIELD_DISPLAY: { sal_uInt16 nTmp; if (SvXMLUnitConverter::convertEnum(nTmp, sAttrValue, aChapterDisplayMap)) { nFormat = (sal_Int16)nTmp; } break; } case XML_TOK_TEXTFIELD_OUTLINE_LEVEL: { sal_Int32 nTmp; if (SvXMLUnitConverter::convertNumber( nTmp, sAttrValue, 1, GetImport().GetTextImport()->GetChapterNumbering()->getCount() )) { // API numbers 0..9, we number 1..10 nLevel = (sal_Int8)nTmp; nLevel--; } break; } default: ; // unknown attribute: ignore break; } } void XMLChapterImportContext::PrepareField( const Reference & xPropertySet) { Any aAny; aAny <<= nFormat; xPropertySet->setPropertyValue(sPropertyChapterFormat, aAny); aAny <<= nLevel; xPropertySet->setPropertyValue(sPropertyLevel, aAny); } // // counting fields // TYPEINIT1( XMLCountFieldImportContext, XMLTextFieldImportContext ); XMLCountFieldImportContext::XMLCountFieldImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName, sal_uInt16 nToken) : XMLTextFieldImportContext(rImport, rHlp, MapTokenToServiceName(nToken), nPrfx, sLocalName), sPropertyNumberingType( RTL_CONSTASCII_USTRINGPARAM(sAPI_numbering_type)), sNumberFormat(), sLetterSync(), bNumberFormatOK(sal_False) { bValid = sal_True; } void XMLCountFieldImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue ) { switch (nAttrToken) { case XML_TOK_TEXTFIELD_NUM_FORMAT: sNumberFormat = sAttrValue; bNumberFormatOK = sal_True; break; case XML_TOK_TEXTFIELD_NUM_LETTER_SYNC: sLetterSync = sAttrValue; break; } } void XMLCountFieldImportContext::PrepareField( const Reference & xPropertySet) { Any aAny; // properties optional // (only page count, but do for all to save common implementation) if (xPropertySet->getPropertySetInfo()-> hasPropertyByName(sPropertyNumberingType)) { sal_Int16 nNumType; if( bNumberFormatOK ) { nNumType= style::NumberingType::ARABIC; GetImport().GetMM100UnitConverter().convertNumFormat( nNumType, sNumberFormat, sLetterSync ); } else nNumType = style::NumberingType::PAGE_DESCRIPTOR; aAny <<= nNumType; xPropertySet->setPropertyValue(sPropertyNumberingType, aAny); } } const sal_Char* XMLCountFieldImportContext::MapTokenToServiceName( sal_uInt16 nToken) { const sal_Char* pServiceName = NULL; switch (nToken) { case XML_TOK_TEXT_WORD_COUNT: pServiceName = sAPI_word_count; break; case XML_TOK_TEXT_PARAGRAPH_COUNT: pServiceName = sAPI_paragraph_count; break; case XML_TOK_TEXT_TABLE_COUNT: pServiceName = sAPI_table_count; break; case XML_TOK_TEXT_CHARACTER_COUNT: pServiceName = sAPI_character_count; break; case XML_TOK_TEXT_IMAGE_COUNT: pServiceName = sAPI_graphic_object_count; break; case XML_TOK_TEXT_OBJECT_COUNT: pServiceName = sAPI_embedded_object_count; break; case XML_TOK_TEXT_PAGE_COUNT: pServiceName = sAPI_page_count; break; default: pServiceName = NULL; DBG_ERROR("unknown count field!"); break; } return pServiceName; } // // page variable import // TYPEINIT1( XMLPageVarGetFieldImportContext, XMLTextFieldImportContext ); XMLPageVarGetFieldImportContext::XMLPageVarGetFieldImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLTextFieldImportContext(rImport, rHlp, sAPI_reference_page_get, nPrfx, sLocalName), sPropertyNumberingType( RTL_CONSTASCII_USTRINGPARAM(sAPI_numbering_type)), sNumberFormat(), sLetterSync(), bNumberFormatOK(sal_False) { bValid = sal_True; } void XMLPageVarGetFieldImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue ) { switch (nAttrToken) { case XML_TOK_TEXTFIELD_NUM_FORMAT: sNumberFormat = sAttrValue; bNumberFormatOK = sal_True; break; case XML_TOK_TEXTFIELD_NUM_LETTER_SYNC: sLetterSync = sAttrValue; break; } } void XMLPageVarGetFieldImportContext::PrepareField( const Reference & xPropertySet) { Any aAny; sal_Int16 nNumType; if( bNumberFormatOK ) { nNumType= style::NumberingType::ARABIC; GetImport().GetMM100UnitConverter().convertNumFormat( nNumType, sNumberFormat, sLetterSync ); } else nNumType = style::NumberingType::PAGE_DESCRIPTOR; aAny <<= nNumType; xPropertySet->setPropertyValue(sPropertyNumberingType, aAny); // display old content (#96657#) aAny <<= GetContent(); xPropertySet->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM(sAPI_current_presentation)), aAny ); } // // page variable set fields // TYPEINIT1(XMLPageVarSetFieldImportContext, XMLTextFieldImportContext); XMLPageVarSetFieldImportContext::XMLPageVarSetFieldImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLTextFieldImportContext(rImport, rHlp, sAPI_reference_page_set, nPrfx, sLocalName), sPropertyOn(RTL_CONSTASCII_USTRINGPARAM(sAPI_on)), sPropertyOffset(RTL_CONSTASCII_USTRINGPARAM(sAPI_offset)), nAdjust(0), bActive(sal_True) { bValid = sal_True; } void XMLPageVarSetFieldImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const ::rtl::OUString& sAttrValue ) { switch (nAttrToken) { case XML_TOK_TEXTFIELD_ACTIVE: { sal_Bool bTmp; if (SvXMLUnitConverter::convertBool(bTmp, sAttrValue)) { bActive = bTmp; } } case XML_TOK_TEXTFIELD_PAGE_ADJUST: { sal_Int32 nTmp; if (SvXMLUnitConverter::convertNumber(nTmp, sAttrValue)) { nAdjust = (sal_Int16)nTmp; } } } } void XMLPageVarSetFieldImportContext::PrepareField( const Reference & xPropertySet) { Any aAny; aAny.setValue(&bActive, ::getBooleanCppuType()); xPropertySet->setPropertyValue(sPropertyOn, aAny); aAny <<= nAdjust; xPropertySet->setPropertyValue(sPropertyOffset, aAny); } // // macro fields // TYPEINIT1( XMLMacroFieldImportContext, XMLTextFieldImportContext ); XMLMacroFieldImportContext::XMLMacroFieldImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLTextFieldImportContext(rImport, rHlp, sAPI_macro, nPrfx, sLocalName), sPropertyHint(RTL_CONSTASCII_USTRINGPARAM(sAPI_hint)), sPropertyMacroName(RTL_CONSTASCII_USTRINGPARAM("MacroName")), sPropertyScriptURL(RTL_CONSTASCII_USTRINGPARAM("ScriptURL")), bDescriptionOK(sal_False) { } SvXMLImportContext* XMLMacroFieldImportContext::CreateChildContext( sal_uInt16 nPrefix, const OUString& rLocalName, const Reference & xAttrList ) { SvXMLImportContext* pContext = NULL; if ( (nPrefix == XML_NAMESPACE_OFFICE) && IsXMLToken( rLocalName, XML_EVENT_LISTENERS ) ) { // create events context and remember it! pContext = new XMLEventsImportContext( GetImport(), nPrefix, rLocalName ); xEventContext = pContext; bValid = sal_True; } else pContext = SvXMLImportContext::CreateChildContext( nPrefix, rLocalName, xAttrList); return pContext; } void XMLMacroFieldImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue ) { switch (nAttrToken) { case XML_TOK_TEXTFIELD_DESCRIPTION: sDescription = sAttrValue; bDescriptionOK = sal_True; break; case XML_TOK_TEXTFIELD_NAME: sMacro = sAttrValue; bValid = sal_True; break; } } void XMLMacroFieldImportContext::PrepareField( const Reference & xPropertySet) { Any aAny; OUString sOnClick(RTL_CONSTASCII_USTRINGPARAM("OnClick")); OUString sPropertyMacroLibrary(RTL_CONSTASCII_USTRINGPARAM("MacroLibrary")); aAny <<= (bDescriptionOK ? sDescription : GetContent()); xPropertySet->setPropertyValue(sPropertyHint, aAny); // if we have an events child element, we'll look for the OnClick // event if not, it may be an old (pre-638i) document. Then, we'll // have to look at the name attribute. OUString sMacroName; OUString sLibraryName; OUString sScriptURL; if ( xEventContext.Is() ) { // get event sequence XMLEventsImportContext* pEvents = (XMLEventsImportContext*)&xEventContext; Sequence aValues; pEvents->GetEventSequence( sOnClick, aValues ); sal_Int32 nLength = aValues.getLength(); for( sal_Int32 i = 0; i < nLength; i++ ) { if ( aValues[i].Name.equalsAsciiL( "ScriptType", sizeof("ScriptType")-1 ) ) { // ignore ScriptType } else if ( aValues[i].Name.equalsAsciiL( "Library", sizeof("Library")-1 ) ) { aValues[i].Value >>= sLibraryName; } else if ( aValues[i].Name.equalsAsciiL( "MacroName", sizeof("MacroName")-1 ) ) { aValues[i].Value >>= sMacroName; } if ( aValues[i].Name.equalsAsciiL( "Script", sizeof("Script")-1 ) ) { aValues[i].Value >>= sScriptURL; } } } else { // disassemble old-style macro-name: Everything before the // third-last dot is the library sal_Int32 nPos = sMacro.getLength() + 1; // the loop starts with nPos-- const sal_Unicode* pBuf = sMacro.getStr(); for( sal_Int32 i = 0; (i < 3) && (nPos > 0); i++ ) { nPos--; while ( (pBuf[nPos] != '.') && (nPos > 0) ) nPos--; } if (nPos > 0) { sLibraryName = sMacro.copy(0, nPos); sMacroName = sMacro.copy(nPos+1); } else sMacroName = sMacro; } aAny <<= sScriptURL; xPropertySet->setPropertyValue(sPropertyScriptURL, aAny); aAny <<= sMacroName; xPropertySet->setPropertyValue(sPropertyMacroName, aAny); aAny <<= sLibraryName; xPropertySet->setPropertyValue(sPropertyMacroLibrary, aAny); } // // reference field import // TYPEINIT1( XMLReferenceFieldImportContext, XMLTextFieldImportContext ); XMLReferenceFieldImportContext::XMLReferenceFieldImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nToken, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLTextFieldImportContext(rImport, rHlp, sAPI_get_reference, nPrfx, sLocalName) , sPropertyReferenceFieldPart(RTL_CONSTASCII_USTRINGPARAM(sAPI_reference_field_part)) , sPropertyReferenceFieldSource(RTL_CONSTASCII_USTRINGPARAM(sAPI_reference_field_source)) , sPropertySourceName(RTL_CONSTASCII_USTRINGPARAM(sAPI_source_name)) , sPropertyCurrentPresentation(RTL_CONSTASCII_USTRINGPARAM(sAPI_current_presentation)) , nElementToken(nToken) , nType(ReferenceFieldPart::PAGE_DESC) , bNameOK(sal_False) , bTypeOK(sal_False) , bSeqNumberOK(sal_False) { } static SvXMLEnumMapEntry __READONLY_DATA lcl_aReferenceTypeTokenMap[] = { { XML_PAGE, ReferenceFieldPart::PAGE}, { XML_CHAPTER, ReferenceFieldPart::CHAPTER }, { XML_TEXT, ReferenceFieldPart::TEXT }, { XML_DIRECTION, ReferenceFieldPart::UP_DOWN }, { XML_CATEGORY_AND_VALUE, ReferenceFieldPart::CATEGORY_AND_NUMBER }, { XML_CAPTION, ReferenceFieldPart::ONLY_CAPTION }, { XML_VALUE, ReferenceFieldPart::ONLY_SEQUENCE_NUMBER }, // --> OD 2007-09-14 #i81002# { XML_NUMBER, ReferenceFieldPart::NUMBER }, { XML_NUMBER_NO_SUPERIOR, ReferenceFieldPart::NUMBER_NO_CONTEXT }, { XML_NUMBER_ALL_SUPERIOR, ReferenceFieldPart::NUMBER_FULL_CONTEXT }, // <-- { XML_TOKEN_INVALID, 0 } }; void XMLReferenceFieldImportContext::StartElement( const Reference & xAttrList) { bTypeOK = sal_True; switch (nElementToken) { case XML_TOK_TEXT_REFERENCE_REF: nSource = ReferenceFieldSource::REFERENCE_MARK; break; case XML_TOK_TEXT_BOOKMARK_REF: nSource = ReferenceFieldSource::BOOKMARK; break; case XML_TOK_TEXT_NOTE_REF: nSource = ReferenceFieldSource::FOOTNOTE; break; case XML_TOK_TEXT_SEQUENCE_REF: nSource = ReferenceFieldSource::SEQUENCE_FIELD; break; default: bTypeOK = sal_False; DBG_ERROR("unknown reference field"); break; } XMLTextFieldImportContext::StartElement(xAttrList); } void XMLReferenceFieldImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue ) { switch (nAttrToken) { case XML_TOK_TEXTFIELD_NOTE_CLASS: if( IsXMLToken( sAttrValue, XML_ENDNOTE ) ) nSource = ReferenceFieldSource::ENDNOTE; break; case XML_TOK_TEXTFIELD_REF_NAME: sName = sAttrValue; bNameOK = sal_True; break; case XML_TOK_TEXTFIELD_REFERENCE_FORMAT: { sal_uInt16 nToken; if (SvXMLUnitConverter::convertEnum(nToken, sAttrValue, lcl_aReferenceTypeTokenMap)) { nType = nToken; } // check for sequence-only-attributes if ( (XML_TOK_TEXT_SEQUENCE_REF != nElementToken) && ( (nType == ReferenceFieldPart::CATEGORY_AND_NUMBER) || (nType == ReferenceFieldPart::ONLY_CAPTION) || (nType == ReferenceFieldPart::ONLY_SEQUENCE_NUMBER) ) ) { nType = ReferenceFieldPart::PAGE_DESC; } break; } } // bValid: we need proper element type and name bValid = bTypeOK && bNameOK; } void XMLReferenceFieldImportContext::PrepareField( const Reference & xPropertySet) { Any aAny; aAny <<= nType; xPropertySet->setPropertyValue(sPropertyReferenceFieldPart, aAny); aAny <<= nSource; xPropertySet->setPropertyValue(sPropertyReferenceFieldSource, aAny); switch (nElementToken) { case XML_TOK_TEXT_REFERENCE_REF: case XML_TOK_TEXT_BOOKMARK_REF: aAny <<= sName; xPropertySet->setPropertyValue(sPropertySourceName, aAny); break; case XML_TOK_TEXT_NOTE_REF: GetImportHelper().ProcessFootnoteReference(sName, xPropertySet); break; case XML_TOK_TEXT_SEQUENCE_REF: GetImportHelper().ProcessSequenceReference(sName, xPropertySet); break; } aAny <<= GetContent(); xPropertySet->setPropertyValue(sPropertyCurrentPresentation, aAny); } // // field declarations container // enum DdeFieldDeclAttrs { XML_TOK_DDEFIELD_NAME, XML_TOK_DDEFIELD_APPLICATION, XML_TOK_DDEFIELD_TOPIC, XML_TOK_DDEFIELD_ITEM, XML_TOK_DDEFIELD_UPDATE }; static __FAR_DATA SvXMLTokenMapEntry aDdeDeclAttrTokenMap[] = { { XML_NAMESPACE_OFFICE, XML_NAME, XML_TOK_DDEFIELD_NAME }, { XML_NAMESPACE_OFFICE, XML_DDE_APPLICATION, XML_TOK_DDEFIELD_APPLICATION }, { XML_NAMESPACE_OFFICE, XML_DDE_TOPIC, XML_TOK_DDEFIELD_TOPIC }, { XML_NAMESPACE_OFFICE, XML_DDE_ITEM, XML_TOK_DDEFIELD_ITEM }, { XML_NAMESPACE_OFFICE, XML_AUTOMATIC_UPDATE, XML_TOK_DDEFIELD_UPDATE }, XML_TOKEN_MAP_END }; TYPEINIT1( XMLDdeFieldDeclsImportContext, SvXMLImportContext ); XMLDdeFieldDeclsImportContext::XMLDdeFieldDeclsImportContext( SvXMLImport& rImport, sal_uInt16 nPrfx, const OUString& sLocalName) : SvXMLImportContext(rImport, nPrfx, sLocalName), aTokenMap(aDdeDeclAttrTokenMap) { } SvXMLImportContext * XMLDdeFieldDeclsImportContext::CreateChildContext( sal_uInt16 nPrefix, const OUString& rLocalName, const Reference & xAttrList ) { if ( (XML_NAMESPACE_TEXT == nPrefix) && (IsXMLToken(rLocalName, XML_DDE_CONNECTION_DECL)) ) { return new XMLDdeFieldDeclImportContext(GetImport(), nPrefix, rLocalName, aTokenMap); } else { return SvXMLImportContext::CreateChildContext(nPrefix, rLocalName, xAttrList); } } // // import dde field declaration // TYPEINIT1( XMLDdeFieldDeclImportContext, SvXMLImportContext ); XMLDdeFieldDeclImportContext::XMLDdeFieldDeclImportContext( SvXMLImport& rImport, sal_uInt16 nPrfx, const OUString& sLocalName, const SvXMLTokenMap& rMap) : SvXMLImportContext(rImport, nPrfx, sLocalName) , sPropertyIsAutomaticUpdate(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_automatic_update)) , sPropertyName(RTL_CONSTASCII_USTRINGPARAM(sAPI_name)) , sPropertyDDECommandType(RTL_CONSTASCII_USTRINGPARAM(sAPI_dde_command_type)) , sPropertyDDECommandFile(RTL_CONSTASCII_USTRINGPARAM(sAPI_dde_command_file)) , sPropertyDDECommandElement(RTL_CONSTASCII_USTRINGPARAM(sAPI_dde_command_element)) , rTokenMap(rMap) { DBG_ASSERT(XML_NAMESPACE_TEXT == nPrfx, "wrong prefix"); DBG_ASSERT(IsXMLToken(sLocalName, XML_DDE_CONNECTION_DECL), "wrong name"); } void XMLDdeFieldDeclImportContext::StartElement( const Reference & xAttrList) { OUString sName; OUString sCommandApplication; OUString sCommandTopic; OUString sCommandItem; sal_Bool bUpdate = sal_False; sal_Bool bNameOK = sal_False; sal_Bool bCommandApplicationOK = sal_False; sal_Bool bCommandTopicOK = sal_False; sal_Bool bCommandItemOK = sal_False; // process attributes sal_Int16 nLength = xAttrList->getLength(); for(sal_Int16 i=0; igetNameByIndex(i), &sLocalName ); switch (rTokenMap.Get(nPrefix, sLocalName)) { case XML_TOK_DDEFIELD_NAME: sName = xAttrList->getValueByIndex(i); bNameOK = sal_True; break; case XML_TOK_DDEFIELD_APPLICATION: sCommandApplication = xAttrList->getValueByIndex(i); bCommandApplicationOK = sal_True; break; case XML_TOK_DDEFIELD_TOPIC: sCommandTopic = xAttrList->getValueByIndex(i); bCommandTopicOK = sal_True; break; case XML_TOK_DDEFIELD_ITEM: sCommandItem = xAttrList->getValueByIndex(i); bCommandItemOK = sal_True; break; case XML_TOK_DDEFIELD_UPDATE: { sal_Bool bTmp; if ( SvXMLUnitConverter::convertBool( bTmp, xAttrList->getValueByIndex(i)) ) { bUpdate = bTmp; } break; } } } // valid data? if (bNameOK && bCommandApplicationOK && bCommandTopicOK && bCommandItemOK) { // make service name OUStringBuffer sBuf; sBuf.appendAscii(sAPI_fieldmaster_prefix); sBuf.appendAscii(sAPI_dde); // create DDE TextFieldMaster Reference xFactory(GetImport().GetModel(), UNO_QUERY); if( xFactory.is() ) { /* #i6432# There might be multiple occurances of one DDE declaration if it is used in more than one of header/footer/body. createInstance will throw an exception if we try to create the second, third, etc. instance of such a declaration. Thus we ignore the exception. Otherwise this will lead to an unloadable document. */ try { Reference xIfc = xFactory->createInstance(sBuf.makeStringAndClear()); if( xIfc.is() ) { Reference xPropSet( xIfc, UNO_QUERY ); if (xPropSet.is() && xPropSet->getPropertySetInfo()->hasPropertyByName( sPropertyDDECommandType)) { Any aAny; aAny <<= sName; xPropSet->setPropertyValue(sPropertyName, aAny); aAny <<= sCommandApplication; xPropSet->setPropertyValue(sPropertyDDECommandType, aAny); aAny <<= sCommandTopic; xPropSet->setPropertyValue(sPropertyDDECommandFile, aAny); aAny <<= sCommandItem; xPropSet->setPropertyValue(sPropertyDDECommandElement, aAny); aAny.setValue(&bUpdate, ::getBooleanCppuType()); xPropSet->setPropertyValue(sPropertyIsAutomaticUpdate, aAny); } // else: ignore (can't get XPropertySet, or DDE // properties are not supported) } // else: ignore } catch ( const Exception& ) { //ignore } } // else: ignore } // else: ignore } // // DDE field import // TYPEINIT1( XMLDdeFieldImportContext, XMLTextFieldImportContext ); XMLDdeFieldImportContext::XMLDdeFieldImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLTextFieldImportContext(rImport, rHlp, sAPI_dde, nPrfx, sLocalName), sName() ,sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content)) { } void XMLDdeFieldImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const ::rtl::OUString& sAttrValue ) { if (XML_TOK_TEXTFIELD_CONNECTION_NAME == nAttrToken) { sName = sAttrValue; bValid = sal_True; } } void XMLDdeFieldImportContext::EndElement() { if (bValid) { // find master OUStringBuffer sBuf; sBuf.appendAscii(sAPI_fieldmaster_prefix); sBuf.appendAscii(sAPI_dde); sBuf.append(sal_Unicode('.')); sBuf.append(sName); OUString sMasterName = sBuf.makeStringAndClear(); Reference xTextFieldsSupp(GetImport().GetModel(), UNO_QUERY); Reference xFieldMasterNameAccess( xTextFieldsSupp->getTextFieldMasters(), UNO_QUERY); if (xFieldMasterNameAccess->hasByName(sMasterName)) { Reference xMaster; Any aAny = xFieldMasterNameAccess->getByName(sMasterName); aAny >>= xMaster; //apply the content to the master xMaster->setPropertyValue( sPropertyContent, uno::makeAny( GetContent())); // master exists: create text field and attach Reference xField; sBuf.appendAscii(sAPI_textfield_prefix); sBuf.appendAscii(sAPI_dde); if (CreateField(xField, sBuf.makeStringAndClear())) { Reference xDepTextField(xField,UNO_QUERY); xDepTextField->attachTextFieldMaster(xMaster); // attach field to document Reference xTextContent(xField, UNO_QUERY); if (xTextContent.is()) { GetImportHelper().InsertTextContent(xTextContent); // we're lucky. nothing else to prepare. } // else: fail, because text content could not be created } // else: fail, because field could not be created } // else: fail, because no master was found (faulty document?!) } // not valid: ignore } void XMLDdeFieldImportContext::PrepareField( const Reference &) { // empty, since not needed. } // // sheet name fields // TYPEINIT1(XMLSheetNameImportContext, XMLTextFieldImportContext); XMLSheetNameImportContext::XMLSheetNameImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLTextFieldImportContext(rImport, rHlp, sAPI_sheet_name, nPrfx, sLocalName) { bValid = sal_True; // always valid! } void XMLSheetNameImportContext::ProcessAttribute( sal_uInt16, const ::rtl::OUString& ) { // no attributes -> nothing to be done } void XMLSheetNameImportContext::PrepareField( const Reference &) { // no attributes -> nothing to be done } // // URL fields (Calc, Impress, Draw) // TYPEINIT1(XMLUrlFieldImportContext, XMLTextFieldImportContext); XMLUrlFieldImportContext::XMLUrlFieldImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLTextFieldImportContext(rImport, rHlp, sAPI_url, nPrfx, sLocalName), sPropertyURL(RTL_CONSTASCII_USTRINGPARAM(sAPI_url)), sPropertyTargetFrame(RTL_CONSTASCII_USTRINGPARAM(sAPI_target_frame)), sPropertyRepresentation(RTL_CONSTASCII_USTRINGPARAM( sAPI_representation)), bFrameOK(sal_False) { } void XMLUrlFieldImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue ) { switch (nAttrToken) { case XML_TOK_TEXTFIELD_HREF: sURL = GetImport().GetAbsoluteReference( sAttrValue ); bValid = sal_True; break; case XML_TOK_TEXTFIELD_TARGET_FRAME: sFrame = sAttrValue; bFrameOK = sal_True; break; default: // ignore break; } } void XMLUrlFieldImportContext::PrepareField( const Reference & xPropertySet) { Any aAny; aAny <<= sURL; xPropertySet->setPropertyValue(sPropertyURL, aAny); if (bFrameOK) { aAny <<= sFrame; xPropertySet->setPropertyValue(sPropertyTargetFrame, aAny); } aAny <<= GetContent(); xPropertySet->setPropertyValue(sPropertyRepresentation, aAny); } TYPEINIT1(XMLBibliographyFieldImportContext, XMLTextFieldImportContext); XMLBibliographyFieldImportContext::XMLBibliographyFieldImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLTextFieldImportContext(rImport, rHlp, sAPI_bibliography, nPrfx, sLocalName), sPropertyFields(RTL_CONSTASCII_USTRINGPARAM("Fields")), aValues() { bValid = sal_True; } // TODO: this is the same map as is used in the text field export SvXMLEnumMapEntry __READONLY_DATA aBibliographyDataTypeMap[] = { { XML_ARTICLE, BibliographyDataType::ARTICLE }, { XML_BOOK, BibliographyDataType::BOOK }, { XML_BOOKLET, BibliographyDataType::BOOKLET }, { XML_CONFERENCE, BibliographyDataType::CONFERENCE }, { XML_CUSTOM1, BibliographyDataType::CUSTOM1 }, { XML_CUSTOM2, BibliographyDataType::CUSTOM2 }, { XML_CUSTOM3, BibliographyDataType::CUSTOM3 }, { XML_CUSTOM4, BibliographyDataType::CUSTOM4 }, { XML_CUSTOM5, BibliographyDataType::CUSTOM5 }, { XML_EMAIL, BibliographyDataType::EMAIL }, { XML_INBOOK, BibliographyDataType::INBOOK }, { XML_INCOLLECTION, BibliographyDataType::INCOLLECTION }, { XML_INPROCEEDINGS, BibliographyDataType::INPROCEEDINGS }, { XML_JOURNAL, BibliographyDataType::JOURNAL }, { XML_MANUAL, BibliographyDataType::MANUAL }, { XML_MASTERSTHESIS, BibliographyDataType::MASTERSTHESIS }, { XML_MISC, BibliographyDataType::MISC }, { XML_PHDTHESIS, BibliographyDataType::PHDTHESIS }, { XML_PROCEEDINGS, BibliographyDataType::PROCEEDINGS }, { XML_TECHREPORT, BibliographyDataType::TECHREPORT }, { XML_UNPUBLISHED, BibliographyDataType::UNPUBLISHED }, { XML_WWW, BibliographyDataType::WWW }, { XML_TOKEN_INVALID, 0 } }; // we'll process attributes on our own and forfit the standard // tecfield mechanism, because our attributes have zero overlp with // all the oher textfields. void XMLBibliographyFieldImportContext::StartElement( const Reference & xAttrList) { // iterate over attributes sal_Int16 nLength = xAttrList->getLength(); for(sal_Int16 i=0; igetNameByIndex(i), &sLocalName ); if (nPrefix == XML_NAMESPACE_TEXT) { PropertyValue aValue; aValue.Name = OUString::createFromAscii( MapBibliographyFieldName(sLocalName)); Any aAny; // special treatment for bibliography type // biblio vs bibilio: #96658#; also read old documents if (IsXMLToken(sLocalName, XML_BIBILIOGRAPHIC_TYPE) || IsXMLToken(sLocalName, XML_BIBLIOGRAPHY_TYPE) ) { sal_uInt16 nTmp; if (SvXMLUnitConverter::convertEnum( nTmp, xAttrList->getValueByIndex(i), aBibliographyDataTypeMap)) { aAny <<= (sal_Int16)nTmp; aValue.Value = aAny; aValues.push_back(aValue); } } else { aAny <<= xAttrList->getValueByIndex(i); aValue.Value = aAny; aValues.push_back(aValue); } } // else: unknown namespace -> ignore } } void XMLBibliographyFieldImportContext::ProcessAttribute( sal_uInt16, const OUString& ) { // attributes are handled in StartElement DBG_ERROR("This should not have happened."); } void XMLBibliographyFieldImportContext::PrepareField( const Reference & xPropertySet) { // convert vector into sequence sal_Int32 nCount = aValues.size(); Sequence aValueSequence(nCount); for(sal_Int32 i = 0; i < nCount; i++) { aValueSequence[i] = aValues[i]; } // set sequence Any aAny; aAny <<= aValueSequence; xPropertySet->setPropertyValue(sPropertyFields, aAny); } const sal_Char* XMLBibliographyFieldImportContext::MapBibliographyFieldName( OUString sName) { const sal_Char* pName = NULL; if (IsXMLToken(sName, XML_IDENTIFIER)) { pName = "Identifier"; } else if (IsXMLToken(sName, XML_BIBILIOGRAPHIC_TYPE) || IsXMLToken(sName, XML_BIBLIOGRAPHY_TYPE) ) { // biblio... vs bibilio...: #96658#: also read old documents pName = "BibiliographicType"; } else if (IsXMLToken(sName, XML_ADDRESS)) { pName = "Address"; } else if (IsXMLToken(sName, XML_ANNOTE)) { pName = "Annote"; } else if (IsXMLToken(sName, XML_AUTHOR)) { pName = "Author"; } else if (IsXMLToken(sName, XML_BOOKTITLE)) { pName = "Booktitle"; } else if (IsXMLToken(sName, XML_CHAPTER)) { pName = "Chapter"; } else if (IsXMLToken(sName, XML_EDITION)) { pName = "Edition"; } else if (IsXMLToken(sName, XML_EDITOR)) { pName = "Editor"; } else if (IsXMLToken(sName, XML_HOWPUBLISHED)) { pName = "Howpublished"; } else if (IsXMLToken(sName, XML_INSTITUTION)) { pName = "Institution"; } else if (IsXMLToken(sName, XML_JOURNAL)) { pName = "Journal"; } else if (IsXMLToken(sName, XML_MONTH)) { pName = "Month"; } else if (IsXMLToken(sName, XML_NOTE)) { pName = "Note"; } else if (IsXMLToken(sName, XML_NUMBER)) { pName = "Number"; } else if (IsXMLToken(sName, XML_ORGANIZATIONS)) { pName = "Organizations"; } else if (IsXMLToken(sName, XML_PAGES)) { pName = "Pages"; } else if (IsXMLToken(sName, XML_PUBLISHER)) { pName = "Publisher"; } else if (IsXMLToken(sName, XML_SCHOOL)) { pName = "School"; } else if (IsXMLToken(sName, XML_SERIES)) { pName = "Series"; } else if (IsXMLToken(sName, XML_TITLE)) { pName = "Title"; } else if (IsXMLToken(sName, XML_REPORT_TYPE)) { pName = "Report_Type"; } else if (IsXMLToken(sName, XML_VOLUME)) { pName = "Volume"; } else if (IsXMLToken(sName, XML_YEAR)) { pName = "Year"; } else if (IsXMLToken(sName, XML_URL)) { pName = "URL"; } else if (IsXMLToken(sName, XML_CUSTOM1)) { pName = "Custom1"; } else if (IsXMLToken(sName, XML_CUSTOM2)) { pName = "Custom2"; } else if (IsXMLToken(sName, XML_CUSTOM3)) { pName = "Custom3"; } else if (IsXMLToken(sName, XML_CUSTOM4)) { pName = "Custom4"; } else if (IsXMLToken(sName, XML_CUSTOM5)) { pName = "Custom5"; } else if (IsXMLToken(sName, XML_ISBN)) { pName = "ISBN"; } else { DBG_ERROR("Unknown bibliography info data"); pName = NULL; } return pName; } // // Annotation Field // TYPEINIT1(XMLAnnotationImportContext, XMLTextFieldImportContext); XMLAnnotationImportContext::XMLAnnotationImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nToken, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLTextFieldImportContext(rImport, rHlp, sAPI_annotation, nPrfx, sLocalName) , sPropertyName(RTL_CONSTASCII_USTRINGPARAM(sAPI_name)) , sPropertyAuthor(RTL_CONSTASCII_USTRINGPARAM(sAPI_author)) , sPropertyInitials(RTL_CONSTASCII_USTRINGPARAM(sAPI_initials)) , sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content)) , sPropertyDate(RTL_CONSTASCII_USTRINGPARAM(sAPI_date_time_value)) , sPropertyTextRange(RTL_CONSTASCII_USTRINGPARAM(sAPI_TextRange)) , m_nToken( nToken ) { bValid = sal_True; // remember old list item and block (#91964#) and reset them // for the text frame // do this in the constructor, not in CreateChildContext (#i93392#) GetImport().GetTextImport()->PushListContext(); } void XMLAnnotationImportContext::ProcessAttribute( sal_uInt16 nToken, const OUString& rValue ) { if ( nToken == XML_TOK_TEXT_NAME ) { aName = rValue; } } SvXMLImportContext* XMLAnnotationImportContext::CreateChildContext( sal_uInt16 nPrefix, const OUString& rLocalName, const Reference& xAttrList ) { SvXMLImportContext *pContext = 0; if( XML_NAMESPACE_DC == nPrefix ) { if( IsXMLToken( rLocalName, XML_CREATOR ) ) { pContext = new XMLStringBufferImportContext( GetImport(), nPrefix, rLocalName, aAuthorBuffer); } else if( IsXMLToken( rLocalName, XML_DATE ) ) { pContext = new XMLStringBufferImportContext( GetImport(), nPrefix, rLocalName, aDateBuffer); } } else if ( XML_NAMESPACE_TEXT == nPrefix ) { if( IsXMLToken( rLocalName, XML_SENDER_INITIALS ) ) { pContext = new XMLStringBufferImportContext( GetImport(), nPrefix, rLocalName, aInitialsBuffer); } } if( !pContext ) { try { if ( !mxField.is() ) CreateField( mxField, sServicePrefix + GetServiceName() ); Any aAny = mxField->getPropertyValue( sPropertyTextRange ); Reference< XText > xText; aAny >>= xText; if( xText.is() ) { UniReference < XMLTextImportHelper > xTxtImport = GetImport().GetTextImport(); if( !mxCursor.is() ) { mxOldCursor = xTxtImport->GetCursor(); mxCursor = xText->createTextCursor(); } if( mxCursor.is() ) { xTxtImport->SetCursor( mxCursor ); pContext = xTxtImport->CreateTextChildContext( GetImport(), nPrefix, rLocalName, xAttrList ); } } } catch ( Exception& ) {} if( !pContext ) pContext = new XMLStringBufferImportContext(GetImport(), nPrefix, rLocalName, aTextBuffer); } return pContext; } void XMLAnnotationImportContext::EndElement() { DBG_ASSERT(GetServiceName().getLength()>0, "no service name for element!"); if( mxCursor.is() ) { // delete addition newline const OUString aEmpty; mxCursor->gotoEnd( sal_False ); mxCursor->goLeft( 1, sal_True ); mxCursor->setString( aEmpty ); // reset cursor GetImport().GetTextImport()->ResetCursor(); } if( mxOldCursor.is() ) GetImport().GetTextImport()->SetCursor( mxOldCursor ); // reinstall old list item #91964# GetImport().GetTextImport()->PopListContext(); if ( bValid ) { if ( mxField.is() || CreateField( mxField, sServicePrefix + GetServiceName() ) ) { // set field properties PrepareField( mxField ); // attach field to document Reference < XTextContent > xTextContent( mxField, UNO_QUERY ); // workaround for #80606# try { if ( m_nToken == XML_TOK_TEXT_ANNOTATION_END && m_xStart.is() ) { // So we are ending a previous annotation, // let's create a text range covering the start and the current position. uno::Reference xText = GetImportHelper().GetText(); uno::Reference xCursor = xText->createTextCursorByRange(m_xStart->getAnchor()); xCursor->gotoRange(GetImportHelper().GetCursorAsRange(), true); uno::Reference xTextRange(xCursor, uno::UNO_QUERY); xText->insertTextContent( xTextRange, xTextContent, !xCursor->isCollapsed() ); // Now we can delete the annotation at the start position. uno::Reference(m_xStart, uno::UNO_QUERY)->dispose(); } else { GetImportHelper().InsertTextContent( xTextContent ); } } catch (lang::IllegalArgumentException) { // ignore } } } else GetImportHelper().InsertString(GetContent()); } void XMLAnnotationImportContext::PrepareField( const Reference & xPropertySet) { if ( m_nToken == XML_TOK_TEXT_ANNOTATION_END && aName.getLength() > 0 ) { // Search for a previous annotation with the same name. Reference xTextFieldsSupplier(GetImport().GetModel(), UNO_QUERY); uno::Reference xFieldsAccess(xTextFieldsSupplier->getTextFields()); uno::Reference xFields(xFieldsAccess->createEnumeration()); uno::Reference xPrevField; while (xFields->hasMoreElements()) { uno::Reference xCurrField(xFields->nextElement(), uno::UNO_QUERY); OUString aFieldName; xCurrField->getPropertyValue(sPropertyName) >>= aFieldName; if ( aFieldName == aName ) { xPrevField = xCurrField; break; } } if (xPrevField.is()) { // copy over the properties. xPropertySet->setPropertyValue(sPropertyAuthor, xPrevField->getPropertyValue(sPropertyAuthor)); xPropertySet->setPropertyValue(sPropertyInitials, xPrevField->getPropertyValue(sPropertyInitials)); xPropertySet->setPropertyValue(sPropertyDate, xPrevField->getPropertyValue(sPropertyDate)); xPropertySet->setPropertyValue(sPropertyName, xPrevField->getPropertyValue(sPropertyName)); xPropertySet->setPropertyValue(sPropertyContent, xPrevField->getPropertyValue(sPropertyContent)); // And save a reference to it, so we can delete it later. m_xStart.set(xPrevField, uno::UNO_QUERY); return; } } // import (possibly empty) author OUString sAuthor( aAuthorBuffer.makeStringAndClear() ); xPropertySet->setPropertyValue(sPropertyAuthor, makeAny(sAuthor)); // import (possibly empty) initials OUString sInitials( aInitialsBuffer.makeStringAndClear() ); xPropertySet->setPropertyValue(sPropertyInitials, makeAny(sInitials)); DateTime aDateTime; if (SvXMLUnitConverter::convertDateTime(aDateTime, aDateBuffer.makeStringAndClear())) { /* Date aDate; aDate.Year = aDateTime.Year; aDate.Month = aDateTime.Month; aDate.Day = aDateTime.Day; xPropertySet->setPropertyValue(sPropertyDate, makeAny(aDate)); */ xPropertySet->setPropertyValue(sPropertyDate, makeAny(aDateTime)); } OUString sBuffer = aTextBuffer.makeStringAndClear(); if ( sBuffer.getLength() > 0 ) { // delete last paragraph mark (if necessary) if (sal_Char(0x0a) == sBuffer.getStr()[sBuffer.getLength()-1]) sBuffer = sBuffer.copy(0, sBuffer.getLength()-1); xPropertySet->setPropertyValue(sPropertyContent, makeAny(sBuffer)); } if ( aName.getLength() > 0 ) { xPropertySet->setPropertyValue(sPropertyName, makeAny(aName)); } } // // script field // TYPEINIT1(XMLScriptImportContext, XMLTextFieldImportContext); XMLScriptImportContext::XMLScriptImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLTextFieldImportContext(rImport, rHlp, sAPI_script, nPrfx, sLocalName) , sPropertyScriptType(RTL_CONSTASCII_USTRINGPARAM(sAPI_script_type)) , sPropertyURLContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_url_content)) , sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content)) , bContentOK(sal_False) , bScriptTypeOK(sal_False) , bUrlContent(sal_False) { } void XMLScriptImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue ) { switch (nAttrToken) { case XML_TOK_TEXTFIELD_HREF: sContent = GetImport().GetAbsoluteReference( sAttrValue ); bContentOK = sal_True; break; case XML_TOK_TEXTFIELD_LANGUAGE: sScriptType = sAttrValue; bScriptTypeOK = sal_True; break; default: // ignore break; } // always valid (even without ScriptType; cf- #96531#) bValid = sal_True; } void XMLScriptImportContext::PrepareField( const Reference & xPropertySet) { Any aAny; // if href attribute was present, we use it. Else we use element content if (! bContentOK) { sContent = GetContent(); } aAny <<= sContent; xPropertySet->setPropertyValue(sPropertyContent, aAny); // URL or script text? We use URL if we have an href-attribute aAny.setValue(&bContentOK, ::getBooleanCppuType()); xPropertySet->setPropertyValue(sPropertyURLContent, aAny); aAny <<= sScriptType; xPropertySet->setPropertyValue(sPropertyScriptType, aAny); } // // measure field // TYPEINIT1(XMLMeasureFieldImportContext, XMLTextFieldImportContext); XMLMeasureFieldImportContext::XMLMeasureFieldImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const OUString& sLocalName) : XMLTextFieldImportContext(rImport, rHlp, sAPI_measure, nPrfx, sLocalName), mnKind( 0 ) { } void XMLMeasureFieldImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const OUString& sAttrValue ) { switch (nAttrToken) { case XML_TOK_TEXTFIELD_MEASURE_KIND: if( IsXMLToken( sAttrValue, XML_VALUE ) ) { mnKind = 0; bValid = sal_True; } else if( IsXMLToken( sAttrValue, XML_UNIT ) ) { mnKind = 1; bValid = sal_True; } else if( IsXMLToken( sAttrValue, XML_GAP ) ) { mnKind = 2; bValid = sal_True; } break; } } void XMLMeasureFieldImportContext::PrepareField( const Reference & xPropertySet) { Any aAny; aAny <<= mnKind; xPropertySet->setPropertyValue(OUString::createFromAscii("Kind"), aAny); } // // dropdown field // TYPEINIT1( XMLDropDownFieldImportContext, XMLTextFieldImportContext ); XMLDropDownFieldImportContext::XMLDropDownFieldImportContext( SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx, const ::rtl::OUString& sLocalName) : XMLTextFieldImportContext( rImport, rHlp, sAPI_drop_down, nPrfx, sLocalName ), aLabels(), sName(), nSelected( -1 ), bNameOK( false ), bHelpOK(false), bHintOK(false), sPropertyItems( RTL_CONSTASCII_USTRINGPARAM( "Items" ) ), sPropertySelectedItem( RTL_CONSTASCII_USTRINGPARAM( "SelectedItem" ) ), sPropertyName( RTL_CONSTASCII_USTRINGPARAM( "Name" ) ), sPropertyHelp( RTL_CONSTASCII_USTRINGPARAM( "Help" ) ), sPropertyToolTip( RTL_CONSTASCII_USTRINGPARAM( "Tooltip" ) ) { bValid = sal_True; } bool lcl_ProcessLabel( const SvXMLImport& rImport, const Reference& xAttrList, OUString& rLabel, bool& rIsSelected ) { bool bValid = false; sal_Int16 nLength = xAttrList->getLength(); for( sal_Int16 n = 0; n < nLength; n++ ) { OUString sLocalName; sal_uInt16 nPrefix = rImport.GetNamespaceMap(). GetKeyByAttrName( xAttrList->getNameByIndex(n), &sLocalName ); OUString sValue = xAttrList->getValueByIndex(n); if( nPrefix == XML_NAMESPACE_TEXT ) { if( IsXMLToken( sLocalName, XML_VALUE ) ) { rLabel = sValue; bValid = true; } else if( IsXMLToken( sLocalName, XML_CURRENT_SELECTED ) ) { sal_Bool bTmp; if( SvXMLUnitConverter::convertBool( bTmp, sValue ) ) rIsSelected = bTmp; } } } return bValid; } SvXMLImportContext* XMLDropDownFieldImportContext::CreateChildContext( sal_uInt16 nPrefix, const OUString& rLocalName, const Reference& xAttrList ) { if( nPrefix == XML_NAMESPACE_TEXT && IsXMLToken( rLocalName, XML_LABEL ) ) { OUString sLabel; bool bIsSelected = sal_False; if( lcl_ProcessLabel( GetImport(), xAttrList, sLabel, bIsSelected ) ) { if( bIsSelected ) nSelected = static_cast( aLabels.size() ); aLabels.push_back( sLabel ); } } return new SvXMLImportContext( GetImport(), nPrefix, rLocalName ); } void XMLDropDownFieldImportContext::ProcessAttribute( sal_uInt16 nAttrToken, const ::rtl::OUString& sAttrValue ) { if( nAttrToken == XML_TOK_TEXTFIELD_NAME ) { sName = sAttrValue; bNameOK = true; } else if (nAttrToken == XML_TOK_TEXTFIELD_HELP) { sHelp = sAttrValue; bHelpOK = true; } else if (nAttrToken == XML_TOK_TEXTFIELD_HINT) { sHint = sAttrValue; bHintOK = true; } } void XMLDropDownFieldImportContext::PrepareField( const Reference& xPropertySet) { // create sequence sal_Int32 nLength = static_cast( aLabels.size() ); Sequence aSequence( nLength ); OUString* pSequence = aSequence.getArray(); for( sal_Int32 n = 0; n < nLength; n++ ) pSequence[n] = aLabels[n]; // now set values: Any aAny; aAny <<= aSequence; xPropertySet->setPropertyValue( sPropertyItems, aAny ); if( nSelected >= 0 && nSelected < nLength ) { aAny <<= pSequence[nSelected]; xPropertySet->setPropertyValue( sPropertySelectedItem, aAny ); } // set name if( bNameOK ) { aAny <<= sName; xPropertySet->setPropertyValue( sPropertyName, aAny ); } // set help if( bHelpOK ) { aAny <<= sHelp; xPropertySet->setPropertyValue( sPropertyHelp, aAny ); } // set hint if( bHintOK ) { aAny <<= sHint; xPropertySet->setPropertyValue( sPropertyToolTip, aAny ); } } /** import header fields () */ TYPEINIT1( XMLHeaderFieldImportContext, XMLTextFieldImportContext ); XMLHeaderFieldImportContext::XMLHeaderFieldImportContext( SvXMLImport& rImport, /// XML Import XMLTextImportHelper& rHlp, /// Text import helper sal_uInt16 nPrfx, /// namespace prefix const ::rtl::OUString& sLocalName) /// element name w/o prefix : XMLTextFieldImportContext(rImport, rHlp, sAPI_header, nPrfx, sLocalName ) { sServicePrefix = OUString::createFromAscii( sAPI_presentation_prefix ); bValid = sal_True; } /// process attribute values void XMLHeaderFieldImportContext::ProcessAttribute( sal_uInt16, const ::rtl::OUString& ) { } /// prepare XTextField for insertion into document void XMLHeaderFieldImportContext::PrepareField(const Reference &) { } /** import footer fields () */ TYPEINIT1( XMLFooterFieldImportContext, XMLTextFieldImportContext ); XMLFooterFieldImportContext::XMLFooterFieldImportContext( SvXMLImport& rImport, /// XML Import XMLTextImportHelper& rHlp, /// Text import helper sal_uInt16 nPrfx, /// namespace prefix const ::rtl::OUString& sLocalName) /// element name w/o prefix : XMLTextFieldImportContext(rImport, rHlp, sAPI_footer, nPrfx, sLocalName ) { sServicePrefix = OUString::createFromAscii( sAPI_presentation_prefix ); bValid = sal_True; } /// process attribute values void XMLFooterFieldImportContext::ProcessAttribute( sal_uInt16, const ::rtl::OUString& ) { } /// prepare XTextField for insertion into document void XMLFooterFieldImportContext::PrepareField(const Reference &) { } /** import footer fields () */ TYPEINIT1( XMLDateTimeFieldImportContext, XMLTextFieldImportContext ); XMLDateTimeFieldImportContext::XMLDateTimeFieldImportContext( SvXMLImport& rImport, /// XML Import XMLTextImportHelper& rHlp, /// Text import helper sal_uInt16 nPrfx, /// namespace prefix const ::rtl::OUString& sLocalName) /// element name w/o prefix : XMLTextFieldImportContext(rImport, rHlp, sAPI_datetime, nPrfx, sLocalName ) { sServicePrefix = OUString::createFromAscii( sAPI_presentation_prefix ); bValid = sal_True; } /// process attribute values void XMLDateTimeFieldImportContext::ProcessAttribute( sal_uInt16, const ::rtl::OUString& ) { } /// prepare XTextField for insertion into document void XMLDateTimeFieldImportContext::PrepareField( const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet> &) { }