xmloff/source/text/txtvfldi.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 /** @#file
  22  *
  23  *  export of all variable related text fields (and database display field)
  24  */
  25 #include <txtvfldi.hxx>
  26 #include <xmloff/xmltoken.hxx>
  27 #include <xmloff/txtimp.hxx>
  28 #include <xmloff/xmlnamespace.hxx>
  29 #include <xmloff/namespacemap.hxx>
  30 #include <xmloff/i18nmap.hxx>
  31 #include <xmloff/xmlimp.hxx>
  32 #include <xmloff/xmluconv.hxx>
  33 #include <xmloff/xmlement.hxx>
  34 #include <com/sun/star/frame/XModel.hpp>
  35 #include <com/sun/star/text/SetVariableType.hpp>
  36 #include <com/sun/star/text/XDependentTextField.hpp>
  37 #include <com/sun/star/text/XTextFieldsSupplier.hpp>
  38 #include <com/sun/star/beans/XPropertySet.hpp>
  39 #include <com/sun/star/beans/XPropertySetInfo.hpp>
  40 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  41 #include <com/sun/star/xml/sax/XAttributeList.hpp>
  42 #include <com/sun/star/style/NumberingType.hpp>
  43 #include <com/sun/star/container/XIndexReplace.hpp>
  44
  45 #include <sax/tools/converter.hxx>
  46
  47 #include <rtl/ustring.hxx>
  48 #include <osl/diagnose.h>
  49 #include <sal/log.hxx>
  50
  51 #include <tools/debug.hxx>
  52 #include <tools/diagnose_ex.h>
  53
  54
  55 // service names
  56 constexpr char16_t sAPI_fieldmaster_prefix[] = u"com.sun.star.text.FieldMaster.";
  57 const char sAPI_get_expression[]     = "GetExpression";
  58 const char sAPI_set_expression[]     = "SetExpression";
  59 const char sAPI_user[]               = "User";
  60 const char sAPI_database[]           = "com.sun.star.text.TextField.Database";
  61
  62 // property names
  63 const char sAPI_content[]            = "Content";
  64 const char sAPI_sub_type[]           = "SubType";
  65 const char sAPI_number_format[]      = "NumberFormat";
  66 const char sAPI_is_visible[]         = "IsVisible";
  67 const char sAPI_current_presentation[]   = "CurrentPresentation";
  68
  69
  70 using namespace ::com::sun::star;
  71 using namespace ::com::sun::star::uno;
  72 using namespace ::com::sun::star::beans;
  73 using namespace ::com::sun::star::text;
  74 using namespace ::com::sun::star::style;
  75 using namespace ::xmloff::token;
  76
  77
  78 // XMLVarFieldImportContext: superclass for all variable related fields
  79
  80
  81 XMLVarFieldImportContext::XMLVarFieldImportContext(
  82     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
  83     const char* pServiceName, sal_uInt16 nPrfx,
  84     const OUString& rLocalName,
  85     bool bFormula, bool bFormulaDefault,
  86     bool bDescription, bool bHelp, bool bHint, bool bVisible,
  87     bool bIsDisplayFormula,
  88     bool bType, bool bStyle, bool bValue,
  89     bool bPresentation) :
  90         XMLTextFieldImportContext(rImport, rHlp, pServiceName, nPrfx, rLocalName),
  91         aValueHelper(rImport, rHlp, bType, bStyle, bValue, false),
  92         bDisplayFormula(false),
  93         bDisplayNone(false),
  94         bFormulaOK(false),
  95         bDescriptionOK(false),
  96         bHelpOK(false),
  97         bHintOK(false),
  98         bDisplayOK(false),
  99         bSetFormula(bFormula),
 100         bSetFormulaDefault(bFormulaDefault),
 101         bSetDescription(bDescription),
 102         bSetHelp(bHelp),
 103         bSetHint(bHint),
 104         bSetVisible(bVisible),
 105         bSetDisplayFormula(bIsDisplayFormula),
 106         bSetPresentation(bPresentation)
 107 {
 108 }
 109
 110 void XMLVarFieldImportContext::ProcessAttribute(
 111     sal_Int32 nAttrToken,
 112     const OUString& sAttrValue )
 113 {
 114     switch (nAttrToken)
 115         {
 116         case XML_ELEMENT(TEXT, XML_NAME):
 117             sName = sAttrValue;
 118             bValid = true;      // we assume: field with name is valid!
 119             break;
 120         case XML_ELEMENT(TEXT, XML_DESCRIPTION):
 121             sDescription = sAttrValue;
 122             bDescriptionOK = true;
 123             break;
 124         case XML_ELEMENT(TEXT, XML_HELP):
 125             sHelp = sAttrValue;
 126             bHelpOK = true;
 127             break;
 128         case XML_ELEMENT(TEXT, XML_HINT):
 129             sHint = sAttrValue;
 130             bHintOK = true;
 131             break;
 132         case XML_ELEMENT(TEXT, XML_FORMULA):
 133             {
 134                 OUString sTmp;
 135                 sal_uInt16 nPrefix = GetImport().GetNamespaceMap().
 136                         GetKeyByAttrValueQName(sAttrValue, &sTmp);
 137                 if( XML_NAMESPACE_OOOW == nPrefix )
 138                 {
 139                     sFormula = sTmp;
 140                     bFormulaOK = true;
 141                 }
 142                 else
 143                     sFormula = sAttrValue;
 144             }
 145             break;
 146         case XML_ELEMENT(TEXT, XML_DISPLAY):
 147             if (IsXMLToken(sAttrValue, XML_FORMULA))
 148             {
 149                 bDisplayFormula = true;
 150                 bDisplayNone = false;
 151                 bDisplayOK = true;
 152             }
 153             else if (IsXMLToken(sAttrValue, XML_VALUE))
 154             {
 155                 bDisplayFormula = false;
 156                 bDisplayNone = false;
 157                 bDisplayOK = true;
 158             }
 159             else if (IsXMLToken(sAttrValue, XML_NONE))
 160             {
 161                 bDisplayFormula = false;
 162                 bDisplayNone = true;
 163                 bDisplayOK = true;
 164             } // else: no change
 165             DBG_ASSERT(!(bDisplayFormula && bDisplayNone),
 166                        "illegal display values");
 167             break;
 168         default:
 169             // delegate all others to value helper
 170             aValueHelper.ProcessAttribute(nAttrToken, sAttrValue);
 171             break;
 172         }
 173 }
 174
 175 void XMLVarFieldImportContext::PrepareField(
 176     const Reference<XPropertySet> & xPropertySet)
 177 {
 178     // bSetName: not implemented
 179
 180     if (bSetFormula)
 181     {
 182         if (!bFormulaOK && bSetFormulaDefault)
 183         {
 184             sFormula = GetContent();
 185             bFormulaOK = true;
 186         }
 187
 188         if (bFormulaOK)
 189         {
 190             xPropertySet->setPropertyValue(sAPI_content, Any(sFormula));
 191         }
 192     }
 193
 194     if (bSetDescription && bDescriptionOK)
 195     {
 196         xPropertySet->setPropertyValue("Hint", Any(sDescription));
 197     }
 198
 199     if (bSetHelp && bHelpOK)
 200     {
 201         xPropertySet->setPropertyValue("Help", Any(sHelp));
 202     }
 203
 204     if (bSetHint && bHintOK)
 205     {
 206         xPropertySet->setPropertyValue("Tooltip", Any(sHint));
 207     }
 208
 209     if (bSetVisible && bDisplayOK)
 210     {
 211         bool bTmp = !bDisplayNone;
 212         xPropertySet->setPropertyValue(sAPI_is_visible, Any(bTmp));
 213     }
 214
 215     // workaround for #no-bug#: display formula by default
 216     if (xPropertySet->getPropertySetInfo()->
 217                 hasPropertyByName("IsShowFormula") &&
 218         !bSetDisplayFormula)
 219     {
 220         bDisplayFormula = false;
 221         bSetDisplayFormula = true;
 222     }
 223
 224
 225     if (bSetDisplayFormula)
 226     {
 227         bool bTmp = bDisplayFormula && bDisplayOK;
 228         xPropertySet->setPropertyValue("IsShowFormula", Any(bTmp));
 229     }
 230
 231     // delegate to value helper
 232     aValueHelper.SetDefault(GetContent());
 233     aValueHelper.PrepareField(xPropertySet);
 234
 235     // finally, set the curren presentation
 236     if (bSetPresentation)
 237     {
 238         Any aAny;
 239         aAny <<= GetContent();
 240         xPropertySet->setPropertyValue(sAPI_current_presentation, aAny);
 241     }
 242 }
 243
 244
 245 // variable set fields
 246
 247
 248 XMLSetVarFieldImportContext::XMLSetVarFieldImportContext(
 249     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
 250     const char* pServiceName, sal_uInt16 nPrfx,
 251     const OUString& rLocalName, VarType eVarType,
 252     bool bFormula, bool bFormulaDefault,
 253     bool bDescription, bool bHelp, bool bHint, bool bVisible, bool bIsDisplayFormula,
 254     bool bType, bool bStyle, bool bValue, bool bPresentation) :
 255         XMLVarFieldImportContext(rImport, rHlp, pServiceName,
 256                                  nPrfx, rLocalName,
 257                                  bFormula, bFormulaDefault,
 258                                  bDescription, bHelp, bHint, bVisible, bIsDisplayFormula,
 259                                  bType, bStyle, bValue, bPresentation),
 260         eFieldType(eVarType)
 261 {
 262 }
 263
 264 void XMLSetVarFieldImportContext::endFastElement(sal_Int32 )
 265 {
 266     // should we call PrepareField on the field, or rather on it's master?
 267     // currently: call on field (just like superclass)
 268     // possible alternatives: call on master
 269     //                        call field or master depending on variable
 270     //                        PrepareMaster() in addition to PrepareField()
 271
 272     DBG_ASSERT(!GetServiceName().isEmpty(), "no service name for element!");
 273
 274     if (bValid)
 275     {
 276         DBG_ASSERT(!GetName().isEmpty(), "variable name needed!");
 277
 278         // find field master
 279         Reference<XPropertySet> xMaster;
 280         if (FindFieldMaster(xMaster))
 281         {
 282             // create field/Service
 283             Reference<XPropertySet> xPropSet;
 284             if (CreateField(xPropSet, "com.sun.star.text.TextField." + GetServiceName()))
 285             {
 286                 Reference<XDependentTextField> xDepTextField(xPropSet, UNO_QUERY);
 287                 if (xDepTextField.is())
 288                 {
 289                     // attach field to field master
 290                     xDepTextField->attachTextFieldMaster(xMaster);
 291
 292                     // attach field to document
 293                     Reference<XTextContent> xTextContent(xPropSet, UNO_QUERY);
 294                     if (xTextContent.is())
 295                     {
 296                         try {
 297                         // insert, set field properties and exit!
 298                         GetImportHelper().InsertTextContent(xTextContent);
 299                         PrepareField(xPropSet);
 300                         } catch (lang::IllegalArgumentException & /*e*/)
 301                         {
 302                             // ignore e: #i54023#
 303                         };
 304                         return;
 305                     }
 306                 }
 307             }
 308         }
 309     }
 310
 311     // above: exit on success; so for all error cases we end up here!
 312     // write element content
 313     GetImportHelper().InsertString(GetContent());
 314 }
 315
 316 bool XMLSetVarFieldImportContext::FindFieldMaster(
 317     Reference<XPropertySet> & xMaster)
 318 {
 319     // currently: delegate to XMLVariableDeclImportContext;
 320     // should eventually go here
 321     return XMLVariableDeclImportContext::FindFieldMaster(xMaster,
 322                                                          GetImport(),
 323                                                          GetImportHelper(),
 324                                                          GetName(),
 325                                                          eFieldType);
 326 }
 327
 328
 329 // sequence field
 330
 331
 332 XMLSequenceFieldImportContext::XMLSequenceFieldImportContext(
 333     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
 334     sal_uInt16 nPrfx, const OUString& rLocalName) :
 335         XMLSetVarFieldImportContext(rImport, rHlp, sAPI_set_expression,
 336                                     nPrfx, rLocalName, VarTypeSequence,
 337                                     // formula
 338                                     true, true,
 339                                     false, false, false, false,
 340                                     false,
 341                                     false, false, false, true),
 342
 343         sNumFormat(OUString('1')),
 344         sNumFormatSync(GetXMLToken(XML_FALSE)),
 345         bRefNameOK(false)
 346 {
 347 }
 348
 349 void XMLSequenceFieldImportContext::ProcessAttribute(
 350     sal_Int32 nAttrToken, const OUString& sAttrValue )
 351 {
 352     switch (nAttrToken)
 353     {
 354         case XML_ELEMENT(STYLE, XML_NUM_FORMAT):
 355             sNumFormat = sAttrValue;
 356             break;
 357         case XML_ELEMENT(STYLE, XML_NUM_LETTER_SYNC):
 358             sNumFormatSync = sAttrValue;
 359             break;
 360         case XML_ELEMENT(TEXT, XML_REF_NAME):
 361             sRefName = sAttrValue;
 362             bRefNameOK = true;
 363             break;
 364         default:
 365             // delegate to super class (name, formula)
 366             XMLSetVarFieldImportContext::ProcessAttribute(nAttrToken,
 367                                                           sAttrValue);
 368             break;
 369     } // switch
 370 }
 371
 372 void XMLSequenceFieldImportContext::PrepareField(
 373     const Reference<XPropertySet> & xPropertySet)
 374 {
 375     // delegate to super class (formula)
 376     XMLSetVarFieldImportContext::PrepareField(xPropertySet);
 377
 378     // set format
 379     sal_Int16 nNumType = NumberingType::ARABIC;
 380     GetImport().GetMM100UnitConverter().convertNumFormat( nNumType, sNumFormat, sNumFormatSync );
 381     xPropertySet->setPropertyValue(sAPI_number_format, Any(nNumType));
 382
 383     // handle reference name
 384     if (bRefNameOK)
 385     {
 386         Any aAny = xPropertySet->getPropertyValue("SequenceValue");
 387         sal_Int16 nValue = 0;
 388         aAny >>= nValue;
 389         GetImportHelper().InsertSequenceID(sRefName, GetName(), nValue);
 390     }
 391 }
 392
 393
 394 // variable set field
 395
 396
 397 XMLVariableSetFieldImportContext::XMLVariableSetFieldImportContext(
 398     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
 399     sal_uInt16 nPrfx, const OUString& rLocalName) :
 400         XMLSetVarFieldImportContext(rImport, rHlp, sAPI_set_expression,
 401                                     nPrfx, rLocalName, VarTypeSimple,
 402                                     // formula, value&type, style,
 403                                     // display none
 404                                     true, true,
 405                                     false, false, false,
 406                                     true, false,
 407                                     true, true, true,
 408                                     true)
 409 {
 410 }
 411
 412 void XMLVariableSetFieldImportContext::PrepareField(
 413         const Reference<XPropertySet> & xPropertySet)
 414 {
 415     // set type
 416     Any aAny;
 417     aAny <<= (IsStringValue()? SetVariableType::STRING : SetVariableType::VAR);
 418     xPropertySet->setPropertyValue(sAPI_sub_type, aAny);
 419
 420     // the remainder is handled by super class
 421     XMLSetVarFieldImportContext::PrepareField(xPropertySet);
 422 }
 423
 424
 425 // variable input field
 426
 427
 428 XMLVariableInputFieldImportContext::XMLVariableInputFieldImportContext(
 429     SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx,
 430     const OUString& rLocalName) :
 431         XMLSetVarFieldImportContext(rImport, rHlp, sAPI_set_expression,
 432                                     nPrfx, rLocalName, VarTypeSimple,
 433                                     // description, display none/formula,
 434                                     // value&type, style, formula
 435                                     true, true,
 436                                     true, true, true,
 437                                     true, false,
 438                                     true, true, true,
 439                                     true)
 440 {
 441 }
 442
 443 void XMLVariableInputFieldImportContext::PrepareField(
 444         const Reference<XPropertySet> & xPropertySet)
 445 {
 446     // set type (input field)
 447     Any aAny;
 448     xPropertySet->setPropertyValue("Input", Any(true));
 449
 450     // set type
 451     aAny <<= (IsStringValue()? SetVariableType::STRING : SetVariableType::VAR);
 452     xPropertySet->setPropertyValue(sAPI_sub_type, aAny);
 453
 454     // the remainder is handled by super class
 455     XMLSetVarFieldImportContext::PrepareField(xPropertySet);
 456 }
 457
 458
 459 // user field
 460
 461
 462 XMLUserFieldImportContext::XMLUserFieldImportContext(
 463     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
 464     sal_uInt16 nPrfx, const OUString& rLocalName) :
 465         XMLSetVarFieldImportContext(rImport, rHlp, sAPI_user, nPrfx,
 466                                     rLocalName, VarTypeUserField,
 467                                     // display none/formula, style
 468                                     false, false,
 469                                     false, false, false, true,
 470                                     true,
 471                                     false, true, false,
 472                                     false)
 473 {
 474 }
 475
 476
 477 // user input field
 478
 479
 480 // bug: doesn't work (SO API lacking)
 481 XMLUserFieldInputImportContext::XMLUserFieldInputImportContext(
 482     SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx,
 483     const OUString& rLocalName) :
 484         XMLVarFieldImportContext(rImport, rHlp, "InputUser",
 485                                  nPrfx, rLocalName,
 486                                  // description, style
 487                                  false, false,
 488                                  true, false, false,
 489                                  false, false,
 490                                  false /*???*/, true, false,
 491                                  false)
 492 {
 493 }
 494
 495 void XMLUserFieldInputImportContext::PrepareField(
 496     const Reference<XPropertySet> & xPropertySet)
 497 {
 498     xPropertySet->setPropertyValue(sAPI_content, Any(GetName()));
 499
 500     // delegate to super class
 501     XMLVarFieldImportContext::PrepareField(xPropertySet);
 502 }
 503
 504
 505 // variable get field
 506
 507
 508 XMLVariableGetFieldImportContext::XMLVariableGetFieldImportContext(
 509     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
 510     sal_uInt16 nPrfx, const OUString& rLocalName) :
 511         XMLVarFieldImportContext(rImport, rHlp, sAPI_get_expression,
 512                                  nPrfx, rLocalName,
 513                                  // style, display formula
 514                                  false, false,
 515                                  false, false, false,
 516                                  false, true,
 517                                  true, true, false,
 518                                  true)
 519 {
 520 }
 521
 522 void XMLVariableGetFieldImportContext::PrepareField(
 523         const Reference<XPropertySet> & xPropertySet)
 524 {
 525     // set name
 526     xPropertySet->setPropertyValue(sAPI_content, Any(GetName()));
 527
 528     // the remainder is handled by super class
 529     XMLVarFieldImportContext::PrepareField(xPropertySet);
 530 }
 531
 532
 533 // expression field
 534
 535
 536 XMLExpressionFieldImportContext::XMLExpressionFieldImportContext(
 537     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
 538     sal_uInt16 nPrfx, const OUString& rLocalName) :
 539         XMLVarFieldImportContext(rImport, rHlp, sAPI_get_expression,
 540                                  nPrfx, rLocalName,
 541                                  // formula, type, style, display formula
 542                                  true, true,
 543                                  false, false, false,
 544                                  false, true,
 545                                  true, true, false,
 546                                  true)
 547 {
 548     bValid = true;  // always valid
 549 }
 550
 551
 552 void XMLExpressionFieldImportContext::PrepareField(
 553     const Reference<XPropertySet> & xPropertySet)
 554 {
 555     xPropertySet->setPropertyValue(sAPI_sub_type, Any(sal_Int16(SetVariableType::FORMULA)));
 556
 557     // delegate to super class
 558     XMLVarFieldImportContext::PrepareField(xPropertySet);
 559 }
 560
 561
 562 // text input field
 563
 564
 565 XMLTextInputFieldImportContext::XMLTextInputFieldImportContext(
 566     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
 567     sal_uInt16 nPrfx, const OUString& sLocalName) :
 568         XMLVarFieldImportContext(rImport, rHlp, "Input",
 569                                  nPrfx, sLocalName,
 570                                  // description
 571                                  false, false,
 572                                  true, true, true,
 573                                  false, false,
 574                                  false, false, false,
 575                                  false)
 576 {
 577     bValid = true;  // always valid
 578 }
 579
 580 void XMLTextInputFieldImportContext::PrepareField(
 581     const Reference<XPropertySet> & xPropertySet)
 582 {
 583     XMLVarFieldImportContext::PrepareField(xPropertySet);
 584
 585     xPropertySet->setPropertyValue(sAPI_content, Any(GetContent()));
 586 }
 587
 588
 589 // table formula field
 590
 591
 592 XMLTableFormulaImportContext::XMLTableFormulaImportContext(
 593     SvXMLImport& rImport,
 594     XMLTextImportHelper& rHlp,
 595     sal_uInt16 nPrfx,
 596     const OUString& rLocalName) :
 597         XMLTextFieldImportContext(rImport, rHlp, "TableFormula",
 598                                   nPrfx, rLocalName),
 599         aValueHelper(rImport, rHlp, false, true, false, true),
 600         bIsShowFormula(false)
 601 {
 602 }
 603
 604 void XMLTableFormulaImportContext::ProcessAttribute(
 605     sal_Int32 nAttrToken,
 606     const OUString& sAttrValue )
 607 {
 608     switch (nAttrToken)
 609     {
 610         case XML_ELEMENT(TEXT, XML_FORMULA):
 611             aValueHelper.ProcessAttribute( nAttrToken, sAttrValue );
 612             bValid = true;  // we need a formula!
 613             break;
 614
 615         case XML_ELEMENT(STYLE, XML_DATA_STYLE_NAME):
 616             aValueHelper.ProcessAttribute( nAttrToken, sAttrValue );
 617             break;
 618         case XML_ELEMENT(TEXT, XML_DISPLAY):
 619             if ( sAttrValue == "formula" )
 620                  bIsShowFormula = true;
 621             break;
 622         default:
 623             // unknown attribute -> ignore
 624             XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
 625             break;
 626     }
 627 }
 628
 629 void XMLTableFormulaImportContext::PrepareField(
 630     const Reference<XPropertySet> & xPropertySet)
 631 {
 632     // set format and formula
 633     aValueHelper.PrepareField( xPropertySet );
 634
 635     Any aAny;
 636
 637     // set 'show formula' and presentation
 638     xPropertySet->setPropertyValue( "IsShowFormula", Any(bIsShowFormula) );
 639
 640     aAny <<= GetContent();
 641     xPropertySet->setPropertyValue( "CurrentPresentation", aAny );
 642 }
 643
 644
 645 // variable declarations
 646
 647 // Should be adapted to XMLVarField-/XMLSetVarFieldImportContext scheme!
 648
 649
 650 // declaration container import (<variable/user-field/sequence-decls>)
 651
 652
 653 XMLVariableDeclsImportContext::XMLVariableDeclsImportContext(
 654     SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx,
 655     const OUString& rLocalName, enum VarType eVarType) :
 656         SvXMLImportContext(rImport, nPrfx, rLocalName),
 657         eVarDeclsContextType(eVarType),
 658         rImportHelper(rHlp)
 659 {
 660 }
 661
 662 css::uno::Reference< css::xml::sax::XFastContextHandler > XMLVariableDeclsImportContext::createFastChildContext(
 663         sal_Int32 nElement,
 664         const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
 665 {
 666     SvXMLImportContextRef xImportContext;
 667
 668     if( IsTokenInNamespace(nElement, XML_NAMESPACE_TEXT) )
 669     {
 670         enum XMLTokenEnum eElementName;
 671         switch (eVarDeclsContextType)
 672         {
 673             case VarTypeSequence:
 674                 eElementName = XML_SEQUENCE_DECL;
 675                 break;
 676             case VarTypeSimple:
 677                 eElementName = XML_VARIABLE_DECL;
 678                 break;
 679             case VarTypeUserField:
 680                 eElementName = XML_USER_FIELD_DECL;
 681                 break;
 682             default:
 683                 OSL_FAIL("unknown field type!");
 684                 eElementName = XML_SEQUENCE_DECL;
 685                 break;
 686         }
 687
 688         if( nElement == XML_ELEMENT(TEXT, eElementName) )
 689         {
 690             return new XMLVariableDeclImportContext(
 691                 GetImport(), rImportHelper, nElement, xAttrList,
 692                 eVarDeclsContextType);
 693         }
 694     }
 695
 696     // if no context was created, use default context
 697     return nullptr;
 698 }
 699
 700
 701 // declaration import (<variable/user-field/sequence-decl> elements)
 702
 703
 704 XMLVariableDeclImportContext::XMLVariableDeclImportContext(
 705     SvXMLImport& rImport, XMLTextImportHelper& rHlp,
 706     sal_Int32 nElement,
 707     const Reference<xml::sax::XFastAttributeList> & xAttrList,
 708     enum VarType eVarType) :
 709         SvXMLImportContext(rImport)
 710 {
 711     // bug?? which properties for userfield/userfieldmaster
 712     XMLValueImportHelper aValueHelper(rImport, rHlp, true, false, true, false);
 713     sal_Unicode cSeparationChar('.');
 714
 715     sal_Int8 nNumLevel(-1);
 716     OUString sName;
 717
 718     if (nElement != XML_ELEMENT(TEXT, XML_SEQUENCE_DECL) &&
 719         nElement != XML_ELEMENT(TEXT, XML_VARIABLE_DECL) &&
 720         nElement != XML_ELEMENT(TEXT, XML_USER_FIELD_DECL) )
 721         return;
 722
 723     // TODO: check validity (need name!)
 724
 725     // parse attributes
 726     for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
 727     {
 728         switch (aIter.getToken())
 729         {
 730             case XML_ELEMENT(TEXT, XML_NAME):
 731                 sName = aIter.toString();
 732                 break;
 733             case XML_ELEMENT(TEXT, XML_DISPLAY_OUTLINE_LEVEL):
 734             {
 735                 sal_Int32 nLevel;
 736                 bool const bRet = ::sax::Converter::convertNumber(
 737                     nLevel, aIter.toString(), 0,
 738                     GetImport().GetTextImport()->GetChapterNumbering()->
 739                                                                getCount());
 740                 if (bRet)
 741                 {
 742                     nNumLevel = static_cast< sal_Int8 >( nLevel-1 ); // API numbers -1..9
 743                 }
 744                 break;
 745             }
 746             case XML_ELEMENT(TEXT, XML_SEPARATION_CHARACTER):
 747                 cSeparationChar =
 748                     static_cast<char>(aIter.toString().toChar());
 749                 break;
 750
 751             default:
 752                 // delegate to value helper
 753                 aValueHelper.ProcessAttribute(aIter.getToken(), aIter.toString());
 754                 break;
 755         }
 756     }
 757
 758     Reference<XPropertySet> xFieldMaster;
 759     if (!FindFieldMaster(xFieldMaster, GetImport(), rHlp,
 760                         sName, eVarType))
 761         return;
 762
 763     // now we have a field master: process attributes!
 764     Any aAny;
 765
 766     switch (eVarType)
 767     {
 768     case VarTypeSequence:
 769         xFieldMaster->setPropertyValue("ChapterNumberingLevel", Any(nNumLevel));
 770
 771         if (nNumLevel >= 0)
 772         {
 773             OUString sStr(&cSeparationChar, 1);
 774             xFieldMaster->setPropertyValue(
 775                 "NumberingSeparator", Any(sStr));
 776         }
 777         break;
 778     case VarTypeSimple:
 779         {
 780             // set string or non-string SubType (#93192#)
 781             // The SubType was already set in the FindFieldMaster
 782             // method, but it needs to be adjusted if it's a string.
 783             aAny <<= aValueHelper.IsStringValue()
 784                 ? SetVariableType::STRING : SetVariableType::VAR;
 785             xFieldMaster->setPropertyValue(sAPI_sub_type, aAny);
 786         }
 787         break;
 788     case VarTypeUserField:
 789     {
 790         bool bTmp = !aValueHelper.IsStringValue();
 791         xFieldMaster->setPropertyValue("IsExpression", Any(bTmp));
 792         aValueHelper.PrepareField(xFieldMaster);
 793         break;
 794     }
 795     default:
 796         OSL_FAIL("unknown varfield type");
 797     } // switch
 798 }
 799
 800
 801 bool XMLVariableDeclImportContext::FindFieldMaster(
 802     Reference<XPropertySet> & xMaster, SvXMLImport& rImport,
 803     XMLTextImportHelper& rImportHelper,
 804     const OUString& sVarName, enum VarType eVarType)
 805 {
 806     static sal_Int32 nCollisionCount = 0;
 807
 808     // rename field
 809     // currently: no family in use! Use 0.
 810     OUString sName = rImportHelper.GetRenameMap().Get(
 811         sal::static_int_cast< sal_uInt16 >(eVarType), sVarName);
 812
 813     // get text fields supplier and field masters
 814     Reference<XTextFieldsSupplier> xTextFieldsSupp(rImport.GetModel(),
 815                                                    UNO_QUERY);
 816     Reference<container::XNameAccess> xFieldMasterNameAccess =
 817         xTextFieldsSupp->getTextFieldMasters();
 818
 819     OUString sVarServiceName =
 820         OUStringLiteral(sAPI_fieldmaster_prefix) +
 821         sAPI_set_expression +
 822         "." +
 823         sName;
 824
 825     OUString sUserServiceName =
 826         OUStringLiteral(sAPI_fieldmaster_prefix) +
 827         sAPI_user +
 828         "." +
 829         sName;
 830
 831     if (xFieldMasterNameAccess->hasByName(sVarServiceName)) {
 832         // variable field master already in document
 833
 834         Any aAny = xFieldMasterNameAccess->getByName(sVarServiceName);
 835         aAny >>= xMaster;
 836
 837         aAny = xMaster->getPropertyValue(sAPI_sub_type);
 838         sal_Int16 nType = 0;
 839         aAny >>= nType;
 840
 841         enum VarType eFMVarType =
 842             (SetVariableType::SEQUENCE == nType) ?
 843                 VarTypeSequence : VarTypeSimple;
 844
 845         if (eFMVarType != eVarType)
 846         {
 847             ++nCollisionCount;
 848             OUString sNew(sName + "_renamed_" + OUString::number(nCollisionCount));
 849
 850             // FIXME! can't find if name is taken already!!!!
 851
 852             rImportHelper.GetRenameMap().Add(
 853                 sal::static_int_cast< sal_uInt16 >(eVarType), sName, sNew);
 854
 855             // call FindFieldMaster recursively to create new master
 856             return FindFieldMaster(xMaster, rImport, rImportHelper,
 857                                    sNew, eVarType);
 858         }
 859     } else if (xFieldMasterNameAccess->hasByName(sUserServiceName)) {
 860         // user field: get field master
 861         Any aAny = xFieldMasterNameAccess->getByName(sUserServiceName);
 862         aAny >>= xMaster;
 863
 864         if (VarTypeUserField != eVarType) {
 865             ++nCollisionCount;
 866             // find new name that is not taken
 867             OUString sNew(sName + "_renamed_" + OUString::number(nCollisionCount));
 868
 869             // FIXME! can't find if name is taken already!!!!
 870
 871             rImportHelper.GetRenameMap().Add(
 872                 sal::static_int_cast< sal_uInt16 >(eVarType), sName, sNew);
 873
 874             // call FindFieldMaster recursively to create new master
 875             return FindFieldMaster(xMaster, rImport, rImportHelper,
 876                                    sNew, eVarType);
 877         }
 878     } else {
 879         // field name not used: create field master
 880
 881         // import -> model is MultiServiceFactory -> createInstance
 882         Reference<lang::XMultiServiceFactory>
 883             xFactory(rImport.GetModel(),UNO_QUERY);
 884         if( xFactory.is() ) {
 885
 886             OUStringBuffer sService;
 887             sService.append(sAPI_fieldmaster_prefix);
 888             sService.appendAscii((eVarType==VarTypeUserField) ?
 889                                  sAPI_user : sAPI_set_expression);
 890             Reference<XInterface> xIfc =
 891                 xFactory->createInstance( sService.makeStringAndClear() );
 892             if (xIfc.is()) {
 893                 Reference<XPropertySet> xTmp( xIfc, UNO_QUERY );
 894                 xMaster = xTmp;
 895
 896                 // set name
 897                 xMaster->setPropertyValue("Name", Any(sName));
 898
 899                 if (eVarType != VarTypeUserField) {
 900                     // set subtype for setexp field
 901                     Any aAny;
 902                     aAny <<= ((eVarType == VarTypeSimple) ?
 903                               SetVariableType::VAR :
 904                               SetVariableType::SEQUENCE);
 905                     xMaster->setPropertyValue(sAPI_sub_type, aAny);
 906                 } // else : user field: no subtype
 907
 908             } else {
 909                 return false;
 910             }
 911         } else {
 912             return false;
 913         }
 914     }
 915
 916     DBG_ASSERT(xMaster.is(), "no field master found!?!");
 917     return true;
 918 }
 919
 920
 921 // Database Display field import
 922
 923
 924 XMLDatabaseDisplayImportContext::XMLDatabaseDisplayImportContext(
 925     SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx,
 926     const OUString& rLocalName) :
 927         XMLDatabaseFieldImportContext(rImport, rHlp, sAPI_database,
 928                                       nPrfx, rLocalName, false),
 929         aValueHelper(rImport, rHlp, false, true, false, false),
 930         bColumnOK(false),
 931         bDisplay( true ),
 932         bDisplayOK( false )
 933 {
 934 }
 935
 936 void XMLDatabaseDisplayImportContext::ProcessAttribute(
 937     sal_Int32 nAttrToken, const OUString& sAttrValue )
 938 {
 939     switch (nAttrToken)
 940     {
 941         case XML_ELEMENT(TEXT, XML_COLUMN_NAME):
 942             sColumnName = sAttrValue;
 943             bColumnOK = true;
 944             break;
 945         case XML_ELEMENT(TEXT, XML_DISPLAY):
 946             {
 947                 bool bNone = IsXMLToken( sAttrValue, XML_NONE );
 948                 bool bValue = IsXMLToken( sAttrValue, XML_VALUE );
 949                 bDisplay = bValue;
 950                 bDisplayOK = bNone || bValue;
 951             }
 952             break;
 953         case XML_ELEMENT(TEXT, XML_DATABASE_NAME):
 954         case XML_ELEMENT(TEXT, XML_TABLE_NAME):
 955         case XML_ELEMENT(TEXT, XML_TABLE_TYPE):
 956             // handled by super class
 957             XMLDatabaseFieldImportContext::ProcessAttribute(nAttrToken,
 958                                                             sAttrValue);
 959             break;
 960         default:
 961             // remainder handled by value helper
 962             aValueHelper.ProcessAttribute(nAttrToken, sAttrValue);
 963             break;
 964     }
 965
 966     bValid = m_bTableOK && m_bDatabaseOK && bColumnOK;
 967 }
 968
 969 void XMLDatabaseDisplayImportContext::endFastElement(sal_Int32 )
 970 {
 971     // we have an EndElement of our own, because database fields need
 972     // to be attached to a field master before they can be inserted into
 973     // the document. Database stuff (database, table, column) all goes
 974     // to the field master, value & style go to the field.
 975
 976     if (bValid)
 977     {
 978
 979         // so here goes: we start with the master
 980         Reference<XPropertySet> xMaster;
 981
 982         // create and prepare field master first
 983         if (CreateField(xMaster,
 984                         "com.sun.star.text.FieldMaster.Database"))
 985         {
 986             Any aAny;
 987             xMaster->setPropertyValue("DataColumnName", Any(sColumnName));
 988
 989             // fieldmaster takes database, table and column name
 990             XMLDatabaseFieldImportContext::PrepareField(xMaster);
 991
 992             // create field
 993             Reference<XPropertySet> xField;
 994             if (CreateField(xField,
 995                             sAPI_database))
 996             {
 997                 // attach field master
 998                 Reference<XDependentTextField> xDepField(xField, UNO_QUERY);
 999                 if (xDepField.is())
1000                 {
1001                     // attach field to field master
1002                     xDepField->attachTextFieldMaster(xMaster);
1003
1004                     // attach field to document
1005                     Reference<XTextContent> xTextContent(xField, UNO_QUERY);
1006                     if (xTextContent.is())
1007                     {
1008                         // insert, set field properties and exit!
1009                         try
1010                         {
1011                             GetImportHelper().InsertTextContent(xTextContent);
1012
1013                             // prepare field: format from database?
1014                             bool bTmp = !aValueHelper.IsFormatOK();
1015                             xField->setPropertyValue("DataBaseFormat", Any(bTmp));
1016
1017                             // value, value-type and format done by value helper
1018                             aValueHelper.PrepareField(xField);
1019
1020                             // visibility
1021                             if( bDisplayOK )
1022                             {
1023                                 xField->setPropertyValue(sAPI_is_visible, Any(bDisplay));
1024                             }
1025
1026                             // set presentation
1027                             aAny <<= GetContent();
1028                             xField->setPropertyValue(sAPI_current_presentation, aAny);
1029
1030                             // success!
1031                             return;
1032                         }
1033                         catch (const lang::IllegalArgumentException&)
1034                         {
1035                             TOOLS_WARN_EXCEPTION("xmloff.text", "Failed to insert text content");
1036                         }
1037                     }
1038                 }
1039             }
1040         }
1041     }
1042
1043     // above: exit on success; so for all error cases we end up here!
1044     // write element content
1045     GetImportHelper().InsertString(GetContent());
1046 }
1047
1048
1049 // value import helper
1050
1051 namespace {
1052
1053 enum ValueType
1054 {
1055     XML_VALUE_TYPE_STRING,
1056     XML_VALUE_TYPE_FLOAT,
1057     XML_VALUE_TYPE_CURRENCY,
1058     XML_VALUE_TYPE_PERCENTAGE,
1059     XML_VALUE_TYPE_DATE,
1060     XML_VALUE_TYPE_TIME,
1061     XML_VALUE_TYPE_BOOLEAN
1062 };
1063
1064 }
1065
1066 SvXMLEnumMapEntry<ValueType> const aValueTypeMap[] =
1067 {
1068     { XML_FLOAT,        XML_VALUE_TYPE_FLOAT },
1069     { XML_CURRENCY,     XML_VALUE_TYPE_CURRENCY },
1070     { XML_PERCENTAGE,   XML_VALUE_TYPE_PERCENTAGE },
1071     { XML_DATE,         XML_VALUE_TYPE_DATE },
1072     { XML_TIME,         XML_VALUE_TYPE_TIME },
1073     { XML_BOOLEAN,      XML_VALUE_TYPE_BOOLEAN },
1074     { XML_STRING,       XML_VALUE_TYPE_STRING },
1075     { XML_TOKEN_INVALID, ValueType(0) }
1076 };
1077
1078 XMLValueImportHelper::XMLValueImportHelper(
1079     SvXMLImport& rImprt,
1080     XMLTextImportHelper& rHlp,
1081     bool bType, bool bStyle, bool bValue, bool bFormula) :
1082
1083         rImport(rImprt),
1084         rHelper(rHlp),
1085
1086         fValue(0.0),
1087         nFormatKey(0),
1088         bIsDefaultLanguage(true),
1089
1090         bStringType(false),
1091         bFormatOK(false),
1092         bStringValueOK(false),
1093         bFormulaOK(false),
1094
1095         bSetType(bType),
1096         bSetValue(bValue),
1097         bSetStyle(bStyle),
1098         bSetFormula(bFormula)
1099 {
1100 }
1101
1102 void XMLValueImportHelper::ProcessAttribute(
1103     sal_Int32 nAttrToken, const OUString& sAttrValue )
1104 {
1105     switch (nAttrToken)
1106     {
1107         case XML_ELEMENT(TEXT, XML_VALUE_TYPE):
1108         case XML_ELEMENT(OFFICE, XML_VALUE_TYPE):
1109         {
1110             // convert enum
1111             ValueType eValueType = XML_VALUE_TYPE_STRING;
1112             bool bRet = SvXMLUnitConverter::convertEnum(
1113                 eValueType, sAttrValue, aValueTypeMap);
1114
1115             if (bRet) {
1116                 switch (eValueType)
1117                 {
1118                     case XML_VALUE_TYPE_STRING:
1119                         bStringType = true;
1120                         break;
1121                     case XML_VALUE_TYPE_FLOAT:
1122                     case XML_VALUE_TYPE_CURRENCY:
1123                     case XML_VALUE_TYPE_PERCENTAGE:
1124                     case XML_VALUE_TYPE_DATE:
1125                     case XML_VALUE_TYPE_TIME:
1126                     case XML_VALUE_TYPE_BOOLEAN:
1127                         bStringType = false;
1128                         break;
1129
1130                     default:
1131                         OSL_FAIL("unknown value type");
1132                 }
1133             }
1134             break;
1135         }
1136
1137         case XML_ELEMENT(TEXT, XML_VALUE):
1138         case XML_ELEMENT(OFFICE, XML_VALUE):
1139         {
1140             double fTmp;
1141             bool const bRet = ::sax::Converter::convertDouble(fTmp,sAttrValue);
1142             if (bRet) {
1143                 fValue = fTmp;
1144             }
1145             break;
1146         }
1147
1148         case XML_ELEMENT(TEXT, XML_TIME_VALUE):
1149         case XML_ELEMENT(OFFICE, XML_TIME_VALUE):
1150         {
1151             double fTmp;
1152             bool const bRet =
1153                 ::sax::Converter::convertDuration(fTmp, sAttrValue);
1154             if (bRet) {
1155                 fValue = fTmp;
1156             }
1157             break;
1158         }
1159
1160         case XML_ELEMENT(TEXT, XML_DATE_VALUE):
1161         case XML_ELEMENT(OFFICE, XML_DATE_VALUE):
1162         {
1163             double fTmp;
1164             bool bRet = rImport.GetMM100UnitConverter().
1165                 convertDateTime(fTmp,sAttrValue);
1166             if (bRet) {
1167                 fValue = fTmp;
1168             }
1169             break;
1170         }
1171
1172         case XML_ELEMENT(OFFICE, XML_BOOLEAN_VALUE):
1173         {
1174             bool bTmp(false);
1175             bool bRet = ::sax::Converter::convertBool(bTmp, sAttrValue);
1176             if (bRet) {
1177                 fValue = (bTmp ? 1.0 : 0.0);
1178             }
1179             else
1180             {
1181                 double fTmp;
1182                 bRet = ::sax::Converter::convertDouble(fTmp, sAttrValue);
1183                 if (bRet) {
1184                     fValue = fTmp;
1185                 }
1186             }
1187             break;
1188         }
1189
1190         case XML_ELEMENT(TEXT, XML_STRING_VALUE):
1191         case XML_ELEMENT(OFFICE, XML_STRING_VALUE):
1192             sValue = sAttrValue;
1193             bStringValueOK = true;
1194             break;
1195
1196         case  XML_ELEMENT(TEXT, XML_FORMULA):
1197             {
1198                 OUString sTmp;
1199                 sal_uInt16 nPrefix = rImport.GetNamespaceMap().
1200                         GetKeyByAttrValueQName(sAttrValue, &sTmp);
1201                 if( XML_NAMESPACE_OOOW == nPrefix )
1202                 {
1203                     sFormula = sTmp;
1204                     bFormulaOK = true;
1205                 }
1206                 else
1207                     sFormula = sAttrValue;
1208             }
1209             break;
1210
1211         case XML_ELEMENT(STYLE, XML_DATA_STYLE_NAME):
1212         {
1213             sal_Int32 nKey = rHelper.GetDataStyleKey(
1214                                           sAttrValue, &bIsDefaultLanguage);
1215             if (-1 != nKey)
1216             {
1217                 nFormatKey = nKey;
1218                 bFormatOK = true;
1219             }
1220             break;
1221         }
1222         default:
1223             XMLOFF_WARN_UNKNOWN_ATTR("xmloff", nAttrToken, sAttrValue);
1224     } // switch
1225 }
1226
1227 void XMLValueImportHelper::PrepareField(
1228     const Reference<XPropertySet> & xPropertySet)
1229 {
1230     Any aAny;
1231
1232     if (bSetType)
1233     {
1234         // ??? how to set type?
1235     }
1236
1237     if (bSetFormula)
1238     {
1239         aAny <<= !bFormulaOK ? sDefault : sFormula;
1240         xPropertySet->setPropertyValue(sAPI_content, aAny);
1241     }
1242
1243     // format/style
1244     if (bSetStyle && bFormatOK)
1245     {
1246         xPropertySet->setPropertyValue(sAPI_number_format, Any(nFormatKey));
1247
1248         if( xPropertySet->getPropertySetInfo()->
1249                 hasPropertyByName( "IsFixedLanguage" ) )
1250         {
1251             bool bIsFixedLanguage = ! bIsDefaultLanguage;
1252             xPropertySet->setPropertyValue( "IsFixedLanguage", Any(bIsFixedLanguage) );
1253         }
1254     }
1255
1256     // value: string or float
1257     if (bSetValue)
1258     {
1259         if (bStringType)
1260         {
1261             aAny <<= !bStringValueOK ? sDefault : sValue;
1262             xPropertySet->setPropertyValue(sAPI_content, aAny);
1263         }
1264         else
1265         {
1266             xPropertySet->setPropertyValue("Value", Any(fValue));
1267         }
1268     }
1269 }
1270
1271 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */