sc/inc/document.hxx | 1
sc/source/core/data/documen2.cxx | 93 -
sc/source/core/data/documen3.cxx | 312 ++----
sc/source/core/data/documen4.cxx | 63 -
sc/source/core/data/documen5.cxx | 8
sc/source/core/data/documen6.cxx | 2
sc/source/core/data/documen7.cxx | 24
sc/source/core/data/documen8.cxx | 4
sc/source/core/data/documen9.cxx | 16
sc/source/core/data/document.cxx | 1793 ++++++++++++++++--------------------
sc/source/core/data/document10.cxx | 2
sc/source/core/data/formulacell.cxx | 2
12 files changed, 1056 insertions(+), 1264 deletions(-)
New commits:
commit 3cc198a0706b25c42cc8dae7e25635cbd911ac02
Author: Tomaž Vajngerl <tomaz.vajng...@collabora.co.uk>
AuthorDate: Sun Jul 9 00:41:12 2023 +0900
Commit: Tomaž Vajngerl <qui...@gmail.com>
CommitDate: Thu Jul 13 07:25:42 2023 +0200
sc: remove duplicated table validity checks and other duplications
Remove the duplicated table validity checks and replace them with
FetchTable(..) call, which returns nullptr if the table is not
valid and available, or the table itself. This simpifies the code
all around.
When only the check if the table is available is needed, use
HasTable(..) in those cases.
The call TableExists(..) is identical to HasTable(..) and has been
removed.
Finally use GetTableCount(), which return a SCTAB type for the number
of tables is used instead of static_cast<SCTAB>(maTabs.size())
that was used all over the code.
Change-Id: Ibfd9777b1350ba8e0cbe577783db81589f95591c
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/154225
Tested-by: Jenkins
Reviewed-by: Tomaž Vajngerl <qui...@gmail.com>
diff --git a/sc/inc/document.hxx b/sc/inc/document.hxx
index 27499ca9f105..157a49099184 100644
--- a/sc/inc/document.hxx
+++ b/sc/inc/document.hxx
@@ -2620,7 +2620,6 @@ public:
void ConvertFormulaToValue( const ScRange& rRange,
sc::TableValues* pUndo );
void SwapNonEmpty( sc::TableValues& rValues );
void finalizeOutlineImport();
- bool TableExists( SCTAB nTab ) const;
// Returns the given column range, first allocating all the columns if
necessary.
SC_DLLPUBLIC ScColumnsRange GetWritableColumnsRange(SCTAB nTab, SCCOL
nColBegin, SCCOL nColEnd);
diff --git a/sc/source/core/data/documen2.cxx b/sc/source/core/data/documen2.cxx
index e5d5df5a94cb..42f971c82cfb 100644
--- a/sc/source/core/data/documen2.cxx
+++ b/sc/source/core/data/documen2.cxx
@@ -528,19 +528,19 @@ void ScDocument::ResetClip( ScDocument* pSourceDoc, const
ScMarkData* pMarks )
{
InitClipPtrs(pSourceDoc);
- for (SCTAB i = 0; i < static_cast<SCTAB>(pSourceDoc->maTabs.size());
i++)
+ for (SCTAB i = 0; i < pSourceDoc->GetTableCount(); i++)
if (pSourceDoc->maTabs[i])
if (!pMarks || pMarks->GetTableSelect(i))
{
OUString aString = pSourceDoc->maTabs[i]->GetName();
- if ( i < static_cast<SCTAB>(maTabs.size()) )
+ if (i < GetTableCount())
{
maTabs[i].reset( new ScTable(*this, i, aString) );
}
else
{
- if( i > static_cast<SCTAB>(maTabs.size()) )
+ if (i > GetTableCount())
{
maTabs.resize(i);
}
@@ -560,12 +560,12 @@ void ScDocument::ResetClip( ScDocument* pSourceDoc, SCTAB
nTab )
if (bIsClip)
{
InitClipPtrs(pSourceDoc);
- if (nTab >= static_cast<SCTAB>(maTabs.size()))
+ if (nTab >= GetTableCount())
{
maTabs.resize(nTab+1);
}
maTabs[nTab].reset( new ScTable(*this, nTab, "baeh") );
- if (nTab < static_cast<SCTAB>(pSourceDoc->maTabs.size()) &&
pSourceDoc->maTabs[nTab])
+ if (nTab < pSourceDoc->GetTableCount() && pSourceDoc->maTabs[nTab])
maTabs[nTab]->SetLayoutRTL(
pSourceDoc->maTabs[nTab]->IsLayoutRTL() );
}
else
@@ -577,7 +577,7 @@ void ScDocument::ResetClip( ScDocument* pSourceDoc, SCTAB
nTab )
void ScDocument::EnsureTable( SCTAB nTab )
{
bool bExtras = !bIsUndo; // Column-Widths, Row-Heights, Flags
- if (o3tl::make_unsigned(nTab) >= maTabs.size())
+ if (nTab >= GetTableCount())
maTabs.resize(nTab+1);
if (!maTabs[nTab])
@@ -586,18 +586,16 @@ void ScDocument::EnsureTable( SCTAB nTab )
ScRefCellValue ScDocument::GetRefCellValue( const ScAddress& rPos )
{
- if (!TableExists(rPos.Tab()))
- return ScRefCellValue(); // empty
-
- return maTabs[rPos.Tab()]->GetRefCellValue(rPos.Col(), rPos.Row());
+ if (ScTable* pTable = FetchTable(rPos.Tab()))
+ return pTable->GetRefCellValue(rPos.Col(), rPos.Row());
+ return ScRefCellValue(); // empty
}
ScRefCellValue ScDocument::GetRefCellValue( const ScAddress& rPos,
sc::ColumnBlockPosition& rBlockPos )
{
- if (!TableExists(rPos.Tab()))
- return ScRefCellValue(); // empty
-
- return maTabs[rPos.Tab()]->GetRefCellValue(rPos.Col(), rPos.Row(),
rBlockPos);
+ if (ScTable* pTable = FetchTable(rPos.Tab()))
+ return pTable->GetRefCellValue(rPos.Col(), rPos.Row(), rBlockPos);
+ return ScRefCellValue(); // empty
}
svl::SharedStringPool& ScDocument::GetSharedStringPool()
@@ -613,9 +611,9 @@ const svl::SharedStringPool&
ScDocument::GetSharedStringPool() const
bool ScDocument::GetPrintArea( SCTAB nTab, SCCOL& rEndCol, SCROW& rEndRow,
bool bNotes) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
+ if (const ScTable* pTable = FetchTable(nTab))
{
- bool bAny = maTabs[nTab]->GetPrintArea( rEndCol, rEndRow, bNotes,
/*bCalcHiddens*/false);
+ bool bAny = pTable->GetPrintArea( rEndCol, rEndRow, bNotes,
/*bCalcHiddens*/false);
if (mpDrawLayer)
{
ScRange aDrawRange(0,0,nTab, MaxCol(),MaxRow(),nTab);
@@ -637,9 +635,9 @@ bool ScDocument::GetPrintArea( SCTAB nTab, SCCOL& rEndCol,
SCROW& rEndRow,
bool ScDocument::GetPrintAreaHor( SCTAB nTab, SCROW nStartRow, SCROW nEndRow,
SCCOL& rEndCol ) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
+ if (const ScTable* pTable = FetchTable(nTab))
{
- bool bAny = maTabs[nTab]->GetPrintAreaHor( nStartRow, nEndRow, rEndCol
);
+ bool bAny = pTable->GetPrintAreaHor( nStartRow, nEndRow, rEndCol );
if (mpDrawLayer)
{
ScRange aDrawRange(0,nStartRow,nTab, MaxCol(),nEndRow,nTab);
@@ -659,9 +657,9 @@ bool ScDocument::GetPrintAreaHor( SCTAB nTab, SCROW
nStartRow, SCROW nEndRow,
bool ScDocument::GetPrintAreaVer( SCTAB nTab, SCCOL nStartCol, SCCOL nEndCol,
SCROW& rEndRow, bool bNotes ) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
+ if (const ScTable* pTable = FetchTable(nTab))
{
- bool bAny = maTabs[nTab]->GetPrintAreaVer( nStartCol, nEndCol,
rEndRow, bNotes );
+ bool bAny = pTable->GetPrintAreaVer( nStartCol, nEndCol, rEndRow,
bNotes );
if (mpDrawLayer)
{
ScRange aDrawRange(nStartCol,0,nTab, nEndCol,MaxRow(),nTab);
@@ -680,9 +678,9 @@ bool ScDocument::GetPrintAreaVer( SCTAB nTab, SCCOL
nStartCol, SCCOL nEndCol,
bool ScDocument::GetDataStart( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow
) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
+ if (const ScTable* pTable = FetchTable(nTab))
{
- bool bAny = maTabs[nTab]->GetDataStart( rStartCol, rStartRow );
+ bool bAny = pTable->GetDataStart( rStartCol, rStartRow );
if (mpDrawLayer)
{
ScRange aDrawRange(0,0,nTab, MaxCol(),MaxRow(),nTab);
@@ -737,7 +735,7 @@ bool ScDocument::MoveTab( SCTAB nOldPos, SCTAB nNewPos,
ScProgress* pProgress )
if (nOldPos == nNewPos)
return false;
- SCTAB nTabCount = static_cast<SCTAB>(maTabs.size());
+ SCTAB nTabCount = GetTableCount();
if(nTabCount < 2)
return false;
@@ -805,8 +803,8 @@ bool ScDocument::MoveTab( SCTAB nOldPos, SCTAB nNewPos,
ScProgress* pProgress )
bool ScDocument::CopyTab( SCTAB nOldPos, SCTAB nNewPos, const ScMarkData*
pOnlyMarked )
{
- if (SC_TAB_APPEND == nNewPos || nNewPos >=
static_cast<SCTAB>(maTabs.size()))
- nNewPos = static_cast<SCTAB>(maTabs.size());
+ if (SC_TAB_APPEND == nNewPos || nNewPos >= GetTableCount())
+ nNewPos = GetTableCount();
OUString aName;
GetName(nOldPos, aName);
@@ -828,14 +826,14 @@ bool ScDocument::CopyTab( SCTAB nOldPos, SCTAB nNewPos,
const ScMarkData* pOnlyM
if (bValid)
{
- if (nNewPos >= static_cast<SCTAB>(maTabs.size()))
+ if (nNewPos >= GetTableCount())
{
- nNewPos = static_cast<SCTAB>(maTabs.size());
+ nNewPos = GetTableCount();
maTabs.emplace_back(new ScTable(*this, nNewPos, aName));
}
else
{
- if (ValidTab(nNewPos) && (nNewPos <
static_cast<SCTAB>(maTabs.size())))
+ if (ValidTab(nNewPos) && nNewPos < GetTableCount())
{
SetNoListening( true );
@@ -979,9 +977,9 @@ sal_uLong ScDocument::TransferTab( ScDocument& rSrcDoc,
SCTAB nSrcPos,
}
else // replace existing tables
{
- if (ValidTab(nDestPos) && nDestPos < static_cast<SCTAB>(maTabs.size())
&& maTabs[nDestPos])
+ if (ScTable* pTable = FetchTable(nDestPos))
{
- maTabs[nDestPos]->DeleteArea( 0,0, MaxCol(),MaxRow(),
InsertDeleteFlags::ALL );
+ pTable->DeleteArea(0, 0, MaxCol(), MaxRow(),
InsertDeleteFlags::ALL);
}
else
bValid = false;
@@ -1130,38 +1128,31 @@ sal_uLong ScDocument::TransferTab( ScDocument& rSrcDoc,
SCTAB nSrcPos,
void ScDocument::SetError( SCCOL nCol, SCROW nRow, SCTAB nTab, const
FormulaError nError)
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
- if (maTabs[nTab])
- maTabs[nTab]->SetError( nCol, nRow, nError );
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->SetError(nCol, nRow, nError);
}
void ScDocument::SetFormula(
const ScAddress& rPos, const ScTokenArray& rArray )
{
- if (!TableExists(rPos.Tab()))
- return;
-
- maTabs[rPos.Tab()]->SetFormula(rPos.Col(), rPos.Row(), rArray,
formula::FormulaGrammar::GRAM_DEFAULT);
+ if (ScTable* pTable = FetchTable(rPos.Tab()))
+ pTable->SetFormula(rPos.Col(), rPos.Row(), rArray,
formula::FormulaGrammar::GRAM_DEFAULT);
}
void ScDocument::SetFormula(
const ScAddress& rPos, const OUString& rFormula,
formula::FormulaGrammar::Grammar eGram )
{
- if (!TableExists(rPos.Tab()))
- return;
-
- maTabs[rPos.Tab()]->SetFormula(rPos.Col(), rPos.Row(), rFormula, eGram);
+ if (ScTable* pTable = FetchTable(rPos.Tab()))
+ pTable->SetFormula(rPos.Col(), rPos.Row(), rFormula, eGram);
}
ScFormulaCell* ScDocument::SetFormulaCell( const ScAddress& rPos,
ScFormulaCell* pCell )
{
- if (!TableExists(rPos.Tab()))
- {
- delete pCell;
- return nullptr;
- }
+ if (ScTable* pTable = FetchTable(rPos.Tab()))
+ return pTable->SetFormulaCell(rPos.Col(), rPos.Row(), pCell);
- return maTabs[rPos.Tab()]->SetFormulaCell(rPos.Col(), rPos.Row(), pCell);
+ delete pCell;
+ return nullptr;
}
bool ScDocument::SetFormulaCells( const ScAddress& rPos,
std::vector<ScFormulaCell*>& rCells )
@@ -1169,11 +1160,9 @@ bool ScDocument::SetFormulaCells( const ScAddress& rPos,
std::vector<ScFormulaCe
if (rCells.empty())
return false;
- ScTable* pTab = FetchTable(rPos.Tab());
- if (!pTab)
- return false;
-
- return pTab->SetFormulaCells(rPos.Col(), rPos.Row(), rCells);
+ if (ScTable* pTable = FetchTable(rPos.Tab()))
+ return pTable->SetFormulaCells(rPos.Col(), rPos.Row(), rCells);
+ return false;
}
void ScDocument::SetConsolidateDlgData( std::unique_ptr<ScConsolidateParam>
pData )
diff --git a/sc/source/core/data/documen3.cxx b/sc/source/core/data/documen3.cxx
index 8d0d2ba9a665..8fb0e824e06f 100644
--- a/sc/source/core/data/documen3.cxx
+++ b/sc/source/core/data/documen3.cxx
@@ -107,7 +107,7 @@ void sortAndRemoveDuplicates(std::vector<ScTypedStrData>&
rStrings, bool bCaseSe
void ScDocument::GetAllTabRangeNames(ScRangeName::TabNameCopyMap& rNames) const
{
ScRangeName::TabNameCopyMap aNames;
- for (SCTAB i = 0; i < static_cast<SCTAB>(maTabs.size()); ++i)
+ for (SCTAB i = 0; i < GetTableCount(); ++i)
{
if (!maTabs[i])
// no more tables to iterate through.
@@ -148,7 +148,7 @@ void ScDocument::SetAllRangeNames(const std::map<OUString,
ScRangeName>& rRangeM
void ScDocument::GetRangeNameMap(std::map<OUString, ScRangeName*>&
aRangeNameMap)
{
- for (SCTAB i = 0; i < static_cast<SCTAB>(maTabs.size()); ++i)
+ for (SCTAB i = 0; i < GetTableCount(); ++i)
{
if (!maTabs[i])
continue;
@@ -170,10 +170,9 @@ void ScDocument::GetRangeNameMap(std::map<OUString,
ScRangeName*>& aRangeNameMap
ScRangeName* ScDocument::GetRangeName(SCTAB nTab) const
{
- if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) ||
!maTabs[nTab])
- return nullptr;
-
- return maTabs[nTab]->GetRangeName();
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->GetRangeName();
+ return nullptr;
}
ScRangeName* ScDocument::GetRangeName() const
@@ -185,10 +184,8 @@ ScRangeName* ScDocument::GetRangeName() const
void ScDocument::SetRangeName(SCTAB nTab, std::unique_ptr<ScRangeName> pNew)
{
- if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) ||
!maTabs[nTab])
- return;
-
- return maTabs[nTab]->SetRangeName(std::move(pNew));
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->SetRangeName(std::move(pNew));
}
void ScDocument::SetRangeName( std::unique_ptr<ScRangeName> pNewRangeName )
@@ -428,70 +425,68 @@ void ScDocument::SetChartListenerCollection(
void ScDocument::SetScenario( SCTAB nTab, bool bFlag )
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- maTabs[nTab]->SetScenario(bFlag);
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->SetScenario(bFlag);
}
bool ScDocument::IsScenario( SCTAB nTab ) const
{
- return ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab] &&maTabs[nTab]->IsScenario();
+ const ScTable* pTable = FetchTable(nTab);
+ return pTable && pTable->IsScenario();
}
void ScDocument::SetScenarioData( SCTAB nTab, const OUString& rComment,
const Color& rColor, ScScenarioFlags
nFlags )
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab] && maTabs[nTab]->IsScenario())
+ if (ScTable* pTable = FetchTable(nTab); pTable->IsScenario())
{
- maTabs[nTab]->SetScenarioComment( rComment );
- maTabs[nTab]->SetScenarioColor( rColor );
- maTabs[nTab]->SetScenarioFlags( nFlags );
+ pTable->SetScenarioComment( rComment );
+ pTable->SetScenarioColor( rColor );
+ pTable->SetScenarioFlags( nFlags );
}
}
Color ScDocument::GetTabBgColor( SCTAB nTab ) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- return maTabs[nTab]->GetTabBgColor();
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->GetTabBgColor();
return COL_AUTO;
}
void ScDocument::SetTabBgColor( SCTAB nTab, const Color& rColor )
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- maTabs[nTab]->SetTabBgColor(rColor);
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->SetTabBgColor(rColor);
}
bool ScDocument::IsDefaultTabBgColor( SCTAB nTab ) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- return maTabs[nTab]->GetTabBgColor() == COL_AUTO;
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->GetTabBgColor() == COL_AUTO;
return true;
}
void ScDocument::GetScenarioData( SCTAB nTab, OUString& rComment,
Color& rColor, ScScenarioFlags& rFlags
) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab] && maTabs[nTab]->IsScenario())
+ if (const ScTable* pTable = FetchTable(nTab); pTable->IsScenario())
{
- maTabs[nTab]->GetScenarioComment( rComment );
- rColor = maTabs[nTab]->GetScenarioColor();
- rFlags = maTabs[nTab]->GetScenarioFlags();
+ pTable->GetScenarioComment( rComment );
+ rColor = pTable->GetScenarioColor();
+ rFlags = pTable->GetScenarioFlags();
}
}
void ScDocument::GetScenarioFlags( SCTAB nTab, ScScenarioFlags& rFlags ) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab] && maTabs[nTab]->IsScenario())
- rFlags = maTabs[nTab]->GetScenarioFlags();
+ if (const ScTable* pTable = FetchTable(nTab); pTable->IsScenario())
+ rFlags = pTable->GetScenarioFlags();
}
bool ScDocument::IsLinked( SCTAB nTab ) const
{
- return ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab] && maTabs[nTab]->IsLinked();
- // equivalent to
- //if (ValidTab(nTab) && pTab[nTab])
- // return pTab[nTab]->IsLinked();
- //return false;
+ const ScTable* pTable = FetchTable(nTab);
+ return pTable && pTable->IsLinked();
}
formula::FormulaGrammar::AddressConvention ScDocument::GetAddressConvention()
const
@@ -506,43 +501,43 @@ void ScDocument::SetGrammar(
formula::FormulaGrammar::Grammar eGram )
ScLinkMode ScDocument::GetLinkMode( SCTAB nTab ) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- return maTabs[nTab]->GetLinkMode();
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->GetLinkMode();
return ScLinkMode::NONE;
}
OUString ScDocument::GetLinkDoc( SCTAB nTab ) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- return maTabs[nTab]->GetLinkDoc();
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->GetLinkDoc();
return OUString();
}
OUString ScDocument::GetLinkFlt( SCTAB nTab ) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- return maTabs[nTab]->GetLinkFlt();
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->GetLinkFlt();
return OUString();
}
OUString ScDocument::GetLinkOpt( SCTAB nTab ) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- return maTabs[nTab]->GetLinkOpt();
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->GetLinkOpt();
return OUString();
}
OUString ScDocument::GetLinkTab( SCTAB nTab ) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- return maTabs[nTab]->GetLinkTab();
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->GetLinkTab();
return OUString();
}
sal_uLong ScDocument::GetLinkRefreshDelay( SCTAB nTab ) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- return maTabs[nTab]->GetLinkRefreshDelay();
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->GetLinkRefreshDelay();
return 0;
}
@@ -550,14 +545,14 @@ void ScDocument::SetLink( SCTAB nTab, ScLinkMode nMode,
const OUString& rDoc,
const OUString& rFilter, const OUString& rOptions,
const OUString& rTabName, sal_uLong nRefreshDelay )
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- maTabs[nTab]->SetLink( nMode, rDoc, rFilter, rOptions, rTabName,
nRefreshDelay );
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->SetLink(nMode, rDoc, rFilter, rOptions, rTabName,
nRefreshDelay);
}
bool ScDocument::HasLink( std::u16string_view rDoc,
std::u16string_view rFilter, std::u16string_view
rOptions ) const
{
- SCTAB nCount = static_cast<SCTAB>(maTabs.size());
+ SCTAB nCount = GetTableCount();
for (SCTAB i=0; i<nCount; i++)
if (maTabs[i]->IsLinked()
&& maTabs[i]->GetLinkDoc() == rDoc
@@ -665,23 +660,23 @@ ScFormulaParserPool& ScDocument::GetFormulaParserPool()
const
const ScSheetEvents* ScDocument::GetSheetEvents( SCTAB nTab ) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- return maTabs[nTab]->GetSheetEvents();
+ if (const ScTable* pTable = FetchTable(nTab))
+ pTable->GetSheetEvents();
return nullptr;
}
void ScDocument::SetSheetEvents( SCTAB nTab, std::unique_ptr<ScSheetEvents>
pNew )
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- maTabs[nTab]->SetSheetEvents( std::move(pNew) );
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->SetSheetEvents( std::move(pNew) );
}
bool ScDocument::HasSheetEventScript( SCTAB nTab, ScSheetEventId nEvent, bool
bWithVbaEvents ) const
{
- if (nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
+ if (const ScTable* pTable = FetchTable(nTab))
{
// check if any event handler script has been configured
- const ScSheetEvents* pEvents = maTabs[nTab]->GetSheetEvents();
+ const ScSheetEvents* pEvents = pTable->GetSheetEvents();
if ( pEvents && pEvents->GetScript( nEvent ) )
return true;
// check if VBA event handlers exist
@@ -701,7 +696,7 @@ bool ScDocument::HasSheetEventScript( SCTAB nTab,
ScSheetEventId nEvent, bool bW
bool ScDocument::HasAnySheetEventScript( ScSheetEventId nEvent, bool
bWithVbaEvents ) const
{
- SCTAB nSize = static_cast<SCTAB>(maTabs.size());
+ SCTAB nSize = GetTableCount();
for (SCTAB nTab = 0; nTab < nSize; nTab++)
if (HasSheetEventScript( nTab, nEvent, bWithVbaEvents ))
return true;
@@ -710,7 +705,7 @@ bool ScDocument::HasAnySheetEventScript( ScSheetEventId
nEvent, bool bWithVbaEve
bool ScDocument::HasAnyCalcNotification() const
{
- SCTAB nSize = static_cast<SCTAB>(maTabs.size());
+ SCTAB nSize = GetTableCount();
for (SCTAB nTab = 0; nTab < nSize; nTab++)
if (maTabs[nTab] && maTabs[nTab]->GetCalcNotification())
return true;
@@ -719,21 +714,21 @@ bool ScDocument::HasAnyCalcNotification() const
bool ScDocument::HasCalcNotification( SCTAB nTab ) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- return maTabs[nTab]->GetCalcNotification();
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->GetCalcNotification();
return false;
}
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())
- maTabs[nTab]->SetCalcNotification(true);
+ if (ScTable* pTable = FetchTable(nTab) ; !pTable->GetCalcNotification())
+ pTable->SetCalcNotification(true);
}
void ScDocument::ResetCalcNotifications()
{
- SCTAB nSize = static_cast<SCTAB>(maTabs.size());
+ SCTAB nSize = GetTableCount();
for (SCTAB nTab = 0; nTab < nSize; nTab++)
if (maTabs[nTab] && maTabs[nTab]->GetCalcNotification())
maTabs[nTab]->SetCalcNotification(false);
@@ -743,46 +738,48 @@ ScOutlineTable* ScDocument::GetOutlineTable( SCTAB nTab,
bool bCreate )
{
ScOutlineTable* pVal = nullptr;
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
- if (maTabs[nTab])
+ if (ScTable* pTable = FetchTable(nTab))
+ {
+ pVal = pTable->GetOutlineTable();
+ if (!pVal && bCreate)
{
- pVal = maTabs[nTab]->GetOutlineTable();
- if (!pVal && bCreate)
- {
- maTabs[nTab]->StartOutlineTable();
- pVal = maTabs[nTab]->GetOutlineTable();
- }
+ pTable->StartOutlineTable();
+ pVal = pTable->GetOutlineTable();
}
+ }
return pVal;
}
bool ScDocument::SetOutlineTable( SCTAB nTab, const ScOutlineTable*
pNewOutline )
{
- return ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab] && maTabs[nTab]->SetOutlineTable(pNewOutline);
+ ScTable* pTable = FetchTable(nTab);
+ return pTable && pTable->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])
- maTabs[nTab]->DoAutoOutline( nStartCol, nStartRow, nEndCol, nEndRow );
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->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 );
+ ScTable* pTable = FetchTable(nTab);
+ return pTable && pTable->TestRemoveSubTotals(rParam);
}
void ScDocument::RemoveSubTotals( SCTAB nTab, ScSubTotalParam& rParam )
{
- if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab] )
- maTabs[nTab]->RemoveSubTotals( rParam );
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->RemoveSubTotals( rParam );
}
bool ScDocument::DoSubTotals( SCTAB nTab, ScSubTotalParam& rParam )
{
- return ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab] && maTabs[nTab]->DoSubTotals( rParam );
+ ScTable* pTable = FetchTable(nTab);
+ return pTable && pTable->DoSubTotals(rParam);
}
bool ScDocument::HasSubTotalCells( const ScRange& rRange )
@@ -805,7 +802,7 @@ bool ScDocument::HasSubTotalCells( const ScRange& rRange )
*/
void ScDocument::CopyUpdated( ScDocument* pPosDoc, ScDocument* pDestDoc )
{
- SCTAB nCount = static_cast<SCTAB>(maTabs.size());
+ SCTAB nCount = GetTableCount();
for (SCTAB nTab=0; nTab<nCount; nTab++)
if (maTabs[nTab] && pPosDoc->maTabs[nTab] && pDestDoc->maTabs[nTab])
maTabs[nTab]->CopyUpdated( pPosDoc->maTabs[nTab].get(),
pDestDoc->maTabs[nTab].get() );
@@ -813,8 +810,7 @@ void ScDocument::CopyUpdated( ScDocument* pPosDoc,
ScDocument* pDestDoc )
void ScDocument::CopyScenario( SCTAB nSrcTab, SCTAB nDestTab, bool
bNewScenario )
{
- if (!(ValidTab(nSrcTab) && ValidTab(nDestTab) && nSrcTab <
static_cast<SCTAB>(maTabs.size())
- && nDestTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nSrcTab] && maTabs[nDestTab]))
+ if (!HasTable(nSrcTab) || !HasTable(nDestTab))
return;
// Set flags correctly for active scenarios
@@ -823,7 +819,7 @@ void ScDocument::CopyScenario( SCTAB nSrcTab, SCTAB
nDestTab, bool bNewScenario
// nDestTab is the target table
for ( SCTAB nTab = nDestTab+1;
- nTab< static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] &&
maTabs[nTab]->IsScenario();
+ nTab < GetTableCount() && maTabs[nTab] &&
maTabs[nTab]->IsScenario();
nTab++ )
{
if ( maTabs[nTab]->IsActiveScenario() ) // Even if it's the same
scenario
@@ -861,41 +857,42 @@ void ScDocument::MarkScenario( SCTAB nSrcTab, SCTAB
nDestTab, ScMarkData& rDestM
if (bResetMark)
rDestMark.ResetMark();
- if (ValidTab(nSrcTab) && nSrcTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nSrcTab])
- maTabs[nSrcTab]->MarkScenarioIn( rDestMark, nNeededBits );
+ if (const ScTable* pTable = FetchTable(nSrcTab))
+ pTable->MarkScenarioIn(rDestMark, nNeededBits);
- rDestMark.SetAreaTab( nDestTab );
+ rDestMark.SetAreaTab( nDestTab);
}
bool ScDocument::HasScenarioRange( SCTAB nTab, const ScRange& rRange ) const
{
- return ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab] && maTabs[nTab]->HasScenarioRange( rRange );
+ const ScTable* pTable = FetchTable(nTab);
+ return pTable && pTable->HasScenarioRange(rRange);
}
const ScRangeList* ScDocument::GetScenarioRanges( SCTAB nTab ) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- return maTabs[nTab]->GetScenarioRanges();
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->GetScenarioRanges();
return nullptr;
}
bool ScDocument::IsActiveScenario( SCTAB nTab ) const
{
- return ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab] && maTabs[nTab]->IsActiveScenario( );
+ const ScTable* pTable = FetchTable(nTab);
+ return pTable && pTable->IsActiveScenario();
}
void ScDocument::SetActiveScenario( SCTAB nTab, bool bActive )
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- maTabs[nTab]->SetActiveScenario( bActive );
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->SetActiveScenario( bActive );
}
bool ScDocument::TestCopyScenario( SCTAB nSrcTab, SCTAB nDestTab ) const
{
- if (ValidTab(nSrcTab) && nSrcTab < static_cast<SCTAB>(maTabs.size())
- && nDestTab < static_cast<SCTAB>(maTabs.size())&&
ValidTab(nDestTab))
- return maTabs[nSrcTab]->TestCopyScenarioTo( maTabs[nDestTab].get() );
+ if (HasTable(nSrcTab) && HasTable(nDestTab))
+ return maTabs[nSrcTab]->TestCopyScenarioTo(maTabs[nDestTab].get());
OSL_FAIL("wrong table at TestCopyScenario");
return false;
@@ -1124,7 +1121,7 @@ void ScDocument::UpdateTranspose( const ScAddress&
rDestPos, ScDocument* pClipDo
ScAddress aDest = rDestPos;
SCTAB nClipTab = 0;
- for (SCTAB nDestTab=0; nDestTab< static_cast<SCTAB>(maTabs.size()) &&
maTabs[nDestTab]; nDestTab++)
+ for (SCTAB nDestTab = 0; nDestTab < GetTableCount() && maTabs[nDestTab];
nDestTab++)
if (rMark.GetTableSelect(nDestTab))
{
while (!pClipDoc->maTabs[nClipTab]) nClipTab = (nClipTab+1) %
(MAXTAB+1);
@@ -1135,7 +1132,7 @@ void ScDocument::UpdateTranspose( const ScAddress&
rDestPos, ScDocument* pClipDo
// Like UpdateReference
if (pRangeName)
pRangeName->UpdateTranspose( aSource, aDest ); // Before the
cells!
- for (SCTAB i=0; i< static_cast<SCTAB>(maTabs.size()); i++)
+ for (SCTAB i = 0; i < GetTableCount(); i++)
if (maTabs[i])
maTabs[i]->UpdateTranspose( aSource, aDest, pUndoDoc );
@@ -1152,7 +1149,7 @@ void ScDocument::UpdateGrow( const ScRange& rArea, SCCOL
nGrowX, SCROW nGrowY )
if (pRangeName)
pRangeName->UpdateGrow( rArea, nGrowX, nGrowY );
- for (SCTAB i=0; i< static_cast<SCTAB>(maTabs.size()) && maTabs[i]; i++)
+ for (SCTAB i = 0; i < GetTableCount() && maTabs[i]; i++)
maTabs[i]->UpdateGrow( rArea, nGrowX, nGrowY );
}
@@ -1181,7 +1178,7 @@ void ScDocument::Fill(SCCOL nCol1, SCROW nRow1, SCCOL
nCol2, SCROW nRow2, ScProg
OUString ScDocument::GetAutoFillPreview( const ScRange& rSource, SCCOL nEndX,
SCROW nEndY )
{
SCTAB nTab = rSource.aStart.Tab();
- if (nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
+ if (nTab < GetTableCount() && maTabs[nTab])
return maTabs[nTab]->GetAutoFillPreview( rSource, nEndX, nEndY );
return OUString();
@@ -1205,14 +1202,11 @@ 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 (ScTable* pTable = FetchTable(nTab))
{
- if (maTabs[nTab])
- {
- PutInOrder(nStartCol, nEndCol);
- PutInOrder(nStartRow, nEndRow);
- maTabs[nTab]->GetAutoFormatData(nStartCol, nStartRow, nEndCol,
nEndRow, rData);
- }
+ PutInOrder(nStartCol, nEndCol);
+ PutInOrder(nStartRow, nEndRow);
+ pTable->GetAutoFormatData(nStartCol, nStartRow, nEndCol, nEndRow,
rData);
}
}
@@ -1317,7 +1311,7 @@ bool ScDocument::SearchAndReplace(
{
// FIXME: Manage separated marks per table!
bool bFound = false;
- if (rTab >= static_cast<SCTAB>(maTabs.size()))
+ if (rTab >= GetTableCount())
OSL_FAIL("table out of range");
if (ValidTab(rTab))
{
@@ -1381,7 +1375,7 @@ bool ScDocument::SearchAndReplace(
}
else
{
- for (nTab = rTab; (nTab < static_cast<SCTAB>(maTabs.size()))
&& !bFound; nTab++)
+ for (nTab = rTab; (nTab < GetTableCount()) && !bFound; nTab++)
if (maTabs[nTab])
{
if (rMark.GetTableSelect(nTab))
@@ -1420,8 +1414,8 @@ bool ScDocument::SearchAndReplace(
*/
bool ScDocument::UpdateOutlineCol( SCCOL nStartCol, SCCOL nEndCol, SCTAB nTab,
bool bShow )
{
- if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab] )
- return maTabs[nTab]->UpdateOutlineCol( nStartCol, nEndCol, bShow );
+ if (ScTable* pTable = FetchTable(nTab))
+ return pTable->UpdateOutlineCol(nStartCol, nEndCol, bShow);
OSL_FAIL("missing tab");
return false;
@@ -1429,8 +1423,8 @@ bool ScDocument::UpdateOutlineCol( SCCOL nStartCol, SCCOL
nEndCol, SCTAB nTab, b
bool ScDocument::UpdateOutlineRow( SCROW nStartRow, SCROW nEndRow, SCTAB nTab,
bool bShow )
{
- if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab] )
- return maTabs[nTab]->UpdateOutlineRow( nStartRow, nEndRow, bShow );
+ if (ScTable* pTable = FetchTable(nTab))
+ return pTable->UpdateOutlineRow(nStartRow, nEndRow, bShow);
OSL_FAIL("missing tab");
return false;
@@ -1440,42 +1434,41 @@ void ScDocument::Sort(
SCTAB nTab, const ScSortParam& rSortParam, bool bKeepQuery, bool
bUpdateRefs,
ScProgress* pProgress, sc::ReorderParam* pUndo )
{
- if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab] )
+ if (ScTable* pTable = FetchTable(nTab))
{
bool bOldEnableIdle = IsIdleEnabled();
EnableIdle(false);
- maTabs[nTab]->Sort(rSortParam, bKeepQuery, bUpdateRefs, pProgress,
pUndo);
+ pTable->Sort(rSortParam, bKeepQuery, bUpdateRefs, pProgress, pUndo);
EnableIdle(bOldEnableIdle);
}
}
void ScDocument::Reorder( const sc::ReorderParam& rParam )
{
- ScTable* pTab = FetchTable(rParam.maSortRange.aStart.Tab());
- if (!pTab)
+ ScTable* pTable = FetchTable(rParam.maSortRange.aStart.Tab());
+ if (!pTable)
return;
bool bOldEnableIdle = IsIdleEnabled();
EnableIdle(false);
- pTab->Reorder(rParam);
+ pTable->Reorder(rParam);
EnableIdle(bOldEnableIdle);
}
void ScDocument::PrepareQuery( SCTAB nTab, ScQueryParam& rQueryParam )
{
- if( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab] )
- maTabs[nTab]->PrepareQuery(rQueryParam);
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->PrepareQuery(rQueryParam);
else
{
OSL_FAIL("missing tab");
- return;
}
}
SCSIZE ScDocument::Query(SCTAB nTab, const ScQueryParam& rQueryParam, bool
bKeepSub)
{
- if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab] )
- return maTabs[nTab]->Query(rQueryParam, bKeepSub);
+ if (ScTable* pTable = FetchTable(nTab))
+ return pTable->Query(rQueryParam, bKeepSub);
OSL_FAIL("missing tab");
return 0;
@@ -1483,23 +1476,19 @@ SCSIZE ScDocument::Query(SCTAB nTab, const
ScQueryParam& rQueryParam, bool bKeep
OUString ScDocument::GetUpperCellString(SCCOL nCol, SCROW nRow, SCTAB nTab)
{
- if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab] )
- return maTabs[nTab]->GetUpperCellString( nCol, nRow );
+ if (ScTable* pTable = FetchTable(nTab))
+ return pTable->GetUpperCellString( nCol, nRow );
else
return OUString();
}
bool ScDocument::CreateQueryParam( const ScRange& rRange, ScQueryParam&
rQueryParam )
{
- ScTable* pTab = FetchTable(rRange.aStart.Tab());
- if (!pTab)
- {
- OSL_FAIL("missing tab");
- return false;
- }
+ if (ScTable* pTable = FetchTable(rRange.aStart.Tab()))
+ return pTable->CreateQueryParam(rRange.aStart.Col(),
rRange.aStart.Row(), rRange.aEnd.Col(), rRange.aEnd.Row(), rQueryParam);
- return pTab->CreateQueryParam(
- rRange.aStart.Col(), rRange.aStart.Row(), rRange.aEnd.Col(),
rRange.aEnd.Row(), rQueryParam);
+ OSL_FAIL("missing tab");
+ return false;
}
bool ScDocument::HasAutoFilter( SCCOL nCurCol, SCROW nCurRow, SCTAB nCurTab )
@@ -1537,20 +1526,23 @@ 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 );
+ ScTable* pTable = FetchTable(nTab);
+ return pTable && pTable->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 );
+ ScTable* pTable = FetchTable(nTab);
+ return pTable && pTable->HasRowHeader(nStartCol, nStartRow, nEndCol,
nEndRow);
}
void ScDocument::GetFilterSelCount( SCCOL nCol, SCROW nRow, SCTAB nTab,
SCSIZE& nSelected, SCSIZE& nTotal )
{
nSelected = 0;
nTotal = 0;
- if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab] )
+
+ if (HasTable(nTab))
{
ScDBData* pDBData = GetDBAtCursor( nCol, nRow, nTab,
ScDBDataPortion::AREA );
if( pDBData && pDBData->HasAutoFilter() )
@@ -1564,7 +1556,7 @@ void ScDocument::GetFilterSelCount( SCCOL nCol, SCROW
nRow, SCTAB nTab, SCSIZE&
void ScDocument::GetFilterEntries(
SCCOL nCol, SCROW nRow, SCTAB nTab, ScFilterEntries& rFilterEntries )
{
- if ( !(ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab] && pDBCollection) )
+ if (!HasTable(nTab) || !pDBCollection)
return;
ScDBData* pDBData = pDBCollection->GetDBAtCursor(nCol, nRow, nTab,
ScDBDataPortion::AREA); //!??
@@ -1617,10 +1609,10 @@ void ScDocument::GetFilterEntriesArea(
SCCOL nCol, SCROW nStartRow, SCROW nEndRow, SCTAB nTab, bool bCaseSens,
ScFilterEntries& rFilterEntries )
{
- if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab] )
+ if (ScTable* pTable = FetchTable(nTab))
{
- maTabs[nTab]->GetFilterEntries( nCol, nStartRow, nEndRow,
rFilterEntries, true );
- sortAndRemoveDuplicates( rFilterEntries.maStrData, bCaseSens);
+ pTable->GetFilterEntries(nCol, nStartRow, nEndRow, rFilterEntries,
true);
+ sortAndRemoveDuplicates(rFilterEntries.maStrData, bCaseSens);
}
}
@@ -1650,10 +1642,7 @@ void ScDocument::GetDataEntries(
}
}
- if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()))
- return;
-
- if (!maTabs[nTab])
+ if (!HasTable(nTab))
return;
std::set<ScTypedStrData> aStrings;
@@ -1720,7 +1709,7 @@ tools::Rectangle ScDocument::GetEmbeddedRect() const //
1/100 mm
{
tools::Rectangle aRect;
ScTable* pTable = nullptr;
- if ( aEmbedRange.aStart.Tab() < static_cast<SCTAB>(maTabs.size()) )
+ if (aEmbedRange.aStart.Tab() < GetTableCount())
pTable = maTabs[aEmbedRange.aStart.Tab()].get();
else
OSL_FAIL("table out of range");
@@ -1808,7 +1797,7 @@ static bool lcl_AddTwipsWhile( tools::Long & rTwips,
tools::Long nStopTwips, SCR
ScRange ScDocument::GetRange( SCTAB nTab, const tools::Rectangle& rMMRect,
bool bHiddenAsZero ) const
{
ScTable* pTable = nullptr;
- if (nTab < static_cast<SCTAB>(maTabs.size()))
+ if (nTab < GetTableCount())
pTable = maTabs[nTab].get();
else
OSL_FAIL("table out of range");
@@ -1915,8 +1904,8 @@ bool ScDocument::IsDocEditable() const
bool ScDocument::IsTabProtected( SCTAB nTab ) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- return maTabs[nTab]->IsProtected();
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->IsProtected();
OSL_FAIL("Wrong table number");
return false;
@@ -1924,23 +1913,21 @@ bool ScDocument::IsTabProtected( SCTAB nTab ) const
const ScTableProtection* ScDocument::GetTabProtection(SCTAB nTab) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- return maTabs[nTab]->GetProtection();
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->GetProtection();
return nullptr;
}
void ScDocument::SetTabProtection(SCTAB nTab, const ScTableProtection*
pProtect)
{
- if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()))
- return;
-
- maTabs[nTab]->SetProtection(pProtect);
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->SetProtection(pProtect);
}
void ScDocument::CopyTabProtection(SCTAB nTabSrc, SCTAB nTabDest)
{
- if (!ValidTab(nTabSrc) || nTabSrc >= static_cast<SCTAB>(maTabs.size()) ||
nTabDest >= static_cast<SCTAB>(maTabs.size()) || !ValidTab(nTabDest))
+ if (!HasTable(nTabSrc) || !HasTable(nTabDest))
return;
maTabs[nTabDest]->SetProtection( maTabs[nTabSrc]->GetProtection() );
@@ -1998,7 +1985,7 @@ void ScDocument::SetLanguage( LanguageType eLatin,
LanguageType eCjk, LanguageTy
tools::Rectangle ScDocument::GetMMRect( SCCOL nStartCol, SCROW nStartRow,
SCCOL nEndCol, SCROW nEndRow, SCTAB nTab, bool bHiddenAsZero ) const
{
- if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) ||
!maTabs[nTab])
+ if (!HasTable(nTab))
{
OSL_FAIL("GetMMRect: wrong table");
return tools::Rectangle(0,0,0,0);
@@ -2109,30 +2096,29 @@ void ScDocument::RemoveMerge( SCCOL nCol, SCROW nRow,
SCTAB nTab )
void ScDocument::ExtendPrintArea( OutputDevice* pDev, SCTAB nTab,
SCCOL nStartCol, SCROW nStartRow, SCCOL& rEndCol, SCROW
nEndRow ) const
{
- if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab] )
- maTabs[nTab]->ExtendPrintArea( pDev, nStartCol, nStartRow, rEndCol,
nEndRow );
+ if (HasTable(nTab))
+ maTabs[nTab]->ExtendPrintArea(pDev, nStartCol, nStartRow, rEndCol,
nEndRow);
}
SCSIZE ScDocument::GetPatternCount( SCTAB nTab, SCCOL nCol ) const
{
- if( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab] )
- return maTabs[nTab]->GetPatternCount( nCol );
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->GetPatternCount( nCol );
else
return 0;
}
SCSIZE ScDocument::GetPatternCount( SCTAB nTab, SCCOL nCol, SCROW nRow1, SCROW
nRow2 ) const
{
- if( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab] )
- return maTabs[nTab]->GetPatternCount( nCol, nRow1, nRow2 );
- else
- return 0;
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->GetPatternCount(nCol, nRow1, nRow2);
+ return 0;
}
void ScDocument::ReservePatternCount( SCTAB nTab, SCCOL nCol, SCSIZE nReserve )
{
- if( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab] )
- maTabs[nTab]->ReservePatternCount( nCol, nReserve );
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->ReservePatternCount(nCol, nReserve);
}
void ScDocument::GetSortParam( ScSortParam& rParam, SCTAB nTab )
diff --git a/sc/source/core/data/documen4.cxx b/sc/source/core/data/documen4.cxx
index 0db93c0aeb5b..313340676df1 100644
--- a/sc/source/core/data/documen4.cxx
+++ b/sc/source/core/data/documen4.cxx
@@ -77,8 +77,8 @@ bool ScDocument::Solver(SCCOL nFCol, SCROW nFRow, SCTAB nFTab,
nX = 0.0;
if ( ValidColRow( nFCol, nFRow ) && ValidTab( nFTab ) &&
ValidColRow( nVCol, nVRow ) && ValidTab( nVTab ) &&
- nFTab < static_cast<SCTAB>( maTabs.size() ) && maTabs[nFTab] &&
- nVTab < static_cast<SCTAB>( maTabs.size() ) && maTabs[nVTab] )
+ nFTab < GetTableCount() && maTabs[nFTab] &&
+ nVTab < GetTableCount() && maTabs[nVTab] )
{
CellType eFType = GetCellType(nFCol, nFRow, nFTab);
CellType eVType = GetCellType(nVCol, nVRow, nVTab);
@@ -291,7 +291,7 @@ void ScDocument::InsertMatrixFormula(SCCOL nCol1, SCROW
nRow1,
else
pCell = new ScFormulaCell(*this, aPos, rFormula, eGram,
ScMatrixMode::Formula);
pCell->SetMatColsRows( nCol2 - nCol1 + 1, nRow2 - nRow1 + 1 );
- SCTAB nMax = static_cast<SCTAB>(maTabs.size());
+ SCTAB nMax = GetTableCount();
for (const auto& rTab : rMark)
{
if (rTab >= nMax)
@@ -365,7 +365,7 @@ void ScDocument::InsertTableOp(const ScTabOpParam& rParam,
// multiple (repeate
SCROW k;
i = 0;
bool bStop = false;
- SCTAB nMax = static_cast<SCTAB>(maTabs.size());
+ SCTAB nMax = GetTableCount();
for (const auto& rTab : rMark)
{
if (rTab >= nMax)
@@ -438,7 +438,7 @@ void ScDocument::InsertTableOp(const ScTabOpParam& rParam,
// multiple (repeate
formula::FormulaGrammar::GRAM_NATIVE, ScMatrixMode::NONE );
for( j = nCol1; j <= nCol2; j++ )
for( k = nRow1; k <= nRow2; k++ )
- for (i = 0; i < static_cast<SCTAB>(maTabs.size()); i++)
+ for (i = 0; i < GetTableCount(); i++)
{
for (const auto& rTab : rMark)
{
@@ -530,27 +530,25 @@ bool ScDocument::MarkUsedExternalReferences( const
ScTokenArray& rArr, const ScA
bool ScDocument::GetNextSpellingCell(SCCOL& nCol, SCROW& nRow, SCTAB nTab,
bool bInSel, const ScMarkData& rMark) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- return maTabs[nTab]->GetNextSpellingCell( nCol, nRow, bInSel, rMark );
- else
- return false;
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->GetNextSpellingCell( nCol, nRow, bInSel, rMark );
+ return false;
}
bool ScDocument::GetNextMarkedCell( SCCOL& rCol, SCROW& rRow, SCTAB nTab,
const ScMarkData& rMark )
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- return maTabs[nTab]->GetNextMarkedCell( rCol, rRow, rMark );
- else
- return false;
+ if (ScTable* pTable = FetchTable(nTab))
+ return pTable->GetNextMarkedCell( rCol, rRow, rMark );
+ return false;
}
void ScDocument::ReplaceStyle(const SvxSearchItem& rSearchItem,
SCCOL nCol, SCROW nRow, SCTAB nTab,
const ScMarkData& rMark)
{
- if (nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
- maTabs[nTab]->ReplaceStyle(rSearchItem, nCol, nRow, rMark,
true/*bIsUndoP*/);
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->ReplaceStyle(rSearchItem, nCol, nRow, rMark, true/*bIsUndoP*/);
}
void ScDocument::CompileDBFormula()
@@ -588,21 +586,17 @@ void ScDocument::InvalidateTableArea()
sal_Int32 ScDocument::GetMaxStringLen( SCTAB nTab, SCCOL nCol,
SCROW nRowStart, SCROW nRowEnd, rtl_TextEncoding eCharSet ) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- return maTabs[nTab]->GetMaxStringLen( nCol, nRowStart, nRowEnd,
eCharSet );
- else
- return 0;
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->GetMaxStringLen(nCol, nRowStart, nRowEnd, eCharSet);
+ return 0;
}
sal_Int32 ScDocument::GetMaxNumberStringLen( sal_uInt16& nPrecision, SCTAB
nTab,
- SCCOL nCol,
- SCROW nRowStart, SCROW nRowEnd ) const
+ SCCOL nCol, SCROW nRowStart, SCROW nRowEnd
) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- return maTabs[nTab]->GetMaxNumberStringLen( nPrecision, nCol,
- nRowStart, nRowEnd );
- else
- return 0;
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->GetMaxNumberStringLen(nPrecision, nCol, nRowStart,
nRowEnd);
+ return 0;
}
bool ScDocument::GetSelectionFunction( ScSubTotalFunc eFunc,
@@ -616,7 +610,7 @@ bool ScDocument::GetSelectionFunction( ScSubTotalFunc eFunc,
if (!aMark.IsMultiMarked() && !aMark.IsCellMarked(rCursor.Col(),
rCursor.Row()))
aMark.SetMarkArea(rCursor);
- SCTAB nMax = static_cast<SCTAB>(maTabs.size());
+ SCTAB nMax = GetTableCount();
ScMarkData::const_iterator itr = aMark.begin(), itrEnd = aMark.end();
for (; itr != itrEnd && *itr < nMax && !aData.getError(); ++itr)
@@ -716,8 +710,8 @@ sal_uLong ScDocument::AddCondFormat(
std::unique_ptr<ScConditionalFormat> pNew,
if(!pNew)
return 0;
- if(ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- return maTabs[nTab]->AddCondFormat( std::move(pNew) );
+ if (ScTable* pTable = FetchTable(nTab))
+ return pTable->AddCondFormat(std::move(pNew));
return 0;
}
@@ -865,16 +859,15 @@ ScConditionalFormat* ScDocument::GetCondFormat(
ScConditionalFormatList* ScDocument::GetCondFormList(SCTAB nTab) const
{
- if(ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
+ if (HasTable(nTab))
return maTabs[nTab]->GetCondFormList();
-
return nullptr;
}
void ScDocument::SetCondFormList( ScConditionalFormatList* pList, SCTAB nTab )
{
- if(ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- maTabs[nTab]->SetCondFormList(pList);
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->SetCondFormList(pList);
}
const ScValidationData* ScDocument::GetValidationEntry( sal_uInt32 nIndex )
const
@@ -887,8 +880,8 @@ const ScValidationData* ScDocument::GetValidationEntry(
sal_uInt32 nIndex ) cons
void ScDocument::DeleteConditionalFormat(sal_uLong nOldIndex, SCTAB nTab)
{
- if(ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- maTabs[nTab]->DeleteConditionalFormat(nOldIndex);
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->DeleteConditionalFormat(nOldIndex);
}
bool ScDocument::HasDetectiveOperations() const
diff --git a/sc/source/core/data/documen5.cxx b/sc/source/core/data/documen5.cxx
index c4f76433b41d..0355812a7b9f 100644
--- a/sc/source/core/data/documen5.cxx
+++ b/sc/source/core/data/documen5.cxx
@@ -528,11 +528,9 @@ void ScDocument::SetChartRangeList( std::u16string_view
rChartName,
bool ScDocument::HasData( SCCOL nCol, SCROW nRow, SCTAB nTab )
{
- if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab]
- && nCol < maTabs[nTab]->GetAllocatedColumnsCount())
- return maTabs[nTab]->HasData( nCol, nRow );
- else
- return false;
+ if (ScTable* pTable = FetchTable(nTab) ; pTable && nCol <
pTable->GetAllocatedColumnsCount())
+ return pTable->HasData(nCol, nRow);
+ return false;
}
uno::Reference< embed::XEmbeddedObject >
diff --git a/sc/source/core/data/documen6.cxx b/sc/source/core/data/documen6.cxx
index 49d433ffebb7..931cb9002bee 100644
--- a/sc/source/core/data/documen6.cxx
+++ b/sc/source/core/data/documen6.cxx
@@ -183,7 +183,7 @@ public:
SvtScriptType ScDocument::GetRangeScriptType(
sc::ColumnBlockPosition& rBlockPos, const ScAddress& rPos, SCROW nLength )
{
- if (!TableExists(rPos.Tab()))
+ if (!HasTable(rPos.Tab()))
return SvtScriptType::NONE;
return maTabs[rPos.Tab()]->GetRangeScriptType(rBlockPos, rPos.Col(),
rPos.Row(), rPos.Row()+nLength-1);
diff --git a/sc/source/core/data/documen7.cxx b/sc/source/core/data/documen7.cxx
index 61f6b68f0543..f69585167c66 100644
--- a/sc/source/core/data/documen7.cxx
+++ b/sc/source/core/data/documen7.cxx
@@ -129,7 +129,7 @@ void ScDocument::Broadcast( const ScHint& rHint )
if ( rHint.GetStartAddress() != BCA_BRDCST_ALWAYS )
{
SCTAB nTab = rHint.GetStartAddress().Tab();
- if (nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
+ if (nTab < GetTableCount() && maTabs[nTab])
maTabs[nTab]->SetStreamValid(false);
}
}
@@ -223,8 +223,8 @@ 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])
- maTabs[nTab]->StartListening( rAddress, pListener );
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->StartListening(rAddress, pListener);
}
void ScDocument::EndListeningCell( const ScAddress& rAddress,
@@ -232,28 +232,22 @@ 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])
- maTabs[nTab]->EndListening( rAddress, pListener );
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->EndListening( rAddress, pListener );
}
void ScDocument::StartListeningCell(
sc::StartListeningContext& rCxt, const ScAddress& rPos, SvtListener&
rListener )
{
- ScTable* pTab = FetchTable(rPos.Tab());
- if (!pTab)
- return;
-
- pTab->StartListening(rCxt, rPos, rListener);
+ if (ScTable* pTable = FetchTable(rPos.Tab()))
+ pTable->StartListening(rCxt, rPos, rListener);
}
void ScDocument::EndListeningCell(
sc::EndListeningContext& rCxt, const ScAddress& rPos, SvtListener&
rListener )
{
- ScTable* pTab = FetchTable(rPos.Tab());
- if (!pTab)
- return;
-
- pTab->EndListening(rCxt, rPos, rListener);
+ if (ScTable* pTable = FetchTable(rPos.Tab()))
+ pTable->EndListening(rCxt, rPos, rListener);
}
void ScDocument::EndListeningFormulaCells( std::vector<ScFormulaCell*>& rCells
)
diff --git a/sc/source/core/data/documen8.cxx b/sc/source/core/data/documen8.cxx
index 1c97e5d2408a..3d4d2ecc4b47 100644
--- a/sc/source/core/data/documen8.cxx
+++ b/sc/source/core/data/documen8.cxx
@@ -549,7 +549,7 @@ bool ScDocument::IdleCalcTextWidth() // true =
try next again
aScope.incTab();
}
- if (!ValidTab(aScope.Tab()) || aScope.Tab() >=
static_cast<SCTAB>(maTabs.size()) || !maTabs[aScope.Tab()])
+ if (!HasTable(aScope.Tab()))
aScope.setTab(0);
ScTable* pTab = maTabs[aScope.Tab()].get();
@@ -628,7 +628,7 @@ bool ScDocument::IdleCalcTextWidth() // true =
try next again
bNewTab = true;
}
- if (!ValidTab(aScope.Tab()) || aScope.Tab() >=
static_cast<SCTAB>(maTabs.size()) || !maTabs[aScope.Tab()] )
+ if (!HasTable(aScope.Tab()))
{
// Sheet doesn't exist at specified sheet position. Restart
at sheet 0.
aScope.setTab(0);
diff --git a/sc/source/core/data/documen9.cxx b/sc/source/core/data/documen9.cxx
index f63c1ee4d1f1..cc49d58c5cdb 100644
--- a/sc/source/core/data/documen9.cxx
+++ b/sc/source/core/data/documen9.cxx
@@ -146,11 +146,11 @@ void ScDocument::InitDrawLayer( SfxObjectShell* pDocShell
)
SCTAB nDrawPages = 0;
SCTAB nTab;
- for (nTab=0; nTab < static_cast<SCTAB>(maTabs.size()); nTab++)
+ for (nTab = 0; nTab < GetTableCount(); nTab++)
if (maTabs[nTab])
nDrawPages = nTab + 1; // needed number of pages
- for (nTab=0; nTab<nDrawPages && nTab < static_cast<SCTAB>(maTabs.size());
nTab++)
+ for (nTab = 0; nTab < nDrawPages && nTab < GetTableCount(); nTab++)
{
mpDrawLayer->ScAddPage( nTab ); // always add page, with or
without the table
if (maTabs[nTab])
@@ -202,10 +202,8 @@ void ScDocument::UpdateDrawPrinter()
void ScDocument::SetDrawPageSize(SCTAB nTab)
{
- if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) ||
!maTabs[nTab])
- return;
-
- maTabs[nTab]->SetDrawPageSize();
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->SetDrawPageSize();
}
bool ScDocument::IsChart( const SdrObject* pObject )
@@ -271,7 +269,7 @@ bool ScDocument::HasOLEObjectsInArea( const ScRange&
rRange, const ScMarkData* p
return false;
SCTAB nStartTab = 0;
- SCTAB nEndTab = static_cast<SCTAB>(maTabs.size());
+ SCTAB nEndTab = GetTableCount();
if ( !pTabMark )
{
nStartTab = rRange.aStart.Tab();
@@ -390,7 +388,7 @@ SdrObject* ScDocument::GetObjectAtPoint( SCTAB nTab, const
Point& rPos )
{
// for Drag&Drop on draw object
SdrObject* pFound = nullptr;
- if (mpDrawLayer && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
+ if (mpDrawLayer && nTab < GetTableCount() && maTabs[nTab])
{
SdrPage* pPage = mpDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
OSL_ENSURE(pPage,"Page ?");
@@ -590,7 +588,7 @@ void ScDocument::SetImportingXML( bool bVal )
{
// #i57869# after loading, do the real RTL mirroring for the sheets
that have the LoadingRTL flag set
- for ( SCTAB nTab=0; nTab< static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab]; nTab++ )
+ for (SCTAB nTab = 0; nTab < GetTableCount() && maTabs[nTab]; nTab++)
if ( maTabs[nTab]->IsLoadingRTL() )
{
// SetLayoutRTL => SetDrawPageSize =>
ScDrawLayer::SetPageSize, includes RTL-mirroring;
diff --git a/sc/source/core/data/document.cxx b/sc/source/core/data/document.cxx
index 0095e7dad744..cc6ee1236098 100644
--- a/sc/source/core/data/document.cxx
+++ b/sc/source/core/data/document.cxx
@@ -170,7 +170,7 @@ typedef std::set<ScDefaultAttr, ScLessDefaultAttr>
ScDefaultAttrSet;
void ScDocument::MakeTable( SCTAB nTab,bool _bNeedsNameCheck )
{
- if ( !(ValidTab(nTab) && ( nTab >= static_cast<SCTAB>(maTabs.size())
||!maTabs[nTab])) )
+ if (!ValidTab(nTab) || HasTable(nTab))
return;
// Get Custom prefix
@@ -178,50 +178,35 @@ void ScDocument::MakeTable( SCTAB nTab,bool
_bNeedsNameCheck )
OUString aString = rOpt.GetInitTabPrefix() + OUString::number(nTab+1);
if ( _bNeedsNameCheck )
CreateValidTabName( aString ); // no doubles
- if (nTab < static_cast<SCTAB>(maTabs.size()))
+ if (nTab < GetTableCount())
{
maTabs[nTab].reset( new ScTable(*this, nTab, aString) );
}
else
{
- while(nTab > static_cast<SCTAB>(maTabs.size()))
+ while (nTab > GetTableCount())
maTabs.push_back(nullptr);
maTabs.emplace_back( new ScTable(*this, nTab, aString) );
}
maTabs[nTab]->SetLoadingMedium(bLoadingMedium);
}
-bool ScDocument::HasTable( SCTAB nTab ) const
-{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
- if (maTabs[nTab])
- return true;
-
- return false;
-}
-
bool ScDocument::GetHashCode( SCTAB nTab, sal_Int64& rHashCode ) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
+ if (const ScTable* pTable = FetchTable(nTab))
{
- if (maTabs[nTab])
- {
- rHashCode = maTabs[nTab]->GetHashCode();
- return true;
- }
+ rHashCode = pTable->GetHashCode();
+ return true;
}
return false;
}
bool ScDocument::GetName( SCTAB nTab, OUString& rName ) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
+ if (const ScTable* pTable = FetchTable(nTab))
{
- if (maTabs[nTab])
- {
- rName = maTabs[nTab]->GetName();
- return true;
- }
+ rName = pTable->GetName();
+ return true;
}
rName.clear();
return false;
@@ -236,13 +221,10 @@ OUString ScDocument::GetCopyTabName( SCTAB nTab ) const
bool ScDocument::SetCodeName( SCTAB nTab, const OUString& rName )
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
+ if (ScTable* pTable = FetchTable(nTab))
{
- if (maTabs[nTab])
- {
- maTabs[nTab]->SetCodeName( rName );
- return true;
- }
+ pTable->SetCodeName(rName);
+ return true;
}
SAL_WARN("sc", "can't set code name " << rName );
return false;
@@ -250,12 +232,11 @@ bool ScDocument::SetCodeName( SCTAB nTab, const OUString&
rName )
bool ScDocument::GetCodeName( SCTAB nTab, OUString& rName ) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
- if (maTabs[nTab])
- {
- rName = maTabs[nTab]->GetCodeName();
- return true;
- }
+ if (const ScTable* pTable = FetchTable(nTab))
+ {
+ rName = pTable->GetCodeName();
+ return true;
+ }
rName.clear();
return false;
}
@@ -273,7 +254,7 @@ bool ScDocument::GetTable( const OUString& rName, SCTAB&
rTab ) const
}
const OUString aUpperName = aCacheUpperName;
- for (SCTAB i=0; i< static_cast<SCTAB>(maTabs.size()); i++)
+ for (SCTAB i = 0; i < GetTableCount(); i++)
if (maTabs[i])
{
if (aUpperName == maTabs[i]->GetUpperName())
@@ -308,8 +289,8 @@ std::vector<OUString> ScDocument::GetAllTableNames() const
ScDBData* ScDocument::GetAnonymousDBData(SCTAB nTab)
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- return maTabs[nTab]->GetAnonymousDBData();
+ if (ScTable* pTable = FetchTable(nTab))
+ return pTable->GetAnonymousDBData();
return nullptr;
}
@@ -320,8 +301,8 @@ SCTAB ScDocument::GetTableCount() const
void ScDocument::SetAnonymousDBData(SCTAB nTab, std::unique_ptr<ScDBData>
pDBData)
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) &&
maTabs[nTab])
- maTabs[nTab]->SetAnonymousDBData(std::move(pDBData));
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->SetAnonymousDBData(std::move(pDBData));
}
void ScDocument::SetAnonymousDBData( std::unique_ptr<ScDBData> pDBData )
@@ -408,7 +389,7 @@ void ScDocument::CreateValidTabName(OUString& rName) const
OSL_ENSURE(bPrefix, "Invalid Table Name");
SCTAB nDummy;
- for ( SCTAB i = static_cast<SCTAB>(maTabs.size())+1; !bOk ; i++ )
+ for (SCTAB i = GetTableCount() + 1; !bOk ; i++)
{
rName = aStrTable + OUString::number(static_cast<sal_Int32>(i));
if (bPrefix)
@@ -450,7 +431,7 @@ void ScDocument::CreateValidTabNames(std::vector<OUString>&
aNames, SCTAB nCount
bool bPrefix = ValidTabName( aStrTable );
OSL_ENSURE(bPrefix, "Invalid Table Name");
SCTAB nDummy;
- SCTAB i = static_cast<SCTAB>(maTabs.size())+1;
+ SCTAB i = GetTableCount() + 1;
for (SCTAB j = 0; j < nCount; ++j)
{
@@ -471,7 +452,7 @@ void ScDocument::CreateValidTabNames(std::vector<OUString>&
aNames, SCTAB nCount
void ScDocument::AppendTabOnLoad(const OUString& rName)
{
- SCTAB nTabCount = static_cast<SCTAB>(maTabs.size());
+ SCTAB nTabCount = GetTableCount();
if (!ValidTab(nTabCount))
// max table count reached. No more tables.
return;
@@ -483,7 +464,7 @@ void ScDocument::AppendTabOnLoad(const OUString& rName)
void ScDocument::SetTabNameOnLoad(SCTAB nTab, const OUString& rName)
{
- if (!ValidTab(nTab) || static_cast<SCTAB>(maTabs.size()) <= nTab)
+ if (!ValidTab(nTab) || GetTableCount() <= nTab)
return;
if (!ValidTabName(rName))
@@ -504,8 +485,8 @@ void ScDocument::InvalidateStreamOnSave()
bool ScDocument::InsertTab(
SCTAB nPos, const OUString& rName, bool bExternalDocument, bool
bUndoDeleteTab )
{
- SCTAB nTabCount = static_cast<SCTAB>(maTabs.size());
- bool bValid = ValidTab(nTabCount);
+ SCTAB nTabCount = GetTableCount();
+ bool bValid = ValidTab(nTabCount);
if ( !bExternalDocument ) // else test rName == "'Doc'!Tab" first
bValid = (bValid && ValidNewTabName(rName));
if (bValid)
@@ -592,9 +573,9 @@ bool ScDocument::InsertTab(
bool ScDocument::InsertTabs( SCTAB nPos, const std::vector<OUString>& rNames,
bool bNamesValid )
{
- SCTAB nNewSheets = static_cast<SCTAB>(rNames.size());
- SCTAB nTabCount = static_cast<SCTAB>(maTabs.size());
- bool bValid = bNamesValid || ValidTab(nTabCount+nNewSheets);
+ SCTAB nNewSheets = static_cast<SCTAB>(rNames.size());
+ SCTAB nTabCount = GetTableCount();
+ bool bValid = bNamesValid || ValidTab(nTabCount+nNewSheets);
if (bValid)
{
@@ -673,94 +654,91 @@ bool ScDocument::InsertTabs( SCTAB nPos, const
std::vector<OUString>& rNames,
bool ScDocument::DeleteTab( SCTAB nTab )
{
bool bValid = false;
- if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
+ if (HasTable(nTab))
{
- if (maTabs[nTab])
+ SCTAB nTabCount = GetTableCount();
+ if (nTabCount > 1)
{
- SCTAB nTabCount = static_cast<SCTAB>(maTabs.size());
- if (nTabCount > 1)
+ sc::AutoCalcSwitch aACSwitch(*this, false);
+ sc::RefUpdateDeleteTabContext aCxt( *this, nTab, 1);
+ sc::DelayDeletingBroadcasters delayDeletingBroadcasters(*this);
+
+ ScRange aRange( 0, 0, nTab, MaxCol(), MaxRow(), nTab );
+ DelBroadcastAreasInRange( aRange );
+
+ // #i8180# remove database ranges etc. that are on the deleted tab
+ // (restored in undo with ScRefUndoData)
+
+ xColNameRanges->DeleteOnTab( nTab );
+ xRowNameRanges->DeleteOnTab( nTab );
+ pDBCollection->DeleteOnTab( nTab );
+ if (pDPCollection)
+ pDPCollection->DeleteOnTab( nTab );
+ if (pDetOpList)
+ pDetOpList->DeleteOnTab( nTab );
+ DeleteAreaLinksOnTab( nTab );
+
+ // normal reference update
+
+ aRange.aEnd.SetTab(GetTableCount() - 1);
+ xColNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,-1
);
+ xRowNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,-1
);
+ if (pRangeName)
+ pRangeName->UpdateDeleteTab(aCxt);
+ pDBCollection->UpdateReference(
+ URM_INSDEL, 0,0,nTab,
MaxCol(),MaxRow(),MAXTAB, 0,0,-1 );
+ if (pDPCollection)
+ pDPCollection->UpdateReference( URM_INSDEL, aRange, 0,0,-1 );
+ if (pDetOpList)
+ pDetOpList->UpdateReference( this, URM_INSDEL, aRange, 0,0,-1
);
+ UpdateChartRef( URM_INSDEL, 0,0,nTab, MaxCol(),MaxRow(),MAXTAB,
0,0,-1 );
+ UpdateRefAreaLinks( URM_INSDEL, aRange, 0,0,-1 );
+ if (pValidationList)
{
- sc::AutoCalcSwitch aACSwitch(*this, false);
- sc::RefUpdateDeleteTabContext aCxt( *this, nTab, 1);
- sc::DelayDeletingBroadcasters delayDeletingBroadcasters(*this);
-
- ScRange aRange( 0, 0, nTab, MaxCol(), MaxRow(), nTab );
- DelBroadcastAreasInRange( aRange );
-
- // #i8180# remove database ranges etc. that are on the deleted
tab
- // (restored in undo with ScRefUndoData)
-
- xColNameRanges->DeleteOnTab( nTab );
- xRowNameRanges->DeleteOnTab( nTab );
- pDBCollection->DeleteOnTab( nTab );
- if (pDPCollection)
- pDPCollection->DeleteOnTab( nTab );
- if (pDetOpList)
- pDetOpList->DeleteOnTab( nTab );
- DeleteAreaLinksOnTab( nTab );
-
- // normal reference update
-
- aRange.aEnd.SetTab( static_cast<SCTAB>(maTabs.size())-1 );
- xColNameRanges->UpdateReference( URM_INSDEL, this, aRange,
0,0,-1 );
- xRowNameRanges->UpdateReference( URM_INSDEL, this, aRange,
0,0,-1 );
- if (pRangeName)
- pRangeName->UpdateDeleteTab(aCxt);
- pDBCollection->UpdateReference(
- URM_INSDEL, 0,0,nTab,
MaxCol(),MaxRow(),MAXTAB, 0,0,-1 );
- if (pDPCollection)
- pDPCollection->UpdateReference( URM_INSDEL, aRange, 0,0,-1
);
- if (pDetOpList)
- pDetOpList->UpdateReference( this, URM_INSDEL, aRange,
0,0,-1 );
- UpdateChartRef( URM_INSDEL, 0,0,nTab,
MaxCol(),MaxRow(),MAXTAB, 0,0,-1 );
- UpdateRefAreaLinks( URM_INSDEL, aRange, 0,0,-1 );
- if (pValidationList)
- {
- ScMutationGuard aGuard(*this, ScMutationGuardFlags::CORE);
- pValidationList->UpdateDeleteTab(aCxt);
- }
- if ( pUnoBroadcaster )
- pUnoBroadcaster->Broadcast( ScUpdateRefHint( URM_INSDEL,
aRange, 0,0,-1 ) );
-
- for (auto & pTab : maTabs)
- if (pTab)
- pTab->UpdateDeleteTab(aCxt);
-
- // tdf#149502 make sure ScTable destructor called after the
erase is finished, when
- // maTabs[x].nTab==x is true again, as it should be always
true.
- // In the end of maTabs.erase, maTabs indexes change, but nTab
updated before erase.
- // ~ScTable expect that maTabs[x].nTab==x so it shouldn't be
called during erase.
- ScTableUniquePtr pErasedTab = std::move(maTabs[nTab]);
- maTabs.erase(maTabs.begin() + nTab);
- delete pErasedTab.release();
-
- // UpdateBroadcastAreas must be called between UpdateDeleteTab,
- // which ends listening, and StartAllListeners, to not modify
- // areas that are to be inserted by starting listeners.
- UpdateBroadcastAreas( URM_INSDEL, aRange, 0,0,-1);
- for (const auto& a : maTabs)
- {
- if (a)
- a->UpdateCompile();
- }
- // Excel-Filter deletes some Tables while loading, Listeners
will
- // only be triggered after the loading is done.
- if ( !bInsertingFromOtherDoc )
- {
- StartAllListeners();
-
- sc::SetFormulaDirtyContext aFormulaDirtyCxt;
- SetAllFormulasDirty(aFormulaDirtyCxt);
- }
+ ScMutationGuard aGuard(*this, ScMutationGuardFlags::CORE);
+ pValidationList->UpdateDeleteTab(aCxt);
+ }
+ if ( pUnoBroadcaster )
+ pUnoBroadcaster->Broadcast( ScUpdateRefHint( URM_INSDEL,
aRange, 0,0,-1 ) );
+
+ for (auto & pTab : maTabs)
+ if (pTab)
+ pTab->UpdateDeleteTab(aCxt);
+
+ // tdf#149502 make sure ScTable destructor called after the erase
is finished, when
+ // maTabs[x].nTab==x is true again, as it should be always true.
+ // In the end of maTabs.erase, maTabs indexes change, but nTab
updated before erase.
+ // ~ScTable expect that maTabs[x].nTab==x so it shouldn't be
called during erase.
+ ScTableUniquePtr pErasedTab = std::move(maTabs[nTab]);
+ maTabs.erase(maTabs.begin() + nTab);
+ delete pErasedTab.release();
+
+ // UpdateBroadcastAreas must be called between UpdateDeleteTab,
+ // which ends listening, and StartAllListeners, to not modify
+ // areas that are to be inserted by starting listeners.
+ UpdateBroadcastAreas( URM_INSDEL, aRange, 0,0,-1);
+ for (const auto& a : maTabs)
+ {
+ if (a)
+ a->UpdateCompile();
+ }
+ // Excel-Filter deletes some Tables while loading, Listeners will
+ // only be triggered after the loading is done.
+ if ( !bInsertingFromOtherDoc )
+ {
+ StartAllListeners();
- if (comphelper::LibreOfficeKit::isActive())
- {
- ScModelObj* pModel =
comphelper::getFromUnoTunnel<ScModelObj>(this->GetDocumentShell()->GetModel());
- SfxLokHelper::notifyDocumentSizeChangedAllViews(pModel);
- }
+ sc::SetFormulaDirtyContext aFormulaDirtyCxt;
+ SetAllFormulasDirty(aFormulaDirtyCxt);
+ }
- bValid = true;
+ if (comphelper::LibreOfficeKit::isActive())
+ {
+ ScModelObj* pModel =
comphelper::getFromUnoTunnel<ScModelObj>(this->GetDocumentShell()->GetModel());
+ SfxLokHelper::notifyDocumentSizeChangedAllViews(pModel);
}
+
+ bValid = true;
}
}
return bValid;
@@ -769,91 +747,88 @@ bool ScDocument::DeleteTab( SCTAB nTab )
bool ScDocument::DeleteTabs( SCTAB nTab, SCTAB nSheets )
{
bool bValid = false;
- if (ValidTab(nTab) && (nTab + nSheets) <=
static_cast<SCTAB>(maTabs.size()))
+ if (HasTable(nTab) && (nTab + nSheets) <= GetTableCount())
{
- if (maTabs[nTab])
+ SCTAB nTabCount = GetTableCount();
+ if (nTabCount > nSheets)
{
- SCTAB nTabCount = static_cast<SCTAB>(maTabs.size());
- if (nTabCount > nSheets)
- {
- sc::AutoCalcSwitch aACSwitch(*this, false);
- sc::RefUpdateDeleteTabContext aCxt( *this, nTab, nSheets);
- sc::DelayDeletingBroadcasters delayDeletingBroadcasters(*this);
+ sc::AutoCalcSwitch aACSwitch(*this, false);
+ sc::RefUpdateDeleteTabContext aCxt( *this, nTab, nSheets);
+ sc::DelayDeletingBroadcasters delayDeletingBroadcasters(*this);
- for (SCTAB aTab = 0; aTab < nSheets; ++aTab)
- {
- ScRange aRange( 0, 0, nTab, MaxCol(), MaxRow(), nTab +
aTab );
- DelBroadcastAreasInRange( aRange );
-
- // #i8180# remove database ranges etc. that are on the
deleted tab
- // (restored in undo with ScRefUndoData)
-
- xColNameRanges->DeleteOnTab( nTab + aTab );
- xRowNameRanges->DeleteOnTab( nTab + aTab );
- pDBCollection->DeleteOnTab( nTab + aTab );
- if (pDPCollection)
- pDPCollection->DeleteOnTab( nTab + aTab );
- if (pDetOpList)
- pDetOpList->DeleteOnTab( nTab + aTab );
- DeleteAreaLinksOnTab( nTab + aTab );
- }
-
- if (pRangeName)
- pRangeName->UpdateDeleteTab(aCxt);
+ for (SCTAB aTab = 0; aTab < nSheets; ++aTab)
+ {
+ ScRange aRange( 0, 0, nTab, MaxCol(), MaxRow(), nTab + aTab );
+ DelBroadcastAreasInRange( aRange );
- // normal reference update
+ // #i8180# remove database ranges etc. that are on the deleted
tab
+ // (restored in undo with ScRefUndoData)
- ScRange aRange( 0, 0, nTab, MaxCol(), MaxRow(), nTabCount - 1
);
- xColNameRanges->UpdateReference( URM_INSDEL, this, aRange,
0,0,-1*nSheets );
- xRowNameRanges->UpdateReference( URM_INSDEL, this, aRange,
0,0,-1*nSheets );
- pDBCollection->UpdateReference(
- URM_INSDEL, 0,0,nTab,
MaxCol(),MaxRow(),MAXTAB, 0,0,-1*nSheets );
+ xColNameRanges->DeleteOnTab( nTab + aTab );
+ xRowNameRanges->DeleteOnTab( nTab + aTab );
+ pDBCollection->DeleteOnTab( nTab + aTab );
if (pDPCollection)
- pDPCollection->UpdateReference( URM_INSDEL, aRange,
0,0,-1*nSheets );
+ pDPCollection->DeleteOnTab( nTab + aTab );
if (pDetOpList)
- pDetOpList->UpdateReference( this, URM_INSDEL, aRange,
0,0,-1*nSheets );
- UpdateChartRef( URM_INSDEL, 0,0,nTab,
MaxCol(),MaxRow(),MAXTAB, 0,0,-1*nSheets );
- UpdateRefAreaLinks( URM_INSDEL, aRange, 0,0,-1*nSheets );
- if (pValidationList)
- {
- ScMutationGuard aGuard(*this, ScMutationGuardFlags::CORE);
- pValidationList->UpdateDeleteTab(aCxt);
- }
- if ( pUnoBroadcaster )
- pUnoBroadcaster->Broadcast( ScUpdateRefHint( URM_INSDEL,
aRange, 0,0,-1*nSheets ) );
-
- for (auto & pTab : maTabs)
- if (pTab)
- pTab->UpdateDeleteTab(aCxt);
-
- maTabs.erase(maTabs.begin() + nTab, maTabs.begin() + nTab +
nSheets);
- // UpdateBroadcastAreas must be called between UpdateDeleteTab,
- // which ends listening, and StartAllListeners, to not modify
- // areas that are to be inserted by starting listeners.
- UpdateBroadcastAreas( URM_INSDEL, aRange, 0,0,-1*nSheets);
- for (const auto& a : maTabs)
- {
- if (a)
- a->UpdateCompile();
- }
- // Excel-Filter deletes some Tables while loading, Listeners
will
- // only be triggered after the loading is done.
- if ( !bInsertingFromOtherDoc )
- {
- StartAllListeners();
+ pDetOpList->DeleteOnTab( nTab + aTab );
+ DeleteAreaLinksOnTab( nTab + aTab );
+ }
- sc::SetFormulaDirtyContext aFormulaDirtyCxt;
- SetAllFormulasDirty(aFormulaDirtyCxt);
- }
+ if (pRangeName)
+ pRangeName->UpdateDeleteTab(aCxt);
+
+ // normal reference update
+
+ ScRange aRange( 0, 0, nTab, MaxCol(), MaxRow(), nTabCount - 1 );
+ xColNameRanges->UpdateReference( URM_INSDEL, this, aRange,
0,0,-1*nSheets );
+ xRowNameRanges->UpdateReference( URM_INSDEL, this, aRange,
0,0,-1*nSheets );
+ pDBCollection->UpdateReference(
+ URM_INSDEL, 0,0,nTab,
MaxCol(),MaxRow(),MAXTAB, 0,0,-1*nSheets );
+ if (pDPCollection)
+ pDPCollection->UpdateReference( URM_INSDEL, aRange,
0,0,-1*nSheets );
+ if (pDetOpList)
+ pDetOpList->UpdateReference( this, URM_INSDEL, aRange,
0,0,-1*nSheets );
+ UpdateChartRef( URM_INSDEL, 0,0,nTab, MaxCol(),MaxRow(),MAXTAB,
0,0,-1*nSheets );
+ UpdateRefAreaLinks( URM_INSDEL, aRange, 0,0,-1*nSheets );
+ if (pValidationList)
+ {
+ ScMutationGuard aGuard(*this, ScMutationGuardFlags::CORE);
+ pValidationList->UpdateDeleteTab(aCxt);
+ }
+ if ( pUnoBroadcaster )
+ pUnoBroadcaster->Broadcast( ScUpdateRefHint( URM_INSDEL,
aRange, 0,0,-1*nSheets ) );
+
+ for (auto & pTab : maTabs)
+ if (pTab)
+ pTab->UpdateDeleteTab(aCxt);
+
+ maTabs.erase(maTabs.begin() + nTab, maTabs.begin() + nTab +
nSheets);
+ // UpdateBroadcastAreas must be called between UpdateDeleteTab,
+ // which ends listening, and StartAllListeners, to not modify
+ // areas that are to be inserted by starting listeners.
+ UpdateBroadcastAreas( URM_INSDEL, aRange, 0,0,-1*nSheets);
+ for (const auto& a : maTabs)
+ {
+ if (a)
+ a->UpdateCompile();
+ }
+ // Excel-Filter deletes some Tables while loading, Listeners will
+ // only be triggered after the loading is done.
+ if ( !bInsertingFromOtherDoc )
+ {
+ StartAllListeners();
- if (comphelper::LibreOfficeKit::isActive())
- {
- ScModelObj* pModel =
comphelper::getFromUnoTunnel<ScModelObj>(this->GetDocumentShell()->GetModel());
- SfxLokHelper::notifyDocumentSizeChangedAllViews(pModel);
- }
+ sc::SetFormulaDirtyContext aFormulaDirtyCxt;
+ SetAllFormulasDirty(aFormulaDirtyCxt);
+ }
- bValid = true;
+ if (comphelper::LibreOfficeKit::isActive())
+ {
+ ScModelObj* pModel =
comphelper::getFromUnoTunnel<ScModelObj>(this->GetDocumentShell()->GetModel());
+ SfxLokHelper::notifyDocumentSizeChangedAllViews(pModel);
}
+
+ bValid = true;
}
}
return bValid;
@@ -863,41 +838,40 @@ bool ScDocument::RenameTab( SCTAB nTab, const OUString&
rName, bool bExternalDoc
{
bool bValid = false;
SCTAB i;
- if (ValidTab(nTab))
+ if (HasTable(nTab))
{
- if (maTabs[nTab])
+ if ( bExternalDocument )
+ bValid = true; // composed name
+ else
+ bValid = ValidTabName(rName);
+ for (i = 0; i < GetTableCount() && bValid; i++)
{
- if ( bExternalDocument )
- bValid = true; // composed name
- else
- bValid = ValidTabName(rName);
- for (i=0; (i< static_cast<SCTAB>(maTabs.size())) && bValid; i++)
- if (maTabs[i] && (i != nTab))
- {
- OUString aOldName = maTabs[i]->GetName();
- bValid = !ScGlobal::GetTransliteration().isEqual( rName,
aOldName );
- }
- if (bValid)
+ if (maTabs[i] && (i != nTab))
{
- // #i75258# update charts before renaming, so they can get
their live data objects.
- // Once the charts are live, the sheet can be renamed without
problems.
- if ( pChartListenerCollection )
- pChartListenerCollection->UpdateChartsContainingTab( nTab
);
- maTabs[nTab]->SetName(rName);
-
- // If formulas refer to the renamed sheet, the TokenArray
remains valid,
- // but the XML stream must be re-generated.
- for (const auto& a : maTabs)
- {
- if (a)
- a->SetStreamValid( false );
- }
+ OUString aOldName = maTabs[i]->GetName();
+ bValid = !ScGlobal::GetTransliteration().isEqual( rName,
aOldName );
+ }
+ }
+ if (bValid)
+ {
+ // #i75258# update charts before renaming, so they can get their
live data objects.
+ // Once the charts are live, the sheet can be renamed without
problems.
+ if ( pChartListenerCollection )
+ pChartListenerCollection->UpdateChartsContainingTab( nTab );
+ maTabs[nTab]->SetName(rName);
+
+ // If formulas refer to the renamed sheet, the TokenArray remains
valid,
+ // but the XML stream must be re-generated.
+ for (const auto& pTable : maTabs)
+ {
+ if (pTable)
+ pTable->SetStreamValid( false );
+ }
- if (comphelper::LibreOfficeKit::isActive() && GetDrawLayer())
- {
- ScModelObj* pModel =
comphelper::getFromUnoTunnel<ScModelObj>(this->GetDocumentShell()->GetModel());
- SfxLokHelper::notifyDocumentSizeChangedAllViews(pModel);
- }
+ if (comphelper::LibreOfficeKit::isActive() && GetDrawLayer())
+ {
+ ScModelObj* pModel =
comphelper::getFromUnoTunnel<ScModelObj>(this->GetDocumentShell()->GetModel());
+ SfxLokHelper::notifyDocumentSizeChangedAllViews(pModel);
}
}
}
@@ -909,32 +883,28 @@ bool ScDocument::RenameTab( SCTAB nTab, const OUString&
rName, bool bExternalDoc
void ScDocument::SetVisible( SCTAB nTab, bool bVisible )
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()))
- if (maTabs[nTab])
- maTabs[nTab]->SetVisible(bVisible);
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->SetVisible(bVisible);
}
bool ScDocument::IsVisible( SCTAB nTab ) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()))
- if (maTabs[nTab])
- return maTabs[nTab]->IsVisible();
-
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->IsVisible();
return false;
}
bool ScDocument::IsStreamValid( SCTAB nTab ) const
{
- if ( ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()) &&
maTabs[nTab] )
- return maTabs[nTab]->IsStreamValid();
-
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->IsStreamValid();
return false;
}
void ScDocument::SetStreamValid( SCTAB nTab, bool bSet, bool bIgnoreLock )
{
- if ( ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()) &&
maTabs[nTab] )
- maTabs[nTab]->SetStreamValid( bSet, bIgnoreLock );
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->SetStreamValid( bSet, bIgnoreLock );
}
void ScDocument::LockStreamValid( bool bLock )
@@ -944,16 +914,15 @@ void ScDocument::LockStreamValid( bool bLock )
bool ScDocument::IsPendingRowHeights( SCTAB nTab ) const
{
- if ( ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()) &&
maTabs[nTab] )
- return maTabs[nTab]->IsPendingRowHeights();
-
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->IsPendingRowHeights();
return false;
}
void ScDocument::SetPendingRowHeights( SCTAB nTab, bool bSet )
{
- if ( ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()) &&
maTabs[nTab] )
- maTabs[nTab]->SetPendingRowHeights( bSet );
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->SetPendingRowHeights(bSet);
}
sal_uInt16 ScDocument::GetSheetOptimalMinRowHeight(SCTAB nTab) const
@@ -967,7 +936,8 @@ sal_uInt16 ScDocument::GetSheetOptimalMinRowHeight(SCTAB
nTab) const
void ScDocument::SetLayoutRTL( SCTAB nTab, bool bRTL, ScObjectHandling
eObjectHandling)
{
- if ( !(ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()) &&
maTabs[nTab]) )
+ ScTable* pTable = FetchTable(nTab);
+ if (!pTable)
return;
if ( bImportingXML )
@@ -976,12 +946,12 @@ void ScDocument::SetLayoutRTL( SCTAB nTab, bool bRTL,
ScObjectHandling eObjectHa
// is applied in SetImportingXML(false). This is so the shapes can be
loaded in
// normal LTR mode.
- maTabs[nTab]->SetLoadingRTL( bRTL );
+ pTable->SetLoadingRTL( bRTL );
return;
}
- maTabs[nTab]->SetLayoutRTL( bRTL ); // only sets the flag
- maTabs[nTab]->SetDrawPageSize(true, true, eObjectHandling);
+ pTable->SetLayoutRTL( bRTL ); // only sets the flag
+ pTable->SetDrawPageSize(true, true, eObjectHandling);
// objects are already repositioned via SetDrawPageSize, only writing
mode is missing
if (!mpDrawLayer)
@@ -1003,8 +973,8 @@ void ScDocument::SetLayoutRTL( SCTAB nTab, bool bRTL,
ScObjectHandling eObjectHa
bool ScDocument::IsLayoutRTL( SCTAB nTab ) const
{
- if ( ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()) &&
maTabs[nTab] )
- return maTabs[nTab]->IsLayoutRTL();
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->IsLayoutRTL();
return false;
}
@@ -1027,9 +997,8 @@ 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 (maTabs[nTab])
- return maTabs[nTab]->GetCellArea( rEndCol, rEndRow );
+ if (HasTable(nTab))
+ return maTabs[nTab]->GetCellArea(rEndCol, rEndRow);
rEndCol = 0;
rEndRow = 0;
@@ -1038,9 +1007,8 @@ bool ScDocument::GetCellArea( SCTAB nTab, SCCOL& rEndCol,
SCROW& rEndRow ) const
bool ScDocument::GetTableArea( SCTAB nTab, SCCOL& rEndCol, SCROW& rEndRow,
bool bCalcHiddens) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()))
- if (maTabs[nTab])
- return maTabs[nTab]->GetTableArea( rEndCol, rEndRow, bCalcHiddens);
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->GetTableArea(rEndCol, rEndRow, bCalcHiddens);
rEndCol = 0;
rEndRow = 0;
@@ -1049,7 +1017,7 @@ bool ScDocument::GetTableArea( SCTAB nTab, SCCOL&
rEndCol, SCROW& rEndRow, bool
bool ScDocument::ShrinkToDataArea(SCTAB nTab, SCCOL& rStartCol, SCROW&
rStartRow, SCCOL& rEndCol, SCROW& rEndRow) const
{
- if (!ValidTab(nTab) || nTab >= static_cast<SCTAB> (maTabs.size()) ||
!maTabs[nTab])
+ if (!HasTable(nTab))
return false;
SCCOL nCol1, nCol2;
@@ -1082,23 +1050,21 @@ bool ScDocument::ShrinkToUsedDataArea( bool& o_bShrunk,
SCTAB nTab, SCCOL& rStar
SCROW& rStartRow, SCCOL& rEndCol, SCROW& rEndRow, bool bColumnsOnly,
bool bStickyTopRow, bool bStickyLeftCol, ScDataAreaExtras*
pDataAreaExtras ) const
{
- if (!ValidTab(nTab) || nTab >= static_cast<SCTAB> (maTabs.size()) ||
!maTabs[nTab])
+ if (const ScTable* pTable = FetchTable(nTab))
{
- o_bShrunk = false;
- return false;
+ return pTable->ShrinkToUsedDataArea(
+ o_bShrunk, rStartCol, rStartRow, rEndCol, rEndRow, bColumnsOnly,
bStickyTopRow,
+ bStickyLeftCol, pDataAreaExtras);
}
- return maTabs[nTab]->ShrinkToUsedDataArea(
- o_bShrunk, rStartCol, rStartRow, rEndCol, rEndRow, bColumnsOnly,
bStickyTopRow,
- bStickyLeftCol, pDataAreaExtras);
+ o_bShrunk = false;
+ return false;
}
SCROW ScDocument::GetLastDataRow( SCTAB nTab, SCCOL nCol1, SCCOL nCol2, SCROW
nLastRow ) const
{
- const ScTable* pTab = FetchTable(nTab);
- if (!pTab)
- return -1;
-
- return pTab->GetLastDataRow(nCol1, nCol2, nLastRow);
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->GetLastDataRow(nCol1, nCol2, nLastRow);
+ return -1;
}
// connected area
@@ -1106,8 +1072,8 @@ SCROW ScDocument::GetLastDataRow( SCTAB nTab, SCCOL
nCol1, SCCOL nCol2, SCROW nL
void ScDocument::GetDataArea( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow,
SCCOL& rEndCol, SCROW& rEndRow, bool
bIncludeOld, bool bOnlyDown ) const
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()) &&
maTabs[nTab])
- maTabs[nTab]->GetDataArea( rStartCol, rStartRow, rEndCol, rEndRow,
bIncludeOld, bOnlyDown );
+ if (const ScTable* pTable = FetchTable(nTab))
+ pTable->GetDataArea( rStartCol, rStartRow, rEndCol, rEndRow,
bIncludeOld, bOnlyDown );
}
bool ScDocument::GetDataAreaSubrange(ScRange& rRange) const
@@ -1116,8 +1082,8 @@ bool ScDocument::GetDataAreaSubrange(ScRange& rRange)
const
if (nTab != rRange.aEnd.Tab())
return true;
- if (ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()) &&
maTabs[nTab])
- return maTabs[nTab]->GetDataAreaSubrange(rRange);
+ if (const ScTable* pTable = FetchTable(nTab))
+ return pTable->GetDataAreaSubrange(rRange);
return true;
}
@@ -1125,9 +1091,8 @@ bool ScDocument::GetDataAreaSubrange(ScRange& rRange)
const
void ScDocument::LimitChartArea( SCTAB nTab, SCCOL& rStartCol, SCROW&
rStartRow,
SCCOL& rEndCol, SCROW& rEndRow )
{
- if (ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()))
- if (maTabs[nTab])
- maTabs[nTab]->LimitChartArea( rStartCol, rStartRow, rEndCol,
rEndRow );
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->LimitChartArea( rStartCol, rStartRow, rEndCol, rEndRow);
}
void ScDocument::LimitChartIfAll( ScRangeListRef& rRangeList )
@@ -1146,8 +1111,8 @@ void ScDocument::LimitChartIfAll( ScRangeListRef&
rRangeList )
SCCOL nEndCol = aRange.aEnd.Col();
SCROW nEndRow = aRange.aEnd.Row();
SCTAB nTab = aRange.aStart.Tab();
- if ( nTab < static_cast<SCTAB> (maTabs.size()) && maTabs[nTab])
- maTabs[nTab]->LimitChartArea(nStartCol, nStartRow,
nEndCol, nEndRow);
+ if (ScTable* pTable = FetchTable(nTab))
+ pTable->LimitChartArea(nStartCol, nStartRow, nEndCol,
nEndRow);
aRange.aStart.SetCol( nStartCol );
aRange.aStart.SetRow( nStartRow );
aRange.aEnd.SetCol( nEndCol );
@@ -1213,7 +1178,7 @@ bool ScDocument::CanInsertRow( const ScRange& rRange )
const
SCSIZE nSize = static_cast<SCSIZE>(nEndRow - nStartRow + 1);
bool bTest = true;
- for (SCTAB i=nStartTab; i<=nEndTab && bTest && i <
static_cast<SCTAB>(maTabs.size()); i++)
+ for (SCTAB i = nStartTab; i <= nEndTab && bTest && i < GetTableCount();
i++)
if (maTabs[i])
bTest &= maTabs[i]->TestInsertRow( nStartCol, nEndCol, nStartRow,
nSize );
@@ -1267,7 +1232,7 @@ bool ScDocument::InsertRow( SCCOL nStartCol, SCTAB
nStartTab,
if ( pTabMark )
{
nStartTab = 0;
- nEndTab = static_cast<SCTAB>(maTabs.size()) -1;
+ nEndTab = GetTableCount() - 1;
}
bool bTest = true;
@@ -1276,7 +1241,7 @@ bool ScDocument::InsertRow( SCCOL nStartCol, SCTAB
nStartTab,
SetAutoCalc( false ); // avoid multiple calculations
bool oldDelayedDeleteBroadcasters = IsDelayedDeletingBroadcasters();
EnableDelayDeletingBroadcasters( true );
- for ( i = nStartTab; i <= nEndTab && bTest && i <
static_cast<SCTAB>(maTabs.size()); i++)
+ for ( i = nStartTab; i <= nEndTab && bTest && i < GetTableCount(); i++)
if (maTabs[i] && (!pTabMark || pTabMark->GetTableSelect(i)))
bTest &= maTabs[i]->TestInsertRow(nStartCol, nEndCol, nStartRow,
nSize);
if (bTest)
@@ -1287,7 +1252,7 @@ bool ScDocument::InsertRow( SCCOL nStartCol, SCTAB
nStartTab,
// handle chunks of consecutive selected sheets together
SCTAB nTabRangeStart = nStartTab;
SCTAB nTabRangeEnd = nEndTab;
- lcl_GetFirstTabRange( nTabRangeStart, nTabRangeEnd, pTabMark,
static_cast<SCTAB>(maTabs.size()) );
+ lcl_GetFirstTabRange(nTabRangeStart, nTabRangeEnd, pTabMark,
GetTableCount());
ScRange aShiftedRange(nStartCol, nStartRow, nTabRangeStart, nEndCol,
MaxRow(), nTabRangeEnd);
sc::EndListeningContext aEndListenCxt(*this);
@@ -1305,9 +1270,9 @@ bool ScDocument::InsertRow( SCCOL nStartCol, SCTAB
nStartTab,
UpdateBroadcastAreas(URM_INSDEL, aShiftedRange, 0,
static_cast<SCROW>(nSize), 0);
}
- while ( lcl_GetNextTabRange( nTabRangeStart, nTabRangeEnd, pTabMark,
static_cast<SCTAB>(maTabs.size()) ) );
+ while (lcl_GetNextTabRange(nTabRangeStart, nTabRangeEnd, pTabMark,
GetTableCount()));
- lcl_GetFirstTabRange( nTabRangeStart, nTabRangeEnd, pTabMark,
static_cast<SCTAB>(maTabs.size()) );
+ lcl_GetFirstTabRange(nTabRangeStart, nTabRangeEnd, pTabMark,
GetTableCount());
sc::RefUpdateContext aCxt(*this);
aCxt.meMode = URM_INSDEL;
@@ -1319,20 +1284,20 @@ bool ScDocument::InsertRow( SCCOL nStartCol, SCTAB
nStartTab,
aCxt.maRange.aEnd.SetTab(nTabRangeEnd);
UpdateReference(aCxt, pRefUndoDoc, false); // without
drawing objects
}
- while ( lcl_GetNextTabRange( nTabRangeStart, nTabRangeEnd, pTabMark,
static_cast<SCTAB>(maTabs.size()) ) );
+ while (lcl_GetNextTabRange( nTabRangeStart, nTabRangeEnd, pTabMark,
GetTableCount()));
// UpdateReference should have set "needs listening" flags to those
// whose references have been modified. We also need to set this flag
// to those that were in the groups that got split by shifting.
SetNeedsListeningGroups(aGroupPos);
- for (i=nStartTab; i<=nEndTab && i < static_cast<SCTAB>(maTabs.size());
i++)
+ for (i=nStartTab; i<=nEndTab && i < GetTableCount(); i++)
if (maTabs[i] && (!pTabMark || pTabMark->GetTableSelect(i)))
maTabs[i]->InsertRow( nStartCol, nEndCol, nStartRow, nSize );
// UpdateRef for drawing layer must be after inserting,
// when the new row heights are known.
- for (i=nStartTab; i<=nEndTab && i < static_cast<SCTAB>(maTabs.size());
i++)
+ for (i=nStartTab; i<=nEndTab && i < GetTableCount(); i++)
if (maTabs[i] && (!pTabMark || pTabMark->GetTableSelect(i)))
maTabs[i]->UpdateDrawRef( URM_INSDEL,
nStartCol, nStartRow, nStartTab, nEndCol,
MaxRow(), nEndTab,
@@ -1390,7 +1355,7 @@ void ScDocument::DeleteRow( SCCOL nStartCol, SCTAB
nStartTab,
if ( pTabMark )
{
nStartTab = 0;
- nEndTab = static_cast<SCTAB>(maTabs.size())-1;
+ nEndTab = GetTableCount() - 1;
}
sc::AutoCalcSwitch aACSwitch(*this, false); // avoid multiple calculations
@@ -1398,7 +1363,7 @@ void ScDocument::DeleteRow( SCCOL nStartCol, SCTAB
nStartTab,
// handle chunks of consecutive selected sheets together
SCTAB nTabRangeStart = nStartTab;
SCTAB nTabRangeEnd = nEndTab;
- lcl_GetFirstTabRange( nTabRangeStart, nTabRangeEnd, pTabMark,
static_cast<SCTAB>(maTabs.size()) );
+ lcl_GetFirstTabRange(nTabRangeStart, nTabRangeEnd, pTabMark,
GetTableCount());
do
{
if ( ValidRow(nStartRow+nSize) )
@@ -1415,13 +1380,13 @@ void ScDocument::DeleteRow( SCCOL nStartCol, SCTAB
nStartTab,
ScAddress( nStartCol, nStartRow, nTabRangeStart ),
ScAddress( nEndCol, MaxRow(), nTabRangeEnd ) ) );
}
- while ( lcl_GetNextTabRange( nTabRangeStart, nTabRangeEnd, pTabMark,
static_cast<SCTAB>(maTabs.size()) ) );
+ while (lcl_GetNextTabRange(nTabRangeStart, nTabRangeEnd, pTabMark,
GetTableCount()));
sc::RefUpdateContext aCxt(*this);
const bool bLastRowIncluded = (static_cast<SCROW>(nStartRow + nSize) ==
GetMaxRowCount() && ValidRow(nStartRow));
if ( ValidRow(nStartRow+nSize) || bLastRowIncluded )
{
- lcl_GetFirstTabRange( nTabRangeStart, nTabRangeEnd, pTabMark,
static_cast<SCTAB>(maTabs.size()) );
+ lcl_GetFirstTabRange(nTabRangeStart, nTabRangeEnd, pTabMark,
GetTableCount());
aCxt.meMode = URM_INSDEL;
aCxt.mnRowDelta = -static_cast<SCROW>(nSize);
if (bLastRowIncluded)
@@ -1437,7 +1402,7 @@ void ScDocument::DeleteRow( SCCOL nStartCol, SCTAB
nStartTab,
{
UpdateReference(aCxt, pRefUndoDoc, true, false);
}
- while ( lcl_GetNextTabRange( nTabRangeStart, nTabRangeEnd, pTabMark,
static_cast<SCTAB>(maTabs.size()) ) );
+ while (lcl_GetNextTabRange(nTabRangeStart, nTabRangeEnd, pTabMark,
GetTableCount()));
}
if (pUndoOutline)
@@ -1447,7 +1412,7 @@ void ScDocument::DeleteRow( SCCOL nStartCol, SCTAB
nStartTab,
// during row deletion.
std::vector<ScAddress> aGroupPos;
... etc. - the rest is truncated
