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