xmloff/source/text/txtfldi.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: txtfldi.cxx,v $
  10  * $Revision: 1.71.66.2 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_xmloff.hxx"
  33
  34 /** @#file
  35  *
  36  *  Import of all text fields except those from txtvfldi.cxx
  37  *  (variable related text fields and database display fields)
  38  */
  39 #include "txtfldi.hxx"
  40 #include "txtvfldi.hxx"
  41 #include <xmloff/xmlimp.hxx>
  42 #include <xmloff/xmlnumi.hxx>
  43 #include <xmloff/txtimp.hxx>
  44 #include "xmlnmspe.hxx"
  45 #include <xmloff/nmspmap.hxx>
  46 #include <xmloff/xmltoken.hxx>
  47 #include <xmloff/xmluconv.hxx>
  48 #include <xmloff/xmlement.hxx>
  49 #include "XMLStringBufferImportContext.hxx"
  50 #include <xmloff/XMLEventsImportContext.hxx>
  51 #include <com/sun/star/xml/sax/XAttributeList.hpp>
  52 #include <com/sun/star/text/UserDataPart.hpp>
  53 #include <com/sun/star/style/NumberingType.hpp>
  54 #include <com/sun/star/text/PlaceholderType.hpp>
  55 #include <com/sun/star/text/ReferenceFieldPart.hpp>
  56 #include <com/sun/star/text/ReferenceFieldSource.hpp>
  57 #include <com/sun/star/text/XTextField.hpp>
  58 #include <com/sun/star/text/XTextContent.hpp>
  59 #include <com/sun/star/beans/XPropertySet.hpp>
  60 #include <com/sun/star/beans/XPropertySetInfo.hpp>
  61 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  62 #include <com/sun/star/text/XTextFieldsSupplier.hpp>
  63 #include <com/sun/star/text/XDependentTextField.hpp>
  64 #include <com/sun/star/text/SetVariableType.hpp>
  65 #include <com/sun/star/text/FilenameDisplayFormat.hpp>
  66 #include <com/sun/star/text/ChapterFormat.hpp>
  67 #include <com/sun/star/text/TemplateDisplayFormat.hpp>
  68 #include <com/sun/star/beans/PropertyValue.hpp>
  69 #include <com/sun/star/text/BibliographyDataType.hpp>
  70 #include <com/sun/star/text/BibliographyDataField.hpp>
  71 #include <com/sun/star/util/XUpdatable.hpp>
  72 #include <com/sun/star/sdb/CommandType.hpp>
  73
  74 #include <rtl/ustring.hxx>
  75 #include <rtl/ustrbuf.hxx>
  76 #include <rtl/math.hxx>
  77 #include <tools/debug.hxx>
  78
  79
  80 using ::rtl::OUString;
  81 using ::rtl::OUStringBuffer;
  82
  83 using namespace ::com::sun::star;
  84 using namespace ::com::sun::star::uno;
  85 using namespace ::com::sun::star::text;
  86 using namespace ::com::sun::star::lang;
  87 using namespace ::com::sun::star::beans;
  88 using namespace ::com::sun::star::document;
  89 using namespace ::com::sun::star::util;
  90 using namespace ::com::sun::star::xml::sax;
  91 using namespace ::xmloff::token;
  92
  93
  94 //
  95 // SO API string constants
  96 //
  97
  98 // service prefix and service anems
  99 const sal_Char sAPI_textfield_prefix[]  = "com.sun.star.text.TextField.";
 100 const sal_Char sAPI_fieldmaster_prefix[] = "com.sun.star.text.FieldMaster.";
 101 const sal_Char sAPI_presentation_prefix[] = "com.sun.star.presentation.TextField.";
 102
 103 const sal_Char sAPI_extended_user[]                             = "ExtendedUser";
 104 const sal_Char sAPI_user_data_type[]                    = "UserDataType";
 105 const sal_Char sAPI_jump_edit[]                                 = "JumpEdit";
 106 const sal_Char sAPI_get_expression[]                    = "GetExpression";
 107 const sal_Char sAPI_set_expression[]                    = "SetExpression";
 108 const sal_Char sAPI_user[]                                              = "User";
 109 const sal_Char sAPI_date_time[]                                 = "DateTime";
 110 const sal_Char sAPI_page_number[]                               = "PageNumber";
 111 const sal_Char sAPI_database_next[]                             = "DatabaseNextSet";
 112 const sal_Char sAPI_database_select[]                   = "DatabaseNumberOfSet";
 113 const sal_Char sAPI_database_number[]                   = "DatabaseSetNumber";
 114 const sal_Char sAPI_database[]                                  = "Database";
 115 const sal_Char sAPI_database_name[]                             = "DatabaseName";
 116 const sal_Char sAPI_docinfo_change_author[]             = "DocInfo.ChangeAuthor";
 117 const sal_Char sAPI_docinfo_change_date_time[]  = "DocInfo.ChangeDateTime";
 118 const sal_Char sAPI_docinfo_edit_time[]                 = "DocInfo.EditTime";
 119 const sal_Char sAPI_docinfo_description[]               = "DocInfo.Description";
 120 const sal_Char sAPI_docinfo_create_author[]             = "DocInfo.CreateAuthor";
 121 const sal_Char sAPI_docinfo_create_date_time[]  = "DocInfo.CreateDateTime";
 122 const sal_Char sAPI_docinfo_custom[]                    = "DocInfo.Custom";
 123 const sal_Char sAPI_docinfo_print_author[]              = "DocInfo.PrintAuthor";
 124 const sal_Char sAPI_docinfo_print_date_time[]   = "DocInfo.PrintDateTime";
 125 const sal_Char sAPI_docinfo_keywords[]                  = "DocInfo.KeyWords";
 126 const sal_Char sAPI_docinfo_subject[]                   = "DocInfo.Subject";
 127 const sal_Char sAPI_docinfo_title[]                             = "DocInfo.Title";
 128 const sal_Char sAPI_docinfo_revision[]                  = "DocInfo.Revision";
 129 const sal_Char sAPI_hidden_paragraph[]                  = "HiddenParagraph";
 130 const sal_Char sAPI_hidden_text[]                               = "HiddenText";
 131 const sal_Char sAPI_conditional_text[]                  = "ConditionalText";
 132 const sal_Char sAPI_file_name[]                                 = "FileName";
 133 const sal_Char sAPI_chapter[]                                   = "Chapter";
 134 const sal_Char sAPI_template_name[]                             = "TemplateName";
 135 const sal_Char sAPI_page_count[]                                = "PageCount";
 136 const sal_Char sAPI_paragraph_count[]                   = "ParagraphCount";
 137 const sal_Char sAPI_word_count[]                                = "WordCount";
 138 const sal_Char sAPI_character_count[]                   = "CharacterCount";
 139 const sal_Char sAPI_table_count[]                               = "TableCount";
 140 const sal_Char sAPI_graphic_object_count[]              = "GraphicObjectCount";
 141 const sal_Char sAPI_embedded_object_count[]             = "EmbeddedObjectCount";
 142 const sal_Char sAPI_reference_page_set[]                = "ReferencePageSet";
 143 const sal_Char sAPI_reference_page_get[]                = "ReferencePageGet";
 144 const sal_Char sAPI_macro[]                                             = "Macro";
 145 const sal_Char sAPI_dde[]                                               = "DDE";
 146 const sal_Char sAPI_get_reference[]                             = "GetReference";
 147 const sal_Char sAPI_sheet_name[]                                = "SheetName";
 148 const sal_Char sAPI_url[]                                               = "URL";
 149 const sal_Char sAPI_bibliography[]                              = "Bibliography";
 150 const sal_Char sAPI_annotation[]                                = "Annotation";
 151 const sal_Char sAPI_script[]                                    = "Script";
 152 const sal_Char sAPI_measure[]                                   = "Measure";
 153 const sal_Char sAPI_drop_down[]                 = "DropDown";
 154 const sal_Char sAPI_header[]                                    = "Header";
 155 const sal_Char sAPI_footer[]                                    = "Footer";
 156 const sal_Char sAPI_datetime[]                                  = "DateTime";
 157
 158 // property names
 159 const sal_Char sAPI_is_fixed[]                  = "IsFixed";
 160 const sal_Char sAPI_content[]                   = "Content";
 161 const sal_Char sAPI_value[]                             = "Value";
 162 const sal_Char sAPI_author[]                    = "Author";
 163 const sal_Char sAPI_full_name[]                 = "FullName";
 164 const sal_Char sAPI_place_holder_type[] = "PlaceHolderType";
 165 const sal_Char sAPI_place_holder[]              = "PlaceHolder";
 166 const sal_Char sAPI_hint[]                              = "Hint";
 167 const sal_Char sAPI_variable_name[]             = "VariableName";
 168 const sal_Char sAPI_name[]                              = "Name";
 169 const sal_Char sAPI_sub_type[]                  = "SubType";
 170 const sal_Char sAPI_numbering_separator[] = "NumberingSeparator";
 171 const sal_Char sAPI_chapter_numbering_level[] = "ChapterNumberingLevel";
 172 const sal_Char sAPI_variable_subtype[]  = "VariableSubtype";
 173 const sal_Char sAPI_formula[]                   = "Formula";
 174 const sal_Char sAPI_date_time_value[]   = "DateTimeValue";
 175 const sal_Char sAPI_number_format[]             = "NumberFormat";
 176 const sal_Char sAPI_user_text[]                 = "UserText";
 177 const sal_Char sAPI_numbering_type[]    = "NumberingType";
 178 const sal_Char sAPI_offset[]                    = "Offset";
 179 const sal_Char sAPI_data_base_name[]    = "DataBaseName";
 180 const sal_Char sAPI_data_base_u_r_l[]   = "DataBaseURL";
 181 const sal_Char sAPI_data_table_name[]   = "DataTableName";
 182 const sal_Char sAPI_condition[]                 = "Condition";
 183 const sal_Char sAPI_set_number[]                = "SetNumber";
 184 const sal_Char sAPI_is_data_base_format[] = "DataBaseFormat";
 185 const sal_Char sAPI_true_content[]              = "TrueContent";
 186 const sal_Char sAPI_false_content[]             = "FalseContent";
 187 const sal_Char sAPI_revision[]                  = "Revision";
 188 const sal_Char sAPI_file_format[]               = "FileFormat";
 189 const sal_Char sAPI_chapter_format[]    = "ChapterFormat";
 190 const sal_Char sAPI_level[]                             = "Level";
 191 const sal_Char sAPI_is_date[]                   = "IsDate";
 192 const sal_Char sAPI_adjust[]                    = "Adjust";
 193 const sal_Char sAPI_on[]                                = "On";
 194 const sal_Char sAPI_is_automatic_update[] = "IsAutomaticUpdate";
 195 const sal_Char sAPI_source_name[]               = "SourceName";
 196 const sal_Char sAPI_current_presentation[] = "CurrentPresentation";
 197 const sal_Char sAPI_reference_field_part[] = "ReferenceFieldPart";
 198 const sal_Char sAPI_reference_field_source[] = "ReferenceFieldSource";
 199 const sal_Char sAPI_dde_command_type[]  = "DDECommandType";
 200 const sal_Char sAPI_dde_command_file[]  = "DDECommandFile";
 201 const sal_Char sAPI_dde_command_element[] = "DDECommandElement";
 202 // sAPI_url: also used as service name
 203 const sal_Char sAPI_target_frame[]              = "TargetFrame";
 204 const sal_Char sAPI_representation[]    = "Representation";
 205 const sal_Char sAPI_date[]                              = "Date";
 206 const sal_Char sAPI_url_content[]               = "URLContent";
 207 const sal_Char sAPI_script_type[]               = "ScriptType";
 208 const sal_Char sAPI_is_hidden[]                 = "IsHidden";
 209 const sal_Char sAPI_is_condition_true[] = "IsConditionTrue";
 210 const sal_Char sAPI_data_command_type[] = "DataCommandType";
 211 const sal_Char sAPI_is_fixed_language[] = "IsFixedLanguage";
 212 const sal_Char sAPI_is_visible[]                = "IsVisible";
 213 const sal_Char sAPI_TextRange[]                 = "TextRange";
 214
 215 const sal_Char sAPI_true[] = "TRUE";
 216
 217
 218 static __FAR_DATA SvXMLTokenMapEntry aTextFieldAttrTokenMap[] =
 219 {
 220     { XML_NAMESPACE_TEXT, XML_FIXED, XML_TOK_TEXTFIELD_FIXED },
 221     { XML_NAMESPACE_TEXT, XML_DESCRIPTION,      XML_TOK_TEXTFIELD_DESCRIPTION },
 222     { XML_NAMESPACE_TEXT, XML_HELP,     XML_TOK_TEXTFIELD_HELP },
 223     { XML_NAMESPACE_TEXT, XML_HINT,     XML_TOK_TEXTFIELD_HINT },
 224     { XML_NAMESPACE_TEXT, XML_PLACEHOLDER_TYPE,
 225                 XML_TOK_TEXTFIELD_PLACEHOLDER_TYPE },
 226     { XML_NAMESPACE_TEXT, XML_NAME, XML_TOK_TEXTFIELD_NAME },
 227     { XML_NAMESPACE_TEXT, XML_FORMULA, XML_TOK_TEXTFIELD_FORMULA },
 228     { XML_NAMESPACE_STYLE, XML_NUM_FORMAT, XML_TOK_TEXTFIELD_NUM_FORMAT },
 229     { XML_NAMESPACE_STYLE, XML_NUM_LETTER_SYNC,
 230                 XML_TOK_TEXTFIELD_NUM_LETTER_SYNC },
 231     { XML_NAMESPACE_TEXT, XML_DISPLAY_FORMULA,
 232                 XML_TOK_TEXTFIELD_DISPLAY_FORMULA },
 233     { XML_NAMESPACE_TEXT, XML_VALUE_TYPE, XML_TOK_TEXTFIELD_VALUE_TYPE }, // #i32362#: src680m48++ saves text:value-type
 234     { XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_TOK_TEXTFIELD_VALUE_TYPE },
 235     { XML_NAMESPACE_TEXT, XML_VALUE, XML_TOK_TEXTFIELD_VALUE },
 236     { XML_NAMESPACE_OFFICE, XML_VALUE, XML_TOK_TEXTFIELD_VALUE },
 237     { XML_NAMESPACE_TEXT, XML_STRING_VALUE, XML_TOK_TEXTFIELD_STRING_VALUE },
 238     { XML_NAMESPACE_OFFICE, XML_STRING_VALUE, XML_TOK_TEXTFIELD_STRING_VALUE },
 239     { XML_NAMESPACE_TEXT, XML_DATE_VALUE, XML_TOK_TEXTFIELD_DATE_VALUE },
 240     { XML_NAMESPACE_OFFICE, XML_DATE_VALUE, XML_TOK_TEXTFIELD_DATE_VALUE },
 241     { XML_NAMESPACE_TEXT, XML_TIME_VALUE, XML_TOK_TEXTFIELD_TIME_VALUE },
 242     { XML_NAMESPACE_OFFICE, XML_TIME_VALUE, XML_TOK_TEXTFIELD_TIME_VALUE },
 243     { XML_NAMESPACE_OFFICE, XML_BOOLEAN_VALUE, XML_TOK_TEXTFIELD_BOOL_VALUE},
 244     { XML_NAMESPACE_OFFICE, XML_CURRENCY, XML_TOK_TEXTFIELD_CURRENCY},
 245     { XML_NAMESPACE_STYLE, XML_DATA_STYLE_NAME,
 246                 XML_TOK_TEXTFIELD_DATA_STYLE_NAME },
 247     { XML_NAMESPACE_TEXT, XML_DISPLAY_OUTLINE_LEVEL,
 248                 XML_TOK_TEXTFIELD_NUMBERING_LEVEL },
 249     { XML_NAMESPACE_TEXT, XML_SEPARATION_CHARACTER,
 250                 XML_TOK_TEXTFIELD_NUMBERING_SEPARATOR },
 251     { XML_NAMESPACE_TEXT, XML_DISPLAY, XML_TOK_TEXTFIELD_DISPLAY },
 252     { XML_NAMESPACE_TEXT, XML_TIME_ADJUST, XML_TOK_TEXTFIELD_TIME_ADJUST },
 253     { XML_NAMESPACE_TEXT, XML_DATE_ADJUST, XML_TOK_TEXTFIELD_DATE_ADJUST },
 254     { XML_NAMESPACE_TEXT, XML_PAGE_ADJUST, XML_TOK_TEXTFIELD_PAGE_ADJUST },
 255     { XML_NAMESPACE_TEXT, XML_SELECT_PAGE, XML_TOK_TEXTFIELD_SELECT_PAGE },
 256     { XML_NAMESPACE_TEXT, XML_DATABASE_NAME, XML_TOK_TEXTFIELD_DATABASE_NAME},
 257     { XML_NAMESPACE_TEXT, XML_TABLE_NAME, XML_TOK_TEXTFIELD_TABLE_NAME },
 258     { XML_NAMESPACE_TEXT, XML_COLUMN_NAME, XML_TOK_TEXTFIELD_COLUMN_NAME },
 259     { XML_NAMESPACE_TEXT, XML_ROW_NUMBER, XML_TOK_TEXTFIELD_ROW_NUMBER },
 260     { XML_NAMESPACE_TEXT, XML_CONDITION, XML_TOK_TEXTFIELD_CONDITION },
 261     { XML_NAMESPACE_TEXT, XML_STRING_VALUE_IF_TRUE,
 262                 XML_TOK_TEXTFIELD_STRING_VALUE_IF_TRUE },
 263     { XML_NAMESPACE_TEXT, XML_STRING_VALUE_IF_FALSE,
 264                 XML_TOK_TEXTFIELD_STRING_VALUE_IF_FALSE },
 265     { XML_NAMESPACE_TEXT, XML_EDITING_CYCLES, XML_TOK_TEXTFIELD_REVISION },
 266     { XML_NAMESPACE_TEXT, XML_OUTLINE_LEVEL, XML_TOK_TEXTFIELD_OUTLINE_LEVEL},
 267     { XML_NAMESPACE_TEXT, XML_ACTIVE, XML_TOK_TEXTFIELD_ACTIVE },
 268     { XML_NAMESPACE_TEXT, XML_NOTE_CLASS, XML_TOK_TEXTFIELD_NOTE_CLASS },
 269     { XML_NAMESPACE_TEXT, XML_REFERENCE_FORMAT,
 270                 XML_TOK_TEXTFIELD_REFERENCE_FORMAT },
 271     { XML_NAMESPACE_TEXT, XML_REF_NAME, XML_TOK_TEXTFIELD_REF_NAME },
 272     { XML_NAMESPACE_TEXT, XML_CONNECTION_NAME,
 273       XML_TOK_TEXTFIELD_CONNECTION_NAME },
 274     { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_TEXTFIELD_HREF },
 275     { XML_NAMESPACE_OFFICE, XML_TARGET_FRAME_NAME,
 276       XML_TOK_TEXTFIELD_TARGET_FRAME },
 277     { XML_NAMESPACE_TEXT, XML_ANNOTATION, XML_TOK_TEXTFIELD_ANNOTATION },
 278     { XML_NAMESPACE_SCRIPT, XML_LANGUAGE, XML_TOK_TEXTFIELD_LANGUAGE },
 279     { XML_NAMESPACE_TEXT, XML_KIND, XML_TOK_TEXTFIELD_MEASURE_KIND },
 280     { XML_NAMESPACE_TEXT, XML_IS_HIDDEN, XML_TOK_TEXTFIELD_IS_HIDDEN },
 281     { XML_NAMESPACE_TEXT, XML_CURRENT_VALUE,
 282                 XML_TOK_TEXTFIELD_CURRENT_VALUE },
 283     { XML_NAMESPACE_TEXT, XML_TABLE_TYPE, XML_TOK_TEXTFIELD_TABLE_TYPE },
 284
 285     XML_TOKEN_MAP_END
 286 };
 287
 288 const SvXMLTokenMap& XMLTextImportHelper::GetTextFieldAttrTokenMap()
 289 {
 290     if ( !pTextFieldAttrTokenMap.get() ) {
 291         pTextFieldAttrTokenMap.reset(
 292             new SvXMLTokenMap(aTextFieldAttrTokenMap) );
 293     }
 294
 295     return *pTextFieldAttrTokenMap;
 296
 297 }
 298
 299 TYPEINIT1( XMLTextFieldImportContext, SvXMLImportContext);
 300
 301 XMLTextFieldImportContext::XMLTextFieldImportContext(
 302     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
 303     const sal_Char* pService,
 304     sal_uInt16 nPrefix, const OUString& rElementName)
 305 :       SvXMLImportContext( rImport, nPrefix, rElementName )
 306 ,       sIsFixed(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed))
 307 ,       rTextImportHelper(rHlp)
 308 ,       sServicePrefix(RTL_CONSTASCII_USTRINGPARAM(sAPI_textfield_prefix))
 309 ,       bValid(sal_False)
 310 {
 311     DBG_ASSERT(NULL != pService, "Need service name!");
 312     sServiceName = OUString::createFromAscii(pService);
 313 }
 314
 315 void XMLTextFieldImportContext::StartElement(
 316     const Reference<XAttributeList> & xAttrList)
 317 {
 318     // process attributes
 319     sal_Int16 nLength = xAttrList->getLength();
 320     for(sal_Int16 i=0; i<nLength; i++) {
 321
 322         OUString sLocalName;
 323         sal_uInt16 nPrefix = GetImport().GetNamespaceMap().
 324             GetKeyByAttrName( xAttrList->getNameByIndex(i), &sLocalName );
 325
 326         ProcessAttribute(rTextImportHelper.GetTextFieldAttrTokenMap().
 327                              Get(nPrefix, sLocalName),
 328                          xAttrList->getValueByIndex(i) );
 329     }
 330 }
 331
 332 XMLTextFieldImportContext::~XMLTextFieldImportContext() {
 333 }
 334
 335 OUString XMLTextFieldImportContext::GetContent()
 336 {
 337     if (sContent.getLength()==0)
 338     {
 339         sContent = sContentBuffer.makeStringAndClear();
 340     }
 341
 342     return sContent;
 343 }
 344
 345 void XMLTextFieldImportContext::EndElement()
 346 {
 347     DBG_ASSERT(GetServiceName().getLength()>0, "no service name for element!");
 348     if (bValid)
 349     {
 350
 351         // create field/Service
 352         Reference<XPropertySet> xPropSet;
 353         if (CreateField(xPropSet, sServicePrefix + GetServiceName()))
 354         {
 355             // set field properties
 356             PrepareField(xPropSet);
 357
 358             // attach field to document
 359             Reference<XTextContent> xTextContent(xPropSet, UNO_QUERY);
 360
 361             // workaround for #80606#
 362             try
 363             {
 364                 rTextImportHelper.InsertTextContent(xTextContent);
 365             }
 366             catch (lang::IllegalArgumentException e)
 367             {
 368                 // ignore
 369             }
 370             return;
 371         }
 372     }
 373
 374     // in case of error: write element content
 375     rTextImportHelper.InsertString(GetContent());
 376 }
 377
 378 void XMLTextFieldImportContext::Characters(const OUString& rContent)
 379 {
 380     sContentBuffer.append(rContent);
 381 }
 382
 383 sal_Bool XMLTextFieldImportContext::CreateField(
 384     Reference<XPropertySet> & xField,
 385     const OUString& rServiceName)
 386 {
 387     // instantiate new XTextField:
 388     // ask import for model, model is factory, ask factory to create service
 389
 390     Reference<XMultiServiceFactory> xFactory(GetImport().GetModel(),UNO_QUERY);
 391     if( xFactory.is() )
 392     {
 393         Reference<XInterface> xIfc = xFactory->createInstance(rServiceName);
 394         if( xIfc.is() )
 395         {
 396             Reference<XPropertySet> xTmp( xIfc, UNO_QUERY );
 397
 398             xField = xTmp;
 399         } else {
 400             return sal_False;   // can't create instance
 401         }
 402     } else {
 403         return sal_False;       // can't get MultiServiceFactory
 404     }
 405
 406     return sal_True;
 407 }
 408
 409 /// create the appropriate field context from
 410 XMLTextFieldImportContext*
 411 XMLTextFieldImportContext::CreateTextFieldImportContext(
 412     SvXMLImport& rImport,
 413     XMLTextImportHelper& rHlp,
 414     sal_uInt16 nPrefix,
 415     const OUString& rName,
 416     sal_uInt16 nToken)
 417 {
 418     XMLTextFieldImportContext* pContext = NULL;
 419
 420     switch (nToken)
 421     {
 422         case XML_TOK_TEXT_SENDER_FIRSTNAME:
 423         case XML_TOK_TEXT_SENDER_LASTNAME:
 424         case XML_TOK_TEXT_SENDER_INITIALS:
 425         case XML_TOK_TEXT_SENDER_TITLE:
 426         case XML_TOK_TEXT_SENDER_POSITION:
 427         case XML_TOK_TEXT_SENDER_EMAIL:
 428         case XML_TOK_TEXT_SENDER_PHONE_PRIVATE:
 429         case XML_TOK_TEXT_SENDER_FAX:
 430         case XML_TOK_TEXT_SENDER_COMPANY:
 431         case XML_TOK_TEXT_SENDER_PHONE_WORK:
 432         case XML_TOK_TEXT_SENDER_STREET:
 433         case XML_TOK_TEXT_SENDER_CITY:
 434         case XML_TOK_TEXT_SENDER_POSTAL_CODE:
 435         case XML_TOK_TEXT_SENDER_COUNTRY:
 436         case XML_TOK_TEXT_SENDER_STATE_OR_PROVINCE:
 437             pContext =
 438                 new XMLSenderFieldImportContext( rImport, rHlp,
 439                                                  nPrefix, rName, nToken );
 440             break;
 441
 442         case XML_TOK_TEXT_AUTHOR_NAME:
 443         case XML_TOK_TEXT_AUTHOR_INITIALS:
 444             pContext =
 445                 new XMLAuthorFieldImportContext( rImport, rHlp,
 446                                                  nPrefix, rName, nToken );
 447             break;
 448
 449         case XML_TOK_TEXT_PLACEHOLDER:
 450             pContext =
 451                 new XMLPlaceholderFieldImportContext( rImport, rHlp,
 452                                                       nPrefix, rName);
 453             break;
 454         case XML_TOK_TEXT_SEQUENCE:
 455             pContext =
 456                 new XMLSequenceFieldImportContext( rImport, rHlp,
 457                                                    nPrefix, rName );
 458             break;
 459         case XML_TOK_TEXT_TEXT_INPUT:
 460             pContext =
 461                 new XMLTextInputFieldImportContext( rImport, rHlp,
 462                                                     nPrefix, rName );
 463             break;
 464         case XML_TOK_TEXT_EXPRESSION:
 465             pContext =
 466                 new XMLExpressionFieldImportContext( rImport, rHlp,
 467                                                      nPrefix, rName );
 468             break;
 469         case XML_TOK_TEXT_VARIABLE_SET:
 470             pContext =
 471                 new XMLVariableSetFieldImportContext( rImport, rHlp,
 472                                                       nPrefix, rName );
 473             break;
 474         case XML_TOK_TEXT_VARIABLE_INPUT:
 475             pContext =
 476                 new XMLVariableInputFieldImportContext( rImport, rHlp,
 477                                                         nPrefix, rName );
 478             break;
 479         case XML_TOK_TEXT_VARIABLE_GET:
 480             pContext =
 481                 new XMLVariableGetFieldImportContext( rImport, rHlp,
 482                                                       nPrefix, rName );
 483             break;
 484         case XML_TOK_TEXT_USER_FIELD_GET:
 485             pContext = new XMLUserFieldImportContext( rImport, rHlp,
 486                                                       nPrefix, rName );
 487             break;
 488         case XML_TOK_TEXT_USER_FIELD_INPUT:
 489             pContext = new XMLUserFieldInputImportContext( rImport, rHlp,
 490                                                            nPrefix, rName );
 491             break;
 492         case XML_TOK_TEXT_TIME:
 493             pContext = new XMLTimeFieldImportContext( rImport, rHlp,
 494                                                       nPrefix, rName );
 495             break;
 496         case XML_TOK_TEXT_PAGE_CONTINUATION_STRING:
 497         case XML_TOK_TEXT_PAGE_CONTINUATION:
 498             pContext = new XMLPageContinuationImportContext( rImport, rHlp,
 499                                                              nPrefix, rName );
 500             break;
 501
 502         case XML_TOK_TEXT_PAGE_NUMBER:
 503             pContext = new XMLPageNumberImportContext( rImport, rHlp,
 504                                                        nPrefix, rName );
 505             break;
 506
 507         case XML_TOK_TEXT_DATE:
 508             pContext = new XMLDateFieldImportContext( rImport, rHlp,
 509                                                       nPrefix, rName );
 510             break;
 511
 512         case XML_TOK_TEXT_DATABASE_NAME:
 513             pContext = new XMLDatabaseNameImportContext( rImport, rHlp,
 514                                                          nPrefix, rName );
 515             break;
 516         case XML_TOK_TEXT_DATABASE_NEXT:
 517             pContext = new XMLDatabaseNextImportContext( rImport, rHlp,
 518                                                          nPrefix, rName );
 519             break;
 520         case XML_TOK_TEXT_DATABASE_SELECT:
 521             pContext = new XMLDatabaseSelectImportContext( rImport, rHlp,
 522                                                            nPrefix, rName );
 523             break;
 524         case XML_TOK_TEXT_DATABASE_ROW_NUMBER:
 525             pContext = new XMLDatabaseNumberImportContext( rImport, rHlp,
 526                                                            nPrefix, rName );
 527             break;
 528         case XML_TOK_TEXT_DATABASE_DISPLAY:
 529             pContext = new XMLDatabaseDisplayImportContext( rImport, rHlp,
 530                                                             nPrefix, rName );
 531             break;
 532         case XML_TOK_TEXT_CONDITIONAL_TEXT:
 533             pContext = new XMLConditionalTextImportContext( rImport, rHlp,
 534                                                             nPrefix, rName );
 535             break;
 536         case XML_TOK_TEXT_HIDDEN_TEXT:
 537             pContext = new XMLHiddenTextImportContext( rImport, rHlp,
 538                                                        nPrefix, rName );
 539             break;
 540         case XML_TOK_TEXT_HIDDEN_PARAGRAPH:
 541             pContext = new XMLHiddenParagraphImportContext( rImport, rHlp,
 542                                                             nPrefix, rName );
 543             break;
 544         case XML_TOK_TEXT_DOCUMENT_DESCRIPTION:
 545         case XML_TOK_TEXT_DOCUMENT_TITLE:
 546         case XML_TOK_TEXT_DOCUMENT_SUBJECT:
 547         case XML_TOK_TEXT_DOCUMENT_KEYWORDS:
 548             pContext = new XMLSimpleDocInfoImportContext( rImport, rHlp,
 549                                                           nPrefix, rName,
 550                                                           nToken, sal_True,
 551                                                           sal_False );
 552             break;
 553         case XML_TOK_TEXT_DOCUMENT_CREATION_AUTHOR:
 554         case XML_TOK_TEXT_DOCUMENT_PRINT_AUTHOR:
 555         case XML_TOK_TEXT_DOCUMENT_SAVE_AUTHOR:
 556             pContext = new XMLSimpleDocInfoImportContext( rImport, rHlp,
 557                                                           nPrefix, rName,
 558                                                           nToken, sal_False,
 559                                                           sal_True );
 560             break;
 561
 562         case XML_TOK_TEXT_DOCUMENT_CREATION_DATE:
 563         case XML_TOK_TEXT_DOCUMENT_CREATION_TIME:
 564         case XML_TOK_TEXT_DOCUMENT_PRINT_DATE:
 565         case XML_TOK_TEXT_DOCUMENT_PRINT_TIME:
 566         case XML_TOK_TEXT_DOCUMENT_SAVE_DATE:
 567         case XML_TOK_TEXT_DOCUMENT_SAVE_TIME:
 568         case XML_TOK_TEXT_DOCUMENT_EDIT_DURATION:
 569             pContext = new XMLDateTimeDocInfoImportContext( rImport, rHlp,
 570                                                             nPrefix, rName,
 571                                                             nToken );
 572             break;
 573
 574         case XML_TOK_TEXT_DOCUMENT_REVISION:
 575             pContext = new XMLRevisionDocInfoImportContext( rImport, rHlp,
 576                                                             nPrefix, rName,
 577                                                             nToken );
 578             break;
 579
 580         case XML_TOK_TEXT_DOCUMENT_USER_DEFINED:
 581             pContext = new XMLUserDocInfoImportContext( rImport, rHlp,
 582                                                         nPrefix, rName,
 583                                                         nToken );
 584             break;
 585
 586         case XML_TOK_TEXT_FILENAME:
 587             pContext = new XMLFileNameImportContext( rImport, rHlp,
 588                                                      nPrefix, rName );
 589             break;
 590
 591         case XML_TOK_TEXT_CHAPTER:
 592             pContext = new XMLChapterImportContext( rImport, rHlp,
 593                                                     nPrefix, rName );
 594             break;
 595
 596         case XML_TOK_TEXT_TEMPLATENAME:
 597             pContext = new XMLTemplateNameImportContext( rImport, rHlp,
 598                                                          nPrefix, rName );
 599             break;
 600
 601         case XML_TOK_TEXT_WORD_COUNT:
 602         case XML_TOK_TEXT_PARAGRAPH_COUNT:
 603         case XML_TOK_TEXT_TABLE_COUNT:
 604         case XML_TOK_TEXT_CHARACTER_COUNT:
 605         case XML_TOK_TEXT_IMAGE_COUNT:
 606         case XML_TOK_TEXT_OBJECT_COUNT:
 607         case XML_TOK_TEXT_PAGE_COUNT:
 608             pContext = new XMLCountFieldImportContext( rImport, rHlp,
 609                                                        nPrefix, rName, nToken);
 610             break;
 611
 612         case XML_TOK_TEXT_GET_PAGE_VAR:
 613             pContext = new XMLPageVarGetFieldImportContext( rImport, rHlp,
 614                                                             nPrefix, rName );
 615             break;
 616
 617         case XML_TOK_TEXT_SET_PAGE_VAR:
 618             pContext = new XMLPageVarSetFieldImportContext( rImport, rHlp,
 619                                                             nPrefix, rName );
 620             break;
 621
 622         case XML_TOK_TEXT_MACRO:
 623             pContext = new XMLMacroFieldImportContext( rImport, rHlp,
 624                                                        nPrefix, rName );
 625             break;
 626
 627         case XML_TOK_TEXT_DDE:
 628             pContext = new XMLDdeFieldImportContext( rImport, rHlp,
 629                                                      nPrefix, rName );
 630             break;
 631
 632         case XML_TOK_TEXT_REFERENCE_REF:
 633         case XML_TOK_TEXT_BOOKMARK_REF:
 634         case XML_TOK_TEXT_NOTE_REF:
 635         case XML_TOK_TEXT_SEQUENCE_REF:
 636             pContext = new XMLReferenceFieldImportContext( rImport, rHlp,
 637                                                            nToken,
 638                                                            nPrefix, rName );
 639             break;
 640
 641         case XML_TOK_TEXT_SHEET_NAME:
 642             pContext = new XMLSheetNameImportContext( rImport, rHlp,
 643                                                       nPrefix, rName );
 644             break;
 645
 646         case XML_TOK_TEXT_BIBLIOGRAPHY_MARK:
 647             pContext = new XMLBibliographyFieldImportContext( rImport, rHlp,
 648                                                               nPrefix, rName );
 649             break;
 650
 651         case XML_TOK_TEXT_ANNOTATION:
 652             pContext = new XMLAnnotationImportContext( rImport, rHlp,
 653                                                        nPrefix, rName);
 654             break;
 655
 656         case XML_TOK_TEXT_SCRIPT:
 657             pContext = new XMLScriptImportContext( rImport, rHlp,
 658                                                    nPrefix, rName);
 659             break;
 660
 661         case XML_TOK_TEXT_MEASURE:
 662             pContext = new XMLMeasureFieldImportContext( rImport, rHlp,
 663                                                          nPrefix, rName );
 664             break;
 665
 666         case XML_TOK_TEXT_TABLE_FORMULA:
 667             pContext = new XMLTableFormulaImportContext( rImport, rHlp,
 668                                                          nPrefix, rName );
 669             break;
 670         case XML_TOK_TEXT_DROPDOWN:
 671             pContext = new XMLDropDownFieldImportContext( rImport, rHlp,
 672                                                           nPrefix, rName );
 673             break;
 674         case XML_TOK_DRAW_HEADER:
 675             pContext = new XMLHeaderFieldImportContext( rImport, rHlp,
 676                                                           nPrefix, rName );
 677             break;
 678         case XML_TOK_DRAW_FOOTER:
 679             pContext = new XMLFooterFieldImportContext( rImport, rHlp,
 680                                                           nPrefix, rName );
 681             break;
 682         case XML_TOK_DRAW_DATE_TIME:
 683             pContext = new XMLDateTimeFieldImportContext( rImport, rHlp,
 684                                                           nPrefix, rName );
 685             break;
 686
 687         default:
 688             // ignore! May not even be a textfield.
 689             // (Reminder: This method is called inside default:-branch)
 690             pContext = NULL;
 691             break;
 692     }
 693
 694     return pContext;
 695 }
 696
 697
 698 void XMLTextFieldImportContext::ForceUpdate(
 699     const Reference<XPropertySet> & rPropertySet)
 700 {
 701     // force update
 702     Reference<XUpdatable> xUpdate(rPropertySet, UNO_QUERY);
 703     if (xUpdate.is())
 704     {
 705         xUpdate->update();
 706     }
 707     else
 708     {
 709         DBG_ERROR("Expected XUpdatable support!");
 710     }
 711 }
 712
 713
 714
 715 //
 716 // XMLSenderFieldImportContext
 717 //
 718
 719 TYPEINIT1( XMLSenderFieldImportContext, XMLTextFieldImportContext);
 720
 721 XMLSenderFieldImportContext::XMLSenderFieldImportContext(
 722     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
 723     sal_uInt16 nPrfx, const OUString& sLocalName,
 724     sal_uInt16 nToken)
 725 :       XMLTextFieldImportContext(rImport, rHlp, sAPI_extended_user,nPrfx, sLocalName)
 726 ,       sPropertyFixed(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed))
 727 ,       sPropertyFieldSubType(RTL_CONSTASCII_USTRINGPARAM(sAPI_user_data_type))
 728 ,       sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content))
 729 ,       bFixed(sal_True)
 730 ,       nElementToken(nToken)
 731 {
 732 }
 733
 734 void XMLSenderFieldImportContext::StartElement(
 735     const Reference<XAttributeList> & xAttrList)
 736 {
 737     bValid = sal_True;
 738     switch (nElementToken) {
 739     case XML_TOK_TEXT_SENDER_FIRSTNAME:
 740         nSubType = UserDataPart::FIRSTNAME;
 741         break;
 742     case XML_TOK_TEXT_SENDER_LASTNAME:
 743         nSubType = UserDataPart::NAME;
 744         break;
 745     case XML_TOK_TEXT_SENDER_INITIALS:
 746         nSubType = UserDataPart::SHORTCUT;
 747         break;
 748     case XML_TOK_TEXT_SENDER_TITLE:
 749         nSubType = UserDataPart::TITLE;
 750         break;
 751     case XML_TOK_TEXT_SENDER_POSITION:
 752         nSubType = UserDataPart::POSITION;
 753         break;
 754     case XML_TOK_TEXT_SENDER_EMAIL:
 755         nSubType = UserDataPart::EMAIL;
 756         break;
 757     case XML_TOK_TEXT_SENDER_PHONE_PRIVATE:
 758         nSubType = UserDataPart::PHONE_PRIVATE;
 759         break;
 760     case XML_TOK_TEXT_SENDER_FAX:
 761         nSubType = UserDataPart::FAX;
 762         break;
 763     case XML_TOK_TEXT_SENDER_COMPANY:
 764         nSubType = UserDataPart::COMPANY;
 765         break;
 766     case XML_TOK_TEXT_SENDER_PHONE_WORK:
 767         nSubType = UserDataPart::PHONE_COMPANY;
 768         break;
 769     case XML_TOK_TEXT_SENDER_STREET:
 770         nSubType = UserDataPart::STREET;
 771         break;
 772     case XML_TOK_TEXT_SENDER_CITY:
 773         nSubType = UserDataPart::CITY;
 774         break;
 775     case XML_TOK_TEXT_SENDER_POSTAL_CODE:
 776         nSubType = UserDataPart::ZIP;
 777         break;
 778     case XML_TOK_TEXT_SENDER_COUNTRY:
 779         nSubType = UserDataPart::COUNTRY;
 780         break;
 781     case XML_TOK_TEXT_SENDER_STATE_OR_PROVINCE:
 782         nSubType = UserDataPart::STATE;
 783         break;
 784     default:
 785         bValid = sal_False;
 786         break;
 787     }
 788
 789     // process Attributes
 790     XMLTextFieldImportContext::StartElement(xAttrList);
 791 }
 792
 793 void XMLSenderFieldImportContext::ProcessAttribute(
 794     sal_uInt16 nAttrToken,
 795     const OUString& sAttrValue)
 796 {
 797     if (XML_TOK_TEXTFIELD_FIXED == nAttrToken) {
 798
 799         // set bVal
 800         sal_Bool bVal;
 801         sal_Bool bRet = GetImport().GetMM100UnitConverter().
 802             convertBool(bVal, sAttrValue);
 803
 804         // set bFixed if successfull
 805         if (bRet) {
 806             bFixed = bVal;
 807         }
 808     }
 809 }
 810
 811 void XMLSenderFieldImportContext::PrepareField(
 812     const Reference<XPropertySet> & rPropSet)
 813 {
 814     // set members
 815     Any aAny;
 816     aAny <<= nSubType;
 817     rPropSet->setPropertyValue(sPropertyFieldSubType, aAny);
 818
 819     // set fixed
 820     aAny.setValue( &bFixed, ::getBooleanCppuType() );
 821     rPropSet->setPropertyValue(sPropertyFixed, aAny);
 822
 823     // set content if fixed
 824     if (bFixed)
 825     {
 826         // in organizer or styles-only mode: force update
 827         if (GetImport().GetTextImport()->IsOrganizerMode() ||
 828             GetImport().GetTextImport()->IsStylesOnlyMode()   )
 829         {
 830             ForceUpdate(rPropSet);
 831         }
 832         else
 833         {
 834             aAny <<= GetContent();
 835             rPropSet->setPropertyValue(sPropertyContent, aAny);
 836         }
 837     }
 838 }
 839
 840
 841
 842 //
 843 // XMLAuthorFieldImportContext
 844 //
 845
 846 TYPEINIT1( XMLAuthorFieldImportContext, XMLSenderFieldImportContext);
 847
 848 XMLAuthorFieldImportContext::XMLAuthorFieldImportContext(
 849     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
 850     sal_uInt16 nPrfx, const OUString& sLocalName,
 851     sal_uInt16 nToken)
 852 :       XMLSenderFieldImportContext(rImport, rHlp, nPrfx, sLocalName, nToken)
 853 ,       bAuthorFullName(sal_True)
 854 ,       sServiceAuthor(RTL_CONSTASCII_USTRINGPARAM(sAPI_author))
 855 ,       sPropertyAuthorFullName(RTL_CONSTASCII_USTRINGPARAM(sAPI_full_name))
 856 ,       sPropertyFixed(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed))
 857 ,       sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content))
 858 {
 859     // overwrite service name from XMLSenderFieldImportContext
 860     SetServiceName(sServiceAuthor);
 861 }
 862
 863 void XMLAuthorFieldImportContext::StartElement(
 864     const Reference<XAttributeList> & xAttrList) {
 865
 866     bAuthorFullName = (XML_TOK_TEXT_AUTHOR_INITIALS != nElementToken);
 867     bValid = sal_True;
 868
 869     // process Attributes
 870     XMLTextFieldImportContext::StartElement(xAttrList);
 871 }
 872
 873 void XMLAuthorFieldImportContext::PrepareField(
 874     const Reference<XPropertySet> & rPropSet)
 875 {
 876     // set members
 877     Any aAny;
 878     aAny.setValue( &bAuthorFullName, ::getBooleanCppuType() );
 879     rPropSet->setPropertyValue(sPropertyAuthorFullName, aAny);
 880
 881     aAny.setValue( &bFixed, ::getBooleanCppuType() );
 882     rPropSet->setPropertyValue(sPropertyFixed, aAny);
 883
 884     // set content if fixed
 885     if (bFixed)
 886     {
 887         // organizer or styles-only mode: force update
 888         if (GetImport().GetTextImport()->IsOrganizerMode() ||
 889             GetImport().GetTextImport()->IsStylesOnlyMode()   )
 890         {
 891             ForceUpdate(rPropSet);
 892         }
 893         else
 894         {
 895             aAny <<= GetContent();
 896             rPropSet->setPropertyValue(sPropertyContent, aAny);
 897         }
 898     }
 899 }
 900
 901
 902 //
 903 // page continuation string
 904 //
 905
 906 TYPEINIT1( XMLPageContinuationImportContext, XMLTextFieldImportContext );
 907
 908 static SvXMLEnumMapEntry __READONLY_DATA lcl_aSelectPageAttrMap[] =
 909 {
 910     { XML_PREVIOUS,     PageNumberType_PREV },
 911     { XML_CURRENT,          PageNumberType_CURRENT },
 912     { XML_NEXT,                 PageNumberType_NEXT },
 913     { XML_TOKEN_INVALID, 0 },
 914 };
 915
 916 XMLPageContinuationImportContext::XMLPageContinuationImportContext(
 917     SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx,
 918     const OUString& sLocalName)
 919 :       XMLTextFieldImportContext(rImport, rHlp, sAPI_page_number, nPrfx, sLocalName)
 920 ,       sPropertySubType(RTL_CONSTASCII_USTRINGPARAM(sAPI_sub_type))
 921 ,       sPropertyUserText(RTL_CONSTASCII_USTRINGPARAM(sAPI_user_text))
 922 ,       sPropertyNumberingType(RTL_CONSTASCII_USTRINGPARAM(sAPI_numbering_type))
 923 ,       eSelectPage(PageNumberType_CURRENT)
 924 ,       sStringOK(sal_False)
 925 {
 926     bValid = sal_True;
 927 }
 928
 929 void XMLPageContinuationImportContext::ProcessAttribute(
 930     sal_uInt16 nAttrToken, const OUString& sAttrValue )
 931 {
 932     switch(nAttrToken)
 933     {
 934         case XML_TOK_TEXTFIELD_SELECT_PAGE:
 935         {
 936             sal_uInt16 nTmp;
 937             if (SvXMLUnitConverter::convertEnum(nTmp, sAttrValue,
 938                                                 lcl_aSelectPageAttrMap)
 939                 && (PageNumberType_CURRENT != nTmp) )
 940             {
 941                 eSelectPage = (PageNumberType)nTmp;
 942             }
 943             break;
 944         }
 945         case XML_TOK_TEXTFIELD_STRING_VALUE:
 946             sString = sAttrValue;
 947             sStringOK = sal_True;
 948             break;
 949     }
 950 }
 951
 952 void XMLPageContinuationImportContext::PrepareField(
 953     const Reference<XPropertySet> & xPropertySet)
 954 {
 955     Any aAny;
 956
 957     aAny <<= eSelectPage;
 958     xPropertySet->setPropertyValue(sPropertySubType, aAny);
 959
 960     aAny <<= (sStringOK ? sString : GetContent());
 961     xPropertySet->setPropertyValue(sPropertyUserText, aAny);
 962
 963     aAny <<= style::NumberingType::CHAR_SPECIAL;
 964     xPropertySet->setPropertyValue(sPropertyNumberingType, aAny);
 965 }
 966
 967
 968
 969 //
 970 // page number field
 971 //
 972
 973 TYPEINIT1( XMLPageNumberImportContext, XMLTextFieldImportContext );
 974
 975 XMLPageNumberImportContext::XMLPageNumberImportContext(
 976     SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx,
 977     const OUString& sLocalName)
 978 :       XMLTextFieldImportContext(rImport, rHlp, sAPI_page_number, nPrfx, sLocalName)
 979 ,       sPropertySubType(RTL_CONSTASCII_USTRINGPARAM(sAPI_sub_type))
 980 ,       sPropertyNumberingType(RTL_CONSTASCII_USTRINGPARAM(sAPI_numbering_type))
 981 ,       sPropertyOffset(RTL_CONSTASCII_USTRINGPARAM(sAPI_offset))
 982 ,       sNumberSync(GetXMLToken(XML_FALSE))
 983 ,       nPageAdjust(0)
 984 ,       eSelectPage(PageNumberType_CURRENT)
 985 ,       sNumberFormatOK(sal_False)
 986 {
 987     bValid = sal_True;
 988 }
 989
 990 void XMLPageNumberImportContext::ProcessAttribute(
 991     sal_uInt16 nAttrToken,
 992     const OUString& sAttrValue )
 993 {
 994     switch (nAttrToken)
 995     {
 996         case XML_TOK_TEXTFIELD_NUM_FORMAT:
 997             sNumberFormat = sAttrValue;
 998             sNumberFormatOK = sal_True;
 999             break;
1000         case XML_TOK_TEXTFIELD_NUM_LETTER_SYNC:
1001             sNumberSync = sAttrValue;
1002             break;
1003         case XML_TOK_TEXTFIELD_SELECT_PAGE:
1004         {
1005             sal_uInt16 nTmp;
1006             if (SvXMLUnitConverter::convertEnum(nTmp, sAttrValue,
1007                                                 lcl_aSelectPageAttrMap))
1008             {
1009                 eSelectPage = (PageNumberType)nTmp;
1010             }
1011             break;
1012         }
1013         case XML_TOK_TEXTFIELD_PAGE_ADJUST:
1014         {
1015             sal_Int32 nTmp;
1016             if (SvXMLUnitConverter::convertNumber(nTmp, sAttrValue))
1017             {
1018                 nPageAdjust = (sal_Int16)nTmp;
1019             }
1020             break;
1021         }
1022     }
1023 }
1024
1025 void XMLPageNumberImportContext::PrepareField(
1026         const Reference<XPropertySet> & xPropertySet)
1027 {
1028     Any aAny;
1029
1030     // all properties are optional
1031     Reference<XPropertySetInfo> xPropertySetInfo(
1032         xPropertySet->getPropertySetInfo());
1033
1034     if (xPropertySetInfo->hasPropertyByName(sPropertyNumberingType))
1035     {
1036         sal_Int16 nNumType;
1037         if( sNumberFormatOK )
1038         {
1039             nNumType= style::NumberingType::ARABIC;
1040             GetImport().GetMM100UnitConverter().convertNumFormat( nNumType,
1041                                                     sNumberFormat,
1042                                                     sNumberSync );
1043         }
1044         else
1045             nNumType = style::NumberingType::PAGE_DESCRIPTOR;
1046
1047         aAny <<= nNumType;
1048         xPropertySet->setPropertyValue(sPropertyNumberingType, aAny);
1049     }
1050
1051     if (xPropertySetInfo->hasPropertyByName(sPropertyOffset))
1052     {
1053         // adjust offset
1054         switch (eSelectPage)
1055         {
1056             case PageNumberType_PREV:
1057                 nPageAdjust--;
1058                 break;
1059             case PageNumberType_CURRENT:
1060                 break;
1061             case PageNumberType_NEXT:
1062                 nPageAdjust++;
1063                 break;
1064             default:
1065                 DBG_WARNING("unknown page number type");
1066         }
1067         aAny <<= nPageAdjust;
1068         xPropertySet->setPropertyValue(sPropertyOffset, aAny);
1069     }
1070
1071     if (xPropertySetInfo->hasPropertyByName(sPropertySubType))
1072     {
1073         aAny <<= eSelectPage;
1074         xPropertySet->setPropertyValue(sPropertySubType, aAny);
1075     }
1076 }
1077
1078
1079
1080 //
1081 // Placeholder
1082 //
1083
1084 TYPEINIT1( XMLPlaceholderFieldImportContext, XMLTextFieldImportContext);
1085
1086 XMLPlaceholderFieldImportContext::XMLPlaceholderFieldImportContext(
1087     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
1088     sal_uInt16 nPrfx, const OUString& sLocalName)
1089 :       XMLTextFieldImportContext(rImport, rHlp, sAPI_jump_edit,nPrfx, sLocalName)
1090 ,       sPropertyPlaceholderType(RTL_CONSTASCII_USTRINGPARAM(sAPI_place_holder_type))
1091 ,       sPropertyPlaceholder(RTL_CONSTASCII_USTRINGPARAM(sAPI_place_holder))
1092 ,       sPropertyHint(RTL_CONSTASCII_USTRINGPARAM(sAPI_hint))
1093 {
1094 }
1095
1096 /// process attribute values
1097 void XMLPlaceholderFieldImportContext::ProcessAttribute(
1098     sal_uInt16 nAttrToken, const OUString& sAttrValue )
1099 {
1100     switch (nAttrToken) {
1101     case XML_TOK_TEXTFIELD_DESCRIPTION:
1102         sDescription = sAttrValue;
1103         break;
1104
1105     case XML_TOK_TEXTFIELD_PLACEHOLDER_TYPE:
1106         bValid = sal_True;
1107         if (IsXMLToken(sAttrValue, XML_TABLE))
1108         {
1109             nPlaceholderType = PlaceholderType::TABLE;
1110         }
1111         else if (IsXMLToken(sAttrValue, XML_TEXT))
1112         {
1113             nPlaceholderType = PlaceholderType::TEXT;
1114         }
1115         else if (IsXMLToken(sAttrValue, XML_TEXT_BOX))
1116         {
1117             nPlaceholderType = PlaceholderType::TEXTFRAME;
1118         }
1119         else if (IsXMLToken(sAttrValue, XML_IMAGE))
1120         {
1121             nPlaceholderType = PlaceholderType::GRAPHIC;
1122         }
1123         else if (IsXMLToken(sAttrValue, XML_OBJECT))
1124         {
1125             nPlaceholderType = PlaceholderType::OBJECT;
1126         }
1127         else
1128         {
1129             bValid = sal_False;
1130         }
1131         break;
1132
1133     default:
1134         ; // ignore
1135     }
1136 }
1137
1138 void XMLPlaceholderFieldImportContext::PrepareField(
1139     const Reference<XPropertySet> & xPropertySet) {
1140
1141     Any aAny;
1142     aAny <<= sDescription;
1143     xPropertySet->setPropertyValue(sPropertyHint, aAny);
1144
1145     // remove <...> around content (if present)
1146     OUString aContent = GetContent();
1147     sal_Int32 nStart = 0;
1148     sal_Int32 nLength = aContent.getLength();
1149     if ((nLength > 0) && (aContent.getStr()[0] == '<'))
1150     {
1151         --nLength;
1152         ++nStart;
1153     }
1154     if ((nLength > 0) && (aContent.getStr()[aContent.getLength()-1] == '>'))
1155     {
1156         --nLength;
1157     }
1158     aAny <<= aContent.copy(nStart, nLength);
1159     xPropertySet->setPropertyValue(sPropertyPlaceholder, aAny);
1160
1161     aAny <<= nPlaceholderType;
1162     xPropertySet->setPropertyValue(sPropertyPlaceholderType, aAny);
1163 }
1164
1165
1166 //
1167 // time field
1168 //
1169
1170 TYPEINIT1( XMLTimeFieldImportContext, XMLTextFieldImportContext);
1171
1172 XMLTimeFieldImportContext::XMLTimeFieldImportContext(
1173     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
1174     sal_uInt16 nPrfx, const OUString& sLocalName)
1175 :       XMLTextFieldImportContext(rImport, rHlp, sAPI_date_time, nPrfx, sLocalName)
1176 ,       sPropertyNumberFormat(RTL_CONSTASCII_USTRINGPARAM(sAPI_number_format))
1177 ,       sPropertyFixed(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed))
1178 ,       sPropertyDateTimeValue(RTL_CONSTASCII_USTRINGPARAM(sAPI_date_time_value))
1179 ,       sPropertyDateTime(RTL_CONSTASCII_USTRINGPARAM(sAPI_date_time))
1180 ,       sPropertyAdjust(RTL_CONSTASCII_USTRINGPARAM(sAPI_adjust))
1181 ,       sPropertyIsDate(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_date))
1182 ,       sPropertyIsFixedLanguage(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed_language))
1183 ,       fTimeValue(0.0)
1184 ,       nAdjust(0)
1185 ,       nFormatKey(0)
1186 ,       bTimeOK(sal_False)
1187 ,       bFormatOK(sal_False)
1188 ,       bFixed(sal_False)
1189 ,       bIsDate(sal_False)
1190 ,       bIsDefaultLanguage( sal_True )
1191 {
1192     bValid = sal_True;  // always valid!
1193 }
1194
1195 void XMLTimeFieldImportContext::ProcessAttribute(
1196     sal_uInt16 nAttrToken, const OUString& sAttrValue )
1197 {
1198     switch (nAttrToken)
1199     {
1200         case XML_TOK_TEXTFIELD_TIME_VALUE:
1201         {
1202             double fTmp;
1203             if (GetImport().GetMM100UnitConverter().
1204                 convertDateTime(fTmp, sAttrValue))
1205             {
1206                 fTimeValue = fTmp;
1207                 bTimeOK = sal_True;
1208             }
1209
1210             if (GetImport().GetMM100UnitConverter().
1211                 convertDateTime(aDateTimeValue, sAttrValue ))
1212             {
1213                 bTimeOK = sal_True;
1214             }
1215             break;
1216         }
1217         case XML_TOK_TEXTFIELD_FIXED:
1218         {
1219             sal_Bool bTmp;
1220             if (SvXMLUnitConverter::convertBool(bTmp, sAttrValue))
1221             {
1222                 bFixed = bTmp;
1223             }
1224             break;
1225         }
1226         case XML_TOK_TEXTFIELD_DATA_STYLE_NAME:
1227         {
1228             sal_Int32 nKey = GetImportHelper().GetDataStyleKey(
1229                                                sAttrValue, &bIsDefaultLanguage);
1230             if (-1 != nKey)
1231             {
1232                 nFormatKey = nKey;
1233                 bFormatOK = sal_True;
1234             }
1235             break;
1236         }
1237         case XML_TOK_TEXTFIELD_TIME_ADJUST:
1238         {
1239             double fTmp;
1240
1241             if (SvXMLUnitConverter::convertTime(fTmp, sAttrValue))
1242             {
1243                 // convert to minutes
1244                 nAdjust = (sal_Int32)::rtl::math::approxFloor(fTmp * 60 * 24);
1245             }
1246             break;
1247         }
1248     }
1249 }
1250
1251 void XMLTimeFieldImportContext::PrepareField(
1252     const Reference<XPropertySet> & rPropertySet)
1253 {
1254     Any aAny;
1255
1256     // all properties are optional (except IsDate)
1257     Reference<XPropertySetInfo> xPropertySetInfo(
1258         rPropertySet->getPropertySetInfo());
1259
1260     if (xPropertySetInfo->hasPropertyByName(sPropertyFixed))
1261     {
1262         aAny.setValue( &bFixed, ::getBooleanCppuType() );
1263         rPropertySet->setPropertyValue(sPropertyFixed, aAny);
1264     }
1265
1266     aAny.setValue( &bIsDate, ::getBooleanCppuType() );
1267     rPropertySet->setPropertyValue(sPropertyIsDate, aAny);
1268
1269     if (xPropertySetInfo->hasPropertyByName(sPropertyAdjust))
1270     {
1271         aAny <<= nAdjust;
1272         rPropertySet->setPropertyValue(sPropertyAdjust, aAny);
1273     }
1274
1275     // set value
1276     if (bFixed)
1277     {
1278         // organizer or styles-only mode: force update
1279         if (GetImport().GetTextImport()->IsOrganizerMode() ||
1280             GetImport().GetTextImport()->IsStylesOnlyMode()   )
1281         {
1282             ForceUpdate(rPropertySet);
1283         }
1284         else
1285         {
1286             // normal mode: set value (if present)
1287             if (bTimeOK)
1288             {
1289                if (xPropertySetInfo->hasPropertyByName(sPropertyDateTimeValue))
1290                {
1291                    aAny <<= aDateTimeValue;
1292                    rPropertySet->setPropertyValue(sPropertyDateTimeValue,aAny);
1293                }
1294                else if (xPropertySetInfo->hasPropertyByName(sPropertyDateTime))
1295                {
1296                    aAny <<= aDateTimeValue;
1297                    rPropertySet->setPropertyValue(sPropertyDateTime, aAny);
1298                }
1299             }
1300         }
1301     }
1302
1303     if (bFormatOK &&
1304         xPropertySetInfo->hasPropertyByName(sPropertyNumberFormat))
1305     {
1306         aAny <<= nFormatKey;
1307         rPropertySet->setPropertyValue(sPropertyNumberFormat, aAny);
1308
1309         if( xPropertySetInfo->hasPropertyByName( sPropertyIsFixedLanguage ) )
1310         {
1311             sal_Bool bIsFixedLanguage = ! bIsDefaultLanguage;
1312             aAny.setValue( &bIsFixedLanguage, ::getBooleanCppuType() );
1313             rPropertySet->setPropertyValue( sPropertyIsFixedLanguage, aAny );
1314         }
1315     }
1316 }
1317
1318
1319
1320 //
1321 // date field
1322 //
1323
1324 TYPEINIT1( XMLDateFieldImportContext, XMLTimeFieldImportContext );
1325
1326 XMLDateFieldImportContext::XMLDateFieldImportContext(
1327     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
1328     sal_uInt16 nPrfx, const OUString& sLocalName) :
1329         XMLTimeFieldImportContext(rImport, rHlp, nPrfx, sLocalName)
1330 {
1331     bIsDate = sal_True; // always a date!
1332 }
1333
1334 void XMLDateFieldImportContext::ProcessAttribute(
1335     sal_uInt16 nAttrToken,
1336     const ::rtl::OUString& sAttrValue )
1337 {
1338     switch (nAttrToken)
1339     {
1340         case XML_TOK_TEXTFIELD_DATE_VALUE:
1341         {
1342             double fTmp;
1343
1344             if (GetImport().GetMM100UnitConverter().
1345                 convertDateTime(fTmp, sAttrValue))
1346             {
1347                 // #96457#: don't truncate in order to read date+time
1348                 fTimeValue = fTmp;
1349                 bTimeOK = sal_True;
1350             }
1351
1352             if (GetImport().GetMM100UnitConverter().
1353                 convertDateTime(aDateTimeValue, sAttrValue ))
1354             {
1355                 bTimeOK = sal_True;
1356             }
1357             break;
1358         }
1359         case XML_TOK_TEXTFIELD_DATE_ADJUST:
1360             // delegate to superclass, pretending it was a time-adjust attr.
1361             XMLTimeFieldImportContext::ProcessAttribute(
1362                 XML_TOK_TEXTFIELD_TIME_ADJUST,
1363                 sAttrValue);
1364             break;
1365         case XML_TOK_TEXTFIELD_TIME_VALUE:
1366         case XML_TOK_TEXTFIELD_TIME_ADJUST:
1367             ; // ignore time-adjust and time-value attributes
1368             break;
1369         default:
1370             // all others: delegate to super-class
1371             XMLTimeFieldImportContext::ProcessAttribute(nAttrToken,
1372                                                         sAttrValue);
1373             break;
1374     }
1375 }
1376
1377
1378
1379
1380 //
1381 // database field superclass
1382 //
1383
1384 TYPEINIT1( XMLDatabaseFieldImportContext, XMLTextFieldImportContext );
1385
1386 XMLDatabaseFieldImportContext::XMLDatabaseFieldImportContext(
1387     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
1388     const sal_Char* pServiceName, sal_uInt16 nPrfx,
1389     const OUString& sLocalName, bool bUseDisply)
1390 :       XMLTextFieldImportContext(rImport, rHlp, pServiceName, nPrfx, sLocalName)
1391 ,       sPropertyDataBaseName(RTL_CONSTASCII_USTRINGPARAM(sAPI_data_base_name))
1392 ,       sPropertyDataBaseURL(RTL_CONSTASCII_USTRINGPARAM(sAPI_data_base_u_r_l))
1393 ,       sPropertyTableName(RTL_CONSTASCII_USTRINGPARAM(sAPI_data_table_name))
1394 ,       sPropertyDataCommandType(RTL_CONSTASCII_USTRINGPARAM(sAPI_data_command_type))
1395 ,       sPropertyIsVisible(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_visible))
1396 ,       nCommandType( sdb::CommandType::TABLE )
1397 ,       bCommandTypeOK(sal_False)
1398 ,       bDisplay( sal_True )
1399 ,       bDisplayOK( false )
1400 ,       bUseDisplay( bUseDisply )
1401 ,       bDatabaseOK(sal_False)
1402 ,       bDatabaseNameOK(sal_False)
1403 ,       bDatabaseURLOK(sal_False)
1404 ,       bTableOK(sal_False)
1405 {
1406 }
1407
1408 void XMLDatabaseFieldImportContext::ProcessAttribute(
1409     sal_uInt16 nAttrToken, const OUString& sAttrValue )
1410 {
1411     switch (nAttrToken)
1412     {
1413         case XML_TOK_TEXTFIELD_DATABASE_NAME:
1414             sDatabaseName = sAttrValue;
1415             bDatabaseOK = sal_True;
1416             bDatabaseNameOK = sal_True;
1417             break;
1418         case XML_TOK_TEXTFIELD_TABLE_NAME:
1419             sTableName = sAttrValue;
1420             bTableOK = sal_True;
1421             break;
1422         case XML_TOK_TEXTFIELD_TABLE_TYPE:
1423             if( IsXMLToken( sAttrValue, XML_TABLE ) )
1424             {
1425                 nCommandType = sdb::CommandType::TABLE;
1426                 bCommandTypeOK = sal_True;
1427             }
1428             else if( IsXMLToken( sAttrValue, XML_QUERY ) )
1429             {
1430                 nCommandType = sdb::CommandType::QUERY;
1431                 bCommandTypeOK = sal_True;
1432             }
1433             else if( IsXMLToken( sAttrValue, XML_COMMAND ) )
1434             {
1435                 nCommandType = sdb::CommandType::COMMAND;
1436                 bCommandTypeOK = sal_True;
1437             }
1438             break;
1439         case XML_TOK_TEXTFIELD_DISPLAY:
1440             if( IsXMLToken( sAttrValue, XML_NONE ) )
1441             {
1442                 bDisplay = sal_False;
1443                 bDisplayOK = true;
1444             }
1445             else if( IsXMLToken( sAttrValue, XML_VALUE ) )
1446             {
1447                 bDisplay = sal_True;
1448                 bDisplayOK = true;
1449             }
1450             break;
1451     }
1452 }
1453
1454 SvXMLImportContext* XMLDatabaseFieldImportContext::CreateChildContext(
1455     sal_uInt16 p_nPrefix,
1456     const OUString& rLocalName,
1457     const Reference<XAttributeList>& xAttrList )
1458 {
1459     if( ( p_nPrefix == XML_NAMESPACE_FORM ) &&
1460         IsXMLToken( rLocalName, XML_CONNECTION_RESOURCE ) )
1461     {
1462         // process attribute list directly
1463         sal_Int16 nLength = xAttrList->getLength();
1464         for( sal_Int16 n = 0; n < nLength; n++ )
1465         {
1466             OUString sLocalName;
1467             sal_uInt16 nPrefix = GetImport().GetNamespaceMap().
1468                 GetKeyByAttrName( xAttrList->getNameByIndex(n), &sLocalName );
1469
1470             if( ( nPrefix == XML_NAMESPACE_XLINK ) &&
1471                 IsXMLToken( sLocalName, XML_HREF ) )
1472             {
1473                 sDatabaseURL = xAttrList->getValueByIndex(n);
1474                 bDatabaseOK = sal_True;
1475                 bDatabaseURLOK = sal_True;
1476             }
1477         }
1478
1479         // we call ProcessAttribute in order to set bValid appropriatly
1480         ProcessAttribute( XML_TOKEN_INVALID, OUString() );
1481     }
1482
1483     return SvXMLImportContext::CreateChildContext(p_nPrefix, rLocalName,
1484                                                   xAttrList);
1485 }
1486
1487
1488 void XMLDatabaseFieldImportContext::PrepareField(
1489         const Reference<XPropertySet> & xPropertySet)
1490 {
1491     Any aAny;
1492
1493     aAny <<= sTableName;
1494     xPropertySet->setPropertyValue(sPropertyTableName, aAny);
1495
1496     if( bDatabaseNameOK )
1497     {
1498         aAny <<= sDatabaseName;
1499         xPropertySet->setPropertyValue(sPropertyDataBaseName, aAny);
1500     }
1501     else if( bDatabaseURLOK )
1502     {
1503         aAny <<= sDatabaseURL;
1504         xPropertySet->setPropertyValue(sPropertyDataBaseURL, aAny);
1505     }
1506
1507     // #99980# load/save command type for all fields; also load
1508     //         old documents without command type
1509     if( bCommandTypeOK )
1510     {
1511         aAny <<= nCommandType;
1512         xPropertySet->setPropertyValue( sPropertyDataCommandType, aAny );
1513     }
1514
1515     if( bUseDisplay && bDisplayOK )
1516     {
1517         aAny.setValue( &bDisplay, ::getBooleanCppuType() );
1518         xPropertySet->setPropertyValue( sPropertyIsVisible, aAny );
1519     }
1520 }
1521
1522
1523
1524 //
1525 // database name field
1526 //
1527
1528 TYPEINIT1( XMLDatabaseNameImportContext, XMLDatabaseFieldImportContext );
1529
1530 XMLDatabaseNameImportContext::XMLDatabaseNameImportContext(
1531     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
1532     sal_uInt16 nPrfx, const OUString& sLocalName) :
1533         XMLDatabaseFieldImportContext(rImport, rHlp, sAPI_database_name,
1534                                       nPrfx, sLocalName, true)
1535 {
1536 }
1537
1538 void XMLDatabaseNameImportContext::ProcessAttribute(
1539     sal_uInt16 nAttrToken, const OUString& sAttrValue )
1540 {
1541     // delegate to superclass and check for success
1542     XMLDatabaseFieldImportContext::ProcessAttribute(nAttrToken, sAttrValue);
1543     bValid = bDatabaseOK && bTableOK;
1544 }
1545
1546
1547
1548 //
1549 // database next field
1550 //
1551
1552 TYPEINIT1( XMLDatabaseNextImportContext, XMLDatabaseFieldImportContext );
1553
1554 XMLDatabaseNextImportContext::XMLDatabaseNextImportContext(
1555     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
1556     const sal_Char* pServiceName, sal_uInt16 nPrfx,
1557     const OUString& sLocalName) :
1558         XMLDatabaseFieldImportContext(rImport, rHlp, pServiceName,
1559                                       nPrfx, sLocalName, false),
1560         sPropertyCondition(RTL_CONSTASCII_USTRINGPARAM(sAPI_condition)),
1561         sTrue(RTL_CONSTASCII_USTRINGPARAM(sAPI_true)),
1562         sCondition(),
1563         bConditionOK(sal_False)
1564 {
1565 }
1566
1567 XMLDatabaseNextImportContext::XMLDatabaseNextImportContext(
1568     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
1569     sal_uInt16 nPrfx, const OUString& sLocalName)
1570 : XMLDatabaseFieldImportContext(rImport, rHlp, sAPI_database_next, nPrfx, sLocalName, false)
1571 ,       sPropertyCondition(RTL_CONSTASCII_USTRINGPARAM(sAPI_condition))
1572 ,       sTrue(RTL_CONSTASCII_USTRINGPARAM(sAPI_true))
1573 ,       bConditionOK(sal_False)
1574 {
1575 }
1576
1577 void XMLDatabaseNextImportContext::ProcessAttribute(
1578     sal_uInt16 nAttrToken, const OUString& sAttrValue )
1579 {
1580     if (XML_TOK_TEXTFIELD_CONDITION == nAttrToken)
1581     {
1582         OUString sTmp;
1583         sal_uInt16 nPrefix = GetImport().GetNamespaceMap()._GetKeyByAttrName(
1584                                     sAttrValue, &sTmp, sal_False );
1585         if( XML_NAMESPACE_OOOW == nPrefix )
1586         {
1587             sCondition = sTmp;
1588             bConditionOK = sal_True;
1589         }
1590         else
1591             sCondition = sAttrValue;
1592     }
1593     else
1594     {
1595         XMLDatabaseFieldImportContext::ProcessAttribute(nAttrToken,
1596                                                         sAttrValue);
1597     }
1598
1599     bValid = bDatabaseOK && bTableOK;
1600 }
1601
1602 void XMLDatabaseNextImportContext::PrepareField(
1603     const Reference<XPropertySet> & xPropertySet)
1604 {
1605     Any aAny;
1606
1607     aAny <<= bConditionOK ? sCondition : sTrue;
1608     xPropertySet->setPropertyValue(sPropertyCondition, aAny);
1609
1610     XMLDatabaseFieldImportContext::PrepareField(xPropertySet);
1611 }
1612
1613
1614
1615 //
1616 // database select field
1617 //
1618
1619 TYPEINIT1( XMLDatabaseSelectImportContext, XMLDatabaseNextImportContext );
1620
1621 XMLDatabaseSelectImportContext::XMLDatabaseSelectImportContext(
1622     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
1623     sal_uInt16 nPrfx, const ::rtl::OUString& sLocalName) :
1624         XMLDatabaseNextImportContext(rImport, rHlp, sAPI_database_select,
1625                                      nPrfx, sLocalName),
1626         sPropertySetNumber(RTL_CONSTASCII_USTRINGPARAM(sAPI_set_number)),
1627         nNumber(0),
1628         bNumberOK(sal_False)
1629 {
1630 }
1631
1632 void XMLDatabaseSelectImportContext::ProcessAttribute(
1633     sal_uInt16 nAttrToken,
1634     const ::rtl::OUString& sAttrValue )
1635 {
1636     if (XML_TOK_TEXTFIELD_ROW_NUMBER == nAttrToken)
1637     {
1638         sal_Int32 nTmp;
1639         if (SvXMLUnitConverter::convertNumber( nTmp, sAttrValue
1640                                                /* , nMin, nMax ??? */ ))
1641         {
1642             nNumber = nTmp;
1643             bNumberOK = sal_True;
1644         }
1645     }
1646     else
1647     {
1648         XMLDatabaseNextImportContext::ProcessAttribute(nAttrToken, sAttrValue);
1649     }
1650
1651     bValid = bTableOK && bDatabaseOK && bNumberOK;
1652 }
1653
1654 void XMLDatabaseSelectImportContext::PrepareField(
1655     const Reference<XPropertySet> & xPropertySet)
1656 {
1657     Any aAny;
1658
1659     aAny <<= nNumber;
1660     xPropertySet->setPropertyValue(sPropertySetNumber, aAny);
1661
1662     XMLDatabaseNextImportContext::PrepareField(xPropertySet);
1663 }
1664
1665
1666
1667 //
1668 // database display row number field
1669 //
1670
1671 TYPEINIT1( XMLDatabaseNumberImportContext, XMLDatabaseFieldImportContext );
1672
1673 XMLDatabaseNumberImportContext::XMLDatabaseNumberImportContext(
1674     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
1675     sal_uInt16 nPrfx, const OUString& sLocalName) :
1676         XMLDatabaseFieldImportContext(rImport, rHlp, sAPI_database_number,
1677                                       nPrfx, sLocalName, true),
1678         sPropertyNumberingType(
1679             RTL_CONSTASCII_USTRINGPARAM(sAPI_numbering_type)),
1680         sPropertySetNumber(RTL_CONSTASCII_USTRINGPARAM(sAPI_set_number)),
1681         sNumberFormat(RTL_CONSTASCII_USTRINGPARAM("1")),
1682         sNumberSync(GetXMLToken(XML_FALSE)),
1683         nValue(0),
1684         bValueOK(sal_False)
1685 {
1686 }
1687
1688 void XMLDatabaseNumberImportContext::ProcessAttribute(
1689     sal_uInt16 nAttrToken,
1690     const OUString& sAttrValue )
1691 {
1692     switch (nAttrToken)
1693     {
1694         case XML_TOK_TEXTFIELD_NUM_FORMAT:
1695             sNumberFormat = sAttrValue;
1696             break;
1697         case XML_TOK_TEXTFIELD_NUM_LETTER_SYNC:
1698             sNumberSync = sAttrValue;
1699             break;
1700         case XML_TOK_TEXTFIELD_VALUE:
1701         {
1702             sal_Int32 nTmp;
1703             if (SvXMLUnitConverter::convertNumber( nTmp, sAttrValue ))
1704             {
1705                 nValue = nTmp;
1706                 bValueOK = sal_True;
1707             }
1708             break;
1709         }
1710         default:
1711             XMLDatabaseFieldImportContext::ProcessAttribute(nAttrToken,
1712                                                             sAttrValue);
1713             break;
1714     }
1715
1716     bValid = bTableOK && bDatabaseOK;
1717 }
1718
1719 void XMLDatabaseNumberImportContext::PrepareField(
1720     const Reference<XPropertySet> & xPropertySet)
1721 {
1722     Any aAny;
1723
1724     sal_Int16 nNumType = style::NumberingType::ARABIC;
1725     GetImport().GetMM100UnitConverter().convertNumFormat( nNumType,
1726                                                     sNumberFormat,
1727                                                     sNumberSync );
1728     aAny <<= nNumType;
1729     xPropertySet->setPropertyValue(sPropertyNumberingType, aAny);
1730
1731     if (bValueOK)
1732     {
1733         aAny <<= nValue;
1734         xPropertySet->setPropertyValue(sPropertySetNumber, aAny);
1735     }
1736
1737     XMLDatabaseFieldImportContext::PrepareField(xPropertySet);
1738 }
1739
1740
1741
1742 //
1743 // Simple doc info fields
1744 //
1745
1746 TYPEINIT1( XMLSimpleDocInfoImportContext, XMLTextFieldImportContext );
1747
1748 XMLSimpleDocInfoImportContext::XMLSimpleDocInfoImportContext(
1749     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
1750     sal_uInt16 nPrfx, const OUString& sLocalName, sal_uInt16 nToken,
1751     sal_Bool bContent, sal_Bool bAuthor)
1752 :       XMLTextFieldImportContext(rImport, rHlp, MapTokenToServiceName(nToken),nPrfx, sLocalName)
1753 ,       sPropertyFixed(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed))
1754 ,       sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content))
1755 ,       sPropertyAuthor(RTL_CONSTASCII_USTRINGPARAM(sAPI_author))
1756 ,       sPropertyCurrentPresentation(RTL_CONSTASCII_USTRINGPARAM(sAPI_current_presentation))
1757 ,       bFixed(sal_False)
1758 ,       bHasAuthor(bAuthor)
1759 ,       bHasContent(bContent)
1760 {
1761     bValid = sal_True;
1762 }
1763
1764 void XMLSimpleDocInfoImportContext::ProcessAttribute(
1765     sal_uInt16 nAttrToken,
1766     const OUString& sAttrValue )
1767 {
1768     if (XML_TOK_TEXTFIELD_FIXED == nAttrToken)
1769     {
1770         sal_Bool bTmp;
1771         if (SvXMLUnitConverter::convertBool(bTmp, sAttrValue))
1772         {
1773             bFixed = bTmp;
1774         }
1775     }
1776 }
1777
1778 void XMLSimpleDocInfoImportContext::PrepareField(
1779     const Reference<XPropertySet> & rPropertySet)
1780 {
1781     //  title field in Calc has no Fixed property
1782     Reference<XPropertySetInfo> xPropertySetInfo(rPropertySet->getPropertySetInfo());
1783     if (xPropertySetInfo->hasPropertyByName(sPropertyFixed))
1784     {
1785         Any aAny;
1786         aAny.setValue(&bFixed, ::getBooleanCppuType() );
1787         rPropertySet->setPropertyValue(sPropertyFixed, aAny);
1788
1789         // set Content and CurrentPresentation (if fixed)
1790         if (bFixed)
1791         {
1792             // in organizer-mode or styles-only-mode, only force update
1793             if (GetImport().GetTextImport()->IsOrganizerMode() ||
1794                 GetImport().GetTextImport()->IsStylesOnlyMode()   )
1795             {
1796                 ForceUpdate(rPropertySet);
1797             }
1798             else
1799             {
1800                 // set content (author, if that's the name) and current
1801                 // presentation
1802                 aAny <<= GetContent();
1803
1804                 if (bFixed && bHasAuthor)
1805                 {
1806                     rPropertySet->setPropertyValue(sPropertyAuthor, aAny);
1807                 }
1808
1809                 if (bFixed && bHasContent)
1810                 {
1811                     rPropertySet->setPropertyValue(sPropertyContent, aAny);
1812                 }
1813
1814                 rPropertySet->setPropertyValue(sPropertyCurrentPresentation, aAny);
1815             }
1816         }
1817     }
1818 }
1819
1820 const sal_Char* XMLSimpleDocInfoImportContext::MapTokenToServiceName(
1821     sal_uInt16 nToken)
1822 {
1823     const sal_Char* pServiceName = NULL;
1824
1825     switch(nToken)
1826     {
1827         case XML_TOK_TEXT_DOCUMENT_CREATION_AUTHOR:
1828             pServiceName = sAPI_docinfo_create_author;
1829             break;
1830         case XML_TOK_TEXT_DOCUMENT_CREATION_DATE:
1831             pServiceName = sAPI_docinfo_create_date_time;
1832             break;
1833         case XML_TOK_TEXT_DOCUMENT_CREATION_TIME:
1834             pServiceName = sAPI_docinfo_create_date_time;
1835             break;
1836         case XML_TOK_TEXT_DOCUMENT_DESCRIPTION:
1837             pServiceName = sAPI_docinfo_description;
1838             break;
1839         case XML_TOK_TEXT_DOCUMENT_EDIT_DURATION:
1840             pServiceName = sAPI_docinfo_edit_time;
1841             break;
1842         case XML_TOK_TEXT_DOCUMENT_USER_DEFINED:
1843             pServiceName = sAPI_docinfo_custom;
1844             break;
1845         case XML_TOK_TEXT_DOCUMENT_PRINT_AUTHOR:
1846             pServiceName = sAPI_docinfo_print_author;
1847             break;
1848         case XML_TOK_TEXT_DOCUMENT_PRINT_DATE:
1849             pServiceName = sAPI_docinfo_print_date_time;
1850             break;
1851         case XML_TOK_TEXT_DOCUMENT_PRINT_TIME:
1852             pServiceName = sAPI_docinfo_print_date_time;
1853             break;
1854         case XML_TOK_TEXT_DOCUMENT_KEYWORDS:
1855             pServiceName = sAPI_docinfo_keywords;
1856             break;
1857         case XML_TOK_TEXT_DOCUMENT_SUBJECT:
1858             pServiceName = sAPI_docinfo_subject;
1859             break;
1860         case XML_TOK_TEXT_DOCUMENT_REVISION:
1861             pServiceName = sAPI_docinfo_revision;
1862             break;
1863         case XML_TOK_TEXT_DOCUMENT_SAVE_AUTHOR:
1864             pServiceName = sAPI_docinfo_change_author;
1865             break;
1866         case XML_TOK_TEXT_DOCUMENT_SAVE_DATE:
1867             pServiceName = sAPI_docinfo_change_date_time;
1868             break;
1869         case XML_TOK_TEXT_DOCUMENT_SAVE_TIME:
1870             pServiceName = sAPI_docinfo_change_date_time;
1871             break;
1872         case XML_TOK_TEXT_DOCUMENT_TITLE:
1873             pServiceName = sAPI_docinfo_title;
1874             break;
1875
1876         default:
1877             DBG_ERROR("no docinfo field token");
1878             pServiceName = NULL;
1879             break;
1880     }
1881
1882     return pServiceName;
1883 }
1884
1885
1886 //
1887 // revision field
1888 //
1889
1890 TYPEINIT1( XMLRevisionDocInfoImportContext, XMLSimpleDocInfoImportContext );
1891
1892 XMLRevisionDocInfoImportContext::XMLRevisionDocInfoImportContext(
1893     SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx,
1894     const OUString& sLocalName, sal_uInt16 nToken) :
1895         XMLSimpleDocInfoImportContext(rImport, rHlp, nPrfx, sLocalName,
1896                                       nToken, sal_False, sal_False),
1897         sPropertyRevision(RTL_CONSTASCII_USTRINGPARAM(sAPI_revision))
1898 {
1899     bValid = sal_True;
1900 }
1901
1902 void XMLRevisionDocInfoImportContext::PrepareField(
1903     const Reference<XPropertySet> & rPropertySet)
1904 {
1905     XMLSimpleDocInfoImportContext::PrepareField(rPropertySet);
1906
1907     // set revision number
1908     // if fixed, if not in organizer-mode, if not in styles-only-mode
1909     if (bFixed)
1910     {
1911         if ( GetImport().GetTextImport()->IsOrganizerMode() ||
1912              GetImport().GetTextImport()->IsStylesOnlyMode()   )
1913         {
1914             ForceUpdate(rPropertySet);
1915         }
1916         else
1917         {
1918             sal_Int32 nTmp;
1919             if (SvXMLUnitConverter::convertNumber(nTmp, GetContent()))
1920             {
1921                 Any aAny;
1922                 aAny <<= nTmp;
1923                 rPropertySet->setPropertyValue(sPropertyRevision, aAny);
1924             }
1925         }
1926     }
1927 }
1928
1929
1930
1931 //
1932 // DocInfo fields with date/time attributes
1933 //
1934
1935 TYPEINIT1( XMLDateTimeDocInfoImportContext, XMLSimpleDocInfoImportContext );
1936
1937 XMLDateTimeDocInfoImportContext::XMLDateTimeDocInfoImportContext(
1938     SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx,
1939     const OUString& sLocalName, sal_uInt16 nToken)
1940 :       XMLSimpleDocInfoImportContext(rImport, rHlp, nPrfx, sLocalName,nToken, sal_False, sal_False)
1941 ,       sPropertyNumberFormat(RTL_CONSTASCII_USTRINGPARAM(sAPI_number_format))
1942 ,       sPropertyIsDate(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_date))
1943 ,       sPropertyIsFixedLanguage(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed_language))
1944 ,       nFormat(0)
1945 ,       bFormatOK(sal_False)
1946 ,       bIsDefaultLanguage(sal_True)
1947 {
1948     // we allow processing of EDIT_DURATION here, because import of actual
1949     // is not supported anyway. If it was, we'd need an extra import class
1950     // because times and time durations are presented differently!
1951
1952     bValid = sal_True;
1953     switch (nToken)
1954     {
1955         case XML_TOK_TEXT_DOCUMENT_CREATION_DATE:
1956         case XML_TOK_TEXT_DOCUMENT_PRINT_DATE:
1957         case XML_TOK_TEXT_DOCUMENT_SAVE_DATE:
1958             bIsDate = sal_True;
1959             bHasDateTime = sal_True;
1960             break;
1961         case XML_TOK_TEXT_DOCUMENT_CREATION_TIME:
1962         case XML_TOK_TEXT_DOCUMENT_PRINT_TIME:
1963         case XML_TOK_TEXT_DOCUMENT_SAVE_TIME:
1964             bIsDate = sal_False;
1965             bHasDateTime = sal_True;
1966             break;
1967         case XML_TOK_TEXT_DOCUMENT_EDIT_DURATION:
1968             bIsDate = sal_False;
1969             bHasDateTime = sal_False;
1970             break;
1971         default:
1972             DBG_ERROR(
1973                 "XMLDateTimeDocInfoImportContext needs date/time doc. fields");
1974             bValid = sal_False;
1975             break;
1976     }
1977 }
1978
1979 void XMLDateTimeDocInfoImportContext::ProcessAttribute(
1980     sal_uInt16 nAttrToken,
1981     const OUString& sAttrValue )
1982 {
1983     switch (nAttrToken)
1984     {
1985         case XML_TOK_TEXTFIELD_DATA_STYLE_NAME:
1986         {
1987             sal_Int32 nKey = GetImportHelper().GetDataStyleKey(
1988                                                sAttrValue, &bIsDefaultLanguage);
1989             if (-1 != nKey)
1990             {
1991                 nFormat = nKey;
1992                 bFormatOK = sal_True;
1993             }
1994             break;
1995         }
1996         case XML_TOK_TEXTFIELD_FIXED:
1997             XMLSimpleDocInfoImportContext::ProcessAttribute(nAttrToken,
1998                                                             sAttrValue);
1999             break;
2000         default:
2001             // ignore -> we can't set date/time value anyway!
2002             break;
2003     }
2004 }
2005
2006 void XMLDateTimeDocInfoImportContext::PrepareField(
2007     const Reference<XPropertySet> & xPropertySet)
2008 {
2009     // process fixed and presentation
2010     XMLSimpleDocInfoImportContext::PrepareField(xPropertySet);
2011
2012     Any aAny;
2013
2014     if (bHasDateTime)
2015     {
2016         aAny.setValue( &bIsDate, ::getBooleanCppuType());
2017         xPropertySet->setPropertyValue(sPropertyIsDate, aAny);
2018     }
2019
2020     if (bFormatOK)
2021     {
2022         aAny <<= nFormat;
2023         xPropertySet->setPropertyValue(sPropertyNumberFormat, aAny);
2024
2025         if( xPropertySet->getPropertySetInfo()->
2026                 hasPropertyByName( sPropertyIsFixedLanguage ) )
2027         {
2028             sal_Bool bIsFixedLanguage = ! bIsDefaultLanguage;
2029             aAny.setValue( &bIsFixedLanguage, ::getBooleanCppuType() );
2030             xPropertySet->setPropertyValue( sPropertyIsFixedLanguage, aAny );
2031         }
2032     }
2033
2034     // can't set date/time/duration value! Sorry.
2035 }
2036
2037
2038 //
2039 // user defined docinfo fields
2040 //
2041
2042 TYPEINIT1( XMLUserDocInfoImportContext, XMLSimpleDocInfoImportContext );
2043
2044 XMLUserDocInfoImportContext::XMLUserDocInfoImportContext(
2045     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
2046     sal_uInt16 nPrfx, const OUString& sLocalName, sal_uInt16 nToken) :
2047         XMLSimpleDocInfoImportContext(rImport, rHlp, nPrfx,
2048                                       sLocalName, nToken,
2049                                       sal_False, sal_False)
2050     , sPropertyName(RTL_CONSTASCII_USTRINGPARAM(sAPI_name))
2051 {
2052     bValid = sal_False;
2053 }
2054
2055 void XMLUserDocInfoImportContext::ProcessAttribute(
2056     sal_uInt16 nAttrToken,
2057     const OUString& sAttrValue )
2058 {
2059     switch (nAttrToken)
2060     {
2061         case XML_TOK_TEXTFIELD_NAME:
2062         {
2063             if (!bValid)
2064             {
2065                 SetServiceName(OUString::createFromAscii( sAPI_docinfo_custom ) );
2066                 aName = sAttrValue;
2067                 bValid = sal_True;
2068             }
2069             break;
2070         }
2071
2072         default:
2073             XMLSimpleDocInfoImportContext::ProcessAttribute(nAttrToken,
2074                                                             sAttrValue);
2075             break;
2076     }
2077 }
2078
2079 void XMLUserDocInfoImportContext::PrepareField(
2080         const ::com::sun::star::uno::Reference<
2081         ::com::sun::star::beans::XPropertySet> & xPropertySet)
2082 {
2083     if ( aName.getLength() )
2084     {
2085         uno::Any aAny;
2086         aAny <<= aName;
2087         xPropertySet->setPropertyValue(sPropertyName, aAny);
2088     }
2089
2090     // call superclass to handle "fixed"
2091     XMLSimpleDocInfoImportContext::PrepareField(xPropertySet);
2092 }
2093
2094
2095 //
2096 // import hidden paragraph fields
2097 //
2098
2099 TYPEINIT1( XMLHiddenParagraphImportContext, XMLTextFieldImportContext );
2100
2101 XMLHiddenParagraphImportContext::XMLHiddenParagraphImportContext(
2102     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
2103     sal_uInt16 nPrfx, const OUString& sLocalName) :
2104         XMLTextFieldImportContext(rImport, rHlp, sAPI_hidden_paragraph,
2105                                   nPrfx, sLocalName),
2106         sPropertyCondition(RTL_CONSTASCII_USTRINGPARAM(sAPI_condition)),
2107         sPropertyIsHidden(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_hidden)),
2108         sCondition(),
2109         bIsHidden(sal_False)
2110 {
2111 }
2112
2113 void XMLHiddenParagraphImportContext::ProcessAttribute(
2114     sal_uInt16 nAttrToken,
2115     const OUString& sAttrValue )
2116 {
2117     if (XML_TOK_TEXTFIELD_CONDITION == nAttrToken)
2118     {
2119         OUString sTmp;
2120         sal_uInt16 nPrefix = GetImport().GetNamespaceMap()._GetKeyByAttrName(
2121                                     sAttrValue, &sTmp, sal_False );
2122         if( XML_NAMESPACE_OOOW == nPrefix )
2123         {
2124             sCondition = sTmp;
2125             bValid = sal_True;
2126         }
2127         else
2128             sCondition = sAttrValue;
2129     }
2130     else if (XML_TOK_TEXTFIELD_IS_HIDDEN == nAttrToken)
2131     {
2132         sal_Bool bTmp;
2133         if (SvXMLUnitConverter::convertBool(bTmp, sAttrValue))
2134         {
2135             bIsHidden = bTmp;
2136         }
2137     }
2138 }
2139
2140 void XMLHiddenParagraphImportContext::PrepareField(
2141     const Reference<XPropertySet> & xPropertySet)
2142 {
2143     Any aAny;
2144     aAny <<= sCondition;
2145     xPropertySet->setPropertyValue(sPropertyCondition, aAny);
2146
2147     aAny.setValue( &bIsHidden, ::getBooleanCppuType() );
2148     xPropertySet->setPropertyValue(sPropertyIsHidden, aAny);
2149 }
2150
2151
2152
2153 //
2154 // import conditional text (<text:conditional-text>)
2155 //
2156
2157 TYPEINIT1( XMLConditionalTextImportContext, XMLTextFieldImportContext );
2158
2159 XMLConditionalTextImportContext::XMLConditionalTextImportContext(
2160     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
2161     sal_uInt16 nPrfx, const OUString& sLocalName) :
2162         XMLTextFieldImportContext(rImport, rHlp, sAPI_conditional_text,
2163                                   nPrfx, sLocalName),
2164         sPropertyCondition(RTL_CONSTASCII_USTRINGPARAM(sAPI_condition)),
2165         sPropertyTrueContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_true_content)),
2166         sPropertyFalseContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_false_content)),
2167         sPropertyIsConditionTrue(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_condition_true)),
2168         sPropertyCurrentPresentation(RTL_CONSTASCII_USTRINGPARAM(sAPI_current_presentation)),
2169         bConditionOK(sal_False),
2170         bTrueOK(sal_False),
2171         bFalseOK(sal_False),
2172         bCurrentValue(sal_False)
2173 {
2174 }
2175
2176 void XMLConditionalTextImportContext::ProcessAttribute(
2177     sal_uInt16 nAttrToken,
2178     const OUString& sAttrValue )
2179 {
2180     switch (nAttrToken)
2181     {
2182         case XML_TOK_TEXTFIELD_CONDITION:
2183             {
2184                 OUString sTmp;
2185                 sal_uInt16 nPrefix = GetImport().GetNamespaceMap().
2186                         _GetKeyByAttrName( sAttrValue, &sTmp, sal_False );
2187                 if( XML_NAMESPACE_OOOW == nPrefix )
2188                 {
2189                     sCondition = sTmp;
2190                     bConditionOK = sal_True;
2191                 }
2192                 else
2193                     sCondition = sAttrValue;
2194             }
2195             break;
2196         case XML_TOK_TEXTFIELD_STRING_VALUE_IF_FALSE:
2197             sFalseContent = sAttrValue;
2198             bFalseOK = sal_True;
2199             break;
2200         case XML_TOK_TEXTFIELD_STRING_VALUE_IF_TRUE:
2201             sTrueContent = sAttrValue;
2202             bTrueOK = sal_True;
2203             break;
2204         case XML_TOK_TEXTFIELD_CURRENT_VALUE:
2205         {
2206             sal_Bool bTmp;
2207             if (SvXMLUnitConverter::convertBool(bTmp, sAttrValue))
2208             {
2209                 bCurrentValue = bTmp;
2210             }
2211             break;
2212         }
2213     }
2214
2215     bValid = bConditionOK && bFalseOK && bTrueOK;
2216 }
2217
2218 void XMLConditionalTextImportContext::PrepareField(
2219     const Reference<XPropertySet> & xPropertySet)
2220 {
2221     Any aAny;
2222
2223     aAny <<= sCondition;
2224     xPropertySet->setPropertyValue(sPropertyCondition, aAny);
2225
2226     aAny <<= sFalseContent;
2227     xPropertySet->setPropertyValue(sPropertyFalseContent, aAny);
2228
2229     aAny <<= sTrueContent;
2230     xPropertySet->setPropertyValue(sPropertyTrueContent, aAny);
2231
2232     aAny.setValue( &bCurrentValue, ::getBooleanCppuType() );
2233     xPropertySet->setPropertyValue(sPropertyIsConditionTrue, aAny);
2234
2235     aAny <<= GetContent();
2236     xPropertySet->setPropertyValue(sPropertyCurrentPresentation, aAny);
2237 }
2238
2239
2240
2241 //
2242 // hidden text
2243 //
2244
2245 TYPEINIT1( XMLHiddenTextImportContext, XMLTextFieldImportContext);
2246
2247 XMLHiddenTextImportContext::XMLHiddenTextImportContext(
2248     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
2249     sal_uInt16 nPrfx, const OUString& sLocalName) :
2250         XMLTextFieldImportContext(rImport, rHlp, sAPI_hidden_text,
2251                                   nPrfx, sLocalName),
2252         sPropertyCondition(RTL_CONSTASCII_USTRINGPARAM(sAPI_condition)),
2253         sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content)),
2254         sPropertyIsHidden(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_hidden)),
2255         bConditionOK(sal_False),
2256         bStringOK(sal_False),
2257         bIsHidden(sal_False)
2258 {
2259 }
2260
2261 void XMLHiddenTextImportContext::ProcessAttribute(
2262     sal_uInt16 nAttrToken,
2263     const OUString& sAttrValue )
2264 {
2265     switch (nAttrToken)
2266     {
2267         case XML_TOK_TEXTFIELD_CONDITION:
2268             {
2269                 OUString sTmp;
2270                 sal_uInt16 nPrefix = GetImport().GetNamespaceMap().
2271                                         _GetKeyByAttrName( sAttrValue, &sTmp, sal_False );
2272                 if( XML_NAMESPACE_OOOW == nPrefix )
2273                 {
2274                     sCondition = sTmp;
2275                     bConditionOK = sal_True;
2276                 }
2277                 else
2278                     sCondition = sAttrValue;
2279             }
2280             break;
2281         case XML_TOK_TEXTFIELD_STRING_VALUE:
2282             sString = sAttrValue;
2283             bStringOK = sal_True;
2284             break;
2285         case XML_TOK_TEXTFIELD_IS_HIDDEN:
2286         {
2287             sal_Bool bTmp;
2288             if (SvXMLUnitConverter::convertBool(bTmp, sAttrValue))
2289             {
2290                 bIsHidden = bTmp;
2291             }
2292             break;
2293         }
2294     }
2295
2296     bValid = bConditionOK && bStringOK;
2297 }
2298
2299 void XMLHiddenTextImportContext::PrepareField(
2300         const Reference<XPropertySet> & xPropertySet)
2301 {
2302     Any aAny;
2303
2304     aAny <<= sCondition;
2305     xPropertySet->setPropertyValue(sPropertyCondition, aAny);
2306
2307     aAny <<= sString;
2308     xPropertySet->setPropertyValue(sPropertyContent, aAny);
2309
2310     aAny.setValue( &bIsHidden, ::getBooleanCppuType() );
2311     xPropertySet->setPropertyValue(sPropertyIsHidden, aAny);
2312 }
2313
2314
2315
2316 //
2317 // file name fields
2318 //
2319
2320 TYPEINIT1( XMLFileNameImportContext, XMLTextFieldImportContext );
2321
2322 static const SvXMLEnumMapEntry aFilenameDisplayMap[] =
2323 {
2324     { XML_PATH,                             FilenameDisplayFormat::PATH },
2325     { XML_NAME,                                 FilenameDisplayFormat::NAME },
2326     { XML_NAME_AND_EXTENSION,   FilenameDisplayFormat::NAME_AND_EXT },
2327     { XML_FULL,                                 FilenameDisplayFormat::FULL },
2328     { XML_TOKEN_INVALID, 0 }
2329 };
2330
2331 XMLFileNameImportContext::XMLFileNameImportContext(
2332     SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx,
2333     const OUString& sLocalName) :
2334         XMLTextFieldImportContext(rImport, rHlp, sAPI_file_name,
2335                                   nPrfx, sLocalName),
2336         sPropertyFixed(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed)),
2337         sPropertyFileFormat(RTL_CONSTASCII_USTRINGPARAM(sAPI_file_format)),
2338         sPropertyCurrentPresentation(
2339             RTL_CONSTASCII_USTRINGPARAM(sAPI_current_presentation)),
2340         nFormat(FilenameDisplayFormat::FULL),
2341         bFixed(sal_False)
2342 {
2343     bValid = sal_True;
2344 }
2345
2346 void XMLFileNameImportContext::ProcessAttribute(
2347     sal_uInt16 nAttrToken,
2348     const ::rtl::OUString& sAttrValue )
2349 {
2350     switch (nAttrToken)
2351     {
2352         case XML_TOK_TEXTFIELD_FIXED:
2353         {
2354             sal_Bool bTmp;
2355             if (SvXMLUnitConverter::convertBool(bTmp, sAttrValue))
2356             {
2357                 bFixed = bTmp;
2358             }
2359             break;
2360         }
2361         case XML_TOK_TEXTFIELD_DISPLAY:
2362         {
2363             sal_uInt16 nTmp;
2364             if (SvXMLUnitConverter::convertEnum(nTmp, sAttrValue,
2365                                                 aFilenameDisplayMap))
2366             {
2367                 nFormat = (sal_uInt16)nTmp;
2368             }
2369             break;
2370         }
2371         default:
2372             ; // unkown attribute: ignore
2373             break;
2374     }
2375 }
2376
2377 void XMLFileNameImportContext::PrepareField(
2378     const Reference<XPropertySet> & xPropertySet)
2379 {
2380     Any aAny;
2381
2382     // properties are optional
2383     Reference<XPropertySetInfo> xPropertySetInfo(
2384         xPropertySet->getPropertySetInfo());
2385
2386      if (xPropertySetInfo->hasPropertyByName(sPropertyFixed))
2387      {
2388          aAny <<= bFixed;
2389          xPropertySet->setPropertyValue(sPropertyFixed, aAny);
2390      }
2391
2392     if (xPropertySetInfo->hasPropertyByName(sPropertyFileFormat))
2393     {
2394         aAny <<= nFormat;
2395         xPropertySet->setPropertyValue(sPropertyFileFormat, aAny);
2396     }
2397
2398     if (xPropertySetInfo->hasPropertyByName(sPropertyCurrentPresentation))
2399     {
2400         aAny <<= GetContent();
2401         xPropertySet->setPropertyValue(sPropertyCurrentPresentation, aAny);
2402     }
2403 }
2404
2405
2406 //
2407 // template name field
2408 //
2409
2410 static const SvXMLEnumMapEntry aTemplateDisplayMap[] =
2411 {
2412     { XML_FULL,                                 TemplateDisplayFormat::FULL },
2413     { XML_PATH,                             TemplateDisplayFormat::PATH },
2414     { XML_NAME,                             TemplateDisplayFormat::NAME },
2415     { XML_NAME_AND_EXTENSION,   TemplateDisplayFormat::NAME_AND_EXT },
2416     { XML_AREA,                                 TemplateDisplayFormat::AREA },
2417     { XML_TITLE,                                TemplateDisplayFormat::TITLE },
2418     { XML_TOKEN_INVALID, 0 }
2419 };
2420
2421 TYPEINIT1( XMLTemplateNameImportContext, XMLTextFieldImportContext );
2422
2423 XMLTemplateNameImportContext::XMLTemplateNameImportContext(
2424     SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx,
2425     const OUString& sLocalName) :
2426         XMLTextFieldImportContext(rImport, rHlp, sAPI_template_name,
2427                                   nPrfx, sLocalName),
2428         sPropertyFileFormat(RTL_CONSTASCII_USTRINGPARAM(sAPI_file_format)),
2429         nFormat(TemplateDisplayFormat::FULL)
2430 {
2431     bValid = sal_True;
2432 }
2433
2434 void XMLTemplateNameImportContext::ProcessAttribute(
2435     sal_uInt16 nAttrToken,
2436     const OUString& sAttrValue )
2437 {
2438     switch (nAttrToken)
2439     {
2440         case XML_TOK_TEXTFIELD_DISPLAY:
2441         {
2442             sal_uInt16 nTmp;
2443             if (SvXMLUnitConverter::convertEnum(nTmp, sAttrValue,
2444                                                 aTemplateDisplayMap))
2445             {
2446                 nFormat = (sal_uInt16)nTmp;
2447             }
2448             break;
2449         }
2450         default:
2451             ; // unknown attribute: ignore
2452             break;
2453     }
2454 }
2455
2456 void XMLTemplateNameImportContext::PrepareField(
2457     const Reference<XPropertySet> & xPropertySet)
2458 {
2459     Any aAny;
2460
2461     aAny <<= nFormat;
2462     xPropertySet->setPropertyValue(sPropertyFileFormat, aAny);
2463 }
2464
2465
2466 //
2467 // import chapter fields
2468 //
2469
2470 TYPEINIT1( XMLChapterImportContext, XMLTextFieldImportContext );
2471
2472 static const SvXMLEnumMapEntry aChapterDisplayMap[] =
2473 {
2474     { XML_NAME,                                     ChapterFormat::NAME },
2475     { XML_NUMBER,                                       ChapterFormat::NUMBER },
2476     { XML_NUMBER_AND_NAME,                      ChapterFormat::NAME_NUMBER },
2477     { XML_PLAIN_NUMBER_AND_NAME,        ChapterFormat::NO_PREFIX_SUFFIX },
2478     { XML_PLAIN_NUMBER,                     ChapterFormat::DIGIT },
2479     { XML_TOKEN_INVALID, 0 }
2480 };
2481
2482 XMLChapterImportContext::XMLChapterImportContext(
2483     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
2484     sal_uInt16 nPrfx, const OUString& sLocalName) :
2485         XMLTextFieldImportContext(rImport, rHlp, sAPI_chapter,
2486                                   nPrfx, sLocalName),
2487         sPropertyChapterFormat(
2488             RTL_CONSTASCII_USTRINGPARAM(sAPI_chapter_format)),
2489         sPropertyLevel(RTL_CONSTASCII_USTRINGPARAM(sAPI_level)),
2490         nFormat(ChapterFormat::NAME_NUMBER),
2491         nLevel(0)
2492 {
2493     bValid = sal_True;
2494 }
2495
2496 void XMLChapterImportContext::ProcessAttribute(
2497     sal_uInt16 nAttrToken,
2498     const OUString& sAttrValue )
2499 {
2500     switch (nAttrToken)
2501     {
2502         case XML_TOK_TEXTFIELD_DISPLAY:
2503         {
2504             sal_uInt16 nTmp;
2505             if (SvXMLUnitConverter::convertEnum(nTmp, sAttrValue,
2506                                                 aChapterDisplayMap))
2507             {
2508                 nFormat = (sal_Int16)nTmp;
2509             }
2510             break;
2511         }
2512         case XML_TOK_TEXTFIELD_OUTLINE_LEVEL:
2513         {
2514             sal_Int32 nTmp;
2515             if (SvXMLUnitConverter::convertNumber(
2516                 nTmp, sAttrValue, 1,
2517                 GetImport().GetTextImport()->GetChapterNumbering()->getCount()
2518                 ))
2519             {
2520                 // API numbers 0..9, we number 1..10
2521                 nLevel = (sal_Int8)nTmp;
2522                 nLevel--;
2523             }
2524             break;
2525         }
2526         default:
2527             ; // unknown attribute: ignore
2528             break;
2529     }
2530 }
2531
2532 void XMLChapterImportContext::PrepareField(
2533         const Reference<XPropertySet> & xPropertySet)
2534 {
2535     Any aAny;
2536
2537     aAny <<= nFormat;
2538     xPropertySet->setPropertyValue(sPropertyChapterFormat, aAny);
2539
2540     aAny <<= nLevel;
2541     xPropertySet->setPropertyValue(sPropertyLevel, aAny);
2542 }
2543
2544
2545 //
2546 // counting fields
2547 //
2548
2549 TYPEINIT1( XMLCountFieldImportContext, XMLTextFieldImportContext );
2550
2551 XMLCountFieldImportContext::XMLCountFieldImportContext(
2552     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
2553     sal_uInt16 nPrfx, const OUString& sLocalName, sal_uInt16 nToken) :
2554         XMLTextFieldImportContext(rImport, rHlp, MapTokenToServiceName(nToken),
2555                                   nPrfx, sLocalName),
2556         sPropertyNumberingType(
2557             RTL_CONSTASCII_USTRINGPARAM(sAPI_numbering_type)),
2558         sNumberFormat(),
2559         sLetterSync(),
2560         bNumberFormatOK(sal_False)
2561 {
2562     bValid = sal_True;
2563 }
2564
2565 void XMLCountFieldImportContext::ProcessAttribute(
2566     sal_uInt16 nAttrToken,
2567     const OUString& sAttrValue )
2568 {
2569     switch (nAttrToken)
2570     {
2571         case XML_TOK_TEXTFIELD_NUM_FORMAT:
2572             sNumberFormat = sAttrValue;
2573             bNumberFormatOK = sal_True;
2574             break;
2575         case XML_TOK_TEXTFIELD_NUM_LETTER_SYNC:
2576             sLetterSync = sAttrValue;
2577             break;
2578     }
2579 }
2580
2581 void XMLCountFieldImportContext::PrepareField(
2582     const Reference<XPropertySet> & xPropertySet)
2583 {
2584     Any aAny;
2585
2586     // properties optional
2587     // (only page count, but do for all to save common implementation)
2588
2589     if (xPropertySet->getPropertySetInfo()->
2590         hasPropertyByName(sPropertyNumberingType))
2591     {
2592         sal_Int16 nNumType;
2593         if( bNumberFormatOK )
2594         {
2595             nNumType= style::NumberingType::ARABIC;
2596             GetImport().GetMM100UnitConverter().convertNumFormat( nNumType,
2597                                                     sNumberFormat,
2598                                                     sLetterSync );
2599         }
2600         else
2601             nNumType = style::NumberingType::PAGE_DESCRIPTOR;
2602         aAny <<= nNumType;
2603         xPropertySet->setPropertyValue(sPropertyNumberingType, aAny);
2604     }
2605 }
2606
2607 const sal_Char* XMLCountFieldImportContext::MapTokenToServiceName(
2608     sal_uInt16 nToken)
2609 {
2610     const sal_Char* pServiceName = NULL;
2611
2612     switch (nToken)
2613     {
2614         case XML_TOK_TEXT_WORD_COUNT:
2615             pServiceName = sAPI_word_count;
2616             break;
2617         case XML_TOK_TEXT_PARAGRAPH_COUNT:
2618             pServiceName = sAPI_paragraph_count;
2619             break;
2620         case XML_TOK_TEXT_TABLE_COUNT:
2621             pServiceName = sAPI_table_count;
2622             break;
2623         case XML_TOK_TEXT_CHARACTER_COUNT:
2624             pServiceName = sAPI_character_count;
2625             break;
2626         case XML_TOK_TEXT_IMAGE_COUNT:
2627             pServiceName = sAPI_graphic_object_count;
2628             break;
2629         case XML_TOK_TEXT_OBJECT_COUNT:
2630             pServiceName = sAPI_embedded_object_count;
2631             break;
2632         case XML_TOK_TEXT_PAGE_COUNT:
2633             pServiceName = sAPI_page_count;
2634             break;
2635         default:
2636             pServiceName = NULL;
2637             DBG_ERROR("unknown count field!");
2638             break;
2639     }
2640
2641     return pServiceName;
2642 }
2643
2644
2645
2646 //
2647 // page variable import
2648 //
2649
2650 TYPEINIT1( XMLPageVarGetFieldImportContext, XMLTextFieldImportContext );
2651
2652 XMLPageVarGetFieldImportContext::XMLPageVarGetFieldImportContext(
2653     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
2654     sal_uInt16 nPrfx, const OUString& sLocalName) :
2655         XMLTextFieldImportContext(rImport, rHlp, sAPI_reference_page_get,
2656                                   nPrfx, sLocalName),
2657         sPropertyNumberingType(
2658             RTL_CONSTASCII_USTRINGPARAM(sAPI_numbering_type)),
2659         sNumberFormat(),
2660         sLetterSync(),
2661         bNumberFormatOK(sal_False)
2662 {
2663     bValid = sal_True;
2664 }
2665
2666 void XMLPageVarGetFieldImportContext::ProcessAttribute(
2667     sal_uInt16 nAttrToken,
2668     const OUString& sAttrValue )
2669 {
2670     switch (nAttrToken)
2671     {
2672         case XML_TOK_TEXTFIELD_NUM_FORMAT:
2673             sNumberFormat = sAttrValue;
2674             bNumberFormatOK = sal_True;
2675             break;
2676         case XML_TOK_TEXTFIELD_NUM_LETTER_SYNC:
2677             sLetterSync = sAttrValue;
2678             break;
2679     }
2680 }
2681
2682 void XMLPageVarGetFieldImportContext::PrepareField(
2683     const Reference<XPropertySet> & xPropertySet)
2684 {
2685     Any aAny;
2686
2687     sal_Int16 nNumType;
2688     if( bNumberFormatOK )
2689     {
2690         nNumType= style::NumberingType::ARABIC;
2691         GetImport().GetMM100UnitConverter().convertNumFormat( nNumType,
2692                                                     sNumberFormat,
2693                                                     sLetterSync );
2694     }
2695     else
2696         nNumType = style::NumberingType::PAGE_DESCRIPTOR;
2697     aAny <<= nNumType;
2698     xPropertySet->setPropertyValue(sPropertyNumberingType, aAny);
2699
2700     // display old content (#96657#)
2701     aAny <<= GetContent();
2702     xPropertySet->setPropertyValue(
2703         OUString(RTL_CONSTASCII_USTRINGPARAM(sAPI_current_presentation)),
2704         aAny );
2705 }
2706
2707
2708
2709 //
2710 // page variable set fields
2711 //
2712
2713 TYPEINIT1(XMLPageVarSetFieldImportContext, XMLTextFieldImportContext);
2714
2715 XMLPageVarSetFieldImportContext::XMLPageVarSetFieldImportContext(
2716     SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx,
2717     const OUString& sLocalName) :
2718         XMLTextFieldImportContext(rImport, rHlp, sAPI_reference_page_set,
2719                                   nPrfx, sLocalName),
2720         sPropertyOn(RTL_CONSTASCII_USTRINGPARAM(sAPI_on)),
2721         sPropertyOffset(RTL_CONSTASCII_USTRINGPARAM(sAPI_offset)),
2722         nAdjust(0),
2723         bActive(sal_True)
2724 {
2725     bValid = sal_True;
2726 }
2727
2728 void XMLPageVarSetFieldImportContext::ProcessAttribute(
2729     sal_uInt16 nAttrToken,
2730     const ::rtl::OUString& sAttrValue )
2731 {
2732     switch (nAttrToken)
2733     {
2734         case XML_TOK_TEXTFIELD_ACTIVE:
2735         {
2736             sal_Bool bTmp;
2737             if (SvXMLUnitConverter::convertBool(bTmp, sAttrValue))
2738             {
2739                 bActive = bTmp;
2740             }
2741         }
2742         case XML_TOK_TEXTFIELD_PAGE_ADJUST:
2743         {
2744             sal_Int32 nTmp;
2745             if (SvXMLUnitConverter::convertNumber(nTmp, sAttrValue))
2746             {
2747                 nAdjust = (sal_Int16)nTmp;
2748             }
2749         }
2750     }
2751 }
2752
2753 void XMLPageVarSetFieldImportContext::PrepareField(
2754     const Reference<XPropertySet> & xPropertySet)
2755 {
2756     Any aAny;
2757
2758     aAny.setValue(&bActive, ::getBooleanCppuType());
2759     xPropertySet->setPropertyValue(sPropertyOn, aAny);
2760
2761     aAny <<= nAdjust;
2762     xPropertySet->setPropertyValue(sPropertyOffset, aAny);
2763 }
2764
2765
2766
2767 //
2768 // macro fields
2769 //
2770
2771 TYPEINIT1( XMLMacroFieldImportContext, XMLTextFieldImportContext );
2772
2773 XMLMacroFieldImportContext::XMLMacroFieldImportContext(
2774     SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx,
2775     const OUString& sLocalName) :
2776         XMLTextFieldImportContext(rImport, rHlp, sAPI_macro,
2777                                   nPrfx, sLocalName),
2778         sPropertyHint(RTL_CONSTASCII_USTRINGPARAM(sAPI_hint)),
2779         sPropertyMacroName(RTL_CONSTASCII_USTRINGPARAM("MacroName")),
2780         sPropertyScriptURL(RTL_CONSTASCII_USTRINGPARAM("ScriptURL")),
2781         bDescriptionOK(sal_False)
2782 {
2783 }
2784
2785 SvXMLImportContext* XMLMacroFieldImportContext::CreateChildContext(
2786     sal_uInt16 nPrefix,
2787     const OUString& rLocalName,
2788     const Reference<XAttributeList> & xAttrList )
2789 {
2790     SvXMLImportContext* pContext = NULL;
2791
2792     if ( (nPrefix == XML_NAMESPACE_OFFICE) &&
2793          IsXMLToken( rLocalName, XML_EVENT_LISTENERS ) )
2794     {
2795         // create events context and remember it!
2796         pContext = new XMLEventsImportContext(
2797             GetImport(), nPrefix, rLocalName );
2798         xEventContext = pContext;
2799         bValid = sal_True;
2800     }
2801     else
2802         pContext = SvXMLImportContext::CreateChildContext(
2803             nPrefix, rLocalName, xAttrList);
2804
2805     return pContext;
2806 }
2807
2808
2809 void XMLMacroFieldImportContext::ProcessAttribute(
2810     sal_uInt16 nAttrToken,
2811     const OUString& sAttrValue )
2812 {
2813     switch (nAttrToken)
2814     {
2815         case XML_TOK_TEXTFIELD_DESCRIPTION:
2816             sDescription = sAttrValue;
2817             bDescriptionOK = sal_True;
2818             break;
2819         case XML_TOK_TEXTFIELD_NAME:
2820             sMacro = sAttrValue;
2821             bValid = sal_True;
2822             break;
2823     }
2824 }
2825
2826 void XMLMacroFieldImportContext::PrepareField(
2827     const Reference<XPropertySet> & xPropertySet)
2828 {
2829     Any aAny;
2830
2831     OUString sOnClick(RTL_CONSTASCII_USTRINGPARAM("OnClick"));
2832     OUString sPropertyMacroLibrary(RTL_CONSTASCII_USTRINGPARAM("MacroLibrary"));
2833
2834     aAny <<= (bDescriptionOK ? sDescription : GetContent());
2835     xPropertySet->setPropertyValue(sPropertyHint, aAny);
2836
2837     // if we have an events child element, we'll look for the OnClick
2838     // event if not, it may be an old (pre-638i) document. Then, we'll
2839     // have to look at the name attribute.
2840     OUString sMacroName;
2841     OUString sLibraryName;
2842     OUString sScriptURL;
2843
2844     if ( xEventContext.Is() )
2845     {
2846         // get event sequence
2847         XMLEventsImportContext* pEvents =
2848             (XMLEventsImportContext*)&xEventContext;
2849         Sequence<PropertyValue> aValues;
2850         pEvents->GetEventSequence( sOnClick, aValues );
2851
2852         sal_Int32 nLength = aValues.getLength();
2853         for( sal_Int32 i = 0; i < nLength; i++ )
2854         {
2855             if ( aValues[i].Name.equalsAsciiL( "ScriptType",
2856                                                sizeof("ScriptType")-1 ) )
2857             {
2858                 // ignore ScriptType
2859             }
2860             else if ( aValues[i].Name.equalsAsciiL( "Library",
2861                                                     sizeof("Library")-1 ) )
2862             {
2863                 aValues[i].Value >>= sLibraryName;
2864             }
2865             else if ( aValues[i].Name.equalsAsciiL( "MacroName",
2866                                                     sizeof("MacroName")-1 ) )
2867             {
2868                 aValues[i].Value >>= sMacroName;
2869             }
2870             if ( aValues[i].Name.equalsAsciiL( "Script",
2871                                                sizeof("Script")-1 ) )
2872             {
2873                 aValues[i].Value >>= sScriptURL;
2874             }
2875         }
2876     }
2877     else
2878     {
2879         // disassemble old-style macro-name: Everything before the
2880         // third-last dot is the library
2881         sal_Int32 nPos = sMacro.getLength() + 1;        // the loop starts with nPos--
2882         const sal_Unicode* pBuf = sMacro.getStr();
2883         for( sal_Int32 i = 0; (i < 3) && (nPos > 0); i++ )
2884         {
2885             nPos--;
2886             while ( (pBuf[nPos] != '.') && (nPos > 0) )
2887                 nPos--;
2888         }
2889
2890         if (nPos > 0)
2891         {
2892             sLibraryName = sMacro.copy(0, nPos);
2893             sMacroName = sMacro.copy(nPos+1);
2894         }
2895         else
2896             sMacroName = sMacro;
2897     }
2898
2899     aAny <<= sScriptURL;
2900     xPropertySet->setPropertyValue(sPropertyScriptURL, aAny);
2901
2902     aAny <<= sMacroName;
2903     xPropertySet->setPropertyValue(sPropertyMacroName, aAny);
2904
2905     aAny <<= sLibraryName;
2906     xPropertySet->setPropertyValue(sPropertyMacroLibrary, aAny);
2907 }
2908
2909
2910
2911 //
2912 // reference field import
2913 //
2914
2915 TYPEINIT1( XMLReferenceFieldImportContext, XMLTextFieldImportContext );
2916
2917 XMLReferenceFieldImportContext::XMLReferenceFieldImportContext(
2918     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
2919     sal_uInt16 nToken, sal_uInt16 nPrfx, const OUString& sLocalName)
2920 :       XMLTextFieldImportContext(rImport, rHlp, sAPI_get_reference, nPrfx, sLocalName)
2921 ,       sPropertyReferenceFieldPart(RTL_CONSTASCII_USTRINGPARAM(sAPI_reference_field_part))
2922 ,       sPropertyReferenceFieldSource(RTL_CONSTASCII_USTRINGPARAM(sAPI_reference_field_source))
2923 ,       sPropertySourceName(RTL_CONSTASCII_USTRINGPARAM(sAPI_source_name))
2924 ,       sPropertyCurrentPresentation(RTL_CONSTASCII_USTRINGPARAM(sAPI_current_presentation))
2925 ,       nElementToken(nToken)
2926 ,       nType(ReferenceFieldPart::PAGE_DESC)
2927 ,       bNameOK(sal_False)
2928 ,       bTypeOK(sal_False)
2929 ,       bSeqNumberOK(sal_False)
2930 {
2931 }
2932
2933 static SvXMLEnumMapEntry __READONLY_DATA lcl_aReferenceTypeTokenMap[] =
2934 {
2935     { XML_PAGE,                 ReferenceFieldPart::PAGE},
2936     { XML_CHAPTER,          ReferenceFieldPart::CHAPTER },
2937     { XML_TEXT,             ReferenceFieldPart::TEXT },
2938     { XML_DIRECTION,    ReferenceFieldPart::UP_DOWN },
2939     { XML_CATEGORY_AND_VALUE, ReferenceFieldPart::CATEGORY_AND_NUMBER },
2940     { XML_CAPTION,          ReferenceFieldPart::ONLY_CAPTION },
2941     { XML_VALUE,                ReferenceFieldPart::ONLY_SEQUENCE_NUMBER },
2942     // --> OD 2007-09-14 #i81002#
2943     { XML_NUMBER,               ReferenceFieldPart::NUMBER },
2944     { XML_NUMBER_NO_SUPERIOR,   ReferenceFieldPart::NUMBER_NO_CONTEXT },
2945     { XML_NUMBER_ALL_SUPERIOR,  ReferenceFieldPart::NUMBER_FULL_CONTEXT },
2946     // <--
2947     { XML_TOKEN_INVALID, 0 }
2948 };
2949
2950 void XMLReferenceFieldImportContext::StartElement(
2951     const Reference<XAttributeList> & xAttrList)
2952 {
2953     bTypeOK = sal_True;
2954     switch (nElementToken)
2955     {
2956         case XML_TOK_TEXT_REFERENCE_REF:
2957             nSource = ReferenceFieldSource::REFERENCE_MARK;
2958             break;
2959         case XML_TOK_TEXT_BOOKMARK_REF:
2960             nSource = ReferenceFieldSource::BOOKMARK;
2961             break;
2962         case XML_TOK_TEXT_NOTE_REF:
2963             nSource = ReferenceFieldSource::FOOTNOTE;
2964             break;
2965         case XML_TOK_TEXT_SEQUENCE_REF:
2966             nSource = ReferenceFieldSource::SEQUENCE_FIELD;
2967             break;
2968         default:
2969             bTypeOK = sal_False;
2970             DBG_ERROR("unknown reference field");
2971             break;
2972     }
2973
2974     XMLTextFieldImportContext::StartElement(xAttrList);
2975 }
2976
2977
2978 void XMLReferenceFieldImportContext::ProcessAttribute(
2979     sal_uInt16 nAttrToken,
2980     const OUString& sAttrValue )
2981 {
2982     switch (nAttrToken)
2983     {
2984         case XML_TOK_TEXTFIELD_NOTE_CLASS:
2985             if( IsXMLToken( sAttrValue, XML_ENDNOTE ) )
2986                 nSource = ReferenceFieldSource::ENDNOTE;
2987             break;
2988         case XML_TOK_TEXTFIELD_REF_NAME:
2989             sName = sAttrValue;
2990             bNameOK = sal_True;
2991             break;
2992         case XML_TOK_TEXTFIELD_REFERENCE_FORMAT:
2993         {
2994             sal_uInt16 nToken;
2995             if (SvXMLUnitConverter::convertEnum(nToken, sAttrValue,
2996                                                 lcl_aReferenceTypeTokenMap))
2997             {
2998                 nType = nToken;
2999             }
3000
3001             // check for sequence-only-attributes
3002             if ( (XML_TOK_TEXT_SEQUENCE_REF != nElementToken) &&
3003                  ( (nType == ReferenceFieldPart::CATEGORY_AND_NUMBER) ||
3004                    (nType == ReferenceFieldPart::ONLY_CAPTION) ||
3005                    (nType == ReferenceFieldPart::ONLY_SEQUENCE_NUMBER) ) )
3006             {
3007                 nType = ReferenceFieldPart::PAGE_DESC;
3008             }
3009
3010             break;
3011         }
3012     }
3013
3014     // bValid: we need proper element type and name
3015     bValid = bTypeOK && bNameOK;
3016 }
3017
3018 void XMLReferenceFieldImportContext::PrepareField(
3019     const Reference<XPropertySet> & xPropertySet)
3020 {
3021     Any aAny;
3022
3023     aAny <<= nType;
3024     xPropertySet->setPropertyValue(sPropertyReferenceFieldPart, aAny);
3025
3026     aAny <<= nSource;
3027     xPropertySet->setPropertyValue(sPropertyReferenceFieldSource, aAny);
3028
3029     switch (nElementToken)
3030     {
3031         case XML_TOK_TEXT_REFERENCE_REF:
3032         case XML_TOK_TEXT_BOOKMARK_REF:
3033             aAny <<= sName;
3034             xPropertySet->setPropertyValue(sPropertySourceName, aAny);
3035             break;
3036
3037         case XML_TOK_TEXT_NOTE_REF:
3038             GetImportHelper().ProcessFootnoteReference(sName, xPropertySet);
3039             break;
3040
3041         case XML_TOK_TEXT_SEQUENCE_REF:
3042             GetImportHelper().ProcessSequenceReference(sName, xPropertySet);
3043             break;
3044     }
3045
3046     aAny <<= GetContent();
3047     xPropertySet->setPropertyValue(sPropertyCurrentPresentation, aAny);
3048 }
3049
3050
3051
3052 //
3053 // field declarations container
3054 //
3055
3056 enum DdeFieldDeclAttrs
3057 {
3058     XML_TOK_DDEFIELD_NAME,
3059     XML_TOK_DDEFIELD_APPLICATION,
3060     XML_TOK_DDEFIELD_TOPIC,
3061     XML_TOK_DDEFIELD_ITEM,
3062     XML_TOK_DDEFIELD_UPDATE
3063 };
3064
3065 static __FAR_DATA SvXMLTokenMapEntry aDdeDeclAttrTokenMap[] =
3066 {
3067     { XML_NAMESPACE_OFFICE, XML_NAME, XML_TOK_DDEFIELD_NAME },
3068     { XML_NAMESPACE_OFFICE, XML_DDE_APPLICATION, XML_TOK_DDEFIELD_APPLICATION },
3069     { XML_NAMESPACE_OFFICE, XML_DDE_TOPIC, XML_TOK_DDEFIELD_TOPIC },
3070     { XML_NAMESPACE_OFFICE, XML_DDE_ITEM, XML_TOK_DDEFIELD_ITEM },
3071     { XML_NAMESPACE_OFFICE, XML_AUTOMATIC_UPDATE, XML_TOK_DDEFIELD_UPDATE },
3072     XML_TOKEN_MAP_END
3073 };
3074
3075 TYPEINIT1( XMLDdeFieldDeclsImportContext, SvXMLImportContext );
3076
3077 XMLDdeFieldDeclsImportContext::XMLDdeFieldDeclsImportContext(
3078     SvXMLImport& rImport, sal_uInt16 nPrfx, const OUString& sLocalName) :
3079         SvXMLImportContext(rImport, nPrfx, sLocalName),
3080         aTokenMap(aDdeDeclAttrTokenMap)
3081 {
3082 }
3083
3084 SvXMLImportContext * XMLDdeFieldDeclsImportContext::CreateChildContext(
3085     sal_uInt16 nPrefix,
3086     const OUString& rLocalName,
3087     const Reference<XAttributeList> & xAttrList )
3088 {
3089     if ( (XML_NAMESPACE_TEXT == nPrefix) &&
3090          (IsXMLToken(rLocalName, XML_DDE_CONNECTION_DECL)) )
3091     {
3092         return new XMLDdeFieldDeclImportContext(GetImport(), nPrefix,
3093                                                 rLocalName, aTokenMap);
3094     }
3095     else
3096     {
3097         return SvXMLImportContext::CreateChildContext(nPrefix,
3098                                                       rLocalName,
3099                                                       xAttrList);
3100     }
3101 }
3102
3103
3104
3105 //
3106 // import dde field declaration
3107 //
3108
3109 TYPEINIT1( XMLDdeFieldDeclImportContext, SvXMLImportContext );
3110
3111 XMLDdeFieldDeclImportContext::XMLDdeFieldDeclImportContext(
3112     SvXMLImport& rImport, sal_uInt16 nPrfx,
3113     const OUString& sLocalName, const SvXMLTokenMap& rMap)
3114 :       SvXMLImportContext(rImport, nPrfx, sLocalName)
3115 ,       sPropertyIsAutomaticUpdate(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_automatic_update))
3116 ,       sPropertyName(RTL_CONSTASCII_USTRINGPARAM(sAPI_name))
3117 ,       sPropertyDDECommandType(RTL_CONSTASCII_USTRINGPARAM(sAPI_dde_command_type))
3118 ,       sPropertyDDECommandFile(RTL_CONSTASCII_USTRINGPARAM(sAPI_dde_command_file))
3119 ,       sPropertyDDECommandElement(RTL_CONSTASCII_USTRINGPARAM(sAPI_dde_command_element))
3120 ,       rTokenMap(rMap)
3121 {
3122     DBG_ASSERT(XML_NAMESPACE_TEXT == nPrfx, "wrong prefix");
3123     DBG_ASSERT(IsXMLToken(sLocalName, XML_DDE_CONNECTION_DECL), "wrong name");
3124 }
3125
3126 void XMLDdeFieldDeclImportContext::StartElement(
3127     const Reference<XAttributeList> & xAttrList)
3128 {
3129     OUString sName;
3130     OUString sCommandApplication;
3131     OUString sCommandTopic;
3132     OUString sCommandItem;
3133
3134     sal_Bool bUpdate = sal_False;
3135     sal_Bool bNameOK = sal_False;
3136     sal_Bool bCommandApplicationOK = sal_False;
3137     sal_Bool bCommandTopicOK = sal_False;
3138     sal_Bool bCommandItemOK = sal_False;
3139
3140     // process attributes
3141     sal_Int16 nLength = xAttrList->getLength();
3142     for(sal_Int16 i=0; i<nLength; i++)
3143     {
3144
3145         OUString sLocalName;
3146         sal_uInt16 nPrefix = GetImport().GetNamespaceMap().
3147             GetKeyByAttrName( xAttrList->getNameByIndex(i), &sLocalName );
3148
3149         switch (rTokenMap.Get(nPrefix, sLocalName))
3150         {
3151             case XML_TOK_DDEFIELD_NAME:
3152                 sName = xAttrList->getValueByIndex(i);
3153                 bNameOK = sal_True;
3154                 break;
3155             case XML_TOK_DDEFIELD_APPLICATION:
3156                 sCommandApplication = xAttrList->getValueByIndex(i);
3157                 bCommandApplicationOK = sal_True;
3158                 break;
3159             case XML_TOK_DDEFIELD_TOPIC:
3160                 sCommandTopic = xAttrList->getValueByIndex(i);
3161                 bCommandTopicOK = sal_True;
3162                 break;
3163             case XML_TOK_DDEFIELD_ITEM:
3164                 sCommandItem = xAttrList->getValueByIndex(i);
3165                 bCommandItemOK = sal_True;
3166                 break;
3167             case XML_TOK_DDEFIELD_UPDATE:
3168             {
3169                 sal_Bool bTmp;
3170                 if ( SvXMLUnitConverter::convertBool(
3171                     bTmp, xAttrList->getValueByIndex(i)) )
3172                 {
3173                     bUpdate = bTmp;
3174                 }
3175                 break;
3176             }
3177         }
3178     }
3179
3180     // valid data?
3181     if (bNameOK && bCommandApplicationOK && bCommandTopicOK && bCommandItemOK)
3182     {
3183         // make service name
3184         OUStringBuffer sBuf;
3185         sBuf.appendAscii(sAPI_fieldmaster_prefix);
3186         sBuf.appendAscii(sAPI_dde);
3187
3188         // create DDE TextFieldMaster
3189         Reference<XMultiServiceFactory> xFactory(GetImport().GetModel(),
3190                                                  UNO_QUERY);
3191         if( xFactory.is() )
3192         {
3193             /* #i6432# There might be multiple occurances of one DDE
3194                declaration if it is used in more than one of
3195                header/footer/body. createInstance will throw an exception if we
3196                try to create the second, third, etc. instance of such a
3197                declaration. Thus we ignore the exception. Otherwise this will
3198                lead to an unloadable document. */
3199             try
3200             {
3201                 Reference<XInterface> xIfc =
3202                     xFactory->createInstance(sBuf.makeStringAndClear());
3203                 if( xIfc.is() )
3204                 {
3205                     Reference<XPropertySet> xPropSet( xIfc, UNO_QUERY );
3206                     if (xPropSet.is() &&
3207                         xPropSet->getPropertySetInfo()->hasPropertyByName(
3208                                                                           sPropertyDDECommandType))
3209                     {
3210                         Any aAny;
3211
3212                         aAny <<= sName;
3213                         xPropSet->setPropertyValue(sPropertyName, aAny);
3214
3215                         aAny <<= sCommandApplication;
3216                         xPropSet->setPropertyValue(sPropertyDDECommandType, aAny);
3217
3218                         aAny <<= sCommandTopic;
3219                         xPropSet->setPropertyValue(sPropertyDDECommandFile, aAny);
3220
3221                         aAny <<= sCommandItem;
3222                         xPropSet->setPropertyValue(sPropertyDDECommandElement,
3223                                                    aAny);
3224
3225                         aAny.setValue(&bUpdate, ::getBooleanCppuType());
3226                         xPropSet->setPropertyValue(sPropertyIsAutomaticUpdate,
3227                                                    aAny);
3228                     }
3229                     // else: ignore (can't get XPropertySet, or DDE
3230                     //               properties are not supported)
3231                 }
3232                 // else: ignore
3233             }
3234             catch ( const Exception& )
3235             {
3236                 //ignore
3237             }
3238         }
3239         // else: ignore
3240     }
3241     // else: ignore
3242 }
3243
3244
3245
3246 //
3247 // DDE field import
3248 //
3249
3250 TYPEINIT1( XMLDdeFieldImportContext, XMLTextFieldImportContext );
3251
3252 XMLDdeFieldImportContext::XMLDdeFieldImportContext(
3253     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
3254     sal_uInt16 nPrfx, const OUString& sLocalName) :
3255         XMLTextFieldImportContext(rImport, rHlp, sAPI_dde,
3256                                   nPrfx, sLocalName),
3257         sName()
3258         ,sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content))
3259 {
3260 }
3261
3262 void XMLDdeFieldImportContext::ProcessAttribute(
3263     sal_uInt16 nAttrToken,
3264     const ::rtl::OUString& sAttrValue )
3265 {
3266     if (XML_TOK_TEXTFIELD_CONNECTION_NAME == nAttrToken)
3267     {
3268         sName = sAttrValue;
3269         bValid = sal_True;
3270     }
3271 }
3272
3273 void XMLDdeFieldImportContext::EndElement()
3274 {
3275     if (bValid)
3276     {
3277         // find master
3278         OUStringBuffer sBuf;
3279         sBuf.appendAscii(sAPI_fieldmaster_prefix);
3280         sBuf.appendAscii(sAPI_dde);
3281         sBuf.append(sal_Unicode('.'));
3282         sBuf.append(sName);
3283         OUString sMasterName = sBuf.makeStringAndClear();
3284
3285         Reference<XTextFieldsSupplier> xTextFieldsSupp(GetImport().GetModel(),
3286                                                        UNO_QUERY);
3287         Reference<container::XNameAccess> xFieldMasterNameAccess(
3288             xTextFieldsSupp->getTextFieldMasters(), UNO_QUERY);
3289
3290         if (xFieldMasterNameAccess->hasByName(sMasterName))
3291         {
3292             Reference<XPropertySet> xMaster;
3293             Any aAny = xFieldMasterNameAccess->getByName(sMasterName);
3294             aAny >>= xMaster;
3295             //apply the content to the master
3296             xMaster->setPropertyValue( sPropertyContent, uno::makeAny( GetContent()));
3297             // master exists: create text field and attach
3298             Reference<XPropertySet> xField;
3299             sBuf.appendAscii(sAPI_textfield_prefix);
3300             sBuf.appendAscii(sAPI_dde);
3301             if (CreateField(xField, sBuf.makeStringAndClear()))
3302             {
3303                 Reference<XDependentTextField> xDepTextField(xField,UNO_QUERY);
3304                 xDepTextField->attachTextFieldMaster(xMaster);
3305
3306                 // attach field to document
3307                 Reference<XTextContent> xTextContent(xField, UNO_QUERY);
3308                 if (xTextContent.is())
3309                 {
3310                     GetImportHelper().InsertTextContent(xTextContent);
3311
3312                     // we're lucky. nothing else to prepare.
3313                 }
3314                 // else: fail, because text content could not be created
3315             }
3316             // else: fail, because field could not be created
3317         }
3318         // else: fail, because no master was found (faulty document?!)
3319     }
3320     // not valid: ignore
3321 }
3322
3323 void XMLDdeFieldImportContext::PrepareField(
3324     const Reference<XPropertySet> &)
3325 {
3326     // empty, since not needed.
3327 }
3328
3329
3330 //
3331 // sheet name fields
3332 //
3333
3334 TYPEINIT1(XMLSheetNameImportContext, XMLTextFieldImportContext);
3335
3336 XMLSheetNameImportContext::XMLSheetNameImportContext(
3337     SvXMLImport& rImport,
3338     XMLTextImportHelper& rHlp,
3339     sal_uInt16 nPrfx,
3340     const OUString& sLocalName) :
3341         XMLTextFieldImportContext(rImport, rHlp, sAPI_sheet_name,
3342                                   nPrfx, sLocalName)
3343 {
3344     bValid = sal_True;  // always valid!
3345 }
3346
3347 void XMLSheetNameImportContext::ProcessAttribute(
3348     sal_uInt16,
3349     const ::rtl::OUString& )
3350 {
3351     // no attributes -> nothing to be done
3352 }
3353
3354 void XMLSheetNameImportContext::PrepareField(
3355     const Reference<XPropertySet> &)
3356 {
3357     // no attributes -> nothing to be done
3358 }
3359
3360
3361 //
3362 // URL fields (Calc, Impress, Draw)
3363 //
3364
3365 TYPEINIT1(XMLUrlFieldImportContext, XMLTextFieldImportContext);
3366
3367 XMLUrlFieldImportContext::XMLUrlFieldImportContext(
3368     SvXMLImport& rImport,
3369     XMLTextImportHelper& rHlp,
3370     sal_uInt16 nPrfx,
3371     const OUString& sLocalName) :
3372         XMLTextFieldImportContext(rImport, rHlp, sAPI_url,
3373                                   nPrfx, sLocalName),
3374         sPropertyURL(RTL_CONSTASCII_USTRINGPARAM(sAPI_url)),
3375         sPropertyTargetFrame(RTL_CONSTASCII_USTRINGPARAM(sAPI_target_frame)),
3376         sPropertyRepresentation(RTL_CONSTASCII_USTRINGPARAM(
3377             sAPI_representation)),
3378         bFrameOK(sal_False)
3379 {
3380 }
3381
3382 void XMLUrlFieldImportContext::ProcessAttribute(
3383     sal_uInt16 nAttrToken,
3384     const OUString& sAttrValue )
3385 {
3386     switch (nAttrToken)
3387     {
3388         case XML_TOK_TEXTFIELD_HREF:
3389             sURL = GetImport().GetAbsoluteReference( sAttrValue );
3390             bValid = sal_True;
3391             break;
3392         case XML_TOK_TEXTFIELD_TARGET_FRAME:
3393             sFrame = sAttrValue;
3394             bFrameOK = sal_True;
3395             break;
3396         default:
3397             // ignore
3398             break;
3399     }
3400 }
3401
3402 void XMLUrlFieldImportContext::PrepareField(
3403     const Reference<XPropertySet> & xPropertySet)
3404 {
3405     Any aAny;
3406
3407     aAny <<= sURL;
3408     xPropertySet->setPropertyValue(sPropertyURL, aAny);
3409
3410     if (bFrameOK)
3411     {
3412         aAny <<= sFrame;
3413         xPropertySet->setPropertyValue(sPropertyTargetFrame, aAny);
3414     }
3415
3416     aAny <<= GetContent();
3417     xPropertySet->setPropertyValue(sPropertyRepresentation, aAny);
3418 }
3419
3420
3421 TYPEINIT1(XMLBibliographyFieldImportContext, XMLTextFieldImportContext);
3422
3423
3424 XMLBibliographyFieldImportContext::XMLBibliographyFieldImportContext(
3425     SvXMLImport& rImport,
3426     XMLTextImportHelper& rHlp,
3427     sal_uInt16 nPrfx,
3428     const OUString& sLocalName) :
3429         XMLTextFieldImportContext(rImport, rHlp, sAPI_bibliography,
3430                                   nPrfx, sLocalName),
3431         sPropertyFields(RTL_CONSTASCII_USTRINGPARAM("Fields")),
3432         aValues()
3433 {
3434     bValid = sal_True;
3435 }
3436
3437 // TODO: this is the same map as is used in the text field export
3438 SvXMLEnumMapEntry __READONLY_DATA aBibliographyDataTypeMap[] =
3439 {
3440     { XML_ARTICLE,                      BibliographyDataType::ARTICLE },
3441     { XML_BOOK,                     BibliographyDataType::BOOK },
3442     { XML_BOOKLET,                      BibliographyDataType::BOOKLET },
3443     { XML_CONFERENCE,           BibliographyDataType::CONFERENCE },
3444     { XML_CUSTOM1,                      BibliographyDataType::CUSTOM1 },
3445     { XML_CUSTOM2,                      BibliographyDataType::CUSTOM2 },
3446     { XML_CUSTOM3,                      BibliographyDataType::CUSTOM3 },
3447     { XML_CUSTOM4,                      BibliographyDataType::CUSTOM4 },
3448     { XML_CUSTOM5,                      BibliographyDataType::CUSTOM5 },
3449     { XML_EMAIL,                        BibliographyDataType::EMAIL },
3450     { XML_INBOOK,                       BibliographyDataType::INBOOK },
3451     { XML_INCOLLECTION,     BibliographyDataType::INCOLLECTION },
3452     { XML_INPROCEEDINGS,        BibliographyDataType::INPROCEEDINGS },
3453     { XML_JOURNAL,                      BibliographyDataType::JOURNAL },
3454     { XML_MANUAL,                       BibliographyDataType::MANUAL },
3455     { XML_MASTERSTHESIS,        BibliographyDataType::MASTERSTHESIS },
3456     { XML_MISC,                     BibliographyDataType::MISC },
3457     { XML_PHDTHESIS,            BibliographyDataType::PHDTHESIS },
3458     { XML_PROCEEDINGS,          BibliographyDataType::PROCEEDINGS },
3459     { XML_TECHREPORT,           BibliographyDataType::TECHREPORT },
3460     { XML_UNPUBLISHED,          BibliographyDataType::UNPUBLISHED },
3461     { XML_WWW,                          BibliographyDataType::WWW },
3462     { XML_TOKEN_INVALID, 0 }
3463 };
3464
3465
3466 // we'll process attributes on our own and forfit the standard
3467 // tecfield mechanism, because our attributes have zero overlp with
3468 // all the oher textfields.
3469 void XMLBibliographyFieldImportContext::StartElement(
3470         const Reference<XAttributeList> & xAttrList)
3471 {
3472     // iterate over attributes
3473     sal_Int16 nLength = xAttrList->getLength();
3474     for(sal_Int16 i=0; i<nLength; i++) {
3475
3476         OUString sLocalName;
3477         sal_uInt16 nPrefix = GetImport().GetNamespaceMap().
3478             GetKeyByAttrName( xAttrList->getNameByIndex(i), &sLocalName );
3479
3480         if (nPrefix == XML_NAMESPACE_TEXT)
3481         {
3482             PropertyValue aValue;
3483             aValue.Name = OUString::createFromAscii(
3484                 MapBibliographyFieldName(sLocalName));
3485             Any aAny;
3486
3487             // special treatment for bibliography type
3488             // biblio vs bibilio: #96658#; also read old documents
3489             if (IsXMLToken(sLocalName, XML_BIBILIOGRAPHIC_TYPE) ||
3490                 IsXMLToken(sLocalName, XML_BIBLIOGRAPHY_TYPE)    )
3491             {
3492                 sal_uInt16 nTmp;
3493                 if (SvXMLUnitConverter::convertEnum(
3494                     nTmp, xAttrList->getValueByIndex(i),
3495                     aBibliographyDataTypeMap))
3496                 {
3497                     aAny <<= (sal_Int16)nTmp;
3498                     aValue.Value = aAny;
3499
3500                     aValues.push_back(aValue);
3501                 }
3502             }
3503             else
3504             {
3505                 aAny <<= xAttrList->getValueByIndex(i);
3506                 aValue.Value = aAny;
3507
3508                 aValues.push_back(aValue);
3509             }
3510         }
3511         // else: unknown namespace -> ignore
3512     }
3513 }
3514
3515 void XMLBibliographyFieldImportContext::ProcessAttribute(
3516     sal_uInt16,
3517     const OUString& )
3518 {
3519     // attributes are handled in StartElement
3520     DBG_ERROR("This should not have happened.");
3521 }
3522
3523
3524 void XMLBibliographyFieldImportContext::PrepareField(
3525     const Reference<XPropertySet> & xPropertySet)
3526 {
3527     // convert vector into sequence
3528     sal_Int32 nCount = aValues.size();
3529     Sequence<PropertyValue> aValueSequence(nCount);
3530     for(sal_Int32 i = 0; i < nCount; i++)
3531     {
3532         aValueSequence[i] = aValues[i];
3533     }
3534
3535     // set sequence
3536     Any aAny;
3537     aAny <<= aValueSequence;
3538     xPropertySet->setPropertyValue(sPropertyFields, aAny);
3539 }
3540
3541 const sal_Char* XMLBibliographyFieldImportContext::MapBibliographyFieldName(
3542     OUString sName)
3543 {
3544     const sal_Char* pName = NULL;
3545
3546     if (IsXMLToken(sName, XML_IDENTIFIER))
3547     {
3548         pName = "Identifier";
3549     }
3550     else if (IsXMLToken(sName, XML_BIBILIOGRAPHIC_TYPE) ||
3551              IsXMLToken(sName, XML_BIBLIOGRAPHY_TYPE)     )
3552     {
3553         // biblio... vs bibilio...: #96658#: also read old documents
3554         pName = "BibiliographicType";
3555     }
3556     else if (IsXMLToken(sName, XML_ADDRESS))
3557     {
3558         pName = "Address";
3559     }
3560     else if (IsXMLToken(sName, XML_ANNOTE))
3561     {
3562         pName = "Annote";
3563     }
3564     else if (IsXMLToken(sName, XML_AUTHOR))
3565     {
3566         pName = "Author";
3567     }
3568     else if (IsXMLToken(sName, XML_BOOKTITLE))
3569     {
3570         pName = "Booktitle";
3571     }
3572     else if (IsXMLToken(sName, XML_CHAPTER))
3573     {
3574         pName = "Chapter";
3575     }
3576     else if (IsXMLToken(sName, XML_EDITION))
3577     {
3578         pName = "Edition";
3579     }
3580     else if (IsXMLToken(sName, XML_EDITOR))
3581     {
3582         pName = "Editor";
3583     }
3584     else if (IsXMLToken(sName, XML_HOWPUBLISHED))
3585     {
3586         pName = "Howpublished";
3587     }
3588     else if (IsXMLToken(sName, XML_INSTITUTION))
3589     {
3590         pName = "Institution";
3591     }
3592     else if (IsXMLToken(sName, XML_JOURNAL))
3593     {
3594         pName = "Journal";
3595     }
3596     else if (IsXMLToken(sName, XML_MONTH))
3597     {
3598         pName = "Month";
3599     }
3600     else if (IsXMLToken(sName, XML_NOTE))
3601     {
3602         pName = "Note";
3603     }
3604     else if (IsXMLToken(sName, XML_NUMBER))
3605     {
3606         pName = "Number";
3607     }
3608     else if (IsXMLToken(sName, XML_ORGANIZATIONS))
3609     {
3610         pName = "Organizations";
3611     }
3612     else if (IsXMLToken(sName, XML_PAGES))
3613     {
3614         pName = "Pages";
3615     }
3616     else if (IsXMLToken(sName, XML_PUBLISHER))
3617     {
3618         pName = "Publisher";
3619     }
3620     else if (IsXMLToken(sName, XML_SCHOOL))
3621     {
3622         pName = "School";
3623     }
3624     else if (IsXMLToken(sName, XML_SERIES))
3625     {
3626         pName = "Series";
3627     }
3628     else if (IsXMLToken(sName, XML_TITLE))
3629     {
3630         pName = "Title";
3631     }
3632     else if (IsXMLToken(sName, XML_REPORT_TYPE))
3633     {
3634         pName = "Report_Type";
3635     }
3636     else if (IsXMLToken(sName, XML_VOLUME))
3637     {
3638         pName = "Volume";
3639     }
3640     else if (IsXMLToken(sName, XML_YEAR))
3641     {
3642         pName = "Year";
3643     }
3644     else if (IsXMLToken(sName, XML_URL))
3645     {
3646         pName = "URL";
3647     }
3648     else if (IsXMLToken(sName, XML_CUSTOM1))
3649     {
3650         pName = "Custom1";
3651     }
3652     else if (IsXMLToken(sName, XML_CUSTOM2))
3653     {
3654         pName = "Custom2";
3655     }
3656     else if (IsXMLToken(sName, XML_CUSTOM3))
3657     {
3658         pName = "Custom3";
3659     }
3660     else if (IsXMLToken(sName, XML_CUSTOM4))
3661     {
3662         pName = "Custom4";
3663     }
3664     else if (IsXMLToken(sName, XML_CUSTOM5))
3665     {
3666         pName = "Custom5";
3667     }
3668     else if (IsXMLToken(sName, XML_ISBN))
3669     {
3670         pName = "ISBN";
3671     }
3672     else
3673     {
3674         DBG_ERROR("Unknown bibliography info data");
3675         pName = NULL;
3676     }
3677
3678     return pName;
3679 }
3680
3681
3682 //
3683 // Annotation Field
3684 //
3685
3686 TYPEINIT1(XMLAnnotationImportContext, XMLTextFieldImportContext);
3687
3688 XMLAnnotationImportContext::XMLAnnotationImportContext(
3689     SvXMLImport& rImport,
3690     XMLTextImportHelper& rHlp,
3691     sal_uInt16 nPrfx,
3692     const OUString& sLocalName) :
3693         XMLTextFieldImportContext(rImport, rHlp, sAPI_annotation,
3694                                   nPrfx, sLocalName),
3695         sPropertyAuthor(RTL_CONSTASCII_USTRINGPARAM(sAPI_author)),
3696         sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content)),
3697         // why is there no UNO_NAME_DATE_TIME, but only UNO_NAME_DATE_TIME_VALUE?
3698         sPropertyDate(RTL_CONSTASCII_USTRINGPARAM(sAPI_date_time_value)),
3699         sPropertyTextRange(RTL_CONSTASCII_USTRINGPARAM(sAPI_TextRange))
3700 {
3701     bValid = sal_True;
3702
3703     // remember old list item and block (#91964#) and reset them
3704     // for the text frame
3705     // do this in the constructor, not in CreateChildContext (#i93392#)
3706     GetImport().GetTextImport()->PushListContext();
3707 }
3708
3709 void XMLAnnotationImportContext::ProcessAttribute(
3710     sal_uInt16,
3711     const OUString& )
3712 {
3713     // ignore
3714 }
3715
3716 SvXMLImportContext* XMLAnnotationImportContext::CreateChildContext(
3717     USHORT nPrefix,
3718     const OUString& rLocalName,
3719     const Reference<XAttributeList >& xAttrList )
3720 {
3721     SvXMLImportContext *pContext = 0;
3722     if( XML_NAMESPACE_DC == nPrefix )
3723     {
3724         if( IsXMLToken( rLocalName, XML_CREATOR ) )
3725             pContext = new XMLStringBufferImportContext(GetImport(), nPrefix,
3726                                             rLocalName, aAuthorBuffer);
3727         else if( IsXMLToken( rLocalName, XML_DATE ) )
3728             pContext = new XMLStringBufferImportContext(GetImport(), nPrefix,
3729                                             rLocalName, aDateBuffer);
3730     }
3731
3732     if( !pContext )
3733     {
3734         try
3735         {
3736             if ( !mxField.is() )
3737                 CreateField( mxField, sServicePrefix + GetServiceName() );
3738             Any aAny = mxField->getPropertyValue( sPropertyTextRange );
3739             Reference< XText > xText;
3740             aAny >>= xText;
3741             if( xText.is() )
3742             {
3743                 UniReference < XMLTextImportHelper > xTxtImport = GetImport().GetTextImport();
3744                 if( !mxCursor.is() )
3745                 {
3746                     mxOldCursor = xTxtImport->GetCursor();
3747                     mxCursor = xText->createTextCursor();
3748                 }
3749
3750                 if( mxCursor.is() )
3751                 {
3752                     xTxtImport->SetCursor( mxCursor );
3753                     pContext = xTxtImport->CreateTextChildContext( GetImport(), nPrefix, rLocalName, xAttrList );
3754                 }
3755             }
3756         }
3757         catch ( Exception& )
3758         {}
3759
3760         if( !pContext )
3761             pContext = new XMLStringBufferImportContext(GetImport(), nPrefix,  rLocalName, aTextBuffer);
3762     }
3763
3764     return pContext;
3765 }
3766
3767 void XMLAnnotationImportContext::EndElement()
3768 {
3769     DBG_ASSERT(GetServiceName().getLength()>0, "no service name for element!");
3770     if( mxCursor.is() )
3771     {
3772         // delete addition newline
3773         const OUString aEmpty;
3774         mxCursor->gotoEnd( sal_False );
3775         mxCursor->goLeft( 1, sal_True );
3776         mxCursor->setString( aEmpty );
3777
3778         // reset cursor
3779         GetImport().GetTextImport()->ResetCursor();
3780     }
3781
3782     if( mxOldCursor.is() )
3783         GetImport().GetTextImport()->SetCursor( mxOldCursor );
3784
3785     // reinstall old list item #91964#
3786     GetImport().GetTextImport()->PopListContext();
3787
3788     if ( bValid )
3789     {
3790         if ( mxField.is() || CreateField( mxField, sServicePrefix + GetServiceName() ) )
3791         {
3792             // set field properties
3793             PrepareField( mxField );
3794
3795             // attach field to document
3796             Reference < XTextContent > xTextContent( mxField, UNO_QUERY );
3797
3798             // workaround for #80606#
3799             try
3800             {
3801                 GetImportHelper().InsertTextContent( xTextContent );
3802             }
3803             catch (lang::IllegalArgumentException)
3804             {
3805                 // ignore
3806             }
3807         }
3808     }
3809     else
3810         GetImportHelper().InsertString(GetContent());
3811 }
3812
3813 void XMLAnnotationImportContext::PrepareField(
3814     const Reference<XPropertySet> & xPropertySet)
3815 {
3816     // import (possibly empty) author
3817     OUString sAuthor( aAuthorBuffer.makeStringAndClear() );
3818     xPropertySet->setPropertyValue(sPropertyAuthor, makeAny(sAuthor));
3819
3820     DateTime aDateTime;
3821     if (SvXMLUnitConverter::convertDateTime(aDateTime,
3822                                             aDateBuffer.makeStringAndClear()))
3823     {
3824         /*
3825         Date aDate;
3826         aDate.Year = aDateTime.Year;
3827         aDate.Month = aDateTime.Month;
3828         aDate.Day = aDateTime.Day;
3829         xPropertySet->setPropertyValue(sPropertyDate, makeAny(aDate));
3830         */
3831         xPropertySet->setPropertyValue(sPropertyDate, makeAny(aDateTime));
3832     }
3833
3834     OUString sBuffer = aTextBuffer.makeStringAndClear();
3835     if ( sBuffer.getLength() )
3836     {
3837         // delete last paragraph mark (if necessary)
3838         if (sal_Char(0x0a) == sBuffer.getStr()[sBuffer.getLength()-1])
3839             sBuffer = sBuffer.copy(0, sBuffer.getLength()-1);
3840         xPropertySet->setPropertyValue(sPropertyContent, makeAny(sBuffer));
3841     }
3842 }
3843
3844
3845
3846 //
3847 // script field
3848 //
3849
3850 TYPEINIT1(XMLScriptImportContext, XMLTextFieldImportContext);
3851
3852 XMLScriptImportContext::XMLScriptImportContext(
3853     SvXMLImport& rImport,
3854     XMLTextImportHelper& rHlp,
3855     sal_uInt16 nPrfx,
3856     const OUString& sLocalName)
3857 :       XMLTextFieldImportContext(rImport, rHlp, sAPI_script, nPrfx, sLocalName)
3858 ,       sPropertyScriptType(RTL_CONSTASCII_USTRINGPARAM(sAPI_script_type))
3859 ,       sPropertyURLContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_url_content))
3860 ,       sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content))
3861 ,       bContentOK(sal_False)
3862 ,       bScriptTypeOK(sal_False)
3863 ,       bUrlContent(sal_False)
3864 {
3865 }
3866
3867 void XMLScriptImportContext::ProcessAttribute(
3868     sal_uInt16 nAttrToken,
3869     const OUString& sAttrValue )
3870 {
3871     switch (nAttrToken)
3872     {
3873         case XML_TOK_TEXTFIELD_HREF:
3874             sContent = GetImport().GetAbsoluteReference( sAttrValue );
3875             bContentOK = sal_True;
3876             break;
3877
3878         case XML_TOK_TEXTFIELD_LANGUAGE:
3879             sScriptType = sAttrValue;
3880             bScriptTypeOK = sal_True;
3881             break;
3882
3883         default:
3884             // ignore
3885             break;
3886     }
3887
3888     // always valid (even without ScriptType; cf- #96531#)
3889     bValid = sal_True;
3890 }
3891
3892 void XMLScriptImportContext::PrepareField(
3893     const Reference<XPropertySet> & xPropertySet)
3894 {
3895     Any aAny;
3896
3897     // if href attribute was present, we use it. Else we use element content
3898     if (! bContentOK)
3899     {
3900         sContent = GetContent();
3901     }
3902     aAny <<= sContent;
3903     xPropertySet->setPropertyValue(sPropertyContent, aAny);
3904
3905     // URL or script text? We use URL if we have an href-attribute
3906     aAny.setValue(&bContentOK, ::getBooleanCppuType());
3907     xPropertySet->setPropertyValue(sPropertyURLContent, aAny);
3908
3909     aAny <<= sScriptType;
3910     xPropertySet->setPropertyValue(sPropertyScriptType, aAny);
3911 }
3912
3913 //
3914 // measure field
3915 //
3916
3917 TYPEINIT1(XMLMeasureFieldImportContext, XMLTextFieldImportContext);
3918
3919 XMLMeasureFieldImportContext::XMLMeasureFieldImportContext(
3920     SvXMLImport& rImport,
3921     XMLTextImportHelper& rHlp,
3922     sal_uInt16 nPrfx,
3923     const OUString& sLocalName) :
3924         XMLTextFieldImportContext(rImport, rHlp, sAPI_measure,
3925                                   nPrfx, sLocalName),
3926         mnKind( 0 )
3927 {
3928 }
3929
3930 void XMLMeasureFieldImportContext::ProcessAttribute(
3931     sal_uInt16 nAttrToken,
3932     const OUString& sAttrValue )
3933 {
3934     switch (nAttrToken)
3935     {
3936         case XML_TOK_TEXTFIELD_MEASURE_KIND:
3937             if( IsXMLToken( sAttrValue, XML_VALUE ) )
3938             {
3939                 mnKind = 0; bValid = sal_True;
3940             }
3941             else if( IsXMLToken( sAttrValue, XML_UNIT ) )
3942             {
3943                 mnKind = 1; bValid = sal_True;
3944             }
3945             else if( IsXMLToken( sAttrValue, XML_GAP ) )
3946             {
3947                 mnKind = 2; bValid = sal_True;
3948             }
3949             break;
3950     }
3951 }
3952
3953 void XMLMeasureFieldImportContext::PrepareField(
3954     const Reference<XPropertySet> & xPropertySet)
3955 {
3956     Any aAny;
3957     aAny <<= mnKind;
3958     xPropertySet->setPropertyValue(OUString::createFromAscii("Kind"), aAny);
3959 }
3960
3961
3962
3963 //
3964 // dropdown field
3965 //
3966
3967
3968 TYPEINIT1( XMLDropDownFieldImportContext, XMLTextFieldImportContext );
3969
3970 XMLDropDownFieldImportContext::XMLDropDownFieldImportContext(
3971         SvXMLImport& rImport,
3972         XMLTextImportHelper& rHlp,
3973         sal_uInt16 nPrfx,
3974         const ::rtl::OUString& sLocalName) :
3975     XMLTextFieldImportContext( rImport, rHlp, sAPI_drop_down,
3976                                nPrfx, sLocalName ),
3977     aLabels(),
3978     sName(),
3979     nSelected( -1 ),
3980     bNameOK( false ),
3981     bHelpOK(false),
3982     bHintOK(false),
3983     sPropertyItems( RTL_CONSTASCII_USTRINGPARAM( "Items" ) ),
3984     sPropertySelectedItem( RTL_CONSTASCII_USTRINGPARAM( "SelectedItem" ) ),
3985     sPropertyName( RTL_CONSTASCII_USTRINGPARAM( "Name" ) ),
3986     sPropertyHelp( RTL_CONSTASCII_USTRINGPARAM( "Help" ) ),
3987     sPropertyToolTip( RTL_CONSTASCII_USTRINGPARAM( "Tooltip" ) )
3988 {
3989     bValid = sal_True;
3990 }
3991
3992 bool lcl_ProcessLabel( const SvXMLImport& rImport,
3993                        const Reference<XAttributeList>& xAttrList,
3994                        OUString& rLabel,
3995                        bool& rIsSelected )
3996 {
3997     bool bValid = false;
3998     sal_Int16 nLength = xAttrList->getLength();
3999     for( sal_Int16 n = 0; n < nLength; n++ )
4000     {
4001         OUString sLocalName;
4002         sal_uInt16 nPrefix = rImport.GetNamespaceMap().
4003             GetKeyByAttrName( xAttrList->getNameByIndex(n), &sLocalName );
4004         OUString sValue = xAttrList->getValueByIndex(n);
4005
4006         if( nPrefix == XML_NAMESPACE_TEXT )
4007         {
4008             if( IsXMLToken( sLocalName, XML_VALUE ) )
4009             {
4010                 rLabel = sValue;
4011                 bValid = true;
4012             }
4013             else if( IsXMLToken( sLocalName, XML_CURRENT_SELECTED ) )
4014             {
4015                 sal_Bool bTmp;
4016                 if( SvXMLUnitConverter::convertBool( bTmp, sValue ) )
4017                     rIsSelected = bTmp;
4018             }
4019         }
4020     }
4021     return bValid;
4022 }
4023
4024 SvXMLImportContext* XMLDropDownFieldImportContext::CreateChildContext(
4025     USHORT nPrefix,
4026     const OUString& rLocalName,
4027     const Reference<XAttributeList>& xAttrList )
4028 {
4029     if( nPrefix == XML_NAMESPACE_TEXT  &&
4030         IsXMLToken( rLocalName, XML_LABEL ) )
4031     {
4032         OUString sLabel;
4033         bool bIsSelected = sal_False;
4034         if( lcl_ProcessLabel( GetImport(), xAttrList, sLabel, bIsSelected ) )
4035         {
4036             if( bIsSelected )
4037                 nSelected = static_cast<sal_Int32>( aLabels.size() );
4038             aLabels.push_back( sLabel );
4039         }
4040     }
4041     return new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
4042 }
4043
4044 void XMLDropDownFieldImportContext::ProcessAttribute(
4045     sal_uInt16 nAttrToken,
4046     const ::rtl::OUString& sAttrValue )
4047 {
4048     if( nAttrToken == XML_TOK_TEXTFIELD_NAME )
4049     {
4050         sName = sAttrValue;
4051         bNameOK = true;
4052     }
4053     else if (nAttrToken == XML_TOK_TEXTFIELD_HELP)
4054     {
4055         sHelp = sAttrValue;
4056         bHelpOK = true;
4057     }
4058     else if (nAttrToken == XML_TOK_TEXTFIELD_HINT)
4059     {
4060         sHint = sAttrValue;
4061         bHintOK = true;
4062     }
4063 }
4064
4065 void XMLDropDownFieldImportContext::PrepareField(
4066     const Reference<XPropertySet>& xPropertySet)
4067 {
4068     // create sequence
4069     sal_Int32 nLength = static_cast<sal_Int32>( aLabels.size() );
4070     Sequence<OUString> aSequence( nLength );
4071     OUString* pSequence = aSequence.getArray();
4072     for( sal_Int32 n = 0; n < nLength; n++ )
4073         pSequence[n] = aLabels[n];
4074
4075     // now set values:
4076     Any aAny;
4077
4078     aAny <<= aSequence;
4079     xPropertySet->setPropertyValue( sPropertyItems, aAny );
4080
4081     if( nSelected >= 0  &&  nSelected < nLength )
4082     {
4083         aAny <<= pSequence[nSelected];
4084         xPropertySet->setPropertyValue( sPropertySelectedItem, aAny );
4085     }
4086
4087     // set name
4088     if( bNameOK )
4089     {
4090         aAny <<= sName;
4091         xPropertySet->setPropertyValue( sPropertyName, aAny );
4092     }
4093     // set help
4094     if( bHelpOK )
4095     {
4096         aAny <<= sHelp;
4097         xPropertySet->setPropertyValue( sPropertyHelp, aAny );
4098     }
4099     // set hint
4100     if( bHintOK )
4101     {
4102         aAny <<= sHint;
4103         xPropertySet->setPropertyValue( sPropertyToolTip, aAny );
4104     }
4105
4106 }
4107
4108 /** import header fields (<draw:header>) */
4109 TYPEINIT1( XMLHeaderFieldImportContext, XMLTextFieldImportContext );
4110
4111 XMLHeaderFieldImportContext::XMLHeaderFieldImportContext(
4112         SvXMLImport& rImport,                                   /// XML Import
4113         XMLTextImportHelper& rHlp,                              /// Text import helper
4114         sal_uInt16 nPrfx,                                               /// namespace prefix
4115         const ::rtl::OUString& sLocalName)              /// element name w/o prefix
4116 : XMLTextFieldImportContext(rImport, rHlp, sAPI_header, nPrfx, sLocalName )
4117 {
4118     sServicePrefix = OUString::createFromAscii( sAPI_presentation_prefix );
4119     bValid = sal_True;
4120 }
4121
4122 /// process attribute values
4123 void XMLHeaderFieldImportContext::ProcessAttribute( sal_uInt16, const ::rtl::OUString& )
4124 {
4125 }
4126
4127 /// prepare XTextField for insertion into document
4128 void XMLHeaderFieldImportContext::PrepareField(const Reference<XPropertySet> &)
4129 {
4130 }
4131
4132 /** import footer fields (<draw:footer>) */
4133 TYPEINIT1( XMLFooterFieldImportContext, XMLTextFieldImportContext );
4134
4135 XMLFooterFieldImportContext::XMLFooterFieldImportContext(
4136         SvXMLImport& rImport,                                   /// XML Import
4137         XMLTextImportHelper& rHlp,                              /// Text import helper
4138         sal_uInt16 nPrfx,                                               /// namespace prefix
4139         const ::rtl::OUString& sLocalName)              /// element name w/o prefix
4140 : XMLTextFieldImportContext(rImport, rHlp, sAPI_footer, nPrfx, sLocalName )
4141 {
4142     sServicePrefix = OUString::createFromAscii( sAPI_presentation_prefix );
4143     bValid = sal_True;
4144 }
4145
4146 /// process attribute values
4147 void XMLFooterFieldImportContext::ProcessAttribute( sal_uInt16, const ::rtl::OUString& )
4148 {
4149 }
4150
4151 /// prepare XTextField for insertion into document
4152 void XMLFooterFieldImportContext::PrepareField(const Reference<XPropertySet> &)
4153 {
4154 }
4155
4156
4157 /** import footer fields (<draw:date-and-time>) */
4158 TYPEINIT1( XMLDateTimeFieldImportContext, XMLTextFieldImportContext );
4159
4160 XMLDateTimeFieldImportContext::XMLDateTimeFieldImportContext(
4161         SvXMLImport& rImport,                                   /// XML Import
4162         XMLTextImportHelper& rHlp,                              /// Text import helper
4163         sal_uInt16 nPrfx,                                               /// namespace prefix
4164         const ::rtl::OUString& sLocalName)              /// element name w/o prefix
4165 : XMLTextFieldImportContext(rImport, rHlp, sAPI_datetime, nPrfx, sLocalName )
4166 {
4167     sServicePrefix = OUString::createFromAscii( sAPI_presentation_prefix );
4168     bValid = sal_True;
4169 }
4170
4171 /// process attribute values
4172 void XMLDateTimeFieldImportContext::ProcessAttribute( sal_uInt16,
4173                                    const ::rtl::OUString& )
4174 {
4175 }
4176
4177 /// prepare XTextField for insertion into document
4178 void XMLDateTimeFieldImportContext::PrepareField(
4179         const ::com::sun::star::uno::Reference<
4180         ::com::sun::star::beans::XPropertySet> &)
4181 {
4182 }