bin/rename-sw-abbreviations.shlibreoffice-5-0-branch-point

renames the most annoying abbreviations in Writer (and partially
in the shared code too).

Change-Id: I9a62759138126c1537cc5c985ba05cf54d6132d9

6 files changed, 232 insertions, 232 deletions

diff --git a/sw/source/core/attr/cellatr.cxx b/sw/source/core/attr/cellatr.cxx
index 4e56fbaeee75..5cda63a62d3a 100644
--- a/sw/source/core/attr/cellatr.cxx
+++ b/sw/source/core/attr/cellatr.cxx
@@ -31,41 +31,41 @@
 #include <calbck.hxx>
 #include <swtable.hxx>
 
-SwTblBoxNumFormat::SwTblBoxNumFormat( sal_uInt32 nFormat, bool bFlag )
+SwTableBoxNumFormat::SwTableBoxNumFormat( sal_uInt32 nFormat, bool bFlag )
     : SfxUInt32Item( RES_BOXATR_FORMAT, nFormat ), bAuto( bFlag )
 {
 }
 
-bool SwTblBoxNumFormat::operator==( const SfxPoolItem& rAttr ) const
+bool SwTableBoxNumFormat::operator==( const SfxPoolItem& rAttr ) const
 {
     assert(SfxPoolItem::operator==(rAttr));
-    return GetValue() == static_cast<const SwTblBoxNumFormat&>(rAttr).GetValue() &&
-           bAuto == static_cast<const SwTblBoxNumFormat&>(rAttr).bAuto;
+    return GetValue() == static_cast<const SwTableBoxNumFormat&>(rAttr).GetValue() &&
+           bAuto == static_cast<const SwTableBoxNumFormat&>(rAttr).bAuto;
 }
 
-SfxPoolItem* SwTblBoxNumFormat::Clone( SfxItemPool* ) const
+SfxPoolItem* SwTableBoxNumFormat::Clone( SfxItemPool* ) const
 {
-    return new SwTblBoxNumFormat( GetValue(), bAuto );
+    return new SwTableBoxNumFormat( GetValue(), bAuto );
 }
 
-SwTblBoxFormula::SwTblBoxFormula( const OUString& rFormula )
+SwTableBoxFormula::SwTableBoxFormula( const OUString& rFormula )
     : SfxPoolItem( RES_BOXATR_FORMULA ),
     SwTableFormula( rFormula ),
     pDefinedIn( 0 )
 {
 }
 
-bool SwTblBoxFormula::operator==( const SfxPoolItem& rAttr ) const
+bool SwTableBoxFormula::operator==( const SfxPoolItem& rAttr ) const
 {
     assert(SfxPoolItem::operator==(rAttr));
-    return GetFormula() == static_cast<const SwTblBoxFormula&>(rAttr).GetFormula() &&
-           pDefinedIn == static_cast<const SwTblBoxFormula&>(rAttr).pDefinedIn;
+    return GetFormula() == static_cast<const SwTableBoxFormula&>(rAttr).GetFormula() &&
+           pDefinedIn == static_cast<const SwTableBoxFormula&>(rAttr).pDefinedIn;
 }
 
-SfxPoolItem* SwTblBoxFormula::Clone( SfxItemPool* ) const
+SfxPoolItem* SwTableBoxFormula::Clone( SfxItemPool* ) const
 {
     // switch to external rendering
-    SwTblBoxFormula* pNew = new SwTblBoxFormula( GetFormula() );
+    SwTableBoxFormula* pNew = new SwTableBoxFormula( GetFormula() );
     pNew->SwTableFormula::operator=( *this );
     return pNew;
 }
@@ -77,7 +77,7 @@ SfxPoolItem* SwTblBoxFormula::Clone( SfxItemPool* ) const
 
     Caution: Must override when inheriting.
 */
-const SwNode* SwTblBoxFormula::GetNodeOfFormula() const
+const SwNode* SwTableBoxFormula::GetNodeOfFormula() const
 {
     const SwNode* pRet = 0;
     if( pDefinedIn )
@@ -89,7 +89,7 @@ const SwNode* SwTblBoxFormula::GetNodeOfFormula() const
     return pRet;
 }
 
-SwTableBox* SwTblBoxFormula::GetTableBox()
+SwTableBox* SwTableBoxFormula::GetTableBox()
 {
     SwTableBox* pBox = 0;
     if( pDefinedIn )
@@ -97,12 +97,12 @@ SwTableBox* SwTblBoxFormula::GetTableBox()
     return pBox;
 }
 
-void SwTblBoxFormula::ChangeState( const SfxPoolItem* pItem )
+void SwTableBoxFormula::ChangeState( const SfxPoolItem* pItem )
 {
     if( !pDefinedIn )
         return ;
 
-    SwTableFmlUpdate* pUpdtFld;
+    SwTableFormulaUpdate* pUpdateField;
     if( !pItem || RES_TABLEFML_UPDATE != pItem->Which() )
     {
         // reset value flag
@@ -110,109 +110,109 @@ void SwTblBoxFormula::ChangeState( const SfxPoolItem* pItem )
         return ;
     }
 
-    pUpdtFld = const_cast<SwTableFmlUpdate*>(static_cast<const SwTableFmlUpdate*>(pItem));
+    pUpdateField = const_cast<SwTableFormulaUpdate*>(static_cast<const SwTableFormulaUpdate*>(pItem));
 
     // detect table that contains this attribute
-    const SwTableNode* pTblNd;
+    const SwTableNode* pTableNd;
     const SwNode* pNd = GetNodeOfFormula();
     if( pNd && &pNd->GetNodes() == &pNd->GetDoc()->GetNodes() &&
-        0 != ( pTblNd = pNd->FindTableNode() ))
+        0 != ( pTableNd = pNd->FindTableNode() ))
     {
-        switch( pUpdtFld->eFlags )
+        switch( pUpdateField->eFlags )
         {
         case TBL_CALC:
             // reset value flag
             ChgValid( false );
             break;
         case TBL_BOXNAME:
-            if( &pTblNd->GetTable() == pUpdtFld->pTbl )
+            if( &pTableNd->GetTable() == pUpdateField->pTable )
                 // use external rendering
-                PtrToBoxNm( pUpdtFld->pTbl );
+                PtrToBoxNm( pUpdateField->pTable );
             break;
         case TBL_BOXPTR:
             // internal rendering
-            BoxNmToPtr( &pTblNd->GetTable() );
+            BoxNmToPtr( &pTableNd->GetTable() );
             break;
         case TBL_RELBOXNAME:
-            if( &pTblNd->GetTable() == pUpdtFld->pTbl )
+            if( &pTableNd->GetTable() == pUpdateField->pTable )
                 // relative rendering
-                ToRelBoxNm( pUpdtFld->pTbl );
+                ToRelBoxNm( pUpdateField->pTable );
             break;
 
         case TBL_SPLITTBL:
-            if( &pTblNd->GetTable() == pUpdtFld->pTbl )
+            if( &pTableNd->GetTable() == pUpdateField->pTable )
             {
-                sal_uInt16 nLnPos = SwTableFormula::GetLnPosInTbl(
-                                        pTblNd->GetTable(), GetTableBox() );
-                pUpdtFld->bBehindSplitLine = USHRT_MAX != nLnPos &&
-                                            pUpdtFld->nSplitLine <= nLnPos;
+                sal_uInt16 nLnPos = SwTableFormula::GetLnPosInTable(
+                                        pTableNd->GetTable(), GetTableBox() );
+                pUpdateField->bBehindSplitLine = USHRT_MAX != nLnPos &&
+                                            pUpdateField->nSplitLine <= nLnPos;
             }
             else
-                pUpdtFld->bBehindSplitLine = false;
+                pUpdateField->bBehindSplitLine = false;
             // no break
         case TBL_MERGETBL:
-            if( pUpdtFld->pHistory )
+            if( pUpdateField->pHistory )
             {
                 // for a history record the unchanged formula is needed
-                SwTblBoxFormula aCopy( *this );
-                pUpdtFld->bModified = false;
-                ToSplitMergeBoxNm( *pUpdtFld );
+                SwTableBoxFormula aCopy( *this );
+                pUpdateField->bModified = false;
+                ToSplitMergeBoxNm( *pUpdateField );
 
-                if( pUpdtFld->bModified )
+                if( pUpdateField->bModified )
                 {
                     // external rendering
-                    aCopy.PtrToBoxNm( &pTblNd->GetTable() );
-                    pUpdtFld->pHistory->Add(
+                    aCopy.PtrToBoxNm( &pTableNd->GetTable() );
+                    pUpdateField->pHistory->Add(
                         &aCopy,
                         &aCopy,
                         pNd->FindTableBoxStartNode()->GetIndex());
                 }
             }
             else
-                ToSplitMergeBoxNm( *pUpdtFld );
+                ToSplitMergeBoxNm( *pUpdateField );
             break;
         }
     }
 }
 
-void SwTblBoxFormula::Calc( SwTblCalcPara& rCalcPara, double& rValue )
+void SwTableBoxFormula::Calc( SwTableCalcPara& rCalcPara, double& rValue )
 {
     if( !rCalcPara.rCalc.IsCalcError() )
     {
         // create pointers from box names
-        BoxNmToPtr( rCalcPara.pTbl );
-        const OUString sFml( MakeFormula( rCalcPara ));
+        BoxNmToPtr( rCalcPara.pTable );
+        const OUString sFormula( MakeFormula( rCalcPara ));
         if( !rCalcPara.rCalc.IsCalcError() )
-            rValue = rCalcPara.rCalc.Calculate( sFml ).GetDouble();
+            rValue = rCalcPara.rCalc.Calculate( sFormula ).GetDouble();
         else
             rValue = DBL_MAX;
         ChgValid( !rCalcPara.IsStackOverflow() ); // value is now valid again
     }
 }
 
-SwTblBoxValue::SwTblBoxValue()
+SwTableBoxValue::SwTableBoxValue()
     : SfxPoolItem( RES_BOXATR_VALUE ), nValue( 0 )
 {
 }
 
-SwTblBoxValue::SwTblBoxValue( const double nVal )
+SwTableBoxValue::SwTableBoxValue( const double nVal )
     : SfxPoolItem( RES_BOXATR_VALUE ), nValue( nVal )
 {
 }
 
-bool SwTblBoxValue::operator==( const SfxPoolItem& rAttr ) const
+bool SwTableBoxValue::operator==( const SfxPoolItem& rAttr ) const
 {
     assert(SfxPoolItem::operator==(rAttr));
-    SwTblBoxValue const& rOther( static_cast<SwTblBoxValue const&>(rAttr) );
+    SwTableBoxValue const& rOther( static_cast<SwTableBoxValue const&>(rAttr) );
     // items with NaN should be equal to enable pooling
     return ::rtl::math::isNan( nValue )
         ?   ::rtl::math::isNan( rOther.nValue )
         :   ( nValue == rOther.nValue );
 }
 
-SfxPoolItem* SwTblBoxValue::Clone( SfxItemPool* ) const
+SfxPoolItem* SwTableBoxValue::Clone( SfxItemPool* ) const
 {
-    return new SwTblBoxValue( nValue );
+    return new SwTableBoxValue( nValue );
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/core/attr/fmtfollowtextflow.cxx b/sw/source/core/attr/fmtfollowtextflow.cxx
index 5660cdba5b3e..7cd973a47fb8 100644
--- a/sw/source/core/attr/fmtfollowtextflow.cxx
+++ b/sw/source/core/attr/fmtfollowtextflow.cxx
@@ -19,11 +19,11 @@
 
 #include <fmtfollowtextflow.hxx>
 
-TYPEINIT1(SwFmtFollowTextFlow, SfxBoolItem);
+TYPEINIT1(SwFormatFollowTextFlow, SfxBoolItem);
 
-SfxPoolItem*    SwFmtFollowTextFlow::Clone( SfxItemPool * ) const
+SfxPoolItem*    SwFormatFollowTextFlow::Clone( SfxItemPool * ) const
 {
-    return new SwFmtFollowTextFlow(*this);
+    return new SwFormatFollowTextFlow(*this);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/core/attr/fmtwrapinfluenceonobjpos.cxx b/sw/source/core/attr/fmtwrapinfluenceonobjpos.cxx
index 0224f4fb9605..6ee45e2c913e 100644
--- a/sw/source/core/attr/fmtwrapinfluenceonobjpos.cxx
+++ b/sw/source/core/attr/fmtwrapinfluenceonobjpos.cxx
@@ -25,45 +25,45 @@
 using namespace ::com::sun::star;
 using namespace ::com::sun::star::uno;
 
-TYPEINIT1(SwFmtWrapInfluenceOnObjPos, SfxPoolItem);
+TYPEINIT1(SwFormatWrapInfluenceOnObjPos, SfxPoolItem);
 
-SwFmtWrapInfluenceOnObjPos::SwFmtWrapInfluenceOnObjPos( sal_Int16 _nWrapInfluenceOnPosition )
+SwFormatWrapInfluenceOnObjPos::SwFormatWrapInfluenceOnObjPos( sal_Int16 _nWrapInfluenceOnPosition )
     : SfxPoolItem( RES_WRAP_INFLUENCE_ON_OBJPOS ),
     mnWrapInfluenceOnPosition( _nWrapInfluenceOnPosition )
 {
 }
 
-SwFmtWrapInfluenceOnObjPos::SwFmtWrapInfluenceOnObjPos( const SwFmtWrapInfluenceOnObjPos& _rCpy )
+SwFormatWrapInfluenceOnObjPos::SwFormatWrapInfluenceOnObjPos( const SwFormatWrapInfluenceOnObjPos& _rCpy )
     : SfxPoolItem( RES_WRAP_INFLUENCE_ON_OBJPOS ),
     mnWrapInfluenceOnPosition( _rCpy.GetWrapInfluenceOnObjPos() )
 {
 }
 
-SwFmtWrapInfluenceOnObjPos::~SwFmtWrapInfluenceOnObjPos()
+SwFormatWrapInfluenceOnObjPos::~SwFormatWrapInfluenceOnObjPos()
 {
 }
 
-SwFmtWrapInfluenceOnObjPos& SwFmtWrapInfluenceOnObjPos::operator=( const SwFmtWrapInfluenceOnObjPos& _rSource )
+SwFormatWrapInfluenceOnObjPos& SwFormatWrapInfluenceOnObjPos::operator=( const SwFormatWrapInfluenceOnObjPos& _rSource )
 {
     mnWrapInfluenceOnPosition = _rSource.GetWrapInfluenceOnObjPos();
 
     return *this;
 }
 
-bool SwFmtWrapInfluenceOnObjPos::operator==( const SfxPoolItem& rAttr ) const
+bool SwFormatWrapInfluenceOnObjPos::operator==( const SfxPoolItem& rAttr ) const
 {
     assert(SfxPoolItem::operator==(rAttr));
     return ( mnWrapInfluenceOnPosition ==
-                    static_cast<const SwFmtWrapInfluenceOnObjPos&>(rAttr).
+                    static_cast<const SwFormatWrapInfluenceOnObjPos&>(rAttr).
                                                 GetWrapInfluenceOnObjPos() );
 }
 
-SfxPoolItem* SwFmtWrapInfluenceOnObjPos::Clone( SfxItemPool * ) const
+SfxPoolItem* SwFormatWrapInfluenceOnObjPos::Clone( SfxItemPool * ) const
 {
-    return new SwFmtWrapInfluenceOnObjPos(*this);
+    return new SwFormatWrapInfluenceOnObjPos(*this);
 }
 
-bool SwFmtWrapInfluenceOnObjPos::QueryValue( Any& rVal, sal_uInt8 nMemberId ) const
+bool SwFormatWrapInfluenceOnObjPos::QueryValue( Any& rVal, sal_uInt8 nMemberId ) const
 {
     nMemberId &= ~CONVERT_TWIPS;
     bool bRet = true;
@@ -73,13 +73,13 @@ bool SwFmtWrapInfluenceOnObjPos::QueryValue( Any& rVal, sal_uInt8 nMemberId ) co
     }
     else
     {
-        OSL_FAIL( "<SwFmtWrapInfluenceOnObjPos::QueryValue()> - unknown MemberId" );
+        OSL_FAIL( "<SwFormatWrapInfluenceOnObjPos::QueryValue()> - unknown MemberId" );
         bRet = false;
     }
     return bRet;
 }
 
-bool SwFmtWrapInfluenceOnObjPos::PutValue( const Any& rVal, sal_uInt8 nMemberId )
+bool SwFormatWrapInfluenceOnObjPos::PutValue( const Any& rVal, sal_uInt8 nMemberId )
 {
     nMemberId &= ~CONVERT_TWIPS;
     bool bRet = false;
@@ -98,17 +98,17 @@ bool SwFmtWrapInfluenceOnObjPos::PutValue( const Any& rVal, sal_uInt8 nMemberId
         }
         else
         {
-            OSL_FAIL( "<SwFmtWrapInfluenceOnObjPos::PutValue(..)> - invalid attribute value" );
+            OSL_FAIL( "<SwFormatWrapInfluenceOnObjPos::PutValue(..)> - invalid attribute value" );
         }
     }
     else
     {
-        OSL_FAIL( "<SwFmtWrapInfluenceOnObjPos::PutValue(..)> - unknown MemberId" );
+        OSL_FAIL( "<SwFormatWrapInfluenceOnObjPos::PutValue(..)> - unknown MemberId" );
     }
     return bRet;
 }
 
-void SwFmtWrapInfluenceOnObjPos::SetWrapInfluenceOnObjPos( sal_Int16 _nWrapInfluenceOnPosition )
+void SwFormatWrapInfluenceOnObjPos::SetWrapInfluenceOnObjPos( sal_Int16 _nWrapInfluenceOnPosition )
 {
     // #i35017# - constant names have changed and consider new value <ITERATIVE>
     if ( _nWrapInfluenceOnPosition == text::WrapInfluenceOnPosition::ONCE_SUCCESSIVE ||
@@ -119,13 +119,13 @@ void SwFmtWrapInfluenceOnObjPos::SetWrapInfluenceOnObjPos( sal_Int16 _nWrapInflu
     }
     else
     {
-        OSL_FAIL( "<SwFmtWrapInfluenceOnObjPos::SetWrapInfluenceOnObjPos(..)> - invalid attribute value" );
+        OSL_FAIL( "<SwFormatWrapInfluenceOnObjPos::SetWrapInfluenceOnObjPos(..)> - invalid attribute value" );
     }
 }
 
 // #i35017# - add parameter <_bIterativeAsOnceConcurrent> to control, if
 // value <ITERATIVE> has to be treated as <ONCE_CONCURRENT>
-sal_Int16 SwFmtWrapInfluenceOnObjPos::GetWrapInfluenceOnObjPos(
+sal_Int16 SwFormatWrapInfluenceOnObjPos::GetWrapInfluenceOnObjPos(
                                 const bool _bIterativeAsOnceConcurrent ) const
 {
     sal_Int16 nWrapInfluenceOnPosition( mnWrapInfluenceOnPosition );
@@ -139,9 +139,9 @@ sal_Int16 SwFmtWrapInfluenceOnObjPos::GetWrapInfluenceOnObjPos(
     return nWrapInfluenceOnPosition;
 }
 
-void SwFmtWrapInfluenceOnObjPos::dumpAsXml(xmlTextWriterPtr pWriter) const
+void SwFormatWrapInfluenceOnObjPos::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("swFmtWrapInfluenceOnObjPos"));
+    xmlTextWriterStartElement(pWriter, BAD_CAST("swFormatWrapInfluenceOnObjPos"));
     xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
     xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nWrapInfluenceOnPosition"), BAD_CAST(OString::number(mnWrapInfluenceOnPosition).getStr()));
     xmlTextWriterEndElement(pWriter);
diff --git a/sw/source/core/attr/format.cxx b/sw/source/core/attr/format.cxx
index 9344426e9b4b..f5df08fa9860 100644
--- a/sw/source/core/attr/format.cxx
+++ b/sw/source/core/attr/format.cxx
@@ -38,72 +38,72 @@
 
 using namespace com::sun::star;
 
-TYPEINIT1( SwFmt, SwClient );
+TYPEINIT1( SwFormat, SwClient );
 
-SwFmt::SwFmt( SwAttrPool& rPool, const sal_Char* pFmtNm,
-              const sal_uInt16* pWhichRanges, SwFmt *pDrvdFrm,
-              sal_uInt16 nFmtWhich )
+SwFormat::SwFormat( SwAttrPool& rPool, const sal_Char* pFormatNm,
+              const sal_uInt16* pWhichRanges, SwFormat *pDrvdFrm,
+              sal_uInt16 nFormatWhich )
     : SwModify( pDrvdFrm ),
-    m_aFmtName( OUString::createFromAscii(pFmtNm) ),
+    m_aFormatName( OUString::createFromAscii(pFormatNm) ),
     m_aSet( rPool, pWhichRanges ),
-    m_nWhichId( nFmtWhich ),
-    m_nPoolFmtId( USHRT_MAX ),
+    m_nWhichId( nFormatWhich ),
+    m_nPoolFormatId( USHRT_MAX ),
     m_nPoolHelpId( USHRT_MAX ),
     m_nPoolHlpFileId( UCHAR_MAX )
 {
-    m_bAutoUpdateFmt = false; // LAYER_IMPL
-    m_bAutoFmt = true;
-    m_bWritten = m_bFmtInDTOR = m_bHidden = false;
+    m_bAutoUpdateFormat = false; // LAYER_IMPL
+    m_bAutoFormat = true;
+    m_bWritten = m_bFormatInDTOR = m_bHidden = false;
 
     if( pDrvdFrm )
         m_aSet.SetParent( &pDrvdFrm->m_aSet );
 }
 
-SwFmt::SwFmt( SwAttrPool& rPool, const OUString& rFmtNm,
-              const sal_uInt16* pWhichRanges, SwFmt* pDrvdFrm,
-              sal_uInt16 nFmtWhich )
+SwFormat::SwFormat( SwAttrPool& rPool, const OUString& rFormatNm,
+              const sal_uInt16* pWhichRanges, SwFormat* pDrvdFrm,
+              sal_uInt16 nFormatWhich )
     : SwModify( pDrvdFrm ),
-    m_aFmtName( rFmtNm ),
+    m_aFormatName( rFormatNm ),
     m_aSet( rPool, pWhichRanges ),
-    m_nWhichId( nFmtWhich ),
-    m_nPoolFmtId( USHRT_MAX ),
+    m_nWhichId( nFormatWhich ),
+    m_nPoolFormatId( USHRT_MAX ),
     m_nPoolHelpId( USHRT_MAX ),
     m_nPoolHlpFileId( UCHAR_MAX )
 {
-    m_bAutoUpdateFmt = false; // LAYER_IMPL
-    m_bAutoFmt = true;
-    m_bWritten = m_bFmtInDTOR = m_bHidden = false;
+    m_bAutoUpdateFormat = false; // LAYER_IMPL
+    m_bAutoFormat = true;
+    m_bWritten = m_bFormatInDTOR = m_bHidden = false;
 
     if( pDrvdFrm )
         m_aSet.SetParent( &pDrvdFrm->m_aSet );
 }
 
-SwFmt::SwFmt( const SwFmt& rFmt )
-    : SwModify( rFmt.DerivedFrom() ),
-    m_aFmtName( rFmt.m_aFmtName ),
-    m_aSet( rFmt.m_aSet ),
-    m_nWhichId( rFmt.m_nWhichId ),
-    m_nPoolFmtId( rFmt.GetPoolFmtId() ),
-    m_nPoolHelpId( rFmt.GetPoolHelpId() ),
-    m_nPoolHlpFileId( rFmt.GetPoolHlpFileId() )
+SwFormat::SwFormat( const SwFormat& rFormat )
+    : SwModify( rFormat.DerivedFrom() ),
+    m_aFormatName( rFormat.m_aFormatName ),
+    m_aSet( rFormat.m_aSet ),
+    m_nWhichId( rFormat.m_nWhichId ),
+    m_nPoolFormatId( rFormat.GetPoolFormatId() ),
+    m_nPoolHelpId( rFormat.GetPoolHelpId() ),
+    m_nPoolHlpFileId( rFormat.GetPoolHlpFileId() )
 {
-    m_bWritten = m_bFmtInDTOR = false; // LAYER_IMPL
-    m_bAutoFmt = rFmt.m_bAutoFmt;
-    m_bHidden = rFmt.m_bHidden;
-    m_bAutoUpdateFmt = rFmt.m_bAutoUpdateFmt;
+    m_bWritten = m_bFormatInDTOR = false; // LAYER_IMPL
+    m_bAutoFormat = rFormat.m_bAutoFormat;
+    m_bHidden = rFormat.m_bHidden;
+    m_bAutoUpdateFormat = rFormat.m_bAutoUpdateFormat;
 
-    if( rFmt.DerivedFrom() )
-        m_aSet.SetParent( &rFmt.DerivedFrom()->m_aSet );
+    if( rFormat.DerivedFrom() )
+        m_aSet.SetParent( &rFormat.DerivedFrom()->m_aSet );
     // a few special treatments for attributes
     m_aSet.SetModifyAtAttr( this );
 }
 
-SwFmt &SwFmt::operator=(const SwFmt& rFmt)
+SwFormat &SwFormat::operator=(const SwFormat& rFormat)
 {
-    m_nWhichId = rFmt.m_nWhichId;
-    m_nPoolFmtId = rFmt.GetPoolFmtId();
-    m_nPoolHelpId = rFmt.GetPoolHelpId();
-    m_nPoolHlpFileId = rFmt.GetPoolHlpFileId();
+    m_nWhichId = rFormat.m_nWhichId;
+    m_nPoolFormatId = rFormat.GetPoolFormatId();
+    m_nPoolHelpId = rFormat.GetPoolHelpId();
+    m_nPoolHlpFileId = rFormat.GetPoolHlpFileId();
 
     if ( IsInCache() )
     {
@@ -115,8 +115,8 @@ SwFmt &SwFmt::operator=(const SwFmt& rFmt)
     // copy only array with attributes delta
     SwAttrSet aOld( *m_aSet.GetPool(), m_aSet.GetRanges() ),
               aNew( *m_aSet.GetPool(), m_aSet.GetRanges() );
-    m_aSet.Intersect_BC( rFmt.m_aSet, &aOld, &aNew );
-    (void)m_aSet.Put_BC( rFmt.m_aSet, &aOld, &aNew );
+    m_aSet.Intersect_BC( rFormat.m_aSet, &aOld, &aNew );
+    (void)m_aSet.Put_BC( rFormat.m_aSet, &aOld, &aNew );
 
     // a few special treatments for attributes
     m_aSet.SetModifyAtAttr( this );
@@ -129,39 +129,39 @@ SwFmt &SwFmt::operator=(const SwFmt& rFmt)
         ModifyNotification( &aChgOld, &aChgNew ); // send all modified ones
     }
 
-    if( GetRegisteredIn() != rFmt.GetRegisteredIn() )
+    if( GetRegisteredIn() != rFormat.GetRegisteredIn() )
     {
         if( GetRegisteredIn() )
             GetRegisteredInNonConst()->Remove(this);
-        if( rFmt.GetRegisteredIn() )
+        if( rFormat.GetRegisteredIn() )
         {
-            const_cast<SwFmt&>(rFmt).GetRegisteredInNonConst()->Add(this);
-            m_aSet.SetParent( &rFmt.m_aSet );
+            const_cast<SwFormat&>(rFormat).GetRegisteredInNonConst()->Add(this);
+            m_aSet.SetParent( &rFormat.m_aSet );
         }
         else
         {
             m_aSet.SetParent( 0 );
         }
     }
-    m_bAutoFmt = rFmt.m_bAutoFmt;
-    m_bHidden = rFmt.m_bHidden;
-    m_bAutoUpdateFmt = rFmt.m_bAutoUpdateFmt;
+    m_bAutoFormat = rFormat.m_bAutoFormat;
+    m_bHidden = rFormat.m_bHidden;
+    m_bAutoUpdateFormat = rFormat.m_bAutoUpdateFormat;
     return *this;
 }
 
-void SwFmt::SetName( const OUString& rNewName, bool bBroadcast )
+void SwFormat::SetName( const OUString& rNewName, bool bBroadcast )
 {
     OSL_ENSURE( !IsDefault(), "SetName: Defaultformat" );
     if( bBroadcast )
     {
-        SwStringMsgPoolItem aOld( RES_NAME_CHANGED, m_aFmtName );
+        SwStringMsgPoolItem aOld( RES_NAME_CHANGED, m_aFormatName );
         SwStringMsgPoolItem aNew( RES_NAME_CHANGED, rNewName );
-        m_aFmtName = rNewName;
+        m_aFormatName = rNewName;
         ModifyNotification( &aOld, &aNew );
     }
     else
     {
-        m_aFmtName = rNewName;
+        m_aFormatName = rNewName;
     }
 }
 
@@ -176,7 +176,7 @@ void SwFmt::SetName( const OUString& rNewName, bool bBroadcast )
     in which <this> is defined. Currently this is important for DropCaps
     because that contains data that needs to be copied deeply.
 */
-void SwFmt::CopyAttrs( const SwFmt& rFmt, bool bReplace )
+void SwFormat::CopyAttrs( const SwFormat& rFormat, bool bReplace )
 {
     // copy only array with attributes delta
     if ( IsInCache() )
@@ -187,12 +187,12 @@ void SwFmt::CopyAttrs( const SwFmt& rFmt, bool bReplace )
     SetInSwFntCache( false );
 
     // special treatments for some attributes
-    SwAttrSet* pChgSet = const_cast<SwAttrSet*>(&rFmt.m_aSet);
+    SwAttrSet* pChgSet = const_cast<SwAttrSet*>(&rFormat.m_aSet);
 
     if( !bReplace )     // refresh only those that are not set?
     {
-        if( pChgSet == &rFmt.m_aSet )
-            pChgSet = new SwAttrSet( rFmt.m_aSet );
+        if( pChgSet == &rFormat.m_aSet )
+            pChgSet = new SwAttrSet( rFormat.m_aSet );
         pChgSet->Differentiate( m_aSet );
     }
 
@@ -215,42 +215,42 @@ void SwFmt::CopyAttrs( const SwFmt& rFmt, bool bReplace )
         }
     }
 
-    if( pChgSet != &rFmt.m_aSet ) // was a Set created?
+    if( pChgSet != &rFormat.m_aSet ) // was a Set created?
         delete pChgSet;
 }
 
-SwFmt::~SwFmt()
+SwFormat::~SwFormat()
 {
     // This happens at a ObjectDying message. Thus put all dependent
     // ones on DerivedFrom.
     if( HasWriterListeners() )
     {
-        OSL_ENSURE( DerivedFrom(), "SwFmt::~SwFmt: Def dependents!" );
+        OSL_ENSURE( DerivedFrom(), "SwFormat::~SwFormat: Def dependents!" );
 
-        m_bFmtInDTOR = true;
+        m_bFormatInDTOR = true;
 
-        SwFmt* pParentFmt = DerivedFrom();
-        if( !pParentFmt )
+        SwFormat* pParentFormat = DerivedFrom();
+        if( !pParentFormat )
         {
             SAL_WARN(
                 "sw.core",
-                "~SwFmt: parent format missing from: " << GetName() );
+                "~SwFormat: parent format missing from: " << GetName() );
         }
         else
         {
-            SwFmtChg aOldFmt( this );
-            SwFmtChg aNewFmt( pParentFmt );
-            SwIterator<SwClient,SwFmt> aIter(*this);
-            for(SwClient* pClient = aIter.First(); pClient && pParentFmt; pClient = aIter.Next())
+            SwFormatChg aOldFormat( this );
+            SwFormatChg aNewFormat( pParentFormat );
+            SwIterator<SwClient,SwFormat> aIter(*this);
+            for(SwClient* pClient = aIter.First(); pClient && pParentFormat; pClient = aIter.Next())
             {
-                pParentFmt->Add( pClient );
-                pClient->ModifyNotification( &aOldFmt, &aNewFmt );
+                pParentFormat->Add( pClient );
+                pClient->ModifyNotification( &aOldFormat, &aNewFormat );
             }
         }
     }
 }
 
-void SwFmt::Modify( const SfxPoolItem* pOldValue, const SfxPoolItem* pNewValue )
+void SwFormat::Modify( const SfxPoolItem* pOldValue, const SfxPoolItem* pNewValue )
 {
     bool bContinue = true; // true = pass on to dependent ones
 
@@ -265,15 +265,15 @@ void SwFmt::Modify( const SfxPoolItem* pOldValue, const SfxPoolItem* pNewValue )
         {
             // If the dying object is the parent format of this format so
             // attach this to the parent of the parent
-            SwFmt* pFmt = static_cast<SwFmt*>(static_cast<const SwPtrMsgPoolItem*>(pNewValue)->pObject);
+            SwFormat* pFormat = static_cast<SwFormat*>(static_cast<const SwPtrMsgPoolItem*>(pNewValue)->pObject);
 
             // do not move if this is the topmost format
-            if( GetRegisteredIn() && GetRegisteredIn() == pFmt )
+            if( GetRegisteredIn() && GetRegisteredIn() == pFormat )
             {
-                if( pFmt->GetRegisteredIn() )
+                if( pFormat->GetRegisteredIn() )
                 {
                     // if parent so register in new parent
-                    pFmt->DerivedFrom()->Add( this );
+                    pFormat->DerivedFrom()->Add( this );
                     m_aSet.SetParent( &DerivedFrom()->m_aSet );
                 }
                 else
@@ -306,8 +306,8 @@ void SwFmt::Modify( const SfxPoolItem* pOldValue, const SfxPoolItem* pNewValue )
 
         // skip my own Modify
         if ( pOldValue && pNewValue &&
-            static_cast<const SwFmtChg*>(pOldValue)->pChangedFmt != this &&
-            static_cast<const SwFmtChg*>(pNewValue)->pChangedFmt == GetRegisteredIn() )
+            static_cast<const SwFormatChg*>(pOldValue)->pChangedFormat != this &&
+            static_cast<const SwFormatChg*>(pNewValue)->pChangedFormat == GetRegisteredIn() )
         {
             // attach Set to new parent
             m_aSet.SetParent( DerivedFrom() ? &DerivedFrom()->m_aSet : 0 );
@@ -322,7 +322,7 @@ void SwFmt::Modify( const SfxPoolItem* pOldValue, const SfxPoolItem* pNewValue )
             // mba: move the code that ignores this event to the clients
 
             // pass Hint only to dependent formats (no Frames)
-            //ModifyBroadcast( pOldValue, pNewValue, TYPE(SwFmt) );
+            //ModifyBroadcast( pOldValue, pNewValue, TYPE(SwFormat) );
             //bContinue = false;
         }
         break;
@@ -345,17 +345,17 @@ void SwFmt::Modify( const SfxPoolItem* pOldValue, const SfxPoolItem* pNewValue )
     }
 }
 
-bool SwFmt::SetDerivedFrom(SwFmt *pDerFrom)
+bool SwFormat::SetDerivedFrom(SwFormat *pDerFrom)
 {
     if ( pDerFrom )
     {
-        const SwFmt* pFmt = pDerFrom;
-        while ( pFmt != 0 )
+        const SwFormat* pFormat = pDerFrom;
+        while ( pFormat != 0 )
         {
-            if ( pFmt == this )
+            if ( pFormat == this )
                 return false;
 
-            pFmt=pFmt->DerivedFrom();
+            pFormat=pFormat->DerivedFrom();
         }
     }
     else
@@ -384,19 +384,19 @@ bool SwFmt::SetDerivedFrom(SwFmt *pDerFrom)
     pDerFrom->Add( this );
     m_aSet.SetParent( &pDerFrom->m_aSet );
 
-    SwFmtChg aOldFmt( this );
-    SwFmtChg aNewFmt( this );
-    ModifyNotification( &aOldFmt, &aNewFmt );
+    SwFormatChg aOldFormat( this );
+    SwFormatChg aNewFormat( this );
+    ModifyNotification( &aOldFormat, &aNewFormat );
 
     return true;
 }
 
-bool SwFmt::supportsFullDrawingLayerFillAttributeSet() const
+bool SwFormat::supportsFullDrawingLayerFillAttributeSet() const
 {
     return false;
 }
 
-const SfxPoolItem& SwFmt::GetFmtAttr( sal_uInt16 nWhich, bool bInParents ) const
+const SfxPoolItem& SwFormat::GetFormatAttr( sal_uInt16 nWhich, bool bInParents ) const
 {
     if (RES_BACKGROUND == nWhich && supportsFullDrawingLayerFillAttributeSet())
     {
@@ -415,12 +415,12 @@ const SfxPoolItem& SwFmt::GetFmtAttr( sal_uInt16 nWhich, bool bInParents ) const
     return m_aSet.Get( nWhich, bInParents );
 }
 
-SfxItemState SwFmt::GetItemState( sal_uInt16 nWhich, bool bSrchInParent, const SfxPoolItem **ppItem ) const
+SfxItemState SwFormat::GetItemState( sal_uInt16 nWhich, bool bSrchInParent, const SfxPoolItem **ppItem ) const
 {
     if (RES_BACKGROUND == nWhich && supportsFullDrawingLayerFillAttributeSet())
     {
         //UUUU FALLBACKBREAKHERE should not be used; instead use [XATTR_FILL_FIRST .. XATTR_FILL_LAST]
-        SAL_INFO("sw.core", "Do no longer use SvxBrushItem, instead use [XATTR_FILL_FIRST .. XATTR_FILL_LAST] FillAttributes or SwFmt::GetBackgroundStat (simple fallback is in place and used)");
+        SAL_INFO("sw.core", "Do no longer use SvxBrushItem, instead use [XATTR_FILL_FIRST .. XATTR_FILL_LAST] FillAttributes or SwFormat::GetBackgroundStat (simple fallback is in place and used)");
         const drawinglayer::attribute::SdrAllFillAttributesHelperPtr aFill = getSdrAllFillAttributesHelper();
 
         // check if the new fill attributes are used
@@ -450,7 +450,7 @@ SfxItemState SwFmt::GetItemState( sal_uInt16 nWhich, bool bSrchInParent, const S
     return m_aSet.GetItemState( nWhich, bSrchInParent, ppItem );
 }
 
-SfxItemState SwFmt::GetBackgroundState(SvxBrushItem &rItem, bool bSrchInParent) const
+SfxItemState SwFormat::GetBackgroundState(SvxBrushItem &rItem, bool bSrchInParent) const
 {
     if (supportsFullDrawingLayerFillAttributeSet())
     {
@@ -478,7 +478,7 @@ SfxItemState SwFmt::GetBackgroundState(SvxBrushItem &rItem, bool bSrchInParent)
     return eRet;
 }
 
-bool SwFmt::SetFmtAttr( const SfxPoolItem& rAttr )
+bool SwFormat::SetFormatAttr( const SfxPoolItem& rAttr )
 {
     if ( IsInCache() || IsInSwFntCache() )
     {
@@ -529,19 +529,19 @@ bool SwFmt::SetFmtAttr( const SfxPoolItem& rAttr )
     }
 
     // if Modify is locked then no modifications will be sent;
-    // but call Modify always for FrmFmts
-    const sal_uInt16 nFmtWhich = Which();
+    // but call Modify always for FrameFormats
+    const sal_uInt16 nFormatWhich = Which();
     if( IsModifyLocked() ||
         ( !HasWriterListeners() &&
-          (RES_GRFFMTCOLL == nFmtWhich  ||
-           RES_TXTFMTCOLL == nFmtWhich ) ) )
+          (RES_GRFFMTCOLL == nFormatWhich  ||
+           RES_TXTFMTCOLL == nFormatWhich ) ) )
     {
         if( ( bRet = (0 != m_aSet.Put( rAttr ))) )
             m_aSet.SetModifyAtAttr( this );
         // #i71574#
-        if ( nFmtWhich == RES_TXTFMTCOLL && rAttr.Which() == RES_PARATR_NUMRULE )
+        if ( nFormatWhich == RES_TXTFMTCOLL && rAttr.Which() == RES_PARATR_NUMRULE )
         {
-            TxtFmtCollFunc::CheckTxtFmtCollForDeletionOfAssignmentToOutlineStyle( this );
+            TextFormatCollFunc::CheckTextFormatCollForDeletionOfAssignmentToOutlineStyle( this );
         }
     }
     else
@@ -564,7 +564,7 @@ bool SwFmt::SetFmtAttr( const SfxPoolItem& rAttr )
     return bRet;
 }
 
-bool SwFmt::SetFmtAttr( const SfxItemSet& rSet )
+bool SwFormat::SetFormatAttr( const SfxItemSet& rSet )
 {
     if( !rSet.Count() )
         return false;
@@ -634,19 +634,19 @@ bool SwFmt::SetFmtAttr( const SfxItemSet& rSet )
     }
 
     // if Modify is locked then no modifications will be sent;
-    // but call Modify always for FrmFmts
-    const sal_uInt16 nFmtWhich = Which();
+    // but call Modify always for FrameFormats
+    const sal_uInt16 nFormatWhich = Which();
     if ( IsModifyLocked() ||
          ( !HasWriterListeners() &&
-           ( RES_GRFFMTCOLL == nFmtWhich ||
-             RES_TXTFMTCOLL == nFmtWhich ) ) )
+           ( RES_GRFFMTCOLL == nFormatWhich ||
+             RES_TXTFMTCOLL == nFormatWhich ) ) )
     {
         if( ( bRet = m_aSet.Put( aTempSet )) )
             m_aSet.SetModifyAtAttr( this );
         // #i71574#
-        if ( nFmtWhich == RES_TXTFMTCOLL )
+        if ( nFormatWhich == RES_TXTFMTCOLL )
         {
-            TxtFmtCollFunc::CheckTxtFmtCollForDeletionOfAssignmentToOutlineStyle( this );
+            TextFormatCollFunc::CheckTextFormatCollForDeletionOfAssignmentToOutlineStyle( this );
         }
     }
     else
@@ -667,7 +667,7 @@ bool SwFmt::SetFmtAttr( const SfxItemSet& rSet )
 }
 
 // remove Hint using nWhich from array with delta
-bool SwFmt::ResetFmtAttr( sal_uInt16 nWhich1, sal_uInt16 nWhich2 )
+bool SwFormat::ResetFormatAttr( sal_uInt16 nWhich1, sal_uInt16 nWhich2 )
 {
     if( !m_aSet.Count() )
         return false;
@@ -700,7 +700,7 @@ bool SwFmt::ResetFmtAttr( sal_uInt16 nWhich1, sal_uInt16 nWhich2 )
 }
 
 // #i73790#
-sal_uInt16 SwFmt::ResetAllFmtAttr()
+sal_uInt16 SwFormat::ResetAllFormatAttr()
 {
     if( !m_aSet.Count() )
         return 0;
@@ -728,12 +728,12 @@ sal_uInt16 SwFmt::ResetAllFmtAttr()
     return aNew.Count();
 }
 
-bool SwFmt::GetInfo( SfxPoolItem& rInfo ) const
+bool SwFormat::GetInfo( SfxPoolItem& rInfo ) const
 {
     return SwModify::GetInfo( rInfo );
 }
 
-void SwFmt::DelDiffs( const SfxItemSet& rSet )
+void SwFormat::DelDiffs( const SfxItemSet& rSet )
 {
     if( !m_aSet.Count() )
         return;
@@ -763,7 +763,7 @@ void SwFmt::DelDiffs( const SfxItemSet& rSet )
     }
 }
 
-/** SwFmt::IsBackgroundTransparent
+/** SwFormat::IsBackgroundTransparent
 
     Virtual method to determine, if background of format is transparent.
     Default implementation returns false. Thus, subclasses have to override
@@ -771,7 +771,7 @@ void SwFmt::DelDiffs( const SfxItemSet& rSet )
 
     @return false, default implementation
 */
-bool SwFmt::IsBackgroundTransparent() const
+bool SwFormat::IsBackgroundTransparent() const
 {
     return false;
 }
@@ -779,16 +779,16 @@ bool SwFmt::IsBackgroundTransparent() const
 /*
  * Document Interface Access
  */
-const IDocumentSettingAccess* SwFmt::getIDocumentSettingAccess() const { return & GetDoc()->GetDocumentSettingManager(); }
-const IDocumentDrawModelAccess* SwFmt::getIDocumentDrawModelAccess() const { return & GetDoc()->getIDocumentDrawModelAccess(); }
-IDocumentDrawModelAccess* SwFmt::getIDocumentDrawModelAccess() { return & GetDoc()->getIDocumentDrawModelAccess(); }
-const IDocumentLayoutAccess* SwFmt::getIDocumentLayoutAccess() const { return &GetDoc()->getIDocumentLayoutAccess(); }
-IDocumentLayoutAccess* SwFmt::getIDocumentLayoutAccess() { return &GetDoc()->getIDocumentLayoutAccess(); }
-IDocumentTimerAccess* SwFmt::getIDocumentTimerAccess() { return & GetDoc()->getIDocumentTimerAccess(); }
-IDocumentFieldsAccess* SwFmt::getIDocumentFieldsAccess() { return &GetDoc()->getIDocumentFieldsAccess(); }
-IDocumentChartDataProviderAccess* SwFmt::getIDocumentChartDataProviderAccess() { return & GetDoc()->getIDocumentChartDataProviderAccess(); }
-
-void SwFmt::GetGrabBagItem(uno::Any& rVal) const
+const IDocumentSettingAccess* SwFormat::getIDocumentSettingAccess() const { return & GetDoc()->GetDocumentSettingManager(); }
+const IDocumentDrawModelAccess* SwFormat::getIDocumentDrawModelAccess() const { return & GetDoc()->getIDocumentDrawModelAccess(); }
+IDocumentDrawModelAccess* SwFormat::getIDocumentDrawModelAccess() { return & GetDoc()->getIDocumentDrawModelAccess(); }
+const IDocumentLayoutAccess* SwFormat::getIDocumentLayoutAccess() const { return &GetDoc()->getIDocumentLayoutAccess(); }
+IDocumentLayoutAccess* SwFormat::getIDocumentLayoutAccess() { return &GetDoc()->getIDocumentLayoutAccess(); }
+IDocumentTimerAccess* SwFormat::getIDocumentTimerAccess() { return & GetDoc()->getIDocumentTimerAccess(); }
+IDocumentFieldsAccess* SwFormat::getIDocumentFieldsAccess() { return &GetDoc()->getIDocumentFieldsAccess(); }
+IDocumentChartDataProviderAccess* SwFormat::getIDocumentChartDataProviderAccess() { return & GetDoc()->getIDocumentChartDataProviderAccess(); }
+
+void SwFormat::GetGrabBagItem(uno::Any& rVal) const
 {
     if (m_pGrabBagItem.get())
         m_pGrabBagItem->QueryValue(rVal);
@@ -799,7 +799,7 @@ void SwFmt::GetGrabBagItem(uno::Any& rVal) const
     }
 }
 
-void SwFmt::SetGrabBagItem(const uno::Any& rVal)
+void SwFormat::SetGrabBagItem(const uno::Any& rVal)
 {
     if (!m_pGrabBagItem.get())
         m_pGrabBagItem.reset(new SfxGrabBagItem);
@@ -808,7 +808,7 @@ void SwFmt::SetGrabBagItem(const uno::Any& rVal)
 }
 
 //UUUU
-SvxBrushItem SwFmt::makeBackgroundBrushItem(bool bInP) const
+SvxBrushItem SwFormat::makeBackgroundBrushItem(bool bInP) const
 {
     if (supportsFullDrawingLayerFillAttributeSet())
     {
@@ -825,7 +825,7 @@ SvxBrushItem SwFmt::makeBackgroundBrushItem(bool bInP) const
 }
 
 //UUUU
-drawinglayer::attribute::SdrAllFillAttributesHelperPtr SwFmt::getSdrAllFillAttributesHelper() const
+drawinglayer::attribute::SdrAllFillAttributesHelperPtr SwFormat::getSdrAllFillAttributesHelper() const
 {
     return drawinglayer::attribute::SdrAllFillAttributesHelperPtr();
 }
diff --git a/sw/source/core/attr/hints.cxx b/sw/source/core/attr/hints.cxx
index c1e79806fdd2..266e2f155170 100644
--- a/sw/source/core/attr/hints.cxx
+++ b/sw/source/core/attr/hints.cxx
@@ -24,12 +24,12 @@
 #include <ndtxt.hxx>
 #include <swtypes.hxx>
 
-SwFmtChg::SwFmtChg( SwFmt* pFmt )
-    : SwMsgPoolItem( RES_FMT_CHG ), pChangedFmt( pFmt )
+SwFormatChg::SwFormatChg( SwFormat* pFormat )
+    : SwMsgPoolItem( RES_FMT_CHG ), pChangedFormat( pFormat )
 {
 }
 
-SwInsTxt::SwInsTxt( sal_Int32 nP, sal_Int32 nL )
+SwInsText::SwInsText( sal_Int32 nP, sal_Int32 nL )
     : SwMsgPoolItem( RES_INS_TXT ), nPos( nP ), nLen( nL )
 {
 }
@@ -39,17 +39,17 @@ SwDelChr::SwDelChr( sal_Int32 nP )
 {
 }
 
-SwDelTxt::SwDelTxt( sal_Int32 nS, sal_Int32 nL )
+SwDelText::SwDelText( sal_Int32 nS, sal_Int32 nL )
     : SwMsgPoolItem( RES_DEL_TXT ), nStart( nS ), nLen( nL )
 {
 }
 
 SwUpdateAttr::SwUpdateAttr( sal_Int32 nS, sal_Int32 nE, sal_uInt16 nW )
-    : SwMsgPoolItem( RES_UPDATE_ATTR ), nStart( nS ), nEnd( nE ), nWhichAttr( nW ), aWhichFmtAttr()
+    : SwMsgPoolItem( RES_UPDATE_ATTR ), nStart( nS ), nEnd( nE ), nWhichAttr( nW ), aWhichFormatAttr()
 {
 }
 
-SwRefMarkFldUpdate::SwRefMarkFldUpdate( OutputDevice* pOutput )
+SwRefMarkFieldUpdate::SwRefMarkFieldUpdate( OutputDevice* pOutput )
     : SwMsgPoolItem( RES_REFMARKFLD_UPDATE ),
     pOut( pOutput )
 {
@@ -61,18 +61,18 @@ SwDocPosUpdate::SwDocPosUpdate( const SwTwips nDcPos )
 {
 }
 
-SwTableFmlUpdate::SwTableFmlUpdate( const SwTable* pNewTbl )
+SwTableFormulaUpdate::SwTableFormulaUpdate( const SwTable* pNewTable )
     : SwMsgPoolItem( RES_TABLEFML_UPDATE ),
-    pTbl( pNewTbl ), pHistory( 0 ), nSplitLine( USHRT_MAX ),
+    pTable( pNewTable ), pHistory( 0 ), nSplitLine( USHRT_MAX ),
     eFlags( TBL_CALC )
 {
-    DATA.pDelTbl = 0;
+    DATA.pDelTable = 0;
     bModified = bBehindSplitLine = false;
-    OSL_ENSURE( pTbl, "No Table pointer" );
+    OSL_ENSURE( pTable, "No Table pointer" );
 }
 
-SwAutoFmtGetDocNode::SwAutoFmtGetDocNode( const SwNodes* pNds )
-    : SwMsgPoolItem( RES_AUTOFMT_DOCNODE ), pCntntNode( 0 ), pNodes( pNds )
+SwAutoFormatGetDocNode::SwAutoFormatGetDocNode( const SwNodes* pNds )
+    : SwMsgPoolItem( RES_AUTOFMT_DOCNODE ), pContentNode( 0 ), pNodes( pNds )
 {
 }
 
@@ -129,7 +129,7 @@ const SfxPoolItem* GetDfltAttr( sal_uInt16 nWhich )
     OSL_ASSERT( nWhich < POOLATTR_END && nWhich >= POOLATTR_BEGIN );
 
     SfxPoolItem *pHt = aAttrTab[ nWhich - POOLATTR_BEGIN ];
-    OSL_ENSURE( pHt, "GetDfltFmtAttr(): Dflt == 0" );
+    OSL_ENSURE( pHt, "GetDfltFormatAttr(): Dflt == 0" );
     return pHt;
 }
 #else
@@ -139,8 +139,8 @@ const SfxPoolItem* GetDfltAttr( sal_uInt16 nWhich )
 }
 #endif
 
-SwCondCollCondChg::SwCondCollCondChg( SwFmt *pFmt )
-    : SwMsgPoolItem( RES_CONDCOLL_CONDCHG ), pChangedFmt( pFmt )
+SwCondCollCondChg::SwCondCollCondChg( SwFormat *pFormat )
+    : SwMsgPoolItem( RES_CONDCOLL_CONDCHG ), pChangedFormat( pFormat )
 {
 }
 
diff --git a/sw/source/core/attr/swatrset.cxx b/sw/source/core/attr/swatrset.cxx
index 8631b06e784c..13806f1a5b25 100644
--- a/sw/source/core/attr/swatrset.cxx
+++ b/sw/source/core/attr/swatrset.cxx
@@ -254,8 +254,8 @@ void  SwAttrSet::Changed( const SfxPoolItem& rOld, const SfxPoolItem& rNew )
 /** special treatment for some attributes
 
     Set the Modify pointer (old pDefinedIn) for the following attributes:
-     - SwFmtDropCaps
-     - SwFmtPageDesc
+     - SwFormatDropCaps
+     - SwFormatPageDesc
 
     (Is called at inserts into formats/nodes)
 */
@@ -265,32 +265,32 @@ bool SwAttrSet::SetModifyAtAttr( const SwModify* pModify )
 
     const SfxPoolItem* pItem;
     if( SfxItemState::SET == GetItemState( RES_PAGEDESC, false, &pItem ) &&
-        static_cast<const SwFmtPageDesc*>(pItem)->GetDefinedIn() != pModify  )
+        static_cast<const SwFormatPageDesc*>(pItem)->GetDefinedIn() != pModify  )
     {
-        const_cast<SwFmtPageDesc*>(static_cast<const SwFmtPageDesc*>(pItem))->ChgDefinedIn( pModify );
+        const_cast<SwFormatPageDesc*>(static_cast<const SwFormatPageDesc*>(pItem))->ChgDefinedIn( pModify );
         bSet = true;
     }
 
     if( SfxItemState::SET == GetItemState( RES_PARATR_DROP, false, &pItem ) &&
-        static_cast<const SwFmtDrop*>(pItem)->GetDefinedIn() != pModify )
+        static_cast<const SwFormatDrop*>(pItem)->GetDefinedIn() != pModify )
     {
         // If CharFormat is set and it is set in different attribute pools then
         // the CharFormat has to be copied.
-        SwCharFmt* pCharFmt;
-        if( 0 != ( pCharFmt = const_cast<SwFmtDrop*>(static_cast<const SwFmtDrop*>(pItem))->GetCharFmt() )
-            && GetPool() != pCharFmt->GetAttrSet().GetPool() )
+        SwCharFormat* pCharFormat;
+        if( 0 != ( pCharFormat = const_cast<SwFormatDrop*>(static_cast<const SwFormatDrop*>(pItem))->GetCharFormat() )
+            && GetPool() != pCharFormat->GetAttrSet().GetPool() )
         {
-           pCharFmt = GetDoc()->CopyCharFmt( *pCharFmt );
-           const_cast<SwFmtDrop*>(static_cast<const SwFmtDrop*>(pItem))->SetCharFmt( pCharFmt );
+           pCharFormat = GetDoc()->CopyCharFormat( *pCharFormat );
+           const_cast<SwFormatDrop*>(static_cast<const SwFormatDrop*>(pItem))->SetCharFormat( pCharFormat );
         }
-        const_cast<SwFmtDrop*>(static_cast<const SwFmtDrop*>(pItem))->ChgDefinedIn( pModify );
+        const_cast<SwFormatDrop*>(static_cast<const SwFormatDrop*>(pItem))->ChgDefinedIn( pModify );
         bSet = true;
     }
 
     if( SfxItemState::SET == GetItemState( RES_BOXATR_FORMULA, false, &pItem ) &&
-        static_cast<const SwTblBoxFormula*>(pItem)->GetDefinedIn() != pModify )
+        static_cast<const SwTableBoxFormula*>(pItem)->GetDefinedIn() != pModify )
     {
-        const_cast<SwTblBoxFormula*>(static_cast<const SwTblBoxFormula*>(pItem))->ChgDefinedIn( pModify );
+        const_cast<SwTableBoxFormula*>(static_cast<const SwTableBoxFormula*>(pItem))->ChgDefinedIn( pModify );
         bSet = true;
     }
 
@@ -300,10 +300,10 @@ bool SwAttrSet::SetModifyAtAttr( const SwModify* pModify )
 void SwAttrSet::CopyToModify( SwModify& rMod ) const
 {
     // copy attributes across multiple documents if needed
-    SwCntntNode* pCNd = PTR_CAST( SwCntntNode, &rMod );
-    SwFmt* pFmt = PTR_CAST( SwFmt, &rMod );
+    SwContentNode* pCNd = PTR_CAST( SwContentNode, &rMod );
+    SwFormat* pFormat = PTR_CAST( SwFormat, &rMod );
 
-    if( pCNd || pFmt )
+    if( pCNd || pFormat )
     {
         if( Count() )
         {
@@ -312,7 +312,7 @@ void SwAttrSet::CopyToModify( SwModify& rMod ) const
 
             const SfxPoolItem* pItem;
             const SwDoc *pSrcDoc = GetDoc();
-            SwDoc *pDstDoc = pCNd ? pCNd->GetDoc() : pFmt->GetDoc();
+            SwDoc *pDstDoc = pCNd ? pCNd->GetDoc() : pFormat->GetDoc();
 
             // Does the NumRule has to be copied?
             if( pSrcDoc != pDstDoc &&
@@ -332,7 +332,7 @@ void SwAttrSet::CopyToModify( SwModify& rMod ) const
             // copy list and if needed also the corresponding list style
             // for text nodes
             if ( pSrcDoc != pDstDoc &&
-                 pCNd && pCNd->IsTxtNode() &&
+                 pCNd && pCNd->IsTextNode() &&
                  GetItemState( RES_PARATR_LIST_ID, false, &pItem ) == SfxItemState::SET )
             {
                 const OUString& sListId =
@@ -383,7 +383,7 @@ void SwAttrSet::CopyToModify( SwModify& rMod ) const
             const SwPageDesc* pPgDesc;
             if( pSrcDoc != pDstDoc && SfxItemState::SET == GetItemState(
                                             RES_PAGEDESC, false, &pItem ) &&
-                0 != ( pPgDesc = static_cast<const SwFmtPageDesc*>(pItem)->GetPageDesc()) )
+                0 != ( pPgDesc = static_cast<const SwFormatPageDesc*>(pItem)->GetPageDesc()) )
             {
                 if( !tmpSet )
                     tmpSet.reset( new SfxItemSet( *this ));
@@ -394,13 +394,13 @@ void SwAttrSet::CopyToModify( SwModify& rMod ) const
                     pDstPgDesc = pDstDoc->MakePageDesc(pPgDesc->GetName());
                     pDstDoc->CopyPageDesc( *pPgDesc, *pDstPgDesc );
                 }
-                SwFmtPageDesc aDesc( pDstPgDesc );
-                aDesc.SetNumOffset( static_cast<const SwFmtPageDesc*>(pItem)->GetNumOffset() );
+                SwFormatPageDesc aDesc( pDstPgDesc );
+                aDesc.SetNumOffset( static_cast<const SwFormatPageDesc*>(pItem)->GetNumOffset() );
                 tmpSet->Put( aDesc );
             }
 
             if( pSrcDoc != pDstDoc && SfxItemState::SET == GetItemState( RES_ANCHOR, false, &pItem )
-                && static_cast< const SwFmtAnchor* >( pItem )->GetCntntAnchor() != NULL )
+                && static_cast< const SwFormatAnchor* >( pItem )->GetContentAnchor() != NULL )
             {
                 if( !tmpSet )
                     tmpSet.reset( new SfxItemSet( *this ));
@@ -422,7 +422,7 @@ void SwAttrSet::CopyToModify( SwModify& rMod ) const
                 }
                 else
                 {
-                    pFmt->SetFmtAttr( *tmpSet );
+                    pFormat->SetFormatAttr( *tmpSet );
                 }
             }
             else if( pCNd )
@@ -441,7 +441,7 @@ void SwAttrSet::CopyToModify( SwModify& rMod ) const
             }
             else
             {
-                pFmt->SetFmtAttr( *this );
+                pFormat->SetFormatAttr( *this );
             }
 
             // #i92811#