LCOV - code coverage report
Current view: top level - sw/source/core/fields - docufld.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 1228 0.0 %
Date: 2014-04-14 Functions: 0 164 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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 <textapi.hxx>
      21             : 
      22             : #include <hintids.hxx>
      23             : #include <com/sun/star/text/XText.hpp>
      24             : #include <com/sun/star/script/Converter.hpp>
      25             : #include <com/sun/star/text/SetVariableType.hpp>
      26             : #include <com/sun/star/text/XTextFieldsSupplier.hpp>
      27             : #include <com/sun/star/text/UserDataPart.hpp>
      28             : #include <com/sun/star/text/ChapterFormat.hpp>
      29             : #include <com/sun/star/text/XTextField.hpp>
      30             : #include <com/sun/star/text/PlaceholderType.hpp>
      31             : #include <com/sun/star/text/TemplateDisplayFormat.hpp>
      32             : #include <com/sun/star/text/UserFieldFormat.hpp>
      33             : #include <com/sun/star/text/PageNumberType.hpp>
      34             : #include <com/sun/star/text/ReferenceFieldPart.hpp>
      35             : #include <com/sun/star/text/FilenameDisplayFormat.hpp>
      36             : #include <com/sun/star/text/XDependentTextField.hpp>
      37             : #include <com/sun/star/text/DocumentStatistic.hpp>
      38             : #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
      39             : #include <com/sun/star/document/XDocumentProperties.hpp>
      40             : #include <com/sun/star/util/Date.hpp>
      41             : #include <com/sun/star/util/Duration.hpp>
      42             : #include <unotools/localedatawrapper.hxx>
      43             : #include <editeng/unolingu.hxx>
      44             : #include <comphelper/processfactory.hxx>
      45             : #include <comphelper/types.hxx>
      46             : #include <comphelper/string.hxx>
      47             : #include <tools/urlobj.hxx>
      48             : #include <vcl/svapp.hxx>
      49             : #include <svl/urihelper.hxx>
      50             : #include <unotools/useroptions.hxx>
      51             : #include <unotools/syslocale.hxx>
      52             : #include <svl/zforlist.hxx>
      53             : 
      54             : #include <tools/time.hxx>
      55             : #include <tools/datetime.hxx>
      56             : 
      57             : #include <com/sun/star/beans/PropertyAttribute.hpp>
      58             : #include <com/sun/star/util/DateTime.hpp>
      59             : #include <com/sun/star/util/Time.hpp>
      60             : 
      61             : #include <tools/shl.hxx>
      62             : #include <swmodule.hxx>
      63             : #include <sfx2/app.hxx>
      64             : #include <sfx2/docfile.hxx>
      65             : #include <sfx2/doctempl.hxx>
      66             : #include <fmtfld.hxx>
      67             : #include <txtfld.hxx>
      68             : #include <charfmt.hxx>
      69             : #include <docstat.hxx>
      70             : #include <pagedesc.hxx>
      71             : #include <fmtpdsc.hxx>
      72             : #include <doc.hxx>
      73             : #include <rootfrm.hxx>
      74             : #include <pagefrm.hxx>
      75             : #include <cntfrm.hxx>
      76             : #include <pam.hxx>
      77             : #include <viewsh.hxx>
      78             : #include <dbmgr.hxx>
      79             : #include <shellres.hxx>
      80             : #include <docufld.hxx>
      81             : #include <flddat.hxx>
      82             : #include <docfld.hxx>
      83             : #include <ndtxt.hxx>
      84             : #include <expfld.hxx>
      85             : #include <poolfmt.hxx>
      86             : #include <docsh.hxx>
      87             : #include <unofldmid.h>
      88             : #include <swunohelper.hxx>
      89             : #include <comcore.hrc>
      90             : 
      91             : #include <editeng/outliner.hxx>
      92             : #include <editeng/outlobj.hxx>
      93             : #include <switerator.hxx>
      94             : #include <docary.hxx>
      95             : 
      96             : #define URL_DECODE  INetURLObject::DECODE_UNAMBIGUOUS
      97             : 
      98             : using namespace ::com::sun::star;
      99             : using namespace ::com::sun::star::uno;
     100             : using namespace nsSwDocInfoSubType;
     101             : 
     102             : // SwPageNumberFieldType
     103             : 
     104           0 : SwPageNumberFieldType::SwPageNumberFieldType()
     105             :     : SwFieldType( RES_PAGENUMBERFLD ),
     106             :     nNumberingType( SVX_NUM_ARABIC ),
     107           0 :     bVirtuell( false )
     108             : {
     109           0 : }
     110             : 
     111           0 : OUString SwPageNumberFieldType::Expand( sal_uInt32 nFmt, short nOff,
     112             :          sal_uInt16 const nPageNumber, sal_uInt16 const nMaxPage,
     113             :          const OUString& rUserStr ) const
     114             : {
     115           0 :     sal_uInt32 nTmpFmt = (SVX_NUM_PAGEDESC == nFmt) ? (sal_uInt32)nNumberingType : nFmt;
     116           0 :     int const nTmp = nPageNumber + nOff;
     117             : 
     118           0 :     if (0 > nTmp || SVX_NUM_NUMBER_NONE == nTmpFmt || (!bVirtuell && nTmp > nMaxPage))
     119           0 :         return OUString();
     120             : 
     121           0 :     if( SVX_NUM_CHAR_SPECIAL == nTmpFmt )
     122           0 :         return rUserStr;
     123             : 
     124           0 :     return FormatNumber( (sal_uInt16)nTmp, nTmpFmt );
     125             : }
     126             : 
     127           0 : SwFieldType* SwPageNumberFieldType::Copy() const
     128             : {
     129           0 :     SwPageNumberFieldType *pTmp = new SwPageNumberFieldType();
     130             : 
     131           0 :     pTmp->nNumberingType = nNumberingType;
     132           0 :     pTmp->bVirtuell  = bVirtuell;
     133             : 
     134           0 :     return pTmp;
     135             : }
     136             : 
     137           0 : void SwPageNumberFieldType::ChangeExpansion( SwDoc* pDoc,
     138             :                                             sal_Bool bVirt,
     139             :                                             const sal_Int16* pNumFmt )
     140             : {
     141           0 :     if( pNumFmt )
     142           0 :         nNumberingType = *pNumFmt;
     143             : 
     144           0 :     bVirtuell = false;
     145           0 :     if (bVirt && pDoc)
     146             :     {
     147             :         // check the flag since the layout NEVER sets it back
     148           0 :         const SfxItemPool &rPool = pDoc->GetAttrPool();
     149             :         const SwFmtPageDesc *pDesc;
     150           0 :         sal_uInt32 nMaxItems = rPool.GetItemCount2( RES_PAGEDESC );
     151           0 :         for( sal_uInt32 n = 0; n < nMaxItems; ++n )
     152           0 :             if( 0 != (pDesc = (SwFmtPageDesc*)rPool.GetItem2( RES_PAGEDESC, n ) )
     153           0 :                 && pDesc->GetNumOffset() && pDesc->GetDefinedIn() )
     154             :             {
     155           0 :                 SwCntntNode* pNd = PTR_CAST( SwCntntNode, pDesc->GetDefinedIn() );
     156           0 :                 if( pNd )
     157             :                 {
     158           0 :                     if ( SwIterator<SwFrm,SwCntntNode>::FirstElement(*pNd) )
     159           0 :                         bVirtuell = true;
     160             :                 }
     161           0 :                 else if( pDesc->GetDefinedIn()->ISA( SwFmt ))
     162             :                 {
     163           0 :                     SwAutoFmtGetDocNode aGetHt( &pDoc->GetNodes() );
     164           0 :                     bVirtuell = !pDesc->GetDefinedIn()->GetInfo( aGetHt );
     165           0 :                     break;
     166             :                 }
     167             :             }
     168             :     }
     169           0 : }
     170             : 
     171             : // SwPageNumberField
     172             : 
     173           0 : SwPageNumberField::SwPageNumberField(SwPageNumberFieldType* pTyp,
     174             :           sal_uInt16 nSub, sal_uInt32 nFmt, short nOff,
     175             :           sal_uInt16 const nPageNumber, sal_uInt16 const nMaxPage)
     176             :     : SwField(pTyp, nFmt), nSubType(nSub), nOffset(nOff)
     177             :     , m_nPageNumber(nPageNumber)
     178           0 :     , m_nMaxPage(nMaxPage)
     179             : {
     180           0 : }
     181             : 
     182           0 : void SwPageNumberField::ChangeExpansion(sal_uInt16 const nPageNumber,
     183             :         sal_uInt16 const nMaxPage)
     184             : {
     185           0 :     m_nPageNumber = nPageNumber;
     186           0 :     m_nMaxPage = nMaxPage;
     187           0 : }
     188             : 
     189           0 : OUString SwPageNumberField::Expand() const
     190             : {
     191           0 :     OUString sRet;
     192           0 :     SwPageNumberFieldType* pFldType = (SwPageNumberFieldType*)GetTyp();
     193             : 
     194           0 :     if( PG_NEXT == nSubType && 1 != nOffset )
     195             :     {
     196           0 :         sRet = pFldType->Expand(GetFormat(), 1, m_nPageNumber, m_nMaxPage, sUserStr);
     197           0 :         if (!sRet.isEmpty())
     198             :         {
     199           0 :             sRet = pFldType->Expand(GetFormat(), nOffset, m_nPageNumber, m_nMaxPage, sUserStr);
     200             :         }
     201             :     }
     202           0 :     else if( PG_PREV == nSubType && -1 != nOffset )
     203             :     {
     204           0 :         sRet = pFldType->Expand(GetFormat(), -1, m_nPageNumber, m_nMaxPage, sUserStr);
     205           0 :         if (!sRet.isEmpty())
     206             :         {
     207           0 :             sRet = pFldType->Expand(GetFormat(), nOffset, m_nPageNumber, m_nMaxPage, sUserStr);
     208             :         }
     209             :     }
     210             :     else
     211           0 :         sRet = pFldType->Expand(GetFormat(), nOffset, m_nPageNumber, m_nMaxPage, sUserStr);
     212           0 :     return sRet;
     213             : }
     214             : 
     215           0 : SwField* SwPageNumberField::Copy() const
     216             : {
     217             :     SwPageNumberField *pTmp = new SwPageNumberField(
     218           0 :                 static_cast<SwPageNumberFieldType*>(GetTyp()), nSubType,
     219           0 :                 GetFormat(), nOffset, m_nPageNumber, m_nMaxPage);
     220           0 :     pTmp->SetLanguage( GetLanguage() );
     221           0 :     pTmp->SetUserString( sUserStr );
     222           0 :     return pTmp;
     223             : }
     224             : 
     225           0 : OUString SwPageNumberField::GetPar2() const
     226             : {
     227           0 :     return OUString::number(nOffset);
     228             : }
     229             : 
     230           0 : void SwPageNumberField::SetPar2(const OUString& rStr)
     231             : {
     232           0 :     nOffset = (short)rStr.toInt32();
     233           0 : }
     234             : 
     235           0 : sal_uInt16 SwPageNumberField::GetSubType() const
     236             : {
     237           0 :     return nSubType;
     238             : }
     239             : 
     240           0 : bool SwPageNumberField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
     241             : {
     242           0 :     switch( nWhichId )
     243             :     {
     244             :     case FIELD_PROP_FORMAT:
     245           0 :         rAny <<= (sal_Int16)GetFormat();
     246           0 :         break;
     247             :     case FIELD_PROP_USHORT1:
     248           0 :         rAny <<= nOffset;
     249           0 :         break;
     250             :     case FIELD_PROP_SUBTYPE:
     251             :         {
     252             :              text::PageNumberType eType;
     253           0 :             eType = text::PageNumberType_CURRENT;
     254           0 :             if(nSubType == PG_PREV)
     255           0 :                 eType = text::PageNumberType_PREV;
     256           0 :             else if(nSubType == PG_NEXT)
     257           0 :                 eType = text::PageNumberType_NEXT;
     258           0 :             rAny.setValue(&eType, ::getCppuType((const text::PageNumberType*)0));
     259             :         }
     260           0 :         break;
     261             :     case FIELD_PROP_PAR1:
     262           0 :         rAny <<= sUserStr;
     263           0 :         break;
     264             : 
     265             :     default:
     266             :         OSL_FAIL("illegal property");
     267             :     }
     268           0 :     return true;
     269             : }
     270             : 
     271           0 : bool SwPageNumberField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
     272             : {
     273           0 :     bool bRet = true;
     274           0 :     sal_Int16 nSet = 0;
     275           0 :     switch( nWhichId )
     276             :     {
     277             :     case FIELD_PROP_FORMAT:
     278           0 :         rAny >>= nSet;
     279             : 
     280             :         // TODO: woher kommen die defines?
     281           0 :         if(nSet <= SVX_NUM_PAGEDESC )
     282           0 :             SetFormat(nSet);
     283             :         else {
     284             :         }
     285           0 :         break;
     286             :     case FIELD_PROP_USHORT1:
     287           0 :         rAny >>= nSet;
     288           0 :         nOffset = nSet;
     289           0 :         break;
     290             :     case FIELD_PROP_SUBTYPE:
     291           0 :         switch( SWUnoHelper::GetEnumAsInt32( rAny ) )
     292             :         {
     293             :             case text::PageNumberType_CURRENT:
     294           0 :                 nSubType = PG_RANDOM;
     295           0 :             break;
     296             :             case text::PageNumberType_PREV:
     297           0 :                 nSubType = PG_PREV;
     298           0 :             break;
     299             :             case text::PageNumberType_NEXT:
     300           0 :                 nSubType = PG_NEXT;
     301           0 :             break;
     302             :             default:
     303           0 :                 bRet = false;
     304             :         }
     305           0 :         break;
     306             :     case FIELD_PROP_PAR1:
     307           0 :         rAny >>= sUserStr;
     308           0 :         break;
     309             : 
     310             :     default:
     311             :         OSL_FAIL("illegal property");
     312             :     }
     313           0 :     return bRet;
     314             : }
     315             : // SwAuthorFieldType
     316             : 
     317           0 : SwAuthorFieldType::SwAuthorFieldType()
     318           0 :     : SwFieldType( RES_AUTHORFLD )
     319             : {
     320           0 : }
     321             : 
     322           0 : OUString SwAuthorFieldType::Expand(sal_uLong nFmt) const
     323             : {
     324           0 :     SvtUserOptions&  rOpt = SW_MOD()->GetUserOptions();
     325           0 :     if((nFmt & 0xff) == AF_NAME)
     326           0 :         return rOpt.GetFullName();
     327             : 
     328           0 :     return rOpt.GetID();
     329             : }
     330             : 
     331           0 : SwFieldType* SwAuthorFieldType::Copy() const
     332             : {
     333           0 :     return new SwAuthorFieldType;
     334             : }
     335             : 
     336             : // SwAuthorField
     337             : 
     338           0 : SwAuthorField::SwAuthorField(SwAuthorFieldType* pTyp, sal_uInt32 nFmt)
     339           0 :     : SwField(pTyp, nFmt)
     340             : {
     341           0 :     aContent = ((SwAuthorFieldType*)GetTyp())->Expand(GetFormat());
     342           0 : }
     343             : 
     344           0 : OUString SwAuthorField::Expand() const
     345             : {
     346           0 :     if (!IsFixed())
     347           0 :         ((SwAuthorField*)this)->aContent =
     348           0 :                     ((SwAuthorFieldType*)GetTyp())->Expand(GetFormat());
     349             : 
     350           0 :     return aContent;
     351             : }
     352             : 
     353           0 : SwField* SwAuthorField::Copy() const
     354             : {
     355           0 :     SwAuthorField *pTmp = new SwAuthorField( (SwAuthorFieldType*)GetTyp(),
     356           0 :                                                 GetFormat());
     357           0 :     pTmp->SetExpansion(aContent);
     358           0 :     return pTmp;
     359             : }
     360             : 
     361           0 : bool SwAuthorField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
     362             : {
     363             :     bool bVal;
     364           0 :     switch( nWhichId )
     365             :     {
     366             :     case FIELD_PROP_BOOL1:
     367           0 :         bVal = (GetFormat() & 0xff) == AF_NAME;
     368           0 :         rAny.setValue(&bVal, ::getBooleanCppuType());
     369           0 :         break;
     370             : 
     371             :     case FIELD_PROP_BOOL2:
     372           0 :         bVal = IsFixed();
     373           0 :         rAny.setValue(&bVal, ::getBooleanCppuType());
     374           0 :         break;
     375             : 
     376             :     case FIELD_PROP_PAR1:
     377           0 :         rAny <<= GetContent();
     378           0 :         break;
     379             : 
     380             :     default:
     381             :         OSL_FAIL("illegal property");
     382             :     }
     383           0 :     return true;
     384             : }
     385             : 
     386           0 : bool SwAuthorField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
     387             : {
     388           0 :     switch( nWhichId )
     389             :     {
     390             :     case FIELD_PROP_BOOL1:
     391           0 :         SetFormat( *(sal_Bool*)rAny.getValue() ? AF_NAME : AF_SHORTCUT );
     392           0 :         break;
     393             : 
     394             :     case FIELD_PROP_BOOL2:
     395           0 :         if( *(sal_Bool*)rAny.getValue() )
     396           0 :             SetFormat( GetFormat() | AF_FIXED);
     397             :         else
     398           0 :             SetFormat( GetFormat() & ~AF_FIXED);
     399           0 :         break;
     400             : 
     401             :     case FIELD_PROP_PAR1:
     402           0 :         rAny >>= aContent;
     403           0 :         break;
     404             : 
     405             :     default:
     406             :         OSL_FAIL("illegal property");
     407             :     }
     408           0 :     return true;
     409             : }
     410             : 
     411             : // SwFileNameFieldType
     412             : 
     413           0 : SwFileNameFieldType::SwFileNameFieldType(SwDoc *pDocument)
     414           0 :     : SwFieldType( RES_FILENAMEFLD )
     415             : {
     416           0 :     pDoc = pDocument;
     417           0 : }
     418             : 
     419           0 : OUString SwFileNameFieldType::Expand(sal_uLong nFmt) const
     420             : {
     421           0 :     OUString aRet;
     422           0 :     const SwDocShell* pDShell = pDoc->GetDocShell();
     423           0 :     if( pDShell && pDShell->HasName() )
     424             :     {
     425           0 :         const INetURLObject& rURLObj = pDShell->GetMedium()->GetURLObject();
     426           0 :         switch( nFmt & ~FF_FIXED )
     427             :         {
     428             :             case FF_PATH:
     429             :                 {
     430           0 :                     if( INET_PROT_FILE == rURLObj.GetProtocol() )
     431             :                     {
     432           0 :                         INetURLObject aTemp(rURLObj);
     433           0 :                         aTemp.removeSegment();
     434             :                         // last slash should belong to the pathname
     435           0 :                         aRet = aTemp.PathToFileName();
     436             :                     }
     437             :                     else
     438             :                     {
     439           0 :                         aRet = URIHelper::removePassword(
     440             :                                     rURLObj.GetMainURL( INetURLObject::NO_DECODE ),
     441           0 :                                     INetURLObject::WAS_ENCODED, URL_DECODE );
     442           0 :                         const sal_Int32 nPos = aRet.indexOf(rURLObj.GetLastName( URL_DECODE ));
     443           0 :                         if (nPos>=0)
     444             :                         {
     445           0 :                             aRet = aRet.copy(0, nPos);
     446             :                         }
     447             :                     }
     448             :                 }
     449           0 :                 break;
     450             : 
     451             :             case FF_NAME:
     452           0 :                 aRet = rURLObj.GetLastName( INetURLObject::DECODE_WITH_CHARSET );
     453           0 :                 break;
     454             : 
     455             :             case FF_NAME_NOEXT:
     456           0 :                 aRet = rURLObj.GetBase();
     457           0 :                 break;
     458             : 
     459             :             default:
     460           0 :                 if( INET_PROT_FILE == rURLObj.GetProtocol() )
     461           0 :                     aRet = rURLObj.GetFull();
     462             :                 else
     463           0 :                     aRet = URIHelper::removePassword(
     464             :                                     rURLObj.GetMainURL( INetURLObject::NO_DECODE ),
     465           0 :                                     INetURLObject::WAS_ENCODED, URL_DECODE );
     466             :         }
     467             :     }
     468           0 :     return aRet;
     469             : }
     470             : 
     471           0 : SwFieldType* SwFileNameFieldType::Copy() const
     472             : {
     473           0 :     SwFieldType *pTmp = new SwFileNameFieldType(pDoc);
     474           0 :     return pTmp;
     475             : }
     476             : 
     477             : // SwFileNameField
     478             : 
     479           0 : SwFileNameField::SwFileNameField(SwFileNameFieldType* pTyp, sal_uInt32 nFmt)
     480           0 :     : SwField(pTyp, nFmt)
     481             : {
     482           0 :     aContent = ((SwFileNameFieldType*)GetTyp())->Expand(GetFormat());
     483           0 : }
     484             : 
     485           0 : OUString SwFileNameField::Expand() const
     486             : {
     487           0 :     if (!IsFixed())
     488           0 :         ((SwFileNameField*)this)->aContent = ((SwFileNameFieldType*)GetTyp())->Expand(GetFormat());
     489             : 
     490           0 :     return aContent;
     491             : }
     492             : 
     493           0 : SwField* SwFileNameField::Copy() const
     494             : {
     495             :     SwFileNameField *pTmp =
     496           0 :         new SwFileNameField((SwFileNameFieldType*)GetTyp(), GetFormat());
     497           0 :     pTmp->SetExpansion(aContent);
     498             : 
     499           0 :     return pTmp;
     500             : }
     501             : 
     502           0 : bool SwFileNameField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
     503             : {
     504           0 :     switch( nWhichId )
     505             :     {
     506             :     case FIELD_PROP_FORMAT:
     507             :         {
     508             :             sal_Int16 nRet;
     509           0 :             switch( GetFormat() &(~FF_FIXED) )
     510             :             {
     511             :                 case FF_PATH:
     512           0 :                     nRet = text::FilenameDisplayFormat::PATH;
     513           0 :                 break;
     514             :                 case FF_NAME_NOEXT:
     515           0 :                     nRet = text::FilenameDisplayFormat::NAME;
     516           0 :                 break;
     517             :                 case FF_NAME:
     518           0 :                     nRet = text::FilenameDisplayFormat::NAME_AND_EXT;
     519           0 :                 break;
     520           0 :                 default:    nRet = text::FilenameDisplayFormat::FULL;
     521             :             }
     522           0 :             rAny <<= nRet;
     523             :         }
     524           0 :         break;
     525             : 
     526             :     case FIELD_PROP_BOOL2:
     527             :         {
     528           0 :             sal_Bool bVal = IsFixed();
     529           0 :             rAny.setValue(&bVal, ::getBooleanCppuType());
     530             :         }
     531           0 :         break;
     532             : 
     533             :     case FIELD_PROP_PAR3:
     534           0 :         rAny <<= GetContent();
     535           0 :         break;
     536             :     default:
     537             :         OSL_FAIL("illegal property");
     538             :     }
     539           0 :     return true;
     540             : }
     541             : 
     542           0 : bool SwFileNameField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
     543             : {
     544           0 :     switch( nWhichId )
     545             :     {
     546             :     case FIELD_PROP_FORMAT:
     547             :         {
     548             :             //JP 24.10.2001: int32 because in UnoField.cxx a putvalue is
     549             :             //              called with a int32 value! But normally we need
     550             :             //              here only a int16
     551           0 :             sal_Int32 nType = 0;
     552           0 :             rAny >>= nType;
     553           0 :             sal_Bool bFixed = IsFixed();
     554           0 :             switch( nType )
     555             :             {
     556             :                 case text::FilenameDisplayFormat::PATH:
     557           0 :                     nType = FF_PATH;
     558           0 :                 break;
     559             :                 case text::FilenameDisplayFormat::NAME:
     560           0 :                     nType = FF_NAME_NOEXT;
     561           0 :                 break;
     562             :                 case text::FilenameDisplayFormat::NAME_AND_EXT:
     563           0 :                     nType = FF_NAME;
     564           0 :                 break;
     565           0 :                 default:    nType = FF_PATHNAME;
     566             :             }
     567           0 :             if(bFixed)
     568           0 :                 nType |= FF_FIXED;
     569           0 :             SetFormat(nType);
     570             :         }
     571           0 :         break;
     572             : 
     573             :     case FIELD_PROP_BOOL2:
     574           0 :         if( *(sal_Bool*)rAny.getValue() )
     575           0 :             SetFormat( GetFormat() | FF_FIXED);
     576             :         else
     577           0 :             SetFormat( GetFormat() & ~FF_FIXED);
     578           0 :         break;
     579             : 
     580             :     case FIELD_PROP_PAR3:
     581           0 :         rAny >>= aContent;
     582           0 :         break;
     583             : 
     584             :     default:
     585             :         OSL_FAIL("illegal property");
     586             :     }
     587           0 :     return true;
     588             : }
     589             : 
     590             : // SwTemplNameFieldType
     591             : 
     592           0 : SwTemplNameFieldType::SwTemplNameFieldType(SwDoc *pDocument)
     593           0 :     : SwFieldType( RES_TEMPLNAMEFLD )
     594             : {
     595           0 :     pDoc = pDocument;
     596           0 : }
     597             : 
     598           0 : OUString SwTemplNameFieldType::Expand(sal_uLong nFmt) const
     599             : {
     600             :     OSL_ENSURE( nFmt < FF_END, "Expand: kein guelt. Fmt!" );
     601             : 
     602           0 :     OUString aRet;
     603           0 :     SwDocShell *pDocShell(pDoc->GetDocShell());
     604             :     OSL_ENSURE(pDocShell, "no SwDocShell");
     605           0 :     if (pDocShell) {
     606             :         uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
     607           0 :             pDocShell->GetModel(), uno::UNO_QUERY_THROW);
     608             :         uno::Reference<document::XDocumentProperties> xDocProps(
     609           0 :             xDPS->getDocumentProperties());
     610             :         OSL_ENSURE(xDocProps.is(), "Doc has no DocumentProperties");
     611             : 
     612           0 :         if( FF_UI_NAME == nFmt )
     613           0 :             aRet = xDocProps->getTemplateName();
     614           0 :         else if( !xDocProps->getTemplateURL().isEmpty() )
     615             :         {
     616           0 :             if( FF_UI_RANGE == nFmt )
     617             :             {
     618             :                 // fuers besorgen vom RegionNamen !!
     619           0 :                 SfxDocumentTemplates aFac;
     620           0 :                 aFac.Construct();
     621           0 :                 OUString sTmp;
     622           0 :                 OUString sRegion;
     623           0 :                 aFac.GetLogicNames( xDocProps->getTemplateURL(), sRegion, sTmp );
     624           0 :                 aRet = sRegion;
     625             :             }
     626             :             else
     627             :             {
     628           0 :                 INetURLObject aPathName( xDocProps->getTemplateURL() );
     629           0 :                 if( FF_NAME == nFmt )
     630           0 :                     aRet = aPathName.GetName(URL_DECODE);
     631           0 :                 else if( FF_NAME_NOEXT == nFmt )
     632           0 :                     aRet = aPathName.GetBase();
     633             :                 else
     634             :                 {
     635           0 :                     if( FF_PATH == nFmt )
     636             :                     {
     637           0 :                         aPathName.removeSegment();
     638           0 :                         aRet = aPathName.GetFull();
     639             :                     }
     640             :                     else
     641           0 :                         aRet = aPathName.GetFull();
     642           0 :                 }
     643             :             }
     644           0 :         }
     645             :     }
     646           0 :     return aRet;
     647             : }
     648             : 
     649           0 : SwFieldType* SwTemplNameFieldType::Copy() const
     650             : {
     651           0 :     SwFieldType *pTmp = new SwTemplNameFieldType(pDoc);
     652           0 :     return pTmp;
     653             : }
     654             : // SwTemplNameField
     655             : 
     656           0 : SwTemplNameField::SwTemplNameField(SwTemplNameFieldType* pTyp, sal_uInt32 nFmt)
     657           0 :     : SwField(pTyp, nFmt)
     658           0 : {}
     659             : 
     660           0 : OUString SwTemplNameField::Expand() const
     661             : {
     662           0 :     return((SwTemplNameFieldType*)GetTyp())->Expand(GetFormat());
     663             : }
     664             : 
     665           0 : SwField* SwTemplNameField::Copy() const
     666             : {
     667             :     SwTemplNameField *pTmp =
     668           0 :         new SwTemplNameField((SwTemplNameFieldType*)GetTyp(), GetFormat());
     669           0 :     return pTmp;
     670             : }
     671             : 
     672           0 : bool SwTemplNameField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
     673             : {
     674           0 :     switch ( nWhichId )
     675             :     {
     676             :     case FIELD_PROP_FORMAT:
     677             :         {
     678             :             sal_Int16 nRet;
     679           0 :             switch( GetFormat() )
     680             :             {
     681           0 :                 case FF_PATH:       nRet = text::FilenameDisplayFormat::PATH; break;
     682           0 :                 case FF_NAME_NOEXT: nRet = text::FilenameDisplayFormat::NAME; break;
     683           0 :                 case FF_NAME:       nRet = text::FilenameDisplayFormat::NAME_AND_EXT; break;
     684           0 :                 case FF_UI_RANGE:   nRet = text::TemplateDisplayFormat::AREA; break;
     685           0 :                 case FF_UI_NAME:    nRet = text::TemplateDisplayFormat::TITLE;  break;
     686           0 :                 default:    nRet = text::FilenameDisplayFormat::FULL;
     687             : 
     688             :             }
     689           0 :             rAny <<= nRet;
     690             :         }
     691           0 :         break;
     692             :     default:
     693             :         OSL_FAIL("illegal property");
     694             :     }
     695           0 :     return true;
     696             : }
     697             : 
     698           0 : bool SwTemplNameField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
     699             : {
     700           0 :     switch ( nWhichId )
     701             :     {
     702             :     case FIELD_PROP_FORMAT:
     703             :         {
     704             :             //JP 24.10.2001: int32 because in UnoField.cxx a putvalue is
     705             :             //              called with a int32 value! But normally we need
     706             :             //              here only a int16
     707           0 :             sal_Int32 nType = 0;
     708           0 :             rAny >>= nType;
     709           0 :             switch( nType )
     710             :             {
     711             :             case text::FilenameDisplayFormat::PATH:
     712           0 :                 SetFormat(FF_PATH);
     713           0 :             break;
     714             :             case text::FilenameDisplayFormat::NAME:
     715           0 :                 SetFormat(FF_NAME_NOEXT);
     716           0 :             break;
     717             :             case text::FilenameDisplayFormat::NAME_AND_EXT:
     718           0 :                 SetFormat(FF_NAME);
     719           0 :             break;
     720             :             case text::TemplateDisplayFormat::AREA  :
     721           0 :                 SetFormat(FF_UI_RANGE);
     722           0 :             break;
     723             :             case text::TemplateDisplayFormat::TITLE  :
     724           0 :                 SetFormat(FF_UI_NAME);
     725           0 :             break;
     726           0 :             default:    SetFormat(FF_PATHNAME);
     727             :             }
     728             :         }
     729           0 :         break;
     730             :     default:
     731             :         OSL_FAIL("illegal property");
     732             :     }
     733           0 :     return true;
     734             : }
     735             : 
     736             : // SwDocStatFieldType
     737             : 
     738           0 : SwDocStatFieldType::SwDocStatFieldType(SwDoc* pDocument)
     739           0 :     : SwFieldType( RES_DOCSTATFLD ), nNumberingType( SVX_NUM_ARABIC )
     740             : {
     741           0 :     pDoc = pDocument;
     742           0 : }
     743             : 
     744           0 : OUString SwDocStatFieldType::Expand(sal_uInt16 nSubType, sal_uInt32 nFmt) const
     745             : {
     746           0 :     sal_uInt32 nVal = 0;
     747           0 :     const SwDocStat& rDStat = pDoc->GetDocStat();
     748           0 :     switch( nSubType )
     749             :     {
     750           0 :         case DS_TBL:  nVal = rDStat.nTbl;   break;
     751           0 :         case DS_GRF:  nVal = rDStat.nGrf;   break;
     752           0 :         case DS_OLE:  nVal = rDStat.nOLE;   break;
     753           0 :         case DS_PARA: nVal = rDStat.nPara;  break;
     754           0 :         case DS_WORD: nVal = rDStat.nWord;  break;
     755           0 :         case DS_CHAR: nVal = rDStat.nChar;  break;
     756             :         case DS_PAGE:
     757           0 :             if( pDoc->GetCurrentLayout() )
     758           0 :                 ((SwDocStat &)rDStat).nPage = pDoc->GetCurrentLayout()->GetPageNum();
     759           0 :             nVal = rDStat.nPage;
     760           0 :             if( SVX_NUM_PAGEDESC == nFmt )
     761           0 :                 nFmt = (sal_uInt32)nNumberingType;
     762           0 :             break;
     763             :         default:
     764             :             OSL_FAIL( "SwDocStatFieldType::Expand: unbekannter SubType" );
     765             :     }
     766             : 
     767           0 :     if( nVal <= SHRT_MAX )
     768           0 :         return FormatNumber( (sal_uInt16)nVal, nFmt );
     769             : 
     770           0 :     return OUString::number( nVal );
     771             : }
     772             : 
     773           0 : SwFieldType* SwDocStatFieldType::Copy() const
     774             : {
     775           0 :     SwDocStatFieldType *pTmp = new SwDocStatFieldType(pDoc);
     776           0 :     return pTmp;
     777             : }
     778             : 
     779             : /**
     780             :  * @param pTyp
     781             :  * @param nSub SubType
     782             :  * @param nFmt
     783             :  */
     784           0 : SwDocStatField::SwDocStatField(SwDocStatFieldType* pTyp, sal_uInt16 nSub, sal_uInt32 nFmt)
     785             :     : SwField(pTyp, nFmt),
     786           0 :     nSubType(nSub)
     787           0 : {}
     788             : 
     789           0 : OUString SwDocStatField::Expand() const
     790             : {
     791           0 :     return((SwDocStatFieldType*)GetTyp())->Expand(nSubType, GetFormat());
     792             : }
     793             : 
     794           0 : SwField* SwDocStatField::Copy() const
     795             : {
     796             :     SwDocStatField *pTmp = new SwDocStatField(
     797           0 :                     (SwDocStatFieldType*)GetTyp(), nSubType, GetFormat() );
     798           0 :     return pTmp;
     799             : }
     800             : 
     801           0 : sal_uInt16 SwDocStatField::GetSubType() const
     802             : {
     803           0 :     return nSubType;
     804             : }
     805             : 
     806           0 : void SwDocStatField::SetSubType(sal_uInt16 nSub)
     807             : {
     808           0 :     nSubType = nSub;
     809           0 : }
     810             : 
     811           0 : void SwDocStatField::ChangeExpansion( const SwFrm* pFrm )
     812             : {
     813           0 :     if( DS_PAGE == nSubType && SVX_NUM_PAGEDESC == GetFormat() )
     814           0 :         ((SwDocStatFieldType*)GetTyp())->SetNumFormat(
     815           0 :                 pFrm->FindPageFrm()->GetPageDesc()->GetNumType().GetNumberingType() );
     816           0 : }
     817             : 
     818           0 : bool SwDocStatField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
     819             : {
     820           0 :     switch ( nWhichId )
     821             :     {
     822             :     case FIELD_PROP_USHORT2:
     823           0 :         rAny <<= (sal_Int16)GetFormat();
     824           0 :         break;
     825             :     default:
     826             :         OSL_FAIL("illegal property");
     827             :     }
     828           0 :     return true;
     829             : }
     830             : 
     831           0 : bool SwDocStatField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
     832             : {
     833           0 :     bool bRet = false;
     834           0 :     switch ( nWhichId )
     835             :     {
     836             :     case FIELD_PROP_USHORT2:
     837             :         {
     838           0 :             sal_Int16 nSet = 0;
     839           0 :             rAny >>= nSet;
     840           0 :             if(nSet <= SVX_NUM_CHARS_LOWER_LETTER_N &&
     841           0 :                 nSet != SVX_NUM_CHAR_SPECIAL &&
     842           0 :                     nSet != SVX_NUM_BITMAP)
     843             :             {
     844           0 :                 SetFormat(nSet);
     845           0 :                 bRet = true;
     846             :             }
     847             :         }
     848           0 :         break;
     849             : 
     850             :     default:
     851             :         OSL_FAIL("illegal property");
     852             :     }
     853           0 :     return bRet;
     854             : }
     855             : 
     856             : // Document info field type
     857             : 
     858           0 : SwDocInfoFieldType::SwDocInfoFieldType(SwDoc* pDc)
     859           0 :     : SwValueFieldType( pDc, RES_DOCINFOFLD )
     860             : {
     861           0 : }
     862             : 
     863           0 : SwFieldType* SwDocInfoFieldType::Copy() const
     864             : {
     865           0 :     SwDocInfoFieldType* pTyp = new SwDocInfoFieldType(GetDoc());
     866           0 :     return pTyp;
     867             : }
     868             : 
     869           0 : static void lcl_GetLocalDataWrapper( sal_uLong nLang,
     870             :                               const LocaleDataWrapper **ppAppLocalData,
     871             :                               const LocaleDataWrapper **ppLocalData )
     872             : {
     873           0 :     SvtSysLocale aLocale;
     874           0 :     *ppAppLocalData = &aLocale.GetLocaleData();
     875           0 :     *ppLocalData = *ppAppLocalData;
     876           0 :     if( nLang != (*ppLocalData)->getLanguageTag().getLanguageType() )
     877             :         *ppLocalData = new LocaleDataWrapper(
     878           0 :                         LanguageTag( static_cast<LanguageType>(nLang) ));
     879           0 : }
     880             : 
     881           0 : OUString SwDocInfoFieldType::Expand( sal_uInt16 nSub, sal_uInt32 nFormat,
     882             :                                     sal_uInt16 nLang, const OUString& rName ) const
     883             : {
     884           0 :     const LocaleDataWrapper *pAppLocalData = 0, *pLocalData = 0;
     885           0 :     SwDocShell *pDocShell(GetDoc()->GetDocShell());
     886             :     OSL_ENSURE(pDocShell, "no SwDocShell");
     887           0 :     if (!pDocShell) { return OUString(); }
     888             : 
     889             :     uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
     890           0 :         pDocShell->GetModel(), uno::UNO_QUERY_THROW);
     891             :     uno::Reference<document::XDocumentProperties> xDocProps(
     892           0 :         xDPS->getDocumentProperties());
     893             :     OSL_ENSURE(xDocProps.is(), "Doc has no DocumentProperties");
     894             : 
     895           0 :     sal_uInt16 nExtSub = nSub & 0xff00;
     896           0 :     nSub &= 0xff;   // ExtendedSubTypes nicht beachten
     897             : 
     898           0 :     OUString aStr;
     899           0 :     switch(nSub)
     900             :     {
     901           0 :     case DI_TITEL:  aStr = xDocProps->getTitle();       break;
     902           0 :     case DI_THEMA:  aStr = xDocProps->getSubject();     break;
     903           0 :     case DI_KEYS:   aStr = ::comphelper::string::convertCommaSeparated(
     904           0 :                                 xDocProps->getKeywords());
     905           0 :                     break;
     906           0 :     case DI_COMMENT:aStr = xDocProps->getDescription(); break;
     907           0 :     case DI_DOCNO:  aStr = OUString::number(
     908           0 :                                         xDocProps->getEditingCycles() );
     909           0 :                     break;
     910             :     case DI_EDIT:
     911           0 :         if ( !nFormat )
     912             :         {
     913           0 :             lcl_GetLocalDataWrapper( nLang, &pAppLocalData, &pLocalData );
     914           0 :             sal_Int32 dur = xDocProps->getEditingDuration();
     915           0 :             aStr = pLocalData->getTime( Time(dur/3600, (dur%3600)/60, dur%60),
     916           0 :                                         false, false);
     917             :         }
     918             :         else
     919             :         {
     920           0 :             sal_Int32 dur = xDocProps->getEditingDuration();
     921           0 :             double fVal = Time(dur/3600, (dur%3600)/60, dur%60).GetTimeInDays();
     922           0 :             aStr = ExpandValue(fVal, nFormat, nLang);
     923             :         }
     924           0 :         break;
     925             :     case DI_CUSTOM:
     926             :         {
     927           0 :             OUString sVal;
     928             :             try
     929             :             {
     930           0 :                 uno::Any aAny;
     931             :                 uno::Reference < beans::XPropertySet > xSet(
     932           0 :                     xDocProps->getUserDefinedProperties(),
     933           0 :                     uno::UNO_QUERY_THROW);
     934           0 :                 aAny = xSet->getPropertyValue( rName );
     935             : 
     936           0 :                 uno::Reference < script::XTypeConverter > xConverter( script::Converter::create(comphelper::getProcessComponentContext()) );
     937           0 :                 uno::Any aNew;
     938           0 :                     aNew = xConverter->convertToSimpleType( aAny, uno::TypeClass_STRING );
     939           0 :                 aNew >>= sVal;
     940             :             }
     941           0 :             catch (uno::Exception&) {}
     942           0 :             return sVal;
     943             :         }
     944             : 
     945             :     default:
     946             :         {
     947           0 :             OUString aName( xDocProps->getAuthor() );
     948           0 :             util::DateTime uDT( xDocProps->getCreationDate() );
     949           0 :             Date aD(uDT.Day, uDT.Month, uDT.Year);
     950           0 :             Time aT(uDT.Hours, uDT.Minutes, uDT.Seconds, uDT.NanoSeconds);
     951           0 :             DateTime aDate(aD,aT);
     952           0 :             if( nSub == DI_CREATE )
     953             :                 ;       // das wars schon!!
     954           0 :             else if( nSub == DI_CHANGE )
     955             :             {
     956           0 :                 aName = xDocProps->getModifiedBy();
     957           0 :                 uDT = xDocProps->getModificationDate();
     958           0 :                 Date bD(uDT.Day, uDT.Month, uDT.Year);
     959           0 :                 Time bT(uDT.Hours, uDT.Minutes, uDT.Seconds, uDT.NanoSeconds);
     960           0 :                 DateTime bDate(bD,bT);
     961           0 :                 aDate = bDate;
     962             :             }
     963           0 :             else if( nSub == DI_PRINT )
     964             :             {
     965           0 :                 aName = xDocProps->getPrintedBy();
     966           0 :                 uDT = xDocProps->getPrintDate();
     967           0 :                 Date bD(uDT.Day, uDT.Month, uDT.Year);
     968           0 :                 Time bT(uDT.Hours, uDT.Minutes, uDT.Seconds, uDT.NanoSeconds);
     969           0 :                 DateTime bDate(bD,bT);
     970           0 :                 aDate = bDate;
     971             :             }
     972             :             else
     973           0 :                 break;
     974             : 
     975           0 :             if (aDate.IsValidAndGregorian())
     976             :             {
     977           0 :                 switch (nExtSub & ~DI_SUB_FIXED)
     978             :                 {
     979             :                 case DI_SUB_AUTHOR:
     980           0 :                     aStr = aName;
     981           0 :                     break;
     982             : 
     983             :                 case DI_SUB_TIME:
     984           0 :                     if (!nFormat)
     985             :                     {
     986             :                         lcl_GetLocalDataWrapper( nLang, &pAppLocalData,
     987           0 :                                                         &pLocalData );
     988           0 :                         aStr = pLocalData->getTime( aDate,
     989           0 :                                                     false, false);
     990             :                     }
     991             :                     else
     992             :                     {
     993             :                         // Numberformatter anwerfen!
     994             :                         double fVal = SwDateTimeField::GetDateTime( GetDoc(),
     995           0 :                                                     aDate);
     996           0 :                         aStr = ExpandValue(fVal, nFormat, nLang);
     997             :                     }
     998           0 :                     break;
     999             : 
    1000             :                 case DI_SUB_DATE:
    1001           0 :                     if (!nFormat)
    1002             :                     {
    1003             :                         lcl_GetLocalDataWrapper( nLang, &pAppLocalData,
    1004           0 :                                                  &pLocalData );
    1005           0 :                         aStr = pLocalData->getDate( aDate );
    1006             :                     }
    1007             :                     else
    1008             :                     {
    1009             :                         // Numberformatter anwerfen!
    1010             :                         double fVal = SwDateTimeField::GetDateTime( GetDoc(),
    1011           0 :                                                     aDate);
    1012           0 :                         aStr = ExpandValue(fVal, nFormat, nLang);
    1013             :                     }
    1014           0 :                     break;
    1015             :                 }
    1016           0 :             }
    1017             :         }
    1018           0 :         break;
    1019             :     }
    1020             : 
    1021           0 :     if( pAppLocalData != pLocalData )
    1022           0 :         delete pLocalData;
    1023             : 
    1024           0 :     return aStr;
    1025             : }
    1026             : 
    1027             : // document info field
    1028             : 
    1029           0 : SwDocInfoField::SwDocInfoField(SwDocInfoFieldType* pTyp, sal_uInt16 nSub, const OUString& rName, sal_uInt32 nFmt) :
    1030           0 :     SwValueField(pTyp, nFmt), nSubType(nSub)
    1031             : {
    1032           0 :     aName = rName;
    1033           0 :     aContent = ((SwDocInfoFieldType*)GetTyp())->Expand(nSubType, nFmt, GetLanguage(), aName);
    1034           0 : }
    1035             : 
    1036           0 : SwDocInfoField::SwDocInfoField(SwDocInfoFieldType* pTyp, sal_uInt16 nSub, const OUString& rName, const OUString& rValue, sal_uInt32 nFmt) :
    1037           0 :     SwValueField(pTyp, nFmt), nSubType(nSub)
    1038             : {
    1039           0 :     aName = rName;
    1040           0 :     aContent = rValue;
    1041           0 : }
    1042             : 
    1043             : template<class T>
    1044           0 : static double lcl_TimeToDouble( const T& rTime )
    1045             : {
    1046           0 :     const double fNanoSecondsPerDay = 86400000000000.0;
    1047           0 :     return ((rTime.Hours*3600000)+(rTime.Minutes*60000)+(rTime.Seconds*1000)+(rTime.NanoSeconds)) / fNanoSecondsPerDay;
    1048             : }
    1049             : 
    1050             : template<class D>
    1051           0 : static double lcl_DateToDouble( const D& rDate, const Date& rNullDate )
    1052             : {
    1053           0 :     long nDate = Date::DateToDays( rDate.Day, rDate.Month, rDate.Year );
    1054           0 :     long nNullDate = Date::DateToDays( rNullDate.GetDay(), rNullDate.GetMonth(), rNullDate.GetYear() );
    1055           0 :     return double( nDate - nNullDate );
    1056             : }
    1057             : 
    1058           0 : OUString SwDocInfoField::Expand() const
    1059             : {
    1060           0 :     if ( ( nSubType & 0xFF ) == DI_CUSTOM )
    1061             :     {
    1062             :         // custom properties currently need special treatment
    1063             :         // We don't have a secure way to detect "real" custom properties in Word import of text
    1064             :         // fields, so we treat *every* unknown property as a custom property, even the "built-in"
    1065             :         // section in Word's document summary information stream as these properties have not been
    1066             :         // inserted when the document summary information was imported, we do it here.
    1067             :         // This approach is still a lot better than the old one to import such fields as
    1068             :         // "user fields" and simple text
    1069           0 :         SwDocShell* pDocShell = GetDoc()->GetDocShell();
    1070           0 :         if( !pDocShell )
    1071           0 :             return aContent;
    1072             :         try
    1073             :         {
    1074           0 :             uno::Reference<document::XDocumentPropertiesSupplier> xDPS( pDocShell->GetModel(), uno::UNO_QUERY_THROW);
    1075           0 :             uno::Reference<document::XDocumentProperties> xDocProps( xDPS->getDocumentProperties());
    1076           0 :             uno::Reference < beans::XPropertySet > xSet( xDocProps->getUserDefinedProperties(), uno::UNO_QUERY_THROW);
    1077           0 :             uno::Reference < beans::XPropertySetInfo > xSetInfo = xSet->getPropertySetInfo();
    1078             : 
    1079           0 :             uno::Any aAny;
    1080           0 :             if( xSetInfo->hasPropertyByName( aName ) )
    1081           0 :                 aAny = xSet->getPropertyValue( aName );
    1082           0 :             if ( aAny.getValueType() != ::getVoidCppuType() )
    1083             :             {
    1084             :                 // "void" type means that the property has not been inserted until now
    1085           0 :                 if ( !IsFixed() )
    1086             :                 {
    1087             :                     // if the field is "fixed" we don't update it from the property
    1088           0 :                     OUString sVal;
    1089           0 :                     uno::Reference < script::XTypeConverter > xConverter( script::Converter::create(comphelper::getProcessComponentContext()) );
    1090           0 :                     util::Date aDate;
    1091           0 :                     util::DateTime aDateTime;
    1092           0 :                     util::Duration aDuration;
    1093           0 :                     if( aAny >>= aDate)
    1094             :                     {
    1095           0 :                         SvNumberFormatter* pFormatter = pDocShell->GetDoc()->GetNumberFormatter();
    1096           0 :                         Date* pNullDate = pFormatter->GetNullDate();
    1097           0 :                         sVal = ExpandValue( lcl_DateToDouble<util::Date>( aDate, *pNullDate ), GetFormat(), GetLanguage());
    1098             :                     }
    1099           0 :                     else if( aAny >>= aDateTime )
    1100             :                     {
    1101           0 :                         double fDateTime = lcl_TimeToDouble<util::DateTime>( aDateTime );
    1102           0 :                         SvNumberFormatter* pFormatter = pDocShell->GetDoc()->GetNumberFormatter();
    1103           0 :                         Date* pNullDate = pFormatter->GetNullDate();
    1104           0 :                         fDateTime += lcl_DateToDouble<util::DateTime>( aDateTime, *pNullDate );
    1105           0 :                         sVal = ExpandValue( fDateTime, GetFormat(), GetLanguage());
    1106             :                     }
    1107           0 :                     else if( aAny >>= aDuration )
    1108             :                     {
    1109           0 :                         sVal = OUString(aDuration.Negative ? '-' : '+')
    1110           0 :                              + SwViewShell::GetShellRes()->sDurationFormat;
    1111           0 :                         sVal = sVal.replaceFirst("%1", OUString::number( aDuration.Years  ) );
    1112           0 :                         sVal = sVal.replaceFirst("%2", OUString::number( aDuration.Months ) );
    1113           0 :                         sVal = sVal.replaceFirst("%3", OUString::number( aDuration.Days   ) );
    1114           0 :                         sVal = sVal.replaceFirst("%4", OUString::number( aDuration.Hours  ) );
    1115           0 :                         sVal = sVal.replaceFirst("%5", OUString::number( aDuration.Minutes) );
    1116           0 :                         sVal = sVal.replaceFirst("%6", OUString::number( aDuration.Seconds) );
    1117             :                     }
    1118             :                     else
    1119             :                     {
    1120           0 :                         uno::Any aNew = xConverter->convertToSimpleType( aAny, uno::TypeClass_STRING );
    1121           0 :                         aNew >>= sVal;
    1122             :                     }
    1123           0 :                     ((SwDocInfoField*)this)->aContent = sVal;
    1124             :                 }
    1125           0 :             }
    1126             :         }
    1127           0 :         catch (uno::Exception&) {}
    1128             :     }
    1129           0 :     else if ( !IsFixed() )
    1130           0 :         ((SwDocInfoField*)this)->aContent = ((SwDocInfoFieldType*)GetTyp())->Expand(nSubType, GetFormat(), GetLanguage(), aName);
    1131             : 
    1132           0 :     return aContent;
    1133             : }
    1134             : 
    1135           0 : OUString SwDocInfoField::GetFieldName() const
    1136             : {
    1137           0 :     OUString aStr(SwFieldType::GetTypeStr(GetTypeId()) + ":");
    1138             : 
    1139           0 :     sal_uInt16 const nSub = nSubType & 0xff;
    1140             : 
    1141           0 :     switch (nSub)
    1142             :     {
    1143             :         case DI_CUSTOM:
    1144           0 :             aStr += aName;
    1145           0 :             break;
    1146             : 
    1147             :         default:
    1148           0 :             aStr += SwViewShell::GetShellRes()
    1149           0 :                      ->aDocInfoLst[ nSub - DI_SUBTYPE_BEGIN ];
    1150           0 :             break;
    1151             :     }
    1152           0 :     if (IsFixed())
    1153             :     {
    1154           0 :         aStr += " " + OUString(SwViewShell::GetShellRes()->aFixedStr);
    1155             :     }
    1156           0 :     return aStr;
    1157             : }
    1158             : 
    1159           0 : SwField* SwDocInfoField::Copy() const
    1160             : {
    1161           0 :     SwDocInfoField* pFld = new SwDocInfoField((SwDocInfoFieldType*)GetTyp(), nSubType, aName, GetFormat());
    1162           0 :     pFld->SetAutomaticLanguage(IsAutomaticLanguage());
    1163           0 :     pFld->aContent = aContent;
    1164             : 
    1165           0 :     return pFld;
    1166             : }
    1167             : 
    1168           0 : sal_uInt16 SwDocInfoField::GetSubType() const
    1169             : {
    1170           0 :     return nSubType;
    1171             : }
    1172             : 
    1173           0 : void SwDocInfoField::SetSubType(sal_uInt16 nSub)
    1174             : {
    1175           0 :     nSubType = nSub;
    1176           0 : }
    1177             : 
    1178           0 : void SwDocInfoField::SetLanguage(sal_uInt16 nLng)
    1179             : {
    1180           0 :     if (!GetFormat())
    1181           0 :         SwField::SetLanguage(nLng);
    1182             :     else
    1183           0 :         SwValueField::SetLanguage(nLng);
    1184           0 : }
    1185             : 
    1186           0 : bool SwDocInfoField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
    1187             : {
    1188           0 :     switch( nWhichId )
    1189             :     {
    1190             :     case FIELD_PROP_PAR1:
    1191           0 :         rAny <<= aContent;
    1192           0 :         break;
    1193             : 
    1194             :     case FIELD_PROP_PAR4:
    1195           0 :         rAny <<= aName;
    1196           0 :         break;
    1197             : 
    1198             :     case FIELD_PROP_USHORT1:
    1199           0 :         rAny  <<= (sal_Int16)aContent.toInt32();
    1200           0 :         break;
    1201             : 
    1202             :     case FIELD_PROP_BOOL1:
    1203             :         {
    1204           0 :             sal_Bool bVal = 0 != (nSubType & DI_SUB_FIXED);
    1205           0 :             rAny.setValue(&bVal, ::getBooleanCppuType());
    1206             :         }
    1207           0 :         break;
    1208             :     case FIELD_PROP_FORMAT:
    1209           0 :         rAny  <<= (sal_Int32)GetFormat();
    1210           0 :         break;
    1211             : 
    1212             :     case FIELD_PROP_DOUBLE:
    1213             :         {
    1214           0 :             double fVal = GetValue();
    1215           0 :             rAny.setValue(&fVal, ::getCppuType(&fVal));
    1216             :         }
    1217           0 :         break;
    1218             :     case FIELD_PROP_PAR3:
    1219           0 :         rAny <<= Expand();
    1220           0 :         break;
    1221             :     case FIELD_PROP_BOOL2:
    1222             :         {
    1223           0 :             sal_uInt16 nExtSub = (nSubType & 0xff00) & ~DI_SUB_FIXED;
    1224           0 :             sal_Bool bVal = (nExtSub == DI_SUB_DATE);
    1225           0 :             rAny.setValue(&bVal, ::getBooleanCppuType());
    1226             :         }
    1227           0 :         break;
    1228             :     default:
    1229           0 :         return SwField::QueryValue(rAny, nWhichId);
    1230             :     }
    1231           0 :     return true;
    1232             : }
    1233             : 
    1234           0 : bool SwDocInfoField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
    1235             : {
    1236           0 :     sal_Int32 nValue = 0;
    1237           0 :     switch( nWhichId )
    1238             :     {
    1239             :     case FIELD_PROP_PAR1:
    1240           0 :         if( nSubType & DI_SUB_FIXED )
    1241           0 :             rAny >>= aContent;
    1242           0 :         break;
    1243             : 
    1244             :     case FIELD_PROP_USHORT1:
    1245           0 :         if( nSubType & DI_SUB_FIXED )
    1246             :         {
    1247           0 :             rAny >>= nValue;
    1248           0 :             aContent = OUString::number(nValue);
    1249             :         }
    1250           0 :         break;
    1251             : 
    1252             :     case FIELD_PROP_BOOL1:
    1253           0 :         if(*(sal_Bool*)rAny.getValue())
    1254           0 :             nSubType |= DI_SUB_FIXED;
    1255             :         else
    1256           0 :             nSubType &= ~DI_SUB_FIXED;
    1257           0 :         break;
    1258             :     case FIELD_PROP_FORMAT:
    1259             :         {
    1260           0 :             rAny >>= nValue;
    1261           0 :             if( nValue >= 0)
    1262           0 :                 SetFormat(nValue);
    1263             :         }
    1264           0 :         break;
    1265             : 
    1266             :     case FIELD_PROP_PAR3:
    1267           0 :         rAny >>= aContent;
    1268           0 :         break;
    1269             :     case FIELD_PROP_BOOL2:
    1270           0 :         nSubType &= 0xf0ff;
    1271           0 :         if(*(sal_Bool*)rAny.getValue())
    1272           0 :             nSubType |= DI_SUB_DATE;
    1273             :         else
    1274           0 :             nSubType |= DI_SUB_TIME;
    1275           0 :         break;
    1276             :     default:
    1277           0 :         return SwField::PutValue(rAny, nWhichId);
    1278             :     }
    1279           0 :     return true;
    1280             : }
    1281             : 
    1282             : // SwHiddenTxtFieldType
    1283             : 
    1284           0 : SwHiddenTxtFieldType::SwHiddenTxtFieldType( sal_Bool bSetHidden )
    1285           0 :     : SwFieldType( RES_HIDDENTXTFLD ), bHidden( bSetHidden )
    1286             : {
    1287           0 : }
    1288             : 
    1289           0 : SwFieldType* SwHiddenTxtFieldType::Copy() const
    1290             : {
    1291           0 :     return new SwHiddenTxtFieldType( bHidden );
    1292             : }
    1293             : 
    1294           0 : void SwHiddenTxtFieldType::SetHiddenFlag( sal_Bool bSetHidden )
    1295             : {
    1296           0 :     if( bHidden != bSetHidden )
    1297             :     {
    1298           0 :         bHidden = bSetHidden;
    1299           0 :         UpdateFlds();       // notify all HiddenTexts
    1300             :     }
    1301           0 : }
    1302             : 
    1303           0 : SwHiddenTxtField::SwHiddenTxtField( SwHiddenTxtFieldType* pFldType,
    1304             :                                     sal_Bool    bConditional,
    1305             :                                     const OUString& rCond,
    1306             :                                     const OUString& rStr,
    1307             :                                     sal_Bool    bHidden,
    1308             :                                     sal_uInt16  nSub) :
    1309             :     SwField( pFldType ), aCond(rCond), nSubType(nSub),
    1310           0 :     bCanToggle(bConditional), bIsHidden(bHidden), bValid(sal_False)
    1311             : {
    1312           0 :     if(nSubType == TYP_CONDTXTFLD)
    1313             :     {
    1314           0 :         sal_Int32 nPos = 0;
    1315           0 :         aTRUETxt = rStr.getToken(0, '|', nPos);
    1316             : 
    1317           0 :         if(nPos != -1)
    1318             :         {
    1319           0 :             aFALSETxt = rStr.getToken(0, '|', nPos);
    1320           0 :             if(nPos != -1)
    1321             :             {
    1322           0 :                 aContent = rStr.getToken(0, '|', nPos);
    1323           0 :                 bValid = sal_True;
    1324             :             }
    1325             :         }
    1326             :     }
    1327             :     else
    1328           0 :         aTRUETxt = rStr;
    1329           0 : }
    1330             : 
    1331           0 : SwHiddenTxtField::SwHiddenTxtField( SwHiddenTxtFieldType* pFldType,
    1332             :                                     const OUString& rCond,
    1333             :                                     const OUString& rTrue,
    1334             :                                     const OUString& rFalse,
    1335             :                                     sal_uInt16 nSub)
    1336             :     : SwField( pFldType ), aTRUETxt(rTrue), aFALSETxt(rFalse), aCond(rCond), nSubType(nSub),
    1337           0 :       bIsHidden(sal_True), bValid(sal_False)
    1338             : {
    1339           0 :     bCanToggle = !aCond.isEmpty();
    1340           0 : }
    1341             : 
    1342           0 : OUString SwHiddenTxtField::Expand() const
    1343             : {
    1344             :     // Type: !Hidden  -> show always
    1345             :     //        Hide    -> evaluate condition
    1346             : 
    1347           0 :     if( TYP_CONDTXTFLD == nSubType )
    1348             :     {
    1349           0 :         if( bValid )
    1350           0 :             return aContent;
    1351             : 
    1352           0 :         if( bCanToggle && !bIsHidden )
    1353           0 :             return aTRUETxt;
    1354             :     }
    1355           0 :     else if( !((SwHiddenTxtFieldType*)GetTyp())->GetHiddenFlag() ||
    1356           0 :         ( bCanToggle && bIsHidden ))
    1357           0 :         return aTRUETxt;
    1358             : 
    1359           0 :     return aFALSETxt;
    1360             : }
    1361             : 
    1362             : /// get current field value and cache it
    1363           0 : void SwHiddenTxtField::Evaluate(SwDoc* pDoc)
    1364             : {
    1365             :     OSL_ENSURE(pDoc, "Wo ist das Dokument Seniore");
    1366             : 
    1367           0 :     if( TYP_CONDTXTFLD == nSubType )
    1368             :     {
    1369           0 :         SwNewDBMgr* pMgr = pDoc->GetNewDBMgr();
    1370             : 
    1371           0 :         bValid = sal_False;
    1372           0 :         OUString sTmpName = (bCanToggle && !bIsHidden) ? aTRUETxt : aFALSETxt;
    1373             : 
    1374             :         // Database expressions need to be different from normal text. Therefore, normal text is set
    1375             :         // in quotes. If the latter exist they will be removed. If not, check if potential DB name.
    1376             :         // Only if there are two or more dots and no quotes, we assume a database.
    1377           0 :         if (sTmpName.getLength()>1 &&
    1378           0 :             sTmpName.startsWith("\"") &&
    1379           0 :             sTmpName.endsWith("\""))
    1380             :         {
    1381           0 :             aContent = sTmpName.copy(1, sTmpName.getLength() - 2);
    1382           0 :             bValid = sal_True;
    1383             :         }
    1384           0 :         else if(sTmpName.indexOf('\"')<0 &&
    1385           0 :             comphelper::string::getTokenCount(sTmpName, '.') > 2)
    1386             :         {
    1387           0 :             sTmpName = ::ReplacePoint(sTmpName);
    1388           0 :             if(sTmpName.startsWith("[") && sTmpName.endsWith("]"))
    1389             :             {   // remove brackets
    1390           0 :                 sTmpName = sTmpName.copy(1, sTmpName.getLength() - 2);
    1391             :             }
    1392             : 
    1393           0 :             if( pMgr)
    1394             :             {
    1395           0 :                 OUString sDBName( GetDBName( sTmpName, pDoc ));
    1396           0 :                 OUString sDataSource(sDBName.getToken(0, DB_DELIM));
    1397           0 :                 OUString sDataTableOrQuery(sDBName.getToken(1, DB_DELIM));
    1398           0 :                 if( pMgr->IsInMerge() && !sDBName.isEmpty() &&
    1399             :                     pMgr->IsDataSourceOpen( sDataSource,
    1400           0 :                                                 sDataTableOrQuery, sal_False))
    1401             :                 {
    1402             :                     double fNumber;
    1403             :                     sal_uInt32 nTmpFormat;
    1404             :                     pMgr->GetMergeColumnCnt(GetColumnName( sTmpName ),
    1405           0 :                         GetLanguage(), aContent, &fNumber, &nTmpFormat );
    1406           0 :                     bValid = sal_True;
    1407             :                 }
    1408           0 :                 else if( !sDBName.isEmpty() && !sDataSource.isEmpty() &&
    1409           0 :                          !sDataTableOrQuery.isEmpty() )
    1410           0 :                     bValid = sal_True;
    1411             :             }
    1412           0 :         }
    1413             :     }
    1414           0 : }
    1415             : 
    1416           0 : OUString SwHiddenTxtField::GetFieldName() const
    1417             : {
    1418           0 :     OUString aStr = SwFieldType::GetTypeStr(nSubType) +
    1419           0 :         " " + aCond + " " + aTRUETxt;
    1420             : 
    1421           0 :     if (nSubType == TYP_CONDTXTFLD)
    1422             :     {
    1423           0 :         aStr += " : " + aFALSETxt;
    1424             :     }
    1425           0 :     return aStr;
    1426             : }
    1427             : 
    1428           0 : SwField* SwHiddenTxtField::Copy() const
    1429             : {
    1430             :     SwHiddenTxtField* pFld =
    1431           0 :         new SwHiddenTxtField((SwHiddenTxtFieldType*)GetTyp(), aCond,
    1432           0 :                               aTRUETxt, aFALSETxt);
    1433           0 :     pFld->bIsHidden = bIsHidden;
    1434           0 :     pFld->bValid    = bValid;
    1435           0 :     pFld->aContent  = aContent;
    1436           0 :     pFld->SetFormat(GetFormat());
    1437           0 :     pFld->nSubType  = nSubType;
    1438           0 :     return pFld;
    1439             : }
    1440             : 
    1441             : /// set condition
    1442           0 : void SwHiddenTxtField::SetPar1(const OUString& rStr)
    1443             : {
    1444           0 :     aCond = rStr;
    1445           0 :     bCanToggle = !aCond.isEmpty();
    1446           0 : }
    1447             : 
    1448           0 : OUString SwHiddenTxtField::GetPar1() const
    1449             : {
    1450           0 :     return aCond;
    1451             : }
    1452             : 
    1453             : /// set True/False text
    1454           0 : void SwHiddenTxtField::SetPar2(const OUString& rStr)
    1455             : {
    1456           0 :     if (nSubType == TYP_CONDTXTFLD)
    1457             :     {
    1458           0 :         sal_Int32 nPos = rStr.indexOf('|');
    1459           0 :         if (nPos == -1)
    1460           0 :             aTRUETxt = rStr;
    1461             :         else
    1462             :         {
    1463           0 :             aTRUETxt = rStr.copy(0, nPos);
    1464           0 :             aFALSETxt = rStr.copy(nPos + 1);
    1465             :         }
    1466             :     }
    1467             :     else
    1468           0 :         aTRUETxt = rStr;
    1469           0 : }
    1470             : 
    1471             : /// get True/False text
    1472           0 : OUString SwHiddenTxtField::GetPar2() const
    1473             : {
    1474           0 :     if(nSubType != TYP_CONDTXTFLD)
    1475             :     {
    1476           0 :         return aTRUETxt;
    1477             :     }
    1478           0 :     return aTRUETxt + "|" + aFALSETxt;
    1479             : }
    1480             : 
    1481           0 : sal_uInt16 SwHiddenTxtField::GetSubType() const
    1482             : {
    1483           0 :     return nSubType;
    1484             : }
    1485             : 
    1486           0 : bool SwHiddenTxtField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
    1487             : {
    1488           0 :     switch( nWhichId )
    1489             :     {
    1490             :     case FIELD_PROP_PAR1:
    1491           0 :         rAny <<= aCond;
    1492           0 :         break;
    1493             :     case FIELD_PROP_PAR2:
    1494           0 :         rAny <<= aTRUETxt;
    1495           0 :         break;
    1496             :     case FIELD_PROP_PAR3:
    1497           0 :         rAny <<= aFALSETxt;
    1498           0 :         break;
    1499             :     case FIELD_PROP_PAR4 :
    1500           0 :         rAny <<= aContent;
    1501           0 :     break;
    1502             :     case FIELD_PROP_BOOL1:
    1503             :         {
    1504           0 :             sal_Bool bHidden = bIsHidden;
    1505           0 :             rAny.setValue(&bHidden, ::getBooleanCppuType());
    1506             :         }
    1507           0 :         break;
    1508             :     default:
    1509             :         OSL_FAIL("illegal property");
    1510             :     }
    1511           0 :     return true;
    1512             : }
    1513             : 
    1514           0 : bool SwHiddenTxtField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
    1515             : {
    1516           0 :     switch( nWhichId )
    1517             :     {
    1518             :     case FIELD_PROP_PAR1:
    1519             :         {
    1520           0 :             OUString sVal;
    1521           0 :             rAny >>= sVal;
    1522           0 :             SetPar1(sVal);
    1523             :         }
    1524           0 :         break;
    1525             :     case FIELD_PROP_PAR2:
    1526           0 :         rAny >>= aTRUETxt;
    1527           0 :         break;
    1528             :     case FIELD_PROP_PAR3:
    1529           0 :         rAny >>= aFALSETxt;
    1530           0 :         break;
    1531             :     case FIELD_PROP_BOOL1:
    1532           0 :         bIsHidden = *(sal_Bool*)rAny.getValue();
    1533           0 :         break;
    1534             :     case FIELD_PROP_PAR4:
    1535           0 :         rAny >>= aContent;
    1536           0 :         bValid = sal_True;
    1537           0 :     break;
    1538             :     default:
    1539             :         OSL_FAIL("illegal property");
    1540             :     }
    1541           0 :     return true;
    1542             : }
    1543             : 
    1544           0 : OUString SwHiddenTxtField::GetColumnName(const OUString& rName)
    1545             : {
    1546           0 :     sal_Int32 nPos = rName.indexOf(DB_DELIM);
    1547           0 :     if( nPos>=0 )
    1548             :     {
    1549           0 :         nPos = rName.indexOf(DB_DELIM, nPos + 1);
    1550             : 
    1551           0 :         if( nPos>=0 )
    1552           0 :             return rName.copy(nPos + 1);
    1553             :     }
    1554           0 :     return rName;
    1555             : }
    1556             : 
    1557           0 : OUString SwHiddenTxtField::GetDBName(const OUString& rName, SwDoc *pDoc)
    1558             : {
    1559           0 :     sal_Int32 nPos = rName.indexOf(DB_DELIM);
    1560           0 :     if( nPos>=0 )
    1561             :     {
    1562           0 :         nPos = rName.indexOf(DB_DELIM, nPos + 1);
    1563             : 
    1564           0 :         if( nPos>=0 )
    1565           0 :             return rName.copy(0, nPos);
    1566             :     }
    1567             : 
    1568           0 :     SwDBData aData = pDoc->GetDBData();
    1569           0 :     return aData.sDataSource + OUString(DB_DELIM) + aData.sCommand;
    1570             : }
    1571             : 
    1572             : // field type for line height 0
    1573             : 
    1574           0 : SwHiddenParaFieldType::SwHiddenParaFieldType()
    1575           0 :     : SwFieldType( RES_HIDDENPARAFLD )
    1576             : {
    1577           0 : }
    1578             : 
    1579           0 : SwFieldType* SwHiddenParaFieldType::Copy() const
    1580             : {
    1581           0 :     SwHiddenParaFieldType* pTyp = new SwHiddenParaFieldType();
    1582           0 :     return pTyp;
    1583             : }
    1584             : 
    1585             : // field for line height 0
    1586             : 
    1587           0 : SwHiddenParaField::SwHiddenParaField(SwHiddenParaFieldType* pTyp, const OUString& rStr)
    1588           0 :     : SwField(pTyp), aCond(rStr)
    1589             : {
    1590           0 :     bIsHidden = sal_False;
    1591           0 : }
    1592             : 
    1593           0 : OUString SwHiddenParaField::Expand() const
    1594             : {
    1595           0 :     return OUString();
    1596             : }
    1597             : 
    1598           0 : SwField* SwHiddenParaField::Copy() const
    1599             : {
    1600           0 :     SwHiddenParaField* pFld = new SwHiddenParaField((SwHiddenParaFieldType*)GetTyp(), aCond);
    1601           0 :     pFld->bIsHidden = bIsHidden;
    1602             : 
    1603           0 :     return pFld;
    1604             : }
    1605             : 
    1606           0 : bool SwHiddenParaField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
    1607             : {
    1608           0 :     switch ( nWhichId )
    1609             :     {
    1610             :     case FIELD_PROP_PAR1:
    1611           0 :         rAny <<= aCond;
    1612           0 :         break;
    1613             :     case  FIELD_PROP_BOOL1:
    1614             :         {
    1615           0 :             sal_Bool bHidden = bIsHidden;
    1616           0 :             rAny.setValue(&bHidden, ::getBooleanCppuType());
    1617             :         }
    1618           0 :         break;
    1619             : 
    1620             :     default:
    1621             :         OSL_FAIL("illegal property");
    1622             :     }
    1623           0 :     return true;
    1624             : }
    1625             : 
    1626           0 : bool SwHiddenParaField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
    1627             : {
    1628           0 :     switch ( nWhichId )
    1629             :     {
    1630             :     case FIELD_PROP_PAR1:
    1631           0 :         rAny >>= aCond;
    1632           0 :         break;
    1633             :     case FIELD_PROP_BOOL1:
    1634           0 :         bIsHidden = *(sal_Bool*)rAny.getValue();
    1635           0 :         break;
    1636             : 
    1637             :     default:
    1638             :         OSL_FAIL("illegal property");
    1639             :     }
    1640           0 :     return true;
    1641             : }
    1642             : 
    1643             : /// set condition
    1644           0 : void SwHiddenParaField::SetPar1(const OUString& rStr)
    1645             : {
    1646           0 :     aCond = rStr;
    1647           0 : }
    1648             : 
    1649           0 : OUString SwHiddenParaField::GetPar1() const
    1650             : {
    1651           0 :     return aCond;
    1652             : }
    1653             : 
    1654             : // PostIt field type
    1655             : 
    1656           0 : SwPostItFieldType::SwPostItFieldType(SwDoc *pDoc)
    1657             :     : SwFieldType( RES_POSTITFLD )
    1658           0 :     , mpDoc(pDoc)
    1659           0 : {}
    1660             : 
    1661           0 : SwFieldType* SwPostItFieldType::Copy() const
    1662             : {
    1663           0 :     return new SwPostItFieldType(mpDoc);
    1664             : }
    1665             : 
    1666             : // PostIt field
    1667             : 
    1668           0 : SwPostItField::SwPostItField( SwPostItFieldType* pT,
    1669             :         const OUString& rAuthor,
    1670             :         const OUString& rTxt,
    1671             :         const OUString& rInitials,
    1672             :         const OUString& rName,
    1673             :         const DateTime& rDateTime )
    1674             :     : SwField( pT )
    1675             :     , sTxt( rTxt )
    1676             :     , sAuthor( rAuthor )
    1677             :     , sInitials( rInitials )
    1678             :     , sName( rName )
    1679             :     , aDateTime( rDateTime )
    1680             :     , mpText( NULL )
    1681           0 :     , m_pTextObject( NULL )
    1682             : {
    1683           0 : }
    1684             : 
    1685           0 : SwPostItField::~SwPostItField()
    1686             : {
    1687           0 :     if ( m_pTextObject != NULL )
    1688             :     {
    1689           0 :         m_pTextObject->DisposeEditSource();
    1690           0 :         m_pTextObject->release();
    1691             :     }
    1692             : 
    1693           0 :     delete mpText;
    1694           0 : }
    1695             : 
    1696           0 : OUString SwPostItField::Expand() const
    1697             : {
    1698           0 :     return OUString();
    1699             : }
    1700             : 
    1701           0 : OUString SwPostItField::GetDescription() const
    1702             : {
    1703           0 :     return SW_RES(STR_NOTE);
    1704             : }
    1705             : 
    1706           0 : SwField* SwPostItField::Copy() const
    1707             : {
    1708           0 :     SwPostItField* pRet = new SwPostItField( (SwPostItFieldType*)GetTyp(), sAuthor, sTxt, sInitials, sName,
    1709           0 :                                 aDateTime);
    1710           0 :     if (mpText)
    1711           0 :         pRet->SetTextObject( new OutlinerParaObject(*mpText) );
    1712             : 
    1713             :     // Note: member <m_pTextObject> not copied.
    1714             : 
    1715           0 :     return pRet;
    1716             : }
    1717             : 
    1718             : /// set author
    1719           0 : void SwPostItField::SetPar1(const OUString& rStr)
    1720             : {
    1721           0 :     sAuthor = rStr;
    1722           0 : }
    1723             : 
    1724             : /// get author
    1725           0 : OUString SwPostItField::GetPar1() const
    1726             : {
    1727           0 :     return sAuthor;
    1728             : }
    1729             : 
    1730             : /// set the PostIt's text
    1731           0 : void SwPostItField::SetPar2(const OUString& rStr)
    1732             : {
    1733           0 :     sTxt = rStr;
    1734           0 : }
    1735             : 
    1736             : /// get the PostIt's text
    1737           0 : OUString SwPostItField::GetPar2() const
    1738             : {
    1739           0 :     return sTxt;
    1740             : }
    1741             : 
    1742           0 : OUString SwPostItField::GetInitials() const
    1743             : {
    1744           0 :     return sInitials;
    1745             : }
    1746             : 
    1747           0 : void SwPostItField::SetName(const OUString& rName)
    1748             : {
    1749           0 :     sName = rName;
    1750           0 : }
    1751             : 
    1752           0 : OUString SwPostItField::GetName() const
    1753             : {
    1754           0 :     return sName;
    1755             : }
    1756             : 
    1757           0 : const OutlinerParaObject* SwPostItField::GetTextObject() const
    1758             : {
    1759           0 :     return mpText;
    1760             : }
    1761             : 
    1762           0 : void SwPostItField::SetTextObject( OutlinerParaObject* pText )
    1763             : {
    1764           0 :     delete mpText;
    1765           0 :     mpText = pText;
    1766           0 : }
    1767             : 
    1768           0 : sal_Int32 SwPostItField::GetNumberOfParagraphs() const
    1769             : {
    1770           0 :     return (mpText) ? mpText->Count() : 1;
    1771             : }
    1772             : 
    1773           0 : bool SwPostItField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
    1774             : {
    1775           0 :     switch( nWhichId )
    1776             :     {
    1777             :     case FIELD_PROP_PAR1:
    1778           0 :         rAny <<= sAuthor;
    1779           0 :         break;
    1780             :     case FIELD_PROP_PAR2:
    1781             :         {
    1782           0 :         rAny <<= sTxt;
    1783           0 :         break;
    1784             :         }
    1785             :     case FIELD_PROP_PAR3:
    1786           0 :         rAny <<= sInitials;
    1787           0 :         break;
    1788             :     case FIELD_PROP_PAR4:
    1789           0 :         rAny <<= sName;
    1790           0 :         break;
    1791             :     case FIELD_PROP_TEXT:
    1792             :         {
    1793           0 :             if ( !m_pTextObject )
    1794             :             {
    1795           0 :                 SwPostItFieldType* pGetType = (SwPostItFieldType*)GetTyp();
    1796           0 :                 SwDoc* pDoc = pGetType->GetDoc();
    1797           0 :                 SwTextAPIEditSource* pObj = new SwTextAPIEditSource( pDoc );
    1798           0 :                 const_cast <SwPostItField*> (this)->m_pTextObject = new SwTextAPIObject( pObj );
    1799           0 :                 m_pTextObject->acquire();
    1800             :             }
    1801             : 
    1802           0 :             if ( mpText )
    1803           0 :                 m_pTextObject->SetText( *mpText );
    1804             :             else
    1805           0 :                 m_pTextObject->SetString( sTxt );
    1806             : 
    1807           0 :             uno::Reference < text::XText > xText( m_pTextObject );
    1808           0 :             rAny <<= xText;
    1809           0 :             break;
    1810             :         }
    1811             :     case FIELD_PROP_DATE:
    1812             :         {
    1813           0 :             util::Date aSetDate;
    1814           0 :             aSetDate.Day = aDateTime.GetDay();
    1815           0 :             aSetDate.Month = aDateTime.GetMonth();
    1816           0 :             aSetDate.Year = aDateTime.GetYear();
    1817           0 :             rAny.setValue(&aSetDate, ::getCppuType((util::Date*)0));
    1818             :         }
    1819           0 :         break;
    1820             :     case FIELD_PROP_DATE_TIME:
    1821             :         {
    1822           0 :                 util::DateTime DateTimeValue;
    1823           0 :                 DateTimeValue.NanoSeconds = aDateTime.GetNanoSec();
    1824           0 :                 DateTimeValue.Seconds = aDateTime.GetSec();
    1825           0 :                 DateTimeValue.Minutes = aDateTime.GetMin();
    1826           0 :                 DateTimeValue.Hours = aDateTime.GetHour();
    1827           0 :                 DateTimeValue.Day = aDateTime.GetDay();
    1828           0 :                 DateTimeValue.Month = aDateTime.GetMonth();
    1829           0 :                 DateTimeValue.Year = aDateTime.GetYear();
    1830           0 :                 rAny <<= DateTimeValue;
    1831             :         }
    1832           0 :         break;
    1833             :     default:
    1834             :         OSL_FAIL("illegal property");
    1835             :     }
    1836           0 :     return true;
    1837             : }
    1838             : 
    1839           0 : bool SwPostItField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
    1840             : {
    1841           0 :     switch( nWhichId )
    1842             :     {
    1843             :     case FIELD_PROP_PAR1:
    1844           0 :         rAny >>= sAuthor;
    1845           0 :         break;
    1846             :     case FIELD_PROP_PAR2:
    1847           0 :         rAny >>= sTxt;
    1848             :         //#i100374# new string via api, delete complex text object so SwPostItNote picks up the new string
    1849           0 :         if (mpText)
    1850             :         {
    1851           0 :             delete mpText;
    1852           0 :             mpText = 0;
    1853             :         }
    1854           0 :         break;
    1855             :     case FIELD_PROP_PAR3:
    1856           0 :         rAny >>= sInitials;
    1857           0 :         break;
    1858             :     case FIELD_PROP_PAR4:
    1859           0 :         rAny >>= sName;
    1860           0 :         break;
    1861             :     case FIELD_PROP_TEXT:
    1862             :         OSL_FAIL("Not implemented!");
    1863           0 :         break;
    1864             :     case FIELD_PROP_DATE:
    1865           0 :         if( rAny.getValueType() == ::getCppuType((util::Date*)0) )
    1866             :         {
    1867           0 :             util::Date aSetDate = *(util::Date*)rAny.getValue();
    1868           0 :             aDateTime = Date(aSetDate.Day, aSetDate.Month, aSetDate.Year);
    1869             :         }
    1870           0 :         break;
    1871             :     case FIELD_PROP_DATE_TIME:
    1872             :     {
    1873           0 :         util::DateTime aDateTimeValue;
    1874           0 :         if(!(rAny >>= aDateTimeValue))
    1875           0 :             return false;
    1876           0 :         aDateTime.SetNanoSec(aDateTimeValue.NanoSeconds);
    1877           0 :         aDateTime.SetSec(aDateTimeValue.Seconds);
    1878           0 :         aDateTime.SetMin(aDateTimeValue.Minutes);
    1879           0 :         aDateTime.SetHour(aDateTimeValue.Hours);
    1880           0 :         aDateTime.SetDay(aDateTimeValue.Day);
    1881           0 :         aDateTime.SetMonth(aDateTimeValue.Month);
    1882           0 :         aDateTime.SetYear(aDateTimeValue.Year);
    1883             :     }
    1884           0 :     break;
    1885             :     default:
    1886             :         OSL_FAIL("illegal property");
    1887             :     }
    1888           0 :     return true;
    1889             : }
    1890             : 
    1891             : // extended user information field type
    1892             : 
    1893           0 : SwExtUserFieldType::SwExtUserFieldType()
    1894           0 :     : SwFieldType( RES_EXTUSERFLD )
    1895             : {
    1896           0 : }
    1897             : 
    1898           0 : SwFieldType* SwExtUserFieldType::Copy() const
    1899             : {
    1900           0 :     SwExtUserFieldType* pTyp = new SwExtUserFieldType;
    1901           0 :     return pTyp;
    1902             : }
    1903             : 
    1904           0 : OUString SwExtUserFieldType::Expand(sal_uInt16 nSub, sal_uInt32 ) const
    1905             : {
    1906           0 :     sal_uInt16 nRet = USHRT_MAX;
    1907           0 :     switch(nSub)
    1908             :     {
    1909           0 :     case EU_FIRSTNAME:      nRet = USER_OPT_FIRSTNAME; break;
    1910           0 :     case EU_NAME:           nRet = USER_OPT_LASTNAME;  break;
    1911           0 :     case EU_SHORTCUT:       nRet = USER_OPT_ID; break;
    1912             : 
    1913           0 :     case EU_COMPANY:        nRet = USER_OPT_COMPANY;        break;
    1914           0 :     case EU_STREET:         nRet = USER_OPT_STREET;         break;
    1915           0 :     case EU_TITLE:          nRet = USER_OPT_TITLE;          break;
    1916           0 :     case EU_POSITION:       nRet = USER_OPT_POSITION;       break;
    1917           0 :     case EU_PHONE_PRIVATE:  nRet = USER_OPT_TELEPHONEHOME;    break;
    1918           0 :     case EU_PHONE_COMPANY:  nRet = USER_OPT_TELEPHONEWORK;    break;
    1919           0 :     case EU_FAX:            nRet = USER_OPT_FAX;            break;
    1920           0 :     case EU_EMAIL:          nRet = USER_OPT_EMAIL;          break;
    1921           0 :     case EU_COUNTRY:        nRet = USER_OPT_COUNTRY;        break;
    1922           0 :     case EU_ZIP:            nRet = USER_OPT_ZIP;            break;
    1923           0 :     case EU_CITY:           nRet = USER_OPT_CITY;           break;
    1924           0 :     case EU_STATE:          nRet = USER_OPT_STATE;          break;
    1925           0 :     case EU_FATHERSNAME:    nRet = USER_OPT_FATHERSNAME;    break;
    1926           0 :     case EU_APARTMENT:      nRet = USER_OPT_APARTMENT;      break;
    1927             :     default:             OSL_ENSURE( !this, "Field unknown");
    1928             :     }
    1929           0 :     if( USHRT_MAX != nRet )
    1930             :     {
    1931           0 :         SvtUserOptions&  rUserOpt = SW_MOD()->GetUserOptions();
    1932           0 :         return rUserOpt.GetToken( nRet );
    1933             :     }
    1934           0 :     return OUString();
    1935             : }
    1936             : 
    1937             : // extended user information field
    1938             : 
    1939           0 : SwExtUserField::SwExtUserField(SwExtUserFieldType* pTyp, sal_uInt16 nSubTyp, sal_uInt32 nFmt) :
    1940           0 :     SwField(pTyp, nFmt), nType(nSubTyp)
    1941             : {
    1942           0 :     aContent = ((SwExtUserFieldType*)GetTyp())->Expand(nType, GetFormat());
    1943           0 : }
    1944             : 
    1945           0 : OUString SwExtUserField::Expand() const
    1946             : {
    1947           0 :     if (!IsFixed())
    1948           0 :         ((SwExtUserField*)this)->aContent = ((SwExtUserFieldType*)GetTyp())->Expand(nType, GetFormat());
    1949             : 
    1950           0 :     return aContent;
    1951             : }
    1952             : 
    1953           0 : SwField* SwExtUserField::Copy() const
    1954             : {
    1955           0 :     SwExtUserField* pFld = new SwExtUserField((SwExtUserFieldType*)GetTyp(), nType, GetFormat());
    1956           0 :     pFld->SetExpansion(aContent);
    1957             : 
    1958           0 :     return pFld;
    1959             : }
    1960             : 
    1961           0 : sal_uInt16 SwExtUserField::GetSubType() const
    1962             : {
    1963           0 :     return nType;
    1964             : }
    1965             : 
    1966           0 : void SwExtUserField::SetSubType(sal_uInt16 nSub)
    1967             : {
    1968           0 :     nType = nSub;
    1969           0 : }
    1970             : 
    1971           0 : bool SwExtUserField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
    1972             : {
    1973           0 :     switch( nWhichId )
    1974             :     {
    1975             :     case FIELD_PROP_PAR1:
    1976           0 :         rAny <<= aContent;
    1977           0 :         break;
    1978             : 
    1979             :     case FIELD_PROP_USHORT1:
    1980             :         {
    1981           0 :             sal_Int16 nTmp = nType;
    1982           0 :             rAny <<= nTmp;
    1983             :         }
    1984           0 :         break;
    1985             :     case FIELD_PROP_BOOL1:
    1986             :         {
    1987           0 :             sal_Bool bTmp = IsFixed();
    1988           0 :             rAny.setValue(&bTmp, ::getBooleanCppuType());
    1989             :         }
    1990           0 :         break;
    1991             :     default:
    1992             :         OSL_FAIL("illegal property");
    1993             :     }
    1994           0 :     return true;
    1995             : }
    1996             : 
    1997           0 : bool SwExtUserField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
    1998             : {
    1999           0 :     switch( nWhichId )
    2000             :     {
    2001             :     case FIELD_PROP_PAR1:
    2002           0 :         rAny >>= aContent;
    2003           0 :         break;
    2004             : 
    2005             :     case FIELD_PROP_USHORT1:
    2006             :         {
    2007           0 :             sal_Int16 nTmp = 0;
    2008           0 :             rAny >>= nTmp;
    2009           0 :             nType = nTmp;
    2010             :         }
    2011           0 :         break;
    2012             :     case FIELD_PROP_BOOL1:
    2013           0 :         if( *(sal_Bool*)rAny.getValue() )
    2014           0 :             SetFormat(GetFormat() | AF_FIXED);
    2015             :         else
    2016           0 :             SetFormat(GetFormat() & ~AF_FIXED);
    2017           0 :         break;
    2018             :     default:
    2019             :         OSL_FAIL("illegal property");
    2020             :     }
    2021           0 :     return true;
    2022             : }
    2023             : 
    2024             : // field type for relative page numbers
    2025             : 
    2026           0 : SwRefPageSetFieldType::SwRefPageSetFieldType()
    2027           0 :     : SwFieldType( RES_REFPAGESETFLD )
    2028             : {
    2029           0 : }
    2030             : 
    2031           0 : SwFieldType* SwRefPageSetFieldType::Copy() const
    2032             : {
    2033           0 :     return new SwRefPageSetFieldType;
    2034             : }
    2035             : 
    2036             : // overridden since there is nothing to update
    2037           0 : void SwRefPageSetFieldType::Modify( const SfxPoolItem*, const SfxPoolItem * )
    2038             : {
    2039           0 : }
    2040             : 
    2041             : // field for relative page numbers
    2042             : 
    2043           0 : SwRefPageSetField::SwRefPageSetField( SwRefPageSetFieldType* pTyp,
    2044             :                     short nOff, sal_Bool bFlag )
    2045           0 :     : SwField( pTyp ), nOffset( nOff ), bOn( bFlag )
    2046             : {
    2047           0 : }
    2048             : 
    2049           0 : OUString SwRefPageSetField::Expand() const
    2050             : {
    2051           0 :     return OUString();
    2052             : }
    2053             : 
    2054           0 : SwField* SwRefPageSetField::Copy() const
    2055             : {
    2056           0 :     return new SwRefPageSetField( (SwRefPageSetFieldType*)GetTyp(), nOffset, bOn );
    2057             : }
    2058             : 
    2059           0 : OUString SwRefPageSetField::GetPar2() const
    2060             : {
    2061           0 :     return OUString::number(GetOffset());
    2062             : }
    2063             : 
    2064           0 : void SwRefPageSetField::SetPar2(const OUString& rStr)
    2065             : {
    2066           0 :     SetOffset( (short) rStr.toInt32() );
    2067           0 : }
    2068             : 
    2069           0 : bool SwRefPageSetField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
    2070             : {
    2071           0 :     switch( nWhichId )
    2072             :     {
    2073             :     case FIELD_PROP_BOOL1:
    2074           0 :         rAny.setValue(&bOn, ::getBooleanCppuType());
    2075           0 :         break;
    2076             :     case FIELD_PROP_USHORT1:
    2077           0 :         rAny <<= (sal_Int16)nOffset;
    2078           0 :         break;
    2079             :     default:
    2080             :         OSL_FAIL("illegal property");
    2081             :     }
    2082           0 :     return true;
    2083             : }
    2084             : 
    2085           0 : bool SwRefPageSetField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
    2086             : {
    2087           0 :     switch( nWhichId )
    2088             :     {
    2089             :     case FIELD_PROP_BOOL1:
    2090           0 :         bOn = *(sal_Bool*)rAny.getValue();
    2091           0 :         break;
    2092             :     case FIELD_PROP_USHORT1:
    2093           0 :         rAny >>=nOffset;
    2094           0 :         break;
    2095             :     default:
    2096             :         OSL_FAIL("illegal property");
    2097             :     }
    2098           0 :     return true;
    2099             : }
    2100             : 
    2101             : // relative page numbers - query field
    2102             : 
    2103           0 : SwRefPageGetFieldType::SwRefPageGetFieldType( SwDoc* pDc )
    2104           0 :     : SwFieldType( RES_REFPAGEGETFLD ), pDoc( pDc ), nNumberingType( SVX_NUM_ARABIC )
    2105             : {
    2106           0 : }
    2107             : 
    2108           0 : SwFieldType* SwRefPageGetFieldType::Copy() const
    2109             : {
    2110           0 :     SwRefPageGetFieldType* pNew = new SwRefPageGetFieldType( pDoc );
    2111           0 :     pNew->nNumberingType = nNumberingType;
    2112           0 :     return pNew;
    2113             : }
    2114             : 
    2115           0 : void SwRefPageGetFieldType::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew )
    2116             : {
    2117             :     // update all GetReference fields
    2118           0 :     if( !pNew && !pOld && GetDepends() )
    2119             :     {
    2120             :         // first collect all SetPageRefFields
    2121           0 :         _SetGetExpFlds aTmpLst;
    2122           0 :         if( MakeSetList( aTmpLst ) )
    2123             :         {
    2124           0 :             SwIterator<SwFmtFld,SwFieldType> aIter( *this );
    2125           0 :             for ( SwFmtFld* pFmtFld = aIter.First(); pFmtFld; pFmtFld = aIter.Next() )
    2126             :                     // update only the GetRef fields
    2127           0 :                     if( pFmtFld->GetTxtFld() )
    2128           0 :                         UpdateField( pFmtFld->GetTxtFld(), aTmpLst );
    2129           0 :         }
    2130             :     }
    2131             : 
    2132             :     // forward to text fields, they "expand" the text
    2133           0 :     NotifyClients( pOld, pNew );
    2134           0 : }
    2135             : 
    2136           0 : sal_uInt16 SwRefPageGetFieldType::MakeSetList( _SetGetExpFlds& rTmpLst )
    2137             : {
    2138           0 :     SwIterator<SwFmtFld,SwFieldType> aIter(*pDoc->GetSysFldType( RES_REFPAGESETFLD));
    2139           0 :     for ( SwFmtFld* pFmtFld = aIter.First(); pFmtFld; pFmtFld = aIter.Next() )
    2140             :     {
    2141             :             // update only the GetRef fields
    2142           0 :             const SwTxtFld* pTFld = pFmtFld->GetTxtFld();
    2143           0 :             if( pTFld )
    2144             :             {
    2145           0 :                 const SwTxtNode& rTxtNd = pTFld->GetTxtNode();
    2146             : 
    2147             :                 // Always the first! (in Tab-Headline, header/footer )
    2148           0 :                 Point aPt;
    2149           0 :                 const SwCntntFrm* pFrm = rTxtNd.getLayoutFrm( rTxtNd.GetDoc()->GetCurrentLayout(), &aPt, 0, false );
    2150             : 
    2151             :                 _SetGetExpFld* pNew;
    2152             : 
    2153           0 :                 if( !pFrm ||
    2154           0 :                      pFrm->IsInDocBody() ||
    2155             :                     // #i31868#
    2156             :                     // Check if pFrm is not yet connected to the layout.
    2157           0 :                     !pFrm->FindPageFrm() )
    2158             :                 {
    2159             :                     //  create index for determination of the TextNode
    2160           0 :                     SwNodeIndex aIdx( rTxtNd );
    2161           0 :                     pNew = new _SetGetExpFld( aIdx, pTFld );
    2162             :                 }
    2163             :                 else
    2164             :                 {
    2165             :                     //  create index for determination of the TextNode
    2166           0 :                     SwPosition aPos( pDoc->GetNodes().GetEndOfPostIts() );
    2167           0 :                     bool const bResult = GetBodyTxtNode( *pDoc, aPos, *pFrm );
    2168             :                     OSL_ENSURE(bResult, "where is the Field?");
    2169             :                     (void) bResult; // unused in non-debug
    2170             :                     pNew = new _SetGetExpFld( aPos.nNode, pTFld,
    2171           0 :                                                 &aPos.nContent );
    2172             :                 }
    2173             : 
    2174           0 :                 if( !rTmpLst.insert( pNew ).second)
    2175           0 :                     delete pNew;
    2176             :             }
    2177             :     }
    2178             : 
    2179           0 :     return rTmpLst.size();
    2180             : }
    2181             : 
    2182           0 : void SwRefPageGetFieldType::UpdateField( SwTxtFld* pTxtFld,
    2183             :                                         _SetGetExpFlds& rSetList )
    2184             : {
    2185           0 :     SwRefPageGetField* pGetFld = (SwRefPageGetField*)pTxtFld->GetFmtFld().GetField();
    2186           0 :     pGetFld->SetText( OUString() );
    2187             : 
    2188             :     // then search the correct RefPageSet field
    2189           0 :     SwTxtNode* pTxtNode = (SwTxtNode*)&pTxtFld->GetTxtNode();
    2190           0 :     if( pTxtNode->StartOfSectionIndex() >
    2191           0 :         pDoc->GetNodes().GetEndOfExtras().GetIndex() )
    2192             :     {
    2193           0 :         SwNodeIndex aIdx( *pTxtNode );
    2194           0 :         _SetGetExpFld aEndFld( aIdx, pTxtFld );
    2195             : 
    2196           0 :         _SetGetExpFlds::const_iterator itLast = rSetList.lower_bound( &aEndFld );
    2197             : 
    2198           0 :         if( itLast != rSetList.begin() )
    2199             :         {
    2200           0 :             --itLast;
    2201           0 :             const SwTxtFld* pRefTxtFld = (*itLast)->GetTxtFld();
    2202             :             const SwRefPageSetField* pSetFld =
    2203           0 :                         (SwRefPageSetField*)pRefTxtFld->GetFmtFld().GetField();
    2204           0 :             if( pSetFld->IsOn() )
    2205             :             {
    2206             :                 // determine the correct offset
    2207           0 :                 Point aPt;
    2208           0 :                 const SwCntntFrm* pFrm = pTxtNode->getLayoutFrm( pTxtNode->GetDoc()->GetCurrentLayout(), &aPt, 0, false );
    2209           0 :                 const SwCntntFrm* pRefFrm = pRefTxtFld->GetTxtNode().getLayoutFrm( pRefTxtFld->GetTxtNode().GetDoc()->GetCurrentLayout(), &aPt, 0, false );
    2210           0 :                 const SwPageFrm* pPgFrm = 0;
    2211           0 :                 sal_uInt16 nDiff = ( pFrm && pRefFrm )
    2212           0 :                         ?   (pPgFrm = pFrm->FindPageFrm())->GetPhyPageNum() -
    2213           0 :                             pRefFrm->FindPageFrm()->GetPhyPageNum() + 1
    2214           0 :                         : 1;
    2215             : 
    2216           0 :                 sal_uInt32 nTmpFmt = SVX_NUM_PAGEDESC == pGetFld->GetFormat()
    2217             :                         ? ( !pPgFrm
    2218             :                                 ? (sal_uInt32)SVX_NUM_ARABIC
    2219           0 :                                 : pPgFrm->GetPageDesc()->GetNumType().GetNumberingType() )
    2220           0 :                         : pGetFld->GetFormat();
    2221           0 :                 short nPageNum = static_cast<short>(std::max(0, pSetFld->GetOffset() + (short)nDiff));
    2222           0 :                 pGetFld->SetText( FormatNumber( nPageNum, nTmpFmt ) );
    2223             :             }
    2224           0 :         }
    2225             :     }
    2226             :     // start formatting
    2227           0 :     ((SwFmtFld&)pTxtFld->GetFmtFld()).ModifyNotification( 0, 0 );
    2228           0 : }
    2229             : 
    2230             : // queries for relative page numbering
    2231             : 
    2232           0 : SwRefPageGetField::SwRefPageGetField( SwRefPageGetFieldType* pTyp,
    2233             :                                     sal_uInt32 nFmt )
    2234           0 :     : SwField( pTyp, nFmt )
    2235             : {
    2236           0 : }
    2237             : 
    2238           0 : OUString SwRefPageGetField::Expand() const
    2239             : {
    2240           0 :     return sTxt;
    2241             : }
    2242             : 
    2243           0 : SwField* SwRefPageGetField::Copy() const
    2244             : {
    2245             :     SwRefPageGetField* pCpy = new SwRefPageGetField(
    2246           0 :                         (SwRefPageGetFieldType*)GetTyp(), GetFormat() );
    2247           0 :     pCpy->SetText( sTxt );
    2248           0 :     return pCpy;
    2249             : }
    2250             : 
    2251           0 : void SwRefPageGetField::ChangeExpansion( const SwFrm* pFrm,
    2252             :                                         const SwTxtFld* pFld )
    2253             : {
    2254             :     // only fields in Footer, Header, FootNote, Flys
    2255           0 :     SwRefPageGetFieldType* pGetType = (SwRefPageGetFieldType*)GetTyp();
    2256           0 :     SwDoc* pDoc = pGetType->GetDoc();
    2257           0 :     if( pFld->GetTxtNode().StartOfSectionIndex() >
    2258           0 :         pDoc->GetNodes().GetEndOfExtras().GetIndex() )
    2259           0 :         return;
    2260             : 
    2261           0 :     sTxt = OUString();
    2262             : 
    2263             :     OSL_ENSURE( !pFrm->IsInDocBody(), "Flag incorrect, frame is in DocBody" );
    2264             : 
    2265             :     // collect all SetPageRefFields
    2266           0 :     _SetGetExpFlds aTmpLst;
    2267           0 :     if( !pGetType->MakeSetList( aTmpLst ) )
    2268           0 :         return ;
    2269             : 
    2270             :     //  create index for determination of the TextNode
    2271           0 :     SwPosition aPos( SwNodeIndex( pDoc->GetNodes() ) );
    2272           0 :     SwTxtNode* pTxtNode = (SwTxtNode*) GetBodyTxtNode( *pDoc, aPos, *pFrm );
    2273             : 
    2274             :     // If no layout exists, ChangeExpansion is called for header and
    2275             :     // footer lines via layout formatting without existing TxtNode.
    2276           0 :     if(!pTxtNode)
    2277           0 :         return;
    2278             : 
    2279           0 :     _SetGetExpFld aEndFld( aPos.nNode, pFld, &aPos.nContent );
    2280             : 
    2281           0 :     _SetGetExpFlds::const_iterator itLast = aTmpLst.lower_bound( &aEndFld );
    2282             : 
    2283           0 :     if( itLast == aTmpLst.begin() )
    2284           0 :         return;        // there is no corresponding set-field in front
    2285           0 :     --itLast;
    2286             : 
    2287           0 :     const SwTxtFld* pRefTxtFld = (*itLast)->GetTxtFld();
    2288             :     const SwRefPageSetField* pSetFld =
    2289           0 :                         (SwRefPageSetField*)pRefTxtFld->GetFmtFld().GetField();
    2290           0 :     Point aPt;
    2291           0 :     const SwCntntFrm* pRefFrm = pRefTxtFld->GetTxtNode().getLayoutFrm( pFrm->getRootFrm(), &aPt, 0, false );
    2292           0 :     if( pSetFld->IsOn() && pRefFrm )
    2293             :     {
    2294             :         // determine the correct offset
    2295           0 :         const SwPageFrm* pPgFrm = pFrm->FindPageFrm();
    2296           0 :         sal_uInt16 nDiff = pPgFrm->GetPhyPageNum() -
    2297           0 :                             pRefFrm->FindPageFrm()->GetPhyPageNum() + 1;
    2298             : 
    2299           0 :         SwRefPageGetField* pGetFld = (SwRefPageGetField*)pFld->GetFmtFld().GetField();
    2300           0 :         sal_uInt32 nTmpFmt = SVX_NUM_PAGEDESC == pGetFld->GetFormat()
    2301           0 :                             ? pPgFrm->GetPageDesc()->GetNumType().GetNumberingType()
    2302           0 :                             : pGetFld->GetFormat();
    2303           0 :         short nPageNum = static_cast<short>(std::max(0, pSetFld->GetOffset() + (short)nDiff ));
    2304           0 :         pGetFld->SetText( FormatNumber( nPageNum, nTmpFmt ) );
    2305           0 :     }
    2306             : }
    2307             : 
    2308           0 : bool SwRefPageGetField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
    2309             : {
    2310           0 :     switch( nWhichId )
    2311             :     {
    2312             :         case FIELD_PROP_USHORT1:
    2313           0 :             rAny <<= (sal_Int16)GetFormat();
    2314           0 :         break;
    2315             :         case FIELD_PROP_PAR1:
    2316           0 :             rAny <<= sTxt;
    2317           0 :         break;
    2318             :         default:
    2319             :             OSL_FAIL("illegal property");
    2320             :     }
    2321           0 :     return true;
    2322             : }
    2323             : 
    2324           0 : bool SwRefPageGetField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
    2325             : {
    2326           0 :     switch( nWhichId )
    2327             :     {
    2328             :         case FIELD_PROP_USHORT1:
    2329             :         {
    2330           0 :             sal_Int16 nSet = 0;
    2331           0 :             rAny >>= nSet;
    2332           0 :             if(nSet <= SVX_NUM_PAGEDESC )
    2333           0 :                 SetFormat(nSet);
    2334             :             else {
    2335             :             }
    2336             :         }
    2337           0 :         break;
    2338             :         case FIELD_PROP_PAR1:
    2339           0 :             rAny >>= sTxt;
    2340           0 :         break;
    2341             :     default:
    2342             :         OSL_FAIL("illegal property");
    2343             :     }
    2344           0 :     return true;
    2345             : }
    2346             : 
    2347             : // field type to jump to and edit
    2348             : 
    2349           0 : SwJumpEditFieldType::SwJumpEditFieldType( SwDoc* pD )
    2350           0 :     : SwFieldType( RES_JUMPEDITFLD ), pDoc( pD ), aDep( this, 0 )
    2351             : {
    2352           0 : }
    2353             : 
    2354           0 : SwFieldType* SwJumpEditFieldType::Copy() const
    2355             : {
    2356           0 :     return new SwJumpEditFieldType( pDoc );
    2357             : }
    2358             : 
    2359           0 : SwCharFmt* SwJumpEditFieldType::GetCharFmt()
    2360             : {
    2361           0 :     SwCharFmt* pFmt = pDoc->GetCharFmtFromPool( RES_POOLCHR_JUMPEDIT );
    2362             : 
    2363             :     // not registered yet?
    2364           0 :     if( !aDep.GetRegisteredIn() )
    2365           0 :         pFmt->Add( &aDep );     // register
    2366             : 
    2367           0 :     return pFmt;
    2368             : }
    2369             : 
    2370           0 : SwJumpEditField::SwJumpEditField( SwJumpEditFieldType* pTyp, sal_uInt32 nForm,
    2371             :                                 const OUString& rTxt, const OUString& rHelp )
    2372           0 :     : SwField( pTyp, nForm ), sTxt( rTxt ), sHelp( rHelp )
    2373             : {
    2374           0 : }
    2375             : 
    2376           0 : OUString SwJumpEditField::Expand() const
    2377             : {
    2378           0 :     return "<" + sTxt + ">";
    2379             : }
    2380             : 
    2381           0 : SwField* SwJumpEditField::Copy() const
    2382             : {
    2383           0 :     return new SwJumpEditField( (SwJumpEditFieldType*)GetTyp(), GetFormat(),
    2384           0 :                                 sTxt, sHelp );
    2385             : }
    2386             : 
    2387             : /// get place holder text
    2388           0 : OUString SwJumpEditField::GetPar1() const
    2389             : {
    2390           0 :     return sTxt;
    2391             : }
    2392             : 
    2393             : /// set place holder text
    2394           0 : void SwJumpEditField::SetPar1(const OUString& rStr)
    2395             : {
    2396           0 :     sTxt = rStr;
    2397           0 : }
    2398             : 
    2399             : /// get hint text
    2400           0 : OUString SwJumpEditField::GetPar2() const
    2401             : {
    2402           0 :     return sHelp;
    2403             : }
    2404             : 
    2405             : /// set hint text
    2406           0 : void SwJumpEditField::SetPar2(const OUString& rStr)
    2407             : {
    2408           0 :     sHelp = rStr;
    2409           0 : }
    2410             : 
    2411           0 : bool SwJumpEditField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
    2412             : {
    2413           0 :     switch( nWhichId )
    2414             :     {
    2415             :     case FIELD_PROP_USHORT1:
    2416             :         {
    2417             :             sal_Int16 nRet;
    2418           0 :             switch( GetFormat() )
    2419             :             {
    2420           0 :             case JE_FMT_TABLE:  nRet = text::PlaceholderType::TABLE; break;
    2421           0 :             case JE_FMT_FRAME:  nRet = text::PlaceholderType::TEXTFRAME; break;
    2422           0 :             case JE_FMT_GRAPHIC:nRet = text::PlaceholderType::GRAPHIC; break;
    2423           0 :             case JE_FMT_OLE:    nRet = text::PlaceholderType::OBJECT; break;
    2424             :             default:
    2425           0 :                 nRet = text::PlaceholderType::TEXT; break;
    2426             :             }
    2427           0 :             rAny <<= nRet;
    2428             :         }
    2429           0 :         break;
    2430             :     case FIELD_PROP_PAR1 :
    2431           0 :         rAny <<= sHelp;
    2432           0 :         break;
    2433             :     case FIELD_PROP_PAR2 :
    2434           0 :          rAny <<= sTxt;
    2435           0 :          break;
    2436             :     default:
    2437             :         OSL_FAIL("illegal property");
    2438             :     }
    2439           0 :     return true;
    2440             : }
    2441             : 
    2442           0 : bool SwJumpEditField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
    2443             : {
    2444           0 :     switch( nWhichId )
    2445             :     {
    2446             :     case FIELD_PROP_USHORT1:
    2447             :         {
    2448             :             //JP 24.10.2001: int32 because in UnoField.cxx a putvalue is
    2449             :             //              called with a int32 value! But normally we need
    2450             :             //              here only a int16
    2451           0 :             sal_Int32 nSet = 0;
    2452           0 :             rAny >>= nSet;
    2453           0 :             switch( nSet )
    2454             :             {
    2455           0 :                 case text::PlaceholderType::TEXT     : SetFormat(JE_FMT_TEXT); break;
    2456           0 :                 case text::PlaceholderType::TABLE    : SetFormat(JE_FMT_TABLE); break;
    2457           0 :                 case text::PlaceholderType::TEXTFRAME: SetFormat(JE_FMT_FRAME); break;
    2458           0 :                 case text::PlaceholderType::GRAPHIC  : SetFormat(JE_FMT_GRAPHIC); break;
    2459           0 :                 case text::PlaceholderType::OBJECT   : SetFormat(JE_FMT_OLE); break;
    2460             :             }
    2461             :         }
    2462           0 :         break;
    2463             :     case FIELD_PROP_PAR1 :
    2464           0 :         rAny >>= sHelp;
    2465           0 :         break;
    2466             :     case FIELD_PROP_PAR2 :
    2467           0 :          rAny >>= sTxt;
    2468           0 :          break;
    2469             :     default:
    2470             :         OSL_FAIL("illegal property");
    2471             :     }
    2472           0 :     return true;
    2473             : }
    2474             : 
    2475             : // combined character field type
    2476             : 
    2477           0 : SwCombinedCharFieldType::SwCombinedCharFieldType()
    2478           0 :     : SwFieldType( RES_COMBINED_CHARS )
    2479             : {
    2480           0 : }
    2481             : 
    2482           0 : SwFieldType* SwCombinedCharFieldType::Copy() const
    2483             : {
    2484           0 :     return new SwCombinedCharFieldType;
    2485             : }
    2486             : 
    2487             : // combined character field
    2488             : 
    2489           0 : SwCombinedCharField::SwCombinedCharField( SwCombinedCharFieldType* pFTyp,
    2490             :                                             const OUString& rChars )
    2491             :     : SwField( pFTyp, 0 ),
    2492           0 :     sCharacters( rChars.copy( 0, std::min<sal_Int32>(rChars.getLength(), MAX_COMBINED_CHARACTERS) ))
    2493             : {
    2494           0 : }
    2495             : 
    2496           0 : OUString SwCombinedCharField::Expand() const
    2497             : {
    2498           0 :     return sCharacters;
    2499             : }
    2500             : 
    2501           0 : SwField* SwCombinedCharField::Copy() const
    2502             : {
    2503           0 :     return new SwCombinedCharField( (SwCombinedCharFieldType*)GetTyp(),
    2504           0 :                                         sCharacters );
    2505             : }
    2506             : 
    2507           0 : OUString SwCombinedCharField::GetPar1() const
    2508             : {
    2509           0 :     return sCharacters;
    2510             : }
    2511             : 
    2512           0 : void SwCombinedCharField::SetPar1(const OUString& rStr)
    2513             : {
    2514           0 :     sCharacters = rStr.copy(0, std::min<sal_Int32>(rStr.getLength(), MAX_COMBINED_CHARACTERS));
    2515           0 : }
    2516             : 
    2517           0 : bool SwCombinedCharField::QueryValue( uno::Any& rAny,
    2518             :                                         sal_uInt16 nWhichId ) const
    2519             : {
    2520           0 :     switch( nWhichId )
    2521             :     {
    2522             :     case FIELD_PROP_PAR1:
    2523           0 :         rAny <<= sCharacters;
    2524           0 :         break;
    2525             :     default:
    2526             :         OSL_FAIL("illegal property");
    2527             :     }
    2528           0 :     return true;
    2529             : }
    2530             : 
    2531           0 : bool SwCombinedCharField::PutValue( const uno::Any& rAny,
    2532             :                                         sal_uInt16 nWhichId )
    2533             : {
    2534           0 :     switch( nWhichId )
    2535             :     {
    2536             :         case FIELD_PROP_PAR1:
    2537             :         {
    2538           0 :             OUString sTmp;
    2539           0 :             rAny >>= sTmp;
    2540           0 :             SetPar1(sTmp);
    2541             :         }
    2542           0 :         break;
    2543             :         default:
    2544             :             OSL_FAIL("illegal property");
    2545             :     }
    2546           0 :     return true;
    2547             : }
    2548             : 
    2549             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10