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