Hi
this patch passes valgrind tests in the sc module, and passes a global
make check.
Regards, Noel Grandin
Disclaimer: http://www.peralex.com/disclaimer.html
diff --git a/sc/inc/column.hxx b/sc/inc/column.hxx
index f86bf9b..5000bae 100644
--- a/sc/inc/column.hxx
+++ b/sc/inc/column.hxx
@@ -35,6 +35,7 @@
#include "rangenam.hxx"
#include <set>
+#include <vector>
namespace editeng { class SvxBorderLine; }
@@ -105,9 +106,7 @@ private:
SCCOL nCol;
SCTAB nTab;
- SCSIZE nCount;
- SCSIZE nLimit;
- ColEntry* pItems;
+ std::vector<ColEntry> aItems;
ScAttrArray* pAttrArray;
ScDocument* pDocument;
@@ -257,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 nCount; }
+ SCSIZE GetCellCount() const { return aItems.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 933abf2..133ccb2 100644
--- a/sc/source/core/data/column.cxx
+++ b/sc/source/core/data/column.cxx
@@ -84,9 +84,6 @@ ScColumn::DoubleAllocSwitch::~DoubleAllocSwitch()
ScColumn::ScColumn() :
nCol( 0 ),
- nCount( 0 ),
- nLimit( 0 ),
- pItems( NULL ),
pAttrArray( NULL ),
pDocument( NULL )
{
@@ -118,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 ( !pItems )
+ if ( aItems.empty() )
return 0;
if ( nRow1 == nRow2 )
{
SCSIZE nIndex;
if ( Search( nRow1, nIndex ) )
{
- ScBaseCell* pCell = pItems[nIndex].pCell;
+ ScBaseCell* pCell = aItems[nIndex].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA
&& ((ScFormulaCell*)pCell)->GetMatrixFlag() )
{
@@ -142,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 < nCount && pItems[nIndex].nRow <= nRow2 )
+ while ( nIndex < aItems.size() && aItems[nIndex].nRow <= nRow2 )
{
- ScBaseCell* pCell = pItems[nIndex].pCell;
+ ScBaseCell* pCell = aItems[nIndex].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA
&& ((ScFormulaCell*)pCell)->GetMatrixFlag() )
{
@@ -191,9 +188,9 @@ bool ScColumn::HasSelectionMatrixFragment(const ScMarkData& rMark) const
sal_uInt16 nEdges;
SCSIZE nIndex;
Search( nTop, nIndex );
- while ( !bFound && nIndex < nCount && pItems[nIndex].nRow <= nBottom )
+ while ( !bFound && nIndex < aItems.size() && aItems[nIndex].nRow <= nBottom )
{
- ScBaseCell* pCell = pItems[nIndex].pCell;
+ ScBaseCell* pCell = aItems[nIndex].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA
&& ((ScFormulaCell*)pCell)->GetMatrixFlag() )
{
@@ -697,39 +694,39 @@ void ScColumn::ApplyAttr( SCROW nRow, const SfxPoolItem& rAttr )
bool ScColumn::Search( SCROW nRow, SCSIZE& nIndex ) const
{
- if ( !pItems || !nCount )
+ if ( aItems.empty() )
{
nIndex = 0;
return false;
}
- SCROW nMinRow = pItems[0].nRow;
+ SCROW nMinRow = aItems[0].nRow;
if ( nRow <= nMinRow )
{
nIndex = 0;
return nRow == nMinRow;
}
- SCROW nMaxRow = pItems[nCount-1].nRow;
+ SCROW nMaxRow = aItems[aItems.size()-1].nRow;
if ( nRow >= nMaxRow )
{
if ( nRow == nMaxRow )
{
- nIndex = nCount - 1;
+ nIndex = aItems.size() - 1;
return true;
}
else
{
- nIndex = nCount;
+ nIndex = aItems.size();
return false;
}
}
long nOldLo, nOldHi;
long nLo = nOldLo = 0;
- long nHi = nOldHi = Min(static_cast<long>(nCount)-1, static_cast<long>(nRow) );
+ long nHi = nOldHi = Min(static_cast<long>(aItems.size())-1, static_cast<long>(nRow) );
long i = 0;
bool bFound = false;
// quite continuous distribution? => interpolating search
- bool bInterpol = (static_cast<SCSIZE>(nMaxRow - nMinRow) < nCount * 2);
+ bool bInterpol = (static_cast<SCSIZE>(nMaxRow - nMinRow) < aItems.size() * 2);
SCROW nR;
while ( !bFound && nLo <= nHi )
@@ -738,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 = pItems[nLo].nRow; // no unsigned underflow upon substraction
+ long nLoRow = aItems[nLo].nRow; // no unsigned underflow upon substraction
i = nLo + (long)((long)(nRow - nLoRow) * (nHi - nLo)
- / (pItems[nHi].nRow - nLoRow));
- if ( i < 0 || static_cast<SCSIZE>(i) >= nCount )
+ / (aItems[nHi].nRow - nLoRow));
+ if ( i < 0 || static_cast<SCSIZE>(i) >= aItems.size() )
{ // oops ...
i = (nLo+nHi) / 2;
bInterpol = false;
}
}
- nR = pItems[i].nRow;
+ nR = aItems[i].nRow;
if ( nR < nRow )
{
nLo = i+1;
@@ -792,7 +789,7 @@ ScBaseCell* ScColumn::GetCell( SCROW nRow ) const
{
SCSIZE nIndex;
if (Search(nRow, nIndex))
- return pItems[nIndex].pCell;
+ return aItems[nIndex].pCell;
return NULL;
}
@@ -801,29 +798,10 @@ void ScColumn::Resize( SCSIZE nSize )
{
if (nSize > sal::static_int_cast<SCSIZE>(MAXROWCOUNT))
nSize = MAXROWCOUNT;
- if (nSize < nCount)
- nSize = nCount;
+ if (nSize < aItems.size())
+ nSize = aItems.size();
- ColEntry* pNewItems;
- if (nSize)
- {
- SCSIZE nNewSize = nSize + COLUMN_DELTA - 1;
- nNewSize -= nNewSize % COLUMN_DELTA;
- nLimit = nNewSize;
- pNewItems = new ColEntry[nLimit];
- }
- else
- {
- nLimit = 0;
- pNewItems = NULL;
- }
- if (pItems)
- {
- if (pNewItems)
- memmove( pNewItems, pItems, nCount * sizeof(ColEntry) );
- delete[] pItems;
- }
- pItems = pNewItems;
+ aItems.reserve(nSize);
}
// SwapRow zum Sortieren
@@ -857,12 +835,12 @@ void ScColumn::SwapRow(SCROW nRow1, SCROW nRow2)
ScBaseCell* pCell1 = 0;
SCSIZE nIndex1;
if ( Search( nRow1, nIndex1 ) )
- pCell1 = pItems[nIndex1].pCell;
+ pCell1 = aItems[nIndex1].pCell;
ScBaseCell* pCell2 = 0;
SCSIZE nIndex2;
if ( Search( nRow2, nIndex2 ) )
- pCell2 = pItems[nIndex2].pCell;
+ pCell2 = aItems[nIndex2].pCell;
// no cells found, nothing to do
if ( !pCell1 && !pCell2 )
@@ -897,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). */
- pItems[nIndex1].pCell = pCell2;
- pItems[nIndex2].pCell = pCell1;
+ aItems[nIndex1].pCell = pCell2;
+ aItems[nIndex2].pCell = pCell1;
SvtBroadcaster* pBC2 = pCell2->ReleaseBroadcaster();
pCell1->TakeBroadcaster( pBC2 );
@@ -910,15 +888,12 @@ void ScColumn::SwapRow(SCROW nRow1, SCROW nRow2)
if ( pDummyCell )
{
// insert dummy note cell (without note) containing old broadcaster
- pItems[nIndex1].pCell = pDummyCell;
+ aItems[nIndex1].pCell = pDummyCell;
}
else
{
// remove ColEntry at old position
- --nCount;
- memmove( &pItems[nIndex1], &pItems[nIndex1 + 1], (nCount - nIndex1) *
sizeof(ColEntry) );
- pItems[nCount].nRow = 0;
- pItems[nCount].pCell = 0;
+ aItems.erase( aItems.begin() + nIndex1 );
}
// insert ColEntry at new position
@@ -1008,12 +983,12 @@ void ScColumn::SwapCell( SCROW nRow, ScColumn& rCol)
ScBaseCell* pCell1 = 0;
SCSIZE nIndex1;
if ( Search( nRow, nIndex1 ) )
- pCell1 = pItems[nIndex1].pCell;
+ pCell1 = aItems[nIndex1].pCell;
ScBaseCell* pCell2 = 0;
SCSIZE nIndex2;
if ( rCol.Search( nRow, nIndex2 ) )
- pCell2 = rCol.pItems[nIndex2].pCell;
+ pCell2 = rCol.aItems[nIndex2].pCell;
// reverse call if own cell is missing (ensures own existing cell in following code)
if( !pCell1 )
@@ -1031,8 +1006,8 @@ void ScColumn::SwapCell( SCROW nRow, ScColumn& rCol)
if ( pCell2 )
{
// Tauschen
- pItems[nIndex1].pCell = pCell2;
- rCol.pItems[nIndex2].pCell = pCell1;
+ aItems[nIndex1].pCell = pCell2;
+ rCol.aItems[nIndex2].pCell = pCell1;
// Referenzen aktualisieren
SCsCOL dx = rCol.nCol - nCol;
if ( pFmlaCell1 )
@@ -1053,10 +1028,7 @@ void ScColumn::SwapCell( SCROW nRow, ScColumn& rCol)
else
{
// Loeschen
- --nCount;
- memmove( &pItems[nIndex1], &pItems[nIndex1 + 1], (nCount - nIndex1) * sizeof(ColEntry) );
- pItems[nCount].nRow = 0;
- pItems[nCount].pCell = 0;
+ aItems.erase(aItems.begin() + nIndex1);
// Referenzen aktualisieren
SCsCOL dx = rCol.nCol - nCol;
if ( pFmlaCell1 )
@@ -1077,10 +1049,10 @@ bool ScColumn::TestInsertCol( SCROW nStartRow, SCROW nEndRow) const
if (!IsEmpty())
{
bool bTest = true;
- if (pItems)
- for (SCSIZE i=0; (i<nCount) && bTest; i++)
- bTest = (pItems[i].nRow < nStartRow) || (pItems[i].nRow > nEndRow)
- || pItems[i].pCell->IsBlank();
+ 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();
// AttrArray testet nur zusammengefasste
@@ -1100,9 +1072,9 @@ bool ScColumn::TestInsertRow( SCSIZE nSize ) const
{
// AttrArray only looks for merged cells
- if ( pItems && nCount )
+ if ( !aItems.empty() )
return ( nSize <= sal::static_int_cast<SCSIZE>(MAXROW) &&
- pItems[nCount-1].nRow <= MAXROW-(SCROW)nSize && pAttrArray->TestInsertRow( nSize
) );
+ aItems[aItems.size()-1].nRow <= MAXROW-(SCROW)nSize && pAttrArray->TestInsertRow(
nSize ) );
else
return pAttrArray->TestInsertRow( nSize );
}
@@ -1114,43 +1086,43 @@ void ScColumn::InsertRow( SCROW nStartRow, SCSIZE nSize )
//! Search
- if ( !pItems || !nCount )
+ if ( aItems.empty() )
return;
SCSIZE i;
Search( nStartRow, i );
- if ( i >= nCount )
+ if ( i >= aItems.size() )
return ;
bool bOldAutoCalc = pDocument->GetAutoCalc();
pDocument->SetAutoCalc( false ); // Mehrfachberechnungen vermeiden
- SCSIZE nNewCount = nCount;
+ SCSIZE nNewCount = aItems.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 = (((pItems[nCount-1].nRow - pItems[i].nRow) /
- (nCount - i)) > 1);
+ bool bSingleBroadcasts = (((aItems[aItems.size()-1].nRow - aItems[i].nRow) /
+ (aItems.size() - i)) > 1);
if ( bSingleBroadcasts )
{
SCROW nLastBroadcast = MAXROW+1;
- for ( ; i < nCount; i++)
+ for ( ; i < aItems.size(); i++)
{
- SCROW nOldRow = pItems[i].nRow;
- // Aenderung Quelle broadcasten
+ SCROW nOldRow = aItems[i].nRow;
+ // Change source broadcaster
if ( nLastBroadcast != nOldRow )
- { // direkt aufeinanderfolgende nicht doppelt broadcasten
+ { // Do not broadcast a direct sequence twice
rAddress.SetRow( nOldRow );
pDocument->AreaBroadcast( aHint );
}
- SCROW nNewRow = (pItems[i].nRow += nSize);
- // Aenderung Ziel broadcasten
+ SCROW nNewRow = (aItems[i].nRow += nSize);
+ // Change target broadcaster
rAddress.SetRow( nNewRow );
pDocument->AreaBroadcast( aHint );
nLastBroadcast = nNewRow;
- ScBaseCell* pCell = pItems[i].pCell;
+ ScBaseCell* pCell = aItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
((ScFormulaCell*)pCell)->aPos.SetRow( nNewRow );
if ( nNewRow > MAXROW && !bCountChanged )
@@ -1162,12 +1134,12 @@ void ScColumn::InsertRow( SCROW nStartRow, SCSIZE nSize )
}
else
{
- rAddress.SetRow( pItems[i].nRow );
+ rAddress.SetRow( aItems[i].nRow );
ScRange aRange( rAddress );
- for ( ; i < nCount; i++)
+ for ( ; i < aItems.size(); i++)
{
- SCROW nNewRow = (pItems[i].nRow += nSize);
- ScBaseCell* pCell = pItems[i].pCell;
+ SCROW nNewRow = (aItems[i].nRow += nSize);
+ ScBaseCell* pCell = aItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
((ScFormulaCell*)pCell)->aPos.SetRow( nNewRow );
if ( nNewRow > MAXROW && !bCountChanged )
@@ -1178,21 +1150,21 @@ void ScColumn::InsertRow( SCROW nStartRow, SCSIZE nSize )
}
}
if ( !bCountChanged )
- aRange.aEnd.SetRow( pItems[nCount-1].nRow );
+ aRange.aEnd.SetRow( aItems[aItems.size()-1].nRow );
pDocument->AreaBroadcastInRange( aRange, aHint );
}
if (bCountChanged)
{
- SCSIZE nDelCount = nCount - nNewCount;
+ SCSIZE nDelCount = aItems.size() - nNewCount;
ScBaseCell** ppDelCells = new ScBaseCell*[nDelCount];
SCROW* pDelRows = new SCROW[nDelCount];
for (i = 0; i < nDelCount; i++)
{
- ppDelCells[i] = pItems[nNewCount+i].pCell;
- pDelRows[i] = pItems[nNewCount+i].nRow;
+ ppDelCells[i] = aItems[nNewCount+i].pCell;
+ pDelRows[i] = aItems[nNewCount+i].nRow;
}
- nCount = nNewCount;
+ aItems.resize( nNewCount );
for (i = 0; i < nDelCount; i++)
{
@@ -1223,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 < nCount; i++)
- if ((pItems[i].nRow >= nRow1) && (pItems[i].nRow <= nRow2))
+ for (i = 0; i < aItems.size(); i++)
+ if ((aItems[i].nRow >= nRow1) && (aItems[i].nRow <= nRow2))
{
if (!nBlockCount)
nStartIndex = i;
@@ -1234,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 ( pItems[i].pCell->GetCellType() == CELLTYPE_FORMULA )
+ if ( aItems[i].pCell->GetCellType() == CELLTYPE_FORMULA )
{
- ScFormulaCell* pFCell = (ScFormulaCell*) pItems[i].pCell;
+ ScFormulaCell* pFCell = (ScFormulaCell*) aItems[i].pCell;
if (pFCell->GetDirty() && pDocument->GetAutoCalc())
pFCell->Interpret();
}
@@ -1250,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( pItems[i].nRow );
- aDestPos.SetRow( pItems[i].nRow );
- ScBaseCell* pNewCell = pItems[i].pCell->CloneWithNote( aOwnPos, *rColumn.pDocument,
aDestPos, nCloneFlags );
+ aOwnPos.SetRow( aItems[i].nRow );
+ aDestPos.SetRow( aItems[i].nRow );
+ ScBaseCell* pNewCell = aItems[i].pCell->CloneWithNote( aOwnPos, *rColumn.pDocument,
aDestPos, nCloneFlags );
rColumn.Append( aDestPos.Row(), pNewCell );
}
}
@@ -1309,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 < nCount; i++)
- if ((pItems[i].nRow >= nRow1) && (pItems[i].nRow <= nRow2))
+ for (i = 0; i < aItems.size(); i++)
+ if ((aItems[i].nRow >= nRow1) && (aItems[i].nRow <= nRow2))
{
if (!nBlockCount)
nStartIndex = i;
@@ -1324,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( pItems[i].nRow );
+ aDestPos.SetRow( aItems[i].nRow );
ScBaseCell* pNew = bAsLink ?
CreateRefCell( rColumn.pDocument, aDestPos, i, nFlags ) :
CloneCell( i, nFlags, *rColumn.pDocument, aDestPos );
@@ -1340,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(pItems[i].nRow);
+ rColumn.Delete(aItems[i].nRow);
else
// non-empty string cell
- rColumn.Insert(pItems[i].nRow, pNew);
+ rColumn.Insert(aItems[i].nRow, pNew);
}
else
- rColumn.Insert(pItems[i].nRow, pNew);
+ rColumn.Insert(aItems[i].nRow, pNew);
}
}
}
@@ -1373,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.nCount;
+ SCSIZE nPosCount = rPosCol.aItems.size();
for (SCSIZE nPosIndex = 0; nPosIndex < nPosCount; nPosIndex++)
{
- aOwnPos.SetRow( rPosCol.pItems[nPosIndex].nRow );
+ aOwnPos.SetRow( rPosCol.aItems[nPosIndex].nRow );
aDestPos.SetRow( aOwnPos.Row() );
SCSIZE nThisIndex;
if ( Search( aDestPos.Row(), nThisIndex ) )
{
- ScBaseCell* pNew = pItems[nThisIndex].pCell->CloneWithNote( aOwnPos, rDestDoc,
aDestPos );
+ ScBaseCell* pNew = aItems[nThisIndex].pCell->CloneWithNote( aOwnPos, rDestDoc,
aDestPos );
rDestCol.Insert( aDestPos.Row(), pNew );
}
}
@@ -1492,19 +1464,7 @@ void ScColumn::MarkScenarioIn( ScMarkData& rDestMark ) const
void ScColumn::SwapCol(ScColumn& rCol)
{
- SCSIZE nTemp;
-
- nTemp = rCol.nCount;
- rCol.nCount = nCount;
- nCount = nTemp;
-
- nTemp = rCol.nLimit;
- rCol.nLimit = nLimit;
- nLimit = nTemp;
-
- ColEntry* pTempItems = rCol.pItems;
- rCol.pItems = pItems;
- pItems = pTempItems;
+ aItems.swap(rCol.aItems);
ScAttrArray* pTempAttr = rCol.pAttrArray;
rCol.pAttrArray = pAttrArray;
@@ -1515,20 +1475,18 @@ void ScColumn::SwapCol(ScColumn& rCol)
rCol.pAttrArray->SetCol(rCol.nCol);
SCSIZE i;
- if (pItems)
- for (i = 0; i < nCount; i++)
- {
- ScFormulaCell* pCell = (ScFormulaCell*) pItems[i].pCell;
- if( pCell->GetCellType() == CELLTYPE_FORMULA)
- pCell->aPos.SetCol(nCol);
- }
- if (rCol.pItems)
- for (i = 0; i < rCol.nCount; i++)
- {
- ScFormulaCell* pCell = (ScFormulaCell*) rCol.pItems[i].pCell;
- if( pCell->GetCellType() == CELLTYPE_FORMULA)
- pCell->aPos.SetCol(rCol.nCol);
- }
+ for (i = 0; i < aItems.size(); i++)
+ {
+ ScFormulaCell* pCell = (ScFormulaCell*) aItems[i].pCell;
+ if( pCell->GetCellType() == CELLTYPE_FORMULA)
+ pCell->aPos.SetCol(nCol);
+ }
+ for (i = 0; i < rCol.aItems.size(); i++)
+ {
+ ScFormulaCell* pCell = (ScFormulaCell*) rCol.aItems[i].pCell;
+ if( pCell->GetCellType() == CELLTYPE_FORMULA)
+ pCell->aPos.SetCol(rCol.nCol);
+ }
}
@@ -1536,19 +1494,19 @@ void ScColumn::MoveTo(SCROW nStartRow, SCROW nEndRow, ScColumn& rCol)
{
pAttrArray->MoveTo(nStartRow, nEndRow, *rCol.pAttrArray);
- if (pItems)
+ if ( !aItems.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 < nCount && pItems[i].nRow <= nEndRow; ++i)
+ for ( ; i < aItems.size() && aItems[i].nRow <= nEndRow; ++i)
{
- SCROW nRow = pItems[i].nRow;
+ SCROW nRow = aItems[i].nRow;
aRows.push_back( nRow);
- rCol.Insert( nRow, pItems[i].pCell);
- if (nRow != pItems[i].nRow)
+ rCol.Insert( nRow, aItems[i].pCell);
+ if (nRow != aItems[i].nRow)
{ // Listener inserted
bConsecutive = false;
Search( nRow, i);
@@ -1568,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 < nCount; ++it,
+ it != aRows.end() && nStopPos < aItems.size(); ++it,
++nStopPos)
{
- if (!bFirst && *it != pItems[nStopPos].nRow)
+ if (!bFirst && *it != aItems[nStopPos].nRow)
{
aEntries.push_back( PosPair(nStartPos, nStopPos));
bFirst = true;
@@ -1598,19 +1556,15 @@ void ScColumn::MoveTo(SCROW nStartRow, SCROW nEndRow, ScColumn& rCol)
nStartPos = (*it).first;
nStopPos = (*it).second;
for (i=nStartPos; i<nStopPos; ++i)
- pItems[i].pCell = pNoteCell;
+ aItems[i].pCell = pNoteCell;
for (i=nStartPos; i<nStopPos; ++i)
{
- rAddress.SetRow( pItems[i].nRow );
+ rAddress.SetRow( aItems[i].nRow );
pDocument->AreaBroadcast( aHint );
}
- nCount -= nStopPos - nStartPos;
- memmove( &pItems[nStartPos], &pItems[nStopPos],
- (nCount - nStartPos) * sizeof(ColEntry) );
+ aItems.erase(aItems.begin() + nStartPos, aItems.begin() + nStopPos - 1);
}
pNoteCell->Delete();
- pItems[nCount].nRow = 0;
- pItems[nCount].pCell = NULL;
}
}
}
@@ -1621,7 +1575,7 @@ bool ScColumn::UpdateReference( UpdateRefMode eUpdateRefMode, SCCOL nCol1,
SCROW
ScDocument* pUndoDoc )
{
bool bUpdated = false;
- if (pItems)
+ if ( !aItems.empty() )
{
ScRange aRange( ScAddress( nCol1, nRow1, nTab1 ),
ScAddress( nCol2, nRow2, nTab2 ) );
@@ -1630,7 +1584,7 @@ bool ScColumn::UpdateReference( UpdateRefMode eUpdateRefMode, SCCOL nCol1,
SCROW
SCSIZE nIndex;
if ( Search( nRow1, nIndex ) )
{
- ScFormulaCell* pCell = (ScFormulaCell*) pItems[nIndex].pCell;
+ ScFormulaCell* pCell = (ScFormulaCell*) aItems[nIndex].pCell;
if( pCell->GetCellType() == CELLTYPE_FORMULA)
bUpdated |= pCell->UpdateReference(
eUpdateRefMode, aRange, nDx, nDy, nDz, pUndoDoc );
@@ -1646,17 +1600,17 @@ bool ScColumn::UpdateReference( UpdateRefMode eUpdateRefMode, SCCOL nCol1,
SCROW
{
SCSIZE i;
Search( nRow1, i );
- for ( ; i < nCount; i++ )
+ for ( ; i < aItems.size(); i++ )
{
- SCROW nRow = pItems[i].nRow;
+ SCROW nRow = aItems[i].nRow;
if ( nRow > nRow2 )
break;
- ScBaseCell* pCell = pItems[i].pCell;
+ ScBaseCell* pCell = aItems[i].pCell;
if( pCell->GetCellType() == CELLTYPE_FORMULA)
{
bUpdated |= ((ScFormulaCell*)pCell)->UpdateReference(
eUpdateRefMode, aRange, nDx, nDy, nDz, pUndoDoc );
- if ( nRow != pItems[i].nRow )
+ if ( nRow != aItems[i].nRow )
Search( nRow, i ); // Listener removed/inserted?
}
}
@@ -1664,18 +1618,18 @@ bool ScColumn::UpdateReference( UpdateRefMode eUpdateRefMode, SCCOL nCol1,
SCROW
else
{
SCSIZE i = 0;
- for ( ; i < nCount; i++ )
+ for ( ; i < aItems.size(); i++ )
{
- ScBaseCell* pCell = pItems[i].pCell;
+ ScBaseCell* pCell = aItems[i].pCell;
if( pCell->GetCellType() == CELLTYPE_FORMULA)
{
- SCROW nRow = pItems[i].nRow;
+ SCROW nRow = aItems[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 != pItems[i].nRow )
+ if ( nRow != aItems[i].nRow )
Search( nRow, i ); // Listener removed/inserted?
}
}
@@ -1689,15 +1643,15 @@ bool ScColumn::UpdateReference( UpdateRefMode eUpdateRefMode, SCCOL nCol1,
SCROW
void ScColumn::UpdateTranspose( const ScRange& rSource, const ScAddress& rDest,
ScDocument* pUndoDoc )
{
- if (pItems)
- for (SCSIZE i=0; i<nCount; i++)
+ if ( !aItems.empty() )
+ for (SCSIZE i=0; i<aItems.size(); i++)
{
- ScBaseCell* pCell = pItems[i].pCell;
+ ScBaseCell* pCell = aItems[i].pCell;
if (pCell->GetCellType() == CELLTYPE_FORMULA)
{
- SCROW nRow = pItems[i].nRow;
+ SCROW nRow = aItems[i].nRow;
((ScFormulaCell*)pCell)->UpdateTranspose( rSource, rDest, pUndoDoc );
- if ( nRow != pItems[i].nRow )
+ if ( nRow != aItems[i].nRow )
Search( nRow, i ); // Listener geloescht/eingefuegt?
}
}
@@ -1706,15 +1660,15 @@ void ScColumn::UpdateTranspose( const ScRange& rSource, const ScAddress&
rDest,
void ScColumn::UpdateGrow( const ScRange& rArea, SCCOL nGrowX, SCROW nGrowY )
{
- if (pItems)
- for (SCSIZE i=0; i<nCount; i++)
+ if ( !aItems.empty() )
+ for (SCSIZE i=0; i<aItems.size(); i++)
{
- ScBaseCell* pCell = pItems[i].pCell;
+ ScBaseCell* pCell = aItems[i].pCell;
if (pCell->GetCellType() == CELLTYPE_FORMULA)
{
- SCROW nRow = pItems[i].nRow;
+ SCROW nRow = aItems[i].nRow;
((ScFormulaCell*)pCell)->UpdateGrow( rArea, nGrowX, nGrowY );
- if ( nRow != pItems[i].nRow )
+ if ( nRow != aItems[i].nRow )
Search( nRow, i ); // Listener geloescht/eingefuegt?
}
}
@@ -1728,22 +1682,22 @@ void ScColumn::UpdateInsertTab( SCTAB nTable, SCTAB nNewSheets )
nTab += nNewSheets;
pAttrArray->SetTab(nTab);
}
- if( pItems )
+ if ( !aItems.empty() )
UpdateInsertTabOnlyCells( nTable, nNewSheets );
}
void ScColumn::UpdateInsertTabOnlyCells( SCTAB nTable, SCTAB nNewSheets )
{
- if (pItems)
- for (SCSIZE i = 0; i < nCount; i++)
+ if ( !aItems.empty() )
+ for (SCSIZE i = 0; i < aItems.size(); i++)
{
- ScFormulaCell* pCell = (ScFormulaCell*) pItems[i].pCell;
+ ScFormulaCell* pCell = (ScFormulaCell*) aItems[i].pCell;
if( pCell->GetCellType() == CELLTYPE_FORMULA)
{
- SCROW nRow = pItems[i].nRow;
+ SCROW nRow = aItems[i].nRow;
pCell->UpdateInsertTab(nTable, nNewSheets);
- if ( nRow != pItems[i].nRow )
+ if ( nRow != aItems[i].nRow )
Search( nRow, i ); // Listener geloescht/eingefuegt?
}
}
@@ -1752,15 +1706,15 @@ void ScColumn::UpdateInsertTabOnlyCells( SCTAB nTable, SCTAB nNewSheets )
void ScColumn::UpdateInsertTabAbs(SCTAB nTable)
{
- if (pItems)
- for (SCSIZE i = 0; i < nCount; i++)
+ if ( !aItems.empty() )
+ for (SCSIZE i = 0; i < aItems.size(); i++)
{
- ScFormulaCell* pCell = (ScFormulaCell*) pItems[i].pCell;
+ ScFormulaCell* pCell = (ScFormulaCell*) aItems[i].pCell;
if( pCell->GetCellType() == CELLTYPE_FORMULA)
{
- SCROW nRow = pItems[i].nRow;
+ SCROW nRow = aItems[i].nRow;
pCell->UpdateInsertTabAbs(nTable);
- if ( nRow != pItems[i].nRow )
+ if ( nRow != aItems[i].nRow )
Search( nRow, i ); // Listener geloescht/eingefuegt?
}
}
@@ -1775,19 +1729,19 @@ void ScColumn::UpdateDeleteTab( SCTAB nTable, bool bIsMove, ScColumn*
pRefUndo,
pAttrArray->SetTab(nTab);
}
- if (pItems)
- for (SCSIZE i = 0; i < nCount; i++)
- if ( pItems[i].pCell->GetCellType() == CELLTYPE_FORMULA )
+ if ( !aItems.empty() )
+ for (SCSIZE i = 0; i < aItems.size(); i++)
+ if ( aItems[i].pCell->GetCellType() == CELLTYPE_FORMULA )
{
- SCROW nRow = pItems[i].nRow;
- ScFormulaCell* pOld = (ScFormulaCell*)pItems[i].pCell;
+ SCROW nRow = aItems[i].nRow;
+ ScFormulaCell* pOld = (ScFormulaCell*)aItems[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 != pItems[i].nRow )
+ if ( nRow != aItems[i].nRow )
Search( nRow, i ); // Listener geloescht/eingefuegt?
if (pRefUndo)
@@ -1805,15 +1759,15 @@ void ScColumn::UpdateMoveTab( SCTAB nOldPos, SCTAB nNewPos, SCTAB nTabNo )
{
nTab = nTabNo;
pAttrArray->SetTab( nTabNo );
- if (pItems)
- for (SCSIZE i = 0; i < nCount; i++)
+ if ( !aItems.empty() )
+ for (SCSIZE i = 0; i < aItems.size(); i++)
{
- ScFormulaCell* pCell = (ScFormulaCell*) pItems[i].pCell;
+ ScFormulaCell* pCell = (ScFormulaCell*) aItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
{
- SCROW nRow = pItems[i].nRow;
+ SCROW nRow = aItems[i].nRow;
pCell->UpdateMoveTab( nOldPos, nNewPos, nTabNo );
- if ( nRow != pItems[i].nRow )
+ if ( nRow != aItems[i].nRow )
Search( nRow, i ); // Listener geloescht/eingefuegt?
}
}
@@ -1822,15 +1776,15 @@ void ScColumn::UpdateMoveTab( SCTAB nOldPos, SCTAB nNewPos, SCTAB nTabNo )
void ScColumn::UpdateCompile( bool bForceIfNameInUse )
{
- if (pItems)
- for (SCSIZE i = 0; i < nCount; i++)
+ if ( !aItems.empty() )
+ for (SCSIZE i = 0; i < aItems.size(); i++)
{
- ScFormulaCell* p = (ScFormulaCell*) pItems[i].pCell;
+ ScFormulaCell* p = (ScFormulaCell*) aItems[i].pCell;
if( p->GetCellType() == CELLTYPE_FORMULA )
{
- SCROW nRow = pItems[i].nRow;
+ SCROW nRow = aItems[i].nRow;
p->UpdateCompile( bForceIfNameInUse );
- if ( nRow != pItems[i].nRow )
+ if ( nRow != aItems[i].nRow )
Search( nRow, i ); // Listener geloescht/eingefuegt?
}
}
@@ -1841,10 +1795,10 @@ void ScColumn::SetTabNo(SCTAB nNewTab)
{
nTab = nNewTab;
pAttrArray->SetTab( nNewTab );
- if (pItems)
- for (SCSIZE i = 0; i < nCount; i++)
+ if ( !aItems.empty() )
+ for (SCSIZE i = 0; i < aItems.size(); i++)
{
- ScFormulaCell* p = (ScFormulaCell*) pItems[i].pCell;
+ ScFormulaCell* p = (ScFormulaCell*) aItems[i].pCell;
if( p->GetCellType() == CELLTYPE_FORMULA )
p->aPos.SetTab( nNewTab );
}
@@ -1852,27 +1806,27 @@ void ScColumn::SetTabNo(SCTAB nNewTab)
void ScColumn::FindRangeNamesInUse(SCROW nRow1, SCROW nRow2, std::set<sal_uInt16>& rIndexes) const
{
- if (pItems)
- for (SCSIZE i = 0; i < nCount; i++)
- if ((pItems[i].nRow >= nRow1) &&
- (pItems[i].nRow <= nRow2) &&
- (pItems[i].pCell->GetCellType() == CELLTYPE_FORMULA))
- ((ScFormulaCell*)pItems[i].pCell)->FindRangeNamesInUse(rIndexes);
+ 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);
}
void ScColumn::ReplaceRangeNamesInUse(SCROW nRow1, SCROW nRow2,
const ScRangeData::IndexMap& rMap )
{
- if (pItems)
- for (SCSIZE i = 0; i < nCount; i++)
+ if ( !aItems.empty() )
+ for (SCSIZE i = 0; i < aItems.size(); i++)
{
- if ((pItems[i].nRow >= nRow1) &&
- (pItems[i].nRow <= nRow2) &&
- (pItems[i].pCell->GetCellType() == CELLTYPE_FORMULA))
+ if ((aItems[i].nRow >= nRow1) &&
+ (aItems[i].nRow <= nRow2) &&
+ (aItems[i].pCell->GetCellType() == CELLTYPE_FORMULA))
{
- SCROW nRow = pItems[i].nRow;
- ((ScFormulaCell*)pItems[i].pCell)->ReplaceRangeNamesInUse( rMap );
- if ( nRow != pItems[i].nRow )
+ SCROW nRow = aItems[i].nRow;
+ ((ScFormulaCell*)aItems[i].pCell)->ReplaceRangeNamesInUse( rMap );
+ if ( nRow != aItems[i].nRow )
Search( nRow, i ); // Listener geloescht/eingefuegt?
}
}
@@ -1880,9 +1834,9 @@ void ScColumn::ReplaceRangeNamesInUse(SCROW nRow1, SCROW nRow2,
void ScColumn::SetDirtyVar()
{
- for (SCSIZE i=0; i<nCount; i++)
+ for (SCSIZE i=0; i<aItems.size(); i++)
{
- ScFormulaCell* p = (ScFormulaCell*) pItems[i].pCell;
+ ScFormulaCell* p = (ScFormulaCell*) aItems[i].pCell;
if( p->GetCellType() == CELLTYPE_FORMULA )
p->SetDirtyVar();
}
@@ -1894,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<nCount; i++)
+ for (SCSIZE i=0; i<aItems.size(); i++)
{
- ScFormulaCell* p = (ScFormulaCell*) pItems[i].pCell;
+ ScFormulaCell* p = (ScFormulaCell*) aItems[i].pCell;
if( p->GetCellType() == CELLTYPE_FORMULA )
{
p->SetDirtyVar();
@@ -1910,7 +1864,7 @@ void ScColumn::SetDirty()
void ScColumn::SetDirty( const ScRange& rRange )
{ // broadcastet alles innerhalb eines Range, mit FormulaTrack
- if ( !pItems || !nCount )
+ if ( aItems.empty() )
return ;
bool bOldAutoCalc = pDocument->GetAutoCalc();
pDocument->SetAutoCalc( false ); // Mehrfachberechnungen vermeiden
@@ -1920,9 +1874,9 @@ void ScColumn::SetDirty( const ScRange& rRange )
SCROW nRow;
SCSIZE nIndex;
Search( rRange.aStart.Row(), nIndex );
- while ( nIndex < nCount && (nRow = pItems[nIndex].nRow) <= nRow2 )
+ while ( nIndex < aItems.size() && (nRow = aItems[nIndex].nRow) <= nRow2 )
{
- ScBaseCell* pCell = pItems[nIndex].pCell;
+ ScBaseCell* pCell = aItems[nIndex].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
((ScFormulaCell*)pCell)->SetDirty();
else
@@ -1939,7 +1893,7 @@ void ScColumn::SetDirty( const ScRange& rRange )
void ScColumn::SetTableOpDirty( const ScRange& rRange )
{
- if ( !pItems || !nCount )
+ if ( aItems.empty() )
return ;
bool bOldAutoCalc = pDocument->GetAutoCalc();
pDocument->SetAutoCalc( false ); // no multiple recalculation
@@ -1949,9 +1903,9 @@ void ScColumn::SetTableOpDirty( const ScRange& rRange )
SCROW nRow;
SCSIZE nIndex;
Search( rRange.aStart.Row(), nIndex );
- while ( nIndex < nCount && (nRow = pItems[nIndex].nRow) <= nRow2 )
+ while ( nIndex < aItems.size() && (nRow = aItems[nIndex].nRow) <= nRow2 )
{
- ScBaseCell* pCell = pItems[nIndex].pCell;
+ ScBaseCell* pCell = aItems[nIndex].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
((ScFormulaCell*)pCell)->SetTableOpDirty();
else
@@ -1970,9 +1924,9 @@ void ScColumn::SetDirtyAfterLoad()
{
bool bOldAutoCalc = pDocument->GetAutoCalc();
pDocument->SetAutoCalc( false ); // Mehrfachberechnungen vermeiden
- for (SCSIZE i=0; i<nCount; i++)
+ for (SCSIZE i=0; i<aItems.size(); i++)
{
- ScFormulaCell* p = (ScFormulaCell*) pItems[i].pCell;
+ ScFormulaCell* p = (ScFormulaCell*) aItems[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
@@ -2003,9 +1957,9 @@ void ScColumn::SetRelNameDirty()
{
bool bOldAutoCalc = pDocument->GetAutoCalc();
pDocument->SetAutoCalc( false ); // Mehrfachberechnungen vermeiden
- for (SCSIZE i=0; i<nCount; i++)
+ for (SCSIZE i=0; i<aItems.size(); i++)
{
- ScFormulaCell* p = (ScFormulaCell*) pItems[i].pCell;
+ ScFormulaCell* p = (ScFormulaCell*) aItems[i].pCell;
if( p->GetCellType() == CELLTYPE_FORMULA && p->HasRelNameReference() )
p->SetDirty();
}
@@ -2015,10 +1969,10 @@ void ScColumn::SetRelNameDirty()
void ScColumn::CalcAll()
{
- if (pItems)
- for (SCSIZE i=0; i<nCount; i++)
+ if ( !aItems.empty() )
+ for (SCSIZE i=0; i<aItems.size(); i++)
{
- ScBaseCell* pCell = pItems[i].pCell;
+ ScBaseCell* pCell = aItems[i].pCell;
if (pCell->GetCellType() == CELLTYPE_FORMULA)
{
#if OSL_DEBUG_LEVEL > 1
@@ -2042,19 +1996,19 @@ void ScColumn::CalcAll()
void ScColumn::CompileAll()
{
- if (pItems)
- for (SCSIZE i = 0; i < nCount; i++)
+ if ( !aItems.empty() )
+ for (SCSIZE i = 0; i < aItems.size(); i++)
{
- ScBaseCell* pCell = pItems[i].pCell;
+ ScBaseCell* pCell = aItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
{
- SCROW nRow = pItems[i].nRow;
+ SCROW nRow = aItems[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 != pItems[i].nRow )
+ if ( nRow != aItems[i].nRow )
Search( nRow, i ); // Listener geloescht/eingefuegt?
}
}
@@ -2063,15 +2017,15 @@ void ScColumn::CompileAll()
void ScColumn::CompileXML( ScProgress& rProgress )
{
- if (pItems)
- for (SCSIZE i = 0; i < nCount; i++)
+ if ( !aItems.empty() )
+ for (SCSIZE i = 0; i < aItems.size(); i++)
{
- ScBaseCell* pCell = pItems[i].pCell;
+ ScBaseCell* pCell = aItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
{
- SCROW nRow = pItems[i].nRow;
+ SCROW nRow = aItems[i].nRow;
((ScFormulaCell*)pCell)->CompileXML( rProgress );
- if ( nRow != pItems[i].nRow )
+ if ( nRow != aItems[i].nRow )
Search( nRow, i ); // Listener geloescht/eingefuegt?
}
}
@@ -2080,10 +2034,10 @@ void ScColumn::CompileXML( ScProgress& rProgress )
void ScColumn::CalcAfterLoad()
{
- if (pItems)
- for (SCSIZE i = 0; i < nCount; i++)
+ if ( !aItems.empty() )
+ for (SCSIZE i = 0; i < aItems.size(); i++)
{
- ScBaseCell* pCell = pItems[i].pCell;
+ ScBaseCell* pCell = aItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
((ScFormulaCell*)pCell)->CalcAfterLoad();
}
@@ -2092,13 +2046,13 @@ void ScColumn::CalcAfterLoad()
void ScColumn::ResetChanged( SCROW nStartRow, SCROW nEndRow )
{
- if (pItems)
+ if ( !aItems.empty() )
{
SCSIZE nIndex;
Search(nStartRow,nIndex);
- while (nIndex<nCount && pItems[nIndex].nRow <= nEndRow)
+ while (nIndex<aItems.size() && aItems[nIndex].nRow <= nEndRow)
{
- ScBaseCell* pCell = pItems[nIndex].pCell;
+ ScBaseCell* pCell = aItems[nIndex].pCell;
if (pCell->GetCellType() == CELLTYPE_FORMULA)
((ScFormulaCell*)pCell)->ResetChanged();
++nIndex;
@@ -2114,9 +2068,9 @@ bool ScColumn::HasEditCells(SCROW nStartRow, SCROW nEndRow, SCROW& rFirst)
const
SCROW nRow = 0;
SCSIZE nIndex;
Search(nStartRow,nIndex);
- while ( (nIndex < nCount) ? ((nRow=pItems[nIndex].nRow) <= nEndRow) : false )
+ while ( (nIndex < aItems.size()) ? ((nRow=aItems[nIndex].nRow) <= nEndRow) : false )
{
- ScBaseCell* pCell = pItems[nIndex].pCell;
+ ScBaseCell* pCell = aItems[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 22d3da4..5dd5685 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 = pItems[nIndex].pCell;
+ ScBaseCell* pCell = aItems[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 (nCount == 0)
+ if ( aItems.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 >= nCount)
+ if (nIndex >= aItems.size())
// Out-of-bound reached. No need to keep going.
break;
- ScBaseCell* pCell = pItems[nIndex].pCell;
+ ScBaseCell* pCell = aItems[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 = pItems[nIndex].nRow;
+ SCROW nRow = aItems[nIndex].nRow;
- sal_uInt8 nScript = pDocument->GetScriptType( nCol, nRow, nTab, pItems[nIndex].pCell );
+ sal_uInt8 nScript = pDocument->GetScriptType( nCol, nRow, nTab, aItems[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 < nCount && (nRow=pItems[nIndex].nRow) <= nEnd )
+ while ( nIndex < aItems.size() && (nRow=aItems[nIndex].nRow) <= nEnd )
{
- sal_uInt8 nScript = pDocument->GetScriptType( nCol, nRow, nTab,
pItems[nIndex].pCell );
+ sal_uInt8 nScript = pDocument->GetScriptType( nCol, nRow, nTab,
aItems[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 < nCount) ? ((nRow=pItems[nIndex].nRow) <= nEnd) : false )
+ while ( (nIndex < aItems.size()) ? ((nRow=aItems[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<nCount; i++)
- if ( pItems[i].pCell->GetCellType() == CELLTYPE_EDIT )
+ for (SCSIZE i=0; i<aItems.size(); i++)
+ if ( aItems[i].pCell->GetCellType() == CELLTYPE_EDIT )
{
- ScEditCell* pOldCell = (ScEditCell*) pItems[i].pCell;
+ ScEditCell* pOldCell = (ScEditCell*) aItems[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() );
- pItems[i].pCell = pNewCell;
+ aItems[i].pCell = pNewCell;
delete pOldCell;
}
}
@@ -949,10 +949,10 @@ void ScColumn::RemoveEditAttribs( SCROW nStartRow, SCROW nEndRow )
SCSIZE i;
Search( nStartRow, i );
- for (; i<nCount && pItems[i].nRow <= nEndRow; i++)
- if ( pItems[i].pCell->GetCellType() == CELLTYPE_EDIT )
+ for (; i<aItems.size() && aItems[i].nRow <= nEndRow; i++)
+ if ( aItems[i].pCell->GetCellType() == CELLTYPE_EDIT )
{
- ScEditCell* pOldCell = (ScEditCell*) pItems[i].pCell;
+ ScEditCell* pOldCell = (ScEditCell*) aItems[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() );
- pItems[i].pCell = pNewCell;
+ aItems[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 (pItems)
- for (SCSIZE i = 0; i < nCount; i++)
- if ( pItems[i].pCell->GetCellType() == CELLTYPE_FORMULA )
- if (((ScFormulaCell*)pItems[i].pCell)->TestTabRefAbs(nTable))
+ 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))
bRet = true;
return bRet;
}
@@ -1042,12 +1042,12 @@ ScColumnIterator::~ScColumnIterator()
bool ScColumnIterator::Next( SCROW& rRow, ScBaseCell*& rpCell )
{
- if ( nPos < pColumn->nCount )
+ if ( nPos < pColumn->aItems.size() )
{
- rRow = pColumn->pItems[nPos].nRow;
+ rRow = pColumn->aItems[nPos].nRow;
if ( rRow <= nBottom )
{
- rpCell = pColumn->pItems[nPos].pCell;
+ rpCell = pColumn->aItems[nPos].pCell;
++nPos;
return true;
}
@@ -1103,10 +1103,10 @@ bool ScMarkedDataIter::Next( SCSIZE& rIndex )
bAll = false; // nur beim ersten Versuch
}
- if ( nPos >= pColumn->nCount )
+ if ( nPos >= pColumn->aItems.size() )
return false;
- if ( pColumn->pItems[nPos].nRow <= nBottom )
+ if ( pColumn->aItems[nPos].nRow <= nBottom )
bFound = true;
else
bNext = true;
@@ -1122,20 +1122,20 @@ bool ScMarkedDataIter::Next( SCSIZE& rIndex )
bool ScColumn::IsEmptyData() const
{
- return (nCount == 0);
+ return (aItems.empty());
}
bool ScColumn::IsEmptyVisData(bool bNotes) const
{
- if (!pItems || nCount == 0)
+ if ( aItems.empty() )
return true;
else
{
bool bVisData = false;
SCSIZE i;
- for (i=0; i<nCount && !bVisData; i++)
+ for (i=0; i<aItems.size() && !bVisData; i++)
{
- ScBaseCell* pCell = pItems[i].pCell;
+ ScBaseCell* pCell = aItems[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 < nCount && pItems[nIndex].nRow <= nEndRow )
+ while ( nIndex < aItems.size() && aItems[nIndex].nRow <= nEndRow )
{
- if ( pItems[nIndex].nRow >= nStartRow &&
- pItems[nIndex].pCell->GetCellType() != CELLTYPE_NOTE )
+ if ( aItems[nIndex].nRow >= nStartRow &&
+ aItems[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 (pItems)
+ if ( !aItems.empty() )
{
SCSIZE i;
bool bFound = false;
- for (i=nCount; i>0 && !bFound; )
+ for (i=aItems.size(); i>0 && !bFound; )
{
--i;
- ScBaseCell* pCell = pItems[i].pCell;
+ ScBaseCell* pCell = aItems[i].pCell;
if ( pCell->GetCellType() != CELLTYPE_NOTE || (bNotes && pCell->HasNote()) )
{
bFound = true;
- nRet = pItems[i].nRow;
+ nRet = aItems[i].nRow;
}
}
}
@@ -1186,17 +1186,17 @@ SCROW ScColumn::GetLastVisDataPos(bool bNotes) const
SCROW ScColumn::GetFirstVisDataPos(bool bNotes) const
{
SCROW nRet = 0;
- if (pItems)
+ if ( !aItems.empty() )
{
SCSIZE i;
bool bFound = false;
- for (i=0; i<nCount && !bFound; i++)
+ for (i=0; i<aItems.size() && !bFound; i++)
{
- ScBaseCell* pCell = pItems[i].pCell;
+ ScBaseCell* pCell = aItems[i].pCell;
if ( pCell->GetCellType() != CELLTYPE_NOTE || (bNotes && pCell->HasNote()) )
{
bFound = true;
- nRet = pItems[i].nRow;
+ nRet = aItems[i].nRow;
}
}
}
@@ -1207,7 +1207,7 @@ bool ScColumn::HasVisibleDataAt(SCROW nRow) const
{
SCSIZE nIndex;
if (Search(nRow, nIndex))
- if (!pItems[nIndex].pCell->IsBlank())
+ if (!aItems[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 ( nCount == 0 || !pItems )
+ if ( aItems.empty() )
return true;
SCSIZE nIndex;
Search( nStartRow, nIndex );
- while ( nIndex < nCount && pItems[nIndex].nRow <= nEndRow )
+ while ( nIndex < aItems.size() && aItems[nIndex].nRow <= nEndRow )
{
- if ( !pItems[nIndex].pCell->IsBlank( bIgnoreNotes ) ) // found a cell
+ if ( !aItems[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 (pItems && (nCount > 0))
+ if ( !aItems.empty() )
{
if (eDir == DIR_BOTTOM)
{
- i = nCount;
+ i = aItems.size();
while (!bFound && (i > 0))
{
i--;
- if ( pItems[i].nRow < nStartRow )
+ if ( aItems[i].nRow < nStartRow )
break;
- bFound = pItems[i].nRow <= nEndRow && !pItems[i].pCell->IsBlank();
+ bFound = aItems[i].nRow <= nEndRow && !aItems[i].pCell->IsBlank();
}
if (bFound)
- nLines = static_cast<SCSIZE>(nEndRow - pItems[i].nRow);
+ nLines = static_cast<SCSIZE>(nEndRow - aItems[i].nRow);
else
nLines = static_cast<SCSIZE>(nEndRow - nStartRow);
}
else if (eDir == DIR_TOP)
{
i = 0;
- while (!bFound && (i < nCount))
+ while (!bFound && (i < aItems.size()))
{
- if ( pItems[i].nRow > nEndRow )
+ if ( aItems[i].nRow > nEndRow )
break;
- bFound = pItems[i].nRow >= nStartRow && !pItems[i].pCell->IsBlank();
+ bFound = aItems[i].nRow >= nStartRow && !aItems[i].pCell->IsBlank();
i++;
}
if (bFound)
- nLines = static_cast<SCSIZE>(pItems[i-1].nRow - nStartRow);
+ nLines = static_cast<SCSIZE>(aItems[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 (nCount)
- return pItems[0].nRow;
+ if ( !aItems.empty() )
+ return aItems[0].nRow;
else
return 0;
}
SCROW ScColumn::GetLastDataPos() const
{
- if (nCount)
- return pItems[nCount-1].nRow;
+ if ( !aItems.empty() )
+ return aItems[aItems.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 = nCount;
+ SCSIZE i = aItems.size();
while (!bFound && (i > 0))
{
--i;
- bFound = (pItems[i].nRow < rRow);
+ bFound = (aItems[i].nRow < rRow);
if (bFound)
- rRow = pItems[i].nRow;
+ rRow = aItems[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 < nCount );
+ bool bMore = ( nIndex < aItems.size() );
if ( bMore )
- rRow = pItems[nIndex].nRow;
+ rRow = aItems[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 && pItems[nIndex].pCell->IsBlank())
+ if (bThere && aItems[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<nCount-1)
+ if (nIndex<aItems.size()-1)
{
++nIndex;
- while (nIndex<nCount-1 && pItems[nIndex].nRow==nLast+1
- && !pItems[nIndex].pCell->IsBlank())
+ while (nIndex<aItems.size()-1 && aItems[nIndex].nRow==nLast+1
+ && !aItems[nIndex].pCell->IsBlank())
{
++nIndex;
++nLast;
}
- if (nIndex==nCount-1)
- if (pItems[nIndex].nRow==nLast+1 && !pItems[nIndex].pCell->IsBlank())
+ if (nIndex==aItems.size()-1)
+ if (aItems[nIndex].nRow==nLast+1 && !aItems[nIndex].pCell->IsBlank())
++nLast;
}
}
@@ -1362,14 +1362,14 @@ void ScColumn::FindDataAreaPos(SCROW& rRow, long nMovY) const
if (nIndex>0)
{
--nIndex;
- while (nIndex>0 && pItems[nIndex].nRow+1==nLast
- && !pItems[nIndex].pCell->IsBlank())
+ while (nIndex>0 && aItems[nIndex].nRow+1==nLast
+ && !aItems[nIndex].pCell->IsBlank())
{
--nIndex;
--nLast;
}
if (nIndex==0)
- if (pItems[nIndex].nRow+1==nLast && !pItems[nIndex].pCell->IsBlank())
+ if (aItems[nIndex].nRow+1==nLast && !aItems[nIndex].pCell->IsBlank())
--nLast;
}
}
@@ -1386,19 +1386,19 @@ void ScColumn::FindDataAreaPos(SCROW& rRow, long nMovY) const
{
if (bForward)
{
- while (nIndex<nCount && pItems[nIndex].pCell->IsBlank())
+ while (nIndex<aItems.size() && aItems[nIndex].pCell->IsBlank())
++nIndex;
- if (nIndex<nCount)
- rRow = pItems[nIndex].nRow;
+ if (nIndex<aItems.size())
+ rRow = aItems[nIndex].nRow;
else
rRow = MAXROW;
}
else
{
- while (nIndex>0 && pItems[nIndex-1].pCell->IsBlank())
+ while (nIndex>0 && aItems[nIndex-1].pCell->IsBlank())
--nIndex;
if (nIndex>0)
- rRow = pItems[nIndex-1].nRow;
+ rRow = aItems[nIndex-1].nRow;
else
rRow = 0;
}
@@ -1412,7 +1412,7 @@ bool ScColumn::HasDataAt(SCROW nRow) const
SCSIZE nIndex;
if (Search(nRow, nIndex))
- if (!pItems[nIndex].pCell->IsBlank())
+ if (!aItems[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 < nCount) ? ((nRow=pItems[nIndex].nRow) <= nEndRow) : false )
+ while ( (nIndex < aItems.size()) ? ((nRow=aItems[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 = pItems[nIndex].pCell;
+ pCell = aItems[nIndex].pCell;
pBC = pCell->GetBroadcaster();
}
else
@@ -1509,7 +1509,7 @@ void ScColumn::MoveListeners( SvtBroadcaster& rSource, SCROW nDestRow )
SCSIZE nIndex;
if (Search(nDestRow,nIndex))
{
- pCell = pItems[nIndex].pCell;
+ pCell = aItems[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 = pItems[nIndex].pCell;
+ ScBaseCell* pCell = aItems[nIndex].pCell;
SvtBroadcaster* pBC = pCell->GetBroadcaster();
if (pBC)
{
@@ -1559,10 +1559,10 @@ void ScColumn::EndListening( SvtListener& rLst, SCROW nRow )
void ScColumn::CompileDBFormula()
{
- if (pItems)
- for (SCSIZE i = 0; i < nCount; i++)
+ if ( !aItems.empty() )
+ for (SCSIZE i = 0; i < aItems.size(); i++)
{
- ScBaseCell* pCell = pItems[i].pCell;
+ ScBaseCell* pCell = aItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
((ScFormulaCell*) pCell)->CompileDBFormula();
}
@@ -1570,10 +1570,10 @@ void ScColumn::CompileDBFormula()
void ScColumn::CompileDBFormula( bool bCreateFormulaString )
{
- if (pItems)
- for (SCSIZE i = 0; i < nCount; i++)
+ if ( !aItems.empty() )
+ for (SCSIZE i = 0; i < aItems.size(); i++)
{
- ScBaseCell* pCell = pItems[i].pCell;
+ ScBaseCell* pCell = aItems[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 (pItems)
- for (SCSIZE i = 0; i < nCount; i++)
+ if ( !aItems.empty() )
+ for (SCSIZE i = 0; i < aItems.size(); i++)
{
- ScBaseCell* pCell = pItems[i].pCell;
+ ScBaseCell* pCell = aItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
((ScFormulaCell*) pCell)->CompileNameFormula( bCreateFormulaString );
}
@@ -1592,10 +1592,10 @@ void ScColumn::CompileNameFormula( bool bCreateFormulaString )
void ScColumn::CompileColRowNameFormula()
{
- if (pItems)
- for (SCSIZE i = 0; i < nCount; i++)
+ if ( !aItems.empty() )
+ for (SCSIZE i = 0; i < aItems.size(); i++)
{
- ScBaseCell* pCell = pItems[i].pCell;
+ ScBaseCell* pCell = aItems[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 = pItems[nIndex].nRow;
+ SCROW nRow = aItems[nIndex].nRow;
bool bRowHidden = rHiddenRows.getValue(nRow);
if ( !bRowHidden )
if ( !bDoExclude || nRow < nExStartRow || nRow > nExEndRow )
- lcl_UpdateSubTotal( rData, pItems[nIndex].pCell );
+ lcl_UpdateSubTotal( rData, aItems[nIndex].pCell );
}
}
@@ -1705,12 +1705,12 @@ void ScColumn::UpdateAreaFunction( ScFunctionData& rData,
{
SCSIZE nIndex;
Search( nStartRow, nIndex );
- while ( nIndex<nCount && pItems[nIndex].nRow<=nEndRow )
+ while ( nIndex<aItems.size() && aItems[nIndex].nRow<=nEndRow )
{
- SCROW nRow = pItems[nIndex].nRow;
+ SCROW nRow = aItems[nIndex].nRow;
bool bRowHidden = rHiddenRows.getValue(nRow);
if ( !bRowHidden )
- lcl_UpdateSubTotal( rData, pItems[nIndex].pCell );
+ lcl_UpdateSubTotal( rData, aItems[nIndex].pCell );
++nIndex;
}
}
@@ -1721,9 +1721,9 @@ sal_uInt32 ScColumn::GetWeightedCount() const
// Notizen werden nicht gezaehlt
- for (SCSIZE i=0; i<nCount; i++)
+ for (SCSIZE i=0; i<aItems.size(); i++)
{
- ScBaseCell* pCell = pItems[i].pCell;
+ ScBaseCell* pCell = aItems[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<nCount; i++)
+ for (SCSIZE i=0; i<aItems.size(); i++)
{
- ScBaseCell* pCell = pItems[i].pCell;
+ ScBaseCell* pCell = aItems[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 fbeb951..bd1fa39 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 (pItems && nCount>0)
+ if ( !aItems.empty() )
{
- if (pItems[nCount-1].nRow < nRow)
+ if (aItems[aItems.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 = pItems[nIndex].pCell;
+ ScBaseCell* pOldCell = aItems[nIndex].pCell;
// move broadcaster and note to new cell, if not existing in new cell
if (pOldCell->HasBroadcaster() && !pNewCell->HasBroadcaster())
@@ -97,42 +97,17 @@ void ScColumn::Insert( SCROW nRow, ScBaseCell* pNewCell )
{
pOldCell->EndListeningTo( pDocument );
// falls in EndListening NoteCell in gleicher Col zerstoert
- if ( nIndex >= nCount || pItems[nIndex].nRow != nRow )
+ if ( nIndex >= aItems.size() || aItems[nIndex].nRow != nRow )
Search(nRow, nIndex);
}
pOldCell->Delete();
- pItems[nIndex].pCell = pNewCell;
+ aItems[nIndex].pCell = pNewCell;
}
else
{
- if (nCount + 1 > nLimit)
- {
- if (bDoubleAlloc)
- {
- if (nLimit < COLUMN_DELTA)
- nLimit = COLUMN_DELTA;
- else
- {
- nLimit *= 2;
- if ( nLimit > sal::static_int_cast<SCSIZE>(MAXROWCOUNT) )
- nLimit = MAXROWCOUNT;
- }
- }
- else
- nLimit += COLUMN_DELTA;
-
- ColEntry* pNewItems = new ColEntry[nLimit];
- if (pItems)
- {
- memmove( pNewItems, pItems, nCount * sizeof(ColEntry) );
- delete[] pItems;
- }
- pItems = pNewItems;
- }
- memmove( &pItems[nIndex + 1], &pItems[nIndex], (nCount - nIndex) * sizeof(ColEntry) );
- pItems[nIndex].pCell = pNewCell;
- pItems[nIndex].nRow = nRow;
- ++nCount;
+ aItems.insert(aItems.begin() + nIndex, ColEntry());
+ aItems[nIndex].pCell = pNewCell;
+ aItems[nIndex].nRow = nRow;
}
}
// Bei aus Clipboard sind hier noch falsche (alte) Referenzen!
@@ -173,33 +148,9 @@ void ScColumn::Insert( SCROW nRow, sal_uInt32 nNumberFormat, ScBaseCell* pCell
)
void ScColumn::Append( SCROW nRow, ScBaseCell* pCell )
{
- if (nCount + 1 > nLimit)
- {
- if (bDoubleAlloc)
- {
- if (nLimit < COLUMN_DELTA)
- nLimit = COLUMN_DELTA;
- else
- {
- nLimit *= 2;
- if ( nLimit > sal::static_int_cast<SCSIZE>(MAXROWCOUNT) )
- nLimit = MAXROWCOUNT;
- }
- }
- else
- nLimit += COLUMN_DELTA;
-
- ColEntry* pNewItems = new ColEntry[nLimit];
- if (pItems)
- {
- memmove( pNewItems, pItems, nCount * sizeof(ColEntry) );
- delete[] pItems;
- }
- pItems = pNewItems;
- }
- pItems[nCount].pCell = pCell;
- pItems[nCount].nRow = nRow;
- ++nCount;
+ aItems.push_back(ColEntry());
+ aItems[aItems.size() - 1].pCell = pCell;
+ aItems[aItems.size() - 1].nRow = nRow;
}
@@ -209,9 +160,9 @@ void ScColumn::Delete( SCROW nRow )
if (Search(nRow, nIndex))
{
- ScBaseCell* pCell = pItems[nIndex].pCell;
+ ScBaseCell* pCell = aItems[nIndex].pCell;
ScNoteCell* pNoteCell = new ScNoteCell;
- pItems[nIndex].pCell = pNoteCell; // Dummy fuer Interpret
+ aItems[nIndex].pCell = pNoteCell; // Dummy fuer Interpret
pDocument->Broadcast( ScHint( SC_HINT_DYING,
ScAddress( nCol, nRow, nTab ), pCell ) );
if ( SvtBroadcaster* pBC = pCell->ReleaseBroadcaster() )
@@ -221,10 +172,7 @@ void ScColumn::Delete( SCROW nRow )
else
{
pNoteCell->Delete();
- --nCount;
- memmove( &pItems[nIndex], &pItems[nIndex + 1], (nCount - nIndex) * sizeof(ColEntry) );
- pItems[nCount].nRow = 0;
- pItems[nCount].pCell = NULL;
+ aItems.erase(aItems.end() - 1);
// Soll man hier den Speicher freigeben (delta)? Wird dann langsamer!
}
pCell->EndListeningTo( pDocument );
@@ -235,16 +183,13 @@ void ScColumn::Delete( SCROW nRow )
void ScColumn::DeleteAtIndex( SCSIZE nIndex )
{
- ScBaseCell* pCell = pItems[nIndex].pCell;
+ ScBaseCell* pCell = aItems[nIndex].pCell;
ScNoteCell* pNoteCell = new ScNoteCell;
- pItems[nIndex].pCell = pNoteCell; // Dummy fuer Interpret
+ aItems[nIndex].pCell = pNoteCell; // Dummy fuer Interpret
pDocument->Broadcast( ScHint( SC_HINT_DYING,
- ScAddress( nCol, pItems[nIndex].nRow, nTab ), pCell ) );
+ ScAddress( nCol, aItems[nIndex].nRow, nTab ), pCell ) );
pNoteCell->Delete();
- --nCount;
- memmove( &pItems[nIndex], &pItems[nIndex + 1], (nCount - nIndex) * sizeof(ColEntry) );
- pItems[nCount].nRow = 0;
- pItems[nCount].pCell = NULL;
+ aItems.erase(aItems.begin() + nIndex);
pCell->EndListeningTo( pDocument );
pCell->Delete();
}
@@ -252,15 +197,9 @@ void ScColumn::DeleteAtIndex( SCSIZE nIndex )
void ScColumn::FreeAll()
{
- if (pItems)
- {
- for (SCSIZE i = 0; i < nCount; i++)
- pItems[i].pCell->Delete();
- delete[] pItems;
- pItems = NULL;
- }
- nCount = 0;
- nLimit = 0;
+ for (SCSIZE i = 0; i < aItems.size(); i++)
+ aItems[i].pCell->Delete();
+ aItems.clear();
}
@@ -268,12 +207,12 @@ void ScColumn::DeleteRow( SCROW nStartRow, SCSIZE nSize )
{
pAttrArray->DeleteRow( nStartRow, nSize );
- if ( !pItems || !nCount )
+ if ( aItems.empty() )
return ;
SCSIZE nFirstIndex;
Search( nStartRow, nFirstIndex );
- if ( nFirstIndex >= nCount )
+ if ( nFirstIndex >= aItems.size() )
return ;
sal_Bool bOldAutoCalc = pDocument->GetAutoCalc();
@@ -285,7 +224,7 @@ void ScColumn::DeleteRow( SCROW nStartRow, SCSIZE nSize )
SCSIZE nEndIndex = 0;
SCSIZE i;
- for ( i = nFirstIndex; i < nCount && pItems[i].nRow <= nEndRow; i++ )
+ for ( i = nFirstIndex; i < aItems.size() && aItems[i].nRow <= nEndRow; i++ )
{
if (!bFound)
{
@@ -294,7 +233,7 @@ void ScColumn::DeleteRow( SCROW nStartRow, SCSIZE nSize )
}
nEndIndex = i;
- ScBaseCell* pCell = pItems[i].pCell;
+ ScBaseCell* pCell = aItems[i].pCell;
SvtBroadcaster* pBC = pCell->GetBroadcaster();
if (pBC)
{
@@ -308,7 +247,7 @@ void ScColumn::DeleteRow( SCROW nStartRow, SCSIZE nSize )
{
DeleteRange( nStartIndex, nEndIndex, IDF_CONTENTS );
Search( nStartRow, i );
- if ( i >= nCount )
+ if ( i >= aItems.size() )
{
pDocument->SetAutoCalc( bOldAutoCalc );
return ;
@@ -321,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 = (((pItems[nCount-1].nRow - pItems[i].nRow) /
- (nCount - i)) > 1);
+ sal_Bool bSingleBroadcasts = (((aItems[aItems.size()-1].nRow - aItems[i].nRow) /
+ (aItems.size() - i)) > 1);
if ( bSingleBroadcasts )
{
SCROW nLastBroadcast = MAXROW+1;
- for ( ; i < nCount; i++ )
+ for ( ; i < aItems.size(); i++ )
{
- SCROW nOldRow = pItems[i].nRow;
+ SCROW nOldRow = aItems[i].nRow;
// Aenderung Quelle broadcasten
rAddress.SetRow( nOldRow );
pDocument->AreaBroadcast( aHint );
- SCROW nNewRow = (pItems[i].nRow -= nSize);
+ SCROW nNewRow = (aItems[i].nRow -= nSize);
// Aenderung Ziel broadcasten
if ( nLastBroadcast != nNewRow )
{ // direkt aufeinanderfolgende nicht doppelt broadcasten
@@ -340,20 +279,20 @@ void ScColumn::DeleteRow( SCROW nStartRow, SCSIZE nSize )
pDocument->AreaBroadcast( aHint );
}
nLastBroadcast = nOldRow;
- ScBaseCell* pCell = pItems[i].pCell;
+ ScBaseCell* pCell = aItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
((ScFormulaCell*)pCell)->aPos.SetRow( nNewRow );
}
}
else
{
- rAddress.SetRow( pItems[i].nRow );
+ rAddress.SetRow( aItems[i].nRow );
ScRange aRange( rAddress );
- aRange.aEnd.SetRow( pItems[nCount-1].nRow );
- for ( ; i < nCount; i++ )
+ aRange.aEnd.SetRow( aItems[aItems.size()-1].nRow );
+ for ( ; i < aItems.size(); i++ )
{
- SCROW nNewRow = (pItems[i].nRow -= nSize);
- ScBaseCell* pCell = pItems[i].pCell;
+ SCROW nNewRow = (aItems[i].nRow -= nSize);
+ ScBaseCell* pCell = aItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
((ScFormulaCell*)pCell)->aPos.SetRow( nNewRow );
}
@@ -374,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 = pItems[ nIdx ].pCell->GetNote() )
+ if ( ScPostIt* pNote = aItems[ nIdx ].pCell->GetNote() )
pNote->ForgetCaption();
ScHint aHint( SC_HINT_DYING, ScAddress( nCol, 0, nTab ), 0 );
@@ -385,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, nCount, false);
+ RemovedSegments_t aRemovedSegments(nStartIndex, aItems.size(), false);
SCSIZE nFirst(nStartIndex);
// dummy replacement for old cells, to prevent that interpreter uses old cell
@@ -394,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) && !pItems[ nIdx ].pCell->GetBroadcaster())
+ if (((nDelFlag & IDF_CONTENTS) == IDF_CONTENTS) && !aItems[ nIdx ].pCell->GetBroadcaster())
{
- ScBaseCell* pOldCell = pItems[ nIdx ].pCell;
+ ScBaseCell* pOldCell = aItems[ nIdx ].pCell;
if (pOldCell->GetCellType() == CELLTYPE_FORMULA)
{
// cache formula cell, will be deleted below
@@ -405,8 +344,8 @@ void ScColumn::DeleteRange( SCSIZE nStartIndex, SCSIZE nEndIndex, sal_uInt16 nDe
else
{
// interpret in broadcast must not use the old cell
- pItems[ nIdx ].pCell = pDummyCell.get();
- aHint.GetAddress().SetRow( pItems[ nIdx ].nRow );
+ aItems[ nIdx ].pCell = pDummyCell.get();
+ aHint.GetAddress().SetRow( aItems[ nIdx ].nRow );
aHint.SetCell( pOldCell );
pDocument->Broadcast( aHint );
pOldCell->Delete();
@@ -416,7 +355,7 @@ void ScColumn::DeleteRange( SCSIZE nStartIndex, SCSIZE nEndIndex, sal_uInt16 nDe
else
{
bool bDelete = false;
- ScBaseCell* pOldCell = pItems[nIdx].pCell;
+ ScBaseCell* pOldCell = aItems[nIdx].pCell;
CellType eCellType = pOldCell->GetCellType();
if ((nDelFlag & IDF_CONTENTS) == IDF_CONTENTS)
bDelete = true;
@@ -435,7 +374,7 @@ void ScColumn::DeleteRange( SCSIZE nStartIndex, SCSIZE nEndIndex, sal_uInt16 nDe
if( !bDelete && (nValFlags != 0) )
{
sal_uLong nIndex = (sal_uLong)((SfxUInt32Item*)GetAttr(
- pItems[nIdx].nRow, ATTR_VALUE_FORMAT ))->GetValue();
+ aItems[nIdx].nRow, ATTR_VALUE_FORMAT ))->GetValue();
short nType = pDocument->GetFormatTable()->GetType(nIndex);
bool bIsDate = (nType == NUMBERFORMAT_DATE) ||
(nType == NUMBERFORMAT_TIME) || (nType ==
NUMBERFORMAT_DATETIME);
@@ -477,16 +416,16 @@ void ScColumn::DeleteRange( SCSIZE nStartIndex, SCSIZE nEndIndex, sal_uInt16
nDe
}
// remove cell entry in cell item list
- SCROW nOldRow = pItems[nIdx].nRow;
+ SCROW nOldRow = aItems[nIdx].nRow;
if (pNoteCell)
{
// replace old cell with the replacement note cell
- pItems[nIdx].pCell = pNoteCell;
+ aItems[nIdx].pCell = pNoteCell;
// ... so it's not really deleted
bDelete = false;
}
else
- pItems[nIdx].pCell = pDummyCell.get();
+ aItems[nIdx].pCell = pDummyCell.get();
// cache formula cells (will be deleted later), delete cell of other type
if (eCellType == CELLTYPE_FORMULA)
@@ -507,7 +446,7 @@ void ScColumn::DeleteRange( SCSIZE nStartIndex, SCSIZE nEndIndex, sal_uInt16 nDe
{
// delete cell note
if (bDeleteNote)
- pItems[nIdx].pCell->DeleteNote();
+ aItems[nIdx].pCell->DeleteNote();
}
if (!bDelete)
@@ -551,20 +490,20 @@ void ScColumn::DeleteRange( SCSIZE nStartIndex, SCSIZE nEndIndex, sal_uInt16
nDe
{ // previous segment(s) removed, move tail
SCSIZE const nEndSegment(aIt->first);
memmove(
- &pItems[nStartSegment - nShift],
- &pItems[nEndSegment - nShift],
- (nCount - nEndSegment) * sizeof(ColEntry));
+ &aItems[nStartSegment - nShift],
+ &aItems[nEndSegment - nShift],
+ (aItems.size() - nEndSegment) * sizeof(ColEntry));
nShift += nEndSegment - nStartSegment;
bRemoved = false;
}
}
++aIt;
}
- // The last removed segment up to nCount is discarded, there's nothing
+ // The last removed segment up to aItems.size() is discarded, there's nothing
// following to be moved.
if (bRemoved)
- nShift += nCount - nStartSegment;
- nCount -= nShift;
+ nShift += aItems.size() - nStartSegment;
+ aItems.erase(aItems.end() - nShift, aItems.end());
}
// *** delete all formula cells ***
@@ -608,17 +547,17 @@ void ScColumn::DeleteArea(SCROW nStartRow, SCROW nEndRow, sal_uInt16 nDelFlag)
nContMask |= IDF_NOCAPTIONS;
sal_uInt16 nContFlag = nDelFlag & nContMask;
- if (pItems && nCount>0 && nContFlag)
+ if ( !aItems.empty() && nContFlag)
{
if (nStartRow==0 && nEndRow==MAXROW)
- DeleteRange( 0, nCount-1, nContFlag );
+ DeleteRange( 0, aItems.size()-1, nContFlag );
else
{
sal_Bool bFound=false;
SCSIZE nStartIndex = 0;
SCSIZE nEndIndex = 0;
- for (SCSIZE i = 0; i < nCount; i++)
- if ((pItems[i].nRow >= nStartRow) && (pItems[i].nRow <= nEndRow))
+ for (SCSIZE i = 0; i < aItems.size(); i++)
+ if ((aItems[i].nRow >= nStartRow) && (aItems[i].nRow <= nEndRow))
{
if (!bFound)
{
@@ -655,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 = pItems[nIndex].pCell;
+ ScBaseCell* pCell = aItems[nIndex].pCell;
CellType eCellType = pCell->GetCellType();
switch ( eCellType )
{
@@ -668,7 +607,7 @@ ScFormulaCell* ScColumn::CreateRefCell( ScDocument* pDestDoc, const ScAddress& r
else if ( nValFlags )
{
sal_uLong nNumIndex = (sal_uLong)((SfxUInt32Item*)GetAttr(
- pItems[nIndex].nRow, ATTR_VALUE_FORMAT ))->GetValue();
+ aItems[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);
@@ -692,7 +631,7 @@ ScFormulaCell* ScColumn::CreateRefCell( ScDocument* pDestDoc, const ScAddress& r
// Referenz einsetzen
ScSingleRefData aRef;
aRef.nCol = nCol;
- aRef.nRow = pItems[nIndex].nRow;
+ aRef.nRow = aItems[nIndex].nRow;
aRef.nTab = nTab;
aRef.InitFlags(); // -> alles absolut
aRef.SetFlag3D(true);
@@ -725,20 +664,20 @@ void ScColumn::CopyFromClip(SCROW nRow1, SCROW nRow2, long nDy,
SCSIZE nStartIndex;
rColumn.Search( nRow1-nDy, nStartIndex );
- while ( nStartIndex < rColumn.nCount && rColumn.pItems[nStartIndex].nRow <= nRow2-nDy )
+ while ( nStartIndex < rColumn.aItems.size() && rColumn.aItems[nStartIndex].nRow <=
nRow2-nDy )
{
SCSIZE nEndIndex = nStartIndex;
- if ( rColumn.pItems[nStartIndex].pCell->GetCellType() != CELLTYPE_NOTE )
+ if ( rColumn.aItems[nStartIndex].pCell->GetCellType() != CELLTYPE_NOTE )
{
- SCROW nStartRow = rColumn.pItems[nStartIndex].nRow;
+ SCROW nStartRow = rColumn.aItems[nStartIndex].nRow;
SCROW nEndRow = nStartRow;
// find consecutive non-empty cells
while ( nEndRow < nRow2-nDy &&
- nEndIndex+1 < rColumn.nCount &&
- rColumn.pItems[nEndIndex+1].nRow == nEndRow+1 &&
- rColumn.pItems[nEndIndex+1].pCell->GetCellType() != CELLTYPE_NOTE )
+ nEndIndex+1 < rColumn.aItems.size() &&
+ rColumn.aItems[nEndIndex+1].nRow == nEndRow+1 &&
+ rColumn.aItems[nEndIndex+1].pCell->GetCellType() != CELLTYPE_NOTE )
{
++nEndIndex;
++nEndRow;
@@ -761,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( nCount + static_cast<SCSIZE>(nRow2-nRow1+1) );
+ Resize( aItems.size() + static_cast<SCSIZE>(nRow2-nRow1+1) );
ScAddress aDestPos( nCol, 0, nTab ); // Row wird angepasst
@@ -787,7 +726,7 @@ void ScColumn::CopyFromClip(SCROW nRow1, SCROW nRow2, long nDy,
return;
}
- SCSIZE nColCount = rColumn.nCount;
+ SCSIZE nColCount = rColumn.aItems.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)
@@ -795,9 +734,8 @@ 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 = nCount + nColCount;
- if ( nLimit < nNew )
- Resize( nNew );
+ SCSIZE nNew = aItems.size() + nColCount;
+ Resize( nNew );
}
// IDF_ADDNOTES must be passed without other content flags than IDF_NOTE
@@ -806,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.pItems[i].nRow + nDy;
+ SCsROW nDestRow = rColumn.aItems[i].nRow + nDy;
if ( nDestRow > (SCsROW) nRow2 )
bAtEnd = sal_True;
else if ( nDestRow >= (SCsROW) nRow1 )
@@ -827,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.pItems[i].pCell;
+ const ScBaseCell* pSourceCell = rColumn.aItems[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.pItems[i].nRow, rColumn.nTab );
+ ScAddress aSourcePos( rColumn.nCol, rColumn.aItems[i].nRow, rColumn.nTab );
ScPostIt* pNewNote = pSourceNote->Clone( aSourcePos, *pDocument, aDestPos,
bCloneCaption );
pAddNoteCell->TakeNote( pNewNote );
}
@@ -882,7 +820,7 @@ ScBaseCell* ScColumn::CloneCell(SCSIZE nIndex, sal_uInt16 nFlags, ScDocument& rD
bool bForceFormula = false;
ScBaseCell* pNew = 0;
- ScBaseCell& rSource = *pItems[nIndex].pCell;
+ ScBaseCell& rSource = *aItems[nIndex].pCell;
switch (rSource.GetCellType())
{
case CELLTYPE_NOTE:
@@ -898,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, pItems[nIndex].nRow, bCloneValue,
bCloneDateTime ))
+ if (lclCanCloneValue( *pDocument, *this, aItems[nIndex].nRow, bCloneValue,
bCloneDateTime ))
pNew = rSource.CloneWithoutNote( rDestDoc, rDestPos );
break;
@@ -937,7 +875,7 @@ ScBaseCell* ScColumn::CloneCell(SCSIZE nIndex, sal_uInt16 nFlags, ScDocument& rD
}
else if (rForm.IsValue())
{
- if (lclCanCloneValue( *pDocument, *this, pItems[nIndex].nRow, bCloneValue,
bCloneDateTime ))
+ if (lclCanCloneValue( *pDocument, *this, aItems[nIndex].nRow, bCloneValue,
bCloneDateTime ))
{
double nVal = rForm.GetValue();
pNew = new ScValueCell(nVal);
@@ -973,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, pItems[nIndex].nRow, nTab );
+ ScAddress aOwnPos( nCol, aItems[nIndex].nRow, nTab );
ScPostIt* pNewNote = pNote->Clone( aOwnPos, rDestDoc, rDestPos, bCloneCaption );
if (!pNew)
pNew = new ScNoteCell( pNewNote );
@@ -1048,7 +986,7 @@ void ScColumn::MixData( SCROW nRow1, SCROW nRow2,
sal_uInt16 nFunction, bool bSkipEmpty,
ScColumn& rSrcCol )
{
- SCSIZE nSrcCount = rSrcCol.nCount;
+ SCSIZE nSrcCount = rSrcCol.aItems.size();
SCSIZE nIndex;
Search( nRow1, nIndex );
@@ -1058,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 < nCount )
- nNextThis = pItems[nIndex].nRow;
+ if ( nIndex < aItems.size() )
+ nNextThis = aItems[nIndex].nRow;
SCROW nNextSrc = MAXROW+1;
if ( nSrcIndex < nSrcCount )
- nNextSrc = rSrcCol.pItems[nSrcIndex].nRow;
+ nNextSrc = rSrcCol.aItems[nSrcIndex].nRow;
while ( nNextThis <= nRow2 || nNextSrc <= nRow2 )
{
@@ -1074,10 +1012,10 @@ void ScColumn::MixData( SCROW nRow1, SCROW nRow2,
sal_Bool bDelete = false;
if ( nSrcIndex < nSrcCount && nNextSrc == nRow )
- pSrc = rSrcCol.pItems[nSrcIndex].pCell;
+ pSrc = rSrcCol.aItems[nSrcIndex].pCell;
- if ( nIndex < nCount && nNextThis == nRow )
- pDest = pItems[nIndex].pCell;
+ if ( nIndex < aItems.size() && nNextThis == nRow )
+ pDest = aItems[nIndex].pCell;
OSL_ENSURE( pSrc || pDest, "Nanu ?" );
@@ -1201,19 +1139,19 @@ void ScColumn::MixData( SCROW nRow1, SCROW nRow2,
if (pNew)
nNextThis = nRow; // nIndex zeigt jetzt genau auf nRow
else
- nNextThis = ( nIndex < nCount ) ? pItems[nIndex].nRow : MAXROW+1;
+ nNextThis = ( nIndex < aItems.size() ) ? aItems[nIndex].nRow : MAXROW+1;
}
if ( nNextThis == nRow )
{
++nIndex;
- nNextThis = ( nIndex < nCount ) ? pItems[nIndex].nRow : MAXROW+1;
+ nNextThis = ( nIndex < aItems.size() ) ? aItems[nIndex].nRow : MAXROW+1;
}
if ( nNextSrc == nRow )
{
++nSrcIndex;
nNextSrc = ( nSrcIndex < nSrcCount ) ?
- rSrcCol.pItems[nSrcIndex].nRow :
+ rSrcCol.aItems[nSrcIndex].nRow :
MAXROW+1;
}
}
@@ -1228,15 +1166,15 @@ ScAttrIterator* ScColumn::CreateAttrIterator( SCROW nStartRow, SCROW
nEndRow ) c
void ScColumn::StartAllListeners()
{
- if (pItems)
- for (SCSIZE i = 0; i < nCount; i++)
+ if ( !aItems.empty() )
+ for (SCSIZE i = 0; i < aItems.size(); i++)
{
- ScBaseCell* pCell = pItems[i].pCell;
+ ScBaseCell* pCell = aItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
{
- SCROW nRow = pItems[i].nRow;
+ SCROW nRow = aItems[i].nRow;
((ScFormulaCell*)pCell)->StartListeningTo( pDocument );
- if ( nRow != pItems[i].nRow )
+ if ( nRow != aItems[i].nRow )
Search( nRow, i ); // Listener eingefuegt?
}
}
@@ -1245,19 +1183,19 @@ void ScColumn::StartAllListeners()
void ScColumn::StartNeededListeners()
{
- if (pItems)
+ if ( !aItems.empty() )
{
- for (SCSIZE i = 0; i < nCount; i++)
+ for (SCSIZE i = 0; i < aItems.size(); i++)
{
- ScBaseCell* pCell = pItems[i].pCell;
+ ScBaseCell* pCell = aItems[i].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
{
ScFormulaCell* pFCell = static_cast<ScFormulaCell*>(pCell);
if (pFCell->NeedsListening())
{
- SCROW nRow = pItems[i].nRow;
+ SCROW nRow = aItems[i].nRow;
pFCell->StartListeningTo( pDocument );
- if ( nRow != pItems[i].nRow )
+ if ( nRow != aItems[i].nRow )
Search( nRow, i ); // Listener eingefuegt?
}
}
@@ -1268,14 +1206,14 @@ void ScColumn::StartNeededListeners()
void ScColumn::BroadcastInArea( SCROW nRow1, SCROW nRow2 )
{
- if ( pItems )
+ if ( !aItems.empty() )
{
SCROW nRow;
SCSIZE nIndex;
Search( nRow1, nIndex );
- while ( nIndex < nCount && (nRow = pItems[nIndex].nRow) <= nRow2 )
+ while ( nIndex < aItems.size() && (nRow = aItems[nIndex].nRow) <= nRow2 )
{
- ScBaseCell* pCell = pItems[nIndex].pCell;
+ ScBaseCell* pCell = aItems[nIndex].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
((ScFormulaCell*)pCell)->SetDirty();
else
@@ -1289,17 +1227,17 @@ void ScColumn::BroadcastInArea( SCROW nRow1, SCROW nRow2 )
void ScColumn::StartListeningInArea( SCROW nRow1, SCROW nRow2 )
{
- if ( pItems )
+ if ( !aItems.empty() )
{
SCROW nRow;
SCSIZE nIndex;
Search( nRow1, nIndex );
- while ( nIndex < nCount && (nRow = pItems[nIndex].nRow) <= nRow2 )
+ while ( nIndex < aItems.size() && (nRow = aItems[nIndex].nRow) <= nRow2 )
{
- ScBaseCell* pCell = pItems[nIndex].pCell;
+ ScBaseCell* pCell = aItems[nIndex].pCell;
if ( pCell->GetCellType() == CELLTYPE_FORMULA )
((ScFormulaCell*)pCell)->StartListeningTo( pDocument );
- if ( nRow != pItems[nIndex].nRow )
+ if ( nRow != aItems[nIndex].nRow )
Search( nRow, nIndex ); // durch Listening eingefuegt
nIndex++;
}
@@ -1375,17 +1313,17 @@ bool ScColumn::SetString( SCROW nRow, SCTAB nTabP, const String& rString,
sal_Bool bIsText = false;
if ( bIsLoading )
{
- if ( pItems && nCount )
+ if ( !aItems.empty() )
{
String aStr;
- SCSIZE i = nCount;
+ SCSIZE i = aItems.size();
SCSIZE nStop = (i >= 3 ? i - 3 : 0);
// die letzten Zellen vergleichen, ob gleicher String
// und IsNumberFormat eingespart werden kann
do
{
i--;
- ScBaseCell* pCell = pItems[i].pCell;
+ ScBaseCell* pCell = aItems[i].pCell;
switch ( pCell->GetCellType() )
{
case CELLTYPE_STRING :
@@ -1396,7 +1334,7 @@ bool ScColumn::SetString( SCROW nRow, SCTAB nTabP, const String& rString,
case CELLTYPE_NOTE : // durch =Formel referenziert
break;
default:
- if ( i == nCount - 1 )
+ if ( i == aItems.size() - 1 )
i = 0;
// wahrscheinlich ganze Spalte kein String
}
@@ -1501,7 +1439,7 @@ bool ScColumn::SetString( SCROW nRow, SCTAB nTabP, const String& rString,
}
}
- if ( bIsLoading && (!nCount || nRow > pItems[nCount-1].nRow) )
+ if ( bIsLoading && (aItems.empty() || nRow > aItems[aItems.size()-1].nRow) )
{ // Search einsparen und ohne Umweg ueber Insert, Listener aufbauen
// und Broadcast kommt eh erst nach dem Laden
if ( pNewCell )
@@ -1512,7 +1450,7 @@ bool ScColumn::SetString( SCROW nRow, SCTAB nTabP, const String& rString,
SCSIZE i;
if (Search(nRow, i))
{
- ScBaseCell* pOldCell = pItems[i].pCell;
+ ScBaseCell* pOldCell = aItems[i].pCell;
ScPostIt* pNote = pOldCell->ReleaseNote();
SvtBroadcaster* pBC = pOldCell->ReleaseBroadcaster();
if (pNewCell || pNote || pBC)
@@ -1531,11 +1469,11 @@ bool ScColumn::SetString( SCROW nRow, SCTAB nTabP, const String& rString,
{
pOldCell->EndListeningTo( pDocument );
// falls in EndListening NoteCell in gleicher Col zerstoert
- if ( i >= nCount || pItems[i].nRow != nRow )
+ if ( i >= aItems.size() || aItems[i].nRow != nRow )
Search(nRow, i);
}
pOldCell->Delete();
- pItems[i].pCell = pNewCell; // ersetzen
+ aItems[i].pCell = pNewCell; // ersetzen
if ( pNewCell->GetCellType() == CELLTYPE_FORMULA )
{
pNewCell->StartListeningTo( pDocument );
@@ -1573,9 +1511,9 @@ void ScColumn::GetFilterEntries(SCROW nStartRow, SCROW nEndRow,
TypedScStrCollec
Search( nStartRow, nIndex );
- while ( (nIndex < nCount) ? ((nRow=pItems[nIndex].nRow) <= nEndRow) : false )
+ while ( (nIndex < aItems.size()) ? ((nRow=aItems[nIndex].nRow) <= nEndRow) : false )
{
- ScBaseCell* pCell = pItems[nIndex].pCell;
+ ScBaseCell* pCell = aItems[nIndex].pCell;
TypedStrData* pData = NULL;
sal_uLong nFormat = GetNumberFormat( nRow );
@@ -1667,11 +1605,11 @@ bool ScColumn::GetDataEntries(SCROW nStartRow, TypedScStrCollection&
rStrings, b
if (bThisUsed)
++nDownIndex; // Startzelle ueberspringen
- while ( nUpIndex || nDownIndex < nCount )
+ while ( nUpIndex || nDownIndex < aItems.size() )
{
if ( nUpIndex ) // nach oben
{
- ScBaseCell* pCell = pItems[nUpIndex-1].pCell;
+ ScBaseCell* pCell = aItems[nUpIndex-1].pCell;
CellType eType = pCell->GetCellType();
if (eType == CELLTYPE_STRING || eType == CELLTYPE_EDIT) // nur Strings
interessieren
{
@@ -1694,9 +1632,9 @@ bool ScColumn::GetDataEntries(SCROW nStartRow, TypedScStrCollection&
rStrings, b
--nUpIndex;
}
- if ( nDownIndex < nCount ) // nach unten
+ if ( nDownIndex < aItems.size() ) // nach unten
{
- ScBaseCell* pCell = pItems[nDownIndex].pCell;
+ ScBaseCell* pCell = aItems[nDownIndex].pCell;
CellType eType = pCell->GetCellType();
if (eType == CELLTYPE_STRING || eType == CELLTYPE_EDIT) // nur Strings
interessieren
{
@@ -1742,21 +1680,21 @@ void ScColumn::RemoveProtected( SCROW nStartRow, SCROW nEndRow )
else if ( pAttr->GetHideFormula() )
{
Search( nTop, nIndex );
- while ( nIndex<nCount && pItems[nIndex].nRow<=nBottom )
+ while ( nIndex<aItems.size() && aItems[nIndex].nRow<=nBottom )
{
- if ( pItems[nIndex].pCell->GetCellType() == CELLTYPE_FORMULA )
+ if ( aItems[nIndex].pCell->GetCellType() == CELLTYPE_FORMULA )
{
- ScFormulaCell* pFormula = (ScFormulaCell*)pItems[nIndex].pCell;
+ ScFormulaCell* pFormula = (ScFormulaCell*)aItems[nIndex].pCell;
if (pFormula->IsValue())
{
double nVal = pFormula->GetValue();
- pItems[nIndex].pCell = new ScValueCell( nVal );
+ aItems[nIndex].pCell = new ScValueCell( nVal );
}
else
{
String aString;
pFormula->GetString(aString);
- pItems[nIndex].pCell = new ScStringCell( aString );
+ aItems[nIndex].pCell = new ScStringCell( aString );
}
delete pFormula;
}
@@ -1797,7 +1735,7 @@ void ScColumn::GetString( SCROW nRow, rtl::OUString& rString ) const
Color* pColor;
if (Search(nRow, nIndex))
{
- ScBaseCell* pCell = pItems[nIndex].pCell;
+ ScBaseCell* pCell = aItems[nIndex].pCell;
if (pCell->GetCellType() != CELLTYPE_NOTE)
{
sal_uLong nFormat = GetNumberFormat( nRow );
@@ -1816,7 +1754,7 @@ void ScColumn::GetInputString( SCROW nRow, rtl::OUString& rString ) const
SCSIZE nIndex;
if (Search(nRow, nIndex))
{
- ScBaseCell* pCell = pItems[nIndex].pCell;
+ ScBaseCell* pCell = aItems[nIndex].pCell;
if (pCell->GetCellType() != CELLTYPE_NOTE)
{
sal_uLong nFormat = GetNumberFormat( nRow );
@@ -1835,7 +1773,7 @@ double ScColumn::GetValue( SCROW nRow ) const
SCSIZE nIndex;
if (Search(nRow, nIndex))
{
- ScBaseCell* pCell = pItems[nIndex].pCell;
+ ScBaseCell* pCell = aItems[nIndex].pCell;
switch (pCell->GetCellType())
{
case CELLTYPE_VALUE:
@@ -1863,7 +1801,7 @@ void ScColumn::GetFormula( SCROW nRow, rtl::OUString& rFormula ) const
SCSIZE nIndex;
if (Search(nRow, nIndex))
{
- ScBaseCell* pCell = pItems[nIndex].pCell;
+ ScBaseCell* pCell = aItems[nIndex].pCell;
if (pCell->GetCellType() == CELLTYPE_FORMULA)
((ScFormulaCell*)pCell)->GetFormula( rFormula );
else
@@ -1878,7 +1816,7 @@ CellType ScColumn::GetCellType( SCROW nRow ) const
{
SCSIZE nIndex;
if (Search(nRow, nIndex))
- return pItems[nIndex].pCell->GetCellType();
+ return aItems[nIndex].pCell->GetCellType();
return CELLTYPE_NONE;
}
@@ -1888,7 +1826,7 @@ sal_uInt16 ScColumn::GetErrCode( SCROW nRow ) const
SCSIZE nIndex;
if (Search(nRow, nIndex))
{
- ScBaseCell* pCell = pItems[nIndex].pCell;
+ ScBaseCell* pCell = aItems[nIndex].pCell;
if (pCell->GetCellType() == CELLTYPE_FORMULA)
return ((ScFormulaCell*)pCell)->GetErrCode();
}
@@ -1900,7 +1838,7 @@ bool ScColumn::HasStringData( SCROW nRow ) const
{
SCSIZE nIndex;
if (Search(nRow, nIndex))
- return (pItems[nIndex].pCell)->HasStringData();
+ return (aItems[nIndex].pCell)->HasStringData();
return false;
}
@@ -1909,7 +1847,7 @@ bool ScColumn::HasValueData( SCROW nRow ) const
{
SCSIZE nIndex;
if (Search(nRow, nIndex))
- return (pItems[nIndex].pCell)->HasValueData();
+ return (aItems[nIndex].pCell)->HasValueData();
return false;
}
@@ -1917,13 +1855,13 @@ bool ScColumn::HasStringCells( SCROW nStartRow, SCROW nEndRow ) const
{
// TRUE, wenn String- oder Editzellen im Bereich
- if ( pItems )
+ if ( !aItems.empty() )
{
SCSIZE nIndex;
Search( nStartRow, nIndex );
- while ( nIndex < nCount && pItems[nIndex].nRow <= nEndRow )
+ while ( nIndex < aItems.size() && aItems[nIndex].nRow <= nEndRow )
{
- CellType eType = pItems[nIndex].pCell->GetCellType();
+ CellType eType = aItems[nIndex].pCell->GetCellType();
if ( eType == CELLTYPE_STRING || eType == CELLTYPE_EDIT )
return sal_True;
++nIndex;
@@ -1936,7 +1874,7 @@ bool ScColumn::HasStringCells( SCROW nStartRow, SCROW nEndRow ) const
ScPostIt* ScColumn::GetNote( SCROW nRow )
{
SCSIZE nIndex;
- return Search( nRow, nIndex ) ? pItems[ nIndex ].pCell->GetNote() : 0;
+ return Search( nRow, nIndex ) ? aItems[ nIndex ].pCell->GetNote() : 0;
}
@@ -1944,7 +1882,7 @@ void ScColumn::TakeNote( SCROW nRow, ScPostIt* pNote )
{
SCSIZE nIndex;
if( Search( nRow, nIndex ) )
- pItems[ nIndex ].pCell->TakeNote( pNote );
+ aItems[ nIndex ].pCell->TakeNote( pNote );
else
Insert( nRow, new ScNoteCell( pNote ) );
}
@@ -1956,7 +1894,7 @@ ScPostIt* ScColumn::ReleaseNote( SCROW nRow )
SCSIZE nIndex;
if( Search( nRow, nIndex ) )
{
- ScBaseCell* pCell = pItems[ nIndex ].pCell;
+ ScBaseCell* pCell = aItems[ nIndex ].pCell;
pNote = pCell->ReleaseNote();
if( (pCell->GetCellType() == CELLTYPE_NOTE) && !pCell->GetBroadcaster() )
DeleteAtIndex( nIndex );
@@ -1974,7 +1912,7 @@ void ScColumn::DeleteNote( SCROW nRow )
sal_Int32 ScColumn::GetMaxStringLen( SCROW nRowStart, SCROW nRowEnd, CharSet eCharSet ) const
{
sal_Int32 nStringLen = 0;
- if ( pItems )
+ if ( !aItems.empty() )
{
rtl::OUString aString;
rtl::OString aOString;
@@ -1983,9 +1921,9 @@ sal_Int32 ScColumn::GetMaxStringLen( SCROW nRowStart, SCROW nRowEnd, CharSet
eCh
SCSIZE nIndex;
SCROW nRow;
Search( nRowStart, nIndex );
- while ( nIndex < nCount && (nRow = pItems[nIndex].nRow) <= nRowEnd )
+ while ( nIndex < aItems.size() && (nRow = aItems[nIndex].nRow) <= nRowEnd )
{
- ScBaseCell* pCell = pItems[nIndex].pCell;
+ ScBaseCell* pCell = aItems[nIndex].pCell;
if ( pCell->GetCellType() != CELLTYPE_NOTE )
{
Color* pColor;
@@ -2028,16 +1966,16 @@ xub_StrLen ScColumn::GetMaxNumberStringLen(
// In case of unlimited precision, use 2 instead.
nPrecision = 2;
- if ( pItems )
+ if ( !aItems.empty() )
{
rtl::OUString aString;
SvNumberFormatter* pNumFmt = pDocument->GetFormatTable();
SCSIZE nIndex;
SCROW nRow;
Search( nRowStart, nIndex );
- while ( nIndex < nCount && (nRow = pItems[nIndex].nRow) <= nRowEnd )
+ while ( nIndex < aItems.size() && (nRow = aItems[nIndex].nRow) <= nRowEnd )
{
- ScBaseCell* pCell = pItems[nIndex].pCell;
+ ScBaseCell* pCell = aItems[nIndex].pCell;
CellType eType = pCell->GetCellType();
if ( eType == CELLTYPE_VALUE || (eType == CELLTYPE_FORMULA
&& ((ScFormulaCell*)pCell)->IsValue()) )
diff --git a/sc/source/core/data/dociter.cxx b/sc/source/core/data/dociter.cxx
index fd6bd28..435cf7c 100644
--- a/sc/source/core/data/dociter.cxx
+++ b/sc/source/core/data/dociter.cxx
@@ -128,7 +128,7 @@ sal_Bool ScDocumentIterator::GetThisCol()
do
{
- nColRow = (nColPos < pCol->nCount) ? pCol->pItems[nColPos].nRow : MAXROW+1;
+ nColRow = (nColPos < pCol->aItems.size()) ? pCol->aItems[nColPos].nRow : MAXROW+1;
if (nColRow < nRow)
++nColPos;
}
@@ -137,7 +137,7 @@ sal_Bool ScDocumentIterator::GetThisCol()
if (nColRow == nRow)
{
bFound = sal_True;
- pCell = pCol->pItems[nColPos].pCell;
+ pCell = pCol->aItems[nColPos].pCell;
pPattern = pAtt->pData[nAttrPos].pPattern;
}
else if ( pAtt->pData[nAttrPos].pPattern != pDefPattern )
@@ -311,19 +311,19 @@ sal_Bool ScValueIterator::GetThis(double& rValue, sal_uInt16& rErr)
}
}
pCol = &(pDoc->maTabs[nTab])->aCol[nCol];
- } while ( pCol->nCount == 0 );
+ } while ( pCol->aItems.size() == 0 );
pCol->Search( nRow, nColRow );
}
- while (( nColRow < pCol->nCount ) && ( pCol->pItems[nColRow].nRow < nRow ))
+ while (( nColRow < pCol->aItems.size() ) && ( pCol->aItems[nColRow].nRow < nRow ))
nColRow++;
- if ( nColRow < pCol->nCount && pCol->pItems[nColRow].nRow <= nEndRow )
+ if ( nColRow < pCol->aItems.size() && pCol->aItems[nColRow].nRow <= nEndRow )
{
- nRow = pCol->pItems[nColRow].nRow + 1;
+ nRow = pCol->aItems[nColRow].nRow + 1;
if ( !bSubTotal || !pDoc->maTabs[nTab]->RowFiltered( nRow-1 ) )
{
- ScBaseCell* pCell = pCol->pItems[nColRow].pCell;
+ ScBaseCell* pCell = pCol->aItems[nColRow].pCell;
++nColRow;
switch (pCell->GetCellType())
{
@@ -343,13 +343,13 @@ sal_Bool ScValueIterator::GetThis(double& rValue, sal_uInt16& rErr)
// wenn in der selben Spalte gleich noch eine Value-Cell folgt, die
// auch noch im Block liegt, den Wert jetzt schon holen
//
- if ( nColRow < pCol->nCount &&
- pCol->pItems[nColRow].nRow <= nEndRow &&
- pCol->pItems[nColRow].pCell->GetCellType() == CELLTYPE_VALUE &&
+ if ( nColRow < pCol->aItems.size() &&
+ pCol->aItems[nColRow].nRow <= nEndRow &&
+ pCol->aItems[nColRow].pCell->GetCellType() == CELLTYPE_VALUE &&
!bSubTotal )
{
- fNextValue = ((ScValueCell*)pCol->pItems[nColRow].pCell)->GetValue();
- nNextRow = pCol->pItems[nColRow].nRow;
+ fNextValue = ((ScValueCell*)pCol->aItems[nColRow].pCell)->GetValue();
+ nNextRow = pCol->aItems[nColRow].nRow;
bNextValid = sal_True;
if ( bCalcAsShown )
{
@@ -422,12 +422,12 @@ void ScValueIterator::GetCurNumFmtInfo( short& nType, sal_uLong& nIndex )
const ScBaseCell* pCell;
SCSIZE nIdx = nColRow - 1;
// there might be rearranged something, so be on the safe side
- if ( nIdx < pCol->nCount && pCol->pItems[nIdx].nRow == nRow )
- pCell = pCol->pItems[nIdx].pCell;
+ if ( nIdx < pCol->aItems.size() && pCol->aItems[nIdx].nRow == nRow )
+ pCell = pCol->aItems[nIdx].pCell;
else
{
if ( pCol->Search( nRow, nIdx ) )
- pCell = pCol->pItems[nIdx].pCell;
+ pCell = pCol->aItems[nIdx].pCell;
else
pCell = NULL;
}
@@ -478,7 +478,7 @@ SCROW ScDBQueryDataIterator::GetRowByColEntryIndex(ScDocument& rDoc, SCTAB nTab,
if (nTab >= rDoc.GetTableCount())
OSL_FAIL("try to access index out of bounds, FIX IT");
ScColumn* pCol = &rDoc.maTabs[nTab]->aCol[nCol];
- return pCol->pItems[nColRow].nRow;
+ return pCol->aItems[nColRow].nRow;
}
ScBaseCell* ScDBQueryDataIterator::GetCellByColEntryIndex(ScDocument& rDoc, SCTAB nTab, SCCOL
nCol, SCSIZE nColRow)
@@ -486,7 +486,7 @@ ScBaseCell* ScDBQueryDataIterator::GetCellByColEntryIndex(ScDocument& rDoc, SCTA
if (nTab >= rDoc.GetTableCount())
OSL_FAIL("try to access index out of bounds, FIX IT");
ScColumn* pCol = &rDoc.maTabs[nTab]->aCol[nCol];
- return pCol->pItems[nColRow].pCell;
+ return pCol->aItems[nColRow].pCell;
}
ScAttrArray* ScDBQueryDataIterator::GetAttrArrayByCol(ScDocument& rDoc, SCTAB nTab, SCCOL nCol)
@@ -1040,19 +1040,19 @@ ScBaseCell* ScCellIterator::GetThis()
return NULL; // Ende und Aus
}
pCol = &(pDoc->maTabs[nTab])->aCol[nCol];
- } while ( pCol->nCount == 0 );
+ } while ( pCol->aItems.size() == 0 );
pCol->Search( nRow, nColRow );
}
- while ( (nColRow < pCol->nCount) && (pCol->pItems[nColRow].nRow < nRow) )
+ while ( (nColRow < pCol->aItems.size()) && (pCol->aItems[nColRow].nRow < nRow) )
nColRow++;
- if ( nColRow < pCol->nCount && pCol->pItems[nColRow].nRow <= nEndRow )
+ if ( nColRow < pCol->aItems.size() && pCol->aItems[nColRow].nRow <= nEndRow )
{
- nRow = pCol->pItems[nColRow].nRow;
+ nRow = pCol->aItems[nColRow].nRow;
if ( !bSubTotal || !pDoc->maTabs[nTab]->RowFiltered( nRow ) )
{
- ScBaseCell* pCell = pCol->pItems[nColRow].pCell;
+ ScBaseCell* pCell = pCol->aItems[nColRow].pCell;
if ( bSubTotal && pCell->GetCellType() == CELLTYPE_FORMULA
&& ((ScFormulaCell*)pCell)->IsSubTotal() )
@@ -1152,20 +1152,20 @@ ScBaseCell* ScQueryCellIterator::GetThis()
nFirstQueryField = rEntry.nField;
}
pCol = &(pDoc->maTabs[nTab])->aCol[nCol];
- } while ( pCol->nCount == 0 );
+ } while ( pCol->aItems.size() == 0 );
pCol->Search( nRow, nColRow );
bFirstStringIgnore = bIgnoreMismatchOnLeadingStrings &&
!mpParam->bHasHeader && rItem.meType == ScQueryEntry::ByString &&
mpParam->bByRow;
}
- while ( nColRow < pCol->nCount && pCol->pItems[nColRow].nRow < nRow )
+ while ( nColRow < pCol->aItems.size() && pCol->aItems[nColRow].nRow < nRow )
nColRow++;
- if ( nColRow < pCol->nCount &&
- (nRow = pCol->pItems[nColRow].nRow) <= mpParam->nRow2 )
+ if ( nColRow < pCol->aItems.size() &&
+ (nRow = pCol->aItems[nColRow].nRow) <= mpParam->nRow2 )
{
- ScBaseCell* pCell = pCol->pItems[nColRow].pCell;
+ ScBaseCell* pCell = pCol->aItems[nColRow].pCell;
if ( pCell->GetCellType() == CELLTYPE_NOTE )
++nRow;
else if (bAllStringIgnore && pCell->HasStringData())
@@ -1394,7 +1394,7 @@ ScBaseCell* ScQueryCellIterator::BinarySearch()
OSL_FAIL("try to access index out of bounds, FIX IT");
nCol = mpParam->nCol1;
ScColumn* pCol = &(pDoc->maTabs[nTab])->aCol[nCol];
- if (!pCol->nCount)
+ if (!pCol->aItems.size())
return 0;
ScBaseCell* pCell;
@@ -1413,13 +1413,12 @@ ScBaseCell* ScQueryCellIterator::BinarySearch()
nRow = mpParam->nRow1;
if (mpParam->bHasHeader)
nRow++;
- const ColEntry* pItems = pCol->pItems;
if (pCol->Search( nRow, nLo ) && bFirstStringIgnore &&
- pItems[nLo].pCell->HasStringData())
+ pCol->aItems[nLo].pCell->HasStringData())
{
rtl::OUString aCellStr;
- sal_uLong nFormat = pCol->GetNumberFormat( pItems[nLo].nRow);
- ScCellFormat::GetInputString( pItems[nLo].pCell, nFormat, aCellStr,
+ sal_uLong nFormat = pCol->GetNumberFormat( pCol->aItems[nLo].nRow);
+ ScCellFormat::GetInputString( pCol->aItems[nLo].pCell, nFormat, aCellStr,
rFormatter);
sal_Int32 nTmp = pCollator->compareString(aCellStr, rEntry.GetQueryItem().maString);
if ((rEntry.eOp == SC_LESS_EQUAL && nTmp > 0) ||
@@ -1429,8 +1428,8 @@ ScBaseCell* ScQueryCellIterator::BinarySearch()
}
if (!pCol->Search( mpParam->nRow2, nHi ) && nHi>0)
--nHi;
- while (bAllStringIgnore && nLo <= nHi && nLo < pCol->nCount &&
- pItems[nLo].pCell->HasStringData())
+ while (bAllStringIgnore && nLo <= nHi && nLo < pCol->aItems.size() &&
+ pCol->aItems[nLo].pCell->HasStringData())
++nLo;
// Bookkeeping values for breaking up the binary search in case the data
@@ -1443,12 +1442,12 @@ ScBaseCell* ScQueryCellIterator::BinarySearch()
String aLastInRangeString;
if (!bLessEqual)
aLastInRangeString.Assign( sal_Unicode(0xFFFF));
- if (nLastInRange < pCol->nCount)
+ if (nLastInRange < pCol->aItems.size())
{
- pCell = pItems[nLastInRange].pCell;
+ pCell = pCol->aItems[nLastInRange].pCell;
if (pCell->HasStringData())
{
- sal_uLong nFormat = pCol->GetNumberFormat( pItems[nLastInRange].nRow);
+ sal_uLong nFormat = pCol->GetNumberFormat( pCol->aItems[nLastInRange].nRow);
rtl::OUString aStr;
ScCellFormat::GetInputString( pCell, nFormat, aStr,
rFormatter);
@@ -1481,7 +1480,7 @@ ScBaseCell* ScQueryCellIterator::BinarySearch()
{
SCSIZE nMid = (nLo+nHi)/2;
SCSIZE i = nMid;
- while (i <= nHi && pItems[i].pCell->GetCellType() == CELLTYPE_NOTE)
+ while (i <= nHi && pCol->aItems[i].pCell->GetCellType() == CELLTYPE_NOTE)
++i;
if (i > nHi)
{
@@ -1491,14 +1490,14 @@ ScBaseCell* ScQueryCellIterator::BinarySearch()
bDone = true;
continue; // while
}
- sal_Bool bStr = pItems[i].pCell->HasStringData();
+ sal_Bool bStr = pCol->aItems[i].pCell->HasStringData();
nRes = 0;
// compares are content<query:-1, content>query:1
// Cell value comparison similar to ScTable::ValidQuery()
if (!bStr && !bByString)
{
double nCellVal;
- pCell = pItems[i].pCell;
+ pCell = pCol->aItems[i].pCell;
switch ( pCell->GetCellType() )
{
case CELLTYPE_VALUE :
@@ -1552,8 +1551,8 @@ ScBaseCell* ScQueryCellIterator::BinarySearch()
else if (bStr && bByString)
{
rtl::OUString aCellStr;
- sal_uLong nFormat = pCol->GetNumberFormat( pItems[i].nRow);
- ScCellFormat::GetInputString( pItems[i].pCell, nFormat, aCellStr,
+ sal_uLong nFormat = pCol->GetNumberFormat( pCol->aItems[i].nRow);
+ ScCellFormat::GetInputString( pCol->aItems[i].pCell, nFormat, aCellStr,
rFormatter);
nRes = pCollator->compareString(aCellStr, rEntry.GetQueryItem().maString);
if (nRes < 0 && bLessEqual)
@@ -1643,17 +1642,17 @@ ScBaseCell* ScQueryCellIterator::BinarySearch()
// --nLo with nLastInRange == nLo-1. Both conditions combined yield:
nLo = nLastInRange;
}
- if (nLo < pCol->nCount && pCol->pItems[nLo].nRow <= mpParam->nRow2)
+ if (nLo < pCol->aItems.size() && pCol->aItems[nLo].nRow <= mpParam->nRow2)
{
- nRow = pItems[nLo].nRow;
- pCell = pItems[nLo].pCell;
+ nRow = pCol->aItems[nLo].nRow;
+ pCell = pCol->aItems[nLo].pCell;
nColRow = nLo;
}
else
{
nRow = mpParam->nRow2 + 1;
pCell = 0;
- nColRow = pCol->nCount - 1;
+ nColRow = pCol->aItems.size() - 1;
}
return pCell;
}
@@ -1701,9 +1700,9 @@ void ScHorizontalCellIterator::SetTab( SCTAB nTabP )
SCSIZE nIndex;
pCol->Search( nStartRow, nIndex );
- if ( nIndex < pCol->nCount )
+ if ( nIndex < pCol->aItems.size() )
{
- pNextRows[i-nStartCol] = pCol->pItems[nIndex].nRow;
+ pNextRows[i-nStartCol] = pCol->aItems[nIndex].nRow;
pNextIndices[i-nStartCol] = nIndex;
}
else
@@ -1726,11 +1725,11 @@ ScBaseCell* ScHorizontalCellIterator::GetNext( SCCOL& rCol, SCROW& rRow )
ScColumn* pCol = &pDoc->maTabs[nTab]->aCol[nCol];
SCSIZE nIndex = pNextIndices[nCol-nStartCol];
- OSL_ENSURE( nIndex < pCol->nCount, "ScHorizontalCellIterator::GetNext: nIndex out of
range" );
- ScBaseCell* pCell = pCol->pItems[nIndex].pCell;
- if ( ++nIndex < pCol->nCount )
+ OSL_ENSURE( nIndex < pCol->aItems.size(), "ScHorizontalCellIterator::GetNext: nIndex out
of range" );
+ ScBaseCell* pCell = pCol->aItems[nIndex].pCell;
+ if ( ++nIndex < pCol->aItems.size() )
{
- pNextRows[nCol-nStartCol] = pCol->pItems[nIndex].nRow;
+ pNextRows[nCol-nStartCol] = pCol->aItems[nIndex].nRow;
pNextIndices[nCol-nStartCol] = nIndex;
}
else
@@ -1920,7 +1919,7 @@ void ScHorizontalValueIterator::GetCurNumFmtInfo( short& nType, sal_uLong&
nInde
const ScBaseCell* pCell;
SCSIZE nCurIndex;
if ( pCol->Search( nCurRow, nCurIndex ) )
- pCell = pCol->pItems[nCurIndex].pCell;
+ pCell = pCol->aItems[nCurIndex].pCell;
else
pCell = NULL;
if ( pCell && pCell->GetCellType() == CELLTYPE_FORMULA )
diff --git a/sc/source/core/data/fillinfo.cxx b/sc/source/core/data/fillinfo.cxx
index fab6161..6729290 100644
--- a/sc/source/core/data/fillinfo.cxx
+++ b/sc/source/core/data/fillinfo.cxx
@@ -390,8 +390,8 @@ void ScDocument::FillInfo( ScTableInfo& rTabInfo, SCCOL nX1, SCROW nY1, SCCOL nX
bool bHiddenRow = true;
SCROW nHiddenEndRow = -1;
(void) pThisCol->Search( nY1, nUIndex );
- while ( nUIndex < pThisCol->nCount &&
- (nThisRow=pThisCol->pItems[nUIndex].nRow) <= nY2 )
+ while ( nUIndex < pThisCol->aItems.size() &&
+ (nThisRow=pThisCol->aItems[nUIndex].nRow) <= nY2 )
{
if (nThisRow > nHiddenEndRow)
bHiddenRow = RowHidden( nThisRow, nTab, NULL, &nHiddenEndRow);
@@ -403,7 +403,7 @@ void ScDocument::FillInfo( ScTableInfo& rTabInfo, SCCOL nX1, SCROW nY1, SCCOL nX
RowInfo* pThisRowInfo = &pRowInfo[nArrY];
CellInfo* pInfo = &pThisRowInfo->pCellInfo[nArrX];
- pInfo->pCell = pThisCol->pItems[nUIndex].pCell;
+ pInfo->pCell = pThisCol->aItems[nUIndex].pCell;
if (pInfo->pCell->GetCellType() != CELLTYPE_NOTE)
{
pThisRowInfo->bEmptyText = false; // Zeile nicht leer
Context
- [Libreoffice] [PATCH V2] replace open-coded array with std::vector in ScColumn · Noel Grandin
Privacy Policy |
Impressum (Legal Info) |
Copyright information: Unless otherwise specified, all text and images
on this website are licensed under the
Creative Commons Attribution-Share Alike 3.0 License.
This does not include the source code of LibreOffice, which is
licensed under the Mozilla Public License (
MPLv2).
"LibreOffice" and "The Document Foundation" are
registered trademarks of their corresponding registered owners or are
in actual use as trademarks in one or more countries. Their respective
logos and icons are also subject to international copyright laws. Use
thereof is explained in our
trademark policy.