diff options
author | Valentin Kettner <vakevk+libreoffice@gmail.com> | 2014-07-24 16:46:12 +0200 |
---|---|---|
committer | Valentin Kettner <vakevk+libreoffice@gmail.com> | 2014-08-12 23:26:36 +0200 |
commit | 69e5f335abcd838ad6dac04f8e2d14f39856dc43 (patch) | |
tree | 19b7e1a929576ec4da8ca981d8aee7a519b119bd /sw/source | |
parent | 274f1811b92b870b8d450423d9b280b0889ca130 (diff) |
Refactored IDocumentFieldsAccess out of SwDoc.
Into the new class DocumentFieldsManager.
Removed SwDoc::_MakeFldList because it is not defined anywhere.
Also moved a few non interface methods that belong to the manager.
Change-Id: Icefd7ca7adcbb05a18d6fae0529fc54150b862fd
Diffstat (limited to 'sw/source')
87 files changed, 2211 insertions, 1924 deletions
diff --git a/sw/source/core/attr/format.cxx b/sw/source/core/attr/format.cxx index 9af7f6a9cc20..2779e7456018 100644 --- a/sw/source/core/attr/format.cxx +++ b/sw/source/core/attr/format.cxx @@ -766,7 +766,7 @@ IDocumentDrawModelAccess* SwFmt::getIDocumentDrawModelAccess() { return & GetDoc const IDocumentLayoutAccess* SwFmt::getIDocumentLayoutAccess() const { return GetDoc(); } IDocumentLayoutAccess* SwFmt::getIDocumentLayoutAccess() { return GetDoc(); } IDocumentTimerAccess* SwFmt::getIDocumentTimerAccess() { return & GetDoc()->getIDocumentTimerAccess(); } -IDocumentFieldsAccess* SwFmt::getIDocumentFieldsAccess() { return GetDoc(); } +IDocumentFieldsAccess* SwFmt::getIDocumentFieldsAccess() { return &GetDoc()->getIDocumentFieldsAccess(); } IDocumentChartDataProviderAccess* SwFmt::getIDocumentChartDataProviderAccess() { return & GetDoc()->getIDocumentChartDataProviderAccess(); } void SwFmt::GetGrabBagItem(uno::Any& rVal) const diff --git a/sw/source/core/bastyp/calc.cxx b/sw/source/core/bastyp/calc.cxx index 5e637d0fd29c..5b95e33a17b4 100644 --- a/sw/source/core/bastyp/calc.cxx +++ b/sw/source/core/bastyp/calc.cxx @@ -32,6 +32,7 @@ #include <docfld.hxx> #include <docstat.hxx> #include <doc.hxx> +#include <IDocumentFieldsAccess.hxx> #include <editeng/langitem.hxx> #include <editeng/scripttypeitem.hxx> #include <editeng/unolingu.hxx> @@ -456,7 +457,7 @@ SwCalcExp* SwCalc::VarLook( const OUString& rStr, sal_uInt16 ins ) if( !pFnd ) { // then check doc - SwHash** ppDocTbl = rDoc.GetUpdtFlds().GetFldTypeTable(); + SwHash** ppDocTbl = rDoc.getIDocumentFieldsAccess().GetUpdtFlds().GetFldTypeTable(); for( SwHash* pEntry = *(ppDocTbl+ii); pEntry; pEntry = pEntry->pNext ) { if( aStr == pEntry->aStr ) diff --git a/sw/source/core/crsr/annotationmark.cxx b/sw/source/core/crsr/annotationmark.cxx index 95faaa52fe90..faa379ccfa52 100644 --- a/sw/source/core/crsr/annotationmark.cxx +++ b/sw/source/core/crsr/annotationmark.cxx @@ -21,6 +21,7 @@ #include <doc.hxx> #include <IDocumentMarkAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <fldbas.hxx> #include <switerator.hxx> #include <fmtfld.hxx> @@ -88,7 +89,7 @@ namespace sw { namespace mark SwFmtFld* pAnnotationFmtFld = NULL; - SwFieldType* pType = pDoc->GetFldType( RES_POSTITFLD, OUString(), false ); + SwFieldType* pType = pDoc->getIDocumentFieldsAccess().GetFldType( RES_POSTITFLD, OUString(), false ); SwIterator<SwFmtFld,SwFieldType> aIter( *pType ); for( SwFmtFld* pFmtFld = aIter.First(); pFmtFld != NULL; pFmtFld = aIter.Next() ) { diff --git a/sw/source/core/crsr/crstrvl.cxx b/sw/source/core/crsr/crstrvl.cxx index 856a5265ff3f..161b10f1081e 100644 --- a/sw/source/core/crsr/crstrvl.cxx +++ b/sw/source/core/crsr/crstrvl.cxx @@ -28,6 +28,7 @@ #include <doc.hxx> #include <IDocumentUndoRedo.hxx> #include <IDocumentRedlineAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <pagefrm.hxx> #include <cntfrm.hxx> #include <rootfrm.hxx> @@ -628,7 +629,7 @@ bool SwCrsrShell::MoveFldType( if( RES_INPUTFLD == pFldType->Which() && bAddSetExpressionFldsToInputFlds ) { // there are hidden input fields in the set exp. fields - const SwFldTypes& rFldTypes = *mpDoc->GetFldTypes(); + const SwFldTypes& rFldTypes = *mpDoc->getIDocumentFieldsAccess().GetFldTypes(); const size_t nSize = rFldTypes.size(); for( size_t i=0; i < nSize; ++i ) { @@ -642,7 +643,7 @@ bool SwCrsrShell::MoveFldType( } else { - const SwFldTypes& rFldTypes = *mpDoc->GetFldTypes(); + const SwFldTypes& rFldTypes = *mpDoc->getIDocumentFieldsAccess().GetFldTypes(); const size_t nSize = rFldTypes.size(); for( size_t i=0; i < nSize; ++i ) { @@ -675,7 +676,7 @@ bool SwCrsrShell::MoveFldType( { // create dummy for the search SwFmtFld* pFmtFld = new SwFmtFld( SwDateTimeField( - (SwDateTimeFieldType*)mpDoc->GetSysFldType( RES_DATETIMEFLD ) ) ); + (SwDateTimeFieldType*)mpDoc->getIDocumentFieldsAccess().GetSysFldType( RES_DATETIMEFLD ) ) ); pTxtFld = new SwTxtFld( *pFmtFld, rPos.nContent.GetIndex(), mpDoc->IsClipBoard() ); diff --git a/sw/source/core/doc/CntntIdxStore.cxx b/sw/source/core/doc/CntntIdxStore.cxx index ee22f8690e51..ffbd356f236f 100644 --- a/sw/source/core/doc/CntntIdxStore.cxx +++ b/sw/source/core/doc/CntntIdxStore.cxx @@ -23,6 +23,7 @@ #include <boost/make_shared.hpp> #include <cntfrm.hxx> #include <doc.hxx> +#include <IDocumentRedlineAccess.hxx> #include <docary.hxx> #include <editsh.hxx> #include <fmtanchr.hxx> @@ -264,8 +265,9 @@ void CntntIdxStoreImpl::RestoreBkmks(SwDoc* pDoc, updater_t& rUpdater) void CntntIdxStoreImpl::SaveRedlines(SwDoc* pDoc, sal_uLong nNode, sal_Int32 nCntnt) { + SwRedlineTbl const & pRedlineTbl = pDoc->getIDocumentRedlineAccess().GetRedlineTbl(); long int nIdx = 0; - BOOST_FOREACH(const SwRangeRedline* pRdl, pDoc->GetRedlineTbl()) + BOOST_FOREACH(const SwRangeRedline* pRdl, std::make_pair(pRedlineTbl.begin(), pRedlineTbl.end())) { int nPointPos = lcl_RelativePosition( *pRdl->GetPoint(), nNode, nCntnt ); int nMarkPos = pRdl->HasMark() ? lcl_RelativePosition( *pRdl->GetMark(), nNode, nCntnt ) : @@ -291,7 +293,7 @@ void CntntIdxStoreImpl::SaveRedlines(SwDoc* pDoc, sal_uLong nNode, sal_Int32 nCn void CntntIdxStoreImpl::RestoreRedlines(SwDoc* pDoc, updater_t& rUpdater) { - const SwRedlineTbl& rRedlTbl = pDoc->GetRedlineTbl(); + const SwRedlineTbl& rRedlTbl = pDoc->getIDocumentRedlineAccess().GetRedlineTbl(); BOOST_FOREACH(const MarkEntry& aEntry, m_aRedlineEntries) { SwPosition* const pPos = (SwPosition*)( aEntry.m_bOther diff --git a/sw/source/core/doc/DocumentFieldsManager.cxx b/sw/source/core/doc/DocumentFieldsManager.cxx new file mode 100644 index 000000000000..ddd557b11a63 --- /dev/null +++ b/sw/source/core/doc/DocumentFieldsManager.cxx @@ -0,0 +1,1667 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with &m_rSwdoc work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#include <DocumentFieldsManager.hxx> +#include <config_features.h> +#include <doc.hxx> +#include <IDocumentUndoRedo.hxx> +#include <dbmgr.hxx> +#include <chpfld.hxx> +#include <dbfld.hxx> +#include <reffld.hxx> +#include <flddropdown.hxx> +#include <poolfmt.hrc> +#include <SwUndoField.hxx> +#include <flddat.hxx> +#include <cntfrm.hxx> +#include <dbfld.hxx> +#include <section.hxx> +#include <docufld.hxx> +#include <switerator.hxx> +#include <cellatr.hxx> +#include <swtable.hxx> +#include <frmfmt.hxx> +#include <fmtfld.hxx> +#include <ndtxt.hxx> +#include <txtfld.hxx> +#include <docfld.hxx> +#include <hints.hxx> +#include <docary.hxx> +#include <fldbas.hxx> +#include <expfld.hxx> +#include <ddefld.hxx> +#include <authfld.hxx> +#include <usrfld.hxx> +#include <unotools/transliterationwrapper.hxx> +#include <com/sun/star/uno/Any.hxx> + +using namespace ::com::sun::star::uno; + +namespace +{ + #if HAVE_FEATURE_DBCONNECTIVITY + + static OUString lcl_GetDBVarName( SwDoc& rDoc, SwDBNameInfField& rDBFld ) + { + SwDBData aDBData( rDBFld.GetDBData( &rDoc )); + OUString sDBNumNm; + SwDBData aDocData = rDoc.GetDBData(); + + if( aDBData != aDocData ) + { + sDBNumNm = aDBData.sDataSource; + sDBNumNm += OUString(DB_DELIM); + sDBNumNm += aDBData.sCommand; + sDBNumNm += OUString(DB_DELIM); + } + sDBNumNm += SwFieldType::GetTypeStr(TYP_DBSETNUMBERFLD); + + return sDBNumNm; + } + + #endif + + static void lcl_CalcFld( SwDoc& rDoc, SwCalc& rCalc, const _SetGetExpFld& rSGEFld, + SwDBManager* pMgr ) + { + const SwTxtFld* pTxtFld = rSGEFld.GetTxtFld(); + if( !pTxtFld ) + return ; + + const SwField* pFld = pTxtFld->GetFmtFld().GetField(); + const sal_uInt16 nFldWhich = pFld->GetTyp()->Which(); + + if( RES_SETEXPFLD == nFldWhich ) + { + SwSbxValue aValue; + if( nsSwGetSetExpType::GSE_EXPR & pFld->GetSubType() ) + aValue.PutDouble( ((SwSetExpField*)pFld)->GetValue() ); + else + // Extension to calculate with Strings + aValue.PutString( ((SwSetExpField*)pFld)->GetExpStr() ); + + // set the new value in Calculator + rCalc.VarChange( pFld->GetTyp()->GetName(), aValue ); + } + else if( pMgr ) + { + #if !HAVE_FEATURE_DBCONNECTIVITY + (void) rDoc; + #else + switch( nFldWhich ) + { + case RES_DBNUMSETFLD: + { + SwDBNumSetField* pDBFld = (SwDBNumSetField*)pFld; + + SwDBData aDBData(pDBFld->GetDBData(&rDoc)); + + if( pDBFld->IsCondValid() && + pMgr->OpenDataSource( aDBData.sDataSource, aDBData.sCommand )) + rCalc.VarChange( lcl_GetDBVarName( rDoc, *pDBFld), + pDBFld->GetFormat() ); + } + break; + case RES_DBNEXTSETFLD: + { + SwDBNextSetField* pDBFld = (SwDBNextSetField*)pFld; + SwDBData aDBData(pDBFld->GetDBData(&rDoc)); + if( !pDBFld->IsCondValid() || + !pMgr->OpenDataSource( aDBData.sDataSource, aDBData.sCommand )) + break; + + OUString sDBNumNm(lcl_GetDBVarName( rDoc, *pDBFld)); + SwCalcExp* pExp = rCalc.VarLook( sDBNumNm ); + if( pExp ) + rCalc.VarChange( sDBNumNm, pExp->nValue.GetLong() + 1 ); + } + break; + + } + #endif + } + } +} + +namespace sw +{ + +DocumentFieldsManager::DocumentFieldsManager( SwDoc& i_rSwdoc ) : m_rSwdoc( i_rSwdoc ), + mbNewFldLst(true), + mpUpdtFlds( new SwDocUpdtFld( &m_rSwdoc ) ), + mpFldTypes( new SwFldTypes() ), + mnLockExpFld( 0 ) +{ +} + +const SwFldTypes* DocumentFieldsManager::GetFldTypes() const +{ + return mpFldTypes; +} + +/** Insert field types + * + * @param rFldTyp ??? + * @return Always returns a pointer to the type, if it's new or already added. + */ +SwFieldType* DocumentFieldsManager::InsertFldType(const SwFieldType &rFldTyp) +{ + sal_uInt16 nSize = mpFldTypes->size(), + nFldWhich = rFldTyp.Which(); + + sal_uInt16 i = INIT_FLDTYPES; + + switch( nFldWhich ) + { + case RES_SETEXPFLD: + //JP 29.01.96: SequenceFields start at INIT_FLDTYPES - 3!! + // Or we get doubble number circles!! + //MIB 14.03.95: From now on also the SW3-Reader relies on &m_rSwdoc, when + //constructing string pools and when reading SetExp fields + if( nsSwGetSetExpType::GSE_SEQ & ((SwSetExpFieldType&)rFldTyp).GetType() ) + i -= INIT_SEQ_FLDTYPES; + // no break; + case RES_DBFLD: + case RES_USERFLD: + case RES_DDEFLD: + { + const ::utl::TransliterationWrapper& rSCmp = GetAppCmpStrIgnore(); + OUString sFldNm( rFldTyp.GetName() ); + for( ; i < nSize; ++i ) + if( nFldWhich == (*mpFldTypes)[i]->Which() && + rSCmp.isEqual( sFldNm, (*mpFldTypes)[i]->GetName() )) + return (*mpFldTypes)[i]; + } + break; + + case RES_AUTHORITY: + for( ; i < nSize; ++i ) + if( nFldWhich == (*mpFldTypes)[i]->Which() ) + return (*mpFldTypes)[i]; + break; + + default: + for( i = 0; i < nSize; ++i ) + if( nFldWhich == (*mpFldTypes)[i]->Which() ) + return (*mpFldTypes)[i]; + } + + SwFieldType* pNew = rFldTyp.Copy(); + switch( nFldWhich ) + { + case RES_DDEFLD: + ((SwDDEFieldType*)pNew)->SetDoc( &m_rSwdoc ); + break; + + case RES_DBFLD: + case RES_TABLEFLD: + case RES_DATETIMEFLD: + case RES_GETEXPFLD: + ((SwValueFieldType*)pNew)->SetDoc( &m_rSwdoc ); + break; + + case RES_USERFLD: + case RES_SETEXPFLD: + ((SwValueFieldType*)pNew)->SetDoc( &m_rSwdoc ); + // JP 29.07.96: Optionally prepare FieldList for Calculator: + mpUpdtFlds->InsertFldType( *pNew ); + break; + case RES_AUTHORITY : + ((SwAuthorityFieldType*)pNew)->SetDoc( &m_rSwdoc ); + break; + } + + mpFldTypes->insert( mpFldTypes->begin() + nSize, pNew ); + m_rSwdoc.SetModified(); + + return (*mpFldTypes)[ nSize ]; +} + +/// @returns the field type of the Doc +SwFieldType *DocumentFieldsManager::GetSysFldType( const sal_uInt16 eWhich ) const +{ + for( sal_uInt16 i = 0; i < INIT_FLDTYPES; ++i ) + if( eWhich == (*mpFldTypes)[i]->Which() ) + return (*mpFldTypes)[i]; + return 0; +} + +/// Find first type with ResId and name +SwFieldType* DocumentFieldsManager::GetFldType( + sal_uInt16 nResId, + const OUString& rName, + bool bDbFieldMatching // used in some UNO calls for RES_DBFLD to use different string matching code #i51815# + ) const +{ + sal_uInt16 nSize = mpFldTypes->size(), i = 0; + const ::utl::TransliterationWrapper& rSCmp = GetAppCmpStrIgnore(); + + switch( nResId ) + { + case RES_SETEXPFLD: + //JP 29.01.96: SequenceFields start at INIT_FLDTYPES - 3!! + // Or we get doubble number circles!! + //MIB 14.03.95: From now on also the SW3-Reader relies on &m_rSwdoc, when + //constructing string pools and when reading SetExp fields + i = INIT_FLDTYPES - INIT_SEQ_FLDTYPES; + break; + + case RES_DBFLD: + case RES_USERFLD: + case RES_DDEFLD: + case RES_AUTHORITY: + i = INIT_FLDTYPES; + break; + } + + SwFieldType* pRet = 0; + for( ; i < nSize; ++i ) + { + SwFieldType* pFldType = (*mpFldTypes)[i]; + + OUString aFldName( pFldType->GetName() ); + if (bDbFieldMatching && nResId == RES_DBFLD) // #i51815# + aFldName = aFldName.replace(DB_DELIM, '.'); + + if( nResId == pFldType->Which() && + rSCmp.isEqual( rName, aFldName )) + { + pRet = pFldType; + break; + } + } + return pRet; +} + +/// Remove field type +void DocumentFieldsManager::RemoveFldType(sal_uInt16 nFld) +{ + OSL_ENSURE( INIT_FLDTYPES <= nFld, "don't remove InitFlds" ); + /* + * Dependent fields present -> ErrRaise + */ + sal_uInt16 nSize = mpFldTypes->size(); + if(nFld < nSize) + { + SwFieldType* pTmp = (*mpFldTypes)[nFld]; + + // JP 29.07.96: Optionally prepare FldLst for Calculator + sal_uInt16 nWhich = pTmp->Which(); + switch( nWhich ) + { + case RES_SETEXPFLD: + case RES_USERFLD: + mpUpdtFlds->RemoveFldType( *pTmp ); + // no break; + case RES_DDEFLD: + if( pTmp->GetDepends() && !m_rSwdoc.IsUsed( *pTmp ) ) + { + if( RES_SETEXPFLD == nWhich ) + ((SwSetExpFieldType*)pTmp)->SetDeleted( true ); + else if( RES_USERFLD == nWhich ) + ((SwUserFieldType*)pTmp)->SetDeleted( true ); + else + ((SwDDEFieldType*)pTmp)->SetDeleted( true ); + nWhich = 0; + } + break; + } + + if( nWhich ) + { + OSL_ENSURE( !pTmp->GetDepends(), "Dependent fields present!" ); + // delete field type + delete pTmp; + } + mpFldTypes->erase( mpFldTypes->begin() + nFld ); + m_rSwdoc.SetModified(); + } +} + +// All have to be re-evaluated. +void DocumentFieldsManager::UpdateFlds( SfxPoolItem *pNewHt, bool bCloseDB ) +{ + // Call Modify() for every field type, + // dependent SwTxtFld get notified ... + + for( sal_uInt16 i=0; i < mpFldTypes->size(); ++i) + { + switch( (*mpFldTypes)[i]->Which() ) + { + // Update table fields second to last + // Update references last + case RES_GETREFFLD: + case RES_TABLEFLD: + case RES_DBFLD: + case RES_JUMPEDITFLD: + case RES_REFPAGESETFLD: // are never expanded! + break; + + case RES_DDEFLD: + { + if( !pNewHt ) + { + SwMsgPoolItem aUpdateDDE( RES_UPDATEDDETBL ); + (*mpFldTypes)[i]->ModifyNotification( 0, &aUpdateDDE ); + } + else + (*mpFldTypes)[i]->ModifyNotification( 0, pNewHt ); + break; + } + case RES_GETEXPFLD: + case RES_SETEXPFLD: + case RES_HIDDENTXTFLD: + case RES_HIDDENPARAFLD: + // Expression fields are treated separately + if( !pNewHt ) + break; + default: + (*mpFldTypes)[i]->ModifyNotification ( 0, pNewHt ); + } + } + + if( !IsExpFldsLocked() ) + UpdateExpFlds( 0, false ); // update expression fields + + // Tables + UpdateTblFlds(pNewHt); + + // References + UpdateRefFlds(pNewHt); + if( bCloseDB ) + { +#if HAVE_FEATURE_DBCONNECTIVITY + m_rSwdoc.GetDBManager()->CloseAll(); +#endif + } + // Only evaluate on full update + m_rSwdoc.SetModified(); +} + +void DocumentFieldsManager::InsDeletedFldType( SwFieldType& rFldTyp ) +{ + // The FldType was marked as deleted and removed from the array. + // One has to look &m_rSwdoc up again, now. + // - If it's not present, it can be re-inserted. + // - If the same type is found, the deleted one has to be renamed. + + sal_uInt16 nSize = mpFldTypes->size(), nFldWhich = rFldTyp.Which(); + sal_uInt16 i = INIT_FLDTYPES; + + OSL_ENSURE( RES_SETEXPFLD == nFldWhich || + RES_USERFLD == nFldWhich || + RES_DDEFLD == nFldWhich, "Wrong FldType" ); + + const ::utl::TransliterationWrapper& rSCmp = GetAppCmpStrIgnore(); + const OUString& rFldNm = rFldTyp.GetName(); + SwFieldType* pFnd; + + for( ; i < nSize; ++i ) + if( nFldWhich == (pFnd = (*mpFldTypes)[i])->Which() && + rSCmp.isEqual( rFldNm, pFnd->GetName() ) ) + { + // find new name + sal_uInt16 nNum = 1; + do { + OUString sSrch = rFldNm + OUString::number( nNum ); + for( i = INIT_FLDTYPES; i < nSize; ++i ) + if( nFldWhich == (pFnd = (*mpFldTypes)[i])->Which() && + rSCmp.isEqual( sSrch, pFnd->GetName() ) ) + break; + + if( i >= nSize ) // not found + { + ((OUString&)rFldNm) = sSrch; + break; // exit while loop + } + ++nNum; + } while( true ); + break; + } + + // not found, so insert and delete flag + mpFldTypes->insert( mpFldTypes->begin() + nSize, &rFldTyp ); + switch( nFldWhich ) + { + case RES_SETEXPFLD: + ((SwSetExpFieldType&)rFldTyp).SetDeleted( false ); + break; + case RES_USERFLD: + ((SwUserFieldType&)rFldTyp).SetDeleted( false ); + break; + case RES_DDEFLD: + ((SwDDEFieldType&)rFldTyp).SetDeleted( false ); + break; + } +} + +bool DocumentFieldsManager::PutValueToField(const SwPosition & rPos, + const Any& rVal, sal_uInt16 nWhich) +{ + Any aOldVal; + SwField * pField = GetFieldAtPos(rPos); + + if (m_rSwdoc.GetIDocumentUndoRedo().DoesUndo() && + pField->QueryValue(aOldVal, nWhich)) + { + SwUndo *const pUndo(new SwUndoFieldFromAPI(rPos, aOldVal, rVal, nWhich)); + m_rSwdoc.GetIDocumentUndoRedo().AppendUndo(pUndo); + } + + return pField->PutValue(rVal, nWhich); +} + +bool DocumentFieldsManager::UpdateFld(SwTxtFld * pDstTxtFld, SwField & rSrcFld, + SwMsgPoolItem * pMsgHnt, + bool bUpdateFlds) +{ + OSL_ENSURE(pDstTxtFld, "no field to update!"); + + bool bTblSelBreak = false; + + SwFmtFld * pDstFmtFld = (SwFmtFld*)&pDstTxtFld->GetFmtFld(); + SwField * pDstFld = pDstFmtFld->GetField(); + sal_uInt16 nFldWhich = rSrcFld.GetTyp()->Which(); + SwNodeIndex aTblNdIdx(pDstTxtFld->GetTxtNode()); + + if (pDstFld->GetTyp()->Which() == + rSrcFld.GetTyp()->Which()) + { + if (m_rSwdoc.GetIDocumentUndoRedo().DoesUndo()) + { + SwPosition aPosition( pDstTxtFld->GetTxtNode() ); + aPosition.nContent = pDstTxtFld->GetStart(); + + SwUndo *const pUndo( new SwUndoFieldFromDoc( aPosition, *pDstFld, rSrcFld, pMsgHnt, bUpdateFlds) ); + m_rSwdoc.GetIDocumentUndoRedo().AppendUndo(pUndo); + } + + SwField * pNewFld = rSrcFld.CopyField(); + pDstFmtFld->SetField(pNewFld); + + switch( nFldWhich ) + { + case RES_SETEXPFLD: + case RES_GETEXPFLD: + case RES_HIDDENTXTFLD: + case RES_HIDDENPARAFLD: + UpdateExpFlds( pDstTxtFld, true ); + break; + + case RES_TABLEFLD: + { + const SwTableNode* pTblNd = + m_rSwdoc.IsIdxInTbl(aTblNdIdx); + if( pTblNd ) + { + SwTableFmlUpdate aTblUpdate( &pTblNd-> + GetTable() ); + if (bUpdateFlds) + UpdateTblFlds( &aTblUpdate ); + else + pNewFld->GetTyp()->ModifyNotification(0, &aTblUpdate); + + if (! bUpdateFlds) + bTblSelBreak = true; + } + } + break; + + case RES_MACROFLD: + if( bUpdateFlds && pDstTxtFld->GetpTxtNode() ) + (pDstTxtFld->GetpTxtNode())-> + ModifyNotification( 0, pDstFmtFld ); + break; + + case RES_DBNAMEFLD: + case RES_DBNEXTSETFLD: + case RES_DBNUMSETFLD: + case RES_DBSETNUMBERFLD: + m_rSwdoc.ChgDBData(((SwDBNameInfField*) pNewFld)->GetRealDBData()); + pNewFld->GetTyp()->UpdateFlds(); + + break; + + case RES_DBFLD: +#if HAVE_FEATURE_DBCONNECTIVITY + { + // JP 10.02.96: call ChgValue, so that the style change sets the + // ContentString correctly + SwDBField* pDBFld = (SwDBField*)pNewFld; + if (pDBFld->IsInitialized()) + pDBFld->ChgValue( pDBFld->GetValue(), true ); + + pDBFld->ClearInitialized(); + pDBFld->InitContent(); + } +#endif + // no break; + + default: + pDstFmtFld->ModifyNotification( 0, pMsgHnt ); + } + + // The fields we can calculate here are being triggered for an update + // here explicitly. + if( nFldWhich == RES_USERFLD ) + UpdateUsrFlds(); + } + + return bTblSelBreak; +} + +/// Update reference and table fields +void DocumentFieldsManager::UpdateRefFlds( SfxPoolItem* pHt ) +{ + SwFieldType* pFldType; + for( sal_uInt16 i = 0; i < mpFldTypes->size(); ++i ) + if( RES_GETREFFLD == ( pFldType = (*mpFldTypes)[i] )->Which() ) + pFldType->ModifyNotification( 0, pHt ); +} + +void DocumentFieldsManager::UpdateTblFlds( SfxPoolItem* pHt ) +{ + OSL_ENSURE( !pHt || RES_TABLEFML_UPDATE == pHt->Which(), + "What MessageItem is &m_rSwdoc?" ); + + SwFieldType* pFldType(0); + + for (sal_uInt16 i = 0; i < mpFldTypes->size(); ++i) + { + if( RES_TABLEFLD == ( pFldType = (*mpFldTypes)[i] )->Which() ) + { + SwTableFmlUpdate* pUpdtFld = 0; + if( pHt && RES_TABLEFML_UPDATE == pHt->Which() ) + pUpdtFld = (SwTableFmlUpdate*)pHt; + + SwIterator<SwFmtFld,SwFieldType> aIter( *pFldType ); + for( SwFmtFld* pFmtFld = aIter.First(); pFmtFld; pFmtFld = aIter.Next() ) + { + if( pFmtFld->GetTxtFld() ) + { + SwTblField* pFld = (SwTblField*)pFmtFld->GetField(); + + if( pUpdtFld ) + { + // table where &m_rSwdoc field is located + const SwTableNode* pTblNd; + const SwTxtNode& rTxtNd = pFmtFld->GetTxtFld()->GetTxtNode(); + if( !rTxtNd.GetNodes().IsDocNodes() || + 0 == ( pTblNd = rTxtNd.FindTableNode() ) ) + continue; + + switch( pUpdtFld->eFlags ) + { + case TBL_CALC: + // re-set the value flag + // JP 17.06.96: internal representation of all formulas + // (reference to other table!!!) + if( nsSwExtendedSubType::SUB_CMD & pFld->GetSubType() ) + pFld->PtrToBoxNm( pUpdtFld->pTbl ); + else + pFld->ChgValid( false ); + break; + case TBL_BOXNAME: + // is &m_rSwdoc the wanted table? + if( &pTblNd->GetTable() == pUpdtFld->pTbl ) + // to the external representation + pFld->PtrToBoxNm( pUpdtFld->pTbl ); + break; + case TBL_BOXPTR: + // to the internal representation + // JP 17.06.96: internal representation on all formulas + // (reference to other table!!!) + pFld->BoxNmToPtr( pUpdtFld->pTbl ); + break; + case TBL_RELBOXNAME: + // is &m_rSwdoc the wanted table? + if( &pTblNd->GetTable() == pUpdtFld->pTbl ) + // to the relative representation + pFld->ToRelBoxNm( pUpdtFld->pTbl ); + break; + default: + break; + } + } + else + // reset the value flag for all + pFld->ChgValid( false ); + } + } + + break; + } + pFldType = 0; + } + + // process all table box formuals + const SfxPoolItem* pItem; + sal_uInt32 nMaxItems = m_rSwdoc.GetAttrPool().GetItemCount2( RES_BOXATR_FORMULA ); + for (sal_uInt32 i = 0; i < nMaxItems; ++i) + { + if( 0 != (pItem = m_rSwdoc.GetAttrPool().GetItem2( RES_BOXATR_FORMULA, i ) ) && + ((SwTblBoxFormula*)pItem)->GetDefinedIn() ) + { + ((SwTblBoxFormula*)pItem)->ChangeState( pHt ); + } + } + + // all fields/boxes are now invalid, so we can start to calculate + if( pHt && ( RES_TABLEFML_UPDATE != pHt->Which() || + TBL_CALC != ((SwTableFmlUpdate*)pHt)->eFlags )) + return ; + + SwCalc* pCalc = 0; + + if( pFldType ) + { + SwIterator<SwFmtFld,SwFieldType> aIter( *pFldType ); + for( SwFmtFld* pFmtFld = aIter.Last(); pFmtFld; pFmtFld = aIter.Previous() ) + { + // start calculation at the end + // new fields are inserted at the beginning of the modify chain + // that gives faster calculation on import + // mba: do we really need &m_rSwdoc "optimization"? Is it still valid? + SwTblField* pFld; + if( !pFmtFld->GetTxtFld() || (nsSwExtendedSubType::SUB_CMD & + (pFld = (SwTblField*)pFmtFld->GetField())->GetSubType() )) + continue; + + // needs to be recalculated + if( !pFld->IsValid() ) + { + // table where &m_rSwdoc field is located + const SwTxtNode& rTxtNd = pFmtFld->GetTxtFld()->GetTxtNode(); + if( !rTxtNd.GetNodes().IsDocNodes() ) + continue; + const SwTableNode* pTblNd = rTxtNd.FindTableNode(); + if( !pTblNd ) + continue; + + // if &m_rSwdoc field is not in the to-be-updated table, skip it + if( pHt && &pTblNd->GetTable() != + ((SwTableFmlUpdate*)pHt)->pTbl ) + continue; + + if( !pCalc ) + pCalc = new SwCalc( m_rSwdoc ); + + // get the values of all SetExpression fields that are valid + // until the table + SwFrm* pFrm = 0; + if( pTblNd->GetIndex() < m_rSwdoc.GetNodes().GetEndOfExtras().GetIndex() ) + { + // is in the special section, that's expensive! + Point aPt; // return the first frame of the layout - Tab.Headline!! + pFrm = rTxtNd.getLayoutFrm( m_rSwdoc.GetCurrentLayout(), &aPt ); + if( pFrm ) + { + SwPosition aPos( *pTblNd ); + if( GetBodyTxtNode( m_rSwdoc, aPos, *pFrm ) ) + FldsToCalc( *pCalc, _SetGetExpFld( + aPos.nNode, pFmtFld->GetTxtFld(), + &aPos.nContent )); + else + pFrm = 0; + } + } + if( !pFrm ) + { + // create index to determine the TextNode + SwNodeIndex aIdx( rTxtNd ); + FldsToCalc( *pCalc, + _SetGetExpFld( aIdx, pFmtFld->GetTxtFld() )); + } + + SwTblCalcPara aPara( *pCalc, pTblNd->GetTable() ); + pFld->CalcField( aPara ); + if( aPara.IsStackOverflow() ) + { + bool const bResult = aPara.CalcWithStackOverflow(); + if (bResult) + { + pFld->CalcField( aPara ); + } + OSL_ENSURE(bResult, + "the chained formula could no be calculated"); + } + pCalc->SetCalcError( CALC_NOERR ); + } + pFmtFld->ModifyNotification( 0, pHt ); + } + } + + // calculate the formula at the boxes + for (sal_uInt32 i = 0; i < nMaxItems; ++i ) + { + if( 0 != (pItem = m_rSwdoc.GetAttrPool().GetItem2( RES_BOXATR_FORMULA, i ) ) && + ((SwTblBoxFormula*)pItem)->GetDefinedIn() && + !((SwTblBoxFormula*)pItem)->IsValid() ) + { + SwTblBoxFormula* pFml = (SwTblBoxFormula*)pItem; + SwTableBox* pBox = pFml->GetTableBox(); + if( pBox && pBox->GetSttNd() && + pBox->GetSttNd()->GetNodes().IsDocNodes() ) + { + const SwTableNode* pTblNd = pBox->GetSttNd()->FindTableNode(); + if( !pHt || &pTblNd->GetTable() == + ((SwTableFmlUpdate*)pHt)->pTbl ) + { + double nValue; + if( !pCalc ) + pCalc = new SwCalc( m_rSwdoc ); + + // get the values of all SetExpression fields that are valid + // until the table + SwFrm* pFrm = 0; + if( pTblNd->GetIndex() < m_rSwdoc.GetNodes().GetEndOfExtras().GetIndex() ) + { + // is in the special section, that's expensive! + Point aPt; // return the first frame of the layout - Tab.Headline!! + SwNodeIndex aCNdIdx( *pTblNd, +2 ); + SwCntntNode* pCNd = aCNdIdx.GetNode().GetCntntNode(); + if( !pCNd ) + pCNd = m_rSwdoc.GetNodes().GoNext( &aCNdIdx ); + + if( pCNd && 0 != (pFrm = pCNd->getLayoutFrm( m_rSwdoc.GetCurrentLayout(), &aPt )) ) + { + SwPosition aPos( *pCNd ); + if( GetBodyTxtNode( m_rSwdoc, aPos, *pFrm ) ) + FldsToCalc( *pCalc, _SetGetExpFld( aPos.nNode )); + else + pFrm = 0; + } + } + if( !pFrm ) + { + // create index to determine the TextNode + SwNodeIndex aIdx( *pTblNd ); + FldsToCalc( *pCalc, _SetGetExpFld( aIdx )); + } + + SwTblCalcPara aPara( *pCalc, pTblNd->GetTable() ); + pFml->Calc( aPara, nValue ); + + if( aPara.IsStackOverflow() ) + { + bool const bResult = aPara.CalcWithStackOverflow(); + if (bResult) + { + pFml->Calc( aPara, nValue ); + } + OSL_ENSURE(bResult, + "the chained formula could no be calculated"); + } + + SwFrmFmt* pFmt = pBox->ClaimFrmFmt(); + SfxItemSet aTmp( m_rSwdoc.GetAttrPool(), + RES_BOXATR_BEGIN,RES_BOXATR_END-1 ); + + if( pCalc->IsCalcError() ) + nValue = DBL_MAX; + aTmp.Put( SwTblBoxValue( nValue )); + if( SFX_ITEM_SET != pFmt->GetItemState( RES_BOXATR_FORMAT )) + aTmp.Put( SwTblBoxNumFormat( 0 )); + pFmt->SetFmtAttr( aTmp ); + + pCalc->SetCalcError( CALC_NOERR ); + } + } + } + } + + delete pCalc; +} + +void DocumentFieldsManager::UpdateExpFlds( SwTxtFld* pUpdtFld, bool bUpdRefFlds ) +{ + if( IsExpFldsLocked() || m_rSwdoc.IsInReading() ) + return; + + bool bOldInUpdateFlds = mpUpdtFlds->IsInUpdateFlds(); + mpUpdtFlds->SetInUpdateFlds( true ); + + mpUpdtFlds->MakeFldList( m_rSwdoc, true, GETFLD_ALL ); + mbNewFldLst = false; + + if( mpUpdtFlds->GetSortLst()->empty() ) + { + if( bUpdRefFlds ) + UpdateRefFlds(NULL); + + mpUpdtFlds->SetInUpdateFlds( bOldInUpdateFlds ); + mpUpdtFlds->SetFieldsDirty( false ); + return ; + } + + sal_uInt16 nWhich, n; + + // Hash table for all string replacements is filled on-the-fly. + // Try to fabricate an uneven number. + sal_uInt16 nStrFmtCnt = (( mpFldTypes->size() / 7 ) + 1 ) * 7; + SwHash** pHashStrTbl = new SwHash*[ nStrFmtCnt ]; + memset( pHashStrTbl, 0, sizeof( _HashStr* ) * nStrFmtCnt ); + + { + const SwFieldType* pFldType; + // process separately: + for( n = mpFldTypes->size(); n; ) + switch( ( pFldType = (*mpFldTypes)[ --n ] )->Which() ) + { + case RES_USERFLD: + { + // Entry present? + sal_uInt16 nPos; + const OUString& rNm = pFldType->GetName(); + OUString sExpand(((SwUserFieldType*)pFldType)->Expand(nsSwGetSetExpType::GSE_STRING, 0, 0)); + SwHash* pFnd = Find( rNm, pHashStrTbl, nStrFmtCnt, &nPos ); + if( pFnd ) + // modify entry in the hash table + ((_HashStr*)pFnd)->aSetStr = sExpand; + else + // insert the new entry + *(pHashStrTbl + nPos ) = new _HashStr( rNm, sExpand, + (_HashStr*)*(pHashStrTbl + nPos) ); + } + break; + case RES_SETEXPFLD: + ((SwSetExpFieldType*)pFldType)->SetOutlineChgNd( 0 ); + break; + } + } + + // The array is filled with all fields; start calculation. + SwCalc aCalc( m_rSwdoc ); + +#if HAVE_FEATURE_DBCONNECTIVITY + OUString sDBNumNm( SwFieldType::GetTypeStr( TYP_DBSETNUMBERFLD ) ); + + // already set the current record number + SwDBManager* pMgr = m_rSwdoc.GetDBManager(); + pMgr->CloseAll(false); +#endif + + // Make sure we don't hide all sections, which would lead to a crash. First, count how many of them do we have. + int nShownSections = 0; + for( _SetGetExpFlds::const_iterator it = mpUpdtFlds->GetSortLst()->begin(); it != mpUpdtFlds->GetSortLst()->end(); ++it ) + { + SwSection* pSect = (SwSection*)(*it)->GetSection(); + if ( pSect && !pSect->IsCondHidden()) + nShownSections++; + } + + OUString aNew; + for( _SetGetExpFlds::const_iterator it = mpUpdtFlds->GetSortLst()->begin(); it != mpUpdtFlds->GetSortLst()->end(); ++it ) + { + SwSection* pSect = (SwSection*)(*it)->GetSection(); + if( pSect ) + { + + SwSbxValue aValue = aCalc.Calculate( + pSect->GetCondition() ); + if(!aValue.IsVoidValue()) + { + // Do we want to hide this one? + bool bHide = aValue.GetBool(); + if (bHide && !pSect->IsCondHidden()) + { + // This section will be hidden, but it wasn't before + if (nShownSections == 1) + { + // Is the last node part of a section? + SwPaM aPam(m_rSwdoc.GetNodes()); + aPam.Move(fnMoveForward, fnGoDoc); + if (aPam.Start()->nNode.GetNode().StartOfSectionNode()->IsSectionNode()) + { + // This would be the last section, so set its condition to false, and avoid hiding it. + OUString aCond("0"); + pSect->SetCondition(aCond); + bHide = false; + } + } + nShownSections--; + } + pSect->SetCondHidden( bHide ); + } + continue; + } + + SwTxtFld* pTxtFld = (SwTxtFld*)(*it)->GetTxtFld(); + if( !pTxtFld ) + { + OSL_ENSURE( false, "what's wrong now'" ); + continue; + } + + SwFmtFld* pFmtFld = (SwFmtFld*)&pTxtFld->GetFmtFld(); + const SwField* pFld = pFmtFld->GetField(); + + switch( nWhich = pFld->GetTyp()->Which() ) + { + case RES_HIDDENTXTFLD: + { + SwHiddenTxtField* pHFld = (SwHiddenTxtField*)pFld; + SwSbxValue aValue = aCalc.Calculate( pHFld->GetPar1() ); + bool bValue = !aValue.GetBool(); + if(!aValue.IsVoidValue()) + { + pHFld->SetValue( bValue ); + // evaluate field + pHFld->Evaluate(&m_rSwdoc); + } + } + break; + case RES_HIDDENPARAFLD: + { + SwHiddenParaField* pHPFld = (SwHiddenParaField*)pFld; + SwSbxValue aValue = aCalc.Calculate( pHPFld->GetPar1() ); + bool bValue = aValue.GetBool(); + if(!aValue.IsVoidValue()) + pHPFld->SetHidden( bValue ); + } + break; + case RES_DBSETNUMBERFLD: +#if HAVE_FEATURE_DBCONNECTIVITY + { + ((SwDBSetNumberField*)pFld)->Evaluate(&m_rSwdoc); + aCalc.VarChange( sDBNumNm, ((SwDBSetNumberField*)pFld)->GetSetNumber()); + } +#endif + break; + case RES_DBNEXTSETFLD: + case RES_DBNUMSETFLD: +#if HAVE_FEATURE_DBCONNECTIVITY + { + UpdateDBNumFlds( *(SwDBNameInfField*)pFld, aCalc ); + } +#endif + break; + case RES_DBFLD: + { +#if HAVE_FEATURE_DBCONNECTIVITY + // evaluate field + ((SwDBField*)pFld)->Evaluate(); + + SwDBData aTmpDBData(((SwDBField*)pFld)->GetDBData()); + + if( pMgr->IsDataSourceOpen(aTmpDBData.sDataSource, aTmpDBData.sCommand, false)) + aCalc.VarChange( sDBNumNm, pMgr->GetSelectedRecordId(aTmpDBData.sDataSource, aTmpDBData.sCommand, aTmpDBData.nCommandType)); + + const OUString& rName = pFld->GetTyp()->GetName(); + + // Add entry to hash table + // Entry present? + sal_uInt16 nPos; + SwHash* pFnd = Find( rName, pHashStrTbl, nStrFmtCnt, &nPos ); + OUString const value(pFld->ExpandField(m_rSwdoc.IsClipBoard())); + if( pFnd ) + { + // Modify entry in the hash table + static_cast<_HashStr*>(pFnd)->aSetStr = value; + } + else + { + // insert new entry + *(pHashStrTbl + nPos ) = new _HashStr( rName, + value, static_cast<_HashStr *>(*(pHashStrTbl + nPos))); + } +#endif + } + break; + case RES_GETEXPFLD: + case RES_SETEXPFLD: + { + if( nsSwGetSetExpType::GSE_STRING & pFld->GetSubType() ) // replace String + { + if( RES_GETEXPFLD == nWhich ) + { + SwGetExpField* pGFld = (SwGetExpField*)pFld; + + if( (!pUpdtFld || pUpdtFld == pTxtFld ) + && pGFld->IsInBodyTxt() ) + { + aNew = LookString( pHashStrTbl, nStrFmtCnt, + pGFld->GetFormula() ); + pGFld->ChgExpStr( aNew ); + } + } + else + { + SwSetExpField* pSFld = (SwSetExpField*)pFld; + // is the "formula" a field? + aNew = LookString( pHashStrTbl, nStrFmtCnt, + pSFld->GetFormula() ); + + if( aNew.isEmpty() ) // nothing found then the formula is the new value + aNew = pSFld->GetFormula(); + + // only update one field + if( !pUpdtFld || pUpdtFld == pTxtFld ) + pSFld->ChgExpStr( aNew ); + + // lookup the field's name + aNew = ((SwSetExpFieldType*)pSFld->GetTyp())->GetSetRefName(); + // Entry present? + sal_uInt16 nPos; + SwHash* pFnd = Find( aNew, pHashStrTbl, nStrFmtCnt, &nPos ); + if( pFnd ) + // Modify entry in the hash table + ((_HashStr*)pFnd)->aSetStr = pSFld->GetExpStr(); + else + // insert new entry + *(pHashStrTbl + nPos ) = pFnd = new _HashStr( aNew, + pSFld->GetExpStr(), + (_HashStr*)*(pHashStrTbl + nPos) ); + + // Extension for calculation with Strings + SwSbxValue aValue; + aValue.PutString( ((_HashStr*)pFnd)->aSetStr ); + aCalc.VarChange( aNew, aValue ); + } + } + else // recalculate formula + { + if( RES_GETEXPFLD == nWhich ) + { + SwGetExpField* pGFld = (SwGetExpField*)pFld; + + if( (!pUpdtFld || pUpdtFld == pTxtFld ) + && pGFld->IsInBodyTxt() ) + { + SwSbxValue aValue = aCalc.Calculate( + pGFld->GetFormula()); + if(!aValue.IsVoidValue()) + pGFld->SetValue(aValue.GetDouble() ); + } + } + else + { + SwSetExpField* pSFld = (SwSetExpField*)pFld; + SwSetExpFieldType* pSFldTyp = (SwSetExpFieldType*)pFld->GetTyp(); + aNew = pSFldTyp->GetName(); + + SwNode* pSeqNd = 0; + + if( pSFld->IsSequenceFld() ) + { + const sal_uInt8 nLvl = pSFldTyp->GetOutlineLvl(); + if( MAXLEVEL > nLvl ) + { + // test if the Number needs to be updated + pSeqNd = m_rSwdoc.GetNodes()[ (*it)->GetNode() ]; + + const SwTxtNode* pOutlNd = pSeqNd-> + FindOutlineNodeOfLevel( nLvl ); + if( pSFldTyp->GetOutlineChgNd() != pOutlNd ) + { + pSFldTyp->SetOutlineChgNd( pOutlNd ); + aCalc.VarChange( aNew, 0 ); + } + } + } + + aNew += "="; + aNew += pSFld->GetFormula(); + + SwSbxValue aValue = aCalc.Calculate( aNew ); + double nErg = aValue.GetDouble(); + // only update one field + if( !aValue.IsVoidValue() && (!pUpdtFld || pUpdtFld == pTxtFld) ) + { + pSFld->SetValue( nErg ); + + if( pSeqNd ) + pSFldTyp->SetChapter( *pSFld, *pSeqNd ); + } + } + } + } + } // switch + + pFmtFld->ModifyNotification( 0, 0 ); // trigger formatting + + if( pUpdtFld == pTxtFld ) // if only &m_rSwdoc one is updated + { + if( RES_GETEXPFLD == nWhich || // only GetField or + RES_HIDDENTXTFLD == nWhich || // HiddenTxt? + RES_HIDDENPARAFLD == nWhich) // HiddenParaFld? + break; // quit + pUpdtFld = 0; // update all from here on + } + } + +#if HAVE_FEATURE_DBCONNECTIVITY + pMgr->CloseAll(false); +#endif + // delete hash table + ::DeleteHashTable( pHashStrTbl, nStrFmtCnt ); + + // update reference fields + if( bUpdRefFlds ) + UpdateRefFlds(NULL); + + mpUpdtFlds->SetInUpdateFlds( bOldInUpdateFlds ); + mpUpdtFlds->SetFieldsDirty( false ); +} + +/// Insert field type that was marked as deleted +void DocumentFieldsManager::UpdateUsrFlds() +{ + SwCalc* pCalc = 0; + const SwFieldType* pFldType; + for( sal_uInt16 i = INIT_FLDTYPES; i < mpFldTypes->size(); ++i ) + if( RES_USERFLD == ( pFldType = (*mpFldTypes)[i] )->Which() ) + { + if( !pCalc ) + pCalc = new SwCalc( m_rSwdoc ); + ((SwUserFieldType*)pFldType)->GetValue( *pCalc ); + } + + if( pCalc ) + { + delete pCalc; + m_rSwdoc.SetModified(); + } +} + +void DocumentFieldsManager::UpdatePageFlds( SfxPoolItem* pMsgHnt ) +{ + SwFieldType* pFldType; + for( sal_uInt16 i = 0; i < INIT_FLDTYPES; ++i ) + switch( ( pFldType = (*mpFldTypes)[ i ] )->Which() ) + { + case RES_PAGENUMBERFLD: + case RES_CHAPTERFLD: + case RES_GETEXPFLD: + case RES_REFPAGEGETFLD: + pFldType->ModifyNotification( 0, pMsgHnt ); + break; + case RES_DOCSTATFLD: + pFldType->ModifyNotification( 0, 0 ); + break; + } + SetNewFldLst(true); +} + +void DocumentFieldsManager::LockExpFlds() +{ + ++mnLockExpFld; +} + +void DocumentFieldsManager::UnlockExpFlds() +{ + if( mnLockExpFld ) + --mnLockExpFld; +} + +bool DocumentFieldsManager::IsExpFldsLocked() const +{ + return 0 != mnLockExpFld; +} + +SwDocUpdtFld& DocumentFieldsManager::GetUpdtFlds() const +{ + return *mpUpdtFlds; +} + +bool DocumentFieldsManager::SetFieldsDirty( bool b, const SwNode* pChk, sal_uLong nLen ) +{ + // See if the supplied nodes actually contain fields. + // If they don't, the flag doesn't need to be changed. + bool bFldsFnd = false; + if( b && pChk && !GetUpdtFlds().IsFieldsDirty() && !m_rSwdoc.IsInDtor() + // ?? what's up with Undo, this is also wanted there! + /*&& &pChk->GetNodes() == &GetNodes()*/ ) + { + b = false; + if( !nLen ) + ++nLen; + sal_uLong nStt = pChk->GetIndex(); + const SwNodes& rNds = pChk->GetNodes(); + while( nLen-- ) + { + const SwTxtNode* pTNd = rNds[ nStt++ ]->GetTxtNode(); + if( pTNd ) + { + if( pTNd->GetAttrOutlineLevel() != 0 ) + // update chapter fields + b = true; + else if( pTNd->GetpSwpHints() && pTNd->GetSwpHints().Count() ) + { + const size_t nEnd = pTNd->GetSwpHints().Count(); + for( size_t n = 0 ; n < nEnd; ++n ) + { + const SwTxtAttr* pAttr = pTNd->GetSwpHints()[ n ]; + if ( pAttr->Which() == RES_TXTATR_FIELD ) + { + b = true; + break; + } + } + } + + if( b ) + break; + } + } + bFldsFnd = b; + } + GetUpdtFlds().SetFieldsDirty( b ); + return bFldsFnd; +} + +void DocumentFieldsManager::SetFixFields( bool bOnlyTimeDate, const DateTime* pNewDateTime ) +{ + bool bIsModified = m_rSwdoc.IsModified(); + + sal_Int32 nDate; + sal_Int64 nTime; + if( pNewDateTime ) + { + nDate = pNewDateTime->GetDate(); + nTime = pNewDateTime->GetTime(); + } + else + { + nDate = Date( Date::SYSTEM ).GetDate(); + nTime = Time( Time::SYSTEM ).GetTime(); + } + + sal_uInt16 aTypes[5] = { + /*0*/ RES_DOCINFOFLD, + /*1*/ RES_AUTHORFLD, + /*2*/ RES_EXTUSERFLD, + /*3*/ RES_FILENAMEFLD, + /*4*/ RES_DATETIMEFLD }; // MUST be at the end! + + sal_uInt16 nStt = bOnlyTimeDate ? 4 : 0; + + for( ; nStt < 5; ++nStt ) + { + SwFieldType* pFldType = GetSysFldType( aTypes[ nStt ] ); + SwIterator<SwFmtFld,SwFieldType> aIter( *pFldType ); + for( SwFmtFld* pFmtFld = aIter.First(); pFmtFld; pFmtFld = aIter.Next() ) + { + if( pFmtFld && pFmtFld->GetTxtFld() ) + { + bool bChgd = false; + switch( aTypes[ nStt ] ) + { + case RES_DOCINFOFLD: + if( ((SwDocInfoField*)pFmtFld->GetField())->IsFixed() ) + { + bChgd = true; + SwDocInfoField* pDocInfFld = (SwDocInfoField*)pFmtFld->GetField(); + pDocInfFld->SetExpansion( ((SwDocInfoFieldType*) + pDocInfFld->GetTyp())->Expand( + pDocInfFld->GetSubType(), + pDocInfFld->GetFormat(), + pDocInfFld->GetLanguage(), + pDocInfFld->GetName() ) ); + } + break; + + case RES_AUTHORFLD: + if( ((SwAuthorField*)pFmtFld->GetField())->IsFixed() ) + { + bChgd = true; + SwAuthorField* pAuthorFld = (SwAuthorField*)pFmtFld->GetField(); + pAuthorFld->SetExpansion( ((SwAuthorFieldType*) + pAuthorFld->GetTyp())->Expand( + pAuthorFld->GetFormat() ) ); + } + break; + + case RES_EXTUSERFLD: + if( ((SwExtUserField*)pFmtFld->GetField())->IsFixed() ) + { + bChgd = true; + SwExtUserField* pExtUserFld = (SwExtUserField*)pFmtFld->GetField(); + pExtUserFld->SetExpansion( ((SwExtUserFieldType*) + pExtUserFld->GetTyp())->Expand( + pExtUserFld->GetSubType(), + pExtUserFld->GetFormat())); + } + break; + + case RES_DATETIMEFLD: + if( ((SwDateTimeField*)pFmtFld->GetField())->IsFixed() ) + { + bChgd = true; + ((SwDateTimeField*)pFmtFld->GetField())->SetDateTime( + DateTime(Date(nDate), Time(nTime)) ); + } + break; + + case RES_FILENAMEFLD: + if( ((SwFileNameField*)pFmtFld->GetField())->IsFixed() ) + { + bChgd = true; + SwFileNameField* pFileNameFld = + (SwFileNameField*)pFmtFld->GetField(); + pFileNameFld->SetExpansion( ((SwFileNameFieldType*) + pFileNameFld->GetTyp())->Expand( + pFileNameFld->GetFormat() ) ); + } + break; + } + + // Trigger formatting + if( bChgd ) + pFmtFld->ModifyNotification( 0, 0 ); + } + } + } + + if( !bIsModified ) + m_rSwdoc.ResetModified(); +} + +void DocumentFieldsManager::FldsToCalc( SwCalc& rCalc, const _SetGetExpFld& rToThisFld ) +{ + // create the sorted list of all SetFields + mpUpdtFlds->MakeFldList( m_rSwdoc, mbNewFldLst, GETFLD_CALC ); + mbNewFldLst = false; + +#if !HAVE_FEATURE_DBCONNECTIVITY + SwDBManager* pMgr = NULL; +#else + SwDBManager* pMgr = m_rSwdoc.GetDBManager(); + pMgr->CloseAll(false); +#endif + + if( !mpUpdtFlds->GetSortLst()->empty() ) + { + _SetGetExpFlds::const_iterator const itLast = + mpUpdtFlds->GetSortLst()->upper_bound( + const_cast<_SetGetExpFld*>(&rToThisFld)); + for( _SetGetExpFlds::const_iterator it = mpUpdtFlds->GetSortLst()->begin(); it != itLast; ++it ) + lcl_CalcFld( m_rSwdoc, rCalc, **it, pMgr ); + } +#if HAVE_FEATURE_DBCONNECTIVITY + pMgr->CloseAll(false); +#endif +} + +void DocumentFieldsManager::FldsToCalc( SwCalc& rCalc, sal_uLong nLastNd, sal_uInt16 nLastCnt ) +{ + // create the sorted list of all SetFields + mpUpdtFlds->MakeFldList( m_rSwdoc, mbNewFldLst, GETFLD_CALC ); + mbNewFldLst = false; + +#if !HAVE_FEATURE_DBCONNECTIVITY + SwDBManager* pMgr = NULL; +#else + SwDBManager* pMgr = m_rSwdoc.GetDBManager(); + pMgr->CloseAll(false); +#endif + + for( _SetGetExpFlds::const_iterator it = mpUpdtFlds->GetSortLst()->begin(); + it != mpUpdtFlds->GetSortLst()->end() && + ( (*it)->GetNode() < nLastNd || + ( (*it)->GetNode() == nLastNd && (*it)->GetCntnt() <= nLastCnt ) + ); + ++it ) + { + lcl_CalcFld( m_rSwdoc, rCalc, **it, pMgr ); + } + +#if HAVE_FEATURE_DBCONNECTIVITY + pMgr->CloseAll(false); +#endif +} + +void DocumentFieldsManager::FldsToExpand( SwHash**& ppHashTbl, sal_uInt16& rTblSize, + const _SetGetExpFld& rToThisFld ) +{ + // create the sorted list of all SetFields + mpUpdtFlds->MakeFldList( m_rSwdoc, mbNewFldLst, GETFLD_EXPAND ); + mbNewFldLst = false; + + // Hash table for all string replacements is filled on-the-fly. + // Try to fabricate an uneven number. + rTblSize = (( mpUpdtFlds->GetSortLst()->size() / 7 ) + 1 ) * 7; + ppHashTbl = new SwHash*[ rTblSize ]; + memset( ppHashTbl, 0, sizeof( _HashStr* ) * rTblSize ); + + _SetGetExpFlds::const_iterator const itLast = + mpUpdtFlds->GetSortLst()->upper_bound( + const_cast<_SetGetExpFld*>(&rToThisFld)); + + for( _SetGetExpFlds::const_iterator it = mpUpdtFlds->GetSortLst()->begin(); it != itLast; ++it ) + { + const SwTxtFld* pTxtFld = (*it)->GetTxtFld(); + if( !pTxtFld ) + continue; + + const SwField* pFld = pTxtFld->GetFmtFld().GetField(); + switch( pFld->GetTyp()->Which() ) + { + case RES_SETEXPFLD: + if( nsSwGetSetExpType::GSE_STRING & pFld->GetSubType() ) + { + // set the new value in the hash table + // is the formula a field? + SwSetExpField* pSFld = (SwSetExpField*)pFld; + OUString aNew = LookString( ppHashTbl, rTblSize, pSFld->GetFormula() ); + + if( aNew.isEmpty() ) // nothing found, then the formula is + aNew = pSFld->GetFormula(); // the new value + + // #i3141# - update expression of field as in method + // <SwDoc::UpdateExpFlds(..)> for string/text fields + pSFld->ChgExpStr( aNew ); + + // look up the field's name + aNew = ((SwSetExpFieldType*)pSFld->GetTyp())->GetSetRefName(); + // Entry present? + sal_uInt16 nPos; + SwHash* pFnd = Find( aNew, ppHashTbl, rTblSize, &nPos ); + if( pFnd ) + // modify entry in the hash table + ((_HashStr*)pFnd)->aSetStr = pSFld->GetExpStr(); + else + // insert the new entry + *(ppHashTbl + nPos ) = new _HashStr( aNew, + pSFld->GetExpStr(), (_HashStr*)*(ppHashTbl + nPos) ); + } + break; + case RES_DBFLD: + { + const OUString& rName = pFld->GetTyp()->GetName(); + + // Insert entry in the hash table + // Entry present? + sal_uInt16 nPos; + SwHash* pFnd = Find( rName, ppHashTbl, rTblSize, &nPos ); + OUString const value(pFld->ExpandField(m_rSwdoc.IsClipBoard())); + if( pFnd ) + { + // modify entry in the hash table + static_cast<_HashStr*>(pFnd)->aSetStr = value; + } + else + { + // insert the new entry + *(ppHashTbl + nPos ) = new _HashStr( rName, + value, static_cast<_HashStr *>(*(ppHashTbl + nPos))); + } + } + break; + } + } +} + + +bool DocumentFieldsManager::IsNewFldLst() const +{ + return mbNewFldLst; +} + +void DocumentFieldsManager::SetNewFldLst(bool bFlag) +{ + mbNewFldLst = bFlag; +} + +void DocumentFieldsManager::InsDelFldInFldLst( bool bIns, const SwTxtFld& rFld ) +{ + if( !mbNewFldLst || !m_rSwdoc.IsInDtor() ) + mpUpdtFlds->InsDelFldInFldLst( bIns, rFld ); +} + +SwField * DocumentFieldsManager::GetFieldAtPos(const SwPosition & rPos) +{ + SwTxtFld * const pAttr = GetTxtFldAtPos(rPos); + + return (pAttr) ? const_cast<SwField *>( pAttr->GetFmtFld().GetField() ) : 0; +} + +SwTxtFld * DocumentFieldsManager::GetTxtFldAtPos(const SwPosition & rPos) +{ + SwTxtNode * const pNode = rPos.nNode.GetNode().GetTxtNode(); + + return (pNode != NULL) + ? pNode->GetFldTxtAttrAt( rPos.nContent.GetIndex(), true ) + : 0; +} + +/// @note For simplicity assume that all field types have updatable contents so +/// optimization currently only available when no fields exist. +bool DocumentFieldsManager::containsUpdatableFields() +{ + for (sal_uInt16 i = 0; i < mpFldTypes->size(); ++i) + { + SwFieldType* pFldType = (*mpFldTypes)[i]; + SwIterator<SwFmtFld,SwFieldType> aIter(*pFldType); + if (aIter.First()) + return true; + } + return false; +} + +/// Remove all unreferenced field types of a document +void DocumentFieldsManager::GCFieldTypes() +{ + for( sal_uInt16 n = mpFldTypes->size(); n > INIT_FLDTYPES; ) + if( !(*mpFldTypes)[ --n ]->GetDepends() ) + RemoveFldType( n ); +} + +void DocumentFieldsManager::_InitFieldTypes() // is being called by the CTOR +{ + // Field types + mpFldTypes->push_back( new SwDateTimeFieldType(&m_rSwdoc) ); + mpFldTypes->push_back( new SwChapterFieldType ); + mpFldTypes->push_back( new SwPageNumberFieldType ); + mpFldTypes->push_back( new SwAuthorFieldType ); + mpFldTypes->push_back( new SwFileNameFieldType(&m_rSwdoc) ); + mpFldTypes->push_back( new SwDBNameFieldType(&m_rSwdoc) ); + mpFldTypes->push_back( new SwGetExpFieldType(&m_rSwdoc) ); + mpFldTypes->push_back( new SwGetRefFieldType( &m_rSwdoc ) ); + mpFldTypes->push_back( new SwHiddenTxtFieldType ); + mpFldTypes->push_back( new SwPostItFieldType(&m_rSwdoc) ); + mpFldTypes->push_back( new SwDocStatFieldType(&m_rSwdoc) ); + mpFldTypes->push_back( new SwDocInfoFieldType(&m_rSwdoc) ); + mpFldTypes->push_back( new SwInputFieldType( &m_rSwdoc ) ); + mpFldTypes->push_back( new SwTblFieldType( &m_rSwdoc ) ); + mpFldTypes->push_back( new SwMacroFieldType(&m_rSwdoc) ); + mpFldTypes->push_back( new SwHiddenParaFieldType ); + mpFldTypes->push_back( new SwDBNextSetFieldType ); + mpFldTypes->push_back( new SwDBNumSetFieldType ); + mpFldTypes->push_back( new SwDBSetNumberFieldType ); + mpFldTypes->push_back( new SwTemplNameFieldType(&m_rSwdoc) ); + mpFldTypes->push_back( new SwTemplNameFieldType(&m_rSwdoc) ); + mpFldTypes->push_back( new SwExtUserFieldType ); + mpFldTypes->push_back( new SwRefPageSetFieldType ); + mpFldTypes->push_back( new SwRefPageGetFieldType( &m_rSwdoc ) ); + mpFldTypes->push_back( new SwJumpEditFieldType( &m_rSwdoc ) ); + mpFldTypes->push_back( new SwScriptFieldType( &m_rSwdoc ) ); + mpFldTypes->push_back( new SwCombinedCharFieldType ); + mpFldTypes->push_back( new SwDropDownFieldType ); + + // Types have to be at the end! + // We expect &m_rSwdoc in the InsertFldType! + // MIB 14.04.95: In Sw3StringPool::Setup (sw3imp.cxx) and + // lcl_sw3io_InSetExpField (sw3field.cxx) now also + mpFldTypes->push_back( new SwSetExpFieldType(&m_rSwdoc, + SW_RESSTR(STR_POOLCOLL_LABEL_ABB), nsSwGetSetExpType::GSE_SEQ) ); + mpFldTypes->push_back( new SwSetExpFieldType(&m_rSwdoc, + SW_RESSTR(STR_POOLCOLL_LABEL_TABLE), nsSwGetSetExpType::GSE_SEQ) ); + mpFldTypes->push_back( new SwSetExpFieldType(&m_rSwdoc, + SW_RESSTR(STR_POOLCOLL_LABEL_FRAME), nsSwGetSetExpType::GSE_SEQ) ); + mpFldTypes->push_back( new SwSetExpFieldType(&m_rSwdoc, + SW_RESSTR(STR_POOLCOLL_LABEL_DRAWING), nsSwGetSetExpType::GSE_SEQ) ); + + assert( mpFldTypes->size() == INIT_FLDTYPES ); +} + +void DocumentFieldsManager::ClearFieldTypes() +{ + for(SwFldTypes::const_iterator it = mpFldTypes->begin() + INIT_FLDTYPES; + it != mpFldTypes->end(); ++it) + delete *it; + mpFldTypes->erase( mpFldTypes->begin() + INIT_FLDTYPES, mpFldTypes->end() ); +} + +void DocumentFieldsManager::UpdateDBNumFlds( SwDBNameInfField& rDBFld, SwCalc& rCalc ) +{ +#if !HAVE_FEATURE_DBCONNECTIVITY + (void) rDBFld; + (void) rCalc; +#else + SwDBManager* pMgr = m_rSwdoc.GetDBManager(); + + sal_uInt16 nFldType = rDBFld.Which(); + + bool bPar1 = rCalc.Calculate( rDBFld.GetPar1() ).GetBool(); + + if( RES_DBNEXTSETFLD == nFldType ) + ((SwDBNextSetField&)rDBFld).SetCondValid( bPar1 ); + else + ((SwDBNumSetField&)rDBFld).SetCondValid( bPar1 ); + + if( !rDBFld.GetRealDBData().sDataSource.isEmpty() ) + { + // Edit a certain database + if( RES_DBNEXTSETFLD == nFldType ) + ((SwDBNextSetField&)rDBFld).Evaluate(&m_rSwdoc); + else + ((SwDBNumSetField&)rDBFld).Evaluate(&m_rSwdoc); + + SwDBData aTmpDBData( rDBFld.GetDBData(&m_rSwdoc) ); + + if( pMgr->OpenDataSource( aTmpDBData.sDataSource, aTmpDBData.sCommand, -1, false )) + rCalc.VarChange( lcl_GetDBVarName( m_rSwdoc, rDBFld), + pMgr->GetSelectedRecordId(aTmpDBData.sDataSource, aTmpDBData.sCommand, aTmpDBData.nCommandType) ); + } + else + { + OSL_FAIL("TODO: what should happen with unnamed DBFields?"); + } +#endif +} + +DocumentFieldsManager::~DocumentFieldsManager() +{ + delete mpUpdtFlds; + delete mpFldTypes; +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/doc/DocumentTimerManager.cxx b/sw/source/core/doc/DocumentTimerManager.cxx index d99f3da39115..3acbaf973a80 100644 --- a/sw/source/core/doc/DocumentTimerManager.cxx +++ b/sw/source/core/doc/DocumentTimerManager.cxx @@ -20,6 +20,7 @@ #include <doc.hxx> #include <DocumentSettingManager.hxx> +#include <IDocumentFieldsAccess.hxx> #include <rootfrm.hxx> #include <viewsh.hxx> #include <unotools/lingucfg.hxx> @@ -125,20 +126,20 @@ IMPL_LINK( DocumentTimerManager, DoIdleJobs, Timer *, pTimer ) SwFldUpdateFlags nFldUpdFlag = m_rSwdoc.GetDocumentSettingManager().getFieldUpdateFlags(true); if( ( AUTOUPD_FIELD_ONLY == nFldUpdFlag || AUTOUPD_FIELD_AND_CHARTS == nFldUpdFlag ) && - m_rSwdoc.GetUpdtFlds().IsFieldsDirty() + m_rSwdoc.getIDocumentFieldsAccess().GetUpdtFlds().IsFieldsDirty() // If we switch the field name the Fields are not updated. // So the "backgorund update" should always be carried out /* && !pStartSh->GetViewOptions()->IsFldName()*/ ) { - if ( m_rSwdoc.GetUpdtFlds().IsInUpdateFlds() || - m_rSwdoc.IsExpFldsLocked() ) + if ( m_rSwdoc.getIDocumentFieldsAccess().GetUpdtFlds().IsInUpdateFlds() || + m_rSwdoc.getIDocumentFieldsAccess().IsExpFldsLocked() ) { pTimer->Start(); return 0; } // Action brackets! - m_rSwdoc.GetUpdtFlds().SetInUpdateFlds( true ); + m_rSwdoc.getIDocumentFieldsAccess().GetUpdtFlds().SetInUpdateFlds( true ); pTmpRoot->StartAllAction(); @@ -146,17 +147,17 @@ IMPL_LINK( DocumentTimerManager, DoIdleJobs, Timer *, pTimer ) const bool bOldLockView = pStartSh->IsViewLocked(); pStartSh->LockView( true ); - m_rSwdoc.GetSysFldType( RES_CHAPTERFLD )->ModifyNotification( 0, 0 ); // ChapterField - m_rSwdoc.UpdateExpFlds( 0, false ); // Updates ExpressionFields - m_rSwdoc.UpdateTblFlds(NULL); // Tables - m_rSwdoc.UpdateRefFlds(NULL); // References + m_rSwdoc.getIDocumentFieldsAccess().GetSysFldType( RES_CHAPTERFLD )->ModifyNotification( 0, 0 ); // ChapterField + m_rSwdoc.getIDocumentFieldsAccess().UpdateExpFlds( 0, false ); // Updates ExpressionFields + m_rSwdoc.getIDocumentFieldsAccess().UpdateTblFlds(NULL); // Tables + m_rSwdoc.getIDocumentFieldsAccess().UpdateRefFlds(NULL); // References pTmpRoot->EndAllAction(); pStartSh->LockView( bOldLockView ); - m_rSwdoc.GetUpdtFlds().SetInUpdateFlds( false ); - m_rSwdoc.GetUpdtFlds().SetFieldsDirty( false ); + m_rSwdoc.getIDocumentFieldsAccess().GetUpdtFlds().SetInUpdateFlds( false ); + m_rSwdoc.getIDocumentFieldsAccess().GetUpdtFlds().SetFieldsDirty( false ); } } #ifdef TIMELOG diff --git a/sw/source/core/doc/doc.cxx b/sw/source/core/doc/doc.cxx index a7034e405865..3e5a3209bdcf 100644 --- a/sw/source/core/doc/doc.cxx +++ b/sw/source/core/doc/doc.cxx @@ -29,6 +29,7 @@ #include <DocumentOutlineNodesManager.hxx> #include <DocumentContentOperationsManager.hxx> #include <DocumentRedlineManager.hxx> +#include <DocumentFieldsManager.hxx> #include <UndoManager.hxx> #include <hintids.hxx> #include <tools/shl.hxx> @@ -383,6 +384,28 @@ IDocumentRedlineAccess& SwDoc::getIDocumentRedlineAccess() return *m_pDocumentRedlineManager; } +//IDocumentFieldsAccess + +IDocumentFieldsAccess const & SwDoc::getIDocumentFieldsAccess() const +{ + return *m_pDocumentFieldsManager; +} + +IDocumentFieldsAccess & SwDoc::getIDocumentFieldsAccess() +{ + return *m_pDocumentFieldsManager; +} + +::sw::DocumentFieldsManager const & SwDoc::GetDocumentFieldsMAnager() const +{ + return *m_pDocumentFieldsManager; +} + +::sw::DocumentFieldsManager & SwDoc::GetDocumentFieldsManager() +{ + return *m_pDocumentFieldsManager; +} + /* Implementations the next Interface here */ /* @@ -396,20 +419,11 @@ void SwDoc::ChgDBData(const SwDBData& rNewData) maDBData = rNewData; SetModified(); } - GetSysFldType(RES_DBNAMEFLD)->UpdateFlds(); + getIDocumentFieldsAccess().GetSysFldType(RES_DBNAMEFLD)->UpdateFlds(); } -/// @returns the field type of the Doc -SwFieldType *SwDoc::GetSysFldType( const sal_uInt16 eWhich ) const -{ - for( sal_uInt16 i = 0; i < INIT_FLDTYPES; ++i ) - if( eWhich == (*mpFldTypes)[i]->Which() ) - return (*mpFldTypes)[i]; - return 0; -} - void SwDoc::SetDocStat( const SwDocStat& rStat ) { *mpDocStat = rStat; @@ -1006,7 +1020,7 @@ bool SwDoc::IncrementalDocStatCalculate(long nChars, bool bFields) // #i93174#: notes contain paragraphs that are not nodes { - SwFieldType * const pPostits( GetSysFldType(RES_POSTITFLD) ); + SwFieldType * const pPostits( getIDocumentFieldsAccess().GetSysFldType(RES_POSTITFLD) ); SwIterator<SwFmtFld,SwFieldType> aIter( *pPostits ); for( SwFmtFld* pFmtFld = aIter.First(); pFmtFld; pFmtFld = aIter.Next() ) { @@ -1068,7 +1082,7 @@ bool SwDoc::IncrementalDocStatCalculate(long nChars, bool bFields) // optionally update stat. fields if (bFields) { - SwFieldType *pType = GetSysFldType(RES_DOCSTATFLD); + SwFieldType *pType = getIDocumentFieldsAccess().GetSysFldType(RES_DOCSTATFLD); pType->UpdateFlds(); } @@ -1104,8 +1118,8 @@ void SwDoc::UpdateDocStat( bool bCompleteAsync, bool bFields ) void SwDoc::DocInfoChgd( ) { - GetSysFldType( RES_DOCINFOFLD )->UpdateFlds(); - GetSysFldType( RES_TEMPLNAMEFLD )->UpdateFlds(); + getIDocumentFieldsAccess().GetSysFldType( RES_DOCINFOFLD )->UpdateFlds(); + getIDocumentFieldsAccess().GetSysFldType( RES_TEMPLNAMEFLD )->UpdateFlds(); SetModified(); } @@ -1456,7 +1470,7 @@ bool SwDoc::RemoveInvisibleContent() { SwTxtNode* pTxtNd; - SwIterator<SwFmtFld,SwFieldType> aIter( *GetSysFldType( RES_HIDDENPARAFLD ) ); + SwIterator<SwFmtFld,SwFieldType> aIter( *getIDocumentFieldsAccess().GetSysFldType( RES_HIDDENPARAFLD ) ); for( SwFmtFld* pFmtFld = aIter.First(); pFmtFld; pFmtFld = aIter.Next() ) { if( pFmtFld->GetTxtFld() && @@ -1620,7 +1634,7 @@ bool SwDoc::HasInvisibleContent() const { bool bRet = false; - SwClientIter aIter( *GetSysFldType( RES_HIDDENPARAFLD ) ); + SwClientIter aIter( *getIDocumentFieldsAccess().GetSysFldType( RES_HIDDENPARAFLD ) ); if( aIter.First( TYPE( SwFmtFld ) ) ) bRet = true; @@ -1676,10 +1690,10 @@ bool SwDoc::RestoreInvisibleContent() bool SwDoc::ConvertFieldsToText() { bool bRet = false; - LockExpFlds(); + getIDocumentFieldsAccess().LockExpFlds(); GetIDocumentUndoRedo().StartUndo( UNDO_UI_REPLACE, NULL ); - const SwFldTypes* pMyFldTypes = GetFldTypes(); + const SwFldTypes* pMyFldTypes = getIDocumentFieldsAccess().GetFldTypes(); sal_uInt16 nCount = pMyFldTypes->size(); //go backward, field types are removed for(sal_uInt16 nType = nCount; nType > 0; --nType) @@ -1747,7 +1761,7 @@ bool SwDoc::ConvertFieldsToText() if( bRet ) SetModified(); GetIDocumentUndoRedo().EndUndo( UNDO_UI_REPLACE, NULL ); - UnlockExpFlds(); + getIDocumentFieldsAccess().UnlockExpFlds(); return bRet; } @@ -1834,22 +1848,6 @@ OUString SwDoc::GetPaMDescr(const SwPaM & rPam) const return OUString("??"); } -SwField * SwDoc::GetFieldAtPos(const SwPosition & rPos) -{ - SwTxtFld * const pAttr = GetTxtFldAtPos(rPos); - - return (pAttr) ? const_cast<SwField *>( pAttr->GetFmtFld().GetField() ) : 0; -} - -SwTxtFld * SwDoc::GetTxtFldAtPos(const SwPosition & rPos) -{ - SwTxtNode * const pNode = rPos.nNode.GetNode().GetTxtNode(); - - return (pNode != NULL) - ? pNode->GetFldTxtAttrAt( rPos.nContent.GetIndex(), true ) - : 0; -} - bool SwDoc::ContainsHiddenChars() const { for( sal_uLong n = GetNodes().Count(); n; ) diff --git a/sw/source/core/doc/docdesc.cxx b/sw/source/core/doc/docdesc.cxx index 96305436f079..e10e9aa1c2c5 100644 --- a/sw/source/core/doc/docdesc.cxx +++ b/sw/source/core/doc/docdesc.cxx @@ -34,6 +34,7 @@ #include <mdiexp.hxx> #include <doc.hxx> #include <IDocumentUndoRedo.hxx> +#include <IDocumentFieldsAccess.hxx> #include <DocumentContentOperationsManager.hxx> #include <docary.hxx> #include <rootfrm.hxx> @@ -395,8 +396,8 @@ void SwDoc::ChgPageDesc( sal_uInt16 i, const SwPageDesc &rChged ) { pDesc->SetNumType( rChged.GetNumType() ); // Notify page number fields that NumFormat has changed - GetSysFldType( RES_PAGENUMBERFLD )->UpdateFlds(); - GetSysFldType( RES_REFPAGEGETFLD )->UpdateFlds(); + getIDocumentFieldsAccess().GetSysFldType( RES_PAGENUMBERFLD )->UpdateFlds(); + getIDocumentFieldsAccess().GetSysFldType( RES_REFPAGEGETFLD )->UpdateFlds(); // If the numbering scheme has changed we could have QuoVadis/ErgoSum texts // that refer to a changed page, so we invalidate foot notes. diff --git a/sw/source/core/doc/docfld.cxx b/sw/source/core/doc/docfld.cxx index 82ef087a2933..241c66b954d7 100644 --- a/sw/source/core/doc/docfld.cxx +++ b/sw/source/core/doc/docfld.cxx @@ -30,6 +30,7 @@ #include <unotools/transliterationwrapper.hxx> #include <doc.hxx> #include <IDocumentUndoRedo.hxx> +#include <IDocumentFieldsAccess.hxx> #include <cntfrm.hxx> #include <pam.hxx> #include <ndtxt.hxx> @@ -63,653 +64,6 @@ using namespace ::com::sun::star::uno; -/** Insert field types - * - * @param rFldTyp ??? - * @return Always returns a pointer to the type, if it's new or already added. - */ -SwFieldType* SwDoc::InsertFldType(const SwFieldType &rFldTyp) -{ - sal_uInt16 nSize = mpFldTypes->size(), - nFldWhich = rFldTyp.Which(); - - sal_uInt16 i = INIT_FLDTYPES; - - switch( nFldWhich ) - { - case RES_SETEXPFLD: - //JP 29.01.96: SequenceFields start at INIT_FLDTYPES - 3!! - // Or we get doubble number circles!! - //MIB 14.03.95: From now on also the SW3-Reader relies on this, when - //constructing string pools and when reading SetExp fields - if( nsSwGetSetExpType::GSE_SEQ & ((SwSetExpFieldType&)rFldTyp).GetType() ) - i -= INIT_SEQ_FLDTYPES; - // no break; - case RES_DBFLD: - case RES_USERFLD: - case RES_DDEFLD: - { - const ::utl::TransliterationWrapper& rSCmp = GetAppCmpStrIgnore(); - OUString sFldNm( rFldTyp.GetName() ); - for( ; i < nSize; ++i ) - if( nFldWhich == (*mpFldTypes)[i]->Which() && - rSCmp.isEqual( sFldNm, (*mpFldTypes)[i]->GetName() )) - return (*mpFldTypes)[i]; - } - break; - - case RES_AUTHORITY: - for( ; i < nSize; ++i ) - if( nFldWhich == (*mpFldTypes)[i]->Which() ) - return (*mpFldTypes)[i]; - break; - - default: - for( i = 0; i < nSize; ++i ) - if( nFldWhich == (*mpFldTypes)[i]->Which() ) - return (*mpFldTypes)[i]; - } - - SwFieldType* pNew = rFldTyp.Copy(); - switch( nFldWhich ) - { - case RES_DDEFLD: - ((SwDDEFieldType*)pNew)->SetDoc( this ); - break; - - case RES_DBFLD: - case RES_TABLEFLD: - case RES_DATETIMEFLD: - case RES_GETEXPFLD: - ((SwValueFieldType*)pNew)->SetDoc( this ); - break; - - case RES_USERFLD: - case RES_SETEXPFLD: - ((SwValueFieldType*)pNew)->SetDoc( this ); - // JP 29.07.96: Optionally prepare FieldList for Calculator: - mpUpdtFlds->InsertFldType( *pNew ); - break; - case RES_AUTHORITY : - ((SwAuthorityFieldType*)pNew)->SetDoc( this ); - break; - } - - mpFldTypes->insert( mpFldTypes->begin() + nSize, pNew ); - SetModified(); - - return (*mpFldTypes)[ nSize ]; -} - -/// Insert field type that was marked as deleted -void SwDoc::InsDeletedFldType( SwFieldType& rFldTyp ) -{ - // The FldType was marked as deleted and removed from the array. - // One has to look this up again, now. - // - If it's not present, it can be re-inserted. - // - If the same type is found, the deleted one has to be renamed. - - sal_uInt16 nSize = mpFldTypes->size(), nFldWhich = rFldTyp.Which(); - sal_uInt16 i = INIT_FLDTYPES; - - OSL_ENSURE( RES_SETEXPFLD == nFldWhich || - RES_USERFLD == nFldWhich || - RES_DDEFLD == nFldWhich, "Wrong FldType" ); - - const ::utl::TransliterationWrapper& rSCmp = GetAppCmpStrIgnore(); - const OUString& rFldNm = rFldTyp.GetName(); - SwFieldType* pFnd; - - for( ; i < nSize; ++i ) - if( nFldWhich == (pFnd = (*mpFldTypes)[i])->Which() && - rSCmp.isEqual( rFldNm, pFnd->GetName() ) ) - { - // find new name - sal_uInt16 nNum = 1; - do { - OUString sSrch = rFldNm + OUString::number( nNum ); - for( i = INIT_FLDTYPES; i < nSize; ++i ) - if( nFldWhich == (pFnd = (*mpFldTypes)[i])->Which() && - rSCmp.isEqual( sSrch, pFnd->GetName() ) ) - break; - - if( i >= nSize ) // not found - { - ((OUString&)rFldNm) = sSrch; - break; // exit while loop - } - ++nNum; - } while( true ); - break; - } - - // not found, so insert and delete flag - mpFldTypes->insert( mpFldTypes->begin() + nSize, &rFldTyp ); - switch( nFldWhich ) - { - case RES_SETEXPFLD: - ((SwSetExpFieldType&)rFldTyp).SetDeleted( false ); - break; - case RES_USERFLD: - ((SwUserFieldType&)rFldTyp).SetDeleted( false ); - break; - case RES_DDEFLD: - ((SwDDEFieldType&)rFldTyp).SetDeleted( false ); - break; - } -} - -/// Remove field type -void SwDoc::RemoveFldType(sal_uInt16 nFld) -{ - OSL_ENSURE( INIT_FLDTYPES <= nFld, "don't remove InitFlds" ); - /* - * Dependent fields present -> ErrRaise - */ - sal_uInt16 nSize = mpFldTypes->size(); - if(nFld < nSize) - { - SwFieldType* pTmp = (*mpFldTypes)[nFld]; - - // JP 29.07.96: Optionally prepare FldLst for Calculator - sal_uInt16 nWhich = pTmp->Which(); - switch( nWhich ) - { - case RES_SETEXPFLD: - case RES_USERFLD: - mpUpdtFlds->RemoveFldType( *pTmp ); - // no break; - case RES_DDEFLD: - if( pTmp->GetDepends() && !IsUsed( *pTmp ) ) - { - if( RES_SETEXPFLD == nWhich ) - ((SwSetExpFieldType*)pTmp)->SetDeleted( true ); - else if( RES_USERFLD == nWhich ) - ((SwUserFieldType*)pTmp)->SetDeleted( true ); - else - ((SwDDEFieldType*)pTmp)->SetDeleted( true ); - nWhich = 0; - } - break; - } - - if( nWhich ) - { - OSL_ENSURE( !pTmp->GetDepends(), "Dependent fields present!" ); - // delete field type - delete pTmp; - } - mpFldTypes->erase( mpFldTypes->begin() + nFld ); - SetModified(); - } -} - -const SwFldTypes* SwDoc::GetFldTypes() const -{ - return mpFldTypes; -} - -/// Find first type with ResId and name -SwFieldType* SwDoc::GetFldType( - sal_uInt16 nResId, - const OUString& rName, - bool bDbFieldMatching // used in some UNO calls for RES_DBFLD to use different string matching code #i51815# - ) const -{ - sal_uInt16 nSize = mpFldTypes->size(), i = 0; - const ::utl::TransliterationWrapper& rSCmp = GetAppCmpStrIgnore(); - - switch( nResId ) - { - case RES_SETEXPFLD: - //JP 29.01.96: SequenceFields start at INIT_FLDTYPES - 3!! - // Or we get doubble number circles!! - //MIB 14.03.95: From now on also the SW3-Reader relies on this, when - //constructing string pools and when reading SetExp fields - i = INIT_FLDTYPES - INIT_SEQ_FLDTYPES; - break; - - case RES_DBFLD: - case RES_USERFLD: - case RES_DDEFLD: - case RES_AUTHORITY: - i = INIT_FLDTYPES; - break; - } - - SwFieldType* pRet = 0; - for( ; i < nSize; ++i ) - { - SwFieldType* pFldType = (*mpFldTypes)[i]; - - OUString aFldName( pFldType->GetName() ); - if (bDbFieldMatching && nResId == RES_DBFLD) // #i51815# - aFldName = aFldName.replace(DB_DELIM, '.'); - - if( nResId == pFldType->Which() && - rSCmp.isEqual( rName, aFldName )) - { - pRet = pFldType; - break; - } - } - return pRet; -} - -// All have to be re-evaluated. -void SwDoc::UpdateFlds( SfxPoolItem *pNewHt, bool bCloseDB ) -{ - // Call Modify() for every field type, - // dependent SwTxtFld get notified ... - - for( sal_uInt16 i=0; i < mpFldTypes->size(); ++i) - { - switch( (*mpFldTypes)[i]->Which() ) - { - // Update table fields second to last - // Update references last - case RES_GETREFFLD: - case RES_TABLEFLD: - case RES_DBFLD: - case RES_JUMPEDITFLD: - case RES_REFPAGESETFLD: // are never expanded! - break; - - case RES_DDEFLD: - { - if( !pNewHt ) - { - SwMsgPoolItem aUpdateDDE( RES_UPDATEDDETBL ); - (*mpFldTypes)[i]->ModifyNotification( 0, &aUpdateDDE ); - } - else - (*mpFldTypes)[i]->ModifyNotification( 0, pNewHt ); - break; - } - case RES_GETEXPFLD: - case RES_SETEXPFLD: - case RES_HIDDENTXTFLD: - case RES_HIDDENPARAFLD: - // Expression fields are treated separately - if( !pNewHt ) - break; - default: - (*mpFldTypes)[i]->ModifyNotification ( 0, pNewHt ); - } - } - - if( !IsExpFldsLocked() ) - UpdateExpFlds( 0, false ); // update expression fields - - // Tables - UpdateTblFlds(pNewHt); - - // References - UpdateRefFlds(pNewHt); - if( bCloseDB ) - { -#if HAVE_FEATURE_DBCONNECTIVITY - GetDBManager()->CloseAll(); -#endif - } - // Only evaluate on full update - SetModified(); -} - -void SwDoc::UpdateUsrFlds() -{ - SwCalc* pCalc = 0; - const SwFieldType* pFldType; - for( sal_uInt16 i = INIT_FLDTYPES; i < mpFldTypes->size(); ++i ) - if( RES_USERFLD == ( pFldType = (*mpFldTypes)[i] )->Which() ) - { - if( !pCalc ) - pCalc = new SwCalc( *this ); - ((SwUserFieldType*)pFldType)->GetValue( *pCalc ); - } - - if( pCalc ) - { - delete pCalc; - SetModified(); - } -} - -/// Update reference and table fields -void SwDoc::UpdateRefFlds( SfxPoolItem* pHt ) -{ - SwFieldType* pFldType; - for( sal_uInt16 i = 0; i < mpFldTypes->size(); ++i ) - if( RES_GETREFFLD == ( pFldType = (*mpFldTypes)[i] )->Which() ) - pFldType->ModifyNotification( 0, pHt ); -} - -/// @note For simplicity assume that all field types have updatable contents so -/// optimization currently only available when no fields exist. -bool SwDoc::containsUpdatableFields() -{ - for (sal_uInt16 i = 0; i < mpFldTypes->size(); ++i) - { - SwFieldType* pFldType = (*mpFldTypes)[i]; - SwIterator<SwFmtFld,SwFieldType> aIter(*pFldType); - if (aIter.First()) - return true; - } - return false; -} - -void SwDoc::UpdateTblFlds( SfxPoolItem* pHt ) -{ - OSL_ENSURE( !pHt || RES_TABLEFML_UPDATE == pHt->Which(), - "What MessageItem is this?" ); - - SwFieldType* pFldType(0); - - for (sal_uInt16 i = 0; i < mpFldTypes->size(); ++i) - { - if( RES_TABLEFLD == ( pFldType = (*mpFldTypes)[i] )->Which() ) - { - SwTableFmlUpdate* pUpdtFld = 0; - if( pHt && RES_TABLEFML_UPDATE == pHt->Which() ) - pUpdtFld = (SwTableFmlUpdate*)pHt; - - SwIterator<SwFmtFld,SwFieldType> aIter( *pFldType ); - for( SwFmtFld* pFmtFld = aIter.First(); pFmtFld; pFmtFld = aIter.Next() ) - { - if( pFmtFld->GetTxtFld() ) - { - SwTblField* pFld = (SwTblField*)pFmtFld->GetField(); - - if( pUpdtFld ) - { - // table where this field is located - const SwTableNode* pTblNd; - const SwTxtNode& rTxtNd = pFmtFld->GetTxtFld()->GetTxtNode(); - if( !rTxtNd.GetNodes().IsDocNodes() || - 0 == ( pTblNd = rTxtNd.FindTableNode() ) ) - continue; - - switch( pUpdtFld->eFlags ) - { - case TBL_CALC: - // re-set the value flag - // JP 17.06.96: internal representation of all formulas - // (reference to other table!!!) - if( nsSwExtendedSubType::SUB_CMD & pFld->GetSubType() ) - pFld->PtrToBoxNm( pUpdtFld->pTbl ); - else - pFld->ChgValid( false ); - break; - case TBL_BOXNAME: - // is this the wanted table? - if( &pTblNd->GetTable() == pUpdtFld->pTbl ) - // to the external representation - pFld->PtrToBoxNm( pUpdtFld->pTbl ); - break; - case TBL_BOXPTR: - // to the internal representation - // JP 17.06.96: internal representation on all formulas - // (reference to other table!!!) - pFld->BoxNmToPtr( pUpdtFld->pTbl ); - break; - case TBL_RELBOXNAME: - // is this the wanted table? - if( &pTblNd->GetTable() == pUpdtFld->pTbl ) - // to the relative representation - pFld->ToRelBoxNm( pUpdtFld->pTbl ); - break; - default: - break; - } - } - else - // reset the value flag for all - pFld->ChgValid( false ); - } - } - - break; - } - pFldType = 0; - } - - // process all table box formuals - const SfxPoolItem* pItem; - sal_uInt32 nMaxItems = GetAttrPool().GetItemCount2( RES_BOXATR_FORMULA ); - for (sal_uInt32 i = 0; i < nMaxItems; ++i) - { - if( 0 != (pItem = GetAttrPool().GetItem2( RES_BOXATR_FORMULA, i ) ) && - ((SwTblBoxFormula*)pItem)->GetDefinedIn() ) - { - ((SwTblBoxFormula*)pItem)->ChangeState( pHt ); - } - } - - // all fields/boxes are now invalid, so we can start to calculate - if( pHt && ( RES_TABLEFML_UPDATE != pHt->Which() || - TBL_CALC != ((SwTableFmlUpdate*)pHt)->eFlags )) - return ; - - SwCalc* pCalc = 0; - - if( pFldType ) - { - SwIterator<SwFmtFld,SwFieldType> aIter( *pFldType ); - for( SwFmtFld* pFmtFld = aIter.Last(); pFmtFld; pFmtFld = aIter.Previous() ) - { - // start calculation at the end - // new fields are inserted at the beginning of the modify chain - // that gives faster calculation on import - // mba: do we really need this "optimization"? Is it still valid? - SwTblField* pFld; - if( !pFmtFld->GetTxtFld() || (nsSwExtendedSubType::SUB_CMD & - (pFld = (SwTblField*)pFmtFld->GetField())->GetSubType() )) - continue; - - // needs to be recalculated - if( !pFld->IsValid() ) - { - // table where this field is located - const SwTxtNode& rTxtNd = pFmtFld->GetTxtFld()->GetTxtNode(); - if( !rTxtNd.GetNodes().IsDocNodes() ) - continue; - const SwTableNode* pTblNd = rTxtNd.FindTableNode(); - if( !pTblNd ) - continue; - - // if this field is not in the to-be-updated table, skip it - if( pHt && &pTblNd->GetTable() != - ((SwTableFmlUpdate*)pHt)->pTbl ) - continue; - - if( !pCalc ) - pCalc = new SwCalc( *this ); - - // get the values of all SetExpression fields that are valid - // until the table - SwFrm* pFrm = 0; - if( pTblNd->GetIndex() < GetNodes().GetEndOfExtras().GetIndex() ) - { - // is in the special section, that's expensive! - Point aPt; // return the first frame of the layout - Tab.Headline!! - pFrm = rTxtNd.getLayoutFrm( GetCurrentLayout(), &aPt ); - if( pFrm ) - { - SwPosition aPos( *pTblNd ); - if( GetBodyTxtNode( *this, aPos, *pFrm ) ) - FldsToCalc( *pCalc, _SetGetExpFld( - aPos.nNode, pFmtFld->GetTxtFld(), - &aPos.nContent )); - else - pFrm = 0; - } - } - if( !pFrm ) - { - // create index to determine the TextNode - SwNodeIndex aIdx( rTxtNd ); - FldsToCalc( *pCalc, - _SetGetExpFld( aIdx, pFmtFld->GetTxtFld() )); - } - - SwTblCalcPara aPara( *pCalc, pTblNd->GetTable() ); - pFld->CalcField( aPara ); - if( aPara.IsStackOverflow() ) - { - bool const bResult = aPara.CalcWithStackOverflow(); - if (bResult) - { - pFld->CalcField( aPara ); - } - OSL_ENSURE(bResult, - "the chained formula could no be calculated"); - } - pCalc->SetCalcError( CALC_NOERR ); - } - pFmtFld->ModifyNotification( 0, pHt ); - } - } - - // calculate the formula at the boxes - for (sal_uInt32 i = 0; i < nMaxItems; ++i ) - { - if( 0 != (pItem = GetAttrPool().GetItem2( RES_BOXATR_FORMULA, i ) ) && - ((SwTblBoxFormula*)pItem)->GetDefinedIn() && - !((SwTblBoxFormula*)pItem)->IsValid() ) - { - SwTblBoxFormula* pFml = (SwTblBoxFormula*)pItem; - SwTableBox* pBox = pFml->GetTableBox(); - if( pBox && pBox->GetSttNd() && - pBox->GetSttNd()->GetNodes().IsDocNodes() ) - { - const SwTableNode* pTblNd = pBox->GetSttNd()->FindTableNode(); - if( !pHt || &pTblNd->GetTable() == - ((SwTableFmlUpdate*)pHt)->pTbl ) - { - double nValue; - if( !pCalc ) - pCalc = new SwCalc( *this ); - - // get the values of all SetExpression fields that are valid - // until the table - SwFrm* pFrm = 0; - if( pTblNd->GetIndex() < GetNodes().GetEndOfExtras().GetIndex() ) - { - // is in the special section, that's expensive! - Point aPt; // return the first frame of the layout - Tab.Headline!! - SwNodeIndex aCNdIdx( *pTblNd, +2 ); - SwCntntNode* pCNd = aCNdIdx.GetNode().GetCntntNode(); - if( !pCNd ) - pCNd = GetNodes().GoNext( &aCNdIdx ); - - if( pCNd && 0 != (pFrm = pCNd->getLayoutFrm( GetCurrentLayout(), &aPt )) ) - { - SwPosition aPos( *pCNd ); - if( GetBodyTxtNode( *this, aPos, *pFrm ) ) - FldsToCalc( *pCalc, _SetGetExpFld( aPos.nNode )); - else - pFrm = 0; - } - } - if( !pFrm ) - { - // create index to determine the TextNode - SwNodeIndex aIdx( *pTblNd ); - FldsToCalc( *pCalc, _SetGetExpFld( aIdx )); - } - - SwTblCalcPara aPara( *pCalc, pTblNd->GetTable() ); - pFml->Calc( aPara, nValue ); - - if( aPara.IsStackOverflow() ) - { - bool const bResult = aPara.CalcWithStackOverflow(); - if (bResult) - { - pFml->Calc( aPara, nValue ); - } - OSL_ENSURE(bResult, - "the chained formula could no be calculated"); - } - - SwFrmFmt* pFmt = pBox->ClaimFrmFmt(); - SfxItemSet aTmp( GetAttrPool(), - RES_BOXATR_BEGIN,RES_BOXATR_END-1 ); - - if( pCalc->IsCalcError() ) - nValue = DBL_MAX; - aTmp.Put( SwTblBoxValue( nValue )); - if( SFX_ITEM_SET != pFmt->GetItemState( RES_BOXATR_FORMAT )) - aTmp.Put( SwTblBoxNumFormat( 0 )); - pFmt->SetFmtAttr( aTmp ); - - pCalc->SetCalcError( CALC_NOERR ); - } - } - } - } - - delete pCalc; -} - -void SwDoc::UpdatePageFlds( SfxPoolItem* pMsgHnt ) -{ - SwFieldType* pFldType; - for( sal_uInt16 i = 0; i < INIT_FLDTYPES; ++i ) - switch( ( pFldType = (*mpFldTypes)[ i ] )->Which() ) - { - case RES_PAGENUMBERFLD: - case RES_CHAPTERFLD: - case RES_GETEXPFLD: - case RES_REFPAGEGETFLD: - pFldType->ModifyNotification( 0, pMsgHnt ); - break; - case RES_DOCSTATFLD: - pFldType->ModifyNotification( 0, 0 ); - break; - } - SetNewFldLst(true); -} - -/// Remove all unreferenced field types of a document -void SwDoc::GCFieldTypes() -{ - for( sal_uInt16 n = mpFldTypes->size(); n > INIT_FLDTYPES; ) - if( !(*mpFldTypes)[ --n ]->GetDepends() ) - RemoveFldType( n ); -} - -void SwDoc::LockExpFlds() -{ - ++mnLockExpFld; -} - -void SwDoc::UnlockExpFlds() -{ - if( mnLockExpFld ) - --mnLockExpFld; -} - -bool SwDoc::IsExpFldsLocked() const -{ - return 0 != mnLockExpFld; -} - -SwDocUpdtFld& SwDoc::GetUpdtFlds() const -{ - return *mpUpdtFlds; -} - -bool SwDoc::IsNewFldLst() const -{ - return mbNewFldLst; -} - -void SwDoc::SetNewFldLst(bool bFlag) -{ - mbNewFldLst = bFlag; -} - // the StartIndex can be supplied optionally (e.g. if it was queried before - is a virtual // method otherwise!) _SetGetExpFld::_SetGetExpFld( @@ -998,647 +352,6 @@ OUString LookString( SwHash** ppTbl, sal_uInt16 nSize, const OUString& rName, return OUString(); } -#if HAVE_FEATURE_DBCONNECTIVITY - -static OUString lcl_GetDBVarName( SwDoc& rDoc, SwDBNameInfField& rDBFld ) -{ - SwDBData aDBData( rDBFld.GetDBData( &rDoc )); - OUString sDBNumNm; - SwDBData aDocData = rDoc.GetDBData(); - - if( aDBData != aDocData ) - { - sDBNumNm = aDBData.sDataSource; - sDBNumNm += OUString(DB_DELIM); - sDBNumNm += aDBData.sCommand; - sDBNumNm += OUString(DB_DELIM); - } - sDBNumNm += SwFieldType::GetTypeStr(TYP_DBSETNUMBERFLD); - - return sDBNumNm; -} - -#endif - -static void lcl_CalcFld( SwDoc& rDoc, SwCalc& rCalc, const _SetGetExpFld& rSGEFld, - SwDBManager* pMgr ) -{ - const SwTxtFld* pTxtFld = rSGEFld.GetTxtFld(); - if( !pTxtFld ) - return ; - - const SwField* pFld = pTxtFld->GetFmtFld().GetField(); - const sal_uInt16 nFldWhich = pFld->GetTyp()->Which(); - - if( RES_SETEXPFLD == nFldWhich ) - { - SwSbxValue aValue; - if( nsSwGetSetExpType::GSE_EXPR & pFld->GetSubType() ) - aValue.PutDouble( ((SwSetExpField*)pFld)->GetValue() ); - else - // Extension to calculate with Strings - aValue.PutString( ((SwSetExpField*)pFld)->GetExpStr() ); - - // set the new value in Calculator - rCalc.VarChange( pFld->GetTyp()->GetName(), aValue ); - } - else if( pMgr ) - { -#if !HAVE_FEATURE_DBCONNECTIVITY - (void) rDoc; -#else - switch( nFldWhich ) - { - case RES_DBNUMSETFLD: - { - SwDBNumSetField* pDBFld = (SwDBNumSetField*)pFld; - - SwDBData aDBData(pDBFld->GetDBData(&rDoc)); - - if( pDBFld->IsCondValid() && - pMgr->OpenDataSource( aDBData.sDataSource, aDBData.sCommand )) - rCalc.VarChange( lcl_GetDBVarName( rDoc, *pDBFld), - pDBFld->GetFormat() ); - } - break; - case RES_DBNEXTSETFLD: - { - SwDBNextSetField* pDBFld = (SwDBNextSetField*)pFld; - SwDBData aDBData(pDBFld->GetDBData(&rDoc)); - if( !pDBFld->IsCondValid() || - !pMgr->OpenDataSource( aDBData.sDataSource, aDBData.sCommand )) - break; - - OUString sDBNumNm(lcl_GetDBVarName( rDoc, *pDBFld)); - SwCalcExp* pExp = rCalc.VarLook( sDBNumNm ); - if( pExp ) - rCalc.VarChange( sDBNumNm, pExp->nValue.GetLong() + 1 ); - } - break; - - } -#endif - } -} - -void SwDoc::FldsToCalc( SwCalc& rCalc, const _SetGetExpFld& rToThisFld ) -{ - // create the sorted list of all SetFields - mpUpdtFlds->MakeFldList( *this, mbNewFldLst, GETFLD_CALC ); - mbNewFldLst = false; - -#if !HAVE_FEATURE_DBCONNECTIVITY - SwDBManager* pMgr = NULL; -#else - SwDBManager* pMgr = GetDBManager(); - pMgr->CloseAll(false); -#endif - - if( !mpUpdtFlds->GetSortLst()->empty() ) - { - _SetGetExpFlds::const_iterator const itLast = - mpUpdtFlds->GetSortLst()->upper_bound( - const_cast<_SetGetExpFld*>(&rToThisFld)); - for( _SetGetExpFlds::const_iterator it = mpUpdtFlds->GetSortLst()->begin(); it != itLast; ++it ) - lcl_CalcFld( *this, rCalc, **it, pMgr ); - } -#if HAVE_FEATURE_DBCONNECTIVITY - pMgr->CloseAll(false); -#endif -} - -void SwDoc::FldsToCalc( SwCalc& rCalc, sal_uLong nLastNd, sal_uInt16 nLastCnt ) -{ - // create the sorted list of all SetFields - mpUpdtFlds->MakeFldList( *this, mbNewFldLst, GETFLD_CALC ); - mbNewFldLst = false; - -#if !HAVE_FEATURE_DBCONNECTIVITY - SwDBManager* pMgr = NULL; -#else - SwDBManager* pMgr = GetDBManager(); - pMgr->CloseAll(false); -#endif - - for( _SetGetExpFlds::const_iterator it = mpUpdtFlds->GetSortLst()->begin(); - it != mpUpdtFlds->GetSortLst()->end() && - ( (*it)->GetNode() < nLastNd || - ( (*it)->GetNode() == nLastNd && (*it)->GetCntnt() <= nLastCnt ) - ); - ++it ) - { - lcl_CalcFld( *this, rCalc, **it, pMgr ); - } - -#if HAVE_FEATURE_DBCONNECTIVITY - pMgr->CloseAll(false); -#endif -} - -void SwDoc::FldsToExpand( SwHash**& ppHashTbl, sal_uInt16& rTblSize, - const _SetGetExpFld& rToThisFld ) -{ - // create the sorted list of all SetFields - mpUpdtFlds->MakeFldList( *this, mbNewFldLst, GETFLD_EXPAND ); - mbNewFldLst = false; - - // Hash table for all string replacements is filled on-the-fly. - // Try to fabricate an uneven number. - rTblSize = (( mpUpdtFlds->GetSortLst()->size() / 7 ) + 1 ) * 7; - ppHashTbl = new SwHash*[ rTblSize ]; - memset( ppHashTbl, 0, sizeof( _HashStr* ) * rTblSize ); - - _SetGetExpFlds::const_iterator const itLast = - mpUpdtFlds->GetSortLst()->upper_bound( - const_cast<_SetGetExpFld*>(&rToThisFld)); - - for( _SetGetExpFlds::const_iterator it = mpUpdtFlds->GetSortLst()->begin(); it != itLast; ++it ) - { - const SwTxtFld* pTxtFld = (*it)->GetTxtFld(); - if( !pTxtFld ) - continue; - - const SwField* pFld = pTxtFld->GetFmtFld().GetField(); - switch( pFld->GetTyp()->Which() ) - { - case RES_SETEXPFLD: - if( nsSwGetSetExpType::GSE_STRING & pFld->GetSubType() ) - { - // set the new value in the hash table - // is the formula a field? - SwSetExpField* pSFld = (SwSetExpField*)pFld; - OUString aNew = LookString( ppHashTbl, rTblSize, pSFld->GetFormula() ); - - if( aNew.isEmpty() ) // nothing found, then the formula is - aNew = pSFld->GetFormula(); // the new value - - // #i3141# - update expression of field as in method - // <SwDoc::UpdateExpFlds(..)> for string/text fields - pSFld->ChgExpStr( aNew ); - - // look up the field's name - aNew = ((SwSetExpFieldType*)pSFld->GetTyp())->GetSetRefName(); - // Entry present? - sal_uInt16 nPos; - SwHash* pFnd = Find( aNew, ppHashTbl, rTblSize, &nPos ); - if( pFnd ) - // modify entry in the hash table - ((_HashStr*)pFnd)->aSetStr = pSFld->GetExpStr(); - else - // insert the new entry - *(ppHashTbl + nPos ) = new _HashStr( aNew, - pSFld->GetExpStr(), (_HashStr*)*(ppHashTbl + nPos) ); - } - break; - case RES_DBFLD: - { - const OUString& rName = pFld->GetTyp()->GetName(); - - // Insert entry in the hash table - // Entry present? - sal_uInt16 nPos; - SwHash* pFnd = Find( rName, ppHashTbl, rTblSize, &nPos ); - OUString const value(pFld->ExpandField(IsClipBoard())); - if( pFnd ) - { - // modify entry in the hash table - static_cast<_HashStr*>(pFnd)->aSetStr = value; - } - else - { - // insert the new entry - *(ppHashTbl + nPos ) = new _HashStr( rName, - value, static_cast<_HashStr *>(*(ppHashTbl + nPos))); - } - } - break; - } - } -} - -void SwDoc::UpdateExpFlds( SwTxtFld* pUpdtFld, bool bUpdRefFlds ) -{ - if( IsExpFldsLocked() || IsInReading() ) - return; - - bool bOldInUpdateFlds = mpUpdtFlds->IsInUpdateFlds(); - mpUpdtFlds->SetInUpdateFlds( true ); - - mpUpdtFlds->MakeFldList( *this, true, GETFLD_ALL ); - mbNewFldLst = false; - - if( mpUpdtFlds->GetSortLst()->empty() ) - { - if( bUpdRefFlds ) - UpdateRefFlds(NULL); - - mpUpdtFlds->SetInUpdateFlds( bOldInUpdateFlds ); - mpUpdtFlds->SetFieldsDirty( false ); - return ; - } - - sal_uInt16 nWhich, n; - - // Hash table for all string replacements is filled on-the-fly. - // Try to fabricate an uneven number. - sal_uInt16 nStrFmtCnt = (( mpFldTypes->size() / 7 ) + 1 ) * 7; - SwHash** pHashStrTbl = new SwHash*[ nStrFmtCnt ]; - memset( pHashStrTbl, 0, sizeof( _HashStr* ) * nStrFmtCnt ); - - { - const SwFieldType* pFldType; - // process separately: - for( n = mpFldTypes->size(); n; ) - switch( ( pFldType = (*mpFldTypes)[ --n ] )->Which() ) - { - case RES_USERFLD: - { - // Entry present? - sal_uInt16 nPos; - const OUString& rNm = pFldType->GetName(); - OUString sExpand(((SwUserFieldType*)pFldType)->Expand(nsSwGetSetExpType::GSE_STRING, 0, 0)); - SwHash* pFnd = Find( rNm, pHashStrTbl, nStrFmtCnt, &nPos ); - if( pFnd ) - // modify entry in the hash table - ((_HashStr*)pFnd)->aSetStr = sExpand; - else - // insert the new entry - *(pHashStrTbl + nPos ) = new _HashStr( rNm, sExpand, - (_HashStr*)*(pHashStrTbl + nPos) ); - } - break; - case RES_SETEXPFLD: - ((SwSetExpFieldType*)pFldType)->SetOutlineChgNd( 0 ); - break; - } - } - - // The array is filled with all fields; start calculation. - SwCalc aCalc( *this ); - -#if HAVE_FEATURE_DBCONNECTIVITY - OUString sDBNumNm( SwFieldType::GetTypeStr( TYP_DBSETNUMBERFLD ) ); - - // already set the current record number - SwDBManager* pMgr = GetDBManager(); - pMgr->CloseAll(false); -#endif - - // Make sure we don't hide all sections, which would lead to a crash. First, count how many of them do we have. - int nShownSections = 0; - for( _SetGetExpFlds::const_iterator it = mpUpdtFlds->GetSortLst()->begin(); it != mpUpdtFlds->GetSortLst()->end(); ++it ) - { - SwSection* pSect = (SwSection*)(*it)->GetSection(); - if ( pSect && !pSect->IsCondHidden()) - nShownSections++; - } - - OUString aNew; - for( _SetGetExpFlds::const_iterator it = mpUpdtFlds->GetSortLst()->begin(); it != mpUpdtFlds->GetSortLst()->end(); ++it ) - { - SwSection* pSect = (SwSection*)(*it)->GetSection(); - if( pSect ) - { - - SwSbxValue aValue = aCalc.Calculate( - pSect->GetCondition() ); - if(!aValue.IsVoidValue()) - { - // Do we want to hide this one? - bool bHide = aValue.GetBool(); - if (bHide && !pSect->IsCondHidden()) - { - // This section will be hidden, but it wasn't before - if (nShownSections == 1) - { - // Is the last node part of a section? - SwPaM aPam(GetNodes()); - aPam.Move(fnMoveForward, fnGoDoc); - if (aPam.Start()->nNode.GetNode().StartOfSectionNode()->IsSectionNode()) - { - // This would be the last section, so set its condition to false, and avoid hiding it. - OUString aCond("0"); - pSect->SetCondition(aCond); - bHide = false; - } - } - nShownSections--; - } - pSect->SetCondHidden( bHide ); - } - continue; - } - - SwTxtFld* pTxtFld = (SwTxtFld*)(*it)->GetTxtFld(); - if( !pTxtFld ) - { - OSL_ENSURE( false, "what's wrong now'" ); - continue; - } - - SwFmtFld* pFmtFld = (SwFmtFld*)&pTxtFld->GetFmtFld(); - const SwField* pFld = pFmtFld->GetField(); - - switch( nWhich = pFld->GetTyp()->Which() ) - { - case RES_HIDDENTXTFLD: - { - SwHiddenTxtField* pHFld = (SwHiddenTxtField*)pFld; - SwSbxValue aValue = aCalc.Calculate( pHFld->GetPar1() ); - bool bValue = !aValue.GetBool(); - if(!aValue.IsVoidValue()) - { - pHFld->SetValue( bValue ); - // evaluate field - pHFld->Evaluate(this); - } - } - break; - case RES_HIDDENPARAFLD: - { - SwHiddenParaField* pHPFld = (SwHiddenParaField*)pFld; - SwSbxValue aValue = aCalc.Calculate( pHPFld->GetPar1() ); - bool bValue = aValue.GetBool(); - if(!aValue.IsVoidValue()) - pHPFld->SetHidden( bValue ); - } - break; - case RES_DBSETNUMBERFLD: -#if HAVE_FEATURE_DBCONNECTIVITY - { - ((SwDBSetNumberField*)pFld)->Evaluate(this); - aCalc.VarChange( sDBNumNm, ((SwDBSetNumberField*)pFld)->GetSetNumber()); - } -#endif - break; - case RES_DBNEXTSETFLD: - case RES_DBNUMSETFLD: -#if HAVE_FEATURE_DBCONNECTIVITY - { - UpdateDBNumFlds( *(SwDBNameInfField*)pFld, aCalc ); - } -#endif - break; - case RES_DBFLD: - { -#if HAVE_FEATURE_DBCONNECTIVITY - // evaluate field - ((SwDBField*)pFld)->Evaluate(); - - SwDBData aTmpDBData(((SwDBField*)pFld)->GetDBData()); - - if( pMgr->IsDataSourceOpen(aTmpDBData.sDataSource, aTmpDBData.sCommand, false)) - aCalc.VarChange( sDBNumNm, pMgr->GetSelectedRecordId(aTmpDBData.sDataSource, aTmpDBData.sCommand, aTmpDBData.nCommandType)); - - const OUString& rName = pFld->GetTyp()->GetName(); - - // Add entry to hash table - // Entry present? - sal_uInt16 nPos; - SwHash* pFnd = Find( rName, pHashStrTbl, nStrFmtCnt, &nPos ); - OUString const value(pFld->ExpandField(IsClipBoard())); - if( pFnd ) - { - // Modify entry in the hash table - static_cast<_HashStr*>(pFnd)->aSetStr = value; - } - else - { - // insert new entry - *(pHashStrTbl + nPos ) = new _HashStr( rName, - value, static_cast<_HashStr *>(*(pHashStrTbl + nPos))); - } -#endif - } - break; - case RES_GETEXPFLD: - case RES_SETEXPFLD: - { - if( nsSwGetSetExpType::GSE_STRING & pFld->GetSubType() ) // replace String - { - if( RES_GETEXPFLD == nWhich ) - { - SwGetExpField* pGFld = (SwGetExpField*)pFld; - - if( (!pUpdtFld || pUpdtFld == pTxtFld ) - && pGFld->IsInBodyTxt() ) - { - aNew = LookString( pHashStrTbl, nStrFmtCnt, - pGFld->GetFormula() ); - pGFld->ChgExpStr( aNew ); - } - } - else - { - SwSetExpField* pSFld = (SwSetExpField*)pFld; - // is the "formula" a field? - aNew = LookString( pHashStrTbl, nStrFmtCnt, - pSFld->GetFormula() ); - - if( aNew.isEmpty() ) // nothing found then the formula is the new value - aNew = pSFld->GetFormula(); - - // only update one field - if( !pUpdtFld || pUpdtFld == pTxtFld ) - pSFld->ChgExpStr( aNew ); - - // lookup the field's name - aNew = ((SwSetExpFieldType*)pSFld->GetTyp())->GetSetRefName(); - // Entry present? - sal_uInt16 nPos; - SwHash* pFnd = Find( aNew, pHashStrTbl, nStrFmtCnt, &nPos ); - if( pFnd ) - // Modify entry in the hash table - ((_HashStr*)pFnd)->aSetStr = pSFld->GetExpStr(); - else - // insert new entry - *(pHashStrTbl + nPos ) = pFnd = new _HashStr( aNew, - pSFld->GetExpStr(), - (_HashStr*)*(pHashStrTbl + nPos) ); - - // Extension for calculation with Strings - SwSbxValue aValue; - aValue.PutString( ((_HashStr*)pFnd)->aSetStr ); - aCalc.VarChange( aNew, aValue ); - } - } - else // recalculate formula - { - if( RES_GETEXPFLD == nWhich ) - { - SwGetExpField* pGFld = (SwGetExpField*)pFld; - - if( (!pUpdtFld || pUpdtFld == pTxtFld ) - && pGFld->IsInBodyTxt() ) - { - SwSbxValue aValue = aCalc.Calculate( - pGFld->GetFormula()); - if(!aValue.IsVoidValue()) - pGFld->SetValue(aValue.GetDouble() ); - } - } - else - { - SwSetExpField* pSFld = (SwSetExpField*)pFld; - SwSetExpFieldType* pSFldTyp = (SwSetExpFieldType*)pFld->GetTyp(); - aNew = pSFldTyp->GetName(); - - SwNode* pSeqNd = 0; - - if( pSFld->IsSequenceFld() ) - { - const sal_uInt8 nLvl = pSFldTyp->GetOutlineLvl(); - if( MAXLEVEL > nLvl ) - { - // test if the Number needs to be updated - pSeqNd = GetNodes()[ (*it)->GetNode() ]; - - const SwTxtNode* pOutlNd = pSeqNd-> - FindOutlineNodeOfLevel( nLvl ); - if( pSFldTyp->GetOutlineChgNd() != pOutlNd ) - { - pSFldTyp->SetOutlineChgNd( pOutlNd ); - aCalc.VarChange( aNew, 0 ); - } - } - } - - aNew += "="; - aNew += pSFld->GetFormula(); - - SwSbxValue aValue = aCalc.Calculate( aNew ); - double nErg = aValue.GetDouble(); - // only update one field - if( !aValue.IsVoidValue() && (!pUpdtFld || pUpdtFld == pTxtFld) ) - { - pSFld->SetValue( nErg ); - - if( pSeqNd ) - pSFldTyp->SetChapter( *pSFld, *pSeqNd ); - } - } - } - } - } // switch - - pFmtFld->ModifyNotification( 0, 0 ); // trigger formatting - - if( pUpdtFld == pTxtFld ) // if only this one is updated - { - if( RES_GETEXPFLD == nWhich || // only GetField or - RES_HIDDENTXTFLD == nWhich || // HiddenTxt? - RES_HIDDENPARAFLD == nWhich) // HiddenParaFld? - break; // quit - pUpdtFld = 0; // update all from here on - } - } - -#if HAVE_FEATURE_DBCONNECTIVITY - pMgr->CloseAll(false); -#endif - // delete hash table - ::DeleteHashTable( pHashStrTbl, nStrFmtCnt ); - - // update reference fields - if( bUpdRefFlds ) - UpdateRefFlds(NULL); - - mpUpdtFlds->SetInUpdateFlds( bOldInUpdateFlds ); - mpUpdtFlds->SetFieldsDirty( false ); -} - -void SwDoc::UpdateDBNumFlds( SwDBNameInfField& rDBFld, SwCalc& rCalc ) -{ -#if !HAVE_FEATURE_DBCONNECTIVITY - (void) rDBFld; - (void) rCalc; -#else - SwDBManager* pMgr = GetDBManager(); - - sal_uInt16 nFldType = rDBFld.Which(); - - bool bPar1 = rCalc.Calculate( rDBFld.GetPar1() ).GetBool(); - - if( RES_DBNEXTSETFLD == nFldType ) - ((SwDBNextSetField&)rDBFld).SetCondValid( bPar1 ); - else - ((SwDBNumSetField&)rDBFld).SetCondValid( bPar1 ); - - if( !rDBFld.GetRealDBData().sDataSource.isEmpty() ) - { - // Edit a certain database - if( RES_DBNEXTSETFLD == nFldType ) - ((SwDBNextSetField&)rDBFld).Evaluate(this); - else - ((SwDBNumSetField&)rDBFld).Evaluate(this); - - SwDBData aTmpDBData( rDBFld.GetDBData(this) ); - - if( pMgr->OpenDataSource( aTmpDBData.sDataSource, aTmpDBData.sCommand, -1, false )) - rCalc.VarChange( lcl_GetDBVarName( *this, rDBFld), - pMgr->GetSelectedRecordId(aTmpDBData.sDataSource, aTmpDBData.sCommand, aTmpDBData.nCommandType) ); - } - else - { - OSL_FAIL("TODO: what should happen with unnamed DBFields?"); - } -#endif -} - -void SwDoc::_InitFieldTypes() // is being called by the CTOR -{ - // Field types - mpFldTypes->push_back( new SwDateTimeFieldType(this) ); - mpFldTypes->push_back( new SwChapterFieldType ); - mpFldTypes->push_back( new SwPageNumberFieldType ); - mpFldTypes->push_back( new SwAuthorFieldType ); - mpFldTypes->push_back( new SwFileNameFieldType(this) ); - mpFldTypes->push_back( new SwDBNameFieldType(this) ); - mpFldTypes->push_back( new SwGetExpFieldType(this) ); - mpFldTypes->push_back( new SwGetRefFieldType( this ) ); - mpFldTypes->push_back( new SwHiddenTxtFieldType ); - mpFldTypes->push_back( new SwPostItFieldType(this) ); - mpFldTypes->push_back( new SwDocStatFieldType(this) ); - mpFldTypes->push_back( new SwDocInfoFieldType(this) ); - mpFldTypes->push_back( new SwInputFieldType( this ) ); - mpFldTypes->push_back( new SwTblFieldType( this ) ); - mpFldTypes->push_back( new SwMacroFieldType(this) ); - mpFldTypes->push_back( new SwHiddenParaFieldType ); - mpFldTypes->push_back( new SwDBNextSetFieldType ); - mpFldTypes->push_back( new SwDBNumSetFieldType ); - mpFldTypes->push_back( new SwDBSetNumberFieldType ); - mpFldTypes->push_back( new SwTemplNameFieldType(this) ); - mpFldTypes->push_back( new SwTemplNameFieldType(this) ); - mpFldTypes->push_back( new SwExtUserFieldType ); - mpFldTypes->push_back( new SwRefPageSetFieldType ); - mpFldTypes->push_back( new SwRefPageGetFieldType( this ) ); - mpFldTypes->push_back( new SwJumpEditFieldType( this ) ); - mpFldTypes->push_back( new SwScriptFieldType( this ) ); - mpFldTypes->push_back( new SwCombinedCharFieldType ); - mpFldTypes->push_back( new SwDropDownFieldType ); - - // Types have to be at the end! - // We expect this in the InsertFldType! - // MIB 14.04.95: In Sw3StringPool::Setup (sw3imp.cxx) and - // lcl_sw3io_InSetExpField (sw3field.cxx) now also - mpFldTypes->push_back( new SwSetExpFieldType(this, - SW_RESSTR(STR_POOLCOLL_LABEL_ABB), nsSwGetSetExpType::GSE_SEQ) ); - mpFldTypes->push_back( new SwSetExpFieldType(this, - SW_RESSTR(STR_POOLCOLL_LABEL_TABLE), nsSwGetSetExpType::GSE_SEQ) ); - mpFldTypes->push_back( new SwSetExpFieldType(this, - SW_RESSTR(STR_POOLCOLL_LABEL_FRAME), nsSwGetSetExpType::GSE_SEQ) ); - mpFldTypes->push_back( new SwSetExpFieldType(this, - SW_RESSTR(STR_POOLCOLL_LABEL_DRAWING), nsSwGetSetExpType::GSE_SEQ) ); - - assert( mpFldTypes->size() == INIT_FLDTYPES ); -} - -void SwDoc::InsDelFldInFldLst( bool bIns, const SwTxtFld& rFld ) -{ - if( !mbNewFldLst || !IsInDtor() ) - mpUpdtFlds->InsDelFldInFldLst( bIns, rFld ); -} - SwDBData SwDoc::GetDBData() { return GetDBDesc(); @@ -1649,10 +362,10 @@ const SwDBData& SwDoc::GetDBDesc() #if HAVE_FEATURE_DBCONNECTIVITY if(maDBData.sDataSource.isEmpty()) { - const sal_uInt16 nSize = mpFldTypes->size(); + const sal_uInt16 nSize = getIDocumentFieldsAccess().GetFldTypes()->size(); for(sal_uInt16 i = 0; i < nSize && maDBData.sDataSource.isEmpty(); ++i) { - SwFieldType& rFldType = *((*mpFldTypes)[i]); + SwFieldType& rFldType = *((*getIDocumentFieldsAccess().GetFldTypes())[i]); sal_uInt16 nWhich = rFldType.Which(); if(IsUsed(rFldType)) { @@ -1924,7 +637,7 @@ void SwDoc::ChangeDBFields( const std::vector<OUString>& rOldNames, { SwDBFieldType* pOldTyp = (SwDBFieldType*)pFld->GetTyp(); - SwDBFieldType* pTyp = (SwDBFieldType*)InsertFldType( + SwDBFieldType* pTyp = (SwDBFieldType*)getIDocumentFieldsAccess().InsertFldType( SwDBFieldType(this, pOldTyp->GetColumnName(), aNewDBData)); pFmtFld->RegisterToFieldType( *pTyp ); @@ -2040,166 +753,13 @@ bool SwDoc::IsNameInArray( const std::vector<OUString>& rArr, const OUString& rN return false; } -void SwDoc::SetFixFields( bool bOnlyTimeDate, const DateTime* pNewDateTime ) -{ - bool bIsModified = IsModified(); - - sal_Int32 nDate; - sal_Int64 nTime; - if( pNewDateTime ) - { - nDate = pNewDateTime->GetDate(); - nTime = pNewDateTime->GetTime(); - } - else - { - nDate = Date( Date::SYSTEM ).GetDate(); - nTime = Time( Time::SYSTEM ).GetTime(); - } - - sal_uInt16 aTypes[5] = { - /*0*/ RES_DOCINFOFLD, - /*1*/ RES_AUTHORFLD, - /*2*/ RES_EXTUSERFLD, - /*3*/ RES_FILENAMEFLD, - /*4*/ RES_DATETIMEFLD }; // MUST be at the end! - - sal_uInt16 nStt = bOnlyTimeDate ? 4 : 0; - - for( ; nStt < 5; ++nStt ) - { - SwFieldType* pFldType = GetSysFldType( aTypes[ nStt ] ); - SwIterator<SwFmtFld,SwFieldType> aIter( *pFldType ); - for( SwFmtFld* pFmtFld = aIter.First(); pFmtFld; pFmtFld = aIter.Next() ) - { - if( pFmtFld && pFmtFld->GetTxtFld() ) - { - bool bChgd = false; - switch( aTypes[ nStt ] ) - { - case RES_DOCINFOFLD: - if( ((SwDocInfoField*)pFmtFld->GetField())->IsFixed() ) - { - bChgd = true; - SwDocInfoField* pDocInfFld = (SwDocInfoField*)pFmtFld->GetField(); - pDocInfFld->SetExpansion( ((SwDocInfoFieldType*) - pDocInfFld->GetTyp())->Expand( - pDocInfFld->GetSubType(), - pDocInfFld->GetFormat(), - pDocInfFld->GetLanguage(), - pDocInfFld->GetName() ) ); - } - break; - - case RES_AUTHORFLD: - if( ((SwAuthorField*)pFmtFld->GetField())->IsFixed() ) - { - bChgd = true; - SwAuthorField* pAuthorFld = (SwAuthorField*)pFmtFld->GetField(); - pAuthorFld->SetExpansion( ((SwAuthorFieldType*) - pAuthorFld->GetTyp())->Expand( - pAuthorFld->GetFormat() ) ); - } - break; - - case RES_EXTUSERFLD: - if( ((SwExtUserField*)pFmtFld->GetField())->IsFixed() ) - { - bChgd = true; - SwExtUserField* pExtUserFld = (SwExtUserField*)pFmtFld->GetField(); - pExtUserFld->SetExpansion( ((SwExtUserFieldType*) - pExtUserFld->GetTyp())->Expand( - pExtUserFld->GetSubType(), - pExtUserFld->GetFormat())); - } - break; - - case RES_DATETIMEFLD: - if( ((SwDateTimeField*)pFmtFld->GetField())->IsFixed() ) - { - bChgd = true; - ((SwDateTimeField*)pFmtFld->GetField())->SetDateTime( - DateTime(Date(nDate), Time(nTime)) ); - } - break; - - case RES_FILENAMEFLD: - if( ((SwFileNameField*)pFmtFld->GetField())->IsFixed() ) - { - bChgd = true; - SwFileNameField* pFileNameFld = - (SwFileNameField*)pFmtFld->GetField(); - pFileNameFld->SetExpansion( ((SwFileNameFieldType*) - pFileNameFld->GetTyp())->Expand( - pFileNameFld->GetFormat() ) ); - } - break; - } - - // Trigger formatting - if( bChgd ) - pFmtFld->ModifyNotification( 0, 0 ); - } - } - } - - if( !bIsModified ) - ResetModified(); -} - -bool SwDoc::SetFieldsDirty( bool b, const SwNode* pChk, sal_uLong nLen ) -{ - // See if the supplied nodes actually contain fields. - // If they don't, the flag doesn't need to be changed. - bool bFldsFnd = false; - if( b && pChk && !GetUpdtFlds().IsFieldsDirty() && !IsInDtor() - // ?? what's up with Undo, this is also wanted there! - /*&& &pChk->GetNodes() == &GetNodes()*/ ) - { - b = false; - if( !nLen ) - ++nLen; - sal_uLong nStt = pChk->GetIndex(); - const SwNodes& rNds = pChk->GetNodes(); - while( nLen-- ) - { - const SwTxtNode* pTNd = rNds[ nStt++ ]->GetTxtNode(); - if( pTNd ) - { - if( pTNd->GetAttrOutlineLevel() != 0 ) - // update chapter fields - b = true; - else if( pTNd->GetpSwpHints() && pTNd->GetSwpHints().Count() ) - { - const size_t nEnd = pTNd->GetSwpHints().Count(); - for( size_t n = 0 ; n < nEnd; ++n ) - { - const SwTxtAttr* pAttr = pTNd->GetSwpHints()[ n ]; - if ( pAttr->Which() == RES_TXTATR_FIELD ) - { - b = true; - break; - } - } - } - - if( b ) - break; - } - } - bFldsFnd = b; - } - GetUpdtFlds().SetFieldsDirty( b ); - return bFldsFnd; -} - void SwDoc::ChangeAuthorityData( const SwAuthEntry* pNewData ) { - const sal_uInt16 nSize = mpFldTypes->size(); + const sal_uInt16 nSize = getIDocumentFieldsAccess().GetFldTypes()->size(); for( sal_uInt16 i = INIT_FLDTYPES; i < nSize; ++i ) { - SwFieldType* pFldType = (*mpFldTypes)[i]; + SwFieldType* pFldType = (*getIDocumentFieldsAccess().GetFldTypes())[i]; if( RES_AUTHORITY == pFldType->Which() ) { SwAuthorityFieldType* pAuthType = (SwAuthorityFieldType*)pFldType; @@ -2626,119 +1186,4 @@ SwDocUpdtFld::~SwDocUpdtFld() delete aFldTypeTable[n]; } -bool SwDoc::UpdateFld(SwTxtFld * pDstTxtFld, SwField & rSrcFld, - SwMsgPoolItem * pMsgHnt, - bool bUpdateFlds) -{ - OSL_ENSURE(pDstTxtFld, "no field to update!"); - - bool bTblSelBreak = false; - - SwFmtFld * pDstFmtFld = (SwFmtFld*)&pDstTxtFld->GetFmtFld(); - SwField * pDstFld = pDstFmtFld->GetField(); - sal_uInt16 nFldWhich = rSrcFld.GetTyp()->Which(); - SwNodeIndex aTblNdIdx(pDstTxtFld->GetTxtNode()); - - if (pDstFld->GetTyp()->Which() == - rSrcFld.GetTyp()->Which()) - { - if (GetIDocumentUndoRedo().DoesUndo()) - { - SwPosition aPosition( pDstTxtFld->GetTxtNode() ); - aPosition.nContent = pDstTxtFld->GetStart(); - - SwUndo *const pUndo( new SwUndoFieldFromDoc( aPosition, *pDstFld, rSrcFld, pMsgHnt, bUpdateFlds) ); - GetIDocumentUndoRedo().AppendUndo(pUndo); - } - - SwField * pNewFld = rSrcFld.CopyField(); - pDstFmtFld->SetField(pNewFld); - - switch( nFldWhich ) - { - case RES_SETEXPFLD: - case RES_GETEXPFLD: - case RES_HIDDENTXTFLD: - case RES_HIDDENPARAFLD: - UpdateExpFlds( pDstTxtFld, true ); - break; - - case RES_TABLEFLD: - { - const SwTableNode* pTblNd = - IsIdxInTbl(aTblNdIdx); - if( pTblNd ) - { - SwTableFmlUpdate aTblUpdate( &pTblNd-> - GetTable() ); - if (bUpdateFlds) - UpdateTblFlds( &aTblUpdate ); - else - pNewFld->GetTyp()->ModifyNotification(0, &aTblUpdate); - - if (! bUpdateFlds) - bTblSelBreak = true; - } - } - break; - - case RES_MACROFLD: - if( bUpdateFlds && pDstTxtFld->GetpTxtNode() ) - (pDstTxtFld->GetpTxtNode())-> - ModifyNotification( 0, pDstFmtFld ); - break; - - case RES_DBNAMEFLD: - case RES_DBNEXTSETFLD: - case RES_DBNUMSETFLD: - case RES_DBSETNUMBERFLD: - ChgDBData(((SwDBNameInfField*) pNewFld)->GetRealDBData()); - pNewFld->GetTyp()->UpdateFlds(); - - break; - - case RES_DBFLD: -#if HAVE_FEATURE_DBCONNECTIVITY - { - // JP 10.02.96: call ChgValue, so that the style change sets the - // ContentString correctly - SwDBField* pDBFld = (SwDBField*)pNewFld; - if (pDBFld->IsInitialized()) - pDBFld->ChgValue( pDBFld->GetValue(), true ); - - pDBFld->ClearInitialized(); - pDBFld->InitContent(); - } -#endif - // no break; - - default: - pDstFmtFld->ModifyNotification( 0, pMsgHnt ); - } - - // The fields we can calculate here are being triggered for an update - // here explicitly. - if( nFldWhich == RES_USERFLD ) - UpdateUsrFlds(); - } - - return bTblSelBreak; -} - -bool SwDoc::PutValueToField(const SwPosition & rPos, - const Any& rVal, sal_uInt16 nWhich) -{ - Any aOldVal; - SwField * pField = GetFieldAtPos(rPos); - - if (GetIDocumentUndoRedo().DoesUndo() && - pField->QueryValue(aOldVal, nWhich)) - { - SwUndo *const pUndo(new SwUndoFieldFromAPI(rPos, aOldVal, rVal, nWhich)); - GetIDocumentUndoRedo().AppendUndo(pUndo); - } - - return pField->PutValue(rVal, nWhich); -} - /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/doc/docfmt.cxx b/sw/source/core/doc/docfmt.cxx index cf594d229f1a..1fe1f3cd36fa 100644 --- a/sw/source/core/doc/docfmt.cxx +++ b/sw/source/core/doc/docfmt.cxx @@ -38,6 +38,7 @@ #include <doc.hxx> #include <IDocumentUndoRedo.hxx> #include <DocumentContentOperationsManager.hxx> +#include <IDocumentFieldsAccess.hxx> #include <rootfrm.hxx> #include <pagefrm.hxx> #include <hints.hxx> @@ -1722,7 +1723,7 @@ SwTblNumFmtMerge::SwTblNumFmtMerge( const SwDoc& rSrc, SwDoc& rDest ) ( pNFmt = rDest.GetNumberFormatter( true ))->MergeFormatter( *pN ); if( &rSrc != &rDest ) - ((SwGetRefFieldType*)rSrc.GetSysFldType( RES_GETREFFLD ))-> + ((SwGetRefFieldType*)rSrc.getIDocumentFieldsAccess().GetSysFldType( RES_GETREFFLD ))-> MergeWithOtherDoc( rDest ); } diff --git a/sw/source/core/doc/docftn.cxx b/sw/source/core/doc/docftn.cxx index 54f0469fa010..eb7dad4b3acc 100644 --- a/sw/source/core/doc/docftn.cxx +++ b/sw/source/core/doc/docftn.cxx @@ -28,6 +28,7 @@ #include <hints.hxx> #include <rolbck.hxx> #include <doc.hxx> +#include <IDocumentFieldsAccess.hxx> #include <IDocumentUndoRedo.hxx> #include <ndtxt.hxx> #include <poolfmt.hxx> @@ -308,7 +309,7 @@ void SwDoc::SetFtnInfo(const SwFtnInfo& rInfo) // #i81002# no update during loading if ( !IsInReading() ) { - UpdateRefFlds(NULL); + getIDocumentFieldsAccess().UpdateRefFlds(NULL); } SetModified(); } @@ -376,7 +377,7 @@ void SwDoc::SetEndNoteInfo(const SwEndNoteInfo& rInfo) // #i81002# no update during loading if ( !IsInReading() ) { - UpdateRefFlds(NULL); + getIDocumentFieldsAccess().UpdateRefFlds(NULL); } SetModified(); } diff --git a/sw/source/core/doc/docglos.cxx b/sw/source/core/doc/docglos.cxx index 79cfe2aeef70..593e25742cba 100644 --- a/sw/source/core/doc/docglos.cxx +++ b/sw/source/core/doc/docglos.cxx @@ -24,6 +24,7 @@ #include <doc.hxx> #include <IDocumentUndoRedo.hxx> +#include <IDocumentFieldsAccess.hxx> #include <shellio.hxx> #include <pam.hxx> #include <swundo.hxx> @@ -126,10 +127,10 @@ bool SwDoc::InsertGlossary( SwTextBlocks& rBlock, const OUString& rEntry, xGlosDPS->getDocumentProperties() ); lcl_copyDocumentProperties(xDocProps, xGlosDocProps); } - pGDoc->SetFixFields(false, NULL); + pGDoc->getIDocumentFieldsAccess().SetFixFields(false, NULL); // StartAllAction(); - LockExpFlds(); + getIDocumentFieldsAccess().LockExpFlds(); SwNodeIndex aStt( pGDoc->GetNodes().GetEndOfExtras(), 1 ); SwCntntNode* pCntntNd = pGDoc->GetNodes().GoNext( &aStt ); @@ -172,9 +173,9 @@ bool SwDoc::InsertGlossary( SwTextBlocks& rBlock, const OUString& rEntry, __pStartCrsr ); GetIDocumentUndoRedo().EndUndo( UNDO_INSGLOSSARY, NULL ); - UnlockExpFlds(); - if( !IsExpFldsLocked() ) - UpdateExpFlds(NULL, true); + getIDocumentFieldsAccess().UnlockExpFlds(); + if( !getIDocumentFieldsAccess().IsExpFldsLocked() ) + getIDocumentFieldsAccess().UpdateExpFlds(NULL, true); bRet = true; } mbInsOnlyTxtGlssry = bSav_IsInsGlossary; diff --git a/sw/source/core/doc/doclay.cxx b/sw/source/core/doc/doclay.cxx index 3595506b482d..3d858708bd18 100644 --- a/sw/source/core/doc/doclay.cxx +++ b/sw/source/core/doc/doclay.cxx @@ -66,6 +66,7 @@ #include <DocumentSettingManager.hxx> #include <IDocumentDrawModelAccess.hxx> #include <DocumentContentOperationsManager.hxx> +#include <IDocumentFieldsAccess.hxx> #include <rootfrm.hxx> #include <pagefrm.hxx> #include <cntfrm.hxx> @@ -1043,9 +1044,9 @@ lcl_InsertLabel(SwDoc & rDoc, SwTxtFmtColls *const pTxtFmtCollTbl, bool bTable = false; // To save some code. // Get the field first, because we retrieve the TxtColl via the field's name - OSL_ENSURE( nId == USHRT_MAX || nId < rDoc.GetFldTypes()->size(), + OSL_ENSURE( nId == USHRT_MAX || nId < rDoc.getIDocumentFieldsAccess().GetFldTypes()->size(), "FldType index out of bounds." ); - SwFieldType *pType = (nId != USHRT_MAX) ? (*rDoc.GetFldTypes())[nId] : NULL; + SwFieldType *pType = (nId != USHRT_MAX) ? (*rDoc.getIDocumentFieldsAccess().GetFldTypes())[nId] : NULL; OSL_ENSURE(!pType || pType->Which() == RES_SETEXPFLD, "wrong Id for Label"); SwTxtFmtColl * pColl = NULL; @@ -1392,9 +1393,9 @@ lcl_InsertDrawLabel( SwDoc & rDoc, SwTxtFmtColls *const pTxtFmtCollTbl, ::sw::DrawUndoGuard const drawUndoGuard(rDoc.GetIDocumentUndoRedo()); // Because we get by the TxtColl's name, we need to create the field first. - OSL_ENSURE( nId == USHRT_MAX || nId < rDoc.GetFldTypes()->size(), + OSL_ENSURE( nId == USHRT_MAX || nId < rDoc.getIDocumentFieldsAccess().GetFldTypes()->size(), "FldType index out of bounds" ); - SwFieldType *pType = nId != USHRT_MAX ? (*rDoc.GetFldTypes())[nId] : 0; + SwFieldType *pType = nId != USHRT_MAX ? (*rDoc.getIDocumentFieldsAccess().GetFldTypes())[nId] : 0; OSL_ENSURE( !pType || pType->Which() == RES_SETEXPFLD, "Wrong label id" ); SwTxtFmtColl *pColl = NULL; diff --git a/sw/source/core/doc/docnew.cxx b/sw/source/core/doc/docnew.cxx index 23ea7e02093d..444e46ccd2d3 100644 --- a/sw/source/core/doc/docnew.cxx +++ b/sw/source/core/doc/docnew.cxx @@ -98,6 +98,7 @@ #include <DocumentOutlineNodesManager.hxx> #include <DocumentContentOperationsManager.hxx> #include <DocumentRedlineManager.hxx> +#include <DocumentFieldsManager.hxx> #include <unochart.hxx> #include <fldbas.hxx> @@ -211,6 +212,7 @@ SwDoc::SwDoc() m_pDocumentListsManager( new ::sw::DocumentListsManager( *this ) ), m_pDocumentOutlineNodesManager( new ::sw::DocumentOutlineNodesManager( *this ) ), m_pDocumentContentOperationsManager( new ::sw::DocumentContentOperationsManager( *this ) ), + m_pDocumentFieldsManager( new ::sw::DocumentFieldsManager( *this ) ), mpDfltFrmFmt( new SwFrmFmt( GetAttrPool(), sFrmFmtStr, 0 ) ), mpEmptyPageFmt( new SwFrmFmt( GetAttrPool(), sEmptyPageStr, mpDfltFrmFmt ) ), mpColumnContFmt( new SwFrmFmt( GetAttrPool(), sColumnCntStr, mpDfltFrmFmt ) ), @@ -227,8 +229,6 @@ SwDoc::SwDoc() mpTOXTypes( new SwTOXTypes() ), mpDefTOXBases( new SwDefTOXBase_Impl() ), mpCurrentView( 0 ), - mpUpdtFlds( new SwDocUpdtFld( this ) ), - mpFldTypes( new SwFldTypes() ), mpGlossaryDoc( 0 ), mpOutlineRule( 0 ), mpFtnInfo( new SwFtnInfo ), @@ -251,7 +251,6 @@ SwDoc::SwDoc() mpGrammarContact(createGrammarContact()), m_pXmlIdRegistry(), mReferenceCount(0), - mnLockExpFld( 0 ), mbGlossDoc(false), mbModified(false), mbDtor(false), @@ -259,7 +258,6 @@ SwDoc::SwDoc() mbLoaded(false), mbUpdateExpFld(false), mbNewDoc(false), - mbNewFldLst(true), mbCopyIsMove(false), mbInReading(false), mbInXMLImport(false), @@ -322,7 +320,7 @@ SwDoc::SwDoc() // Set BodyFmt for columns mpColumnContFmt->SetFmtAttr( SwFmtFillOrder( ATT_LEFT_TO_RIGHT ) ); - _InitFieldTypes(); + GetDocumentFieldsManager()._InitFieldTypes(); // Create a default OutlineNumRule (for Filters) mpOutlineRule = new SwNumRule( SwNumRule::GetOutlineRuleName(), @@ -473,7 +471,6 @@ SwDoc::~SwDoc() getIDocumentRedlineAccess().GetExtraRedlineTbl().DeleteAndDestroyAll(); delete mpUnoCrsrTbl; - delete mpUpdtFlds; delete mpACEWord; // Release the BaseLinks @@ -622,7 +619,6 @@ SwDoc::~SwDoc() delete mpEndNoteInfo; delete mpLineNumberInfo; delete mpFtnIdxs; - delete mpFldTypes; delete mpTOXTypes; delete mpDocStat; delete mpEmptyPageFmt; @@ -774,10 +770,7 @@ void SwDoc::ClearDoc() mxForbiddenCharsTable.clear(); - for(SwFldTypes::const_iterator it = mpFldTypes->begin() + INIT_FLDTYPES; - it != mpFldTypes->end(); ++it) - delete *it; - mpFldTypes->erase( mpFldTypes->begin() + INIT_FLDTYPES, mpFldTypes->end() ); + GetDocumentFieldsManager().ClearFieldTypes(); delete mpNumberFormatter, mpNumberFormatter = 0; @@ -948,7 +941,7 @@ void SwDoc::Paste( const SwDoc& rSource ) aCpyPam.Move( fnMoveForward, fnGoDoc ); this->GetIDocumentUndoRedo().StartUndo( UNDO_INSGLOSSARY, NULL ); - this->LockExpFlds(); + this->getIDocumentFieldsAccess().LockExpFlds(); { SwPosition& rInsPos = *aInsertPam.GetPoint(); @@ -1000,8 +993,8 @@ void SwDoc::Paste( const SwDoc& rSource ) this->GetIDocumentUndoRedo().EndUndo( UNDO_INSGLOSSARY, NULL ); - UnlockExpFlds(); - UpdateFlds(NULL, false); + getIDocumentFieldsAccess().UnlockExpFlds(); + getIDocumentFieldsAccess().UpdateFlds(NULL, false); } sal_uInt16 SwTxtFmtColls::GetPos(const SwTxtFmtColl* p) const diff --git a/sw/source/core/doc/docnum.cxx b/sw/source/core/doc/docnum.cxx index decdb5a7b0a7..04e6b2ddc559 100644 --- a/sw/source/core/doc/docnum.cxx +++ b/sw/source/core/doc/docnum.cxx @@ -27,6 +27,7 @@ #include <IDocumentUndoRedo.hxx> #include <IDocumentListsAccess.hxx> #include <DocumentRedlineManager.hxx> +#include <IDocumentFieldsAccess.hxx> #include <pam.hxx> #include <ndtxt.hxx> #include <doctxm.hxx> @@ -140,7 +141,7 @@ void SwDoc::SetOutlineNumRule( const SwNumRule& rRule ) if( !GetFtnIdxs().empty() && FTNNUM_CHAPTER == GetFtnInfo().eNum ) GetFtnIdxs().UpdateAllFtn(); - UpdateExpFlds(NULL, true); + getIDocumentFieldsAccess().UpdateExpFlds(NULL, true); SetModified(); } diff --git a/sw/source/core/doc/docsort.cxx b/sw/source/core/doc/docsort.cxx index 687cc7885c17..fa3fa254daeb 100644 --- a/sw/source/core/doc/docsort.cxx +++ b/sw/source/core/doc/docsort.cxx @@ -32,6 +32,7 @@ #include <frmfmt.hxx> #include <doc.hxx> #include <IDocumentUndoRedo.hxx> +#include <IDocumentFieldsAccess.hxx> #include <node.hxx> #include <pam.hxx> #include <ndtxt.hxx> @@ -522,7 +523,7 @@ bool SwDoc::SortTbl(const SwSelBoxes& rBoxes, const SwSortOptions& rOpt) // Switch to relative Formulas SwTableFmlUpdate aMsgHnt( &pTblNd->GetTable() ); aMsgHnt.eFlags = TBL_RELBOXNAME; - UpdateTblFlds( &aMsgHnt ); + getIDocumentFieldsAccess().UpdateTblFlds( &aMsgHnt ); // Table as a flat array structure FlatFndBox aFlatBox(this, aFndBox); diff --git a/sw/source/core/doc/doctxm.cxx b/sw/source/core/doc/doctxm.cxx index 7cb16d3e4c56..b635e8d2fde4 100644 --- a/sw/source/core/doc/doctxm.cxx +++ b/sw/source/core/doc/doctxm.cxx @@ -38,6 +38,7 @@ #include <IDocumentUndoRedo.hxx> #include <DocumentSettingManager.hxx> #include <IDocumentRedlineAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <pagefrm.hxx> #include <ndtxt.hxx> #include <swtable.hxx> @@ -1261,7 +1262,7 @@ void SwTOXBaseSection::UpdateTemplate( const SwTxtNode* pOwnChapterNode ) void SwTOXBaseSection::UpdateSequence( const SwTxtNode* pOwnChapterNode ) { SwDoc* pDoc = (SwDoc*)GetFmt()->GetDoc(); - SwFieldType* pSeqFld = pDoc->GetFldType(RES_SETEXPFLD, GetSequenceName(), false); + SwFieldType* pSeqFld = pDoc->getIDocumentFieldsAccess().GetFldType(RES_SETEXPFLD, GetSequenceName(), false); if(!pSeqFld) return; @@ -1303,7 +1304,7 @@ void SwTOXBaseSection::UpdateSequence( const SwTxtNode* pOwnChapterNode ) void SwTOXBaseSection::UpdateAuthorities( const SwTOXInternational& rIntl ) { SwDoc* pDoc = (SwDoc*)GetFmt()->GetDoc(); - SwFieldType* pAuthFld = pDoc->GetFldType(RES_AUTHORITY, OUString(), false); + SwFieldType* pAuthFld = pDoc->getIDocumentFieldsAccess().GetFldType(RES_AUTHORITY, OUString(), false); if(!pAuthFld) return; diff --git a/sw/source/core/doc/tblcpy.cxx b/sw/source/core/doc/tblcpy.cxx index bcf61c1099ac..e6bc6ef44afe 100644 --- a/sw/source/core/doc/tblcpy.cxx +++ b/sw/source/core/doc/tblcpy.cxx @@ -25,6 +25,7 @@ #include <IDocumentUndoRedo.hxx> #include <DocumentContentOperationsManager.hxx> #include <IDocumentRedlineAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <cntfrm.hxx> #include <pam.hxx> #include <swtable.hxx> @@ -697,7 +698,7 @@ bool SwTable::InsNewTable( const SwTable& rCpyTbl, const SwSelBoxes& rSelBoxes, // Change table formulas into relative representation SwTableFmlUpdate aMsgHnt( &rCpyTbl ); aMsgHnt.eFlags = TBL_RELBOXNAME; - pCpyDoc->UpdateTblFlds( &aMsgHnt ); + pCpyDoc->getIDocumentFieldsAccess().UpdateTblFlds( &aMsgHnt ); } // delete frames @@ -747,7 +748,7 @@ bool SwTable::InsTable( const SwTable& rCpyTbl, const SwNodeIndex& rSttBox, // Convert Table formulas to their relative representation SwTableFmlUpdate aMsgHnt( &rCpyTbl ); aMsgHnt.eFlags = TBL_RELBOXNAME; - pCpyDoc->UpdateTblFlds( &aMsgHnt ); + pCpyDoc->getIDocumentFieldsAccess().UpdateTblFlds( &aMsgHnt ); } SwTblNumFmtMerge aTNFM( *pCpyDoc, *pDoc ); @@ -995,7 +996,7 @@ bool SwTable::InsTable( const SwTable& rCpyTbl, const SwSelBoxes& rSelBoxes, // Convert Table formulas to their relative representation SwTableFmlUpdate aMsgHnt( &rCpyTbl ); aMsgHnt.eFlags = TBL_RELBOXNAME; - pCpyDoc->UpdateTblFlds( &aMsgHnt ); + pCpyDoc->getIDocumentFieldsAccess().UpdateTblFlds( &aMsgHnt ); } // Delete the Frames diff --git a/sw/source/core/doc/tblrwcl.cxx b/sw/source/core/doc/tblrwcl.cxx index 7101be27602f..2575f19fea8a 100644 --- a/sw/source/core/doc/tblrwcl.cxx +++ b/sw/source/core/doc/tblrwcl.cxx @@ -33,6 +33,7 @@ #include <IDocumentChartDataProviderAccess.hxx> #include <DocumentContentOperationsManager.hxx> #include <IDocumentRedlineAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <cntfrm.hxx> #include <tabfrm.hxx> #include <frmtool.hxx> @@ -2092,7 +2093,7 @@ bool SwTable::CopyHeadlineIntoTable( SwTableNode& rTblNd ) // Convert Table formulas to their relative representation SwTableFmlUpdate aMsgHnt( this ); aMsgHnt.eFlags = TBL_RELBOXNAME; - GetFrmFmt()->GetDoc()->UpdateTblFlds( &aMsgHnt ); + GetFrmFmt()->GetDoc()->getIDocumentFieldsAccess().UpdateTblFlds( &aMsgHnt ); } _CpyTabFrms aCpyFmt; @@ -2159,7 +2160,7 @@ bool SwTable::MakeCopy( SwDoc* pInsDoc, const SwPosition& rPos, { // A DDE-Table is being copied // Does the new Document actually have it's FieldType? - SwFieldType* pFldType = pInsDoc->InsertFldType( + SwFieldType* pFldType = pInsDoc->getIDocumentFieldsAccess().InsertFldType( *((SwDDETable*)this)->GetDDEFldType() ); OSL_ENSURE( pFldType, "unknown FieldType" ); @@ -2179,7 +2180,7 @@ bool SwTable::MakeCopy( SwDoc* pInsDoc, const SwPosition& rPos, // Conver the Table formulas to their relative representation SwTableFmlUpdate aMsgHnt( this ); aMsgHnt.eFlags = TBL_RELBOXNAME; - pSrcDoc->UpdateTblFlds( &aMsgHnt ); + pSrcDoc->getIDocumentFieldsAccess().UpdateTblFlds( &aMsgHnt ); } SwTblNumFmtMerge aTNFM( *pSrcDoc, *pInsDoc ); diff --git a/sw/source/core/docnode/ndcopy.cxx b/sw/source/core/docnode/ndcopy.cxx index d403e16b7ee6..37ad94d5baea 100644 --- a/sw/source/core/docnode/ndcopy.cxx +++ b/sw/source/core/docnode/ndcopy.cxx @@ -17,6 +17,7 @@ * the License at http://www.apache.org/licenses/LICENSE-2.0 . */ #include <doc.hxx> +#include <IDocumentFieldsAccess.hxx> #include <node.hxx> #include <frmfmt.hxx> #include <swtable.hxx> @@ -271,9 +272,9 @@ SwTableNode* SwTableNode::MakeCopy( SwDoc* pDoc, const SwNodeIndex& rIdx ) const // Is the field type available in the new document? pDDEType = ((SwDDETable&)GetTable()).GetDDEFldType(); if( pDDEType->IsDeleted() ) - pDoc->InsDeletedFldType( *pDDEType ); + pDoc->getIDocumentFieldsAccess().InsDeletedFldType( *pDDEType ); else - pDDEType = (SwDDEFieldType*)pDoc->InsertFldType( *pDDEType ); + pDDEType = (SwDDEFieldType*)pDoc->getIDocumentFieldsAccess().InsertFldType( *pDDEType ); OSL_ENSURE( pDDEType, "unknown FieldType" ); // Swap the table pointers in the node diff --git a/sw/source/core/docnode/ndnum.cxx b/sw/source/core/docnode/ndnum.cxx index efe0567088a0..270c7d4656b3 100644 --- a/sw/source/core/docnode/ndnum.cxx +++ b/sw/source/core/docnode/ndnum.cxx @@ -19,6 +19,7 @@ #include <node.hxx> #include <doc.hxx> +#include <IDocumentFieldsAccess.hxx> #include <pam.hxx> #include <ndtxt.hxx> #include <fldbas.hxx> @@ -68,7 +69,7 @@ void SwNodes::UpdateOutlineNode(SwNode & rNd) pTxtNd->UpdateOutlineState(); // update the structure fields - GetDoc()->GetSysFldType( RES_CHAPTERFLD )->UpdateFlds(); + GetDoc()->getIDocumentFieldsAccess().GetSysFldType( RES_CHAPTERFLD )->UpdateFlds(); } } diff --git a/sw/source/core/docnode/ndsect.cxx b/sw/source/core/docnode/ndsect.cxx index 5f3312e6ec10..1084d95420d6 100644 --- a/sw/source/core/docnode/ndsect.cxx +++ b/sw/source/core/docnode/ndsect.cxx @@ -29,6 +29,7 @@ #include <doc.hxx> #include <IDocumentUndoRedo.hxx> #include <IDocumentLinksAdministration.hxx> +#include <IDocumentFieldsAccess.hxx> #include <rootfrm.hxx> #include <pam.hxx> #include <ndtxt.hxx> @@ -339,7 +340,7 @@ SwDoc::InsertSwSection(SwPaM const& rRange, SwSectionData & rNewData, SwCalc aCalc( *this ); if( ! IsInReading() ) { - FldsToCalc( aCalc, pNewSectNode->GetIndex(), USHRT_MAX ); + getIDocumentFieldsAccess().FldsToCalc( aCalc, pNewSectNode->GetIndex(), USHRT_MAX ); } SwSection& rNewSect = pNewSectNode->GetSection(); rNewSect.SetCondHidden( aCalc.Calculate( rNewSect.GetCondition() ).GetBool() ); @@ -715,7 +716,7 @@ void SwDoc::UpdateSection(sal_uInt16 const nPos, SwSectionData & rNewData, SwCalc aCalc( *this ); if( !pIdx ) pIdx = pFmt->GetCntnt().GetCntntIdx(); - FldsToCalc( aCalc, pIdx->GetIndex(), USHRT_MAX ); + getIDocumentFieldsAccess().FldsToCalc( aCalc, pIdx->GetIndex(), USHRT_MAX ); /// Because on using SwSection::operator=() to set up <pSection> /// with <rNewData> and the above given note, the hidden condition flag diff --git a/sw/source/core/docnode/ndtbl.cxx b/sw/source/core/docnode/ndtbl.cxx index 380ba88fd77d..c52b0de866bb 100644 --- a/sw/source/core/docnode/ndtbl.cxx +++ b/sw/source/core/docnode/ndtbl.cxx @@ -43,6 +43,7 @@ #include <DocumentSettingManager.hxx> #include <IDocumentChartDataProviderAccess.hxx> #include <IDocumentRedlineAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <cntfrm.hxx> #include <pam.hxx> #include <swcrsr.hxx> @@ -871,7 +872,7 @@ const SwTable* SwDoc::TextToTable( const SwInsertTableOptions& rInsTblOpts, } SetModified(); - SetFieldsDirty(true, NULL, 0); + getIDocumentFieldsAccess().SetFieldsDirty(true, NULL, 0); return pNdTbl; } @@ -1225,7 +1226,7 @@ const SwTable* SwDoc::TextToTable( const std::vector< std::vector<SwNodeRange> > aNode2Layout.RestoreUpperFrms( GetNodes(), nIdx, nIdx + 1 ); SetModified(); - SetFieldsDirty( true, NULL, 0 ); + getIDocumentFieldsAccess().SetFieldsDirty( true, NULL, 0 ); return pNdTbl; } @@ -1433,7 +1434,7 @@ bool SwDoc::TableToText( const SwTableNode* pTblNd, sal_Unicode cCh ) SwTableFmlUpdate aMsgHnt( &pTblNd->GetTable() ); aMsgHnt.eFlags = TBL_BOXNAME; - UpdateTblFlds( &aMsgHnt ); + getIDocumentFieldsAccess().UpdateTblFlds( &aMsgHnt ); bool bRet = GetNodes().TableToText( aRg, cCh, pUndo ); if( pUndoRg ) @@ -1702,14 +1703,14 @@ bool SwDoc::InsertCol( const SwSelBoxes& rBoxes, sal_uInt16 nCnt, bool bBehind ) SwTableFmlUpdate aMsgHnt( &rTbl ); aMsgHnt.eFlags = TBL_BOXPTR; - UpdateTblFlds( &aMsgHnt ); + getIDocumentFieldsAccess().UpdateTblFlds( &aMsgHnt ); bRet = rTbl.InsertCol( this, rBoxes, nCnt, bBehind ); if (bRet) { SetModified(); ::ClearFEShellTabCols(); - SetFieldsDirty( true, NULL, 0 ); + getIDocumentFieldsAccess().SetFieldsDirty( true, NULL, 0 ); } } @@ -1764,14 +1765,14 @@ bool SwDoc::InsertRow( const SwSelBoxes& rBoxes, sal_uInt16 nCnt, bool bBehind ) SwTableFmlUpdate aMsgHnt( &rTbl ); aMsgHnt.eFlags = TBL_BOXPTR; - UpdateTblFlds( &aMsgHnt ); + getIDocumentFieldsAccess().UpdateTblFlds( &aMsgHnt ); bRet = rTbl.InsertRow( this, rBoxes, nCnt, bBehind ); if (bRet) { SetModified(); ::ClearFEShellTabCols(); - SetFieldsDirty( true, NULL, 0 ); + getIDocumentFieldsAccess().SetFieldsDirty( true, NULL, 0 ); } } @@ -2076,7 +2077,7 @@ bool SwDoc::DeleteRowCol( const SwSelBoxes& rBoxes, bool bColumn ) getIDocumentContentOperations().DeleteSection( pTblNd ); } SetModified(); - SetFieldsDirty( true, NULL, 0 ); + getIDocumentFieldsAccess().SetFieldsDirty( true, NULL, 0 ); return true; } @@ -2093,7 +2094,7 @@ bool SwDoc::DeleteRowCol( const SwSelBoxes& rBoxes, bool bColumn ) SwTableFmlUpdate aMsgHnt( &pTblNd->GetTable() ); aMsgHnt.eFlags = TBL_BOXPTR; - UpdateTblFlds( &aMsgHnt ); + getIDocumentFieldsAccess().UpdateTblFlds( &aMsgHnt ); if (rTable.IsNewModel()) { @@ -2107,7 +2108,7 @@ bool SwDoc::DeleteRowCol( const SwSelBoxes& rBoxes, bool bColumn ) if (bRet) { SetModified(); - SetFieldsDirty( true, NULL, 0 ); + getIDocumentFieldsAccess().SetFieldsDirty( true, NULL, 0 ); } } @@ -2165,7 +2166,7 @@ bool SwDoc::SplitTbl( const SwSelBoxes& rBoxes, bool bVert, sal_uInt16 nCnt, SwTableFmlUpdate aMsgHnt( &rTbl ); aMsgHnt.eFlags = TBL_BOXPTR; - UpdateTblFlds( &aMsgHnt ); + getIDocumentFieldsAccess().UpdateTblFlds( &aMsgHnt ); if (bVert) bRet = rTbl.SplitCol( this, rBoxes, nCnt ); @@ -2175,7 +2176,7 @@ bool SwDoc::SplitTbl( const SwSelBoxes& rBoxes, bool bVert, sal_uInt16 nCnt, if (bRet) { SetModified(); - SetFieldsDirty( true, NULL, 0 ); + getIDocumentFieldsAccess().SetFieldsDirty( true, NULL, 0 ); } } @@ -2276,13 +2277,13 @@ sal_uInt16 SwDoc::MergeTbl( SwPaM& rPam ) // Merge them SwTableFmlUpdate aMsgHnt( &pTblNd->GetTable() ); aMsgHnt.eFlags = TBL_BOXPTR; - UpdateTblFlds( &aMsgHnt ); + getIDocumentFieldsAccess().UpdateTblFlds( &aMsgHnt ); if( pTblNd->GetTable().Merge( this, aBoxes, aMerged, pMergeBox, pUndo )) { nRet = TBLMERGE_OK; SetModified(); - SetFieldsDirty( true, NULL, 0 ); + getIDocumentFieldsAccess().SetFieldsDirty( true, NULL, 0 ); if( pUndo ) { GetIDocumentUndoRedo().AppendUndo( pUndo ); @@ -3125,7 +3126,7 @@ bool SwDoc::SplitTable( const SwPosition& rPos, sal_uInt16 eHdlnMode, OUString sNewTblNm( GetUniqueTblName() ); aMsgHnt.DATA.pNewTblNm = &sNewTblNm; aMsgHnt.eFlags = TBL_SPLITTBL; - UpdateTblFlds( &aMsgHnt ); + getIDocumentFieldsAccess().UpdateTblFlds( &aMsgHnt ); } // Find Lines for the Layout update @@ -3222,7 +3223,7 @@ bool SwDoc::SplitTable( const SwPosition& rPos, sal_uInt16 eHdlnMode, // TL_CHART2: need to inform chart of probably changed cell names UpdateCharts( rTbl.GetFrmFmt()->GetName() ); - SetFieldsDirty( true, NULL, 0 ); + getIDocumentFieldsAccess().SetFieldsDirty( true, NULL, 0 ); return 0 != pNew; } @@ -3478,7 +3479,7 @@ bool SwDoc::MergeTable( const SwPosition& rPos, bool bWithPrev, sal_uInt16 nMode aMsgHnt.DATA.pDelTbl = &pDelTblNd->GetTable(); aMsgHnt.eFlags = TBL_MERGETBL; aMsgHnt.pHistory = pHistory; - UpdateTblFlds( &aMsgHnt ); + getIDocumentFieldsAccess().UpdateTblFlds( &aMsgHnt ); // The actual merge SwNodeIndex aIdx( bWithPrev ? *pTblNd : *pDelTblNd ); @@ -3493,7 +3494,7 @@ bool SwDoc::MergeTable( const SwPosition& rPos, bool bWithPrev, sal_uInt16 nMode if( bRet ) { SetModified(); - SetFieldsDirty( true, NULL, 0 ); + getIDocumentFieldsAccess().SetFieldsDirty( true, NULL, 0 ); } return bRet; } @@ -3766,7 +3767,7 @@ bool SwDoc::SetTableAutoFmt( const SwSelBoxes& rBoxes, const SwTableAutoFmt& rNe } SetModified(); - SetFieldsDirty( true, NULL, 0 ); + getIDocumentFieldsAccess().SetFieldsDirty( true, NULL, 0 ); return true; } @@ -3921,7 +3922,7 @@ bool SwDoc::SetColRowWidthHeight( SwTableBox& rAktBox, sal_uInt16 eType, SwTableFmlUpdate aMsgHnt( &pTblNd->GetTable() ); aMsgHnt.eFlags = TBL_BOXPTR; - UpdateTblFlds( &aMsgHnt ); + getIDocumentFieldsAccess().UpdateTblFlds( &aMsgHnt ); bool const bUndo(GetIDocumentUndoRedo().DoesUndo()); bool bRet = false; @@ -3957,7 +3958,7 @@ bool SwDoc::SetColRowWidthHeight( SwTableBox& rAktBox, sal_uInt16 eType, { SetModified(); if( nsTblChgWidthHeightType::WH_FLAG_INSDEL & eType ) - SetFieldsDirty( true, NULL, 0 ); + getIDocumentFieldsAccess().SetFieldsDirty( true, NULL, 0 ); } return bRet; } @@ -4093,7 +4094,7 @@ void SwDoc::ChkBoxNumFmt( SwTableBox& rBox, bool bCallUpdate ) if( bCallUpdate ) { SwTableFmlUpdate aTblUpdate( &pTblNd->GetTable() ); - UpdateTblFlds( &aTblUpdate ); + getIDocumentFieldsAccess().UpdateTblFlds( &aTblUpdate ); // TL_CHART2: update charts (when cursor leaves cell and // automatic update is enabled) @@ -4365,7 +4366,7 @@ bool SwDoc::InsCopyOfTbl( SwPosition& rInsPos, const SwSelBoxes& rBoxes, if( bRet ) { SetModified(); - SetFieldsDirty( true, NULL, 0 ); + getIDocumentFieldsAccess().SetFieldsDirty( true, NULL, 0 ); } return bRet; } diff --git a/sw/source/core/docnode/node.cxx b/sw/source/core/docnode/node.cxx index 8d31f7f0d3a0..16e04f73af52 100644 --- a/sw/source/core/docnode/node.cxx +++ b/sw/source/core/docnode/node.cxx @@ -1919,8 +1919,8 @@ const IDocumentLayoutAccess* SwNode::getIDocumentLayoutAccess() const { return G IDocumentLayoutAccess* SwNode::getIDocumentLayoutAccess() { return GetDoc(); } const IDocumentLinksAdministration* SwNode::getIDocumentLinksAdministration() const { return &GetDoc()->getIDocumentLinksAdministration(); } IDocumentLinksAdministration* SwNode::getIDocumentLinksAdministration() { return &GetDoc()->getIDocumentLinksAdministration(); } -const IDocumentFieldsAccess* SwNode::getIDocumentFieldsAccess() const { return GetDoc(); } -IDocumentFieldsAccess* SwNode::getIDocumentFieldsAccess() { return GetDoc(); } +const IDocumentFieldsAccess* SwNode::getIDocumentFieldsAccess() const { return &GetDoc()->getIDocumentFieldsAccess(); } +IDocumentFieldsAccess* SwNode::getIDocumentFieldsAccess() { return &GetDoc()->getIDocumentFieldsAccess(); } IDocumentContentOperations* SwNode::getIDocumentContentOperations() { return &GetDoc()->getIDocumentContentOperations(); } IDocumentListItems& SwNode::getIDocumentListItems() { return GetDoc()->getIDocumentListItems(); } // #i83479# diff --git a/sw/source/core/docnode/nodedump.cxx b/sw/source/core/docnode/nodedump.cxx index 23f61fb3e24f..b5267ef84833 100644 --- a/sw/source/core/docnode/nodedump.cxx +++ b/sw/source/core/docnode/nodedump.cxx @@ -11,6 +11,7 @@ #include "drawdoc.hxx" #include <IDocumentDrawModelAccess.hxx> #include <IDocumentRedlineAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <UndoManager.hxx> #include "ndtxt.hxx" #include "MarkManager.hxx" @@ -184,7 +185,7 @@ void SwDoc::dumpAsXml( xmlTextWriterPtr w ) m_pNodes->dumpAsXml( writer ); mpMarkManager->dumpAsXml( writer ); m_pUndoManager->dumpAsXml(writer); - mpFldTypes->dumpAsXml( writer ); + getIDocumentFieldsAccess().GetFldTypes()->dumpAsXml( writer ); mpTxtFmtCollTbl->dumpAsXml( writer ); mpCharFmtTbl->dumpAsXml( writer ); mpFrmFmtTbl->dumpAsXml( writer, "frmFmtTbl" ); @@ -242,7 +243,7 @@ void MarkManager::dumpAsXml( xmlTextWriterPtr w ) } // namespace mark } // namespace sw -void SwFldTypes::dumpAsXml( xmlTextWriterPtr w ) +void SwFldTypes::dumpAsXml( xmlTextWriterPtr w ) const { WriterHelper writer(w); writer.startElement("swfldtypes"); diff --git a/sw/source/core/docnode/nodes.cxx b/sw/source/core/docnode/nodes.cxx index 032ddd5cb8ba..140f2b12c142 100644 --- a/sw/source/core/docnode/nodes.cxx +++ b/sw/source/core/docnode/nodes.cxx @@ -22,6 +22,7 @@ #include <node.hxx> #include <doc.hxx> #include <IDocumentUndoRedo.hxx> +#include <IDocumentFieldsAccess.hxx> #include <pam.hxx> #include <txtfld.hxx> #include <fmtfld.hxx> @@ -118,9 +119,9 @@ void SwNodes::ChgNode( SwNodeIndex& rDelPos, sal_uLong nSz, // declare all fields as invalid, updating will happen // in the idle-handler of the doc - if( GetDoc()->SetFieldsDirty( true, &rDelPos.GetNode(), nSz ) && + if( GetDoc()->getIDocumentFieldsAccess().SetFieldsDirty( true, &rDelPos.GetNode(), nSz ) && rNds.GetDoc() != GetDoc() ) - rNds.GetDoc()->SetFieldsDirty( true, NULL, 0 ); + rNds.GetDoc()->getIDocumentFieldsAccess().SetFieldsDirty( true, NULL, 0 ); // NEVER include nodes from the RedLineArea sal_uLong nNd = rInsPos.GetIndex(); @@ -268,7 +269,7 @@ void SwNodes::ChgNode( SwNodeIndex& rDelPos, sal_uLong nSz, case RES_TXTATR_INPUTFIELD: { SwTxtFld* pTxtFld = static_cast<SwTxtFld*>(pAttr); - rNds.GetDoc()->InsDelFldInFldLst( !bToUndo, *pTxtFld ); + rNds.GetDoc()->getIDocumentFieldsAccess().InsDelFldInFldLst( !bToUndo, *pTxtFld ); const SwFieldType* pTyp = pTxtFld->GetFmtFld().GetField()->GetTyp(); if ( RES_POSTITFLD == pTyp->Which() ) @@ -345,9 +346,9 @@ void SwNodes::ChgNode( SwNodeIndex& rDelPos, sal_uLong nSz, // declare all fields as invalid, updating will happen // in the idle-handler of the doc - GetDoc()->SetFieldsDirty( true, NULL, 0 ); + GetDoc()->getIDocumentFieldsAccess().SetFieldsDirty( true, NULL, 0 ); if( rNds.GetDoc() != GetDoc() ) - rNds.GetDoc()->SetFieldsDirty( true, NULL, 0 ); + rNds.GetDoc()->getIDocumentFieldsAccess().SetFieldsDirty( true, NULL, 0 ); if( bNewFrms ) bNewFrms = &GetDoc()->GetNodes() == (const SwNodes*)&rNds && diff --git a/sw/source/core/docnode/section.cxx b/sw/source/core/docnode/section.cxx index 0e570565dec2..feefc0ec7473 100644 --- a/sw/source/core/docnode/section.cxx +++ b/sw/source/core/docnode/section.cxx @@ -36,6 +36,7 @@ #include <DocumentLinksAdministrationManager.hxx> #include <DocumentContentOperationsManager.hxx> #include <IDocumentRedlineAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <node.hxx> #include <pam.hxx> #include <frmtool.hxx> @@ -1194,7 +1195,7 @@ static void lcl_UpdateLinksInSect( SwBaseLink& rUpdLnk, SwSectionNode& rSectNd ) SwPaM* pPam; SwViewShell* pVSh = 0; SwEditShell* pESh = pDoc->GetEditShell( &pVSh ); - pDoc->LockExpFlds(); + pDoc->getIDocumentFieldsAccess().LockExpFlds(); { // Insert an empty TextNode at the Section's start SwNodeIndex aIdx( *pSectNd, +1 ); @@ -1419,9 +1420,9 @@ static void lcl_UpdateLinksInSect( SwBaseLink& rUpdLnk, SwSectionNode& rSectNd ) pDoc->GetIDocumentUndoRedo().DoUndo(bWasUndo); pDoc->getIDocumentLinksAdministration().SetVisibleLinks( bWasVisibleLinks ); - pDoc->UnlockExpFlds(); - if( !pDoc->IsExpFldsLocked() ) - pDoc->UpdateExpFlds(NULL, true); + pDoc->getIDocumentFieldsAccess().UnlockExpFlds(); + if( !pDoc->getIDocumentFieldsAccess().IsExpFldsLocked() ) + pDoc->getIDocumentFieldsAccess().UpdateExpFlds(NULL, true); if( pESh ) pESh->EndAllAction(); diff --git a/sw/source/core/edit/edfld.cxx b/sw/source/core/edit/edfld.cxx index cf95961d7266..d25a72f2da33 100644 --- a/sw/source/core/edit/edfld.cxx +++ b/sw/source/core/edit/edfld.cxx @@ -23,6 +23,7 @@ #include <editsh.hxx> #include <fldbas.hxx> #include <doc.hxx> +#include <IDocumentFieldsAccess.hxx> #include <docary.hxx> #include <fmtfld.hxx> #include <txtfld.hxx> @@ -42,7 +43,7 @@ /// count field types with a ResId, if 0 count all sal_uInt16 SwEditShell::GetFldTypeCount(sal_uInt16 nResId, bool bUsed ) const { - const SwFldTypes* pFldTypes = GetDoc()->GetFldTypes(); + const SwFldTypes* pFldTypes = GetDoc()->getIDocumentFieldsAccess().GetFldTypes(); const sal_uInt16 nSize = pFldTypes->size(); if(nResId == USHRT_MAX) @@ -75,7 +76,7 @@ sal_uInt16 SwEditShell::GetFldTypeCount(sal_uInt16 nResId, bool bUsed ) const /// get field types with a ResId, if 0 get all SwFieldType* SwEditShell::GetFldType(sal_uInt16 nFld, sal_uInt16 nResId, bool bUsed ) const { - const SwFldTypes* pFldTypes = GetDoc()->GetFldTypes(); + const SwFldTypes* pFldTypes = GetDoc()->getIDocumentFieldsAccess().GetFldTypes(); const sal_uInt16 nSize = pFldTypes->size(); if(nResId == USHRT_MAX && nFld < nSize) @@ -118,7 +119,7 @@ SwFieldType* SwEditShell::GetFldType(sal_uInt16 nFld, sal_uInt16 nResId, bool bU /// get first type with given ResId and name SwFieldType* SwEditShell::GetFldType(sal_uInt16 nResId, const OUString& rName) const { - return GetDoc()->GetFldType( nResId, rName, false ); + return GetDoc()->getIDocumentFieldsAccess().GetFldType( nResId, rName, false ); } /// delete field type @@ -126,11 +127,11 @@ void SwEditShell::RemoveFldType(sal_uInt16 nFld, sal_uInt16 nResId) { if( USHRT_MAX == nResId ) { - GetDoc()->RemoveFldType(nFld); + GetDoc()->getIDocumentFieldsAccess().RemoveFldType(nFld); return; } - const SwFldTypes* pFldTypes = GetDoc()->GetFldTypes(); + const SwFldTypes* pFldTypes = GetDoc()->getIDocumentFieldsAccess().GetFldTypes(); const sal_uInt16 nSize = pFldTypes->size(); sal_uInt16 nIdx = 0; for( sal_uInt16 i = 0; i < nSize; ++i ) @@ -138,7 +139,7 @@ void SwEditShell::RemoveFldType(sal_uInt16 nFld, sal_uInt16 nResId) if( (*pFldTypes)[i]->Which() == nResId && nIdx++ == nFld ) { - GetDoc()->RemoveFldType( i ); + GetDoc()->getIDocumentFieldsAccess().RemoveFldType( i ); return; } } @@ -146,7 +147,7 @@ void SwEditShell::RemoveFldType(sal_uInt16 nFld, sal_uInt16 nResId) /// delete field type based on its name void SwEditShell::RemoveFldType(sal_uInt16 nResId, const OUString& rStr) { - const SwFldTypes* pFldTypes = GetDoc()->GetFldTypes(); + const SwFldTypes* pFldTypes = GetDoc()->getIDocumentFieldsAccess().GetFldTypes(); const sal_uInt16 nSize = pFldTypes->size(); const CharClass& rCC = GetAppCharClass(); @@ -160,7 +161,7 @@ void SwEditShell::RemoveFldType(sal_uInt16 nResId, const OUString& rStr) { if( aTmp == rCC.lowercase( pFldType->GetName() ) ) { - GetDoc()->RemoveFldType(i); + GetDoc()->getIDocumentFieldsAccess().RemoveFldType(i); return; } } @@ -270,7 +271,7 @@ void SwEditShell::UpdateFlds( SwField &rFld ) pTxtFld = lcl_FindInputFld( GetDoc(), rFld); if (pTxtFld != 0) - GetDoc()->UpdateFld(pTxtFld, rFld, pMsgHnt, true); + GetDoc()->getIDocumentFieldsAccess().UpdateFld(pTxtFld, rFld, pMsgHnt, true); } // bOkay (instead of return because of EndAllAction) becomes false, @@ -318,7 +319,7 @@ void SwEditShell::UpdateFlds( SwField &rFld ) rFld.GetTyp()->Which() ) bOkay = false; - bTblSelBreak = GetDoc()->UpdateFld(pTxtFld, rFld, + bTblSelBreak = GetDoc()->getIDocumentFieldsAccess().UpdateFld(pTxtFld, rFld, pMsgHnt, false); } // The search area is reduced by the found area: @@ -367,7 +368,7 @@ void SwEditShell::UpdateExpFlds(bool bCloseDB) { SET_CURR_SHELL( this ); StartAllAction(); - GetDoc()->UpdateExpFlds(NULL, true); + GetDoc()->getIDocumentFieldsAccess().UpdateExpFlds(NULL, true); if (bCloseDB) { #if HAVE_FEATURE_DBCONNECTIVITY @@ -389,17 +390,17 @@ SwDBManager* SwEditShell::GetDBManager() const /// insert field type SwFieldType* SwEditShell::InsertFldType(const SwFieldType& rFldType) { - return GetDoc()->InsertFldType(rFldType); + return GetDoc()->getIDocumentFieldsAccess().InsertFldType(rFldType); } void SwEditShell::LockExpFlds() { - GetDoc()->LockExpFlds(); + GetDoc()->getIDocumentFieldsAccess().LockExpFlds(); } void SwEditShell::UnlockExpFlds() { - GetDoc()->UnlockExpFlds(); + GetDoc()->getIDocumentFieldsAccess().UnlockExpFlds(); } void SwEditShell::SetFldUpdateFlags( SwFldUpdateFlags eFlags ) @@ -429,7 +430,7 @@ void SwEditShell::ChangeAuthorityData(const SwAuthEntry* pNewData) bool SwEditShell::IsAnyDatabaseFieldInDoc()const { - const SwFldTypes * pFldTypes = GetDoc()->GetFldTypes(); + const SwFldTypes * pFldTypes = GetDoc()->getIDocumentFieldsAccess().GetFldTypes(); const sal_uInt16 nSize = pFldTypes->size(); for(sal_uInt16 i = 0; i < nSize; ++i) { diff --git a/sw/source/core/edit/edfldexp.cxx b/sw/source/core/edit/edfldexp.cxx index e24e66b67db4..86e3a1b7e14d 100644 --- a/sw/source/core/edit/edfldexp.cxx +++ b/sw/source/core/edit/edfldexp.cxx @@ -25,6 +25,7 @@ #include <com/sun/star/lang/XMultiServiceFactory.hpp> #include <com/sun/star/sdb/DatabaseContext.hpp> #include <doc.hxx> +#include <IDocumentFieldsAccess.hxx> #include <docary.hxx> #include <txtfld.hxx> #include <fmtfld.hxx> @@ -36,7 +37,7 @@ using namespace com::sun::star; bool SwEditShell::IsFieldDataSourceAvailable(OUString& rUsedDataSource) const { - const SwFldTypes * pFldTypes = GetDoc()->GetFldTypes(); + const SwFldTypes * pFldTypes = GetDoc()->getIDocumentFieldsAccess().GetFldTypes(); const sal_uInt16 nSize = pFldTypes->size(); uno::Reference<uno::XComponentContext> xContext( ::comphelper::getProcessComponentContext() ); uno::Reference<sdb::XDatabaseContext> xDBContext = sdb::DatabaseContext::create(xContext); diff --git a/sw/source/core/edit/edglss.cxx b/sw/source/core/edit/edglss.cxx index e3ab17944f7d..755a4892562c 100644 --- a/sw/source/core/edit/edglss.cxx +++ b/sw/source/core/edit/edglss.cxx @@ -23,6 +23,7 @@ #include <svl/urihelper.hxx> #include <doc.hxx> #include <IDocumentRedlineAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <pam.hxx> #include <docary.hxx> #include <editsh.hxx> @@ -176,7 +177,7 @@ bool SwEditShell::_CopySelToDoc( SwDoc* pInsDoc, SwNodeIndex* pSttNd ) bool bRet = false; SET_CURR_SHELL( this ); - pInsDoc->LockExpFlds(); + pInsDoc->getIDocumentFieldsAccess().LockExpFlds(); if( IsTableMode() ) { @@ -249,9 +250,9 @@ bool SwEditShell::_CopySelToDoc( SwDoc* pInsDoc, SwNodeIndex* pSttNd ) } } - pInsDoc->UnlockExpFlds(); - if( !pInsDoc->IsExpFldsLocked() ) - pInsDoc->UpdateExpFlds(NULL, true); + pInsDoc->getIDocumentFieldsAccess().UnlockExpFlds(); + if( !pInsDoc->getIDocumentFieldsAccess().IsExpFldsLocked() ) + pInsDoc->getIDocumentFieldsAccess().UpdateExpFlds(NULL, true); // set the saved Node position back to the correct Node if( bRet && pSttNd ) diff --git a/sw/source/core/edit/editsh.cxx b/sw/source/core/edit/editsh.cxx index 4db32ab381e5..be5174f694dc 100644 --- a/sw/source/core/edit/editsh.cxx +++ b/sw/source/core/edit/editsh.cxx @@ -33,6 +33,7 @@ #include <IDocumentUndoRedo.hxx> #include <IDocumentSettingAccess.hxx> #include <IDocumentLinksAdministration.hxx> +#include <IDocumentFieldsAccess.hxx> #include <docary.hxx> #include <editsh.hxx> #include <frame.hxx> @@ -565,7 +566,7 @@ OUString SwEditShell::Calculate() { if( !bValidFlds ) { - GetDoc()->FldsToCalc( aCalc, + GetDoc()->getIDocumentFieldsAccess().FldsToCalc( aCalc, pStart->nNode.GetIndex(), pStart->nContent.GetIndex() ); bValidFlds = true; diff --git a/sw/source/core/edit/edtab.cxx b/sw/source/core/edit/edtab.cxx index 145d565565d3..7e95ed4f5076 100644 --- a/sw/source/core/edit/edtab.cxx +++ b/sw/source/core/edit/edtab.cxx @@ -32,6 +32,7 @@ #include <doc.hxx> #include <IDocumentUndoRedo.hxx> #include <IDocumentChartDataProviderAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <cntfrm.hxx> #include <pam.hxx> #include <ndtxt.hxx> @@ -253,7 +254,7 @@ void SwEditShell::UpdateTable() StartUndo(); EndAllTblBoxEdit(); SwTableFmlUpdate aTblUpdate( (SwTable*)&pTblNd->GetTable() ); - GetDoc()->UpdateTblFlds( &aTblUpdate ); + GetDoc()->getIDocumentFieldsAccess().UpdateTblFlds( &aTblUpdate ); if( DoesUndo() ) EndUndo(); EndAllAction(); @@ -319,7 +320,7 @@ bool SwEditShell::GetTblBoxFormulaAttrs( SfxItemSet& rSet ) const SwTableFmlUpdate aTblUpdate( (SwTable*)&rTbl ); aTblUpdate.eFlags = TBL_BOXNAME; - ((SwDoc*)GetDoc())->UpdateTblFlds( &aTblUpdate ); + ((SwDoc*)GetDoc())->getIDocumentFieldsAccess().UpdateTblFlds( &aTblUpdate ); rSet.Put( pTblFmt->GetAttrSet() ); } diff --git a/sw/source/core/fields/authfld.cxx b/sw/source/core/fields/authfld.cxx index 2eff387c12a6..3a4bb733ce64 100644 --- a/sw/source/core/fields/authfld.cxx +++ b/sw/source/core/fields/authfld.cxx @@ -35,6 +35,7 @@ #include <txtfld.hxx> #include <ndtxt.hxx> #include <doc.hxx> +#include <IDocumentFieldsAccess.hxx> #include <unofldmid.h> #include <unoprnms.hxx> #include <switerator.hxx> @@ -552,7 +553,7 @@ OUString SwAuthorityField::ConditionalExpand(ToxAuthorityField eField) const if( pAuthType->IsSequence() ) { - if(!pAuthType->GetDoc()->IsExpFldsLocked()) + if(!pAuthType->GetDoc()->getIDocumentFieldsAccess().IsExpFldsLocked()) m_nTempSequencePos = pAuthType->GetSequencePos( m_nHandle ); if( m_nTempSequencePos >= 0 ) sRet += OUString::number( m_nTempSequencePos ); @@ -576,7 +577,7 @@ OUString SwAuthorityField::ExpandCitation(ToxAuthorityField eField) const if( pAuthType->IsSequence() ) { - if(!pAuthType->GetDoc()->IsExpFldsLocked()) + if(!pAuthType->GetDoc()->getIDocumentFieldsAccess().IsExpFldsLocked()) m_nTempSequencePos = pAuthType->GetSequencePos( m_nHandle ); if( m_nTempSequencePos >= 0 ) sRet += OUString::number( m_nTempSequencePos ); diff --git a/sw/source/core/fields/dbfld.cxx b/sw/source/core/fields/dbfld.cxx index 0a1d8a6e1be8..9318e0927604 100644 --- a/sw/source/core/fields/dbfld.cxx +++ b/sw/source/core/fields/dbfld.cxx @@ -26,6 +26,7 @@ #include <fmtfld.hxx> #include <txtfld.hxx> #include <doc.hxx> +#include <IDocumentFieldsAccess.hxx> #include <docary.hxx> #include <frame.hxx> #include <fldbas.hxx> @@ -88,11 +89,11 @@ void SwDBFieldType::ReleaseRef() if (--nRefCnt <= 0) { - sal_uInt16 nPos = GetDoc()->GetFldTypes()->GetPos(this); + sal_uInt16 nPos = GetDoc()->getIDocumentFieldsAccess().GetFldTypes()->GetPos(this); if (nPos != USHRT_MAX) { - GetDoc()->RemoveFldType(nPos); + GetDoc()->getIDocumentFieldsAccess().RemoveFldType(nPos); delete this; } } diff --git a/sw/source/core/fields/ddetbl.cxx b/sw/source/core/fields/ddetbl.cxx index e52463e5d3b0..43e5485a0010 100644 --- a/sw/source/core/fields/ddetbl.cxx +++ b/sw/source/core/fields/ddetbl.cxx @@ -21,6 +21,7 @@ #include <frmfmt.hxx> #include <doc.hxx> #include <IDocumentSettingAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <index.hxx> #include <ndtxt.hxx> #include <swtable.hxx> @@ -133,7 +134,7 @@ void SwDDETable::ChangeContent() const IDocumentSettingAccess* pIDSA = GetFrmFmt()->getIDocumentSettingAccess(); SwDoc* pDoc = GetFrmFmt()->GetDoc(); if( AUTOUPD_FIELD_AND_CHARTS == pIDSA->getFieldUpdateFlags(true) ) - pDoc->SetFieldsDirty( true, NULL, 0 ); + pDoc->getIDocumentFieldsAccess().SetFieldsDirty( true, NULL, 0 ); } SwDDEFieldType* SwDDETable::GetDDEFldType() diff --git a/sw/source/core/fields/docufld.cxx b/sw/source/core/fields/docufld.cxx index db0fd8e7dca7..8551b87326c8 100644 --- a/sw/source/core/fields/docufld.cxx +++ b/sw/source/core/fields/docufld.cxx @@ -72,6 +72,7 @@ #include <pagedesc.hxx> #include <fmtpdsc.hxx> #include <doc.hxx> +#include <IDocumentFieldsAccess.hxx> #include <rootfrm.hxx> #include <pagefrm.hxx> #include <cntfrm.hxx> @@ -2113,7 +2114,7 @@ void SwRefPageGetFieldType::Modify( const SfxPoolItem* pOld, const SfxPoolItem* sal_uInt16 SwRefPageGetFieldType::MakeSetList( _SetGetExpFlds& rTmpLst ) { - SwIterator<SwFmtFld,SwFieldType> aIter(*pDoc->GetSysFldType( RES_REFPAGESETFLD)); + SwIterator<SwFmtFld,SwFieldType> aIter(*pDoc->getIDocumentFieldsAccess().GetSysFldType( RES_REFPAGESETFLD)); for ( SwFmtFld* pFmtFld = aIter.First(); pFmtFld; pFmtFld = aIter.Next() ) { // update only the GetRef fields diff --git a/sw/source/core/fields/expfld.cxx b/sw/source/core/fields/expfld.cxx index 0d2afb79ddcb..8433e6738531 100644 --- a/sw/source/core/fields/expfld.cxx +++ b/sw/source/core/fields/expfld.cxx @@ -35,6 +35,7 @@ #include <fmtanchr.hxx> #include <txtftn.hxx> #include <doc.hxx> +#include <IDocumentFieldsAccess.hxx> #include <layfrm.hxx> #include <pagefrm.hxx> #include <cntfrm.hxx> @@ -340,7 +341,7 @@ void SwGetExpField::ChangeExpansion( const SwFrm& rFrm, const SwTxtFld& rFld ) // #i82544# if( bLateInitialization ) { - SwFieldType* pSetExpFld = rDoc.GetFldType(RES_SETEXPFLD, GetFormula(), false); + SwFieldType* pSetExpFld = rDoc.getIDocumentFieldsAccess().GetFldType(RES_SETEXPFLD, GetFormula(), false); if( pSetExpFld ) { bLateInitialization = false; @@ -355,7 +356,7 @@ void SwGetExpField::ChangeExpansion( const SwFrm& rFrm, const SwTxtFld& rFld ) { SwHash** ppHashTbl; sal_uInt16 nSize; - rDoc.FldsToExpand( ppHashTbl, nSize, aEndFld ); + rDoc.getIDocumentFieldsAccess().FldsToExpand( ppHashTbl, nSize, aEndFld ); sExpand = LookString( ppHashTbl, nSize, GetFormula() ); ::DeleteHashTable( ppHashTbl, nSize ); } @@ -363,7 +364,7 @@ void SwGetExpField::ChangeExpansion( const SwFrm& rFrm, const SwTxtFld& rFld ) { // fill calculator with values SwCalc aCalc( rDoc ); - rDoc.FldsToCalc(aCalc, aEndFld); + rDoc.getIDocumentFieldsAccess().FldsToCalc(aCalc, aEndFld); // calculate value SetValue(aCalc.Calculate(GetFormula()).GetDouble()); @@ -1171,7 +1172,7 @@ void SwInputField::applyFieldContent( const OUString& rNewFieldContent ) else if( (nSubType & 0x00ff) == INP_USR ) { SwUserFieldType* pUserTyp = static_cast<SwUserFieldType*>( - static_cast<SwInputFieldType*>(GetTyp())->GetDoc()->GetFldType( RES_USERFLD, getContent(), false ) ); + static_cast<SwInputFieldType*>(GetTyp())->GetDoc()->getIDocumentFieldsAccess().GetFldType( RES_USERFLD, getContent(), false ) ); if( pUserTyp ) { pUserTyp->SetContent( rNewFieldContent ); @@ -1224,7 +1225,7 @@ OUString SwInputField::Expand() const if( (nSubType & 0x00ff) == INP_USR ) { SwUserFieldType* pUserTyp = static_cast<SwUserFieldType*>( - static_cast<SwInputFieldType*>(GetTyp())->GetDoc()->GetFldType( RES_USERFLD, getContent(), false ) ); + static_cast<SwInputFieldType*>(GetTyp())->GetDoc()->getIDocumentFieldsAccess().GetFldType( RES_USERFLD, getContent(), false ) ); if( pUserTyp ) return pUserTyp->GetContent(); } diff --git a/sw/source/core/fields/fldlst.cxx b/sw/source/core/fields/fldlst.cxx index eae9d35eca70..e0fd57633305 100644 --- a/sw/source/core/fields/fldlst.cxx +++ b/sw/source/core/fields/fldlst.cxx @@ -20,6 +20,7 @@ #include "switerator.hxx" #include "editsh.hxx" #include "doc.hxx" +#include <IDocumentFieldsAccess.hxx> #include <docary.hxx> #include <fmtfld.hxx> #include <txtfld.hxx> @@ -37,7 +38,7 @@ SwInputFieldList::SwInputFieldList( SwEditShell* pShell, bool bBuildTmpLst ) // create sorted list of all input fields pSrtLst = new _SetGetExpFlds(); - const SwFldTypes& rFldTypes = *pSh->GetDoc()->GetFldTypes(); + const SwFldTypes& rFldTypes = *pSh->GetDoc()->getIDocumentFieldsAccess().GetFldTypes(); const size_t nSize = rFldTypes.size(); // iterate over all types @@ -125,7 +126,7 @@ void SwInputFieldList::GotoFieldPos(size_t nId) */ bool SwInputFieldList::BuildSortLst() { - const SwFldTypes& rFldTypes = *pSh->GetDoc()->GetFldTypes(); + const SwFldTypes& rFldTypes = *pSh->GetDoc()->getIDocumentFieldsAccess().GetFldTypes(); const size_t nSize = rFldTypes.size(); // iterate over all types diff --git a/sw/source/core/fields/reffld.cxx b/sw/source/core/fields/reffld.cxx index c62db3d913c0..4741564e6609 100644 --- a/sw/source/core/fields/reffld.cxx +++ b/sw/source/core/fields/reffld.cxx @@ -25,6 +25,7 @@ #include <comphelper/string.hxx> #include <editeng/unolingu.hxx> #include <doc.hxx> +#include <IDocumentFieldsAccess.hxx> #include <pam.hxx> #include <cntfrm.hxx> #include <pagefrm.hxx> @@ -748,7 +749,7 @@ void SwGetRefField::ConvertProgrammaticToUIName() SwDoc* pDoc = ((SwGetRefFieldType*)GetTyp())->GetDoc(); const OUString rPar1 = GetPar1(); // don't convert when the name points to an existing field type - if(!pDoc->GetFldType(RES_SETEXPFLD, rPar1, false)) + if(!pDoc->getIDocumentFieldsAccess().GetFldType(RES_SETEXPFLD, rPar1, false)) { sal_uInt16 nPoolId = SwStyleNameMapper::GetPoolIdFromProgName( rPar1, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL ); sal_uInt16 nResId = USHRT_MAX; @@ -834,7 +835,7 @@ SwTxtNode* SwGetRefFieldType::FindAnchor( SwDoc* pDoc, const OUString& rRefMark, case REF_SEQUENCEFLD: { - SwFieldType* pFldType = pDoc->GetFldType( RES_SETEXPFLD, rRefMark, false ); + SwFieldType* pFldType = pDoc->getIDocumentFieldsAccess().GetFldType( RES_SETEXPFLD, rRefMark, false ); if( pFldType && pFldType->GetDepends() && nsSwGetSetExpType::GSE_SEQ & ((SwSetExpFieldType*)pFldType)->GetType() ) { @@ -948,7 +949,7 @@ typedef boost::ptr_vector<_RefIdsMap> _RefIdsMaps; /// @param[in,out] rIds The list of IDs found in the document. void _RefIdsMap::GetFieldIdsFromDoc( SwDoc& rDoc, std::set<sal_uInt16> &rIds) { - SwFieldType *const pType = rDoc.GetFldType(RES_SETEXPFLD, aName, false); + SwFieldType *const pType = rDoc.getIDocumentFieldsAccess().GetFldType(RES_SETEXPFLD, aName, false); if (!pType) return; @@ -996,7 +997,7 @@ void _RefIdsMap::Init( SwDoc& rDoc, SwDoc& rDestDoc, bool bField ) AddId( GetFirstUnusedId(aIds), *pIt ); // Change the Sequence number of all SetExp fields in the source document - SwFieldType* pType = rDoc.GetFldType( RES_SETEXPFLD, aName, false ); + SwFieldType* pType = rDoc.getIDocumentFieldsAccess().GetFldType( RES_SETEXPFLD, aName, false ); if( pType ) { SwIterator<SwFmtFld,SwFieldType> aIter( *pType ); @@ -1090,7 +1091,7 @@ void SwGetRefFieldType::MergeWithOtherDoc( SwDoc& rDestDoc ) { // when copying _to_ clipboard, expectation is that no fields exist // so no re-mapping is required to avoid collisions - assert(!rDestDoc.GetSysFldType(RES_GETREFFLD)->GetDepends()); + assert(!rDestDoc.getIDocumentFieldsAccess().GetSysFldType(RES_GETREFFLD)->GetDepends()); return; // don't modify the fields in the source doc } diff --git a/sw/source/core/fields/usrfld.cxx b/sw/source/core/fields/usrfld.cxx index b58306a5c0d9..760167644647 100644 --- a/sw/source/core/fields/usrfld.cxx +++ b/sw/source/core/fields/usrfld.cxx @@ -26,6 +26,7 @@ #include <calc.hxx> #include <usrfld.hxx> #include <doc.hxx> +#include <IDocumentFieldsAccess.hxx> #include <IDocumentUndoRedo.hxx> #include <editsh.hxx> #include <dpage.hxx> @@ -207,7 +208,7 @@ void SwUserFieldType::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew ) if ( !IsModifyLocked() ) { LockModify(); - GetDoc()->GetSysFldType( RES_INPUTFLD )->UpdateFlds(); + GetDoc()->getIDocumentFieldsAccess().GetSysFldType( RES_INPUTFLD )->UpdateFlds(); UnlockModify(); } } diff --git a/sw/source/core/frmedt/fecopy.cxx b/sw/source/core/frmedt/fecopy.cxx index d66182b25eb5..aeea08370c87 100644 --- a/sw/source/core/frmedt/fecopy.cxx +++ b/sw/source/core/frmedt/fecopy.cxx @@ -56,6 +56,7 @@ #include <IDocumentUndoRedo.hxx> #include <IDocumentDrawModelAccess.hxx> #include <IDocumentRedlineAccess.hxx> +#include <DocumentFieldsManager.hxx> #include <rootfrm.hxx> #include <ndtxt.hxx> #include <pam.hxx> @@ -104,7 +105,7 @@ bool SwFEShell::Copy( SwDoc* pClpDoc, const OUString* pNewClpTxt ) SwFlyFrmFmt* pFly = (SwFlyFrmFmt*)(*pClpDoc->GetSpzFrmFmts())[n]; pClpDoc->DelLayoutFmt( pFly ); } - pClpDoc->GCFieldTypes(); // delete the FieldTypes + pClpDoc->GetDocumentFieldsManager().GCFieldTypes(); // delete the FieldTypes // if a string was passed, copy it to the clipboard- // document. Then also the Calculator can use the internal @@ -115,7 +116,7 @@ bool SwFEShell::Copy( SwDoc* pClpDoc, const OUString* pNewClpTxt ) return true; // das wars. } - pClpDoc->LockExpFlds(); + pClpDoc->getIDocumentFieldsAccess().LockExpFlds(); pClpDoc->getIDocumentRedlineAccess().SetRedlineMode_intern( nsRedlineMode_t::REDLINE_DELETE_REDLINES ); bool bRet; @@ -216,9 +217,9 @@ bool SwFEShell::Copy( SwDoc* pClpDoc, const OUString* pNewClpTxt ) bRet = _CopySelToDoc( pClpDoc, 0 ); // copy the selections pClpDoc->getIDocumentRedlineAccess().SetRedlineMode_intern((RedlineMode_t)0 ); - pClpDoc->UnlockExpFlds(); - if( !pClpDoc->IsExpFldsLocked() ) - pClpDoc->UpdateExpFlds(NULL, true); + pClpDoc->getIDocumentFieldsAccess().UnlockExpFlds(); + if( !pClpDoc->getIDocumentFieldsAccess().IsExpFldsLocked() ) + pClpDoc->getIDocumentFieldsAccess().UpdateExpFlds(NULL, true); return bRet; } @@ -449,7 +450,7 @@ bool SwFEShell::Copy( SwFEShell* pDestShell, const Point& rSttPt, SET_CURR_SHELL( pDestShell ); pDestShell->StartAllAction(); - pDestShell->GetDoc()->LockExpFlds(); + pDestShell->GetDoc()->getIDocumentFieldsAccess().LockExpFlds(); // Shift references bool bCopyIsMove = mpDoc->IsCopyIsMove(); @@ -463,7 +464,7 @@ bool SwFEShell::Copy( SwFEShell* pDestShell, const Point& rSttPt, // If there are table formulas in the area, then display the table first // so that the table formula can calculate a new value first // (individual boxes in the area are retrieved via the layout) - SwFieldType* pTblFldTyp = pDestShell->GetDoc()->GetSysFldType( RES_TABLEFLD ); + SwFieldType* pTblFldTyp = pDestShell->GetDoc()->getIDocumentFieldsAccess().GetSysFldType( RES_TABLEFLD ); if( IsFrmSelected() ) { @@ -654,8 +655,8 @@ bool SwFEShell::Copy( SwFEShell* pDestShell, const Point& rSttPt, for( ; nActCnt; --nActCnt ) pDestShell->StartAllAction(); } - pDestShell->GetDoc()->UnlockExpFlds(); - pDestShell->GetDoc()->UpdateFlds(NULL, false); + pDestShell->GetDoc()->getIDocumentFieldsAccess().UnlockExpFlds(); + pDestShell->GetDoc()->getIDocumentFieldsAccess().UpdateFlds(NULL, false); pDestShell->EndAllAction(); return bRet; @@ -681,7 +682,7 @@ bool SwFEShell::Paste( SwDoc* pClpDoc, bool bIncludingPageFrames ) // If there are table formulas in the area, then display the table first // so that the table formula can calculate a new value first // (individual boxes in the area are retrieved via the layout) - SwFieldType* pTblFldTyp = GetDoc()->GetSysFldType( RES_TABLEFLD ); + SwFieldType* pTblFldTyp = GetDoc()->getIDocumentFieldsAccess().GetSysFldType( RES_TABLEFLD ); SwTableNode *pDestNd, *pSrcNd = aCpyPam.GetNode().GetTableNode(); if( !pSrcNd ) // TabellenNode ? @@ -699,7 +700,7 @@ bool SwFEShell::Paste( SwDoc* pClpDoc, bool bIncludingPageFrames ) bool bRet = true, bDelTbl = true; StartAllAction(); GetDoc()->GetIDocumentUndoRedo().StartUndo( UNDO_INSGLOSSARY, NULL ); - GetDoc()->LockExpFlds(); + GetDoc()->getIDocumentFieldsAccess().LockExpFlds(); // When the clipboard content has been created by a rectangular selection // the pasting is more sophisticated: @@ -1106,8 +1107,8 @@ bool SwFEShell::Paste( SwDoc* pClpDoc, bool bIncludingPageFrames ) for( ; nActCnt; --nActCnt ) StartAllAction(); } - GetDoc()->UnlockExpFlds(); - GetDoc()->UpdateFlds(NULL, false); + GetDoc()->getIDocumentFieldsAccess().UnlockExpFlds(); + GetDoc()->getIDocumentFieldsAccess().UpdateFlds(NULL, false); EndAllAction(); return bRet; @@ -1156,7 +1157,7 @@ bool SwFEShell::PastePages( SwFEShell& rToFill, sal_uInt16 nStartPage, sal_uInt1 SET_CURR_SHELL( this ); StartAllAction(); - GetDoc()->LockExpFlds(); + GetDoc()->getIDocumentFieldsAccess().LockExpFlds(); SetSelection(aCpyPam); // copy the text of the selection SwEditShell::Copy(&rToFill); @@ -1192,8 +1193,8 @@ bool SwFEShell::PastePages( SwFEShell& rToFill, sal_uInt16 nStartPage, sal_uInt1 rToFill.GetDoc()->CopyLayoutFmt( rCpyFmt, aAnchor, true, true ); } } - GetDoc()->UnlockExpFlds(); - GetDoc()->UpdateFlds(NULL, false); + GetDoc()->getIDocumentFieldsAccess().UnlockExpFlds(); + GetDoc()->getIDocumentFieldsAccess().UpdateFlds(NULL, false); Pop(false); EndAllAction(); diff --git a/sw/source/core/inc/DocumentFieldsManager.hxx b/sw/source/core/inc/DocumentFieldsManager.hxx new file mode 100644 index 000000000000..acc1bde75cd9 --- /dev/null +++ b/sw/source/core/inc/DocumentFieldsManager.hxx @@ -0,0 +1,106 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#ifndef INCLUDED_SW_SOURCE_CORE_INC_DOCUMENTFIELDSMANAGER_HXX +#define INCLUDED_SW_SOURCE_CORE_INC_DOCUMENTFIELDSMANAGER_HXX + +#include <IDocumentFieldsAccess.hxx> +#include <boost/utility.hpp> +#include <sal/types.h> + +class SwDoc; +class SwDBNameInfField; + +namespace sw { + +class DocumentFieldsManager : public IDocumentFieldsAccess, + public ::boost::noncopyable +{ + +public: + + DocumentFieldsManager( SwDoc& i_rSwdoc ); + + virtual const SwFldTypes *GetFldTypes() const SAL_OVERRIDE; + virtual SwFieldType *InsertFldType(const SwFieldType &) SAL_OVERRIDE; + virtual SwFieldType *GetSysFldType( const sal_uInt16 eWhich ) const SAL_OVERRIDE; + virtual SwFieldType* GetFldType(sal_uInt16 nResId, const OUString& rName, bool bDbFieldMatching) const SAL_OVERRIDE; + virtual void RemoveFldType(sal_uInt16 nFld) SAL_OVERRIDE; + virtual void UpdateFlds( SfxPoolItem* pNewHt, bool bCloseDB) SAL_OVERRIDE; + virtual void InsDeletedFldType(SwFieldType &) SAL_OVERRIDE; + virtual bool PutValueToField(const SwPosition & rPos, const com::sun::star::uno::Any& rVal, sal_uInt16 nWhich) SAL_OVERRIDE; + virtual bool UpdateFld(SwTxtFld * rDstFmtFld, SwField & rSrcFld, SwMsgPoolItem * pMsgHnt, bool bUpdateTblFlds) SAL_OVERRIDE; + virtual void UpdateRefFlds(SfxPoolItem* pHt) SAL_OVERRIDE; + virtual void UpdateTblFlds(SfxPoolItem* pHt) SAL_OVERRIDE; + virtual void UpdateExpFlds(SwTxtFld* pFld, bool bUpdateRefFlds) SAL_OVERRIDE; + virtual void UpdateUsrFlds() SAL_OVERRIDE; + virtual void UpdatePageFlds(SfxPoolItem*) SAL_OVERRIDE; + virtual void LockExpFlds() SAL_OVERRIDE; + virtual void UnlockExpFlds() SAL_OVERRIDE; + virtual bool IsExpFldsLocked() const SAL_OVERRIDE; + virtual SwDocUpdtFld& GetUpdtFlds() const SAL_OVERRIDE; + virtual bool SetFieldsDirty(bool b, const SwNode* pChk, sal_uLong nLen) SAL_OVERRIDE; + virtual void SetFixFields(bool bOnlyTimeDate, const DateTime* pNewDateTime) SAL_OVERRIDE; + virtual void FldsToCalc(SwCalc& rCalc, sal_uLong nLastNd, sal_uInt16 nLastCnt) SAL_OVERRIDE; + virtual void FldsToCalc(SwCalc& rCalc, const _SetGetExpFld& rToThisFld) SAL_OVERRIDE; + virtual void FldsToExpand(SwHash**& ppTbl, sal_uInt16& rTblSize, const _SetGetExpFld& rToThisFld) SAL_OVERRIDE; + virtual bool IsNewFldLst() const SAL_OVERRIDE; + virtual void SetNewFldLst( bool bFlag) SAL_OVERRIDE; + virtual void InsDelFldInFldLst(bool bIns, const SwTxtFld& rFld) SAL_OVERRIDE; + + //Non Interface methods + + /** Returns the field at a certain position. + @param rPos position to search at + @return pointer to field at the given position or NULL in case no field is found + */ + static SwField* GetFieldAtPos(const SwPosition& rPos); + + /** Returns the field at a certain position. + @param rPos position to search at + @return pointer to field at the given position or NULL in case no field is found + */ + static SwTxtFld* GetTxtFldAtPos(const SwPosition& rPos); + + bool containsUpdatableFields(); + + // Delete all unreferenced field types. + void GCFieldTypes(); + + void _InitFieldTypes(); + + void ClearFieldTypes(); + + void UpdateDBNumFlds( SwDBNameInfField& rDBFld, SwCalc& rCalc ); + + virtual ~DocumentFieldsManager(); + +private: + + SwDoc& m_rSwdoc; + + bool mbNewFldLst; //< TRUE: Rebuild field-list. + SwDocUpdtFld *mpUpdtFlds; //< Struct for updating fields + SwFldTypes *mpFldTypes; + sal_Int8 mnLockExpFld; //< If != 0 UpdateExpFlds() has no effect! +}; + +} +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/layout/flowfrm.cxx b/sw/source/core/layout/flowfrm.cxx index 687409235738..6653210cf382 100644 --- a/sw/source/core/layout/flowfrm.cxx +++ b/sw/source/core/layout/flowfrm.cxx @@ -23,6 +23,7 @@ #include "viewimp.hxx" #include "viewopt.hxx" #include "frmtool.hxx" +#include <IDocumentFieldsAccess.hxx> #include "dcontact.hxx" #include <editeng/formatbreakitem.hxx> #include <editeng/keepitem.hxx> @@ -1935,7 +1936,7 @@ bool SwFlowFrm::MoveFwd( bool bMakePage, bool bPageBreak, bool bMoveAlways ) { SwViewShell *pSh = m_rThis.getRootFrm()->GetCurrShell(); if ( pSh && !pSh->Imp()->IsUpdateExpFlds() ) - pSh->GetDoc()->SetNewFldLst(true); // Will be done by CalcLayout() later on! + pSh->GetDoc()->getIDocumentFieldsAccess().SetNewFldLst(true); // Will be done by CalcLayout() later on! pNewPage->InvalidateSpelling(); pNewPage->InvalidateSmartTags(); @@ -2467,7 +2468,7 @@ bool SwFlowFrm::MoveBwd( bool &rbReformat ) m_rThis.Prepare( PREP_BOSS_CHGD, (const void*)pOldPage, false ); SwViewShell *pSh = m_rThis.getRootFrm()->GetCurrShell(); if ( pSh && !pSh->Imp()->IsUpdateExpFlds() ) - pSh->GetDoc()->SetNewFldLst(true); // Will be done by CalcLayout() later on + pSh->GetDoc()->getIDocumentFieldsAccess().SetNewFldLst(true); // Will be done by CalcLayout() later on pNewPage->InvalidateSpelling(); pNewPage->InvalidateSmartTags(); diff --git a/sw/source/core/layout/frmtool.cxx b/sw/source/core/layout/frmtool.cxx index 965bda821a63..49bde440469b 100644 --- a/sw/source/core/layout/frmtool.cxx +++ b/sw/source/core/layout/frmtool.cxx @@ -64,6 +64,7 @@ #include <DocumentSettingManager.hxx> #include <IDocumentTimerAccess.hxx> #include <IDocumentRedlineAccess.hxx> +#include <IDocumentFieldsAccess.hxx> //UUUU #include <svx/sdr/attribute/sdrallfillattributeshelper.hxx> @@ -1310,7 +1311,7 @@ void _InsertCnt( SwLayoutFrm *pLay, SwDoc *pDoc, // all table formulas to internal (BOXPTR) representation. SwTableFmlUpdate aMsgHnt( &pTblNode->GetTable() ); aMsgHnt.eFlags = TBL_BOXPTR; - pDoc->UpdateTblFlds( &aMsgHnt ); + pDoc->getIDocumentFieldsAccess().UpdateTblFlds( &aMsgHnt ); pTblNode->GetTable().GCLines(); pFrm = pTblNode->MakeFrm( pLay ); diff --git a/sw/source/core/layout/newfrm.cxx b/sw/source/core/layout/newfrm.cxx index 23ab1796eae6..a052114ff6cf 100644 --- a/sw/source/core/layout/newfrm.cxx +++ b/sw/source/core/layout/newfrm.cxx @@ -36,6 +36,7 @@ #include <viewopt.hxx> #include <set> #include <IDocumentSettingAccess.hxx> +#include <IDocumentFieldsAccess.hxx> SwLayVout *SwRootFrm::pVout = 0; bool SwRootFrm::bInPaint = false; diff --git a/sw/source/core/layout/pagechg.cxx b/sw/source/core/layout/pagechg.cxx index 45c3f51635ea..61488fe6af71 100644 --- a/sw/source/core/layout/pagechg.cxx +++ b/sw/source/core/layout/pagechg.cxx @@ -46,6 +46,7 @@ #include "doc.hxx" #include <IDocumentSettingAccess.hxx> #include <IDocumentDrawModelAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include "fesh.hxx" #include "dview.hxx" #include "dflyobj.hxx" @@ -1128,7 +1129,7 @@ void SwFrm::CheckPageDescs( SwPageFrm *pStart, bool bNotifyFields, SwPageFrm** p if ( bNotifyFields && (!pImp || !pImp->IsUpdateExpFlds()) ) { SwDocPosUpdate aMsgHnt( nDocPos ); - pDoc->UpdatePageFlds( &aMsgHnt ); + pDoc->getIDocumentFieldsAccess().UpdatePageFlds( &aMsgHnt ); } #if OSL_DEBUG_LEVEL > 0 @@ -1257,7 +1258,7 @@ SwPageFrm *SwFrm::InsertPage( SwPageFrm *pPrevPage, bool bFtn ) if ( !pSh || !pSh->Imp()->IsUpdateExpFlds() ) { SwDocPosUpdate aMsgHnt( pPrevPage->Frm().Top() ); - pDoc->UpdatePageFlds( &aMsgHnt ); + pDoc->getIDocumentFieldsAccess().UpdatePageFlds( &aMsgHnt ); } return pPage; } @@ -1384,7 +1385,7 @@ void SwRootFrm::RemoveSuperfluous() (!pSh || !pSh->Imp()->IsUpdateExpFlds()) ) { SwDocPosUpdate aMsgHnt( nDocPos ); - GetFmt()->GetDoc()->UpdatePageFlds( &aMsgHnt ); + GetFmt()->GetDoc()->getIDocumentFieldsAccess().UpdatePageFlds( &aMsgHnt ); } } diff --git a/sw/source/core/layout/tabfrm.cxx b/sw/source/core/layout/tabfrm.cxx index b6104eed510a..52370a428fac 100644 --- a/sw/source/core/layout/tabfrm.cxx +++ b/sw/source/core/layout/tabfrm.cxx @@ -22,6 +22,7 @@ #include "cntfrm.hxx" #include "viewsh.hxx" #include "doc.hxx" +#include <IDocumentFieldsAccess.hxx> #include "docsh.hxx" #include "viewimp.hxx" #include "swtable.hxx" @@ -3092,7 +3093,7 @@ void SwTabFrm::_UpdateAttr( const SfxPoolItem *pOld, const SfxPoolItem *pNew, if (GetFmt()->GetPageDesc().GetNumOffset()) ((SwRootFrm*)pPage->GetUpper())->SetVirtPageNum( true ); SwDocPosUpdate aMsgHnt( pPage->Frm().Top() ); - GetFmt()->GetDoc()->UpdatePageFlds( &aMsgHnt ); + GetFmt()->GetDoc()->getIDocumentFieldsAccess().UpdatePageFlds( &aMsgHnt ); } } break; diff --git a/sw/source/core/layout/wsfrm.cxx b/sw/source/core/layout/wsfrm.cxx index f30fa20d023e..8b2a905650d5 100644 --- a/sw/source/core/layout/wsfrm.cxx +++ b/sw/source/core/layout/wsfrm.cxx @@ -37,6 +37,7 @@ #include "viewopt.hxx" #include <doc.hxx> #include <IDocumentSettingAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <fesh.hxx> #include <docsh.hxx> #include <flyfrm.hxx> @@ -2027,7 +2028,7 @@ void SwCntntFrm::_UpdateAttr( const SfxPoolItem* pOld, const SfxPoolItem* pNew, if ( GetAttrSet()->GetPageDesc().GetNumOffset() ) ((SwRootFrm*)pPage->GetUpper())->SetVirtPageNum( true ); SwDocPosUpdate aMsgHnt( pPage->Frm().Top() ); - pPage->GetFmt()->GetDoc()->UpdatePageFlds( &aMsgHnt ); + pPage->GetFmt()->GetDoc()->getIDocumentFieldsAccess().UpdatePageFlds( &aMsgHnt ); } break; diff --git a/sw/source/core/table/swtable.cxx b/sw/source/core/table/swtable.cxx index 0604a623665f..2237de6e5fd0 100644 --- a/sw/source/core/table/swtable.cxx +++ b/sw/source/core/table/swtable.cxx @@ -36,6 +36,7 @@ #include <doc.hxx> #include <IDocumentLinksAdministration.hxx> #include <IDocumentRedlineAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <docary.hxx> #include <frame.hxx> #include <swtable.hxx> @@ -2200,7 +2201,7 @@ void SwTableBoxFmt::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew ) // something changed and some BoxAttribut remained in the set! if( pNewFmt || pNewFml || pNewVal ) { - GetDoc()->SetFieldsDirty(true, NULL, 0); + GetDoc()->getIDocumentFieldsAccess().SetFieldsDirty(true, NULL, 0); if( SFX_ITEM_SET == GetItemState( RES_BOXATR_FORMAT, false ) || SFX_ITEM_SET == GetItemState( RES_BOXATR_VALUE, false ) || diff --git a/sw/source/core/text/txtfrm.cxx b/sw/source/core/text/txtfrm.cxx index 9da12567a6a6..9c72fc8df542 100644 --- a/sw/source/core/text/txtfrm.cxx +++ b/sw/source/core/text/txtfrm.cxx @@ -33,6 +33,7 @@ #include <doc.hxx> #include <IDocumentSettingAccess.hxx> #include <IDocumentDeviceAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include "rootfrm.hxx" #include <pagefrm.hxx> #include <viewsh.hxx> diff --git a/sw/source/core/txtnode/atrfld.cxx b/sw/source/core/txtnode/atrfld.cxx index 7329b879dcb8..3e06ec99fe8b 100644 --- a/sw/source/core/txtnode/atrfld.cxx +++ b/sw/source/core/txtnode/atrfld.cxx @@ -550,7 +550,7 @@ void SwTxtInputFld::UpdateFieldContent() { const_cast<SwInputField*>(pInputFld)->applyFieldContent( aNewFieldContent ); // trigger update of fields for scenarios in which the Input Field's content is part of e.g. a table formula - GetTxtNode().GetDoc()->GetUpdtFlds().SetFieldsDirty(true); + GetTxtNode().GetDoc()->getIDocumentFieldsAccess().GetUpdtFlds().SetFieldsDirty(true); } } } diff --git a/sw/source/core/txtnode/thints.cxx b/sw/source/core/txtnode/thints.cxx index 49a260f332af..23b661ea7676 100644 --- a/sw/source/core/txtnode/thints.cxx +++ b/sw/source/core/txtnode/thints.cxx @@ -53,6 +53,7 @@ #include <breakit.hxx> #include <doc.hxx> #include <IDocumentUndoRedo.hxx> +#include <IDocumentFieldsAccess.hxx> #include <fldbas.hxx> #include <pam.hxx> #include <ndtxt.hxx> @@ -1159,8 +1160,8 @@ void SwTxtNode::DestroyAttr( SwTxtAttr* pAttr ) case RES_HIDDENTXTFLD: case RES_DBNUMSETFLD: case RES_DBNEXTSETFLD: - if( !pDoc->IsNewFldLst() && GetNodes().IsDocNodes() ) - pDoc->InsDelFldInFldLst( false, *(SwTxtFld*)pAttr ); + if( !pDoc->getIDocumentFieldsAccess().IsNewFldLst() && GetNodes().IsDocNodes() ) + pDoc->getIDocumentFieldsAccess().InsDelFldInFldLst( false, *(SwTxtFld*)pAttr ); break; case RES_DDEFLD: if( GetNodes().IsDocNodes() && @@ -3020,7 +3021,7 @@ bool SwpHints::TryInsertHint( SwDoc* pDoc = rNode.GetDoc(); const SwField* pFld = ((SwTxtFld*)pHint)->GetFmtFld().GetField(); - if( !pDoc->IsNewFldLst() ) + if( !pDoc->getIDocumentFieldsAccess().IsNewFldLst() ) { // was fuer ein Feld ist es denn ?? // bestimmte Felder mussen am Doc das Calculations-Flag updaten @@ -3034,9 +3035,9 @@ bool SwpHints::TryInsertHint( case RES_DBNEXTSETFLD: { if( bDelFirst ) - pDoc->InsDelFldInFldLst( false, *(SwTxtFld*)pHint ); + pDoc->getIDocumentFieldsAccess().InsDelFldInFldLst( false, *(SwTxtFld*)pHint ); if( rNode.GetNodes().IsDocNodes() ) - pDoc->InsDelFldInFldLst( true, *(SwTxtFld*)pHint ); + pDoc->getIDocumentFieldsAccess().InsDelFldInFldLst( true, *(SwTxtFld*)pHint ); } break; case RES_DDEFLD: @@ -3059,7 +3060,7 @@ bool SwpHints::TryInsertHint( // bevor die ReferenzNummer gesetzt wird, sollte // das Feld am richtigen FeldTypen haengen! SwSetExpFieldType* pFldType = (SwSetExpFieldType*) - pDoc->InsertFldType( *pFld->GetTyp() ); + pDoc->getIDocumentFieldsAccess().InsertFldType( *pFld->GetTyp() ); if( pFldType != pFld->GetTyp() ) { SwFmtFld* pFmtFld = (SwFmtFld*)&((SwTxtFld*)pHint)->GetFmtFld(); @@ -3074,7 +3075,7 @@ bool SwpHints::TryInsertHint( break; case RES_DDEFLD: - if( pDoc->IsNewFldLst() ) + if( pDoc->getIDocumentFieldsAccess().IsNewFldLst() ) ((SwDDEFieldType*)pFld->GetTyp())->IncRefCnt(); bInsFldType = ((SwDDEFieldType*)pFld->GetTyp())->IsDeleted(); break; @@ -3085,7 +3086,7 @@ bool SwpHints::TryInsertHint( break; } if( bInsFldType ) - pDoc->InsDeletedFldType( *pFld->GetTyp() ); + pDoc->getIDocumentFieldsAccess().InsDeletedFldType( *pFld->GetTyp() ); } } break; diff --git a/sw/source/core/txtnode/txtedt.cxx b/sw/source/core/txtnode/txtedt.cxx index 3a02a7ad709f..57706917bfc8 100644 --- a/sw/source/core/txtnode/txtedt.cxx +++ b/sw/source/core/txtnode/txtedt.cxx @@ -106,7 +106,7 @@ lcl_MaskRedlines( const SwTxtNode& rNode, OUStringBuffer& rText, const SwDoc& rDoc = *rNode.GetDoc(); - for ( size_t nAct = rDoc.GetRedlinePos( rNode, USHRT_MAX ); nAct < rDoc.getIDocumentRedlineAccess().GetRedlineTbl().size(); ++nAct ) + for ( size_t nAct = rDoc.getIDocumentRedlineAccess().GetRedlinePos( rNode, USHRT_MAX ); nAct < rDoc.getIDocumentRedlineAccess().GetRedlineTbl().size(); ++nAct ) { const SwRangeRedline* pRed = rDoc.getIDocumentRedlineAccess().GetRedlineTbl()[ nAct ]; diff --git a/sw/source/core/undo/SwUndoField.cxx b/sw/source/core/undo/SwUndoField.cxx index 738df46bb7d8..7c11c9bef538 100644 --- a/sw/source/core/undo/SwUndoField.cxx +++ b/sw/source/core/undo/SwUndoField.cxx @@ -23,6 +23,7 @@ #include <swundo.hxx> #include <doc.hxx> #include <IDocumentUndoRedo.hxx> +#include <DocumentFieldsManager.hxx> #include <txtfld.hxx> #include <fldbas.hxx> #include <ndtxt.hxx> @@ -77,26 +78,26 @@ SwUndoFieldFromDoc::~SwUndoFieldFromDoc() void SwUndoFieldFromDoc::UndoImpl(::sw::UndoRedoContext &) { - SwTxtFld * pTxtFld = SwDoc::GetTxtFldAtPos(GetPosition()); + SwTxtFld * pTxtFld = sw::DocumentFieldsManager::GetTxtFldAtPos(GetPosition()); const SwField * pField = pTxtFld ? pTxtFld->GetFmtFld().GetField() : NULL; if (pField) { - pDoc->UpdateFld(pTxtFld, *pOldField, pHnt, bUpdate); + pDoc->getIDocumentFieldsAccess().UpdateFld(pTxtFld, *pOldField, pHnt, bUpdate); } } void SwUndoFieldFromDoc::DoImpl() { - SwTxtFld * pTxtFld = SwDoc::GetTxtFldAtPos(GetPosition()); + SwTxtFld * pTxtFld = sw::DocumentFieldsManager::GetTxtFldAtPos(GetPosition()); const SwField * pField = pTxtFld ? pTxtFld->GetFmtFld().GetField() : NULL; if (pField) { - pDoc->UpdateFld(pTxtFld, *pNewField, pHnt, bUpdate); + pDoc->getIDocumentFieldsAccess().UpdateFld(pTxtFld, *pNewField, pHnt, bUpdate); SwFmtFld* pDstFmtFld = (SwFmtFld*)&pTxtFld->GetFmtFld(); - if ( pDoc->GetFldType(RES_POSTITFLD, aEmptyOUStr, false) == pDstFmtFld->GetField()->GetTyp() ) + if ( pDoc->getIDocumentFieldsAccess().GetFldType(RES_POSTITFLD, aEmptyOUStr, false) == pDstFmtFld->GetField()->GetTyp() ) pDoc->GetDocShell()->Broadcast( SwFmtFldHint( pDstFmtFld, SWFMTFLD_INSERTED ) ); } } @@ -125,7 +126,7 @@ SwUndoFieldFromAPI::~SwUndoFieldFromAPI() void SwUndoFieldFromAPI::UndoImpl(::sw::UndoRedoContext &) { - SwField * pField = SwDoc::GetFieldAtPos(GetPosition()); + SwField * pField = sw::DocumentFieldsManager::GetFieldAtPos(GetPosition()); if (pField) pField->PutValue(aOldVal, nWhich); @@ -133,7 +134,7 @@ void SwUndoFieldFromAPI::UndoImpl(::sw::UndoRedoContext &) void SwUndoFieldFromAPI::DoImpl() { - SwField * pField = SwDoc::GetFieldAtPos(GetPosition()); + SwField * pField = sw::DocumentFieldsManager::GetFieldAtPos(GetPosition()); if (pField) pField->PutValue(aNewVal, nWhich); diff --git a/sw/source/core/undo/rolbck.cxx b/sw/source/core/undo/rolbck.cxx index 96a229ff231e..41675082886e 100644 --- a/sw/source/core/undo/rolbck.cxx +++ b/sw/source/core/undo/rolbck.cxx @@ -40,6 +40,7 @@ #include <ftnidx.hxx> #include <doc.hxx> #include <IDocumentUndoRedo.hxx> +#include <IDocumentFieldsAccess.hxx> #include <docary.hxx> #include <ndtxt.hxx> #include <paratr.hxx> @@ -266,7 +267,7 @@ SwHistorySetTxtFld::SwHistorySetTxtFld( SwTxtFld* pTxtFld, sal_uLong nNodePos ) m_nFldWhich == RES_USERFLD || m_nFldWhich == RES_SETEXPFLD || m_nFldWhich == RES_DDEFLD || - !pDoc->GetSysFldType( m_nFldWhich )) + !pDoc->getIDocumentFieldsAccess().GetSysFldType( m_nFldWhich )) { m_pFldType.reset( m_pFld->GetField()->GetTyp()->Copy() ); m_pFld->GetField()->ChgTyp( m_pFldType.get() ); // change field type @@ -292,12 +293,12 @@ void SwHistorySetTxtFld::SetInDoc( SwDoc* pDoc, bool ) SwFieldType* pNewFldType = m_pFldType.get(); if ( !pNewFldType ) { - pNewFldType = pDoc->GetSysFldType( m_nFldWhich ); + pNewFldType = pDoc->getIDocumentFieldsAccess().GetSysFldType( m_nFldWhich ); } else { // register type with the document - pNewFldType = pDoc->InsertFldType( *m_pFldType ); + pNewFldType = pDoc->getIDocumentFieldsAccess().InsertFldType( *m_pFldType ); } m_pFld->GetField()->ChgTyp( pNewFldType ); // change field type diff --git a/sw/source/core/undo/unsect.cxx b/sw/source/core/undo/unsect.cxx index cd69474fa6d8..402094a318d8 100644 --- a/sw/source/core/undo/unsect.cxx +++ b/sw/source/core/undo/unsect.cxx @@ -24,6 +24,7 @@ #include <doc.hxx> #include <IDocumentLinksAdministration.hxx> #include <IDocumentRedlineAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <docary.hxx> #include <swundo.hxx> #include <pam.hxx> @@ -363,7 +364,7 @@ void SwUndoDelSection::UndoImpl(::sw::UndoRedoContext & rContext) !aInsertedSect.GetCondition().isEmpty() ) { SwCalc aCalc( rDoc ); - rDoc.FldsToCalc(aCalc, pInsertedSectNd->GetIndex(), USHRT_MAX); + rDoc.getIDocumentFieldsAccess().FldsToCalc(aCalc, pInsertedSectNd->GetIndex(), USHRT_MAX); bool bRecalcCondHidden = aCalc.Calculate( aInsertedSect.GetCondition() ).GetBool(); aInsertedSect.SetCondHidden( bRecalcCondHidden ); diff --git a/sw/source/core/undo/untbl.cxx b/sw/source/core/undo/untbl.cxx index 9f3d31a0a24b..2be19a0f1998 100644 --- a/sw/source/core/undo/untbl.cxx +++ b/sw/source/core/undo/untbl.cxx @@ -37,6 +37,7 @@ #include <IDocumentUndoRedo.hxx> #include <IDocumentChartDataProviderAccess.hxx> #include <IDocumentRedlineAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <editsh.hxx> #include <docary.hxx> #include <ndtxt.hxx> @@ -310,7 +311,7 @@ void SwUndoInsTbl::RedoImpl(::sw::UndoRedoContext & rContext) if( pDDEFldType ) { - SwDDEFieldType* pNewType = (SwDDEFieldType*)rDoc.InsertFldType( + SwDDEFieldType* pNewType = (SwDDEFieldType*)rDoc.getIDocumentFieldsAccess().InsertFldType( *pDDEFldType); SwDDETable* pDDETbl = new SwDDETable( pTblNode->GetTable(), pNewType ); pTblNode->SetNewTable( pDDETbl ); @@ -472,7 +473,7 @@ void SwUndoTblToTxt::UndoImpl(::sw::UndoRedoContext & rContext) if( pDDEFldType ) { - SwDDEFieldType* pNewType = (SwDDEFieldType*)rDoc.InsertFldType( + SwDDEFieldType* pNewType = (SwDDEFieldType*)rDoc.getIDocumentFieldsAccess().InsertFldType( *pDDEFldType); SwDDETable* pDDETbl = new SwDDETable( pTblNd->GetTable(), pNewType ); pTblNd->SetNewTable( pDDETbl, false ); @@ -1686,7 +1687,7 @@ void SwUndoTblNdsChg::UndoImpl(::sw::UndoRedoContext & rContext) SwTableFmlUpdate aMsgHnt( &pTblNd->GetTable() ); aMsgHnt.eFlags = TBL_BOXPTR; - rDoc.UpdateTblFlds( &aMsgHnt ); + rDoc.getIDocumentFieldsAccess().UpdateTblFlds( &aMsgHnt ); CHECK_TABLE( pTblNd->GetTable() ) @@ -1870,7 +1871,7 @@ void SwUndoTblNdsChg::RedoImpl(::sw::UndoRedoContext & rContext) { SwTableFmlUpdate aMsgHnt( &pTblNd->GetTable() ); aMsgHnt.eFlags = TBL_BOXPTR; - rDoc.UpdateTblFlds( &aMsgHnt ); + rDoc.getIDocumentFieldsAccess().UpdateTblFlds( &aMsgHnt ); SwTable &rTable = pTblNd->GetTable(); if( nMax > nMin && rTable.IsNewModel() ) rTable.PrepareDeleteCol( nMin, nMax ); @@ -1882,7 +1883,7 @@ void SwUndoTblNdsChg::RedoImpl(::sw::UndoRedoContext & rContext) SwTableFmlUpdate aMsgHnt( &rTbl ); aMsgHnt.eFlags = TBL_BOXPTR; - rDoc.UpdateTblFlds( &aMsgHnt ); + rDoc.getIDocumentFieldsAccess().UpdateTblFlds( &aMsgHnt ); SwTableBox* pBox = rTbl.GetTblBox( nCurrBox ); TblChgMode eOldMode = rTbl.GetTblChgMode(); @@ -1955,7 +1956,7 @@ void SwUndoTblMerge::UndoImpl(::sw::UndoRedoContext & rContext) SwTableFmlUpdate aMsgHnt( &pTblNd->GetTable() ); aMsgHnt.eFlags = TBL_BOXPTR; - rDoc.UpdateTblFlds( &aMsgHnt ); + rDoc.getIDocumentFieldsAccess().UpdateTblFlds( &aMsgHnt ); _FndBox aTmpBox( 0, 0 ); // ? TL_CHART2: notification or locking of controller required ? @@ -2392,7 +2393,7 @@ void SwUndoTblNumFmt::RedoImpl(::sw::UndoRedoContext & rContext) { // No matter what was set, an update of the table is always a good idea SwTableFmlUpdate aTblUpdate( &pSttNd->FindTableNode()->GetTable() ); - rDoc.UpdateTblFlds( &aTblUpdate ); + rDoc.getIDocumentFieldsAccess().UpdateTblFlds( &aTblUpdate ); } if( !pNd->IsCntntNode() ) @@ -2909,7 +2910,7 @@ void SwUndoSplitTbl::UndoImpl(::sw::UndoRedoContext & rContext) SwTableFmlUpdate aMsgHnt( &rTbl ); aMsgHnt.eFlags = TBL_BOXPTR; - pDoc->UpdateTblFlds( &aMsgHnt ); + pDoc->getIDocumentFieldsAccess().UpdateTblFlds( &aMsgHnt ); switch( nMode ) { @@ -3024,7 +3025,7 @@ void SwUndoMergeTbl::UndoImpl(::sw::UndoRedoContext & rContext) SwTableFmlUpdate aMsgHnt( pTbl ); aMsgHnt.eFlags = TBL_BOXPTR; - pDoc->UpdateTblFlds( &aMsgHnt ); + pDoc->getIDocumentFieldsAccess().UpdateTblFlds( &aMsgHnt ); // get lines for layout update _FndBox aFndBox( 0, 0 ); diff --git a/sw/source/core/unocore/unocoll.cxx b/sw/source/core/unocore/unocoll.cxx index 4c2e4af66231..d42cab250f9f 100644 --- a/sw/source/core/unocore/unocoll.cxx +++ b/sw/source/core/unocore/unocoll.cxx @@ -23,6 +23,7 @@ #include <svx/svxids.hrc> #include <doc.hxx> #include <IDocumentChartDataProviderAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <docary.hxx> #include <fmtcol.hxx> #include <poolfmt.hxx> @@ -784,11 +785,11 @@ uno::Reference< uno::XInterface > SwXServiceProvider::MakeInstance(sal_uInt16 break; case SW_SERVICE_FIELDMASTER_BIBLIOGRAPHY: { - SwFieldType* pType = pDoc->GetFldType(RES_AUTHORITY, aEmptyOUStr, true); + SwFieldType* pType = pDoc->getIDocumentFieldsAccess().GetFldType(RES_AUTHORITY, aEmptyOUStr, true); if(!pType) { SwAuthorityFieldType aType(pDoc); - pType = pDoc->InsertFldType(aType); + pType = pDoc->getIDocumentFieldsAccess().InsertFldType(aType); } xRet = SwXFieldMaster::CreateXFieldMaster(*pDoc, *pType); } diff --git a/sw/source/core/unocore/unofield.cxx b/sw/source/core/unocore/unofield.cxx index 4396c2677548..51c367f7aec7 100644 --- a/sw/source/core/unocore/unofield.cxx +++ b/sw/source/core/unocore/unofield.cxx @@ -28,6 +28,7 @@ #include <swtypes.hxx> #include <cmdid.h> #include <doc.hxx> +#include <IDocumentFieldsAccess.hxx> #include <hints.hxx> #include <fmtfld.hxx> #include <txtfld.hxx> @@ -622,7 +623,7 @@ throw (beans::UnknownPropertyException, beans::PropertyVetoException, { OUString sTypeName; rValue >>= sTypeName; - SwFieldType * pType2 = m_pImpl->m_pDoc->GetFldType( + SwFieldType * pType2 = m_pImpl->m_pDoc->getIDocumentFieldsAccess().GetFldType( m_pImpl->m_nResTypeId, sTypeName, false); if(pType2 || @@ -640,7 +641,7 @@ throw (beans::UnknownPropertyException, beans::PropertyVetoException, case RES_USERFLD : { SwUserFieldType aType(m_pImpl->m_pDoc, sTypeName); - pType2 = m_pImpl->m_pDoc->InsertFldType(aType); + pType2 = m_pImpl->m_pDoc->getIDocumentFieldsAccess().InsertFldType(aType); static_cast<SwUserFieldType*>(pType2)->SetContent(m_pImpl->m_sParam1); static_cast<SwUserFieldType*>(pType2)->SetValue(m_pImpl->m_fParam1); static_cast<SwUserFieldType*>(pType2)->SetType(m_pImpl->m_bParam1 @@ -652,7 +653,7 @@ throw (beans::UnknownPropertyException, beans::PropertyVetoException, SwDDEFieldType aType(sTypeName, m_pImpl->m_sParam1, sal::static_int_cast<sal_uInt16>((m_pImpl->m_bParam1) ? sfx2::LINKUPDATE_ALWAYS : sfx2::LINKUPDATE_ONCALL)); - pType2 = m_pImpl->m_pDoc->InsertFldType(aType); + pType2 = m_pImpl->m_pDoc->getIDocumentFieldsAccess().InsertFldType(aType); } break; case RES_SETEXPFLD : @@ -662,7 +663,7 @@ throw (beans::UnknownPropertyException, beans::PropertyVetoException, aType.SetDelimiter(OUString(m_pImpl->m_sParam1[0])); if (m_pImpl->m_nParam1 > -1 && m_pImpl->m_nParam1 < MAXLEVEL) aType.SetOutlineLvl(m_pImpl->m_nParam1); - pType2 = m_pImpl->m_pDoc->InsertFldType(aType); + pType2 = m_pImpl->m_pDoc->getIDocumentFieldsAccess().InsertFldType(aType); } break; case RES_DBFLD : @@ -788,7 +789,7 @@ SwFieldType* SwXFieldMaster::GetFldType(bool const bDontCreate) const aData.sCommand = m_pImpl->m_sParam2; aData.nCommandType = m_pImpl->m_nParam2; SwDBFieldType aType(m_pImpl->m_pDoc, m_pImpl->m_sParam3, aData); - SwFieldType *const pType = m_pImpl->m_pDoc->InsertFldType(aType); + SwFieldType *const pType = m_pImpl->m_pDoc->getIDocumentFieldsAccess().InsertFldType(aType); pType->Add(m_pImpl.get()); const_cast<SwXFieldMaster*>(this)->m_pImpl->m_bIsDescriptor = false; } @@ -972,7 +973,7 @@ throw (uno::RuntimeException, std::exception) if (!pFldType) throw uno::RuntimeException(); sal_uInt16 nTypeIdx = USHRT_MAX; - const SwFldTypes* pTypes = m_pImpl->m_pDoc->GetFldTypes(); + const SwFldTypes* pTypes = m_pImpl->m_pDoc->getIDocumentFieldsAccess().GetFldTypes(); for( size_t i = 0; i < pTypes->size(); i++ ) { if((*pTypes)[i] == pFldType) @@ -992,7 +993,7 @@ throw (uno::RuntimeException, std::exception) pFld = aIter.Next(); } // then delete FieldType - m_pImpl->m_pDoc->RemoveFldType(nTypeIdx); + m_pImpl->m_pDoc->getIDocumentFieldsAccess().RemoveFldType(nTypeIdx); } void SAL_CALL SwXFieldMaster::addEventListener( @@ -1028,7 +1029,7 @@ OUString SwXFieldMaster::GetProgrammaticName(const SwFieldType& rType, SwDoc& rD const OUString sName(rType.GetName()); if(RES_SETEXPFLD == rType.Which()) { - const SwFldTypes* pTypes = rDoc.GetFldTypes(); + const SwFldTypes* pTypes = rDoc.getIDocumentFieldsAccess().GetFldTypes(); for( size_t i = 0; i <= size_t(INIT_FLDTYPES); i++ ) { if((*pTypes)[i] == &rType) @@ -1323,7 +1324,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) { case SW_SERVICE_FIELDTYPE_ANNOTATION: { - SwFieldType* pFldType = pDoc->GetSysFldType(RES_POSTITFLD); + SwFieldType* pFldType = pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_POSTITFLD); DateTime aDateTime( DateTime::EMPTY ); if (m_pImpl->m_pProps->pDateTime) @@ -1352,7 +1353,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) break; case SW_SERVICE_FIELDTYPE_SCRIPT: { - SwFieldType* pFldType = pDoc->GetSysFldType(RES_SCRIPTFLD); + SwFieldType* pFldType = pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_SCRIPTFLD); pFld = new SwScriptField((SwScriptFieldType*)pFldType, m_pImpl->m_pProps->sPar1, m_pImpl->m_pProps->sPar2, m_pImpl->m_pProps->bBool1); @@ -1367,7 +1368,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) nSub |= DATEFLD; else nSub |= TIMEFLD; - SwFieldType* pFldType = pDoc->GetSysFldType(RES_DATETIMEFLD); + SwFieldType* pFldType = pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_DATETIMEFLD); SwDateTimeField *const pDTField = new SwDateTimeField( static_cast<SwDateTimeFieldType*>(pFldType), nSub, m_pImpl->m_pProps->nFormat); @@ -1386,7 +1387,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) break; case SW_SERVICE_FIELDTYPE_FILE_NAME: { - SwFieldType* pFldType = pDoc->GetSysFldType(RES_FILENAMEFLD); + SwFieldType* pFldType = pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_FILENAMEFLD); sal_Int32 nFormat = m_pImpl->m_pProps->nFormat; if (m_pImpl->m_pProps->bBool2) nFormat |= FF_FIXED; @@ -1402,7 +1403,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) break; case SW_SERVICE_FIELDTYPE_TEMPLATE_NAME: { - SwFieldType* pFldType = pDoc->GetSysFldType(RES_TEMPLNAMEFLD); + SwFieldType* pFldType = pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_TEMPLNAMEFLD); pFld = new SwTemplNameField((SwTemplNameFieldType*)pFldType, m_pImpl->m_pProps->nFormat); uno::Any aFormat; @@ -1412,7 +1413,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) break; case SW_SERVICE_FIELDTYPE_CHAPTER: { - SwFieldType* pFldType = pDoc->GetSysFldType(RES_CHAPTERFLD); + SwFieldType* pFldType = pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_CHAPTERFLD); SwChapterField *const pChapterField = new SwChapterField( static_cast<SwChapterFieldType*>(pFldType), m_pImpl->m_pProps->nUSHORT1); @@ -1429,7 +1430,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) if (m_pImpl->m_pProps->bBool2) nFormat |= AF_FIXED; - SwFieldType* pFldType = pDoc->GetSysFldType(RES_AUTHORFLD); + SwFieldType* pFldType = pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_AUTHORFLD); SwAuthorField *const pAuthorField = new SwAuthorField( static_cast<SwAuthorFieldType*>(pFldType), nFormat); pFld = pAuthorField; @@ -1439,7 +1440,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) case SW_SERVICE_FIELDTYPE_CONDITIONED_TEXT: case SW_SERVICE_FIELDTYPE_HIDDEN_TEXT: { - SwFieldType* pFldType = pDoc->GetSysFldType(RES_HIDDENTXTFLD); + SwFieldType* pFldType = pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_HIDDENTXTFLD); SwHiddenTxtField *const pHTField = new SwHiddenTxtField( static_cast<SwHiddenTxtFieldType*>(pFldType), m_pImpl->m_pProps->sPar1, @@ -1455,7 +1456,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) break; case SW_SERVICE_FIELDTYPE_HIDDEN_PARA: { - SwFieldType* pFldType = pDoc->GetSysFldType(RES_HIDDENPARAFLD); + SwFieldType* pFldType = pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_HIDDENPARAFLD); SwHiddenParaField *const pHPField = new SwHiddenParaField( static_cast<SwHiddenParaFieldType*>(pFldType), m_pImpl->m_pProps->sPar1); @@ -1465,7 +1466,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) break; case SW_SERVICE_FIELDTYPE_GET_REFERENCE: { - SwFieldType* pFldType = pDoc->GetSysFldType(RES_GETREFFLD); + SwFieldType* pFldType = pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_GETREFFLD); pFld = new SwGetRefField((SwGetRefFieldType*)pFldType, m_pImpl->m_pProps->sPar1, 0, @@ -1484,7 +1485,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) break; case SW_SERVICE_FIELDTYPE_JUMP_EDIT: { - SwFieldType* pFldType = pDoc->GetSysFldType(RES_JUMPEDITFLD); + SwFieldType* pFldType = pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_JUMPEDITFLD); pFld = new SwJumpEditField((SwJumpEditFieldType*)pFldType, m_pImpl->m_pProps->nUSHORT1, m_pImpl->m_pProps->sPar2, m_pImpl->m_pProps->sPar1); @@ -1505,7 +1506,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) case SW_SERVICE_FIELDTYPE_DOCINFO_REVISION : case SW_SERVICE_FIELDTYPE_DOC_INFO: { - SwFieldType* pFldType = pDoc->GetSysFldType(RES_DOCINFOFLD); + SwFieldType* pFldType = pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_DOCINFOFLD); sal_uInt16 nSubType = aDocInfoSubTypeFromService[ m_pImpl->m_nServiceId - SW_SERVICE_FIELDTYPE_DOCINFO_CHANGE_AUTHOR]; if (SW_SERVICE_FIELDTYPE_DOCINFO_CHANGE_DATE_TIME == m_pImpl->m_nServiceId || @@ -1539,7 +1540,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) if (m_pImpl->m_pProps->bBool1) nFormat = AF_FIXED; - SwFieldType* pFldType = pDoc->GetSysFldType(RES_EXTUSERFLD); + SwFieldType* pFldType = pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_EXTUSERFLD); SwExtUserField *const pEUField = new SwExtUserField( static_cast<SwExtUserFieldType*>(pFldType), m_pImpl->m_pProps->nUSHORT1, nFormat); @@ -1550,7 +1551,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) case SW_SERVICE_FIELDTYPE_USER: { SwFieldType* pFldType = - pDoc->GetFldType(RES_USERFLD, m_pImpl->m_sTypeName, true); + pDoc->getIDocumentFieldsAccess().GetFldType(RES_USERFLD, m_pImpl->m_sTypeName, true); if (!pFldType) throw uno::RuntimeException(); sal_uInt16 nUserSubType = (m_pImpl->m_pProps->bBool1) @@ -1569,7 +1570,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) break; case SW_SERVICE_FIELDTYPE_REF_PAGE_SET: { - SwFieldType* pFldType = pDoc->GetSysFldType(RES_REFPAGESETFLD); + SwFieldType* pFldType = pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_REFPAGESETFLD); pFld = new SwRefPageSetField( (SwRefPageSetFieldType*)pFldType, m_pImpl->m_pProps->nUSHORT1, m_pImpl->m_pProps->bBool1 ); @@ -1577,7 +1578,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) break; case SW_SERVICE_FIELDTYPE_REF_PAGE_GET: { - SwFieldType* pFldType = pDoc->GetSysFldType(RES_REFPAGEGETFLD); + SwFieldType* pFldType = pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_REFPAGEGETFLD); SwRefPageGetField *const pRGField = new SwRefPageGetField( static_cast<SwRefPageGetFieldType*>(pFldType), m_pImpl->m_pProps->nUSHORT1 ); @@ -1587,7 +1588,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) break; case SW_SERVICE_FIELDTYPE_PAGE_NUM: { - SwFieldType* pFldType = pDoc->GetSysFldType(RES_PAGENUMBERFLD); + SwFieldType* pFldType = pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_PAGENUMBERFLD); SwPageNumberField *const pPNField = new SwPageNumberField( static_cast<SwPageNumberFieldType*>(pFldType), PG_RANDOM, m_pImpl->m_pProps->nFormat, @@ -1602,7 +1603,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) case SW_SERVICE_FIELDTYPE_DDE: { SwFieldType* pFldType = - pDoc->GetFldType(RES_DDEFLD, m_pImpl->m_sTypeName, true); + pDoc->getIDocumentFieldsAccess().GetFldType(RES_DDEFLD, m_pImpl->m_sTypeName, true); if (!pFldType) throw uno::RuntimeException(); pFld = new SwDDEField( (SwDDEFieldType*)pFldType ); @@ -1611,7 +1612,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) case SW_SERVICE_FIELDTYPE_DATABASE_NAME: #if HAVE_FEATURE_DBCONNECTIVITY { - SwFieldType* pFldType = pDoc->GetSysFldType(RES_DBNAMEFLD); + SwFieldType* pFldType = pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_DBNAMEFLD); SwDBData aData; aData.sDataSource = m_pImpl->m_pProps->sPar1; aData.sCommand = m_pImpl->m_pProps->sPar2; @@ -1633,7 +1634,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) aData.sDataSource = m_pImpl->m_pProps->sPar1; aData.sCommand = m_pImpl->m_pProps->sPar2; aData.nCommandType = m_pImpl->m_pProps->nSHORT1; - SwFieldType* pFldType = pDoc->GetSysFldType(RES_DBNEXTSETFLD); + SwFieldType* pFldType = pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_DBNEXTSETFLD); pFld = new SwDBNextSetField((SwDBNextSetFieldType*)pFldType, m_pImpl->m_pProps->sPar3, OUString(), aData); } @@ -1647,7 +1648,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) aData.sCommand = m_pImpl->m_pProps->sPar2; aData.nCommandType = m_pImpl->m_pProps->nSHORT1; pFld = new SwDBNumSetField( (SwDBNumSetFieldType*) - pDoc->GetSysFldType(RES_DBNUMSETFLD), + pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_DBNUMSETFLD), m_pImpl->m_pProps->sPar3, OUString::number(m_pImpl->m_pProps->nFormat), aData ); @@ -1663,7 +1664,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) aData.nCommandType = m_pImpl->m_pProps->nSHORT1; SwDBSetNumberField *const pDBSNField = new SwDBSetNumberField(static_cast<SwDBSetNumberFieldType*>( - pDoc->GetSysFldType(RES_DBSETNUMBERFLD)), aData, + pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_DBSETNUMBERFLD)), aData, m_pImpl->m_pProps->nUSHORT1); pFld = pDBSNField; pDBSNField->SetSetNumber(m_pImpl->m_pProps->nFormat); @@ -1680,7 +1681,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) #if HAVE_FEATURE_DBCONNECTIVITY { SwFieldType* pFldType = - pDoc->GetFldType(RES_DBFLD, m_pImpl->m_sTypeName, false); + pDoc->getIDocumentFieldsAccess().GetFldType(RES_DBFLD, m_pImpl->m_sTypeName, false); if (!pFldType) throw uno::RuntimeException(); pFld = new SwDBField(static_cast<SwDBFieldType*>(pFldType), @@ -1698,7 +1699,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) case SW_SERVICE_FIELDTYPE_SET_EXP: { SwFieldType* pFldType = - pDoc->GetFldType(RES_SETEXPFLD, m_pImpl->m_sTypeName, true); + pDoc->getIDocumentFieldsAccess().GetFldType(RES_SETEXPFLD, m_pImpl->m_sTypeName, true); if (!pFldType) throw uno::RuntimeException(); // detect the field type's sub type and set an appropriate number format @@ -1746,7 +1747,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) nSubType = nsSwGetSetExpType::GSE_EXPR; } //make sure the SubType matches the field type - SwFieldType* pSetExpFld = pDoc->GetFldType( + SwFieldType* pSetExpFld = pDoc->getIDocumentFieldsAccess().GetFldType( RES_SETEXPFLD, m_pImpl->m_pProps->sPar1, false); bool bSetGetExpFieldUninitialized = false; if (pSetExpFld) @@ -1764,7 +1765,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) nSubType &= ~nsSwExtendedSubType::SUB_CMD; SwGetExpField *const pGEField = new SwGetExpField( static_cast<SwGetExpFieldType*>( - pDoc->GetSysFldType(RES_GETEXPFLD)), + pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_GETEXPFLD)), m_pImpl->m_pProps->sPar1, nSubType, m_pImpl->m_pProps->nFormat); pFld = pGEField; @@ -1780,7 +1781,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) case SW_SERVICE_FIELDTYPE_INPUT: { SwFieldType* pFldType = - pDoc->GetFldType(RES_INPUTFLD, m_pImpl->m_sTypeName, true); + pDoc->getIDocumentFieldsAccess().GetFldType(RES_INPUTFLD, m_pImpl->m_sTypeName, true); if (!pFldType) throw uno::RuntimeException(); sal_uInt16 nInpSubType = @@ -1800,7 +1801,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) break; case SW_SERVICE_FIELDTYPE_MACRO: { - SwFieldType* pFldType = pDoc->GetSysFldType(RES_MACROFLD); + SwFieldType* pFldType = pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_MACROFLD); OUString aName; // support for Scripting Framework macros @@ -1835,7 +1836,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) case SW_SERVICE_FIELDTYPE_GRAPHIC_OBJECT_COUNT : nSubType = DS_GRF; break; case SW_SERVICE_FIELDTYPE_EMBEDDED_OBJECT_COUNT : nSubType = DS_OLE; break; } - SwFieldType* pFldType = pDoc->GetSysFldType(RES_DOCSTATFLD); + SwFieldType* pFldType = pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_DOCSTATFLD); pFld = new SwDocStatField( static_cast<SwDocStatFieldType*>(pFldType), nSubType, m_pImpl->m_pProps->nUSHORT2); @@ -1845,7 +1846,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) { SwAuthorityFieldType const type(pDoc); pFld = new SwAuthorityField(static_cast<SwAuthorityFieldType*>( - pDoc->InsertFldType(type)), + pDoc->getIDocumentFieldsAccess().InsertFldType(type)), OUString()); if (m_pImpl->m_pProps->aPropSeq.getLength()) { @@ -1858,14 +1859,14 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) case SW_SERVICE_FIELDTYPE_COMBINED_CHARACTERS: // create field pFld = new SwCombinedCharField( (SwCombinedCharFieldType*) - pDoc->GetSysFldType(RES_COMBINED_CHARS), + pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_COMBINED_CHARS), m_pImpl->m_pProps->sPar1); break; case SW_SERVICE_FIELDTYPE_DROPDOWN: { SwDropDownField *const pDDField = new SwDropDownField( static_cast<SwDropDownFieldType *>( - pDoc->GetSysFldType(RES_DROPDOWN))); + pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_DROPDOWN))); pFld = pDDField; pDDField->SetItems(m_pImpl->m_pProps->aStrings); @@ -1887,7 +1888,7 @@ throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) m_pImpl->m_pProps->nFormat = -1; } pFld = new SwTblField( (SwTblFieldType*) - pDoc->GetSysFldType(RES_TABLEFLD), + pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_TABLEFLD), m_pImpl->m_pProps->sPar2, nType, m_pImpl->m_pProps->nFormat); @@ -2142,7 +2143,7 @@ throw (beans::UnknownPropertyException, beans::PropertyVetoException, throw uno::RuntimeException(); SwPosition aPosition( pTxtFld->GetTxtNode() ); aPosition.nContent = pTxtFld->GetStart(); - pDoc->PutValueToField( aPosition, rValue, pEntry->nWID); + pDoc->getIDocumentFieldsAccess().PutValueToField( aPosition, rValue, pEntry->nWID); } //#i100374# notify SwPostIt about new field content @@ -2704,7 +2705,7 @@ uno::Any SwXTextFieldMasters::getByName(const OUString& rName) css::uno::Reference<css::uno::XInterface>()); sName = sName.copy(std::min(sTypeName.getLength()+1, sName.getLength())); - SwFieldType* pType = GetDoc()->GetFldType(nResId, sName, true); + SwFieldType* pType = GetDoc()->getIDocumentFieldsAccess().GetFldType(nResId, sName, true); if(!pType) throw container::NoSuchElementException( "SwXTextFieldMasters::getByName(" + rName + ")", @@ -2756,7 +2757,7 @@ uno::Sequence< OUString > SwXTextFieldMasters::getElementNames(void) if(!GetDoc()) throw uno::RuntimeException(); - const SwFldTypes* pFldTypes = GetDoc()->GetFldTypes(); + const SwFldTypes* pFldTypes = GetDoc()->getIDocumentFieldsAccess().GetFldTypes(); const size_t nCount = pFldTypes->size(); std::vector<OUString> aFldNames; @@ -2793,7 +2794,7 @@ sal_Bool SwXTextFieldMasters::hasByName(const OUString& rName) throw( uno::Runti if( USHRT_MAX != nResId ) { sName = sName.copy(std::min(sTypeName.getLength()+1, sName.getLength())); - bRet = USHRT_MAX != nResId && 0 != GetDoc()->GetFldType(nResId, sName, true); + bRet = USHRT_MAX != nResId && 0 != GetDoc()->getIDocumentFieldsAccess().GetFldType(nResId, sName, true); } return bRet; } @@ -2888,7 +2889,7 @@ void SAL_CALL SwXTextFieldTypes::refresh() throw (uno::RuntimeException, std::ex throw uno::RuntimeException(); UnoActionContext aContext(GetDoc()); GetDoc()->UpdateDocStat(); - GetDoc()->UpdateFlds(0, false); + GetDoc()->getIDocumentFieldsAccess().UpdateFlds(0, false); } // call refresh listeners (without SolarMutex locked) lang::EventObject const event(static_cast< ::cppu::OWeakObject*>(this)); @@ -2963,7 +2964,7 @@ SwXFieldEnumeration::SwXFieldEnumeration(SwDoc & rDoc) uno::Reference< text::XTextField > *pItems = m_pImpl->m_Items.getArray(); sal_Int32 nFillPos = 0; - const SwFldTypes* pFldTypes = m_pImpl->m_pDoc->GetFldTypes(); + const SwFldTypes* pFldTypes = m_pImpl->m_pDoc->getIDocumentFieldsAccess().GetFldTypes(); const size_t nCount = pFldTypes->size(); for(size_t nType = 0; nType < nCount; ++nType) { diff --git a/sw/source/core/unocore/unotbl.cxx b/sw/source/core/unocore/unotbl.cxx index 61d770e51ec7..af288e5c0234 100644 --- a/sw/source/core/unocore/unotbl.cxx +++ b/sw/source/core/unocore/unotbl.cxx @@ -35,6 +35,7 @@ #include <doc.hxx> #include <IDocumentUndoRedo.hxx> #include <IDocumentContentOperations.hxx> +#include <IDocumentFieldsAccess.hxx> #include <shellres.hxx> #include <docary.hxx> #include <ndole.hxx> @@ -766,7 +767,7 @@ void sw_setValue( SwXCell &rCell, double nVal ) pDoc->SetTblBoxFormulaAttrs( *rCell.pBox, aSet ); // update table SwTableFmlUpdate aTblUpdate( SwTable::FindTable( rCell.GetFrmFmt() )); - pDoc->UpdateTblFlds( &aTblUpdate ); + pDoc->getIDocumentFieldsAccess().UpdateTblFlds( &aTblUpdate ); } } @@ -945,7 +946,7 @@ void SwXCell::setFormula(const OUString& rFormula) throw( uno::RuntimeException, GetDoc()->SetTblBoxFormulaAttrs( *pBox, aSet ); // update table SwTableFmlUpdate aTblUpdate( SwTable::FindTable( GetFrmFmt() )); - pMyDoc->UpdateTblFlds( &aTblUpdate ); + pMyDoc->getIDocumentFieldsAccess().UpdateTblFlds( &aTblUpdate ); } } diff --git a/sw/source/core/view/printdata.cxx b/sw/source/core/view/printdata.cxx index 164d760a1405..ae395f77f756 100644 --- a/sw/source/core/view/printdata.cxx +++ b/sw/source/core/view/printdata.cxx @@ -49,7 +49,7 @@ void SwRenderData::CreatePostItData( SwDoc *pDoc, const SwViewOption *pViewOpt, { DeletePostItData(); m_pPostItFields.reset(new _SetGetExpFlds); - sw_GetPostIts( pDoc, m_pPostItFields.get() ); + sw_GetPostIts( &pDoc->getIDocumentFieldsAccess(), m_pPostItFields.get() ); //!! Disable spell and grammar checking in the temporary document. //!! Otherwise the grammar checker might process it and crash if we later on diff --git a/sw/source/core/view/viewsh.cxx b/sw/source/core/view/viewsh.cxx index 540224af8696..dbc7d88ad86c 100644 --- a/sw/source/core/view/viewsh.cxx +++ b/sw/source/core/view/viewsh.cxx @@ -35,6 +35,7 @@ #include <IDocumentDeviceAccess.hxx> #include <IDocumentDrawModelAccess.hxx> #include <IDocumentOutlineNodes.hxx> +#include <IDocumentFieldsAccess.hxx> #include <rootfrm.hxx> #include <pagefrm.hxx> #include <cntfrm.hxx> @@ -606,7 +607,7 @@ void SwViewShell::UpdateFlds(bool bCloseDB) else StartAction(); - GetDoc()->UpdateFlds(0, bCloseDB); + GetDoc()->getIDocumentFieldsAccess().UpdateFlds(0, bCloseDB); if ( bCrsr ) ((SwCrsrShell*)this)->EndAction(); @@ -917,9 +918,9 @@ void SwViewShell::CalcLayout() aAction.SetStatBar( true ); aAction.SetCalcLayout( true ); aAction.SetReschedule( true ); - GetDoc()->LockExpFlds(); + GetDoc()->getIDocumentFieldsAccess().LockExpFlds(); aAction.Action(); - GetDoc()->UnlockExpFlds(); + GetDoc()->getIDocumentFieldsAccess().UnlockExpFlds(); //the SetNewFldLst() on the Doc was cut off and must be fetched again //(see flowfrm.cxx, txtfld.cxx) @@ -931,8 +932,8 @@ void SwViewShell::CalcLayout() aAction.SetReschedule( true ); SwDocPosUpdate aMsgHnt( 0 ); - GetDoc()->UpdatePageFlds( &aMsgHnt ); - GetDoc()->UpdateExpFlds(NULL, true); + GetDoc()->getIDocumentFieldsAccess().UpdatePageFlds( &aMsgHnt ); + GetDoc()->getIDocumentFieldsAccess().UpdateExpFlds(NULL, true); aAction.Action(); } @@ -2099,14 +2100,14 @@ void SwViewShell::ImplApplyViewOptions( const SwViewOption &rOpt ) if( mpOpt->IsShowHiddenField() != rOpt.IsShowHiddenField() ) { - ((SwHiddenTxtFieldType*)mpDoc->GetSysFldType( RES_HIDDENTXTFLD ))-> + ((SwHiddenTxtFieldType*)mpDoc->getIDocumentFieldsAccess().GetSysFldType( RES_HIDDENTXTFLD ))-> SetHiddenFlag( !rOpt.IsShowHiddenField() ); bReformat = true; } if ( mpOpt->IsShowHiddenPara() != rOpt.IsShowHiddenPara() ) { SwHiddenParaFieldType* pFldType = (SwHiddenParaFieldType*)GetDoc()-> - GetSysFldType(RES_HIDDENPARAFLD); + getIDocumentFieldsAccess().GetSysFldType(RES_HIDDENPARAFLD); if( pFldType && pFldType->GetDepends() ) { SwMsgPoolItem aHnt( RES_HIDDENPARA_PRINT ); diff --git a/sw/source/core/view/vnew.cxx b/sw/source/core/view/vnew.cxx index af0a0f6ce2af..e4e3d7e3179f 100644 --- a/sw/source/core/view/vnew.cxx +++ b/sw/source/core/view/vnew.cxx @@ -22,6 +22,7 @@ #include <IDocumentUndoRedo.hxx> #include <DocumentSettingManager.hxx> #include <IDocumentDeviceAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <docsh.hxx> #include <viewsh.hxx> #include <rootfrm.hxx> @@ -196,7 +197,7 @@ SwViewShell::SwViewShell( SwDoc& rDocument, Window *pWindow, SET_CURR_SHELL( this ); - ((SwHiddenTxtFieldType*)mpDoc->GetSysFldType( RES_HIDDENTXTFLD ))-> + ((SwHiddenTxtFieldType*)mpDoc->getIDocumentFieldsAccess().GetSysFldType( RES_HIDDENTXTFLD ))-> SetHiddenFlag( !mpOpt->IsShowHiddenField() ); // In Init a standard FrmFmt is created. @@ -270,7 +271,7 @@ SwViewShell::SwViewShell( SwViewShell& rShell, Window *pWindow, if ( mbPreview ) mpImp->InitPagePreviewLayout(); - ((SwHiddenTxtFieldType*)mpDoc->GetSysFldType( RES_HIDDENTXTFLD ))-> + ((SwHiddenTxtFieldType*)mpDoc->getIDocumentFieldsAccess().GetSysFldType( RES_HIDDENTXTFLD ))-> SetHiddenFlag( !mpOpt->IsShowHiddenField() ); // In Init a standard FrmFmt is created. diff --git a/sw/source/core/view/vprint.cxx b/sw/source/core/view/vprint.cxx index 78c4ee1ce868..381707eef279 100644 --- a/sw/source/core/view/vprint.cxx +++ b/sw/source/core/view/vprint.cxx @@ -47,6 +47,7 @@ #include <doc.hxx> #include <IDocumentUndoRedo.hxx> #include <IDocumentDeviceAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <wdocsh.hxx> #include <fesh.hxx> #include <pam.hxx> @@ -323,7 +324,7 @@ SwDoc * SwViewShell::FillPrtDoc( SwDoc *pPrtDoc, const SfxPrinter* pPrt) { OSL_ENSURE( this->IsA( TYPE(SwFEShell) ),"SwViewShell::Prt for FEShell only"); SwFEShell* pFESh = (SwFEShell*)this; - pPrtDoc->LockExpFlds(); + pPrtDoc->getIDocumentFieldsAccess().LockExpFlds(); // use given printer //! Make a copy of it since it gets destroyed with the temporary document diff --git a/sw/source/filter/basflt/shellio.cxx b/sw/source/filter/basflt/shellio.cxx index 322e6092c014..af5e99588e7b 100644 --- a/sw/source/filter/basflt/shellio.cxx +++ b/sw/source/filter/basflt/shellio.cxx @@ -41,6 +41,7 @@ #include <IDocumentDeviceAccess.hxx> #include <IDocumentLinksAdministration.hxx> #include <IDocumentRedlineAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <pam.hxx> #include <editsh.hxx> #include <undobj.hxx> @@ -366,7 +367,7 @@ sal_uLong SwReader::Read( const Reader& rOptions ) eOld = static_cast<RedlineMode_t>( ePostReadRedlineMode & ~nsRedlineMode_t::REDLINE_IGNORE); - pDoc->SetFieldsDirty(false, NULL, 0); + pDoc->getIDocumentFieldsAccess().SetFieldsDirty(false, NULL, 0); } pDoc->getIDocumentRedlineAccess().SetRedlineMode_intern( eOld ); @@ -531,7 +532,7 @@ bool Reader::SetTemplate( SwDoc& rDoc ) { rDoc.RemoveAllFmtLanguageDependencies(); rDoc.ReplaceStyles( *pTemplate ); - rDoc.SetFixFields(false, NULL); + rDoc.getIDocumentFieldsAccess().SetFixFields(false, NULL); bRet = true; } diff --git a/sw/source/filter/html/htmlbas.cxx b/sw/source/filter/html/htmlbas.cxx index 5662e20580bc..22cb2c845ad1 100644 --- a/sw/source/filter/html/htmlbas.cxx +++ b/sw/source/filter/html/htmlbas.cxx @@ -37,6 +37,7 @@ #include <fmtfld.hxx> #include "doc.hxx" +#include <IDocumentFieldsAccess.hxx> #include "docsh.hxx" #include "docufld.hxx" #include "wrthtml.hxx" @@ -90,7 +91,7 @@ void SwHTMLParser::EndScript() if( bInsSrcIntoFld && !bIgnoreHTMLComments ) { SwScriptFieldType *pType = - (SwScriptFieldType*)pDoc->GetSysFldType( RES_SCRIPTFLD ); + (SwScriptFieldType*)pDoc->getIDocumentFieldsAccess().GetSysFldType( RES_SCRIPTFLD ); SwScriptField aFld( pType, aScriptType, !aScriptURL.isEmpty() ? aScriptURL : aScriptSource, diff --git a/sw/source/filter/html/htmlfld.cxx b/sw/source/filter/html/htmlfld.cxx index 36648def7d64..079f4792104d 100644 --- a/sw/source/filter/html/htmlfld.cxx +++ b/sw/source/filter/html/htmlfld.cxx @@ -21,6 +21,7 @@ #include <com/sun/star/document/XDocumentProperties.hpp> #include "docsh.hxx" +#include <IDocumentFieldsAccess.hxx> #include <svtools/htmltokn.h> #include <svl/zformat.hxx> #include <unotools/useroptions.hxx> @@ -283,7 +284,7 @@ void SwHTMLParser::NewField() if( RES_DATEFLD==nType || RES_TIMEFLD==nType ) nWhich = RES_DATETIMEFLD; - SwFieldType* pType = pDoc->GetSysFldType( nWhich ); + SwFieldType* pType = pDoc->getIDocumentFieldsAccess().GetSysFldType( nWhich ); SwField *pFld = 0; bool bInsOnEndTag = false; @@ -640,7 +641,7 @@ void SwHTMLParser::InsertComment( const OUString& rComment, const sal_Char *pTag } SwPostItField aPostItFld( - (SwPostItFieldType*)pDoc->GetSysFldType( RES_POSTITFLD ), + (SwPostItFieldType*)pDoc->getIDocumentFieldsAccess().GetSysFldType( RES_POSTITFLD ), aEmptyOUStr, aComment, aEmptyOUStr, aEmptyOUStr, DateTime( DateTime::SYSTEM ) ); InsertAttr( SwFmtFld( aPostItFld ) ); diff --git a/sw/source/filter/html/swhtml.cxx b/sw/source/filter/html/swhtml.cxx index e1f8a07c829e..4c8a6f1daf71 100644 --- a/sw/source/filter/html/swhtml.cxx +++ b/sw/source/filter/html/swhtml.cxx @@ -81,6 +81,7 @@ #include <IDocumentSettingAccess.hxx> #include <IDocumentLinksAdministration.hxx> #include <IDocumentRedlineAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <pam.hxx> #include <ndtxt.hxx> #include <mdiexp.hxx> @@ -637,7 +638,7 @@ void SwHTMLParser::Continue( int nToken ) if( !aScriptSource.isEmpty() ) { SwScriptFieldType *pType = - (SwScriptFieldType*)pDoc->GetSysFldType( RES_SCRIPTFLD ); + (SwScriptFieldType*)pDoc->getIDocumentFieldsAccess().GetSysFldType( RES_SCRIPTFLD ); SwScriptField aFld( pType, aScriptType, aScriptSource, false ); @@ -5433,7 +5434,7 @@ void SwHTMLParser::ParseMoreMetaOptions() sText.append("\">"); SwPostItField aPostItFld( - (SwPostItFieldType*)pDoc->GetSysFldType( RES_POSTITFLD ), + (SwPostItFieldType*)pDoc->getIDocumentFieldsAccess().GetSysFldType( RES_POSTITFLD ), aEmptyOUStr, sText.makeStringAndClear(), aEmptyOUStr, aEmptyOUStr, DateTime( DateTime::SYSTEM ) ); SwFmtFld aFmtFld( aPostItFld ); InsertAttr( aFmtFld ); diff --git a/sw/source/filter/ww1/fltshell.cxx b/sw/source/filter/ww1/fltshell.cxx index 87df0bd8786a..d341ebf71702 100644 --- a/sw/source/filter/ww1/fltshell.cxx +++ b/sw/source/filter/ww1/fltshell.cxx @@ -45,6 +45,7 @@ #include <redline.hxx> #include <pam.hxx> #include <doc.hxx> +#include <IDocumentFieldsAccess.hxx> #include <IDocumentRedlineAccess.hxx> #include <ndtxt.hxx> #include <frmatr.hxx> @@ -557,11 +558,11 @@ void SwFltControlStack::SetAttrInDoc(const SwPosition& rTmpPos, if (IsFlagSet(BOOK_TO_VAR_REF)) { - SwFieldType* pFT = pDoc->GetFldType(RES_SETEXPFLD, rName, false); + SwFieldType* pFT = pDoc->getIDocumentFieldsAccess().GetFldType(RES_SETEXPFLD, rName, false); if (!pFT) { SwSetExpFieldType aS(pDoc, rName, nsSwGetSetExpType::GSE_STRING); - pFT = pDoc->InsertFldType(aS); + pFT = pDoc->getIDocumentFieldsAccess().InsertFldType(aS); } SwSetExpField aFld((SwSetExpFieldType*)pFT, pB->GetValSys()); aFld.SetSubType( nsSwExtendedSubType::SUB_INVISIBLE ); @@ -1153,11 +1154,11 @@ SwFltShell& SwFltShell::operator << ( const sal_Unicode c ) SwFltShell& SwFltShell::AddError( const sal_Char* pErr ) { OUString aName("ErrorTag"); - SwFieldType* pFT = GetDoc().GetFldType( RES_SETEXPFLD, aName, false ); + SwFieldType* pFT = GetDoc().getIDocumentFieldsAccess().GetFldType( RES_SETEXPFLD, aName, false ); if( pFT == 0) { SwSetExpFieldType aS(&GetDoc(), aName, nsSwGetSetExpType::GSE_STRING); - pFT = GetDoc().InsertFldType(aS); + pFT = GetDoc().getIDocumentFieldsAccess().InsertFldType(aS); } SwSetExpField aFld( (SwSetExpFieldType*)pFT, OUString::createFromAscii( pErr )); @@ -1335,7 +1336,7 @@ const SfxPoolItem& SwFltShell::GetFlyFrmAttr(sal_uInt16 nWhich) SwFieldType* SwFltShell::GetSysFldType(sal_uInt16 eWhich) { - return GetDoc().GetSysFldType(eWhich); + return GetDoc().getIDocumentFieldsAccess().GetSysFldType(eWhich); } bool SwFltShell::GetWeightBold() diff --git a/sw/source/filter/ww1/w1filter.cxx b/sw/source/filter/ww1/w1filter.cxx index 9bdbe7f0b09a..1ee058754799 100644 --- a/sw/source/filter/ww1/w1filter.cxx +++ b/sw/source/filter/ww1/w1filter.cxx @@ -43,6 +43,7 @@ #include <svl/urihelper.hxx> #include <fmtfsize.hxx> #include <doc.hxx> +#include <IDocumentFieldsAccess.hxx> #include <pam.hxx> #include <ndtxt.hxx> #include <pagedesc.hxx> @@ -628,7 +629,7 @@ oncemore: if (aName.isEmpty()) break; aName = rOut.ConvertUStr(aName); - SwFieldType* pFT = rOut.GetDoc().InsertFldType( + SwFieldType* pFT = rOut.GetDoc().getIDocumentFieldsAccess().InsertFldType( SwSetExpFieldType( &rOut.GetDoc(), aName, nsSwGetSetExpType::GSE_STRING ) ); pField = new SwSetExpField((SwSetExpFieldType*)pFT, aStr); ((SwSetExpField*)pField)->SetSubType( nsSwExtendedSubType::SUB_INVISIBLE ); @@ -817,11 +818,11 @@ oncemore: { OUString aName("Ww"); aName += OUString::number( nPlcIndex ); - SwFieldType* pFT = rOut.GetDoc().GetFldType( RES_SETEXPFLD, aName, false); + SwFieldType* pFT = rOut.GetDoc().getIDocumentFieldsAccess().GetFldType( RES_SETEXPFLD, aName, false); if (pFT == 0) { SwSetExpFieldType aS(&rOut.GetDoc(), aName, nsSwGetSetExpType::GSE_FORMULA); - pFT = rOut.GetDoc().InsertFldType(aS); + pFT = rOut.GetDoc().getIDocumentFieldsAccess().InsertFldType(aS); } SwSetExpField aFld((SwSetExpFieldType*)pFT, sFormula); aFld.SetSubType(nsSwExtendedSubType::SUB_INVISIBLE); @@ -883,7 +884,7 @@ oncemore: if (aName.isEmpty()) break; - SwFieldType* pFT = rOut.GetDoc().InsertFldType( + SwFieldType* pFT = rOut.GetDoc().getIDocumentFieldsAccess().InsertFldType( SwSetExpFieldType( &rOut.GetDoc(), aName, nsSwGetSetExpType::GSE_STRING ) ); pField = new SwSetExpField((SwSetExpFieldType*)pFT, aStr ); ((SwSetExpField*)pField)->SetInputFlag( true ); diff --git a/sw/source/filter/ww8/ww8atr.cxx b/sw/source/filter/ww8/ww8atr.cxx index 3568ca7143c6..dd4dbebf8dcf 100644 --- a/sw/source/filter/ww8/ww8atr.cxx +++ b/sw/source/filter/ww8/ww8atr.cxx @@ -92,6 +92,7 @@ #include <poolfmt.hxx> #include <doc.hxx> #include <IDocumentSettingAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <docary.hxx> #include <pam.hxx> #include <paratr.hxx> @@ -312,7 +313,7 @@ void MSWordExportBase::OutputItemSet( const SfxItemSet& rSet, bool bPapFmt, bool void MSWordExportBase::GatherChapterFields() { //If the header/footer contains a chapter field - SwFieldType* pType = pDoc->GetSysFldType( RES_CHAPTERFLD ); + SwFieldType* pType = pDoc->getIDocumentFieldsAccess().GetSysFldType( RES_CHAPTERFLD ); SwIterator<SwFmtFld,SwFieldType> aFmtFlds( *pType ); for ( SwFmtFld* pFld = aFmtFlds.First(); pFld; pFld = aFmtFlds.Next() ) { @@ -893,7 +894,7 @@ bool MSWordExportBase::HasRefToObject( sal_uInt16 nTyp, const OUString* pName, s { const SwTxtNode* pNd; - SwFieldType* pType = pDoc->GetSysFldType( RES_GETREFFLD ); + SwFieldType* pType = pDoc->getIDocumentFieldsAccess().GetSysFldType( RES_GETREFFLD ); SwIterator<SwFmtFld, SwFieldType> aFmtFlds( *pType ); for ( SwFmtFld* pFmtFld = aFmtFlds.First(); pFmtFld; pFmtFld = aFmtFlds.Next() ) { diff --git a/sw/source/filter/ww8/ww8par.cxx b/sw/source/filter/ww8/ww8par.cxx index a56a97ea94c7..49f288c41e31 100644 --- a/sw/source/filter/ww8/ww8par.cxx +++ b/sw/source/filter/ww8/ww8par.cxx @@ -73,6 +73,7 @@ #include <fmtclbl.hxx> #include <section.hxx> #include <docsh.hxx> +#include <IDocumentFieldsAccess.hxx> #include <docufld.hxx> #include <swfltopt.hxx> #include <viewsh.hxx> @@ -2252,7 +2253,7 @@ long SwWW8ImplReader::Read_And(WW8PLCFManResult* pRes) this->pFmtOfJustInsertedApo = 0; SwPostItField aPostIt( - (SwPostItFieldType*)rDoc.GetSysFldType(RES_POSTITFLD), sAuthor, + (SwPostItFieldType*)rDoc.getIDocumentFieldsAccess().GetSysFldType(RES_POSTITFLD), sAuthor, sTxt, sInitials, OUString(), aDate ); aPostIt.SetTextObject(pOutliner); @@ -3522,7 +3523,7 @@ bool SwWW8ImplReader::ReadChar(long nPosCp, long nCpOfs) { // Page number SwPageNumberField aFld( - (SwPageNumberFieldType*)rDoc.GetSysFldType( + (SwPageNumberFieldType*)rDoc.getIDocumentFieldsAccess().GetSysFldType( RES_PAGENUMBERFLD ), PG_RANDOM, SVX_NUM_ARABIC); rDoc.getIDocumentContentOperations().InsertPoolItem(*pPaM, SwFmtFld(aFld), 0); } diff --git a/sw/source/filter/ww8/ww8par3.cxx b/sw/source/filter/ww8/ww8par3.cxx index b64769d47349..9c4a9a0b958a 100644 --- a/sw/source/filter/ww8/ww8par3.cxx +++ b/sw/source/filter/ww8/ww8par3.cxx @@ -61,6 +61,7 @@ #include <unotextrange.hxx> #include <doc.hxx> #include <docary.hxx> +#include <IDocumentFieldsAccess.hxx> #include <docsh.hxx> #include <numrule.hxx> #include <paratr.hxx> @@ -125,7 +126,7 @@ eF_ResT SwWW8ImplReader::Read_F_FormTextBox( WW8FieldDesc* pF, OUString& rStr ) aFormula.sDefault = GetFieldResult(pF); SwInputField aFld( - static_cast<SwInputFieldType*>(rDoc.GetSysFldType( RES_INPUTFLD )), + static_cast<SwInputFieldType*>(rDoc.getIDocumentFieldsAccess().GetSysFldType( RES_INPUTFLD )), aFormula.sDefault, aFormula.sTitle, INP_TXT, @@ -240,7 +241,7 @@ eF_ResT SwWW8ImplReader::Read_F_FormListBox( WW8FieldDesc* pF, OUString& rStr) if (!bUseEnhFields) { - SwDropDownField aFld((SwDropDownFieldType*)rDoc.GetSysFldType(RES_DROPDOWN)); + SwDropDownField aFld((SwDropDownFieldType*)rDoc.getIDocumentFieldsAccess().GetSysFldType(RES_DROPDOWN)); aFld.SetName(aFormula.sTitle); aFld.SetHelp(aFormula.sHelp); diff --git a/sw/source/filter/ww8/ww8par5.cxx b/sw/source/filter/ww8/ww8par5.cxx index 384756a50158..06f89549f6d4 100644 --- a/sw/source/filter/ww8/ww8par5.cxx +++ b/sw/source/filter/ww8/ww8par5.cxx @@ -47,6 +47,7 @@ #include <fmtanchr.hxx> #include <pam.hxx> #include <doc.hxx> +#include <IDocumentFieldsAccess.hxx> #include <charatr.hxx> #include <flddat.hxx> #include <docufld.hxx> @@ -1033,7 +1034,7 @@ void SwWW8ImplReader::InsertTagField( const sal_uInt16 nId, const OUString& rTag else { // normal tagggen - SwFieldType* pFT = rDoc.InsertFldType( + SwFieldType* pFT = rDoc.getIDocumentFieldsAccess().InsertFldType( SwSetExpFieldType( &rDoc, aName, nsSwGetSetExpType::GSE_STRING ) ); SwSetExpField aFld( (SwSetExpFieldType*)pFT, rTagText ); // SUB_INVISIBLE sal_uInt16 nSubType = ( SwFltGetFlag( nFieldFlags, SwFltControlStack::TAGS_VISIBLE ) ) ? 0 : nsSwExtendedSubType::SUB_INVISIBLE; @@ -1094,7 +1095,7 @@ eF_ResT SwWW8ImplReader::Read_F_Input( WW8FieldDesc* pF, OUString& rStr ) if ( pF->nId != 0x01 ) // 0x01 fields have no result { - SwInputField aFld( static_cast<SwInputFieldType*>(rDoc.GetSysFldType( RES_INPUTFLD )), + SwInputField aFld( static_cast<SwInputFieldType*>(rDoc.getIDocumentFieldsAccess().GetSysFldType( RES_INPUTFLD )), aDef, aQ, INP_TXT, 0, false ); rDoc.getIDocumentContentOperations().InsertPoolItem( *pPaM, SwFmtFld( aFld ), 0 ); } @@ -1219,7 +1220,7 @@ SwFltStackEntry *SwWW8FltRefStack::RefToVar(const SwField* pFld, if (aResult != aFieldVarNames.end()) { SwGetExpField aFld( (SwGetExpFieldType*) - pDoc->GetSysFldType(RES_GETEXPFLD), sName, nsSwGetSetExpType::GSE_STRING, 0); + pDoc->getIDocumentFieldsAccess().GetSysFldType(RES_GETEXPFLD), sName, nsSwGetSetExpType::GSE_STRING, 0); delete rEntry.pAttr; SwFmtFld aTmp(aFld); rEntry.pAttr = aTmp.Clone(); @@ -1287,7 +1288,7 @@ eF_ResT SwWW8ImplReader::Read_F_InputVar( WW8FieldDesc* pF, OUString& rStr ) const long nNo = MapBookmarkVariables(pF, sOrigName, aResult); - SwSetExpFieldType* pFT = (SwSetExpFieldType*)rDoc.InsertFldType( + SwSetExpFieldType* pFT = (SwSetExpFieldType*)rDoc.getIDocumentFieldsAccess().InsertFldType( SwSetExpFieldType(&rDoc, sOrigName, nsSwGetSetExpType::GSE_STRING)); SwSetExpField aFld(pFT, aResult); aFld.SetSubType(nsSwExtendedSubType::SUB_INVISIBLE | nsSwGetSetExpType::GSE_STRING); @@ -1305,7 +1306,7 @@ eF_ResT SwWW8ImplReader::Read_F_ANumber( WW8FieldDesc*, OUString& rStr ) { if( !pNumFldType ){ // 1. Mal SwSetExpFieldType aT( &rDoc, OUString("AutoNr"), nsSwGetSetExpType::GSE_SEQ ); - pNumFldType = rDoc.InsertFldType( aT ); + pNumFldType = rDoc.getIDocumentFieldsAccess().InsertFldType( aT ); } SwSetExpField aFld( (SwSetExpFieldType*)pNumFldType, OUString(), GetNumberPara( rStr ) ); @@ -1374,7 +1375,7 @@ eF_ResT SwWW8ImplReader::Read_F_Seq( WW8FieldDesc*, OUString& rStr ) if (aSequenceName.isEmpty() && aBook.isEmpty()) return FLD_TAGIGN; - SwSetExpFieldType* pFT = (SwSetExpFieldType*)rDoc.InsertFldType( + SwSetExpFieldType* pFT = (SwSetExpFieldType*)rDoc.getIDocumentFieldsAccess().InsertFldType( SwSetExpFieldType( &rDoc, aSequenceName, nsSwGetSetExpType::GSE_SEQ ) ); SwSetExpField aFld( pFT, OUString(), eNumFormat ); @@ -1507,7 +1508,7 @@ eF_ResT SwWW8ImplReader::Read_F_DocInfo( WW8FieldDesc* pF, OUString& rStr ) if( !bFldFound ) { SwDocInfoField aFld( (SwDocInfoFieldType*) - rDoc.GetSysFldType( RES_DOCINFOFLD ), DI_CUSTOM|nReg, aDocProperty, GetFieldResult( pF ) ); + rDoc.getIDocumentFieldsAccess().GetSysFldType( RES_DOCINFOFLD ), DI_CUSTOM|nReg, aDocProperty, GetFieldResult( pF ) ); rDoc.getIDocumentContentOperations().InsertPoolItem(*pPaM, SwFmtFld(aFld), 0); return FLD_OK; @@ -1614,7 +1615,7 @@ eF_ResT SwWW8ImplReader::Read_F_DocInfo( WW8FieldDesc* pF, OUString& rStr ) } SwDocInfoField aFld( (SwDocInfoFieldType*) - rDoc.GetSysFldType( RES_DOCINFOFLD ), nSub|nReg, aData, nFormat ); + rDoc.getIDocumentFieldsAccess().GetSysFldType( RES_DOCINFOFLD ), nSub|nReg, aData, nFormat ); if (bDateTime) ForceFieldLanguage(aFld, nLang); rDoc.getIDocumentContentOperations().InsertPoolItem(*pPaM, SwFmtFld(aFld), 0); @@ -1627,7 +1628,7 @@ eF_ResT SwWW8ImplReader::Read_F_Author( WW8FieldDesc*, OUString& ) // SH: Das SwAuthorField bezeichnet nicht den urspruenglichen // Autor, sondern den aktuellen Benutzer, also besser ueber DocInfo SwDocInfoField aFld( (SwDocInfoFieldType*) - rDoc.GetSysFldType( RES_DOCINFOFLD ), + rDoc.getIDocumentFieldsAccess().GetSysFldType( RES_DOCINFOFLD ), DI_CREATE|DI_SUB_AUTHOR, OUString() ); rDoc.getIDocumentContentOperations().InsertPoolItem( *pPaM, SwFmtFld( aFld ), 0 ); return FLD_OK; @@ -1636,7 +1637,7 @@ eF_ResT SwWW8ImplReader::Read_F_Author( WW8FieldDesc*, OUString& ) eF_ResT SwWW8ImplReader::Read_F_TemplName( WW8FieldDesc*, OUString& ) { SwTemplNameField aFld( (SwTemplNameFieldType*) - rDoc.GetSysFldType( RES_TEMPLNAMEFLD ), FF_NAME ); + rDoc.getIDocumentFieldsAccess().GetSysFldType( RES_TEMPLNAMEFLD ), FF_NAME ); rDoc.getIDocumentContentOperations().InsertPoolItem( *pPaM, SwFmtFld( aFld ), 0 ); return FLD_OK; } @@ -1691,14 +1692,14 @@ eF_ResT SwWW8ImplReader::Read_F_DateTime( WW8FieldDesc*pF, OUString& rStr ) if (nDT & NUMBERFORMAT_DATE) { SwDateTimeField aFld((SwDateTimeFieldType*) - rDoc.GetSysFldType(RES_DATETIMEFLD ), DATEFLD, nFormat); + rDoc.getIDocumentFieldsAccess().GetSysFldType(RES_DATETIMEFLD ), DATEFLD, nFormat); ForceFieldLanguage(aFld, nLang); rDoc.getIDocumentContentOperations().InsertPoolItem( *pPaM, SwFmtFld( aFld ), 0 ); } else if (nDT == NUMBERFORMAT_TIME) { SwDateTimeField aFld((SwDateTimeFieldType*) - rDoc.GetSysFldType(RES_DATETIMEFLD), TIMEFLD, nFormat); + rDoc.getIDocumentFieldsAccess().GetSysFldType(RES_DATETIMEFLD), TIMEFLD, nFormat); ForceFieldLanguage(aFld, nLang); rDoc.getIDocumentContentOperations().InsertPoolItem( *pPaM, SwFmtFld( aFld ), 0 ); } @@ -1731,7 +1732,7 @@ eF_ResT SwWW8ImplReader::Read_F_FileName(WW8FieldDesc*, OUString &rStr) } SwFileNameField aFld( - (SwFileNameFieldType*)rDoc.GetSysFldType(RES_FILENAMEFLD), eType); + (SwFileNameFieldType*)rDoc.getIDocumentFieldsAccess().GetSysFldType(RES_FILENAMEFLD), eType); rDoc.getIDocumentContentOperations().InsertPoolItem(*pPaM, SwFmtFld(aFld), 0); return FLD_OK; } @@ -1744,7 +1745,7 @@ eF_ResT SwWW8ImplReader::Read_F_Anz( WW8FieldDesc* pF, OUString& rStr ) case 28: nSub = DS_CHAR; break; // number of characters } SwDocStatField aFld( (SwDocStatFieldType*) - rDoc.GetSysFldType( RES_DOCSTATFLD ), nSub, + rDoc.getIDocumentFieldsAccess().GetSysFldType( RES_DOCSTATFLD ), nSub, GetNumberPara( rStr ) ); rDoc.getIDocumentContentOperations().InsertPoolItem( *pPaM, SwFmtFld( aFld ), 0 ); return FLD_OK; @@ -1754,7 +1755,7 @@ eF_ResT SwWW8ImplReader::Read_F_CurPage( WW8FieldDesc*, OUString& rStr ) { // page number SwPageNumberField aFld( (SwPageNumberFieldType*) - rDoc.GetSysFldType( RES_PAGENUMBERFLD ), PG_RANDOM, + rDoc.getIDocumentFieldsAccess().GetSysFldType( RES_PAGENUMBERFLD ), PG_RANDOM, GetNumberPara(rStr, true)); rDoc.getIDocumentContentOperations().InsertPoolItem( *pPaM, SwFmtFld( aFld ), 0 ); @@ -1881,7 +1882,7 @@ eF_ResT SwWW8ImplReader::Read_F_Set( WW8FieldDesc* pF, OUString& rStr ) const long nNo = MapBookmarkVariables(pF, sOrigName, sVal); - SwFieldType* pFT = rDoc.InsertFldType( SwSetExpFieldType( &rDoc, sOrigName, + SwFieldType* pFT = rDoc.getIDocumentFieldsAccess().InsertFldType( SwSetExpFieldType( &rDoc, sOrigName, nsSwGetSetExpType::GSE_STRING ) ); SwSetExpField aFld( (SwSetExpFieldType*)pFT, sVal, ULONG_MAX ); aFld.SetSubType(nsSwExtendedSubType::SUB_INVISIBLE | nsSwGetSetExpType::GSE_STRING); @@ -1946,7 +1947,7 @@ eF_ResT SwWW8ImplReader::Read_F_Ref( WW8FieldDesc*, OUString& rStr ) OUString sBkmName(GetMappedBookmark(sOrigBkmName)); SwGetRefField aFld( - (SwGetRefFieldType*)rDoc.GetSysFldType( RES_GETREFFLD ), + (SwGetRefFieldType*)rDoc.getIDocumentFieldsAccess().GetSysFldType( RES_GETREFFLD ), sBkmName,REF_BOOKMARK,0,eFormat); if (eFormat == REF_CONTENT) @@ -2002,14 +2003,14 @@ eF_ResT SwWW8ImplReader::Read_F_NoteReference( WW8FieldDesc*, OUString& rStr ) // set Sequence No of corresponding Foot-/Endnote to Zero // (will be corrected in SwGetRefField aFld( (SwGetRefFieldType*) - rDoc.GetSysFldType( RES_GETREFFLD ), aBkmName, REF_FOOTNOTE, 0, + rDoc.getIDocumentFieldsAccess().GetSysFldType( RES_GETREFFLD ), aBkmName, REF_FOOTNOTE, 0, REF_ONLYNUMBER ); pReffingStck->NewAttr(*pPaM->GetPoint(), SwFmtFld(aFld)); pReffingStck->SetAttr(*pPaM->GetPoint(), RES_TXTATR_FIELD); if (bAboveBelow) { SwGetRefField aFld2( (SwGetRefFieldType*) - rDoc.GetSysFldType( RES_GETREFFLD ),aBkmName, REF_FOOTNOTE, 0, + rDoc.getIDocumentFieldsAccess().GetSysFldType( RES_GETREFFLD ),aBkmName, REF_FOOTNOTE, 0, REF_UPDOWN ); pReffingStck->NewAttr(*pPaM->GetPoint(), SwFmtFld(aFld2)); pReffingStck->SetAttr(*pPaM->GetPoint(), RES_TXTATR_FIELD); @@ -2084,7 +2085,7 @@ eF_ResT SwWW8ImplReader::Read_F_PgRef( WW8FieldDesc*, OUString& rStr ) { sPageRefBookmarkName = sName; } - SwGetRefField aFld( (SwGetRefFieldType*)rDoc.GetSysFldType( RES_GETREFFLD ), + SwGetRefField aFld( (SwGetRefFieldType*)rDoc.getIDocumentFieldsAccess().GetSysFldType( RES_GETREFFLD ), sPageRefBookmarkName, REF_BOOKMARK, 0, REF_PAGE ); rDoc.getIDocumentContentOperations().InsertPoolItem( *pPaM, SwFmtFld( aFld ), 0 ); @@ -2164,7 +2165,7 @@ eF_ResT SwWW8ImplReader::Read_F_Macro( WW8FieldDesc*, OUString& rStr) aName = "StarOffice.Standard.Modul1." + aName; SwMacroField aFld( (SwMacroFieldType*) - rDoc.GetSysFldType( RES_MACROFLD ), aName, aVText ); + rDoc.getIDocumentFieldsAccess().GetSysFldType( RES_MACROFLD ), aName, aVText ); if( !bApplyWingdings ) { @@ -2401,7 +2402,7 @@ eF_ResT SwWW8ImplReader::Read_F_DBField( WW8FieldDesc* pF, OUString& rStr ) } SwDBFieldType aD( &rDoc, aName, SwDBData() ); // Datenbank: Nichts - SwFieldType* pFT = rDoc.InsertFldType( aD ); + SwFieldType* pFT = rDoc.getIDocumentFieldsAccess().InsertFldType( aD ); SwDBField aFld( (SwDBFieldType*)pFT ); aFld.SetFieldCode( rStr ); @@ -2423,7 +2424,7 @@ eF_ResT SwWW8ImplReader::Read_F_DBNext( WW8FieldDesc*, OUString& ) { #if HAVE_FEATURE_DBCONNECTIVITY SwDBNextSetFieldType aN; - SwFieldType* pFT = rDoc.InsertFldType( aN ); + SwFieldType* pFT = rDoc.getIDocumentFieldsAccess().InsertFldType( aN ); SwDBNextSetField aFld( (SwDBNextSetFieldType*)pFT, OUString(), OUString(), SwDBData() ); // Datenbank: Nichts rDoc.getIDocumentContentOperations().InsertPoolItem( *pPaM, SwFmtFld( aFld ), 0 ); @@ -2436,7 +2437,7 @@ eF_ResT SwWW8ImplReader::Read_F_DBNum( WW8FieldDesc*, OUString& ) { #if HAVE_FEATURE_DBCONNECTIVITY SwDBSetNumberFieldType aN; - SwFieldType* pFT = rDoc.InsertFldType( aN ); + SwFieldType* pFT = rDoc.getIDocumentFieldsAccess().InsertFldType( aN ); SwDBSetNumberField aFld( (SwDBSetNumberFieldType*)pFT, SwDBData() ); // Datenbank: Nichts rDoc.getIDocumentContentOperations().InsertPoolItem( *pPaM, SwFmtFld( aFld ), 0 ); @@ -2463,14 +2464,14 @@ eF_ResT SwWW8ImplReader::Read_F_Equation( WW8FieldDesc*, OUString& rStr ) if (aResult.sType == "Input") { - SwInputField aFld( static_cast<SwInputFieldType*>(rDoc.GetSysFldType( RES_INPUTFLD )), + SwInputField aFld( static_cast<SwInputFieldType*>(rDoc.getIDocumentFieldsAccess().GetSysFldType( RES_INPUTFLD )), aResult.sResult, aResult.sResult, INP_TXT, 0 ); rDoc.getIDocumentContentOperations().InsertPoolItem( *pPaM, SwFmtFld( aFld ), 0 ); // insert input field } else if (aResult.sType == "CombinedCharacters") { SwCombinedCharField aFld((SwCombinedCharFieldType*) - rDoc.GetSysFldType(RES_COMBINED_CHARS), aResult.sType); + rDoc.getIDocumentFieldsAccess().GetSysFldType(RES_COMBINED_CHARS), aResult.sType); rDoc.getIDocumentContentOperations().InsertPoolItem(*pPaM, SwFmtFld(aFld), 0); } } diff --git a/sw/source/filter/xml/xmltbli.cxx b/sw/source/filter/xml/xmltbli.cxx index 2022621ffdd1..ed024890f4d6 100644 --- a/sw/source/filter/xml/xmltbli.cxx +++ b/sw/source/filter/xml/xmltbli.cxx @@ -39,6 +39,7 @@ #include "fmtornt.hxx" #include "fmtfordr.hxx" #include "doc.hxx" +#include <IDocumentFieldsAccess.hxx> #include "swtable.hxx" #include "swtblfmt.hxx" #include "pam.hxx" @@ -1157,7 +1158,7 @@ static OUString lcl_GenerateFldTypeName(const OUString& sPrefix, SwTableNode* pT ++nCount; sName = sPrefixStr + OUString::number(nCount); } - while (NULL != pTableNode->GetDoc()->GetFldType(RES_DDEFLD, sName, false)); + while (NULL != pTableNode->GetDoc()->getIDocumentFieldsAccess().GetFldType(RES_DDEFLD, sName, false)); return sName; } @@ -1192,7 +1193,7 @@ static SwDDEFieldType* lcl_GetDDEFieldType(SwXMLDDETableContext_Impl* pContext, else { // check for existing DDE field type with the same name - SwDDEFieldType* pOldType = (SwDDEFieldType*)pTableNode->GetDoc()->GetFldType(RES_DDEFLD, sName, false); + SwDDEFieldType* pOldType = (SwDDEFieldType*)pTableNode->GetDoc()->getIDocumentFieldsAccess().GetFldType(RES_DDEFLD, sName, false); if (NULL != pOldType) { // same values -> return old type @@ -1218,7 +1219,7 @@ static SwDDEFieldType* lcl_GetDDEFieldType(SwXMLDDETableContext_Impl* pContext, // create new field type and return SwDDEFieldType aDDEFieldType(sName, sCommand, nType); pType = (SwDDEFieldType*)pTableNode-> - GetDoc()->InsertFldType(aDDEFieldType); + GetDoc()->getIDocumentFieldsAccess().InsertFldType(aDDEFieldType); } OSL_ENSURE(NULL != pType, "We really want a SwDDEFieldType here!"); diff --git a/sw/source/ui/fldui/fldvar.cxx b/sw/source/ui/fldui/fldvar.cxx index 2a1a9c4435d1..178495830f41 100644 --- a/sw/source/ui/fldui/fldvar.cxx +++ b/sw/source/ui/fldui/fldvar.cxx @@ -19,6 +19,7 @@ #include <swtypes.hxx> #include <sfx2/linkmgr.hxx> +#include <IDocumentFieldsAccess.hxx> #include <usrfld.hxx> #include <docufld.hxx> #include <expfld.hxx> @@ -890,7 +891,7 @@ IMPL_LINK_NOARG(SwFldVarPage, ModifyHdl) pSh = ::GetActiveWrtShell(); if(pSh) { - const SwFldTypes* p = pSh->GetDoc()->GetFldTypes(); + const SwFldTypes* p = pSh->GetDoc()->getIDocumentFieldsAccess().GetFldTypes(); sal_uInt16 i; for (i = 0; i < INIT_FLDTYPES; i++) diff --git a/sw/source/uibase/app/apphdl.cxx b/sw/source/uibase/app/apphdl.cxx index 502a336d633a..15ed86ba956c 100644 --- a/sw/source/uibase/app/apphdl.cxx +++ b/sw/source/uibase/app/apphdl.cxx @@ -68,6 +68,7 @@ #include <glosdoc.hxx> #include <doc.hxx> #include <IDocumentUndoRedo.hxx> +#include <IDocumentFieldsAccess.hxx> #include <cfgitems.hxx> #include <prtopt.hxx> #include <modcfg.hxx> @@ -672,7 +673,7 @@ void SwModule::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint ) SID_TEMPLATE, false); if (pTemplateItem && pTemplateItem->GetValue()) { - pDocSh->GetDoc()->SetFixFields(false, 0); + pDocSh->GetDoc()->getIDocumentFieldsAccess().SetFixFields(false, 0); } } break; diff --git a/sw/source/uibase/app/docsh2.cxx b/sw/source/uibase/app/docsh2.cxx index deaaa7a825b0..00b845ac1e27 100644 --- a/sw/source/uibase/app/docsh2.cxx +++ b/sw/source/uibase/app/docsh2.cxx @@ -77,6 +77,7 @@ #include <IDocumentSettingAccess.hxx> #include <IDocumentDeviceAccess.hxx> #include <IDocumentLinksAdministration.hxx> +#include <IDocumentFieldsAccess.hxx> #include <pagedesc.hxx> #include <shellio.hxx> #include <pview.hxx> @@ -270,7 +271,7 @@ void SwDocShell::Notify( SfxBroadcaster&, const SfxHint& rHint ) switch( nAction ) { case 2: - mpDoc->GetSysFldType( RES_FILENAMEFLD )->UpdateFlds(); + mpDoc->getIDocumentFieldsAccess().GetSysFldType( RES_FILENAMEFLD )->UpdateFlds(); break; // #i38126# - own action for event LOADFINISHED // in order to avoid a modified document. @@ -826,7 +827,7 @@ void SwDocShell::Execute(SfxRequest& rReq) //pWrtShell is not set in page preview if(mpWrtShell) mpWrtShell->StartAllAction(); - mpDoc->UpdateFlds( NULL, false ); + mpDoc->getIDocumentFieldsAccess().UpdateFlds( NULL, false ); mpDoc->getIDocumentLinksAdministration().EmbedAllLinks(); mpDoc->RemoveInvisibleContent(); if(mpWrtShell) diff --git a/sw/source/uibase/app/docst.cxx b/sw/source/uibase/app/docst.cxx index cc03d2c14994..d77caa848766 100644 --- a/sw/source/uibase/app/docst.cxx +++ b/sw/source/uibase/app/docst.cxx @@ -63,6 +63,7 @@ #include <IDocumentUndoRedo.hxx> #include <IDocumentSettingAccess.hxx> #include <IDocumentDeviceAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <IDocumentListsAccess.hxx> #include "swstyle.h" #include "frmfmt.hxx" @@ -1257,7 +1258,7 @@ void SwDocShell::_LoadStyles( SfxObjectShell& rSource, bool bPreserveCurrentDocu // of the template, update all the Source's // FixFields once. if(!bPreserveCurrentDocument) - ((SwDocShell&)rSource).mpDoc->SetFixFields(false, NULL); + ((SwDocShell&)rSource).mpDoc->getIDocumentFieldsAccess().SetFixFields(false, NULL); if( mpWrtShell ) { // rhbz#818557, fdo#58893: EndAllAction will call SelectShell(), diff --git a/sw/source/uibase/dbui/dbmgr.cxx b/sw/source/uibase/dbui/dbmgr.cxx index c411cf291b15..2a417ec451dc 100644 --- a/sw/source/uibase/dbui/dbmgr.cxx +++ b/sw/source/uibase/dbui/dbmgr.cxx @@ -80,6 +80,7 @@ #include <IDocumentSettingAccess.hxx> #include <IDocumentLinksAdministration.hxx> #include <IDocumentContentOperations.hxx> +#include <IDocumentFieldsAccess.hxx> #include <swwait.hxx> #include <swunohelper.hxx> #include <dbui.hrc> @@ -1028,7 +1029,7 @@ bool SwDBManager::MergeMailFiles(SwWrtShell* pSourceShell, SwDBManager* pOldDBManager = pWorkDoc->GetDBManager(); pWorkDoc->SetDBManager( this ); SfxGetpApp()->NotifyEvent(SfxEventHint(SW_EVENT_FIELD_MERGE, SwDocShell::GetEventName(STR_SW_EVENT_FIELD_MERGE), xWorkDocSh)); - pWorkDoc->UpdateFlds(NULL, false); + pWorkDoc->getIDocumentFieldsAccess().UpdateFlds(NULL, false); SfxGetpApp()->NotifyEvent(SfxEventHint(SW_EVENT_FIELD_MERGE_FINISHED, SwDocShell::GetEventName(STR_SW_EVENT_FIELD_MERGE_FINISHED), xWorkDocSh)); pWorkDoc->RemoveInvisibleContent(); diff --git a/sw/source/uibase/dochdl/swdtflvr.cxx b/sw/source/uibase/dochdl/swdtflvr.cxx index edc074df2b05..29959b27c004 100644 --- a/sw/source/uibase/dochdl/swdtflvr.cxx +++ b/sw/source/uibase/dochdl/swdtflvr.cxx @@ -82,6 +82,7 @@ #include <IDocumentSettingAccess.hxx> #include <IDocumentDeviceAccess.hxx> #include <IDocumentDrawModelAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <pagedesc.hxx> #include <IMark.hxx> #include <docary.hxx> @@ -439,7 +440,7 @@ bool SwTransferable::GetData( const DataFlavor& rFlavor, const OUString& rDestDo pClpDocFac = new SwDocFac; SwDoc *const pTmpDoc = lcl_GetDoc(*pClpDocFac); - pTmpDoc->LockExpFlds(); // never update fields - leave text as it is + pTmpDoc->getIDocumentFieldsAccess().LockExpFlds(); // never update fields - leave text as it is lclOverWriteDoc(*pWrtShell, *pTmpDoc); // in CORE a new one was created (OLE-Objekte copied!) @@ -871,7 +872,7 @@ int SwTransferable::PrepareForCopy( bool bIsCut ) SwDoc *const pTmpDoc = lcl_GetDoc(*pClpDocFac); - pTmpDoc->LockExpFlds(); // Never update fields - leave text as is + pTmpDoc->getIDocumentFieldsAccess().LockExpFlds(); // Never update fields - leave text as is lclOverWriteDoc(*pWrtShell, *pTmpDoc); { @@ -1049,7 +1050,7 @@ int SwTransferable::CopyGlossary( SwTextBlocks& rGlossary, SwCntntNode* pCNd = rNds.GoNext( &aNodeIdx ); // go to 1st ContentNode SwPaM aPam( *pCNd ); - pCDoc->LockExpFlds(); // never update fields - leave text as it is + pCDoc->getIDocumentFieldsAccess().LockExpFlds(); // never update fields - leave text as it is pCDoc->InsertGlossary( rGlossary, rStr, aPam, 0 ); diff --git a/sw/source/uibase/docvw/PostItMgr.cxx b/sw/source/uibase/docvw/PostItMgr.cxx index 4b6fd1d9c688..6c1b7f350d03 100644 --- a/sw/source/uibase/docvw/PostItMgr.cxx +++ b/sw/source/uibase/docvw/PostItMgr.cxx @@ -41,6 +41,7 @@ #include <wrtsh.hxx> #include <doc.hxx> #include <IDocumentSettingAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <fldbas.hxx> #include <fmtfld.hxx> #include <docufld.hxx> @@ -1149,7 +1150,7 @@ bool SwPostItMgr::LayoutByPage(std::list<SwSidebarWin*> &aVisiblePostItList,cons void SwPostItMgr::AddPostIts(bool bCheckExistance, bool bFocus) { bool bEmpty = mvPostItFlds.empty(); - SwFieldType* pType = mpView->GetDocShell()->GetDoc()->GetFldType(RES_POSTITFLD, OUString(),false); + SwFieldType* pType = mpView->GetDocShell()->GetDoc()->getIDocumentFieldsAccess().GetFldType(RES_POSTITFLD, OUString(),false); SwIterator<SwFmtFld,SwFieldType> aIter( *pType ); SwFmtFld* pSwFmtFld = aIter.First(); while(pSwFmtFld) diff --git a/sw/source/uibase/shells/textfld.cxx b/sw/source/uibase/shells/textfld.cxx index f4ffe1fd511a..cf0488462fda 100644 --- a/sw/source/uibase/shells/textfld.cxx +++ b/sw/source/uibase/shells/textfld.cxx @@ -21,6 +21,7 @@ #include <crsskip.hxx> #include <hintids.hxx> #include <SidebarWin.hxx> +#include <IDocumentFieldsAccess.hxx> #include <editeng/eeitem.hxx> #include <editeng/kernitem.hxx> #include <editeng/outliner.hxx> @@ -387,7 +388,7 @@ void SwTextShell::ExecField(SfxRequest &rReq) if (pPostIt) { - SwFieldType* pType = rSh.GetDoc()->GetFldType(RES_POSTITFLD, OUString(), false); + SwFieldType* pType = rSh.GetDoc()->getIDocumentFieldsAccess().GetFldType(RES_POSTITFLD, OUString(), false); SwIterator<SwFmtFld,SwFieldType> aIter( *pType ); SwFmtFld* pSwFmtFld = aIter.First(); while( pSwFmtFld ) diff --git a/sw/source/uibase/uiview/view.cxx b/sw/source/uibase/uiview/view.cxx index 1d0db016bb3c..9e3b5319fdbd 100644 --- a/sw/source/uibase/uiview/view.cxx +++ b/sw/source/uibase/uiview/view.cxx @@ -73,6 +73,7 @@ #include <IDocumentUndoRedo.hxx> #include <IDocumentSettingAccess.hxx> #include <IDocumentDrawModelAccess.hxx> +#include <DocumentFieldsManager.hxx> #include <drawdoc.hxx> #include <wdocsh.hxx> #include <wview.hxx> @@ -948,12 +949,12 @@ SwView::SwView( SfxViewFrame *_pFrame, SfxViewShell* pOldSh ) if( m_pWrtShell->GetDoc()->IsUpdateExpFld() ) { - if (m_pWrtShell->GetDoc()->containsUpdatableFields()) + if (m_pWrtShell->GetDoc()->GetDocumentFieldsManager().containsUpdatableFields()) { SET_CURR_SHELL( m_pWrtShell ); m_pWrtShell->StartAction(); m_pWrtShell->CalcLayout(); - m_pWrtShell->GetDoc()->UpdateFlds(NULL, false); + m_pWrtShell->GetDoc()->getIDocumentFieldsAccess().UpdateFlds(NULL, false); m_pWrtShell->EndAction(); } m_pWrtShell->GetDoc()->SetUpdateExpFldStat( false ); diff --git a/sw/source/uibase/uno/unoatxt.cxx b/sw/source/uibase/uno/unoatxt.cxx index 0c98fc4aafb5..9aad4ad761f5 100644 --- a/sw/source/uibase/uno/unoatxt.cxx +++ b/sw/source/uibase/uno/unoatxt.cxx @@ -41,6 +41,7 @@ #include <IMark.hxx> #include <IDocumentContentOperations.hxx> #include <IDocumentRedlineAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <unoprnms.hxx> #include <docsh.hxx> #include <swmodule.hxx> @@ -327,7 +328,7 @@ static bool lcl_CopySelToDoc( SwDoc* pInsDoc, OTextCursorHelper* pxCursor, SwXTe SwPosition aPos(aIdx, SwIndex(pNd, (pNd) ? pNd->Len() : 0)); bool bRet = false; - pInsDoc->LockExpFlds(); + pInsDoc->getIDocumentFieldsAccess().LockExpFlds(); { SwDoc *const pDoc((pxCursor) ? pxCursor->GetDoc() : pxRange->GetDoc()); SwPaM aPam(pDoc->GetNodes()); @@ -347,9 +348,9 @@ static bool lcl_CopySelToDoc( SwDoc* pInsDoc, OTextCursorHelper* pxCursor, SwXTe bRet = pDoc->getIDocumentContentOperations().CopyRange( *pPam, aPos, false ) || bRet; } - pInsDoc->UnlockExpFlds(); - if( !pInsDoc->IsExpFldsLocked() ) - pInsDoc->UpdateExpFlds(NULL, true); + pInsDoc->getIDocumentFieldsAccess().UnlockExpFlds(); + if( !pInsDoc->getIDocumentFieldsAccess().IsExpFldsLocked() ) + pInsDoc->getIDocumentFieldsAccess().UpdateExpFlds(NULL, true); return bRet; } diff --git a/sw/source/uibase/uno/unotxdoc.cxx b/sw/source/uibase/uno/unotxdoc.cxx index 9c78bdc5c014..893ee043614a 100644 --- a/sw/source/uibase/uno/unotxdoc.cxx +++ b/sw/source/uibase/uno/unotxdoc.cxx @@ -100,6 +100,7 @@ #include <IDocumentChartDataProviderAccess.hxx> #include <IDocumentLinksAdministration.hxx> #include <IDocumentRedlineAccess.hxx> +#include <IDocumentFieldsAccess.hxx> #include <editeng/forbiddencharacterstable.hxx> #include <svl/zforlist.hxx> #include <drawdoc.hxx> @@ -168,7 +169,7 @@ static SwPrintUIOptions * lcl_GetPrintUIOptions( const bool bSwSrcView = NULL != dynamic_cast< const SwSrcView * >(pView); const SwView * pSwView = dynamic_cast< const SwView * >(pView); const bool bHasSelection = pSwView && pSwView->HasSelection( false ); // check for any selection, not just text selection - const bool bHasPostIts = sw_GetPostIts( pDocShell->GetDoc(), 0 ); + const bool bHasPostIts = sw_GetPostIts( &pDocShell->GetDoc()->getIDocumentFieldsAccess(), 0 ); // get default values to use in dialog from documents SwPrintData const SwPrintData &rPrintData = pDocShell->GetDoc()->getIDocumentDeviceAccess().getPrintData(); @@ -3961,11 +3962,11 @@ SwViewOptionAdjust_Impl::AdjustViewOptions(SwPrintData const*const pPrtOptions) // to avoid unnecessary reformatting the view options related to the content // below should only change if necessary, that is if respective content is present const bool bContainsHiddenChars = m_pShell->GetDoc()->ContainsHiddenChars(); - const SwFieldType* pFldType = m_pShell->GetDoc()->GetSysFldType( RES_HIDDENTXTFLD ); + const SwFieldType* pFldType = m_pShell->GetDoc()->getIDocumentFieldsAccess().GetSysFldType( RES_HIDDENTXTFLD ); const bool bContainsHiddenFields = pFldType && pFldType->GetDepends(); - pFldType = m_pShell->GetDoc()->GetSysFldType( RES_HIDDENPARAFLD ); + pFldType = m_pShell->GetDoc()->getIDocumentFieldsAccess().GetSysFldType( RES_HIDDENPARAFLD ); const bool bContainsHiddenParagraphs = pFldType && pFldType->GetDepends(); - pFldType = m_pShell->GetDoc()->GetSysFldType( RES_JUMPEDITFLD ); + pFldType = m_pShell->GetDoc()->getIDocumentFieldsAccess().GetSysFldType( RES_JUMPEDITFLD ); const bool bContainsPlaceHolders = pFldType && pFldType->GetDepends(); const bool bContainsFields = m_pShell->IsAnyFieldInDoc(); |