xref: /aoo41x/main/sw/source/core/undo/undobj.cxx (revision bdf72556)

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



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


#include <IShellCursorSupplier.hxx>
#include <txtftn.hxx>
#include <fmtanchr.hxx>
#include <ftnidx.hxx>
#include <frmfmt.hxx>
#include <doc.hxx>
#include <UndoManager.hxx>
#include <docary.hxx>
#include <swundo.hxx>			// fuer die UndoIds
#include <pam.hxx>
#include <ndtxt.hxx>
#include <UndoCore.hxx>
#include <rolbck.hxx>
#include <ndnotxt.hxx>
#include <IMark.hxx>
#include <mvsave.hxx>
#include <redline.hxx>
#include <crossrefbookmark.hxx>
#include <undo.hrc>
#include <comcore.hrc>
#include <docsh.hxx>

class SwRedlineSaveData: public SwUndRng, public SwRedlineData, private SwUndoSaveSection
{
public:
    SwRedlineSaveData(
        SwComparePosition eCmpPos,
        const SwPosition& rSttPos,
        const SwPosition& rEndPos,
        SwRedline& rRedl,
        sal_Bool bCopyNext );

    ~SwRedlineSaveData();

    void RedlineToDoc( SwPaM& rPam );

    SwNodeIndex* GetMvSttIdx() const
    {
        return SwUndoSaveSection::GetMvSttIdx();
    }

#ifdef DBG_UTIL
    sal_uInt16 nRedlineCount;
#endif
};

SV_IMPL_PTRARR( SwRedlineSaveDatas, SwRedlineSaveDataPtr )


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

// Diese Klasse speichert den Pam als sal_uInt16's und kann diese wieder zu

// einem PaM zusammensetzen
SwUndRng::SwUndRng()
	: nSttNode( 0 ), nEndNode( 0 ), nSttCntnt( 0 ), nEndCntnt( 0 )
{
}

SwUndRng::SwUndRng( const SwPaM& rPam )
{
	SetValues( rPam );
}

void SwUndRng::SetValues( const SwPaM& rPam )
{
	const SwPosition *pStt = rPam.Start();
	if( rPam.HasMark() )
	{
		const SwPosition *pEnd = rPam.GetPoint() == pStt
						? rPam.GetMark()
						: rPam.GetPoint();
		nEndNode = pEnd->nNode.GetIndex();
		nEndCntnt = pEnd->nContent.GetIndex();
	}
	else
		// keine Selektion !!
		nEndNode = 0, nEndCntnt = STRING_MAXLEN;

	nSttNode = pStt->nNode.GetIndex();
	nSttCntnt = pStt->nContent.GetIndex();
}

void SwUndRng::SetPaM( SwPaM & rPam, sal_Bool bCorrToCntnt ) const
{
	rPam.DeleteMark();
	rPam.GetPoint()->nNode = nSttNode;
	SwNode* pNd = rPam.GetNode();
	if( pNd->IsCntntNode() )
		rPam.GetPoint()->nContent.Assign( pNd->GetCntntNode(), nSttCntnt );
	else if( bCorrToCntnt )
		rPam.Move( fnMoveForward, fnGoCntnt );
	else
		rPam.GetPoint()->nContent.Assign( 0, 0 );

	if( !nEndNode && STRING_MAXLEN == nEndCntnt )		// keine Selection
		return ;

	rPam.SetMark();
	if( nSttNode == nEndNode && nSttCntnt == nEndCntnt )
		return;								// nichts mehr zu tun

	rPam.GetPoint()->nNode = nEndNode;
	if( (pNd = rPam.GetNode())->IsCntntNode() )
		rPam.GetPoint()->nContent.Assign( pNd->GetCntntNode(), nEndCntnt );
	else if( bCorrToCntnt )
		rPam.Move( fnMoveBackward, fnGoCntnt );
	else
		rPam.GetPoint()->nContent.Assign( 0, 0 );
}

SwPaM & SwUndRng::AddUndoRedoPaM(
        ::sw::UndoRedoContext & rContext, bool const bCorrToCntnt) const
{
    SwPaM & rPaM( rContext.GetCursorSupplier().CreateNewShellCursor() );
    SetPaM( rPaM, bCorrToCntnt );
    return rPaM;
}


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


void SwUndo::RemoveIdxFromSection( SwDoc& rDoc, sal_uLong nSttIdx,
									sal_uLong* pEndIdx )
{
	SwNodeIndex aIdx( rDoc.GetNodes(), nSttIdx );
	SwNodeIndex aEndIdx( rDoc.GetNodes(), pEndIdx ? *pEndIdx
									: aIdx.GetNode().EndOfSectionIndex() );
	SwPosition aPos( rDoc.GetNodes().GetEndOfPostIts() );
	rDoc.CorrAbs( aIdx, aEndIdx, aPos, sal_True );
}

void SwUndo::RemoveIdxFromRange( SwPaM& rPam, sal_Bool bMoveNext )
{
	const SwPosition* pEnd = rPam.End();
	if( bMoveNext )
	{
		if( pEnd != rPam.GetPoint() )
			rPam.Exchange();

		SwNodeIndex aStt( rPam.GetMark()->nNode );
		SwNodeIndex aEnd( rPam.GetPoint()->nNode );

		if( !rPam.Move( fnMoveForward ) )
		{
			rPam.Exchange();
			if( !rPam.Move( fnMoveBackward ) )
			{
				rPam.GetPoint()->nNode = rPam.GetDoc()->GetNodes().GetEndOfPostIts();
				rPam.GetPoint()->nContent.Assign( 0, 0 );
			}
		}

		rPam.GetDoc()->CorrAbs( aStt, aEnd, *rPam.GetPoint(), sal_True );
	}
	else
		rPam.GetDoc()->CorrAbs( rPam, *pEnd, sal_True );
}

void SwUndo::RemoveIdxRel( sal_uLong nIdx, const SwPosition& rPos )
{
	// nur die Crsr verschieben; die Bookmarks/TOXMarks/.. werden vom
	// entsp. JoinNext/JoinPrev erledigt!
	SwNodeIndex aIdx( rPos.nNode.GetNode().GetNodes(), nIdx );
	::PaMCorrRel( aIdx, rPos );
}

SwUndo::SwUndo(SwUndoId const nId)
    : m_nId(nId), nOrigRedlineMode(nsRedlineMode_t::REDLINE_NONE),
      bCacheComment(true), pComment(NULL)
{
}

bool SwUndo::IsDelBox() const
{
    return GetId() == UNDO_COL_DELETE || GetId() == UNDO_ROW_DELETE ||
        GetId() == UNDO_TABLE_DELBOX;
}

SwUndo::~SwUndo()
{
    delete pComment;
}


class UndoRedoRedlineGuard
{
public:
    UndoRedoRedlineGuard(::sw::UndoRedoContext & rContext, SwUndo & rUndo)
        : m_rRedlineAccess(rContext.GetDoc())
        , m_eMode(m_rRedlineAccess.GetRedlineMode())
    {
        RedlineMode_t const eTmpMode =
            static_cast<RedlineMode_t>(rUndo.GetRedlineMode());
        if ((nsRedlineMode_t::REDLINE_SHOW_MASK & eTmpMode) !=
            (nsRedlineMode_t::REDLINE_SHOW_MASK & m_eMode))
        {
            m_rRedlineAccess.SetRedlineMode( eTmpMode );
        }
        m_rRedlineAccess.SetRedlineMode_intern( static_cast<RedlineMode_t>(
                eTmpMode | nsRedlineMode_t::REDLINE_IGNORE) );
    }
    ~UndoRedoRedlineGuard()
    {
        m_rRedlineAccess.SetRedlineMode(m_eMode);
    }
private:
    IDocumentRedlineAccess & m_rRedlineAccess;
    RedlineMode_t const m_eMode;
};

void SwUndo::Undo()
{
    OSL_ENSURE(false, "SwUndo::Undo(): ERROR: must call Undo(context) instead");
}

void SwUndo::Redo()
{
    OSL_ENSURE(false, "SwUndo::Redo(): ERROR: must call Redo(context) instead");
}

void SwUndo::UndoWithContext(SfxUndoContext & rContext)
{
    ::sw::UndoRedoContext *const pContext(
            dynamic_cast< ::sw::UndoRedoContext * >(& rContext));
    OSL_ASSERT(pContext);
    if (!pContext) { return; }
    const UndoRedoRedlineGuard aUndoRedoRedlineGuard(*pContext, *this);
    UndoImpl(*pContext);
}

void SwUndo::RedoWithContext(SfxUndoContext & rContext)
{
    ::sw::UndoRedoContext *const pContext(
            dynamic_cast< ::sw::UndoRedoContext * >(& rContext));
    OSL_ASSERT(pContext);
    if (!pContext) { return; }
    const UndoRedoRedlineGuard aUndoRedoRedlineGuard(*pContext, *this);
    RedoImpl(*pContext);
}

void SwUndo::Repeat(SfxRepeatTarget & rContext)
{
    ::sw::RepeatContext *const pRepeatContext(
            dynamic_cast< ::sw::RepeatContext * >(& rContext));
    OSL_ASSERT(pRepeatContext);
    if (!pRepeatContext) { return; }
    RepeatImpl(*pRepeatContext);
}

sal_Bool SwUndo::CanRepeat(SfxRepeatTarget & rContext) const
{
    ::sw::RepeatContext *const pRepeatContext(
            dynamic_cast< ::sw::RepeatContext * >(& rContext));
    OSL_ASSERT(pRepeatContext);
    if (!pRepeatContext) { return false; }
    return CanRepeatImpl(*pRepeatContext);
}

void SwUndo::RepeatImpl( ::sw::RepeatContext & )
{
}

bool SwUndo::CanRepeatImpl( ::sw::RepeatContext & ) const
{
//    return false;
    return ((REPEAT_START <= GetId()) && (GetId() < REPEAT_END));
}

String SwUndo::GetComment() const
{
    String aResult;

    if (bCacheComment)
    {
        if (! pComment)
        {
            pComment = new String(SW_RES(UNDO_BASE + GetId()));

            SwRewriter aRewriter = GetRewriter();

            *pComment = aRewriter.Apply(*pComment);
        }

        aResult = *pComment;
    }
    else
    {
        aResult = String(SW_RES(UNDO_BASE + GetId()));

        SwRewriter aRewriter = GetRewriter();

        aResult = aRewriter.Apply(aResult);
    }

    return aResult;
}

SwRewriter SwUndo::GetRewriter() const
{
    SwRewriter aResult;

    return aResult;
}


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

SwUndoSaveCntnt::SwUndoSaveCntnt()
	: pHistory( 0 )
{}

SwUndoSaveCntnt::~SwUndoSaveCntnt()
{
	delete pHistory;
}

	// wird fuer das Loeschen von Inhalt benoetigt. Fuer das ReDo werden
	// Inhalte in das UndoNodesArray verschoben. Diese Methoden fuegen
	// am Ende eines TextNodes fuer die Attribute einen Trenner ein.
	// Dadurch werden die Attribute nicht expandiert.
	// MoveTo.. 	verschiebt aus dem NodesArray in das UndoNodesArray
	// MoveFrom..	verschiebt aus dem UndoNodesArray in das NodesArray

	// 2.8.93:	ist pEndNdIdx angebenen, wird vom Undo/Redo -Ins/DelFly
	//			aufgerufen. Dann soll die gesamte Section verschoben werden.

void SwUndoSaveCntnt::MoveToUndoNds( SwPaM& rPaM, SwNodeIndex* pNodeIdx,
					SwIndex* pCntIdx, sal_uLong* pEndNdIdx, xub_StrLen* pEndCntIdx )
{
	SwDoc& rDoc = *rPaM.GetDoc();
    ::sw::UndoGuard const undoGuard(rDoc.GetIDocumentUndoRedo());

	SwNoTxtNode* pCpyNd = rPaM.GetNode()->GetNoTxtNode();

	// jetzt kommt das eigentliche Loeschen(Verschieben)
    SwNodes & rNds = rDoc.GetUndoManager().GetUndoNodes();
	SwPosition aPos( pEndNdIdx ? rNds.GetEndOfPostIts()
							   : rNds.GetEndOfExtras() );
	aPos.nNode--;

	const SwPosition* pStt = rPaM.Start(), *pEnd = rPaM.End();

	if( pCpyNd || pEndNdIdx || !aPos.nNode.GetNode().GetCntntNode() ||
		(!pStt->nContent.GetIndex() && (pStt->nNode != pEnd->nNode ||
				(!pStt->nNode.GetNode().GetCntntNode() ||
					pStt->nNode.GetNode().GetCntntNode()->Len() ==
						pEnd->nContent.GetIndex() ) ) ) )
	{
		aPos.nNode++;
		aPos.nContent = 0;
	}
	else
		aPos.nNode.GetNode().GetCntntNode()->MakeEndIndex( &aPos.nContent );

	// als sal_uInt16 merken; die Indizies verschieben sich !!
	sal_uLong nTmpMvNode = aPos.nNode.GetIndex();
	xub_StrLen nTmpMvCntnt = aPos.nContent.GetIndex();

	if( pCpyNd || pEndNdIdx )
	{
		SwNodeRange aRg( pStt->nNode, 0, pEnd->nNode, 1 );
		rDoc.GetNodes()._MoveNodes( aRg, rNds, aPos.nNode, sal_False );
		aPos.nContent = 0;
		aPos.nNode--;
	}
	else
    {
        rDoc.GetNodes().MoveRange( rPaM, aPos, rNds );

		SwTxtNode* pTxtNd = aPos.nNode.GetNode().GetTxtNode();
		if( pTxtNd )		// fuege einen Trenner fuer die Attribute ein !
		{
			// weil aber beim Insert die Attribute angefasst/sprich
			// aus dem Array geloescht und wieder eingefuegt werden, koennen
			// dadurch Attribute verschwinden (z.B "Fett aus" von 10-20,
			// "Fett an" von 12-15, dann wird durchs Insert/Delete das
			// "Fett an" geloescht !! Ist hier aber nicht erwuenscht !!)
			// DARUM: nicht die Hints anfassen, direct den String manipulieren

			String& rStr = (String&)pTxtNd->GetTxt();
			// Zur Sicherheit lieber nur wenn wirklich am Ende steht
			if( rStr.Len() == aPos.nContent.GetIndex() )
			{
				rStr.Insert( ' ' );
				++aPos.nContent;
			}
			else
            {
                pTxtNd->InsertText( sal_Unicode(' '), aPos.nContent,
                        IDocumentContentOperations::INS_NOHINTEXPAND );
            }
		}
	}
	if( pEndNdIdx )
		*pEndNdIdx = aPos.nNode.GetIndex();
	if( pEndCntIdx )
		*pEndCntIdx = aPos.nContent.GetIndex();

	// alte Position
	aPos.nNode = nTmpMvNode;
	if( pNodeIdx )
		*pNodeIdx = aPos.nNode;

	if( pCntIdx )
	{
		SwCntntNode* pCNd = aPos.nNode.GetNode().GetCntntNode();
		if( pCNd )
			pCntIdx->Assign( pCNd, nTmpMvCntnt );
		else
			pCntIdx->Assign( 0, 0 );
	}
}

void SwUndoSaveCntnt::MoveFromUndoNds( SwDoc& rDoc, sal_uLong nNodeIdx,
							xub_StrLen nCntIdx, SwPosition& rInsPos,
							sal_uLong* pEndNdIdx, xub_StrLen* pEndCntIdx )
{
	// jetzt kommt das wiederherstellen
    SwNodes & rNds = rDoc.GetUndoManager().GetUndoNodes();
	if( nNodeIdx == rNds.GetEndOfPostIts().GetIndex() )
		return;		// nichts gespeichert

    ::sw::UndoGuard const undoGuard(rDoc.GetIDocumentUndoRedo());

	SwPaM aPaM( rInsPos );
	if( pEndNdIdx )			// dann hole aus diesem den Bereich
		aPaM.GetPoint()->nNode.Assign( rNds, *pEndNdIdx );
	else
	{
		aPaM.GetPoint()->nNode = rNds.GetEndOfExtras();
		GoInCntnt( aPaM, fnMoveBackward );
	}

	SwTxtNode* pTxtNd = aPaM.GetNode()->GetTxtNode();
	if( !pEndNdIdx && pTxtNd )	// loesche den Trenner wieder
	{
		if( pEndCntIdx )
			aPaM.GetPoint()->nContent.Assign( pTxtNd, *pEndCntIdx );
		if( pTxtNd->GetTxt().Len() )
		{
			GoInCntnt( aPaM, fnMoveBackward );
            pTxtNd->EraseText( aPaM.GetPoint()->nContent, 1 );
        }

		aPaM.SetMark();
		aPaM.GetPoint()->nNode = nNodeIdx;
		aPaM.GetPoint()->nContent.Assign( aPaM.GetCntntNode(), nCntIdx );

		_SaveRedlEndPosForRestore aRedlRest( rInsPos.nNode, rInsPos.nContent.GetIndex() );

        rNds.MoveRange( aPaM, rInsPos, rDoc.GetNodes() );

		// noch den letzen Node loeschen.
		if( !aPaM.GetPoint()->nContent.GetIndex() ||
			( aPaM.GetPoint()->nNode++ && 		// noch leere Nodes am Ende ??
			&rNds.GetEndOfExtras() != &aPaM.GetPoint()->nNode.GetNode() ))
		{
			aPaM.GetPoint()->nContent.Assign( 0, 0 );
			aPaM.SetMark();
			rNds.Delete( aPaM.GetPoint()->nNode,
						rNds.GetEndOfExtras().GetIndex() -
						aPaM.GetPoint()->nNode.GetIndex() );
		}

		aRedlRest.Restore();
	}
	else if( pEndNdIdx || !pTxtNd )
	{
		SwNodeRange aRg( rNds, nNodeIdx, rNds, (pEndNdIdx
						? ((*pEndNdIdx) + 1)
						: rNds.GetEndOfExtras().GetIndex() ) );
		rNds._MoveNodes( aRg, rDoc.GetNodes(), rInsPos.nNode, 0 == pEndNdIdx );

	}
	else {
		ASSERT( sal_False, "was ist es denn nun?" );
    }
}

// diese beiden Methoden bewegen den Point vom Pam zurueck/vor. Damit
// kann fuer ein Undo/Redo ein Bereich aufgespannt werden. (Der
// Point liegt dann vor dem manipuliertem Bereich !!)
// Das Flag gibt an, ob noch vorm Point Inhalt steht.

sal_Bool SwUndoSaveCntnt::MovePtBackward( SwPaM& rPam )
{
	rPam.SetMark();
	if( rPam.Move( fnMoveBackward ))
		return sal_True;

	// gibt es nach vorne keinen Inhalt mehr, so setze den Point einfach
	// auf die vorherige Position (Node und Content, damit der Content
	// abgemeldet wird !!)
	rPam.GetPoint()->nNode--;
	rPam.GetPoint()->nContent.Assign( 0, 0 );
	return sal_False;
}

void SwUndoSaveCntnt::MovePtForward( SwPaM& rPam, sal_Bool bMvBkwrd )
{
	// gab es noch Inhalt vor der Position ?
	if( bMvBkwrd )
		rPam.Move( fnMoveForward );
	else
	{                       // setzen Point auf die naechste Position
		rPam.GetPoint()->nNode++;
		SwCntntNode* pCNd = rPam.GetCntntNode();
		if( pCNd )
			pCNd->MakeStartIndex( &rPam.GetPoint()->nContent );
		else
			rPam.Move( fnMoveForward );
	}
}


/*
   JP 21.03.94: loesche alle Objecte, die ContentIndizies auf den ang.
				Bereich besitzen.
				Zur Zeit gibts folgende Objecte
					- Fussnoten
					- Flys
					- Bookmarks
					- Verzeichnisse
*/
// --> OD 2007-10-17 #i81002# - extending method:
// delete certain (not all) cross-reference bookmarks at text node of <rMark>
// and at text node of <rPoint>, if these text nodes aren't the same.
void SwUndoSaveCntnt::DelCntntIndex( const SwPosition& rMark,
								     const SwPosition& rPoint,
									 DelCntntType nDelCntntType )
{
	const SwPosition *pStt = rMark < rPoint ? &rMark : &rPoint,
					*pEnd = &rMark == pStt ? &rPoint : &rMark;

	SwDoc* pDoc = rMark.nNode.GetNode().GetDoc();

    ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());

	// 1. Fussnoten
    if( nsDelCntntType::DELCNT_FTN & nDelCntntType )
	{
		SwFtnIdxs& rFtnArr = pDoc->GetFtnIdxs();
		if( rFtnArr.Count() )
		{
			const SwNode* pFtnNd;
			sal_uInt16 nPos;
			rFtnArr.SeekEntry( pStt->nNode, &nPos );
			SwTxtFtn* pSrch;

			// loesche erstmal alle, die dahinter stehen
			while( nPos < rFtnArr.Count() && ( pFtnNd =
				&( pSrch = rFtnArr[ nPos ] )->GetTxtNode())->GetIndex()
						<= pEnd->nNode.GetIndex() )
			{
				xub_StrLen nFtnSttIdx = *pSrch->GetStart();
                if( (nsDelCntntType::DELCNT_CHKNOCNTNT & nDelCntntType )
					? (&pEnd->nNode.GetNode() == pFtnNd )
					: (( &pStt->nNode.GetNode() == pFtnNd &&
					pStt->nContent.GetIndex() > nFtnSttIdx) ||
					( &pEnd->nNode.GetNode() == pFtnNd &&
					nFtnSttIdx >= pEnd->nContent.GetIndex() )) )
				{
					++nPos;		// weiter suchen
					continue;
				}

				// es muss leider ein Index angelegt werden. Sonst knallts im
				// TextNode, weil im DTOR der SwFtn dieser geloescht wird !!
				SwTxtNode* pTxtNd = (SwTxtNode*)pFtnNd;
				if( !pHistory )
					pHistory = new SwHistory;
                SwTxtAttr* const pFtnHnt =
                    pTxtNd->GetTxtAttrForCharAt( nFtnSttIdx );
				ASSERT( pFtnHnt, "kein FtnAttribut" );
				SwIndex aIdx( pTxtNd, nFtnSttIdx );
                pHistory->Add( pFtnHnt, pTxtNd->GetIndex(), false );
                pTxtNd->EraseText( aIdx, 1 );
            }

			while( nPos-- && ( pFtnNd = &( pSrch = rFtnArr[ nPos ] )->
					GetTxtNode())->GetIndex() >= pStt->nNode.GetIndex() )
			{
				xub_StrLen nFtnSttIdx = *pSrch->GetStart();
                if( !(nsDelCntntType::DELCNT_CHKNOCNTNT & nDelCntntType) && (
					( &pStt->nNode.GetNode() == pFtnNd &&
					pStt->nContent.GetIndex() > nFtnSttIdx ) ||
					( &pEnd->nNode.GetNode() == pFtnNd &&
					nFtnSttIdx >= pEnd->nContent.GetIndex() )))
					continue;				// weiter suchen

				// es muss leider ein Index angelegt werden. Sonst knallts im
				// TextNode, weil im DTOR der SwFtn dieser geloescht wird !!
				SwTxtNode* pTxtNd = (SwTxtNode*)pFtnNd;
				if( !pHistory )
					pHistory = new SwHistory;
                SwTxtAttr* const pFtnHnt =
                    pTxtNd->GetTxtAttrForCharAt( nFtnSttIdx );
				ASSERT( pFtnHnt, "kein FtnAttribut" );
				SwIndex aIdx( pTxtNd, nFtnSttIdx );
                pHistory->Add( pFtnHnt, pTxtNd->GetIndex(), false );
                pTxtNd->EraseText( aIdx, 1 );
            }
        }
    }

	// 2. Flys
    if( nsDelCntntType::DELCNT_FLY & nDelCntntType )
	{
		sal_uInt16 nChainInsPos = pHistory ? pHistory->Count() : 0;
		const SwSpzFrmFmts& rSpzArr = *pDoc->GetSpzFrmFmts();
		if( rSpzArr.Count() )
		{
			const sal_Bool bDelFwrd = rMark.nNode.GetIndex() <= rPoint.nNode.GetIndex();
			SwFlyFrmFmt* pFmt;
			const SwFmtAnchor* pAnchor;
			sal_uInt16 n = rSpzArr.Count();
			const SwPosition* pAPos;

			while( n && rSpzArr.Count() )
			{
				pFmt = (SwFlyFrmFmt*)rSpzArr[--n];
				pAnchor = &pFmt->GetAnchor();
				switch( pAnchor->GetAnchorId() )
				{
                case FLY_AS_CHAR:
					if( 0 != (pAPos = pAnchor->GetCntntAnchor() ) &&
                        (( nsDelCntntType::DELCNT_CHKNOCNTNT & nDelCntntType )
						? ( pStt->nNode <= pAPos->nNode &&
							pAPos->nNode < pEnd->nNode )
						: ( *pStt <= *pAPos && *pAPos < *pEnd )) )
					{
						if( !pHistory )
							pHistory = new SwHistory;
                        SwTxtNode *const pTxtNd =
                            pAPos->nNode.GetNode().GetTxtNode();
                        SwTxtAttr* const pFlyHnt = pTxtNd->GetTxtAttrForCharAt(
                            pAPos->nContent.GetIndex());
						ASSERT( pFlyHnt, "kein FlyAttribut" );
                        pHistory->Add( pFlyHnt, 0, false );
						// n wieder zurueck, damit nicht ein Format uebesprungen wird !
						n = n >= rSpzArr.Count() ? rSpzArr.Count() : n+1;
					}
					break;
                case FLY_AT_PARA:
                    {
                        pAPos =  pAnchor->GetCntntAnchor();
                        if( pAPos )
                        {
                            bool bTmp;
                            if( nsDelCntntType::DELCNT_CHKNOCNTNT & nDelCntntType )
                                bTmp = pStt->nNode <= pAPos->nNode && pAPos->nNode < pEnd->nNode;
                            else
                            {
                                if (bDelFwrd)
                                    bTmp = rMark.nNode < pAPos->nNode &&
                                        pAPos->nNode <= rPoint.nNode;
                                else
                                    bTmp = rPoint.nNode <= pAPos->nNode &&
                                        pAPos->nNode < rMark.nNode;
                            }

                            if (bTmp)
                            {
                                if( !pHistory )
                                    pHistory = new SwHistory;

                                // Moving the anchor?
                                if( !( nsDelCntntType::DELCNT_CHKNOCNTNT & nDelCntntType ) &&
                                    ( rPoint.nNode.GetIndex() == pAPos->nNode.GetIndex() ) )
                                {
                                    // Do not try to move the anchor to a table!
                                    if( rMark.nNode.GetNode().GetTxtNode() )
                                    {
                                        pHistory->Add( *pFmt );
                                        SwFmtAnchor aAnch( *pAnchor );
                                        SwPosition aPos( rMark.nNode );
                                        aAnch.SetAnchor( &aPos );
                                        pFmt->SetFmtAttr( aAnch );
                                    }
                                }
                                else
                                {
                                    pHistory->Add( *pFmt, nChainInsPos );
                                    // n wieder zurueck, damit nicht ein
                                    // Format uebesprungen wird !
                                    n = n >= rSpzArr.Count() ?
                                        rSpzArr.Count() : n+1;
                                }
                            }
                        }
                    }
					break;
                case FLY_AT_CHAR:
					if( 0 != (pAPos = pAnchor->GetCntntAnchor() ) &&
						( pStt->nNode <= pAPos->nNode && pAPos->nNode <= pEnd->nNode ) )
					{
						if( !pHistory )
							pHistory = new SwHistory;
                        if (IsDestroyFrameAnchoredAtChar(
                                *pAPos, *pStt, *pEnd, nDelCntntType))
                        {
							pHistory->Add( *pFmt, nChainInsPos );
							n = n >= rSpzArr.Count() ? rSpzArr.Count() : n+1;
						}
                        else if( !( nsDelCntntType::DELCNT_CHKNOCNTNT & nDelCntntType ) )
                        {
                            if( *pStt <= *pAPos && *pAPos < *pEnd )
                            {
                                // These are the objects anchored
                                // between section start and end position
                                // Do not try to move the anchor to a table!
                                if( rMark.nNode.GetNode().GetTxtNode() )
                                {
                                    pHistory->Add( *pFmt );
                                    SwFmtAnchor aAnch( *pAnchor );
                                    aAnch.SetAnchor( &rMark );
                                    pFmt->SetFmtAttr( aAnch );
                                }
                            }
                        }
					}
					break;
				case FLY_AT_FLY:

					if( 0 != (pAPos = pAnchor->GetCntntAnchor() ) &&
						pStt->nNode == pAPos->nNode )
					{
						if( !pHistory )
							pHistory = new SwHistory;

						pHistory->Add( *pFmt, nChainInsPos );

						// n wieder zurueck, damit nicht ein Format uebesprungen wird !
						n = n >= rSpzArr.Count() ? rSpzArr.Count() : n+1;
					}
					break;
				default: break;
				}
			}
		}
	}

    // 3. Bookmarks
    if( nsDelCntntType::DELCNT_BKM & nDelCntntType )
    {
        IDocumentMarkAccess* const pMarkAccess = pDoc->getIDocumentMarkAccess();
        if( pMarkAccess->getAllMarksCount() )
        {

            for( sal_uInt16 n = 0; n < pMarkAccess->getAllMarksCount(); ++n )
            {
                bool bSavePos = false;
                bool bSaveOtherPos = false;
                const ::sw::mark::IMark* pBkmk = (pMarkAccess->getAllMarksBegin() + n)->get();

                if( nsDelCntntType::DELCNT_CHKNOCNTNT & nDelCntntType )
                {
                    if ( pStt->nNode <= pBkmk->GetMarkPos().nNode
                         && pBkmk->GetMarkPos().nNode < pEnd->nNode )
                    {
                        bSavePos = true;
                    }
                    if ( pBkmk->IsExpanded()
                         && pStt->nNode <= pBkmk->GetOtherMarkPos().nNode
                         && pBkmk->GetOtherMarkPos().nNode < pEnd->nNode )
                    {
                        bSaveOtherPos = true;
                    }
                }
                else
                {
                    // keep cross-reference bookmarks, if content inside one paragraph is deleted.
                    if ( rMark.nNode == rPoint.nNode
                         && ( IDocumentMarkAccess::GetType(*pBkmk) == IDocumentMarkAccess::CROSSREF_HEADING_BOOKMARK
                              || IDocumentMarkAccess::GetType(*pBkmk) == IDocumentMarkAccess::CROSSREF_NUMITEM_BOOKMARK ) )
                    {
                        continue;
                    }

                    bool bMaybe = false;
                    if ( *pStt <= pBkmk->GetMarkPos() && pBkmk->GetMarkPos() <= *pEnd )
                    {
                        if ( pBkmk->GetMarkPos() == *pEnd
                             || ( *pStt == pBkmk->GetMarkPos() && pBkmk->IsExpanded() ) )
                            bMaybe = true;
                        else
                            bSavePos = true;
                    }
                    if( pBkmk->IsExpanded() &&
                        *pStt <= pBkmk->GetOtherMarkPos() && pBkmk->GetOtherMarkPos() <= *pEnd )
                    {
                        if ( bSavePos || bSaveOtherPos
                             || ( pBkmk->GetOtherMarkPos() < *pEnd && pBkmk->GetOtherMarkPos() > *pStt ) )
                        {
                            if( bMaybe )
                                bSavePos = true;
                            bSaveOtherPos = true;
                        }
                    }

                    if ( !bSavePos && !bSaveOtherPos
                         && dynamic_cast< const ::sw::mark::CrossRefBookmark* >(pBkmk) )
                    {
                        // certain special handling for cross-reference bookmarks
                        const bool bDifferentTxtNodesAtMarkAndPoint =
                            rMark.nNode != rPoint.nNode
                            && rMark.nNode.GetNode().GetTxtNode()
                            && rPoint.nNode.GetNode().GetTxtNode();
                        if ( bDifferentTxtNodesAtMarkAndPoint )
                        {
                            // delete cross-reference bookmark at <pStt>, if only part of
                            // <pEnd> text node content is deleted.
                            if( pStt->nNode == pBkmk->GetMarkPos().nNode
                                && pEnd->nContent.GetIndex() != pEnd->nNode.GetNode().GetTxtNode()->Len() )
                            {
                                bSavePos = true;
                                bSaveOtherPos = false; // cross-reference bookmarks are not expanded
                            }
                            // delete cross-reference bookmark at <pEnd>, if only part of
                            // <pStt> text node content is deleted.
                            else if( pEnd->nNode == pBkmk->GetMarkPos().nNode &&
                                pStt->nContent.GetIndex() != 0 )
                            {
                                bSavePos = true;
                                bSaveOtherPos = false; // cross-reference bookmarks are not expanded
                            }
                        }
                    }
                    else if ( IDocumentMarkAccess::GetType(*pBkmk) == IDocumentMarkAccess::ANNOTATIONMARK )
                    {
                        // delete annotation marks, if its end position is covered by the deletion
                        const SwPosition& rAnnotationEndPos = pBkmk->GetMarkEnd();
                        if ( *pStt < rAnnotationEndPos && rAnnotationEndPos <= *pEnd )
                        {
                            bSavePos = true;
                            bSaveOtherPos = true;
                        }
                    }
                }

                if ( bSavePos || bSaveOtherPos )
                {
                    if( !pHistory )
                        pHistory = new SwHistory;

                    pHistory->Add( *pBkmk, bSavePos, bSaveOtherPos );
                    if ( bSavePos
                         && ( bSaveOtherPos
                              || !pBkmk->IsExpanded() ) )
                    {
                        pMarkAccess->deleteMark(pMarkAccess->getAllMarksBegin()+n);
                        n--;
                    }
                }
            }
        }
    }
}


// sicher eine vollstaendige Section im Undo-Nodes-Array

SwUndoSaveSection::SwUndoSaveSection()
	: pMvStt( 0 ), pRedlSaveData( 0 ), nMvLen( 0 ), nStartPos( ULONG_MAX )
{
}

SwUndoSaveSection::~SwUndoSaveSection()
{
	if( pMvStt )		// loesche noch den Bereich aus dem UndoNodes Array
	{
		// SaveSection speichert den Inhalt in der PostIt-Section
		SwNodes& rUNds = pMvStt->GetNode().GetNodes();
		rUNds.Delete( *pMvStt, nMvLen );

		delete pMvStt;
	}
	delete pRedlSaveData;
}

void SwUndoSaveSection::SaveSection( SwDoc* pDoc, const SwNodeIndex& rSttIdx )
{
	SwNodeRange aRg( rSttIdx.GetNode(), *rSttIdx.GetNode().EndOfSectionNode() );
	SaveSection( pDoc, aRg );
}


void SwUndoSaveSection::SaveSection(
    SwDoc* pDoc,
    const SwNodeRange& rRange )
{
    SwPaM aPam( rRange.aStart, rRange.aEnd );

    // delete all footnotes, fly frames, bookmarks and indexes
    DelCntntIndex( *aPam.GetMark(), *aPam.GetPoint() );
    {
        // move certain indexes out of deleted range
        SwNodeIndex aSttIdx( aPam.Start()->nNode.GetNode() );
        SwNodeIndex aEndIdx( aPam.End()->nNode.GetNode() );
        SwNodeIndex aMvStt( aEndIdx, 1 );
        pDoc->CorrAbs( aSttIdx, aEndIdx, SwPosition( aMvStt ), sal_True );
    }

	pRedlSaveData = new SwRedlineSaveDatas;
	if( !SwUndo::FillSaveData( aPam, *pRedlSaveData, sal_True, sal_True ))
		delete pRedlSaveData, pRedlSaveData = 0;

	nStartPos = rRange.aStart.GetIndex();

	aPam.GetPoint()->nNode--;
	aPam.GetMark()->nNode++;

	SwCntntNode* pCNd = aPam.GetCntntNode( sal_False );
	if( pCNd )
		aPam.GetMark()->nContent.Assign( pCNd, 0 );
	if( 0 != ( pCNd = aPam.GetCntntNode( sal_True )) )
		aPam.GetPoint()->nContent.Assign( pCNd, pCNd->Len() );

	// Positionen als SwIndex merken, damit im DTOR dieser Bereich
	// entfernt werden kann !!
	sal_uLong nEnd;
	pMvStt = new SwNodeIndex( rRange.aStart );
	MoveToUndoNds( aPam, pMvStt, 0, &nEnd, 0 );
	nMvLen = nEnd - pMvStt->GetIndex() + 1;
}

void SwUndoSaveSection::RestoreSection( SwDoc* pDoc, SwNodeIndex* pIdx,
										sal_uInt16 nSectType )
{
	if( ULONG_MAX != nStartPos )		// gab es ueberhaupt Inhalt ?
	{
		// ueberpruefe, ob der Inhalt an der alten Position steht
		SwNodeIndex aSttIdx( pDoc->GetNodes(), nStartPos );
        OSL_ENSURE(!aSttIdx.GetNode().GetCntntNode(),
                "RestoreSection(): Position on content node");

		// move den Inhalt aus dem UndoNodes-Array in den Fly
		SwStartNode* pSttNd = pDoc->GetNodes().MakeEmptySection( aSttIdx,
												(SwStartNodeType)nSectType );

		RestoreSection( pDoc, SwNodeIndex( *pSttNd->EndOfSectionNode() ));

		if( pIdx )
			*pIdx = *pSttNd;
	}
}

void SwUndoSaveSection::RestoreSection( SwDoc* pDoc, const SwNodeIndex& rInsPos )
{
	if( ULONG_MAX != nStartPos )		// gab es ueberhaupt Inhalt ?
	{
		SwPosition aInsPos( rInsPos );
		sal_uLong nEnd = pMvStt->GetIndex() + nMvLen - 1;
		MoveFromUndoNds( *pDoc, pMvStt->GetIndex(), 0, aInsPos, &nEnd, 0 );

		// Indizies wieder zerstoren, Inhalt ist aus dem UndoNodes-Array
		// entfernt worden.
		DELETEZ( pMvStt );
		nMvLen = 0;

		if( pRedlSaveData )
		{
			SwUndo::SetSaveData( *pDoc, *pRedlSaveData );
			delete pRedlSaveData, pRedlSaveData = 0;
		}
	}
}

		// sicher und setze die RedlineDaten

SwRedlineSaveData::SwRedlineSaveData(
    SwComparePosition eCmpPos,
    const SwPosition& rSttPos,
    const SwPosition& rEndPos,
    SwRedline& rRedl,
    sal_Bool bCopyNext )
    : SwUndRng( rRedl )
    , SwRedlineData( rRedl.GetRedlineData(), bCopyNext )
{
    ASSERT( POS_OUTSIDE == eCmpPos || !rRedl.GetContentIdx(), "Redline mit Content" );

    switch (eCmpPos)
    {
    case POS_OVERLAP_BEFORE:		// Pos1 ueberlappt Pos2 am Anfang
        nEndNode = rEndPos.nNode.GetIndex();
        nEndCntnt = rEndPos.nContent.GetIndex();
        break;

    case POS_OVERLAP_BEHIND: 		// Pos1 ueberlappt Pos2 am Ende
        nSttNode = rSttPos.nNode.GetIndex();
        nSttCntnt = rSttPos.nContent.GetIndex();
        break;

    case POS_INSIDE:				// Pos1 liegt vollstaendig in Pos2
        nSttNode = rSttPos.nNode.GetIndex();
        nSttCntnt = rSttPos.nContent.GetIndex();
        nEndNode = rEndPos.nNode.GetIndex();
        nEndCntnt = rEndPos.nContent.GetIndex();
        break;

    case POS_OUTSIDE:				// Pos2 liegt vollstaendig in Pos1
        if ( rRedl.GetContentIdx() )
        {
            // dann den Bereich ins UndoArray verschieben und merken
            SaveSection( rRedl.GetDoc(), *rRedl.GetContentIdx() );
            rRedl.SetContentIdx( 0 );
        }
        break;

    case POS_EQUAL:					// Pos1 ist genauso gross wie Pos2
        break;

    default:
        ASSERT( !this, "keine gueltigen Daten!" )
    }

#ifdef DBG_UTIL
    nRedlineCount = rSttPos.nNode.GetNode().GetDoc()->GetRedlineTbl().Count();
#endif
}

SwRedlineSaveData::~SwRedlineSaveData()
{
}

void SwRedlineSaveData::RedlineToDoc( SwPaM& rPam )
{
	SwDoc& rDoc = *rPam.GetDoc();
	SwRedline* pRedl = new SwRedline( *this, rPam );

	if( GetMvSttIdx() )
	{
		SwNodeIndex aIdx( rDoc.GetNodes() );
		RestoreSection( &rDoc, &aIdx, SwNormalStartNode );
		if( GetHistory() )
			GetHistory()->Rollback( &rDoc );
		pRedl->SetContentIdx( &aIdx );
	}
	SetPaM( *pRedl );
	// erstmal die "alten" entfernen, damit im Append keine unerwarteten
	// Dinge passieren, wie z.B. eine Delete in eigenen Insert. Dann wird
	// naehmlich das gerade restaurierte wieder geloescht - nicht das gewollte
    rDoc.DeleteRedline( *pRedl, false, USHRT_MAX );

    RedlineMode_t eOld = rDoc.GetRedlineMode();
    rDoc.SetRedlineMode_intern((RedlineMode_t)(eOld | nsRedlineMode_t::REDLINE_DONTCOMBINE_REDLINES));
	//#i92154# let UI know about a new redline with comment
	if (rDoc.GetDocShell() && (pRedl->GetComment() != String(::rtl::OUString::createFromAscii(""))) )
		rDoc.GetDocShell()->Broadcast(SwRedlineHint(pRedl,SWREDLINE_INSERTED));
	//
#if OSL_DEBUG_LEVEL > 0
    bool const bSuccess =
#endif
        rDoc.AppendRedline( pRedl, true );
    OSL_ENSURE(bSuccess,
        "SwRedlineSaveData::RedlineToDoc: insert redline failed");
	rDoc.SetRedlineMode_intern( eOld );
}


sal_Bool SwUndo::FillSaveData(
    const SwPaM& rRange,
    SwRedlineSaveDatas& rSData,
    sal_Bool bDelRange,
    sal_Bool bCopyNext )
{
    if ( rSData.Count() )
    {
        rSData.DeleteAndDestroy( 0, rSData.Count() );
    }

    SwRedlineSaveData* pNewData;
    const SwPosition* pStt = rRange.Start();
    const SwPosition* pEnd = rRange.End();
    const SwRedlineTbl& rTbl = rRange.GetDoc()->GetRedlineTbl();
    sal_uInt16 n = 0;
    rRange.GetDoc()->GetRedline( *pStt, &n );
    for ( ; n < rTbl.Count(); ++n )
    {
        SwRedline* pRedl = rTbl[n];

        const SwComparePosition eCmpPos =
            ComparePosition( *pStt, *pEnd, *pRedl->Start(), *pRedl->End() );
        if ( eCmpPos != POS_BEFORE
             && eCmpPos != POS_BEHIND
             && eCmpPos != POS_COLLIDE_END
             && eCmpPos != POS_COLLIDE_START )
        {
            pNewData = new SwRedlineSaveData( eCmpPos, *pStt, *pEnd, *pRedl, bCopyNext );
            rSData.Insert( pNewData, rSData.Count() );
        }
    }
    if ( rSData.Count() && bDelRange )
    {
        rRange.GetDoc()->DeleteRedline( rRange, false, USHRT_MAX );
    }
    return 0 != rSData.Count();
}


sal_Bool SwUndo::FillSaveDataForFmt(
    const SwPaM& rRange,
    SwRedlineSaveDatas& rSData )
{
    if ( rSData.Count() )
    {
        rSData.DeleteAndDestroy( 0, rSData.Count() );
    }

    SwRedlineSaveData* pNewData;
    const SwPosition *pStt = rRange.Start(), *pEnd = rRange.End();
    const SwRedlineTbl& rTbl = rRange.GetDoc()->GetRedlineTbl();
    sal_uInt16 n = 0;
    rRange.GetDoc()->GetRedline( *pStt, &n );
    for ( ; n < rTbl.Count(); ++n )
    {
        SwRedline* pRedl = rTbl[n];
        if ( nsRedlineType_t::REDLINE_FORMAT == pRedl->GetType() )
        {
            const SwComparePosition eCmpPos = ComparePosition( *pStt, *pEnd, *pRedl->Start(), *pRedl->End() );
            if ( eCmpPos != POS_BEFORE
                 && eCmpPos != POS_BEHIND
                 && eCmpPos != POS_COLLIDE_END
                 && eCmpPos != POS_COLLIDE_START )
            {
                pNewData = new SwRedlineSaveData( eCmpPos, *pStt, *pEnd, *pRedl, sal_True );
                rSData.Insert( pNewData, rSData.Count() );
            }

        }
    }
    return 0 != rSData.Count();
}


void SwUndo::SetSaveData( SwDoc& rDoc, const SwRedlineSaveDatas& rSData )
{
    RedlineMode_t eOld = rDoc.GetRedlineMode();
    rDoc.SetRedlineMode_intern( (RedlineMode_t)(( eOld & ~nsRedlineMode_t::REDLINE_IGNORE) | nsRedlineMode_t::REDLINE_ON ));
	SwPaM aPam( rDoc.GetNodes().GetEndOfContent() );

	for( sal_uInt16 n = rSData.Count(); n; )
		rSData[ --n ]->RedlineToDoc( aPam );

    // check redline count against count saved in RedlineSaveData object
    DBG_ASSERT( (rSData.Count() == 0) ||
                (rSData[0]->nRedlineCount == rDoc.GetRedlineTbl().Count()),
                "redline count not restored properly" );

	rDoc.SetRedlineMode_intern( eOld );
}

sal_Bool SwUndo::HasHiddenRedlines( const SwRedlineSaveDatas& rSData )
{
	for( sal_uInt16 n = rSData.Count(); n; )
		if( rSData[ --n ]->GetMvSttIdx() )
			return sal_True;
	return sal_False;
}

sal_Bool SwUndo::CanRedlineGroup( SwRedlineSaveDatas& rCurr,
						const SwRedlineSaveDatas& rCheck, sal_Bool bCurrIsEnd )
{
	sal_Bool bRet = sal_False;
	sal_uInt16 n;

	if( rCurr.Count() == rCheck.Count() )
	{
		bRet = sal_True;
		for( n = 0; n < rCurr.Count(); ++n )
		{
			const SwRedlineSaveData& rSet = *rCurr[ n ];
			const SwRedlineSaveData& rGet = *rCheck[ n ];
			if( rSet.nSttNode != rGet.nSttNode ||
				rSet.GetMvSttIdx() || rGet.GetMvSttIdx() ||
				( bCurrIsEnd ? rSet.nSttCntnt != rGet.nEndCntnt
							 : rSet.nEndCntnt != rGet.nSttCntnt ) ||
				!rGet.CanCombine( rSet ) )
			{
				bRet = sal_False;
				break;
			}
		}

		if( bRet )
			for( n = 0; n < rCurr.Count(); ++n )
			{
				SwRedlineSaveData& rSet = *rCurr[ n ];
				const SwRedlineSaveData& rGet = *rCheck[ n ];
				if( bCurrIsEnd )
					rSet.nSttCntnt = rGet.nSttCntnt;
				else
					rSet.nEndCntnt = rGet.nEndCntnt;
			}
	}
	return bRet;
}

// #111827#
String ShortenString(const String & rStr, xub_StrLen nLength, const String & rFillStr)
{
    ASSERT( nLength - rFillStr.Len() >= 2, "improper arguments")

    String aResult;

    if (rStr.Len() <= nLength)
        aResult = rStr;
    else
    {
        long nTmpLength = nLength - rFillStr.Len();
        if ( nTmpLength < 2 )
            nTmpLength = 2;

        nLength = static_cast<xub_StrLen>(nTmpLength);

        const xub_StrLen nFrontLen = nLength - nLength / 2;
        const xub_StrLen nBackLen = nLength - nFrontLen;

        aResult += rStr.Copy(0, nFrontLen);
        aResult += rFillStr;
        aResult += rStr.Copy(rStr.Len() - nBackLen, nBackLen);
    }

    return aResult;
}

static bool lcl_IsSpecialCharacter(sal_Unicode nChar)
{
    switch (nChar)
    {
    case CH_TXTATR_BREAKWORD:
    case CH_TXTATR_INWORD:
    case CH_TXTATR_TAB:
    case CH_TXTATR_NEWLINE:
        return true;

    default:
        break;
    }

    return false;
}

static String lcl_DenotedPortion(String rStr, xub_StrLen nStart,
                                 xub_StrLen nEnd)
{
    String aResult;

    if (nEnd - nStart > 0)
    {
        sal_Unicode cLast = rStr.GetChar(nEnd - 1);
        if (lcl_IsSpecialCharacter(cLast))
        {
            switch(cLast)
            {
            case CH_TXTATR_TAB:
                aResult += String(SW_RES(STR_UNDO_TABS));

                break;
            case CH_TXTATR_NEWLINE:
                aResult += String(SW_RES(STR_UNDO_NLS));

                break;

            case CH_TXTATR_INWORD:
            case CH_TXTATR_BREAKWORD:
                aResult += UNDO_ARG2;

                break;

            }
            SwRewriter aRewriter;
            aRewriter.AddRule(UNDO_ARG1,
                              String::CreateFromInt32(nEnd - nStart));
            aResult = aRewriter.Apply(aResult);
        }
        else
        {
            aResult = String(SW_RES(STR_START_QUOTE));
            aResult += rStr.Copy(nStart, nEnd - nStart);
            aResult += String(SW_RES(STR_END_QUOTE));
        }
    }

    return aResult;
}

String DenoteSpecialCharacters(const String & rStr)
{
    String aResult;

    if (rStr.Len() > 0)
    {
        bool bStart = false;
        xub_StrLen nStart = 0;
        sal_Unicode cLast = 0;

        for (xub_StrLen i = 0; i < rStr.Len(); i++)
        {
            if (lcl_IsSpecialCharacter(rStr.GetChar(i)))
            {
                if (cLast != rStr.GetChar(i))
                    bStart = true;

            }
            else
            {
                if (lcl_IsSpecialCharacter(cLast))
                    bStart = true;
            }

            if (bStart)
            {
                aResult += lcl_DenotedPortion(rStr, nStart, i);

                nStart = i;
                bStart = false;
            }

            cLast = rStr.GetChar(i);
        }

        aResult += lcl_DenotedPortion(rStr, nStart, rStr.Len());
    }
    else
        aResult = UNDO_ARG2;

    return aResult;
}

bool IsDestroyFrameAnchoredAtChar(SwPosition const & rAnchorPos,
        SwPosition const & rStart, SwPosition const & rEnd,
        DelCntntType const nDelCntntType)
{

    // Here we identified the objects to destroy:
    // - anchored between start and end of the selection
    // - anchored in start of the selection with "CheckNoContent"
    // - anchored in start of sel. and the selection start at pos 0
    return  (rAnchorPos.nNode < rEnd.nNode)
         && (   (nsDelCntntType::DELCNT_CHKNOCNTNT & nDelCntntType)
            ||  (rStart.nNode < rAnchorPos.nNode)
            ||  !rStart.nContent.GetIndex()
            );
}