xref: /aoo41x/main/sw/source/core/doc/tblcpy.cxx (revision dec99bbd)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sw.hxx"


#include <hintids.hxx>

#define _ZFORLIST_DECLARE_TABLE
#include <svl/zforlist.hxx>
#include <frmfmt.hxx>
#include <doc.hxx>
#include <IDocumentUndoRedo.hxx>
#include <cntfrm.hxx>
#include <pam.hxx>
#include <swtable.hxx>
#include <ndtxt.hxx>
#include <fldbas.hxx>
#include <tblsel.hxx>
#include <tabfrm.hxx>
#include <poolfmt.hxx>
#include <cellatr.hxx>
#include <mvsave.hxx>
#include <docary.hxx>
#include <fmtanchr.hxx>
#include <hints.hxx>
#include <UndoTable.hxx>
#include <redline.hxx>
#include <fmtfsize.hxx>
#include <list>

sal_Bool _FndCntntLine( const SwTableLine*& rpLine, void* pPara );
sal_Bool _FndCntntBox( const SwTableBox*& rpBox, void* pPara );
void lcl_CpyBox( const SwTable& rCpyTbl, const SwTableBox* pCpyBox,
					SwTable& rDstTbl, SwTableBox* pDstBox,
					sal_Bool bDelCntnt, SwUndoTblCpyTbl* pUndo );

// The following type will be used by table copy functions to describe
// the structure of tables (or parts of tables).
// It's for new table model only.

namespace
{
    struct BoxSpanInfo
    {
        SwTableBox* mpBox;
        SwTableBox* mpCopy;
        sal_uInt16 mnColSpan;
        bool mbSelected;
    };

    typedef std::vector< BoxSpanInfo > BoxStructure;
    typedef std::vector< BoxStructure > LineStructure;
    typedef std::list< sal_uLong > ColumnStructure;

    struct SubBox
    {
        SwTableBox *mpBox;
        bool mbCovered;
    };

    typedef std::list< SubBox > SubLine;
    typedef std::list< SubLine > SubTable;

    class TableStructure
    {
    public:
        LineStructure maLines;
        ColumnStructure maCols;
        sal_uInt16 mnStartCol;
        sal_uInt16 mnAddLine;
        void addLine( sal_uInt16 &rLine, const SwTableBoxes&, const SwSelBoxes*,
                      bool bNewModel );
        void addBox( sal_uInt16 nLine, const SwSelBoxes*, SwTableBox *pBox,
                     sal_uLong &rnB, sal_uInt16 &rnC, ColumnStructure::iterator& rpCl,
                     BoxStructure::iterator& rpSel, bool &rbSel, bool bCover );
        void incColSpan( sal_uInt16 nLine, sal_uInt16 nCol );
        TableStructure( const SwTable& rTable );
        TableStructure( const SwTable& rTable, _FndBox &rFndBox,
                        const SwSelBoxes& rSelBoxes,
                        LineStructure::size_type nMinSize );
        LineStructure::size_type getLineCount() const
            { return maLines.size(); }
        void moreLines( const SwTable& rTable );
        void assignBoxes( const TableStructure &rSource );
        void copyBoxes( const SwTable& rSource, SwTable& rDstTbl,
					    SwUndoTblCpyTbl* pUndo ) const;
    };

    SubTable::iterator insertSubLine( SubTable& rSubTable, SwTableLine& rLine,
        SubTable::iterator pStartLn );

    SubTable::iterator insertSubBox( SubTable& rSubTable, SwTableBox& rBox,
        SubTable::iterator pStartLn, SubTable::iterator pEndLn )
    {
        if( rBox.GetTabLines().Count() )
        {
            SubTable::difference_type nSize = std::distance( pStartLn, pEndLn );
            if( nSize < rBox.GetTabLines().Count() )
            {
                SubLine aSubLine;
                SubLine::iterator pBox = pStartLn->begin();
                SubLine::iterator pEnd = pStartLn->end();
                while( pBox != pEnd )
                {
                    SubBox aSub;
                    aSub.mpBox = pBox->mpBox;
                    aSub.mbCovered = true;
                    aSubLine.push_back( aSub );
                    ++pBox;
                }
                do
                {
                    rSubTable.insert( pEndLn, aSubLine );
                } while( ++nSize < rBox.GetTabLines().Count() );
            }
            for( sal_uInt16 nLine = 0; nLine < rBox.GetTabLines().Count(); ++nLine )
                pStartLn = insertSubLine( rSubTable, *rBox.GetTabLines()[nLine],
                           pStartLn );
            ASSERT( pStartLn == pEndLn, "Sub line confusion" );
        }
        else
        {
            SubBox aSub;
            aSub.mpBox = &rBox;
            aSub.mbCovered = false;
            while( pStartLn != pEndLn )
            {
                pStartLn->push_back( aSub );
                aSub.mbCovered = true;
                ++pStartLn;
            }
        }
        return pStartLn;
    }

    SubTable::iterator insertSubLine( SubTable& rSubTable, SwTableLine& rLine,
        SubTable::iterator pStartLn )
    {
        SubTable::iterator pMax = pStartLn;
        ++pMax;
        SubTable::difference_type nMax = 1;
        for( sal_uInt16 nBox = 0; nBox < rLine.GetTabBoxes().Count(); ++nBox )
        {
            SubTable::iterator pTmp = insertSubBox( rSubTable,
                *rLine.GetTabBoxes()[nBox], pStartLn, pMax );
            SubTable::difference_type nTmp = std::distance( pStartLn, pTmp );
            if( nTmp > nMax )
            {
                pMax = pTmp;
                nMax = nTmp;
            }
        }
        return pMax;
    }

    TableStructure::TableStructure( const SwTable& rTable ) :
        maLines( rTable.GetTabLines().Count() ), mnStartCol(USHRT_MAX),
        mnAddLine(0)
    {
        maCols.push_front(0);
        const SwTableLines &rLines = rTable.GetTabLines();
        sal_uInt16 nCnt = 0;
        for( sal_uInt16 nLine = 0; nLine < rLines.Count(); ++nLine )
            addLine( nCnt, rLines[nLine]->GetTabBoxes(), 0, rTable.IsNewModel() );
    }

    TableStructure::TableStructure( const SwTable& rTable,
        _FndBox &rFndBox, const SwSelBoxes& rSelBoxes,
        LineStructure::size_type nMinSize )
        : mnStartCol(USHRT_MAX), mnAddLine(0)
    {
        if( rFndBox.GetLines().Count() )
        {
            bool bNoSelection = rSelBoxes.Count() < 2;
            _FndLines &rFndLines = rFndBox.GetLines();
            maCols.push_front(0);
            const SwTableLine* pLine = rFndLines[0]->GetLine();
            sal_uInt16 nStartLn = rTable.GetTabLines().C40_GETPOS( SwTableLine, pLine );
            sal_uInt16 nEndLn = nStartLn;
            if( rFndLines.Count() > 1 )
            {
                pLine = rFndLines[ rFndLines.Count()-1 ]->GetLine();
                nEndLn = rTable.GetTabLines().C40_GETPOS( SwTableLine, pLine );
            }
            if( nStartLn < USHRT_MAX && nEndLn < USHRT_MAX )
            {
                const SwTableLines &rLines = rTable.GetTabLines();
                if( bNoSelection &&
                    (sal_uInt16)nMinSize > nEndLn - nStartLn + 1 )
                {
                    sal_uInt16 nNewEndLn = nStartLn + (sal_uInt16)nMinSize - 1;
                    if( nNewEndLn >= rLines.Count() )
                    {
                        mnAddLine = nNewEndLn - rLines.Count() + 1;
                        nNewEndLn = rLines.Count() - 1;
                    }
                    while( nEndLn < nNewEndLn )
                    {
                        SwTableLine *pLine2 = rLines[ ++nEndLn ];
                        SwTableBox *pTmpBox = pLine2->GetTabBoxes()[0];
                        _FndLine *pInsLine = new _FndLine( pLine2, &rFndBox );
                        _FndBox *pFndBox = new _FndBox( pTmpBox, pInsLine );
                        pInsLine->GetBoxes().C40_INSERT( _FndBox, pFndBox, 0 );
                        rFndLines.C40_INSERT( _FndLine, pInsLine, rFndLines.Count() );
                    }
                }
                maLines.resize( nEndLn - nStartLn + 1 );
                const SwSelBoxes* pSelBoxes = &rSelBoxes;
                sal_uInt16 nCnt = 0;
                for( sal_uInt16 nLine = nStartLn; nLine <= nEndLn; ++nLine )
                {
                    addLine( nCnt, rLines[nLine]->GetTabBoxes(),
                             pSelBoxes, rTable.IsNewModel() );
                    if( bNoSelection )
                        pSelBoxes = 0;
                }
            }
            if( bNoSelection && mnStartCol < USHRT_MAX )
            {
                BoxStructure::iterator pC = maLines[0].begin();
                BoxStructure::iterator pEnd = maLines[0].end();
                sal_uInt16 nIdx = mnStartCol;
                mnStartCol = 0;
                while( nIdx && pC != pEnd )
                {
                    mnStartCol = mnStartCol + pC->mnColSpan;
                    --nIdx;
                    ++pC;
                }
            }
            else
                mnStartCol = USHRT_MAX;
        }
    }

    void TableStructure::addLine( sal_uInt16 &rLine, const SwTableBoxes& rBoxes,
        const SwSelBoxes* pSelBoxes, bool bNewModel )
    {
        bool bComplex = false;
        if( !bNewModel )
            for( sal_uInt16 nBox = 0; !bComplex && nBox < rBoxes.Count(); ++nBox )
                bComplex = rBoxes[nBox]->GetTabLines().Count() > 0;
        if( bComplex )
        {
            SubTable aSubTable;
            SubLine aSubLine;
            aSubTable.push_back( aSubLine );
            SubTable::iterator pStartLn = aSubTable.begin();
            SubTable::iterator pEndLn = aSubTable.end();
            for( sal_uInt16 nBox = 0; nBox < rBoxes.Count(); ++nBox )
                insertSubBox( aSubTable, *rBoxes[nBox], pStartLn, pEndLn );
            SubTable::size_type nSize = aSubTable.size();
            if( nSize )
            {
                maLines.resize( maLines.size() + nSize - 1 );
                while( pStartLn != pEndLn )
                {
                    bool bSelected = false;
                    sal_uLong nBorder = 0;
                    sal_uInt16 nCol = 0;
                    maLines[rLine].reserve( pStartLn->size() );
                    BoxStructure::iterator pSel = maLines[rLine].end();
                    ColumnStructure::iterator pCol = maCols.begin();
                    SubLine::iterator pBox = pStartLn->begin();
                    SubLine::iterator pEnd = pStartLn->end();
                    while( pBox != pEnd )
                    {
                        addBox( rLine, pSelBoxes, pBox->mpBox, nBorder, nCol,
                            pCol, pSel, bSelected, pBox->mbCovered );
                        ++pBox;
                    }
                    ++rLine;
                    ++pStartLn;
                }
            }
        }
        else
        {
            bool bSelected = false;
            sal_uLong nBorder = 0;
            sal_uInt16 nCol = 0;
            maLines[rLine].reserve( rBoxes.Count() );
            ColumnStructure::iterator pCol = maCols.begin();
            BoxStructure::iterator pSel = maLines[rLine].end();
            for( sal_uInt16 nBox = 0; nBox < rBoxes.Count(); ++nBox )
                addBox( rLine, pSelBoxes, rBoxes[nBox], nBorder, nCol,
                        pCol, pSel, bSelected, false );
            ++rLine;
        }
    }

    void TableStructure::addBox( sal_uInt16 nLine, const SwSelBoxes* pSelBoxes,
        SwTableBox *pBox, sal_uLong &rnBorder, sal_uInt16 &rnCol,
        ColumnStructure::iterator& rpCol, BoxStructure::iterator& rpSel,
        bool &rbSelected, bool bCovered )
    {
        BoxSpanInfo aInfo;
        if( pSelBoxes &&
            USHRT_MAX != pSelBoxes->GetPos( pBox ) )
        {
            aInfo.mbSelected = true;
            if( mnStartCol == USHRT_MAX )
            {
                mnStartCol = (sal_uInt16)maLines[nLine].size();
                if( pSelBoxes->Count() < 2 )
                {
                    pSelBoxes = 0;
                    aInfo.mbSelected = false;
                }
            }
        }
        else
            aInfo.mbSelected = false;
        rnBorder += pBox->GetFrmFmt()->GetFrmSize().GetWidth();
        sal_uInt16 nLeftCol = rnCol;
        while( rpCol != maCols.end() && *rpCol < rnBorder )
        {
            ++rnCol;
            ++rpCol;
        }
        if( rpCol == maCols.end() || *rpCol > rnBorder )
        {
            maCols.insert( rpCol, rnBorder );
            --rpCol;
            incColSpan( nLine, rnCol );
        }
        aInfo.mnColSpan = rnCol - nLeftCol;
        aInfo.mpCopy = 0;
        aInfo.mpBox = bCovered ? 0 : pBox;
        maLines[nLine].push_back( aInfo );
        if( aInfo.mbSelected )
        {
            if( rbSelected )
            {
                while( rpSel != maLines[nLine].end() )
                {
                    rpSel->mbSelected = true;
                    ++rpSel;
                }
            }
            else
            {
                rpSel = maLines[nLine].end();
                rbSelected = true;
            }
            --rpSel;
        }
    }

    void TableStructure::moreLines( const SwTable& rTable )
    {
        if( mnAddLine )
        {
            const SwTableLines &rLines = rTable.GetTabLines();
            sal_uInt16 nLineCount = rLines.Count();
            if( nLineCount < mnAddLine )
                mnAddLine = nLineCount;
            sal_uInt16 nLine = (sal_uInt16)maLines.size();
            maLines.resize( nLine + mnAddLine );
            while( mnAddLine )
            {
                SwTableLine *pLine = rLines[ nLineCount - mnAddLine ];
                addLine( nLine, pLine->GetTabBoxes(), 0, rTable.IsNewModel() );
                --mnAddLine;
            }
        }
    }

    void TableStructure::incColSpan( sal_uInt16 nLineMax, sal_uInt16 nNewCol )
    {
        for( sal_uInt16 nLine = 0; nLine < nLineMax; ++nLine )
        {
            BoxStructure::iterator pInfo = maLines[nLine].begin();
            BoxStructure::iterator pEnd = maLines[nLine].end();
            long nCol = pInfo->mnColSpan;
            while( nNewCol > nCol && ++pInfo != pEnd )
                nCol += pInfo->mnColSpan;
            if( pInfo != pEnd )
                ++(pInfo->mnColSpan);
        }
    }

    void TableStructure::assignBoxes( const TableStructure &rSource )
    {
        LineStructure::const_iterator pFirstLine = rSource.maLines.begin();
        LineStructure::const_iterator pLastLine = rSource.maLines.end();
        if( pFirstLine == pLastLine )
            return;
        LineStructure::const_iterator pCurrLine = pFirstLine;
        LineStructure::size_type nLineCount = maLines.size();
        sal_uInt16 nFirstStartCol = 0;
        {
            BoxStructure::const_iterator pFirstBox = pFirstLine->begin();
            if( pFirstBox != pFirstLine->end() && pFirstBox->mpBox &&
                pFirstBox->mpBox->getDummyFlag() )
                nFirstStartCol = pFirstBox->mnColSpan;
        }
        for( LineStructure::size_type nLine = 0; nLine < nLineCount; ++nLine )
        {
            BoxStructure::const_iterator pFirstBox = pCurrLine->begin();
            BoxStructure::const_iterator pLastBox = pCurrLine->end();
            sal_uInt16 nCurrStartCol = mnStartCol;
            if( pFirstBox != pLastBox )
            {
                BoxStructure::const_iterator pTmpBox = pLastBox;
                --pTmpBox;
                if( pTmpBox->mpBox && pTmpBox->mpBox->getDummyFlag() )
                    --pLastBox;
                if( pFirstBox != pLastBox && pFirstBox->mpBox &&
                    pFirstBox->mpBox->getDummyFlag() )
                {
                    if( nCurrStartCol < USHRT_MAX )
                    {
                        if( pFirstBox->mnColSpan > nFirstStartCol )
                            nCurrStartCol = pFirstBox->mnColSpan - nFirstStartCol
                                            + nCurrStartCol;
                    }
                    ++pFirstBox;
                }
            }
            if( pFirstBox != pLastBox )
            {
                BoxStructure::const_iterator pCurrBox = pFirstBox;
                BoxStructure &rBox = maLines[nLine];
                BoxStructure::size_type nBoxCount = rBox.size();
                sal_uInt16 nCol = 0;
                for( BoxStructure::size_type nBox = 0; nBox < nBoxCount; ++nBox )
                {
                    BoxSpanInfo& rInfo = rBox[nBox];
                    nCol = nCol + rInfo.mnColSpan;
                    if( rInfo.mbSelected || nCol > nCurrStartCol )
                    {
                        rInfo.mpCopy = pCurrBox->mpBox;
                        if( rInfo.mbSelected && rInfo.mpCopy->getDummyFlag() )
                        {
                            ++pCurrBox;
                            if( pCurrBox == pLastBox )
                            {
                                pCurrBox = pFirstBox;
                                if( pCurrBox->mpBox->getDummyFlag() )
                                    ++pCurrBox;
                            }
                            rInfo.mpCopy = pCurrBox->mpBox;
                        }
                        ++pCurrBox;
                        if( pCurrBox == pLastBox )
                        {
                            if( rInfo.mbSelected )
                                pCurrBox = pFirstBox;
                            else
                            {
                                rInfo.mbSelected = rInfo.mpCopy == 0;
                                break;
                            }
                        }
                        rInfo.mbSelected = rInfo.mpCopy == 0;
                    }
                }
            }
            ++pCurrLine;
            if( pCurrLine == pLastLine )
                pCurrLine = pFirstLine;
        }
    }

    void TableStructure::copyBoxes( const SwTable& rSource, SwTable& rDstTbl,
					                SwUndoTblCpyTbl* pUndo ) const
    {
        LineStructure::size_type nLineCount = maLines.size();
        for( LineStructure::size_type nLine = 0; nLine < nLineCount; ++nLine )
        {
            const BoxStructure &rBox = maLines[nLine];
            BoxStructure::size_type nBoxCount = rBox.size();
            for( BoxStructure::size_type nBox = 0; nBox < nBoxCount; ++nBox )
            {
                const BoxSpanInfo& rInfo = rBox[nBox];
                if( ( rInfo.mpCopy && !rInfo.mpCopy->getDummyFlag() )
                    || rInfo.mbSelected )
                {
                    SwTableBox *pBox = rInfo.mpBox;
                    if( pBox && pBox->getRowSpan() > 0 )
                        lcl_CpyBox( rSource, rInfo.mpCopy, rDstTbl, pBox,
                                    sal_True, pUndo );
                    /* Idea: If target cell is a covered cell, append content
                             to master cell.
                    sal_Bool bReplace = sal_True;
                    if( pBox->getRowSpan() < 0 )
                    {
                        if( rInfo.mpCopy->getRowSpan() < 0 )
                            continue;
                        pBox = &pBox->FindStartOfRowSpan( rDstTbl );
                        bReplace = sal_False;
                    }
                    lcl_CpyBox( rSource, rInfo.mpCopy, rDstTbl, pBox,
                                bReplace, pUndo );
                    */
                }
            }
        }
    }
}

// ---------------------------------------------------------------

// kopiere die Tabelle in diese.
//	Kopiere alle Boxen einer Line in entsprechenden Boxen. Der alte Inhalt
// 	wird dabei geloescht.
// 	Ist keine mehr vorhanden, kommt der restliche Inhalt in die letzte
// 	Box einer "GrundLine".
//	Ist auch keine Line mehr vorhanden, -> auch in die letzte Box
//	einer "GrundLine"


void lcl_CpyBox( const SwTable& rCpyTbl, const SwTableBox* pCpyBox,
					SwTable& rDstTbl, SwTableBox* pDstBox,
					sal_Bool bDelCntnt, SwUndoTblCpyTbl* pUndo )
{
	ASSERT( ( !pCpyBox || pCpyBox->GetSttNd() ) && pDstBox->GetSttNd(),
			"Keine inhaltstragende Box" );

	SwDoc* pCpyDoc = rCpyTbl.GetFrmFmt()->GetDoc();
	SwDoc* pDoc = rDstTbl.GetFrmFmt()->GetDoc();

	// kopiere erst den neuen und loeschen dann den alten Inhalt
	// (keine leeren Section erzeugen; werden sonst geloescht!)
    std::auto_ptr< SwNodeRange > pRg( pCpyBox ?
        new SwNodeRange ( *pCpyBox->GetSttNd(), 1,
        *pCpyBox->GetSttNd()->EndOfSectionNode() ) : 0 );

	SwNodeIndex aInsIdx( *pDstBox->GetSttNd(), bDelCntnt ? 1 :
						pDstBox->GetSttNd()->EndOfSectionIndex() -
						pDstBox->GetSttIdx() );

	if( pUndo )
		pUndo->AddBoxBefore( *pDstBox, bDelCntnt );

    bool bUndoRedline = pUndo && pDoc->IsRedlineOn();
    ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());

	SwNodeIndex aSavePos( aInsIdx, -1 );
    if( pRg.get() )
        pCpyDoc->CopyWithFlyInFly( *pRg, 0, aInsIdx, NULL, sal_False );
    else
		pDoc->GetNodes().MakeTxtNode( aInsIdx, (SwTxtFmtColl*)pDoc->GetDfltTxtFmtColl() );
	aSavePos++;

	SwTableLine* pLine = pDstBox->GetUpper();
	while( pLine->GetUpper() )
		pLine = pLine->GetUpper()->GetUpper();

	sal_Bool bReplaceColl = sal_True;
	if( bDelCntnt && !bUndoRedline )
	{
		// zuerst die Fly loeschen, dann die entsprechenden Nodes
		SwNodeIndex aEndNdIdx( *aInsIdx.GetNode().EndOfSectionNode() );

			// Bookmarks usw. verschieben
		{
			SwPosition aMvPos( aInsIdx );
			SwCntntNode* pCNd = pDoc->GetNodes().GoPrevious( &aMvPos.nNode );
			aMvPos.nContent.Assign( pCNd, pCNd->Len() );
			pDoc->CorrAbs( aInsIdx, aEndNdIdx, aMvPos, /*sal_True*/sal_False );
		}

		// stehen noch FlyFrames rum, loesche auch diese
		for( sal_uInt16 n = 0; n < pDoc->GetSpzFrmFmts()->Count(); ++n )
		{
            SwFrmFmt *const pFly = (*pDoc->GetSpzFrmFmts())[n];
            SwFmtAnchor const*const pAnchor = &pFly->GetAnchor();
            SwPosition const*const pAPos = pAnchor->GetCntntAnchor();
            if (pAPos &&
                ((FLY_AT_PARA == pAnchor->GetAnchorId()) ||
                 (FLY_AT_CHAR == pAnchor->GetAnchorId())) &&
				aInsIdx <= pAPos->nNode && pAPos->nNode <= aEndNdIdx )
			{
				pDoc->DelLayoutFmt( pFly );
			}
		}

		// ist DestBox eine Headline-Box und hat Tabellen-Vorlage gesetzt,
		// dann NICHT die TabellenHeadline-Vorlage automatisch setzen
		if( 1 < rDstTbl.GetTabLines().Count() &&
			pLine == rDstTbl.GetTabLines()[0] )
		{
			SwCntntNode* pCNd = aInsIdx.GetNode().GetCntntNode();
			if( !pCNd )
			{
				SwNodeIndex aTmp( aInsIdx );
				pCNd = pDoc->GetNodes().GoNext( &aTmp );
			}

			if( pCNd &&
				/*RES_POOLCOLL_TABLE == */
				RES_POOLCOLL_TABLE_HDLN !=
					pCNd->GetFmtColl()->GetPoolFmtId() )
				bReplaceColl = sal_False;
		}

        pDoc->GetNodes().Delete( aInsIdx, aEndNdIdx.GetIndex() - aInsIdx.GetIndex() );
	}

    //b6341295: Table copy redlining will be managed by AddBoxAfter()
	if( pUndo )
		pUndo->AddBoxAfter( *pDstBox, aInsIdx, bDelCntnt );

    // heading
    SwTxtNode *const pTxtNd = aSavePos.GetNode().GetTxtNode();
	if( pTxtNd )
	{
		sal_uInt16 nPoolId = pTxtNd->GetTxtColl()->GetPoolFmtId();
		if( bReplaceColl &&
			(( 1 < rDstTbl.GetTabLines().Count() &&
				pLine == rDstTbl.GetTabLines()[0] )
				// gilt noch die Tabellen-Inhalt ??
				? RES_POOLCOLL_TABLE == nPoolId
				: RES_POOLCOLL_TABLE_HDLN == nPoolId ) )
		{
			SwTxtFmtColl* pColl = pDoc->GetTxtCollFromPool(
                static_cast<sal_uInt16>(
									RES_POOLCOLL_TABLE == nPoolId
										? RES_POOLCOLL_TABLE_HDLN
										: RES_POOLCOLL_TABLE ) );
			if( pColl )			// Vorlage umsetzen
			{
				SwPaM aPam( aSavePos );
				aPam.SetMark();
				aPam.Move( fnMoveForward, fnGoSection );
				pDoc->SetTxtFmtColl( aPam, pColl );
			}
		}

        // loesche die akt. Formel/Format/Value Werte
		if( SFX_ITEM_SET == pDstBox->GetFrmFmt()->GetItemState( RES_BOXATR_FORMAT ) ||
			SFX_ITEM_SET == pDstBox->GetFrmFmt()->GetItemState( RES_BOXATR_FORMULA ) ||
			SFX_ITEM_SET == pDstBox->GetFrmFmt()->GetItemState( RES_BOXATR_VALUE ) )
		{
            pDstBox->ClaimFrmFmt()->ResetFmtAttr( RES_BOXATR_FORMAT,
												 RES_BOXATR_VALUE );
		}

		// kopiere die TabellenBoxAttribute - Formel/Format/Value
        if( pCpyBox )
        {
            SfxItemSet aBoxAttrSet( pCpyDoc->GetAttrPool(), RES_BOXATR_FORMAT,
                                                            RES_BOXATR_VALUE );
            aBoxAttrSet.Put( pCpyBox->GetFrmFmt()->GetAttrSet() );
            if( aBoxAttrSet.Count() )
            {
                const SfxPoolItem* pItem;
                SvNumberFormatter* pN = pDoc->GetNumberFormatter( sal_False );
                if( pN && pN->HasMergeFmtTbl() && SFX_ITEM_SET == aBoxAttrSet.
                    GetItemState( RES_BOXATR_FORMAT, sal_False, &pItem ) )
                {
                    sal_uLong nOldIdx = ((SwTblBoxNumFormat*)pItem)->GetValue();
                    sal_uLong nNewIdx = pN->GetMergeFmtIndex( nOldIdx );
                    if( nNewIdx != nOldIdx )
                        aBoxAttrSet.Put( SwTblBoxNumFormat( nNewIdx ));
                }
                pDstBox->ClaimFrmFmt()->SetFmtAttr( aBoxAttrSet );
            }
        }
	}
}

sal_Bool SwTable::InsNewTable( const SwTable& rCpyTbl, const SwSelBoxes& rSelBoxes,
						SwUndoTblCpyTbl* pUndo )
{
	SwDoc* pDoc = GetFrmFmt()->GetDoc();
	SwDoc* pCpyDoc = rCpyTbl.GetFrmFmt()->GetDoc();

	SwTblNumFmtMerge aTNFM( *pCpyDoc, *pDoc );

    // analyse source structure
    TableStructure aCopyStruct( rCpyTbl );

    // analyse target structure (from start box) and selected substructure
	_FndBox aFndBox( 0, 0 );
	{   // get all boxes/lines
		_FndPara aPara( rSelBoxes, &aFndBox );
		GetTabLines().ForEach( &_FndLineCopyCol, &aPara );
	}
    TableStructure aTarget( *this, aFndBox, rSelBoxes, aCopyStruct.getLineCount() );

    bool bClear = false;
    if( aTarget.mnAddLine && IsNewModel() )
    {
        SwSelBoxes aBoxes;
        aBoxes.Insert( GetTabLines()[ GetTabLines().Count()-1 ]->GetTabBoxes()[0] );
        if( pUndo )
            pUndo->InsertRow( *this, aBoxes, aTarget.mnAddLine );
        else
            InsertRow( pDoc, aBoxes, aTarget.mnAddLine, sal_True );

        aTarget.moreLines( *this );
        bClear = true;
    }

    // find mapping, if needed extend target table and/or selection
    aTarget.assignBoxes( aCopyStruct );

	{
		// Change table formulas into relative representation
		SwTableFmlUpdate aMsgHnt( &rCpyTbl );
		aMsgHnt.eFlags = TBL_RELBOXNAME;
		pCpyDoc->UpdateTblFlds( &aMsgHnt );
	}

	// delete frames
	aFndBox.SetTableLines( *this );
    if( bClear )
        aFndBox.ClearLineBehind();
	aFndBox.DelFrms( *this );

    // copy boxes
    aTarget.copyBoxes( rCpyTbl, *this, pUndo );

    // adjust row span attributes accordingly

    // make frames
	aFndBox.MakeFrms( *this );

    return sal_True;
}

// ---------------------------------------------------------------

// kopiere die Tabelle in diese.
//	Kopiere alle Boxen einer Line in entsprechenden Boxen. Der alte Inhalt
// 	wird dabei geloescht.
// 	Ist keine mehr vorhanden, kommt der restliche Inhalt in die letzte
// 	Box einer "GrundLine".
//	Ist auch keine Line mehr vorhanden, -> auch in die letzte Box
//	einer "GrundLine"


sal_Bool SwTable::InsTable( const SwTable& rCpyTbl, const SwNodeIndex& rSttBox,
						SwUndoTblCpyTbl* pUndo )
{
	SetHTMLTableLayout( 0 ); 	// MIB 9.7.97: HTML-Layout loeschen

	SwDoc* pDoc = GetFrmFmt()->GetDoc();

	SwTableNode* pTblNd = pDoc->IsIdxInTbl( rSttBox );

	// suche erstmal die Box, in die kopiert werden soll:
	SwTableBox* pMyBox = (SwTableBox*)GetTblBox(
			rSttBox.GetNode().FindTableBoxStartNode()->GetIndex() );

	ASSERT( pMyBox, "Index steht nicht in dieser Tabelle in einer Box" );

	// loesche erstmal die Frames der Tabelle
	_FndBox aFndBox( 0, 0 );
	aFndBox.DelFrms( pTblNd->GetTable() );

	SwDoc* pCpyDoc = rCpyTbl.GetFrmFmt()->GetDoc();

	{
		// Tabellen-Formeln in die relative Darstellung umwandeln
		SwTableFmlUpdate aMsgHnt( &rCpyTbl );
		aMsgHnt.eFlags = TBL_RELBOXNAME;
		pCpyDoc->UpdateTblFlds( &aMsgHnt );
	}

	SwTblNumFmtMerge aTNFM( *pCpyDoc, *pDoc );

	sal_Bool bDelCntnt = sal_True;
	const SwTableBox* pTmp;

	for( sal_uInt16 nLines = 0; nLines < rCpyTbl.GetTabLines().Count(); ++nLines )
	{
		// hole die erste Box von der Copy-Line
		const SwTableBox* pCpyBox = rCpyTbl.GetTabLines()[nLines]
									->GetTabBoxes()[0];
		while( pCpyBox->GetTabLines().Count() )
			pCpyBox = pCpyBox->GetTabLines()[0]->GetTabBoxes()[0];

		do {
			// kopiere erst den neuen und loeschen dann den alten Inhalt
			// (keine leeren Section erzeugen, werden sonst geloescht!)
			lcl_CpyBox( rCpyTbl, pCpyBox, *this, pMyBox, bDelCntnt, pUndo );

			if( 0 == (pTmp = pCpyBox->FindNextBox( rCpyTbl, pCpyBox, sal_False )))
				break;		// es folgt keine weitere Box mehr
			pCpyBox = pTmp;

			if( 0 == ( pTmp = pMyBox->FindNextBox( *this, pMyBox, sal_False )))
				bDelCntnt = sal_False;	// kein Platz mehr ??
			else
				pMyBox = (SwTableBox*)pTmp;

		} while( sal_True );

		// suche die oberste Line
		SwTableLine* pNxtLine = pMyBox->GetUpper();
		while( pNxtLine->GetUpper() )
			pNxtLine = pNxtLine->GetUpper()->GetUpper();
		sal_uInt16 nPos = GetTabLines().C40_GETPOS( SwTableLine, pNxtLine );
		// gibt es eine naechste ??
		if( nPos + 1 >= GetTabLines().Count() )
			bDelCntnt = sal_False;		// es gibt keine, alles in die letzte Box
		else
		{
			// suche die naechste "Inhaltstragende Box"
			pNxtLine = GetTabLines()[ nPos+1 ];
			pMyBox = pNxtLine->GetTabBoxes()[0];
			while( pMyBox->GetTabLines().Count() )
				pMyBox = pMyBox->GetTabLines()[0]->GetTabBoxes()[0];
			bDelCntnt = sal_True;
		}
	}

	aFndBox.MakeFrms( pTblNd->GetTable() ); 	// erzeuge die Frames neu
	return sal_True;
}


sal_Bool SwTable::InsTable( const SwTable& rCpyTbl, const SwSelBoxes& rSelBoxes,
						SwUndoTblCpyTbl* pUndo )
{
	ASSERT( rSelBoxes.Count(), "Missing selection" )

	SetHTMLTableLayout( 0 ); 	// MIB 9.7.97: HTML-Layout loeschen

    if( IsNewModel() || rCpyTbl.IsNewModel() )
        return InsNewTable( rCpyTbl, rSelBoxes, pUndo );

	ASSERT( !rCpyTbl.IsTblComplex(), "Table too complex" )

            SwDoc* pDoc = GetFrmFmt()->GetDoc();
	SwDoc* pCpyDoc = rCpyTbl.GetFrmFmt()->GetDoc();

	SwTblNumFmtMerge aTNFM( *pCpyDoc, *pDoc );

	SwTableBox *pTmpBox, *pSttBox = (SwTableBox*)rSelBoxes[0];

	sal_uInt16 nLn, nBx;
	_FndLine *pFLine, *pInsFLine = 0;
	_FndBox aFndBox( 0, 0 );
	// suche alle Boxen / Lines
	{
		_FndPara aPara( rSelBoxes, &aFndBox );
		((SwTableLines&)GetTabLines()).ForEach( &_FndLineCopyCol, &aPara );
	}

	// JP 06.09.96: Sonderfall - eine Box in der Tabelle -> in alle
	//				selektierten Boxen kopieren!
	if( 1 != rCpyTbl.GetTabSortBoxes().Count() )
	{
		SwTableLine* pSttLine = pSttBox->GetUpper();
		sal_uInt16 nSttBox = pSttLine->GetTabBoxes().C40_GETPOS( SwTableBox, pSttBox );
		sal_uInt16 nSttLine = GetTabLines().C40_GETPOS( SwTableLine, pSttLine );
		_FndBox* pFndBox;

		sal_uInt16 nFndCnt = aFndBox.GetLines().Count();
		if( !nFndCnt )
			return sal_False;

		// teste ob genug Platz fuer die einzelnen Lines und Boxen ist:
		sal_uInt16 nTstLns = 0;
		pFLine = aFndBox.GetLines()[ 0 ];
		pSttLine = pFLine->GetLine();
		nSttLine = GetTabLines().C40_GETPOS( SwTableLine, pSttLine );
		// sind ueberhaupt soviele Zeilen vorhanden
		if( 1 == nFndCnt )
		{
			// in der Tabelle noch genug Platz ??
			if( (GetTabLines().Count() - nSttLine ) <
				rCpyTbl.GetTabLines().Count() )
			{
				// sollte nicht mehr soviele Lines vorhanden sein, dann
				// teste, ob man durch einfuegen neuer zum Ziel kommt. Aber
				// nur wenn die SSelection eine Box umfasst !!
				if( 1 < rSelBoxes.Count() )
					return sal_False;

				sal_uInt16 nNewLns = rCpyTbl.GetTabLines().Count() -
								(GetTabLines().Count() - nSttLine );

				// Dann teste mal ob die Anzahl der Boxen fuer die Lines reicht
				SwTableLine* pLastLn = GetTabLines()[ GetTabLines().Count()-1 ];

				pSttBox = pFLine->GetBoxes()[0]->GetBox();
				nSttBox = pFLine->GetLine()->GetTabBoxes().C40_GETPOS( SwTableBox, pSttBox );
				for( sal_uInt16 n = rCpyTbl.GetTabLines().Count() - nNewLns;
						n < rCpyTbl.GetTabLines().Count(); ++n )
				{
					SwTableLine* pCpyLn = rCpyTbl.GetTabLines()[ n ];

					if( pLastLn->GetTabBoxes().Count() < nSttBox ||
						( pLastLn->GetTabBoxes().Count() - nSttBox ) <
							pCpyLn->GetTabBoxes().Count() )
						return sal_False;

					// Test auf Verschachtelungen
					for( nBx = 0; nBx < pCpyLn->GetTabBoxes().Count(); ++nBx )
						if( !( pTmpBox = pLastLn->GetTabBoxes()[ nSttBox + nBx ])
									->GetSttNd() )
							return sal_False;
				}
				// es ist also Platz fuer das zu kopierende vorhanden, also
				// fuege entsprechend neue Zeilen ein.
				SwTableBox* pInsBox = pLastLn->GetTabBoxes()[ nSttBox ];
				ASSERT( pInsBox && pInsBox->GetSttNd(),
					"kein CntntBox oder steht nicht in dieser Tabelle" );
				SwSelBoxes aBoxes;

				if( pUndo
					? !pUndo->InsertRow( *this, SelLineFromBox( pInsBox,
								aBoxes, sal_True ), nNewLns )
					: !InsertRow( pDoc, SelLineFromBox( pInsBox,
								aBoxes, sal_True ), nNewLns, sal_True ) )
					return sal_False;
			}

			nTstLns = rCpyTbl.GetTabLines().Count();		// soviele Kopieren
		}
		else if( 0 == (nFndCnt % rCpyTbl.GetTabLines().Count()) )
			nTstLns = nFndCnt;
		else
			return sal_False;		// kein Platz fuer die Zeilen

		for( nLn = 0; nLn < nTstLns; ++nLn )
		{
			// Zeilen sind genug vorhanden, dann ueberpruefe die Boxen
			// je Zeile
			pFLine = aFndBox.GetLines()[ nLn % nFndCnt ];
			SwTableLine* pLine = pFLine->GetLine();
			pSttBox = pFLine->GetBoxes()[0]->GetBox();
			nSttBox = pLine->GetTabBoxes().C40_GETPOS( SwTableBox, pSttBox );
			if( nLn >= nFndCnt )
			{
				// es sind im ClipBoard mehr Zeilen als selectiert wurden
				pInsFLine = new _FndLine( GetTabLines()[ nSttLine + nLn ],
										&aFndBox );
				pLine = pInsFLine->GetLine();
			}
			SwTableLine* pCpyLn = rCpyTbl.GetTabLines()[ nLn %
										rCpyTbl.GetTabLines().Count() ];

			// zu wenig Zeilen selektiert ?
			if( pInsFLine )
			{
				// eine neue Zeile wird in die FndBox eingefuegt,
				if( pLine->GetTabBoxes().Count() < nSttBox ||
					( pLine->GetTabBoxes().Count() - nSttBox ) <
					pFLine->GetBoxes().Count() )
					return sal_False;

				// Test auf Verschachtelungen
				for( nBx = 0; nBx < pFLine->GetBoxes().Count(); ++nBx )
				{
					if( !( pTmpBox = pLine->GetTabBoxes()[ nSttBox + nBx ])
						->GetSttNd() )
						return sal_False;
					// wenn Ok, fuege die Box in die FndLine zu
					pFndBox = new _FndBox( pTmpBox, pInsFLine );
					pInsFLine->GetBoxes().C40_INSERT( _FndBox, pFndBox, nBx );
				}
				aFndBox.GetLines().C40_INSERT( _FndLine, pInsFLine, nLn );
			}
			else if( pFLine->GetBoxes().Count() == 1 )
			{
				if( pLine->GetTabBoxes().Count() < nSttBox  ||
					( pLine->GetTabBoxes().Count() - nSttBox ) <
					pCpyLn->GetTabBoxes().Count() )
					return sal_False;

				// Test auf Verschachtelungen
				for( nBx = 0; nBx < pCpyLn->GetTabBoxes().Count(); ++nBx )
				{
					if( !( pTmpBox = pLine->GetTabBoxes()[ nSttBox + nBx ])
						->GetSttNd() )
						return sal_False;
					// wenn Ok, fuege die Box in die FndLine zu
					if( nBx == pFLine->GetBoxes().Count() )
					{
						pFndBox = new _FndBox( pTmpBox, pFLine );
						pFLine->GetBoxes().C40_INSERT( _FndBox, pFndBox, nBx );
					}
				}
			}
			else
			{
				// ueberpruefe die selektierten Boxen mit denen im Clipboard
				// (n-Fach)
				if( 0 != ( pFLine->GetBoxes().Count() %
							pCpyLn->GetTabBoxes().Count() ))
					return sal_False;

				// Test auf Verschachtelungen
				for( nBx = 0; nBx < pFLine->GetBoxes().Count(); ++nBx )
					if( !pFLine->GetBoxes()[ nBx ]->GetBox()->GetSttNd() )
						return sal_False;
			}
		}

		if( !aFndBox.GetLines().Count() )
			return sal_False;
	}

	{
		// Tabellen-Formeln in die relative Darstellung umwandeln
		SwTableFmlUpdate aMsgHnt( &rCpyTbl );
		aMsgHnt.eFlags = TBL_RELBOXNAME;
		pCpyDoc->UpdateTblFlds( &aMsgHnt );
	}

	// loesche die Frames
	aFndBox.SetTableLines( *this );
	//Solution:Not dispose accessible table
	//aFndBox.DelFrms( *this );
	aFndBox.DelFrms( *this,sal_False );

	if( 1 == rCpyTbl.GetTabSortBoxes().Count() )
	{
		SwTableBox *pTmpBx = rCpyTbl.GetTabSortBoxes()[0];
		for( sal_uInt16 n = 0; n < rSelBoxes.Count(); ++n )
			lcl_CpyBox( rCpyTbl, pTmpBx, *this,
						(SwTableBox*)rSelBoxes[n], sal_True, pUndo );
	}
	else
		for( nLn = 0; nLn < aFndBox.GetLines().Count(); ++nLn )
		{
			pFLine = aFndBox.GetLines()[ nLn ];
			SwTableLine* pCpyLn = rCpyTbl.GetTabLines()[
								nLn % rCpyTbl.GetTabLines().Count() ];
			for( nBx = 0; nBx < pFLine->GetBoxes().Count(); ++nBx )
			{
				// Kopiere in pMyBox die pCpyBox
				lcl_CpyBox( rCpyTbl, pCpyLn->GetTabBoxes()[
							nBx % pCpyLn->GetTabBoxes().Count() ],
					*this, pFLine->GetBoxes()[ nBx ]->GetBox(), sal_True, pUndo );
			}
		}

	aFndBox.MakeFrms( *this );
	return sal_True;
}



sal_Bool _FndCntntBox( const SwTableBox*& rpBox, void* pPara )
{
	SwTableBox* pBox = (SwTableBox*)rpBox;
	if( rpBox->GetTabLines().Count() )
		pBox->GetTabLines().ForEach( &_FndCntntLine, pPara );
	else
		((SwSelBoxes*)pPara)->Insert( pBox );
	return sal_True;
}


sal_Bool _FndCntntLine( const SwTableLine*& rpLine, void* pPara )
{
	((SwTableLine*)rpLine)->GetTabBoxes().ForEach( &_FndCntntBox, pPara );
	return sal_True;
}


// suche alle Inhaltstragenden-Boxen dieser Box
SwSelBoxes& SwTable::SelLineFromBox( const SwTableBox* pBox,
									SwSelBoxes& rBoxes, sal_Bool bToTop ) const
{
	SwTableLine* pLine = (SwTableLine*)pBox->GetUpper();
	if( bToTop )
		while( pLine->GetUpper() )
			pLine = pLine->GetUpper()->GetUpper();

	// alle alten loeschen
	rBoxes.Remove( sal_uInt16(0), rBoxes.Count() );
	pLine->GetTabBoxes().ForEach( &_FndCntntBox, &rBoxes );
	return rBoxes;
}