xmloff/inc/txtfldi.hxx

   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 /** @#file
  21  *
  22  *  import of all text fields
  23  *  (except variable related + database display field: see txtvfldi.hxx)
  24  */
  25
  26 #pragma once
  27
  28 #include <com/sun/star/uno/Reference.h>
  29 #include <com/sun/star/beans/PropertyValue.hpp>
  30 #include <com/sun/star/text/PageNumberType.hpp>
  31 #include <com/sun/star/util/DateTime.hpp>
  32 #include <xmloff/xmlictxt.hxx>
  33 #include <xmloff/txtimp.hxx>
  34 #include <xmloff/xmltkmap.hxx>
  35 #include <rtl/ustrbuf.hxx>
  36 #include <vector>
  37 #include "txtfld.hxx"
  38
  39 namespace com::sun::star {
  40     namespace xml::sax { class XAttributeList; }
  41     namespace text { class XTextField; }
  42     namespace beans { class XPropertySet; struct PropertyValue; }
  43 }
  44
  45 class SvXMLImport;
  46 class XMLTextImportHelper;
  47 class SvXMLTokenMap;
  48
  49 /// abstract class for text field import
  50 class XMLTextFieldImportContext : public SvXMLImportContext
  51 {
  52     // data members
  53     OUStringBuffer sContentBuffer;   /// collect character data
  54     OUString sContent;               /// character data after collection
  55     OUString sServiceName;           /// service name for text field
  56     XMLTextImportHelper& rTextImportHelper; /// the import helper
  57
  58 protected:
  59     OUString sServicePrefix;
  60
  61     // data members for use in subclasses
  62     bool bValid;                 /// whether this field is valid ?
  63
  64 public:
  65
  66     XMLTextFieldImportContext(
  67         SvXMLImport& rImport,                   /// XML Import
  68         XMLTextImportHelper& rHlp,              /// Text import helper
  69         OUString aService);              /// name of SO API service
  70
  71     /// process character data: will be collected in member sContentBuffer
  72     virtual void SAL_CALL characters( const OUString& sContent ) override;
  73
  74     /// parses attributes and calls ProcessAttribute
  75     virtual void SAL_CALL startFastElement(
  76         sal_Int32 nElement,
  77         const css::uno::Reference<css::xml::sax::XFastAttributeList> & xAttrList) override;
  78
  79     /// create XTextField and insert into document; calls PrepareTextField
  80     virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
  81
  82     /// create the appropriate field context from
  83     /// (for use in paragraph import)
  84     static XMLTextFieldImportContext* CreateTextFieldImportContext(
  85         SvXMLImport& rImport,
  86         XMLTextImportHelper& rHlp,
  87         sal_Int32 nElement);
  88
  89 protected:
  90     /// get helper
  91     XMLTextImportHelper& GetImportHelper() { return rTextImportHelper; }
  92
  93     const OUString& GetServiceName() const { return sServiceName; }
  94     void SetServiceName(const OUString& sStr) { sServiceName = sStr; }
  95
  96     OUString const & GetContent();
  97
  98     /// process attribute values
  99     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 100                                    std::string_view sAttrValue ) = 0;
 101
 102     /// prepare XTextField for insertion into document
 103     virtual void PrepareField(
 104         const css::uno::Reference< css::beans::XPropertySet> & xPropertySet) = 0;
 105
 106     /// create field from ServiceName
 107     bool CreateField(css::uno::Reference< css::beans::XPropertySet> & xField,
 108                          const OUString& sServiceName);
 109
 110     /// force an update of the field's value
 111     /// call update on optional XUpdatable interface; (disable Fixed property)
 112     static void ForceUpdate(
 113         const css::uno::Reference< css::beans::XPropertySet> & rPropertySet);
 114 };
 115
 116 class XMLSenderFieldImportContext : public XMLTextFieldImportContext
 117 {
 118
 119     sal_Int16 nSubType;         /// API subtype for ExtUser field
 120
 121     const OUString sPropertyFixed;
 122     const OUString sPropertyContent;
 123
 124 protected:
 125     // variables for access in subclass
 126     bool bFixed;
 127
 128 public:
 129
 130     XMLSenderFieldImportContext(
 131         SvXMLImport& rImport,                   /// XML Import
 132         XMLTextImportHelper& rHlp);              /// Text import helper
 133
 134 protected:
 135     /// start element
 136     virtual void SAL_CALL startFastElement(
 137         sal_Int32 nElement,
 138         const css::uno::Reference<css::xml::sax::XFastAttributeList> & xAttrList) override;
 139
 140     /// process attribute values
 141     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 142                                    std::string_view sAttrValue ) override;
 143
 144     /// prepare XTextField for insertion into document
 145     virtual void PrepareField(
 146         const css::uno::Reference< css::beans::XPropertySet> & xPropertySet) override;
 147 };
 148
 149 /** inherit sender field because of fixed attribute in ProcessAttributes */
 150 class XMLAuthorFieldImportContext final : public XMLSenderFieldImportContext
 151 {
 152     bool bAuthorFullName;
 153     const OUString sPropertyFixed;
 154     const OUString sPropertyContent;
 155
 156 public:
 157
 158     XMLAuthorFieldImportContext(
 159         SvXMLImport& rImport,                   /// XML Import
 160         XMLTextImportHelper& rHlp);              /// Text import helper
 161
 162 private:
 163     /// start element
 164     virtual void SAL_CALL startFastElement(
 165         sal_Int32 nElement,
 166         const css::uno::Reference<css::xml::sax::XFastAttributeList> & xAttrList) override;
 167
 168     /// process attribute values
 169     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 170                                    std::string_view sAttrValue ) override;
 171
 172     /// prepare XTextField for insertion into document
 173     virtual void PrepareField(
 174         const css::uno::Reference< css::beans::XPropertySet> & xPropertySet) override;
 175 };
 176
 177 class XMLPlaceholderFieldImportContext final : public XMLTextFieldImportContext
 178 {
 179     const OUString sPropertyHint;
 180
 181     OUString sDescription;
 182
 183     sal_Int16 nPlaceholderType;
 184
 185 public:
 186
 187     XMLPlaceholderFieldImportContext(
 188         SvXMLImport& rImport,                   /// XML Import
 189         XMLTextImportHelper& rHlp);              /// Text import helper
 190
 191 private:
 192     /// process attribute values
 193     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 194                                    std::string_view sAttrValue ) override;
 195
 196     /// prepare XTextField for insertion into document
 197     virtual void PrepareField(
 198         const css::uno::Reference< css::beans::XPropertySet> & xPropertySet) override;
 199 };
 200
 201 class XMLTimeFieldImportContext : public XMLTextFieldImportContext
 202 {
 203 protected:
 204     const OUString sPropertyNumberFormat;
 205     const OUString sPropertyFixed;
 206     const OUString sPropertyDateTimeValue;
 207     const OUString sPropertyDateTime;
 208     const OUString sPropertyIsDate;
 209     const OUString sPropertyIsFixedLanguage;
 210
 211     css::util::DateTime aDateTimeValue;
 212     sal_Int32 nAdjust;
 213     sal_Int32 nFormatKey;
 214     bool bTimeOK;
 215     bool bFormatOK;
 216     bool bFixed;
 217     bool bIsDate;           // is this a date?
 218                                 // (for XMLDateFieldImportContext, really)
 219     bool     bIsDefaultLanguage;
 220
 221 public:
 222
 223     XMLTimeFieldImportContext(
 224         SvXMLImport& rImport,                   /// XML Import
 225         XMLTextImportHelper& rHlp);              /// Text import helper
 226
 227     /// process attribute values
 228     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 229                                    std::string_view sAttrValue ) override;
 230
 231     /// prepare XTextField for insertion into document
 232     virtual void PrepareField(
 233         const css::uno::Reference< css::beans::XPropertySet> & xPropertySet) override;
 234 };
 235
 236 /** import date fields (<text:date>);
 237     inherit from TimeField to reuse implementation */
 238 class XMLDateFieldImportContext final : public XMLTimeFieldImportContext
 239 {
 240 public:
 241
 242     XMLDateFieldImportContext(
 243         SvXMLImport& rImport,                   /// XML Import
 244         XMLTextImportHelper& rHlp);              /// Text import helper
 245
 246     /// process attribute values
 247     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 248                                    std::string_view sAttrValue ) override;
 249 };
 250
 251 /** import page continuation fields (<text:page-continuation-string>) */
 252 class XMLPageContinuationImportContext final : public XMLTextFieldImportContext
 253 {
 254     const OUString sPropertySubType;
 255     const OUString sPropertyNumberingType;
 256
 257     OUString sString;            /// continuation string
 258     css::text::PageNumberType eSelectPage;   /// previous, current
 259                                                         /// or next page
 260     bool sStringOK;                 /// continuation string encountered?
 261
 262 public:
 263
 264     XMLPageContinuationImportContext(
 265         SvXMLImport& rImport,                   /// XML Import
 266         XMLTextImportHelper& rHlp);              /// Text import helper
 267
 268     /// process attribute values
 269     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 270                                    std::string_view sAttrValue ) override;
 271
 272     /// prepare XTextField for insertion into document
 273     virtual void PrepareField(
 274         const css::uno::Reference< css::beans::XPropertySet> & xPropertySet) override;
 275 };
 276
 277 /** import page number fields (<text:page-number>) */
 278 class XMLPageNumberImportContext final : public XMLTextFieldImportContext
 279 {
 280     const OUString sPropertySubType;
 281     const OUString sPropertyNumberingType;
 282     const OUString sPropertyOffset;
 283
 284     OUString sNumberFormat;
 285     OUString sNumberSync;
 286     sal_Int16 nPageAdjust;
 287     css::text::PageNumberType eSelectPage;   /// previous, current
 288                                                         /// or next page
 289     bool sNumberFormatOK;
 290
 291 public:
 292
 293     XMLPageNumberImportContext(
 294         SvXMLImport& rImport,                   /// XML Import
 295         XMLTextImportHelper& rHlp);              /// Text import helper
 296
 297
 298     /// process attribute values
 299     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 300                                    std::string_view sAttrValue ) override;
 301
 302     /// prepare XTextField for insertion into document
 303     virtual void PrepareField(
 304         const css::uno::Reference< css::beans::XPropertySet> & xPropertySet) override;
 305 };
 306
 307 /** superclass for database fields: handle database and table names */
 308 class XMLDatabaseFieldImportContext : public XMLTextFieldImportContext
 309 {
 310     OUString m_sDatabaseName;
 311     OUString m_sDatabaseURL;
 312     OUString m_sTableName;
 313
 314     sal_Int32 m_nCommandType;
 315     bool m_bCommandTypeOK;
 316
 317     bool m_bDisplay;
 318     bool m_bDisplayOK;
 319     bool m_bUseDisplay;
 320
 321 protected:
 322     bool m_bDatabaseOK;
 323     bool m_bDatabaseNameOK;
 324     bool m_bDatabaseURLOK;
 325     bool m_bTableOK;
 326
 327     /// protected constructor: only for subclasses
 328     XMLDatabaseFieldImportContext(SvXMLImport& rImport,
 329                                   XMLTextImportHelper& rHlp,
 330                                   const OUString& pServiceName,
 331                                   bool bUseDisplay );
 332
 333 public:
 334
 335     /// process attribute values
 336     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 337                                    std::string_view sAttrValue ) override;
 338
 339     /// prepare XTextField for insertion into document
 340     virtual void PrepareField(
 341         const css::uno::Reference< css::beans::XPropertySet> & xPropertySet) override;
 342
 343     /// handle database-location children
 344     virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
 345         sal_Int32 nElement,
 346         const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
 347 };
 348
 349 /** import database name fields (<text:database-name>) */
 350 class XMLDatabaseNameImportContext final : public XMLDatabaseFieldImportContext
 351 {
 352 public:
 353
 354     XMLDatabaseNameImportContext(SvXMLImport& rImport,
 355                                  XMLTextImportHelper& rHlp);
 356
 357     /// process attribute values
 358     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 359                                    std::string_view sAttrValue ) override;
 360 };
 361
 362 /** import database next fields (<text:database-next>) */
 363 class XMLDatabaseNextImportContext : public XMLDatabaseFieldImportContext
 364 {
 365     const OUString sPropertyCondition;
 366     const OUString sTrue;
 367     OUString sCondition;
 368     bool bConditionOK;
 369
 370 protected:
 371     // for use in child classes
 372     XMLDatabaseNextImportContext(SvXMLImport& rImport,
 373                                  XMLTextImportHelper& rHlp,
 374                                  const OUString& pServiceName);
 375
 376 public:
 377
 378     XMLDatabaseNextImportContext(SvXMLImport& rImport,
 379                                  XMLTextImportHelper& rHlp);
 380
 381     /// process attribute values
 382     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 383                                    std::string_view sAttrValue ) override;
 384
 385     /// prepare XTextField for insertion into document
 386     virtual void PrepareField(
 387         const css::uno::Reference< css::beans::XPropertySet> & xPropertySet) override;
 388 };
 389
 390 /** import database select fields (<text:database-select>) */
 391 class XMLDatabaseSelectImportContext final : public XMLDatabaseNextImportContext
 392 {
 393     const OUString sPropertySetNumber;
 394     sal_Int32 nNumber;
 395     bool bNumberOK;
 396
 397 public:
 398
 399     XMLDatabaseSelectImportContext(SvXMLImport& rImport,
 400                                    XMLTextImportHelper& rHlp);
 401
 402     /// process attribute values
 403     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 404                                    std::string_view sAttrValue ) override;
 405
 406     /// prepare XTextField for insertion into document
 407     virtual void PrepareField(
 408         const css::uno::Reference<
 409         css::beans::XPropertySet> & xPropertySet) override;
 410 };
 411
 412 /** import database display number fields (<text:database-row-number>) */
 413 class XMLDatabaseNumberImportContext final : public XMLDatabaseFieldImportContext
 414 {
 415     const OUString sPropertyNumberingType;
 416     const OUString sPropertySetNumber;
 417     OUString sNumberFormat;
 418     OUString sNumberSync;
 419     sal_Int32 nValue;
 420     bool bValueOK;
 421
 422 public:
 423
 424     XMLDatabaseNumberImportContext(SvXMLImport& rImport,
 425                                    XMLTextImportHelper& rHlp);
 426
 427     /// process attribute values
 428     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 429                                    std::string_view sAttrValue ) override;
 430
 431     /// prepare XTextField for insertion into document
 432     virtual void PrepareField(
 433         const css::uno::Reference< css::beans::XPropertySet> & xPropertySet) override;
 434 };
 435
 436 /** import docinfo fields with only fixed attribute */
 437 class XMLSimpleDocInfoImportContext : public XMLTextFieldImportContext
 438 {
 439     const OUString sPropertyFixed;
 440     const OUString sPropertyContent;
 441     const OUString sPropertyAuthor;
 442     const OUString sPropertyCurrentPresentation;
 443
 444 protected:
 445     bool bFixed;
 446     bool bHasAuthor;
 447     bool bHasContent;
 448
 449 public:
 450
 451     XMLSimpleDocInfoImportContext(SvXMLImport& rImport,
 452                                   XMLTextImportHelper& rHlp,
 453                                   sal_Int32 nElementToken,
 454                                   bool bContent,
 455                                   bool bAuthor);
 456
 457 protected:
 458     /// process attribute values
 459     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 460                                    std::string_view sAttrValue ) override;
 461
 462     /// prepare XTextField for insertion into document
 463     virtual void PrepareField(
 464         const css::uno::Reference< css::beans::XPropertySet> & xPropertySet) override;
 465
 466     static OUString MapTokenToServiceName(sal_Int32 nElementToken);
 467 };
 468
 469 /** import docinfo fields with date or time attributes and numberformats */
 470 class XMLDateTimeDocInfoImportContext final : public XMLSimpleDocInfoImportContext
 471 {
 472     const OUString sPropertyNumberFormat;
 473     const OUString sPropertyIsDate;
 474     const OUString sPropertyIsFixedLanguage;
 475
 476     sal_Int32 nFormat;
 477     bool bFormatOK;
 478     bool bIsDate;
 479     bool bHasDateTime;
 480     bool     bIsDefaultLanguage;
 481
 482 public:
 483
 484     XMLDateTimeDocInfoImportContext(SvXMLImport& rImport,
 485                                     XMLTextImportHelper& rHlp,
 486                                     sal_Int32 nElement);
 487
 488 private:
 489     /// process attribute values
 490     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 491                                    std::string_view sAttrValue ) override;
 492
 493     /// prepare XTextField for insertion into document
 494     virtual void PrepareField(
 495         const css::uno::Reference< css::beans::XPropertySet> & xPropertySet) override;
 496 };
 497
 498 /** import revision field (<text:editing-cycles>) */
 499 class XMLRevisionDocInfoImportContext final : public XMLSimpleDocInfoImportContext
 500 {
 501 public:
 502
 503     XMLRevisionDocInfoImportContext(SvXMLImport& rImport,
 504                                     XMLTextImportHelper& rHlp,
 505                                     sal_Int32 nElement);
 506
 507 private:
 508     /// prepare XTextField for insertion into document
 509     virtual void PrepareField(
 510         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
 511 };
 512
 513 /** import user docinfo field (<text:user-defined>) */
 514 class XMLUserDocInfoImportContext final : public XMLSimpleDocInfoImportContext
 515 {
 516     OUString aName;
 517     const OUString sPropertyName;
 518     const OUString sPropertyNumberFormat;
 519     const OUString sPropertyIsFixedLanguage;
 520     sal_Int32   nFormat;
 521     bool    bFormatOK;
 522     bool        bIsDefaultLanguage;
 523
 524 public:
 525
 526     XMLUserDocInfoImportContext(SvXMLImport& rImport,
 527                                 XMLTextImportHelper& rHlp,
 528                                 sal_Int32 nElement);
 529
 530 private:
 531     /// process attribute values
 532     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 533                                    std::string_view sAttrValue ) override;
 534     virtual void PrepareField(
 535         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
 536 };
 537
 538 /** import hidden paragraph fields (<text:hidden-paragraph>) */
 539 class XMLHiddenParagraphImportContext final : public XMLTextFieldImportContext
 540 {
 541     const OUString sPropertyCondition;
 542     const OUString sPropertyIsHidden;
 543
 544     OUString sCondition;
 545     bool bIsHidden;
 546
 547 public:
 548
 549     XMLHiddenParagraphImportContext(SvXMLImport& rImport,
 550                                     XMLTextImportHelper& rHlp);
 551
 552 private:
 553     /// process attribute values
 554     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 555                                    std::string_view sAttrValue ) override;
 556
 557     /// prepare XTextField for insertion into document
 558     virtual void PrepareField(
 559         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
 560 };
 561
 562 /** import conditional text fields (<text:conditional-text>) */
 563 class XMLConditionalTextImportContext final : public XMLTextFieldImportContext
 564 {
 565     const OUString sPropertyCondition;
 566     const OUString sPropertyCurrentPresentation;
 567
 568     OUString sCondition;
 569     OUString sTrueContent;
 570     OUString sFalseContent;
 571
 572     bool bConditionOK;
 573     bool bTrueOK;
 574     bool bFalseOK;
 575     bool bCurrentValue;
 576
 577 public:
 578
 579     XMLConditionalTextImportContext(SvXMLImport& rImport,
 580                                     XMLTextImportHelper& rHlp);
 581
 582 private:
 583     /// process attribute values
 584     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 585                                    std::string_view sAttrValue ) override;
 586
 587     /// prepare XTextField for insertion into document
 588     virtual void PrepareField(
 589         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
 590 };
 591
 592 /** import conditional text fields (<text:hidden-text>) */
 593 class XMLHiddenTextImportContext final : public XMLTextFieldImportContext
 594 {
 595     const OUString sPropertyCondition;
 596     const OUString sPropertyContent;
 597     const OUString sPropertyIsHidden;
 598
 599     OUString sCondition;
 600     OUString sString;
 601
 602     bool bConditionOK;
 603     bool bStringOK;
 604     bool bIsHidden;
 605
 606 public:
 607
 608     XMLHiddenTextImportContext(SvXMLImport& rImport,
 609                                XMLTextImportHelper& rHlp);
 610
 611 private:
 612     /// process attribute values
 613     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 614                                    std::string_view sAttrValue ) override;
 615
 616     /// prepare XTextField for insertion into document
 617     virtual void PrepareField(
 618         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
 619 };
 620
 621 /** import file name fields (<text:file-name>) */
 622 class XMLFileNameImportContext final : public XMLTextFieldImportContext
 623 {
 624     const OUString sPropertyFixed;
 625     const OUString sPropertyFileFormat;
 626     const OUString sPropertyCurrentPresentation;
 627
 628     sal_Int16 nFormat;
 629     bool bFixed;
 630
 631 public:
 632
 633     XMLFileNameImportContext(SvXMLImport& rImport,
 634                              XMLTextImportHelper& rHlp);
 635
 636 private:
 637     /// process attribute values
 638     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 639                                    std::string_view sAttrValue ) override;
 640
 641     /// prepare XTextField for insertion into document
 642     virtual void PrepareField(
 643         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
 644 };
 645
 646 /** import document template name fields (<text:template-name>) */
 647 class XMLTemplateNameImportContext final : public XMLTextFieldImportContext
 648 {
 649     const OUString sPropertyFileFormat;
 650
 651     sal_Int16 nFormat;
 652
 653 public:
 654
 655     XMLTemplateNameImportContext(SvXMLImport& rImport,
 656                                  XMLTextImportHelper& rHlp);
 657
 658 private:
 659     /// process attribute values
 660     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 661                                    std::string_view sAttrValue ) override;
 662
 663     /// prepare XTextField for insertion into document
 664     virtual void PrepareField(
 665         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
 666 };
 667
 668 /** import chapter fields (<text:chapter>) */
 669 class XMLChapterImportContext final : public XMLTextFieldImportContext
 670 {
 671     sal_Int16 nFormat;
 672     sal_Int8 nLevel;
 673
 674 public:
 675
 676     XMLChapterImportContext(SvXMLImport& rImport,
 677                             XMLTextImportHelper& rHlp);
 678
 679 private:
 680     /// process attribute values
 681     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 682                                    std::string_view sAttrValue ) override;
 683
 684     /// prepare XTextField for insertion into document
 685     virtual void PrepareField(
 686         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
 687 };
 688
 689 /** import count fields (<text:[XXX]-count>) */
 690 class XMLCountFieldImportContext final : public XMLTextFieldImportContext
 691 {
 692     const OUString sPropertyNumberingType;
 693
 694     OUString sNumberFormat;
 695     OUString sLetterSync;
 696
 697     bool bNumberFormatOK;
 698
 699 public:
 700
 701     XMLCountFieldImportContext(SvXMLImport& rImport,
 702                                XMLTextImportHelper& rHlp,
 703                                sal_Int32 nElement);
 704
 705 private:
 706     /// process attribute values
 707     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 708                                    std::string_view sAttrValue ) override;
 709
 710     /// prepare XTextField for insertion into document
 711     virtual void PrepareField(
 712         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
 713
 714     static OUString MapTokenToServiceName(sal_Int32 nElement);
 715 };
 716
 717 /** import page variable fields (<text:get-page-variable>) */
 718 class XMLPageVarGetFieldImportContext final : public XMLTextFieldImportContext
 719 {
 720     OUString sNumberFormat;
 721     OUString sLetterSync;
 722
 723     bool bNumberFormatOK;
 724
 725 public:
 726
 727     XMLPageVarGetFieldImportContext(SvXMLImport& rImport,
 728                                     XMLTextImportHelper& rHlp);
 729
 730 private:
 731     /// process attribute values
 732     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 733                                    std::string_view sAttrValue ) override;
 734
 735     /// prepare XTextField for insertion into document
 736     virtual void PrepareField(
 737         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
 738 };
 739
 740 /** import page variable fields (<text:get-page-variable>) */
 741 class XMLPageVarSetFieldImportContext final : public XMLTextFieldImportContext
 742 {
 743     sal_Int16 nAdjust;
 744     bool bActive;
 745
 746 public:
 747
 748     XMLPageVarSetFieldImportContext(SvXMLImport& rImport,
 749                                     XMLTextImportHelper& rHlp);
 750
 751 private:
 752     /// process attribute values
 753     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 754                                    std::string_view sAttrValue ) override;
 755
 756     /// prepare XTextField for insertion into document
 757     virtual void PrepareField(
 758         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
 759 };
 760
 761 /** import macro fields (<text:execute-macro>) */
 762 class XMLMacroFieldImportContext final : public XMLTextFieldImportContext
 763 {
 764     OUString sDescription;
 765     rtl::Reference<XMLEventsImportContext> xEventContext;
 766
 767     OUString sMacro; // macro for old documents (pre 638i)
 768
 769     bool bDescriptionOK;
 770
 771 public:
 772
 773     XMLMacroFieldImportContext(SvXMLImport& rImport,
 774                                XMLTextImportHelper& rHlp);
 775
 776 private:
 777     /// for <office:events> children
 778     virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
 779         sal_Int32 nElement,
 780         const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
 781
 782     /// process attribute values
 783     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 784                                    std::string_view sAttrValue ) override;
 785
 786     /// prepare XTextField for insertion into document
 787     virtual void PrepareField(
 788         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
 789 };
 790
 791 /** import reference fields (<text:reference-get>) */
 792 class XMLReferenceFieldImportContext final : public XMLTextFieldImportContext
 793 {
 794     OUString sName;
 795     OUString sLanguage;
 796     sal_Int32 nElementToken;
 797     sal_Int16 nSource;
 798     sal_Int16 nType;
 799     sal_uInt16 nFlags;
 800
 801     bool bNameOK;
 802     bool bTypeOK;
 803
 804 public:
 805
 806     XMLReferenceFieldImportContext(SvXMLImport& rImport,
 807                                    XMLTextImportHelper& rHlp,
 808                                    sal_Int32 nToken);
 809
 810 private:
 811     /// start element
 812     virtual void SAL_CALL startFastElement(
 813         sal_Int32 nElement,
 814         const css::uno::Reference<css::xml::sax::XFastAttributeList> & xAttrList) override;
 815
 816     /// process attribute values
 817     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 818                                    std::string_view sAttrValue ) override;
 819
 820     /// prepare XTextField for insertion into document
 821     virtual void PrepareField(
 822         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
 823 };
 824
 825 /** import dde field declaration container (<text:dde-connection-decls>) */
 826 class XMLDdeFieldDeclsImportContext final : public SvXMLImportContext
 827 {
 828 public:
 829
 830     XMLDdeFieldDeclsImportContext(SvXMLImport& rImport);
 831
 832     virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
 833         sal_Int32 nElement,
 834         const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
 835 };
 836
 837 /** import dde field declaration (<text:dde-connection-decl>) */
 838 class XMLDdeFieldDeclImportContext final : public SvXMLImportContext
 839 {
 840 public:
 841
 842     XMLDdeFieldDeclImportContext(SvXMLImport& rImport);
 843
 844     // create fieldmaster
 845     virtual void SAL_CALL startFastElement(
 846         sal_Int32 nElement,
 847         const css::uno::Reference<css::xml::sax::XFastAttributeList> & xAttrList) override;
 848 };
 849
 850 /** import dde fields (<text:dde-connection>) */
 851 class XMLDdeFieldImportContext final : public XMLTextFieldImportContext
 852 {
 853     OUString sName;
 854     OUString sPropertyContent;
 855
 856 public:
 857
 858     XMLDdeFieldImportContext(SvXMLImport& rImport,
 859                              XMLTextImportHelper& rHlp);
 860
 861 private:
 862     /// process attribute values
 863     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 864                                    std::string_view sAttrValue ) override;
 865
 866     /// create textfield, attach master, and insert into document
 867     virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
 868
 869     /// empty method
 870     virtual void PrepareField(
 871         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
 872 };
 873
 874 /** import sheet name fields (Calc) dde fields (<text:sheet-name>) */
 875 class XMLSheetNameImportContext final : public XMLTextFieldImportContext
 876 {
 877
 878 public:
 879
 880     XMLSheetNameImportContext(SvXMLImport& rImport,
 881                               XMLTextImportHelper& rHlp);
 882
 883 private:
 884     /// no attributes -> empty method
 885     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 886                                    std::string_view sAttrValue ) override;
 887
 888     /// no attributes -> empty method
 889     virtual void PrepareField(
 890         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
 891 };
 892
 893 /** import page|slide name fields (<text:page-name>) */
 894 class XMLPageNameFieldImportContext final : public XMLTextFieldImportContext
 895 {
 896 public:
 897
 898     XMLPageNameFieldImportContext(
 899         SvXMLImport& rImport,                   /// XML Import
 900         XMLTextImportHelper& rHlp);              /// Text import helper
 901
 902     /// process attribute values
 903     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 904                                    std::string_view sAttrValue ) override;
 905
 906     /// prepare XTextField for insertion into document
 907     virtual void PrepareField(
 908         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
 909 };
 910
 911 /** import hyperlinks as URL fields (Calc, Impress, Draw) (<office:a>) */
 912 class XMLUrlFieldImportContext final : public XMLTextFieldImportContext
 913 {
 914     OUString sURL;
 915     OUString sFrame;
 916     bool bFrameOK;
 917
 918 public:
 919
 920     XMLUrlFieldImportContext(SvXMLImport& rImport,
 921                              XMLTextImportHelper& rHlp);
 922
 923 private:
 924     /// no attributes -> empty method
 925     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 926                                    std::string_view sAttrValue ) override;
 927
 928     /// no attributes -> empty method
 929     virtual void PrepareField(
 930         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
 931 };
 932
 933 /** import bibliography info fields (<text:bibliography-mark>) */
 934 class XMLBibliographyFieldImportContext final : public XMLTextFieldImportContext
 935 {
 936     ::std::vector< css::beans::PropertyValue> aValues;
 937
 938 public:
 939
 940     XMLBibliographyFieldImportContext(SvXMLImport& rImport,
 941                                       XMLTextImportHelper& rHlp);
 942
 943 private:
 944     /// process attributes (fill aValues)
 945     virtual void SAL_CALL startFastElement(
 946         sal_Int32 nElement,
 947         const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList) override;
 948
 949     /// empty method; all attributes are handled in StartElement
 950     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 951                                    std::string_view sAttrValue ) override;
 952
 953     /// convert aValues into sequence and set property
 954     virtual void PrepareField(
 955         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
 956
 957     static const char* MapBibliographyFieldName(sal_Int32 nElement);
 958 };
 959
 960 /** Import an annotation field (<text:annotation>) */
 961 class XMLAnnotationImportContext final : public XMLTextFieldImportContext
 962 {
 963     OUStringBuffer aAuthorBuffer;
 964     OUStringBuffer aInitialsBuffer;
 965     OUString aName;
 966     OUString aParentName;
 967     OUStringBuffer aTextBuffer;
 968     OUStringBuffer aDateBuffer;
 969     OUString aResolved;
 970
 971     css::uno::Reference < css::beans::XPropertySet > mxField;
 972     css::uno::Reference < css::text::XTextCursor >  mxCursor;
 973     css::uno::Reference < css::text::XTextCursor >  mxOldCursor;
 974
 975     sal_Int32 mnElement;
 976
 977 public:
 978
 979     XMLAnnotationImportContext(SvXMLImport& rImport,
 980                                XMLTextImportHelper& rHlp,
 981                                sal_Int32 nElement);
 982
 983 private:
 984     /// process attributes
 985     virtual void ProcessAttribute( sal_Int32 nAttrToken,
 986                                    std::string_view sAttrValue ) override;
 987
 988     /// set properties
 989     virtual void PrepareField(
 990         const css::uno::Reference< css::beans::XPropertySet > & xPropertySet) override;
 991
 992     virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
 993         sal_Int32 nElement,
 994         const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
 995     virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
 996 };
 997
 998 /** Import a script field (<text:script>) */
 999 class XMLScriptImportContext final : public XMLTextFieldImportContext
1000 {
1001     OUString sContent;
1002     OUString sScriptType;
1003
1004     bool bContentOK;
1005
1006 public:
1007
1008     XMLScriptImportContext(SvXMLImport& rImport,
1009                            XMLTextImportHelper& rHlp);
1010
1011 private:
1012     /// process attributes
1013     virtual void ProcessAttribute( sal_Int32 nAttrToken,
1014                                    std::string_view sAttrValue ) override;
1015
1016     /// set properties
1017     virtual void PrepareField(
1018         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
1019 };
1020
1021 /** import measure fields (<text:measure>) */
1022 class XMLMeasureFieldImportContext final : public XMLTextFieldImportContext
1023 {
1024     sal_Int16 mnKind;
1025
1026 public:
1027
1028     XMLMeasureFieldImportContext(SvXMLImport& rImport,
1029                                     XMLTextImportHelper& rHlp);
1030
1031 private:
1032     /// process attribute values
1033     virtual void ProcessAttribute( sal_Int32 nAttrToken,
1034                                    std::string_view sAttrValue ) override;
1035
1036     /// prepare XTextField for insertion into document
1037     virtual void PrepareField(
1038         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
1039 };
1040
1041 /** dropdown field (filter legacy) */
1042 class XMLDropDownFieldImportContext final : public XMLTextFieldImportContext
1043 {
1044     std::vector<OUString> aLabels;
1045     OUString sName;
1046     OUString sHelp;
1047     OUString sHint;
1048     sal_Int32 nSelected;
1049     bool bNameOK;
1050     bool bHelpOK;
1051     bool bHintOK;
1052
1053 public:
1054
1055     XMLDropDownFieldImportContext(SvXMLImport& rImport,
1056                                     XMLTextImportHelper& rHlp);
1057
1058     virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
1059         sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
1060
1061 private:
1062     /// process attribute values
1063     virtual void ProcessAttribute( sal_Int32 nAttrToken,
1064                                    std::string_view sAttrValue ) override;
1065
1066     /// prepare XTextField for insertion into document
1067     virtual void PrepareField(
1068         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
1069 };
1070
1071 /** import header fields (<draw:header>) */
1072 class XMLHeaderFieldImportContext final : public XMLTextFieldImportContext
1073 {
1074 public:
1075
1076     XMLHeaderFieldImportContext(
1077         SvXMLImport& rImport,                   /// XML Import
1078         XMLTextImportHelper& rHlp);              /// Text import helper
1079
1080     /// process attribute values
1081     virtual void ProcessAttribute( sal_Int32 nAttrToken,
1082                                    std::string_view sAttrValue ) override;
1083
1084     /// prepare XTextField for insertion into document
1085     virtual void PrepareField(
1086         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
1087 };
1088
1089 /** import footer fields (<draw:footer>) */
1090 class XMLFooterFieldImportContext final : public XMLTextFieldImportContext
1091 {
1092 public:
1093
1094     XMLFooterFieldImportContext(
1095         SvXMLImport& rImport,                   /// XML Import
1096         XMLTextImportHelper& rHlp);              /// Text import helper
1097
1098     /// process attribute values
1099     virtual void ProcessAttribute( sal_Int32 nAttrToken,
1100                                    std::string_view sAttrValue ) override;
1101
1102     /// prepare XTextField for insertion into document
1103     virtual void PrepareField(
1104         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
1105 };
1106
1107 /** import footer fields (<draw:date-and-time>) */
1108 class XMLDateTimeFieldImportContext final : public XMLTextFieldImportContext
1109 {
1110 public:
1111
1112     XMLDateTimeFieldImportContext(
1113         SvXMLImport& rImport,                   /// XML Import
1114         XMLTextImportHelper& rHlp);              /// Text import helper
1115
1116     /// process attribute values
1117     virtual void ProcessAttribute( sal_Int32 nAttrToken,
1118                                    std::string_view sAttrValue ) override;
1119
1120     /// prepare XTextField for insertion into document
1121     virtual void PrepareField(
1122         const css::uno::Reference<css::beans::XPropertySet> & xPropertySet) override;
1123 };
1124
1125 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */