Remove VALIDTAB and other similar macros

Change-Id: I57e4ca031553bfeb2abfbf48a7cb024b6d8b0b5b

15 files changed, 115 insertions, 118 deletions

diff --git a/sc/inc/address.hxx b/sc/inc/address.hxx
index 5f7c83f07397..a45b346d4a9e 100644
--- a/sc/inc/address.hxx
+++ b/sc/inc/address.hxx
@@ -121,11 +121,6 @@ const SCROW W16MAXROW = W16MAXROWCOUNT - 1;
 #define MAXROW      W16MAXROW
 #endif
 
-#define VALIDCOL(nCol)                  (ValidCol(nCol))
-#define VALIDROW(nRow)                  (ValidRow(nRow))
-#define VALIDTAB(nTab)                  (ValidTab(nTab))
-#define VALIDCOLROW(nCol,nRow)          (ValidColRow(nCol,nRow))
-
 // === old stuff defines end =================================================
 
 inline bool ValidCol( SCCOL nCol )
diff --git a/sc/source/core/data/attarray.cxx b/sc/source/core/data/attarray.cxx
index c450509394d8..f8f982a6358f 100644
--- a/sc/source/core/data/attarray.cxx
+++ b/sc/source/core/data/attarray.cxx
@@ -240,7 +240,7 @@ const ScPatternAttr* ScAttrArray::GetPatternRange( SCROW& rStartRow,
 
 void ScAttrArray::AddCondFormat( SCROW nStartRow, SCROW nEndRow, sal_uInt32 nIndex )
 {
-    if(!VALIDROW(nStartRow) || !VALIDROW(nEndRow))
+    if(!ValidRow(nStartRow) || !ValidRow(nEndRow))
         return;
 
     if(nEndRow < nStartRow)
@@ -291,7 +291,7 @@ void ScAttrArray::AddCondFormat( SCROW nStartRow, SCROW nEndRow, sal_uInt32 nInd
 
 void ScAttrArray::RemoveCondFormat( SCROW nStartRow, SCROW nEndRow, sal_uInt32 nIndex )
 {
-    if(!VALIDROW(nStartRow) || !VALIDROW(nEndRow))
+    if(!ValidRow(nStartRow) || !ValidRow(nEndRow))
         return;
 
     if(nEndRow < nStartRow)
@@ -1670,7 +1670,7 @@ void ScAttrArray::ChangeIndent( SCROW nStartRow, SCROW nEndRow, bool bIncrement
 SCsROW ScAttrArray::GetNextUnprotected( SCsROW nRow, bool bUp ) const
 {
     long nRet = nRow;
-    if (VALIDROW(nRow))
+    if (ValidRow(nRow))
     {
         SCSIZE nIndex;
         Search(nRow, nIndex);
@@ -2309,7 +2309,7 @@ SCsROW ScAttrArray::SearchStyle(
     if (pMarkArray)
     {
         nRow = pMarkArray->GetNextMarked( nRow, bUp );
-        if (!VALIDROW(nRow))
+        if (!ValidRow(nRow))
             return nRow;
     }
 
@@ -2369,7 +2369,7 @@ bool ScAttrArray::SearchStyleRange(
     const ScMarkArray* pMarkArray) const
 {
     SCsROW nStartRow = SearchStyle( rRow, pSearchStyle, bUp, pMarkArray );
-    if (VALIDROW(nStartRow))
+    if (ValidRow(nStartRow))
     {
         SCSIZE nIndex;
         Search(nStartRow,nIndex);
diff --git a/sc/source/core/data/column3.cxx b/sc/source/core/data/column3.cxx
index 043cec9f9d15..7976996ee5b5 100644
--- a/sc/source/core/data/column3.cxx
+++ b/sc/source/core/data/column3.cxx
@@ -1643,7 +1643,7 @@ void ScColumn::RemoveProtected( SCROW nStartRow, SCROW nEndRow )
 
 void ScColumn::SetError( SCROW nRow, const sal_uInt16 nError)
 {
-    if (VALIDROW(nRow))
+    if (ValidRow(nRow))
     {
         ScFormulaCell* pCell = new ScFormulaCell
             ( pDocument, ScAddress( nCol, nRow, nTab ) );
@@ -1655,7 +1655,7 @@ void ScColumn::SetError( SCROW nRow, const sal_uInt16 nError)
 
 void ScColumn::SetValue( SCROW nRow, const double& rVal)
 {
-    if (VALIDROW(nRow))
+    if (ValidRow(nRow))
     {
         ScBaseCell* pCell = new ScValueCell(rVal);
         Insert( nRow, pCell );
diff --git a/sc/source/core/data/documen2.cxx b/sc/source/core/data/documen2.cxx
index f182316f0781..a995d126dbf9 100644
--- a/sc/source/core/data/documen2.cxx
+++ b/sc/source/core/data/documen2.cxx
@@ -576,7 +576,7 @@ void ScDocument::ResetClip( ScDocument* pSourceDoc, SCTAB nTab )
 void ScDocument::PutCell( SCCOL nCol, SCROW nRow, SCTAB nTab,
                           ScBaseCell* pCell, sal_uLong nFormatIndex, bool bForceTab )
 {
-    if (VALIDTAB(nTab))
+    if (ValidTab(nTab))
     {
         if ( bForceTab && ( nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab] ) )
         {
@@ -697,7 +697,7 @@ bool ScDocument::MoveTab( SCTAB nOldPos, SCTAB nNewPos, ScProgress* pProgress )
         return false;
 
     bool bValid = false;
-    if (VALIDTAB(nOldPos) && nOldPos < nTabCount )
+    if (ValidTab(nOldPos) && nOldPos < nTabCount )
     {
         if (maTabs[nOldPos])
         {
@@ -792,7 +792,7 @@ bool ScDocument::CopyTab( SCTAB nOldPos, SCTAB nNewPos, const ScMarkData* pOnlyM
         }
         else
         {
-            if (VALIDTAB(nNewPos) && (nNewPos < static_cast<SCTAB>(maTabs.size())))
+            if (ValidTab(nNewPos) && (nNewPos < static_cast<SCTAB>(maTabs.size())))
             {
                 SetNoListening( true );
 
@@ -925,7 +925,7 @@ sal_uLong ScDocument::TransferTab( ScDocument* pSrcDoc, SCTAB nSrcPos,
     }
     else                        // bestehende Tabelle ersetzen
     {
-        if (VALIDTAB(nDestPos) && nDestPos < static_cast<SCTAB>(maTabs.size()) && maTabs[nDestPos])
+        if (ValidTab(nDestPos) && nDestPos < static_cast<SCTAB>(maTabs.size()) && maTabs[nDestPos])
         {
             maTabs[nDestPos]->DeleteArea( 0,0, MAXCOL,MAXROW, IDF_ALL );
         }
@@ -1033,7 +1033,7 @@ sal_uLong ScDocument::TransferTab( ScDocument* pSrcDoc, SCTAB nSrcPos,
 
 void ScDocument::SetError( SCCOL nCol, SCROW nRow, SCTAB nTab, const sal_uInt16 nError)
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
         if (maTabs[nTab])
             maTabs[nTab]->SetError( nCol, nRow, nError );
 }
diff --git a/sc/source/core/data/documen3.cxx b/sc/source/core/data/documen3.cxx
index dfe5fe826ab9..944241b0bc72 100644
--- a/sc/source/core/data/documen3.cxx
+++ b/sc/source/core/data/documen3.cxx
@@ -434,7 +434,7 @@ void ScDocument::GetScenarioData( SCTAB nTab, rtl::OUString& rComment,
 
 void ScDocument::GetScenarioFlags( SCTAB nTab, sal_uInt16& rFlags ) const
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && maTabs[nTab]->IsScenario())
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && maTabs[nTab]->IsScenario())
         rFlags = maTabs[nTab]->GetScenarioFlags();
 }
 
@@ -617,14 +617,14 @@ ScFormulaParserPool& ScDocument::GetFormulaParserPool() const
 
 const ScSheetEvents* ScDocument::GetSheetEvents( SCTAB nTab ) const
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
         return maTabs[nTab]->GetSheetEvents();
     return NULL;
 }
 
 void ScDocument::SetSheetEvents( SCTAB nTab, const ScSheetEvents* pNew )
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
         maTabs[nTab]->SetSheetEvents( pNew );
 }
 
@@ -672,7 +672,7 @@ bool ScDocument::HasAnyCalcNotification() const
 
 bool ScDocument::HasCalcNotification( SCTAB nTab ) const
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
         return maTabs[nTab]->GetCalcNotification();
     return false;
 }
@@ -680,7 +680,7 @@ bool ScDocument::HasCalcNotification( SCTAB nTab ) const
 void ScDocument::SetCalcNotification( SCTAB nTab )
 {
     // set only if not set before
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && !maTabs[nTab]->GetCalcNotification())
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && !maTabs[nTab]->GetCalcNotification())
         maTabs[nTab]->SetCalcNotification(true);
 }
 
@@ -696,7 +696,7 @@ ScOutlineTable* ScDocument::GetOutlineTable( SCTAB nTab, bool bCreate )
 {
     ScOutlineTable* pVal = NULL;
 
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
         if (maTabs[nTab])
         {
             pVal = maTabs[nTab]->GetOutlineTable();
@@ -713,30 +713,30 @@ ScOutlineTable* ScDocument::GetOutlineTable( SCTAB nTab, bool bCreate )
 
 bool ScDocument::SetOutlineTable( SCTAB nTab, const ScOutlineTable* pNewOutline )
 {
-    return VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && maTabs[nTab]->SetOutlineTable(pNewOutline);
+    return ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && maTabs[nTab]->SetOutlineTable(pNewOutline);
 }
 
 void ScDocument::DoAutoOutline( SCCOL nStartCol, SCROW nStartRow,
                                 SCCOL nEndCol, SCROW nEndRow, SCTAB nTab )
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
         maTabs[nTab]->DoAutoOutline( nStartCol, nStartRow, nEndCol, nEndRow );
 }
 
 bool ScDocument::TestRemoveSubTotals( SCTAB nTab, const ScSubTotalParam& rParam )
 {
-    return VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && maTabs[nTab]->TestRemoveSubTotals( rParam );
+    return ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && maTabs[nTab]->TestRemoveSubTotals( rParam );
 }
 
 void ScDocument::RemoveSubTotals( SCTAB nTab, ScSubTotalParam& rParam )
 {
-    if ( VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
+    if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
         maTabs[nTab]->RemoveSubTotals( rParam );
 }
 
 bool ScDocument::DoSubTotals( SCTAB nTab, ScSubTotalParam& rParam )
 {
-    return VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && maTabs[nTab]->DoSubTotals( rParam );
+    return ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && maTabs[nTab]->DoSubTotals( rParam );
 }
 
 bool ScDocument::HasSubTotalCells( const ScRange& rRange )
@@ -981,7 +981,7 @@ void ScDocument::UpdateReference( UpdateRefMode eUpdateRefMode,
     PutInOrder( nCol1, nCol2 );
     PutInOrder( nRow1, nRow2 );
     PutInOrder( nTab1, nTab2 );
-    if (VALIDTAB(nTab1) && VALIDTAB(nTab2))
+    if (ValidTab(nTab1) && ValidTab(nTab2))
     {
         bool bExpandRefsOld = IsExpandRefs();
         if ( eUpdateRefMode == URM_INSDEL && (nDx > 0 || nDy > 0 || nDz > 0) )
@@ -1136,7 +1136,7 @@ void ScDocument::AutoFormat( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SC
 void ScDocument::GetAutoFormatData(SCTAB nTab, SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
                                     ScAutoFormatData& rData)
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
     {
         if (maTabs[nTab])
         {
@@ -1243,7 +1243,7 @@ bool ScDocument::SearchAndReplace(
     bool bFound = false;
     if (rTab >= static_cast<SCTAB>(maTabs.size()))
         OSL_FAIL("table out of range");
-    if (VALIDTAB(rTab))
+    if (ValidTab(rTab))
     {
         SCCOL nCol;
         SCROW nRow;
@@ -1411,13 +1411,13 @@ bool ScDocument::HasAutoFilter( SCCOL nCurCol, SCROW nCurRow, SCTAB nCurTab )
 bool ScDocument::HasColHeader( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
                                     SCTAB nTab )
 {
-    return VALIDTAB(nTab) && maTabs[nTab] && maTabs[nTab]->HasColHeader( nStartCol, nStartRow, nEndCol, nEndRow );
+    return ValidTab(nTab) && maTabs[nTab] && maTabs[nTab]->HasColHeader( nStartCol, nStartRow, nEndCol, nEndRow );
 }
 
 bool ScDocument::HasRowHeader( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
                                     SCTAB nTab )
 {
-    return VALIDTAB(nTab) && maTabs[nTab] && maTabs[nTab]->HasRowHeader( nStartCol, nStartRow, nEndCol, nEndRow );
+    return ValidTab(nTab) && maTabs[nTab] && maTabs[nTab]->HasRowHeader( nStartCol, nStartRow, nEndCol, nEndRow );
 }
 
 //
@@ -1804,7 +1804,7 @@ bool ScDocument::IsDocEditable() const
 
 bool ScDocument::IsTabProtected( SCTAB nTab ) const
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
         return maTabs[nTab]->IsProtected();
 
     OSL_FAIL("Falsche Tabellennummer");
@@ -1813,7 +1813,7 @@ bool ScDocument::IsTabProtected( SCTAB nTab ) const
 
 ScTableProtection* ScDocument::GetTabProtection( SCTAB nTab ) const
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
         return maTabs[nTab]->GetProtection();
 
     return NULL;
diff --git a/sc/source/core/data/documen4.cxx b/sc/source/core/data/documen4.cxx
index a79552f685a7..9356e775ea89 100644
--- a/sc/source/core/data/documen4.cxx
+++ b/sc/source/core/data/documen4.cxx
@@ -55,7 +55,7 @@ bool ScDocument::Solver(SCCOL nFCol, SCROW nFRow, SCTAB nFTab,
     bool bRet = false;
     nX = 0.0;
     if (ValidColRow(nFCol, nFRow) && ValidColRow(nVCol, nVRow) &&
-        VALIDTAB(nFTab) && VALIDTAB(nVTab) &&
+        ValidTab(nFTab) && ValidTab(nVTab) &&
         nFTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nFTab] &&
         nVTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nVTab])
     {
@@ -576,7 +576,7 @@ sal_uLong ScDocument::AddCondFormat( ScConditionalFormat* pNew, SCTAB nTab )
     if(!pNew)
         return 0;
 
-    if(VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
+    if(ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
         return maTabs[nTab]->AddCondFormat( pNew );
 
     return 0;
@@ -702,7 +702,7 @@ ScConditionalFormat* ScDocument::GetCondFormat(
 
 ScConditionalFormatList* ScDocument::GetCondFormList(SCTAB nTab) const
 {
-    if(VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
+    if(ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
         return maTabs[nTab]->GetCondFormList();
 
     return NULL;
@@ -710,7 +710,7 @@ ScConditionalFormatList* ScDocument::GetCondFormList(SCTAB nTab) const
 
 void ScDocument::SetCondFormList( ScConditionalFormatList* pList, SCTAB nTab )
 {
-    if(VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
+    if(ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
         maTabs[nTab]->SetCondFormList(pList);
 }
 
@@ -725,7 +725,7 @@ const ScValidationData* ScDocument::GetValidationEntry( sal_uLong nIndex ) const
 
 void ScDocument::DeleteConditionalFormat(sal_uLong nOldIndex, SCTAB nTab)
 {
-    if(VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
+    if(ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
         maTabs[nTab]->DeleteConditionalFormat(nOldIndex);
 }
 
diff --git a/sc/source/core/data/documen5.cxx b/sc/source/core/data/documen5.cxx
index c4ca715a509e..d2bcac185f19 100644
--- a/sc/source/core/data/documen5.cxx
+++ b/sc/source/core/data/documen5.cxx
@@ -623,7 +623,7 @@ void ScDocument::SetChartRangeList( const rtl::OUString& rChartName,
 
 bool ScDocument::HasData( SCCOL nCol, SCROW nRow, SCTAB nTab )
 {
-    if ( VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
+    if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
         return maTabs[nTab]->HasData( nCol, nRow );
     else
         return false;
diff --git a/sc/source/core/data/documen7.cxx b/sc/source/core/data/documen7.cxx
index c67d3723d8b8..5a8bed3ed0f1 100644
--- a/sc/source/core/data/documen7.cxx
+++ b/sc/source/core/data/documen7.cxx
@@ -200,7 +200,7 @@ void ScDocument::StartListeningCell( const ScAddress& rAddress,
 {
     OSL_ENSURE(pListener, "StartListeningCell: pListener Null");
     SCTAB nTab = rAddress.Tab();
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
         maTabs[nTab]->StartListening( rAddress, pListener );
 }
 
@@ -209,7 +209,7 @@ void ScDocument::EndListeningCell( const ScAddress& rAddress,
 {
     OSL_ENSURE(pListener, "EndListeningCell: pListener Null");
     SCTAB nTab = rAddress.Tab();
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
         maTabs[nTab]->EndListening( rAddress, pListener );
 }
 
diff --git a/sc/source/core/data/document.cxx b/sc/source/core/data/document.cxx
index 8667b3fa1b3c..cc7883b9e628 100644
--- a/sc/source/core/data/document.cxx
+++ b/sc/source/core/data/document.cxx
@@ -156,7 +156,7 @@ void ScDocument::MakeTable( SCTAB nTab,bool _bNeedsNameCheck )
 
 bool ScDocument::HasTable( SCTAB nTab ) const
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
         if (maTabs[nTab])
             return true;
 
@@ -165,7 +165,7 @@ bool ScDocument::HasTable( SCTAB nTab ) const
 
 bool ScDocument::GetName( SCTAB nTab, rtl::OUString& rName ) const
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
         if (maTabs[nTab])
         {
             maTabs[nTab]->GetName( rName );
@@ -185,7 +185,7 @@ rtl::OUString ScDocument::GetCopyTabName( SCTAB nTab ) const
 
 bool ScDocument::SetCodeName( SCTAB nTab, const rtl::OUString& rName )
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
     {
         if (maTabs[nTab])
         {
@@ -199,7 +199,7 @@ bool ScDocument::SetCodeName( SCTAB nTab, const rtl::OUString& rName )
 
 bool ScDocument::GetCodeName( SCTAB nTab, rtl::OUString& rName ) const
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
         if (maTabs[nTab])
         {
             maTabs[nTab]->GetCodeName( rName );
@@ -228,14 +228,14 @@ bool ScDocument::GetTable( const rtl::OUString& rName, SCTAB& rTab ) const
 
 ScDBData* ScDocument::GetAnonymousDBData(SCTAB nTab)
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
         return maTabs[nTab]->GetAnonymousDBData();
     return NULL;
 }
 
 void ScDocument::SetAnonymousDBData(SCTAB nTab, ScDBData* pDBData)
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
         maTabs[nTab]->SetAnonymousDBData(pDBData);
 }
 
@@ -430,7 +430,7 @@ bool ScDocument::InsertTab( SCTAB nPos, const rtl::OUString& rName,
         }
         else
         {
-            if (VALIDTAB(nPos) && (nPos < nTabCount))
+            if (ValidTab(nPos) && (nPos < nTabCount))
             {
                 ScRange aRange( 0,0,nPos, MAXCOL,MAXROW,MAXTAB );
                 xColNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,1 );
@@ -515,7 +515,7 @@ bool ScDocument::InsertTabs( SCTAB nPos, const std::vector<rtl::OUString>& rName
         }
         else
         {
-            if (VALIDTAB(nPos) && (nPos < nTabCount))
+            if (ValidTab(nPos) && (nPos < nTabCount))
             {
                 ScRange aRange( 0,0,nPos, MAXCOL,MAXROW,MAXTAB );
                 xColNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,nNewSheets );
@@ -582,7 +582,7 @@ bool ScDocument::InsertTabs( SCTAB nPos, const std::vector<rtl::OUString>& rName
 bool ScDocument::DeleteTab( SCTAB nTab, ScDocument* pRefUndoDoc )
 {
     bool bValid = false;
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
     {
         if (maTabs[nTab])
         {
@@ -667,7 +667,7 @@ bool ScDocument::DeleteTab( SCTAB nTab, ScDocument* pRefUndoDoc )
 bool ScDocument::DeleteTabs( SCTAB nTab, SCTAB nSheets, ScDocument* pRefUndoDoc )
 {
     bool bValid = false;
-    if (VALIDTAB(nTab) && (nTab + nSheets) < static_cast<SCTAB>(maTabs.size()))
+    if (ValidTab(nTab) && (nTab + nSheets) < static_cast<SCTAB>(maTabs.size()))
     {
         if (maTabs[nTab])
         {
@@ -755,9 +755,10 @@ bool ScDocument::DeleteTabs( SCTAB nTab, SCTAB nSheets, ScDocument* pRefUndoDoc
 bool ScDocument::RenameTab( SCTAB nTab, const rtl::OUString& rName, bool /* bUpdateRef */,
         bool bExternalDocument )
 {
-    bool    bValid = false;
-    SCTAB   i;
-    if VALIDTAB(nTab)
+    bool bValid = false;
+    SCTAB i;
+    if (ValidTab(nTab))
+    {
         if (maTabs[nTab])
         {
             if ( bExternalDocument )
@@ -787,13 +788,14 @@ bool ScDocument::RenameTab( SCTAB nTab, const rtl::OUString& rName, bool /* bUpd
                         (*it)->SetStreamValid( false );
             }
         }
+    }
     return bValid;
 }
 
 
 void ScDocument::SetVisible( SCTAB nTab, bool bVisible )
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB> (maTabs.size()))
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()))
         if (maTabs[nTab])
             maTabs[nTab]->SetVisible(bVisible);
 }
@@ -801,7 +803,7 @@ void ScDocument::SetVisible( SCTAB nTab, bool bVisible )
 
 bool ScDocument::IsVisible( SCTAB nTab ) const
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB> (maTabs.size()))
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()))
         if (maTabs[nTab])
             return maTabs[nTab]->IsVisible();
 
@@ -921,7 +923,7 @@ bool ScDocument::IsNegativePage( SCTAB nTab ) const
 
 bool ScDocument::GetCellArea( SCTAB nTab, SCCOL& rEndCol, SCROW& rEndRow ) const
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB> (maTabs.size()))
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()))
         if (maTabs[nTab])
             return maTabs[nTab]->GetCellArea( rEndCol, rEndRow );
 
@@ -933,7 +935,7 @@ bool ScDocument::GetCellArea( SCTAB nTab, SCCOL& rEndCol, SCROW& rEndRow ) const
 
 bool ScDocument::GetTableArea( SCTAB nTab, SCCOL& rEndCol, SCROW& rEndRow ) const
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB> (maTabs.size()))
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()))
         if (maTabs[nTab])
             return maTabs[nTab]->GetTableArea( rEndCol, rEndRow );
 
@@ -997,7 +999,7 @@ void ScDocument::GetDataArea( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow,
 void ScDocument::LimitChartArea( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow,
                                     SCCOL& rEndCol, SCROW& rEndRow )
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB> (maTabs.size()))
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()))
         if (maTabs[nTab])
             maTabs[nTab]->LimitChartArea( rStartCol, rStartRow, rEndCol, rEndRow );
 }
@@ -1638,7 +1640,7 @@ void ScDocument::DeleteAreaTab(SCCOL nCol1, SCROW nRow1,
 {
     PutInOrder( nCol1, nCol2 );
     PutInOrder( nRow1, nRow2 );
-    if ( VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
+    if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
     {
         bool bOldAutoCalc = GetAutoCalc();
         SetAutoCalc( false );   // avoid multiple calculations
@@ -1775,7 +1777,7 @@ void ScDocument::CopyToDocument(SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
     PutInOrder( nTab1, nTab2 );
     if( pDestDoc->aDocName.isEmpty() )
         pDestDoc->aDocName = aDocName;
-    if (VALIDTAB(nTab1) && VALIDTAB(nTab2))
+    if (ValidTab(nTab1) && ValidTab(nTab2))
     {
         bool bOldAutoCalc = pDestDoc->GetAutoCalc();
         pDestDoc->SetAutoCalc( false );     // avoid multiple calculations
@@ -1799,7 +1801,7 @@ void ScDocument::UndoToDocument(SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
     PutInOrder( nCol1, nCol2 );
     PutInOrder( nRow1, nRow2 );
     PutInOrder( nTab1, nTab2 );
-    if (VALIDTAB(nTab1) && VALIDTAB(nTab2))
+    if (ValidTab(nTab1) && ValidTab(nTab2))
     {
         bool bOldAutoCalc = pDestDoc->GetAutoCalc();
         pDestDoc->SetAutoCalc( false );     // avoid multiple calculations
@@ -2893,7 +2895,7 @@ void ScDocument::FillTabMarked( SCTAB nSrcTab, const ScMarkData& rMark,
 
 void ScDocument::PutCell( SCCOL nCol, SCROW nRow, SCTAB nTab, ScBaseCell* pCell, bool bForceTab )
 {
-    if (VALIDTAB(nTab))
+    if (ValidTab(nTab))
     {
         if ( bForceTab && ( nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab]) )
         {
@@ -2943,7 +2945,7 @@ bool ScDocument::SetString( SCCOL nCol, SCROW nRow, SCTAB nTab, const rtl::OUStr
 
 void ScDocument::SetValue( SCCOL nCol, SCROW nRow, SCTAB nTab, const double& rVal )
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
         if (maTabs[nTab])
             maTabs[nTab]->SetValue( nCol, nRow, rVal );
 }
@@ -2962,7 +2964,7 @@ OUString ScDocument::GetString( SCCOL nCol, SCROW nRow, SCTAB nTab )
 
 void ScDocument::GetInputString( SCCOL nCol, SCROW nRow, SCTAB nTab, rtl::OUString& rString )
 {
-    if ( VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
+    if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
         maTabs[nTab]->GetInputString( nCol, nRow, rString );
     else
         rString = rtl::OUString();
@@ -3031,7 +3033,7 @@ sal_uInt16 ScDocument::GetStringForFormula( const ScAddress& rPos, rtl::OUString
 
 void ScDocument::GetValue( SCCOL nCol, SCROW nRow, SCTAB nTab, double& rValue )
 {
-    if ( VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
+    if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
         rValue = maTabs[nTab]->GetValue( nCol, nRow );
     else
         rValue = 0.0;
@@ -3058,7 +3060,7 @@ double ScDocument::GetValue( const ScAddress& rPos )
 void ScDocument::GetNumberFormat( SCCOL nCol, SCROW nRow, SCTAB nTab,
                                   sal_uInt32& rFormat ) const
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
         if (maTabs[nTab])
         {
             rFormat = maTabs[nTab]->GetNumberFormat( nCol, nRow );
@@ -3126,7 +3128,7 @@ void ScDocument::GetNumberFormatInfo( short& nType, sal_uLong& nIndex,
 
 void ScDocument::GetFormula( SCCOL nCol, SCROW nRow, SCTAB nTab, rtl::OUString& rFormula ) const
 {
-    if ( VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
+    if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
             maTabs[nTab]->GetFormula( nCol, nRow, rFormula );
     else
         rFormula = rtl::OUString();
@@ -3186,7 +3188,7 @@ ScBaseCell* ScDocument::GetCell( const ScAddress& rPos ) const
 
 bool ScDocument::HasStringData( SCCOL nCol, SCROW nRow, SCTAB nTab ) const
 {
-    if ( VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
+    if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
             return maTabs[nTab]->HasStringData( nCol, nRow );
     else
         return false;
@@ -3195,7 +3197,7 @@ bool ScDocument::HasStringData( SCCOL nCol, SCROW nRow, SCTAB nTab ) const
 
 bool ScDocument::HasValueData( SCCOL nCol, SCROW nRow, SCTAB nTab ) const
 {
-    if ( VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
+    if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
             return maTabs[nTab]->HasValueData( nCol, nRow );
     else
         return false;
@@ -4209,7 +4211,7 @@ void ScDocument::ApplyPatternArea( SCCOL nStartCol, SCROW nStartRow,
 void ScDocument::ApplyPatternAreaTab( SCCOL nStartCol, SCROW nStartRow,
                         SCCOL nEndCol, SCROW nEndRow, SCTAB nTab, const ScPatternAttr& rAttr )
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
         if (maTabs[nTab])
             maTabs[nTab]->ApplyPatternArea( nStartCol, nStartRow, nEndCol, nEndRow, rAttr );
 }
@@ -4257,7 +4259,7 @@ void ScDocument::RemoveCondFormatData( const ScRangeList& rRange, SCTAB nTab, sa
 
 void ScDocument::ApplyStyle( SCCOL nCol, SCROW nRow, SCTAB nTab, const ScStyleSheet& rStyle)
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
         if (maTabs[nTab])
             maTabs[nTab]->ApplyStyle( nCol, nRow, rStyle );
 }
@@ -4279,7 +4281,7 @@ void ScDocument::ApplyStyleArea( SCCOL nStartCol, SCROW nStartRow,
 void ScDocument::ApplyStyleAreaTab( SCCOL nStartCol, SCROW nStartRow,
                         SCCOL nEndCol, SCROW nEndRow, SCTAB nTab, const ScStyleSheet& rStyle)
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
         if (maTabs[nTab])
             maTabs[nTab]->ApplyStyleArea( nStartCol, nStartRow, nEndCol, nEndRow, rStyle );
 }
@@ -4322,7 +4324,7 @@ void ScDocument::ApplySelectionLineStyle( const ScMarkData& rMark,
 
 const ScStyleSheet* ScDocument::GetStyle( SCCOL nCol, SCROW nRow, SCTAB nTab ) const
 {
-    if ( VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
+    if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
         return maTabs[nTab]->GetStyle(nCol, nRow);
     else
         return NULL;
@@ -4439,7 +4441,7 @@ bool ScDocument::IsStyleSheetUsed( const ScStyleSheet& rStyle, bool bGatherAllSt
 bool ScDocument::ApplyFlagsTab( SCCOL nStartCol, SCROW nStartRow,
                         SCCOL nEndCol, SCROW nEndRow, SCTAB nTab, sal_Int16 nFlags )
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
         if (maTabs[nTab])
             return maTabs[nTab]->ApplyFlags( nStartCol, nStartRow, nEndCol, nEndRow, nFlags );
 
@@ -4451,7 +4453,7 @@ bool ScDocument::ApplyFlagsTab( SCCOL nStartCol, SCROW nStartRow,
 bool ScDocument::RemoveFlagsTab( SCCOL nStartCol, SCROW nStartRow,
                         SCCOL nEndCol, SCROW nEndRow, SCTAB nTab, sal_Int16 nFlags )
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
         if (maTabs[nTab])
             return maTabs[nTab]->RemoveFlags( nStartCol, nStartRow, nEndCol, nEndRow, nFlags );
 
@@ -4463,7 +4465,7 @@ bool ScDocument::RemoveFlagsTab( SCCOL nStartCol, SCROW nStartRow,
 void ScDocument::SetPattern( SCCOL nCol, SCROW nRow, SCTAB nTab, const ScPatternAttr& rAttr,
                                 bool bPutToPool )
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
         if (maTabs[nTab])
             maTabs[nTab]->SetPattern( nCol, nRow, rAttr, bPutToPool );
 }
@@ -4719,7 +4721,7 @@ void ScDocument::GetBorderLines( SCCOL nCol, SCROW nRow, SCTAB nTab,
 bool ScDocument::IsBlockEmpty( SCTAB nTab, SCCOL nStartCol, SCROW nStartRow,
                                         SCCOL nEndCol, SCROW nEndRow, bool bIgnoreNotes ) const
 {
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
         if (maTabs[nTab])
             return maTabs[nTab]->IsBlockEmpty( nStartCol, nStartRow, nEndCol, nEndRow, bIgnoreNotes );
 
@@ -4762,7 +4764,7 @@ bool ScDocument::IsBlockEditable( SCTAB nTab, SCCOL nStartCol, SCROW nStartRow,
         return false;
     }
 
-    if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
+    if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
         if (maTabs[nTab])
             return maTabs[nTab]->IsBlockEditable( nStartCol, nStartRow, nEndCol,
                 nEndRow, pOnlyNotBecauseOfMatrix );
@@ -5312,7 +5314,7 @@ SCSIZE ScDocument::GetEmptyLinesInBlock( SCCOL nStartCol, SCROW nStartRow, SCTAB
     PutInOrder(nStartCol, nEndCol);
     PutInOrder(nStartRow, nEndRow);
     PutInOrder(nStartTab, nEndTab);
-    if (VALIDTAB(nStartTab) && nStartTab < static_cast<SCTAB>(maTabs.size()))
+    if (ValidTab(nStartTab) && nStartTab < static_cast<SCTAB>(maTabs.size()))
     {
         if (maTabs[nStartTab])
             return maTabs[nStartTab]->GetEmptyLinesInBlock(nStartCol, nStartRow, nEndCol, nEndRow, eDir);
diff --git a/sc/source/core/data/markarr.cxx b/sc/source/core/data/markarr.cxx
index 2c3db6e79819..a1fa29546252 100644
--- a/sc/source/core/data/markarr.cxx
+++ b/sc/source/core/data/markarr.cxx
@@ -305,7 +305,7 @@ SCsROW ScMarkArray::GetNextMarked( SCsROW nRow, sal_Bool bUp ) const
         const_cast<ScMarkArray*>(this)->Reset(false);   // create pData for further processing
 
     SCsROW nRet = nRow;
-    if (VALIDROW(nRow))
+    if (ValidRow(nRow))
     {
         SCSIZE nIndex;
         Search(nRow, nIndex);
diff --git a/sc/source/core/data/table1.cxx b/sc/source/core/data/table1.cxx
index 446686eeca5c..caf858f90add 100644
--- a/sc/source/core/data/table1.cxx
+++ b/sc/source/core/data/table1.cxx
@@ -1220,7 +1220,7 @@ void ScTable::GetNextPos( SCCOL& rCol, SCROW& rRow, SCsCOL nMovX, SCsROW nMovY,
     {
         bool bUp = ( nMovY < 0 );
         nRow = rMark.GetNextMarked( nCol, nRow, bUp );
-        while ( VALIDROW(nRow) &&
+        while ( ValidRow(nRow) &&
                 (RowHidden(nRow) || pDocument->HasAttrib(nCol, nRow, nTab, nCol, nRow, nTab, HASATTR_OVERLAPPED)) )
         {
             //  ausgeblendete ueberspringen (s.o.)
@@ -1231,7 +1231,7 @@ void ScTable::GetNextPos( SCCOL& rCol, SCROW& rRow, SCsCOL nMovX, SCsROW nMovY,
         while ( nRow < 0 || nRow > MAXROW )
         {
             nCol = sal::static_int_cast<SCsCOL>( nCol + static_cast<SCsCOL>(nMovY) );
-            while ( VALIDCOL(nCol) && ColHidden(nCol) )
+            while ( ValidCol(nCol) && ColHidden(nCol) )
                 nCol = sal::static_int_cast<SCsCOL>( nCol + static_cast<SCsCOL>(nMovY) );   //  skip hidden rows (see above)
             if (nCol < 0)
             {
@@ -1250,7 +1250,7 @@ void ScTable::GetNextPos( SCCOL& rCol, SCROW& rRow, SCsCOL nMovX, SCsROW nMovY,
             else if (nRow > MAXROW)
                 nRow = 0;
             nRow = rMark.GetNextMarked( nCol, nRow, bUp );
-            while ( VALIDROW(nRow) &&
+            while ( ValidRow(nRow) &&
                     (RowHidden(nRow) || pDocument->HasAttrib(nCol, nRow, nTab, nCol, nRow, nTab, HASATTR_OVERLAPPED)) )
             {
                 //  ausgeblendete ueberspringen (s.o.)
@@ -1358,7 +1358,7 @@ void ScTable::GetNextPos( SCCOL& rCol, SCROW& rRow, SCsCOL nMovX, SCsROW nMovY,
     //  wenn nicht markiert und nicht geschuetzt ist (linker / rechter Rand),
     //  dann Werte unveraendert lassen
 
-    if (VALIDCOLROW(nCol,nRow))
+    if (ValidColRow(nCol,nRow))
     {
         rCol = nCol;
         rRow = nRow;
diff --git a/sc/source/core/data/table2.cxx b/sc/source/core/data/table2.cxx
index 9d553fae9863..665db7c236df 100644
--- a/sc/source/core/data/table2.cxx
+++ b/sc/source/core/data/table2.cxx
@@ -2416,7 +2416,7 @@ void ScTable::ClearSelectionItems( const sal_uInt16* pWhich, const ScMarkData& r
 
 void ScTable::SetColWidth( SCCOL nCol, sal_uInt16 nNewWidth )
 {
-    if (VALIDCOL(nCol) && pColWidth)
+    if (ValidCol(nCol) && pColWidth)
     {
         if (!nNewWidth)
         {
@@ -2437,7 +2437,7 @@ void ScTable::SetColWidth( SCCOL nCol, sal_uInt16 nNewWidth )
 
 void ScTable::SetColWidthOnly( SCCOL nCol, sal_uInt16 nNewWidth )
 {
-    if (!VALIDCOL(nCol) || !pColWidth)
+    if (!ValidCol(nCol) || !pColWidth)
         return;
 
     if (!nNewWidth)
@@ -2449,7 +2449,7 @@ void ScTable::SetColWidthOnly( SCCOL nCol, sal_uInt16 nNewWidth )
 
 void ScTable::SetRowHeight( SCROW nRow, sal_uInt16 nNewHeight )
 {
-    if (VALIDROW(nRow) && mpRowHeights)
+    if (ValidRow(nRow) && mpRowHeights)
     {
         if (!nNewHeight)
         {
@@ -2508,7 +2508,7 @@ bool ScTable::SetRowHeightRange( SCROW nStartRow, SCROW nEndRow, sal_uInt16 nNew
                                     double /* nPPTX */, double nPPTY )
 {
     bool bChanged = false;
-    if (VALIDROW(nStartRow) && VALIDROW(nEndRow) && mpRowHeights)
+    if (ValidRow(nStartRow) && ValidRow(nEndRow) && mpRowHeights)
     {
         if (!nNewHeight)
         {
@@ -2579,7 +2579,7 @@ void ScTable::SetRowHeightOnly( SCROW nStartRow, SCROW nEndRow, sal_uInt16 nNewH
 
 void ScTable::SetManualHeight( SCROW nStartRow, SCROW nEndRow, bool bManual )
 {
-    if (VALIDROW(nStartRow) && VALIDROW(nEndRow) && pRowFlags)
+    if (ValidRow(nStartRow) && ValidRow(nEndRow) && pRowFlags)
     {
         if (bManual)
             pRowFlags->OrValue( nStartRow, nEndRow, CR_MANUALSIZE);
@@ -2595,9 +2595,9 @@ void ScTable::SetManualHeight( SCROW nStartRow, SCROW nEndRow, bool bManual )
 
 sal_uInt16 ScTable::GetColWidth( SCCOL nCol ) const
 {
-    OSL_ENSURE(VALIDCOL(nCol),"Falsche Spaltennummer");
+    OSL_ENSURE(ValidCol(nCol),"Falsche Spaltennummer");
 
-    if (VALIDCOL(nCol) && pColFlags && pColWidth)
+    if (ValidCol(nCol) && pColFlags && pColWidth)
     {
         if (ColHidden(nCol))
             return 0;
@@ -2611,9 +2611,9 @@ sal_uInt16 ScTable::GetColWidth( SCCOL nCol ) const
 
 sal_uInt16 ScTable::GetOriginalWidth( SCCOL nCol ) const        // immer die eingestellte
 {
-    OSL_ENSURE(VALIDCOL(nCol),"Falsche Spaltennummer");
+    OSL_ENSURE(ValidCol(nCol),"Falsche Spaltennummer");
 
-    if (VALIDCOL(nCol) && pColWidth)
+    if (ValidCol(nCol) && pColWidth)
         return pColWidth[nCol];
     else
         return (sal_uInt16) STD_COL_WIDTH;
@@ -2669,9 +2669,9 @@ sal_uInt16 ScTable::GetCommonWidth( SCCOL nEndCol ) const
 
 sal_uInt16 ScTable::GetRowHeight( SCROW nRow, SCROW* pStartRow, SCROW* pEndRow, bool bHiddenAsZero ) const
 {
-    OSL_ENSURE(VALIDROW(nRow),"Invalid row number");
+    OSL_ENSURE(ValidRow(nRow),"Invalid row number");
 
-    if (VALIDROW(nRow) && mpRowHeights)
+    if (ValidRow(nRow) && mpRowHeights)
     {
         if (bHiddenAsZero && RowHidden( nRow, pStartRow, pEndRow))
             return 0;
@@ -2712,9 +2712,9 @@ sal_uInt16 ScTable::GetRowHeight( SCROW nRow, SCROW* pStartRow, SCROW* pEndRow,
 
 sal_uLong ScTable::GetRowHeight( SCROW nStartRow, SCROW nEndRow ) const
 {
-    OSL_ENSURE(VALIDROW(nStartRow) && VALIDROW(nEndRow),"Falsche Zeilennummer");
+    OSL_ENSURE(ValidRow(nStartRow) && ValidRow(nEndRow),"Falsche Zeilennummer");
 
-    if (VALIDROW(nStartRow) && VALIDROW(nEndRow) && mpRowHeights)
+    if (ValidRow(nStartRow) && ValidRow(nEndRow) && mpRowHeights)
     {
         sal_uLong nHeight = 0;
         SCROW nRow = nStartRow;
@@ -2738,9 +2738,9 @@ sal_uLong ScTable::GetRowHeight( SCROW nStartRow, SCROW nEndRow ) const
 
 sal_uLong ScTable::GetScaledRowHeight( SCROW nStartRow, SCROW nEndRow, double fScale ) const
 {
-    OSL_ENSURE(VALIDROW(nStartRow) && VALIDROW(nEndRow),"Falsche Zeilennummer");
+    OSL_ENSURE(ValidRow(nStartRow) && ValidRow(nEndRow),"Falsche Zeilennummer");
 
-    if (VALIDROW(nStartRow) && VALIDROW(nEndRow) && mpRowHeights)
+    if (ValidRow(nStartRow) && ValidRow(nEndRow) && mpRowHeights)
     {
         sal_uLong nHeight = 0;
         SCROW nRow = nStartRow;
@@ -2779,9 +2779,9 @@ sal_uLong ScTable::GetScaledRowHeight( SCROW nStartRow, SCROW nEndRow, double fS
 
 sal_uInt16 ScTable::GetOriginalHeight( SCROW nRow ) const       // non-0 even if hidden
 {
-    OSL_ENSURE(VALIDROW(nRow),"wrong row number");
+    OSL_ENSURE(ValidRow(nRow),"wrong row number");
 
-    if (VALIDROW(nRow) && mpRowHeights)
+    if (ValidRow(nRow) && mpRowHeights)
         return mpRowHeights->getValue(nRow);
     else
         return (sal_uInt16) ScGlobal::nStdRowHeight;
@@ -2808,7 +2808,7 @@ SCROW ScTable::GetHiddenRowCount( SCROW nRow ) const
 
 void ScTable::ShowCol(SCCOL nCol, bool bShow)
 {
-    if (VALIDCOL(nCol))
+    if (ValidCol(nCol))
     {
         bool bWasVis = !ColHidden(nCol);
         if (bWasVis != bShow)
@@ -2829,7 +2829,7 @@ void ScTable::ShowCol(SCCOL nCol, bool bShow)
 
 void ScTable::ShowRow(SCROW nRow, bool bShow)
 {
-    if (VALIDROW(nRow) && pRowFlags)
+    if (ValidRow(nRow) && pRowFlags)
     {
         bool bWasVis = !RowHidden(nRow);
         if (bWasVis != bShow)
@@ -2853,7 +2853,7 @@ void ScTable::ShowRow(SCROW nRow, bool bShow)
 
 void ScTable::DBShowRow(SCROW nRow, bool bShow)
 {
-    if (VALIDROW(nRow) && pRowFlags)
+    if (ValidRow(nRow) && pRowFlags)
     {
         //  Filter-Flag immer setzen, auch wenn Hidden unveraendert
         bool bChanged = SetRowHidden(nRow, nRow, !bShow);
@@ -2976,7 +2976,7 @@ bool ScTable::IsDataFiltered(const ScRange& rRange) const
 
 void ScTable::SetRowFlags( SCROW nRow, sal_uInt8 nNewFlags )
 {
-    if (VALIDROW(nRow) && pRowFlags)
+    if (ValidRow(nRow) && pRowFlags)
         pRowFlags->SetValue( nRow, nNewFlags);
     else
     {
@@ -2987,7 +2987,7 @@ void ScTable::SetRowFlags( SCROW nRow, sal_uInt8 nNewFlags )
 
 void ScTable::SetRowFlags( SCROW nStartRow, SCROW nEndRow, sal_uInt8 nNewFlags )
 {
-    if (VALIDROW(nStartRow) && VALIDROW(nEndRow) && pRowFlags)
+    if (ValidRow(nStartRow) && ValidRow(nEndRow) && pRowFlags)
         pRowFlags->SetValue( nStartRow, nEndRow, nNewFlags);
     else
     {
@@ -2998,7 +2998,7 @@ void ScTable::SetRowFlags( SCROW nStartRow, SCROW nEndRow, sal_uInt8 nNewFlags )
 
 sal_uInt8 ScTable::GetColFlags( SCCOL nCol ) const
 {
-    if (VALIDCOL(nCol) && pColFlags)
+    if (ValidCol(nCol) && pColFlags)
         return pColFlags[nCol];
     else
         return 0;
@@ -3007,7 +3007,7 @@ sal_uInt8 ScTable::GetColFlags( SCCOL nCol ) const
 
 sal_uInt8 ScTable::GetRowFlags( SCROW nRow ) const
 {
-    if (VALIDROW(nRow) && pRowFlags)
+    if (ValidRow(nRow) && pRowFlags)
         return pRowFlags->GetValue(nRow);
     else
         return 0;
diff --git a/sc/source/core/data/table6.cxx b/sc/source/core/data/table6.cxx
index b3b183f4139e..8206cd841537 100644
--- a/sc/source/core/data/table6.cxx
+++ b/sc/source/core/data/table6.cxx
@@ -665,8 +665,8 @@ bool ScTable::SearchAndReplace(
     bool bFound = false;
     if ( ValidColRow(rCol, rRow) ||
          ((nCommand == SVX_SEARCHCMD_FIND || nCommand == SVX_SEARCHCMD_REPLACE) &&
-           (((rCol == MAXCOLCOUNT || rCol == -1) && VALIDROW(rRow)) ||
-            ((rRow == MAXROWCOUNT || rRow == -1) && VALIDCOL(rCol))
+           (((rCol == MAXCOLCOUNT || rCol == -1) && ValidRow(rRow)) ||
+            ((rRow == MAXROWCOUNT || rRow == -1) && ValidCol(rCol))
            )
          )
        )
diff --git a/sc/source/core/tool/refdata.cxx b/sc/source/core/tool/refdata.cxx
index 3c0f40f1ec8e..8ebcf8ed969e 100644
--- a/sc/source/core/tool/refdata.cxx
+++ b/sc/source/core/tool/refdata.cxx
@@ -52,19 +52,19 @@ void ScSingleRefData::CalcAbsIfRel( const ScAddress& rPos )
     if ( Flags.bColRel )
     {
         nCol = nRelCol + rPos.Col();
-        if ( !VALIDCOL( nCol ) )
+        if ( !ValidCol( nCol ) )
             Flags.bColDeleted = sal_True;
     }
     if ( Flags.bRowRel )
     {
         nRow = nRelRow + rPos.Row();
-        if ( !VALIDROW( nRow ) )
+        if ( !ValidRow( nRow ) )
             Flags.bRowDeleted = sal_True;
     }
     if ( Flags.bTabRel )
     {
         nTab = nRelTab + rPos.Tab();
-        if ( !VALIDTAB( nTab ) )
+        if ( !ValidTab( nTab ) )
             Flags.bTabDeleted = sal_True;
     }
 }
diff --git a/sc/source/ui/view/tabview3.cxx b/sc/source/ui/view/tabview3.cxx
index c35ea9decf57..0124f6a0f795 100644
--- a/sc/source/ui/view/tabview3.cxx
+++ b/sc/source/ui/view/tabview3.cxx
@@ -1056,10 +1056,10 @@ void ScTabView::MoveCursorRel( SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode,
 
     aViewData.ResetOldCursor();
 
-    if (nMovX != 0 && VALIDCOLROW(nCurX,nCurY))
+    if (nMovX != 0 && ValidColRow(nCurX,nCurY))
         SkipCursorHorizontal(nCurX, nCurY, nOldX, nMovX);
 
-    if (nMovY != 0 && VALIDCOLROW(nCurX,nCurY))
+    if (nMovY != 0 && ValidColRow(nCurX,nCurY))
         SkipCursorVertical(nCurX, nCurY, nOldY, nMovY);
 
     MoveCursorAbs( nCurX, nCurY, eMode, bShift, false, true, bKeepSel );