xref: /aoo41x/main/sc/source/ui/undo/undoblk3.cxx (revision 8f080d45)

/**************************************************************
 *
 * 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_sc.hxx"

// INCLUDE -------------------------------------------------------------------

#include "scitems.hxx"
#include <editeng/boxitem.hxx>
#include <svl/srchitem.hxx>
#include <sfx2/linkmgr.hxx>
#include <sfx2/bindings.hxx>
#include <vcl/virdev.hxx>
#include <sfx2/app.hxx>

#include "undoblk.hxx"
#include "sc.hrc"
#include "globstr.hrc"
#include "global.hxx"
#include "rangenam.hxx"
#include "arealink.hxx"
#include "patattr.hxx"
#include "target.hxx"
#include "document.hxx"
#include "docpool.hxx"
#include "table.hxx"
#include "docsh.hxx"
#include "tabvwsh.hxx"
#include "undoolk.hxx"
#include "undoutil.hxx"
#include "chgtrack.hxx"
#include "dociter.hxx"
#include "cell.hxx"
#include "paramisc.hxx"
#include "postit.hxx"
#include "docuno.hxx"

// STATIC DATA ---------------------------------------------------------------

TYPEINIT1(ScUndoDeleteContents, 	SfxUndoAction);
TYPEINIT1(ScUndoFillTable,		 	SfxUndoAction);
TYPEINIT1(ScUndoSelectionAttr,		SfxUndoAction);
TYPEINIT1(ScUndoAutoFill,			SfxUndoAction);
TYPEINIT1(ScUndoMerge,				SfxUndoAction);
TYPEINIT1(ScUndoAutoFormat, 		SfxUndoAction);
TYPEINIT1(ScUndoReplace,			SfxUndoAction);
TYPEINIT1(ScUndoTabOp,				SfxUndoAction);
TYPEINIT1(ScUndoConversion,         SfxUndoAction);
TYPEINIT1(ScUndoRefConversion,      SfxUndoAction);
TYPEINIT1(ScUndoRefreshLink,		SfxUndoAction);
TYPEINIT1(ScUndoInsertAreaLink,		SfxUndoAction);
TYPEINIT1(ScUndoRemoveAreaLink,		SfxUndoAction);
TYPEINIT1(ScUndoUpdateAreaLink,		SfxUndoAction);


// To Do:
/*A*/	// SetOptimalHeight auf Dokument, wenn keine View


//============================================================================
//	class ScUndoDeleteContents
//
//	Inhalte loeschen

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

ScUndoDeleteContents::ScUndoDeleteContents(
				ScDocShell* pNewDocShell,
				const ScMarkData& rMark, const ScRange& rRange,
				ScDocument* pNewUndoDoc, sal_Bool bNewMulti,
				sal_uInt16 nNewFlags, sal_Bool bObjects )
		//
	:	ScSimpleUndo( pNewDocShell ),
		//
		aRange		( rRange ),
		aMarkData	( rMark ),
		pUndoDoc	( pNewUndoDoc ),
		pDrawUndo	( NULL ),
		nFlags		( nNewFlags ),
		bMulti		( bNewMulti )	// ueberliquid
{
	if (bObjects)
		pDrawUndo = GetSdrUndoAction( pDocShell->GetDocument() );

	if ( !(aMarkData.IsMarked() || aMarkData.IsMultiMarked()) )		// keine Zelle markiert:
		aMarkData.SetMarkArea( aRange );							// Zelle unter Cursor markieren

	SetChangeTrack();
}


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

__EXPORT ScUndoDeleteContents::~ScUndoDeleteContents()
{
	delete pUndoDoc;
	DeleteSdrUndoAction( pDrawUndo );
}


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

String __EXPORT ScUndoDeleteContents::GetComment() const
{
	return ScGlobal::GetRscString( STR_UNDO_DELETECONTENTS );	 // "Loeschen"
}


void ScUndoDeleteContents::SetChangeTrack()
{
	ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
	if ( pChangeTrack && (nFlags & IDF_CONTENTS) )
		pChangeTrack->AppendContentRange( aRange, pUndoDoc,
			nStartChangeAction, nEndChangeAction );
	else
		nStartChangeAction = nEndChangeAction = 0;
}


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

void ScUndoDeleteContents::DoChange( const sal_Bool bUndo )
{
	ScDocument* pDoc = pDocShell->GetDocument();

	SetViewMarkData( aMarkData );

	sal_uInt16 nExtFlags = 0;

	if (bUndo)	// nur Undo
	{
		sal_uInt16 nUndoFlags = IDF_NONE;		//	entweder alle oder keine Inhalte kopieren
		if (nFlags & IDF_CONTENTS)			//	(es sind nur die richtigen ins UndoDoc kopiert worden)
			nUndoFlags |= IDF_CONTENTS;
		if (nFlags & IDF_ATTRIB)
			nUndoFlags |= IDF_ATTRIB;
		if (nFlags & IDF_EDITATTR)			// Edit-Engine-Attribute
			nUndoFlags |= IDF_STRING;		// -> Zellen werden geaendert
        // do not create clones of note captions, they will be restored via drawing undo
        nUndoFlags |= IDF_NOCAPTIONS;

		ScRange aCopyRange = aRange;
		SCTAB nTabCount = pDoc->GetTableCount();
		aCopyRange.aStart.SetTab(0);
		aCopyRange.aEnd.SetTab(nTabCount-1);

		pUndoDoc->CopyToDocument( aCopyRange, nUndoFlags, bMulti, pDoc, &aMarkData );

        DoSdrUndoAction( pDrawUndo, pDoc );

		ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
		if ( pChangeTrack )
			pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );

		pDocShell->UpdatePaintExt( nExtFlags, aRange );				// content after the change
	}
	else		// nur Redo
	{
		pDocShell->UpdatePaintExt( nExtFlags, aRange );				// content before the change

		aMarkData.MarkToMulti();
        RedoSdrUndoAction( pDrawUndo );
        // do not delete objects and note captions, they have been removed via drawing undo
        sal_uInt16 nRedoFlags = (nFlags & ~IDF_OBJECTS) | IDF_NOCAPTIONS;
        pDoc->DeleteSelection( nRedoFlags, aMarkData );
		aMarkData.MarkToSimple();

		SetChangeTrack();
	}

	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
	if ( !( (pViewShell) && pViewShell->AdjustRowHeight(
								aRange.aStart.Row(), aRange.aEnd.Row() ) ) )
/*A*/	pDocShell->PostPaint( aRange, PAINT_GRID | PAINT_EXTRAS, nExtFlags );

	pDocShell->PostDataChanged();
	if (pViewShell)
		pViewShell->CellContentChanged();

	ShowTable( aRange );
}


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

void __EXPORT ScUndoDeleteContents::Undo()
{
	BeginUndo();
	DoChange( sal_True );
	EndUndo();

    // #i97876# Spreadsheet data changes are not notified
    ScModelObj* pModelObj = ScModelObj::getImplementation( pDocShell->GetModel() );
    if ( pModelObj && pModelObj->HasChangesListeners() )
    {
        ScRangeList aChangeRanges;
        aChangeRanges.Append( aRange );
        pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "cell-change" ) ), aChangeRanges );
    }
}


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

void __EXPORT ScUndoDeleteContents::Redo()
{
	BeginRedo();
	DoChange( sal_False );
	EndRedo();

    // #i97876# Spreadsheet data changes are not notified
    ScModelObj* pModelObj = ScModelObj::getImplementation( pDocShell->GetModel() );
    if ( pModelObj && pModelObj->HasChangesListeners() )
    {
        ScRangeList aChangeRanges;
        aChangeRanges.Append( aRange );
        pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "cell-change" ) ), aChangeRanges );
    }
}


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

void __EXPORT ScUndoDeleteContents::Repeat(SfxRepeatTarget& rTarget)
{
	if (rTarget.ISA(ScTabViewTarget))
		((ScTabViewTarget&)rTarget).GetViewShell()->DeleteContents( nFlags, sal_True );
}


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

sal_Bool __EXPORT ScUndoDeleteContents::CanRepeat(SfxRepeatTarget& rTarget) const
{
	return (rTarget.ISA(ScTabViewTarget));
}


//============================================================================
//	class ScUndoFillTable
//
//	Tabellen ausfuellen
//	(Bearbeiten|Ausfuellen|...)

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

ScUndoFillTable::ScUndoFillTable( ScDocShell* pNewDocShell,
				const ScMarkData& rMark,
				SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
				SCCOL nEndX, SCROW nEndY, SCTAB nEndZ,
				ScDocument* pNewUndoDoc, sal_Bool bNewMulti, SCTAB nSrc,
				sal_uInt16 nFlg, sal_uInt16 nFunc, sal_Bool bSkip, sal_Bool bLink )
		//
	:	ScSimpleUndo( pNewDocShell ),
		//
		aRange		( nStartX, nStartY, nStartZ, nEndX, nEndY, nEndZ ),
		aMarkData	( rMark ),
		pUndoDoc	( pNewUndoDoc ),
		nFlags		( nFlg ),
		nFunction	( nFunc ),
		nSrcTab		( nSrc ),
		bMulti		( bNewMulti ),
		bSkipEmpty	( bSkip ),
		bAsLink		( bLink )
{
	SetChangeTrack();
}


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

__EXPORT ScUndoFillTable::~ScUndoFillTable()
{
	delete pUndoDoc;
}


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

String __EXPORT ScUndoFillTable::GetComment() const
{
	return ScGlobal::GetRscString( STR_FILL_TAB );
}


void ScUndoFillTable::SetChangeTrack()
{
	ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
	if ( pChangeTrack )
	{
		SCTAB nTabCount = pDocShell->GetDocument()->GetTableCount();
		ScRange aWorkRange(aRange);
		nStartChangeAction = 0;
		sal_uLong nTmpAction;
		for ( SCTAB i = 0; i < nTabCount; i++ )
		{
			if (i != nSrcTab && aMarkData.GetTableSelect(i))
			{
				aWorkRange.aStart.SetTab(i);
				aWorkRange.aEnd.SetTab(i);
				pChangeTrack->AppendContentRange( aWorkRange, pUndoDoc,
					nTmpAction, nEndChangeAction );
				if ( !nStartChangeAction )
					nStartChangeAction = nTmpAction;
			}
		}
	}
	else
		nStartChangeAction = nEndChangeAction = 0;
}


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

void ScUndoFillTable::DoChange( const sal_Bool bUndo )
{
	ScDocument* pDoc = pDocShell->GetDocument();

	SetViewMarkData( aMarkData );

	if (bUndo)	// nur Undo
	{
		SCTAB nTabCount = pDoc->GetTableCount();
		ScRange aWorkRange(aRange);
		for ( SCTAB i = 0; i < nTabCount; i++ )
			if (i != nSrcTab && aMarkData.GetTableSelect(i))
			{
				aWorkRange.aStart.SetTab(i);
				aWorkRange.aEnd.SetTab(i);
				if (bMulti)
					pDoc->DeleteSelectionTab( i, IDF_ALL, aMarkData );
				else
					pDoc->DeleteAreaTab( aWorkRange, IDF_ALL );
				pUndoDoc->CopyToDocument( aWorkRange, IDF_ALL, bMulti, pDoc, &aMarkData );
			}

		ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
		if ( pChangeTrack )
			pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
	}
	else		// nur Redo
	{
		aMarkData.MarkToMulti();
		pDoc->FillTabMarked( nSrcTab, aMarkData, nFlags, nFunction, bSkipEmpty, bAsLink );
		aMarkData.MarkToSimple();
		SetChangeTrack();
	}

	pDocShell->PostPaint(0,0,0,MAXCOL,MAXROW,MAXTAB, PAINT_GRID|PAINT_EXTRAS);
	pDocShell->PostDataChanged();

	//	CellContentChanged kommt mit der Markierung

	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
	if (pViewShell)
	{
		SCTAB nTab = pViewShell->GetViewData()->GetTabNo();
		if ( !aMarkData.GetTableSelect(nTab) )
			pViewShell->SetTabNo( nSrcTab );

		pViewShell->DoneBlockMode();	// gibt sonst Probleme, weil Markierung auf falscher Tabelle
	}
}


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

void __EXPORT ScUndoFillTable::Undo()
{
	BeginUndo();
	DoChange( sal_True );
	EndUndo();
}


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

void __EXPORT ScUndoFillTable::Redo()
{
	BeginRedo();
	DoChange( sal_False );
	EndRedo();
}


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

void __EXPORT ScUndoFillTable::Repeat(SfxRepeatTarget& rTarget)
{
	if (rTarget.ISA(ScTabViewTarget))
		((ScTabViewTarget&)rTarget).GetViewShell()->FillTab( nFlags, nFunction, bSkipEmpty, bAsLink );
}


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

sal_Bool __EXPORT ScUndoFillTable::CanRepeat(SfxRepeatTarget& rTarget) const
{
	return (rTarget.ISA(ScTabViewTarget));
}


//============================================================================
//	class ScUndoSelectionAttr
//
//	Zellformat aendern

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

ScUndoSelectionAttr::ScUndoSelectionAttr( ScDocShell* pNewDocShell,
				const ScMarkData& rMark,
				SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
				SCCOL nEndX, SCROW nEndY, SCTAB nEndZ,
				ScDocument* pNewUndoDoc, sal_Bool bNewMulti,
				const ScPatternAttr* pNewApply,
				const SvxBoxItem* pNewOuter, const SvxBoxInfoItem* pNewInner )
		//
	:	ScSimpleUndo( pNewDocShell ),
		//
		aMarkData	( rMark ),
		aRange		( nStartX, nStartY, nStartZ, nEndX, nEndY, nEndZ ),
		pUndoDoc	( pNewUndoDoc ),
		bMulti		( bNewMulti )
{
	ScDocumentPool* pPool = pDocShell->GetDocument()->GetPool();
	pApplyPattern = (ScPatternAttr*) &pPool->Put( *pNewApply );
	pLineOuter = pNewOuter ? (SvxBoxItem*) &pPool->Put( *pNewOuter ) : NULL;
	pLineInner = pNewInner ? (SvxBoxInfoItem*) &pPool->Put( *pNewInner ) : NULL;
}


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

__EXPORT ScUndoSelectionAttr::~ScUndoSelectionAttr()
{
	ScDocumentPool* pPool = pDocShell->GetDocument()->GetPool();
	pPool->Remove(*pApplyPattern);
	if (pLineOuter)
		pPool->Remove(*pLineOuter);
	if (pLineInner)
		pPool->Remove(*pLineInner);

	delete pUndoDoc;
}


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

String __EXPORT ScUndoSelectionAttr::GetComment() const
{
	//"Attribute" "/Linien"
	return ScGlobal::GetRscString( pLineOuter ? STR_UNDO_SELATTRLINES : STR_UNDO_SELATTR );
}


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

void ScUndoSelectionAttr::DoChange( const sal_Bool bUndo )
{
	ScDocument* pDoc = pDocShell->GetDocument();

	SetViewMarkData( aMarkData );

	ScRange aEffRange( aRange );
	if ( pDoc->HasAttrib( aEffRange, HASATTR_MERGED ) )			// zusammengefasste Zellen?
		pDoc->ExtendMerge( aEffRange );

	sal_uInt16 nExtFlags = 0;
	pDocShell->UpdatePaintExt( nExtFlags, aEffRange );

	if (bUndo)	// nur bei Undo
	{
		ScRange aCopyRange = aRange;
		SCTAB nTabCount = pDoc->GetTableCount();
		aCopyRange.aStart.SetTab(0);
		aCopyRange.aEnd.SetTab(nTabCount-1);
		pUndoDoc->CopyToDocument( aCopyRange, IDF_ATTRIB, bMulti, pDoc, &aMarkData );
	}
	else		// nur bei Redo
	{
		aMarkData.MarkToMulti();
		pDoc->ApplySelectionPattern( *pApplyPattern, aMarkData );
		aMarkData.MarkToSimple();

		if (pLineOuter)
			pDoc->ApplySelectionFrame( aMarkData, pLineOuter, pLineInner );
	}

	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
	if ( !( (pViewShell) && pViewShell->AdjustBlockHeight() ) )
/*A*/	pDocShell->PostPaint( aEffRange, PAINT_GRID | PAINT_EXTRAS, nExtFlags );

	ShowTable( aRange );
}


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

void __EXPORT ScUndoSelectionAttr::Undo()
{
	BeginUndo();
	DoChange( sal_True );
	EndUndo();
}


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

void __EXPORT ScUndoSelectionAttr::Redo()
{
	BeginRedo();
	DoChange( sal_False );
	EndRedo();
}


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

void __EXPORT ScUndoSelectionAttr::Repeat(SfxRepeatTarget& rTarget)
{
	if (rTarget.ISA(ScTabViewTarget))
	{
		ScTabViewShell& rViewShell = *((ScTabViewTarget&)rTarget).GetViewShell();
		if (pLineOuter)
			rViewShell.ApplyPatternLines( *pApplyPattern, pLineOuter, pLineInner, sal_True );
		else
			rViewShell.ApplySelectionPattern( *pApplyPattern, sal_True );
	}
}


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

sal_Bool __EXPORT ScUndoSelectionAttr::CanRepeat(SfxRepeatTarget& rTarget) const
{
	return (rTarget.ISA(ScTabViewTarget));
}


//============================================================================
//	class ScUndoAutoFill
//
//	Auto-Fill (nur einfache Bloecke)

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

ScUndoAutoFill::ScUndoAutoFill( ScDocShell* pNewDocShell,
				const ScRange& rRange, const ScRange& rSourceArea,
				ScDocument* pNewUndoDoc, const ScMarkData& rMark,
				FillDir eNewFillDir, FillCmd eNewFillCmd, FillDateCmd eNewFillDateCmd,
				double fNewStartValue, double fNewStepValue, double fNewMaxValue,
				sal_uInt16 nMaxShIndex )
		//
	:	ScBlockUndo( pNewDocShell, rRange, SC_UNDO_AUTOHEIGHT ),
		//
		aSource			( rSourceArea ),
		aMarkData		( rMark ),
		pUndoDoc		( pNewUndoDoc ),
		eFillDir		( eNewFillDir ),
		eFillCmd		( eNewFillCmd ),
		eFillDateCmd	( eNewFillDateCmd ),
		fStartValue		( fNewStartValue ),
		fStepValue		( fNewStepValue ),
		fMaxValue		( fNewMaxValue ),
		nMaxSharedIndex	( nMaxShIndex)
{
	SetChangeTrack();
}


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

__EXPORT ScUndoAutoFill::~ScUndoAutoFill()
{
	pDocShell->GetDocument()->EraseNonUsedSharedNames(nMaxSharedIndex);
	delete pUndoDoc;
}


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

String __EXPORT ScUndoAutoFill::GetComment() const
{
	return ScGlobal::GetRscString( STR_UNDO_AUTOFILL ); //"Ausfuellen"
}


void ScUndoAutoFill::SetChangeTrack()
{
	ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
	if ( pChangeTrack )
		pChangeTrack->AppendContentRange( aBlockRange, pUndoDoc,
			nStartChangeAction, nEndChangeAction );
	else
		nStartChangeAction = nEndChangeAction = 0;
}


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

void __EXPORT ScUndoAutoFill::Undo()
{
	BeginUndo();

	ScDocument* pDoc = pDocShell->GetDocument();

	SCTAB nTabCount = pDoc->GetTableCount();
	for (SCTAB nTab=0; nTab<nTabCount; nTab++)
	{
		if (aMarkData.GetTableSelect(nTab))
		{
			ScRange aWorkRange = aBlockRange;
			aWorkRange.aStart.SetTab(nTab);
			aWorkRange.aEnd.SetTab(nTab);

			sal_uInt16 nExtFlags = 0;
			pDocShell->UpdatePaintExt( nExtFlags, aWorkRange );
            pDoc->DeleteAreaTab( aWorkRange, IDF_AUTOFILL );
            pUndoDoc->CopyToDocument( aWorkRange, IDF_AUTOFILL, sal_False, pDoc );

			pDoc->ExtendMerge( aWorkRange, sal_True );
			pDocShell->PostPaint( aWorkRange, PAINT_GRID, nExtFlags );
		}
	}
	pDocShell->PostDataChanged();
	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
	if (pViewShell)
		pViewShell->CellContentChanged();

// Shared-Names loeschen
// Falls Undo ins Dokument gespeichert
// => automatisches Loeschen am Ende
// umarbeiten!!

	String aName = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("___SC_"));
	aName += String::CreateFromInt32(nMaxSharedIndex);
	aName += '_';
	ScRangeName* pRangeName = pDoc->GetRangeName();
	sal_Bool bHasFound = sal_False;
	for (sal_uInt16 i = 0; i < pRangeName->GetCount(); i++)
	{
		ScRangeData* pRangeData = (*pRangeName)[i];
		if (pRangeData)
		{
			String aRName;
			pRangeData->GetName(aRName);
			if (aRName.Search(aName) != STRING_NOTFOUND)
			{
				pRangeName->AtFree(i);
				bHasFound = sal_True;
			}
		}
	}
	if (bHasFound)
		pRangeName->SetSharedMaxIndex(pRangeName->GetSharedMaxIndex()-1);

	ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
	if ( pChangeTrack )
		pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );

	EndUndo();
}


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

void __EXPORT ScUndoAutoFill::Redo()
{
	BeginRedo();

//!	Tabellen selektieren

    SCCOLROW nCount = 0;
	switch (eFillDir)
	{
		case FILL_TO_BOTTOM:
			nCount = aBlockRange.aEnd.Row() - aSource.aEnd.Row();
			break;
		case FILL_TO_RIGHT:
			nCount = aBlockRange.aEnd.Col() - aSource.aEnd.Col();
			break;
		case FILL_TO_TOP:
			nCount = aSource.aStart.Row() - aBlockRange.aStart.Row();
			break;
		case FILL_TO_LEFT:
			nCount = aSource.aStart.Col() - aBlockRange.aStart.Col();
			break;
	}

	ScDocument* pDoc = pDocShell->GetDocument();
	if ( fStartValue != MAXDOUBLE )
	{
		SCCOL nValX = (eFillDir == FILL_TO_LEFT) ? aSource.aEnd.Col() : aSource.aStart.Col();
		SCROW nValY = (eFillDir == FILL_TO_TOP ) ? aSource.aEnd.Row() : aSource.aStart.Row();
		SCTAB nTab = aSource.aStart.Tab();
		pDoc->SetValue( nValX, nValY, nTab, fStartValue );
	}
	pDoc->Fill( aSource.aStart.Col(), aSource.aStart.Row(),
				aSource.aEnd.Col(),   aSource.aEnd.Row(),
				aMarkData, nCount,
				eFillDir, eFillCmd, eFillDateCmd,
				fStepValue, fMaxValue );

	SetChangeTrack();

	pDocShell->PostPaint( aBlockRange, PAINT_GRID );
	pDocShell->PostDataChanged();
	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
	if (pViewShell)
		pViewShell->CellContentChanged();

	EndRedo();
}


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

void __EXPORT ScUndoAutoFill::Repeat(SfxRepeatTarget& rTarget)
{
	if (rTarget.ISA(ScTabViewTarget))
	{
		ScTabViewShell& rViewShell = *((ScTabViewTarget&)rTarget).GetViewShell();
		if (eFillCmd==FILL_SIMPLE)
			rViewShell.FillSimple( eFillDir, sal_True );
		else
			rViewShell.FillSeries( eFillDir, eFillCmd, eFillDateCmd,
								   fStartValue, fStepValue, fMaxValue, sal_True );
	}
}


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

sal_Bool __EXPORT ScUndoAutoFill::CanRepeat(SfxRepeatTarget& rTarget) const
{
	return (rTarget.ISA(ScTabViewTarget));
}


//============================================================================
//	class ScUndoMerge
//
//	Zellen zusammenfassen / Zusammenfassung aufheben

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

ScUndoMerge::ScUndoMerge( ScDocShell* pNewDocShell,
							SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
							SCCOL nEndX, SCROW nEndY, SCTAB nEndZ,
                            bool bMergeContents, ScDocument* pUndoDoc, SdrUndoAction* pDrawUndo )
		//
	:	ScSimpleUndo( pNewDocShell ),
		//
		maRange( nStartX, nStartY, nStartZ, nEndX, nEndY, nEndZ ),
        mbMergeContents( bMergeContents ),
        mpUndoDoc( pUndoDoc ),
        mpDrawUndo( pDrawUndo )
{
}


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

ScUndoMerge::~ScUndoMerge()
{
	delete mpUndoDoc;
    DeleteSdrUndoAction( mpDrawUndo );
}


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

String ScUndoMerge::GetComment() const
{
	return ScGlobal::GetRscString( STR_UNDO_MERGE );
}


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

void ScUndoMerge::DoChange( bool bUndo ) const
{
	ScDocument* pDoc = pDocShell->GetDocument();

	ScUndoUtil::MarkSimpleBlock( pDocShell, maRange );

	if (bUndo)
        // remove merge (contents are copied back below from undo document)
		pDoc->RemoveMerge( maRange.aStart.Col(), maRange.aStart.Row(), maRange.aStart.Tab() );
	else
        // repeat merge, but do not remove note captions (will be done by drawing redo below)
/*!*/	pDoc->DoMerge( maRange.aStart.Tab(),
					   maRange.aStart.Col(), maRange.aStart.Row(),
                       maRange.aEnd.Col(),   maRange.aEnd.Row(), false );

    // undo -> copy back deleted contents
	if (bUndo && mpUndoDoc)
    {
        pDoc->DeleteAreaTab( maRange, IDF_CONTENTS|IDF_NOCAPTIONS );
        mpUndoDoc->CopyToDocument( maRange, IDF_ALL|IDF_NOCAPTIONS, sal_False, pDoc );
    }

    // redo -> merge contents again
    else if (!bUndo && mbMergeContents)
    {
/*!*/   pDoc->DoMergeContents( maRange.aStart.Tab(),
							   maRange.aStart.Col(), maRange.aStart.Row(),
							   maRange.aEnd.Col(),   maRange.aEnd.Row()   );
    }

    if (bUndo)
        DoSdrUndoAction( mpDrawUndo, pDoc );
    else
        RedoSdrUndoAction( mpDrawUndo );

	sal_Bool bDidPaint = sal_False;
	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
	if ( pViewShell )
	{
		pViewShell->SetTabNo( maRange.aStart.Tab() );
		bDidPaint = pViewShell->AdjustRowHeight( maRange.aStart.Row(), maRange.aEnd.Row() );
	}

	if (!bDidPaint)
		ScUndoUtil::PaintMore( pDocShell, maRange );

	ShowTable( maRange );
}


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

void ScUndoMerge::Undo()
{
	BeginUndo();
	DoChange( true );
	EndUndo();
}


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

void ScUndoMerge::Redo()
{
	BeginRedo();
	DoChange( false );
	EndRedo();
}


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

void ScUndoMerge::Repeat(SfxRepeatTarget& rTarget)
{
	if (rTarget.ISA(ScTabViewTarget))
	{
		ScTabViewShell& rViewShell = *((ScTabViewTarget&)rTarget).GetViewShell();
		sal_Bool bCont = sal_False;
		rViewShell.MergeCells( sal_False, bCont, sal_True );
	}
}


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

sal_Bool ScUndoMerge::CanRepeat(SfxRepeatTarget& rTarget) const
{
	return (rTarget.ISA(ScTabViewTarget));
}


//============================================================================
//	class ScUndoAutoFormat
//
//		Auto-Format (nur einfache Bloecke)

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

ScUndoAutoFormat::ScUndoAutoFormat( ScDocShell* pNewDocShell,
						const ScRange& rRange, ScDocument* pNewUndoDoc,
						const ScMarkData& rMark, sal_Bool bNewSize, sal_uInt16 nNewFormatNo )
		//
	:	ScBlockUndo( pNewDocShell, rRange, bNewSize ? SC_UNDO_MANUALHEIGHT : SC_UNDO_AUTOHEIGHT ),
		//
		pUndoDoc	( pNewUndoDoc ),
		aMarkData	( rMark ),
		bSize		( bNewSize ),
		nFormatNo	( nNewFormatNo )
{
}


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

__EXPORT ScUndoAutoFormat::~ScUndoAutoFormat()
{
	delete pUndoDoc;
}


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

String __EXPORT ScUndoAutoFormat::GetComment() const
{
	return ScGlobal::GetRscString( STR_UNDO_AUTOFORMAT );	//"Auto-Format"
}


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

void __EXPORT ScUndoAutoFormat::Undo()
{
	BeginUndo();

	ScDocument* pDoc = pDocShell->GetDocument();

	// Attribute
//	pDoc->DeleteAreaTab( aBlockRange, IDF_ATTRIB );
//	pUndoDoc->CopyToDocument( aBlockRange, IDF_ATTRIB, sal_False, pDoc );

	SCTAB nTabCount = pDoc->GetTableCount();
	pDoc->DeleteArea( aBlockRange.aStart.Col(), aBlockRange.aStart.Row(),
					  aBlockRange.aEnd.Col(), aBlockRange.aEnd.Row(),
					  aMarkData, IDF_ATTRIB );
	ScRange aCopyRange = aBlockRange;
	aCopyRange.aStart.SetTab(0);
	aCopyRange.aEnd.SetTab(nTabCount-1);
	pUndoDoc->CopyToDocument( aCopyRange, IDF_ATTRIB, sal_False, pDoc, &aMarkData );

	// Zellhoehen und -breiten (IDF_NONE)
	if (bSize)
	{
		SCCOL nStartX = aBlockRange.aStart.Col();
		SCROW nStartY = aBlockRange.aStart.Row();
		SCTAB nStartZ = aBlockRange.aStart.Tab();
		SCCOL nEndX = aBlockRange.aEnd.Col();
		SCROW nEndY = aBlockRange.aEnd.Row();
		SCTAB nEndZ = aBlockRange.aEnd.Tab();

		pUndoDoc->CopyToDocument( nStartX, 0, 0, nEndX, MAXROW, nTabCount-1,
									IDF_NONE, sal_False, pDoc, &aMarkData );
		pUndoDoc->CopyToDocument( 0, nStartY, 0, MAXCOL, nEndY, nTabCount-1,
									IDF_NONE, sal_False, pDoc, &aMarkData );
		pDocShell->PostPaint( 0, 0, nStartZ, MAXCOL, MAXROW, nEndZ,
							  PAINT_GRID | PAINT_LEFT | PAINT_TOP, SC_PF_LINES );
	}
	else
		pDocShell->PostPaint( aBlockRange, PAINT_GRID, SC_PF_LINES );

	EndUndo();
}


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

void __EXPORT ScUndoAutoFormat::Redo()
{
	BeginRedo();

	ScDocument* pDoc = pDocShell->GetDocument();

	SCCOL nStartX = aBlockRange.aStart.Col();
	SCROW nStartY = aBlockRange.aStart.Row();
	SCTAB nStartZ = aBlockRange.aStart.Tab();
	SCCOL nEndX = aBlockRange.aEnd.Col();
	SCROW nEndY = aBlockRange.aEnd.Row();
	SCTAB nEndZ = aBlockRange.aEnd.Tab();

	pDoc->AutoFormat( nStartX, nStartY, nEndX, nEndY, nFormatNo, aMarkData );

	if (bSize)
	{
		VirtualDevice aVirtDev;
		Fraction aZoomX(1,1);
		Fraction aZoomY = aZoomX;
		double nPPTX,nPPTY;
		ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
		if (pViewShell)
		{
			ScViewData* pData = pViewShell->GetViewData();
			nPPTX = pData->GetPPTX();
			nPPTY = pData->GetPPTY();
			aZoomX = pData->GetZoomX();
			aZoomY = pData->GetZoomY();
		}
		else
		{
			//	Zoom auf 100 lassen
			nPPTX = ScGlobal::nScreenPPTX;
			nPPTY = ScGlobal::nScreenPPTY;
		}

		sal_Bool bFormula = sal_False;	//! merken

		for (SCTAB nTab=nStartZ; nTab<=nEndZ; nTab++)
		{
			ScMarkData aDestMark;
			aDestMark.SelectOneTable( nTab );
			aDestMark.SetMarkArea( ScRange( nStartX, nStartY, nTab, nEndX, nEndY, nTab ) );
			aDestMark.MarkToMulti();

			// wie SC_SIZE_VISOPT
            SCROW nLastRow = -1;
			for (SCROW nRow=nStartY; nRow<=nEndY; nRow++)
			{
				sal_uInt8 nOld = pDoc->GetRowFlags(nRow,nTab);
                bool bHidden = pDoc->RowHidden(nRow, nTab, nLastRow);
				if ( !bHidden && ( nOld & CR_MANUALSIZE ) )
					pDoc->SetRowFlags( nRow, nTab, nOld & ~CR_MANUALSIZE );
			}
			pDoc->SetOptimalHeight( nStartY, nEndY, nTab, 0, &aVirtDev,
										nPPTX, nPPTY, aZoomX, aZoomY, sal_False );

            SCCOL nLastCol = -1;
			for (SCCOL nCol=nStartX; nCol<=nEndX; nCol++)
                if (!pDoc->ColHidden(nCol, nTab, nLastCol))
				{
					sal_uInt16 nThisSize = STD_EXTRA_WIDTH + pDoc->GetOptimalColWidth( nCol, nTab,
												&aVirtDev, nPPTX, nPPTY, aZoomX, aZoomY, bFormula,
												&aDestMark );
					pDoc->SetColWidth( nCol, nTab, nThisSize );
					pDoc->ShowCol( nCol, nTab, sal_True );
				}
		}

		pDocShell->PostPaint( 0,      0,      nStartZ,
							  MAXCOL, MAXROW, nEndZ,
							  PAINT_GRID | PAINT_LEFT | PAINT_TOP, SC_PF_LINES);
	}
	else
		pDocShell->PostPaint( aBlockRange, PAINT_GRID, SC_PF_LINES );

	EndRedo();
}


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

void __EXPORT ScUndoAutoFormat::Repeat(SfxRepeatTarget& rTarget)
{
	if (rTarget.ISA(ScTabViewTarget))
		((ScTabViewTarget&)rTarget).GetViewShell()->AutoFormat( nFormatNo, sal_True );
}


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

sal_Bool __EXPORT ScUndoAutoFormat::CanRepeat(SfxRepeatTarget& rTarget) const
{
	return (rTarget.ISA(ScTabViewTarget));
}


//============================================================================
//	class ScUndoReplace
//
//		Ersetzen

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

ScUndoReplace::ScUndoReplace( ScDocShell* pNewDocShell, const ScMarkData& rMark,
									SCCOL nCurX, SCROW nCurY, SCTAB nCurZ,
									const String& rNewUndoStr, ScDocument* pNewUndoDoc,
									const SvxSearchItem* pItem )
		//
	:	ScSimpleUndo( pNewDocShell ),
		//
		aCursorPos	( nCurX, nCurY, nCurZ ),
		aMarkData	( rMark ),
		aUndoStr	( rNewUndoStr ),
		pUndoDoc	( pNewUndoDoc )
{
	pSearchItem = new SvxSearchItem( *pItem );
	SetChangeTrack();
}


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

__EXPORT ScUndoReplace::~ScUndoReplace()
{
	delete pUndoDoc;
	delete pSearchItem;
}


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

void ScUndoReplace::SetChangeTrack()
{
	ScDocument* pDoc = pDocShell->GetDocument();
	ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
	if ( pChangeTrack )
	{
		if ( pUndoDoc )
		{	//! im UndoDoc stehen nur die geaenderten Zellen,
			// deswegen per Iterator moeglich
			pChangeTrack->AppendContentsIfInRefDoc( pUndoDoc,
				nStartChangeAction,	nEndChangeAction );
		}
		else
		{
			nStartChangeAction = pChangeTrack->GetActionMax() + 1;
			ScChangeActionContent* pContent = new ScChangeActionContent(
				ScRange( aCursorPos) );
			pContent->SetOldValue( aUndoStr, pDoc );
			pContent->SetNewValue( pDoc->GetCell( aCursorPos ), pDoc );
			pChangeTrack->Append( pContent );
			nEndChangeAction = pChangeTrack->GetActionMax();
		}
	}
	else
		nStartChangeAction = nEndChangeAction = 0;
}

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

String __EXPORT ScUndoReplace::GetComment() const
{
	return ScGlobal::GetRscString( STR_UNDO_REPLACE );	// "Ersetzen"
}


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

void __EXPORT ScUndoReplace::Undo()
{
	BeginUndo();

	ScDocument* pDoc = pDocShell->GetDocument();
	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();

	ShowTable( aCursorPos.Tab() );

	if (pUndoDoc)		// nur bei ReplaceAll !!
	{
		DBG_ASSERT(pSearchItem->GetCommand() == SVX_SEARCHCMD_REPLACE_ALL,
				   "ScUndoReplace:: Falscher Modus");

	    SetViewMarkData( aMarkData );

//!	markierte Tabellen
//!	Bereich merken ?

		//	Undo-Dokument hat keine Zeilen-/Spalten-Infos, also mit bColRowFlags = FALSE
		//	kopieren, um Outline-Gruppen nicht kaputtzumachen.

		sal_uInt16 nUndoFlags = (pSearchItem->GetPattern()) ? IDF_ATTRIB : IDF_CONTENTS;
		pUndoDoc->CopyToDocument( 0,      0,      0,
								  MAXCOL, MAXROW, MAXTAB,
								  nUndoFlags, sal_False, pDoc, NULL, sal_False );	// ohne Row-Flags
		pDocShell->PostPaintGridAll();
	}
	else if (pSearchItem->GetPattern() &&
			 pSearchItem->GetCommand() == SVX_SEARCHCMD_REPLACE)
	{
		String aTempStr = pSearchItem->GetSearchString();		// vertauschen
		pSearchItem->SetSearchString(pSearchItem->GetReplaceString());
		pSearchItem->SetReplaceString(aTempStr);
		pDoc->ReplaceStyle( *pSearchItem,
							aCursorPos.Col(), aCursorPos.Row(), aCursorPos.Tab(),
							aMarkData, sal_True);
		pSearchItem->SetReplaceString(pSearchItem->GetSearchString());
		pSearchItem->SetSearchString(aTempStr);
		if (pViewShell)
			pViewShell->MoveCursorAbs( aCursorPos.Col(), aCursorPos.Row(),
									   SC_FOLLOW_JUMP, sal_False, sal_False );
		pDocShell->PostPaintGridAll();
	}
	else if (pSearchItem->GetCellType() == SVX_SEARCHIN_NOTE)
	{
        ScPostIt* pNote = pDoc->GetNote( aCursorPos );
        DBG_ASSERT( pNote, "ScUndoReplace::Undo - cell does not contain a note" );
        if (pNote)
            pNote->SetText( aCursorPos, aUndoStr );
		if (pViewShell)
			pViewShell->MoveCursorAbs( aCursorPos.Col(), aCursorPos.Row(),
									   SC_FOLLOW_JUMP, sal_False, sal_False );
	}
	else
	{
		// #78889# aUndoStr may contain line breaks
		if ( aUndoStr.Search('\n') != STRING_NOTFOUND )
			pDoc->PutCell( aCursorPos, new ScEditCell( aUndoStr, pDoc ) );
		else
			pDoc->SetString( aCursorPos.Col(), aCursorPos.Row(), aCursorPos.Tab(), aUndoStr );
		if (pViewShell)
			pViewShell->MoveCursorAbs( aCursorPos.Col(), aCursorPos.Row(),
									   SC_FOLLOW_JUMP, sal_False, sal_False );
		pDocShell->PostPaintGridAll();
	}

	ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
	if ( pChangeTrack )
		pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );

	EndUndo();
}


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

void __EXPORT ScUndoReplace::Redo()
{
	BeginRedo();

	ScDocument* pDoc = pDocShell->GetDocument();
	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();

	if (pViewShell)
		pViewShell->MoveCursorAbs( aCursorPos.Col(), aCursorPos.Row(),
								   SC_FOLLOW_JUMP, sal_False, sal_False );
	if (pUndoDoc)
	{
		if (pViewShell)
		{
            SetViewMarkData( aMarkData );

			pViewShell->SearchAndReplace( pSearchItem, sal_False, sal_True );
		}
	}
	else if (pSearchItem->GetPattern() &&
			 pSearchItem->GetCommand() == SVX_SEARCHCMD_REPLACE)
	{
		pDoc->ReplaceStyle( *pSearchItem,
							aCursorPos.Col(), aCursorPos.Row(), aCursorPos.Tab(),
							aMarkData, sal_True);
		pDocShell->PostPaintGridAll();
	}
	else
		if (pViewShell)
			pViewShell->SearchAndReplace( pSearchItem, sal_False, sal_True );

	SetChangeTrack();

	EndRedo();
}


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

void __EXPORT ScUndoReplace::Repeat(SfxRepeatTarget& rTarget)
{
	if (rTarget.ISA(ScTabViewTarget))
		((ScTabViewTarget&)rTarget).GetViewShell()->SearchAndReplace( pSearchItem, sal_True, sal_False );
}


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

sal_Bool __EXPORT ScUndoReplace::CanRepeat(SfxRepeatTarget& rTarget) const
{
	return (rTarget.ISA(ScTabViewTarget));
}


//============================================================================
//	class ScUndoTabOp
//
//	Mehrfachoperation (nur einfache Bloecke)

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

ScUndoTabOp::ScUndoTabOp( ScDocShell* pNewDocShell,
				SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
				SCCOL nEndX, SCROW nEndY, SCTAB nEndZ, ScDocument* pNewUndoDoc,
				const ScRefAddress& rFormulaCell,
				const ScRefAddress& rFormulaEnd,
				const ScRefAddress& rRowCell,
				const ScRefAddress& rColCell,
				sal_uInt8 nMd )
		//
	:	ScSimpleUndo( pNewDocShell ),
		//
		aRange			( nStartX, nStartY, nStartZ, nEndX, nEndY, nEndZ ),
		pUndoDoc		( pNewUndoDoc ),
		theFormulaCell	( rFormulaCell ),
		theFormulaEnd	( rFormulaEnd ),
		theRowCell		( rRowCell ),
		theColCell		( rColCell ),
		nMode			( nMd )
{
}


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

__EXPORT ScUndoTabOp::~ScUndoTabOp()
{
	delete pUndoDoc;
}


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

String __EXPORT ScUndoTabOp::GetComment() const
{
	return ScGlobal::GetRscString( STR_UNDO_TABOP );	// "Mehrfachoperation"
}


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

void __EXPORT ScUndoTabOp::Undo()
{
	BeginUndo();

	ScUndoUtil::MarkSimpleBlock( pDocShell, aRange );

	sal_uInt16 nExtFlags = 0;
	pDocShell->UpdatePaintExt( nExtFlags, aRange );

	ScDocument* pDoc = pDocShell->GetDocument();
    pDoc->DeleteAreaTab( aRange,IDF_ALL & ~IDF_NOTE );
    pUndoDoc->CopyToDocument( aRange, IDF_ALL & ~IDF_NOTE, sal_False, pDoc );
	pDocShell->PostPaint( aRange, PAINT_GRID, nExtFlags );
	pDocShell->PostDataChanged();
	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
	if (pViewShell)
		pViewShell->CellContentChanged();

	EndUndo();
}


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

void __EXPORT ScUndoTabOp::Redo()
{
	BeginRedo();

	ScUndoUtil::MarkSimpleBlock( pDocShell, aRange );

	ScTabOpParam aParam( theFormulaCell, theFormulaEnd,
						 theRowCell,     theColCell,
						 nMode );

	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
	if (pViewShell)
		pViewShell->TabOp( aParam, sal_False);

	EndRedo();
}


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

void __EXPORT ScUndoTabOp::Repeat(SfxRepeatTarget& /* rTarget */)
{
}


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

sal_Bool __EXPORT ScUndoTabOp::CanRepeat(SfxRepeatTarget& /* rTarget */) const
{
	return sal_False;
}


//============================================================================
//  class ScUndoConversion
//
//	Spelling

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

ScUndoConversion::ScUndoConversion(
        ScDocShell* pNewDocShell, const ScMarkData& rMark,
        SCCOL nCurX, SCROW nCurY, SCTAB nCurZ, ScDocument* pNewUndoDoc,
        SCCOL nNewX, SCROW nNewY, SCTAB nNewZ, ScDocument* pNewRedoDoc,
        const ScConversionParam& rConvParam ) :
    ScSimpleUndo( pNewDocShell ),
    aMarkData( rMark ),
    aCursorPos( nCurX, nCurY, nCurZ ),
    pUndoDoc( pNewUndoDoc ),
    aNewCursorPos( nNewX, nNewY, nNewZ ),
    pRedoDoc( pNewRedoDoc ),
    maConvParam( rConvParam )
{
	SetChangeTrack();
}


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

__EXPORT ScUndoConversion::~ScUndoConversion()
{
	delete pUndoDoc;
	delete pRedoDoc;
}


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

void ScUndoConversion::SetChangeTrack()
{
	ScDocument* pDoc = pDocShell->GetDocument();
	ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
	if ( pChangeTrack )
	{
		if ( pUndoDoc )
			pChangeTrack->AppendContentsIfInRefDoc( pUndoDoc,
				nStartChangeAction, nEndChangeAction );
		else
		{
            DBG_ERROR( "ScUndoConversion::SetChangeTrack: kein UndoDoc" );
			nStartChangeAction = nEndChangeAction = 0;
		}
	}
	else
		nStartChangeAction = nEndChangeAction = 0;
}

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

String ScUndoConversion::GetComment() const
{
    String aText;
    switch( maConvParam.GetType() )
    {
        case SC_CONVERSION_SPELLCHECK:      aText = ScGlobal::GetRscString( STR_UNDO_SPELLING );    break;
        case SC_CONVERSION_HANGULHANJA:     aText = ScGlobal::GetRscString( STR_UNDO_HANGULHANJA ); break;
        case SC_CONVERSION_CHINESE_TRANSL:  aText = ScGlobal::GetRscString( STR_UNDO_CHINESE_TRANSLATION ); break;
        default: DBG_ERRORFILE( "ScUndoConversion::GetComment - unknown conversion type" );
    }
    return aText;
}


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

void ScUndoConversion::DoChange( ScDocument* pRefDoc, const ScAddress& rCursorPos )
{
	if (pRefDoc)
	{
		ScDocument* pDoc = pDocShell->GetDocument();
		ShowTable( rCursorPos.Tab() );

	    SetViewMarkData( aMarkData );

		SCTAB nTabCount = pDoc->GetTableCount();
		//	Undo/Redo-doc has only selected tables

		sal_Bool bMulti = aMarkData.IsMultiMarked();
		pRefDoc->CopyToDocument( 0,      0,      0,
								 MAXCOL, MAXROW, nTabCount-1,
								 IDF_CONTENTS, bMulti, pDoc, &aMarkData );
		pDocShell->PostPaintGridAll();
	}
	else
	{
		DBG_ERROR("Kein Un-/RedoDoc bei Un-/RedoSpelling");
	}
}


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

void ScUndoConversion::Undo()
{
	BeginUndo();
	DoChange( pUndoDoc, aCursorPos );
	ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
	if ( pChangeTrack )
		pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
	EndUndo();
}


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

void ScUndoConversion::Redo()
{
	BeginRedo();
	DoChange( pRedoDoc, aNewCursorPos );
	SetChangeTrack();
	EndRedo();
}


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

void ScUndoConversion::Repeat( SfxRepeatTarget& rTarget )
{
    if( rTarget.ISA( ScTabViewTarget ) )
        ((ScTabViewTarget&)rTarget).GetViewShell()->DoSheetConversion( maConvParam, sal_True );
}


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

sal_Bool ScUndoConversion::CanRepeat(SfxRepeatTarget& rTarget) const
{
    return rTarget.ISA( ScTabViewTarget );
}


//============================================================================
//  class ScUndoRefConversion
//
//	cell reference conversion

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

ScUndoRefConversion::ScUndoRefConversion( ScDocShell* pNewDocShell,
                                         const ScRange& aMarkRange, const ScMarkData& rMark,
                                         ScDocument* pNewUndoDoc, ScDocument* pNewRedoDoc, sal_Bool bNewMulti, sal_uInt16 nNewFlag) :
ScSimpleUndo( pNewDocShell ),
aMarkData   ( rMark ),
pUndoDoc	( pNewUndoDoc ),
pRedoDoc	( pNewRedoDoc ),
aRange  	( aMarkRange ),
bMulti      ( bNewMulti ),
nFlags      ( nNewFlag )
{
    SetChangeTrack();
}

__EXPORT ScUndoRefConversion::~ScUndoRefConversion()
{
    delete pUndoDoc;
    delete pRedoDoc;
}

String __EXPORT ScUndoRefConversion::GetComment() const
{
    return ScGlobal::GetRscString( STR_UNDO_ENTERDATA ); // "Eingabe"
}

void ScUndoRefConversion::SetChangeTrack()
{
    ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
    if ( pChangeTrack && (nFlags & IDF_FORMULA) )
        pChangeTrack->AppendContentsIfInRefDoc( pUndoDoc,
            nStartChangeAction, nEndChangeAction );
    else
        nStartChangeAction = nEndChangeAction = 0;
}

void ScUndoRefConversion::DoChange( ScDocument* pRefDoc)
{
    ScDocument* pDoc = pDocShell->GetDocument();

    ShowTable(aRange);

    SetViewMarkData( aMarkData );

    ScRange aCopyRange = aRange;
    SCTAB nTabCount = pDoc->GetTableCount();
    aCopyRange.aStart.SetTab(0);
    aCopyRange.aEnd.SetTab(nTabCount-1);
    pRefDoc->CopyToDocument( aCopyRange, nFlags, bMulti, pDoc, &aMarkData );
    pDocShell->PostPaint( aRange, PAINT_GRID);
    pDocShell->PostDataChanged();
    ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
    if (pViewShell)
        pViewShell->CellContentChanged();
}
void __EXPORT ScUndoRefConversion::Undo()
{
    BeginUndo();
    if (pUndoDoc)
        DoChange(pUndoDoc);
    ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
    if ( pChangeTrack )
        pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
    EndUndo();
}

void __EXPORT ScUndoRefConversion::Redo()
{
    BeginRedo();
    if (pRedoDoc)
        DoChange(pRedoDoc);
    SetChangeTrack();
    EndRedo();
}

void __EXPORT ScUndoRefConversion::Repeat(SfxRepeatTarget& rTarget)
{
    if (rTarget.ISA(ScTabViewTarget))
        ((ScTabViewTarget&)rTarget).GetViewShell()->DoRefConversion();
}

sal_Bool __EXPORT ScUndoRefConversion::CanRepeat(SfxRepeatTarget& rTarget) const
{
    return (rTarget.ISA(ScTabViewTarget));
}
//============================================================================
//	class ScUndoRefreshLink
//
//	Link aktualisieren / aendern

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

ScUndoRefreshLink::ScUndoRefreshLink( ScDocShell* pNewDocShell,
									ScDocument* pNewUndoDoc )
		//
	:	ScSimpleUndo( pNewDocShell ),
		//
		pUndoDoc( pNewUndoDoc ),
		pRedoDoc( NULL )
{
}


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

__EXPORT ScUndoRefreshLink::~ScUndoRefreshLink()
{
	delete pUndoDoc;
	delete pRedoDoc;
}


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

String __EXPORT ScUndoRefreshLink::GetComment() const
{
	return ScGlobal::GetRscString( STR_UNDO_UPDATELINK );
}


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

void __EXPORT ScUndoRefreshLink::Undo()
{
	BeginUndo();

	sal_Bool bMakeRedo = !pRedoDoc;
	if (bMakeRedo)
		pRedoDoc = new ScDocument( SCDOCMODE_UNDO );

	sal_Bool bFirst = sal_True;
	ScDocument* pDoc = pDocShell->GetDocument();
	SCTAB nCount = pDoc->GetTableCount();
	for (SCTAB nTab=0; nTab<nCount; nTab++)
		if (pUndoDoc->HasTable(nTab))
		{
			ScRange aRange(0,0,nTab,MAXCOL,MAXROW,nTab);
			if (bMakeRedo)
			{
				if (bFirst)
					pRedoDoc->InitUndo( pDoc, nTab, nTab, sal_True, sal_True );
				else
					pRedoDoc->AddUndoTab( nTab, nTab, sal_True, sal_True );
				bFirst = sal_False;
				pDoc->CopyToDocument(aRange, IDF_ALL, sal_False, pRedoDoc);
//				pRedoDoc->TransferDrawPage( pDoc, nTab, nTab );
				pRedoDoc->SetLink( nTab,
								   pDoc->GetLinkMode(nTab),
								   pDoc->GetLinkDoc(nTab),
								   pDoc->GetLinkFlt(nTab),
								   pDoc->GetLinkOpt(nTab),
								   pDoc->GetLinkTab(nTab),
								   pDoc->GetLinkRefreshDelay(nTab) );
				pRedoDoc->SetTabBgColor( nTab, pDoc->GetTabBgColor(nTab) );
			}

			pDoc->DeleteAreaTab( aRange,IDF_ALL );
			pUndoDoc->CopyToDocument( aRange, IDF_ALL, sal_False, pDoc );
//			pDoc->TransferDrawPage( pUndoDoc, nTab, nTab );
			pDoc->SetLink( nTab, pUndoDoc->GetLinkMode(nTab), pUndoDoc->GetLinkDoc(nTab),
								 pUndoDoc->GetLinkFlt(nTab),  pUndoDoc->GetLinkOpt(nTab),
								 pUndoDoc->GetLinkTab(nTab),
								 pUndoDoc->GetLinkRefreshDelay(nTab) );
			pDoc->SetTabBgColor( nTab, pUndoDoc->GetTabBgColor(nTab) );
		}

	pDocShell->PostPaintGridAll();
	pDocShell->PostPaintExtras();

	EndUndo();
}


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

void __EXPORT ScUndoRefreshLink::Redo()
{
	DBG_ASSERT(pRedoDoc, "Kein RedoDoc bei ScUndoRefreshLink::Redo");

	BeginUndo();

	ScDocument* pDoc = pDocShell->GetDocument();
	SCTAB nCount = pDoc->GetTableCount();
	for (SCTAB nTab=0; nTab<nCount; nTab++)
		if (pRedoDoc->HasTable(nTab))
		{
			ScRange aRange(0,0,nTab,MAXCOL,MAXROW,nTab);

			pDoc->DeleteAreaTab( aRange, IDF_ALL );
			pRedoDoc->CopyToDocument( aRange, IDF_ALL, sal_False, pDoc );
//			pDoc->TransferDrawPage( pRedoDoc, nTab, nTab );
			pDoc->SetLink( nTab,
						   pRedoDoc->GetLinkMode(nTab),
						   pRedoDoc->GetLinkDoc(nTab),
						   pRedoDoc->GetLinkFlt(nTab),
						   pRedoDoc->GetLinkOpt(nTab),
						   pRedoDoc->GetLinkTab(nTab),
						   pRedoDoc->GetLinkRefreshDelay(nTab) );
			pDoc->SetTabBgColor( nTab, pRedoDoc->GetTabBgColor(nTab) );
		}

	pDocShell->PostPaintGridAll();
	pDocShell->PostPaintExtras();

	EndUndo();
}


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

void __EXPORT ScUndoRefreshLink::Repeat(SfxRepeatTarget& /* rTarget */)
{
	//	gippsnich
}


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

sal_Bool __EXPORT ScUndoRefreshLink::CanRepeat(SfxRepeatTarget& /* rTarget */) const
{
	return sal_False;
}


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

ScAreaLink* lcl_FindAreaLink( sfx2::LinkManager* pLinkManager, const String& rDoc,
							const String& rFlt, const String& rOpt,
							const String& rSrc, const ScRange& rDest )
{
    const ::sfx2::SvBaseLinks& rLinks = pLinkManager->GetLinks();
	sal_uInt16 nCount = pLinkManager->GetLinks().Count();
	for (sal_uInt16 i=0; i<nCount; i++)
	{
        ::sfx2::SvBaseLink* pBase = *rLinks[i];
		if (pBase->ISA(ScAreaLink))
			if ( ((ScAreaLink*)pBase)->IsEqual( rDoc, rFlt, rOpt, rSrc, rDest ) )
				return (ScAreaLink*)pBase;
	}

	DBG_ERROR("ScAreaLink nicht gefunden");
	return NULL;
}


//============================================================================
//	class ScUndoInsertAreaLink
//
//	Bereichs-Verknuepfung einfuegen

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

ScUndoInsertAreaLink::ScUndoInsertAreaLink( ScDocShell* pShell,
							const String& rDoc,
							const String& rFlt, const String& rOpt,
							const String& rArea, const ScRange& rDestRange,
							sal_uLong nRefresh )
		//
	:	ScSimpleUndo	( pShell ),
		//
		aDocName		( rDoc ),
		aFltName		( rFlt ),
		aOptions		( rOpt ),
		aAreaName		( rArea ),
		aRange			( rDestRange ),
		nRefreshDelay	( nRefresh )
{
}


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

__EXPORT ScUndoInsertAreaLink::~ScUndoInsertAreaLink()
{
}


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

String __EXPORT ScUndoInsertAreaLink::GetComment() const
{
	return ScGlobal::GetRscString( STR_UNDO_INSERTAREALINK );
}


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

void __EXPORT ScUndoInsertAreaLink::Undo()
{
	ScDocument* pDoc = pDocShell->GetDocument();
	sfx2::LinkManager* pLinkManager = pDoc->GetLinkManager();

	ScAreaLink* pLink = lcl_FindAreaLink( pLinkManager, aDocName, aFltName, aOptions,
											aAreaName, aRange );
	if (pLink)
		pLinkManager->Remove( pLink );

	SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );		// Navigator
}


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

void __EXPORT ScUndoInsertAreaLink::Redo()
{
	ScDocument* pDoc = pDocShell->GetDocument();
	sfx2::LinkManager* pLinkManager = pDoc->GetLinkManager();

	ScAreaLink* pLink = new ScAreaLink( pDocShell, aDocName, aFltName, aOptions,
											aAreaName, aRange.aStart, nRefreshDelay );
	pLink->SetInCreate( sal_True );
	pLink->SetDestArea( aRange );
	pLinkManager->InsertFileLink( *pLink, OBJECT_CLIENT_FILE, aDocName, &aFltName, &aAreaName );
	pLink->Update();
	pLink->SetInCreate( sal_False );

	SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );		// Navigator
}


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

void __EXPORT ScUndoInsertAreaLink::Repeat(SfxRepeatTarget& /* rTarget */)
{
	//!	....
}


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

sal_Bool __EXPORT ScUndoInsertAreaLink::CanRepeat(SfxRepeatTarget& /* rTarget */) const
{
	return sal_False;
}


//============================================================================
//	class ScUndoRemoveAreaLink
//
//	Bereichs-Verknuepfung loeschen

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

ScUndoRemoveAreaLink::ScUndoRemoveAreaLink( ScDocShell* pShell,
							const String& rDoc, const String& rFlt, const String& rOpt,
							const String& rArea, const ScRange& rDestRange,
							sal_uLong nRefresh )
		//
	:	ScSimpleUndo	( pShell ),
		//
		aDocName		( rDoc ),
		aFltName		( rFlt ),
		aOptions		( rOpt ),
		aAreaName		( rArea ),
		aRange			( rDestRange ),
		nRefreshDelay	( nRefresh )
{
}


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

__EXPORT ScUndoRemoveAreaLink::~ScUndoRemoveAreaLink()
{
}


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

String __EXPORT ScUndoRemoveAreaLink::GetComment() const
{
	return ScGlobal::GetRscString( STR_UNDO_REMOVELINK );	//! eigener Text ??
}


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

void __EXPORT ScUndoRemoveAreaLink::Undo()
{
	ScDocument* pDoc = pDocShell->GetDocument();
	sfx2::LinkManager* pLinkManager = pDoc->GetLinkManager();

	ScAreaLink* pLink = new ScAreaLink( pDocShell, aDocName, aFltName, aOptions,
										aAreaName, aRange.aStart, nRefreshDelay );
	pLink->SetInCreate( sal_True );
	pLink->SetDestArea( aRange );
	pLinkManager->InsertFileLink( *pLink, OBJECT_CLIENT_FILE, aDocName, &aFltName, &aAreaName );
	pLink->Update();
	pLink->SetInCreate( sal_False );

	SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );		// Navigator
}


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

void __EXPORT ScUndoRemoveAreaLink::Redo()
{
	ScDocument* pDoc = pDocShell->GetDocument();
	sfx2::LinkManager* pLinkManager = pDoc->GetLinkManager();

	ScAreaLink* pLink = lcl_FindAreaLink( pLinkManager, aDocName, aFltName, aOptions,
											aAreaName, aRange );
	if (pLink)
		pLinkManager->Remove( pLink );

	SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );		// Navigator
}


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

void __EXPORT ScUndoRemoveAreaLink::Repeat(SfxRepeatTarget& /* rTarget */)
{
	//	gippsnich
}


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

sal_Bool __EXPORT ScUndoRemoveAreaLink::CanRepeat(SfxRepeatTarget& /* rTarget */) const
{
	return sal_False;
}


//============================================================================
//	class ScUndoUpdateAreaLink
//
//	Bereichs-Verknuepfung aktualisieren

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

ScUndoUpdateAreaLink::ScUndoUpdateAreaLink( ScDocShell* pShell,
							const String& rOldD, const String& rOldF, const String& rOldO,
							const String& rOldA, const ScRange& rOldR, sal_uLong nOldRD,
							const String& rNewD, const String& rNewF, const String& rNewO,
							const String& rNewA, const ScRange& rNewR, sal_uLong nNewRD,
							ScDocument* pUndo, ScDocument* pRedo, sal_Bool bDoInsert )
		//
	:	ScSimpleUndo( pShell ),
		//
		aOldDoc		( rOldD ),
		aOldFlt		( rOldF ),
		aOldOpt		( rOldO ),
		aOldArea	( rOldA ),
		aOldRange	( rOldR ),
		aNewDoc		( rNewD ),
		aNewFlt		( rNewF ),
		aNewOpt		( rNewO ),
		aNewArea	( rNewA ),
		aNewRange	( rNewR ),
		pUndoDoc	( pUndo ),
		pRedoDoc	( pRedo ),
		nOldRefresh	( nOldRD ),
		nNewRefresh	( nNewRD ),
		bWithInsert	( bDoInsert )
{
	DBG_ASSERT( aOldRange.aStart == aNewRange.aStart, "AreaLink verschoben ?" );
}


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

__EXPORT ScUndoUpdateAreaLink::~ScUndoUpdateAreaLink()
{
	delete pUndoDoc;
	delete pRedoDoc;
}


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

String __EXPORT ScUndoUpdateAreaLink::GetComment() const
{
	return ScGlobal::GetRscString( STR_UNDO_UPDATELINK );	//! eigener Text ??
}


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

void ScUndoUpdateAreaLink::DoChange( const sal_Bool bUndo ) const
{
	ScDocument* pDoc = pDocShell->GetDocument();

	SCCOL nEndX = Max( aOldRange.aEnd.Col(), aNewRange.aEnd.Col() );
	SCROW nEndY = Max( aOldRange.aEnd.Row(), aNewRange.aEnd.Row() );
	SCTAB nEndZ = Max( aOldRange.aEnd.Tab(), aNewRange.aEnd.Tab() );	//?

	if ( bUndo )
	{
		if ( bWithInsert )
		{
			pDoc->FitBlock( aNewRange, aOldRange );
            pDoc->DeleteAreaTab( aOldRange, IDF_ALL & ~IDF_NOTE );
            pUndoDoc->UndoToDocument( aOldRange, IDF_ALL & ~IDF_NOTE, sal_False, pDoc );
		}
		else
		{
			ScRange aCopyRange( aOldRange.aStart, ScAddress(nEndX,nEndY,nEndZ) );
            pDoc->DeleteAreaTab( aCopyRange, IDF_ALL & ~IDF_NOTE );
            pUndoDoc->CopyToDocument( aCopyRange, IDF_ALL & ~IDF_NOTE, sal_False, pDoc );
		}
	}
	else
	{
		if ( bWithInsert )
		{
			pDoc->FitBlock( aOldRange, aNewRange );
            pDoc->DeleteAreaTab( aNewRange, IDF_ALL & ~IDF_NOTE );
            pRedoDoc->CopyToDocument( aNewRange, IDF_ALL & ~IDF_NOTE, sal_False, pDoc );
		}
		else
		{
			ScRange aCopyRange( aOldRange.aStart, ScAddress(nEndX,nEndY,nEndZ) );
            pDoc->DeleteAreaTab( aCopyRange, IDF_ALL & ~IDF_NOTE );
            pRedoDoc->CopyToDocument( aCopyRange, IDF_ALL & ~IDF_NOTE, sal_False, pDoc );
		}
	}

	ScRange aWorkRange( aNewRange.aStart, ScAddress( nEndX, nEndY, nEndZ ) );
	pDoc->ExtendMerge( aWorkRange, sal_True );

	//	Paint

	if ( aNewRange.aEnd.Col() != aOldRange.aEnd.Col() )
		aWorkRange.aEnd.SetCol(MAXCOL);
	if ( aNewRange.aEnd.Row() != aOldRange.aEnd.Row() )
		aWorkRange.aEnd.SetRow(MAXROW);

	if ( !pDocShell->AdjustRowHeight( aWorkRange.aStart.Row(), aWorkRange.aEnd.Row(), aWorkRange.aStart.Tab() ) )
		pDocShell->PostPaint( aWorkRange, PAINT_GRID );

	pDocShell->PostDataChanged();
	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
	if (pViewShell)
		pViewShell->CellContentChanged();
}


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

void __EXPORT ScUndoUpdateAreaLink::Undo()
{
	ScDocument* pDoc = pDocShell->GetDocument();
	sfx2::LinkManager* pLinkManager = pDoc->GetLinkManager();
	ScAreaLink* pLink = lcl_FindAreaLink( pLinkManager, aNewDoc, aNewFlt, aNewOpt,
											aNewArea, aNewRange );
	if (pLink)
	{
		pLink->SetSource( aOldDoc, aOldFlt, aOldOpt, aOldArea );		// alte Werte im Link
		pLink->SetDestArea( aOldRange );
		pLink->SetRefreshDelay( nOldRefresh );
	}

	DoChange(sal_True);
}


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

void __EXPORT ScUndoUpdateAreaLink::Redo()
{
	ScDocument* pDoc = pDocShell->GetDocument();
	sfx2::LinkManager* pLinkManager = pDoc->GetLinkManager();
	ScAreaLink* pLink = lcl_FindAreaLink( pLinkManager, aOldDoc, aOldFlt, aOldOpt,
											aOldArea, aOldRange );
	if (pLink)
	{
		pLink->SetSource( aNewDoc, aNewFlt, aNewOpt, aNewArea );		// neue Werte im Link
		pLink->SetDestArea( aNewRange );
		pLink->SetRefreshDelay( nNewRefresh );
	}

	DoChange(sal_False);
}


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

void __EXPORT ScUndoUpdateAreaLink::Repeat(SfxRepeatTarget& /* rTarget */)
{
	//	gippsnich
}


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

sal_Bool __EXPORT ScUndoUpdateAreaLink::CanRepeat(SfxRepeatTarget& /* rTarget */) const
{
	return sal_False;
}