/*************************************************************************
 *
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 * 
 * Copyright 2000, 2010 Oracle and/or its affiliates.
 *
 * OpenOffice.org - a multi-platform office productivity suite
 *
 * This file is part of OpenOffice.org.
 *
 * OpenOffice.org is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * OpenOffice.org is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License version 3 for more details
 * (a copy is included in the LICENSE file that accompanied this code).
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with OpenOffice.org.  If not, see
 * <http://www.openoffice.org/license.html>
 * for a copy of the LGPLv3 License.
 *
 ************************************************************************/

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


#include <hintids.hxx>

#include <vcl/graph.hxx>
#include <sot/formats.hxx>
#include <sot/storage.hxx>
#include <unotools/pathoptions.hxx>
#include <sfx2/dispatch.hxx>
#include <sfx2/viewsh.hxx>
#include <svx/xexch.hxx>
#include <svx/xflasit.hxx>
#include <svx/xfillit0.hxx>
#include <svx/xflclit.hxx>
#include <editeng/brshitem.hxx>
#include <svx/svdocapt.hxx>
#include <svx/svdouno.hxx>
#include <svx/xfillit.hxx>
#include <svx/svdpage.hxx>
#include <svx/svdogrp.hxx>
#include <svx/xoutbmp.hxx>
#include <svx/svdoole2.hxx>
#include <svx/fmmodel.hxx>
#include <svx/unomodel.hxx>
// --> OD 2005-08-03 #i50824#
#include <svx/svditer.hxx>
// <--
// --> OD 2006-03-01 #b6382898#
#include <svx/svdograf.hxx>
// <--
#include <unotools/streamwrap.hxx>
#include <fmtanchr.hxx>
#include <fmtcntnt.hxx>
#include <fmtornt.hxx>
#include <fmtflcnt.hxx>
#include <frmfmt.hxx>
#include <docary.hxx>
#include <txtfrm.hxx>
#include <txtflcnt.hxx>
#include <fesh.hxx>
#include <doc.hxx>
#include <IDocumentUndoRedo.hxx>
#include <rootfrm.hxx>
#include <ndtxt.hxx>
#include <pam.hxx>
#include <tblsel.hxx>
#include <swtable.hxx>
#include <flyfrm.hxx>
#include <pagefrm.hxx>
#include <fldbas.hxx>
#include <edimp.hxx>
#include <swundo.hxx>
#include <viewimp.hxx>
#include <dview.hxx>
#include <dcontact.hxx>
#include <dflyobj.hxx>
#include <docsh.hxx>
#include <pagedesc.hxx>
#include <mvsave.hxx>
#include <vcl/virdev.hxx>


using namespace ::com::sun::star;

/*************************************************************************
|*
|*	SwFEShell::Copy()	Copy fuer das Interne Clipboard.
|*		Kopiert alle Selektionen in das Clipboard.
|*
|*	Ersterstellung		JP ??
|*	Letzte Aenderung	MA 22. Feb. 95
|
|*************************************************************************/

sal_Bool SwFEShell::Copy( SwDoc* pClpDoc, const String* pNewClpTxt )
{
	ASSERT( pClpDoc, "kein Clipboard-Dokument"	);

    pClpDoc->GetIDocumentUndoRedo().DoUndo(false); // always false!

	// steht noch Inhalt im ClpDocument, dann muss dieser geloescht werden
	SwNodeIndex aSttIdx( pClpDoc->GetNodes().GetEndOfExtras(), 2 );
	SwTxtNode* pTxtNd = aSttIdx.GetNode().GetTxtNode();
	if( !pTxtNd || pTxtNd->GetTxt().Len() ||
		aSttIdx.GetIndex()+1 != pClpDoc->GetNodes().GetEndOfContent().GetIndex() )
	{
		pClpDoc->GetNodes().Delete( aSttIdx,
			pClpDoc->GetNodes().GetEndOfContent().GetIndex() - aSttIdx.GetIndex() );
		pTxtNd = pClpDoc->GetNodes().MakeTxtNode( aSttIdx,
							(SwTxtFmtColl*)pClpDoc->GetDfltTxtFmtColl() );
		aSttIdx--;
	}

	// stehen noch FlyFrames rum, loesche auch diese
	for( sal_uInt16 n = 0; n < pClpDoc->GetSpzFrmFmts()->Count(); ++n )
	{
		SwFlyFrmFmt* pFly = (SwFlyFrmFmt*)(*pClpDoc->GetSpzFrmFmts())[n];
		pClpDoc->DelLayoutFmt( pFly );
	}
	pClpDoc->GCFieldTypes();		// loesche die FieldTypes

	// wurde ein String uebergeben, so kopiere diesen in das Clipboard-
	// Dokument. Somit kann auch der Calculator das interne Clipboard
	// benutzen.
	if( pNewClpTxt )
	{
        pTxtNd->InsertText( *pNewClpTxt, SwIndex( pTxtNd ) );
		return sal_True;				// das wars.
	}

	pClpDoc->LockExpFlds();
	pClpDoc->SetRedlineMode_intern( nsRedlineMode_t::REDLINE_DELETE_REDLINES );
	sal_Bool bRet;

	// soll ein FlyFrame kopiert werden ?
	if( IsFrmSelected() )
	{
		// hole das FlyFormat
		SwFlyFrm* pFly = FindFlyFrm();
		SwFrmFmt* pFlyFmt = pFly->GetFmt();
		SwFmtAnchor aAnchor( pFlyFmt->GetAnchor() );

        if ((FLY_AT_PARA == aAnchor.GetAnchorId()) ||
            (FLY_AT_CHAR == aAnchor.GetAnchorId()) ||
            (FLY_AT_FLY  == aAnchor.GetAnchorId()) ||
            (FLY_AS_CHAR == aAnchor.GetAnchorId()))
        {
            SwPosition aPos( aSttIdx );
            if ( FLY_AS_CHAR == aAnchor.GetAnchorId() )
            {
                aPos.nContent.Assign( pTxtNd, 0 );
            }
			aAnchor.SetAnchor( &aPos );
		}
        pFlyFmt = pClpDoc->CopyLayoutFmt( *pFlyFmt, aAnchor, true, true );

		// sorge dafuer das das "RootFmt" als erstes im SpzArray-steht
		// (Es wurden ggf. Flys in Flys kopiert.
		SwSpzFrmFmts& rSpzFrmFmts = *(SwSpzFrmFmts*)pClpDoc->GetSpzFrmFmts();
		if( rSpzFrmFmts[ 0 ] != pFlyFmt )
		{
			sal_uInt16 nPos = rSpzFrmFmts.GetPos( pFlyFmt );
			ASSERT( nPos != USHRT_MAX, "Fly steht nicht im Spz-Array" );

			rSpzFrmFmts.Remove( nPos );
			rSpzFrmFmts.Insert( pFlyFmt, 0 );
		}

        if ( FLY_AS_CHAR == aAnchor.GetAnchorId() )
        {
			// JP 13.02.99 Bug 61863: wenn eine Rahmenselektion ins Clipboard
			//				gestellt wird, so muss beim Pasten auch wieder
			//				eine solche vorgefunden werden. Also muss im Node
			//				das kopierte TextAttribut wieder entfernt werden,
			//				sonst wird es als TextSelektion erkannt
			const SwIndex& rIdx = pFlyFmt->GetAnchor().GetCntntAnchor()->nContent;
            SwTxtFlyCnt *const pTxtFly = static_cast<SwTxtFlyCnt *>(
                pTxtNd->GetTxtAttrForCharAt(
                    rIdx.GetIndex(), RES_TXTATR_FLYCNT));
			if( pTxtFly )
			{
				((SwFmtFlyCnt&)pTxtFly->GetFlyCnt()).SetFlyFmt( 0 );
                pTxtNd->EraseText( rIdx, 1 );
            }
        }
		bRet = sal_True;
	}
	else if ( IsObjSelected() )
	{
        SwPosition aPos( aSttIdx, SwIndex( pTxtNd, 0 ));
		const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
		for ( sal_uInt16 i = 0; i < rMrkList.GetMarkCount(); ++i )
		{
			SdrObject *pObj = rMrkList.GetMark( i )->GetMarkedSdrObj();

			if( Imp()->GetDrawView()->IsGroupEntered() ||
				( !pObj->GetUserCall() && pObj->GetUpGroup()) )
			{
				SfxItemSet aSet( pClpDoc->GetAttrPool(), aFrmFmtSetRange );

                SwFmtAnchor aAnchor( FLY_AT_PARA );
				aAnchor.SetAnchor( &aPos );
				aSet.Put( aAnchor );

                SdrObject *const pNew =
                    pClpDoc->CloneSdrObj( *pObj, sal_False, sal_True );

                SwPaM aTemp(aPos);
                pClpDoc->Insert(aTemp, *pNew, &aSet, NULL);
			}
			else
			{
				SwDrawContact *pContact = (SwDrawContact*)GetUserCall( pObj );
				SwFrmFmt *pFmt = pContact->GetFmt();
				SwFmtAnchor aAnchor( pFmt->GetAnchor() );
                if ((FLY_AT_PARA == aAnchor.GetAnchorId()) ||
                    (FLY_AT_CHAR == aAnchor.GetAnchorId()) ||
                    (FLY_AT_FLY  == aAnchor.GetAnchorId()) ||
                    (FLY_AS_CHAR == aAnchor.GetAnchorId()))
                {
					aAnchor.SetAnchor( &aPos );
				}

                pClpDoc->CopyLayoutFmt( *pFmt, aAnchor, true, true );
			}
		}
		bRet = sal_True;
	}
	else
		bRet = _CopySelToDoc( pClpDoc, 0 );		// kopiere die Selectionen

	pClpDoc->SetRedlineMode_intern((RedlineMode_t)0 );
	pClpDoc->UnlockExpFlds();
	if( !pClpDoc->IsExpFldsLocked() )
		pClpDoc->UpdateExpFlds(NULL, true);

	return bRet;
}

const Point &lcl_FindBasePos( const SwFrm *pFrm, const Point &rPt )
{
	const SwFrm *pF = pFrm;
	while ( pF && !pF->Frm().IsInside( rPt ) )
	{
		if ( pF->IsCntntFrm() )
			pF = ((SwCntntFrm*)pF)->GetFollow();
		else
			pF = 0;
	}
	if ( pF )
		return pF->Frm().Pos();
	else
		return pFrm->Frm().Pos();
}

sal_Bool lcl_SetAnchor( const SwPosition& rPos, const SwNode& rNd, SwFlyFrm* pFly,
				const Point& rInsPt, SwFEShell& rDestShell, SwFmtAnchor& rAnchor,
				Point& rNewPos, sal_Bool bCheckFlyRecur )
{
	sal_Bool bRet = sal_True;
	rAnchor.SetAnchor( &rPos );
	SwCntntFrm* pTmpFrm = rNd.GetCntntNode()->getLayoutFrm( rDestShell.GetLayout(), &rInsPt, 0, sal_False );
	SwFlyFrm *pTmpFly = pTmpFrm->FindFlyFrm();
    if( pTmpFly && bCheckFlyRecur && pFly->IsUpperOf( *pTmpFly ) )
    {
		bRet = sal_False;
    }
    else if ( FLY_AT_FLY == rAnchor.GetAnchorId() )
    {
		if( pTmpFly )
		{
			const SwNodeIndex& rIdx = *pTmpFly->GetFmt()->GetCntnt().GetCntntIdx();
			SwPosition aPos( rIdx );
			rAnchor.SetAnchor( &aPos );
			rNewPos = pTmpFly->Frm().Pos();
		}
		else
		{
            rAnchor.SetType( FLY_AT_PAGE );
			rAnchor.SetPageNum( rDestShell.GetPageNumber( rInsPt ) );
			const SwFrm *pPg = pTmpFrm->FindPageFrm();
			rNewPos = pPg->Frm().Pos();
		}
	}
	else
		rNewPos = ::lcl_FindBasePos( pTmpFrm, rInsPt );
	return bRet;
}

sal_Bool SwFEShell::CopyDrawSel( SwFEShell* pDestShell, const Point& rSttPt,
					const Point& rInsPt, sal_Bool bIsMove, sal_Bool bSelectInsert )
{
	sal_Bool bRet = sal_True;

	//Die Liste muss kopiert werden, weil unten die neuen Objekte
	//selektiert werden.
	const SdrMarkList aMrkList( Imp()->GetDrawView()->GetMarkedObjectList() );
	sal_uLong nMarkCount = aMrkList.GetMarkCount();
	if( !pDestShell->Imp()->GetDrawView() )
		// sollte mal eine erzeugt werden
		pDestShell->MakeDrawView();
	else if( bSelectInsert )
		pDestShell->Imp()->GetDrawView()->UnmarkAll();

	SdrPageView *pDestPgView = pDestShell->Imp()->GetPageView(),
				*pSrcPgView = Imp()->GetPageView();
	SwDrawView *pDestDrwView = pDestShell->Imp()->GetDrawView(),
				*pSrcDrwView = Imp()->GetDrawView();
	SwDoc* pDestDoc = pDestShell->GetDoc();

	Size aSiz( rInsPt.X() - rSttPt.X(), rInsPt.Y() - rSttPt.Y() );
	for( sal_uInt16 i = 0; i < nMarkCount; ++i )
	{
		SdrObject *pObj = aMrkList.GetMark( i )->GetMarkedSdrObj();

		SwDrawContact *pContact = (SwDrawContact*)GetUserCall( pObj );
		SwFrmFmt *pFmt = pContact->GetFmt();
		const SwFmtAnchor& rAnchor = pFmt->GetAnchor();

		sal_Bool bInsWithFmt = sal_True;

		if( pDestDrwView->IsGroupEntered() )
		{
			// in die Gruppe einfuegen, wenns aus einer betretenen Gruppe
			// kommt oder das Object nicht zeichengebunden ist
			if( pSrcDrwView->IsGroupEntered() ||
                (FLY_AS_CHAR != rAnchor.GetAnchorId()) )

			{
				SdrObject* pNew = pDestDoc->CloneSdrObj( *pObj, bIsMove &&
										GetDoc() == pDestDoc, sal_False );
				pNew->NbcMove( aSiz );
				pDestDrwView->InsertObjectAtView( pNew, *pDestPgView );
				bInsWithFmt = sal_False;
			}
		}

		if( bInsWithFmt )
		{
			SwFmtAnchor aAnchor( rAnchor );
			Point aNewAnch;

            if ((FLY_AT_PARA == aAnchor.GetAnchorId()) ||
                (FLY_AT_CHAR == aAnchor.GetAnchorId()) ||
                (FLY_AT_FLY  == aAnchor.GetAnchorId()) ||
                (FLY_AS_CHAR == aAnchor.GetAnchorId()))
            {
				if ( this == pDestShell )
				{
					//gleiche Shell? Dann erfrage die Position an der
					//uebergebenen DokumentPosition
					SwPosition aPos( *GetCrsr()->GetPoint() );
					Point aPt( rInsPt );
					aPt -= rSttPt - pObj->GetSnapRect().TopLeft();
					SwCrsrMoveState aState( MV_SETONLYTEXT );
					GetLayout()->GetCrsrOfst( &aPos, aPt, &aState );
					const SwNode *pNd;
					if( (pNd = &aPos.nNode.GetNode())->IsNoTxtNode() )
						bRet = sal_False;
					else
						bRet = ::lcl_SetAnchor( aPos, *pNd, 0, rInsPt,
								*pDestShell, aAnchor, aNewAnch, sal_False );
				}
				else
				{
					SwPaM *pCrsr = pDestShell->GetCrsr();
					if( pCrsr->GetNode()->IsNoTxtNode() )
						bRet = sal_False;
					else
						bRet = ::lcl_SetAnchor( *pCrsr->GetPoint(),
												*pCrsr->GetNode(), 0, rInsPt,
												*pDestShell, aAnchor,
												aNewAnch, sal_False );
				}
			}
            else if ( FLY_AT_PAGE == aAnchor.GetAnchorId() )
			{
				aAnchor.SetPageNum( pDestShell->GetPageNumber( rInsPt ) );
                const SwRootFrm* pTmpRoot = pDestShell->GetLayout();
                const SwFrm* pPg = pTmpRoot->GetPageAtPos( rInsPt, 0, true );
                if ( pPg )
                    aNewAnch = pPg->Frm().Pos();
			}

			if( bRet )
			{
				if( pSrcDrwView->IsGroupEntered() ||
					( !pObj->GetUserCall() && pObj->GetUpGroup()) )
				{
					SfxItemSet aSet( pDestDoc->GetAttrPool(),aFrmFmtSetRange);
					aSet.Put( aAnchor );
					SdrObject* pNew = pDestDoc->CloneSdrObj( *pObj, bIsMove &&
												GetDoc() == pDestDoc, sal_True );
					pFmt = pDestDoc->Insert( *pDestShell->GetCrsr(),
											*pNew, &aSet, NULL );
				}
				else
                    pFmt = pDestDoc->CopyLayoutFmt( *pFmt, aAnchor, true, true );

				//Kann 0 sein, weil Draws in Kopf-/Fusszeilen nicht erlaubt sind.
				if ( pFmt )
				{
                    SdrObject* pNew = pFmt->FindSdrObject();
                    if ( FLY_AS_CHAR != aAnchor.GetAnchorId() )
                    {
						Point aPos( rInsPt );
						aPos -= aNewAnch;
						aPos -= rSttPt - pObj->GetSnapRect().TopLeft();
                        // OD 2004-04-05 #i26791# - change attributes instead of
                        // direct positioning
                        pFmt->SetFmtAttr( SwFmtHoriOrient( aPos.X(), text::HoriOrientation::NONE, text::RelOrientation::FRAME ) );
                        pFmt->SetFmtAttr( SwFmtVertOrient( aPos.Y(), text::VertOrientation::NONE, text::RelOrientation::FRAME ) );
                        // --> OD 2005-04-15 #i47455# - notify draw frame format
                        // that position attributes are already set.
                        if ( pFmt->ISA(SwDrawFrmFmt) )
                        {
                            static_cast<SwDrawFrmFmt*>(pFmt)->PosAttrSet();
                        }
                        // <--
                    }
					if( bSelectInsert )
						pDestDrwView->MarkObj( pNew, pDestPgView );
				}
			}
		}
	}

	if ( bIsMove && bRet )
	{
		if( pDestShell == this )
		{
			const SdrMarkList aList( pSrcDrwView->GetMarkedObjectList() );
			pSrcDrwView->UnmarkAll();

            sal_uLong nMrkCnt = aMrkList.GetMarkCount();
			sal_uInt16 i;
            for ( i = 0; i < nMrkCnt; ++i )
			{
				SdrObject *pObj = aMrkList.GetMark( i )->GetMarkedSdrObj();
				pSrcDrwView->MarkObj( pObj, pSrcPgView );
			}
			DelSelectedObj();
            nMrkCnt = aList.GetMarkCount();
            for ( i = 0; i < nMrkCnt; ++i )
			{
				SdrObject *pObj = aList.GetMark( i )->GetMarkedSdrObj();
				pSrcDrwView->MarkObj( pObj, pSrcPgView );
			}
		}
		else
			DelSelectedObj();
	}

	return bRet;
}

sal_Bool SwFEShell::Copy( SwFEShell* pDestShell, const Point& rSttPt,
					const Point& rInsPt, sal_Bool bIsMove, sal_Bool bSelectInsert )
{
	sal_Bool bRet = sal_False;

	ASSERT( pDestShell, "Copy ohne DestShell." );
	ASSERT( this == pDestShell || !pDestShell->IsObjSelected(),
			"Dest-Shell darf nie im Obj-Modus sein" );

	SET_CURR_SHELL( pDestShell );

	pDestShell->StartAllAction();
	pDestShell->GetDoc()->LockExpFlds();

	// Referenzen sollen verschoben werden.
	sal_Bool bCopyIsMove = pDoc->IsCopyIsMove();
	if( bIsMove )
		// am Doc ein Flag setzen, damit in den TextNodes
		pDoc->SetCopyIsMove( sal_True );

	RedlineMode_t eOldRedlMode = pDestShell->GetDoc()->GetRedlineMode();
	pDestShell->GetDoc()->SetRedlineMode_intern( (RedlineMode_t)(eOldRedlMode | nsRedlineMode_t::REDLINE_DELETE_REDLINES));

	// sind Tabellen-Formeln im Bereich, dann muss erst die Tabelle
	// angezeigt werden, damit die Tabellen-Formel den neuen Wert errechnen
	// kann (bei Bereichen wird sich ueber das Layout die einzelnen Boxen
	// besorgt)
	SwFieldType* pTblFldTyp = pDestShell->GetDoc()->GetSysFldType( RES_TABLEFLD );

	if( IsFrmSelected() )
	{
		SwFlyFrm* pFly = FindFlyFrm();
		SwFrmFmt* pFlyFmt = pFly->GetFmt();
		SwFmtAnchor aAnchor( pFlyFmt->GetAnchor() );
		bRet = sal_True;
		Point aNewAnch;

        if ((FLY_AT_PARA == aAnchor.GetAnchorId()) ||
            (FLY_AT_CHAR == aAnchor.GetAnchorId()) ||
            (FLY_AT_FLY  == aAnchor.GetAnchorId()) ||
            (FLY_AS_CHAR == aAnchor.GetAnchorId()))
        {
			if ( this == pDestShell )
			{
				// gleiche Shell? Dann erfrage die Position an der
				// uebergebenen DokumentPosition
				SwPosition aPos( *GetCrsr()->GetPoint() );
				Point aPt( rInsPt );
				aPt -= rSttPt - pFly->Frm().Pos();
				SwCrsrMoveState aState( MV_SETONLYTEXT );
				GetLayout()->GetCrsrOfst( &aPos, aPt, &aState );
				const SwNode *pNd;
				if( (pNd = &aPos.nNode.GetNode())->IsNoTxtNode() )
					bRet = sal_False;
				else
				{	//Nicht in sich selbst kopieren
					const SwNodeIndex *pTmp = pFlyFmt->GetCntnt().GetCntntIdx();
					if ( aPos.nNode > *pTmp && aPos.nNode <
						pTmp->GetNode().EndOfSectionIndex() )
					{
						bRet = sal_False;
					}
					else
						bRet = ::lcl_SetAnchor( aPos, *pNd, pFly, rInsPt,
										*pDestShell, aAnchor, aNewAnch, sal_True );
				}
			}
			else
			{
				const SwPaM *pCrsr = pDestShell->GetCrsr();
				if( pCrsr->GetNode()->IsNoTxtNode() )
					bRet = sal_False;
				else
					bRet = ::lcl_SetAnchor( *pCrsr->GetPoint(), *pCrsr->GetNode(),
											pFly, rInsPt, *pDestShell, aAnchor,
									aNewAnch, GetDoc() == pDestShell->GetDoc());
			}
		}
        else if ( FLY_AT_PAGE == aAnchor.GetAnchorId() )
        {
			aAnchor.SetPageNum( pDestShell->GetPageNumber( rInsPt ) );
            const SwRootFrm* pTmpRoot = pDestShell->GetLayout();
            const SwFrm* pPg = pTmpRoot->GetPageAtPos( rInsPt, 0, true );
            if ( pPg )
                aNewAnch = pPg->Frm().Pos();
        }
		else {
			ASSERT( !this, "was fuer ein Anchor ist es denn?" );
        }

		if( bRet )
		{
			SwFrmFmt *pOldFmt = pFlyFmt;
            pFlyFmt = pDestShell->GetDoc()->CopyLayoutFmt( *pFlyFmt, aAnchor, true, true );

            if ( FLY_AS_CHAR != aAnchor.GetAnchorId() )
            {
				Point aPos( rInsPt );
				aPos -= aNewAnch;
				aPos -= rSttPt - pFly->Frm().Pos();
                pFlyFmt->SetFmtAttr( SwFmtHoriOrient( aPos.X(),text::HoriOrientation::NONE, text::RelOrientation::FRAME ) );
                pFlyFmt->SetFmtAttr( SwFmtVertOrient( aPos.Y(),text::VertOrientation::NONE, text::RelOrientation::FRAME ) );
			}

			const Point aPt( pDestShell->GetCrsrDocPos() );

			if( bIsMove )
				GetDoc()->DelLayoutFmt( pOldFmt );

			// nur selektieren wenn es in der gleichen Shell verschoben/
			//	kopiert wird
			if( bSelectInsert )
			{
				SwFlyFrm* pFlyFrm = ((SwFlyFrmFmt*)pFlyFmt)->GetFrm( &aPt, sal_False );
				if( pFlyFrm )
				{
					//JP 12.05.98: sollte das nicht im SelectFlyFrm stehen???
					pDestShell->Imp()->GetDrawView()->UnmarkAll();
					pDestShell->SelectFlyFrm( *pFlyFrm, sal_True );
				}
			}

			if( this != pDestShell && !pDestShell->HasShFcs() )
				pDestShell->Imp()->GetDrawView()->hideMarkHandles();
		}
	}
	else if ( IsObjSelected() )
		bRet = CopyDrawSel( pDestShell, rSttPt, rInsPt, bIsMove, bSelectInsert );
	else if( IsTableMode() )
	{
		// kopiere Teile aus einer Tabelle: lege eine Tabelle mit der Breite
		// von der Originalen an und kopiere die selectierten Boxen.
		// Die Groessen werden prozentual korrigiert.

		// lasse ueber das Layout die Boxen suchen
		const SwTableNode* pTblNd;
		SwSelBoxes aBoxes;
		GetTblSel( *this, aBoxes );
		if( aBoxes.Count() &&
			0 != (pTblNd = aBoxes[0]->GetSttNd()->FindTableNode()) )
		{
			SwPosition* pDstPos = 0;
			if( this == pDestShell )
			{
				// gleiche Shell? Dann erzeuge einen Crsr an der
				// uebergebenen DokumentPosition
				pDstPos = new SwPosition( *GetCrsr()->GetPoint() );
				Point aPt( rInsPt );
				GetLayout()->GetCrsrOfst( pDstPos, aPt );
				if( !pDstPos->nNode.GetNode().IsNoTxtNode() )
					bRet = sal_True;
			}
			else if( !pDestShell->GetCrsr()->GetNode()->IsNoTxtNode() )
			{
				pDstPos = new SwPosition( *pDestShell->GetCrsr()->GetPoint() );
				bRet = sal_True;
			}

			if( bRet )
			{
				if( GetDoc() == pDestShell->GetDoc() )
					ParkTblCrsr();

				bRet = pDestShell->GetDoc()->InsCopyOfTbl( *pDstPos, aBoxes,0,
										bIsMove && this == pDestShell &&
										aBoxes.Count() == pTblNd->GetTable().
										GetTabSortBoxes().Count(),
										this != pDestShell );

				if( this != pDestShell )
					*pDestShell->GetCrsr()->GetPoint() = *pDstPos;

				// wieder alle geparkten Crsr erzeugen?
				if( GetDoc() == pDestShell->GetDoc() )
					GetCrsr();

				// JP 16.04.99: Bug 64908 - InsPos setzen, damit der geparkte
				//				Cursor auf die EinfuegePos. positioniert wird
				if( this == pDestShell )
					GetCrsrDocPos() = rInsPt;
			}
			delete pDstPos;
		}
	}
	else
	{
		bRet = sal_True;
		if( this == pDestShell )
		{
			// gleiche Shell? Dann erfrage die Position an der
			// uebergebenen DokumentPosition
			SwPosition aPos( *GetCrsr()->GetPoint() );
			Point aPt( rInsPt );
			GetLayout()->GetCrsrOfst( &aPos, aPt );
			bRet = !aPos.nNode.GetNode().IsNoTxtNode();
		}
		else if( pDestShell->GetCrsr()->GetNode()->IsNoTxtNode() )
			bRet = sal_False;

		if( bRet )
			bRet = 0 != SwEditShell::Copy( pDestShell );
	}

	pDestShell->GetDoc()->SetRedlineMode_intern( eOldRedlMode );
	pDoc->SetCopyIsMove( bCopyIsMove );

	// wurden neue Tabellenformeln eingefuegt ?
	if( pTblFldTyp->GetDepends() )
	{
		// alte Actions beenden; die Tabellen-Frames werden angelegt und
		// eine SSelection kann erzeugt werden
		sal_uInt16 nActCnt;
		for( nActCnt = 0; pDestShell->ActionPend(); ++nActCnt )
			pDestShell->EndAllAction();

		for( ; nActCnt; --nActCnt )
			pDestShell->StartAllAction();
	}
	pDestShell->GetDoc()->UnlockExpFlds();
	pDestShell->GetDoc()->UpdateFlds(NULL, false);

	pDestShell->EndAllAction();
	return bRet;
}

/*************************************************************************
|*
|*	SwFEShell::Paste()	Paste fuer das Interne Clipboard.
|*		Kopiert den Inhalt vom Clipboard in das Dokument.
|*
|*	Ersterstellung		JP ??
|*	Letzte Aenderung	MA 22. Feb. 95
|
|*************************************************************************/

namespace {
    typedef boost::shared_ptr<SwPaM> PaMPtr;
    typedef boost::shared_ptr<SwPosition> PositionPtr;
    typedef std::pair< PaMPtr, PositionPtr > Insertion;
}

sal_Bool SwFEShell::Paste( SwDoc* pClpDoc, sal_Bool bIncludingPageFrames )
{
	SET_CURR_SHELL( this );
	ASSERT( pClpDoc, "kein Clipboard-Dokument"	);
    const sal_uInt16 nStartPageNumber = GetPhyPageNum();
	// dann bis zum Ende vom Nodes Array
	SwNodeIndex aIdx( pClpDoc->GetNodes().GetEndOfExtras(), 2 );
	SwPaM aCpyPam( aIdx ); //DocStart

	// sind Tabellen-Formeln im Bereich, dann muss erst die Tabelle
	// angezeigt werden, damit die Tabellen-Formel den neuen Wert errechnen
	// kann (bei Bereichen wird sich ueber das Layout die einzelnen Boxen
	// besorgt)
	SwFieldType* pTblFldTyp = GetDoc()->GetSysFldType( RES_TABLEFLD );

	SwTableNode *pDestNd, *pSrcNd = aCpyPam.GetNode()->GetTableNode();
	if( !pSrcNd )								// TabellenNode ?
	{											// nicht ueberspringen!!
		SwCntntNode* pCNd = aCpyPam.GetNode()->GetCntntNode();
		if( pCNd )
			aCpyPam.GetPoint()->nContent.Assign( pCNd, 0 );
		else if( !aCpyPam.Move( fnMoveForward, fnGoNode ))
			aCpyPam.Move( fnMoveBackward, fnGoNode );
	}

	aCpyPam.SetMark();
	aCpyPam.Move( fnMoveForward, fnGoDoc );

	sal_Bool bRet = sal_True, bDelTbl = sal_True;
	StartAllAction();
    GetDoc()->GetIDocumentUndoRedo().StartUndo( UNDO_INSGLOSSARY, NULL );
	GetDoc()->LockExpFlds();

    // When the clipboard content has been created by a rectangular selection
    // the pasting is more sophisticated:
    // every paragraph will be inserted into another position.
    // The first positions are given by the actual cursor ring,
    // if there are more text portions to insert than cursor in this ring,
    // the additional insert positions will be created by moving the last
    // cursor position into the next line (like pressing the cursor down key)
    if( pClpDoc->IsColumnSelection() && !IsTableMode() )
    {
        // Creation of the list of insert positions
        std::list< Insertion > aCopyList;
        // The number of text portions of the rectangular selection
        const sal_uInt32 nSelCount = aCpyPam.GetPoint()->nNode.GetIndex()
                       - aCpyPam.GetMark()->nNode.GetIndex();
        sal_uInt32 nCount = nSelCount;
        SwNodeIndex aClpIdx( aIdx );
        SwPaM* pStartCursor = GetCrsr();
        SwPaM* pCurrCrsr = pStartCursor;
        sal_uInt32 nCursorCount = pStartCursor->numberOf();
        // If the target selection is a multi-selection, often the last and first
        // cursor of the ring points to identical document positions. Then
        // we should avoid double insertion of text portions...
        while( nCursorCount > 1 && *pCurrCrsr->GetPoint() ==
            *(dynamic_cast<SwPaM*>(pCurrCrsr->GetPrev())->GetPoint()) )
        {
            --nCursorCount;
            pCurrCrsr = dynamic_cast<SwPaM*>(pCurrCrsr->GetNext());
            pStartCursor = pCurrCrsr;
        }
        SwPosition aStartPos( *pStartCursor->GetPoint() );
        SwPosition aInsertPos( aStartPos ); // first insertion position
        bool bCompletePara = false;
        sal_uInt16 nMove = 0;
        while( nCount )
        {
            --nCount;
            ASSERT( aIdx.GetNode().GetCntntNode(), "Who filled the clipboard?!" )
            if( aIdx.GetNode().GetCntntNode() ) // robust
            {
                Insertion aInsertion( PaMPtr( new SwPaM( aIdx ) ),
                    PositionPtr( new SwPosition( aInsertPos ) ) );
                ++aIdx;
                aInsertion.first->SetMark();
                if( pStartCursor == pCurrCrsr->GetNext() )
                {   // Now we have to look for insertion positions...
                    if( !nMove ) // Annotate the last given insert position
                        aStartPos = aInsertPos;
                    SwCursor aCrsr( aStartPos, 0, false);
                    // Check if we find another insert position by moving
                    // down the last given position
                    if( aCrsr.UpDown( sal_False, ++nMove, 0, 0 ) )
                        aInsertPos = *aCrsr.GetPoint();
                    else // if there is no paragraph we have to create it
                        bCompletePara = nCount > 0;
                    nCursorCount = 0;
                }
                else // as long as we find more insert positions in the cursor ring
                {    // we'll take them
                    pCurrCrsr = dynamic_cast<SwPaM*>(pCurrCrsr->GetNext());
                    aInsertPos = *pCurrCrsr->GetPoint();
                    --nCursorCount;
                }
                // If there are no more paragraphs e.g. at the end of a document,
                // we insert complete paragraphs instead of text portions
                if( bCompletePara )
                    aInsertion.first->GetPoint()->nNode = aIdx;
                else
                    aInsertion.first->GetPoint()->nContent =
                        aInsertion.first->GetCntntNode()->Len();
                aCopyList.push_back( aInsertion );
            }
            // If there are no text portions left but there are some more
            // cursor positions to fill we have to restart with the first
            // text portion
            if( !nCount && nCursorCount )
            {
                nCount = std::min( nSelCount, nCursorCount );
                aIdx = aClpIdx; // Start of clipboard content
            }
        }
        std::list< Insertion >::const_iterator pCurr = aCopyList.begin();
        std::list< Insertion >::const_iterator pEnd = aCopyList.end();
        while( pCurr != pEnd )
        {
            SwPosition& rInsPos = *pCurr->second;
            SwPaM& rCopy = *pCurr->first;
            const SwStartNode* pBoxNd = rInsPos.nNode.GetNode().FindTableBoxStartNode();
            if( pBoxNd && 2 == pBoxNd->EndOfSectionIndex() - pBoxNd->GetIndex() &&
                rCopy.GetPoint()->nNode != rCopy.GetMark()->nNode )
            {
                // if more than one node will be copied into a cell
                // the box attributes have to be removed
                GetDoc()->ClearBoxNumAttrs( rInsPos.nNode );
            }
            {
                SwNodeIndex aIndexBefore(rInsPos.nNode);
                aIndexBefore--;
                pClpDoc->CopyRange( rCopy, rInsPos, false );
                {
                    aIndexBefore++;
                    SwPaM aPaM(SwPosition(aIndexBefore),
                               SwPosition(rInsPos.nNode));
                    aPaM.GetDoc()->MakeUniqueNumRules(aPaM);
                }
            }
            SaveTblBoxCntnt( &rInsPos );
            ++pCurr;
        }
    }
    else
    {
        FOREACHPAM_START(this)

        if( pSrcNd &&
			0 != ( pDestNd = GetDoc()->IsIdxInTbl( PCURCRSR->GetPoint()->nNode )))
		{
			SwPosition aDestPos( *PCURCRSR->GetPoint() );

			sal_Bool bParkTblCrsr = sal_False;
			const SwStartNode* pSttNd =  PCURCRSR->GetNode()->FindTableBoxStartNode();

            // TABLE IN TABLE: Tabelle in Tabelle kopieren
			// lasse ueber das Layout die Boxen suchen
			SwSelBoxes aBoxes;
			if( IsTableMode() )		// Tabellen-Selecktion ??
			{
				GetTblSel( *this, aBoxes );
				ParkTblCrsr();
				bParkTblCrsr = sal_True;
			}
			else if( !PCURCRSR->HasMark() && PCURCRSR->GetNext() == PCURCRSR &&
				     ( !pSrcNd->GetTable().IsTblComplex() ||
                       pDestNd->GetTable().IsNewModel() ) )
			{
				// dann die Tabelle "relativ" kopieren
				SwTableBox* pBox = pDestNd->GetTable().GetTblBox(
										pSttNd->GetIndex() );
				ASSERT( pBox, "Box steht nicht in dieser Tabelle" );
				aBoxes.Insert( pBox );
			}

			SwNodeIndex aNdIdx( *pDestNd->EndOfSectionNode());
			if( !bParkTblCrsr )
			{
				// erstmal aus der gesamten Tabelle raus
// ????? was ist mit Tabelle alleine im Rahmen ???????
				SwCntntNode* pCNd = GetDoc()->GetNodes().GoNext( &aNdIdx );
				SwPosition aPos( aNdIdx, SwIndex( pCNd, 0 ));
                // #i59539: Don't remove all redline
                SwPaM const tmpPaM(*pDestNd, *pDestNd->EndOfSectionNode());
                ::PaMCorrAbs(tmpPaM, aPos);
			}

			bRet = GetDoc()->InsCopyOfTbl( aDestPos, aBoxes, &pSrcNd->GetTable(),
											sal_False, sal_False );

			if( bParkTblCrsr )
				GetCrsr();
			else
			{
				// und wieder in die Box zurueck
				aNdIdx = *pSttNd;
				SwCntntNode* pCNd = GetDoc()->GetNodes().GoNext( &aNdIdx );
				SwPosition aPos( aNdIdx, SwIndex( pCNd, 0 ));
                // #i59539: Don't remove all redline
                SwNode & rNode(PCURCRSR->GetPoint()->nNode.GetNode());
                SwCntntNode *const pCntntNode( rNode.GetCntntNode() );
                SwPaM const tmpPam(rNode, 0,
                                   rNode, (pCntntNode) ? pCntntNode->Len() : 0);
                ::PaMCorrAbs(tmpPam, aPos);
			}

			break;		// aus der "while"-Schleife heraus
		}
        else if( *aCpyPam.GetPoint() == *aCpyPam.GetMark() &&
				 pClpDoc->GetSpzFrmFmts()->Count() )
		{
			// so langsam sollte mal eine DrawView erzeugt werden
			if( !Imp()->GetDrawView() )
				MakeDrawView();

            for ( sal_uInt16 i = 0; i < pClpDoc->GetSpzFrmFmts()->Count(); ++i )
			{
				sal_Bool bInsWithFmt = sal_True;
				const SwFrmFmt& rCpyFmt = *(*pClpDoc->GetSpzFrmFmts())[i];

				if( Imp()->GetDrawView()->IsGroupEntered() &&
					RES_DRAWFRMFMT == rCpyFmt.Which() &&
                    (FLY_AS_CHAR != rCpyFmt.GetAnchor().GetAnchorId()) )
                {
					const SdrObject* pSdrObj = rCpyFmt.FindSdrObject();
					if( pSdrObj )
					{
						SdrObject* pNew = GetDoc()->CloneSdrObj( *pSdrObj,
															sal_False, sal_False );

                        // Insert object sets any anchor position to 0.
                        // Therefore we calculate the absolute position here
                        // and after the insert the anchor of the object
                        // is set to the anchor of the group object.
                        Rectangle aSnapRect = pNew->GetSnapRect();
                        if( pNew->GetAnchorPos().X() || pNew->GetAnchorPos().Y() )
                        {
                            const Point aPoint( 0, 0 );
                            // OD 2004-04-05 #i26791# - direct drawing object
                            // positioning for group members
                            pNew->NbcSetAnchorPos( aPoint );
                            pNew->NbcSetSnapRect( aSnapRect );
                        }

						Imp()->GetDrawView()->InsertObjectAtView( pNew, *Imp()->GetPageView() );

                        Point aGrpAnchor( 0, 0 );
                        SdrObjList* pList = pNew->GetObjList();
                        if ( pList )
                        {
                            SdrObject* pOwner = pList->GetOwnerObj();
                            if ( pOwner )
                            {
                                SdrObjGroup* pThisGroup = PTR_CAST(SdrObjGroup, pOwner);
                                aGrpAnchor = pThisGroup->GetAnchorPos();
                            }
                        }

                        // OD 2004-04-05 #i26791# - direct drawing object
                        // positioning for group members
                        pNew->NbcSetAnchorPos( aGrpAnchor );
                        pNew->SetSnapRect( aSnapRect );

						bInsWithFmt = sal_False;
					}
				}

				if( bInsWithFmt  )
				{
					SwFmtAnchor aAnchor( rCpyFmt.GetAnchor() );
                    if ((FLY_AT_PARA == aAnchor.GetAnchorId()) ||
                        (FLY_AT_CHAR == aAnchor.GetAnchorId()) ||
                        (FLY_AS_CHAR == aAnchor.GetAnchorId()))
                    {
						SwPosition* pPos = PCURCRSR->GetPoint();
                        // #108784# allow shapes (no controls) in header/footer
                        if( RES_DRAWFRMFMT == rCpyFmt.Which() &&
                            GetDoc()->IsInHeaderFooter( pPos->nNode ) &&
                            CheckControlLayer( rCpyFmt.FindSdrObject() ) )
                            continue;

						aAnchor.SetAnchor( pPos );
                    }
                    else if ( FLY_AT_PAGE == aAnchor.GetAnchorId() )
                    {
						aAnchor.SetPageNum( GetPhyPageNum() );
					}
					else if( FLY_AT_FLY == aAnchor.GetAnchorId() )
					{
						Point aPt;
						lcl_SetAnchor( *PCURCRSR->GetPoint(), *PCURCRSR->GetNode(),
										0, aPt, *this, aAnchor, aPt, sal_False );
					}

                    SwFrmFmt * pNew = GetDoc()->CopyLayoutFmt( rCpyFmt, aAnchor, true, true );

					if( pNew )
					{
						if( RES_FLYFRMFMT == pNew->Which() )
						{
							const Point aPt( GetCrsrDocPos() );
							SwFlyFrm* pFlyFrm = ((SwFlyFrmFmt*)pNew)->
														GetFrm( &aPt, sal_False );
							if( pFlyFrm )
								SelectFlyFrm( *pFlyFrm, sal_True );
							// immer nur den ersten Fly-Frame nehmen; die anderen
							// wurden ueber Fly in Fly ins ClipBoard kopiert !
							break;
						}
						else
						{
							ASSERT( RES_DRAWFRMFMT == pNew->Which(), "Neues Format.");
                            // --> OD 2005-09-01 #i52780# - drawing object has
                            // to be made visible on paste.
                            {
                                SwDrawContact* pContact =
                                    static_cast<SwDrawContact*>(pNew->FindContactObj());
                                pContact->MoveObjToVisibleLayer( pContact->GetMaster() );
                            }
                            // <--
                            SdrObject *pObj = pNew->FindSdrObject();
							SwDrawView  *pDV = Imp()->GetDrawView();
							pDV->MarkObj( pObj, pDV->GetSdrPageView() );
                            // --> OD 2005-04-15 #i47455# - notify draw frame format
                            // that position attributes are already set.
                            if ( pNew->ISA(SwDrawFrmFmt) )
                            {
                                static_cast<SwDrawFrmFmt*>(pNew)->PosAttrSet();
                            }
                            // <--
						}
					}
				}
			}
		}
		else
		{
			if( bDelTbl && IsTableMode() )
			{
				SwEditShell::Delete();
				bDelTbl = sal_False;
			}

			SwPosition& rInsPos = *PCURCRSR->GetPoint();
			const SwStartNode* pBoxNd = rInsPos.nNode.GetNode().
													FindTableBoxStartNode();
			if( pBoxNd && 2 == pBoxNd->EndOfSectionIndex() -
								pBoxNd->GetIndex() &&
				aCpyPam.GetPoint()->nNode != aCpyPam.GetMark()->nNode )
			{
				// es wird mehr als 1 Node in die akt. Box kopiert. Dann
				// muessen die BoxAttribute aber entfernt werden.
				GetDoc()->ClearBoxNumAttrs( rInsPos.nNode );
			}
            //find out if the clipboard document starts with a table
            bool bStartWithTable = 0 != aCpyPam.Start()->nNode.GetNode().FindTableNode();
            SwPosition aInsertPosition( rInsPos );

            {
                SwNodeIndex aIndexBefore(rInsPos.nNode);

                aIndexBefore--;

                pClpDoc->CopyRange( aCpyPam, rInsPos, false );

                {
                    aIndexBefore++;
                    SwPaM aPaM(SwPosition(aIndexBefore),
                               SwPosition(rInsPos.nNode));

                    aPaM.GetDoc()->MakeUniqueNumRules(aPaM);
                }
            }

			SaveTblBoxCntnt( &rInsPos );
            if(bIncludingPageFrames && bStartWithTable)
            {
                //remove the paragraph in front of the table
                SwPaM aPara(aInsertPosition);
                GetDoc()->DelFullPara(aPara);
            }
            //additionally copy page bound frames
            if( bIncludingPageFrames && pClpDoc->GetSpzFrmFmts()->Count() )
            {
                // create a draw view if necessary
                if( !Imp()->GetDrawView() )
                    MakeDrawView();

                for ( sal_uInt16 i = 0; i < pClpDoc->GetSpzFrmFmts()->Count(); ++i )
                {
                    sal_Bool bInsWithFmt = sal_True;
                    const SwFrmFmt& rCpyFmt = *(*pClpDoc->GetSpzFrmFmts())[i];
                    if( bInsWithFmt  )
                    {
                        SwFmtAnchor aAnchor( rCpyFmt.GetAnchor() );
                        if ( FLY_AT_PAGE == aAnchor.GetAnchorId() )
                        {
                            aAnchor.SetPageNum( aAnchor.GetPageNum() + nStartPageNumber - 1 );
                        }
                        else
                            continue;
                        GetDoc()->CopyLayoutFmt( rCpyFmt, aAnchor, true, true );
                    }
                }
            }
		}

        FOREACHPAM_END()
    }

    GetDoc()->GetIDocumentUndoRedo().EndUndo( UNDO_INSGLOSSARY, NULL );

	// wurden neue Tabellenformeln eingefuegt ?
	if( pTblFldTyp->GetDepends() )
	{
		// alte Actions beenden; die Tabellen-Frames werden angelegt und
		// eine Selection kann erzeugt werden
		sal_uInt16 nActCnt;
		for( nActCnt = 0; ActionPend(); ++nActCnt )
			EndAllAction();

		for( ; nActCnt; --nActCnt )
			StartAllAction();
	}
	GetDoc()->UnlockExpFlds();
	GetDoc()->UpdateFlds(NULL, false);
	EndAllAction();

	return bRet;
}

/*-- 14.06.2004 13:31:17---------------------------------------------------

  -----------------------------------------------------------------------*/
sal_Bool SwFEShell::PastePages( SwFEShell& rToFill, sal_uInt16 nStartPage, sal_uInt16 nEndPage)
{
    Push();
    if(!GotoPage(nStartPage))
    {
        Pop(sal_False);
        return sal_False;
    }
    MovePage( fnPageCurr, fnPageStart );
    SwPaM aCpyPam( *GetCrsr()->GetPoint() );
    String sStartingPageDesc = GetPageDesc( GetCurPageDesc()).GetName();
    SwPageDesc* pDesc = rToFill.FindPageDescByName( sStartingPageDesc, sal_True );
    if( pDesc )
        rToFill.ChgCurPageDesc( *pDesc );

    if(!GotoPage(nEndPage))
    {
        Pop(sal_False);
        return sal_False;
    }
    //if the page starts with a table a paragraph has to be inserted before
    SwNode* pTableNode = aCpyPam.GetNode()->FindTableNode();
    if(pTableNode)
    {
        //insert a paragraph
        StartUndo(UNDO_INSERT);
        SwNodeIndex aTblIdx(  *pTableNode, -1 );
        SwPosition aBefore(aTblIdx);
        if(GetDoc()->AppendTxtNode( aBefore ))
        {
            SwPaM aTmp(aBefore);
            aCpyPam = aTmp;
        }
        EndUndo(UNDO_INSERT);
    }

    MovePage( fnPageCurr, fnPageEnd );
    aCpyPam.SetMark();
    *aCpyPam.GetMark() = *GetCrsr()->GetPoint();

    SET_CURR_SHELL( this );

    StartAllAction();
    GetDoc()->LockExpFlds();
    SetSelection(aCpyPam);
    // copy the text of the selection
    SwEditShell::Copy(&rToFill);

    if(pTableNode)
    {
        //remove the inserted paragraph
        Undo();
        //remove the paragraph in the second doc, too
	    SwNodeIndex aIdx( rToFill.GetDoc()->GetNodes().GetEndOfExtras(), 2 );
	    SwPaM aPara( aIdx ); //DocStart
        rToFill.GetDoc()->DelFullPara(aPara);
    }
    // now the page bound objects
    //additionally copy page bound frames
    if( GetDoc()->GetSpzFrmFmts()->Count() )
    {
        // create a draw view if necessary
        if( !rToFill.Imp()->GetDrawView() )
            rToFill.MakeDrawView();

        for ( sal_uInt16 i = 0; i < GetDoc()->GetSpzFrmFmts()->Count(); ++i )
        {
            const SwFrmFmt& rCpyFmt = *(*GetDoc()->GetSpzFrmFmts())[i];
            SwFmtAnchor aAnchor( rCpyFmt.GetAnchor() );
            if ((FLY_AT_PAGE == aAnchor.GetAnchorId()) &&
                    aAnchor.GetPageNum() >= nStartPage && aAnchor.GetPageNum() <= nEndPage)
            {
                aAnchor.SetPageNum( aAnchor.GetPageNum() - nStartPage + 1);
            }
            else
                continue;
            rToFill.GetDoc()->CopyLayoutFmt( rCpyFmt, aAnchor, true, true );
        }
    }
    GetDoc()->UnlockExpFlds();
    GetDoc()->UpdateFlds(NULL, false);
    Pop(sal_False);
    EndAllAction();

    return sal_True;
}

sal_Bool SwFEShell::GetDrawObjGraphic( sal_uLong nFmt, Graphic& rGrf ) const
{
	ASSERT( Imp()->HasDrawView(), "GetDrawObjGraphic without DrawView?" );
	const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
	sal_Bool bConvert = sal_True;
	if( rMrkList.GetMarkCount() )
	{
		if( rMrkList.GetMarkCount() == 1 &&
			rMrkList.GetMark( 0 )->GetMarkedSdrObj()->ISA(SwVirtFlyDrawObj) )
		{
			// Rahmen selektiert
			if( CNT_GRF == GetCntType() )
			{
                // --> OD 2005-02-09 #119353# - robust
                const Graphic* pGrf( GetGraphic() );
                if ( pGrf )
                {
                    Graphic aGrf( *pGrf );
                    if( SOT_FORMAT_GDIMETAFILE == nFmt )
                    {
                        if( GRAPHIC_BITMAP != aGrf.GetType() )
                        {
                            rGrf = aGrf;
                            bConvert = sal_False;
                        }
                        else if( GetWin() )
                        {
                            Size aSz;
                            Point aPt;
                            GetGrfSize( aSz );

                            VirtualDevice aVirtDev;
                            aVirtDev.EnableOutput( sal_False );

                            MapMode aTmp( GetWin()->GetMapMode() );
                            aTmp.SetOrigin( aPt );
                            aVirtDev.SetMapMode( aTmp );

                            GDIMetaFile aMtf;
                            aMtf.Record( &aVirtDev );
                            aGrf.Draw( &aVirtDev, aPt, aSz );
                            aMtf.Stop();
                            aMtf.SetPrefMapMode( aTmp );
                            aMtf.SetPrefSize( aSz );
                            rGrf = aMtf;
                        }
                    }
                    else if( GRAPHIC_BITMAP == aGrf.GetType() )
                    {
                        rGrf = aGrf;
                        bConvert = sal_False;
                    }
                    else
                    {
                        //fix(23806): Nicht die Originalgroesse, sondern die
                        //aktuelle. Anderfalls kann es passieren, dass z.B. bei
                        //Vektorgrafiken mal eben zig MB angefordert werden.
                        const Size aSz( FindFlyFrm()->Prt().SSize() );
                        VirtualDevice aVirtDev( *GetWin() );

                        MapMode aTmp( MAP_TWIP );
                        aVirtDev.SetMapMode( aTmp );
                        if( aVirtDev.SetOutputSize( aSz ) )
                        {
                            aGrf.Draw( &aVirtDev, Point(), aSz );
                            rGrf = aVirtDev.GetBitmap( Point(), aSz );
                        }
                        else
                        {
                            rGrf = aGrf;
                            bConvert = sal_False;
                        }
                    }
                }
                // <--
			}
		}
		else if( SOT_FORMAT_GDIMETAFILE == nFmt )
			rGrf = Imp()->GetDrawView()->GetAllMarkedMetaFile();
		else if( SOT_FORMAT_BITMAP == nFmt )
			rGrf = Imp()->GetDrawView()->GetAllMarkedBitmap();
	}
	return bConvert;
}

// --> OD 2005-08-03 #i50824#
// --> OD 2006-03-01 #b6382898#
// replace method <lcl_RemoveOleObjsFromSdrModel> by <lcl_ConvertSdrOle2ObjsToSdrGrafObjs>
void lcl_ConvertSdrOle2ObjsToSdrGrafObjs( SdrModel* _pModel )
{
    for ( sal_uInt16 nPgNum = 0; nPgNum < _pModel->GetPageCount(); ++nPgNum )
    {
        // setup object iterator in order to iterate through all objects
        // including objects in group objects, but exclusive group objects.
        SdrObjListIter aIter(*(_pModel->GetPage( nPgNum )));
        while( aIter.IsMore() )
        {
            SdrOle2Obj* pOle2Obj = dynamic_cast< SdrOle2Obj* >( aIter.Next() );
            if( pOle2Obj )
            {
                // found an ole2 shape
                SdrObjList* pObjList = pOle2Obj->GetObjList();

                // get its graphic
                Graphic aGraphic;
                pOle2Obj->Connect();
                Graphic* pGraphic = pOle2Obj->GetGraphic();
                if( pGraphic )
                    aGraphic = *pGraphic;
                pOle2Obj->Disconnect();

                // create new graphic shape with the ole graphic and shape size
                SdrGrafObj* pGraphicObj = new SdrGrafObj( aGraphic, pOle2Obj->GetCurrentBoundRect() );
                // apply layer of ole2 shape at graphic shape
                pGraphicObj->SetLayer( pOle2Obj->GetLayer() );

                // replace ole2 shape with the new graphic object and delete the ol2 shape
                SdrObject* pRemovedObject = pObjList->ReplaceObject( pGraphicObj, pOle2Obj->GetOrdNum() );
                SdrObject::Free( pRemovedObject );
            }
        }
    }
}
// <--
void SwFEShell::Paste( SvStream& rStrm, sal_uInt16 nAction, const Point* pPt )
{
	SET_CURR_SHELL( this );
	StartAllAction();
	StartUndo();

	SvtPathOptions aPathOpt;
	FmFormModel* pModel = new FmFormModel( aPathOpt.GetPalettePath(),
											0, GetDoc()->GetDocShell() );
	pModel->GetItemPool().FreezeIdRanges();

	rStrm.Seek(0);

    uno::Reference< io::XInputStream > xInputStream( new utl::OInputStreamWrapper( rStrm ) );
	SvxDrawingLayerImport( pModel, xInputStream );

	if ( !Imp()->HasDrawView() )
		Imp()->MakeDrawView();

	Point aPos( pPt ? *pPt : GetCharRect().Pos() );
	SdrView *pView = Imp()->GetDrawView();

	//Drop auf bestehendes Objekt: Objekt ersetzen oder neu Attributieren.
	if( pModel->GetPageCount() > 0 &&
        1 == pModel->GetPage(0)->GetObjCount() &&
		1 == pView->GetMarkedObjectList().GetMarkCount() )
	{
        // OD 10.07.2003 #110742# - replace a marked 'virtual' drawing object
        // by its corresponding 'master' drawing object in the mark list.
        SwDrawView::ReplaceMarkedDrawVirtObjs( *pView );

        SdrObject* pClpObj = pModel->GetPage(0)->GetObj(0);
		SdrObject* pOldObj = pView->GetMarkedObjectList().GetMark( 0 )->GetMarkedSdrObj();

		if( SW_PASTESDR_SETATTR == nAction && pOldObj->ISA(SwVirtFlyDrawObj) )
			nAction = SW_PASTESDR_REPLACE;

		switch( nAction )
		{
		case SW_PASTESDR_REPLACE:
			{
				const SwFrmFmt* pFmt(0);
				const SwFrm* pAnchor(0);
				if( pOldObj->ISA(SwVirtFlyDrawObj) )
				{
					pFmt = FindFrmFmt( pOldObj );

					Point aNullPt;
					SwFlyFrm* pFlyFrm = ((SwFlyFrmFmt*)pFmt)->GetFrm( &aNullPt );
                    pAnchor = pFlyFrm->GetAnchorFrm();

					if( pAnchor->FindFooterOrHeader() )
					{
						// wenn TextRahmen in der Kopf/Fusszeile steht, dann
						// nicht ersetzen, sondern nur einfuegen
						nAction = SW_PASTESDR_INSERT;
						break;
					}
				}

				SdrObject* pNewObj = pClpObj->Clone();
				Rectangle aOldObjRect( pOldObj->GetCurrentBoundRect() );
				Size aOldObjSize( aOldObjRect.GetSize() );
				Rectangle aNewRect( pNewObj->GetCurrentBoundRect() );
				Size aNewSize( aNewRect.GetSize() );

				Fraction aScaleWidth( aOldObjSize.Width(), aNewSize.Width() );
				Fraction aScaleHeight( aOldObjSize.Height(), aNewSize.Height());
				pNewObj->NbcResize( aNewRect.TopLeft(), aScaleWidth, aScaleHeight);

				Point aVec = aOldObjRect.TopLeft() - aNewRect.TopLeft();
				pNewObj->NbcMove(Size(aVec.X(), aVec.Y()));

                if( pNewObj->ISA( SdrUnoObj ) )
                    pNewObj->SetLayer( GetDoc()->GetControlsId() );
                else if( pOldObj->ISA( SdrUnoObj ) )
                    pNewObj->SetLayer( GetDoc()->GetHeavenId() );
                else
                    pNewObj->SetLayer( pOldObj->GetLayer() );

				if( pOldObj->ISA(SwVirtFlyDrawObj) )
				{
					// Attribute sichern und dam SdrObject setzen
					SfxItemSet aFrmSet( pDoc->GetAttrPool(),
											RES_SURROUND, RES_ANCHOR );
					aFrmSet.Set( pFmt->GetAttrSet() );

					Point aNullPt;
					if( pAnchor->IsTxtFrm() && ((SwTxtFrm*)pAnchor)->IsFollow() )
					{
						const SwTxtFrm* pTmp = (SwTxtFrm*)pAnchor;
						do {
							pTmp = pTmp->FindMaster();
							ASSERT( pTmp, "Where's my Master?" );
						} while( pTmp->IsFollow() );
						pAnchor = pTmp;
					}
					if( pOldObj->ISA( SdrCaptionObj ))
						aNullPt = ((SdrCaptionObj*)pOldObj)->GetTailPos();
					else
						aNullPt = aOldObjRect.TopLeft();

                    Point aNewAnchor = pAnchor->GetFrmAnchorPos( ::HasWrap( pOldObj ) );
                    // OD 2004-04-05 #i26791# - direct positioning of Writer
                    // fly frame object for <SwDoc::Insert(..)>
                    pNewObj->NbcSetRelativePos( aNullPt - aNewAnchor );
                    pNewObj->NbcSetAnchorPos( aNewAnchor );

                    pOldObj->GetOrdNum();

					DelSelectedObj();

					pFmt = GetDoc()->Insert( *GetCrsr(), *pNewObj, &aFrmSet, NULL );
				}
				else
					pView->ReplaceObjectAtView( pOldObj, *Imp()->GetPageView(), pNewObj, sal_True );
			}
			break;

		case SW_PASTESDR_SETATTR:
			{
				SfxItemSet aSet( GetAttrPool() );
				aSet.Put(pClpObj->GetMergedItemSet());
				pView->SetAttributes( aSet, sal_False );
			}
			break;

		default:
			nAction = SW_PASTESDR_INSERT;
			break;
		}
	}
	else
		nAction = SW_PASTESDR_INSERT;

	if( SW_PASTESDR_INSERT == nAction )
    {
        ::sw::DrawUndoGuard drawUndoGuard(GetDoc()->GetIDocumentUndoRedo());

        sal_Bool bDesignMode = pView->IsDesignMode();
        if( !bDesignMode )
            pView->SetDesignMode( sal_True );

        // --> OD 2005-08-03 #i50824#
        // --> OD 2006-03-01 #b6382898#
        // method <lcl_RemoveOleObjsFromSdrModel> replaced by <lcl_ConvertSdrOle2ObjsToSdrGrafObjs>
        lcl_ConvertSdrOle2ObjsToSdrGrafObjs( pModel );
        // <--
        pView->Paste( *pModel, aPos );

		sal_uLong nCnt = pView->GetMarkedObjectList().GetMarkCount();
		if( nCnt )
		{
			const Point aNull( 0, 0 );
			for( sal_uLong i=0; i < nCnt; ++i )
			{
				SdrObject *pObj = pView->GetMarkedObjectList().GetMark(i)->GetMarkedSdrObj();
				pObj->ImpSetAnchorPos( aNull );
			}

			pView->SetCurrentObj( OBJ_GRUP, SdrInventor );
			if ( nCnt > 1 )
				pView->GroupMarked();
			SdrObject *pObj = pView->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj();
            if( pObj->ISA( SdrUnoObj ) )
            {
                pObj->SetLayer( GetDoc()->GetControlsId() );
                bDesignMode = sal_True;
            }
            else
                pObj->SetLayer( GetDoc()->GetHeavenId() );
			const Rectangle &rSnap = pObj->GetSnapRect();
			const Size aDiff( rSnap.GetWidth()/2, rSnap.GetHeight()/2 );
			pView->MoveMarkedObj( aDiff );
			ImpEndCreate();
            if( !bDesignMode )
                pView->SetDesignMode( sal_False );
		}
	}
	EndUndo();
	EndAllAction();
	delete pModel;
}

sal_Bool SwFEShell::Paste( const Graphic &rGrf )
{
	SET_CURR_SHELL( this );
	SdrObject* pObj;
	SdrView *pView = Imp()->GetDrawView();

	sal_Bool bRet = 1 == pView->GetMarkedObjectList().GetMarkCount() &&
		(pObj = pView->GetMarkedObjectList().GetMark( 0 )->GetMarkedSdrObj())->IsClosedObj() &&
		!pObj->ISA( SdrOle2Obj );

	if( bRet )
	{
		XOBitmap aXOBitmap( rGrf.GetBitmap() );
		SfxItemSet aSet( GetAttrPool(), XATTR_FILLSTYLE, XATTR_FILLBITMAP );
		aSet.Put( XFillStyleItem( XFILL_BITMAP ));
		aSet.Put( XFillBitmapItem( aEmptyStr, aXOBitmap ));
		pView->SetAttributes( aSet, sal_False );
	}
	return bRet;
}
