summaryrefslogtreecommitdiffstats
path: root/xmloff/source/text/txtfldi.cxx
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-27 16:51:28 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-27 16:51:28 +0000
commit940b4d1848e8c70ab7642901a68594e8016caffc (patch)
treeeb72f344ee6c3d9b80a7ecc079ea79e9fba8676d /xmloff/source/text/txtfldi.cxx
parentInitial commit. (diff)
downloadlibreoffice-940b4d1848e8c70ab7642901a68594e8016caffc.tar.xz
libreoffice-940b4d1848e8c70ab7642901a68594e8016caffc.zip
Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'xmloff/source/text/txtfldi.cxx')
-rw-r--r--xmloff/source/text/txtfldi.cxx3795
1 files changed, 3795 insertions, 0 deletions
diff --git a/xmloff/source/text/txtfldi.cxx b/xmloff/source/text/txtfldi.cxx
new file mode 100644
index 000000000..62dd48c76
--- /dev/null
+++ b/xmloff/source/text/txtfldi.cxx
@@ -0,0 +1,3795 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * 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 .
+ */
+
+
+/** @#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 <xmloff/xmlimp.hxx>
+#include <xmloff/txtimp.hxx>
+#include <xmloff/xmlnmspe.hxx>
+#include <xmloff/nmspmap.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlement.hxx>
+#include <XMLStringBufferImportContext.hxx>
+#include <xmloff/XMLEventsImportContext.hxx>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/xml/sax/XAttributeList.hpp>
+#include <com/sun/star/text/UserDataPart.hpp>
+#include <com/sun/star/style/NumberingType.hpp>
+#include <com/sun/star/text/PlaceholderType.hpp>
+#include <com/sun/star/text/ReferenceFieldPart.hpp>
+#include <com/sun/star/text/ReferenceFieldSource.hpp>
+#include <com/sun/star/text/XTextContent.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/beans/XPropertySetInfo.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/text/XTextFieldsSupplier.hpp>
+#include <com/sun/star/text/XDependentTextField.hpp>
+#include <com/sun/star/text/FilenameDisplayFormat.hpp>
+#include <com/sun/star/text/ChapterFormat.hpp>
+#include <com/sun/star/text/TemplateDisplayFormat.hpp>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/text/BibliographyDataType.hpp>
+#include <com/sun/star/util/XUpdatable.hpp>
+#include <com/sun/star/sdb/CommandType.hpp>
+#include <com/sun/star/container/XIndexReplace.hpp>
+
+#include <sax/tools/converter.hxx>
+
+#include <rtl/ustring.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <sal/log.hxx>
+#include <rtl/math.hxx>
+#include <tools/debug.hxx>
+#include <osl/diagnose.h>
+
+
+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 names
+const char sAPI_textfield_prefix[] = "com.sun.star.text.TextField.";
+const char sAPI_fieldmaster_prefix[] = "com.sun.star.text.FieldMaster.";
+const char sAPI_presentation_prefix[] = "com.sun.star.presentation.TextField.";
+
+const char sAPI_date_time[] = "DateTime";
+const char sAPI_page_number[] = "PageNumber";
+const char sAPI_docinfo_change_date_time[] = "DocInfo.ChangeDateTime";
+const char sAPI_docinfo_create_date_time[] = "DocInfo.CreateDateTime";
+const char sAPI_docinfo_custom[] = "DocInfo.Custom";
+const char sAPI_docinfo_print_date_time[] = "DocInfo.PrintDateTime";
+const char sAPI_dde[] = "DDE";
+const char sAPI_url[] = "URL";
+
+// property names
+const char sAPI_is_fixed[] = "IsFixed";
+const char sAPI_content[] = "Content";
+const char sAPI_author[] = "Author";
+const char sAPI_hint[] = "Hint";
+const char sAPI_name[] = "Name";
+const char sAPI_sub_type[] = "SubType";
+const char sAPI_date_time_value[] = "DateTimeValue";
+const char sAPI_number_format[] = "NumberFormat";
+const char sAPI_numbering_type[] = "NumberingType";
+const char sAPI_offset[] = "Offset";
+const char sAPI_condition[] = "Condition";
+const char sAPI_set_number[] = "SetNumber";
+const char sAPI_file_format[] = "FileFormat";
+const char sAPI_is_date[] = "IsDate";
+const char sAPI_current_presentation[] = "CurrentPresentation";
+const char sAPI_is_hidden[] = "IsHidden";
+const char sAPI_is_fixed_language[] = "IsFixedLanguage";
+
+const char sAPI_true[] = "TRUE";
+
+
+XMLTextFieldImportContext::XMLTextFieldImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp,
+ const char* pService,
+ sal_uInt16 nPrefix, const OUString& rElementName)
+: SvXMLImportContext( rImport, nPrefix, rElementName )
+, rTextImportHelper(rHlp)
+, sServicePrefix(sAPI_textfield_prefix)
+, bValid(false)
+{
+ DBG_ASSERT(nullptr != pService, "Need service name!");
+ sServiceName = OUString::createFromAscii(pService);
+}
+
+void XMLTextFieldImportContext::StartElement(
+ const Reference<XAttributeList> & xAttrList)
+{
+ // process attributes
+ sal_Int16 nLength = xAttrList->getLength();
+ for(sal_Int16 i=0; i<nLength; i++) {
+
+ OUString sLocalName;
+ sal_uInt16 nPrefix = GetImport().GetNamespaceMap().
+ GetKeyByAttrName( xAttrList->getNameByIndex(i), &sLocalName );
+
+ ProcessAttribute(rTextImportHelper.GetTextFieldAttrTokenMap().
+ Get(nPrefix, sLocalName),
+ xAttrList->getValueByIndex(i) );
+ }
+}
+
+OUString const & XMLTextFieldImportContext::GetContent()
+{
+ if (sContent.isEmpty())
+ {
+ sContent = sContentBuffer.makeStringAndClear();
+ }
+
+ return sContent;
+}
+
+void XMLTextFieldImportContext::EndElement()
+{
+ DBG_ASSERT(!GetServiceName().isEmpty(), "no service name for element!");
+ if (bValid)
+ {
+
+ // create field/Service
+ Reference<XPropertySet> xPropSet;
+ if (CreateField(xPropSet, sServicePrefix + GetServiceName()))
+ {
+ // set field properties
+ PrepareField(xPropSet);
+
+ // attach field to document
+ Reference<XTextContent> xTextContent(xPropSet, UNO_QUERY);
+
+ // workaround for #80606#
+ try
+ {
+ rTextImportHelper.InsertTextContent(xTextContent);
+ }
+ catch (const lang::IllegalArgumentException&)
+ {
+ // ignore
+ }
+ return;
+ }
+ }
+
+ // in case of error: write element content
+ rTextImportHelper.InsertString(GetContent());
+}
+
+void XMLTextFieldImportContext::Characters(const OUString& rContent)
+{
+ sContentBuffer.append(rContent);
+}
+
+bool XMLTextFieldImportContext::CreateField(
+ Reference<XPropertySet> & xField,
+ const OUString& rServiceName)
+{
+ // instantiate new XTextField:
+ // ask import for model, model is factory, ask factory to create service
+
+ Reference<XMultiServiceFactory> xFactory(GetImport().GetModel(),UNO_QUERY);
+ if( xFactory.is() )
+ {
+ Reference<XInterface> xIfc = xFactory->createInstance(rServiceName);
+ if( xIfc.is() )
+ {
+ Reference<XPropertySet> xTmp( xIfc, UNO_QUERY );
+
+ xField = xTmp;
+ } else {
+ return false; // can't create instance
+ }
+ } else {
+ return false; // can't get MultiServiceFactory
+ }
+
+ return 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 = nullptr;
+
+ 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, true,
+ 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, false,
+ 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_PAGE_NAME:
+ pContext = new XMLPageNameFieldImportContext( 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_DROP_DOWN:
+ 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 = nullptr;
+ break;
+ }
+
+ return pContext;
+}
+
+
+void XMLTextFieldImportContext::ForceUpdate(
+ const Reference<XPropertySet> & rPropertySet)
+{
+ // force update
+ Reference<XUpdatable> xUpdate(rPropertySet, UNO_QUERY);
+ if (xUpdate.is())
+ {
+ xUpdate->update();
+ }
+ else
+ {
+ OSL_FAIL("Expected XUpdatable support!");
+ }
+}
+
+
+// XMLSenderFieldImportContext
+
+
+static const OUStringLiteral gsPropertyFieldSubType("UserDataType");
+
+XMLSenderFieldImportContext::XMLSenderFieldImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx, const OUString& sLocalName,
+ sal_uInt16 nToken)
+ : XMLTextFieldImportContext(rImport, rHlp, "ExtendedUser", nPrfx, sLocalName)
+ , nSubType(0)
+ , sPropertyFixed(sAPI_is_fixed)
+ , sPropertyContent(sAPI_content)
+ , bFixed(true)
+ , nElementToken(nToken)
+{
+}
+
+void XMLSenderFieldImportContext::StartElement(
+ const Reference<XAttributeList> & xAttrList)
+{
+ bValid = 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 = false;
+ break;
+ }
+
+ // process Attributes
+ XMLTextFieldImportContext::StartElement(xAttrList);
+}
+
+void XMLSenderFieldImportContext::ProcessAttribute(
+ sal_uInt16 nAttrToken,
+ const OUString& sAttrValue)
+{
+ if (XML_TOK_TEXTFIELD_FIXED == nAttrToken) {
+
+ // set bVal
+ bool bVal(false);
+ bool const bRet = ::sax::Converter::convertBool(bVal, sAttrValue);
+
+ // set bFixed if successful
+ if (bRet) {
+ bFixed = bVal;
+ }
+ }
+}
+
+void XMLSenderFieldImportContext::PrepareField(
+ const Reference<XPropertySet> & rPropSet)
+{
+ // set members
+ rPropSet->setPropertyValue(gsPropertyFieldSubType, Any(nSubType));
+
+ // set fixed
+ rPropSet->setPropertyValue(sPropertyFixed, Any(bFixed));
+
+ // set content if fixed
+ if (bFixed)
+ {
+ // in organizer or styles-only mode: force update
+ if (GetImport().GetTextImport()->IsOrganizerMode() ||
+ GetImport().GetTextImport()->IsStylesOnlyMode() )
+ {
+ ForceUpdate(rPropSet);
+ }
+ else
+ {
+ rPropSet->setPropertyValue(sPropertyContent, Any(GetContent()));
+ }
+ }
+}
+
+
+// XMLAuthorFieldImportContext
+
+static const OUStringLiteral gsPropertyAuthorFullName("FullName");
+
+XMLAuthorFieldImportContext::XMLAuthorFieldImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx, const OUString& sLocalName,
+ sal_uInt16 nToken)
+: XMLSenderFieldImportContext(rImport, rHlp, nPrfx, sLocalName, nToken)
+, bAuthorFullName(true)
+, sPropertyFixed(sAPI_is_fixed)
+, sPropertyContent(sAPI_content)
+{
+ // overwrite service name from XMLSenderFieldImportContext
+ SetServiceName(sAPI_author);
+}
+
+void XMLAuthorFieldImportContext::StartElement(
+ const Reference<XAttributeList> & xAttrList) {
+
+ bAuthorFullName = (XML_TOK_TEXT_AUTHOR_INITIALS != nElementToken);
+ bValid = true;
+
+ // process Attributes
+ XMLTextFieldImportContext::StartElement(xAttrList);
+}
+
+void XMLAuthorFieldImportContext::ProcessAttribute(sal_uInt16 nAttrToken, const OUString& sAttrValue)
+{
+ if(nAttrToken == XML_TOK_TEXTFIELD_FIXED)
+ {
+ bool bTmp(false);
+ if (::sax::Converter::convertBool(bTmp, sAttrValue))
+ bFixed = bTmp;
+ }
+}
+
+void XMLAuthorFieldImportContext::PrepareField(
+ const Reference<XPropertySet> & rPropSet)
+{
+ // set members
+ Any aAny;
+ rPropSet->setPropertyValue(gsPropertyAuthorFullName, Any(bAuthorFullName));
+
+ rPropSet->setPropertyValue(sPropertyFixed, Any(bFixed));
+
+ // 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
+
+
+static SvXMLEnumMapEntry<PageNumberType> const lcl_aSelectPageAttrMap[] =
+{
+ { XML_PREVIOUS, PageNumberType_PREV },
+ { XML_CURRENT, PageNumberType_CURRENT },
+ { XML_NEXT, PageNumberType_NEXT },
+ { XML_TOKEN_INVALID, PageNumberType(0) },
+};
+
+static const OUStringLiteral gsPropertyUserText("UserText");
+
+XMLPageContinuationImportContext::XMLPageContinuationImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx,
+ const OUString& sLocalName)
+: XMLTextFieldImportContext(rImport, rHlp, sAPI_page_number, nPrfx, sLocalName)
+, sPropertySubType(sAPI_sub_type)
+, sPropertyNumberingType(sAPI_numbering_type)
+, eSelectPage(PageNumberType_CURRENT)
+, sStringOK(false)
+{
+ bValid = true;
+}
+
+void XMLPageContinuationImportContext::ProcessAttribute(
+ sal_uInt16 nAttrToken, const OUString& sAttrValue )
+{
+ switch(nAttrToken)
+ {
+ case XML_TOK_TEXTFIELD_SELECT_PAGE:
+ {
+ PageNumberType nTmp;
+ if (SvXMLUnitConverter::convertEnum(nTmp, sAttrValue,
+ lcl_aSelectPageAttrMap)
+ && (PageNumberType_CURRENT != nTmp) )
+ {
+ eSelectPage = nTmp;
+ }
+ break;
+ }
+ case XML_TOK_TEXTFIELD_STRING_VALUE:
+ sString = sAttrValue;
+ sStringOK = true;
+ break;
+ }
+}
+
+void XMLPageContinuationImportContext::PrepareField(
+ const Reference<XPropertySet> & xPropertySet)
+{
+ Any aAny;
+
+ xPropertySet->setPropertyValue(sPropertySubType, Any(eSelectPage));
+
+ aAny <<= (sStringOK ? sString : GetContent());
+ xPropertySet->setPropertyValue(gsPropertyUserText, aAny);
+
+ aAny <<= style::NumberingType::CHAR_SPECIAL;
+ xPropertySet->setPropertyValue(sPropertyNumberingType, aAny);
+}
+
+
+// page number field
+
+
+XMLPageNumberImportContext::XMLPageNumberImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx,
+ const OUString& sLocalName)
+: XMLTextFieldImportContext(rImport, rHlp, sAPI_page_number, nPrfx, sLocalName)
+, sPropertySubType(sAPI_sub_type)
+, sPropertyNumberingType(sAPI_numbering_type)
+, sPropertyOffset(sAPI_offset)
+, sNumberSync(GetXMLToken(XML_FALSE))
+, nPageAdjust(0)
+, eSelectPage(PageNumberType_CURRENT)
+, sNumberFormatOK(false)
+{
+ bValid = true;
+}
+
+void XMLPageNumberImportContext::ProcessAttribute(
+ sal_uInt16 nAttrToken,
+ const OUString& sAttrValue )
+{
+ switch (nAttrToken)
+ {
+ case XML_TOK_TEXTFIELD_NUM_FORMAT:
+ sNumberFormat = sAttrValue;
+ sNumberFormatOK = true;
+ break;
+ case XML_TOK_TEXTFIELD_NUM_LETTER_SYNC:
+ sNumberSync = sAttrValue;
+ break;
+ case XML_TOK_TEXTFIELD_SELECT_PAGE:
+ SvXMLUnitConverter::convertEnum(eSelectPage, sAttrValue,
+ lcl_aSelectPageAttrMap);
+ break;
+ case XML_TOK_TEXTFIELD_PAGE_ADJUST:
+ {
+ sal_Int32 nTmp;
+ if (::sax::Converter::convertNumber(nTmp, sAttrValue))
+ {
+ nPageAdjust = static_cast<sal_Int16>(nTmp);
+ }
+ break;
+ }
+ }
+}
+
+void XMLPageNumberImportContext::PrepareField(
+ const Reference<XPropertySet> & xPropertySet)
+{
+ // all properties are optional
+ Reference<XPropertySetInfo> 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;
+
+ xPropertySet->setPropertyValue(sPropertyNumberingType, Any(nNumType));
+ }
+
+ if (xPropertySetInfo->hasPropertyByName(sPropertyOffset))
+ {
+ // adjust offset
+ switch (eSelectPage)
+ {
+ case PageNumberType_PREV:
+ nPageAdjust--;
+ break;
+ case PageNumberType_CURRENT:
+ break;
+ case PageNumberType_NEXT:
+ nPageAdjust++;
+ break;
+ default:
+ SAL_WARN("xmloff.text", "unknown page number type");
+ }
+ xPropertySet->setPropertyValue(sPropertyOffset, Any(nPageAdjust));
+ }
+
+ if (xPropertySetInfo->hasPropertyByName(sPropertySubType))
+ {
+ xPropertySet->setPropertyValue(sPropertySubType, Any(eSelectPage));
+ }
+}
+
+
+// Placeholder
+
+
+static const OUStringLiteral gsPropertyPlaceholderType("PlaceHolderType");
+static const OUStringLiteral gsPropertyPlaceholder("PlaceHolder");
+
+XMLPlaceholderFieldImportContext::XMLPlaceholderFieldImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx, const OUString& sLocalName)
+: XMLTextFieldImportContext(rImport, rHlp, "JumpEdit", nPrfx, sLocalName)
+, sPropertyHint(sAPI_hint)
+, nPlaceholderType(PlaceholderType::TEXT)
+{
+}
+
+/// 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 = 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 = false;
+ }
+ break;
+
+ default:
+ ; // ignore
+ }
+}
+
+void XMLPlaceholderFieldImportContext::PrepareField(
+ const Reference<XPropertySet> & xPropertySet) {
+
+ Any aAny;
+ xPropertySet->setPropertyValue(sPropertyHint, Any(sDescription));
+
+ // remove <...> around content (if present)
+ OUString aContent = GetContent();
+ sal_Int32 nStart = 0;
+ sal_Int32 nLength = aContent.getLength();
+ if (aContent.startsWith("<"))
+ {
+ --nLength;
+ ++nStart;
+ }
+ if (aContent.endsWith(">"))
+ {
+ --nLength;
+ }
+ aAny <<= aContent.copy(nStart, nLength);
+ xPropertySet->setPropertyValue(gsPropertyPlaceholder, aAny);
+
+ xPropertySet->setPropertyValue(gsPropertyPlaceholderType, Any(nPlaceholderType));
+}
+
+
+// time field
+
+static const OUStringLiteral gsPropertyAdjust("Adjust");
+
+XMLTimeFieldImportContext::XMLTimeFieldImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx, const OUString& sLocalName)
+: XMLTextFieldImportContext(rImport, rHlp, sAPI_date_time, nPrfx, sLocalName)
+, sPropertyNumberFormat(sAPI_number_format)
+, sPropertyFixed(sAPI_is_fixed)
+, sPropertyDateTimeValue(sAPI_date_time_value)
+, sPropertyDateTime(sAPI_date_time)
+, sPropertyIsDate(sAPI_is_date)
+, sPropertyIsFixedLanguage(sAPI_is_fixed_language)
+, nAdjust(0)
+, nFormatKey(0)
+, bTimeOK(false)
+, bFormatOK(false)
+, bFixed(false)
+, bIsDate(false)
+, bIsDefaultLanguage( true )
+{
+ bValid = true; // always valid!
+}
+
+void XMLTimeFieldImportContext::ProcessAttribute(
+ sal_uInt16 nAttrToken, const OUString& sAttrValue )
+{
+ switch (nAttrToken)
+ {
+ case XML_TOK_TEXTFIELD_TIME_VALUE:
+ {
+ if (::sax::Converter::parseTimeOrDateTime(aDateTimeValue, sAttrValue))
+ {
+ bTimeOK = true;
+ }
+ break;
+ }
+ case XML_TOK_TEXTFIELD_FIXED:
+ {
+ bool bTmp(false);
+ if (::sax::Converter::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 = true;
+ }
+ break;
+ }
+ case XML_TOK_TEXTFIELD_TIME_ADJUST:
+ {
+ double fTmp;
+
+ if (::sax::Converter::convertDuration(fTmp, sAttrValue))
+ {
+ // convert to minutes
+ nAdjust = static_cast<sal_Int32>(::rtl::math::approxFloor(fTmp * 60 * 24));
+ }
+ break;
+ }
+ }
+}
+
+void XMLTimeFieldImportContext::PrepareField(
+ const Reference<XPropertySet> & rPropertySet)
+{
+ // all properties are optional (except IsDate)
+ Reference<XPropertySetInfo> xPropertySetInfo(
+ rPropertySet->getPropertySetInfo());
+
+ if (xPropertySetInfo->hasPropertyByName(sPropertyFixed))
+ {
+ rPropertySet->setPropertyValue(sPropertyFixed, Any(bFixed));
+ }
+
+ rPropertySet->setPropertyValue(sPropertyIsDate, Any(bIsDate));
+
+ if (xPropertySetInfo->hasPropertyByName(gsPropertyAdjust))
+ {
+ rPropertySet->setPropertyValue(gsPropertyAdjust, Any(nAdjust));
+ }
+
+ // 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))
+ {
+ rPropertySet->setPropertyValue(sPropertyDateTimeValue, Any(aDateTimeValue));
+ }
+ else if (xPropertySetInfo->hasPropertyByName(sPropertyDateTime))
+ {
+ rPropertySet->setPropertyValue(sPropertyDateTime, Any(aDateTimeValue));
+ }
+ }
+ }
+ }
+
+ if (bFormatOK &&
+ xPropertySetInfo->hasPropertyByName(sPropertyNumberFormat))
+ {
+ rPropertySet->setPropertyValue(sPropertyNumberFormat, Any(nFormatKey));
+
+ if( xPropertySetInfo->hasPropertyByName( sPropertyIsFixedLanguage ) )
+ {
+ bool bIsFixedLanguage = ! bIsDefaultLanguage;
+ rPropertySet->setPropertyValue( sPropertyIsFixedLanguage, Any(bIsFixedLanguage) );
+ }
+ }
+}
+
+
+// date field
+
+
+XMLDateFieldImportContext::XMLDateFieldImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx, const OUString& sLocalName) :
+ XMLTimeFieldImportContext(rImport, rHlp, nPrfx, sLocalName)
+{
+ bIsDate = true; // always a date!
+}
+
+void XMLDateFieldImportContext::ProcessAttribute(
+ sal_uInt16 nAttrToken,
+ const OUString& sAttrValue )
+{
+ switch (nAttrToken)
+ {
+ case XML_TOK_TEXTFIELD_DATE_VALUE:
+ {
+ if (::sax::Converter::parseDateTime(aDateTimeValue, sAttrValue))
+ {
+ bTimeOK = 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
+
+
+static const OUStringLiteral gsPropertyDataBaseName("DataBaseName");
+static const OUStringLiteral gsPropertyDataBaseURL("DataBaseURL");
+static const OUStringLiteral gsPropertyTableName("DataTableName");
+static const OUStringLiteral gsPropertyDataCommandType("DataCommandType");
+static const OUStringLiteral gsPropertyIsVisible("IsVisible");
+
+XMLDatabaseFieldImportContext::XMLDatabaseFieldImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp,
+ const char* pServiceName, sal_uInt16 nPrfx,
+ const OUString& sLocalName, bool bUseDisply)
+: XMLTextFieldImportContext(rImport, rHlp, pServiceName, nPrfx, sLocalName)
+, nCommandType( sdb::CommandType::TABLE )
+, bCommandTypeOK(false)
+, bDisplay( true )
+, bDisplayOK( false )
+, bUseDisplay( bUseDisply )
+, bDatabaseOK(false)
+, bDatabaseNameOK(false)
+, bDatabaseURLOK(false)
+, bTableOK(false)
+{
+}
+
+void XMLDatabaseFieldImportContext::ProcessAttribute(
+ sal_uInt16 nAttrToken, const OUString& sAttrValue )
+{
+ switch (nAttrToken)
+ {
+ case XML_TOK_TEXTFIELD_DATABASE_NAME:
+ sDatabaseName = sAttrValue;
+ bDatabaseOK = true;
+ bDatabaseNameOK = true;
+ break;
+ case XML_TOK_TEXTFIELD_TABLE_NAME:
+ sTableName = sAttrValue;
+ bTableOK = true;
+ break;
+ case XML_TOK_TEXTFIELD_TABLE_TYPE:
+ if( IsXMLToken( sAttrValue, XML_TABLE ) )
+ {
+ nCommandType = sdb::CommandType::TABLE;
+ bCommandTypeOK = true;
+ }
+ else if( IsXMLToken( sAttrValue, XML_QUERY ) )
+ {
+ nCommandType = sdb::CommandType::QUERY;
+ bCommandTypeOK = true;
+ }
+ else if( IsXMLToken( sAttrValue, XML_COMMAND ) )
+ {
+ nCommandType = sdb::CommandType::COMMAND;
+ bCommandTypeOK = true;
+ }
+ break;
+ case XML_TOK_TEXTFIELD_DISPLAY:
+ if( IsXMLToken( sAttrValue, XML_NONE ) )
+ {
+ bDisplay = false;
+ bDisplayOK = true;
+ }
+ else if( IsXMLToken( sAttrValue, XML_VALUE ) )
+ {
+ bDisplay = true;
+ bDisplayOK = true;
+ }
+ break;
+ }
+}
+
+SvXMLImportContextRef XMLDatabaseFieldImportContext::CreateChildContext(
+ sal_uInt16 p_nPrefix,
+ const OUString& rLocalName,
+ const Reference<XAttributeList>& 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 = true;
+ bDatabaseURLOK = true;
+ }
+ }
+
+ // we call ProcessAttribute in order to set bValid appropriately
+ ProcessAttribute( XML_TOKEN_INVALID, OUString() );
+ }
+
+ return SvXMLImportContext::CreateChildContext(p_nPrefix, rLocalName,
+ xAttrList);
+}
+
+
+void XMLDatabaseFieldImportContext::PrepareField(
+ const Reference<XPropertySet> & xPropertySet)
+{
+ xPropertySet->setPropertyValue(gsPropertyTableName, Any(sTableName));
+
+ if( bDatabaseNameOK )
+ {
+ xPropertySet->setPropertyValue(gsPropertyDataBaseName, Any(sDatabaseName));
+ }
+ else if( bDatabaseURLOK )
+ {
+ xPropertySet->setPropertyValue(gsPropertyDataBaseURL, Any(sDatabaseURL));
+ }
+
+ // #99980# load/save command type for all fields; also load
+ // old documents without command type
+ if( bCommandTypeOK )
+ {
+ xPropertySet->setPropertyValue( gsPropertyDataCommandType, Any(nCommandType) );
+ }
+
+ if( bUseDisplay && bDisplayOK )
+ {
+ xPropertySet->setPropertyValue( gsPropertyIsVisible, Any(bDisplay) );
+ }
+}
+
+
+// database name field
+
+
+XMLDatabaseNameImportContext::XMLDatabaseNameImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx, const OUString& sLocalName) :
+ XMLDatabaseFieldImportContext(rImport, rHlp, "DatabaseName",
+ 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
+
+
+XMLDatabaseNextImportContext::XMLDatabaseNextImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp,
+ const char* pServiceName, sal_uInt16 nPrfx,
+ const OUString& sLocalName) :
+ XMLDatabaseFieldImportContext(rImport, rHlp, pServiceName,
+ nPrfx, sLocalName, false),
+ sPropertyCondition(sAPI_condition),
+ sTrue(sAPI_true),
+ sCondition(),
+ bConditionOK(false)
+{
+}
+
+XMLDatabaseNextImportContext::XMLDatabaseNextImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx, const OUString& sLocalName)
+: XMLDatabaseFieldImportContext(rImport, rHlp, "DatabaseNextSet", nPrfx, sLocalName, false)
+, sPropertyCondition(sAPI_condition)
+, sTrue(sAPI_true)
+, bConditionOK(false)
+{
+}
+
+void XMLDatabaseNextImportContext::ProcessAttribute(
+ sal_uInt16 nAttrToken, const OUString& sAttrValue )
+{
+ if (XML_TOK_TEXTFIELD_CONDITION == nAttrToken)
+ {
+ OUString sTmp;
+ sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrValueQName(
+ sAttrValue, &sTmp );
+ if( XML_NAMESPACE_OOOW == nPrefix )
+ {
+ sCondition = sTmp;
+ bConditionOK = true;
+ }
+ else
+ sCondition = sAttrValue;
+ }
+ else
+ {
+ XMLDatabaseFieldImportContext::ProcessAttribute(nAttrToken,
+ sAttrValue);
+ }
+
+ bValid = bDatabaseOK && bTableOK;
+}
+
+void XMLDatabaseNextImportContext::PrepareField(
+ const Reference<XPropertySet> & xPropertySet)
+{
+ Any aAny;
+
+ aAny <<= bConditionOK ? sCondition : sTrue;
+ xPropertySet->setPropertyValue(sPropertyCondition, aAny);
+
+ XMLDatabaseFieldImportContext::PrepareField(xPropertySet);
+}
+
+
+// database select field
+
+
+XMLDatabaseSelectImportContext::XMLDatabaseSelectImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx, const OUString& sLocalName) :
+ XMLDatabaseNextImportContext(rImport, rHlp, "DatabaseNumberOfSet",
+ nPrfx, sLocalName),
+ sPropertySetNumber(sAPI_set_number),
+ nNumber(0),
+ bNumberOK(false)
+{
+}
+
+void XMLDatabaseSelectImportContext::ProcessAttribute(
+ sal_uInt16 nAttrToken,
+ const OUString& sAttrValue )
+{
+ if (XML_TOK_TEXTFIELD_ROW_NUMBER == nAttrToken)
+ {
+ sal_Int32 nTmp;
+ if (::sax::Converter::convertNumber( nTmp, sAttrValue
+ /* , nMin, nMax ??? */ ))
+ {
+ nNumber = nTmp;
+ bNumberOK = true;
+ }
+ }
+ else
+ {
+ XMLDatabaseNextImportContext::ProcessAttribute(nAttrToken, sAttrValue);
+ }
+
+ bValid = bTableOK && bDatabaseOK && bNumberOK;
+}
+
+void XMLDatabaseSelectImportContext::PrepareField(
+ const Reference<XPropertySet> & xPropertySet)
+{
+ xPropertySet->setPropertyValue(sPropertySetNumber, Any(nNumber));
+
+ XMLDatabaseNextImportContext::PrepareField(xPropertySet);
+}
+
+
+// database display row number field
+
+
+XMLDatabaseNumberImportContext::XMLDatabaseNumberImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx, const OUString& sLocalName) :
+ XMLDatabaseFieldImportContext(rImport, rHlp, "DatabaseSetNumber",
+ nPrfx, sLocalName, true),
+ sPropertyNumberingType(
+ sAPI_numbering_type),
+ sPropertySetNumber(sAPI_set_number),
+ sNumberFormat("1"),
+ sNumberSync(GetXMLToken(XML_FALSE)),
+ nValue(0),
+ bValueOK(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 (::sax::Converter::convertNumber( nTmp, sAttrValue ))
+ {
+ nValue = nTmp;
+ bValueOK = true;
+ }
+ break;
+ }
+ default:
+ XMLDatabaseFieldImportContext::ProcessAttribute(nAttrToken,
+ sAttrValue);
+ break;
+ }
+
+ bValid = bTableOK && bDatabaseOK;
+}
+
+void XMLDatabaseNumberImportContext::PrepareField(
+ const Reference<XPropertySet> & xPropertySet)
+{
+ sal_Int16 nNumType = style::NumberingType::ARABIC;
+ GetImport().GetMM100UnitConverter().convertNumFormat( nNumType,
+ sNumberFormat,
+ sNumberSync );
+ xPropertySet->setPropertyValue(sPropertyNumberingType, Any(nNumType));
+
+ if (bValueOK)
+ {
+ xPropertySet->setPropertyValue(sPropertySetNumber, Any(nValue));
+ }
+
+ XMLDatabaseFieldImportContext::PrepareField(xPropertySet);
+}
+
+
+// Simple doc info fields
+
+
+XMLSimpleDocInfoImportContext::XMLSimpleDocInfoImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx, const OUString& sLocalName, sal_uInt16 nToken,
+ bool bContent, bool bAuthor)
+: XMLTextFieldImportContext(rImport, rHlp, MapTokenToServiceName(nToken),nPrfx, sLocalName)
+, sPropertyFixed(sAPI_is_fixed)
+, sPropertyContent(sAPI_content)
+, sPropertyAuthor(sAPI_author)
+, sPropertyCurrentPresentation(sAPI_current_presentation)
+, bFixed(false)
+, bHasAuthor(bAuthor)
+, bHasContent(bContent)
+{
+ bValid = true;
+}
+
+void XMLSimpleDocInfoImportContext::ProcessAttribute(
+ sal_uInt16 nAttrToken,
+ const OUString& sAttrValue )
+{
+ if (XML_TOK_TEXTFIELD_FIXED == nAttrToken)
+ {
+ bool bTmp(false);
+ if (::sax::Converter::convertBool(bTmp, sAttrValue))
+ {
+ bFixed = bTmp;
+ }
+ }
+}
+
+void XMLSimpleDocInfoImportContext::PrepareField(
+ const Reference<XPropertySet> & rPropertySet)
+{
+ // title field in Calc has no Fixed property
+ Reference<XPropertySetInfo> xPropertySetInfo(rPropertySet->getPropertySetInfo());
+ if (xPropertySetInfo->hasPropertyByName(sPropertyFixed))
+ {
+ Any aAny;
+ rPropertySet->setPropertyValue(sPropertyFixed, Any(bFixed));
+
+ // 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 char* XMLSimpleDocInfoImportContext::MapTokenToServiceName(
+ sal_uInt16 nToken)
+{
+ const char* pServiceName = nullptr;
+
+ switch(nToken)
+ {
+ case XML_TOK_TEXT_DOCUMENT_CREATION_AUTHOR:
+ pServiceName = "DocInfo.CreateAuthor";
+ 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 = "DocInfo.Description";
+ break;
+ case XML_TOK_TEXT_DOCUMENT_EDIT_DURATION:
+ pServiceName = "DocInfo.EditTime";
+ break;
+ case XML_TOK_TEXT_DOCUMENT_USER_DEFINED:
+ pServiceName = sAPI_docinfo_custom;
+ break;
+ case XML_TOK_TEXT_DOCUMENT_PRINT_AUTHOR:
+ pServiceName = "DocInfo.PrintAuthor";
+ 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 = "DocInfo.KeyWords";
+ break;
+ case XML_TOK_TEXT_DOCUMENT_SUBJECT:
+ pServiceName = "DocInfo.Subject";
+ break;
+ case XML_TOK_TEXT_DOCUMENT_REVISION:
+ pServiceName = "DocInfo.Revision";
+ break;
+ case XML_TOK_TEXT_DOCUMENT_SAVE_AUTHOR:
+ pServiceName = "DocInfo.ChangeAuthor";
+ 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 = "DocInfo.Title";
+ break;
+
+ default:
+ OSL_FAIL("no docinfo field token");
+ pServiceName = nullptr;
+ break;
+ }
+
+ return pServiceName;
+}
+
+
+// revision field
+
+static const OUStringLiteral sPropertyRevision("Revision");
+
+XMLRevisionDocInfoImportContext::XMLRevisionDocInfoImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx,
+ const OUString& sLocalName, sal_uInt16 nToken) :
+ XMLSimpleDocInfoImportContext(rImport, rHlp, nPrfx, sLocalName,
+ nToken, false, false)
+{
+ bValid = true;
+}
+
+void XMLRevisionDocInfoImportContext::PrepareField(
+ const Reference<XPropertySet> & 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 (::sax::Converter::convertNumber(nTmp, GetContent()))
+ {
+ rPropertySet->setPropertyValue(sPropertyRevision, Any(nTmp));
+ }
+ }
+ }
+}
+
+
+// DocInfo fields with date/time attributes
+
+
+XMLDateTimeDocInfoImportContext::XMLDateTimeDocInfoImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx,
+ const OUString& sLocalName, sal_uInt16 nToken)
+ : XMLSimpleDocInfoImportContext(rImport, rHlp, nPrfx, sLocalName,nToken, false, false)
+ , sPropertyNumberFormat(sAPI_number_format)
+ , sPropertyIsDate(sAPI_is_date)
+ , sPropertyIsFixedLanguage(sAPI_is_fixed_language)
+ , nFormat(0)
+ , bFormatOK(false)
+ , bIsDate(false)
+ , bHasDateTime(false)
+ , bIsDefaultLanguage(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 = 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 = true;
+ bHasDateTime = true;
+ break;
+ case XML_TOK_TEXT_DOCUMENT_CREATION_TIME:
+ case XML_TOK_TEXT_DOCUMENT_PRINT_TIME:
+ case XML_TOK_TEXT_DOCUMENT_SAVE_TIME:
+ bIsDate = false;
+ bHasDateTime = true;
+ break;
+ case XML_TOK_TEXT_DOCUMENT_EDIT_DURATION:
+ bIsDate = false;
+ bHasDateTime = false;
+ break;
+ default:
+ OSL_FAIL(
+ "XMLDateTimeDocInfoImportContext needs date/time doc. fields");
+ bValid = 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 = 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> & xPropertySet)
+{
+ // process fixed and presentation
+ XMLSimpleDocInfoImportContext::PrepareField(xPropertySet);
+
+ if (bHasDateTime)
+ {
+ xPropertySet->setPropertyValue(sPropertyIsDate, Any(bIsDate));
+ }
+
+ if (bFormatOK)
+ {
+ xPropertySet->setPropertyValue(sPropertyNumberFormat, Any(nFormat));
+
+ if( xPropertySet->getPropertySetInfo()->
+ hasPropertyByName( sPropertyIsFixedLanguage ) )
+ {
+ bool bIsFixedLanguage = ! bIsDefaultLanguage;
+ xPropertySet->setPropertyValue( sPropertyIsFixedLanguage, Any(bIsFixedLanguage) );
+ }
+ }
+
+ // can't set date/time/duration value! Sorry.
+}
+
+
+// user defined docinfo fields
+
+
+XMLUserDocInfoImportContext::XMLUserDocInfoImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx, const OUString& sLocalName, sal_uInt16 nToken) :
+ XMLSimpleDocInfoImportContext(rImport, rHlp, nPrfx,
+ sLocalName, nToken,
+ false, false)
+ , sPropertyName(sAPI_name)
+ , sPropertyNumberFormat(sAPI_number_format)
+ , sPropertyIsFixedLanguage(sAPI_is_fixed_language)
+ , nFormat(0)
+ , bFormatOK(false)
+ , bIsDefaultLanguage( true )
+{
+ bValid = 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 = true;
+ }
+ break;
+ }
+ case XML_TOK_TEXTFIELD_NAME:
+ {
+ if (!bValid)
+ {
+ SetServiceName(sAPI_docinfo_custom );
+ aName = sAttrValue;
+ bValid = true;
+ }
+ break;
+ }
+
+ default:
+ XMLSimpleDocInfoImportContext::ProcessAttribute(nAttrToken,
+ sAttrValue);
+ break;
+ }
+}
+
+void XMLUserDocInfoImportContext::PrepareField(
+ const css::uno::Reference<css::beans::XPropertySet> & xPropertySet)
+{
+ if ( !aName.isEmpty() )
+ {
+ xPropertySet->setPropertyValue(sPropertyName, Any(aName));
+ }
+ Reference<XPropertySetInfo> xPropertySetInfo(
+ xPropertySet->getPropertySetInfo());
+ if (bFormatOK &&
+ xPropertySetInfo->hasPropertyByName(sPropertyNumberFormat))
+ {
+ xPropertySet->setPropertyValue(sPropertyNumberFormat, Any(nFormat));
+
+ if( xPropertySetInfo->hasPropertyByName( sPropertyIsFixedLanguage ) )
+ {
+ bool bIsFixedLanguage = ! bIsDefaultLanguage;
+ xPropertySet->setPropertyValue( sPropertyIsFixedLanguage, Any(bIsFixedLanguage) );
+ }
+ }
+
+ // call superclass to handle "fixed"
+ XMLSimpleDocInfoImportContext::PrepareField(xPropertySet);
+}
+
+
+// import hidden paragraph fields
+
+
+XMLHiddenParagraphImportContext::XMLHiddenParagraphImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx, const OUString& sLocalName) :
+ XMLTextFieldImportContext(rImport, rHlp, "HiddenParagraph",
+ nPrfx, sLocalName),
+ sPropertyCondition(sAPI_condition),
+ sPropertyIsHidden(sAPI_is_hidden),
+ sCondition(),
+ bIsHidden(false)
+{
+}
+
+void XMLHiddenParagraphImportContext::ProcessAttribute(
+ sal_uInt16 nAttrToken,
+ const OUString& sAttrValue )
+{
+ if (XML_TOK_TEXTFIELD_CONDITION == nAttrToken)
+ {
+ OUString sTmp;
+ sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrValueQName(
+ sAttrValue, &sTmp );
+ if( XML_NAMESPACE_OOOW == nPrefix )
+ {
+ sCondition = sTmp;
+ bValid = true;
+ }
+ else
+ sCondition = sAttrValue;
+ }
+ else if (XML_TOK_TEXTFIELD_IS_HIDDEN == nAttrToken)
+ {
+ bool bTmp(false);
+ if (::sax::Converter::convertBool(bTmp, sAttrValue))
+ {
+ bIsHidden = bTmp;
+ }
+ }
+}
+
+void XMLHiddenParagraphImportContext::PrepareField(
+ const Reference<XPropertySet> & xPropertySet)
+{
+ xPropertySet->setPropertyValue(sPropertyCondition, Any(sCondition));
+ xPropertySet->setPropertyValue(sPropertyIsHidden, Any(bIsHidden));
+}
+
+
+// import conditional text (<text:conditional-text>)
+
+static const OUStringLiteral gsPropertyTrueContent("TrueContent");
+static const OUStringLiteral gsPropertyFalseContent("FalseContent");
+static const OUStringLiteral gsPropertyIsConditionTrue("IsConditionTrue");
+
+XMLConditionalTextImportContext::XMLConditionalTextImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx, const OUString& sLocalName) :
+ XMLTextFieldImportContext(rImport, rHlp, "ConditionalText",
+ nPrfx, sLocalName),
+ sPropertyCondition(sAPI_condition),
+ sPropertyCurrentPresentation(sAPI_current_presentation),
+ bConditionOK(false),
+ bTrueOK(false),
+ bFalseOK(false),
+ bCurrentValue(false)
+{
+}
+
+void XMLConditionalTextImportContext::ProcessAttribute(
+ sal_uInt16 nAttrToken,
+ const OUString& sAttrValue )
+{
+ switch (nAttrToken)
+ {
+ case XML_TOK_TEXTFIELD_CONDITION:
+ {
+ OUString sTmp;
+ sal_uInt16 nPrefix = GetImport().GetNamespaceMap().
+ GetKeyByAttrValueQName(sAttrValue, &sTmp);
+ if( XML_NAMESPACE_OOOW == nPrefix )
+ {
+ sCondition = sTmp;
+ bConditionOK = true;
+ }
+ else
+ sCondition = sAttrValue;
+ }
+ break;
+ case XML_TOK_TEXTFIELD_STRING_VALUE_IF_FALSE:
+ sFalseContent = sAttrValue;
+ bFalseOK = true;
+ break;
+ case XML_TOK_TEXTFIELD_STRING_VALUE_IF_TRUE:
+ sTrueContent = sAttrValue;
+ bTrueOK = true;
+ break;
+ case XML_TOK_TEXTFIELD_CURRENT_VALUE:
+ {
+ bool bTmp(false);
+ if (::sax::Converter::convertBool(bTmp, sAttrValue))
+ {
+ bCurrentValue = bTmp;
+ }
+ break;
+ }
+ }
+
+ bValid = bConditionOK && bFalseOK && bTrueOK;
+}
+
+void XMLConditionalTextImportContext::PrepareField(
+ const Reference<XPropertySet> & xPropertySet)
+{
+ xPropertySet->setPropertyValue(sPropertyCondition, Any(sCondition));
+ xPropertySet->setPropertyValue(gsPropertyFalseContent, Any(sFalseContent));
+ xPropertySet->setPropertyValue(gsPropertyTrueContent, Any(sTrueContent));
+ xPropertySet->setPropertyValue(gsPropertyIsConditionTrue, Any(bCurrentValue));
+ xPropertySet->setPropertyValue(sPropertyCurrentPresentation, Any(GetContent()));
+}
+
+
+// hidden text
+
+
+XMLHiddenTextImportContext::XMLHiddenTextImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx, const OUString& sLocalName) :
+ XMLTextFieldImportContext(rImport, rHlp, "HiddenText",
+ nPrfx, sLocalName),
+ sPropertyCondition(sAPI_condition),
+ sPropertyContent(sAPI_content),
+ sPropertyIsHidden(sAPI_is_hidden),
+ bConditionOK(false),
+ bStringOK(false),
+ bIsHidden(false)
+{
+}
+
+void XMLHiddenTextImportContext::ProcessAttribute(
+ sal_uInt16 nAttrToken,
+ const OUString& sAttrValue )
+{
+ switch (nAttrToken)
+ {
+ case XML_TOK_TEXTFIELD_CONDITION:
+ {
+ OUString sTmp;
+ sal_uInt16 nPrefix = GetImport().GetNamespaceMap().
+ GetKeyByAttrValueQName(sAttrValue, &sTmp);
+ if( XML_NAMESPACE_OOOW == nPrefix )
+ {
+ sCondition = sTmp;
+ bConditionOK = true;
+ }
+ else
+ sCondition = sAttrValue;
+ }
+ break;
+ case XML_TOK_TEXTFIELD_STRING_VALUE:
+ sString = sAttrValue;
+ bStringOK = true;
+ break;
+ case XML_TOK_TEXTFIELD_IS_HIDDEN:
+ {
+ bool bTmp(false);
+ if (::sax::Converter::convertBool(bTmp, sAttrValue))
+ {
+ bIsHidden = bTmp;
+ }
+ break;
+ }
+ }
+
+ bValid = bConditionOK && bStringOK;
+}
+
+void XMLHiddenTextImportContext::PrepareField(
+ const Reference<XPropertySet> & xPropertySet)
+{
+ xPropertySet->setPropertyValue(sPropertyCondition, Any(sCondition));
+ xPropertySet->setPropertyValue(sPropertyContent, Any(sString));
+ xPropertySet->setPropertyValue(sPropertyIsHidden, Any(bIsHidden));
+}
+
+
+// file name fields
+
+
+static const SvXMLEnumMapEntry<sal_uInt16> 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, "FileName",
+ nPrfx, sLocalName),
+ sPropertyFixed(sAPI_is_fixed),
+ sPropertyFileFormat(sAPI_file_format),
+ sPropertyCurrentPresentation(
+ sAPI_current_presentation),
+ nFormat(FilenameDisplayFormat::FULL),
+ bFixed(false)
+{
+ bValid = true;
+}
+
+void XMLFileNameImportContext::ProcessAttribute(
+ sal_uInt16 nAttrToken,
+ const OUString& sAttrValue )
+{
+ switch (nAttrToken)
+ {
+ case XML_TOK_TEXTFIELD_FIXED:
+ {
+ bool bTmp(false);
+ if (::sax::Converter::convertBool(bTmp, sAttrValue))
+ {
+ bFixed = bTmp;
+ }
+ break;
+ }
+ case XML_TOK_TEXTFIELD_DISPLAY:
+ {
+ sal_uInt16 nTmp;
+ if (SvXMLUnitConverter::convertEnum(nTmp, sAttrValue,
+ aFilenameDisplayMap))
+ {
+ nFormat = nTmp;
+ }
+ break;
+ }
+ default:
+ ; // unknown attribute: ignore
+ break;
+ }
+}
+
+void XMLFileNameImportContext::PrepareField(
+ const Reference<XPropertySet> & xPropertySet)
+{
+ // properties are optional
+ Reference<XPropertySetInfo> xPropertySetInfo(
+ xPropertySet->getPropertySetInfo());
+
+ if (xPropertySetInfo->hasPropertyByName(sPropertyFixed))
+ {
+ xPropertySet->setPropertyValue(sPropertyFixed, Any(bFixed));
+ }
+
+ if (xPropertySetInfo->hasPropertyByName(sPropertyFileFormat))
+ {
+ xPropertySet->setPropertyValue(sPropertyFileFormat, Any(nFormat));
+ }
+
+ if (xPropertySetInfo->hasPropertyByName(sPropertyCurrentPresentation))
+ {
+ xPropertySet->setPropertyValue(sPropertyCurrentPresentation, Any(GetContent()));
+ }
+}
+
+
+// template name field
+
+
+static const SvXMLEnumMapEntry<sal_uInt16> 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 }
+};
+
+
+XMLTemplateNameImportContext::XMLTemplateNameImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx,
+ const OUString& sLocalName) :
+ XMLTextFieldImportContext(rImport, rHlp, "TemplateName",
+ nPrfx, sLocalName),
+ sPropertyFileFormat(sAPI_file_format),
+ nFormat(TemplateDisplayFormat::FULL)
+{
+ bValid = 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 = nTmp;
+ }
+ break;
+ }
+ default:
+ ; // unknown attribute: ignore
+ break;
+ }
+}
+
+void XMLTemplateNameImportContext::PrepareField(
+ const Reference<XPropertySet> & xPropertySet)
+{
+ xPropertySet->setPropertyValue(sPropertyFileFormat, Any(nFormat));
+}
+
+
+// import chapter fields
+
+
+static const SvXMLEnumMapEntry<sal_uInt16> 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 }
+};
+
+static const OUStringLiteral gsPropertyChapterFormat("ChapterFormat");
+static const OUStringLiteral gsPropertyLevel("Level");
+
+XMLChapterImportContext::XMLChapterImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx, const OUString& sLocalName) :
+ XMLTextFieldImportContext(rImport, rHlp, "Chapter",
+ nPrfx, sLocalName),
+ nFormat(ChapterFormat::NAME_NUMBER),
+ nLevel(0)
+{
+ bValid = 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 = static_cast<sal_Int16>(nTmp);
+ }
+ break;
+ }
+ case XML_TOK_TEXTFIELD_OUTLINE_LEVEL:
+ {
+ sal_Int32 nTmp;
+ if (::sax::Converter::convertNumber(
+ nTmp, sAttrValue, 1,
+ GetImport().GetTextImport()->GetChapterNumbering()->getCount()
+ ))
+ {
+ // API numbers 0..9, we number 1..10
+ nLevel = static_cast<sal_Int8>(nTmp);
+ nLevel--;
+ }
+ break;
+ }
+ default:
+ ; // unknown attribute: ignore
+ break;
+ }
+}
+
+void XMLChapterImportContext::PrepareField(
+ const Reference<XPropertySet> & xPropertySet)
+{
+ xPropertySet->setPropertyValue(gsPropertyChapterFormat, Any(nFormat));
+ xPropertySet->setPropertyValue(gsPropertyLevel, Any(nLevel));
+}
+
+
+// counting fields
+
+
+XMLCountFieldImportContext::XMLCountFieldImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx, const OUString& sLocalName, sal_uInt16 nToken) :
+ XMLTextFieldImportContext(rImport, rHlp, MapTokenToServiceName(nToken),
+ nPrfx, sLocalName),
+ sPropertyNumberingType(
+ sAPI_numbering_type),
+ sNumberFormat(),
+ sLetterSync(),
+ bNumberFormatOK(false)
+{
+ bValid = true;
+}
+
+void XMLCountFieldImportContext::ProcessAttribute(
+ sal_uInt16 nAttrToken,
+ const OUString& sAttrValue )
+{
+ switch (nAttrToken)
+ {
+ case XML_TOK_TEXTFIELD_NUM_FORMAT:
+ sNumberFormat = sAttrValue;
+ bNumberFormatOK = true;
+ break;
+ case XML_TOK_TEXTFIELD_NUM_LETTER_SYNC:
+ sLetterSync = sAttrValue;
+ break;
+ }
+}
+
+void XMLCountFieldImportContext::PrepareField(
+ const Reference<XPropertySet> & xPropertySet)
+{
+ // 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;
+ xPropertySet->setPropertyValue(sPropertyNumberingType, Any(nNumType));
+ }
+}
+
+const char* XMLCountFieldImportContext::MapTokenToServiceName(
+ sal_uInt16 nToken)
+{
+ const char* pServiceName = nullptr;
+
+ switch (nToken)
+ {
+ case XML_TOK_TEXT_WORD_COUNT:
+ pServiceName = "WordCount";
+ break;
+ case XML_TOK_TEXT_PARAGRAPH_COUNT:
+ pServiceName = "ParagraphCount";
+ break;
+ case XML_TOK_TEXT_TABLE_COUNT:
+ pServiceName = "TableCount";
+ break;
+ case XML_TOK_TEXT_CHARACTER_COUNT:
+ pServiceName = "CharacterCount";
+ break;
+ case XML_TOK_TEXT_IMAGE_COUNT:
+ pServiceName = "GraphicObjectCount";
+ break;
+ case XML_TOK_TEXT_OBJECT_COUNT:
+ pServiceName = "EmbeddedObjectCount";
+ break;
+ case XML_TOK_TEXT_PAGE_COUNT:
+ pServiceName = "PageCount";
+ break;
+ default:
+ pServiceName = nullptr;
+ OSL_FAIL("unknown count field!");
+ break;
+ }
+
+ return pServiceName;
+}
+
+
+// page variable import
+
+
+XMLPageVarGetFieldImportContext::XMLPageVarGetFieldImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx, const OUString& sLocalName) :
+ XMLTextFieldImportContext(rImport, rHlp, "ReferencePageGet",
+ nPrfx, sLocalName),
+ sNumberFormat(),
+ sLetterSync(),
+ bNumberFormatOK(false)
+{
+ bValid = true;
+}
+
+void XMLPageVarGetFieldImportContext::ProcessAttribute(
+ sal_uInt16 nAttrToken,
+ const OUString& sAttrValue )
+{
+ switch (nAttrToken)
+ {
+ case XML_TOK_TEXTFIELD_NUM_FORMAT:
+ sNumberFormat = sAttrValue;
+ bNumberFormatOK = true;
+ break;
+ case XML_TOK_TEXTFIELD_NUM_LETTER_SYNC:
+ sLetterSync = sAttrValue;
+ break;
+ }
+}
+
+void XMLPageVarGetFieldImportContext::PrepareField(
+ const Reference<XPropertySet> & xPropertySet)
+{
+ sal_Int16 nNumType;
+ if( bNumberFormatOK )
+ {
+ nNumType= style::NumberingType::ARABIC;
+ GetImport().GetMM100UnitConverter().convertNumFormat( nNumType,
+ sNumberFormat,
+ sLetterSync );
+ }
+ else
+ nNumType = style::NumberingType::PAGE_DESCRIPTOR;
+ xPropertySet->setPropertyValue(sAPI_numbering_type, Any(nNumType));
+
+ // display old content (#96657#)
+ xPropertySet->setPropertyValue( sAPI_current_presentation, Any(GetContent()) );
+}
+
+
+// page variable set fields
+
+
+XMLPageVarSetFieldImportContext::XMLPageVarSetFieldImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx,
+ const OUString& sLocalName) :
+ XMLTextFieldImportContext(rImport, rHlp, "ReferencePageSet",
+ nPrfx, sLocalName),
+ nAdjust(0),
+ bActive(true)
+{
+ bValid = true;
+}
+
+void XMLPageVarSetFieldImportContext::ProcessAttribute(
+ sal_uInt16 nAttrToken,
+ const OUString& sAttrValue )
+{
+ switch (nAttrToken)
+ {
+ case XML_TOK_TEXTFIELD_ACTIVE:
+ {
+ bool bTmp(false);
+ if (::sax::Converter::convertBool(bTmp, sAttrValue))
+ {
+ bActive = bTmp;
+ }
+ break;
+ }
+ case XML_TOK_TEXTFIELD_PAGE_ADJUST:
+ {
+ sal_Int32 nTmp(0);
+ if (::sax::Converter::convertNumber(nTmp, sAttrValue))
+ {
+ nAdjust = static_cast<sal_Int16>(nTmp);
+ }
+ break;
+ }
+ default:
+ break;
+ }
+}
+
+void XMLPageVarSetFieldImportContext::PrepareField(
+ const Reference<XPropertySet> & xPropertySet)
+{
+ xPropertySet->setPropertyValue("On", Any(bActive));
+ xPropertySet->setPropertyValue(sAPI_offset, Any(nAdjust));
+}
+
+
+// macro fields
+
+
+XMLMacroFieldImportContext::XMLMacroFieldImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx,
+ const OUString& sLocalName) :
+ XMLTextFieldImportContext(rImport, rHlp, "Macro",
+ nPrfx, sLocalName),
+ bDescriptionOK(false)
+{
+}
+
+SvXMLImportContextRef XMLMacroFieldImportContext::CreateChildContext(
+ sal_uInt16 nPrefix,
+ const OUString& rLocalName,
+ const Reference<XAttributeList> & /*xAttrList*/ )
+{
+ SvXMLImportContextRef xContext;
+
+ if ( (nPrefix == XML_NAMESPACE_OFFICE) &&
+ IsXMLToken( rLocalName, XML_EVENT_LISTENERS ) )
+ {
+ // create events context and remember it!
+ xContext = new XMLEventsImportContext(
+ GetImport(), nPrefix, rLocalName );
+ xEventContext = xContext;
+ bValid = true;
+ }
+
+ return xContext;
+}
+
+void XMLMacroFieldImportContext::ProcessAttribute(
+ sal_uInt16 nAttrToken,
+ const OUString& sAttrValue )
+{
+ switch (nAttrToken)
+ {
+ case XML_TOK_TEXTFIELD_DESCRIPTION:
+ sDescription = sAttrValue;
+ bDescriptionOK = true;
+ break;
+ case XML_TOK_TEXTFIELD_NAME:
+ sMacro = sAttrValue;
+ bValid = true;
+ break;
+ }
+}
+
+void XMLMacroFieldImportContext::PrepareField(
+ const Reference<XPropertySet> & xPropertySet)
+{
+ Any aAny;
+ aAny <<= (bDescriptionOK ? sDescription : GetContent());
+ xPropertySet->setPropertyValue(sAPI_hint, 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 =
+ static_cast<XMLEventsImportContext*>(xEventContext.get());
+ Sequence<PropertyValue> aValues;
+ pEvents->GetEventSequence( "OnClick", aValues );
+
+ for( const auto& rValue : std::as_const(aValues) )
+ {
+ if ( rValue.Name == "ScriptType" )
+ {
+ // ignore ScriptType
+ }
+ else if ( rValue.Name == "Library" )
+ {
+ rValue.Value >>= sLibraryName;
+ }
+ else if ( rValue.Name == "MacroName" )
+ {
+ rValue.Value >>= sMacroName;
+ }
+ if ( rValue.Name == "Script" )
+ {
+ rValue.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;
+ }
+
+ xPropertySet->setPropertyValue("ScriptURL", Any(sScriptURL));
+ xPropertySet->setPropertyValue("MacroName", Any(sMacroName));
+ xPropertySet->setPropertyValue("MacroLibrary", Any(sLibraryName));
+}
+
+
+// reference field import
+
+
+XMLReferenceFieldImportContext::XMLReferenceFieldImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp,
+ sal_uInt16 nToken, sal_uInt16 nPrfx, const OUString& sLocalName)
+: XMLTextFieldImportContext(rImport, rHlp, "GetReference", nPrfx, sLocalName)
+, nElementToken(nToken)
+, nSource(0)
+, nType(ReferenceFieldPart::PAGE_DESC)
+, bNameOK(false)
+, bTypeOK(false)
+{
+}
+
+static SvXMLEnumMapEntry<sal_uInt16> const 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 },
+ // Core implementation for direct cross-references (#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<XAttributeList> & xAttrList)
+{
+ bTypeOK = 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 = false;
+ OSL_FAIL("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 = 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;
+ }
+ case XML_TOK_TEXTFIELD_REFERENCE_LANGUAGE:
+ sLanguage = sAttrValue;
+ break;
+ }
+
+ // bValid: we need proper element type and name
+ bValid = bTypeOK && bNameOK;
+}
+
+void XMLReferenceFieldImportContext::PrepareField(
+ const Reference<XPropertySet> & xPropertySet)
+{
+ xPropertySet->setPropertyValue("ReferenceFieldPart", Any(nType));
+
+ xPropertySet->setPropertyValue("ReferenceFieldSource", Any(nSource));
+
+ xPropertySet->setPropertyValue("ReferenceFieldLanguage", Any(sLanguage));
+ switch (nElementToken)
+ {
+ case XML_TOK_TEXT_REFERENCE_REF:
+ case XML_TOK_TEXT_BOOKMARK_REF:
+ xPropertySet->setPropertyValue("SourceName", Any(sName));
+ break;
+
+ case XML_TOK_TEXT_NOTE_REF:
+ GetImportHelper().ProcessFootnoteReference(sName, xPropertySet);
+ break;
+
+ case XML_TOK_TEXT_SEQUENCE_REF:
+ GetImportHelper().ProcessSequenceReference(sName, xPropertySet);
+ break;
+ }
+
+ xPropertySet->setPropertyValue(sAPI_current_presentation, Any(GetContent()));
+}
+
+
+// field declarations container
+
+namespace {
+
+enum DdeFieldDeclAttrs
+{
+ XML_TOK_DDEFIELD_NAME,
+ XML_TOK_DDEFIELD_APPLICATION,
+ XML_TOK_DDEFIELD_TOPIC,
+ XML_TOK_DDEFIELD_ITEM,
+ XML_TOK_DDEFIELD_UPDATE
+};
+
+}
+
+static const 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
+};
+
+
+XMLDdeFieldDeclsImportContext::XMLDdeFieldDeclsImportContext(
+ SvXMLImport& rImport, sal_uInt16 nPrfx, const OUString& sLocalName) :
+ SvXMLImportContext(rImport, nPrfx, sLocalName)
+{
+}
+
+SvXMLImportContextRef XMLDdeFieldDeclsImportContext::CreateChildContext(
+ sal_uInt16 nPrefix,
+ const OUString& rLocalName,
+ const Reference<XAttributeList> & /*xAttrList*/ )
+{
+ if ( (XML_NAMESPACE_TEXT == nPrefix) &&
+ (IsXMLToken(rLocalName, XML_DDE_CONNECTION_DECL)) )
+ {
+ static const SvXMLTokenMap aTokenMap(aDdeDeclAttrTokenMap);
+ return new XMLDdeFieldDeclImportContext(GetImport(), nPrefix,
+ rLocalName, aTokenMap);
+ }
+ return nullptr;
+}
+
+
+// import dde field declaration
+
+
+XMLDdeFieldDeclImportContext::XMLDdeFieldDeclImportContext(
+ SvXMLImport& rImport, sal_uInt16 nPrfx,
+ const OUString& sLocalName, const SvXMLTokenMap& rMap)
+: SvXMLImportContext(rImport, nPrfx, sLocalName)
+, 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<XAttributeList> & xAttrList)
+{
+ OUString sName;
+ OUString sCommandApplication;
+ OUString sCommandTopic;
+ OUString sCommandItem;
+
+ bool bUpdate = false;
+ bool bNameOK = false;
+ bool bCommandApplicationOK = false;
+ bool bCommandTopicOK = false;
+ bool bCommandItemOK = false;
+
+ // process attributes
+ sal_Int16 nLength = xAttrList->getLength();
+ for(sal_Int16 i=0; i<nLength; i++)
+ {
+
+ OUString sLocalName;
+ sal_uInt16 nPrefix = GetImport().GetNamespaceMap().
+ GetKeyByAttrName( xAttrList->getNameByIndex(i), &sLocalName );
+
+ switch (rTokenMap.Get(nPrefix, sLocalName))
+ {
+ case XML_TOK_DDEFIELD_NAME:
+ sName = xAttrList->getValueByIndex(i);
+ bNameOK = true;
+ break;
+ case XML_TOK_DDEFIELD_APPLICATION:
+ sCommandApplication = xAttrList->getValueByIndex(i);
+ bCommandApplicationOK = true;
+ break;
+ case XML_TOK_DDEFIELD_TOPIC:
+ sCommandTopic = xAttrList->getValueByIndex(i);
+ bCommandTopicOK = true;
+ break;
+ case XML_TOK_DDEFIELD_ITEM:
+ sCommandItem = xAttrList->getValueByIndex(i);
+ bCommandItemOK = true;
+ break;
+ case XML_TOK_DDEFIELD_UPDATE:
+ {
+ bool bTmp(false);
+ if (::sax::Converter::convertBool(
+ bTmp, xAttrList->getValueByIndex(i)) )
+ {
+ bUpdate = bTmp;
+ }
+ break;
+ }
+ }
+ }
+
+ // valid data?
+ if (bNameOK && bCommandApplicationOK && bCommandTopicOK && bCommandItemOK)
+ {
+ // create DDE TextFieldMaster
+ Reference<XMultiServiceFactory> xFactory(GetImport().GetModel(),
+ UNO_QUERY);
+ if( xFactory.is() )
+ {
+ /* #i6432# There might be multiple occurrences 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<XInterface> xIfc =
+ xFactory->createInstance(OUStringLiteral(sAPI_fieldmaster_prefix) + sAPI_dde);
+ if( xIfc.is() )
+ {
+ Reference<XPropertySet> xPropSet( xIfc, UNO_QUERY );
+ if (xPropSet.is() &&
+ xPropSet->getPropertySetInfo()->hasPropertyByName(
+ "DDECommandType"))
+ {
+ xPropSet->setPropertyValue(sAPI_name, Any(sName));
+
+ xPropSet->setPropertyValue("DDECommandType", Any(sCommandApplication));
+
+ xPropSet->setPropertyValue("DDECommandFile", Any(sCommandTopic));
+
+ xPropSet->setPropertyValue("DDECommandElement",
+ Any(sCommandItem));
+
+ xPropSet->setPropertyValue("IsAutomaticUpdate",
+ Any(bUpdate));
+ }
+ // 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
+
+
+XMLDdeFieldImportContext::XMLDdeFieldImportContext(
+ SvXMLImport& rImport, XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx, const OUString& sLocalName) :
+ XMLTextFieldImportContext(rImport, rHlp, sAPI_dde,
+ nPrfx, sLocalName),
+ sName()
+ ,sPropertyContent(sAPI_content)
+{
+}
+
+void XMLDdeFieldImportContext::ProcessAttribute(
+ sal_uInt16 nAttrToken,
+ const OUString& sAttrValue )
+{
+ if (XML_TOK_TEXTFIELD_CONNECTION_NAME == nAttrToken)
+ {
+ sName = sAttrValue;
+ bValid = true;
+ }
+}
+
+void XMLDdeFieldImportContext::EndElement()
+{
+ if (bValid)
+ {
+ // find master
+ OUStringBuffer sBuf;
+ sBuf.append(sAPI_fieldmaster_prefix);
+ sBuf.append(sAPI_dde);
+ sBuf.append('.');
+ sBuf.append(sName);
+ OUString sMasterName = sBuf.makeStringAndClear();
+
+ Reference<XTextFieldsSupplier> xTextFieldsSupp(GetImport().GetModel(),
+ UNO_QUERY);
+ Reference<container::XNameAccess> xFieldMasterNameAccess =
+ xTextFieldsSupp->getTextFieldMasters();
+
+ if (xFieldMasterNameAccess->hasByName(sMasterName))
+ {
+ Reference<XPropertySet> 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<XPropertySet> xField;
+ sBuf.append(sAPI_textfield_prefix);
+ sBuf.append(sAPI_dde);
+ if (CreateField(xField, sBuf.makeStringAndClear()))
+ {
+ Reference<XDependentTextField> xDepTextField(xField,UNO_QUERY);
+ xDepTextField->attachTextFieldMaster(xMaster);
+
+ // attach field to document
+ Reference<XTextContent> 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<XPropertySet> &)
+{
+ // empty, since not needed.
+}
+
+
+// sheet name fields
+
+
+XMLSheetNameImportContext::XMLSheetNameImportContext(
+ SvXMLImport& rImport,
+ XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx,
+ const OUString& sLocalName) :
+ XMLTextFieldImportContext(rImport, rHlp, "SheetName",
+ nPrfx, sLocalName)
+{
+ bValid = true; // always valid!
+}
+
+void XMLSheetNameImportContext::ProcessAttribute(
+ sal_uInt16,
+ const OUString& )
+{
+ // no attributes -> nothing to be done
+}
+
+void XMLSheetNameImportContext::PrepareField(
+ const Reference<XPropertySet> &)
+{
+ // no attributes -> nothing to be done
+}
+
+/** import page|slide name fields (<text:page-name>) */
+
+XMLPageNameFieldImportContext::XMLPageNameFieldImportContext(
+ SvXMLImport& rImport, /// XML Import
+ XMLTextImportHelper& rHlp, /// Text import helper
+ sal_uInt16 nPrfx, /// namespace prefix
+ const OUString& sLocalName) /// element name w/o prefix
+: XMLTextFieldImportContext(rImport, rHlp, "PageName", nPrfx, sLocalName )
+{
+ bValid = true;
+}
+
+/// process attribute values
+void XMLPageNameFieldImportContext::ProcessAttribute( sal_uInt16,
+ const OUString& )
+{
+}
+
+/// prepare XTextField for insertion into document
+void XMLPageNameFieldImportContext::PrepareField(
+ const css::uno::Reference<css::beans::XPropertySet> &)
+{
+}
+
+
+// URL fields (Calc, Impress, Draw)
+
+
+XMLUrlFieldImportContext::XMLUrlFieldImportContext(
+ SvXMLImport& rImport,
+ XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx,
+ const OUString& sLocalName) :
+ XMLTextFieldImportContext(rImport, rHlp, sAPI_url,
+ nPrfx, sLocalName),
+ bFrameOK(false)
+{
+}
+
+void XMLUrlFieldImportContext::ProcessAttribute(
+ sal_uInt16 nAttrToken,
+ const OUString& sAttrValue )
+{
+ switch (nAttrToken)
+ {
+ case XML_TOK_TEXTFIELD_HREF:
+ sURL = GetImport().GetAbsoluteReference( sAttrValue );
+ bValid = true;
+ break;
+ case XML_TOK_TEXTFIELD_TARGET_FRAME:
+ sFrame = sAttrValue;
+ bFrameOK = true;
+ break;
+ default:
+ // ignore
+ break;
+ }
+}
+
+void XMLUrlFieldImportContext::PrepareField(
+ const Reference<XPropertySet> & xPropertySet)
+{
+ xPropertySet->setPropertyValue(sAPI_url, Any(sURL));
+
+ if (bFrameOK)
+ {
+ xPropertySet->setPropertyValue("TargetFrame", Any(sFrame));
+ }
+
+ xPropertySet->setPropertyValue("Representation", Any(GetContent()));
+}
+
+
+XMLBibliographyFieldImportContext::XMLBibliographyFieldImportContext(
+ SvXMLImport& rImport,
+ XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx,
+ const OUString& sLocalName) :
+ XMLTextFieldImportContext(rImport, rHlp, "Bibliography",
+ nPrfx, sLocalName),
+ aValues()
+{
+ bValid = true;
+}
+
+// TODO: this is the same map as is used in the text field export
+static SvXMLEnumMapEntry<sal_uInt16> const 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 for fit the standard
+// textfield mechanism, because our attributes have zero overlap with
+// all the other textfields.
+void XMLBibliographyFieldImportContext::StartElement(
+ const Reference<XAttributeList> & xAttrList)
+{
+ // iterate over attributes
+ sal_Int16 nLength = xAttrList->getLength();
+ for(sal_Int16 i=0; i<nLength; i++) {
+
+ OUString sLocalName;
+ sal_uInt16 nPrefix = GetImport().GetNamespaceMap().
+ GetKeyByAttrName( xAttrList->getNameByIndex(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 <<= static_cast<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
+ OSL_FAIL("This should not have happened.");
+}
+
+
+void XMLBibliographyFieldImportContext::PrepareField(
+ const Reference<XPropertySet> & xPropertySet)
+{
+ // convert vector into sequence
+ sal_Int32 nCount = aValues.size();
+ Sequence<PropertyValue> aValueSequence(nCount);
+ for(sal_Int32 i = 0; i < nCount; i++)
+ {
+ aValueSequence[i] = aValues[i];
+ }
+
+ // set sequence
+ xPropertySet->setPropertyValue("Fields", Any(aValueSequence));
+}
+
+const char* XMLBibliographyFieldImportContext::MapBibliographyFieldName(
+ const OUString& sName)
+{
+ const char* pName = nullptr;
+
+ 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
+ {
+ OSL_FAIL("Unknown bibliography info data");
+ pName = nullptr;
+ }
+
+ return pName;
+}
+
+
+// Annotation Field
+
+
+XMLAnnotationImportContext::XMLAnnotationImportContext(
+ SvXMLImport& rImport,
+ XMLTextImportHelper& rHlp,
+ sal_uInt16 nToken,
+ sal_uInt16 nPrfx,
+ const OUString& sLocalName) :
+ XMLTextFieldImportContext(rImport, rHlp, "Annotation",
+ nPrfx, sLocalName),
+ m_nToken(nToken)
+{
+ bValid = 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;
+ if (nToken == XML_TOK_TEXT_RESOLVED)
+ aResolved = rValue;
+}
+
+SvXMLImportContextRef XMLAnnotationImportContext::CreateChildContext(
+ sal_uInt16 nPrefix,
+ const OUString& rLocalName,
+ const Reference<XAttributeList >& xAttrList )
+{
+ SvXMLImportContext *pContext = nullptr;
+ 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 || XML_NAMESPACE_LO_EXT == nPrefix)
+ && IsXMLToken(rLocalName, XML_SENDER_INITIALS))
+ || (XML_NAMESPACE_META == nPrefix
+ && IsXMLToken(rLocalName, XML_CREATOR_INITIALS)))
+ {
+ pContext = new XMLStringBufferImportContext(GetImport(), nPrefix,
+ rLocalName, aInitialsBuffer);
+ }
+
+ if( !pContext )
+ {
+ try
+ {
+ bool bOK = true;
+ if ( !mxField.is() )
+ bOK = CreateField( mxField, sServicePrefix + GetServiceName() );
+ if (bOK)
+ {
+ Any aAny = mxField->getPropertyValue( "TextRange" );
+ Reference< XText > xText;
+ aAny >>= xText;
+ if( xText.is() )
+ {
+ rtl::Reference < 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 (const Exception&)
+ {
+ }
+
+ if( !pContext )
+ pContext = new XMLStringBufferImportContext(GetImport(), nPrefix, rLocalName, aTextBuffer);
+ }
+
+ return pContext;
+}
+
+void XMLAnnotationImportContext::EndElement()
+{
+ DBG_ASSERT(!GetServiceName().isEmpty(), "no service name for element!");
+ if( mxCursor.is() )
+ {
+ // delete addition newline
+ mxCursor->gotoEnd( false );
+ mxCursor->goLeft( 1, true );
+ mxCursor->setString( "" );
+
+ // reset cursor
+ GetImport().GetTextImport()->ResetCursor();
+ }
+
+ if( mxOldCursor.is() )
+ GetImport().GetTextImport()->SetCursor( mxOldCursor );
+
+ // reinstall old list item #91964#
+ GetImport().GetTextImport()->PopListContext();
+
+ if ( bValid )
+ {
+ if ( m_nToken == XML_TOK_TEXT_ANNOTATION_END )
+ {
+ // Search for a previous annotation with the same name.
+ uno::Reference< text::XTextContent > xPrevField;
+ {
+ Reference<XTextFieldsSupplier> xTextFieldsSupplier(GetImport().GetModel(), UNO_QUERY);
+ uno::Reference<container::XEnumerationAccess> xFieldsAccess(xTextFieldsSupplier->getTextFields());
+ uno::Reference<container::XEnumeration> xFields(xFieldsAccess->createEnumeration());
+ while (xFields->hasMoreElements())
+ {
+ uno::Reference<beans::XPropertySet> xCurrField(xFields->nextElement(), uno::UNO_QUERY);
+ uno::Reference<beans::XPropertySetInfo> const xInfo(
+ xCurrField->getPropertySetInfo());
+ if (xInfo->hasPropertyByName(sAPI_name))
+ {
+ OUString aFieldName;
+ xCurrField->getPropertyValue(sAPI_name) >>= aFieldName;
+ if (aFieldName == aName)
+ {
+ xPrevField.set( xCurrField, uno::UNO_QUERY );
+ break;
+ }
+ }
+ }
+ }
+ if ( xPrevField.is() )
+ {
+ // So we are ending a previous annotation,
+ // let's create a text range covering the old and the current position.
+ uno::Reference<text::XText> xText = GetImportHelper().GetText();
+ uno::Reference<text::XTextCursor> xCursor =
+ xText->createTextCursorByRange(GetImportHelper().GetCursorAsRange());
+ xCursor->gotoRange(xPrevField->getAnchor(), true);
+
+ xText->insertTextContent(xCursor, xPrevField, !xCursor->isCollapsed());
+ }
+ }
+ else
+ {
+ 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
+ {
+ GetImportHelper().InsertTextContent( xTextContent );
+ }
+ catch (const lang::IllegalArgumentException&)
+ {
+ // ignore
+ }
+ }
+ }
+ }
+ else
+ GetImportHelper().InsertString(GetContent());
+}
+
+void XMLAnnotationImportContext::PrepareField(
+ const Reference<XPropertySet> & xPropertySet )
+{
+ // import (possibly empty) author
+ OUString sAuthor( aAuthorBuffer.makeStringAndClear() );
+ xPropertySet->setPropertyValue(sAPI_author, makeAny(sAuthor));
+
+ // import (possibly empty) initials
+ OUString sInitials( aInitialsBuffer.makeStringAndClear() );
+ xPropertySet->setPropertyValue("Initials", makeAny(sInitials));
+
+ //import resolved flag
+ bool bTmp(false);
+ (void)::sax::Converter::convertBool(bTmp, aResolved);
+ xPropertySet->setPropertyValue("Resolved", makeAny(bTmp));
+
+ util::DateTime aDateTime;
+ if (::sax::Converter::parseDateTime(aDateTime,
+ aDateBuffer.makeStringAndClear()))
+ {
+ /*
+ Date aDate;
+ aDate.Year = aDateTime.Year;
+ aDate.Month = aDateTime.Month;
+ aDate.Day = aDateTime.Day;
+ xPropertySet->setPropertyValue(sPropertyDate, makeAny(aDate));
+ */
+ // why is there no UNO_NAME_DATE_TIME, but only UNO_NAME_DATE_TIME_VALUE?
+ xPropertySet->setPropertyValue(sAPI_date_time_value, makeAny(aDateTime));
+ }
+
+ OUString sBuffer = aTextBuffer.makeStringAndClear();
+ if ( sBuffer.getLength() )
+ {
+ // delete last paragraph mark (if necessary)
+ if (char(0x0a) == sBuffer[sBuffer.getLength()-1])
+ sBuffer = sBuffer.copy(0, sBuffer.getLength()-1);
+ xPropertySet->setPropertyValue(sAPI_content, makeAny(sBuffer));
+ }
+
+ if (!aName.isEmpty())
+ xPropertySet->setPropertyValue(sAPI_name, makeAny(aName));
+}
+
+
+// script field
+
+
+XMLScriptImportContext::XMLScriptImportContext(
+ SvXMLImport& rImport,
+ XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx,
+ const OUString& sLocalName)
+: XMLTextFieldImportContext(rImport, rHlp, "Script", nPrfx, sLocalName)
+, bContentOK(false)
+{
+}
+
+void XMLScriptImportContext::ProcessAttribute(
+ sal_uInt16 nAttrToken,
+ const OUString& sAttrValue )
+{
+ switch (nAttrToken)
+ {
+ case XML_TOK_TEXTFIELD_HREF:
+ sContent = GetImport().GetAbsoluteReference( sAttrValue );
+ bContentOK = true;
+ break;
+
+ case XML_TOK_TEXTFIELD_LANGUAGE:
+ sScriptType = sAttrValue;
+ break;
+
+ default:
+ // ignore
+ break;
+ }
+
+ // always valid (even without ScriptType; cf- #96531#)
+ bValid = true;
+}
+
+void XMLScriptImportContext::PrepareField(
+ const Reference<XPropertySet> & xPropertySet)
+{
+ // if href attribute was present, we use it. Else we use element content
+ if (! bContentOK)
+ {
+ sContent = GetContent();
+ }
+ xPropertySet->setPropertyValue(sAPI_content, Any(sContent));
+
+ // URL or script text? We use URL if we have an href-attribute
+ xPropertySet->setPropertyValue("URLContent", Any(bContentOK));
+
+ xPropertySet->setPropertyValue("ScriptType", Any(sScriptType));
+}
+
+
+// measure field
+
+
+XMLMeasureFieldImportContext::XMLMeasureFieldImportContext(
+ SvXMLImport& rImport,
+ XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx,
+ const OUString& sLocalName) :
+ XMLTextFieldImportContext(rImport, rHlp, "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 = true;
+ }
+ else if( IsXMLToken( sAttrValue, XML_UNIT ) )
+ {
+ mnKind = 1; bValid = true;
+ }
+ else if( IsXMLToken( sAttrValue, XML_GAP ) )
+ {
+ mnKind = 2; bValid = true;
+ }
+ break;
+ }
+}
+
+void XMLMeasureFieldImportContext::PrepareField(
+ const Reference<XPropertySet> & xPropertySet)
+{
+ xPropertySet->setPropertyValue("Kind", Any(mnKind));
+}
+
+
+// dropdown field
+
+
+XMLDropDownFieldImportContext::XMLDropDownFieldImportContext(
+ SvXMLImport& rImport,
+ XMLTextImportHelper& rHlp,
+ sal_uInt16 nPrfx,
+ const OUString& sLocalName) :
+ XMLTextFieldImportContext( rImport, rHlp, "DropDown",
+ nPrfx, sLocalName ),
+ aLabels(),
+ sName(),
+ nSelected( -1 ),
+ bNameOK( false ),
+ bHelpOK(false),
+ bHintOK(false)
+{
+ bValid = true;
+}
+
+static bool lcl_ProcessLabel( const SvXMLImport& rImport,
+ const Reference<XAttributeList>& 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 ) )
+ {
+ bool bTmp(false);
+ if (::sax::Converter::convertBool( bTmp, sValue ))
+ rIsSelected = bTmp;
+ }
+ }
+ }
+ return bValid;
+}
+
+SvXMLImportContextRef XMLDropDownFieldImportContext::CreateChildContext(
+ sal_uInt16 nPrefix,
+ const OUString& rLocalName,
+ const Reference<XAttributeList>& xAttrList )
+{
+ if( nPrefix == XML_NAMESPACE_TEXT &&
+ IsXMLToken( rLocalName, XML_LABEL ) )
+ {
+ OUString sLabel;
+ bool bIsSelected = false;
+ if( lcl_ProcessLabel( GetImport(), xAttrList, sLabel, bIsSelected ) )
+ {
+ if( bIsSelected )
+ nSelected = static_cast<sal_Int32>( aLabels.size() );
+ aLabels.push_back( sLabel );
+ }
+ }
+ return new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
+}
+
+void XMLDropDownFieldImportContext::ProcessAttribute(
+ sal_uInt16 nAttrToken,
+ const 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>& xPropertySet)
+{
+ // create sequence
+ sal_Int32 nLength = static_cast<sal_Int32>( aLabels.size() );
+ Sequence<OUString> aSequence( nLength );
+ OUString* pSequence = aSequence.getArray();
+ for( sal_Int32 n = 0; n < nLength; n++ )
+ pSequence[n] = aLabels[n];
+
+ // now set values:
+
+ xPropertySet->setPropertyValue( "Items", Any(aSequence) );
+
+ if( nSelected >= 0 && nSelected < nLength )
+ {
+ xPropertySet->setPropertyValue( "SelectedItem", Any(pSequence[nSelected]) );
+ }
+
+ // set name
+ if( bNameOK )
+ {
+ xPropertySet->setPropertyValue( "Name", Any(sName) );
+ }
+ // set help
+ if( bHelpOK )
+ {
+ xPropertySet->setPropertyValue( "Help", Any(sHelp) );
+ }
+ // set hint
+ if( bHintOK )
+ {
+ xPropertySet->setPropertyValue( "Tooltip", Any(sHint) );
+ }
+
+}
+
+/** import header fields (<draw:header>) */
+
+XMLHeaderFieldImportContext::XMLHeaderFieldImportContext(
+ SvXMLImport& rImport, /// XML Import
+ XMLTextImportHelper& rHlp, /// Text import helper
+ sal_uInt16 nPrfx, /// namespace prefix
+ const OUString& sLocalName) /// element name w/o prefix
+: XMLTextFieldImportContext(rImport, rHlp, "Header", nPrfx, sLocalName )
+{
+ sServicePrefix = sAPI_presentation_prefix;
+ bValid = true;
+}
+
+/// process attribute values
+void XMLHeaderFieldImportContext::ProcessAttribute( sal_uInt16, const OUString& )
+{
+}
+
+/// prepare XTextField for insertion into document
+void XMLHeaderFieldImportContext::PrepareField(const Reference<XPropertySet> &)
+{
+}
+
+/** import footer fields (<draw:footer>) */
+
+XMLFooterFieldImportContext::XMLFooterFieldImportContext(
+ SvXMLImport& rImport, /// XML Import
+ XMLTextImportHelper& rHlp, /// Text import helper
+ sal_uInt16 nPrfx, /// namespace prefix
+ const OUString& sLocalName) /// element name w/o prefix
+: XMLTextFieldImportContext(rImport, rHlp, "Footer", nPrfx, sLocalName )
+{
+ sServicePrefix = sAPI_presentation_prefix;
+ bValid = true;
+}
+
+/// process attribute values
+void XMLFooterFieldImportContext::ProcessAttribute( sal_uInt16, const OUString& )
+{
+}
+
+/// prepare XTextField for insertion into document
+void XMLFooterFieldImportContext::PrepareField(const Reference<XPropertySet> &)
+{
+}
+
+
+/** import footer fields (<draw:date-and-time>) */
+
+XMLDateTimeFieldImportContext::XMLDateTimeFieldImportContext(
+ SvXMLImport& rImport, /// XML Import
+ XMLTextImportHelper& rHlp, /// Text import helper
+ sal_uInt16 nPrfx, /// namespace prefix
+ const OUString& sLocalName) /// element name w/o prefix
+: XMLTextFieldImportContext(rImport, rHlp, "DateTime", nPrfx, sLocalName )
+{
+ sServicePrefix = sAPI_presentation_prefix;
+ bValid = true;
+}
+
+/// process attribute values
+void XMLDateTimeFieldImportContext::ProcessAttribute( sal_uInt16,
+ const OUString& )
+{
+}
+
+/// prepare XTextField for insertion into document
+void XMLDateTimeFieldImportContext::PrepareField(
+ const css::uno::Reference<
+ css::beans::XPropertySet> &)
+{
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-25 09:20:04 +0000