sw/source/core/fields/expfld.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 #include <sal/config.h>
  21
  22 #include <UndoTable.hxx>
  23 #include <hintids.hxx>
  24 #include <o3tl/any.hxx>
  25 #include <unotools/collatorwrapper.hxx>
  26 #include <unotools/charclass.hxx>
  27 #include <editeng/unolingu.hxx>
  28 #include <svx/pageitem.hxx>
  29 #include <editeng/langitem.hxx>
  30 #include <editeng/fontitem.hxx>
  31 #include <com/sun/star/text/SetVariableType.hpp>
  32 #include <unofield.hxx>
  33 #include <frmfmt.hxx>
  34 #include <fmtfld.hxx>
  35 #include <txtfld.hxx>
  36 #include <fmtanchr.hxx>
  37 #include <txtftn.hxx>
  38 #include <doc.hxx>
  39 #include <IDocumentFieldsAccess.hxx>
  40 #include <layfrm.hxx>
  41 #include <pagefrm.hxx>
  42 #include <cntfrm.hxx>
  43 #include <rootfrm.hxx>
  44 #include <tabfrm.hxx>
  45 #include <flyfrm.hxx>
  46 #include <ftnfrm.hxx>
  47 #include <rowfrm.hxx>
  48 #include <expfld.hxx>
  49 #include <usrfld.hxx>
  50 #include <ndtxt.hxx>
  51 #include <calc.hxx>
  52 #include <pam.hxx>
  53 #include <docfld.hxx>
  54 #include <swcache.hxx>
  55 #include <swtable.hxx>
  56 #include <breakit.hxx>
  57 #include <SwStyleNameMapper.hxx>
  58 #include <unofldmid.h>
  59 #include <numrule.hxx>
  60 #include <calbck.hxx>
  61
  62 using namespace ::com::sun::star;
  63 using namespace ::com::sun::star::text;
  64
  65 static sal_Int16 lcl_SubTypeToAPI(sal_uInt16 nSubType)
  66 {
  67         sal_Int16 nRet = 0;
  68         switch(nSubType)
  69         {
  70             case nsSwGetSetExpType::GSE_EXPR:
  71                 nRet = SetVariableType::VAR;      // 0
  72                 break;
  73             case nsSwGetSetExpType::GSE_SEQ:
  74                 nRet = SetVariableType::SEQUENCE; // 1
  75                 break;
  76             case nsSwGetSetExpType::GSE_FORMULA:
  77                 nRet = SetVariableType::FORMULA;  // 2
  78                 break;
  79             case nsSwGetSetExpType::GSE_STRING:
  80                 nRet = SetVariableType::STRING;   // 3
  81                 break;
  82         }
  83         return nRet;
  84 }
  85
  86 static sal_Int32 lcl_APIToSubType(const uno::Any& rAny)
  87 {
  88         sal_Int16 nVal = 0;
  89         rAny >>= nVal;
  90         sal_Int32 nSet = 0;
  91         switch(nVal)
  92         {
  93             case SetVariableType::VAR:      nSet = nsSwGetSetExpType::GSE_EXPR;  break;
  94             case SetVariableType::SEQUENCE: nSet = nsSwGetSetExpType::GSE_SEQ;  break;
  95             case SetVariableType::FORMULA:  nSet = nsSwGetSetExpType::GSE_FORMULA; break;
  96             case SetVariableType::STRING:   nSet = nsSwGetSetExpType::GSE_STRING;   break;
  97             default:
  98                 OSL_FAIL("wrong value");
  99                 nSet = -1;
 100         }
 101         return nSet;
 102 }
 103
 104 OUString ReplacePoint( const OUString& rTmpName, bool bWithCommandType )
 105 {
 106     // replace first and last (if bWithCommandType: last two) dot
 107     // since table names may contain dots
 108
 109     sal_Int32 nIndex = rTmpName.lastIndexOf('.');
 110     if (nIndex<0)
 111     {
 112         return rTmpName;
 113     }
 114
 115     OUString sRes = rTmpName.replaceAt(nIndex, 1, OUString(DB_DELIM));
 116
 117     if (bWithCommandType)
 118     {
 119         nIndex = sRes.lastIndexOf('.', nIndex);
 120         if (nIndex<0)
 121         {
 122             return sRes;
 123         }
 124         sRes = sRes.replaceAt(nIndex, 1, OUString(DB_DELIM));
 125     }
 126
 127     nIndex = sRes.indexOf('.');
 128     if (nIndex>=0)
 129     {
 130         sRes = sRes.replaceAt(nIndex, 1, OUString(DB_DELIM));
 131     }
 132     return sRes;
 133 }
 134
 135 SwTextNode* GetFirstTextNode( const SwDoc& rDoc, SwPosition& rPos,
 136                             const SwContentFrame *pCFrame, Point &rPt )
 137 {
 138     SwTextNode* pTextNode = nullptr;
 139     if ( !pCFrame )
 140     {
 141         const SwNodes& rNodes = rDoc.GetNodes();
 142         rPos.nNode = *rNodes.GetEndOfContent().StartOfSectionNode();
 143         SwContentNode* pCNd;
 144         while( nullptr != (pCNd = rNodes.GoNext( &rPos.nNode ) ) &&
 145                 nullptr == ( pTextNode = pCNd->GetTextNode() ) )
 146                         ;
 147         OSL_ENSURE( pTextNode, "Where is the 1. TextNode?" );
 148         rPos.nContent.Assign( pTextNode, 0 );
 149     }
 150     else if ( !pCFrame->IsValid() )
 151     {
 152         pTextNode = const_cast<SwTextNode*>(static_cast<const SwTextNode*>(pCFrame->GetNode()));
 153         rPos.nNode = *pTextNode;
 154         rPos.nContent.Assign( pTextNode, 0 );
 155     }
 156     else
 157     {
 158         pCFrame->GetCursorOfst( &rPos, rPt );
 159         pTextNode = rPos.nNode.GetNode().GetTextNode();
 160     }
 161     return pTextNode;
 162 }
 163
 164 const SwTextNode* GetBodyTextNode( const SwDoc& rDoc, SwPosition& rPos,
 165                                 const SwFrame& rFrame )
 166 {
 167     const SwLayoutFrame* pLayout = rFrame.GetUpper();
 168     const SwTextNode* pTextNode = nullptr;
 169
 170     while( pLayout )
 171     {
 172         if( pLayout->IsFlyFrame() )
 173         {
 174             // get the FlyFormat
 175             const SwFrameFormat* pFlyFormat = static_cast<const SwFlyFrame*>(pLayout)->GetFormat();
 176             OSL_ENSURE( pFlyFormat, "Could not find FlyFormat, where is the field?" );
 177
 178             const SwFormatAnchor &rAnchor = pFlyFormat->GetAnchor();
 179
 180             if( FLY_AT_FLY == rAnchor.GetAnchorId() )
 181             {
 182                 // the fly needs to be attached somewhere, so ask it
 183                 pLayout = static_cast<const SwLayoutFrame*>(static_cast<const SwFlyFrame*>(pLayout)->GetAnchorFrame());
 184                 continue;
 185             }
 186             else if ((FLY_AT_PARA == rAnchor.GetAnchorId()) ||
 187                      (FLY_AT_CHAR == rAnchor.GetAnchorId()) ||
 188                      (FLY_AS_CHAR == rAnchor.GetAnchorId()))
 189             {
 190                 OSL_ENSURE( rAnchor.GetContentAnchor(), "no valid position" );
 191                 rPos = *rAnchor.GetContentAnchor();
 192                 pTextNode = rPos.nNode.GetNode().GetTextNode();
 193                 if ( FLY_AT_PARA == rAnchor.GetAnchorId() )
 194                 {
 195                     const_cast<SwTextNode*>(pTextNode)->MakeStartIndex(
 196                             &rPos.nContent );
 197                 }
 198
 199                 // do not break yet, might be as well in Header/Footer/Footnote/Fly
 200                 pLayout = static_cast<const SwFlyFrame*>(pLayout)->GetAnchorFrame()
 201                             ? static_cast<const SwFlyFrame*>(pLayout)->GetAnchorFrame()->GetUpper() : nullptr;
 202                 continue;
 203             }
 204             else
 205             {
 206                 pLayout->FindPageFrame()->GetContentPosition(
 207                                                 pLayout->Frame().Pos(), rPos );
 208                 pTextNode = rPos.nNode.GetNode().GetTextNode();
 209             }
 210         }
 211         else if( pLayout->IsFootnoteFrame() )
 212         {
 213             // get the anchor's node
 214             const SwTextFootnote* pFootnote = static_cast<const SwFootnoteFrame*>(pLayout)->GetAttr();
 215             pTextNode = &pFootnote->GetTextNode();
 216             rPos.nNode = *pTextNode;
 217             rPos.nContent = pFootnote->GetStart();
 218         }
 219         else if( pLayout->IsHeaderFrame() || pLayout->IsFooterFrame() )
 220         {
 221             const SwContentFrame* pContentFrame;
 222             const SwPageFrame* pPgFrame = pLayout->FindPageFrame();
 223             if( pLayout->IsHeaderFrame() )
 224             {
 225                 const SwTabFrame *pTab;
 226                 if( nullptr != ( pContentFrame = pPgFrame->FindFirstBodyContent()) &&
 227                     nullptr != (pTab = pContentFrame->FindTabFrame()) && pTab->IsFollow() &&
 228                     pTab->GetTable()->GetRowsToRepeat() > 0 &&
 229                     pTab->IsInHeadline( *pContentFrame ) )
 230                 {
 231                     // take the next line
 232                     const SwLayoutFrame* pRow = pTab->GetFirstNonHeadlineRow();
 233                     pContentFrame = pRow->ContainsContent();
 234                 }
 235             }
 236             else
 237                 pContentFrame = pPgFrame->FindLastBodyContent();
 238
 239             if( pContentFrame )
 240             {
 241                 pTextNode = pContentFrame->GetNode()->GetTextNode();
 242                 rPos.nNode = *pTextNode;
 243                 const_cast<SwTextNode*>(pTextNode)->MakeEndIndex( &rPos.nContent );
 244             }
 245             else
 246             {
 247                 Point aPt( pLayout->Frame().Pos() );
 248                 aPt.Y()++;      // get out of the header
 249                 pContentFrame = pPgFrame->GetContentPos( aPt, false, true );
 250                 pTextNode = GetFirstTextNode( rDoc, rPos, pContentFrame, aPt );
 251             }
 252         }
 253         else
 254         {
 255             pLayout = pLayout->GetUpper();
 256             continue;
 257         }
 258         break; // found, so finish loop
 259     }
 260     return pTextNode;
 261 }
 262
 263 SwGetExpFieldType::SwGetExpFieldType(SwDoc* pDc)
 264     : SwValueFieldType( pDc, RES_GETEXPFLD )
 265 {
 266 }
 267
 268 SwFieldType* SwGetExpFieldType::Copy() const
 269 {
 270     return new SwGetExpFieldType(GetDoc());
 271 }
 272
 273 void SwGetExpFieldType::Modify( const SfxPoolItem*, const SfxPoolItem* pNew )
 274 {
 275     if( pNew && RES_DOCPOS_UPDATE == pNew->Which() )
 276         NotifyClients( nullptr, pNew );
 277     // do not expand anything else
 278 }
 279
 280 SwGetExpField::SwGetExpField(SwGetExpFieldType* pTyp, const OUString& rFormel,
 281                             sal_uInt16 nSub, sal_uLong nFormat)
 282     : SwFormulaField( pTyp, nFormat, 0.0 ),
 283     bIsInBodyText( true ),
 284     nSubType(nSub),
 285     bLateInitialization( false )
 286 {
 287     SetFormula( rFormel );
 288 }
 289
 290 OUString SwGetExpField::Expand() const
 291 {
 292     if(nSubType & nsSwExtendedSubType::SUB_CMD)
 293         return GetFormula();
 294
 295     return sExpand;
 296 }
 297
 298 OUString SwGetExpField::GetFieldName() const
 299 {
 300     const sal_uInt16 nType = static_cast<sal_uInt16>(
 301         (nsSwGetSetExpType::GSE_FORMULA & nSubType)
 302         ? TYP_FORMELFLD
 303         : TYP_GETFLD);
 304
 305     return SwFieldType::GetTypeStr(nType) + " " + GetFormula();
 306 }
 307
 308 SwField* SwGetExpField::Copy() const
 309 {
 310     SwGetExpField *pTmp = new SwGetExpField(static_cast<SwGetExpFieldType*>(GetTyp()),
 311                                             GetFormula(), nSubType, GetFormat());
 312     pTmp->SetLanguage(GetLanguage());
 313     pTmp->SwValueField::SetValue(GetValue());
 314     pTmp->sExpand       = sExpand;
 315     pTmp->bIsInBodyText  = bIsInBodyText;
 316     pTmp->SetAutomaticLanguage(IsAutomaticLanguage());
 317     if( bLateInitialization )
 318         pTmp->SetLateInitialization();
 319
 320     return pTmp;
 321 }
 322
 323 void SwGetExpField::ChangeExpansion( const SwFrame& rFrame, const SwTextField& rField )
 324 {
 325     if( bIsInBodyText ) // only fields in Footer, Header, FootNote, Flys
 326         return;
 327
 328     OSL_ENSURE( !rFrame.IsInDocBody(), "Flag incorrect, frame is in DocBody" );
 329
 330     // determine document (or is there an easier way?)
 331     const SwTextNode* pTextNode = &rField.GetTextNode();
 332     SwDoc& rDoc = *const_cast<SwDoc*>(pTextNode->GetDoc());
 333
 334     // create index for determination of the TextNode
 335     SwPosition aPos( SwNodeIndex( rDoc.GetNodes() ) );
 336     pTextNode = GetBodyTextNode( rDoc, aPos, rFrame );
 337
 338     // If no layout exists, ChangeExpansion is called for header and
 339     // footer lines via layout formatting without existing TextNode.
 340     if(!pTextNode)
 341         return;
 342     // #i82544#
 343     if( bLateInitialization )
 344     {
 345         SwFieldType* pSetExpField = rDoc.getIDocumentFieldsAccess().GetFieldType(RES_SETEXPFLD, GetFormula(), false);
 346         if( pSetExpField )
 347         {
 348             bLateInitialization = false;
 349             if( !(GetSubType() & nsSwGetSetExpType::GSE_STRING) &&
 350                 static_cast< SwSetExpFieldType* >(pSetExpField)->GetType() == nsSwGetSetExpType::GSE_STRING )
 351             SetSubType( nsSwGetSetExpType::GSE_STRING );
 352         }
 353     }
 354
 355     SetGetExpField aEndField( aPos.nNode, &rField, &aPos.nContent );
 356     if(GetSubType() & nsSwGetSetExpType::GSE_STRING)
 357     {
 358         SwHash** ppHashTable;
 359         sal_uInt16 nSize;
 360         rDoc.getIDocumentFieldsAccess().FieldsToExpand( ppHashTable, nSize, aEndField );
 361         sExpand = LookString( ppHashTable, nSize, GetFormula() );
 362         ::DeleteHashTable( ppHashTable, nSize );
 363     }
 364     else
 365     {
 366         // fill calculator with values
 367         SwCalc aCalc( rDoc );
 368         rDoc.getIDocumentFieldsAccess().FieldsToCalc(aCalc, aEndField);
 369
 370         // calculate value
 371         SetValue(aCalc.Calculate(GetFormula()).GetDouble());
 372
 373         // analyse based on format
 374         sExpand = static_cast<SwValueFieldType*>(GetTyp())->ExpandValue(
 375                                 GetValue(), GetFormat(), GetLanguage());
 376     }
 377 }
 378
 379 OUString SwGetExpField::GetPar2() const
 380 {
 381     return GetFormula();
 382 }
 383
 384 void SwGetExpField::SetPar2(const OUString& rStr)
 385 {
 386     SetFormula(rStr);
 387 }
 388
 389 sal_uInt16 SwGetExpField::GetSubType() const
 390 {
 391     return nSubType;
 392 }
 393
 394 void SwGetExpField::SetSubType(sal_uInt16 nType)
 395 {
 396     nSubType = nType;
 397 }
 398
 399 void SwGetExpField::SetLanguage(sal_uInt16 nLng)
 400 {
 401     if (nSubType & nsSwExtendedSubType::SUB_CMD)
 402         SwField::SetLanguage(nLng);
 403     else
 404         SwValueField::SetLanguage(nLng);
 405 }
 406
 407 bool SwGetExpField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
 408 {
 409     switch( nWhichId )
 410     {
 411     case FIELD_PROP_DOUBLE:
 412         rAny <<= GetValue();
 413         break;
 414     case FIELD_PROP_FORMAT:
 415         rAny <<= (sal_Int32)GetFormat();
 416         break;
 417     case FIELD_PROP_USHORT1:
 418          rAny <<= (sal_Int16)nSubType;
 419         break;
 420     case FIELD_PROP_PAR1:
 421          rAny <<= GetFormula();
 422         break;
 423     case FIELD_PROP_SUBTYPE:
 424         {
 425             sal_Int16 nRet = lcl_SubTypeToAPI(GetSubType() & 0xff);
 426             rAny <<= nRet;
 427         }
 428         break;
 429     case FIELD_PROP_BOOL2:
 430         rAny <<= 0 != (nSubType & nsSwExtendedSubType::SUB_CMD);
 431         break;
 432     case FIELD_PROP_PAR4:
 433         rAny <<= GetExpStr();
 434         break;
 435     default:
 436         return SwField::QueryValue(rAny, nWhichId);
 437     }
 438     return true;
 439 }
 440
 441 bool SwGetExpField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
 442 {
 443     sal_Int32 nTmp = 0;
 444     switch( nWhichId )
 445     {
 446     case FIELD_PROP_DOUBLE:
 447         SwValueField::SetValue(*o3tl::doAccess<double>(rAny));
 448         break;
 449     case FIELD_PROP_FORMAT:
 450         rAny >>= nTmp;
 451         SetFormat(nTmp);
 452         break;
 453     case FIELD_PROP_USHORT1:
 454          rAny >>= nTmp;
 455          nSubType = static_cast<sal_uInt16>(nTmp);
 456         break;
 457     case FIELD_PROP_PAR1:
 458     {
 459         OUString sTmp;
 460         rAny >>= sTmp;
 461         SetFormula(sTmp);
 462         break;
 463     }
 464     case FIELD_PROP_SUBTYPE:
 465         nTmp = lcl_APIToSubType(rAny);
 466         if( nTmp >=0 )
 467             SetSubType( static_cast<sal_uInt16>((GetSubType() & 0xff00) | nTmp));
 468         break;
 469     case FIELD_PROP_BOOL2:
 470         if(*o3tl::doAccess<bool>(rAny))
 471             nSubType |= nsSwExtendedSubType::SUB_CMD;
 472         else
 473             nSubType &= (~nsSwExtendedSubType::SUB_CMD);
 474         break;
 475     case FIELD_PROP_PAR4:
 476     {
 477         OUString sTmp;
 478         rAny >>= sTmp;
 479         ChgExpStr(sTmp);
 480         break;
 481     }
 482     default:
 483         return SwField::PutValue(rAny, nWhichId);
 484     }
 485     return true;
 486 }
 487
 488 SwSetExpFieldType::SwSetExpFieldType( SwDoc* pDc, const OUString& rName, sal_uInt16 nTyp )
 489     : SwValueFieldType( pDc, RES_SETEXPFLD ),
 490     sName( rName ),
 491     pOutlChgNd( nullptr ),
 492     sDelim( "." ),
 493     nType(nTyp), nLevel( UCHAR_MAX ),
 494     bDeleted( false )
 495 {
 496     if( ( nsSwGetSetExpType::GSE_SEQ | nsSwGetSetExpType::GSE_STRING ) & nType )
 497         EnableFormat(false);    // do not use Numberformatter
 498 }
 499
 500 SwFieldType* SwSetExpFieldType::Copy() const
 501 {
 502     SwSetExpFieldType* pNew = new SwSetExpFieldType(GetDoc(), sName, nType);
 503     pNew->bDeleted = bDeleted;
 504     pNew->sDelim = sDelim;
 505     pNew->nLevel = nLevel;
 506
 507     return pNew;
 508 }
 509
 510 OUString SwSetExpFieldType::GetName() const
 511 {
 512     return sName;
 513 }
 514
 515 void SwSetExpFieldType::Modify( const SfxPoolItem*, const SfxPoolItem* )
 516 {
 517     return;     // do not expand further
 518 }
 519
 520 void SwSetExpFieldType::SetSeqFormat(sal_uLong nFormat)
 521 {
 522     SwIterator<SwFormatField,SwFieldType> aIter(*this);
 523     for( SwFormatField* pFormatField = aIter.First(); pFormatField; pFormatField = aIter.Next() )
 524         pFormatField->GetField()->ChangeFormat( nFormat );
 525 }
 526
 527 sal_uLong SwSetExpFieldType::GetSeqFormat()
 528 {
 529     if( !HasWriterListeners() )
 530         return SVX_NUM_ARABIC;
 531
 532     const SwField *pField = SwIterator<SwFormatField,SwSetExpFieldType>(*this).First()->GetField();
 533     return pField->GetFormat();
 534 }
 535
 536 void SwSetExpFieldType::SetSeqRefNo( SwSetExpField& rField )
 537 {
 538     if( !HasWriterListeners() || !(nsSwGetSetExpType::GSE_SEQ & nType) )
 539         return;
 540
 541     std::vector<sal_uInt16> aArr;
 542
 543     // check if number is already used and if a new one needs to be created
 544     SwIterator<SwFormatField,SwFieldType> aIter( *this );
 545     for( SwFormatField* pF = aIter.First(); pF; pF = aIter.Next() )
 546     {
 547         const SwTextNode* pNd;
 548         if( pF->GetField() != &rField && pF->GetTextField() &&
 549             nullptr != ( pNd = pF->GetTextField()->GetpTextNode() ) &&
 550             pNd->GetNodes().IsDocNodes() )
 551         {
 552             InsertSort( aArr, static_cast<SwSetExpField*>(pF->GetField())->GetSeqNumber() );
 553         }
 554     }
 555
 556     // check first if number already exists
 557     sal_uInt16 nNum = rField.GetSeqNumber();
 558     if( USHRT_MAX != nNum )
 559     {
 560         std::vector<sal_uInt16>::size_type n {0};
 561
 562         for( n = 0; n < aArr.size(); ++n )
 563             if( aArr[ n ] >= nNum )
 564                 break;
 565
 566         if( n == aArr.size() || aArr[ n ] > nNum )
 567             return;            // no -> use it
 568     }
 569
 570     // flagged all numbers, so determine the right number
 571     sal_uInt16 n = aArr.size();
 572     OSL_ENSURE( n == aArr.size(), "Array is too big for using a sal_uInt16 index" );
 573
 574     if ( n > 0 && aArr[ n-1 ] != n-1 )
 575     {
 576         for( n = 0; n < aArr.size(); ++n )
 577             if( n != aArr[ n ] )
 578                 break;
 579     }
 580
 581     rField.SetSeqNumber( n );
 582 }
 583
 584 size_t SwSetExpFieldType::GetSeqFieldList( SwSeqFieldList& rList )
 585 {
 586     rList.Clear();
 587
 588     SwIterator<SwFormatField,SwFieldType> aIter( *this );
 589     for( SwFormatField* pF = aIter.First(); pF; pF = aIter.Next() )
 590     {
 591         const SwTextNode* pNd;
 592         if( pF->GetTextField() &&
 593             nullptr != ( pNd = pF->GetTextField()->GetpTextNode() ) &&
 594             pNd->GetNodes().IsDocNodes() )
 595         {
 596             SeqFieldLstElem* pNew = new SeqFieldLstElem(
 597                     pNd->GetExpandText(),
 598                     static_cast<SwSetExpField*>(pF->GetField())->GetSeqNumber() );
 599             rList.InsertSort( pNew );
 600         }
 601     }
 602
 603     return rList.Count();
 604 }
 605
 606 void SwSetExpFieldType::SetChapter( SwSetExpField& rField, const SwNode& rNd )
 607 {
 608     const SwTextNode* pTextNd = rNd.FindOutlineNodeOfLevel( nLevel );
 609     if( pTextNd )
 610     {
 611         SwNumRule * pRule = pTextNd->GetNumRule();
 612
 613         if (pRule)
 614         {
 615             // --> OD 2005-11-02 #i51089 - TUNING#
 616             if ( pTextNd->GetNum() )
 617             {
 618                 const SwNodeNum & aNum = *(pTextNd->GetNum());
 619
 620                 // only get the number, without pre-/post-fixstrings
 621                 OUString sNumber( pRule->MakeNumString(aNum, false ));
 622
 623                 if( !sNumber.isEmpty() )
 624                     rField.ChgExpStr( sNumber + sDelim + rField.GetExpStr() );
 625             }
 626             else
 627             {
 628                 OSL_FAIL( "<SwSetExpFieldType::SetChapter(..)> - text node with numbering rule, but without number. This is a serious defect" );
 629             }
 630         }
 631     }
 632 }
 633
 634 bool SwSetExpFieldType::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
 635 {
 636     switch( nWhichId )
 637     {
 638     case FIELD_PROP_SUBTYPE:
 639         {
 640             sal_Int16 nRet = lcl_SubTypeToAPI(GetType());
 641             rAny <<= nRet;
 642         }
 643         break;
 644     case FIELD_PROP_PAR2:
 645         rAny <<= GetDelimiter();
 646         break;
 647     case FIELD_PROP_SHORT1:
 648         {
 649             sal_Int8 nRet = nLevel < MAXLEVEL? nLevel : -1;
 650             rAny <<= nRet;
 651         }
 652         break;
 653     default:
 654         assert(false);
 655     }
 656     return true;
 657 }
 658
 659 bool SwSetExpFieldType::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
 660 {
 661     switch( nWhichId )
 662     {
 663     case FIELD_PROP_SUBTYPE:
 664         {
 665             sal_Int32 nSet = lcl_APIToSubType(rAny);
 666             if(nSet >=0)
 667                 SetType(static_cast<sal_uInt16>(nSet));
 668         }
 669         break;
 670     case FIELD_PROP_PAR2:
 671         {
 672             OUString sTmp;
 673             rAny >>= sTmp;
 674             if( !sTmp.isEmpty() )
 675                 SetDelimiter( sTmp );
 676             else
 677                 SetDelimiter( " " );
 678         }
 679         break;
 680     case FIELD_PROP_SHORT1:
 681         {
 682             sal_Int8 nLvl = 0;
 683             rAny >>= nLvl;
 684             if(nLvl < 0 || nLvl >= MAXLEVEL)
 685                 SetOutlineLvl(UCHAR_MAX);
 686             else
 687                 SetOutlineLvl(nLvl);
 688         }
 689         break;
 690     default:
 691         assert(false);
 692     }
 693     return true;
 694 }
 695
 696 bool SwSeqFieldList::InsertSort( SeqFieldLstElem* pNew )
 697 {
 698     OUStringBuffer aBuf(pNew->sDlgEntry);
 699     const sal_Int32 nLen = aBuf.getLength();
 700     for (sal_Int32 i = 0; i < nLen; ++i)
 701     {
 702         if (aBuf[i]<' ')
 703         {
 704             aBuf[i]=' ';
 705         }
 706     }
 707     pNew->sDlgEntry = aBuf.makeStringAndClear();
 708
 709     size_t nPos = 0;
 710     bool bRet = SeekEntry( *pNew, &nPos );
 711     if( !bRet )
 712         maData.insert( maData.begin() + nPos, pNew );
 713     return bRet;
 714 }
 715
 716 bool SwSeqFieldList::SeekEntry( const SeqFieldLstElem& rNew, size_t* pP ) const
 717 {
 718     size_t nO = maData.size();
 719     size_t nU = 0;
 720     if( nO > 0 )
 721     {
 722         CollatorWrapper & rCaseColl = ::GetAppCaseCollator(),
 723                         & rColl = ::GetAppCollator();
 724         const CharClass& rCC = GetAppCharClass();
 725
 726         //#59900# Sorting should sort number correctly (e.g. "10" after "9" not after "1")
 727         const OUString rTmp2 = rNew.sDlgEntry;
 728         sal_Int32 nFndPos2 = 0;
 729         const OUString sNum2( rTmp2.getToken( 0, ' ', nFndPos2 ));
 730         bool bIsNum2IsNumeric = CharClass::isAsciiNumeric( sNum2 );
 731         sal_Int32 nNum2 = bIsNum2IsNumeric ? sNum2.toInt32() : 0;
 732
 733         nO--;
 734         while( nU <= nO )
 735         {
 736             const size_t nM = nU + ( nO - nU ) / 2;
 737
 738             //#59900# Sorting should sort number correctly (e.g. "10" after "9" not after "1")
 739             const OUString rTmp1 = maData[nM]->sDlgEntry;
 740             sal_Int32 nFndPos1 = 0;
 741             const OUString sNum1( rTmp1.getToken( 0, ' ', nFndPos1 ));
 742             sal_Int32 nCmp;
 743
 744             if( bIsNum2IsNumeric && rCC.isNumeric( sNum1 ) )
 745             {
 746                 sal_Int32 nNum1 = sNum1.toInt32();
 747                 nCmp = nNum2 - nNum1;
 748                 if( 0 == nCmp )
 749                 {
 750                     OUString aTmp1 = nFndPos1 != -1 ? rTmp1.copy(nFndPos1) : OUString();
 751                     OUString aTmp2 = nFndPos2 != -1 ? rTmp2.copy(nFndPos2) : OUString();
 752                     nCmp = rCaseColl.compareString(aTmp2, aTmp1);
 753                 }
 754             }
 755             else
 756                 nCmp = rColl.compareString( rTmp2, rTmp1 );
 757
 758             if( 0 == nCmp )
 759             {
 760                 if( pP ) *pP = nM;
 761                 return true;
 762             }
 763             else if( 0 < nCmp )
 764                 nU = nM + 1;
 765             else if( nM == 0 )
 766                 break;
 767             else
 768                 nO = nM - 1;
 769         }
 770     }
 771     if( pP ) *pP = nU;
 772     return false;
 773 }
 774
 775 SwSetExpField::SwSetExpField(SwSetExpFieldType* pTyp, const OUString& rFormel,
 776                                         sal_uLong nFormat)
 777     : SwFormulaField( pTyp, nFormat, 0.0 ), nSeqNo( USHRT_MAX ),
 778     nSubType(0)
 779     , mpFormatField(nullptr)
 780 {
 781     SetFormula(rFormel);
 782     // ignore SubType
 783     bInput = false;
 784     if( IsSequenceField() )
 785     {
 786         SwValueField::SetValue(1.0);
 787         if( rFormel.isEmpty() )
 788         {
 789             SetFormula(pTyp->GetName() + "+1");
 790         }
 791     }
 792 }
 793
 794 void SwSetExpField::SetFormatField(SwFormatField & rFormatField)
 795 {
 796     mpFormatField = &rFormatField;
 797 }
 798
 799 OUString SwSetExpField::Expand() const
 800 {
 801     if (nSubType & nsSwExtendedSubType::SUB_CMD)
 802     {   // we need the CommandString
 803         return GetTyp()->GetName() + " = " + GetFormula();
 804     }
 805     if(!(nSubType & nsSwExtendedSubType::SUB_INVISIBLE))
 806     {   // value is visible
 807         return sExpand;
 808     }
 809     return OUString();
 810 }
 811
 812 /// @return the field name
 813 OUString SwSetExpField::GetFieldName() const
 814 {
 815     SwFieldTypesEnum const nStrType( (IsSequenceField())
 816                             ? TYP_SEQFLD
 817                             : (bInput)
 818                                 ? TYP_SETINPFLD
 819                                 : TYP_SETFLD   );
 820
 821     OUString aStr(
 822         SwFieldType::GetTypeStr( static_cast<sal_uInt16>(nStrType) )
 823         + " "
 824         + GetTyp()->GetName() );
 825
 826     // Sequence: without formula
 827     if (TYP_SEQFLD != nStrType)
 828     {
 829         aStr += " = " + GetFormula();
 830     }
 831     return aStr;
 832 }
 833
 834 SwField* SwSetExpField::Copy() const
 835 {
 836     SwSetExpField *pTmp = new SwSetExpField(static_cast<SwSetExpFieldType*>(GetTyp()),
 837                                             GetFormula(), GetFormat());
 838     pTmp->SwValueField::SetValue(GetValue());
 839     pTmp->sExpand       = sExpand;
 840     pTmp->SetAutomaticLanguage(IsAutomaticLanguage());
 841     pTmp->SetLanguage(GetLanguage());
 842     pTmp->aPText        = aPText;
 843     pTmp->bInput        = bInput;
 844     pTmp->nSeqNo        = nSeqNo;
 845     pTmp->SetSubType(GetSubType());
 846
 847     return pTmp;
 848 }
 849
 850 void SwSetExpField::SetSubType(sal_uInt16 nSub)
 851 {
 852     static_cast<SwSetExpFieldType*>(GetTyp())->SetType(nSub & 0xff);
 853     nSubType = nSub & 0xff00;
 854
 855     OSL_ENSURE( (nSub & 0xff) != 3, "SubType ist illegal!" );
 856 }
 857
 858 sal_uInt16 SwSetExpField::GetSubType() const
 859 {
 860     return static_cast<SwSetExpFieldType*>(GetTyp())->GetType() | nSubType;
 861 }
 862
 863 void SwSetExpField::SetValue( const double& rAny )
 864 {
 865     SwValueField::SetValue(rAny);
 866
 867     if( IsSequenceField() )
 868         sExpand = FormatNumber( GetValue(), GetFormat() );
 869     else
 870         sExpand = static_cast<SwValueFieldType*>(GetTyp())->ExpandValue( rAny,
 871                                                 GetFormat(), GetLanguage());
 872 }
 873
 874 void SwGetExpField::SetValue( const double& rAny )
 875 {
 876     SwValueField::SetValue(rAny);
 877     sExpand = static_cast<SwValueFieldType*>(GetTyp())->ExpandValue( rAny, GetFormat(),
 878                                                             GetLanguage());
 879 }
 880
 881 /** Find the index of the reference text following the current field
 882  *
 883  * @param rFormat
 884  * @param rDoc
 885  * @param nHint search starting position after the current field (or 0 if default)
 886  * @return
 887  */
 888 sal_Int32 SwGetExpField::GetReferenceTextPos( const SwFormatField& rFormat, SwDoc& rDoc, sal_Int32 nHint)
 889 {
 890
 891     const SwTextField* pTextField = rFormat.GetTextField();
 892     const SwTextNode& rTextNode = pTextField->GetTextNode();
 893
 894     sal_Int32 nRet = nHint ? nHint : pTextField->GetStart() + 1;
 895     OUString sNodeText = rTextNode.GetText();
 896
 897     if(nRet<sNodeText.getLength())
 898     {
 899         sNodeText = sNodeText.copy(nRet);
 900
 901         // now check if sNodeText starts with a non-alphanumeric character plus blanks
 902         sal_uInt16 nSrcpt = g_pBreakIt->GetRealScriptOfText( sNodeText, 0 );
 903
 904         static const sal_uInt16 nIds[] =
 905         {
 906             RES_CHRATR_LANGUAGE, RES_CHRATR_LANGUAGE,
 907             RES_CHRATR_FONT, RES_CHRATR_FONT,
 908             RES_CHRATR_CJK_LANGUAGE, RES_CHRATR_CJK_LANGUAGE,
 909             RES_CHRATR_CJK_FONT, RES_CHRATR_CJK_FONT,
 910             RES_CHRATR_CTL_LANGUAGE, RES_CHRATR_CTL_LANGUAGE,
 911             RES_CHRATR_CTL_FONT, RES_CHRATR_CTL_FONT,
 912             0, 0
 913         };
 914         SwAttrSet aSet(rDoc.GetAttrPool(), nIds);
 915         rTextNode.GetAttr(aSet, nRet, nRet+1);
 916
 917         if( RTL_TEXTENCODING_SYMBOL != static_cast<const SvxFontItem&>(aSet.Get(
 918                 GetWhichOfScript( RES_CHRATR_FONT, nSrcpt )) ).GetCharSet() )
 919         {
 920             LanguageType eLang = static_cast<const SvxLanguageItem&>(aSet.Get(
 921                 GetWhichOfScript( RES_CHRATR_LANGUAGE, nSrcpt )) ).GetLanguage();
 922             LanguageTag aLanguageTag( eLang);
 923             CharClass aCC( aLanguageTag);
 924             sal_Unicode c0 = sNodeText[0];
 925             bool bIsAlphaNum = aCC.isAlphaNumeric( sNodeText, 0 );
 926             if( !bIsAlphaNum ||
 927                 (c0 == ' ' || c0 == '\t'))
 928             {
 929                 // ignoring blanks
 930                 nRet++;
 931                 const sal_Int32 nLen = sNodeText.getLength();
 932                 for (sal_Int32 i = 1;
 933                      i<nLen && (sNodeText[i]==' ' || sNodeText[i]=='\t');
 934                      ++i
 935                 )
 936                     ++nRet;
 937             }
 938         }
 939     }
 940     return nRet;
 941 }
 942
 943 OUString SwSetExpField::GetPar1() const
 944 {
 945     return static_cast<const SwSetExpFieldType*>(GetTyp())->GetName();
 946 }
 947
 948 OUString SwSetExpField::GetPar2() const
 949 {
 950     sal_uInt16 nType = static_cast<SwSetExpFieldType*>(GetTyp())->GetType();
 951
 952     if (nType & nsSwGetSetExpType::GSE_STRING)
 953         return GetFormula();
 954     return GetExpandedFormula();
 955 }
 956
 957 void SwSetExpField::SetPar2(const OUString& rStr)
 958 {
 959     sal_uInt16 nType = static_cast<SwSetExpFieldType*>(GetTyp())->GetType();
 960
 961     if( !(nType & nsSwGetSetExpType::GSE_SEQ) || !rStr.isEmpty() )
 962     {
 963         if (nType & nsSwGetSetExpType::GSE_STRING)
 964             SetFormula(rStr);
 965         else
 966             SetExpandedFormula(rStr);
 967     }
 968 }
 969
 970 bool SwSetExpField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
 971 {
 972     sal_Int32 nTmp32 = 0;
 973     sal_Int16 nTmp16 = 0;
 974     switch( nWhichId )
 975     {
 976     case FIELD_PROP_BOOL2:
 977         if(*o3tl::doAccess<bool>(rAny))
 978             nSubType &= ~nsSwExtendedSubType::SUB_INVISIBLE;
 979         else
 980             nSubType |= nsSwExtendedSubType::SUB_INVISIBLE;
 981         break;
 982     case FIELD_PROP_FORMAT:
 983         rAny >>= nTmp32;
 984         SetFormat(nTmp32);
 985         break;
 986     case FIELD_PROP_USHORT2:
 987         {
 988             rAny >>= nTmp16;
 989             if(nTmp16 <= SVX_NUMBER_NONE )
 990                 SetFormat(nTmp16);
 991             else {
 992                 //exception(wrong_value)
 993                 ;
 994             }
 995         }
 996         break;
 997     case FIELD_PROP_USHORT1:
 998         rAny >>= nTmp16;
 999         nSeqNo = nTmp16;
1000         break;
1001     case FIELD_PROP_PAR1:
1002         {
1003             OUString sTmp;
1004             rAny >>= sTmp;
1005             SetPar1( SwStyleNameMapper::GetUIName( sTmp, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL ) );
1006         }
1007         break;
1008     case FIELD_PROP_PAR2:
1009         {
1010             OUString uTmp;
1011             rAny >>= uTmp;
1012             //I18N - if the formula contains only "TypeName+1"
1013             //and it's one of the initially created sequence fields
1014             //then the localized names has to be replaced by a programmatic name
1015             OUString sMyFormula = SwXFieldMaster::LocalizeFormula(*this, uTmp, false);
1016             SetFormula( sMyFormula );
1017         }
1018         break;
1019     case FIELD_PROP_DOUBLE:
1020         {
1021             double fVal = 0.0;
1022             rAny >>= fVal;
1023             SetValue(fVal);
1024         }
1025         break;
1026     case FIELD_PROP_SUBTYPE:
1027         nTmp32 = lcl_APIToSubType(rAny);
1028         if(nTmp32 >= 0)
1029             SetSubType(static_cast<sal_uInt16>((GetSubType() & 0xff00) | nTmp32));
1030         break;
1031     case FIELD_PROP_PAR3:
1032         rAny >>= aPText;
1033         break;
1034     case FIELD_PROP_BOOL3:
1035         if(*o3tl::doAccess<bool>(rAny))
1036             nSubType |= nsSwExtendedSubType::SUB_CMD;
1037         else
1038             nSubType &= (~nsSwExtendedSubType::SUB_CMD);
1039         break;
1040     case FIELD_PROP_BOOL1:
1041         SetInputFlag(*o3tl::doAccess<bool>(rAny));
1042         break;
1043     case FIELD_PROP_PAR4:
1044         {
1045             OUString sTmp;
1046             rAny >>= sTmp;
1047             ChgExpStr( sTmp );
1048         }
1049         break;
1050     default:
1051         return SwField::PutValue(rAny, nWhichId);
1052     }
1053     return true;
1054 }
1055
1056 bool SwSetExpField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
1057 {
1058     switch( nWhichId )
1059     {
1060     case FIELD_PROP_BOOL2:
1061         rAny <<= 0 == (nSubType & nsSwExtendedSubType::SUB_INVISIBLE);
1062         break;
1063     case FIELD_PROP_FORMAT:
1064         rAny <<= (sal_Int32)GetFormat();
1065         break;
1066     case FIELD_PROP_USHORT2:
1067         rAny <<= (sal_Int16)GetFormat();
1068         break;
1069     case FIELD_PROP_USHORT1:
1070         rAny <<= (sal_Int16)nSeqNo;
1071         break;
1072     case FIELD_PROP_PAR1:
1073         rAny <<= OUString ( SwStyleNameMapper::GetProgName(GetPar1(), nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL ) );
1074         break;
1075     case FIELD_PROP_PAR2:
1076         {
1077             //I18N - if the formula contains only "TypeName+1"
1078             //and it's one of the initially created sequence fields
1079             //then the localized names has to be replaced by a programmatic name
1080             OUString sMyFormula = SwXFieldMaster::LocalizeFormula(*this, GetFormula(), true);
1081             rAny <<= OUString( sMyFormula );
1082         }
1083         break;
1084     case FIELD_PROP_DOUBLE:
1085         rAny <<= (double)GetValue();
1086         break;
1087     case FIELD_PROP_SUBTYPE:
1088         {
1089             sal_Int16 nRet = 0;
1090                 nRet = lcl_SubTypeToAPI(GetSubType() & 0xff);
1091             rAny <<= nRet;
1092         }
1093         break;
1094     case FIELD_PROP_PAR3:
1095         rAny <<= OUString( aPText );
1096         break;
1097     case FIELD_PROP_BOOL3:
1098         rAny <<= 0 != (nSubType & nsSwExtendedSubType::SUB_CMD);
1099         break;
1100     case FIELD_PROP_BOOL1:
1101         rAny <<= GetInputFlag();
1102         break;
1103     case FIELD_PROP_PAR4:
1104         rAny <<= OUString(GetExpStr());
1105         break;
1106     default:
1107         return SwField::QueryValue(rAny, nWhichId);
1108     }
1109     return true;
1110 }
1111
1112 SwInputFieldType::SwInputFieldType( SwDoc* pD )
1113     : SwFieldType( RES_INPUTFLD )
1114     , pDoc( pD )
1115 {
1116 }
1117
1118 SwFieldType* SwInputFieldType::Copy() const
1119 {
1120     SwInputFieldType* pType = new SwInputFieldType( pDoc );
1121     return pType;
1122 }
1123
1124 SwInputField::SwInputField( SwInputFieldType* pFieldType,
1125                             const OUString& rContent,
1126                             const OUString& rPrompt,
1127                             sal_uInt16 nSub,
1128                             sal_uLong nFormat,
1129                             bool bIsFormField )
1130     : SwField( pFieldType, nFormat, LANGUAGE_SYSTEM, false )
1131     , aContent(rContent)
1132     , aPText(rPrompt)
1133     , nSubType(nSub)
1134     , mbIsFormField( bIsFormField )
1135     , mpFormatField( nullptr )
1136 {
1137 }
1138
1139 SwInputField::~SwInputField()
1140 {
1141 }
1142
1143 void SwInputField::SetFormatField( SwFormatField& rFormatField )
1144 {
1145     mpFormatField = &rFormatField;
1146 }
1147
1148
1149 void SwInputField::LockNotifyContentChange()
1150 {
1151     if ( GetFormatField() != nullptr )
1152     {
1153         SwTextInputField* pTextInputField = dynamic_cast< SwTextInputField* >(GetFormatField()->GetTextField());
1154         if ( pTextInputField != nullptr )
1155         {
1156             pTextInputField->LockNotifyContentChange();
1157         }
1158     }
1159 }
1160
1161 void SwInputField::UnlockNotifyContentChange()
1162 {
1163     if ( GetFormatField() != nullptr )
1164     {
1165         SwTextInputField* pTextInputField = dynamic_cast< SwTextInputField* >(GetFormatField()->GetTextField());
1166         if ( pTextInputField != nullptr )
1167         {
1168             pTextInputField->UnlockNotifyContentChange();
1169         }
1170     }
1171 }
1172
1173 void SwInputField::applyFieldContent( const OUString& rNewFieldContent )
1174 {
1175     if ( (nSubType & 0x00ff) == INP_TXT )
1176     {
1177         aContent = rNewFieldContent;
1178     }
1179     else if( (nSubType & 0x00ff) == INP_USR )
1180     {
1181         SwUserFieldType* pUserTyp = static_cast<SwUserFieldType*>(
1182             static_cast<SwInputFieldType*>(GetTyp())->GetDoc()->getIDocumentFieldsAccess().GetFieldType( RES_USERFLD, getContent(), false ) );
1183         if( pUserTyp )
1184         {
1185             pUserTyp->SetContent( rNewFieldContent );
1186
1187             // trigger update of the corresponding User Fields and other related Input Fields
1188             {
1189                 LockNotifyContentChange();
1190                 pUserTyp->UpdateFields();
1191                 UnlockNotifyContentChange();
1192             }
1193         }
1194     }
1195 }
1196
1197 OUString SwInputField::GetFieldName() const
1198 {
1199     OUString aStr(SwField::GetFieldName());
1200     if ((nSubType & 0x00ff) == INP_USR)
1201     {
1202         aStr += GetTyp()->GetName() + " " + getContent();
1203     }
1204     return aStr;
1205 }
1206
1207 SwField* SwInputField::Copy() const
1208 {
1209     SwInputField* pField =
1210         new SwInputField(
1211             static_cast<SwInputFieldType*>(GetTyp()),
1212             getContent(),
1213             aPText,
1214             GetSubType(),
1215             GetFormat(),
1216             mbIsFormField );
1217
1218     pField->SetHelp( aHelp );
1219     pField->SetToolTip( aToolTip );
1220
1221     pField->SetAutomaticLanguage(IsAutomaticLanguage());
1222     return pField;
1223 }
1224
1225 OUString SwInputField::Expand() const
1226 {
1227     if((nSubType & 0x00ff) == INP_TXT)
1228     {
1229         return getContent();
1230     }
1231
1232     if( (nSubType & 0x00ff) == INP_USR )
1233     {
1234         SwUserFieldType* pUserTyp = static_cast<SwUserFieldType*>(
1235             static_cast<SwInputFieldType*>(GetTyp())->GetDoc()->getIDocumentFieldsAccess().GetFieldType( RES_USERFLD, getContent(), false ) );
1236         if( pUserTyp )
1237             return pUserTyp->GetContent();
1238     }
1239
1240     return OUString();
1241 }
1242
1243 bool SwInputField::isFormField() const
1244 {
1245     return mbIsFormField
1246            || !aHelp.isEmpty()
1247            || !aToolTip.isEmpty();
1248 }
1249
1250 bool SwInputField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
1251 {
1252     switch( nWhichId )
1253     {
1254     case FIELD_PROP_PAR1:
1255         rAny <<= getContent();
1256         break;
1257     case FIELD_PROP_PAR2:
1258         rAny <<= aPText;
1259         break;
1260     case FIELD_PROP_PAR3:
1261         rAny <<= aHelp;
1262         break;
1263     case FIELD_PROP_PAR4:
1264         rAny <<= aToolTip;
1265         break;
1266     default:
1267         assert(false);
1268     }
1269     return true;
1270 }
1271
1272 bool SwInputField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
1273 {
1274     switch( nWhichId )
1275     {
1276     case FIELD_PROP_PAR1:
1277         rAny >>= aContent;
1278         break;
1279     case FIELD_PROP_PAR2:
1280         rAny >>= aPText;
1281         break;
1282     case FIELD_PROP_PAR3:
1283         rAny >>= aHelp;
1284         break;
1285     case FIELD_PROP_PAR4:
1286         rAny >>= aToolTip;
1287         break;
1288     default:
1289         assert(false);
1290     }
1291     return true;
1292 }
1293
1294 /// set condition
1295 void SwInputField::SetPar1(const OUString& rStr)
1296 {
1297     aContent = rStr;
1298 }
1299
1300 OUString SwInputField::GetPar1() const
1301 {
1302     return getContent();
1303 }
1304
1305 void SwInputField::SetPar2(const OUString& rStr)
1306 {
1307     aPText = rStr;
1308 }
1309
1310 OUString SwInputField::GetPar2() const
1311 {
1312     return aPText;
1313 }
1314
1315 void SwInputField::SetHelp(const OUString & rStr)
1316 {
1317     aHelp = rStr;
1318 }
1319
1320 const OUString& SwInputField::GetHelp() const
1321 {
1322     return aHelp;
1323 }
1324
1325 void SwInputField::SetToolTip(const OUString & rStr)
1326 {
1327     aToolTip = rStr;
1328 }
1329
1330 const OUString& SwInputField::GetToolTip() const
1331 {
1332     return aToolTip;
1333 }
1334
1335 sal_uInt16 SwInputField::GetSubType() const
1336 {
1337     return nSubType;
1338 }
1339
1340 void SwInputField::SetSubType(sal_uInt16 nSub)
1341 {
1342     nSubType = nSub;
1343 }
1344
1345 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */