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