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