xref: /AOO41X/main/xmloff/source/text/txtfldi.cxx (revision 9030e3c10f1280060e8124e8a06b112b21016170)

/**************************************************************
 *
 * 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> &)
{
}