/**************************************************************
*
* 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"
#define _SVSTDARR_USHORTS
#define _SVSTDARR_USHORTSSORT
#include <UndoAttribute.hxx>
#include <svl/itemiter.hxx>
#include <editeng/tstpitem.hxx>
#include <svx/svdmodel.hxx>
#include <svx/svdpage.hxx>
#include <hintids.hxx>
#include <fmtflcnt.hxx>
#include <txtftn.hxx>
#include <fmtornt.hxx>
#include <fmtanchr.hxx>
#include <fmtfsize.hxx>
#include <frmfmt.hxx>
#include <fmtcntnt.hxx>
#include <ftnidx.hxx>
#include <doc.hxx>
#include <IDocumentUndoRedo.hxx>
#include <IShellCursorSupplier.hxx>
#include <docary.hxx>
#include <swundo.hxx> // fuer die UndoIds
#include <pam.hxx>
#include <ndtxt.hxx>
#include <swtable.hxx>
#include <swtblfmt.hxx>
#include <UndoCore.hxx>
#include <hints.hxx>
#include <rolbck.hxx>
#include <ndnotxt.hxx>
#include <dcontact.hxx>
#include <ftninfo.hxx>
#include <redline.hxx>
#include <section.hxx>
#include <charfmt.hxx>
#include <switerator.hxx>
// -----------------------------------------------------
SwUndoFmtAttrHelper::SwUndoFmtAttrHelper( SwFmt& rFmt, bool bSvDrwPt )
: SwClient( &rFmt )
, m_pUndo( 0 )
, m_bSaveDrawPt( bSvDrwPt )
{
}
void SwUndoFmtAttrHelper::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew )
{
if( pOld )
{
if ( pOld->Which() == RES_OBJECTDYING )
{
CheckRegistration( pOld, pNew );
}
else if ( pNew )
{
if( POOLATTR_END >= pOld->Which() )
{
if ( GetUndo() )
{
m_pUndo->PutAttr( *pOld );
}
else
{
m_pUndo.reset( new SwUndoFmtAttr( *pOld,
*static_cast<SwFmt*>(GetRegisteredInNonConst()), m_bSaveDrawPt ) );
}
}
else if ( RES_ATTRSET_CHG == pOld->Which() )
{
if ( GetUndo() )
{
SfxItemIter aIter(
*(static_cast<const SwAttrSetChg*>(pOld))->GetChgSet() );
const SfxPoolItem* pItem = aIter.GetCurItem();
while ( pItem )
{
m_pUndo->PutAttr( *pItem );
if( aIter.IsAtEnd() )
break;
pItem = aIter.NextItem();
}
}
else
{
m_pUndo.reset( new SwUndoFmtAttr(
*static_cast<const SwAttrSetChg*>(pOld)->GetChgSet(),
*static_cast<SwFmt*>(GetRegisteredInNonConst()), m_bSaveDrawPt ) );
}
}
}
}
}
// -----------------------------------------------------
SwUndoFmtAttr::SwUndoFmtAttr( const SfxItemSet& rOldSet,
SwFmt& rChgFmt,
bool bSaveDrawPt )
: SwUndo( UNDO_INSFMTATTR )
, m_pFmt( &rChgFmt )
// --> OD 2007-07-11 #i56253#
, m_pOldSet( new SfxItemSet( rOldSet ) )
// <--
, m_nNodeIndex( 0 )
, m_nFmtWhich( rChgFmt.Which() )
, m_bSaveDrawPt( bSaveDrawPt )
{
Init();
}
SwUndoFmtAttr::SwUndoFmtAttr( const SfxPoolItem& rItem, SwFmt& rChgFmt,
bool bSaveDrawPt )
: SwUndo( UNDO_INSFMTATTR )
, m_pFmt( &rChgFmt )
, m_pOldSet( m_pFmt->GetAttrSet().Clone( sal_False ) )
, m_nNodeIndex( 0 )
, m_nFmtWhich( rChgFmt.Which() )
, m_bSaveDrawPt( bSaveDrawPt )
{
m_pOldSet->Put( rItem );
Init();
}
void SwUndoFmtAttr::Init()
{
// treat change of anchor specially
if ( SFX_ITEM_SET == m_pOldSet->GetItemState( RES_ANCHOR, sal_False ))
{
SaveFlyAnchor( m_bSaveDrawPt );
}
else if ( RES_FRMFMT == m_nFmtWhich )
{
SwDoc* pDoc = m_pFmt->GetDoc();
if (USHRT_MAX != pDoc->GetTblFrmFmts()->GetPos(
static_cast<const SwFrmFmtPtr>(m_pFmt)))
{
// Table Format: save table position, table formats are volatile!
SwTable * pTbl = SwIterator<SwTable,SwFmt>::FirstElement( *m_pFmt );
if ( pTbl )
{
m_nNodeIndex = pTbl->GetTabSortBoxes()[ 0 ]->GetSttNd()
->FindTableNode()->GetIndex();
}
}
else if (USHRT_MAX != pDoc->GetSections().GetPos(
static_cast<const SwSectionFmtPtr>(m_pFmt)))
{
m_nNodeIndex = m_pFmt->GetCntnt().GetCntntIdx()->GetIndex();
}
else if ( 0 != dynamic_cast< SwTableBoxFmt* >( m_pFmt ) )
{
SwTableBox * pTblBox = SwIterator<SwTableBox,SwFmt>::FirstElement( *m_pFmt );
if ( pTblBox )
{
m_nNodeIndex = pTblBox->GetSttIdx();
}
}
}
}
SwUndoFmtAttr::~SwUndoFmtAttr()
{
}
void SwUndoFmtAttr::UndoImpl(::sw::UndoRedoContext & rContext)
{
// OD 2004-10-26 #i35443#
// Important note: <Undo(..)> also called by <ReDo(..)>
if ( !m_pOldSet.get() || !m_pFmt || !IsFmtInDoc( &rContext.GetDoc() ))
return;
// --> OD 2004-10-26 #i35443# - If anchor attribute has been successfull
// restored, all other attributes are also restored.
// Thus, keep track of its restoration
bool bAnchorAttrRestored( false );
if ( SFX_ITEM_SET == m_pOldSet->GetItemState( RES_ANCHOR, sal_False ))
{
bAnchorAttrRestored = RestoreFlyAnchor(rContext);
if ( bAnchorAttrRestored )
{
// Anchor attribute successfull restored.
// Thus, keep anchor position for redo
SaveFlyAnchor();
}
else
{
// Anchor attribute not restored due to invalid anchor position.
// Thus, delete anchor attribute.
m_pOldSet->ClearItem( RES_ANCHOR );
}
}
if ( !bAnchorAttrRestored )
// <--
{
SwUndoFmtAttrHelper aTmp( *m_pFmt, m_bSaveDrawPt );
m_pFmt->SetFmtAttr( *m_pOldSet );
if ( aTmp.GetUndo() )
{
// transfer ownership of helper object's old set
m_pOldSet = aTmp.GetUndo()->m_pOldSet;
}
else
{
m_pOldSet->ClearItem();
}
if ( RES_FLYFRMFMT == m_nFmtWhich || RES_DRAWFRMFMT == m_nFmtWhich )
{
rContext.SetSelections(static_cast<SwFrmFmt*>(m_pFmt), 0);
}
}
}
bool SwUndoFmtAttr::IsFmtInDoc( SwDoc* pDoc )
{
// search for the Format in the Document; if it does not exist any more,
// the attribute is not restored!
sal_uInt16 nPos = USHRT_MAX;
switch ( m_nFmtWhich )
{
case RES_TXTFMTCOLL:
nPos = pDoc->GetTxtFmtColls()->GetPos(
static_cast<const SwTxtFmtCollPtr>(m_pFmt) );
break;
case RES_GRFFMTCOLL:
nPos = pDoc->GetGrfFmtColls()->GetPos(
static_cast<const SwGrfFmtCollPtr>(m_pFmt) );
break;
case RES_CHRFMT:
nPos = pDoc->GetCharFmts()->GetPos(
static_cast<SwCharFmtPtr>(m_pFmt) );
break;
case RES_FRMFMT:
if ( m_nNodeIndex && (m_nNodeIndex < pDoc->GetNodes().Count()) )
{
SwNode* pNd = pDoc->GetNodes()[ m_nNodeIndex ];
if ( pNd->IsTableNode() )
{
m_pFmt =
static_cast<SwTableNode*>(pNd)->GetTable().GetFrmFmt();
nPos = 0;
break;
}
else if ( pNd->IsSectionNode() )
{
m_pFmt =
static_cast<SwSectionNode*>(pNd)->GetSection().GetFmt();
nPos = 0;
break;
}
else if ( pNd->IsStartNode() && (SwTableBoxStartNode ==
static_cast< SwStartNode* >(pNd)->GetStartNodeType()) )
{
SwTableNode* pTblNode = pNd->FindTableNode();
if ( pTblNode )
{
SwTableBox* pBox =
pTblNode->GetTable().GetTblBox( m_nNodeIndex );
if ( pBox )
{
m_pFmt = pBox->GetFrmFmt();
nPos = 0;
break;
}
}
}
}
// no break!
case RES_DRAWFRMFMT:
case RES_FLYFRMFMT:
nPos = pDoc->GetSpzFrmFmts()->GetPos(
static_cast<const SwFrmFmtPtr>(m_pFmt) );
if ( USHRT_MAX == nPos )
{
nPos = pDoc->GetFrmFmts()->GetPos(
static_cast<const SwFrmFmtPtr>(m_pFmt) );
}
break;
}
if ( USHRT_MAX == nPos )
{
// Format does not exist; reset
m_pFmt = 0;
}
return 0 != m_pFmt;
}
// prueft, ob es noch im Doc ist!
SwFmt* SwUndoFmtAttr::GetFmt( SwDoc& rDoc )
{
return m_pFmt && IsFmtInDoc( &rDoc ) ? m_pFmt : 0;
}
void SwUndoFmtAttr::RedoImpl(::sw::UndoRedoContext & rContext)
{
// --> OD 2004-10-26 #i35443# - Because the undo stores the attributes for
// redo, the same code as for <Undo(..)> can be applied for <Redo(..)>
UndoImpl(rContext);
// <--
}
void SwUndoFmtAttr::RepeatImpl(::sw::RepeatContext & rContext)
{
if ( !m_pOldSet.get() )
return;
SwDoc & rDoc(rContext.GetDoc());
switch ( m_nFmtWhich )
{
case RES_GRFFMTCOLL:
{
SwNoTxtNode *const pNd =
rContext.GetRepeatPaM().GetNode()->GetNoTxtNode();
if( pNd )
{
rDoc.SetAttr( m_pFmt->GetAttrSet(), *pNd->GetFmtColl() );
}
}
break;
case RES_TXTFMTCOLL:
{
SwTxtNode *const pNd =
rContext.GetRepeatPaM().GetNode()->GetTxtNode();
if( pNd )
{
rDoc.SetAttr( m_pFmt->GetAttrSet(), *pNd->GetFmtColl() );
}
}
break;
// case RES_CHRFMT:
// case RES_FRMFMT:
case RES_FLYFRMFMT:
{
// erstal pruefen, ob der Cursor ueberhaupt in einem fliegenden
// Rahmen steht. Der Weg ist: suche in allen FlyFrmFormaten
// nach dem FlyCntnt-Attribut und teste ob der Cursor in der
// entsprechenden Section liegt.
SwFrmFmt *const pFly =
rContext.GetRepeatPaM().GetNode()->GetFlyFmt();
if( pFly )
{
// Bug 43672: es duerfen nicht alle Attribute gesetzt werden!
if (SFX_ITEM_SET ==
m_pFmt->GetAttrSet().GetItemState( RES_CNTNT ))
{
SfxItemSet aTmpSet( m_pFmt->GetAttrSet() );
aTmpSet.ClearItem( RES_CNTNT );
if( aTmpSet.Count() )
{
rDoc.SetAttr( aTmpSet, *pFly );
}
}
else
{
rDoc.SetAttr( m_pFmt->GetAttrSet(), *pFly );
}
}
break;
}
}
}
SwRewriter SwUndoFmtAttr::GetRewriter() const
{
SwRewriter aRewriter;
if (m_pFmt)
{
aRewriter.AddRule(UNDO_ARG1, m_pFmt->GetName());
}
return aRewriter;
}
void SwUndoFmtAttr::PutAttr( const SfxPoolItem& rItem )
{
m_pOldSet->Put( rItem );
if ( RES_ANCHOR == rItem.Which() )
{
SaveFlyAnchor( m_bSaveDrawPt );
}
}
void SwUndoFmtAttr::SaveFlyAnchor( bool bSvDrwPt )
{
// das Format ist gueltig, sonst wuerde man gar bis hier kommen
if( bSvDrwPt )
{
if ( RES_DRAWFRMFMT == m_pFmt->Which() )
{
Point aPt( static_cast<SwFrmFmt*>(m_pFmt)->FindSdrObject()
->GetRelativePos() );
// store old value as attribute, to keep SwUndoFmtAttr small
m_pOldSet->Put( SwFmtFrmSize( ATT_VAR_SIZE, aPt.X(), aPt.Y() ) );
}
/* else
{
pOldSet->Put( pFmt->GetVertOrient() );
pOldSet->Put( pFmt->GetHoriOrient() );
}
*/ }
const SwFmtAnchor& rAnchor =
static_cast<const SwFmtAnchor&>( m_pOldSet->Get( RES_ANCHOR, sal_False ) );
if( !rAnchor.GetCntntAnchor() )
return;
xub_StrLen nCntnt = 0;
switch( rAnchor.GetAnchorId() )
{
case FLY_AS_CHAR:
case FLY_AT_CHAR:
nCntnt = rAnchor.GetCntntAnchor()->nContent.GetIndex();
case FLY_AT_PARA:
case FLY_AT_FLY:
m_nNodeIndex = rAnchor.GetCntntAnchor()->nNode.GetIndex();
break;
default:
return;
}
SwFmtAnchor aAnchor( rAnchor.GetAnchorId(), nCntnt );
m_pOldSet->Put( aAnchor );
}
// --> OD 2004-10-26 #i35443# - Add return value, type <bool>.
// Return value indicates, if anchor attribute is restored.
// Note: If anchor attribute is restored, all other existing attributes
// are also restored.
bool SwUndoFmtAttr::RestoreFlyAnchor(::sw::UndoRedoContext & rContext)
{
SwDoc *const pDoc = & rContext.GetDoc();
SwFlyFrmFmt* pFrmFmt = static_cast<SwFlyFrmFmt*>(m_pFmt);
const SwFmtAnchor& rAnchor =
static_cast<const SwFmtAnchor&>( m_pOldSet->Get( RES_ANCHOR, sal_False ) );
SwFmtAnchor aNewAnchor( rAnchor.GetAnchorId() );
if (FLY_AT_PAGE != rAnchor.GetAnchorId())
{
SwNode* pNd = pDoc->GetNodes()[ m_nNodeIndex ];
if ( (FLY_AT_FLY == rAnchor.GetAnchorId())
? ( !pNd->IsStartNode() || (SwFlyStartNode !=
static_cast<SwStartNode*>(pNd)->GetStartNodeType()) )
: !pNd->IsTxtNode() )
{
// --> OD 2004-10-26 #i35443# - invalid position.
// Thus, anchor attribute not restored
return false;
// <--
}
SwPosition aPos( *pNd );
if ((FLY_AS_CHAR == rAnchor.GetAnchorId()) ||
(FLY_AT_CHAR == rAnchor.GetAnchorId()))
{
aPos.nContent.Assign( (SwTxtNode*)pNd, rAnchor.GetPageNum() );
if ( aPos.nContent.GetIndex() >
static_cast<SwTxtNode*>(pNd)->GetTxt().Len() )
{
// --> OD 2004-10-26 #i35443# - invalid position.
// Thus, anchor attribute not restored
return false;
// <--
}
}
aNewAnchor.SetAnchor( &aPos );
}
else
aNewAnchor.SetPageNum( rAnchor.GetPageNum() );
Point aDrawSavePt, aDrawOldPt;
if( pDoc->GetCurrentViewShell() ) //swmod 071108//swmod 071225
{
if( RES_DRAWFRMFMT == pFrmFmt->Which() )
{
// den alten zwischengespeicherten Wert herausholen.
const SwFmtFrmSize& rOldSize = static_cast<const SwFmtFrmSize&>(
m_pOldSet->Get( RES_FRM_SIZE ) );
aDrawSavePt.X() = rOldSize.GetWidth();
aDrawSavePt.Y() = rOldSize.GetHeight();
m_pOldSet->ClearItem( RES_FRM_SIZE );
// den akt. wieder zwischenspeichern
aDrawOldPt = pFrmFmt->FindSdrObject()->GetRelativePos();
//JP 08.10.97: ist laut AMA/MA nicht mehr noetig
// pCont->DisconnectFromLayout();
}
else
{
pFrmFmt->DelFrms(); // delete Frms
}
}
const SwFmtAnchor &rOldAnch = pFrmFmt->GetAnchor();
// --> OD 2006-03-13 #i54336#
// Consider case, that as-character anchored object has moved its anchor position.
if (FLY_AS_CHAR == rOldAnch.GetAnchorId())
// <--
{
//Bei InCntnt's wird es spannend: Das TxtAttribut muss vernichtet
//werden. Leider reisst dies neben den Frms auch noch das Format mit
//in sein Grab. Um dass zu unterbinden loesen wir vorher die
//Verbindung zwischen Attribut und Format.
const SwPosition *pPos = rOldAnch.GetCntntAnchor();
SwTxtNode *pTxtNode = (SwTxtNode*)&pPos->nNode.GetNode();
ASSERT( pTxtNode->HasHints(), "Missing FlyInCnt-Hint." );
const xub_StrLen nIdx = pPos->nContent.GetIndex();
SwTxtAttr * const pHnt =
pTxtNode->GetTxtAttrForCharAt( nIdx, RES_TXTATR_FLYCNT );
ASSERT( pHnt && pHnt->Which() == RES_TXTATR_FLYCNT,
"Missing FlyInCnt-Hint." );
ASSERT( pHnt && pHnt->GetFlyCnt().GetFrmFmt() == pFrmFmt,
"Wrong TxtFlyCnt-Hint." );
const_cast<SwFmtFlyCnt&>(pHnt->GetFlyCnt()).SetFlyFmt();
//Die Verbindung ist geloest, jetzt muss noch das Attribut vernichtet
//werden.
pTxtNode->DeleteAttributes( RES_TXTATR_FLYCNT, nIdx, nIdx );
}
{
m_pOldSet->Put( aNewAnchor );
SwUndoFmtAttrHelper aTmp( *m_pFmt, m_bSaveDrawPt );
m_pFmt->SetFmtAttr( *m_pOldSet );
if ( aTmp.GetUndo() )
{
m_nNodeIndex = aTmp.GetUndo()->m_nNodeIndex;
// transfer ownership of helper object's old set
m_pOldSet = aTmp.GetUndo()->m_pOldSet;
}
else
{
m_pOldSet->ClearItem();
}
}
if ( RES_DRAWFRMFMT == pFrmFmt->Which() )
{
SwDrawContact *pCont =
static_cast<SwDrawContact*>(pFrmFmt->FindContactObj());
// das Draw-Model hat auch noch ein Undo-Object fuer die
// richtige Position vorbereitet; dieses ist aber relativ.
// Darum verhinder hier, das durch setzen des Ankers das
// Contact-Object seine Position aendert.
//JP 08.10.97: ist laut AMA/MA nicht mehr noetig
// pCont->ConnectToLayout();
SdrObject* pObj = pCont->GetMaster();
if( pCont->GetAnchorFrm() && !pObj->IsInserted() )
{
ASSERT( pDoc->GetDrawModel(), "RestoreFlyAnchor without DrawModel" );
pDoc->GetDrawModel()->GetPage( 0 )->InsertObject( pObj );
}
pObj->SetRelativePos( aDrawSavePt );
// den alten Wert wieder zwischenspeichern.
m_pOldSet->Put(
SwFmtFrmSize( ATT_VAR_SIZE, aDrawOldPt.X(), aDrawOldPt.Y() ) );
}
if (FLY_AS_CHAR == aNewAnchor.GetAnchorId())
{
const SwPosition* pPos = aNewAnchor.GetCntntAnchor();
SwTxtNode* pTxtNd = pPos->nNode.GetNode().GetTxtNode();
ASSERT( pTxtNd, "no Text Node at position." );
SwFmtFlyCnt aFmt( pFrmFmt );
pTxtNd->InsertItem( aFmt, pPos->nContent.GetIndex(), 0 );
}
if( RES_DRAWFRMFMT != pFrmFmt->Which() )
pFrmFmt->MakeFrms();
rContext.SetSelections(pFrmFmt, 0);
// --> OD 2004-10-26 #i35443# - anchor attribute restored.
return true;
// <--
}
// -----------------------------------------------------
// --> OD 2008-02-12 #newlistlevelattrs#
SwUndoFmtResetAttr::SwUndoFmtResetAttr( SwFmt& rChangedFormat,
const sal_uInt16 nWhichId )
: SwUndo( UNDO_RESETATTR )
, m_pChangedFormat( &rChangedFormat )
, m_nWhichId( nWhichId )
, m_pOldItem( 0 )
{
const SfxPoolItem* pItem = 0;
if (rChangedFormat.GetItemState( nWhichId, sal_False, &pItem ) == SFX_ITEM_SET)
{
m_pOldItem.reset( pItem->Clone() );
}
}
SwUndoFmtResetAttr::~SwUndoFmtResetAttr()
{
}
void SwUndoFmtResetAttr::UndoImpl(::sw::UndoRedoContext &)
{
if ( m_pOldItem.get() )
{
m_pChangedFormat->SetFmtAttr( *m_pOldItem );
}
}
void SwUndoFmtResetAttr::RedoImpl(::sw::UndoRedoContext &)
{
if ( m_pOldItem.get() )
{
m_pChangedFormat->ResetFmtAttr( m_nWhichId );
}
}
// <--
// -----------------------------------------------------
SwUndoResetAttr::SwUndoResetAttr( const SwPaM& rRange, sal_uInt16 nFmtId )
: SwUndo( UNDO_RESETATTR ), SwUndRng( rRange )
, m_pHistory( new SwHistory )
, m_nFormatId( nFmtId )
{
}
SwUndoResetAttr::SwUndoResetAttr( const SwPosition& rPos, sal_uInt16 nFmtId )
: SwUndo( UNDO_RESETATTR )
, m_pHistory( new SwHistory )
, m_nFormatId( nFmtId )
{
nSttNode = nEndNode = rPos.nNode.GetIndex();
nSttCntnt = nEndCntnt = rPos.nContent.GetIndex();
}
SwUndoResetAttr::~SwUndoResetAttr()
{
}
void SwUndoResetAttr::UndoImpl(::sw::UndoRedoContext & rContext)
{
// reset old values
SwDoc & rDoc = rContext.GetDoc();
m_pHistory->TmpRollback( &rDoc, 0 );
m_pHistory->SetTmpEnd( m_pHistory->Count() );
if ((RES_CONDTXTFMTCOLL == m_nFormatId) &&
(nSttNode == nEndNode) && (nSttCntnt == nEndCntnt))
{
SwTxtNode* pTNd = rDoc.GetNodes()[ nSttNode ]->GetTxtNode();
if( pTNd )
{
SwIndex aIdx( pTNd, nSttCntnt );
pTNd->DontExpandFmt( aIdx, sal_False );
}
}
AddUndoRedoPaM(rContext);
}
void SwUndoResetAttr::RedoImpl(::sw::UndoRedoContext & rContext)
{
SwDoc & rDoc = rContext.GetDoc();
SwPaM & rPam = AddUndoRedoPaM(rContext);
SvUShortsSort* pIdArr = m_Ids.Count() ? &m_Ids : 0;
switch ( m_nFormatId )
{
case RES_CHRFMT:
rDoc.RstTxtAttrs(rPam);
break;
case RES_TXTFMTCOLL:
rDoc.ResetAttrs(rPam, sal_False, pIdArr );
break;
case RES_CONDTXTFMTCOLL:
rDoc.ResetAttrs(rPam, sal_True, pIdArr );
break;
case RES_TXTATR_TOXMARK:
// special treatment for TOXMarks
{
SwTOXMarks aArr;
SwNodeIndex aIdx( rDoc.GetNodes(), nSttNode );
SwPosition aPos( aIdx, SwIndex( aIdx.GetNode().GetCntntNode(),
nSttCntnt ));
sal_uInt16 nCnt = rDoc.GetCurTOXMark( aPos, aArr );
if( nCnt )
{
if( 1 < nCnt )
{
// search for the right one
SwHistoryHint* pHHint = (GetHistory())[ 0 ];
if( pHHint && HSTRY_SETTOXMARKHNT == pHHint->Which() )
{
while( nCnt )
{
if ( static_cast<SwHistorySetTOXMark*>(pHHint)
->IsEqual( *aArr[ --nCnt ] ) )
{
++nCnt;
break;
}
}
}
else
nCnt = 0;
}
// gefunden, also loeschen
if( nCnt-- )
{
rDoc.DeleteTOXMark( aArr[ nCnt ] );
}
}
}
break;
}
}
void SwUndoResetAttr::RepeatImpl(::sw::RepeatContext & rContext)
{
if (m_nFormatId < RES_FMT_BEGIN)
{
return;
}
SvUShortsSort* pIdArr = m_Ids.Count() ? &m_Ids : 0;
switch ( m_nFormatId )
{
case RES_CHRFMT:
rContext.GetDoc().RstTxtAttrs(rContext.GetRepeatPaM());
break;
case RES_TXTFMTCOLL:
rContext.GetDoc().ResetAttrs(rContext.GetRepeatPaM(), false, pIdArr);
break;
case RES_CONDTXTFMTCOLL:
rContext.GetDoc().ResetAttrs(rContext.GetRepeatPaM(), true, pIdArr);
break;
}
}
void SwUndoResetAttr::SetAttrs( const SvUShortsSort& rArr )
{
if ( m_Ids.Count() )
{
m_Ids.Remove( 0, m_Ids.Count() );
}
m_Ids.Insert( &rArr );
}
// -----------------------------------------------------
SwUndoAttr::SwUndoAttr( const SwPaM& rRange, const SfxPoolItem& rAttr,
const SetAttrMode nFlags )
: SwUndo( UNDO_INSATTR ), SwUndRng( rRange )
, m_AttrSet( rRange.GetDoc()->GetAttrPool(), rAttr.Which(), rAttr.Which() )
, m_pHistory( new SwHistory )
, m_pRedlineData( 0 )
, m_pRedlineSaveData( 0 )
, m_nNodeIndex( ULONG_MAX )
, m_nInsertFlags( nFlags )
{
m_AttrSet.Put( rAttr );
}
SwUndoAttr::SwUndoAttr( const SwPaM& rRange, const SfxItemSet& rSet,
const SetAttrMode nFlags )
: SwUndo( UNDO_INSATTR ), SwUndRng( rRange )
, m_AttrSet( rSet )
, m_pHistory( new SwHistory )
, m_pRedlineData( 0 )
, m_pRedlineSaveData( 0 )
, m_nNodeIndex( ULONG_MAX )
, m_nInsertFlags( nFlags )
{
}
SwUndoAttr::~SwUndoAttr()
{
}
void SwUndoAttr::SaveRedlineData( const SwPaM& rPam, sal_Bool bIsCntnt )
{
SwDoc* pDoc = rPam.GetDoc();
if ( pDoc->IsRedlineOn() )
{
m_pRedlineData.reset( new SwRedlineData( bIsCntnt
? nsRedlineType_t::REDLINE_INSERT
: nsRedlineType_t::REDLINE_FORMAT,
pDoc->GetRedlineAuthor() ) );
}
m_pRedlineSaveData.reset( new SwRedlineSaveDatas );
if ( !FillSaveDataForFmt( rPam, *m_pRedlineSaveData ))
{
m_pRedlineSaveData.reset(0);
}
SetRedlineMode( pDoc->GetRedlineMode() );
if ( bIsCntnt )
{
m_nNodeIndex = rPam.GetPoint()->nNode.GetIndex();
}
}
void SwUndoAttr::UndoImpl(::sw::UndoRedoContext & rContext)
{
SwDoc *const pDoc = & rContext.GetDoc();
RemoveIdx( *pDoc );
if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ) )
{
SwPaM aPam(pDoc->GetNodes().GetEndOfContent());
if ( ULONG_MAX != m_nNodeIndex )
{
aPam.DeleteMark();
aPam.GetPoint()->nNode = m_nNodeIndex;
aPam.GetPoint()->nContent.Assign( aPam.GetCntntNode(), nSttCntnt );
aPam.SetMark();
aPam.GetPoint()->nContent++;
pDoc->DeleteRedline(aPam, false, USHRT_MAX);
}
else
{
// alle Format-Redlines entfernen, werden ggfs. neu gesetzt
SetPaM(aPam);
pDoc->DeleteRedline(aPam, false, nsRedlineType_t::REDLINE_FORMAT);
if ( m_pRedlineSaveData.get() )
{
SetSaveData( *pDoc, *m_pRedlineSaveData );
}
}
}
const bool bToLast = (1 == m_AttrSet.Count())
&& (RES_TXTATR_FIELD <= *m_AttrSet.GetRanges())
&& (*m_AttrSet.GetRanges() <= RES_TXTATR_ANNOTATION);
// restore old values
m_pHistory->TmpRollback( pDoc, 0, !bToLast );
m_pHistory->SetTmpEnd( m_pHistory->Count() );
// set cursor onto Undo area
AddUndoRedoPaM(rContext);
}
void SwUndoAttr::RepeatImpl(::sw::RepeatContext & rContext)
{
// RefMarks are not repeat capable
if ( SFX_ITEM_SET != m_AttrSet.GetItemState( RES_TXTATR_REFMARK, sal_False ) )
{
rContext.GetDoc().InsertItemSet( rContext.GetRepeatPaM(),
m_AttrSet, m_nInsertFlags );
}
else if ( 1 < m_AttrSet.Count() )
{
SfxItemSet aTmpSet( m_AttrSet );
aTmpSet.ClearItem( RES_TXTATR_REFMARK );
rContext.GetDoc().InsertItemSet( rContext.GetRepeatPaM(),
aTmpSet, m_nInsertFlags );
}
}
void SwUndoAttr::RedoImpl(::sw::UndoRedoContext & rContext)
{
SwDoc & rDoc = rContext.GetDoc();
SwPaM & rPam = AddUndoRedoPaM(rContext);
if ( m_pRedlineData.get() &&
IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ) )
{
RedlineMode_t eOld = rDoc.GetRedlineMode();
rDoc.SetRedlineMode_intern(static_cast<RedlineMode_t>(
eOld & ~nsRedlineMode_t::REDLINE_IGNORE));
rDoc.InsertItemSet( rPam, m_AttrSet, m_nInsertFlags );
if ( ULONG_MAX != m_nNodeIndex )
{
rPam.SetMark();
if ( rPam.Move( fnMoveBackward ) )
{
rDoc.AppendRedline( new SwRedline( *m_pRedlineData, rPam ),
true);
}
rPam.DeleteMark();
}
else
{
rDoc.AppendRedline( new SwRedline( *m_pRedlineData, rPam ), true);
}
rDoc.SetRedlineMode_intern( eOld );
}
else
{
rDoc.InsertItemSet( rPam, m_AttrSet, m_nInsertFlags );
}
}
void SwUndoAttr::RemoveIdx( SwDoc& rDoc )
{
if ( SFX_ITEM_SET != m_AttrSet.GetItemState( RES_TXTATR_FTN, sal_False ))
return ;
SwHistoryHint* pHstHnt;
SwNodes& rNds = rDoc.GetNodes();
for ( sal_uInt16 n = 0; n < m_pHistory->Count(); ++n )
{
xub_StrLen nCntnt = 0;
sal_uLong nNode = 0;
pHstHnt = (*m_pHistory)[ n ];
switch ( pHstHnt->Which() )
{
case HSTRY_RESETTXTHNT:
{
SwHistoryResetTxt * pHistoryHint
= static_cast<SwHistoryResetTxt*>(pHstHnt);
if ( RES_TXTATR_FTN == pHistoryHint->GetWhich() )
{
nNode = pHistoryHint->GetNode();
nCntnt = pHistoryHint->GetCntnt();
}
}
break;
case HSTRY_RESETATTRSET:
{
SwHistoryResetAttrSet * pHistoryHint
= static_cast<SwHistoryResetAttrSet*>(pHstHnt);
nCntnt = pHistoryHint->GetCntnt();
if ( STRING_MAXLEN != nCntnt )
{
const SvUShorts& rArr = pHistoryHint->GetArr();
for ( sal_uInt16 i = rArr.Count(); i; )
{
if ( RES_TXTATR_FTN == rArr[ --i ] )
{
nNode = pHistoryHint->GetNode();
break;
}
}
}
}
break;
default:
break;
}
if( nNode )
{
SwTxtNode* pTxtNd = rNds[ nNode ]->GetTxtNode();
if( pTxtNd )
{
SwTxtAttr *const pTxtHt =
pTxtNd->GetTxtAttrForCharAt(nCntnt, RES_TXTATR_FTN);
if( pTxtHt )
{
// ok, dann hole mal die Werte
SwTxtFtn* pFtn = static_cast<SwTxtFtn*>(pTxtHt);
RemoveIdxFromSection( rDoc, pFtn->GetStartNode()->GetIndex() );
return ;
}
}
}
}
}
// -----------------------------------------------------
SwUndoDefaultAttr::SwUndoDefaultAttr( const SfxItemSet& rSet )
: SwUndo( UNDO_SETDEFTATTR )
, m_pOldSet( 0 )
, m_pTabStop( 0 )
{
const SfxPoolItem* pItem;
if( SFX_ITEM_SET == rSet.GetItemState( RES_PARATR_TABSTOP, sal_False, &pItem ) )
{
// store separately, because it may change!
m_pTabStop.reset( static_cast<SvxTabStopItem*>(pItem->Clone()) );
if ( 1 != rSet.Count() ) // are there more attributes?
{
m_pOldSet.reset( new SfxItemSet( rSet ) );
}
}
else
{
m_pOldSet.reset( new SfxItemSet( rSet ) );
}
}
SwUndoDefaultAttr::~SwUndoDefaultAttr()
{
}
void SwUndoDefaultAttr::UndoImpl(::sw::UndoRedoContext & rContext)
{
SwDoc & rDoc = rContext.GetDoc();
if ( m_pOldSet.get() )
{
SwUndoFmtAttrHelper aTmp(
*const_cast<SwTxtFmtColl*>(rDoc.GetDfltTxtFmtColl()) );
rDoc.SetDefault( *m_pOldSet );
m_pOldSet.reset( 0 );
if ( aTmp.GetUndo() )
{
// transfer ownership of helper object's old set
m_pOldSet = aTmp.GetUndo()->m_pOldSet;
}
}
if ( m_pTabStop.get() )
{
SvxTabStopItem* pOld = static_cast<SvxTabStopItem*>(
rDoc.GetDefault( RES_PARATR_TABSTOP ).Clone() );
rDoc.SetDefault( *m_pTabStop );
m_pTabStop.reset( pOld );
}
}
void SwUndoDefaultAttr::RedoImpl(::sw::UndoRedoContext & rContext)
{
UndoImpl(rContext);
}
// -----------------------------------------------------
SwUndoMoveLeftMargin::SwUndoMoveLeftMargin(
const SwPaM& rPam, sal_Bool bFlag, sal_Bool bMod )
: SwUndo( bFlag ? UNDO_INC_LEFTMARGIN : UNDO_DEC_LEFTMARGIN )
, SwUndRng( rPam )
, m_pHistory( new SwHistory )
, m_bModulus( bMod )
{
}
SwUndoMoveLeftMargin::~SwUndoMoveLeftMargin()
{
}
void SwUndoMoveLeftMargin::UndoImpl(::sw::UndoRedoContext & rContext)
{
SwDoc & rDoc = rContext.GetDoc();
// restore old values
m_pHistory->TmpRollback( & rDoc, 0 );
m_pHistory->SetTmpEnd( m_pHistory->Count() );
AddUndoRedoPaM(rContext);
}
void SwUndoMoveLeftMargin::RedoImpl(::sw::UndoRedoContext & rContext)
{
SwDoc & rDoc = rContext.GetDoc();
SwPaM & rPam = AddUndoRedoPaM(rContext);
rDoc.MoveLeftMargin( rPam,
GetId() == UNDO_INC_LEFTMARGIN, m_bModulus );
}
void SwUndoMoveLeftMargin::RepeatImpl(::sw::RepeatContext & rContext)
{
SwDoc & rDoc = rContext.GetDoc();
rDoc.MoveLeftMargin(rContext.GetRepeatPaM(), GetId() == UNDO_INC_LEFTMARGIN,
m_bModulus );
}
// -----------------------------------------------------
SwUndoChangeFootNote::SwUndoChangeFootNote(
const SwPaM& rRange, const String& rTxt,
sal_uInt16 nNum, bool bIsEndNote )
: SwUndo( UNDO_CHGFTN ), SwUndRng( rRange )
, m_pHistory( new SwHistory() )
, m_Text( rTxt )
, m_nNumber( nNum )
, m_bEndNote( bIsEndNote )
{
}
SwUndoChangeFootNote::~SwUndoChangeFootNote()
{
}
void SwUndoChangeFootNote::UndoImpl(::sw::UndoRedoContext & rContext)
{
SwDoc & rDoc = rContext.GetDoc();
m_pHistory->TmpRollback( &rDoc, 0 );
m_pHistory->SetTmpEnd( m_pHistory->Count() );
rDoc.GetFtnIdxs().UpdateAllFtn();
AddUndoRedoPaM(rContext);
}
void SwUndoChangeFootNote::RedoImpl(::sw::UndoRedoContext & rContext)
{
SwDoc & rDoc( rContext.GetDoc() );
SwPaM & rPaM = AddUndoRedoPaM(rContext);
rDoc.SetCurFtn(rPaM, m_Text, m_nNumber, m_bEndNote);
SetPaM(rPaM);
}
void SwUndoChangeFootNote::RepeatImpl(::sw::RepeatContext & rContext)
{
SwDoc & rDoc = rContext.GetDoc();
rDoc.SetCurFtn( rContext.GetRepeatPaM(), m_Text, m_nNumber, m_bEndNote );
}
// -----------------------------------------------------
SwUndoFootNoteInfo::SwUndoFootNoteInfo( const SwFtnInfo &rInfo )
: SwUndo( UNDO_FTNINFO )
, m_pFootNoteInfo( new SwFtnInfo( rInfo ) )
{
}
SwUndoFootNoteInfo::~SwUndoFootNoteInfo()
{
}
void SwUndoFootNoteInfo::UndoImpl(::sw::UndoRedoContext & rContext)
{
SwDoc & rDoc = rContext.GetDoc();
SwFtnInfo *pInf = new SwFtnInfo( rDoc.GetFtnInfo() );
rDoc.SetFtnInfo( *m_pFootNoteInfo );
m_pFootNoteInfo.reset( pInf );
}
void SwUndoFootNoteInfo::RedoImpl(::sw::UndoRedoContext & rContext)
{
SwDoc & rDoc = rContext.GetDoc();
SwFtnInfo *pInf = new SwFtnInfo( rDoc.GetFtnInfo() );
rDoc.SetFtnInfo( *m_pFootNoteInfo );
m_pFootNoteInfo.reset( pInf );
}
// -----------------------------------------------------
SwUndoEndNoteInfo::SwUndoEndNoteInfo( const SwEndNoteInfo &rInfo )
: SwUndo( UNDO_FTNINFO )
, m_pEndNoteInfo( new SwEndNoteInfo( rInfo ) )
{
}
SwUndoEndNoteInfo::~SwUndoEndNoteInfo()
{
}
void SwUndoEndNoteInfo::UndoImpl(::sw::UndoRedoContext & rContext)
{
SwDoc & rDoc = rContext.GetDoc();
SwEndNoteInfo *pInf = new SwEndNoteInfo( rDoc.GetEndNoteInfo() );
rDoc.SetEndNoteInfo( *m_pEndNoteInfo );
m_pEndNoteInfo.reset( pInf );
}
void SwUndoEndNoteInfo::RedoImpl(::sw::UndoRedoContext & rContext)
{
SwDoc & rDoc = rContext.GetDoc();
SwEndNoteInfo *pInf = new SwEndNoteInfo( rDoc.GetEndNoteInfo() );
rDoc.SetEndNoteInfo( *m_pEndNoteInfo );
m_pEndNoteInfo.reset( pInf );
}
// -----------------------------------------------------
SwUndoDontExpandFmt::SwUndoDontExpandFmt( const SwPosition& rPos )
: SwUndo( UNDO_DONTEXPAND )
, m_nNodeIndex( rPos.nNode.GetIndex() )
, m_nContentIndex( rPos.nContent.GetIndex() )
{
}
void SwUndoDontExpandFmt::UndoImpl(::sw::UndoRedoContext & rContext)
{
SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
SwDoc *const pDoc = & rContext.GetDoc();
SwPosition& rPos = *pPam->GetPoint();
rPos.nNode = m_nNodeIndex;
rPos.nContent.Assign( rPos.nNode.GetNode().GetCntntNode(), m_nContentIndex);
pDoc->DontExpandFmt( rPos, sal_False );
}
void SwUndoDontExpandFmt::RedoImpl(::sw::UndoRedoContext & rContext)
{
SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
SwDoc *const pDoc = & rContext.GetDoc();
SwPosition& rPos = *pPam->GetPoint();
rPos.nNode = m_nNodeIndex;
rPos.nContent.Assign( rPos.nNode.GetNode().GetCntntNode(), m_nContentIndex);
pDoc->DontExpandFmt( rPos );
}
void SwUndoDontExpandFmt::RepeatImpl(::sw::RepeatContext & rContext)
{
SwPaM & rPam = rContext.GetRepeatPaM();
SwDoc & rDoc = rContext.GetDoc();
rDoc.DontExpandFmt( *rPam.GetPoint() );
}