office-gobmx/xmloff/source/text/txtfldi.cxx
Caolán McNamara 8c1dbd3188 cid#1607542 COPY_INSTEAD_OF_MOVE
and

cid#1606986 COPY_INSTEAD_OF_MOVE
cid#1557969 COPY_INSTEAD_OF_MOVE
cid#1557837 COPY_INSTEAD_OF_MOVE
cid#1557772 COPY_INSTEAD_OF_MOVE
cid#1557735 COPY_INSTEAD_OF_MOVE
cid#1557672 COPY_INSTEAD_OF_MOVE
cid#1557664 COPY_INSTEAD_OF_MOVE
cid#1557650 COPY_INSTEAD_OF_MOVE
cid#1557642 COPY_INSTEAD_OF_MOVE
cid#1557639 COPY_INSTEAD_OF_MOVE
cid#1557628 COPY_INSTEAD_OF_MOVE
cid#1557623 COPY_INSTEAD_OF_MOVE
cid#1557581 COPY_INSTEAD_OF_MOVE
cid#1557489 COPY_INSTEAD_OF_MOVE
cid#1557473 COPY_INSTEAD_OF_MOVE
cid#1557317 COPY_INSTEAD_OF_MOVE
cid#1557261 COPY_INSTEAD_OF_MOVE
cid#1557146 COPY_INSTEAD_OF_MOVE
cid#1557135 COPY_INSTEAD_OF_MOVE
cid#1557134 COPY_INSTEAD_OF_MOVE
cid#1557079 COPY_INSTEAD_OF_MOVE
cid#1557063 COPY_INSTEAD_OF_MOVE
cid#1557052 COPY_INSTEAD_OF_MOVE
cid#1556982 COPY_INSTEAD_OF_MOVE
cid#1556977 COPY_INSTEAD_OF_MOVE
cid#1556950 COPY_INSTEAD_OF_MOVE
cid#1556943 COPY_INSTEAD_OF_MOVE
cid#1556804 COPY_INSTEAD_OF_MOVE
cid#1556736 COPY_INSTEAD_OF_MOVE
cid#1556658 COPY_INSTEAD_OF_MOVE
cid#1556621 COPY_INSTEAD_OF_MOVE
cid#1556590 COPY_INSTEAD_OF_MOVE
cid#1556579 COPY_INSTEAD_OF_MOVE
cid#1556534 COPY_INSTEAD_OF_MOVE
cid#1556524 COPY_INSTEAD_OF_MOVE
cid#1556478 COPY_INSTEAD_OF_MOVE
cid#1556467 COPY_INSTEAD_OF_MOVE
cid#1556422 COPY_INSTEAD_OF_MOVE
cid#1556314 COPY_INSTEAD_OF_MOVE
cid#1556309 COPY_INSTEAD_OF_MOVE
cid#1556258 COPY_INSTEAD_OF_MOVE
cid#1556143 COPY_INSTEAD_OF_MOVE
cid#1556119 COPY_INSTEAD_OF_MOVE
cid#1556101 COPY_INSTEAD_OF_MOVE
cid#1556097 COPY_INSTEAD_OF_MOVE
cid#1556039 COPY_INSTEAD_OF_MOVE
cid#1555966 COPY_INSTEAD_OF_MOVE
cid#1555948 COPY_INSTEAD_OF_MOVE
cid#1555915 COPY_INSTEAD_OF_MOVE
cid#1555836 COPY_INSTEAD_OF_MOVE
cid#1555748 COPY_INSTEAD_OF_MOVE
cid#1555644 COPY_INSTEAD_OF_MOVE
cid#1555582 COPY_INSTEAD_OF_MOVE
cid#1555478 COPY_INSTEAD_OF_MOVE
cid#1555475 COPY_INSTEAD_OF_MOVE
cid#1555409 COPY_INSTEAD_OF_MOVE
cid#1555372 COPY_INSTEAD_OF_MOVE
cid#1555334 COPY_INSTEAD_OF_MOVE
cid#1555330 COPY_INSTEAD_OF_MOVE
cid#1555310 COPY_INSTEAD_OF_MOVE
cid#1555257 COPY_INSTEAD_OF_MOVE
cid#1555247 COPY_INSTEAD_OF_MOVE
cid#1555147 COPY_INSTEAD_OF_MOVE
cid#1555120 COPY_INSTEAD_OF_MOVE
cid#1555059 COPY_INSTEAD_OF_MOVE
cid#1555016 COPY_INSTEAD_OF_MOVE
cid#1554880 COPY_INSTEAD_OF_MOVE
cid#1554824 COPY_INSTEAD_OF_MOVE
cid#1554808 COPY_INSTEAD_OF_MOVE
cid#1546189 COPY_INSTEAD_OF_MOVE

Change-Id: I2d2f33c603f1596228c9ecb169472ba6751e7826
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/177593
Tested-by: Jenkins
Reviewed-by: Caolán McNamara <caolan.mcnamara@collabora.com>
2024-11-30 22:39:23 +01:00

3641 lines
112 KiB
C++

/* -*- 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 <sal/config.h>
#include <cassert>
#include <txtfld.hxx>
#include <txtfldi.hxx>
#include <txtvfldi.hxx>
#include <utility>
#include <xmloff/xmlimp.hxx>
#include <xmloff/txtimp.hxx>
#include <xmloff/xmlnamespace.hxx>
#include <xmloff/namespacemap.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/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 <com/sun/star/container/XUniqueIDAccess.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>
#include <comphelper/diagnose_ex.hxx>
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
constexpr OUString sAPI_textfield_prefix = u"com.sun.star.text.TextField."_ustr;
constexpr char16_t sAPI_fieldmaster_prefix[] = u"com.sun.star.text.FieldMaster.";
constexpr OUString sAPI_presentation_prefix = u"com.sun.star.presentation.TextField."_ustr;
constexpr OUString sAPI_date_time = u"DateTime"_ustr;
constexpr OUString sAPI_page_number = u"PageNumber"_ustr;
constexpr OUString sAPI_docinfo_change_date_time = u"DocInfo.ChangeDateTime"_ustr;
constexpr OUString sAPI_docinfo_create_date_time = u"DocInfo.CreateDateTime"_ustr;
constexpr OUString sAPI_docinfo_custom = u"DocInfo.Custom"_ustr;
constexpr OUString sAPI_docinfo_print_date_time = u"DocInfo.PrintDateTime"_ustr;
constexpr OUString sAPI_dde = u"DDE"_ustr;
constexpr OUString sAPI_url = u"URL"_ustr;
// property names
constexpr OUString sAPI_is_fixed = u"IsFixed"_ustr;
constexpr OUString sAPI_content = u"Content"_ustr;
constexpr OUString sAPI_author = u"Author"_ustr;
constexpr OUString sAPI_hint = u"Hint"_ustr;
constexpr OUString sAPI_name = u"Name"_ustr;
constexpr OUStringLiteral sAPI_parent_name = u"ParentName";
constexpr OUString sAPI_sub_type = u"SubType"_ustr;
constexpr OUString sAPI_date_time_value = u"DateTimeValue"_ustr;
constexpr OUString sAPI_number_format = u"NumberFormat"_ustr;
constexpr OUString sAPI_numbering_type = u"NumberingType"_ustr;
constexpr OUString sAPI_offset = u"Offset"_ustr;
constexpr OUString sAPI_condition = u"Condition"_ustr;
constexpr OUString sAPI_set_number = u"SetNumber"_ustr;
constexpr OUString sAPI_file_format = u"FileFormat"_ustr;
constexpr OUString sAPI_is_date = u"IsDate"_ustr;
constexpr OUString sAPI_current_presentation = u"CurrentPresentation"_ustr;
constexpr OUString sAPI_is_hidden = u"IsHidden"_ustr;
constexpr OUString sAPI_is_fixed_language = u"IsFixedLanguage"_ustr;
constexpr OUString sAPI_true = u"TRUE"_ustr;
XMLTextFieldImportContext::XMLTextFieldImportContext(
SvXMLImport& rImport, XMLTextImportHelper& rHlp,
OUString aService)
: SvXMLImportContext( rImport )
, sServiceName(std::move(aService))
, rTextImportHelper(rHlp)
, sServicePrefix(sAPI_textfield_prefix)
, bValid(false)
{
}
void XMLTextFieldImportContext::startFastElement(
sal_Int32 /*nElement*/,
const Reference<XFastAttributeList> & xAttrList)
{
// process attributes
for( auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ) )
ProcessAttribute(aIter.getToken(), aIter.toView() );
}
OUString const & XMLTextFieldImportContext::GetContent()
{
if (sContent.isEmpty())
{
sContent = sContentBuffer.makeStringAndClear();
}
return sContent;
}
void XMLTextFieldImportContext::endFastElement(sal_Int32 )
{
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() )
{
xField.set(xIfc, UNO_QUERY);
} 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_Int32 nToken)
{
XMLTextFieldImportContext* pContext = nullptr;
switch (nToken)
{
case XML_ELEMENT(TEXT, XML_SENDER_FIRSTNAME):
case XML_ELEMENT(TEXT, XML_SENDER_LASTNAME):
case XML_ELEMENT(LO_EXT, XML_SENDER_INITIALS):
case XML_ELEMENT(TEXT, XML_SENDER_INITIALS):
case XML_ELEMENT(TEXT, XML_SENDER_TITLE):
case XML_ELEMENT(TEXT, XML_SENDER_POSITION):
case XML_ELEMENT(TEXT, XML_SENDER_EMAIL):
case XML_ELEMENT(TEXT, XML_SENDER_PHONE_PRIVATE):
case XML_ELEMENT(TEXT, XML_SENDER_FAX):
case XML_ELEMENT(TEXT, XML_SENDER_COMPANY):
case XML_ELEMENT(TEXT, XML_SENDER_PHONE_WORK):
case XML_ELEMENT(TEXT, XML_SENDER_STREET):
case XML_ELEMENT(TEXT, XML_SENDER_CITY):
case XML_ELEMENT(TEXT, XML_SENDER_POSTAL_CODE):
case XML_ELEMENT(TEXT, XML_SENDER_COUNTRY):
case XML_ELEMENT(TEXT, XML_SENDER_STATE_OR_PROVINCE):
pContext =
new XMLSenderFieldImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_AUTHOR_NAME):
case XML_ELEMENT(TEXT, XML_AUTHOR_INITIALS):
pContext =
new XMLAuthorFieldImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_PLACEHOLDER):
pContext =
new XMLPlaceholderFieldImportContext( rImport, rHlp);
break;
case XML_ELEMENT(TEXT, XML_SEQUENCE):
pContext =
new XMLSequenceFieldImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_TEXT_INPUT):
pContext =
new XMLTextInputFieldImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_EXPRESSION):
pContext =
new XMLExpressionFieldImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_VARIABLE_SET):
pContext =
new XMLVariableSetFieldImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_VARIABLE_INPUT):
pContext =
new XMLVariableInputFieldImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_VARIABLE_GET):
pContext =
new XMLVariableGetFieldImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_USER_FIELD_GET):
pContext = new XMLUserFieldImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_USER_FIELD_INPUT):
pContext = new XMLUserFieldInputImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_TIME):
pContext = new XMLTimeFieldImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_PAGE_CONTINUATION_STRING):
case XML_ELEMENT(TEXT, XML_PAGE_CONTINUATION):
pContext = new XMLPageContinuationImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_PAGE_NUMBER):
pContext = new XMLPageNumberImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_DATE):
pContext = new XMLDateFieldImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_DATABASE_NAME):
pContext = new XMLDatabaseNameImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_DATABASE_NEXT):
pContext = new XMLDatabaseNextImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_DATABASE_ROW_SELECT):
pContext = new XMLDatabaseSelectImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_DATABASE_ROW_NUMBER):
pContext = new XMLDatabaseNumberImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_DATABASE_DISPLAY):
pContext = new XMLDatabaseDisplayImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_CONDITIONAL_TEXT):
pContext = new XMLConditionalTextImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_HIDDEN_TEXT):
pContext = new XMLHiddenTextImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_HIDDEN_PARAGRAPH):
pContext = new XMLHiddenParagraphImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_DESCRIPTION):
case XML_ELEMENT(TEXT, XML_TITLE):
case XML_ELEMENT(TEXT, XML_SUBJECT):
case XML_ELEMENT(TEXT, XML_KEYWORDS):
pContext = new XMLSimpleDocInfoImportContext( rImport, rHlp,
nToken, true,
false );
break;
case XML_ELEMENT(TEXT, XML_INITIAL_CREATOR):
case XML_ELEMENT(TEXT, XML_PRINTED_BY):
case XML_ELEMENT(TEXT, XML_CREATOR):
pContext = new XMLSimpleDocInfoImportContext( rImport, rHlp,
nToken, false,
true );
break;
case XML_ELEMENT(TEXT, XML_CREATION_DATE):
case XML_ELEMENT(TEXT, XML_CREATION_TIME):
case XML_ELEMENT(TEXT, XML_PRINT_DATE):
case XML_ELEMENT(TEXT, XML_PRINT_TIME):
case XML_ELEMENT(TEXT, XML_MODIFICATION_DATE):
case XML_ELEMENT(TEXT, XML_MODIFICATION_TIME):
case XML_ELEMENT(TEXT, XML_EDITING_DURATION):
pContext = new XMLDateTimeDocInfoImportContext( rImport, rHlp,
nToken );
break;
case XML_ELEMENT(TEXT, XML_EDITING_CYCLES):
pContext = new XMLRevisionDocInfoImportContext( rImport, rHlp,
nToken );
break;
case XML_ELEMENT(TEXT, XML_USER_DEFINED):
pContext = new XMLUserDocInfoImportContext( rImport, rHlp,
nToken );
break;
case XML_ELEMENT(TEXT, XML_FILE_NAME):
pContext = new XMLFileNameImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_CHAPTER):
pContext = new XMLChapterImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_TEMPLATE_NAME):
pContext = new XMLTemplateNameImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_WORD_COUNT):
case XML_ELEMENT(TEXT, XML_PARAGRAPH_COUNT):
case XML_ELEMENT(TEXT, XML_TABLE_COUNT):
case XML_ELEMENT(TEXT, XML_CHARACTER_COUNT):
case XML_ELEMENT(TEXT, XML_IMAGE_COUNT):
case XML_ELEMENT(TEXT, XML_OBJECT_COUNT):
case XML_ELEMENT(TEXT, XML_PAGE_COUNT):
pContext = new XMLCountFieldImportContext( rImport, rHlp, nToken);
break;
case XML_ELEMENT(TEXT, XML_PAGE_VARIABLE_GET):
pContext = new XMLPageVarGetFieldImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_PAGE_VARIABLE_SET):
pContext = new XMLPageVarSetFieldImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_EXECUTE_MACRO):
pContext = new XMLMacroFieldImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_DDE_CONNECTION):
pContext = new XMLDdeFieldImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_REFERENCE_REF):
case XML_ELEMENT(TEXT, XML_BOOKMARK_REF):
case XML_ELEMENT(TEXT, XML_NOTE_REF):
case XML_ELEMENT(TEXT, XML_SEQUENCE_REF):
case XML_ELEMENT(TEXT, XML_STYLE_REF):
case XML_ELEMENT(LO_EXT, XML_STYLE_REF):
pContext = new XMLReferenceFieldImportContext( rImport, rHlp, nToken );
break;
case XML_ELEMENT(TEXT, XML_SHEET_NAME):
pContext = new XMLSheetNameImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_PAGE_NAME):
case XML_ELEMENT(LO_EXT, XML_PAGE_NAME):
pContext = new XMLPageNameFieldImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_BIBLIOGRAPHY_MARK):
pContext = new XMLBibliographyFieldImportContext( rImport, rHlp );
break;
case XML_ELEMENT(OFFICE, XML_ANNOTATION):
case XML_ELEMENT(OFFICE, XML_ANNOTATION_END):
pContext = new XMLAnnotationImportContext( rImport, rHlp, nToken);
break;
case XML_ELEMENT(TEXT, XML_SCRIPT):
pContext = new XMLScriptImportContext( rImport, rHlp);
break;
case XML_ELEMENT(TEXT, XML_MEASURE):
pContext = new XMLMeasureFieldImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_TABLE_FORMULA):
pContext = new XMLTableFormulaImportContext( rImport, rHlp );
break;
case XML_ELEMENT(TEXT, XML_DROP_DOWN):
pContext = new XMLDropDownFieldImportContext( rImport, rHlp );
break;
case XML_ELEMENT(PRESENTATION, XML_HEADER):
pContext = new XMLHeaderFieldImportContext( rImport, rHlp );
break;
case XML_ELEMENT(PRESENTATION, XML_FOOTER):
pContext = new XMLFooterFieldImportContext( rImport, rHlp );
break;
case XML_ELEMENT(PRESENTATION, XML_DATE_TIME):
pContext = new XMLDateTimeFieldImportContext( rImport, rHlp );
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
constexpr OUStringLiteral gsPropertyFieldSubType(u"UserDataType");
XMLSenderFieldImportContext::XMLSenderFieldImportContext(
SvXMLImport& rImport, XMLTextImportHelper& rHlp)
: XMLTextFieldImportContext(rImport, rHlp, u"ExtendedUser"_ustr)
, nSubType(0)
, sPropertyFixed(sAPI_is_fixed)
, sPropertyContent(sAPI_content)
, bFixed(true)
{
}
void XMLSenderFieldImportContext::startFastElement(
sal_Int32 nElement,
const Reference<XFastAttributeList> & xAttrList)
{
bValid = true;
switch (nElement) {
case XML_ELEMENT(TEXT, XML_SENDER_FIRSTNAME):
nSubType = UserDataPart::FIRSTNAME;
break;
case XML_ELEMENT(TEXT, XML_SENDER_LASTNAME):
nSubType = UserDataPart::NAME;
break;
case XML_ELEMENT(LO_EXT, XML_SENDER_INITIALS):
case XML_ELEMENT(TEXT, XML_SENDER_INITIALS):
nSubType = UserDataPart::SHORTCUT;
break;
case XML_ELEMENT(TEXT, XML_SENDER_TITLE):
nSubType = UserDataPart::TITLE;
break;
case XML_ELEMENT(TEXT, XML_SENDER_POSITION):
nSubType = UserDataPart::POSITION;
break;
case XML_ELEMENT(TEXT, XML_SENDER_EMAIL):
nSubType = UserDataPart::EMAIL;
break;
case XML_ELEMENT(TEXT, XML_SENDER_PHONE_PRIVATE):
nSubType = UserDataPart::PHONE_PRIVATE;
break;
case XML_ELEMENT(TEXT, XML_SENDER_FAX):
nSubType = UserDataPart::FAX;
break;
case XML_ELEMENT(TEXT, XML_SENDER_COMPANY):
nSubType = UserDataPart::COMPANY;
break;
case XML_ELEMENT(TEXT, XML_SENDER_PHONE_WORK):
nSubType = UserDataPart::PHONE_COMPANY;
break;
case XML_ELEMENT(TEXT, XML_SENDER_STREET):
nSubType = UserDataPart::STREET;
break;
case XML_ELEMENT(TEXT, XML_SENDER_CITY):
nSubType = UserDataPart::CITY;
break;
case XML_ELEMENT(TEXT, XML_SENDER_POSTAL_CODE):
nSubType = UserDataPart::ZIP;
break;
case XML_ELEMENT(TEXT, XML_SENDER_COUNTRY):
nSubType = UserDataPart::COUNTRY;
break;
case XML_ELEMENT(TEXT, XML_SENDER_STATE_OR_PROVINCE):
nSubType = UserDataPart::STATE;
break;
default:
bValid = false;
XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
break;
}
// process Attributes
XMLTextFieldImportContext::startFastElement(nElement, xAttrList);
}
void XMLSenderFieldImportContext::ProcessAttribute(
sal_Int32 nAttrToken,
std::string_view sAttrValue)
{
if (XML_ELEMENT(TEXT, XML_FIXED) == nAttrToken) {
// set bVal
bool bVal(false);
bool const bRet = ::sax::Converter::convertBool(bVal, sAttrValue);
// set bFixed if successful
if (bRet) {
bFixed = bVal;
}
}
else
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
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)
return;
// in organizer or styles-only mode: force update
if (GetImport().GetTextImport()->IsOrganizerMode() ||
GetImport().GetTextImport()->IsStylesOnlyMode() )
{
ForceUpdate(rPropSet);
}
else
{
rPropSet->setPropertyValue(sPropertyContent, Any(GetContent()));
}
}
// XMLAuthorFieldImportContext
constexpr OUStringLiteral gsPropertyAuthorFullName(u"FullName");
XMLAuthorFieldImportContext::XMLAuthorFieldImportContext(
SvXMLImport& rImport, XMLTextImportHelper& rHlp)
: XMLSenderFieldImportContext(rImport, rHlp)
, bAuthorFullName(true)
, sPropertyFixed(sAPI_is_fixed)
, sPropertyContent(sAPI_content)
{
// overwrite service name from XMLSenderFieldImportContext
SetServiceName(sAPI_author);
}
void XMLAuthorFieldImportContext::startFastElement(
sal_Int32 nElement,
const Reference<XFastAttributeList> & xAttrList)
{
bAuthorFullName = ( XML_ELEMENT(TEXT, XML_AUTHOR_INITIALS) != nElement);
bValid = true;
// process Attributes
XMLTextFieldImportContext::startFastElement(nElement, xAttrList);
}
void XMLAuthorFieldImportContext::ProcessAttribute(sal_Int32 nAttrToken, std::string_view sAttrValue)
{
if(nAttrToken == XML_ELEMENT(TEXT, XML_FIXED))
{
bool bTmp(false);
if (::sax::Converter::convertBool(bTmp, sAttrValue))
bFixed = bTmp;
}
else
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
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)
return;
// 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
SvXMLEnumMapEntry<PageNumberType> const lcl_aSelectPageAttrMap[] =
{
{ XML_PREVIOUS, PageNumberType_PREV },
{ XML_CURRENT, PageNumberType_CURRENT },
{ XML_NEXT, PageNumberType_NEXT },
{ XML_TOKEN_INVALID, PageNumberType(0) },
};
constexpr OUStringLiteral gsPropertyUserText(u"UserText");
XMLPageContinuationImportContext::XMLPageContinuationImportContext(
SvXMLImport& rImport, XMLTextImportHelper& rHlp)
: XMLTextFieldImportContext(rImport, rHlp, sAPI_page_number)
, sPropertySubType(sAPI_sub_type)
, sPropertyNumberingType(sAPI_numbering_type)
, eSelectPage(PageNumberType_CURRENT)
, sStringOK(false)
{
bValid = true;
}
void XMLPageContinuationImportContext::ProcessAttribute(
sal_Int32 nAttrToken, std::string_view sAttrValue )
{
switch(nAttrToken)
{
case XML_ELEMENT(TEXT, XML_SELECT_PAGE):
{
PageNumberType nTmp;
if (SvXMLUnitConverter::convertEnum(nTmp, sAttrValue,
lcl_aSelectPageAttrMap)
&& (PageNumberType_CURRENT != nTmp) )
{
eSelectPage = nTmp;
}
break;
}
case XML_ELEMENT(TEXT, XML_STRING_VALUE):
case XML_ELEMENT(OFFICE, XML_STRING_VALUE):
sString = OUString::fromUtf8(sAttrValue);
sStringOK = true;
break;
default:
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
}
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)
: XMLTextFieldImportContext(rImport, rHlp, sAPI_page_number)
, 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_Int32 nAttrToken,
std::string_view sAttrValue )
{
switch (nAttrToken)
{
case XML_ELEMENT(STYLE, XML_NUM_FORMAT):
sNumberFormat = OUString::fromUtf8(sAttrValue);
sNumberFormatOK = true;
break;
case XML_ELEMENT(STYLE, XML_NUM_LETTER_SYNC):
sNumberSync = OUString::fromUtf8(sAttrValue);
break;
case XML_ELEMENT(TEXT, XML_SELECT_PAGE):
SvXMLUnitConverter::convertEnum(eSelectPage, sAttrValue,
lcl_aSelectPageAttrMap);
break;
case XML_ELEMENT(TEXT, XML_PAGE_ADJUST):
{
sal_Int32 nTmp;
if (::sax::Converter::convertNumber(nTmp, sAttrValue))
{
nPageAdjust = static_cast<sal_Int16>(nTmp);
}
break;
}
default:
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
}
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
constexpr OUStringLiteral gsPropertyPlaceholderType(u"PlaceHolderType");
constexpr OUStringLiteral gsPropertyPlaceholder(u"PlaceHolder");
XMLPlaceholderFieldImportContext::XMLPlaceholderFieldImportContext(
SvXMLImport& rImport, XMLTextImportHelper& rHlp)
: XMLTextFieldImportContext(rImport, rHlp, u"JumpEdit"_ustr)
, sPropertyHint(sAPI_hint)
, nPlaceholderType(PlaceholderType::TEXT)
{
}
/// process attribute values
void XMLPlaceholderFieldImportContext::ProcessAttribute(
sal_Int32 nAttrToken, std::string_view sAttrValue )
{
switch (nAttrToken) {
case XML_ELEMENT(TEXT, XML_DESCRIPTION):
sDescription = OUString::fromUtf8(sAttrValue);
break;
case XML_ELEMENT(TEXT, XML_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
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
}
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
constexpr OUString gsPropertyAdjust(u"Adjust"_ustr);
XMLTimeFieldImportContext::XMLTimeFieldImportContext(
SvXMLImport& rImport, XMLTextImportHelper& rHlp)
: XMLTextFieldImportContext(rImport, rHlp, sAPI_date_time)
, 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_Int32 nAttrToken, std::string_view sAttrValue )
{
switch (nAttrToken)
{
case XML_ELEMENT(TEXT, XML_TIME_VALUE):
case XML_ELEMENT(OFFICE, XML_TIME_VALUE):
{
if (::sax::Converter::parseTimeOrDateTime(aDateTimeValue, sAttrValue))
{
bTimeOK = true;
}
break;
}
case XML_ELEMENT(TEXT, XML_FIXED):
{
bool bTmp(false);
if (::sax::Converter::convertBool(bTmp, sAttrValue))
{
bFixed = bTmp;
}
break;
}
case XML_ELEMENT(STYLE, XML_DATA_STYLE_NAME):
{
sal_Int32 nKey = GetImportHelper().GetDataStyleKey(
OUString::fromUtf8(sAttrValue), &bIsDefaultLanguage);
if (-1 != nKey)
{
nFormatKey = nKey;
bFormatOK = true;
}
break;
}
case XML_ELEMENT(TEXT, XML_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;
}
default:
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
}
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) :
XMLTimeFieldImportContext(rImport, rHlp)
{
bIsDate = true; // always a date!
}
void XMLDateFieldImportContext::ProcessAttribute(
sal_Int32 nAttrToken,
std::string_view sAttrValue )
{
switch (nAttrToken)
{
case XML_ELEMENT(TEXT, XML_DATE_VALUE):
case XML_ELEMENT(OFFICE, XML_DATE_VALUE):
{
if (::sax::Converter::parseDateTime(aDateTimeValue, sAttrValue))
{
bTimeOK = true;
}
break;
}
case XML_ELEMENT(TEXT, XML_DATE_ADJUST):
// delegate to superclass, pretending it was a time-adjust attr.
XMLTimeFieldImportContext::ProcessAttribute(
XML_ELEMENT(TEXT, XML_TIME_ADJUST),
sAttrValue);
break;
case XML_ELEMENT(TEXT, XML_TIME_VALUE):
case XML_ELEMENT(OFFICE, XML_TIME_VALUE):
case XML_ELEMENT(TEXT, XML_TIME_ADJUST):
; // ignore time-adjust and time-value attributes
break;
default:
// all others: delegate to super-class
return XMLTimeFieldImportContext::ProcessAttribute(nAttrToken,
sAttrValue);
break;
}
}
// database field superclass
constexpr OUStringLiteral gsPropertyDataBaseName(u"DataBaseName");
constexpr OUStringLiteral gsPropertyDataBaseURL(u"DataBaseURL");
constexpr OUStringLiteral gsPropertyTableName(u"DataTableName");
constexpr OUStringLiteral gsPropertyDataCommandType(u"DataCommandType");
constexpr OUStringLiteral gsPropertyIsVisible(u"IsVisible");
XMLDatabaseFieldImportContext::XMLDatabaseFieldImportContext(
SvXMLImport& rImport, XMLTextImportHelper& rHlp,
const OUString& pServiceName, bool bUseDisplay)
: XMLTextFieldImportContext(rImport, rHlp, pServiceName)
, m_nCommandType( sdb::CommandType::TABLE )
, m_bCommandTypeOK(false)
, m_bDisplay( true )
, m_bDisplayOK( false )
, m_bUseDisplay( bUseDisplay )
, m_bDatabaseOK(false)
, m_bDatabaseNameOK(false)
, m_bDatabaseURLOK(false)
, m_bTableOK(false)
{
}
void XMLDatabaseFieldImportContext::ProcessAttribute(
sal_Int32 nAttrToken, std::string_view sAttrValue )
{
switch (nAttrToken)
{
case XML_ELEMENT(TEXT, XML_DATABASE_NAME):
m_sDatabaseName = OUString::fromUtf8(sAttrValue);
m_bDatabaseOK = true;
m_bDatabaseNameOK = true;
break;
case XML_ELEMENT(TEXT, XML_TABLE_NAME):
m_sTableName = OUString::fromUtf8(sAttrValue);
m_bTableOK = true;
break;
case XML_ELEMENT(TEXT, XML_TABLE_TYPE):
if( IsXMLToken( sAttrValue, XML_TABLE ) )
{
m_nCommandType = sdb::CommandType::TABLE;
m_bCommandTypeOK = true;
}
else if( IsXMLToken( sAttrValue, XML_QUERY ) )
{
m_nCommandType = sdb::CommandType::QUERY;
m_bCommandTypeOK = true;
}
else if( IsXMLToken( sAttrValue, XML_COMMAND ) )
{
m_nCommandType = sdb::CommandType::COMMAND;
m_bCommandTypeOK = true;
}
break;
case XML_ELEMENT(TEXT, XML_DISPLAY):
if( IsXMLToken( sAttrValue, XML_NONE ) )
{
m_bDisplay = false;
m_bDisplayOK = true;
}
else if( IsXMLToken( sAttrValue, XML_VALUE ) )
{
m_bDisplay = true;
m_bDisplayOK = true;
}
break;
default:
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
}
css::uno::Reference< css::xml::sax::XFastContextHandler > XMLDatabaseFieldImportContext::createFastChildContext(
sal_Int32 nElement,
const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
{
if (nElement == XML_ELEMENT(FORM, XML_CONNECTION_RESOURCE) )
{
for( auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList) )
{
switch (aIter.getToken())
{
case XML_ELEMENT(XLINK, XML_HREF):
{
m_sDatabaseURL = aIter.toString();
m_bDatabaseOK = true;
m_bDatabaseURLOK = true;
}
break;
default:;
}
}
// we call ProcessAttribute in order to set bValid appropriately
ProcessAttribute( XML_TOKEN_INVALID, "" );
}
else
XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
return nullptr;
}
void XMLDatabaseFieldImportContext::PrepareField(
const Reference<XPropertySet> & xPropertySet)
{
xPropertySet->setPropertyValue(gsPropertyTableName, Any(m_sTableName));
if( m_bDatabaseNameOK )
{
xPropertySet->setPropertyValue(gsPropertyDataBaseName, Any(m_sDatabaseName));
}
else if( m_bDatabaseURLOK )
{
xPropertySet->setPropertyValue(gsPropertyDataBaseURL, Any(m_sDatabaseURL));
}
// #99980# load/save command type for all fields; also load
// old documents without command type
if( m_bCommandTypeOK )
{
xPropertySet->setPropertyValue( gsPropertyDataCommandType, Any(m_nCommandType) );
}
if( m_bUseDisplay && m_bDisplayOK )
{
xPropertySet->setPropertyValue( gsPropertyIsVisible, Any(m_bDisplay) );
}
}
// database name field
XMLDatabaseNameImportContext::XMLDatabaseNameImportContext(
SvXMLImport& rImport, XMLTextImportHelper& rHlp) :
XMLDatabaseFieldImportContext(rImport, rHlp, u"DatabaseName"_ustr, true)
{
}
void XMLDatabaseNameImportContext::ProcessAttribute(
sal_Int32 nAttrToken, std::string_view sAttrValue )
{
// delegate to superclass and check for success
XMLDatabaseFieldImportContext::ProcessAttribute(nAttrToken, sAttrValue);
bValid = m_bDatabaseOK && m_bTableOK;
}
// database next field
XMLDatabaseNextImportContext::XMLDatabaseNextImportContext(
SvXMLImport& rImport, XMLTextImportHelper& rHlp,
const OUString& pServiceName) :
XMLDatabaseFieldImportContext(rImport, rHlp, pServiceName, false),
sPropertyCondition(sAPI_condition),
sTrue(sAPI_true),
bConditionOK(false)
{
}
XMLDatabaseNextImportContext::XMLDatabaseNextImportContext(
SvXMLImport& rImport, XMLTextImportHelper& rHlp)
: XMLDatabaseFieldImportContext(rImport, rHlp, u"DatabaseNextSet"_ustr, false)
, sPropertyCondition(sAPI_condition)
, sTrue(sAPI_true)
, bConditionOK(false)
{
}
void XMLDatabaseNextImportContext::ProcessAttribute(
sal_Int32 nAttrToken, std::string_view sAttrValue )
{
if (XML_ELEMENT(TEXT, XML_CONDITION) == nAttrToken)
{
OUString sTmp;
sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrValueQName(
OUString::fromUtf8(sAttrValue), &sTmp );
if( XML_NAMESPACE_OOOW == nPrefix )
{
sCondition = sTmp;
bConditionOK = true;
}
else
sCondition = OUString::fromUtf8(sAttrValue);
}
else
{
XMLDatabaseFieldImportContext::ProcessAttribute(nAttrToken,
sAttrValue);
}
bValid = m_bDatabaseOK && m_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) :
XMLDatabaseNextImportContext(rImport, rHlp, u"DatabaseNumberOfSet"_ustr),
sPropertySetNumber(sAPI_set_number),
nNumber(0),
bNumberOK(false)
{
}
void XMLDatabaseSelectImportContext::ProcessAttribute(
sal_Int32 nAttrToken,
std::string_view sAttrValue )
{
if (XML_ELEMENT(TEXT, XML_ROW_NUMBER) == nAttrToken)
{
sal_Int32 nTmp;
if (::sax::Converter::convertNumber( nTmp, sAttrValue
/* , nMin, nMax ??? */ ))
{
nNumber = nTmp;
bNumberOK = true;
}
}
else
{
XMLDatabaseNextImportContext::ProcessAttribute(nAttrToken, sAttrValue);
}
bValid = m_bTableOK && m_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) :
XMLDatabaseFieldImportContext(rImport, rHlp, u"DatabaseSetNumber"_ustr, true),
sPropertyNumberingType(
sAPI_numbering_type),
sPropertySetNumber(sAPI_set_number),
sNumberFormat(u"1"_ustr),
sNumberSync(GetXMLToken(XML_FALSE)),
nValue(0),
bValueOK(false)
{
}
void XMLDatabaseNumberImportContext::ProcessAttribute(
sal_Int32 nAttrToken,
std::string_view sAttrValue )
{
switch (nAttrToken)
{
case XML_ELEMENT(STYLE, XML_NUM_FORMAT):
sNumberFormat = OUString::fromUtf8(sAttrValue);
break;
case XML_ELEMENT(STYLE, XML_NUM_LETTER_SYNC):
sNumberSync = OUString::fromUtf8(sAttrValue);
break;
case XML_ELEMENT(TEXT, XML_VALUE_TYPE):
case XML_ELEMENT(OFFICE, XML_VALUE_TYPE):
{
sal_Int32 nTmp;
if (::sax::Converter::convertNumber( nTmp, sAttrValue ))
{
nValue = nTmp;
bValueOK = true;
}
break;
}
default:
XMLDatabaseFieldImportContext::ProcessAttribute(nAttrToken,
sAttrValue);
break;
}
bValid = m_bTableOK && m_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_Int32 nElementToken,
bool bContent, bool bAuthor)
: XMLTextFieldImportContext(rImport, rHlp, MapTokenToServiceName(nElementToken) )
, 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_Int32 nAttrToken,
std::string_view sAttrValue )
{
if (XML_ELEMENT(TEXT, XML_FIXED) == nAttrToken)
{
bool bTmp(false);
if (::sax::Converter::convertBool(bTmp, sAttrValue))
{
bFixed = bTmp;
}
}
else
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
void XMLSimpleDocInfoImportContext::PrepareField(
const Reference<XPropertySet> & rPropertySet)
{
// title field in Calc has no Fixed property
Reference<XPropertySetInfo> xPropertySetInfo(rPropertySet->getPropertySetInfo());
if (!xPropertySetInfo->hasPropertyByName(sPropertyFixed))
return;
Any aAny;
rPropertySet->setPropertyValue(sPropertyFixed, Any(bFixed));
// set Content and CurrentPresentation (if fixed)
if (!bFixed)
return;
// 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);
}
}
OUString XMLSimpleDocInfoImportContext::MapTokenToServiceName(
sal_Int32 nElementToken)
{
OUString pServiceName;
switch(nElementToken)
{
case XML_ELEMENT(TEXT, XML_INITIAL_CREATOR):
pServiceName = "DocInfo.CreateAuthor";
break;
case XML_ELEMENT(TEXT, XML_CREATION_DATE):
pServiceName = sAPI_docinfo_create_date_time;
break;
case XML_ELEMENT(TEXT, XML_CREATION_TIME):
pServiceName = sAPI_docinfo_create_date_time;
break;
case XML_ELEMENT(TEXT, XML_DESCRIPTION):
pServiceName = "DocInfo.Description";
break;
case XML_ELEMENT(TEXT, XML_EDITING_DURATION):
pServiceName = "DocInfo.EditTime";
break;
case XML_ELEMENT(TEXT, XML_USER_DEFINED):
pServiceName = sAPI_docinfo_custom;
break;
case XML_ELEMENT(TEXT, XML_PRINTED_BY):
pServiceName = "DocInfo.PrintAuthor";
break;
case XML_ELEMENT(TEXT, XML_PRINT_DATE):
pServiceName = sAPI_docinfo_print_date_time;
break;
case XML_ELEMENT(TEXT, XML_PRINT_TIME):
pServiceName = sAPI_docinfo_print_date_time;
break;
case XML_ELEMENT(TEXT, XML_KEYWORDS):
pServiceName = "DocInfo.KeyWords";
break;
case XML_ELEMENT(TEXT, XML_SUBJECT):
pServiceName = "DocInfo.Subject";
break;
case XML_ELEMENT(TEXT, XML_EDITING_CYCLES):
pServiceName = "DocInfo.Revision";
break;
case XML_ELEMENT(TEXT, XML_CREATOR):
pServiceName = "DocInfo.ChangeAuthor";
break;
case XML_ELEMENT(TEXT, XML_MODIFICATION_DATE):
pServiceName = sAPI_docinfo_change_date_time;
break;
case XML_ELEMENT(TEXT, XML_MODIFICATION_TIME):
pServiceName = sAPI_docinfo_change_date_time;
break;
case XML_ELEMENT(TEXT, XML_TITLE):
pServiceName = "DocInfo.Title";
break;
default:
XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElementToken);
assert(false);
}
return pServiceName;
}
// revision field
constexpr OUStringLiteral sPropertyRevision(u"Revision");
XMLRevisionDocInfoImportContext::XMLRevisionDocInfoImportContext(
SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_Int32 nElement) :
XMLSimpleDocInfoImportContext(rImport, rHlp, nElement, 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)
return;
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_Int32 nElement)
: XMLSimpleDocInfoImportContext(rImport, rHlp, nElement, 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 (nElement)
{
case XML_ELEMENT(TEXT, XML_CREATION_DATE):
case XML_ELEMENT(TEXT, XML_PRINT_DATE):
case XML_ELEMENT(TEXT, XML_MODIFICATION_DATE):
bIsDate = true;
bHasDateTime = true;
break;
case XML_ELEMENT(TEXT, XML_CREATION_TIME):
case XML_ELEMENT(TEXT, XML_PRINT_TIME):
case XML_ELEMENT(TEXT, XML_MODIFICATION_TIME):
bIsDate = false;
bHasDateTime = true;
break;
case XML_ELEMENT(TEXT, XML_EDITING_DURATION):
bIsDate = false;
bHasDateTime = false;
break;
default:
XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
OSL_FAIL("XMLDateTimeDocInfoImportContext needs date/time doc. fields");
bValid = false;
break;
}
}
void XMLDateTimeDocInfoImportContext::ProcessAttribute(
sal_Int32 nAttrToken,
std::string_view sAttrValue )
{
switch (nAttrToken)
{
case XML_ELEMENT(STYLE, XML_DATA_STYLE_NAME):
{
sal_Int32 nKey = GetImportHelper().GetDataStyleKey(
OUString::fromUtf8(sAttrValue), &bIsDefaultLanguage);
if (-1 != nKey)
{
nFormat = nKey;
bFormatOK = true;
}
break;
}
case XML_ELEMENT(TEXT, XML_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_Int32 nElement) :
XMLSimpleDocInfoImportContext(rImport, rHlp, nElement, 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_Int32 nAttrToken,
std::string_view sAttrValue )
{
switch (nAttrToken)
{
case XML_ELEMENT(STYLE, XML_DATA_STYLE_NAME):
{
sal_Int32 nKey = GetImportHelper().GetDataStyleKey(
OUString::fromUtf8(sAttrValue), &bIsDefaultLanguage);
if (-1 != nKey)
{
nFormat = nKey;
bFormatOK = true;
}
break;
}
case XML_ELEMENT(TEXT, XML_NAME):
{
if (!bValid)
{
SetServiceName(sAPI_docinfo_custom );
aName = OUString::fromUtf8(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) :
XMLTextFieldImportContext(rImport, rHlp, u"HiddenParagraph"_ustr),
sPropertyCondition(sAPI_condition),
sPropertyIsHidden(sAPI_is_hidden),
bIsHidden(false)
{
}
void XMLHiddenParagraphImportContext::ProcessAttribute(
sal_Int32 nAttrToken,
std::string_view sAttrValue )
{
if ( XML_ELEMENT(TEXT, XML_CONDITION) == nAttrToken)
{
OUString sTmp;
sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrValueQName(
OUString::fromUtf8(sAttrValue), &sTmp );
if( XML_NAMESPACE_OOOW == nPrefix )
{
sCondition = sTmp;
bValid = true;
}
else
sCondition = OUString::fromUtf8(sAttrValue);
}
else if ( XML_ELEMENT(TEXT, XML_IS_HIDDEN) == nAttrToken)
{
bool bTmp(false);
if (::sax::Converter::convertBool(bTmp, sAttrValue))
{
bIsHidden = bTmp;
}
}
else
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
void XMLHiddenParagraphImportContext::PrepareField(
const Reference<XPropertySet> & xPropertySet)
{
xPropertySet->setPropertyValue(sPropertyCondition, Any(sCondition));
xPropertySet->setPropertyValue(sPropertyIsHidden, Any(bIsHidden));
}
// import conditional text (<text:conditional-text>)
constexpr OUStringLiteral gsPropertyTrueContent(u"TrueContent");
constexpr OUStringLiteral gsPropertyFalseContent(u"FalseContent");
constexpr OUStringLiteral gsPropertyIsConditionTrue(u"IsConditionTrue");
XMLConditionalTextImportContext::XMLConditionalTextImportContext(
SvXMLImport& rImport, XMLTextImportHelper& rHlp) :
XMLTextFieldImportContext(rImport, rHlp, u"ConditionalText"_ustr),
sPropertyCondition(sAPI_condition),
sPropertyCurrentPresentation(sAPI_current_presentation),
bConditionOK(false),
bTrueOK(false),
bFalseOK(false),
bCurrentValue(false)
{
}
void XMLConditionalTextImportContext::ProcessAttribute(
sal_Int32 nAttrToken,
std::string_view sAttrValue )
{
switch (nAttrToken)
{
case XML_ELEMENT(TEXT, XML_CONDITION):
{
OUString sTmp;
sal_uInt16 nPrefix = GetImport().GetNamespaceMap().
GetKeyByAttrValueQName(OUString::fromUtf8(sAttrValue), &sTmp);
if( XML_NAMESPACE_OOOW == nPrefix )
{
sCondition = sTmp;
bConditionOK = true;
}
else
sCondition = OUString::fromUtf8(sAttrValue);
}
break;
case XML_ELEMENT(TEXT, XML_STRING_VALUE_IF_FALSE):
sFalseContent = OUString::fromUtf8(sAttrValue);
bFalseOK = true;
break;
case XML_ELEMENT(TEXT, XML_STRING_VALUE_IF_TRUE):
sTrueContent = OUString::fromUtf8(sAttrValue);
bTrueOK = true;
break;
case XML_ELEMENT(TEXT, XML_CURRENT_VALUE):
{
bool bTmp(false);
if (::sax::Converter::convertBool(bTmp, sAttrValue))
{
bCurrentValue = bTmp;
}
break;
}
default:
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
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) :
XMLTextFieldImportContext(rImport, rHlp, u"HiddenText"_ustr),
sPropertyCondition(sAPI_condition),
sPropertyContent(sAPI_content),
sPropertyIsHidden(sAPI_is_hidden),
bConditionOK(false),
bStringOK(false),
bIsHidden(false)
{
}
void XMLHiddenTextImportContext::ProcessAttribute(
sal_Int32 nAttrToken,
std::string_view sAttrValue )
{
switch (nAttrToken)
{
case XML_ELEMENT(TEXT, XML_CONDITION):
{
OUString sTmp;
sal_uInt16 nPrefix = GetImport().GetNamespaceMap().
GetKeyByAttrValueQName(OUString::fromUtf8(sAttrValue), &sTmp);
if( XML_NAMESPACE_OOOW == nPrefix )
{
sCondition = sTmp;
bConditionOK = true;
}
else
sCondition = OUString::fromUtf8(sAttrValue);
}
break;
case XML_ELEMENT(TEXT, XML_STRING_VALUE):
case XML_ELEMENT(OFFICE, XML_STRING_VALUE):
sString = OUString::fromUtf8(sAttrValue);
bStringOK = true;
break;
case XML_ELEMENT(TEXT, XML_IS_HIDDEN):
{
bool bTmp(false);
if (::sax::Converter::convertBool(bTmp, sAttrValue))
{
bIsHidden = bTmp;
}
break;
}
default:
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
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
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) :
XMLTextFieldImportContext(rImport, rHlp, u"FileName"_ustr),
sPropertyFixed(sAPI_is_fixed),
sPropertyFileFormat(sAPI_file_format),
sPropertyCurrentPresentation(
sAPI_current_presentation),
nFormat(FilenameDisplayFormat::FULL),
bFixed(false)
{
bValid = true;
}
void XMLFileNameImportContext::ProcessAttribute(
sal_Int32 nAttrToken,
std::string_view sAttrValue )
{
switch (nAttrToken)
{
case XML_ELEMENT(TEXT, XML_FIXED):
{
bool bTmp(false);
if (::sax::Converter::convertBool(bTmp, sAttrValue))
{
bFixed = bTmp;
}
break;
}
case XML_ELEMENT(TEXT, XML_DISPLAY):
{
sal_uInt16 nTmp;
if (SvXMLUnitConverter::convertEnum(nTmp, sAttrValue,
aFilenameDisplayMap))
{
nFormat = nTmp;
}
break;
}
default:
// unknown attribute: ignore
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
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
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) :
XMLTextFieldImportContext(rImport, rHlp, u"TemplateName"_ustr),
sPropertyFileFormat(sAPI_file_format),
nFormat(TemplateDisplayFormat::FULL)
{
bValid = true;
}
void XMLTemplateNameImportContext::ProcessAttribute(
sal_Int32 nAttrToken,
std::string_view sAttrValue )
{
switch (nAttrToken)
{
case XML_ELEMENT(TEXT, XML_DISPLAY):
{
sal_uInt16 nTmp;
if (SvXMLUnitConverter::convertEnum(nTmp, sAttrValue,
aTemplateDisplayMap))
{
nFormat = nTmp;
}
break;
}
default:
// unknown attribute: ignore
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
break;
}
}
void XMLTemplateNameImportContext::PrepareField(
const Reference<XPropertySet> & xPropertySet)
{
xPropertySet->setPropertyValue(sPropertyFileFormat, Any(nFormat));
}
// import chapter fields
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 }
};
constexpr OUStringLiteral gsPropertyChapterFormat(u"ChapterFormat");
constexpr OUStringLiteral gsPropertyLevel(u"Level");
XMLChapterImportContext::XMLChapterImportContext(
SvXMLImport& rImport, XMLTextImportHelper& rHlp) :
XMLTextFieldImportContext(rImport, rHlp, u"Chapter"_ustr),
nFormat(ChapterFormat::NAME_NUMBER),
nLevel(0)
{
bValid = true;
}
void XMLChapterImportContext::ProcessAttribute(
sal_Int32 nAttrToken,
std::string_view sAttrValue )
{
switch (nAttrToken)
{
case XML_ELEMENT(TEXT, XML_DISPLAY):
{
sal_uInt16 nTmp;
if (SvXMLUnitConverter::convertEnum(nTmp, sAttrValue,
aChapterDisplayMap))
{
nFormat = static_cast<sal_Int16>(nTmp);
}
break;
}
case XML_ELEMENT(TEXT, XML_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
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
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_Int32 nElement) :
XMLTextFieldImportContext(rImport, rHlp, MapTokenToServiceName(nElement)),
sPropertyNumberingType(
sAPI_numbering_type),
bNumberFormatOK(false)
{
bValid = true;
}
void XMLCountFieldImportContext::ProcessAttribute(
sal_Int32 nAttrToken,
std::string_view sAttrValue )
{
switch (nAttrToken)
{
case XML_ELEMENT(STYLE, XML_NUM_FORMAT):
sNumberFormat = OUString::fromUtf8(sAttrValue);
bNumberFormatOK = true;
break;
case XML_ELEMENT(STYLE, XML_NUM_LETTER_SYNC):
sLetterSync = OUString::fromUtf8(sAttrValue);
break;
default:
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
}
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))
return;
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));
}
OUString XMLCountFieldImportContext::MapTokenToServiceName(
sal_Int32 nElement)
{
OUString pServiceName;
switch (nElement)
{
case XML_ELEMENT(TEXT, XML_WORD_COUNT):
pServiceName = "WordCount";
break;
case XML_ELEMENT(TEXT, XML_PARAGRAPH_COUNT):
pServiceName = "ParagraphCount";
break;
case XML_ELEMENT(TEXT, XML_TABLE_COUNT):
pServiceName = "TableCount";
break;
case XML_ELEMENT(TEXT, XML_CHARACTER_COUNT):
pServiceName = "CharacterCount";
break;
case XML_ELEMENT(TEXT, XML_IMAGE_COUNT):
pServiceName = "GraphicObjectCount";
break;
case XML_ELEMENT(TEXT, XML_OBJECT_COUNT):
pServiceName = "EmbeddedObjectCount";
break;
case XML_ELEMENT(TEXT, XML_PAGE_COUNT):
pServiceName = "PageCount";
break;
default:
XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
assert(false);
}
return pServiceName;
}
// page variable import
XMLPageVarGetFieldImportContext::XMLPageVarGetFieldImportContext(
SvXMLImport& rImport, XMLTextImportHelper& rHlp) :
XMLTextFieldImportContext(rImport, rHlp, u"ReferencePageGet"_ustr),
bNumberFormatOK(false)
{
bValid = true;
}
void XMLPageVarGetFieldImportContext::ProcessAttribute(
sal_Int32 nAttrToken,
std::string_view sAttrValue )
{
switch (nAttrToken)
{
case XML_ELEMENT(STYLE, XML_NUM_FORMAT):
sNumberFormat = OUString::fromUtf8(sAttrValue);
bNumberFormatOK = true;
break;
case XML_ELEMENT(STYLE, XML_NUM_LETTER_SYNC):
sLetterSync = OUString::fromUtf8(sAttrValue);
break;
default:
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
}
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) :
XMLTextFieldImportContext(rImport, rHlp, u"ReferencePageSet"_ustr),
nAdjust(0),
bActive(true)
{
bValid = true;
}
void XMLPageVarSetFieldImportContext::ProcessAttribute(
sal_Int32 nAttrToken,
std::string_view sAttrValue )
{
switch (nAttrToken)
{
case XML_ELEMENT(TEXT, XML_ACTIVE):
{
bool bTmp(false);
if (::sax::Converter::convertBool(bTmp, sAttrValue))
{
bActive = bTmp;
}
break;
}
case XML_ELEMENT(TEXT, XML_PAGE_ADJUST):
{
sal_Int32 nTmp(0);
if (::sax::Converter::convertNumber(nTmp, sAttrValue))
{
nAdjust = static_cast<sal_Int16>(nTmp);
}
break;
}
default:
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
break;
}
}
void XMLPageVarSetFieldImportContext::PrepareField(
const Reference<XPropertySet> & xPropertySet)
{
xPropertySet->setPropertyValue(u"On"_ustr, Any(bActive));
xPropertySet->setPropertyValue(sAPI_offset, Any(nAdjust));
}
// macro fields
XMLMacroFieldImportContext::XMLMacroFieldImportContext(
SvXMLImport& rImport, XMLTextImportHelper& rHlp) :
XMLTextFieldImportContext(rImport, rHlp, u"Macro"_ustr),
bDescriptionOK(false)
{
}
css::uno::Reference< css::xml::sax::XFastContextHandler > XMLMacroFieldImportContext::createFastChildContext(
sal_Int32 nElement,
const css::uno::Reference< css::xml::sax::XFastAttributeList >& )
{
if ( nElement == XML_ELEMENT(OFFICE, XML_EVENT_LISTENERS) )
{
// create events context and remember it!
xEventContext = new XMLEventsImportContext( GetImport() );
bValid = true;
return xEventContext;
}
XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
return nullptr;
}
void XMLMacroFieldImportContext::ProcessAttribute(
sal_Int32 nAttrToken,
std::string_view sAttrValue )
{
switch (nAttrToken)
{
case XML_ELEMENT(TEXT, XML_DESCRIPTION):
sDescription = OUString::fromUtf8(sAttrValue);
bDescriptionOK = true;
break;
case XML_ELEMENT(TEXT, XML_NAME):
sMacro = OUString::fromUtf8(sAttrValue);
bValid = true;
break;
default:
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
}
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 = xEventContext.get();
Sequence<PropertyValue> aValues;
pEvents->GetEventSequence( u"OnClick"_ustr, aValues );
for (const auto& rValue : 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(u"ScriptURL"_ustr, Any(sScriptURL));
xPropertySet->setPropertyValue(u"MacroName"_ustr, Any(sMacroName));
xPropertySet->setPropertyValue(u"MacroLibrary"_ustr, Any(sLibraryName));
}
// reference field import
XMLReferenceFieldImportContext::XMLReferenceFieldImportContext(
SvXMLImport& rImport, XMLTextImportHelper& rHlp,
sal_Int32 nToken)
: XMLTextFieldImportContext(rImport, rHlp, u"GetReference"_ustr)
, nElementToken(nToken)
, nSource(0)
, nType(ReferenceFieldPart::PAGE_DESC)
, nFlags(0)
, bNameOK(false)
, bTypeOK(false)
{
}
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::startFastElement(
sal_Int32 nElement,
const Reference<XFastAttributeList> & xAttrList)
{
bTypeOK = true;
switch (nElementToken)
{
case XML_ELEMENT(TEXT, XML_REFERENCE_REF):
nSource = ReferenceFieldSource::REFERENCE_MARK;
break;
case XML_ELEMENT(TEXT, XML_BOOKMARK_REF):
nSource = ReferenceFieldSource::BOOKMARK;
break;
case XML_ELEMENT(TEXT, XML_NOTE_REF):
nSource = ReferenceFieldSource::FOOTNOTE;
break;
case XML_ELEMENT(TEXT, XML_SEQUENCE_REF):
nSource = ReferenceFieldSource::SEQUENCE_FIELD;
break;
case XML_ELEMENT(TEXT, XML_STYLE_REF):
case XML_ELEMENT(LO_EXT, XML_STYLE_REF):
nSource = ReferenceFieldSource::STYLE;
break;
default:
XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElementToken);
bTypeOK = false;
break;
}
XMLTextFieldImportContext::startFastElement(nElement, xAttrList);
}
void XMLReferenceFieldImportContext::ProcessAttribute(
sal_Int32 nAttrToken,
std::string_view sAttrValue )
{
switch (nAttrToken)
{
case XML_ELEMENT(TEXT, XML_NOTE_CLASS):
if( IsXMLToken( sAttrValue, XML_ENDNOTE ) )
nSource = ReferenceFieldSource::ENDNOTE;
break;
case XML_ELEMENT(TEXT, XML_REF_NAME):
sName = OUString::fromUtf8(sAttrValue);
bNameOK = true;
break;
case XML_ELEMENT(TEXT, XML_REFERENCE_FORMAT):
{
sal_uInt16 nToken;
if (SvXMLUnitConverter::convertEnum(nToken, sAttrValue,
lcl_aReferenceTypeTokenMap))
{
nType = nToken;
}
// check for sequence-only-attributes
if ( (XML_ELEMENT(TEXT, XML_SEQUENCE_REF) != nElementToken) &&
( (nType == ReferenceFieldPart::CATEGORY_AND_NUMBER) ||
(nType == ReferenceFieldPart::ONLY_CAPTION) ||
(nType == ReferenceFieldPart::ONLY_SEQUENCE_NUMBER) ) )
{
nType = ReferenceFieldPart::PAGE_DESC;
}
break;
}
case XML_ELEMENT(LO_EXT, XML_REFERENCE_LANGUAGE):
case XML_ELEMENT(TEXT, XML_REFERENCE_LANGUAGE):
sLanguage = OUString::fromUtf8(sAttrValue);
break;
case XML_ELEMENT(LO_EXT, XML_REFERENCE_HIDE_NON_NUMERICAL):
case XML_ELEMENT(TEXT, XML_REFERENCE_HIDE_NON_NUMERICAL):
if (OUString::fromUtf8(sAttrValue).toBoolean())
nFlags |= REFFLDFLAG_STYLE_HIDE_NON_NUMERICAL;
break;
case XML_ELEMENT(LO_EXT, XML_REFERENCE_FROM_BOTTOM):
case XML_ELEMENT(TEXT, XML_REFERENCE_FROM_BOTTOM):
if (OUString::fromUtf8(sAttrValue).toBoolean())
nFlags |= REFFLDFLAG_STYLE_FROM_BOTTOM;
break;
default:
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
// bValid: we need proper element type and name
bValid = bTypeOK && bNameOK;
}
void XMLReferenceFieldImportContext::PrepareField(
const Reference<XPropertySet> & xPropertySet)
{
xPropertySet->setPropertyValue(u"ReferenceFieldPart"_ustr, Any(nType));
xPropertySet->setPropertyValue(u"ReferenceFieldSource"_ustr, Any(nSource));
xPropertySet->setPropertyValue(u"ReferenceFieldLanguage"_ustr, Any(sLanguage));
switch (nElementToken)
{
case XML_ELEMENT(TEXT, XML_REFERENCE_REF):
case XML_ELEMENT(TEXT, XML_BOOKMARK_REF):
case XML_ELEMENT(TEXT, XML_STYLE_REF):
case XML_ELEMENT(LO_EXT, XML_STYLE_REF):
xPropertySet->setPropertyValue(u"SourceName"_ustr, Any(sName));
xPropertySet->setPropertyValue(u"ReferenceFieldFlags"_ustr, Any(nFlags));
break;
case XML_ELEMENT(TEXT, XML_NOTE_REF):
GetImportHelper().ProcessFootnoteReference(sName, xPropertySet);
break;
case XML_ELEMENT(TEXT, XML_SEQUENCE_REF):
GetImportHelper().ProcessSequenceReference(sName, xPropertySet);
break;
}
xPropertySet->setPropertyValue(sAPI_current_presentation, Any(GetContent()));
}
// field declarations container
XMLDdeFieldDeclsImportContext::XMLDdeFieldDeclsImportContext(SvXMLImport& rImport) :
SvXMLImportContext(rImport)
{
}
css::uno::Reference< css::xml::sax::XFastContextHandler > XMLDdeFieldDeclsImportContext::createFastChildContext(
sal_Int32 nElement,
const css::uno::Reference< css::xml::sax::XFastAttributeList >& )
{
if ( nElement == XML_ELEMENT(TEXT, XML_DDE_CONNECTION_DECL) )
{
return new XMLDdeFieldDeclImportContext(GetImport());
}
else
XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
return nullptr;
}
// import dde field declaration
XMLDdeFieldDeclImportContext::XMLDdeFieldDeclImportContext(SvXMLImport& rImport)
: SvXMLImportContext(rImport)
{
}
void XMLDdeFieldDeclImportContext::startFastElement(
sal_Int32 /*nElement*/,
const Reference<XFastAttributeList> & 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
for( auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ) )
{
switch (aIter.getToken())
{
case XML_ELEMENT(OFFICE, XML_NAME):
sName = aIter.toString();
bNameOK = true;
break;
case XML_ELEMENT(OFFICE, XML_DDE_APPLICATION):
sCommandApplication = aIter.toString();
bCommandApplicationOK = true;
break;
case XML_ELEMENT(OFFICE, XML_DDE_TOPIC):
sCommandTopic = aIter.toString();
bCommandTopicOK = true;
break;
case XML_ELEMENT(OFFICE, XML_DDE_ITEM):
sCommandItem = aIter.toString();
bCommandItemOK = true;
break;
case XML_ELEMENT(OFFICE, XML_AUTOMATIC_UPDATE):
{
bool bTmp(false);
if (::sax::Converter::convertBool(bTmp, aIter.toView()) )
{
bUpdate = bTmp;
}
break;
}
default:
XMLOFF_WARN_UNKNOWN("xmloff", aIter);
}
}
// valid data?
if (!(bNameOK && bCommandApplicationOK && bCommandTopicOK && bCommandItemOK))
return;
// create DDE TextFieldMaster
Reference<XMultiServiceFactory> xFactory(GetImport().GetModel(),
UNO_QUERY);
if( !xFactory.is() )
return;
/* #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(OUString::Concat(sAPI_fieldmaster_prefix) + sAPI_dde);
if( xIfc.is() )
{
Reference<XPropertySet> xPropSet( xIfc, UNO_QUERY );
if (xPropSet.is() &&
xPropSet->getPropertySetInfo()->hasPropertyByName(
u"DDECommandType"_ustr))
{
xPropSet->setPropertyValue(sAPI_name, Any(sName));
xPropSet->setPropertyValue(u"DDECommandType"_ustr, Any(sCommandApplication));
xPropSet->setPropertyValue(u"DDECommandFile"_ustr, Any(sCommandTopic));
xPropSet->setPropertyValue(u"DDECommandElement"_ustr,
Any(sCommandItem));
xPropSet->setPropertyValue(u"IsAutomaticUpdate"_ustr,
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) :
XMLTextFieldImportContext(rImport, rHlp, sAPI_dde),
sPropertyContent(sAPI_content)
{
}
void XMLDdeFieldImportContext::ProcessAttribute(
sal_Int32 nAttrToken,
std::string_view sAttrValue )
{
if ( XML_ELEMENT(TEXT, XML_CONNECTION_NAME) == nAttrToken)
{
sName = OUString::fromUtf8(sAttrValue);
bValid = true;
}
else
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
void XMLDdeFieldImportContext::endFastElement(sal_Int32 )
{
if (!bValid)
return;
// find master
OUString sMasterName = OUString::Concat(sAPI_fieldmaster_prefix) + sAPI_dde + "." + sName;
Reference<XTextFieldsSupplier> xTextFieldsSupp(GetImport().GetModel(),
UNO_QUERY);
Reference<container::XNameAccess> xFieldMasterNameAccess =
xTextFieldsSupp->getTextFieldMasters();
if (!xFieldMasterNameAccess->hasByName(sMasterName))
return;
Reference<XPropertySet> xMaster;
Any aAny = xFieldMasterNameAccess->getByName(sMasterName);
aAny >>= xMaster;
//apply the content to the master
xMaster->setPropertyValue( sPropertyContent, uno::Any( GetContent()));
// master exists: create text field and attach
Reference<XPropertySet> xField;
OUString sFieldName = OUString::Concat(sAPI_textfield_prefix) + sAPI_dde;
if (!CreateField(xField, sFieldName))
return;
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) :
XMLTextFieldImportContext(rImport, rHlp, u"SheetName"_ustr)
{
bValid = true; // always valid!
}
void XMLSheetNameImportContext::ProcessAttribute(
sal_Int32 nAttrToken,
std::string_view sAttrValue)
{
// no attributes -> nothing to be done
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
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
: XMLTextFieldImportContext(rImport, rHlp, u"PageName"_ustr )
{
bValid = true;
}
/// process attribute values
void XMLPageNameFieldImportContext::ProcessAttribute( sal_Int32 nAttrToken,
std::string_view sAttrValue )
{
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
/// 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) :
XMLTextFieldImportContext(rImport, rHlp, sAPI_url),
bFrameOK(false)
{
}
void XMLUrlFieldImportContext::ProcessAttribute(
sal_Int32 nAttrToken,
std::string_view sAttrValue )
{
switch (nAttrToken)
{
case XML_ELEMENT(XLINK, XML_HREF):
sURL = GetImport().GetAbsoluteReference( OUString::fromUtf8(sAttrValue) );
bValid = true;
break;
case XML_ELEMENT(OFFICE, XML_TARGET_FRAME_NAME):
sFrame = OUString::fromUtf8(sAttrValue);
bFrameOK = true;
break;
default:
// ignore
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
break;
}
}
void XMLUrlFieldImportContext::PrepareField(
const Reference<XPropertySet> & xPropertySet)
{
xPropertySet->setPropertyValue(sAPI_url, Any(sURL));
if (bFrameOK)
{
xPropertySet->setPropertyValue(u"TargetFrame"_ustr, Any(sFrame));
}
xPropertySet->setPropertyValue(u"Representation"_ustr, Any(GetContent()));
}
XMLBibliographyFieldImportContext::XMLBibliographyFieldImportContext(
SvXMLImport& rImport,
XMLTextImportHelper& rHlp) :
XMLTextFieldImportContext(rImport, rHlp, u"Bibliography"_ustr)
{
bValid = true;
}
// TODO: this is the same map as is used in the text field export
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::startFastElement(
sal_Int32 /*nElement*/,
const Reference<XFastAttributeList> & xAttrList)
{
// iterate over attributes
for( auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ) )
{
if (IsTokenInNamespace(aIter.getToken(), XML_NAMESPACE_TEXT)
|| IsTokenInNamespace(aIter.getToken(), XML_NAMESPACE_LO_EXT))
{
auto nToken = aIter.getToken() & TOKEN_MASK;
PropertyValue aValue;
aValue.Name = MapBibliographyFieldName(nToken);
// special treatment for bibliography type
// biblio vs bibilio: #96658#; also read old documents
if (nToken == XML_BIBILIOGRAPHIC_TYPE ||
nToken == XML_BIBLIOGRAPHY_TYPE )
{
sal_uInt16 nTmp;
if (SvXMLUnitConverter::convertEnum(
nTmp, aIter.toView(),
aBibliographyDataTypeMap))
{
aValue.Value <<= static_cast<sal_Int16>(nTmp);
aValues.push_back(aValue);
}
}
else
{
OUString aStringValue = aIter.toString();
if (nToken == XML_URL || nToken == XML_LOCAL_URL || nToken == XML_TARGET_URL)
{
aStringValue = GetImport().GetAbsoluteReference(aStringValue);
}
aValue.Value <<= aStringValue;
aValues.push_back(aValue);
}
}
// else: unknown namespace -> ignore
}
}
void XMLBibliographyFieldImportContext::ProcessAttribute(
sal_Int32 ,
std::string_view )
{
// attributes are handled in StartElement
assert(false && "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);
auto aValueSequenceRange = asNonConstRange(aValueSequence);
for(sal_Int32 i = 0; i < nCount; i++)
{
aValueSequenceRange[i] = aValues[i];
}
// set sequence
xPropertySet->setPropertyValue(u"Fields"_ustr, Any(aValueSequence));
}
OUString XMLBibliographyFieldImportContext::MapBibliographyFieldName(
sal_Int32 nElement)
{
OUString pName;
switch (nElement & TOKEN_MASK)
{
case XML_IDENTIFIER:
pName = u"Identifier"_ustr;
break;
case XML_BIBILIOGRAPHIC_TYPE:
case XML_BIBLIOGRAPHY_TYPE:
// biblio... vs bibilio...: #96658#: also read old documents
pName = u"BibiliographicType"_ustr;
break;
case XML_ADDRESS:
pName = u"Address"_ustr;
break;
case XML_ANNOTE:
pName = u"Annote"_ustr;
break;
case XML_AUTHOR:
pName = u"Author"_ustr;
break;
case XML_BOOKTITLE:
pName = u"Booktitle"_ustr;
break;
case XML_CHAPTER:
pName = u"Chapter"_ustr;
break;
case XML_EDITION:
pName = u"Edition"_ustr;
break;
case XML_EDITOR:
pName = u"Editor"_ustr;
break;
case XML_HOWPUBLISHED:
pName = u"Howpublished"_ustr;
break;
case XML_INSTITUTION:
pName = u"Institution"_ustr;
break;
case XML_JOURNAL:
pName = u"Journal"_ustr;
break;
case XML_MONTH:
pName = u"Month"_ustr;
break;
case XML_NOTE:
pName = u"Note"_ustr;
break;
case XML_NUMBER:
pName = u"Number"_ustr;
break;
case XML_ORGANIZATIONS:
pName = u"Organizations"_ustr;
break;
case XML_PAGES:
pName = u"Pages"_ustr;
break;
case XML_PUBLISHER:
pName = u"Publisher"_ustr;
break;
case XML_SCHOOL:
pName = u"School"_ustr;
break;
case XML_SERIES:
pName = u"Series"_ustr;
break;
case XML_TITLE:
pName = u"Title"_ustr;
break;
case XML_REPORT_TYPE:
pName = u"Report_Type"_ustr;
break;
case XML_VOLUME:
pName = u"Volume"_ustr;
break;
case XML_YEAR:
pName = u"Year"_ustr;
break;
case XML_URL:
pName = u"URL"_ustr;
break;
case XML_CUSTOM1:
pName = u"Custom1"_ustr;
break;
case XML_CUSTOM2:
pName = u"Custom2"_ustr;
break;
case XML_CUSTOM3:
pName = u"Custom3"_ustr;
break;
case XML_CUSTOM4:
pName = u"Custom4"_ustr;
break;
case XML_CUSTOM5:
pName = u"Custom5"_ustr;
break;
case XML_ISBN:
pName = u"ISBN"_ustr;
break;
case XML_LOCAL_URL:
pName = u"LocalURL"_ustr;
break;
case XML_TARGET_TYPE:
pName = u"TargetType"_ustr;
break;
case XML_TARGET_URL:
pName = u"TargetURL"_ustr;
break;
default:
assert(false && "Unknown bibliography info data");
}
return pName;
}
// Annotation Field
XMLAnnotationImportContext::XMLAnnotationImportContext(
SvXMLImport& rImport,
XMLTextImportHelper& rHlp,
sal_Int32 nElement) :
XMLTextFieldImportContext(rImport, rHlp, u"Annotation"_ustr),
mnElement(nElement)
{
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_Int32 nAttrToken,
std::string_view sAttrValue )
{
if (nAttrToken == XML_ELEMENT(OFFICE, XML_NAME))
aName = OUString::fromUtf8(sAttrValue);
else if (nAttrToken == XML_ELEMENT(LO_EXT, XML_RESOLVED))
aResolved = OUString::fromUtf8(sAttrValue);
else if (nAttrToken == XML_ELEMENT(LO_EXT, XML_PARENT_NAME))
aParentName = OUString::fromUtf8(sAttrValue);
else
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
css::uno::Reference< css::xml::sax::XFastContextHandler > XMLAnnotationImportContext::createFastChildContext(
sal_Int32 nElement,
const uno::Reference< xml::sax::XFastAttributeList>& xAttrList )
{
if( nElement == XML_ELEMENT(DC, XML_CREATOR) )
return new XMLStringBufferImportContext(GetImport(), aAuthorBuffer);
else if( nElement == XML_ELEMENT(DC, XML_DATE) )
return new XMLStringBufferImportContext(GetImport(), aDateBuffer);
else if (nElement == XML_ELEMENT(TEXT,XML_SENDER_INITIALS) ||
nElement == XML_ELEMENT(LO_EXT, XML_SENDER_INITIALS) ||
nElement == XML_ELEMENT(META, XML_CREATOR_INITIALS))
return new XMLStringBufferImportContext(GetImport(), aInitialsBuffer);
try
{
bool bOK = true;
if ( !mxField.is() )
bOK = CreateField( mxField, sServicePrefix + GetServiceName() );
if (bOK)
{
Any aAny = mxField->getPropertyValue( u"TextRange"_ustr );
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 );
return xTxtImport->CreateTextChildContext( GetImport(), nElement, xAttrList );
}
}
}
}
catch (const Exception&)
{
}
return new XMLStringBufferImportContext(GetImport(), aTextBuffer);
}
void XMLAnnotationImportContext::endFastElement(sal_Int32 /*nElement*/)
{
DBG_ASSERT(!GetServiceName().isEmpty(), "no service name for element!");
if( mxCursor.is() )
{
// delete addition newline
mxCursor->gotoEnd( false );
mxCursor->goLeft( 1, true );
mxCursor->setString( u""_ustr );
// reset cursor
GetImport().GetTextImport()->ResetCursor();
}
if( mxOldCursor.is() )
GetImport().GetTextImport()->SetCursor( mxOldCursor );
// reinstall old list item #91964#
GetImport().GetTextImport()->PopListContext();
if (!bValid)
{
GetImportHelper().InsertString(GetContent());
return;
}
if ( mnElement == XML_ELEMENT(OFFICE, XML_ANNOTATION_END) )
{
// Search for a previous annotation with the same name.
uno::Reference< text::XTextContent > xPrevField;
{
Reference<XTextFieldsSupplier> xTextFieldsSupplier(GetImport().GetModel(), UNO_QUERY);
if (!xTextFieldsSupplier)
return;
uno::Reference<container::XUniqueIDAccess> xFieldsAccess(xTextFieldsSupplier->getTextFields(), UNO_QUERY_THROW);
uno::Any aAny = xFieldsAccess->getByUniqueID(aName);
aAny >>= xPrevField;
}
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());
try
{
xCursor->gotoRange(xPrevField->getAnchor(), true);
}
catch (const uno::RuntimeException&)
{
// Losing the start of the anchor is better than not opening the document at
// all.
TOOLS_WARN_EXCEPTION(
"xmloff.text",
"XMLAnnotationImportContext::endFastElement: gotoRange() failed: ");
}
xText->insertTextContent(xCursor, xPrevField, !xCursor->isCollapsed());
}
return;
}
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
}
}
}
void XMLAnnotationImportContext::PrepareField(
const Reference<XPropertySet> & xPropertySet )
{
// import (possibly empty) author
OUString sAuthor( aAuthorBuffer.makeStringAndClear() );
xPropertySet->setPropertyValue(sAPI_author, Any(sAuthor));
// import (possibly empty) initials
OUString sInitials( aInitialsBuffer.makeStringAndClear() );
xPropertySet->setPropertyValue(u"Initials"_ustr, Any(sInitials));
//import resolved flag
bool bTmp(false);
(void)::sax::Converter::convertBool(bTmp, aResolved);
xPropertySet->setPropertyValue(u"Resolved"_ustr, Any(bTmp));
util::DateTime aDateTime;
if (::sax::Converter::parseDateTime(aDateTime, aDateBuffer))
{
/*
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, Any(aDateTime));
}
aDateBuffer.setLength(0);
if ( aTextBuffer.getLength() )
{
// delete last paragraph mark (if necessary)
if (char(0x0a) == aTextBuffer[aTextBuffer.getLength()-1])
aTextBuffer.setLength(aTextBuffer.getLength()-1);
xPropertySet->setPropertyValue(sAPI_content, Any(aTextBuffer.makeStringAndClear()));
}
if (!aName.isEmpty())
xPropertySet->setPropertyValue(sAPI_name, Any(aName));
if (!aParentName.isEmpty())
xPropertySet->setPropertyValue(sAPI_parent_name, Any(aParentName));
}
// script field
XMLScriptImportContext::XMLScriptImportContext(
SvXMLImport& rImport,
XMLTextImportHelper& rHlp)
: XMLTextFieldImportContext(rImport, rHlp, u"Script"_ustr)
, bContentOK(false)
{
}
void XMLScriptImportContext::ProcessAttribute(
sal_Int32 nAttrToken,
std::string_view sAttrValue )
{
switch (nAttrToken)
{
case XML_ELEMENT(XLINK, XML_HREF):
sContent = GetImport().GetAbsoluteReference( OUString::fromUtf8(sAttrValue) );
bContentOK = true;
break;
case XML_ELEMENT(SCRIPT, XML_LANGUAGE):
sScriptType = OUString::fromUtf8(sAttrValue);
break;
default:
// ignore
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
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(u"URLContent"_ustr, Any(bContentOK));
xPropertySet->setPropertyValue(u"ScriptType"_ustr, Any(sScriptType));
}
// measure field
XMLMeasureFieldImportContext::XMLMeasureFieldImportContext(
SvXMLImport& rImport,
XMLTextImportHelper& rHlp) :
XMLTextFieldImportContext(rImport, rHlp, u"Measure"_ustr),
mnKind( 0 )
{
}
void XMLMeasureFieldImportContext::ProcessAttribute(
sal_Int32 nAttrToken,
std::string_view sAttrValue )
{
switch (nAttrToken)
{
case XML_ELEMENT(TEXT, XML_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;
default:
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
}
void XMLMeasureFieldImportContext::PrepareField(
const Reference<XPropertySet> & xPropertySet)
{
xPropertySet->setPropertyValue(u"Kind"_ustr, Any(mnKind));
}
// dropdown field
XMLDropDownFieldImportContext::XMLDropDownFieldImportContext(
SvXMLImport& rImport,
XMLTextImportHelper& rHlp) :
XMLTextFieldImportContext( rImport, rHlp, u"DropDown"_ustr ),
nSelected( -1 ),
bNameOK( false ),
bHelpOK(false),
bHintOK(false)
{
bValid = true;
}
static bool lcl_ProcessLabel(
const Reference<XFastAttributeList>& xAttrList,
OUString& rLabel,
bool& rIsSelected )
{
bool bValid = false;
for( auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList) )
{
switch (aIter.getToken())
{
case XML_ELEMENT(TEXT, XML_VALUE):
{
rLabel = aIter.toString();
bValid = true;
break;
}
case XML_ELEMENT(TEXT, XML_CURRENT_SELECTED):
{
bool bTmp(false);
if (::sax::Converter::convertBool( bTmp, aIter.toView() ))
rIsSelected = bTmp;
break;
}
default:
XMLOFF_WARN_UNKNOWN("xmloff", aIter);
}
}
return bValid;
}
css::uno::Reference< css::xml::sax::XFastContextHandler > XMLDropDownFieldImportContext::createFastChildContext(
sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
{
if( nElement == XML_ELEMENT(TEXT, XML_LABEL) )
{
OUString sLabel;
bool bIsSelected = false;
if( lcl_ProcessLabel( xAttrList, sLabel, bIsSelected ) )
{
if( bIsSelected )
nSelected = static_cast<sal_Int32>( aLabels.size() );
aLabels.push_back( sLabel );
}
}
return new SvXMLImportContext( GetImport() );
}
void XMLDropDownFieldImportContext::ProcessAttribute(
sal_Int32 nAttrToken,
std::string_view sAttrValue )
{
if( nAttrToken == XML_ELEMENT(TEXT, XML_NAME))
{
sName = OUString::fromUtf8(sAttrValue);
bNameOK = true;
}
else if (nAttrToken == XML_ELEMENT(TEXT, XML_HELP))
{
sHelp = OUString::fromUtf8(sAttrValue);
bHelpOK = true;
}
else if (nAttrToken == XML_ELEMENT(TEXT, XML_HINT))
{
sHint = OUString::fromUtf8(sAttrValue);
bHintOK = true;
}
else
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
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( u"Items"_ustr, Any(aSequence) );
if( nSelected >= 0 && nSelected < nLength )
{
xPropertySet->setPropertyValue( u"SelectedItem"_ustr, Any(pSequence[nSelected]) );
}
// set name
if( bNameOK )
{
xPropertySet->setPropertyValue( u"Name"_ustr, Any(sName) );
}
// set help
if( bHelpOK )
{
xPropertySet->setPropertyValue( u"Help"_ustr, Any(sHelp) );
}
// set hint
if( bHintOK )
{
xPropertySet->setPropertyValue( u"Tooltip"_ustr, Any(sHint) );
}
}
/** import header fields (<draw:header>) */
XMLHeaderFieldImportContext::XMLHeaderFieldImportContext(
SvXMLImport& rImport, /// XML Import
XMLTextImportHelper& rHlp) /// Text import helper
: XMLTextFieldImportContext(rImport, rHlp, u"Header"_ustr )
{
sServicePrefix = sAPI_presentation_prefix;
bValid = true;
}
/// process attribute values
void XMLHeaderFieldImportContext::ProcessAttribute( sal_Int32 nAttrToken, std::string_view sAttrValue )
{
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
/// 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
: XMLTextFieldImportContext(rImport, rHlp, u"Footer"_ustr )
{
sServicePrefix = sAPI_presentation_prefix;
bValid = true;
}
/// process attribute values
void XMLFooterFieldImportContext::ProcessAttribute( sal_Int32 nAttrToken, std::string_view sAttrValue)
{
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
/// 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
: XMLTextFieldImportContext(rImport, rHlp, u"DateTime"_ustr )
{
sServicePrefix = sAPI_presentation_prefix;
bValid = true;
}
/// process attribute values
void XMLDateTimeFieldImportContext::ProcessAttribute( sal_Int32 nAttrToken,
std::string_view sAttrValue )
{
XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
}
/// prepare XTextField for insertion into document
void XMLDateTimeFieldImportContext::PrepareField(
const css::uno::Reference<
css::beans::XPropertySet> &)
{
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */