Date: prev next · Thread: first prev next last
2012 Archives by date, by thread · List index


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


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.