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