change remaining manual loops to ScMarkData::iterator

9 files changed, 433 insertions, 444 deletions

diff --git a/sc/source/ui/docshell/docfunc.cxx b/sc/source/ui/docshell/docfunc.cxx
index 40615a7447f7..6646ec600b30 100644
--- a/sc/source/ui/docshell/docfunc.cxx
+++ b/sc/source/ui/docshell/docfunc.cxx
@@ -633,8 +633,9 @@ sal_Bool ScDocFunc::DeleteContents( const ScMarkData& rMark, sal_uInt16 nFlags,
     {
         bObjects = sal_True;
         SCTAB nTabCount = pDoc->GetTableCount();
-        for (SCTAB nTab=0; nTab<nTabCount; nTab++)
-            if (aMultiMark.GetTableSelect(nTab) && pDoc->IsTabProtected(nTab))
+        ScMarkData::iterator itr = rMark.begin(), itrEnd = rMark.end();
+        for (; itr != itrEnd && *itr < nTabCount; ++itr)
+            if (pDoc->IsTabProtected(*itr))
                 bObjects = false;
     }
 
@@ -739,9 +740,10 @@ sal_Bool ScDocFunc::TransliterateText( const ScMarkData& rMark, sal_Int32 nType,
 
         ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
         pUndoDoc->InitUndo( pDoc, nStartTab, nStartTab );
-        for (SCTAB i=0; i<nTabCount; i++)
-            if (i != nStartTab && rMark.GetTableSelect(i))
-                pUndoDoc->AddUndoTab( i, i );
+        ScMarkData::iterator itr = rMark.begin(), itrEnd = rMark.end();
+        for (; itr != itrEnd && *itr < nTabCount; ++itr)
+            if (*itr != nStartTab)
+                pUndoDoc->AddUndoTab( *itr, *itr );
 
         ScRange aCopyRange = aMarkRange;
         aCopyRange.aStart.SetTab(0);
@@ -1321,9 +1323,10 @@ sal_Bool ScDocFunc::ApplyStyle( const ScMarkData& rMark, const String& rStyleNam
         SCTAB nStartTab = aMultiRange.aStart.Tab();
         SCTAB nTabCount = pDoc->GetTableCount();
         pUndoDoc->InitUndo( pDoc, nStartTab, nStartTab );
-        for (SCTAB i=0; i<nTabCount; i++)
-            if (i != nStartTab && rMark.GetTableSelect(i))
-                pUndoDoc->AddUndoTab( i, i );
+        ScMarkData::iterator itr = rMark.begin(), itrEnd = rMark.end();
+        for (; itr != itrEnd && *itr < nTabCount; ++itr)
+            if (*itr != nStartTab)
+                pUndoDoc->AddUndoTab( *itr, *itr );
 
         ScRange aCopyRange = aMultiRange;
         aCopyRange.aStart.SetTab(0);
@@ -1412,12 +1415,10 @@ sal_Bool ScDocFunc::InsertCells( const ScRange& rRange, const ScMarkData* pTabMa
     }
 
     ScMarkData aFullMark( aMark );          // including scenario sheets
-    for( i=0; i<nTabCount; i++ )
-        if( aMark.GetTableSelect( i ) )
-        {
-            for( SCTAB j = i+1; j<nTabCount && pDoc->IsScenario(j); j++ )
-                aFullMark.SelectTable( j, sal_True );
-        }
+    ScMarkData::iterator itr = aMark.begin(), itrEnd = aMark.end();
+    for (; itr != itrEnd && *itr < nTabCount; ++itr)
+        for( SCTAB j = *itr+1; j<nTabCount && pDoc->IsScenario(j); j++ )
+            aFullMark.SelectTable( j, true );
 
     SCTAB nSelCount = aMark.GetSelectCount();
 
@@ -1492,129 +1493,128 @@ sal_Bool ScDocFunc::InsertCells( const ScRange& rRange, const ScMarkData* pTabMa
     if (bRecord)
         rDocShell.GetUndoManager()->EnterListAction( aUndo, aUndo );
 
-    for( i=0; i<nTabCount; i++ )
+    itr = aMark.begin();
+    for (; itr != itrEnd && nTabCount; ++itr)
     {
-        if( aMark.GetTableSelect(i) )
+        i = *itr;
+        if( pDoc->HasAttrib( nMergeTestStartX, nMergeTestStartY, i, nMergeTestEndX, nMergeTestEndY, i, HASATTR_MERGED | HASATTR_OVERLAPPED ) )
         {
-            if( pDoc->HasAttrib( nMergeTestStartX, nMergeTestStartY, i, nMergeTestEndX, nMergeTestEndY, i, HASATTR_MERGED | HASATTR_OVERLAPPED ) )
-            {
-                if (eCmd==INS_CELLSRIGHT)
-                    bNeedRefresh = sal_True;
+            if (eCmd==INS_CELLSRIGHT)
+                bNeedRefresh = sal_True;
 
-                SCCOL nMergeStartX = nMergeTestStartX;
-                SCROW nMergeStartY = nMergeTestStartY;
-                SCCOL nMergeEndX   = nMergeTestEndX;
-                SCROW nMergeEndY   = nMergeTestEndY;
+            SCCOL nMergeStartX = nMergeTestStartX;
+            SCROW nMergeStartY = nMergeTestStartY;
+            SCCOL nMergeEndX   = nMergeTestEndX;
+            SCROW nMergeEndY   = nMergeTestEndY;
 
-                pDoc->ExtendMerge( nMergeStartX, nMergeStartY, nMergeEndX, nMergeEndY, i );
-                pDoc->ExtendOverlapped( nMergeStartX, nMergeStartY, nMergeEndX, nMergeEndY, i );
+            pDoc->ExtendMerge( nMergeStartX, nMergeStartY, nMergeEndX, nMergeEndY, i );
+            pDoc->ExtendOverlapped( nMergeStartX, nMergeStartY, nMergeEndX, nMergeEndY, i );
 
-                if(( eCmd == INS_CELLSDOWN && ( nMergeStartX != nMergeTestStartX || nMergeEndX != nMergeTestEndX )) ||
-                    (eCmd == INS_CELLSRIGHT && ( nMergeStartY != nMergeTestStartY || nMergeEndY != nMergeTestEndY )) )
-                {
-                    if (!bApi)
-                        rDocShell.ErrorMessage(STR_MSSG_INSERTCELLS_0);
-                    rDocShell.GetUndoManager()->LeaveListAction();
-                    return false;
-                }
+            if(( eCmd == INS_CELLSDOWN && ( nMergeStartX != nMergeTestStartX || nMergeEndX != nMergeTestEndX )) ||
+                (eCmd == INS_CELLSRIGHT && ( nMergeStartY != nMergeTestStartY || nMergeEndY != nMergeTestEndY )) )
+            {
+                if (!bApi)
+                    rDocShell.ErrorMessage(STR_MSSG_INSERTCELLS_0);
+                rDocShell.GetUndoManager()->LeaveListAction();
+                return false;
+            }
 
-                SCCOL nTestCol = -1;
-                SCROW nTestRow1 = -1;
-                SCROW nTestRow2 = -1;
+            SCCOL nTestCol = -1;
+            SCROW nTestRow1 = -1;
+            SCROW nTestRow2 = -1;
 
-                ScDocAttrIterator aTestIter( pDoc, i, nMergeTestStartX, nMergeTestStartY, nMergeTestEndX, nMergeTestEndY );
-                ScRange aExtendRange( nMergeTestStartX, nMergeTestStartY, i, nMergeTestEndX, nMergeTestEndY, i );
-                const ScPatternAttr* pPattern = NULL;
-                const ScMergeAttr* pMergeFlag = NULL;
-                const ScMergeFlagAttr* pMergeFlagAttr = NULL;
-                while ( ( pPattern = aTestIter.GetNext( nTestCol, nTestRow1, nTestRow2 ) ) != NULL )
+            ScDocAttrIterator aTestIter( pDoc, i, nMergeTestStartX, nMergeTestStartY, nMergeTestEndX, nMergeTestEndY );
+            ScRange aExtendRange( nMergeTestStartX, nMergeTestStartY, i, nMergeTestEndX, nMergeTestEndY, i );
+            const ScPatternAttr* pPattern = NULL;
+            const ScMergeAttr* pMergeFlag = NULL;
+            const ScMergeFlagAttr* pMergeFlagAttr = NULL;
+            while ( ( pPattern = aTestIter.GetNext( nTestCol, nTestRow1, nTestRow2 ) ) != NULL )
+            {
+                pMergeFlag = (const ScMergeAttr*) &pPattern->GetItem(ATTR_MERGE);
+                pMergeFlagAttr = (const ScMergeFlagAttr*) &pPattern->GetItem(ATTR_MERGE_FLAG);
+                sal_Int16 nNewFlags = pMergeFlagAttr->GetValue() & ( SC_MF_HOR | SC_MF_VER );
+                if( ( pMergeFlag && pMergeFlag->IsMerged() ) || nNewFlags == SC_MF_HOR || nNewFlags == SC_MF_VER )
                 {
-                    pMergeFlag = (const ScMergeAttr*) &pPattern->GetItem(ATTR_MERGE);
-                    pMergeFlagAttr = (const ScMergeFlagAttr*) &pPattern->GetItem(ATTR_MERGE_FLAG);
-                    sal_Int16 nNewFlags = pMergeFlagAttr->GetValue() & ( SC_MF_HOR | SC_MF_VER );
-                    if( ( pMergeFlag && pMergeFlag->IsMerged() ) || nNewFlags == SC_MF_HOR || nNewFlags == SC_MF_VER )
-                    {
-                        ScRange aRange( nTestCol, nTestRow1, i );
-                        pDoc->ExtendOverlapped(aRange);
-                        pDoc->ExtendMerge(aRange, sal_True, sal_True);
+                    ScRange aRange( nTestCol, nTestRow1, i );
+                    pDoc->ExtendOverlapped(aRange);
+                    pDoc->ExtendMerge(aRange, sal_True, sal_True);
 
-                        if( nTestRow1 < nTestRow2 && nNewFlags == SC_MF_HOR )
+                    if( nTestRow1 < nTestRow2 && nNewFlags == SC_MF_HOR )
+                    {
+                        for( SCROW nTestRow = nTestRow1; nTestRow <= nTestRow2; nTestRow++ )
                         {
-                            for( SCROW nTestRow = nTestRow1; nTestRow <= nTestRow2; nTestRow++ )
+                            ScRange aTestRange( nTestCol, nTestRow, i );
+                            pDoc->ExtendOverlapped( aTestRange );
+                            pDoc->ExtendMerge( aTestRange, sal_True, sal_True);
+                            ScRange aMergeRange( aTestRange.aStart.Col(),aTestRange.aStart.Row(), i );
+                            if( !aExtendRange.In( aMergeRange ) )
                             {
-                                ScRange aTestRange( nTestCol, nTestRow, i );
-                                pDoc->ExtendOverlapped( aTestRange );
-                                pDoc->ExtendMerge( aTestRange, sal_True, sal_True);
-                                ScRange aMergeRange( aTestRange.aStart.Col(),aTestRange.aStart.Row(), i );
-                                if( !aExtendRange.In( aMergeRange ) )
-                                {
-                                    qIncreaseRange.push_back( aTestRange );
-                                    bInsertMerge = sal_True;
-                                }
+                                qIncreaseRange.push_back( aTestRange );
+                                bInsertMerge = sal_True;
                             }
                         }
-                        else
+                    }
+                    else
+                    {
+                        ScRange aMergeRange( aRange.aStart.Col(),aRange.aStart.Row(), i );
+                        if( !aExtendRange.In( aMergeRange ) )
                         {
-                            ScRange aMergeRange( aRange.aStart.Col(),aRange.aStart.Row(), i );
-                            if( !aExtendRange.In( aMergeRange ) )
-                            {
-                                qIncreaseRange.push_back( aRange );
-                            }
-                            bInsertMerge = sal_True;
+                            qIncreaseRange.push_back( aRange );
                         }
+                        bInsertMerge = sal_True;
                     }
                 }
+            }
 
-                if( bInsertMerge )
+            if( bInsertMerge )
+            {
+                if( eCmd == INS_INSROWS || eCmd == INS_CELLSDOWN )
                 {
-                    if( eCmd == INS_INSROWS || eCmd == INS_CELLSDOWN )
+                    nStartRow = aExtendMergeRange.aStart.Row();
+                    nEndRow = aExtendMergeRange.aEnd.Row();
+
+                    if( eCmd == INS_CELLSDOWN )
+                        nEndCol = nMergeTestEndX;
+                    else
                     {
-                        nStartRow = aExtendMergeRange.aStart.Row();
-                        nEndRow = aExtendMergeRange.aEnd.Row();
+                        nStartCol = 0;
+                        nEndCol = MAXCOL;
+                    }
+                }
+                else if( eCmd == INS_CELLSRIGHT || eCmd == INS_INSCOLS )
+                {
 
-                        if( eCmd == INS_CELLSDOWN )
-                            nEndCol = nMergeTestEndX;
-                        else
-                        {
-                            nStartCol = 0;
-                            nEndCol = MAXCOL;
-                        }
+                    nStartCol = aExtendMergeRange.aStart.Col();
+                    nEndCol = aExtendMergeRange.aEnd.Col();
+                    if( eCmd == INS_CELLSRIGHT )
+                    {
+                        nEndRow = nMergeTestEndY;
                     }
-                    else if( eCmd == INS_CELLSRIGHT || eCmd == INS_INSCOLS )
+                    else
                     {
-
-                        nStartCol = aExtendMergeRange.aStart.Col();
-                        nEndCol = aExtendMergeRange.aEnd.Col();
-                        if( eCmd == INS_CELLSRIGHT )
-                        {
-                            nEndRow = nMergeTestEndY;
-                        }
-                        else
-                        {
-                            nStartRow = 0;
-                            nEndRow = MAXROW;
-                        }
+                        nStartRow = 0;
+                        nEndRow = MAXROW;
                     }
+                }
 
-                    if( !qIncreaseRange.empty() )
+                if( !qIncreaseRange.empty() )
+                {
+                    for( ::std::vector<ScRange>::const_iterator iIter( qIncreaseRange.begin()); iIter != qIncreaseRange.end(); ++iIter )
                     {
-                        for( ::std::vector<ScRange>::const_iterator iIter( qIncreaseRange.begin()); iIter != qIncreaseRange.end(); ++iIter )
+                        ScRange aRange( *iIter );
+                        if( pDoc->HasAttrib( aRange, HASATTR_OVERLAPPED | HASATTR_MERGED ) )
                         {
-                            ScRange aRange( *iIter );
-                            if( pDoc->HasAttrib( aRange, HASATTR_OVERLAPPED | HASATTR_MERGED ) )
-                            {
-                                UnmergeCells( aRange, sal_True, sal_True );
-                            }
+                            UnmergeCells( aRange, sal_True, sal_True );
                         }
                     }
                 }
-                else
-                {
-                    if (!bApi)
-                        rDocShell.ErrorMessage(STR_MSSG_INSERTCELLS_0);
-                    rDocShell.GetUndoManager()->LeaveListAction();
-                    return false;
-                }
+            }
+            else
+            {
+                if (!bApi)
+                    rDocShell.ErrorMessage(STR_MSSG_INSERTCELLS_0);
+                rDocShell.GetUndoManager()->LeaveListAction();
+                return false;
             }
         }
     }
@@ -1660,18 +1660,16 @@ sal_Bool ScDocFunc::InsertCells( const ScRange& rRange, const ScMarkData* pTabMa
             pTabs       = new SCTAB[nSelCount];
             pScenarios  = new SCTAB[nSelCount];
             nUndoPos    = 0;
-            for( i=0; i<nTabCount; i++ )
+            itr = aMark.begin();
+            for (; itr != itrEnd && *itr < nTabCount; ++itr)
             {
-                if( aMark.GetTableSelect( i ) )
-                {
-                    SCTAB nCount = 0;
-                    for( SCTAB j=i+1; j<nTabCount && pDoc->IsScenario(j); j++ )
-                        nCount ++;
+                SCTAB nCount = 0;
+                for( SCTAB j=*itr+1; j<nTabCount && pDoc->IsScenario(j); j++ )
+                    nCount ++;
 
-                    pScenarios[nUndoPos] = nCount;
-                    pTabs[nUndoPos] = i;
-                    nUndoPos ++;
-                }
+                pScenarios[nUndoPos] = nCount;
+                pTabs[nUndoPos] = *itr;
+                nUndoPos ++;
             }
 
             if( !bInsertMerge )
@@ -1716,37 +1714,36 @@ sal_Bool ScDocFunc::InsertCells( const ScRange& rRange, const ScMarkData* pTabMa
         if( bInsertMerge )
             rDocShell.GetUndoManager()->LeaveListAction();
 
-        for( i=0; i<nTabCount; i++ )
+        itr = aMark.begin();
+        for (; itr != itrEnd && *itr < nTabCount; ++itr)
         {
-            if( aMark.GetTableSelect( i ) )
-            {
-                if (bNeedRefresh)
-                    pDoc->ExtendMerge( nMergeTestStartX, nMergeTestStartY, nMergeTestEndX, nMergeTestEndY, i, sal_True );
-                else
-                    pDoc->RefreshAutoFilter( nMergeTestStartX, nMergeTestStartY, nMergeTestEndX, nMergeTestEndY, i );
+            i = *itr;
+            if (bNeedRefresh)
+                pDoc->ExtendMerge( nMergeTestStartX, nMergeTestStartY, nMergeTestEndX, nMergeTestEndY, i, sal_True );
+            else
+                pDoc->RefreshAutoFilter( nMergeTestStartX, nMergeTestStartY, nMergeTestEndX, nMergeTestEndY, i );
 
-                if ( eCmd == INS_INSROWS || eCmd == INS_INSCOLS )
-                    pDoc->UpdatePageBreaks( i );
+            if ( eCmd == INS_INSROWS || eCmd == INS_INSCOLS )
+                pDoc->UpdatePageBreaks( i );
 
-                sal_uInt16 nExtFlags = 0;
-                rDocShell.UpdatePaintExt( nExtFlags, nPaintStartX, nPaintStartY, i, nPaintEndX, nPaintEndY, i );
+            sal_uInt16 nExtFlags = 0;
+            rDocShell.UpdatePaintExt( nExtFlags, nPaintStartX, nPaintStartY, i, nPaintEndX, nPaintEndY, i );
 
-                SCTAB nScenarioCount = 0;
+            SCTAB nScenarioCount = 0;
 
-                for( SCTAB j = i+1; j<nTabCount && pDoc->IsScenario(j); j++ )
-                    nScenarioCount ++;
+            for( SCTAB j = i+1; j<nTabCount && pDoc->IsScenario(j); j++ )
+                nScenarioCount ++;
 
-                sal_Bool bAdjusted = ( eCmd == INS_INSROWS ) ? AdjustRowHeight(ScRange(0, nStartRow, i, MAXCOL, nEndRow, i+nScenarioCount )) :
-                                                           AdjustRowHeight(ScRange(0, nPaintStartY, i, MAXCOL, nPaintEndY, i+nScenarioCount ));
-                if (bAdjusted)
-                {
-                    //  paint only what is not done by AdjustRowHeight
-                    if (nPaintFlags & PAINT_TOP)
-                        rDocShell.PostPaint( nPaintStartX, nPaintStartY, i, nPaintEndX, nPaintEndY, i+nScenarioCount, PAINT_TOP );
-                }
-                else
-                    rDocShell.PostPaint( nPaintStartX, nPaintStartY, i, nPaintEndX, nPaintEndY, i+nScenarioCount, nPaintFlags, nExtFlags );
+            sal_Bool bAdjusted = ( eCmd == INS_INSROWS ) ? AdjustRowHeight(ScRange(0, nStartRow, i, MAXCOL, nEndRow, i+nScenarioCount )) :
+                                                       AdjustRowHeight(ScRange(0, nPaintStartY, i, MAXCOL, nPaintEndY, i+nScenarioCount ));
+            if (bAdjusted)
+            {
+                //  paint only what is not done by AdjustRowHeight
+                if (nPaintFlags & PAINT_TOP)
+                    rDocShell.PostPaint( nPaintStartX, nPaintStartY, i, nPaintEndX, nPaintEndY, i+nScenarioCount, PAINT_TOP );
             }
+            else
+                rDocShell.PostPaint( nPaintStartX, nPaintStartY, i, nPaintEndX, nPaintEndY, i+nScenarioCount, nPaintFlags, nExtFlags );
         }
     }
     else
@@ -1836,12 +1833,10 @@ sal_Bool ScDocFunc::DeleteCells( const ScRange& rRange, const ScMarkData* pTabMa
     }
 
     ScMarkData aFullMark( aMark );          // including scenario sheets
-    for( i=0; i<nTabCount; i++ )
-        if( aMark.GetTableSelect( i ) )
-        {
-            for( SCTAB j = i+1; j<nTabCount && pDoc->IsScenario(j); j++ )
-                aFullMark.SelectTable( j, sal_True );
-        }
+    ScMarkData::iterator itr = aMark.begin(), itrEnd = aMark.end();
+    for (; itr != itrEnd && *itr < nTabCount; ++itr)
+        for( SCTAB j = *itr+1; j<nTabCount && pDoc->IsScenario(j); j++ )
+            aFullMark.SelectTable( j, sal_True );
 
     SCTAB nSelCount = aMark.GetSelectCount();
 
@@ -1904,132 +1899,131 @@ sal_Bool ScDocFunc::DeleteCells( const ScRange& rRange, const ScMarkData* pTabMa
     if (bRecord)
         rDocShell.GetUndoManager()->EnterListAction( aUndo, aUndo );
 
-    for( i=0; i<nTabCount; i++ )
+    itr = aMark.begin();
+    for (; itr != itrEnd && *itr < nTabCount; ++itr)
     {
-        if( aMark.GetTableSelect(i) )
+        i = *itr;
+        if ( pDoc->HasAttrib( nUndoStartX, nUndoStartY, i, nMergeTestEndX, nMergeTestEndY, i, HASATTR_MERGED | HASATTR_OVERLAPPED ))
         {
-            if ( pDoc->HasAttrib( nUndoStartX, nUndoStartY, i, nMergeTestEndX, nMergeTestEndY, i, HASATTR_MERGED | HASATTR_OVERLAPPED ))
+            SCCOL nMergeStartX = nUndoStartX;
+            SCROW nMergeStartY = nUndoStartY;
+            SCCOL nMergeEndX   = nMergeTestEndX;
+            SCROW nMergeEndY   = nMergeTestEndY;
+
+            pDoc->ExtendMerge( nMergeStartX, nMergeStartY, nMergeEndX, nMergeEndY, i );
+            pDoc->ExtendOverlapped( nMergeStartX, nMergeStartY, nMergeEndX, nMergeEndY, i );
+            if( ( eCmd == DEL_CELLSUP && ( nMergeStartX != nUndoStartX || nMergeEndX != nMergeTestEndX))||
+                ( eCmd == DEL_CELLSLEFT && ( nMergeStartY != nUndoStartY || nMergeEndY != nMergeTestEndY)))
             {
-                SCCOL nMergeStartX = nUndoStartX;
-                SCROW nMergeStartY = nUndoStartY;
-                SCCOL nMergeEndX   = nMergeTestEndX;
-                SCROW nMergeEndY   = nMergeTestEndY;
-
-                pDoc->ExtendMerge( nMergeStartX, nMergeStartY, nMergeEndX, nMergeEndY, i );
-                pDoc->ExtendOverlapped( nMergeStartX, nMergeStartY, nMergeEndX, nMergeEndY, i );
-                if( ( eCmd == DEL_CELLSUP && ( nMergeStartX != nUndoStartX || nMergeEndX != nMergeTestEndX))||
-                    ( eCmd == DEL_CELLSLEFT && ( nMergeStartY != nUndoStartY || nMergeEndY != nMergeTestEndY)))
-                {
-                    if (!bApi)
-                        rDocShell.ErrorMessage(STR_MSSG_DELETECELLS_0);
-                    rDocShell.GetUndoManager()->LeaveListAction();
-                    return false;
-                }
+                if (!bApi)
+                    rDocShell.ErrorMessage(STR_MSSG_DELETECELLS_0);
+                rDocShell.GetUndoManager()->LeaveListAction();
+                return false;
+            }
 
-                nExtendStartCol = nMergeStartX;
-                nExtendStartRow = nMergeStartY;
-                SCCOL nTestCol = -1;
-                SCROW nTestRow1 = -1;
-                SCROW nTestRow2 = -1;
-
-                ScDocAttrIterator aTestIter( pDoc, i, nUndoStartX, nUndoStartY, nMergeTestEndX, nMergeTestEndY );
-                ScRange aExtendRange( nUndoStartX, nUndoStartY, i, nMergeTestEndX, nMergeTestEndY, i );
-                const ScPatternAttr* pPattern = NULL;
-                const ScMergeAttr* pMergeFlag = NULL;
-                const ScMergeFlagAttr* pMergeFlagAttr = NULL;
-                while ( ( pPattern = aTestIter.GetNext( nTestCol, nTestRow1, nTestRow2 ) ) != NULL )
+            nExtendStartCol = nMergeStartX;
+            nExtendStartRow = nMergeStartY;
+            SCCOL nTestCol = -1;
+            SCROW nTestRow1 = -1;
+            SCROW nTestRow2 = -1;
+
+            ScDocAttrIterator aTestIter( pDoc, i, nUndoStartX, nUndoStartY, nMergeTestEndX, nMergeTestEndY );
+            ScRange aExtendRange( nUndoStartX, nUndoStartY, i, nMergeTestEndX, nMergeTestEndY, i );
+            const ScPatternAttr* pPattern = NULL;
+            const ScMergeAttr* pMergeFlag = NULL;
+            const ScMergeFlagAttr* pMergeFlagAttr = NULL;
+            while ( ( pPattern = aTestIter.GetNext( nTestCol, nTestRow1, nTestRow2 ) ) != NULL )
+            {
+                pMergeFlag = (const ScMergeAttr*) &pPattern->GetItem( ATTR_MERGE );
+                pMergeFlagAttr = (const ScMergeFlagAttr*) &pPattern->GetItem( ATTR_MERGE_FLAG );
+                sal_Int16 nNewFlags = pMergeFlagAttr->GetValue() & ( SC_MF_HOR | SC_MF_VER );
+                if( ( pMergeFlag && pMergeFlag->IsMerged() ) || nNewFlags == SC_MF_HOR || nNewFlags == SC_MF_VER )
                 {
-                    pMergeFlag = (const ScMergeAttr*) &pPattern->GetItem( ATTR_MERGE );
-                    pMergeFlagAttr = (const ScMergeFlagAttr*) &pPattern->GetItem( ATTR_MERGE_FLAG );
-                    sal_Int16 nNewFlags = pMergeFlagAttr->GetValue() & ( SC_MF_HOR | SC_MF_VER );
-                    if( ( pMergeFlag && pMergeFlag->IsMerged() ) || nNewFlags == SC_MF_HOR || nNewFlags == SC_MF_VER )
-                    {
-                        ScRange aRange( nTestCol, nTestRow1, i );
-                        pDoc->ExtendOverlapped( aRange );
-                        pDoc->ExtendMerge( aRange, sal_True, sal_True );
+                    ScRange aRange( nTestCol, nTestRow1, i );
+                    pDoc->ExtendOverlapped( aRange );
+                    pDoc->ExtendMerge( aRange, sal_True, sal_True );
 
-                        if( nTestRow1 < nTestRow2 && nNewFlags == SC_MF_HOR )
+                    if( nTestRow1 < nTestRow2 && nNewFlags == SC_MF_HOR )
+                    {
+                        for( SCROW nTestRow = nTestRow1; nTestRow <= nTestRow2; nTestRow++ )
                         {
-                            for( SCROW nTestRow = nTestRow1; nTestRow <= nTestRow2; nTestRow++ )
+                            ScRange aTestRange( nTestCol, nTestRow, i );
+                            pDoc->ExtendOverlapped( aTestRange );
+                            pDoc->ExtendMerge( aTestRange, sal_True, sal_True);
+                            ScRange aMergeRange( aTestRange.aStart.Col(),aTestRange.aStart.Row(), i );
+                            if( !aExtendRange.In( aMergeRange ) )
                             {
-                                ScRange aTestRange( nTestCol, nTestRow, i );
-                                pDoc->ExtendOverlapped( aTestRange );
-                                pDoc->ExtendMerge( aTestRange, sal_True, sal_True);
-                                ScRange aMergeRange( aTestRange.aStart.Col(),aTestRange.aStart.Row(), i );
-                                if( !aExtendRange.In( aMergeRange ) )
-                                {
-                                    qDecreaseRange.push_back( aTestRange );
-                                    bDeletingMerge = sal_True;
-                                }
+                                qDecreaseRange.push_back( aTestRange );
+                                bDeletingMerge = sal_True;
                             }
                         }
-                        else
+                    }
+                    else
+                    {
+                        ScRange aMergeRange( aRange.aStart.Col(),aRange.aStart.Row(), i );
+                        if( !aExtendRange.In( aMergeRange ) )
                         {
-                            ScRange aMergeRange( aRange.aStart.Col(),aRange.aStart.Row(), i );
-                            if( !aExtendRange.In( aMergeRange ) )
-                            {
-                                qDecreaseRange.push_back( aRange );
-                            }
-                            bDeletingMerge = sal_True;
+                            qDecreaseRange.push_back( aRange );
                         }
+                        bDeletingMerge = sal_True;
                     }
                 }
+            }
+
+            if( bDeletingMerge )
+            {
+
+                if( eCmd == DEL_DELROWS || eCmd == DEL_CELLSUP )
+                {
+                    nStartRow = aExtendMergeRange.aStart.Row();
+                    nEndRow = aExtendMergeRange.aEnd.Row();
+                    bNeedRefresh = sal_True;
 
-                if( bDeletingMerge )
+                    if( eCmd == DEL_CELLSUP )
+                    {
+                        nEndCol = aExtendMergeRange.aEnd.Col();
+                    }
+                    else
+                    {
+                        nStartCol = 0;
+                        nEndCol = MAXCOL;
+                    }
+                }
+                else if( eCmd == DEL_CELLSLEFT || eCmd == DEL_DELCOLS )
                 {
 
-                    if( eCmd == DEL_DELROWS || eCmd == DEL_CELLSUP )
+                    nStartCol = aExtendMergeRange.aStart.Col();
+                    nEndCol = aExtendMergeRange.aEnd.Col();
+                    if( eCmd == DEL_CELLSLEFT )
                     {
-                        nStartRow = aExtendMergeRange.aStart.Row();
                         nEndRow = aExtendMergeRange.aEnd.Row();
                         bNeedRefresh = sal_True;
-
-                        if( eCmd == DEL_CELLSUP )
-                        {
-                            nEndCol = aExtendMergeRange.aEnd.Col();
-                        }
-                        else
-                        {
-                            nStartCol = 0;
-                            nEndCol = MAXCOL;
-                        }
                     }
-                    else if( eCmd == DEL_CELLSLEFT || eCmd == DEL_DELCOLS )
+                    else
                     {
-
-                        nStartCol = aExtendMergeRange.aStart.Col();
-                        nEndCol = aExtendMergeRange.aEnd.Col();
-                        if( eCmd == DEL_CELLSLEFT )
-                        {
-                            nEndRow = aExtendMergeRange.aEnd.Row();
-                            bNeedRefresh = sal_True;
-                        }
-                        else
-                        {
-                            nStartRow = 0;
-                            nEndRow = MAXROW;
-                        }
+                        nStartRow = 0;
+                        nEndRow = MAXROW;
                     }
+                }
 
-                    if( !qDecreaseRange.empty() )
+                if( !qDecreaseRange.empty() )
+                {
+                    for( ::std::vector<ScRange>::const_iterator iIter( qDecreaseRange.begin()); iIter != qDecreaseRange.end(); ++iIter )
                     {
-                        for( ::std::vector<ScRange>::const_iterator iIter( qDecreaseRange.begin()); iIter != qDecreaseRange.end(); ++iIter )
+                        ScRange aRange( *iIter );
+                        if( pDoc->HasAttrib( aRange, HASATTR_OVERLAPPED | HASATTR_MERGED ) )
                         {
-                            ScRange aRange( *iIter );
-                            if( pDoc->HasAttrib( aRange, HASATTR_OVERLAPPED | HASATTR_MERGED ) )
-                            {
-                                UnmergeCells( aRange, sal_True, sal_True );
-                            }
+                            UnmergeCells( aRange, sal_True, sal_True );
                         }
                     }
                 }
-                else
-                {
-                    if (!bApi)
-                        rDocShell.ErrorMessage(STR_MSSG_DELETECELLS_0);
-                    rDocShell.GetUndoManager()->LeaveListAction();
-                    return false;
-                }
+            }
+            else
+            {
+                if (!bApi)
+                    rDocShell.ErrorMessage(STR_MSSG_DELETECELLS_0);
+                rDocShell.GetUndoManager()->LeaveListAction();
+                return false;
             }
         }
     }
@@ -2050,18 +2044,16 @@ sal_Bool ScDocFunc::DeleteCells( const ScRange& rRange, const ScMarkData* pTabMa
 
         pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
         pUndoDoc->InitUndo( pDoc, 0, nTabCount-1, (eCmd==DEL_DELCOLS), (eCmd==DEL_DELROWS) );
-        for( i=0; i<nTabCount; i++ )
+        itr = aMark.begin();
+        for (; itr != itrEnd && *itr < nTabCount; ++itr)
         {
-            if( aMark.GetTableSelect( i ) )
-            {
-                SCTAB nScenarioCount = 0;
+            SCTAB nScenarioCount = 0;
 
-                for( SCTAB j = i+1; j<nTabCount && pDoc->IsScenario(j); j++ )
-                    nScenarioCount ++;
+            for( SCTAB j = *itr+1; j<nTabCount && pDoc->IsScenario(j); j++ )
+                nScenarioCount ++;
 
-                pDoc->CopyToDocument( nUndoStartX, nUndoStartY, i, nUndoEndX, nUndoEndY, i+nScenarioCount,
-                    IDF_ALL | IDF_NOCAPTIONS, false, pUndoDoc );
-            }
+            pDoc->CopyToDocument( nUndoStartX, nUndoStartY, *itr, nUndoEndX, nUndoEndY, i+nScenarioCount,
+                IDF_ALL | IDF_NOCAPTIONS, false, pUndoDoc );
         }
 
         pRefUndoDoc = new ScDocument( SCDOCMODE_UNDO );
@@ -2073,10 +2065,10 @@ sal_Bool ScDocFunc::DeleteCells( const ScRange& rRange, const ScMarkData* pTabMa
     }
 
     sal_uInt16 nExtFlags = 0;
-    for( i=0; i<nTabCount; i++ )
+    itr = aMark.begin();
+    for (; itr != itrEnd && *itr < nTabCount; ++itr)
     {
-        if( aMark.GetTableSelect( i ) )
-            rDocShell.UpdatePaintExt( nExtFlags, nStartCol, nStartRow, i, nEndCol, nEndRow, i );
+        rDocShell.UpdatePaintExt( nExtFlags, nStartCol, nStartRow, *itr, nEndCol, nEndRow, *itr );
     }
 
     sal_Bool bUndoOutline = false;
@@ -2113,9 +2105,9 @@ sal_Bool ScDocFunc::DeleteCells( const ScRange& rRange, const ScMarkData* pTabMa
 
     if ( bRecord )
     {
-        for( i=0; i<nTabCount; i++ )
-            if( aFullMark.GetTableSelect( i ) )
-                pRefUndoDoc->DeleteAreaTab(nUndoStartX,nUndoStartY,nUndoEndX,nUndoEndY, i, IDF_ALL);
+        itr = aFullMark.begin(), itrEnd = aFullMark.end();
+        for (; itr != itrEnd && *itr < nTabCount; ++itr)
+            pRefUndoDoc->DeleteAreaTab(nUndoStartX,nUndoStartY,nUndoEndX,nUndoEndY, *itr, IDF_ALL);
 
             //  alle Tabellen anlegen, damit Formeln kopiert werden koennen:
         pUndoDoc->AddUndoTab( 0, nTabCount-1, false, false );
@@ -2128,18 +2120,16 @@ sal_Bool ScDocFunc::DeleteCells( const ScRange& rRange, const ScMarkData* pTabMa
         SCTAB* pScenarios = new SCTAB[nSelCount];
         SCTAB   nUndoPos  = 0;
 
-        for( i=0; i<nTabCount; i++ )
+        itr = aMark.begin(), itrEnd = aMark.end();
+        for (; itr != itrEnd && *itr < nTabCount; ++itr)
         {
-            if( aMark.GetTableSelect( i ) )
-            {
-                SCTAB nCount = 0;
-                for( SCTAB j=i+1; j<nTabCount && pDoc->IsScenario(j); j++ )
-                    nCount ++;
+            SCTAB nCount = 0;
+            for( SCTAB j=*itr+1; j<nTabCount && pDoc->IsScenario(j); j++ )
+                nCount ++;
 
-                pScenarios[nUndoPos] = nCount;
-                pTabs[nUndoPos] = i;
-                nUndoPos ++;
-            }
+            pScenarios[nUndoPos] = nCount;
+            pTabs[nUndoPos] = *itr;
+            nUndoPos ++;
         }
 
         if( !bDeletingMerge )
@@ -2219,46 +2209,42 @@ sal_Bool ScDocFunc::DeleteCells( const ScRange& rRange, const ScMarkData* pTabMa
 
         pDoc->ApplyPatternArea( nExtendStartCol, nExtendStartRow, nMergeTestEndX, nMergeTestEndY, aMark, aPattern );
 
-        for( i=0; i<nTabCount; i++ )
+        itr = aMark.begin(), itrEnd = aMark.end();
+        for (; itr != itrEnd && *itr < nTabCount; ++itr)
         {
-            if( aMark.GetTableSelect( i ) )
-            {
-                SCTAB nScenarioCount = 0;
+            SCTAB nScenarioCount = 0;
 
-                for( SCTAB j = i+1; j<nTabCount && pDoc->IsScenario(j); j++ )
-                    nScenarioCount ++;
+            for( SCTAB j = *itr+1; j<nTabCount && pDoc->IsScenario(j); j++ )
+                nScenarioCount ++;
 
-                ScRange aMergedRange( nExtendStartCol, nExtendStartRow, i, nMergeTestEndX, nMergeTestEndY, i+nScenarioCount );
-                pDoc->ExtendMerge( aMergedRange, sal_True );
-            }
+            ScRange aMergedRange( nExtendStartCol, nExtendStartRow, *itr, nMergeTestEndX, nMergeTestEndY, *itr+nScenarioCount );
+            pDoc->ExtendMerge( aMergedRange, sal_True );
         }
     }
 
-    for( i=0; i<nTabCount; i++ )
+    itr = aMark.begin(), itrEnd = aMark.end();
+    for (; itr != itrEnd && *itr < nTabCount; ++itr)
     {
-        if( aMark.GetTableSelect( i ) )
-        {
-            if ( eCmd == DEL_DELCOLS || eCmd == DEL_DELROWS )
-                pDoc->UpdatePageBreaks( i );
+        if ( eCmd == DEL_DELCOLS || eCmd == DEL_DELROWS )
+            pDoc->UpdatePageBreaks( *itr );
 
-            rDocShell.UpdatePaintExt( nExtFlags, nPaintStartX, nPaintStartY, i, nPaintEndX, nPaintEndY, i );
+        rDocShell.UpdatePaintExt( nExtFlags, nPaintStartX, nPaintStartY, *itr, nPaintEndX, nPaintEndY, *itr );
 
-            SCTAB nScenarioCount = 0;
+        SCTAB nScenarioCount = 0;
 
-            for( SCTAB j = i+1; j<nTabCount && pDoc->IsScenario(j); j++ )
-                nScenarioCount ++;
+        for( SCTAB j = *itr+1; j<nTabCount && pDoc->IsScenario(j); j++ )
+            nScenarioCount ++;
 
-            //  ganze Zeilen loeschen: nichts anpassen
-            if ( eCmd == DEL_DELROWS || !AdjustRowHeight(ScRange( 0, nPaintStartY, i, MAXCOL, nPaintEndY, i+nScenarioCount )) )
-                rDocShell.PostPaint( nPaintStartX, nPaintStartY, i, nPaintEndX, nPaintEndY, i+nScenarioCount, nPaintFlags,  nExtFlags );
-            else
-            {
-                //  paint only what is not done by AdjustRowHeight
-                if (nExtFlags & SC_PF_LINES)
-                    lcl_PaintAbove( rDocShell, ScRange( nPaintStartX, nPaintStartY, i, nPaintEndX, nPaintEndY, i+nScenarioCount) );
-                if (nPaintFlags & PAINT_TOP)
-                    rDocShell.PostPaint( nPaintStartX, nPaintStartY, i, nPaintEndX, nPaintEndY, i+nScenarioCount, PAINT_TOP );
-            }
+        //  ganze Zeilen loeschen: nichts anpassen
+        if ( eCmd == DEL_DELROWS || !AdjustRowHeight(ScRange( 0, nPaintStartY, *itr, MAXCOL, nPaintEndY, *itr+nScenarioCount )) )
+            rDocShell.PostPaint( nPaintStartX, nPaintStartY, *itr, nPaintEndX, nPaintEndY, i+nScenarioCount, nPaintFlags,  nExtFlags );
+        else
+        {
+            //  paint only what is not done by AdjustRowHeight
+            if (nExtFlags & SC_PF_LINES)
+                lcl_PaintAbove( rDocShell, ScRange( nPaintStartX, nPaintStartY, *itr, nPaintEndX, nPaintEndY, *itr+nScenarioCount) );
+            if (nPaintFlags & PAINT_TOP)
+                rDocShell.PostPaint( nPaintStartX, nPaintStartY, *itr, nPaintEndX, nPaintEndY, *itr+nScenarioCount, PAINT_TOP );
         }
     }
     aModificator.SetDocumentModified();
@@ -3638,9 +3624,10 @@ sal_Bool ScDocFunc::ChangeIndent( const ScMarkData& rMark, sal_Bool bIncrement,
 
         ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
         pUndoDoc->InitUndo( pDoc, nStartTab, nStartTab );
-        for (SCTAB i=0; i<nTabCount; i++)
-            if (i != nStartTab && rMark.GetTableSelect(i))
-                pUndoDoc->AddUndoTab( i, i );
+        ScMarkData::iterator itr = rMark.begin(), itrEnd = rMark.end();
+        for (; itr != itrEnd && *itr < nTabCount; ++itr)
+            if (*itr != nStartTab)
+                pUndoDoc->AddUndoTab( *itr, *itr );
 
         ScRange aCopyRange = aMarkRange;
         aCopyRange.aStart.SetTab(0);
@@ -3713,9 +3700,10 @@ sal_Bool ScDocFunc::AutoFormat( const ScRange& rRange, const ScMarkData* pTabMar
         {
             pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
             pUndoDoc->InitUndo( pDoc, nStartTab, nStartTab, bSize, bSize );
-            for (SCTAB i=0; i<nTabCount; i++)
-                if (i != nStartTab && aMark.GetTableSelect(i))
-                    pUndoDoc->AddUndoTab( i, i, bSize, bSize );
+            ScMarkData::iterator itr = aMark.begin(), itrEnd = aMark.end();
+            for (; itr != itrEnd && *itr < nTabCount; ++itr)
+                if (*itr != nStartTab)
+                    pUndoDoc->AddUndoTab( *itr, *itr, bSize, bSize );
 
             ScRange aCopyRange = rRange;
             aCopyRange.aStart.SetTab(0);
@@ -3738,29 +3726,27 @@ sal_Bool ScDocFunc::AutoFormat( const ScRange& rRange, const ScMarkData* pTabMar
             SCCOLROW nCols[2] = { nStartCol, nEndCol };
             SCCOLROW nRows[2] = { nStartRow, nEndRow };
 
-            for (SCTAB nTab=0; nTab<nTabCount; nTab++)
-                if (aMark.GetTableSelect(nTab))
-                {
-                    SetWidthOrHeight( sal_True, 1,nCols, nTab, SC_SIZE_VISOPT, STD_EXTRA_WIDTH, false, sal_True);
-                    SetWidthOrHeight( false,1,nRows, nTab, SC_SIZE_VISOPT, 0, false, false);
-                    rDocShell.PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab,
-                                    PAINT_GRID | PAINT_LEFT | PAINT_TOP );
-                }
+            ScMarkData::iterator itr = aMark.begin(), itrEnd = aMark.end();
+            for (; itr != itrEnd && *itr < nTabCount; ++itr)
+                SetWidthOrHeight( sal_True, 1,nCols, *itr, SC_SIZE_VISOPT, STD_EXTRA_WIDTH, false, sal_True);
+                SetWidthOrHeight( false,1,nRows, *itr, SC_SIZE_VISOPT, 0, false, false);
+                rDocShell.PostPaint( 0,0,*itr, MAXCOL,MAXROW,*itr,
+                                PAINT_GRID | PAINT_LEFT | PAINT_TOP );
         }
         else
         {
-            for (SCTAB nTab=0; nTab<nTabCount; nTab++)
-                if (aMark.GetTableSelect(nTab))
-                {
-                    sal_Bool bAdj = AdjustRowHeight( ScRange(nStartCol, nStartRow, nTab,
-                                                        nEndCol, nEndRow, nTab), false );
-                    if (bAdj)
-                        rDocShell.PostPaint( 0,nStartRow,nTab, MAXCOL,MAXROW,nTab,
-                                            PAINT_GRID | PAINT_LEFT );
-                    else
-                        rDocShell.PostPaint( nStartCol, nStartRow, nTab,
-                                            nEndCol, nEndRow, nTab, PAINT_GRID );
-                }
+            ScMarkData::iterator itr = aMark.begin(), itrEnd = aMark.end();
+            for (; itr != itrEnd && *itr < nTabCount; ++itr)
+            {
+                sal_Bool bAdj = AdjustRowHeight( ScRange(nStartCol, nStartRow, *itr,
+                                                    nEndCol, nEndRow, *itr), false );
+                if (bAdj)
+                    rDocShell.PostPaint( 0,nStartRow,*itr, MAXCOL,MAXROW,*itr,
+                                        PAINT_GRID | PAINT_LEFT );
+                else
+                    rDocShell.PostPaint( nStartCol, nStartRow, *itr,
+                                        nEndCol, nEndRow, *itr, PAINT_GRID );
+            }
         }
 
         if ( bRecord )      // Draw-Undo erst jetzt verfuegbar
@@ -4004,9 +3990,10 @@ sal_Bool ScDocFunc::FillSimple( const ScRange& rRange, const ScMarkData* pTabMar
 
             pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
             pUndoDoc->InitUndo( pDoc, nDestStartTab, nDestStartTab );
-            for (SCTAB i=0; i<nTabCount; i++)
-                if (i != nDestStartTab && aMark.GetTableSelect(i))
-                    pUndoDoc->AddUndoTab( i, i );
+            ScMarkData::iterator itr = aMark.begin(), itrEnd = aMark.end();
+            for (; itr != itrEnd && *itr < nTabCount; ++itr)
+                if (*itr != nDestStartTab)
+                    pUndoDoc->AddUndoTab( *itr, *itr );
 
             ScRange aCopyRange = aDestArea;
             aCopyRange.aStart.SetTab(0);
@@ -4109,9 +4096,10 @@ sal_Bool ScDocFunc::FillSeries( const ScRange& rRange, const ScMarkData* pTabMar
 
             pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
             pUndoDoc->InitUndo( pDoc, nDestStartTab, nDestStartTab );
-            for (SCTAB i=0; i<nTabCount; i++)
-                if (i != nDestStartTab && aMark.GetTableSelect(i))
-                    pUndoDoc->AddUndoTab( i, i );
+            ScMarkData::iterator itr = aMark.begin(), itrEnd = aMark.end();
+            for (; itr != itrEnd && *itr < nTabCount; ++itr)
+                if (*itr != nDestStartTab)
+                    pUndoDoc->AddUndoTab( *itr, *itr );
 
             pDoc->CopyToDocument(
                 aDestArea.aStart.Col(), aDestArea.aStart.Row(), 0,
@@ -4248,9 +4236,10 @@ sal_Bool ScDocFunc::FillAuto( ScRange& rRange, const ScMarkData* pTabMark, FillD
 
         pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
         pUndoDoc->InitUndo( pDoc, nDestStartTab, nDestStartTab );
-        for (SCTAB i=0; i<nTabCount; i++)
-            if (i != nDestStartTab && aMark.GetTableSelect(i))
-                pUndoDoc->AddUndoTab( i, i );
+        ScMarkData::iterator itr = aMark.begin(), itrEnd = aMark.end();
+        for (; itr != itrEnd && nTabCount; ++itr)
+            if (*itr != nDestStartTab)
+                pUndoDoc->AddUndoTab( *itr, *itr );
 
         // do not clone note captions in undo document
         pDoc->CopyToDocument(
diff --git a/sc/source/ui/docshell/editable.cxx b/sc/source/ui/docshell/editable.cxx
index 4e5535f92677..daae0c5abdc8 100644
--- a/sc/source/ui/docshell/editable.cxx
+++ b/sc/source/ui/docshell/editable.cxx
@@ -104,9 +104,9 @@ void ScEditableTester::TestSelectedBlock( ScDocument* pDoc,
                         const ScMarkData& rMark )
 {
     SCTAB nTabCount = pDoc->GetTableCount();
-    for (SCTAB nTab=0; nTab<nTabCount; nTab++)
-        if (rMark.GetTableSelect(nTab))
-            TestBlock( pDoc, nTab, nStartCol, nStartRow, nEndCol, nEndRow );
+    ScMarkData::iterator itr = rMark.begin(), itrEnd = rMark.end();
+    for (; itr != itrEnd && *itr < nTabCount; ++itr)
+        TestBlock( pDoc, *itr, nStartCol, nStartRow, nEndCol, nEndRow );
 }
 
 void ScEditableTester::TestRange( ScDocument* pDoc, const ScRange& rRange )
diff --git a/sc/source/ui/undo/undoblk.cxx b/sc/source/ui/undo/undoblk.cxx
index 16eed11a4aba..4b046f839ad4 100644
--- a/sc/source/ui/undo/undoblk.cxx
+++ b/sc/source/ui/undo/undoblk.cxx
@@ -991,18 +991,18 @@ void ScUndoPaste::DoChange( const sal_Bool bUndo )
 
     SCTAB nFirstSelected = aMarkData.GetFirstSelected();
     ScRange aTabSelectRange = aBlockRange;
-    SCTAB nTab;
 
     if ( !bUndo && pRedoDoc )       // Redo: UndoToDocument before handling RefData
     {
         aTabSelectRange.aStart.SetTab( nFirstSelected );
         aTabSelectRange.aEnd.SetTab( nFirstSelected );
         pRedoDoc->UndoToDocument( aTabSelectRange, nUndoFlags, false, pDoc );
-        for (nTab=0; nTab<nTabCount; nTab++)
-            if (nTab != nFirstSelected && aMarkData.GetTableSelect(nTab))
+        ScMarkData::iterator itr = aMarkData.begin(), itrEnd = aMarkData.end();
+        for (; itr != itrEnd && *itr < nTabCount; ++itr)
+            if (*itr != nFirstSelected)
             {
-                aTabSelectRange.aStart.SetTab( nTab );
-                aTabSelectRange.aEnd.SetTab( nTab );
+                aTabSelectRange.aStart.SetTab( *itr );
+                aTabSelectRange.aEnd.SetTab( *itr );
                 pRedoDoc->CopyToDocument( aTabSelectRange, nUndoFlags, false, pDoc );
             }
     }
@@ -1022,11 +1022,12 @@ void ScUndoPaste::DoChange( const sal_Bool bUndo )
         aTabSelectRange.aStart.SetTab( nFirstSelected );
         aTabSelectRange.aEnd.SetTab( nFirstSelected );
         pUndoDoc->UndoToDocument( aTabSelectRange, nUndoFlags, false, pDoc );
-        for (nTab=0; nTab<nTabCount; nTab++)
-            if (nTab != nFirstSelected && aMarkData.GetTableSelect(nTab))
+        ScMarkData::iterator itr = aMarkData.begin(), itrEnd = aMarkData.end();
+        for (; itr != itrEnd && *itr < nTabCount; ++itr)
+            if (*itr != nFirstSelected)
             {
-                aTabSelectRange.aStart.SetTab( nTab );
-                aTabSelectRange.aEnd.SetTab( nTab );
+                aTabSelectRange.aStart.SetTab( *itr );
+                aTabSelectRange.aEnd.SetTab( *itr );
                 pUndoDoc->UndoToDocument( aTabSelectRange, nUndoFlags, false, pDoc );
             }
     }
diff --git a/sc/source/ui/undo/undoblk2.cxx b/sc/source/ui/undo/undoblk2.cxx
index 208a10d437cc..fc2a02e0caef 100644
--- a/sc/source/ui/undo/undoblk2.cxx
+++ b/sc/source/ui/undo/undoblk2.cxx
@@ -128,26 +128,25 @@ void ScUndoWidthOrHeight::Undo()
         pDoc->SetOutlineTable( nStartTab, pUndoTab );
 
     SCTAB nTabCount = pDoc->GetTableCount();
-    SCTAB nTab;
-    for (nTab=0; nTab<nTabCount; nTab++)
-        if (aMarkData.GetTableSelect(nTab))
+    ScMarkData::iterator itr = aMarkData.begin(), itrEnd = aMarkData.end();
+    for (; itr != itrEnd && *itr < nTabCount; ++itr)
+    {
+        if (bWidth) // Width
+        {
+            pUndoDoc->CopyToDocument( static_cast<SCCOL>(nStart), 0, *itr,
+                    static_cast<SCCOL>(nEnd), MAXROW, *itr, IDF_NONE,
+                    false, pDoc );
+            pDoc->UpdatePageBreaks( *itr );
+            pDocShell->PostPaint( static_cast<SCCOL>(nPaintStart), 0, *itr,
+                    MAXCOL, MAXROW, *itr, PAINT_GRID | PAINT_TOP );
+        }
+        else        // Height
         {
-            if (bWidth) // Width
-            {
-                pUndoDoc->CopyToDocument( static_cast<SCCOL>(nStart), 0, nTab,
-                        static_cast<SCCOL>(nEnd), MAXROW, nTab, IDF_NONE,
-                        false, pDoc );
-                pDoc->UpdatePageBreaks( nTab );
-                pDocShell->PostPaint( static_cast<SCCOL>(nPaintStart), 0, nTab,
-                        MAXCOL, MAXROW, nTab, PAINT_GRID | PAINT_TOP );
-            }
-            else        // Height
-            {
-                pUndoDoc->CopyToDocument( 0, nStart, nTab, MAXCOL, nEnd, nTab, IDF_NONE, false, pDoc );
-                pDoc->UpdatePageBreaks( nTab );
-                pDocShell->PostPaint( 0, nPaintStart, nTab, MAXCOL, MAXROW, nTab, PAINT_GRID | PAINT_LEFT );
-            }
+            pUndoDoc->CopyToDocument( 0, nStart, *itr, MAXCOL, nEnd, *itr, IDF_NONE, false, pDoc );
+            pDoc->UpdatePageBreaks( *itr );
+            pDocShell->PostPaint( 0, nPaintStart, *itr, MAXCOL, MAXROW, *itr, PAINT_GRID | PAINT_LEFT );
         }
+    }
 
     DoSdrUndoAction( pDrawUndo, pDoc );
 
diff --git a/sc/source/ui/undo/undoblk3.cxx b/sc/source/ui/undo/undoblk3.cxx
index 1ee860414220..6f467e7f7411 100644
--- a/sc/source/ui/undo/undoblk3.cxx
+++ b/sc/source/ui/undo/undoblk3.cxx
@@ -320,12 +320,13 @@ void ScUndoFillTable::SetChangeTrack()
         ScRange aWorkRange(aRange);
         nStartChangeAction = 0;
         sal_uLong nTmpAction;
-        for ( SCTAB i = 0; i < nTabCount; i++ )
+        ScMarkData::iterator itr = aMarkData.begin(), itrEnd = aMarkData.end();
+        for (; itr != itrEnd && *itr < nTabCount; ++itr)
         {
-            if (i != nSrcTab && aMarkData.GetTableSelect(i))
+            if (*itr != nSrcTab)
             {
-                aWorkRange.aStart.SetTab(i);
-                aWorkRange.aEnd.SetTab(i);
+                aWorkRange.aStart.SetTab(*itr);
+                aWorkRange.aEnd.SetTab(*itr);
                 pChangeTrack->AppendContentRange( aWorkRange, pUndoDoc,
                     nTmpAction, nEndChangeAction );
                 if ( !nStartChangeAction )
@@ -350,13 +351,14 @@ void ScUndoFillTable::DoChange( const sal_Bool bUndo )
     {
         SCTAB nTabCount = pDoc->GetTableCount();
         ScRange aWorkRange(aRange);
-        for ( SCTAB i = 0; i < nTabCount; i++ )
-            if (i != nSrcTab && aMarkData.GetTableSelect(i))
+        ScMarkData::iterator itr = aMarkData.begin(), itrEnd = aMarkData.end();
+        for (; itr != itrEnd && *itr < nTabCount; ++itr)
+            if (*itr != nSrcTab)
             {
-                aWorkRange.aStart.SetTab(i);
-                aWorkRange.aEnd.SetTab(i);
+                aWorkRange.aStart.SetTab(*itr);
+                aWorkRange.aEnd.SetTab(*itr);
                 if (bMulti)
-                    pDoc->DeleteSelectionTab( i, IDF_ALL, aMarkData );
+                    pDoc->DeleteSelectionTab( *itr, IDF_ALL, aMarkData );
                 else
                     pDoc->DeleteAreaTab( aWorkRange, IDF_ALL );
                 pUndoDoc->CopyToDocument( aWorkRange, IDF_ALL, bMulti, pDoc, &aMarkData );
@@ -653,22 +655,20 @@ void ScUndoAutoFill::Undo()
     ScDocument* pDoc = pDocShell->GetDocument();
 
     SCTAB nTabCount = pDoc->GetTableCount();
-    for (SCTAB nTab=0; nTab<nTabCount; nTab++)
+    ScMarkData::iterator itr = aMarkData.begin(), itrEnd = aMarkData.end();
+    for (; itr != itrEnd && *itr < nTabCount; ++itr)
     {
-        if (aMarkData.GetTableSelect(nTab))
-        {
-            ScRange aWorkRange = aBlockRange;
-            aWorkRange.aStart.SetTab(nTab);
-            aWorkRange.aEnd.SetTab(nTab);
+        ScRange aWorkRange = aBlockRange;
+        aWorkRange.aStart.SetTab(*itr);
+        aWorkRange.aEnd.SetTab(*itr);
 
-            sal_uInt16 nExtFlags = 0;
-            pDocShell->UpdatePaintExt( nExtFlags, aWorkRange );
-            pDoc->DeleteAreaTab( aWorkRange, IDF_AUTOFILL );
-            pUndoDoc->CopyToDocument( aWorkRange, IDF_AUTOFILL, false, pDoc );
+        sal_uInt16 nExtFlags = 0;
+        pDocShell->UpdatePaintExt( nExtFlags, aWorkRange );
+        pDoc->DeleteAreaTab( aWorkRange, IDF_AUTOFILL );
+        pUndoDoc->CopyToDocument( aWorkRange, IDF_AUTOFILL, false, pDoc );
 
-            pDoc->ExtendMerge( aWorkRange, sal_True );
-            pDocShell->PostPaint( aWorkRange, PAINT_GRID, nExtFlags );
-        }
+        pDoc->ExtendMerge( aWorkRange, sal_True );
+        pDocShell->PostPaint( aWorkRange, PAINT_GRID, nExtFlags );
     }
     pDocShell->PostDataChanged();
     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
diff --git a/sc/source/ui/unoobj/cellsuno.cxx b/sc/source/ui/unoobj/cellsuno.cxx
index 9107e1d2a226..9d33a95a061f 100644
--- a/sc/source/ui/unoobj/cellsuno.cxx
+++ b/sc/source/ui/unoobj/cellsuno.cxx
@@ -4015,10 +4015,11 @@ sal_Int32 SAL_CALL ScCellRangesBase::replaceAll( const uno::Reference<util::XSea
                 ScMarkData aMark(*GetMarkData());
 
                 SCTAB nTabCount = pDoc->GetTableCount();
-                sal_Bool bProtected = !pDocShell->IsEditable();
-                for (SCTAB i=0; i<nTabCount; i++)
-                    if ( aMark.GetTableSelect(i) && pDoc->IsTabProtected(i) )
-                        bProtected = sal_True;
+                bool bProtected = !pDocShell->IsEditable();
+                ScMarkData::iterator itr = aMark.begin(), itrEnd = aMark.end();
+                for (; itr != itrEnd && *itr < nTabCount; ++itr)
+                    if ( pDoc->IsTabProtected(*itr) )
+                        bProtected = true;
                 if (bProtected)
                 {
                     //! Exception, oder was?
@@ -4036,9 +4037,10 @@ sal_Int32 SAL_CALL ScCellRangesBase::replaceAll( const uno::Reference<util::XSea
                         pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
                         pUndoDoc->InitUndo( pDoc, nTab, nTab );
                     }
-                    for (SCTAB i=0; i<nTabCount; i++)
-                        if ( aMark.GetTableSelect(i) && i != nTab && bUndo)
-                            pUndoDoc->AddUndoTab( i, i );
+                    itr = aMark.begin();
+                    for (; itr != itrEnd && *itr < nTabCount; ++itr)
+                        if ( *itr != nTab && bUndo)
+                            pUndoDoc->AddUndoTab( *itr, *itr );
                     ScMarkData* pUndoMark = NULL;
                     if (bUndo)
                         pUndoMark = new ScMarkData(aMark);
diff --git a/sc/source/ui/unoobj/docuno.cxx b/sc/source/ui/unoobj/docuno.cxx
index d77bb37a56c3..8645e9f44ed3 100644
--- a/sc/source/ui/unoobj/docuno.cxx
+++ b/sc/source/ui/unoobj/docuno.cxx
@@ -2186,50 +2186,51 @@ void ScModelObj::NotifyChanges( const ::rtl::OUString& rOperation, const ScRange
         aMarkData.MarkFromRangeList( rRanges, false );
         ScDocument* pDoc = pDocShell->GetDocument();
         SCTAB nTabCount = pDoc->GetTableCount();
-        for (SCTAB nTab = 0; nTab < nTabCount; nTab++)
-            if (aMarkData.GetTableSelect(nTab))
+        ScMarkData::iterator itr = aMarkData.begin(), itrEnd = aMarkData.end();
+        for (; itr != itrEnd && *itr < nTabCount; ++itr)
+        {
+            SCTAB nTab = *itr;
+            const ScSheetEvents* pEvents = pDoc->GetSheetEvents(nTab);
+            if (pEvents)
             {
-                const ScSheetEvents* pEvents = pDoc->GetSheetEvents(nTab);
-                if (pEvents)
+                const rtl::OUString* pScript = pEvents->GetScript(SC_SHEETEVENT_CHANGE);
+                if (pScript)
                 {
-                    const rtl::OUString* pScript = pEvents->GetScript(SC_SHEETEVENT_CHANGE);
-                    if (pScript)
+                    ScRangeList aTabRanges;     // collect ranges on this sheet
+                    size_t nRangeCount = rRanges.size();
+                    for ( size_t nIndex = 0; nIndex < nRangeCount; ++nIndex )
                     {
-                        ScRangeList aTabRanges;     // collect ranges on this sheet
-                        size_t nRangeCount = rRanges.size();
-                        for ( size_t nIndex = 0; nIndex < nRangeCount; ++nIndex )
-                        {
-                            ScRange aRange( *rRanges[ nIndex ] );
-                            if ( aRange.aStart.Tab() == nTab )
-                                aTabRanges.Append( aRange );
-                        }
-                        size_t nTabRangeCount = aTabRanges.size();
-                        if ( nTabRangeCount > 0 )
+                        ScRange aRange( *rRanges[ nIndex ] );
+                        if ( aRange.aStart.Tab() == nTab )
+                            aTabRanges.Append( aRange );
+                    }
+                    size_t nTabRangeCount = aTabRanges.size();
+                    if ( nTabRangeCount > 0 )
+                    {
+                        uno::Reference<uno::XInterface> xTarget;
+                        if ( nTabRangeCount == 1 )
                         {
-                            uno::Reference<uno::XInterface> xTarget;
-                            if ( nTabRangeCount == 1 )
-                            {
-                                ScRange aRange( *aTabRanges[ 0 ] );
-                                if ( aRange.aStart == aRange.aEnd )
-                                    xTarget.set( static_cast<cppu::OWeakObject*>( new ScCellObj( pDocShell, aRange.aStart ) ) );
-                                else
-                                    xTarget.set( static_cast<cppu::OWeakObject*>( new ScCellRangeObj( pDocShell, aRange ) ) );
-                            }
+                            ScRange aRange( *aTabRanges[ 0 ] );
+                            if ( aRange.aStart == aRange.aEnd )
+                                xTarget.set( static_cast<cppu::OWeakObject*>( new ScCellObj( pDocShell, aRange.aStart ) ) );
                             else
-                                xTarget.set( static_cast<cppu::OWeakObject*>( new ScCellRangesObj( pDocShell, aTabRanges ) ) );
+                                xTarget.set( static_cast<cppu::OWeakObject*>( new ScCellRangeObj( pDocShell, aRange ) ) );
+                        }
+                        else
+                            xTarget.set( static_cast<cppu::OWeakObject*>( new ScCellRangesObj( pDocShell, aTabRanges ) ) );
 
-                            uno::Sequence<uno::Any> aParams(1);
-                            aParams[0] <<= xTarget;
+                        uno::Sequence<uno::Any> aParams(1);
+                        aParams[0] <<= xTarget;
 
-                            uno::Any aRet;
-                            uno::Sequence<sal_Int16> aOutArgsIndex;
-                            uno::Sequence<uno::Any> aOutArgs;
+                        uno::Any aRet;
+                        uno::Sequence<sal_Int16> aOutArgsIndex;
+                        uno::Sequence<uno::Any> aOutArgs;
 
-                            /*ErrCode eRet =*/ pDocShell->CallXScript( *pScript, aParams, aRet, aOutArgsIndex, aOutArgs );
-                        }
+                        /*ErrCode eRet =*/ pDocShell->CallXScript( *pScript, aParams, aRet, aOutArgsIndex, aOutArgs );
                     }
                 }
             }
+        }
     }
 }
 
diff --git a/sc/source/ui/vba/vbawindow.cxx b/sc/source/ui/vba/vbawindow.cxx
index 42c21cc953ce..8bbf74ffc02b 100644
--- a/sc/source/ui/vba/vbawindow.cxx
+++ b/sc/source/ui/vba/vbawindow.cxx
@@ -126,15 +126,13 @@ public:
         sheets.reserve( nTabCount );
         uno::Reference <sheet::XSpreadsheetDocument> xSpreadSheet( m_xModel, uno::UNO_QUERY_THROW );
         uno::Reference <container::XIndexAccess> xIndex( xSpreadSheet->getSheets(), uno::UNO_QUERY_THROW );
-        for ( SCTAB nTab=0; nTab<nTabCount; nTab++ )
+        ScMarkData::iterator itr = rMarkData.begin(), itrEnd = rMarkData.end();
+        for (; itr != itrEnd && *itr < nTabCount; ++itr)
         {
-            if ( rMarkData.GetTableSelect(nTab) )
-            {
-                uno::Reference< sheet::XSpreadsheet > xSheet( xIndex->getByIndex( nTab ), uno::UNO_QUERY_THROW );
-                uno::Reference< container::XNamed > xNamed( xSheet, uno::UNO_QUERY_THROW );
-                sheets.push_back( xSheet );
-                namesToIndices[ xNamed->getName() ] = nIndex++;
-            }
+            uno::Reference< sheet::XSpreadsheet > xSheet( xIndex->getByIndex( *itr ), uno::UNO_QUERY_THROW );
+            uno::Reference< container::XNamed > xNamed( xSheet, uno::UNO_QUERY_THROW );
+            sheets.push_back( xSheet );
+            namesToIndices[ xNamed->getName() ] = nIndex++;
         }
 
     }
diff --git a/sc/source/ui/view/formatsh.cxx b/sc/source/ui/view/formatsh.cxx
index f7ea3973a3b5..d4cc64f7af9a 100644
--- a/sc/source/ui/view/formatsh.cxx
+++ b/sc/source/ui/view/formatsh.cxx
@@ -625,19 +625,18 @@ void ScFormatShell::ExecuteStyle( SfxRequest& rReq )
                         if ( pStyleSheet && !pScMod->GetIsWaterCan() )
                         {
                             ScUndoApplyPageStyle* pUndoAction = 0;
-                            for( SCTAB nTab = 0, nTabCount = pDoc->GetTableCount(); nTab < nTabCount; ++nTab )
+                            SCTAB nTabCount = pDoc->GetTableCount();
+                            ScMarkData::iterator itr = rMark.begin(), itrEnd = rMark.end();
+                            for (; itr != itrEnd && *itr < nTabCount; ++itr)
                             {
-                                if( rMark.GetTableSelect( nTab ) )
+                                String aOldName = pDoc->GetPageStyle( *itr );
+                                if ( aOldName != aStyleName )
                                 {
-                                    String aOldName = pDoc->GetPageStyle( nTab );
-                                    if ( aOldName != aStyleName )
-                                    {
-                                        pDoc->SetPageStyle( nTab, aStyleName );
-                                        ScPrintFunc( pDocSh, pTabViewShell->GetPrinter(sal_True), nTab ).UpdatePages();
-                                        if( !pUndoAction )
-                                            pUndoAction = new ScUndoApplyPageStyle( pDocSh, aStyleName );
-                                        pUndoAction->AddSheetAction( nTab, aOldName );
-                                    }
+                                    pDoc->SetPageStyle( *itr, aStyleName );
+                                    ScPrintFunc( pDocSh, pTabViewShell->GetPrinter(sal_True), *itr ).UpdatePages();
+                                    if( !pUndoAction )
+                                        pUndoAction = new ScUndoApplyPageStyle( pDocSh, aStyleName );
+                                    pUndoAction->AddSheetAction( *itr, aOldName );
                                 }
                             }
                             if( pUndoAction )