[Libreoffice-commits] .: 3 commits - sc/inc sc/source
Kohei Yoshida
kohei at kemper.freedesktop.org
Fri Jan 20 14:15:11 PST 2012
sc/inc/column.hxx | 7
sc/source/core/data/column.cxx | 440 +++++++++++++++++----------------------
sc/source/core/data/column2.cxx | 206 +++++++++---------
sc/source/core/data/column3.cxx | 362 +++++++++++++-------------------
sc/source/core/data/dociter.cxx | 107 ++++-----
sc/source/core/data/fillinfo.cxx | 6
6 files changed, 511 insertions(+), 617 deletions(-)
New commits:
commit 94c63b8699e822fe1344002b68c3b11e687a1153
Author: Kohei Yoshida <kohei.yoshida at suse.com>
Date: Fri Jan 20 14:39:54 2012 -0500
Prefer using back() to access the last element.
diff --git a/sc/inc/column.hxx b/sc/inc/column.hxx
index e00aa64..2f58a92 100644
--- a/sc/inc/column.hxx
+++ b/sc/inc/column.hxx
@@ -256,7 +256,7 @@ public:
double GetValue( SCROW nRow ) const;
void GetFormula( SCROW nRow, rtl::OUString& rFormula ) const;
CellType GetCellType( SCROW nRow ) const;
- SCSIZE GetCellCount() const { return maItems.size(); }
+ SCSIZE GetCellCount() const;
sal_uInt32 GetWeightedCount() const;
sal_uInt32 GetCodeCount() const; // RPN-Code in formulas
sal_uInt16 GetErrCode( SCROW nRow ) const;
diff --git a/sc/source/core/data/column.cxx b/sc/source/core/data/column.cxx
index bc2a040..6c1c849 100644
--- a/sc/source/core/data/column.cxx
+++ b/sc/source/core/data/column.cxx
@@ -705,7 +705,7 @@ bool ScColumn::Search( SCROW nRow, SCSIZE& nIndex ) const
nIndex = 0;
return nRow == nMinRow;
}
- SCROW nMaxRow = maItems[maItems.size()-1].nRow;
+ SCROW nMaxRow = maItems.back().nRow;
if ( nRow >= nMaxRow )
{
if ( nRow == nMaxRow )
@@ -1103,7 +1103,7 @@ void ScColumn::InsertRow( SCROW nStartRow, SCSIZE nSize )
ScHint aHint( SC_HINT_DATACHANGED, aAdr, NULL ); // only areas (ScBaseCell* == NULL)
ScAddress& rAddress = aHint.GetAddress();
// for sparse occupation use single broadcasts, not ranges
- bool bSingleBroadcasts = (((maItems[maItems.size()-1].nRow - maItems[i].nRow) /
+ bool bSingleBroadcasts = (((maItems.back().nRow - maItems[i].nRow) /
(maItems.size() - i)) > 1);
if ( bSingleBroadcasts )
{
@@ -1150,7 +1150,7 @@ void ScColumn::InsertRow( SCROW nStartRow, SCSIZE nSize )
}
}
if ( !bCountChanged )
- aRange.aEnd.SetRow( maItems[maItems.size()-1].nRow );
+ aRange.aEnd.SetRow( maItems.back().nRow );
pDocument->AreaBroadcastInRange( aRange, aHint );
}
diff --git a/sc/source/core/data/column2.cxx b/sc/source/core/data/column2.cxx
index f7c9dbb..b97b0de 100644
--- a/sc/source/core/data/column2.cxx
+++ b/sc/source/core/data/column2.cxx
@@ -1296,7 +1296,7 @@ SCROW ScColumn::GetFirstDataPos() const
SCROW ScColumn::GetLastDataPos() const
{
if ( !maItems.empty() )
- return maItems[maItems.size()-1].nRow;
+ return maItems.back().nRow;
else
return 0;
}
diff --git a/sc/source/core/data/column3.cxx b/sc/source/core/data/column3.cxx
index e880110..687c62d 100644
--- a/sc/source/core/data/column3.cxx
+++ b/sc/source/core/data/column3.cxx
@@ -74,7 +74,7 @@ void ScColumn::Insert( SCROW nRow, ScBaseCell* pNewCell )
sal_Bool bIsAppended = false;
if ( !maItems.empty() )
{
- if (maItems[maItems.size()-1].nRow < nRow)
+ if (maItems.back().nRow < nRow)
{
Append(nRow, pNewCell );
bIsAppended = sal_True;
@@ -149,8 +149,8 @@ void ScColumn::Insert( SCROW nRow, sal_uInt32 nNumberFormat, ScBaseCell* pCell )
void ScColumn::Append( SCROW nRow, ScBaseCell* pCell )
{
maItems.push_back(ColEntry());
- maItems[maItems.size() - 1].pCell = pCell;
- maItems[maItems.size() - 1].nRow = nRow;
+ maItems.back().pCell = pCell;
+ maItems.back().nRow = nRow;
}
@@ -260,7 +260,7 @@ void ScColumn::DeleteRow( SCROW nStartRow, SCSIZE nSize )
ScHint aHint( SC_HINT_DATACHANGED, aAdr, NULL ); // only areas (ScBaseCell* == NULL)
ScAddress& rAddress = aHint.GetAddress();
// for sparse occupation use single broadcasts, not ranges
- sal_Bool bSingleBroadcasts = (((maItems[maItems.size()-1].nRow - maItems[i].nRow) /
+ bool bSingleBroadcasts = (((maItems.back().nRow - maItems[i].nRow) /
(maItems.size() - i)) > 1);
if ( bSingleBroadcasts )
{
@@ -288,7 +288,7 @@ void ScColumn::DeleteRow( SCROW nStartRow, SCSIZE nSize )
{
rAddress.SetRow( maItems[i].nRow );
ScRange aRange( rAddress );
- aRange.aEnd.SetRow( maItems[maItems.size()-1].nRow );
+ aRange.aEnd.SetRow( maItems.back().nRow );
for ( ; i < maItems.size(); i++ )
{
SCROW nNewRow = (maItems[i].nRow -= nSize);
@@ -1439,7 +1439,7 @@ bool ScColumn::SetString( SCROW nRow, SCTAB nTabP, const String& rString,
}
}
- if ( bIsLoading && (maItems.empty() || nRow > maItems[maItems.size()-1].nRow) )
+ if ( bIsLoading && (maItems.empty() || nRow > maItems.back().nRow) )
{ // Search einsparen und ohne Umweg ueber Insert, Listener aufbauen
// und Broadcast kommt eh erst nach dem Laden
if ( pNewCell )
@@ -1820,6 +1820,10 @@ CellType ScColumn::GetCellType( SCROW nRow ) const
return CELLTYPE_NONE;
}
+SCSIZE ScColumn::GetCellCount() const
+{
+ return maItems.size();
+}
sal_uInt16 ScColumn::GetErrCode( SCROW nRow ) const
{
commit bd161794ac844891f18660c292387dd449cb4c71
Author: Kohei Yoshida <kohei.yoshida at suse.com>
Date: Fri Jan 20 12:36:07 2012 -0500
Added 'm' prefix for a data member.
diff --git a/sc/inc/column.hxx b/sc/inc/column.hxx
index 5000bae..e00aa64 100644
--- a/sc/inc/column.hxx
+++ b/sc/inc/column.hxx
@@ -106,7 +106,7 @@ private:
SCCOL nCol;
SCTAB nTab;
- std::vector<ColEntry> aItems;
+ std::vector<ColEntry> maItems;
ScAttrArray* pAttrArray;
ScDocument* pDocument;
@@ -256,7 +256,7 @@ public:
double GetValue( SCROW nRow ) const;
void GetFormula( SCROW nRow, rtl::OUString& rFormula ) const;
CellType GetCellType( SCROW nRow ) const;
- SCSIZE GetCellCount() const { return aItems.size(); }
+ SCSIZE GetCellCount() const { return maItems.size(); }
sal_uInt32 GetWeightedCount() const;
sal_uInt32 GetCodeCount() const; // RPN-Code in formulas
sal_uInt16 GetErrCode( SCROW nRow ) const;
diff --git a/sc/source/core/data/column.cxx b/sc/source/core/data/column.cxx
index 133ccb2..bc2a040 100644
--- a/sc/source/core/data/column.cxx
+++ b/sc/source/core/data/column.cxx
@@ -115,14 +115,14 @@ SCsROW ScColumn::GetNextUnprotected( SCROW nRow, bool bUp ) const
sal_uInt16 ScColumn::GetBlockMatrixEdges( SCROW nRow1, SCROW nRow2, sal_uInt16 nMask ) const
{
// nothing:0, inside:1, bottom:2, left:4, top:8, right:16, open:32
- if ( aItems.empty() )
+ if ( maItems.empty() )
return 0;
if ( nRow1 == nRow2 )
{
SCSIZE nIndex;
if ( Search( nRow1, nIndex ) )
{
- ScBaseCell* pCell = aItems[nIndex].pCell;
+ ScBaseCell* pCell = maItems[nIndex].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA
&& ((ScFormulaCell*)pCell)->GetMatrixFlag() )
{
@@ -139,9 +139,9 @@ sal_uInt16 ScColumn::GetBlockMatrixEdges( SCROW nRow1, SCROW nRow2, sal_uInt16 n
sal_uInt16 nEdges = 0;
SCSIZE nIndex;
Search( nRow1, nIndex );
- while ( nIndex < aItems.size() && aItems[nIndex].nRow <= nRow2 )
+ while ( nIndex < maItems.size() && maItems[nIndex].nRow <= nRow2 )
{
- ScBaseCell* pCell = aItems[nIndex].pCell;
+ ScBaseCell* pCell = maItems[nIndex].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA
&& ((ScFormulaCell*)pCell)->GetMatrixFlag() )
{
@@ -188,9 +188,9 @@ bool ScColumn::HasSelectionMatrixFragment(const ScMarkData& rMark) const
sal_uInt16 nEdges;
SCSIZE nIndex;
Search( nTop, nIndex );
- while ( !bFound && nIndex < aItems.size() && aItems[nIndex].nRow <= nBottom )
+ while ( !bFound && nIndex < maItems.size() && maItems[nIndex].nRow <= nBottom )
{
- ScBaseCell* pCell = aItems[nIndex].pCell;
+ ScBaseCell* pCell = maItems[nIndex].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA
&& ((ScFormulaCell*)pCell)->GetMatrixFlag() )
{
@@ -694,39 +694,39 @@ void ScColumn::ApplyAttr( SCROW nRow, const SfxPoolItem& rAttr )
bool ScColumn::Search( SCROW nRow, SCSIZE& nIndex ) const
{
- if ( aItems.empty() )
+ if ( maItems.empty() )
{
nIndex = 0;
return false;
}
- SCROW nMinRow = aItems[0].nRow;
+ SCROW nMinRow = maItems[0].nRow;
if ( nRow <= nMinRow )
{
nIndex = 0;
return nRow == nMinRow;
}
- SCROW nMaxRow = aItems[aItems.size()-1].nRow;
+ SCROW nMaxRow = maItems[maItems.size()-1].nRow;
if ( nRow >= nMaxRow )
{
if ( nRow == nMaxRow )
{
- nIndex = aItems.size() - 1;
+ nIndex = maItems.size() - 1;
return true;
}
else
{
- nIndex = aItems.size();
+ nIndex = maItems.size();
return false;
}
}
long nOldLo, nOldHi;
long nLo = nOldLo = 0;
- long nHi = nOldHi = Min(static_cast<long>(aItems.size())-1, static_cast<long>(nRow) );
+ long nHi = nOldHi = Min(static_cast<long>(maItems.size())-1, static_cast<long>(nRow) );
long i = 0;
bool bFound = false;
// quite continuous distribution? => interpolating search
- bool bInterpol = (static_cast<SCSIZE>(nMaxRow - nMinRow) < aItems.size() * 2);
+ bool bInterpol = (static_cast<SCSIZE>(nMaxRow - nMinRow) < maItems.size() * 2);
SCROW nR;
while ( !bFound && nLo <= nHi )
@@ -735,16 +735,16 @@ bool ScColumn::Search( SCROW nRow, SCSIZE& nIndex ) const
i = (nLo+nHi) / 2; // no effort, no division by zero
else
{ // interpolating search
- long nLoRow = aItems[nLo].nRow; // no unsigned underflow upon substraction
+ long nLoRow = maItems[nLo].nRow; // no unsigned underflow upon substraction
i = nLo + (long)((long)(nRow - nLoRow) * (nHi - nLo)
- / (aItems[nHi].nRow - nLoRow));
- if ( i < 0 || static_cast<SCSIZE>(i) >= aItems.size() )
+ / (maItems[nHi].nRow - nLoRow));
+ if ( i < 0 || static_cast<SCSIZE>(i) >= maItems.size() )
{ // oops ...
i = (nLo+nHi) / 2;
bInterpol = false;
}
}
- nR = aItems[i].nRow;
+ nR = maItems[i].nRow;
if ( nR < nRow )
{
nLo = i+1;
@@ -789,7 +789,7 @@ ScBaseCell* ScColumn::GetCell( SCROW nRow ) const
{
SCSIZE nIndex;
if (Search(nRow, nIndex))
- return aItems[nIndex].pCell;
+ return maItems[nIndex].pCell;
return NULL;
}
@@ -798,10 +798,10 @@ void ScColumn::Resize( SCSIZE nSize )
{
if (nSize > sal::static_int_cast<SCSIZE>(MAXROWCOUNT))
nSize = MAXROWCOUNT;
- if (nSize < aItems.size())
- nSize = aItems.size();
+ if (nSize < maItems.size())
+ nSize = maItems.size();
- aItems.reserve(nSize);
+ maItems.reserve(nSize);
}
// SwapRow zum Sortieren
@@ -835,12 +835,12 @@ void ScColumn::SwapRow(SCROW nRow1, SCROW nRow2)
ScBaseCell* pCell1 = 0;
SCSIZE nIndex1;
if ( Search( nRow1, nIndex1 ) )
- pCell1 = aItems[nIndex1].pCell;
+ pCell1 = maItems[nIndex1].pCell;
ScBaseCell* pCell2 = 0;
SCSIZE nIndex2;
if ( Search( nRow2, nIndex2 ) )
- pCell2 = aItems[nIndex2].pCell;
+ pCell2 = maItems[nIndex2].pCell;
// no cells found, nothing to do
if ( !pCell1 && !pCell2 )
@@ -875,8 +875,8 @@ void ScColumn::SwapRow(SCROW nRow1, SCROW nRow2)
{
/* Both cells exist, no formula cells involved, a simple swap can
be performed (but keep broadcasters and notes at old position). */
- aItems[nIndex1].pCell = pCell2;
- aItems[nIndex2].pCell = pCell1;
+ maItems[nIndex1].pCell = pCell2;
+ maItems[nIndex2].pCell = pCell1;
SvtBroadcaster* pBC2 = pCell2->ReleaseBroadcaster();
pCell1->TakeBroadcaster( pBC2 );
@@ -888,12 +888,12 @@ void ScColumn::SwapRow(SCROW nRow1, SCROW nRow2)
if ( pDummyCell )
{
// insert dummy note cell (without note) containing old broadcaster
- aItems[nIndex1].pCell = pDummyCell;
+ maItems[nIndex1].pCell = pDummyCell;
}
else
{
// remove ColEntry at old position
- aItems.erase( aItems.begin() + nIndex1 );
+ maItems.erase( maItems.begin() + nIndex1 );
}
// insert ColEntry at new position
@@ -983,12 +983,12 @@ void ScColumn::SwapCell( SCROW nRow, ScColumn& rCol)
ScBaseCell* pCell1 = 0;
SCSIZE nIndex1;
if ( Search( nRow, nIndex1 ) )
- pCell1 = aItems[nIndex1].pCell;
+ pCell1 = maItems[nIndex1].pCell;
ScBaseCell* pCell2 = 0;
SCSIZE nIndex2;
if ( rCol.Search( nRow, nIndex2 ) )
- pCell2 = rCol.aItems[nIndex2].pCell;
+ pCell2 = rCol.maItems[nIndex2].pCell;
// reverse call if own cell is missing (ensures own existing cell in following code)
if( !pCell1 )
@@ -1006,8 +1006,8 @@ void ScColumn::SwapCell( SCROW nRow, ScColumn& rCol)
if ( pCell2 )
{
// Tauschen
- aItems[nIndex1].pCell = pCell2;
- rCol.aItems[nIndex2].pCell = pCell1;
+ maItems[nIndex1].pCell = pCell2;
+ rCol.maItems[nIndex2].pCell = pCell1;
// Referenzen aktualisieren
SCsCOL dx = rCol.nCol - nCol;
if ( pFmlaCell1 )
@@ -1028,7 +1028,7 @@ void ScColumn::SwapCell( SCROW nRow, ScColumn& rCol)
else
{
// Loeschen
- aItems.erase(aItems.begin() + nIndex1);
+ maItems.erase(maItems.begin() + nIndex1);
// Referenzen aktualisieren
SCsCOL dx = rCol.nCol - nCol;
if ( pFmlaCell1 )
@@ -1049,10 +1049,10 @@ bool ScColumn::TestInsertCol( SCROW nStartRow, SCROW nEndRow) const
if (!IsEmpty())
{
bool bTest = true;
- if ( !aItems.empty() )
- for (SCSIZE i=0; (i<aItems.size()) && bTest; i++)
- bTest = (aItems[i].nRow < nStartRow) || (aItems[i].nRow > nEndRow)
- || aItems[i].pCell->IsBlank();
+ if ( !maItems.empty() )
+ for (SCSIZE i=0; (i<maItems.size()) && bTest; i++)
+ bTest = (maItems[i].nRow < nStartRow) || (maItems[i].nRow > nEndRow)
+ || maItems[i].pCell->IsBlank();
// AttrArray testet nur zusammengefasste
@@ -1072,9 +1072,9 @@ bool ScColumn::TestInsertRow( SCSIZE nSize ) const
{
// AttrArray only looks for merged cells
- if ( !aItems.empty() )
+ if ( !maItems.empty() )
return ( nSize <= sal::static_int_cast<SCSIZE>(MAXROW) &&
- aItems[aItems.size()-1].nRow <= MAXROW-(SCROW)nSize && pAttrArray->TestInsertRow( nSize ) );
+ maItems[maItems.size()-1].nRow <= MAXROW-(SCROW)nSize && pAttrArray->TestInsertRow( nSize ) );
else
return pAttrArray->TestInsertRow( nSize );
}
@@ -1086,43 +1086,43 @@ void ScColumn::InsertRow( SCROW nStartRow, SCSIZE nSize )
//! Search
- if ( aItems.empty() )
+ if ( maItems.empty() )
return;
SCSIZE i;
Search( nStartRow, i );
- if ( i >= aItems.size() )
+ if ( i >= maItems.size() )
return ;
bool bOldAutoCalc = pDocument->GetAutoCalc();
pDocument->SetAutoCalc( false ); // Mehrfachberechnungen vermeiden
- SCSIZE nNewCount = aItems.size();
+ SCSIZE nNewCount = maItems.size();
bool bCountChanged = false;
ScAddress aAdr( nCol, 0, nTab );
ScHint aHint( SC_HINT_DATACHANGED, aAdr, NULL ); // only areas (ScBaseCell* == NULL)
ScAddress& rAddress = aHint.GetAddress();
// for sparse occupation use single broadcasts, not ranges
- bool bSingleBroadcasts = (((aItems[aItems.size()-1].nRow - aItems[i].nRow) /
- (aItems.size() - i)) > 1);
+ bool bSingleBroadcasts = (((maItems[maItems.size()-1].nRow - maItems[i].nRow) /
+ (maItems.size() - i)) > 1);
if ( bSingleBroadcasts )
{
SCROW nLastBroadcast = MAXROW+1;
- for ( ; i < aItems.size(); i++)
+ for ( ; i < maItems.size(); i++)
{
- SCROW nOldRow = aItems[i].nRow;
+ SCROW nOldRow = maItems[i].nRow;
// Change source broadcaster
if ( nLastBroadcast != nOldRow )
{ // Do not broadcast a direct sequence twice
rAddress.SetRow( nOldRow );
pDocument->AreaBroadcast( aHint );
}
- SCROW nNewRow = (aItems[i].nRow += nSize);
+ SCROW nNewRow = (maItems[i].nRow += nSize);
// Change target broadcaster
rAddress.SetRow( nNewRow );
pDocument->AreaBroadcast( aHint );
nLastBroadcast = nNewRow;
- ScBaseCell* pCell = aItems[i].pCell;
+ ScBaseCell* pCell = maItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
((ScFormulaCell*)pCell)->aPos.SetRow( nNewRow );
if ( nNewRow > MAXROW && !bCountChanged )
@@ -1134,12 +1134,12 @@ void ScColumn::InsertRow( SCROW nStartRow, SCSIZE nSize )
}
else
{
- rAddress.SetRow( aItems[i].nRow );
+ rAddress.SetRow( maItems[i].nRow );
ScRange aRange( rAddress );
- for ( ; i < aItems.size(); i++)
+ for ( ; i < maItems.size(); i++)
{
- SCROW nNewRow = (aItems[i].nRow += nSize);
- ScBaseCell* pCell = aItems[i].pCell;
+ SCROW nNewRow = (maItems[i].nRow += nSize);
+ ScBaseCell* pCell = maItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
((ScFormulaCell*)pCell)->aPos.SetRow( nNewRow );
if ( nNewRow > MAXROW && !bCountChanged )
@@ -1150,21 +1150,21 @@ void ScColumn::InsertRow( SCROW nStartRow, SCSIZE nSize )
}
}
if ( !bCountChanged )
- aRange.aEnd.SetRow( aItems[aItems.size()-1].nRow );
+ aRange.aEnd.SetRow( maItems[maItems.size()-1].nRow );
pDocument->AreaBroadcastInRange( aRange, aHint );
}
if (bCountChanged)
{
- SCSIZE nDelCount = aItems.size() - nNewCount;
+ SCSIZE nDelCount = maItems.size() - nNewCount;
ScBaseCell** ppDelCells = new ScBaseCell*[nDelCount];
SCROW* pDelRows = new SCROW[nDelCount];
for (i = 0; i < nDelCount; i++)
{
- ppDelCells[i] = aItems[nNewCount+i].pCell;
- pDelRows[i] = aItems[nNewCount+i].nRow;
+ ppDelCells[i] = maItems[nNewCount+i].pCell;
+ pDelRows[i] = maItems[nNewCount+i].nRow;
}
- aItems.resize( nNewCount );
+ maItems.resize( nNewCount );
for (i = 0; i < nDelCount; i++)
{
@@ -1195,8 +1195,8 @@ void ScColumn::CopyToClip(SCROW nRow1, SCROW nRow2, ScColumn& rColumn, bool bKee
SCSIZE i;
SCSIZE nBlockCount = 0;
SCSIZE nStartIndex = 0, nEndIndex = 0;
- for (i = 0; i < aItems.size(); i++)
- if ((aItems[i].nRow >= nRow1) && (aItems[i].nRow <= nRow2))
+ for (i = 0; i < maItems.size(); i++)
+ if ((maItems[i].nRow >= nRow1) && (maItems[i].nRow <= nRow2))
{
if (!nBlockCount)
nStartIndex = i;
@@ -1206,9 +1206,9 @@ void ScColumn::CopyToClip(SCROW nRow1, SCROW nRow2, ScColumn& rColumn, bool bKee
// im Clipboard muessen interpretierte Zellen stehen, um andere Formate
// (Text, Grafik...) erzueugen zu koennen
- if ( aItems[i].pCell->GetCellType() == CELLTYPE_FORMULA )
+ if ( maItems[i].pCell->GetCellType() == CELLTYPE_FORMULA )
{
- ScFormulaCell* pFCell = (ScFormulaCell*) aItems[i].pCell;
+ ScFormulaCell* pFCell = (ScFormulaCell*) maItems[i].pCell;
if (pFCell->GetDirty() && pDocument->GetAutoCalc())
pFCell->Interpret();
}
@@ -1222,9 +1222,9 @@ void ScColumn::CopyToClip(SCROW nRow1, SCROW nRow2, ScColumn& rColumn, bool bKee
ScAddress aDestPos( rColumn.nCol, 0, rColumn.nTab );
for (i = nStartIndex; i <= nEndIndex; i++)
{
- aOwnPos.SetRow( aItems[i].nRow );
- aDestPos.SetRow( aItems[i].nRow );
- ScBaseCell* pNewCell = aItems[i].pCell->CloneWithNote( aOwnPos, *rColumn.pDocument, aDestPos, nCloneFlags );
+ aOwnPos.SetRow( maItems[i].nRow );
+ aDestPos.SetRow( maItems[i].nRow );
+ ScBaseCell* pNewCell = maItems[i].pCell->CloneWithNote( aOwnPos, *rColumn.pDocument, aDestPos, nCloneFlags );
rColumn.Append( aDestPos.Row(), pNewCell );
}
}
@@ -1281,8 +1281,8 @@ void ScColumn::CopyToColumn(SCROW nRow1, SCROW nRow2, sal_uInt16 nFlags, bool bM
SCSIZE i;
SCSIZE nBlockCount = 0;
SCSIZE nStartIndex = 0, nEndIndex = 0;
- for (i = 0; i < aItems.size(); i++)
- if ((aItems[i].nRow >= nRow1) && (aItems[i].nRow <= nRow2))
+ for (i = 0; i < maItems.size(); i++)
+ if ((maItems[i].nRow >= nRow1) && (maItems[i].nRow <= nRow2))
{
if (!nBlockCount)
nStartIndex = i;
@@ -1296,7 +1296,7 @@ void ScColumn::CopyToColumn(SCROW nRow1, SCROW nRow2, sal_uInt16 nFlags, bool bM
ScAddress aDestPos( rColumn.nCol, 0, rColumn.nTab );
for (i = nStartIndex; i <= nEndIndex; i++)
{
- aDestPos.SetRow( aItems[i].nRow );
+ aDestPos.SetRow( maItems[i].nRow );
ScBaseCell* pNew = bAsLink ?
CreateRefCell( rColumn.pDocument, aDestPos, i, nFlags ) :
CloneCell( i, nFlags, *rColumn.pDocument, aDestPos );
@@ -1312,13 +1312,13 @@ void ScColumn::CopyToColumn(SCROW nRow1, SCROW nRow2, sal_uInt16 nFlags, bool bM
static_cast<ScStringCell*>(pNew)->GetString(aStr);
if (aStr.Len() == 0)
// A string cell with empty string. Delete the cell itself.
- rColumn.Delete(aItems[i].nRow);
+ rColumn.Delete(maItems[i].nRow);
else
// non-empty string cell
- rColumn.Insert(aItems[i].nRow, pNew);
+ rColumn.Insert(maItems[i].nRow, pNew);
}
else
- rColumn.Insert(aItems[i].nRow, pNew);
+ rColumn.Insert(maItems[i].nRow, pNew);
}
}
}
@@ -1345,15 +1345,15 @@ void ScColumn::CopyUpdated( const ScColumn& rPosCol, ScColumn& rDestCol ) const
ScAddress aOwnPos( nCol, 0, nTab );
ScAddress aDestPos( rDestCol.nCol, 0, rDestCol.nTab );
- SCSIZE nPosCount = rPosCol.aItems.size();
+ SCSIZE nPosCount = rPosCol.maItems.size();
for (SCSIZE nPosIndex = 0; nPosIndex < nPosCount; nPosIndex++)
{
- aOwnPos.SetRow( rPosCol.aItems[nPosIndex].nRow );
+ aOwnPos.SetRow( rPosCol.maItems[nPosIndex].nRow );
aDestPos.SetRow( aOwnPos.Row() );
SCSIZE nThisIndex;
if ( Search( aDestPos.Row(), nThisIndex ) )
{
- ScBaseCell* pNew = aItems[nThisIndex].pCell->CloneWithNote( aOwnPos, rDestDoc, aDestPos );
+ ScBaseCell* pNew = maItems[nThisIndex].pCell->CloneWithNote( aOwnPos, rDestDoc, aDestPos );
rDestCol.Insert( aDestPos.Row(), pNew );
}
}
@@ -1464,7 +1464,7 @@ void ScColumn::MarkScenarioIn( ScMarkData& rDestMark ) const
void ScColumn::SwapCol(ScColumn& rCol)
{
- aItems.swap(rCol.aItems);
+ maItems.swap(rCol.maItems);
ScAttrArray* pTempAttr = rCol.pAttrArray;
rCol.pAttrArray = pAttrArray;
@@ -1475,15 +1475,15 @@ void ScColumn::SwapCol(ScColumn& rCol)
rCol.pAttrArray->SetCol(rCol.nCol);
SCSIZE i;
- for (i = 0; i < aItems.size(); i++)
+ for (i = 0; i < maItems.size(); i++)
{
- ScFormulaCell* pCell = (ScFormulaCell*) aItems[i].pCell;
+ ScFormulaCell* pCell = (ScFormulaCell*) maItems[i].pCell;
if( pCell->GetCellType() == CELLTYPE_FORMULA)
pCell->aPos.SetCol(nCol);
}
- for (i = 0; i < rCol.aItems.size(); i++)
+ for (i = 0; i < rCol.maItems.size(); i++)
{
- ScFormulaCell* pCell = (ScFormulaCell*) rCol.aItems[i].pCell;
+ ScFormulaCell* pCell = (ScFormulaCell*) rCol.maItems[i].pCell;
if( pCell->GetCellType() == CELLTYPE_FORMULA)
pCell->aPos.SetCol(rCol.nCol);
}
@@ -1494,19 +1494,19 @@ void ScColumn::MoveTo(SCROW nStartRow, SCROW nEndRow, ScColumn& rCol)
{
pAttrArray->MoveTo(nStartRow, nEndRow, *rCol.pAttrArray);
- if ( !aItems.empty() )
+ if ( !maItems.empty() )
{
::std::vector<SCROW> aRows;
bool bConsecutive = true;
SCSIZE i;
Search( nStartRow, i); // i points to start row or position thereafter
SCSIZE nStartPos = i;
- for ( ; i < aItems.size() && aItems[i].nRow <= nEndRow; ++i)
+ for ( ; i < maItems.size() && maItems[i].nRow <= nEndRow; ++i)
{
- SCROW nRow = aItems[i].nRow;
+ SCROW nRow = maItems[i].nRow;
aRows.push_back( nRow);
- rCol.Insert( nRow, aItems[i].pCell);
- if (nRow != aItems[i].nRow)
+ rCol.Insert( nRow, maItems[i].pCell);
+ if (nRow != maItems[i].nRow)
{ // Listener inserted
bConsecutive = false;
Search( nRow, i);
@@ -1526,10 +1526,10 @@ void ScColumn::MoveTo(SCROW nStartRow, SCROW nEndRow, ScColumn& rCol)
bool bFirst = true;
nStopPos = 0;
for (::std::vector<SCROW>::const_iterator it( aRows.begin());
- it != aRows.end() && nStopPos < aItems.size(); ++it,
+ it != aRows.end() && nStopPos < maItems.size(); ++it,
++nStopPos)
{
- if (!bFirst && *it != aItems[nStopPos].nRow)
+ if (!bFirst && *it != maItems[nStopPos].nRow)
{
aEntries.push_back( PosPair(nStartPos, nStopPos));
bFirst = true;
@@ -1556,13 +1556,13 @@ void ScColumn::MoveTo(SCROW nStartRow, SCROW nEndRow, ScColumn& rCol)
nStartPos = (*it).first;
nStopPos = (*it).second;
for (i=nStartPos; i<nStopPos; ++i)
- aItems[i].pCell = pNoteCell;
+ maItems[i].pCell = pNoteCell;
for (i=nStartPos; i<nStopPos; ++i)
{
- rAddress.SetRow( aItems[i].nRow );
+ rAddress.SetRow( maItems[i].nRow );
pDocument->AreaBroadcast( aHint );
}
- aItems.erase(aItems.begin() + nStartPos, aItems.begin() + nStopPos - 1);
+ maItems.erase(maItems.begin() + nStartPos, maItems.begin() + nStopPos - 1);
}
pNoteCell->Delete();
}
@@ -1575,7 +1575,7 @@ bool ScColumn::UpdateReference( UpdateRefMode eUpdateRefMode, SCCOL nCol1, SCROW
ScDocument* pUndoDoc )
{
bool bUpdated = false;
- if ( !aItems.empty() )
+ if ( !maItems.empty() )
{
ScRange aRange( ScAddress( nCol1, nRow1, nTab1 ),
ScAddress( nCol2, nRow2, nTab2 ) );
@@ -1584,7 +1584,7 @@ bool ScColumn::UpdateReference( UpdateRefMode eUpdateRefMode, SCCOL nCol1, SCROW
SCSIZE nIndex;
if ( Search( nRow1, nIndex ) )
{
- ScFormulaCell* pCell = (ScFormulaCell*) aItems[nIndex].pCell;
+ ScFormulaCell* pCell = (ScFormulaCell*) maItems[nIndex].pCell;
if( pCell->GetCellType() == CELLTYPE_FORMULA)
bUpdated |= pCell->UpdateReference(
eUpdateRefMode, aRange, nDx, nDy, nDz, pUndoDoc );
@@ -1600,17 +1600,17 @@ bool ScColumn::UpdateReference( UpdateRefMode eUpdateRefMode, SCCOL nCol1, SCROW
{
SCSIZE i;
Search( nRow1, i );
- for ( ; i < aItems.size(); i++ )
+ for ( ; i < maItems.size(); i++ )
{
- SCROW nRow = aItems[i].nRow;
+ SCROW nRow = maItems[i].nRow;
if ( nRow > nRow2 )
break;
- ScBaseCell* pCell = aItems[i].pCell;
+ ScBaseCell* pCell = maItems[i].pCell;
if( pCell->GetCellType() == CELLTYPE_FORMULA)
{
bUpdated |= ((ScFormulaCell*)pCell)->UpdateReference(
eUpdateRefMode, aRange, nDx, nDy, nDz, pUndoDoc );
- if ( nRow != aItems[i].nRow )
+ if ( nRow != maItems[i].nRow )
Search( nRow, i ); // Listener removed/inserted?
}
}
@@ -1618,18 +1618,18 @@ bool ScColumn::UpdateReference( UpdateRefMode eUpdateRefMode, SCCOL nCol1, SCROW
else
{
SCSIZE i = 0;
- for ( ; i < aItems.size(); i++ )
+ for ( ; i < maItems.size(); i++ )
{
- ScBaseCell* pCell = aItems[i].pCell;
+ ScBaseCell* pCell = maItems[i].pCell;
if( pCell->GetCellType() == CELLTYPE_FORMULA)
{
- SCROW nRow = aItems[i].nRow;
+ SCROW nRow = maItems[i].nRow;
// When deleting rows on several sheets, the formula's position may be updated with the first call,
// so the undo position must be passed from here.
ScAddress aUndoPos( nCol, nRow, nTab );
bUpdated |= ((ScFormulaCell*)pCell)->UpdateReference(
eUpdateRefMode, aRange, nDx, nDy, nDz, pUndoDoc, &aUndoPos );
- if ( nRow != aItems[i].nRow )
+ if ( nRow != maItems[i].nRow )
Search( nRow, i ); // Listener removed/inserted?
}
}
@@ -1643,15 +1643,15 @@ bool ScColumn::UpdateReference( UpdateRefMode eUpdateRefMode, SCCOL nCol1, SCROW
void ScColumn::UpdateTranspose( const ScRange& rSource, const ScAddress& rDest,
ScDocument* pUndoDoc )
{
- if ( !aItems.empty() )
- for (SCSIZE i=0; i<aItems.size(); i++)
+ if ( !maItems.empty() )
+ for (SCSIZE i=0; i<maItems.size(); i++)
{
- ScBaseCell* pCell = aItems[i].pCell;
+ ScBaseCell* pCell = maItems[i].pCell;
if (pCell->GetCellType() == CELLTYPE_FORMULA)
{
- SCROW nRow = aItems[i].nRow;
+ SCROW nRow = maItems[i].nRow;
((ScFormulaCell*)pCell)->UpdateTranspose( rSource, rDest, pUndoDoc );
- if ( nRow != aItems[i].nRow )
+ if ( nRow != maItems[i].nRow )
Search( nRow, i ); // Listener geloescht/eingefuegt?
}
}
@@ -1660,15 +1660,15 @@ void ScColumn::UpdateTranspose( const ScRange& rSource, const ScAddress& rDest,
void ScColumn::UpdateGrow( const ScRange& rArea, SCCOL nGrowX, SCROW nGrowY )
{
- if ( !aItems.empty() )
- for (SCSIZE i=0; i<aItems.size(); i++)
+ if ( !maItems.empty() )
+ for (SCSIZE i=0; i<maItems.size(); i++)
{
- ScBaseCell* pCell = aItems[i].pCell;
+ ScBaseCell* pCell = maItems[i].pCell;
if (pCell->GetCellType() == CELLTYPE_FORMULA)
{
- SCROW nRow = aItems[i].nRow;
+ SCROW nRow = maItems[i].nRow;
((ScFormulaCell*)pCell)->UpdateGrow( rArea, nGrowX, nGrowY );
- if ( nRow != aItems[i].nRow )
+ if ( nRow != maItems[i].nRow )
Search( nRow, i ); // Listener geloescht/eingefuegt?
}
}
@@ -1682,22 +1682,22 @@ void ScColumn::UpdateInsertTab( SCTAB nTable, SCTAB nNewSheets )
nTab += nNewSheets;
pAttrArray->SetTab(nTab);
}
- if ( !aItems.empty() )
+ if ( !maItems.empty() )
UpdateInsertTabOnlyCells( nTable, nNewSheets );
}
void ScColumn::UpdateInsertTabOnlyCells( SCTAB nTable, SCTAB nNewSheets )
{
- if ( !aItems.empty() )
- for (SCSIZE i = 0; i < aItems.size(); i++)
+ if ( !maItems.empty() )
+ for (SCSIZE i = 0; i < maItems.size(); i++)
{
- ScFormulaCell* pCell = (ScFormulaCell*) aItems[i].pCell;
+ ScFormulaCell* pCell = (ScFormulaCell*) maItems[i].pCell;
if( pCell->GetCellType() == CELLTYPE_FORMULA)
{
- SCROW nRow = aItems[i].nRow;
+ SCROW nRow = maItems[i].nRow;
pCell->UpdateInsertTab(nTable, nNewSheets);
- if ( nRow != aItems[i].nRow )
+ if ( nRow != maItems[i].nRow )
Search( nRow, i ); // Listener geloescht/eingefuegt?
}
}
@@ -1706,15 +1706,15 @@ void ScColumn::UpdateInsertTabOnlyCells( SCTAB nTable, SCTAB nNewSheets )
void ScColumn::UpdateInsertTabAbs(SCTAB nTable)
{
- if ( !aItems.empty() )
- for (SCSIZE i = 0; i < aItems.size(); i++)
+ if ( !maItems.empty() )
+ for (SCSIZE i = 0; i < maItems.size(); i++)
{
- ScFormulaCell* pCell = (ScFormulaCell*) aItems[i].pCell;
+ ScFormulaCell* pCell = (ScFormulaCell*) maItems[i].pCell;
if( pCell->GetCellType() == CELLTYPE_FORMULA)
{
- SCROW nRow = aItems[i].nRow;
+ SCROW nRow = maItems[i].nRow;
pCell->UpdateInsertTabAbs(nTable);
- if ( nRow != aItems[i].nRow )
+ if ( nRow != maItems[i].nRow )
Search( nRow, i ); // Listener geloescht/eingefuegt?
}
}
@@ -1729,19 +1729,19 @@ void ScColumn::UpdateDeleteTab( SCTAB nTable, bool bIsMove, ScColumn* pRefUndo,
pAttrArray->SetTab(nTab);
}
- if ( !aItems.empty() )
- for (SCSIZE i = 0; i < aItems.size(); i++)
- if ( aItems[i].pCell->GetCellType() == CELLTYPE_FORMULA )
+ if ( !maItems.empty() )
+ for (SCSIZE i = 0; i < maItems.size(); i++)
+ if ( maItems[i].pCell->GetCellType() == CELLTYPE_FORMULA )
{
- SCROW nRow = aItems[i].nRow;
- ScFormulaCell* pOld = (ScFormulaCell*)aItems[i].pCell;
+ SCROW nRow = maItems[i].nRow;
+ ScFormulaCell* pOld = (ScFormulaCell*)maItems[i].pCell;
/* Do not copy cell note to the undo document. Undo will copy
back the formula cell while keeping the original note. */
ScBaseCell* pSave = pRefUndo ? pOld->CloneWithoutNote( *pDocument ) : 0;
bool bChanged = pOld->UpdateDeleteTab(nTable, bIsMove, nSheets);
- if ( nRow != aItems[i].nRow )
+ if ( nRow != maItems[i].nRow )
Search( nRow, i ); // Listener geloescht/eingefuegt?
if (pRefUndo)
@@ -1759,15 +1759,15 @@ void ScColumn::UpdateMoveTab( SCTAB nOldPos, SCTAB nNewPos, SCTAB nTabNo )
{
nTab = nTabNo;
pAttrArray->SetTab( nTabNo );
- if ( !aItems.empty() )
- for (SCSIZE i = 0; i < aItems.size(); i++)
+ if ( !maItems.empty() )
+ for (SCSIZE i = 0; i < maItems.size(); i++)
{
- ScFormulaCell* pCell = (ScFormulaCell*) aItems[i].pCell;
+ ScFormulaCell* pCell = (ScFormulaCell*) maItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
{
- SCROW nRow = aItems[i].nRow;
+ SCROW nRow = maItems[i].nRow;
pCell->UpdateMoveTab( nOldPos, nNewPos, nTabNo );
- if ( nRow != aItems[i].nRow )
+ if ( nRow != maItems[i].nRow )
Search( nRow, i ); // Listener geloescht/eingefuegt?
}
}
@@ -1776,15 +1776,15 @@ void ScColumn::UpdateMoveTab( SCTAB nOldPos, SCTAB nNewPos, SCTAB nTabNo )
void ScColumn::UpdateCompile( bool bForceIfNameInUse )
{
- if ( !aItems.empty() )
- for (SCSIZE i = 0; i < aItems.size(); i++)
+ if ( !maItems.empty() )
+ for (SCSIZE i = 0; i < maItems.size(); i++)
{
- ScFormulaCell* p = (ScFormulaCell*) aItems[i].pCell;
+ ScFormulaCell* p = (ScFormulaCell*) maItems[i].pCell;
if( p->GetCellType() == CELLTYPE_FORMULA )
{
- SCROW nRow = aItems[i].nRow;
+ SCROW nRow = maItems[i].nRow;
p->UpdateCompile( bForceIfNameInUse );
- if ( nRow != aItems[i].nRow )
+ if ( nRow != maItems[i].nRow )
Search( nRow, i ); // Listener geloescht/eingefuegt?
}
}
@@ -1795,10 +1795,10 @@ void ScColumn::SetTabNo(SCTAB nNewTab)
{
nTab = nNewTab;
pAttrArray->SetTab( nNewTab );
- if ( !aItems.empty() )
- for (SCSIZE i = 0; i < aItems.size(); i++)
+ if ( !maItems.empty() )
+ for (SCSIZE i = 0; i < maItems.size(); i++)
{
- ScFormulaCell* p = (ScFormulaCell*) aItems[i].pCell;
+ ScFormulaCell* p = (ScFormulaCell*) maItems[i].pCell;
if( p->GetCellType() == CELLTYPE_FORMULA )
p->aPos.SetTab( nNewTab );
}
@@ -1806,27 +1806,27 @@ void ScColumn::SetTabNo(SCTAB nNewTab)
void ScColumn::FindRangeNamesInUse(SCROW nRow1, SCROW nRow2, std::set<sal_uInt16>& rIndexes) const
{
- if ( !aItems.empty() )
- for (SCSIZE i = 0; i < aItems.size(); i++)
- if ((aItems[i].nRow >= nRow1) &&
- (aItems[i].nRow <= nRow2) &&
- (aItems[i].pCell->GetCellType() == CELLTYPE_FORMULA))
- ((ScFormulaCell*)aItems[i].pCell)->FindRangeNamesInUse(rIndexes);
+ if ( !maItems.empty() )
+ for (SCSIZE i = 0; i < maItems.size(); i++)
+ if ((maItems[i].nRow >= nRow1) &&
+ (maItems[i].nRow <= nRow2) &&
+ (maItems[i].pCell->GetCellType() == CELLTYPE_FORMULA))
+ ((ScFormulaCell*)maItems[i].pCell)->FindRangeNamesInUse(rIndexes);
}
void ScColumn::ReplaceRangeNamesInUse(SCROW nRow1, SCROW nRow2,
const ScRangeData::IndexMap& rMap )
{
- if ( !aItems.empty() )
- for (SCSIZE i = 0; i < aItems.size(); i++)
+ if ( !maItems.empty() )
+ for (SCSIZE i = 0; i < maItems.size(); i++)
{
- if ((aItems[i].nRow >= nRow1) &&
- (aItems[i].nRow <= nRow2) &&
- (aItems[i].pCell->GetCellType() == CELLTYPE_FORMULA))
+ if ((maItems[i].nRow >= nRow1) &&
+ (maItems[i].nRow <= nRow2) &&
+ (maItems[i].pCell->GetCellType() == CELLTYPE_FORMULA))
{
- SCROW nRow = aItems[i].nRow;
- ((ScFormulaCell*)aItems[i].pCell)->ReplaceRangeNamesInUse( rMap );
- if ( nRow != aItems[i].nRow )
+ SCROW nRow = maItems[i].nRow;
+ ((ScFormulaCell*)maItems[i].pCell)->ReplaceRangeNamesInUse( rMap );
+ if ( nRow != maItems[i].nRow )
Search( nRow, i ); // Listener geloescht/eingefuegt?
}
}
@@ -1834,9 +1834,9 @@ void ScColumn::ReplaceRangeNamesInUse(SCROW nRow1, SCROW nRow2,
void ScColumn::SetDirtyVar()
{
- for (SCSIZE i=0; i<aItems.size(); i++)
+ for (SCSIZE i=0; i<maItems.size(); i++)
{
- ScFormulaCell* p = (ScFormulaCell*) aItems[i].pCell;
+ ScFormulaCell* p = (ScFormulaCell*) maItems[i].pCell;
if( p->GetCellType() == CELLTYPE_FORMULA )
p->SetDirtyVar();
}
@@ -1848,9 +1848,9 @@ void ScColumn::SetDirty()
// wird nur dokumentweit verwendet, kein FormulaTrack
bool bOldAutoCalc = pDocument->GetAutoCalc();
pDocument->SetAutoCalc( false ); // Mehrfachberechnungen vermeiden
- for (SCSIZE i=0; i<aItems.size(); i++)
+ for (SCSIZE i=0; i<maItems.size(); i++)
{
- ScFormulaCell* p = (ScFormulaCell*) aItems[i].pCell;
+ ScFormulaCell* p = (ScFormulaCell*) maItems[i].pCell;
if( p->GetCellType() == CELLTYPE_FORMULA )
{
p->SetDirtyVar();
@@ -1864,7 +1864,7 @@ void ScColumn::SetDirty()
void ScColumn::SetDirty( const ScRange& rRange )
{ // broadcastet alles innerhalb eines Range, mit FormulaTrack
- if ( aItems.empty() )
+ if ( maItems.empty() )
return ;
bool bOldAutoCalc = pDocument->GetAutoCalc();
pDocument->SetAutoCalc( false ); // Mehrfachberechnungen vermeiden
@@ -1874,9 +1874,9 @@ void ScColumn::SetDirty( const ScRange& rRange )
SCROW nRow;
SCSIZE nIndex;
Search( rRange.aStart.Row(), nIndex );
- while ( nIndex < aItems.size() && (nRow = aItems[nIndex].nRow) <= nRow2 )
+ while ( nIndex < maItems.size() && (nRow = maItems[nIndex].nRow) <= nRow2 )
{
- ScBaseCell* pCell = aItems[nIndex].pCell;
+ ScBaseCell* pCell = maItems[nIndex].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
((ScFormulaCell*)pCell)->SetDirty();
else
@@ -1893,7 +1893,7 @@ void ScColumn::SetDirty( const ScRange& rRange )
void ScColumn::SetTableOpDirty( const ScRange& rRange )
{
- if ( aItems.empty() )
+ if ( maItems.empty() )
return ;
bool bOldAutoCalc = pDocument->GetAutoCalc();
pDocument->SetAutoCalc( false ); // no multiple recalculation
@@ -1903,9 +1903,9 @@ void ScColumn::SetTableOpDirty( const ScRange& rRange )
SCROW nRow;
SCSIZE nIndex;
Search( rRange.aStart.Row(), nIndex );
- while ( nIndex < aItems.size() && (nRow = aItems[nIndex].nRow) <= nRow2 )
+ while ( nIndex < maItems.size() && (nRow = maItems[nIndex].nRow) <= nRow2 )
{
- ScBaseCell* pCell = aItems[nIndex].pCell;
+ ScBaseCell* pCell = maItems[nIndex].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
((ScFormulaCell*)pCell)->SetTableOpDirty();
else
@@ -1924,9 +1924,9 @@ void ScColumn::SetDirtyAfterLoad()
{
bool bOldAutoCalc = pDocument->GetAutoCalc();
pDocument->SetAutoCalc( false ); // Mehrfachberechnungen vermeiden
- for (SCSIZE i=0; i<aItems.size(); i++)
+ for (SCSIZE i=0; i<maItems.size(); i++)
{
- ScFormulaCell* p = (ScFormulaCell*) aItems[i].pCell;
+ ScFormulaCell* p = (ScFormulaCell*) maItems[i].pCell;
#if 1
// Simply set dirty and append to FormulaTree, without broadcasting,
// which is a magnitude faster. This is used to calculate the entire
@@ -1957,9 +1957,9 @@ void ScColumn::SetRelNameDirty()
{
bool bOldAutoCalc = pDocument->GetAutoCalc();
pDocument->SetAutoCalc( false ); // Mehrfachberechnungen vermeiden
- for (SCSIZE i=0; i<aItems.size(); i++)
+ for (SCSIZE i=0; i<maItems.size(); i++)
{
- ScFormulaCell* p = (ScFormulaCell*) aItems[i].pCell;
+ ScFormulaCell* p = (ScFormulaCell*) maItems[i].pCell;
if( p->GetCellType() == CELLTYPE_FORMULA && p->HasRelNameReference() )
p->SetDirty();
}
@@ -1969,10 +1969,10 @@ void ScColumn::SetRelNameDirty()
void ScColumn::CalcAll()
{
- if ( !aItems.empty() )
- for (SCSIZE i=0; i<aItems.size(); i++)
+ if ( !maItems.empty() )
+ for (SCSIZE i=0; i<maItems.size(); i++)
{
- ScBaseCell* pCell = aItems[i].pCell;
+ ScBaseCell* pCell = maItems[i].pCell;
if (pCell->GetCellType() == CELLTYPE_FORMULA)
{
#if OSL_DEBUG_LEVEL > 1
@@ -1996,19 +1996,19 @@ void ScColumn::CalcAll()
void ScColumn::CompileAll()
{
- if ( !aItems.empty() )
- for (SCSIZE i = 0; i < aItems.size(); i++)
+ if ( !maItems.empty() )
+ for (SCSIZE i = 0; i < maItems.size(); i++)
{
- ScBaseCell* pCell = aItems[i].pCell;
+ ScBaseCell* pCell = maItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
{
- SCROW nRow = aItems[i].nRow;
+ SCROW nRow = maItems[i].nRow;
// fuer unbedingtes kompilieren
// bCompile=true und pCode->nError=0
((ScFormulaCell*)pCell)->GetCode()->SetCodeError( 0 );
((ScFormulaCell*)pCell)->SetCompile( true );
((ScFormulaCell*)pCell)->CompileTokenArray();
- if ( nRow != aItems[i].nRow )
+ if ( nRow != maItems[i].nRow )
Search( nRow, i ); // Listener geloescht/eingefuegt?
}
}
@@ -2017,15 +2017,15 @@ void ScColumn::CompileAll()
void ScColumn::CompileXML( ScProgress& rProgress )
{
- if ( !aItems.empty() )
- for (SCSIZE i = 0; i < aItems.size(); i++)
+ if ( !maItems.empty() )
+ for (SCSIZE i = 0; i < maItems.size(); i++)
{
- ScBaseCell* pCell = aItems[i].pCell;
+ ScBaseCell* pCell = maItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
{
- SCROW nRow = aItems[i].nRow;
+ SCROW nRow = maItems[i].nRow;
((ScFormulaCell*)pCell)->CompileXML( rProgress );
- if ( nRow != aItems[i].nRow )
+ if ( nRow != maItems[i].nRow )
Search( nRow, i ); // Listener geloescht/eingefuegt?
}
}
@@ -2034,10 +2034,10 @@ void ScColumn::CompileXML( ScProgress& rProgress )
void ScColumn::CalcAfterLoad()
{
- if ( !aItems.empty() )
- for (SCSIZE i = 0; i < aItems.size(); i++)
+ if ( !maItems.empty() )
+ for (SCSIZE i = 0; i < maItems.size(); i++)
{
- ScBaseCell* pCell = aItems[i].pCell;
+ ScBaseCell* pCell = maItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
((ScFormulaCell*)pCell)->CalcAfterLoad();
}
@@ -2046,13 +2046,13 @@ void ScColumn::CalcAfterLoad()
void ScColumn::ResetChanged( SCROW nStartRow, SCROW nEndRow )
{
- if ( !aItems.empty() )
+ if ( !maItems.empty() )
{
SCSIZE nIndex;
Search(nStartRow,nIndex);
- while (nIndex<aItems.size() && aItems[nIndex].nRow <= nEndRow)
+ while (nIndex<maItems.size() && maItems[nIndex].nRow <= nEndRow)
{
- ScBaseCell* pCell = aItems[nIndex].pCell;
+ ScBaseCell* pCell = maItems[nIndex].pCell;
if (pCell->GetCellType() == CELLTYPE_FORMULA)
((ScFormulaCell*)pCell)->ResetChanged();
++nIndex;
@@ -2068,9 +2068,9 @@ bool ScColumn::HasEditCells(SCROW nStartRow, SCROW nEndRow, SCROW& rFirst) const
SCROW nRow = 0;
SCSIZE nIndex;
Search(nStartRow,nIndex);
- while ( (nIndex < aItems.size()) ? ((nRow=aItems[nIndex].nRow) <= nEndRow) : false )
+ while ( (nIndex < maItems.size()) ? ((nRow=maItems[nIndex].nRow) <= nEndRow) : false )
{
- ScBaseCell* pCell = aItems[nIndex].pCell;
+ ScBaseCell* pCell = maItems[nIndex].pCell;
CellType eCellType = pCell->GetCellType();
if ( eCellType == CELLTYPE_EDIT ||
IsAmbiguousScriptNonZero( pDocument->GetScriptType(nCol, nRow, nTab, pCell) ) ||
diff --git a/sc/source/core/data/column2.cxx b/sc/source/core/data/column2.cxx
index 5dd5685..f7c9dbb 100644
--- a/sc/source/core/data/column2.cxx
+++ b/sc/source/core/data/column2.cxx
@@ -105,7 +105,7 @@ long ScColumn::GetNeededSize( SCROW nRow, OutputDevice* pDev,
double nPPT = bWidth ? nPPTX : nPPTY;
if (Search(nRow,nIndex))
{
- ScBaseCell* pCell = aItems[nIndex].pCell;
+ ScBaseCell* pCell = maItems[nIndex].pCell;
const ScPatternAttr* pPattern = rOptions.pPattern;
if (!pPattern)
pPattern = pAttrArray->GetPattern( nRow );
@@ -544,7 +544,7 @@ sal_uInt16 ScColumn::GetOptimalColWidth( OutputDevice* pDev, double nPPTX, doubl
const ScMarkData* pMarkData,
const ScColWidthParam* pParam )
{
- if ( aItems.empty() )
+ if ( maItems.empty() )
return nOldWidth;
sal_uInt16 nWidth = (sal_uInt16) (nOldWidth * nPPTX);
@@ -579,11 +579,11 @@ sal_uInt16 ScColumn::GetOptimalColWidth( OutputDevice* pDev, double nPPTX, doubl
xub_StrLen nLongLen = 0;
while (aDataIter.Next(nIndex))
{
- if (nIndex >= aItems.size())
+ if (nIndex >= maItems.size())
// Out-of-bound reached. No need to keep going.
break;
- ScBaseCell* pCell = aItems[nIndex].pCell;
+ ScBaseCell* pCell = maItems[nIndex].pCell;
rtl::OUString aValStr;
ScCellFormat::GetString(
pCell, nFormat, aValStr, &pColor, *pFormatter, true, false, ftCheck );
@@ -611,9 +611,9 @@ sal_uInt16 ScColumn::GetOptimalColWidth( OutputDevice* pDev, double nPPTX, doubl
while (aDataIter.Next( nIndex ))
{
- SCROW nRow = aItems[nIndex].nRow;
+ SCROW nRow = maItems[nIndex].nRow;
- sal_uInt8 nScript = pDocument->GetScriptType( nCol, nRow, nTab, aItems[nIndex].pCell );
+ sal_uInt8 nScript = pDocument->GetScriptType( nCol, nRow, nTab, maItems[nIndex].pCell );
if (nScript == 0) nScript = ScGlobal::GetDefaultScriptType();
const ScPatternAttr* pPattern = GetPattern( nRow );
@@ -778,9 +778,9 @@ void ScColumn::GetOptimalHeight( SCROW nStartRow, SCROW nEndRow, sal_uInt16* pHe
SCSIZE nIndex;
Search(nStart,nIndex);
- while ( nIndex < aItems.size() && (nRow=aItems[nIndex].nRow) <= nEnd )
+ while ( nIndex < maItems.size() && (nRow=maItems[nIndex].nRow) <= nEnd )
{
- sal_uInt8 nScript = pDocument->GetScriptType( nCol, nRow, nTab, aItems[nIndex].pCell );
+ sal_uInt8 nScript = pDocument->GetScriptType( nCol, nRow, nTab, maItems[nIndex].pCell );
if ( nScript != nDefScript )
{
if ( nScript == SCRIPTTYPE_ASIAN )
@@ -816,7 +816,7 @@ void ScColumn::GetOptimalHeight( SCROW nStartRow, SCROW nEndRow, sal_uInt16* pHe
SCSIZE nIndex;
Search(nStart,nIndex);
- while ( (nIndex < aItems.size()) ? ((nRow=aItems[nIndex].nRow) <= nEnd) : false )
+ while ( (nIndex < maItems.size()) ? ((nRow=maItems[nIndex].nRow) <= nEnd) : false )
{
// Zellhoehe nur berechnen, wenn sie spaeter auch gebraucht wird (#37928#)
@@ -904,10 +904,10 @@ void ScColumn::RemoveAutoSpellObj()
{
ScTabEditEngine* pEngine = NULL;
- for (SCSIZE i=0; i<aItems.size(); i++)
- if ( aItems[i].pCell->GetCellType() == CELLTYPE_EDIT )
+ for (SCSIZE i=0; i<maItems.size(); i++)
+ if ( maItems[i].pCell->GetCellType() == CELLTYPE_EDIT )
{
- ScEditCell* pOldCell = (ScEditCell*) aItems[i].pCell;
+ ScEditCell* pOldCell = (ScEditCell*) maItems[i].pCell;
const EditTextObject* pData = pOldCell->GetData();
// keine Abfrage auf HasOnlineSpellErrors, damit es auch
// nach dem Laden funktioniert
@@ -935,7 +935,7 @@ void ScColumn::RemoveAutoSpellObj()
ScBaseCell* pNewCell = new ScStringCell( aText );
pNewCell->TakeBroadcaster( pOldCell->ReleaseBroadcaster() );
pNewCell->TakeNote( pOldCell->ReleaseNote() );
- aItems[i].pCell = pNewCell;
+ maItems[i].pCell = pNewCell;
delete pOldCell;
}
}
@@ -949,10 +949,10 @@ void ScColumn::RemoveEditAttribs( SCROW nStartRow, SCROW nEndRow )
SCSIZE i;
Search( nStartRow, i );
- for (; i<aItems.size() && aItems[i].nRow <= nEndRow; i++)
- if ( aItems[i].pCell->GetCellType() == CELLTYPE_EDIT )
+ for (; i<maItems.size() && maItems[i].nRow <= nEndRow; i++)
+ if ( maItems[i].pCell->GetCellType() == CELLTYPE_EDIT )
{
- ScEditCell* pOldCell = (ScEditCell*) aItems[i].pCell;
+ ScEditCell* pOldCell = (ScEditCell*) maItems[i].pCell;
const EditTextObject* pData = pOldCell->GetData();
// Fuer den Test auf harte Formatierung (ScEditAttrTester) sind die Defaults
@@ -1005,7 +1005,7 @@ void ScColumn::RemoveEditAttribs( SCROW nStartRow, SCROW nEndRow )
ScBaseCell* pNewCell = new ScStringCell( aText );
pNewCell->TakeBroadcaster( pOldCell->ReleaseBroadcaster() );
pNewCell->TakeNote( pOldCell->ReleaseNote() );
- aItems[i].pCell = pNewCell;
+ maItems[i].pCell = pNewCell;
delete pOldCell;
}
}
@@ -1018,10 +1018,10 @@ void ScColumn::RemoveEditAttribs( SCROW nStartRow, SCROW nEndRow )
bool ScColumn::TestTabRefAbs(SCTAB nTable)
{
bool bRet = false;
- if ( !aItems.empty() )
- for (SCSIZE i = 0; i < aItems.size(); i++)
- if ( aItems[i].pCell->GetCellType() == CELLTYPE_FORMULA )
- if (((ScFormulaCell*)aItems[i].pCell)->TestTabRefAbs(nTable))
+ if ( !maItems.empty() )
+ for (SCSIZE i = 0; i < maItems.size(); i++)
+ if ( maItems[i].pCell->GetCellType() == CELLTYPE_FORMULA )
+ if (((ScFormulaCell*)maItems[i].pCell)->TestTabRefAbs(nTable))
bRet = true;
return bRet;
}
@@ -1042,12 +1042,12 @@ ScColumnIterator::~ScColumnIterator()
bool ScColumnIterator::Next( SCROW& rRow, ScBaseCell*& rpCell )
{
- if ( nPos < pColumn->aItems.size() )
+ if ( nPos < pColumn->maItems.size() )
{
- rRow = pColumn->aItems[nPos].nRow;
+ rRow = pColumn->maItems[nPos].nRow;
if ( rRow <= nBottom )
{
- rpCell = pColumn->aItems[nPos].pCell;
+ rpCell = pColumn->maItems[nPos].pCell;
++nPos;
return true;
}
@@ -1103,10 +1103,10 @@ bool ScMarkedDataIter::Next( SCSIZE& rIndex )
bAll = false; // nur beim ersten Versuch
}
- if ( nPos >= pColumn->aItems.size() )
+ if ( nPos >= pColumn->maItems.size() )
return false;
- if ( pColumn->aItems[nPos].nRow <= nBottom )
+ if ( pColumn->maItems[nPos].nRow <= nBottom )
bFound = true;
else
bNext = true;
@@ -1122,20 +1122,20 @@ bool ScMarkedDataIter::Next( SCSIZE& rIndex )
bool ScColumn::IsEmptyData() const
{
- return (aItems.empty());
+ return (maItems.empty());
}
bool ScColumn::IsEmptyVisData(bool bNotes) const
{
- if ( aItems.empty() )
+ if ( maItems.empty() )
return true;
else
{
bool bVisData = false;
SCSIZE i;
- for (i=0; i<aItems.size() && !bVisData; i++)
+ for (i=0; i<maItems.size() && !bVisData; i++)
{
- ScBaseCell* pCell = aItems[i].pCell;
+ ScBaseCell* pCell = maItems[i].pCell;
if ( pCell->GetCellType() != CELLTYPE_NOTE || (bNotes && pCell->HasNote()) )
bVisData = true;
}
@@ -1150,10 +1150,10 @@ SCSIZE ScColumn::VisibleCount( SCROW nStartRow, SCROW nEndRow ) const
SCSIZE nVisCount = 0;
SCSIZE nIndex;
Search( nStartRow, nIndex );
- while ( nIndex < aItems.size() && aItems[nIndex].nRow <= nEndRow )
+ while ( nIndex < maItems.size() && maItems[nIndex].nRow <= nEndRow )
{
- if ( aItems[nIndex].nRow >= nStartRow &&
- aItems[nIndex].pCell->GetCellType() != CELLTYPE_NOTE )
+ if ( maItems[nIndex].nRow >= nStartRow &&
+ maItems[nIndex].pCell->GetCellType() != CELLTYPE_NOTE )
{
++nVisCount;
}
@@ -1165,18 +1165,18 @@ SCSIZE ScColumn::VisibleCount( SCROW nStartRow, SCROW nEndRow ) const
SCROW ScColumn::GetLastVisDataPos(bool bNotes) const
{
SCROW nRet = 0;
- if ( !aItems.empty() )
+ if ( !maItems.empty() )
{
SCSIZE i;
bool bFound = false;
- for (i=aItems.size(); i>0 && !bFound; )
+ for (i=maItems.size(); i>0 && !bFound; )
{
--i;
- ScBaseCell* pCell = aItems[i].pCell;
+ ScBaseCell* pCell = maItems[i].pCell;
if ( pCell->GetCellType() != CELLTYPE_NOTE || (bNotes && pCell->HasNote()) )
{
bFound = true;
- nRet = aItems[i].nRow;
+ nRet = maItems[i].nRow;
}
}
}
@@ -1186,17 +1186,17 @@ SCROW ScColumn::GetLastVisDataPos(bool bNotes) const
SCROW ScColumn::GetFirstVisDataPos(bool bNotes) const
{
SCROW nRet = 0;
- if ( !aItems.empty() )
+ if ( !maItems.empty() )
{
SCSIZE i;
bool bFound = false;
- for (i=0; i<aItems.size() && !bFound; i++)
+ for (i=0; i<maItems.size() && !bFound; i++)
{
- ScBaseCell* pCell = aItems[i].pCell;
+ ScBaseCell* pCell = maItems[i].pCell;
if ( pCell->GetCellType() != CELLTYPE_NOTE || (bNotes && pCell->HasNote()) )
{
bFound = true;
- nRet = aItems[i].nRow;
+ nRet = maItems[i].nRow;
}
}
}
@@ -1207,7 +1207,7 @@ bool ScColumn::HasVisibleDataAt(SCROW nRow) const
{
SCSIZE nIndex;
if (Search(nRow, nIndex))
- if (!aItems[nIndex].pCell->IsBlank())
+ if (!maItems[nIndex].pCell->IsBlank())
return true;
return false;
@@ -1228,14 +1228,14 @@ bool ScColumn::IsEmpty() const
bool ScColumn::IsEmptyBlock(SCROW nStartRow, SCROW nEndRow, bool bIgnoreNotes) const
{
- if ( aItems.empty() )
+ if ( maItems.empty() )
return true;
SCSIZE nIndex;
Search( nStartRow, nIndex );
- while ( nIndex < aItems.size() && aItems[nIndex].nRow <= nEndRow )
+ while ( nIndex < maItems.size() && maItems[nIndex].nRow <= nEndRow )
{
- if ( !aItems[nIndex].pCell->IsBlank( bIgnoreNotes ) ) // found a cell
+ if ( !maItems[nIndex].pCell->IsBlank( bIgnoreNotes ) ) // found a cell
return false; // not empty
++nIndex;
}
@@ -1247,35 +1247,35 @@ SCSIZE ScColumn::GetEmptyLinesInBlock( SCROW nStartRow, SCROW nEndRow, ScDirecti
SCSIZE nLines = 0;
bool bFound = false;
SCSIZE i;
- if ( !aItems.empty() )
+ if ( !maItems.empty() )
{
if (eDir == DIR_BOTTOM)
{
- i = aItems.size();
+ i = maItems.size();
while (!bFound && (i > 0))
{
i--;
- if ( aItems[i].nRow < nStartRow )
+ if ( maItems[i].nRow < nStartRow )
break;
- bFound = aItems[i].nRow <= nEndRow && !aItems[i].pCell->IsBlank();
+ bFound = maItems[i].nRow <= nEndRow && !maItems[i].pCell->IsBlank();
}
if (bFound)
- nLines = static_cast<SCSIZE>(nEndRow - aItems[i].nRow);
+ nLines = static_cast<SCSIZE>(nEndRow - maItems[i].nRow);
else
nLines = static_cast<SCSIZE>(nEndRow - nStartRow);
}
else if (eDir == DIR_TOP)
{
i = 0;
- while (!bFound && (i < aItems.size()))
+ while (!bFound && (i < maItems.size()))
{
- if ( aItems[i].nRow > nEndRow )
+ if ( maItems[i].nRow > nEndRow )
break;
- bFound = aItems[i].nRow >= nStartRow && !aItems[i].pCell->IsBlank();
+ bFound = maItems[i].nRow >= nStartRow && !maItems[i].pCell->IsBlank();
i++;
}
if (bFound)
- nLines = static_cast<SCSIZE>(aItems[i-1].nRow - nStartRow);
+ nLines = static_cast<SCSIZE>(maItems[i-1].nRow - nStartRow);
else
nLines = static_cast<SCSIZE>(nEndRow - nStartRow);
}
@@ -1287,16 +1287,16 @@ SCSIZE ScColumn::GetEmptyLinesInBlock( SCROW nStartRow, SCROW nEndRow, ScDirecti
SCROW ScColumn::GetFirstDataPos() const
{
- if ( !aItems.empty() )
- return aItems[0].nRow;
+ if ( !maItems.empty() )
+ return maItems[0].nRow;
else
return 0;
}
SCROW ScColumn::GetLastDataPos() const
{
- if ( !aItems.empty() )
- return aItems[aItems.size()-1].nRow;
+ if ( !maItems.empty() )
+ return maItems[maItems.size()-1].nRow;
else
return 0;
}
@@ -1304,13 +1304,13 @@ SCROW ScColumn::GetLastDataPos() const
bool ScColumn::GetPrevDataPos(SCROW& rRow) const
{
bool bFound = false;
- SCSIZE i = aItems.size();
+ SCSIZE i = maItems.size();
while (!bFound && (i > 0))
{
--i;
- bFound = (aItems[i].nRow < rRow);
+ bFound = (maItems[i].nRow < rRow);
if (bFound)
- rRow = aItems[i].nRow;
+ rRow = maItems[i].nRow;
}
return bFound;
}
@@ -1321,9 +1321,9 @@ bool ScColumn::GetNextDataPos(SCROW& rRow) const // greater than rRow
if (Search( rRow, nIndex ))
++nIndex; // next cell
- bool bMore = ( nIndex < aItems.size() );
+ bool bMore = ( nIndex < maItems.size() );
if ( bMore )
- rRow = aItems[nIndex].nRow;
+ rRow = maItems[nIndex].nRow;
return bMore;
}
@@ -1334,7 +1334,7 @@ void ScColumn::FindDataAreaPos(SCROW& rRow, long nMovY) const
SCSIZE nIndex;
bool bThere = Search(rRow, nIndex);
- if (bThere && aItems[nIndex].pCell->IsBlank())
+ if (bThere && maItems[nIndex].pCell->IsBlank())
bThere = false;
if (bThere)
@@ -1343,17 +1343,17 @@ void ScColumn::FindDataAreaPos(SCROW& rRow, long nMovY) const
SCSIZE nOldIndex = nIndex;
if (bForward)
{
- if (nIndex<aItems.size()-1)
+ if (nIndex<maItems.size()-1)
{
++nIndex;
- while (nIndex<aItems.size()-1 && aItems[nIndex].nRow==nLast+1
- && !aItems[nIndex].pCell->IsBlank())
+ while (nIndex<maItems.size()-1 && maItems[nIndex].nRow==nLast+1
+ && !maItems[nIndex].pCell->IsBlank())
{
++nIndex;
++nLast;
}
- if (nIndex==aItems.size()-1)
- if (aItems[nIndex].nRow==nLast+1 && !aItems[nIndex].pCell->IsBlank())
+ if (nIndex==maItems.size()-1)
+ if (maItems[nIndex].nRow==nLast+1 && !maItems[nIndex].pCell->IsBlank())
++nLast;
}
}
@@ -1362,14 +1362,14 @@ void ScColumn::FindDataAreaPos(SCROW& rRow, long nMovY) const
if (nIndex>0)
{
--nIndex;
- while (nIndex>0 && aItems[nIndex].nRow+1==nLast
- && !aItems[nIndex].pCell->IsBlank())
+ while (nIndex>0 && maItems[nIndex].nRow+1==nLast
+ && !maItems[nIndex].pCell->IsBlank())
{
--nIndex;
--nLast;
}
if (nIndex==0)
- if (aItems[nIndex].nRow+1==nLast && !aItems[nIndex].pCell->IsBlank())
+ if (maItems[nIndex].nRow+1==nLast && !maItems[nIndex].pCell->IsBlank())
--nLast;
}
}
@@ -1386,19 +1386,19 @@ void ScColumn::FindDataAreaPos(SCROW& rRow, long nMovY) const
{
if (bForward)
{
- while (nIndex<aItems.size() && aItems[nIndex].pCell->IsBlank())
+ while (nIndex<maItems.size() && maItems[nIndex].pCell->IsBlank())
++nIndex;
- if (nIndex<aItems.size())
- rRow = aItems[nIndex].nRow;
+ if (nIndex<maItems.size())
+ rRow = maItems[nIndex].nRow;
else
rRow = MAXROW;
}
else
{
- while (nIndex>0 && aItems[nIndex-1].pCell->IsBlank())
+ while (nIndex>0 && maItems[nIndex-1].pCell->IsBlank())
--nIndex;
if (nIndex>0)
- rRow = aItems[nIndex-1].nRow;
+ rRow = maItems[nIndex-1].nRow;
else
rRow = 0;
}
@@ -1412,7 +1412,7 @@ bool ScColumn::HasDataAt(SCROW nRow) const
SCSIZE nIndex;
if (Search(nRow, nIndex))
- if (!aItems[nIndex].pCell->IsBlank())
+ if (!maItems[nIndex].pCell->IsBlank())
return true;
return false;
@@ -1469,7 +1469,7 @@ void ScColumn::FindUsed( SCROW nStartRow, SCROW nEndRow, bool* pUsed ) const
SCROW nRow = 0;
SCSIZE nIndex;
Search( nStartRow, nIndex );
- while ( (nIndex < aItems.size()) ? ((nRow=aItems[nIndex].nRow) <= nEndRow) : false )
+ while ( (nIndex < maItems.size()) ? ((nRow=maItems[nIndex].nRow) <= nEndRow) : false )
{
pUsed[nRow-nStartRow] = true;
++nIndex;
@@ -1484,7 +1484,7 @@ void ScColumn::StartListening( SvtListener& rLst, SCROW nRow )
SCSIZE nIndex;
if (Search(nRow,nIndex))
{
- pCell = aItems[nIndex].pCell;
+ pCell = maItems[nIndex].pCell;
pBC = pCell->GetBroadcaster();
}
else
@@ -1509,7 +1509,7 @@ void ScColumn::MoveListeners( SvtBroadcaster& rSource, SCROW nDestRow )
SCSIZE nIndex;
if (Search(nDestRow,nIndex))
{
- pCell = aItems[nIndex].pCell;
+ pCell = maItems[nIndex].pCell;
pBC = pCell->GetBroadcaster();
}
else
@@ -1540,7 +1540,7 @@ void ScColumn::EndListening( SvtListener& rLst, SCROW nRow )
SCSIZE nIndex;
if (Search(nRow,nIndex))
{
- ScBaseCell* pCell = aItems[nIndex].pCell;
+ ScBaseCell* pCell = maItems[nIndex].pCell;
SvtBroadcaster* pBC = pCell->GetBroadcaster();
if (pBC)
{
@@ -1559,10 +1559,10 @@ void ScColumn::EndListening( SvtListener& rLst, SCROW nRow )
void ScColumn::CompileDBFormula()
{
- if ( !aItems.empty() )
- for (SCSIZE i = 0; i < aItems.size(); i++)
+ if ( !maItems.empty() )
+ for (SCSIZE i = 0; i < maItems.size(); i++)
{
- ScBaseCell* pCell = aItems[i].pCell;
+ ScBaseCell* pCell = maItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
((ScFormulaCell*) pCell)->CompileDBFormula();
}
@@ -1570,10 +1570,10 @@ void ScColumn::CompileDBFormula()
void ScColumn::CompileDBFormula( bool bCreateFormulaString )
{
- if ( !aItems.empty() )
- for (SCSIZE i = 0; i < aItems.size(); i++)
+ if ( !maItems.empty() )
+ for (SCSIZE i = 0; i < maItems.size(); i++)
{
- ScBaseCell* pCell = aItems[i].pCell;
+ ScBaseCell* pCell = maItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
((ScFormulaCell*) pCell)->CompileDBFormula( bCreateFormulaString );
}
@@ -1581,10 +1581,10 @@ void ScColumn::CompileDBFormula( bool bCreateFormulaString )
void ScColumn::CompileNameFormula( bool bCreateFormulaString )
{
- if ( !aItems.empty() )
- for (SCSIZE i = 0; i < aItems.size(); i++)
+ if ( !maItems.empty() )
+ for (SCSIZE i = 0; i < maItems.size(); i++)
{
- ScBaseCell* pCell = aItems[i].pCell;
+ ScBaseCell* pCell = maItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
((ScFormulaCell*) pCell)->CompileNameFormula( bCreateFormulaString );
}
@@ -1592,10 +1592,10 @@ void ScColumn::CompileNameFormula( bool bCreateFormulaString )
void ScColumn::CompileColRowNameFormula()
{
- if ( !aItems.empty() )
- for (SCSIZE i = 0; i < aItems.size(); i++)
+ if ( !maItems.empty() )
+ for (SCSIZE i = 0; i < maItems.size(); i++)
{
- ScBaseCell* pCell = aItems[i].pCell;
+ ScBaseCell* pCell = maItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
((ScFormulaCell*) pCell)->CompileColRowNameFormula();
}
@@ -1690,11 +1690,11 @@ void ScColumn::UpdateSelectionFunction( const ScMarkData& rMark,
ScMarkedDataIter aDataIter(this, &rMark, false);
while (aDataIter.Next( nIndex ))
{
- SCROW nRow = aItems[nIndex].nRow;
+ SCROW nRow = maItems[nIndex].nRow;
bool bRowHidden = rHiddenRows.getValue(nRow);
if ( !bRowHidden )
if ( !bDoExclude || nRow < nExStartRow || nRow > nExEndRow )
- lcl_UpdateSubTotal( rData, aItems[nIndex].pCell );
+ lcl_UpdateSubTotal( rData, maItems[nIndex].pCell );
}
}
@@ -1705,12 +1705,12 @@ void ScColumn::UpdateAreaFunction( ScFunctionData& rData,
{
SCSIZE nIndex;
Search( nStartRow, nIndex );
- while ( nIndex<aItems.size() && aItems[nIndex].nRow<=nEndRow )
+ while ( nIndex<maItems.size() && maItems[nIndex].nRow<=nEndRow )
{
- SCROW nRow = aItems[nIndex].nRow;
+ SCROW nRow = maItems[nIndex].nRow;
bool bRowHidden = rHiddenRows.getValue(nRow);
if ( !bRowHidden )
- lcl_UpdateSubTotal( rData, aItems[nIndex].pCell );
+ lcl_UpdateSubTotal( rData, maItems[nIndex].pCell );
++nIndex;
}
}
@@ -1721,9 +1721,9 @@ sal_uInt32 ScColumn::GetWeightedCount() const
// Notizen werden nicht gezaehlt
- for (SCSIZE i=0; i<aItems.size(); i++)
+ for (SCSIZE i=0; i<maItems.size(); i++)
{
- ScBaseCell* pCell = aItems[i].pCell;
+ ScBaseCell* pCell = maItems[i].pCell;
switch ( pCell->GetCellType() )
{
case CELLTYPE_VALUE:
@@ -1750,9 +1750,9 @@ sal_uInt32 ScColumn::GetCodeCount() const
{
sal_uInt32 nCodeCount = 0;
- for (SCSIZE i=0; i<aItems.size(); i++)
+ for (SCSIZE i=0; i<maItems.size(); i++)
{
- ScBaseCell* pCell = aItems[i].pCell;
+ ScBaseCell* pCell = maItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
nCodeCount += ((ScFormulaCell*)pCell)->GetCode()->GetCodeLen();
}
diff --git a/sc/source/core/data/column3.cxx b/sc/source/core/data/column3.cxx
index 5c140bb..e880110 100644
--- a/sc/source/core/data/column3.cxx
+++ b/sc/source/core/data/column3.cxx
@@ -72,9 +72,9 @@ bool ScColumn::bDoubleAlloc = false; // fuer Import: Groesse beim Allozieren
void ScColumn::Insert( SCROW nRow, ScBaseCell* pNewCell )
{
sal_Bool bIsAppended = false;
- if ( !aItems.empty() )
+ if ( !maItems.empty() )
{
- if (aItems[aItems.size()-1].nRow < nRow)
+ if (maItems[maItems.size()-1].nRow < nRow)
{
Append(nRow, pNewCell );
bIsAppended = sal_True;
@@ -85,7 +85,7 @@ void ScColumn::Insert( SCROW nRow, ScBaseCell* pNewCell )
SCSIZE nIndex;
if (Search(nRow, nIndex))
{
- ScBaseCell* pOldCell = aItems[nIndex].pCell;
+ ScBaseCell* pOldCell = maItems[nIndex].pCell;
// move broadcaster and note to new cell, if not existing in new cell
if (pOldCell->HasBroadcaster() && !pNewCell->HasBroadcaster())
@@ -97,17 +97,17 @@ void ScColumn::Insert( SCROW nRow, ScBaseCell* pNewCell )
{
pOldCell->EndListeningTo( pDocument );
// falls in EndListening NoteCell in gleicher Col zerstoert
- if ( nIndex >= aItems.size() || aItems[nIndex].nRow != nRow )
+ if ( nIndex >= maItems.size() || maItems[nIndex].nRow != nRow )
Search(nRow, nIndex);
}
pOldCell->Delete();
- aItems[nIndex].pCell = pNewCell;
+ maItems[nIndex].pCell = pNewCell;
}
else
{
- aItems.insert(aItems.begin() + nIndex, ColEntry());
- aItems[nIndex].pCell = pNewCell;
- aItems[nIndex].nRow = nRow;
+ maItems.insert(maItems.begin() + nIndex, ColEntry());
+ maItems[nIndex].pCell = pNewCell;
+ maItems[nIndex].nRow = nRow;
}
}
// Bei aus Clipboard sind hier noch falsche (alte) Referenzen!
@@ -148,9 +148,9 @@ void ScColumn::Insert( SCROW nRow, sal_uInt32 nNumberFormat, ScBaseCell* pCell )
void ScColumn::Append( SCROW nRow, ScBaseCell* pCell )
{
- aItems.push_back(ColEntry());
- aItems[aItems.size() - 1].pCell = pCell;
- aItems[aItems.size() - 1].nRow = nRow;
+ maItems.push_back(ColEntry());
+ maItems[maItems.size() - 1].pCell = pCell;
+ maItems[maItems.size() - 1].nRow = nRow;
}
@@ -160,9 +160,9 @@ void ScColumn::Delete( SCROW nRow )
if (Search(nRow, nIndex))
{
- ScBaseCell* pCell = aItems[nIndex].pCell;
+ ScBaseCell* pCell = maItems[nIndex].pCell;
ScNoteCell* pNoteCell = new ScNoteCell;
- aItems[nIndex].pCell = pNoteCell; // Dummy fuer Interpret
+ maItems[nIndex].pCell = pNoteCell; // Dummy fuer Interpret
pDocument->Broadcast( ScHint( SC_HINT_DYING,
ScAddress( nCol, nRow, nTab ), pCell ) );
if ( SvtBroadcaster* pBC = pCell->ReleaseBroadcaster() )
@@ -172,7 +172,7 @@ void ScColumn::Delete( SCROW nRow )
else
{
pNoteCell->Delete();
- aItems.erase(aItems.end() - 1);
+ maItems.erase(maItems.end() - 1);
// Soll man hier den Speicher freigeben (delta)? Wird dann langsamer!
}
pCell->EndListeningTo( pDocument );
@@ -183,13 +183,13 @@ void ScColumn::Delete( SCROW nRow )
void ScColumn::DeleteAtIndex( SCSIZE nIndex )
{
- ScBaseCell* pCell = aItems[nIndex].pCell;
+ ScBaseCell* pCell = maItems[nIndex].pCell;
ScNoteCell* pNoteCell = new ScNoteCell;
- aItems[nIndex].pCell = pNoteCell; // Dummy fuer Interpret
+ maItems[nIndex].pCell = pNoteCell; // Dummy fuer Interpret
pDocument->Broadcast( ScHint( SC_HINT_DYING,
- ScAddress( nCol, aItems[nIndex].nRow, nTab ), pCell ) );
+ ScAddress( nCol, maItems[nIndex].nRow, nTab ), pCell ) );
pNoteCell->Delete();
- aItems.erase(aItems.begin() + nIndex);
+ maItems.erase(maItems.begin() + nIndex);
pCell->EndListeningTo( pDocument );
pCell->Delete();
}
@@ -197,9 +197,9 @@ void ScColumn::DeleteAtIndex( SCSIZE nIndex )
void ScColumn::FreeAll()
{
- for (SCSIZE i = 0; i < aItems.size(); i++)
- aItems[i].pCell->Delete();
- aItems.clear();
+ for (SCSIZE i = 0; i < maItems.size(); i++)
+ maItems[i].pCell->Delete();
+ maItems.clear();
}
@@ -207,12 +207,12 @@ void ScColumn::DeleteRow( SCROW nStartRow, SCSIZE nSize )
{
pAttrArray->DeleteRow( nStartRow, nSize );
- if ( aItems.empty() )
+ if ( maItems.empty() )
return ;
SCSIZE nFirstIndex;
Search( nStartRow, nFirstIndex );
- if ( nFirstIndex >= aItems.size() )
+ if ( nFirstIndex >= maItems.size() )
return ;
sal_Bool bOldAutoCalc = pDocument->GetAutoCalc();
@@ -224,7 +224,7 @@ void ScColumn::DeleteRow( SCROW nStartRow, SCSIZE nSize )
SCSIZE nEndIndex = 0;
SCSIZE i;
- for ( i = nFirstIndex; i < aItems.size() && aItems[i].nRow <= nEndRow; i++ )
+ for ( i = nFirstIndex; i < maItems.size() && maItems[i].nRow <= nEndRow; i++ )
{
if (!bFound)
{
@@ -233,7 +233,7 @@ void ScColumn::DeleteRow( SCROW nStartRow, SCSIZE nSize )
}
nEndIndex = i;
- ScBaseCell* pCell = aItems[i].pCell;
+ ScBaseCell* pCell = maItems[i].pCell;
SvtBroadcaster* pBC = pCell->GetBroadcaster();
if (pBC)
{
@@ -247,7 +247,7 @@ void ScColumn::DeleteRow( SCROW nStartRow, SCSIZE nSize )
{
DeleteRange( nStartIndex, nEndIndex, IDF_CONTENTS );
Search( nStartRow, i );
- if ( i >= aItems.size() )
+ if ( i >= maItems.size() )
{
pDocument->SetAutoCalc( bOldAutoCalc );
return ;
@@ -260,18 +260,18 @@ void ScColumn::DeleteRow( SCROW nStartRow, SCSIZE nSize )
ScHint aHint( SC_HINT_DATACHANGED, aAdr, NULL ); // only areas (ScBaseCell* == NULL)
ScAddress& rAddress = aHint.GetAddress();
// for sparse occupation use single broadcasts, not ranges
- sal_Bool bSingleBroadcasts = (((aItems[aItems.size()-1].nRow - aItems[i].nRow) /
- (aItems.size() - i)) > 1);
+ sal_Bool bSingleBroadcasts = (((maItems[maItems.size()-1].nRow - maItems[i].nRow) /
+ (maItems.size() - i)) > 1);
if ( bSingleBroadcasts )
{
SCROW nLastBroadcast = MAXROW+1;
- for ( ; i < aItems.size(); i++ )
+ for ( ; i < maItems.size(); i++ )
{
- SCROW nOldRow = aItems[i].nRow;
+ SCROW nOldRow = maItems[i].nRow;
// Aenderung Quelle broadcasten
rAddress.SetRow( nOldRow );
pDocument->AreaBroadcast( aHint );
- SCROW nNewRow = (aItems[i].nRow -= nSize);
+ SCROW nNewRow = (maItems[i].nRow -= nSize);
// Aenderung Ziel broadcasten
if ( nLastBroadcast != nNewRow )
{ // direkt aufeinanderfolgende nicht doppelt broadcasten
@@ -279,20 +279,20 @@ void ScColumn::DeleteRow( SCROW nStartRow, SCSIZE nSize )
pDocument->AreaBroadcast( aHint );
}
nLastBroadcast = nOldRow;
- ScBaseCell* pCell = aItems[i].pCell;
+ ScBaseCell* pCell = maItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
((ScFormulaCell*)pCell)->aPos.SetRow( nNewRow );
}
}
else
{
- rAddress.SetRow( aItems[i].nRow );
+ rAddress.SetRow( maItems[i].nRow );
ScRange aRange( rAddress );
- aRange.aEnd.SetRow( aItems[aItems.size()-1].nRow );
- for ( ; i < aItems.size(); i++ )
+ aRange.aEnd.SetRow( maItems[maItems.size()-1].nRow );
+ for ( ; i < maItems.size(); i++ )
{
- SCROW nNewRow = (aItems[i].nRow -= nSize);
- ScBaseCell* pCell = aItems[i].pCell;
+ SCROW nNewRow = (maItems[i].nRow -= nSize);
+ ScBaseCell* pCell = maItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
((ScFormulaCell*)pCell)->aPos.SetRow( nNewRow );
}
@@ -313,7 +313,7 @@ void ScColumn::DeleteRange( SCSIZE nStartIndex, SCSIZE nEndIndex, sal_uInt16 nDe
bool bNoCaptions = (nDelFlag & IDF_NOCAPTIONS) != 0;
if (bDeleteNote && bNoCaptions)
for ( SCSIZE nIdx = nStartIndex; nIdx <= nEndIndex; ++nIdx )
- if ( ScPostIt* pNote = aItems[ nIdx ].pCell->GetNote() )
+ if ( ScPostIt* pNote = maItems[ nIdx ].pCell->GetNote() )
pNote->ForgetCaption();
ScHint aHint( SC_HINT_DYING, ScAddress( nCol, 0, nTab ), 0 );
@@ -324,7 +324,7 @@ void ScColumn::DeleteRange( SCSIZE nStartIndex, SCSIZE nEndIndex, sal_uInt16 nDe
aDelCells.reserve( nEndIndex - nStartIndex + 1 );
typedef mdds::flat_segment_tree<SCSIZE, bool> RemovedSegments_t;
- RemovedSegments_t aRemovedSegments(nStartIndex, aItems.size(), false);
+ RemovedSegments_t aRemovedSegments(nStartIndex, maItems.size(), false);
SCSIZE nFirst(nStartIndex);
// dummy replacement for old cells, to prevent that interpreter uses old cell
@@ -333,9 +333,9 @@ void ScColumn::DeleteRange( SCSIZE nStartIndex, SCSIZE nEndIndex, sal_uInt16 nDe
for ( SCSIZE nIdx = nStartIndex; nIdx <= nEndIndex; ++nIdx )
{
// all content is deleted and cell does not contain broadcaster
- if (((nDelFlag & IDF_CONTENTS) == IDF_CONTENTS) && !aItems[ nIdx ].pCell->GetBroadcaster())
+ if (((nDelFlag & IDF_CONTENTS) == IDF_CONTENTS) && !maItems[ nIdx ].pCell->GetBroadcaster())
{
- ScBaseCell* pOldCell = aItems[ nIdx ].pCell;
+ ScBaseCell* pOldCell = maItems[ nIdx ].pCell;
if (pOldCell->GetCellType() == CELLTYPE_FORMULA)
{
// cache formula cell, will be deleted below
@@ -344,8 +344,8 @@ void ScColumn::DeleteRange( SCSIZE nStartIndex, SCSIZE nEndIndex, sal_uInt16 nDe
else
{
// interpret in broadcast must not use the old cell
- aItems[ nIdx ].pCell = pDummyCell.get();
- aHint.GetAddress().SetRow( aItems[ nIdx ].nRow );
+ maItems[ nIdx ].pCell = pDummyCell.get();
+ aHint.GetAddress().SetRow( maItems[ nIdx ].nRow );
aHint.SetCell( pOldCell );
pDocument->Broadcast( aHint );
pOldCell->Delete();
@@ -355,13 +355,13 @@ void ScColumn::DeleteRange( SCSIZE nStartIndex, SCSIZE nEndIndex, sal_uInt16 nDe
else
{
bool bDelete = false;
- ScBaseCell* pOldCell = aItems[nIdx].pCell;
+ ScBaseCell* pOldCell = maItems[nIdx].pCell;
CellType eCellType = pOldCell->GetCellType();
if ((nDelFlag & IDF_CONTENTS) == IDF_CONTENTS)
bDelete = true;
else
{
- // decide whether to delete the cell object according to passed
+ // decide whether to delete the cell object according to passed
// flags
switch ( eCellType )
{
@@ -374,7 +374,7 @@ void ScColumn::DeleteRange( SCSIZE nStartIndex, SCSIZE nEndIndex, sal_uInt16 nDe
if( !bDelete && (nValFlags != 0) )
{
sal_uLong nIndex = (sal_uLong)((SfxUInt32Item*)GetAttr(
- aItems[nIdx].nRow, ATTR_VALUE_FORMAT ))->GetValue();
+ maItems[nIdx].nRow, ATTR_VALUE_FORMAT ))->GetValue();
short nType = pDocument->GetFormatTable()->GetType(nIndex);
bool bIsDate = (nType == NUMBERFORMAT_DATE) ||
(nType == NUMBERFORMAT_TIME) || (nType == NUMBERFORMAT_DATETIME);
@@ -416,16 +416,16 @@ void ScColumn::DeleteRange( SCSIZE nStartIndex, SCSIZE nEndIndex, sal_uInt16 nDe
}
// remove cell entry in cell item list
- SCROW nOldRow = aItems[nIdx].nRow;
+ SCROW nOldRow = maItems[nIdx].nRow;
if (pNoteCell)
{
// replace old cell with the replacement note cell
- aItems[nIdx].pCell = pNoteCell;
+ maItems[nIdx].pCell = pNoteCell;
// ... so it's not really deleted
bDelete = false;
}
else
- aItems[nIdx].pCell = pDummyCell.get();
+ maItems[nIdx].pCell = pDummyCell.get();
// cache formula cells (will be deleted later), delete cell of other type
if (eCellType == CELLTYPE_FORMULA)
@@ -446,7 +446,7 @@ void ScColumn::DeleteRange( SCSIZE nStartIndex, SCSIZE nEndIndex, sal_uInt16 nDe
{
// delete cell note
if (bDeleteNote)
- aItems[nIdx].pCell->DeleteNote();
+ maItems[nIdx].pCell->DeleteNote();
}
if (!bDelete)
@@ -480,7 +480,7 @@ void ScColumn::DeleteRange( SCSIZE nStartIndex, SCSIZE nEndIndex, sal_uInt16 nDe
{ // this segment removed
if (!bRemoved)
nStartSegment = aIt->first;
- // The first of removes in a row sets start (they should be
+ // The first of removes in a row sets start (they should be
// alternating removed/notremoved anyway).
bRemoved = true;
}
@@ -490,9 +490,9 @@ void ScColumn::DeleteRange( SCSIZE nStartIndex, SCSIZE nEndIndex, sal_uInt16 nDe
{ // previous segment(s) removed, move tail
SCSIZE const nEndSegment(aIt->first);
memmove(
- &aItems[nStartSegment - nShift],
- &aItems[nEndSegment - nShift],
- (aItems.size() - nEndSegment) * sizeof(ColEntry));
+ &maItems[nStartSegment - nShift],
+ &maItems[nEndSegment - nShift],
+ (maItems.size() - nEndSegment) * sizeof(ColEntry));
nShift += nEndSegment - nStartSegment;
bRemoved = false;
}
@@ -502,8 +502,8 @@ void ScColumn::DeleteRange( SCSIZE nStartIndex, SCSIZE nEndIndex, sal_uInt16 nDe
// The last removed segment up to aItems.size() is discarded, there's
// nothing following to be moved.
if (bRemoved)
- nShift += aItems.size() - nStartSegment;
- aItems.erase(aItems.end() - nShift, aItems.end());
+ nShift += maItems.size() - nStartSegment;
+ maItems.erase(maItems.end() - nShift, maItems.end());
}
// *** delete all formula cells ***
@@ -547,17 +547,17 @@ void ScColumn::DeleteArea(SCROW nStartRow, SCROW nEndRow, sal_uInt16 nDelFlag)
nContMask |= IDF_NOCAPTIONS;
sal_uInt16 nContFlag = nDelFlag & nContMask;
- if ( !aItems.empty() && nContFlag)
+ if ( !maItems.empty() && nContFlag)
{
if (nStartRow==0 && nEndRow==MAXROW)
- DeleteRange( 0, aItems.size()-1, nContFlag );
+ DeleteRange( 0, maItems.size()-1, nContFlag );
else
{
sal_Bool bFound=false;
SCSIZE nStartIndex = 0;
SCSIZE nEndIndex = 0;
- for (SCSIZE i = 0; i < aItems.size(); i++)
- if ((aItems[i].nRow >= nStartRow) && (aItems[i].nRow <= nEndRow))
+ for (SCSIZE i = 0; i < maItems.size(); i++)
+ if ((maItems[i].nRow >= nStartRow) && (maItems[i].nRow <= nEndRow))
{
if (!bFound)
{
@@ -594,7 +594,7 @@ ScFormulaCell* ScColumn::CreateRefCell( ScDocument* pDestDoc, const ScAddress& r
// auch bei IDF_CONTENTS komplett, wegen Notes / Broadcastern
sal_Bool bMatch = false;
- ScBaseCell* pCell = aItems[nIndex].pCell;
+ ScBaseCell* pCell = maItems[nIndex].pCell;
CellType eCellType = pCell->GetCellType();
switch ( eCellType )
{
@@ -607,7 +607,7 @@ ScFormulaCell* ScColumn::CreateRefCell( ScDocument* pDestDoc, const ScAddress& r
else if ( nValFlags )
{
sal_uLong nNumIndex = (sal_uLong)((SfxUInt32Item*)GetAttr(
- aItems[nIndex].nRow, ATTR_VALUE_FORMAT ))->GetValue();
+ maItems[nIndex].nRow, ATTR_VALUE_FORMAT ))->GetValue();
short nTyp = pDocument->GetFormatTable()->GetType(nNumIndex);
if ((nTyp == NUMBERFORMAT_DATE) || (nTyp == NUMBERFORMAT_TIME) || (nTyp == NUMBERFORMAT_DATETIME))
bMatch = ((nFlags & IDF_DATETIME) != 0);
@@ -631,7 +631,7 @@ ScFormulaCell* ScColumn::CreateRefCell( ScDocument* pDestDoc, const ScAddress& r
// Referenz einsetzen
ScSingleRefData aRef;
aRef.nCol = nCol;
- aRef.nRow = aItems[nIndex].nRow;
+ aRef.nRow = maItems[nIndex].nRow;
aRef.nTab = nTab;
aRef.InitFlags(); // -> alles absolut
aRef.SetFlag3D(true);
@@ -664,20 +664,20 @@ void ScColumn::CopyFromClip(SCROW nRow1, SCROW nRow2, long nDy,
SCSIZE nStartIndex;
rColumn.Search( nRow1-nDy, nStartIndex );
- while ( nStartIndex < rColumn.aItems.size() && rColumn.aItems[nStartIndex].nRow <= nRow2-nDy )
+ while ( nStartIndex < rColumn.maItems.size() && rColumn.maItems[nStartIndex].nRow <= nRow2-nDy )
{
SCSIZE nEndIndex = nStartIndex;
- if ( rColumn.aItems[nStartIndex].pCell->GetCellType() != CELLTYPE_NOTE )
+ if ( rColumn.maItems[nStartIndex].pCell->GetCellType() != CELLTYPE_NOTE )
{
- SCROW nStartRow = rColumn.aItems[nStartIndex].nRow;
+ SCROW nStartRow = rColumn.maItems[nStartIndex].nRow;
SCROW nEndRow = nStartRow;
// find consecutive non-empty cells
while ( nEndRow < nRow2-nDy &&
- nEndIndex+1 < rColumn.aItems.size() &&
- rColumn.aItems[nEndIndex+1].nRow == nEndRow+1 &&
- rColumn.aItems[nEndIndex+1].pCell->GetCellType() != CELLTYPE_NOTE )
+ nEndIndex+1 < rColumn.maItems.size() &&
+ rColumn.maItems[nEndIndex+1].nRow == nEndRow+1 &&
+ rColumn.maItems[nEndIndex+1].pCell->GetCellType() != CELLTYPE_NOTE )
{
++nEndIndex;
++nEndRow;
@@ -700,7 +700,7 @@ void ScColumn::CopyFromClip(SCROW nRow1, SCROW nRow2, long nDy,
//! IDF_ALL muss immer mehr Flags enthalten, als bei "Inhalte Einfuegen"
//! einzeln ausgewaehlt werden koennen!
- Resize( aItems.size() + static_cast<SCSIZE>(nRow2-nRow1+1) );
+ Resize( maItems.size() + static_cast<SCSIZE>(nRow2-nRow1+1) );
ScAddress aDestPos( nCol, 0, nTab ); // Row wird angepasst
@@ -726,7 +726,7 @@ void ScColumn::CopyFromClip(SCROW nRow1, SCROW nRow2, long nDy,
return;
}
- SCSIZE nColCount = rColumn.aItems.size();
+ SCSIZE nColCount = rColumn.maItems.size();
// ignore IDF_FORMULA - "all contents but no formulas" results in the same number of cells
if ((nInsFlag & ( IDF_CONTENTS & ~IDF_FORMULA )) == ( IDF_CONTENTS & ~IDF_FORMULA ) && nRow2-nRow1 >= 64)
@@ -734,7 +734,7 @@ void ScColumn::CopyFromClip(SCROW nRow1, SCROW nRow2, long nDy,
//! Always do the Resize from the outside, where the number of repetitions is known
//! (then it can be removed here)
- SCSIZE nNew = aItems.size() + nColCount;
+ SCSIZE nNew = maItems.size() + nColCount;
Resize( nNew );
}
@@ -744,7 +744,7 @@ void ScColumn::CopyFromClip(SCROW nRow1, SCROW nRow2, long nDy,
sal_Bool bAtEnd = false;
for (SCSIZE i = 0; i < nColCount && !bAtEnd; i++)
{
- SCsROW nDestRow = rColumn.aItems[i].nRow + nDy;
+ SCsROW nDestRow = rColumn.maItems[i].nRow + nDy;
if ( nDestRow > (SCsROW) nRow2 )
bAtEnd = sal_True;
else if ( nDestRow >= (SCsROW) nRow1 )
@@ -765,14 +765,14 @@ void ScColumn::CopyFromClip(SCROW nRow1, SCROW nRow2, long nDy,
if (pAddNoteCell)
{
// do nothing if source cell does not contain a note
- const ScBaseCell* pSourceCell = rColumn.aItems[i].pCell;
+ const ScBaseCell* pSourceCell = rColumn.maItems[i].pCell;
const ScPostIt* pSourceNote = pSourceCell ? pSourceCell->GetNote() : 0;
if (pSourceNote)
{
OSL_ENSURE( !pAddNoteCell->HasNote(), "ScColumn::CopyFromClip - unexpected note at destination cell" );
bool bCloneCaption = (nInsFlag & IDF_NOCAPTIONS) == 0;
// #i52342# if caption is cloned, the note must be constructed with the destination document
- ScAddress aSourcePos( rColumn.nCol, rColumn.aItems[i].nRow, rColumn.nTab );
+ ScAddress aSourcePos( rColumn.nCol, rColumn.maItems[i].nRow, rColumn.nTab );
ScPostIt* pNewNote = pSourceNote->Clone( aSourcePos, *pDocument, aDestPos, bCloneCaption );
pAddNoteCell->TakeNote( pNewNote );
}
@@ -820,7 +820,7 @@ ScBaseCell* ScColumn::CloneCell(SCSIZE nIndex, sal_uInt16 nFlags, ScDocument& rD
bool bForceFormula = false;
ScBaseCell* pNew = 0;
- ScBaseCell& rSource = *aItems[nIndex].pCell;
+ ScBaseCell& rSource = *maItems[nIndex].pCell;
switch (rSource.GetCellType())
{
case CELLTYPE_NOTE:
@@ -836,7 +836,7 @@ ScBaseCell* ScColumn::CloneCell(SCSIZE nIndex, sal_uInt16 nFlags, ScDocument& rD
case CELLTYPE_VALUE:
// note will be cloned below
- if (lclCanCloneValue( *pDocument, *this, aItems[nIndex].nRow, bCloneValue, bCloneDateTime ))
+ if (lclCanCloneValue( *pDocument, *this, maItems[nIndex].nRow, bCloneValue, bCloneDateTime ))
pNew = rSource.CloneWithoutNote( rDestDoc, rDestPos );
break;
@@ -875,7 +875,7 @@ ScBaseCell* ScColumn::CloneCell(SCSIZE nIndex, sal_uInt16 nFlags, ScDocument& rD
}
else if (rForm.IsValue())
{
- if (lclCanCloneValue( *pDocument, *this, aItems[nIndex].nRow, bCloneValue, bCloneDateTime ))
+ if (lclCanCloneValue( *pDocument, *this, maItems[nIndex].nRow, bCloneValue, bCloneDateTime ))
{
double nVal = rForm.GetValue();
pNew = new ScValueCell(nVal);
@@ -911,7 +911,7 @@ ScBaseCell* ScColumn::CloneCell(SCSIZE nIndex, sal_uInt16 nFlags, ScDocument& rD
{
bool bCloneCaption = (nFlags & IDF_NOCAPTIONS) == 0;
// #i52342# if caption is cloned, the note must be constructed with the destination document
- ScAddress aOwnPos( nCol, aItems[nIndex].nRow, nTab );
+ ScAddress aOwnPos( nCol, maItems[nIndex].nRow, nTab );
ScPostIt* pNewNote = pNote->Clone( aOwnPos, rDestDoc, rDestPos, bCloneCaption );
if (!pNew)
pNew = new ScNoteCell( pNewNote );
@@ -986,7 +986,7 @@ void ScColumn::MixData( SCROW nRow1, SCROW nRow2,
sal_uInt16 nFunction, bool bSkipEmpty,
ScColumn& rSrcCol )
{
- SCSIZE nSrcCount = rSrcCol.aItems.size();
+ SCSIZE nSrcCount = rSrcCol.maItems.size();
SCSIZE nIndex;
Search( nRow1, nIndex );
@@ -996,11 +996,11 @@ void ScColumn::MixData( SCROW nRow1, SCROW nRow2,
rSrcCol.Search( nRow1, nSrcIndex ); //! Testen, ob Daten ganz vorne
SCROW nNextThis = MAXROW+1;
- if ( nIndex < aItems.size() )
- nNextThis = aItems[nIndex].nRow;
+ if ( nIndex < maItems.size() )
+ nNextThis = maItems[nIndex].nRow;
SCROW nNextSrc = MAXROW+1;
if ( nSrcIndex < nSrcCount )
- nNextSrc = rSrcCol.aItems[nSrcIndex].nRow;
+ nNextSrc = rSrcCol.maItems[nSrcIndex].nRow;
while ( nNextThis <= nRow2 || nNextSrc <= nRow2 )
{
@@ -1012,10 +1012,10 @@ void ScColumn::MixData( SCROW nRow1, SCROW nRow2,
sal_Bool bDelete = false;
if ( nSrcIndex < nSrcCount && nNextSrc == nRow )
- pSrc = rSrcCol.aItems[nSrcIndex].pCell;
+ pSrc = rSrcCol.maItems[nSrcIndex].pCell;
- if ( nIndex < aItems.size() && nNextThis == nRow )
- pDest = aItems[nIndex].pCell;
+ if ( nIndex < maItems.size() && nNextThis == nRow )
+ pDest = maItems[nIndex].pCell;
OSL_ENSURE( pSrc || pDest, "Nanu ?" );
@@ -1139,19 +1139,19 @@ void ScColumn::MixData( SCROW nRow1, SCROW nRow2,
if (pNew)
nNextThis = nRow; // nIndex zeigt jetzt genau auf nRow
else
- nNextThis = ( nIndex < aItems.size() ) ? aItems[nIndex].nRow : MAXROW+1;
+ nNextThis = ( nIndex < maItems.size() ) ? maItems[nIndex].nRow : MAXROW+1;
}
if ( nNextThis == nRow )
{
++nIndex;
- nNextThis = ( nIndex < aItems.size() ) ? aItems[nIndex].nRow : MAXROW+1;
+ nNextThis = ( nIndex < maItems.size() ) ? maItems[nIndex].nRow : MAXROW+1;
}
if ( nNextSrc == nRow )
{
++nSrcIndex;
nNextSrc = ( nSrcIndex < nSrcCount ) ?
- rSrcCol.aItems[nSrcIndex].nRow :
+ rSrcCol.maItems[nSrcIndex].nRow :
MAXROW+1;
}
}
@@ -1166,15 +1166,15 @@ ScAttrIterator* ScColumn::CreateAttrIterator( SCROW nStartRow, SCROW nEndRow ) c
void ScColumn::StartAllListeners()
{
- if ( !aItems.empty() )
- for (SCSIZE i = 0; i < aItems.size(); i++)
+ if ( !maItems.empty() )
+ for (SCSIZE i = 0; i < maItems.size(); i++)
{
- ScBaseCell* pCell = aItems[i].pCell;
+ ScBaseCell* pCell = maItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
{
- SCROW nRow = aItems[i].nRow;
+ SCROW nRow = maItems[i].nRow;
((ScFormulaCell*)pCell)->StartListeningTo( pDocument );
- if ( nRow != aItems[i].nRow )
+ if ( nRow != maItems[i].nRow )
Search( nRow, i ); // Listener eingefuegt?
}
}
@@ -1183,19 +1183,19 @@ void ScColumn::StartAllListeners()
void ScColumn::StartNeededListeners()
{
- if ( !aItems.empty() )
+ if ( !maItems.empty() )
{
- for (SCSIZE i = 0; i < aItems.size(); i++)
+ for (SCSIZE i = 0; i < maItems.size(); i++)
{
- ScBaseCell* pCell = aItems[i].pCell;
+ ScBaseCell* pCell = maItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
{
ScFormulaCell* pFCell = static_cast<ScFormulaCell*>(pCell);
if (pFCell->NeedsListening())
{
- SCROW nRow = aItems[i].nRow;
+ SCROW nRow = maItems[i].nRow;
pFCell->StartListeningTo( pDocument );
- if ( nRow != aItems[i].nRow )
+ if ( nRow != maItems[i].nRow )
Search( nRow, i ); // Listener eingefuegt?
}
}
@@ -1206,14 +1206,14 @@ void ScColumn::StartNeededListeners()
void ScColumn::BroadcastInArea( SCROW nRow1, SCROW nRow2 )
{
- if ( !aItems.empty() )
+ if ( !maItems.empty() )
{
SCROW nRow;
SCSIZE nIndex;
Search( nRow1, nIndex );
- while ( nIndex < aItems.size() && (nRow = aItems[nIndex].nRow) <= nRow2 )
+ while ( nIndex < maItems.size() && (nRow = maItems[nIndex].nRow) <= nRow2 )
{
- ScBaseCell* pCell = aItems[nIndex].pCell;
... etc. - the rest is truncated
More information about the Libreoffice-commits
mailing list