Adopt CopyAsLinkHandler as well.

With this, we no longer use CopyCellsInRangeToColumn().

Change-Id: I6506d72d084f724ccf7a6395a0daf88fe7bff40e

3 files changed, 84 insertions, 173 deletions

diff --git a/sc/inc/column.hxx b/sc/inc/column.hxx
index 95444f820411..bb3219c941f9 100644
--- a/sc/inc/column.hxx
+++ b/sc/inc/column.hxx
@@ -492,10 +492,6 @@ public:
 
 private:
 
-    void CopyCellsInRangeToColumn(
-        sc::ColumnBlockConstPosition* rSrcColPos, sc::ColumnBlockPosition* pDestColPos,
-        sc::CellBlockCloneHandler& Hdl, SCROW nRow1, SCROW nRow2, ScColumn& rColumn ) const;
-
     sc::CellStoreType::iterator GetPositionToInsert( SCROW nRow );
     sc::CellStoreType::iterator GetPositionToInsert( const sc::CellStoreType::iterator& it, SCROW nRow );
     void ActivateNewFormulaCell( ScFormulaCell* pCell );
diff --git a/sc/source/core/data/column.cxx b/sc/source/core/data/column.cxx
index 4bbca6e4613b..e6ba2d328669 100644
--- a/sc/source/core/data/column.cxx
+++ b/sc/source/core/data/column.cxx
@@ -1558,92 +1558,114 @@ bool canCopyValue(const ScDocument& rDoc, const ScAddress& rPos, sal_uInt16 nFla
     return ((nFlags & IDF_VALUE) != 0);
 }
 
-class CopyAsLinkHandler : public sc::CellBlockCloneHandler
+class CopyAsLinkHandler
 {
+    const ScColumn& mrSrcCol;
+    ScColumn& mrDestCol;
+    sc::ColumnBlockPosition maDestPos;
+    sc::ColumnBlockPosition* mpDestPos;
     sal_uInt16 mnCopyFlags;
     std::vector<ScFormulaCell*> maCellBuffer;
 
-    ScFormulaCell* createRefCell(const ScAddress& rSrcPos, const ScAddress& rDestPos)
+    void setDefaultAttrToDest(size_t nRow)
+    {
+        maDestPos.miCellTextAttrPos = mrDestCol.GetCellAttrStore().set(
+            maDestPos.miCellTextAttrPos, nRow, sc::CellTextAttr());
+    }
+
+    void setDefaultAttrsToDest(size_t nRow, size_t nSize)
+    {
+        std::vector<sc::CellTextAttr> aAttrs(nSize); // default values
+        maDestPos.miCellTextAttrPos = mrDestCol.GetCellAttrStore().set(
+            maDestPos.miCellTextAttrPos, nRow, aAttrs.begin(), aAttrs.end());
+    }
+
+    ScFormulaCell* createRefCell(size_t nRow)
     {
         ScSingleRefData aRef;
-        aRef.InitAddress(rSrcPos); // Absolute reference.
+        aRef.InitAddress(ScAddress(mrSrcCol.GetCol(), nRow, mrSrcCol.GetTab())); // Absolute reference.
         aRef.SetFlag3D(true);
 
         ScTokenArray aArr;
         aArr.AddSingleReference(aRef);
-        return new ScFormulaCell(&getDestDoc(), rDestPos, &aArr);
+        return new ScFormulaCell(&mrDestCol.GetDoc(), ScAddress(mrDestCol.GetCol(), nRow, mrDestCol.GetTab()), &aArr);
     }
 
-    template<typename _DataBlock>
-    void createRefBlock(
-        sc::ColumnBlockPosition& rPos, const ScAddress& rSrcPos, const ScAddress& rDestPos,
-        const typename _DataBlock::const_iterator& itBegin, const typename _DataBlock::const_iterator& itEnd)
+    void createRefBlock(const sc::CellStoreType::value_type& aNode, size_t nOffset, size_t nDataSize)
     {
-        size_t nSize = std::distance(itBegin, itEnd);
+        size_t nTopRow = aNode.position + nOffset;
+
         maCellBuffer.clear();
-        maCellBuffer.reserve(nSize);
-        ScAddress aSrcPos = rSrcPos;
-        ScAddress aDestPos = rDestPos;
-        for (typename _DataBlock::const_iterator it = itBegin; it != itEnd; ++it, aSrcPos.IncRow(), aDestPos.IncRow())
-            maCellBuffer.push_back(createRefCell(aSrcPos, aDestPos));
+        maCellBuffer.reserve(nDataSize);
+
+        for (size_t i = 0; i < nDataSize; ++i)
+            maCellBuffer.push_back(createRefCell(nTopRow + i));
 
-        rPos.miCellPos = getDestCellStore().set(rPos.miCellPos, rDestPos.Row(), maCellBuffer.begin(), maCellBuffer.end());
-        setDefaultAttrsToDest(rPos, rDestPos.Row(), nSize);
+        maDestPos.miCellPos = mrDestCol.GetCellStore().set(maDestPos.miCellPos, nTopRow, maCellBuffer.begin(), maCellBuffer.end());
+        setDefaultAttrsToDest(nTopRow, nDataSize);
     }
 
 public:
-    CopyAsLinkHandler(
-        ScDocument& rSrcDoc, ScDocument& rDestDoc, sc::CellStoreType& rDestCellStore, sc::CellTextAttrStoreType& rDestAttrStore, sal_uInt16 nCopyFlags) :
-        sc::CellBlockCloneHandler(rSrcDoc, rDestDoc, rDestCellStore, rDestAttrStore),
-        mnCopyFlags(nCopyFlags) {}
-
-    virtual void cloneDoubleBlock(
-        sc::ColumnBlockPosition& rPos, const ScAddress& rSrcPos, const ScAddress& rDestPos,
-        const sc::numeric_block::const_iterator& itBegin, const sc::numeric_block::const_iterator& itEnd)
+    CopyAsLinkHandler(const ScColumn& rSrcCol, ScColumn& rDestCol, sc::ColumnBlockPosition* pDestPos, sal_uInt16 nCopyFlags) :
+        mrSrcCol(rSrcCol), mrDestCol(rDestCol), mpDestPos(pDestPos), mnCopyFlags(nCopyFlags)
     {
-        if ((mnCopyFlags & (IDF_DATETIME|IDF_VALUE)) == 0)
-            return;
-
-        ScAddress aSrcPos = rSrcPos;
-        ScAddress aDestPos = rDestPos;
-        for (sc::numeric_block::const_iterator it = itBegin; it != itEnd; ++it, aSrcPos.IncRow(), aDestPos.IncRow())
-        {
-            if (!canCopyValue(getSrcDoc(), aSrcPos, mnCopyFlags))
-                continue;
-
-            rPos.miCellPos = getDestCellStore().set(rPos.miCellPos, aDestPos.Row(), createRefCell(aSrcPos, aDestPos));
-            setDefaultAttrToDest(rPos, aDestPos.Row());
-        }
+        if (mpDestPos)
+            maDestPos = *mpDestPos;
     }
 
-    virtual void cloneStringBlock(
-        sc::ColumnBlockPosition& rPos, const ScAddress& rSrcPos, const ScAddress& rDestPos,
-        const sc::string_block::const_iterator& itBegin, const sc::string_block::const_iterator& itEnd)
+    ~CopyAsLinkHandler()
     {
-        if (!(mnCopyFlags & IDF_STRING))
-            return;
-
-        createRefBlock<sc::string_block>(rPos, rSrcPos, rDestPos, itBegin, itEnd);
+        if (mpDestPos)
+            *mpDestPos = maDestPos;
     }
 
-    virtual void cloneEditTextBlock(
-        sc::ColumnBlockPosition& rPos, const ScAddress& rSrcPos, const ScAddress& rDestPos,
-        const sc::edittext_block::const_iterator& itBegin, const sc::edittext_block::const_iterator& itEnd)
+    void operator() (const sc::CellStoreType::value_type& aNode, size_t nOffset, size_t nDataSize)
     {
-        if (!(mnCopyFlags & IDF_STRING))
-            return;
+        size_t nRow = aNode.position - nOffset;
 
-        createRefBlock<sc::edittext_block>(rPos, rSrcPos, rDestPos, itBegin, itEnd);
-    }
+        switch (aNode.type)
+        {
+            case sc::element_type_numeric:
+            {
+                if ((mnCopyFlags & (IDF_DATETIME|IDF_VALUE)) == 0)
+                    return;
 
-    virtual void cloneFormulaBlock(
-        sc::ColumnBlockPosition& rPos, const ScAddress& rSrcPos, const ScAddress& rDestPos,
-        const sc::formula_block::const_iterator& itBegin, const sc::formula_block::const_iterator& itEnd)
-    {
-        if (!(mnCopyFlags & IDF_FORMULA))
-            return;
+                sc::numeric_block::const_iterator it = sc::numeric_block::begin(*aNode.data);
+                std::advance(it, nOffset);
+                sc::numeric_block::const_iterator itEnd = it;
+                std::advance(itEnd, nDataSize);
 
-        createRefBlock<sc::formula_block>(rPos, rSrcPos, rDestPos, itBegin, itEnd);
+                ScAddress aSrcPos(mrSrcCol.GetCol(), nRow, mrSrcCol.GetTab());
+                for (; it != itEnd; ++it, aSrcPos.IncRow(), ++nRow)
+                {
+                    if (!canCopyValue(mrSrcCol.GetDoc(), aSrcPos, mnCopyFlags))
+                        continue;
+
+                    maDestPos.miCellPos = mrDestCol.GetCellStore().set(maDestPos.miCellPos, nRow, createRefCell(nRow));
+                    setDefaultAttrToDest(nRow);
+                }
+            }
+            break;
+            case sc::element_type_string:
+            case sc::element_type_edittext:
+            {
+                if (!(mnCopyFlags & IDF_STRING))
+                    return;
+
+                createRefBlock(aNode, nOffset, nDataSize);
+            }
+            break;
+            case sc::element_type_formula:
+            {
+                if (!(mnCopyFlags & IDF_FORMULA))
+                    return;
+
+                createRefBlock(aNode, nOffset, nDataSize);
+            }
+            break;
+            default:
+                ;
+        }
     }
 };
 
@@ -1920,21 +1942,19 @@ void ScColumn::CopyToColumn(
 
     if ((nFlags & IDF_CONTENTS) != 0)
     {
-        boost::scoped_ptr<sc::CellBlockCloneHandler> pHdl(NULL);
-
         if (bAsLink)
         {
-            pHdl.reset(new CopyAsLinkHandler(*pDocument, *rColumn.pDocument, rColumn.maCells, rColumn.maCellTextAttrs, nFlags));
-            CopyCellsInRangeToColumn(NULL, rCxt.getBlockPosition(rColumn.nTab, rColumn.nCol), *pHdl, nRow1, nRow2, rColumn);
+            CopyAsLinkHandler aFunc(*this, rColumn, rCxt.getBlockPosition(rColumn.nTab, rColumn.nCol), nFlags);
+            sc::ParseBlock(maCells.begin(), maCells, aFunc, nRow1, nRow2);
         }
         else
         {
             CopyByCloneHandler aFunc(*this, rColumn, rCxt.getBlockPosition(rColumn.nTab, rColumn.nCol), nFlags);
             sc::ParseBlock(maCells.begin(), maCells, aFunc, nRow1, nRow2);
-            rColumn.RegroupFormulaCells(nRow1, nRow2);
-            rColumn.CellStorageModified();
         }
 
+        rColumn.RegroupFormulaCells(nRow1, nRow2);
+        rColumn.CellStorageModified();
     }
 }
 
diff --git a/sc/source/core/data/column3.cxx b/sc/source/core/data/column3.cxx
index 9d234149ca68..b89b5a1612dc 100644
--- a/sc/source/core/data/column3.cxx
+++ b/sc/source/core/data/column3.cxx
@@ -323,111 +323,6 @@ void ScColumn::DeleteRow( SCROW nStartRow, SCSIZE nSize )
     std::for_each(aSpans.begin(), aSpans.end(), RangeBroadcaster(*pDocument, nTab, nCol));
 }
 
-void ScColumn::CopyCellsInRangeToColumn(
-    sc::ColumnBlockConstPosition* pSrcColPos,
-    sc::ColumnBlockPosition* pDestColPos, sc::CellBlockCloneHandler& rHdl, SCROW nRow1, SCROW nRow2, ScColumn& rColumn ) const
-{
-    sc::ColumnBlockConstPosition aSrcColPos;
-    sc::ColumnBlockPosition aDestColPos;
-
-    if (pSrcColPos)
-        aSrcColPos = *pSrcColPos;
-    else
-        InitBlockPosition(aSrcColPos);
-
-    if (pDestColPos)
-        aDestColPos = *pDestColPos;
-    else
-        rColumn.InitBlockPosition(aDestColPos);
-
-    std::pair<sc::CellStoreType::const_iterator,size_t> aPos = maCells.position(aSrcColPos.miCellPos, nRow1);
-    sc::CellStoreType::const_iterator it = aPos.first;
-    aSrcColPos.miCellPos = aPos.first;
-    size_t nOffset = aPos.second;
-    size_t nDataSize = 0;
-    size_t nCurRow = nRow1;
-
-    for (; it != maCells.end() && nCurRow <= static_cast<size_t>(nRow2); ++it, nOffset = 0, nCurRow += nDataSize)
-    {
-        bool bLastBlock = false;
-        nDataSize = it->size - nOffset;
-        if (nCurRow + nDataSize - 1 > static_cast<size_t>(nRow2))
-        {
-            // Truncate the block to copy to clipboard.
-            nDataSize = nRow2 - nCurRow + 1;
-            bLastBlock = true;
-        }
-
-        switch (it->type)
-        {
-            case sc::element_type_numeric:
-            {
-                sc::numeric_block::const_iterator itData = sc::numeric_block::begin(*it->data);
-                std::advance(itData, nOffset);
-                sc::numeric_block::const_iterator itDataEnd = itData;
-                std::advance(itDataEnd, nDataSize);
-                ScAddress aSrcPos(nCol, nCurRow, nTab);
-                ScAddress aDestPos(rColumn.nCol, nCurRow, rColumn.nTab);
-                rHdl.cloneDoubleBlock(aDestColPos, aSrcPos, aDestPos, itData, itDataEnd);
-            }
-            break;
-            case sc::element_type_string:
-            {
-                sc::string_block::const_iterator itData = sc::string_block::begin(*it->data);
-                std::advance(itData, nOffset);
-                sc::string_block::const_iterator itDataEnd = itData;
-                std::advance(itDataEnd, nDataSize);
-                ScAddress aSrcPos(nCol, nCurRow, nTab);
-                ScAddress aDestPos(rColumn.nCol, nCurRow, rColumn.nTab);
-                rHdl.cloneStringBlock(aDestColPos, aSrcPos, aDestPos, itData, itDataEnd);
-            }
-            break;
-            case sc::element_type_edittext:
-            {
-                sc::edittext_block::const_iterator itData = sc::edittext_block::begin(*it->data);
-                std::advance(itData, nOffset);
-                sc::edittext_block::const_iterator itDataEnd = itData;
-                std::advance(itDataEnd, nDataSize);
-                ScAddress aSrcPos(nCol, nCurRow, nTab);
-                ScAddress aDestPos(rColumn.nCol, nCurRow, rColumn.nTab);
-                rHdl.cloneEditTextBlock(aDestColPos, aSrcPos, aDestPos, itData, itDataEnd);
-            }
-            break;
-            case sc::element_type_formula:
-            {
-                sc::formula_block::const_iterator itData = sc::formula_block::begin(*it->data);
-                std::advance(itData, nOffset);
-                sc::formula_block::const_iterator itDataEnd = itData;
-                std::advance(itDataEnd, nDataSize);
-                ScAddress aSrcPos(nCol, nCurRow, nTab);
-                ScAddress aDestPos(rColumn.nCol, nCurRow, rColumn.nTab);
-                rHdl.cloneFormulaBlock(aDestColPos, aSrcPos, aDestPos, itData, itDataEnd);
-            }
-            break;
-            default:
-                ;
-        }
-
-        if (bLastBlock)
-            break;
-    }
-
-    if (pSrcColPos)
-    {
-        // Save the positions for the next iteration.
-        *pSrcColPos = aSrcColPos;
-    }
-
-    if (pDestColPos)
-    {
-        // Save the positions for the next iteration.
-        *pDestColPos = aDestColPos;
-    }
-
-    rColumn.RegroupFormulaCells(nRow1, nRow2);
-    rColumn.CellStorageModified();
-}
-
 sc::CellStoreType::iterator ScColumn::GetPositionToInsert( SCROW nRow )
 {
     return GetPositionToInsert(maCells.begin(), nRow);