/************************************************************************* * * OpenOffice.org - a multi-platform office productivity suite * * $RCSfile: unredln.cxx,v $ * * $Revision: 1.9 $ * * last change: $Author: hr $ $Date: 2006-04-19 14:20:52 $ * * The Contents of this file are made available subject to * the terms of GNU Lesser General Public License Version 2.1. * * * GNU Lesser General Public License Version 2.1 * ============================================= * Copyright 2005 by Sun Microsystems, Inc. * 901 San Antonio Road, Palo Alto, CA 94303, USA * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License version 2.1, as published by the Free Software Foundation. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * MA 02111-1307 USA * ************************************************************************/ #pragma hdrstop #ifndef _HINTIDS_HXX #include #endif #ifndef _UNOTOOLS_CHARCLASS_HXX #include #endif #ifndef _DOC_HXX #include #endif #ifndef _SWUNDO_HXX #include // fuer die UndoIds #endif #ifndef _PAM_HXX #include #endif #ifndef _NDTXT_HXX #include #endif #ifndef _UNDOBJ_HXX #include #endif #ifndef _ROLBCK_HXX #include #endif #ifndef _REDLINE_HXX #include #endif #ifndef _DOCARY_HXX #include #endif #ifndef _SORTOPT_HXX #include #endif extern void lcl_JoinText( SwPaM& rPam, BOOL bJoinPrev ); extern void lcl_GetJoinFlags( SwPaM& rPam, BOOL& rJoinTxt, BOOL& rJoinPrev ); //------------------------------------------------------------------ inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); } SwUndoRedline::SwUndoRedline( USHORT nUsrId, const SwPaM& rRange ) : SwUndo( UNDO_REDLINE ), SwUndRng( rRange ), pRedlData( 0 ), pRedlSaveData( 0 ), nUserId( nUsrId ), bHiddenRedlines( FALSE ) { // Redline beachten SwDoc& rDoc = *rRange.GetDoc(); if( rDoc.IsRedlineOn() ) { switch( nUserId ) { case UNDO_DELETE: case UNDO_REPLACE: pRedlData = new SwRedlineData( REDLINE_DELETE, rDoc.GetRedlineAuthor() ); break; } SetRedlineMode( rDoc.GetRedlineMode() ); } ULONG nEndExtra = rDoc.GetNodes().GetEndOfExtras().GetIndex(); pRedlSaveData = new SwRedlineSaveDatas; if( !FillSaveData( rRange, *pRedlSaveData, FALSE, UNDO_REJECT_REDLINE != nUserId )) delete pRedlSaveData, pRedlSaveData = 0; else { bHiddenRedlines = HasHiddenRedlines( *pRedlSaveData ); if( bHiddenRedlines ) // dann muessen die NodeIndizies { // vom SwUndRng korrigiert werden nEndExtra -= rDoc.GetNodes().GetEndOfExtras().GetIndex(); nSttNode -= nEndExtra; nEndNode -= nEndExtra; } } } SwUndoRedline::~SwUndoRedline() { delete pRedlData; delete pRedlSaveData; } void SwUndoRedline::Undo( SwUndoIter& rIter ) { SwDoc* pDoc = &rIter.GetDoc(); SetPaM( *rIter.pAktPam ); // RedlineMode setzen? _Undo( rIter ); if( pRedlSaveData ) { ULONG nEndExtra = pDoc->GetNodes().GetEndOfExtras().GetIndex(); SetSaveData( *pDoc, *pRedlSaveData ); if( bHiddenRedlines ) { pRedlSaveData->DeleteAndDestroy( 0, pRedlSaveData->Count() ); nEndExtra = pDoc->GetNodes().GetEndOfExtras().GetIndex() - nEndExtra; nSttNode += nEndExtra; nEndNode += nEndExtra; } SetPaM( *rIter.pAktPam, TRUE ); } } void SwUndoRedline::Redo( SwUndoIter& rIter ) { SwDoc* pDoc = &rIter.GetDoc(); SwRedlineMode eOld = pDoc->GetRedlineMode(); pDoc->SetRedlineMode_intern( ( eOld & ~REDLINE_IGNORE) | REDLINE_ON ); SetPaM( *rIter.pAktPam ); if( pRedlSaveData && bHiddenRedlines ) { ULONG nEndExtra = pDoc->GetNodes().GetEndOfExtras().GetIndex(); FillSaveData( *rIter.pAktPam, *pRedlSaveData, FALSE, UNDO_REJECT_REDLINE != nUserId ); nEndExtra -= pDoc->GetNodes().GetEndOfExtras().GetIndex(); nSttNode -= nEndExtra; nEndNode -= nEndExtra; } _Redo( rIter ); SetPaM( *rIter.pAktPam, TRUE ); pDoc->SetRedlineMode_intern( eOld ); } // default ist leer void SwUndoRedline::_Undo( SwUndoIter& ) { } // default ist Redlines entfernen void SwUndoRedline::_Redo( SwUndoIter& rIter ) { rIter.GetDoc().DeleteRedline( *rIter.pAktPam ); } /* */ SwUndoRedlineDelete::SwUndoRedlineDelete( const SwPaM& rRange, USHORT nUsrId ) : SwUndoRedline( nUsrId = (nUsrId ? nUsrId : UNDO_DELETE), rRange ), bIsDelim( FALSE ), bIsBackspace( FALSE ), bCanGroup( FALSE ) { const SwTxtNode* pTNd; if( UNDO_DELETE == nUserId && nSttNode == nEndNode && nSttCntnt + 1 == nEndCntnt && 0 != (pTNd = rRange.GetNode()->GetTxtNode()) ) { sal_Unicode cCh = pTNd->GetTxt().GetChar( nSttCntnt ); if( CH_TXTATR_BREAKWORD != cCh && CH_TXTATR_INWORD != cCh ) { bCanGroup = TRUE; bIsDelim = !GetAppCharClass().isLetterNumeric( pTNd->GetTxt(), nSttCntnt ); bIsBackspace = nSttCntnt == rRange.GetPoint()->nContent.GetIndex(); } } bCacheComment = false; } void SwUndoRedlineDelete::_Undo( SwUndoIter& rIter ) { rIter.GetDoc().DeleteRedline( *rIter.pAktPam ); } void SwUndoRedlineDelete::_Redo( SwUndoIter& rIter ) { if( *rIter.pAktPam->GetPoint() != *rIter.pAktPam->GetMark() ) rIter.GetDoc().AppendRedline( new SwRedline( *pRedlData, *rIter.pAktPam ), FALSE ); } BOOL SwUndoRedlineDelete::CanGrouping( const SwUndoRedlineDelete& rNext ) { BOOL bRet = FALSE; if( UNDO_DELETE == nUserId && nUserId == rNext.nUserId && bCanGroup == rNext.bCanGroup && bIsDelim == rNext.bIsDelim && bIsBackspace == rNext.bIsBackspace && nSttNode == nEndNode && rNext.nSttNode == nSttNode && rNext.nEndNode == nEndNode ) { int bIsEnd = 0; if( rNext.nSttCntnt == nEndCntnt ) bIsEnd = 1; else if( rNext.nEndCntnt == nSttCntnt ) bIsEnd = -1; if( bIsEnd && (( !pRedlSaveData && !rNext.pRedlSaveData ) || ( pRedlSaveData && rNext.pRedlSaveData && SwUndo::CanRedlineGroup( *pRedlSaveData, *rNext.pRedlSaveData, 1 != bIsEnd ) ))) { if( 1 == bIsEnd ) nEndCntnt = rNext.nEndCntnt; else nSttCntnt = rNext.nSttCntnt; bRet = TRUE; } } return bRet; } /* */ SwUndoRedlineSort::SwUndoRedlineSort( const SwPaM& rRange, const SwSortOptions& rOpt ) : SwUndoRedline( UNDO_SORT_TXT, rRange ), pOpt( new SwSortOptions( rOpt ) ), nSaveEndNode( nEndNode ), nOffset( 0 ), nSaveEndCntnt( nEndCntnt ) { } SwUndoRedlineSort::~SwUndoRedlineSort() { delete pOpt; } void SwUndoRedlineSort::_Undo( SwUndoIter& rIter ) { // im rIter.pAktPam ist der sortiete Bereich, // im aSaveRange steht der kopierte, sprich der originale. SwDoc& rDoc = rIter.GetDoc(); if( 0 == ( REDLINE_SHOW_DELETE & rDoc.GetRedlineMode()) ) { // die beiden Redline Objecte suchen und diese dann anzeigen lassen, // damit die Nodes wieder uebereinstimmen! // das Geloeschte ist versteckt, also suche das INSERT // Redline Object. Dahinter steht das Geloeschte USHORT nFnd = rDoc.GetRedlinePos( *rDoc.GetNodes()[ nSttNode + nOffset + 1 ], REDLINE_INSERT ); ASSERT( USHRT_MAX != nFnd && nFnd+1 < rDoc.GetRedlineTbl().Count(), "kein Insert Object gefunden" ); ++nFnd; rDoc.GetRedlineTbl()[nFnd]->Show(); SetPaM( *rIter.pAktPam ); } { SwPaM aTmp( *rIter.pAktPam->GetMark() ); aTmp.SetMark(); aTmp.GetPoint()->nNode = nSaveEndNode; aTmp.GetPoint()->nContent.Assign( aTmp.GetCntntNode(), nSaveEndCntnt ); rDoc.DeleteRedline( aTmp ); } rDoc.DelFullPara( *rIter.pAktPam ); SetPaM( *rIter.pAktPam ); } void SwUndoRedlineSort::_Redo( SwUndoIter& rIter ) { SwPaM& rPam = *rIter.pAktPam; rIter.GetDoc().SortText( rPam, *pOpt ); SetPaM( rPam ); rPam.GetPoint()->nNode = nSaveEndNode; rPam.GetPoint()->nContent.Assign( rPam.GetCntntNode(), nSaveEndCntnt ); } void SwUndoRedlineSort::Repeat( SwUndoIter& rIter ) { rIter.GetDoc().SortText( *rIter.pAktPam, *pOpt ); } void SwUndoRedlineSort::SetSaveRange( const SwPaM& rRange ) { const SwPosition& rPos = *rRange.End(); nSaveEndNode = rPos.nNode.GetIndex(); nSaveEndCntnt = rPos.nContent.GetIndex(); } void SwUndoRedlineSort::SetOffset( const SwNodeIndex& rIdx ) { nOffset = rIdx.GetIndex() - nSttNode; } /* */ SwUndoAcceptRedline::SwUndoAcceptRedline( const SwPaM& rRange ) : SwUndoRedline( UNDO_ACCEPT_REDLINE, rRange ) { } void SwUndoAcceptRedline::_Redo( SwUndoIter& rIter ) { rIter.GetDoc().AcceptRedline( *rIter.pAktPam, FALSE ); } void SwUndoAcceptRedline::Repeat( SwUndoIter& rIter ) { rIter.GetDoc().AcceptRedline( *rIter.pAktPam ); } SwUndoRejectRedline::SwUndoRejectRedline( const SwPaM& rRange ) : SwUndoRedline( UNDO_REJECT_REDLINE, rRange ) { } void SwUndoRejectRedline::_Redo( SwUndoIter& rIter ) { rIter.GetDoc().RejectRedline( *rIter.pAktPam, FALSE ); } void SwUndoRejectRedline::Repeat( SwUndoIter& rIter ) { rIter.GetDoc().RejectRedline( *rIter.pAktPam ); } /* */ SwUndoCompDoc::SwUndoCompDoc( const SwPaM& rRg, BOOL bIns ) : SwUndo( UNDO_COMPAREDOC ), SwUndRng( rRg ), pRedlData( 0 ), pUnDel( 0 ), pUnDel2( 0 ), pRedlSaveData( 0 ), bInsert( bIns ) { SwDoc* pDoc = (SwDoc*)rRg.GetDoc(); if( pDoc->IsRedlineOn() ) { SwRedlineType eTyp = bInsert ? REDLINE_INSERT : REDLINE_DELETE; pRedlData = new SwRedlineData( eTyp, pDoc->GetRedlineAuthor() ); SetRedlineMode( pDoc->GetRedlineMode() ); } } SwUndoCompDoc::SwUndoCompDoc( const SwRedline& rRedl ) : SwUndo( UNDO_COMPAREDOC ), SwUndRng( rRedl ), pRedlData( 0 ), pUnDel( 0 ), pUnDel2( 0 ), pRedlSaveData( 0 ), // fuers MergeDoc wird aber der jeweils umgekehrte Zweig benoetigt! bInsert( REDLINE_DELETE == rRedl.GetType() ) { SwDoc* pDoc = (SwDoc*)rRedl.GetDoc(); if( pDoc->IsRedlineOn() ) { pRedlData = new SwRedlineData( rRedl.GetRedlineData() ); SetRedlineMode( pDoc->GetRedlineMode() ); } pRedlSaveData = new SwRedlineSaveDatas; if( !FillSaveData( rRedl, *pRedlSaveData, FALSE, TRUE )) delete pRedlSaveData, pRedlSaveData = 0; } SwUndoCompDoc::~SwUndoCompDoc() { delete pRedlData; delete pUnDel; delete pUnDel2; delete pRedlSaveData; } void SwUndoCompDoc::Undo( SwUndoIter& rIter ) { SwPaM* pPam = rIter.pAktPam; SwDoc* pDoc = pPam->GetDoc(); SetPaM( *pPam ); if( !bInsert ) { // die Redlines loeschen SwRedlineMode eOld = pDoc->GetRedlineMode(); pDoc->SetRedlineMode_intern( ( eOld & ~REDLINE_IGNORE) | REDLINE_ON ); pDoc->DeleteRedline( *pPam ); pDoc->SetRedlineMode_intern( eOld ); //per definition Point is end (in SwUndRng!) SwCntntNode* pCSttNd = pPam->GetCntntNode( FALSE ); SwCntntNode* pCEndNd = pPam->GetCntntNode( TRUE ); // if start- and end-content is zero, then the doc-compare moves // complete nodes into the current doc. And then the selection // must be from end to start, so the delete join into the right // direction. if( !nSttCntnt && !nEndCntnt ) pPam->Exchange(); BOOL bJoinTxt, bJoinPrev; ::lcl_GetJoinFlags( *pPam, bJoinTxt, bJoinPrev ); pUnDel = new SwUndoDelete( *pPam, FALSE ); if( bJoinTxt ) ::lcl_JoinText( *pPam, bJoinPrev ); if( pCSttNd && !pCEndNd) { // #112139# Do not step behind the end of content. SwNode * pTmp = pPam->GetNode(TRUE); if (pTmp) { SwNode * pEnd = pDoc->GetNodes().DocumentSectionEndNode(pTmp); if (pTmp != pEnd) { pPam->SetMark(); pPam->GetPoint()->nNode++; pPam->GetBound( TRUE ).nContent.Assign( 0, 0 ); pPam->GetBound( FALSE ).nContent.Assign( 0, 0 ); pUnDel2 = new SwUndoDelete( *pPam, TRUE ); } } } pPam->DeleteMark(); } else { if( IsRedlineOn( GetRedlineMode() )) { pDoc->DeleteRedline( *pPam ); if( pRedlSaveData ) SetSaveData( *pDoc, *pRedlSaveData ); } SetPaM( rIter, TRUE ); } } void SwUndoCompDoc::Redo( SwUndoIter& rIter ) { // setze noch den Cursor auf den Redo-Bereich SwPaM* pPam = rIter.pAktPam; SwDoc* pDoc = pPam->GetDoc(); rIter.pLastUndoObj = 0; if( bInsert ) { SetPaM( *pPam ); if( pRedlData && IsRedlineOn( GetRedlineMode() )) { SwRedline* pTmp = new SwRedline( *pRedlData, *pPam ); ((SwRedlineTbl&)pDoc->GetRedlineTbl()).Insert( pTmp ); pTmp->InvalidateRange(); /* SwRedlineMode eOld = pDoc->GetRedlineMode(); pDoc->SetRedlineMode_intern( eOld & ~REDLINE_IGNORE ); pDoc->AppendRedline( new SwRedline( *pRedlData, *pPam )); pDoc->SetRedlineMode_intern( eOld ); */ } else if( !( REDLINE_IGNORE & GetRedlineMode() ) && pDoc->GetRedlineTbl().Count() ) pDoc->SplitRedline( *pPam ); } else { // SwRedlineMode eOld = pDoc->GetRedlineMode(); // pDoc->SetRedlineMode_intern( ( eOld & ~REDLINE_IGNORE) | REDLINE_ON ); if( pUnDel2 ) { pUnDel2->Undo( rIter ); delete pUnDel2, pUnDel2 = 0; } pUnDel->Undo( rIter ); delete pUnDel, pUnDel = 0; SetPaM( *pPam ); SwRedline* pTmp = new SwRedline( *pRedlData, *pPam ); ((SwRedlineTbl&)pDoc->GetRedlineTbl()).Insert( pTmp ); if (pTmp) // #i19649# pTmp->InvalidateRange(); // pDoc->SetRedlineMode_intern( eOld ); } SetPaM( rIter, TRUE ); }