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