/************************************************************** * * 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 #include #include #include "undotab.hxx" #include "document.hxx" #include "docsh.hxx" #include "tabvwsh.hxx" #include "globstr.hrc" #include "global.hxx" #include "sc.hrc" #include "undoolk.hxx" #include "target.hxx" #include "uiitems.hxx" #include "prnsave.hxx" #include "printfun.hxx" #include "chgtrack.hxx" #include "tabprotection.hxx" #include "viewdata.hxx" // for ScUndoRenameObject - might me moved to another file later #include #include #include #include "drwlayer.hxx" #include "scresid.hxx" extern sal_Bool bDrawIsInUndo; //! irgendwo als Member !!! using namespace com::sun::star; using ::com::sun::star::uno::Sequence; using ::std::auto_ptr; // STATIC DATA ----------------------------------------------------------- TYPEINIT1(ScUndoInsertTab, SfxUndoAction); TYPEINIT1(ScUndoInsertTables, SfxUndoAction); TYPEINIT1(ScUndoDeleteTab, SfxUndoAction); TYPEINIT1(ScUndoRenameTab, SfxUndoAction); TYPEINIT1(ScUndoMoveTab, SfxUndoAction); TYPEINIT1(ScUndoCopyTab, SfxUndoAction); TYPEINIT1(ScUndoMakeScenario, SfxUndoAction); TYPEINIT1(ScUndoImportTab, SfxUndoAction); TYPEINIT1(ScUndoRemoveLink, SfxUndoAction); TYPEINIT1(ScUndoShowHideTab, SfxUndoAction); TYPEINIT1(ScUndoPrintRange, SfxUndoAction); TYPEINIT1(ScUndoScenarioFlags, SfxUndoAction); TYPEINIT1(ScUndoRenameObject, SfxUndoAction); TYPEINIT1(ScUndoLayoutRTL, SfxUndoAction); //UNUSED2009-05 TYPEINIT1(ScUndoSetGrammar, SfxUndoAction); TYPEINIT1(ScUndoTabColor, SfxUndoAction); // ----------------------------------------------------------------------- // // Tabelle einfuegen // ScUndoInsertTab::ScUndoInsertTab( ScDocShell* pNewDocShell, SCTAB nTabNum, sal_Bool bApp, const String& rNewName) : ScSimpleUndo( pNewDocShell ), sNewName( rNewName ), pDrawUndo( NULL ), nTab( nTabNum ), bAppend( bApp ) { pDrawUndo = GetSdrUndoAction( pDocShell->GetDocument() ); SetChangeTrack(); } ScUndoInsertTab::~ScUndoInsertTab() { DeleteSdrUndoAction( pDrawUndo ); } String ScUndoInsertTab::GetComment() const { if (bAppend) return ScGlobal::GetRscString( STR_UNDO_APPEND_TAB ); else return ScGlobal::GetRscString( STR_UNDO_INSERT_TAB ); } void ScUndoInsertTab::SetChangeTrack() { ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack(); if ( pChangeTrack ) { ScRange aRange( 0, 0, nTab, MAXCOL, MAXROW, nTab ); pChangeTrack->AppendInsert( aRange ); nEndChangeAction = pChangeTrack->GetActionMax(); } else nEndChangeAction = 0; } void ScUndoInsertTab::Undo() { ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell(); pViewShell->SetTabNo(nTab); pDocShell->SetInUndo( sal_True ); //! BeginUndo bDrawIsInUndo = sal_True; pViewShell->DeleteTable( nTab, sal_False ); bDrawIsInUndo = sal_False; pDocShell->SetInUndo( sal_False ); //! EndUndo DoSdrUndoAction( pDrawUndo, pDocShell->GetDocument() ); ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack(); if ( pChangeTrack ) pChangeTrack->Undo( nEndChangeAction, nEndChangeAction ); // SetTabNo(...,sal_True) for all views to sync with drawing layer pages pDocShell->Broadcast( SfxSimpleHint( SC_HINT_FORCESETTAB ) ); } void ScUndoInsertTab::Redo() { ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell(); RedoSdrUndoAction( pDrawUndo ); // Draw Redo first pDocShell->SetInUndo( sal_True ); //! BeginRedo bDrawIsInUndo = sal_True; if (bAppend) pViewShell->AppendTable( sNewName, sal_False ); else { pViewShell->SetTabNo(nTab); pViewShell->InsertTable( sNewName, nTab, sal_False ); } bDrawIsInUndo = sal_False; pDocShell->SetInUndo( sal_False ); //! EndRedo SetChangeTrack(); } void ScUndoInsertTab::Repeat(SfxRepeatTarget& rTarget) { if (rTarget.ISA(ScTabViewTarget)) ((ScTabViewTarget&)rTarget).GetViewShell()->GetViewData()->GetDispatcher(). Execute(FID_INS_TABLE, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD); } sal_Bool ScUndoInsertTab::CanRepeat(SfxRepeatTarget& rTarget) const { return (rTarget.ISA(ScTabViewTarget)); } // ----------------------------------------------------------------------- // // Tabellen einfuegen // ScUndoInsertTables::ScUndoInsertTables( ScDocShell* pNewDocShell, SCTAB nTabNum, sal_Bool bApp,SvStrings *pNewNameList) : ScSimpleUndo( pNewDocShell ), pDrawUndo( NULL ), nTab( nTabNum ), bAppend( bApp ) { pNameList = pNewNameList; pDrawUndo = GetSdrUndoAction( pDocShell->GetDocument() ); SetChangeTrack(); } ScUndoInsertTables::~ScUndoInsertTables() { String *pStr=NULL; if(pNameList!=NULL) { for(int i=0;iCount();i++) { pStr=pNameList->GetObject(sal::static_int_cast(i)); delete pStr; } pNameList->Remove(0,pNameList->Count()); delete pNameList; } DeleteSdrUndoAction( pDrawUndo ); } String ScUndoInsertTables::GetComment() const { return ScGlobal::GetRscString( STR_UNDO_INSERT_TAB ); } void ScUndoInsertTables::SetChangeTrack() { ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack(); if ( pChangeTrack ) { nStartChangeAction = pChangeTrack->GetActionMax() + 1; nEndChangeAction = 0; ScRange aRange( 0, 0, nTab, MAXCOL, MAXROW, nTab ); for( int i = 0; i < pNameList->Count(); i++ ) { aRange.aStart.SetTab( sal::static_int_cast( nTab + i ) ); aRange.aEnd.SetTab( sal::static_int_cast( nTab + i ) ); pChangeTrack->AppendInsert( aRange ); nEndChangeAction = pChangeTrack->GetActionMax(); } } else nStartChangeAction = nEndChangeAction = 0; } void ScUndoInsertTables::Undo() { ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell(); pViewShell->SetTabNo(nTab); pDocShell->SetInUndo( sal_True ); //! BeginUndo bDrawIsInUndo = sal_True; SvShorts TheTabs; for(int i=0;iCount();i++) { TheTabs.push_back( sal::static_int_cast(nTab+i) ); } pViewShell->DeleteTables( TheTabs, sal_False ); TheTabs.clear(); bDrawIsInUndo = sal_False; pDocShell->SetInUndo( sal_False ); //! EndUndo DoSdrUndoAction( pDrawUndo, pDocShell->GetDocument() ); ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack(); if ( pChangeTrack ) pChangeTrack->Undo( nStartChangeAction, nEndChangeAction ); // SetTabNo(...,sal_True) for all views to sync with drawing layer pages pDocShell->Broadcast( SfxSimpleHint( SC_HINT_FORCESETTAB ) ); } void ScUndoInsertTables::Redo() { ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell(); RedoSdrUndoAction( pDrawUndo ); // Draw Redo first pDocShell->SetInUndo( sal_True ); //! BeginRedo bDrawIsInUndo = sal_True; pViewShell->SetTabNo(nTab); pViewShell->InsertTables( pNameList, nTab, static_cast(pNameList->Count()),sal_False ); bDrawIsInUndo = sal_False; pDocShell->SetInUndo( sal_False ); //! EndRedo SetChangeTrack(); } void ScUndoInsertTables::Repeat(SfxRepeatTarget& rTarget) { if (rTarget.ISA(ScTabViewTarget)) ((ScTabViewTarget&)rTarget).GetViewShell()->GetViewData()->GetDispatcher(). Execute(FID_INS_TABLE, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD); } sal_Bool ScUndoInsertTables::CanRepeat(SfxRepeatTarget& rTarget) const { return (rTarget.ISA(ScTabViewTarget)); } //---------------------------------------------------------------------------------- // // Tabelle loeschen // ScUndoDeleteTab::ScUndoDeleteTab( ScDocShell* pNewDocShell,const SvShorts &aTab, //SCTAB nNewTab, ScDocument* pUndoDocument, ScRefUndoData* pRefData ) : ScMoveUndo( pNewDocShell, pUndoDocument, pRefData, SC_UNDO_REFLAST ) { theTabs=aTab; SetChangeTrack(); } ScUndoDeleteTab::~ScUndoDeleteTab() { theTabs.clear(); } String ScUndoDeleteTab::GetComment() const { return ScGlobal::GetRscString( STR_UNDO_DELETE_TAB ); } void ScUndoDeleteTab::SetChangeTrack() { ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack(); if ( pChangeTrack ) { sal_uLong nTmpChangeAction; nStartChangeAction = pChangeTrack->GetActionMax() + 1; nEndChangeAction = 0; ScRange aRange( 0, 0, 0, MAXCOL, MAXROW, 0 ); for ( size_t i = 0; i < theTabs.size(); i++ ) { aRange.aStart.SetTab( theTabs[sal::static_int_cast(i)] ); aRange.aEnd.SetTab( theTabs[sal::static_int_cast(i)] ); pChangeTrack->AppendDeleteRange( aRange, pRefUndoDoc, nTmpChangeAction, nEndChangeAction, (short) i ); } } else nStartChangeAction = nEndChangeAction = 0; } SCTAB lcl_GetVisibleTabBefore( ScDocument& rDoc, SCTAB nTab ) { while ( nTab > 0 && !rDoc.IsVisible( nTab ) ) --nTab; return nTab; } void ScUndoDeleteTab::Undo() { BeginUndo(); size_t i=0; ScDocument* pDoc = pDocShell->GetDocument(); sal_Bool bLink = sal_False; String aName; for(i=0;i(i)]; pRefUndoDoc->GetName( nTab, aName ); bDrawIsInUndo = sal_True; sal_Bool bOk = pDoc->InsertTab( nTab, aName ); bDrawIsInUndo = sal_False; if (bOk) { // Ref-Undo passiert in EndUndo // pUndoDoc->UndoToDocument(0,0,nTab, MAXCOL,MAXROW,nTab, IDF_ALL,sal_False, pDoc ); pRefUndoDoc->CopyToDocument(0,0,nTab, MAXCOL,MAXROW,nTab, IDF_ALL,sal_False, pDoc ); String aOldName; pRefUndoDoc->GetName( nTab, aOldName ); pDoc->RenameTab( nTab, aOldName, sal_False ); if (pRefUndoDoc->IsLinked(nTab)) { pDoc->SetLink( nTab, pRefUndoDoc->GetLinkMode(nTab), pRefUndoDoc->GetLinkDoc(nTab), pRefUndoDoc->GetLinkFlt(nTab), pRefUndoDoc->GetLinkOpt(nTab), pRefUndoDoc->GetLinkTab(nTab), pRefUndoDoc->GetLinkRefreshDelay(nTab) ); bLink = sal_True; } if ( pRefUndoDoc->IsScenario(nTab) ) { pDoc->SetScenario( nTab, sal_True ); String aComment; Color aColor; sal_uInt16 nScenFlags; pRefUndoDoc->GetScenarioData( nTab, aComment, aColor, nScenFlags ); pDoc->SetScenarioData( nTab, aComment, aColor, nScenFlags ); sal_Bool bActive = pRefUndoDoc->IsActiveScenario( nTab ); pDoc->SetActiveScenario( nTab, bActive ); } pDoc->SetVisible( nTab, pRefUndoDoc->IsVisible( nTab ) ); pDoc->SetTabBgColor( nTab, pRefUndoDoc->GetTabBgColor(nTab) ); pDoc->SetSheetEvents( nTab, pRefUndoDoc->GetSheetEvents( nTab ) ); if ( pRefUndoDoc->IsTabProtected( nTab ) ) pDoc->SetTabProtection(nTab, pRefUndoDoc->GetTabProtection(nTab)); // Drawing-Layer passiert beim MoveUndo::EndUndo // pDoc->TransferDrawPage(pRefUndoDoc, nTab,nTab); } } if (bLink) { pDocShell->UpdateLinks(); // Link-Manager updaten } EndUndo(); // Draw-Undo muss vor dem Broadcast kommen! ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack(); if ( pChangeTrack ) pChangeTrack->Undo( nStartChangeAction, nEndChangeAction ); for(i=0;iBroadcast( ScTablesHint( SC_TAB_INSERTED, theTabs[sal::static_int_cast(i)]) ); } SfxApplication* pSfxApp = SFX_APP(); // Navigator pSfxApp->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) ); pSfxApp->Broadcast( SfxSimpleHint( SC_HINT_DBAREAS_CHANGED ) ); pSfxApp->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) ); pDocShell->PostPaint(0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_ALL ); // incl. Extras // nicht ShowTable wegen SetTabNo(..., sal_True): ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell(); if (pViewShell) pViewShell->SetTabNo( lcl_GetVisibleTabBefore( *pDoc, theTabs.front() ), sal_True ); // EndUndo(); } void ScUndoDeleteTab::Redo() { ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell(); pViewShell->SetTabNo( lcl_GetVisibleTabBefore( *pDocShell->GetDocument(), theTabs.front() ) ); RedoSdrUndoAction( pDrawUndo ); // Draw Redo first pDocShell->SetInUndo( sal_True ); //! BeginRedo bDrawIsInUndo = sal_True; pViewShell->DeleteTables( theTabs, sal_False ); bDrawIsInUndo = sal_False; pDocShell->SetInUndo( sal_True ); //! EndRedo SetChangeTrack(); // SetTabNo(...,sal_True) for all views to sync with drawing layer pages pDocShell->Broadcast( SfxSimpleHint( SC_HINT_FORCESETTAB ) ); } void ScUndoDeleteTab::Repeat(SfxRepeatTarget& rTarget) { if (rTarget.ISA(ScTabViewTarget)) { ScTabViewShell* pViewShell = ((ScTabViewTarget&)rTarget).GetViewShell(); pViewShell->DeleteTable( pViewShell->GetViewData()->GetTabNo(), sal_True ); } } sal_Bool ScUndoDeleteTab::CanRepeat(SfxRepeatTarget& rTarget) const { return (rTarget.ISA(ScTabViewTarget)); } //--------------------------------------------------------------------------------- // // Tabelle umbenennen // ScUndoRenameTab::ScUndoRenameTab( ScDocShell* pNewDocShell, SCTAB nT, const String& rOldName, const String& rNewName) : ScSimpleUndo( pNewDocShell ), nTab ( nT ) { sOldName = rOldName; sNewName = rNewName; } ScUndoRenameTab::~ScUndoRenameTab() { } String ScUndoRenameTab::GetComment() const { return ScGlobal::GetRscString( STR_UNDO_RENAME_TAB ); } void ScUndoRenameTab::DoChange( SCTAB nTabP, const String& rName ) const { ScDocument* pDoc = pDocShell->GetDocument(); pDoc->RenameTab( nTabP, rName ); SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) ); // Navigator pDocShell->PostPaintGridAll(); pDocShell->PostPaintExtras(); pDocShell->PostDataChanged(); // Der Tabellenname koennte in einer Formel vorkommen... ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell(); if (pViewShell) pViewShell->UpdateInputHandler(); } void ScUndoRenameTab::Undo() { DoChange(nTab, sOldName); } void ScUndoRenameTab::Redo() { DoChange(nTab, sNewName); } void ScUndoRenameTab::Repeat(SfxRepeatTarget& /* rTarget */) { // Repeat macht keinen Sinn } sal_Bool ScUndoRenameTab::CanRepeat(SfxRepeatTarget& /* rTarget */) const { return sal_False; } //---------------------------------------------------------------------------------- // // Tabelle verschieben // ScUndoMoveTab::ScUndoMoveTab( ScDocShell* pNewDocShell, const SvShorts &aOldTab, const SvShorts &aNewTab) : ScSimpleUndo( pNewDocShell ) { theOldTabs=aOldTab; theNewTabs=aNewTab; } ScUndoMoveTab::~ScUndoMoveTab() { theNewTabs.clear(); theOldTabs.clear(); } String ScUndoMoveTab::GetComment() const { return ScGlobal::GetRscString( STR_UNDO_MOVE_TAB ); } void ScUndoMoveTab::DoChange( sal_Bool bUndo ) const { ScDocument* pDoc = pDocShell->GetDocument(); ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell(); if (bUndo) // UnDo { for (size_t i = theNewTabs.size(); i > 0; i--) { SCTAB nDestTab = theNewTabs[i - 1]; SCTAB nOldTab = theOldTabs[i - 1]; if (nDestTab > MAXTAB) // append ? nDestTab = pDoc->GetTableCount() - 1; pDoc->MoveTab( nDestTab, nOldTab ); pViewShell->GetViewData()->MoveTab( nDestTab, nOldTab ); pViewShell->SetTabNo( nOldTab, sal_True ); } } else { for(size_t i=0;i MAXTAB) // append ? nDestTab = pDoc->GetTableCount() - 1; pDoc->MoveTab( nOldTab, nNewTab ); pViewShell->GetViewData()->MoveTab( nOldTab, nNewTab ); pViewShell->SetTabNo( nDestTab, sal_True ); } } SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) ); // Navigator pDocShell->PostPaintGridAll(); pDocShell->PostPaintExtras(); pDocShell->PostDataChanged(); } void ScUndoMoveTab::Undo() { DoChange( sal_True ); } void ScUndoMoveTab::Redo() { DoChange( sal_False ); } void ScUndoMoveTab::Repeat(SfxRepeatTarget& /* rTarget */) { // No Repeat ! ? ! } sal_Bool ScUndoMoveTab::CanRepeat(SfxRepeatTarget& /* rTarget */) const { return sal_False; } //---------------------------------------------------------------------------------- // // Copy table // ScUndoCopyTab::ScUndoCopyTab( ScDocShell* pNewDocShell, const SvShorts &aOldTab, const SvShorts &aNewTab) : ScSimpleUndo( pNewDocShell ), pDrawUndo( NULL ) { pDrawUndo = GetSdrUndoAction( pDocShell->GetDocument() ); theOldTabs=aOldTab; theNewTabs=aNewTab; } ScUndoCopyTab::~ScUndoCopyTab() { DeleteSdrUndoAction( pDrawUndo ); } String ScUndoCopyTab::GetComment() const { return ScGlobal::GetRscString( STR_UNDO_COPY_TAB ); } void ScUndoCopyTab::DoChange() const { ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell(); if (pViewShell) pViewShell->SetTabNo(theOldTabs.front(),sal_True); SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) ); // Navigator pDocShell->PostPaintGridAll(); pDocShell->PostPaintExtras(); pDocShell->PostDataChanged(); } void ScUndoCopyTab::Undo() { ScDocument* pDoc = pDocShell->GetDocument(); DoSdrUndoAction( pDrawUndo, pDoc ); // before the sheets are deleted for (size_t i = theNewTabs.size(); i > 0; i--) { SCTAB nDestTab = theNewTabs[i - 1]; if (nDestTab > MAXTAB) // append? nDestTab = pDoc->GetTableCount() - 1; bDrawIsInUndo = sal_True; pDoc->DeleteTab(nDestTab); bDrawIsInUndo = sal_False; } // ScTablesHint broadcasts after all sheets have been deleted, // so sheets and draw pages are in sync! for (size_t i = theNewTabs.size(); i > 0; i--) { SCTAB nDestTab = theNewTabs[i - 1]; if (nDestTab > MAXTAB) // append? nDestTab = pDoc->GetTableCount() - 1; pDocShell->Broadcast( ScTablesHint( SC_TAB_DELETED, nDestTab ) ); } DoChange(); } void ScUndoCopyTab::Redo() { ScDocument* pDoc = pDocShell->GetDocument(); ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell(); SCTAB nDestTab = 0; for(size_t i=0;i MAXTAB) // append ? nDestTab = pDoc->GetTableCount() - 1; bDrawIsInUndo = sal_True; pDoc->CopyTab( nOldTab, nNewTab ); bDrawIsInUndo = sal_False; pViewShell->GetViewData()->MoveTab( nOldTab, nNewTab ); SCTAB nAdjSource = nOldTab; if ( nNewTab <= nOldTab ) ++nAdjSource; // new position of source table after CopyTab if ( pDoc->IsScenario(nAdjSource) ) { pDoc->SetScenario(nNewTab, sal_True ); String aComment; Color aColor; sal_uInt16 nScenFlags; pDoc->GetScenarioData(nAdjSource, aComment, aColor, nScenFlags ); pDoc->SetScenarioData(nNewTab, aComment, aColor, nScenFlags ); sal_Bool bActive = pDoc->IsActiveScenario(nAdjSource); pDoc->SetActiveScenario(nNewTab, bActive ); sal_Bool bVisible=pDoc->IsVisible(nAdjSource); pDoc->SetVisible(nNewTab,bVisible ); } if ( pDoc->IsTabProtected( nAdjSource ) ) pDoc->CopyTabProtection(nAdjSource, nNewTab); } RedoSdrUndoAction( pDrawUndo ); // after the sheets are inserted pViewShell->SetTabNo( nDestTab, sal_True ); // after draw-undo DoChange(); } void ScUndoCopyTab::Repeat(SfxRepeatTarget& /* rTarget */) { // kein Repeat ! ? ! } sal_Bool ScUndoCopyTab::CanRepeat(SfxRepeatTarget& /* rTarget */) const { return sal_False; } //--------------------------------------------------------------------------------- // // Tab Bg Color // ScUndoTabColor::ScUndoTabColor( ScDocShell* pNewDocShell, SCTAB nT, const Color& aOTabBgColor, const Color& aNTabBgColor) : ScSimpleUndo( pNewDocShell ) { ScUndoTabColorInfo aInfo(nT); aInfo.maOldTabBgColor = aOTabBgColor; aInfo.maNewTabBgColor = aNTabBgColor; aTabColorList.push_back(aInfo); } ScUndoTabColor::ScUndoTabColor( ScDocShell* pNewDocShell, const ScUndoTabColorInfo::List& rUndoTabColorList) : ScSimpleUndo(pNewDocShell), aTabColorList(rUndoTabColorList) { } ScUndoTabColor::~ScUndoTabColor() { } String ScUndoTabColor::GetComment() const { if (aTabColorList.size() > 1) return ScGlobal::GetRscString(STR_UNDO_SET_MULTI_TAB_BG_COLOR); return ScGlobal::GetRscString(STR_UNDO_SET_TAB_BG_COLOR); } void ScUndoTabColor::DoChange(bool bUndoType) const { ScDocument* pDoc = pDocShell->GetDocument(); if (!pDoc) return; size_t nTabColorCount = aTabColorList.size(); for (size_t i = 0; i < nTabColorCount; ++i) { const ScUndoTabColorInfo& rTabColor = aTabColorList[i]; pDoc->SetTabBgColor(rTabColor.mnTabId, bUndoType ? rTabColor.maOldTabBgColor : rTabColor.maNewTabBgColor); } pDocShell->PostPaintExtras(); ScDocShellModificator aModificator( *pDocShell ); aModificator.SetDocumentModified(); } void ScUndoTabColor::Undo() { DoChange(true); } void ScUndoTabColor::Redo() { DoChange(false); } void ScUndoTabColor::Repeat(SfxRepeatTarget& /* rTarget */) { // No Repeat } sal_Bool ScUndoTabColor::CanRepeat(SfxRepeatTarget& /* rTarget */) const { return sal_False; } // ----------------------------------------------------------------------- // // Szenario anlegen // ScUndoMakeScenario::ScUndoMakeScenario( ScDocShell* pNewDocShell, SCTAB nSrc, SCTAB nDest, const String& rN, const String& rC, const Color& rCol, sal_uInt16 nF, const ScMarkData& rMark ) : ScSimpleUndo( pNewDocShell ), nSrcTab( nSrc ), nDestTab( nDest ), aName( rN ), aComment( rC ), aColor( rCol ), nFlags( nF ), aMarkData( rMark ), pDrawUndo( NULL ) { pDrawUndo = GetSdrUndoAction( pDocShell->GetDocument() ); } ScUndoMakeScenario::~ScUndoMakeScenario() { DeleteSdrUndoAction( pDrawUndo ); } String ScUndoMakeScenario::GetComment() const { return ScGlobal::GetRscString( STR_UNDO_MAKESCENARIO ); } void ScUndoMakeScenario::Undo() { ScDocument* pDoc = pDocShell->GetDocument(); pDocShell->SetInUndo( sal_True ); bDrawIsInUndo = sal_True; pDoc->DeleteTab( nDestTab ); bDrawIsInUndo = sal_False; pDocShell->SetInUndo( sal_False ); DoSdrUndoAction( pDrawUndo, pDoc ); pDocShell->PostPaint(0,0,nDestTab,MAXCOL,MAXROW,MAXTAB, PAINT_ALL); pDocShell->PostDataChanged(); ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell(); if (pViewShell) pViewShell->SetTabNo( nSrcTab, sal_True ); SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) ); // SetTabNo(...,sal_True) for all views to sync with drawing layer pages pDocShell->Broadcast( SfxSimpleHint( SC_HINT_FORCESETTAB ) ); } void ScUndoMakeScenario::Redo() { SetViewMarkData( aMarkData ); RedoSdrUndoAction( pDrawUndo ); // Draw Redo first pDocShell->SetInUndo( sal_True ); bDrawIsInUndo = sal_True; pDocShell->MakeScenario( nSrcTab, aName, aComment, aColor, nFlags, aMarkData, sal_False ); bDrawIsInUndo = sal_False; pDocShell->SetInUndo( sal_False ); ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell(); if (pViewShell) pViewShell->SetTabNo( nDestTab, sal_True ); SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) ); } void ScUndoMakeScenario::Repeat(SfxRepeatTarget& rTarget) { if (rTarget.ISA(ScTabViewTarget)) { ((ScTabViewTarget&)rTarget).GetViewShell()->MakeScenario( aName, aComment, aColor, nFlags ); } } sal_Bool ScUndoMakeScenario::CanRepeat(SfxRepeatTarget& rTarget) const { return (rTarget.ISA(ScTabViewTarget)); } // ----------------------------------------------------------------------- // // Tabelle einfuegen // ScUndoImportTab::ScUndoImportTab( ScDocShell* pShell, SCTAB nNewTab, SCTAB nNewCount, sal_Bool bNewLink ) : ScSimpleUndo( pShell ), nTab( nNewTab ), nCount( nNewCount ), bLink( bNewLink ), pRedoDoc( NULL ), pDrawUndo( NULL ) { pDrawUndo = GetSdrUndoAction( pDocShell->GetDocument() ); } ScUndoImportTab::~ScUndoImportTab() { delete pRedoDoc; DeleteSdrUndoAction( pDrawUndo ); } String ScUndoImportTab::GetComment() const { return ScGlobal::GetRscString( STR_UNDO_INSERT_TAB ); } void ScUndoImportTab::DoChange() const { ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell(); ScDocument* pDoc = pDocShell->GetDocument(); SCTAB nTabCount = pDoc->GetTableCount(); if (pViewShell) { if(nTabSetTabNo(nTab,sal_True); } else { pViewShell->SetTabNo(nTab-1,sal_True); } } SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) ); // Navigator pDocShell->PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_GRID | PAINT_TOP | PAINT_LEFT | PAINT_EXTRAS ); } void ScUndoImportTab::Undo() { //! eingefuegte Bereichsnamen etc. SCTAB i; ScDocument* pDoc = pDocShell->GetDocument(); sal_Bool bMakeRedo = !pRedoDoc; if (bMakeRedo) { pRedoDoc = new ScDocument( SCDOCMODE_UNDO ); pRedoDoc->InitUndo( pDoc, nTab,nTab+nCount-1, sal_True,sal_True ); String aOldName; for (i=0; iCopyToDocument(0,0,nTabPos, MAXCOL,MAXROW,nTabPos, IDF_ALL,sal_False, pRedoDoc ); pDoc->GetName( nTabPos, aOldName ); pRedoDoc->RenameTab( nTabPos, aOldName, sal_False ); pRedoDoc->SetTabBgColor( nTabPos, pDoc->GetTabBgColor(nTabPos) ); if ( pDoc->IsScenario(nTabPos) ) { pRedoDoc->SetScenario(nTabPos, sal_True ); String aComment; Color aColor; sal_uInt16 nScenFlags; pDoc->GetScenarioData(nTabPos, aComment, aColor, nScenFlags ); pRedoDoc->SetScenarioData(nTabPos, aComment, aColor, nScenFlags ); sal_Bool bActive = pDoc->IsActiveScenario(nTabPos); pRedoDoc->SetActiveScenario(nTabPos, bActive ); sal_Bool bVisible=pDoc->IsVisible(nTabPos); pRedoDoc->SetVisible(nTabPos,bVisible ); } if ( pDoc->IsTabProtected( nTabPos ) ) pRedoDoc->SetTabProtection(nTabPos, pDoc->GetTabProtection(nTabPos)); } } DoSdrUndoAction( pDrawUndo, pDoc ); // before the sheets are deleted bDrawIsInUndo = sal_True; for (i=0; iDeleteTab( nTab ); bDrawIsInUndo = sal_False; DoChange(); } void ScUndoImportTab::Redo() { if (!pRedoDoc) { DBG_ERROR("wo ist mein Redo-Document?"); return; } ScDocument* pDoc = pDocShell->GetDocument(); String aName; SCTAB i; for (i=0; iGetName(nTabPos,aName); bDrawIsInUndo = sal_True; pDoc->InsertTab(nTabPos,aName); bDrawIsInUndo = sal_False; } for (i=0; iCopyToDocument(0,0,nTabPos, MAXCOL,MAXROW,nTabPos, IDF_ALL,sal_False, pDoc ); pDoc->SetTabBgColor( nTabPos, pRedoDoc->GetTabBgColor(nTabPos) ); if ( pRedoDoc->IsScenario(nTabPos) ) { pDoc->SetScenario(nTabPos, sal_True ); String aComment; Color aColor; sal_uInt16 nScenFlags; pRedoDoc->GetScenarioData(nTabPos, aComment, aColor, nScenFlags ); pDoc->SetScenarioData(nTabPos, aComment, aColor, nScenFlags ); sal_Bool bActive = pRedoDoc->IsActiveScenario(nTabPos); pDoc->SetActiveScenario(nTabPos, bActive ); sal_Bool bVisible=pRedoDoc->IsVisible(nTabPos); pDoc->SetVisible(nTabPos,bVisible ); } if ( pRedoDoc->IsTabProtected( nTabPos ) ) pDoc->SetTabProtection(nTabPos, pRedoDoc->GetTabProtection(nTabPos)); } RedoSdrUndoAction( pDrawUndo ); // after the sheets are inserted DoChange(); } void ScUndoImportTab::Repeat(SfxRepeatTarget& rTarget) { if (rTarget.ISA(ScTabViewTarget)) ((ScTabViewTarget&)rTarget).GetViewShell()->GetViewData()->GetDispatcher(). Execute(FID_INS_TABLE, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD); } sal_Bool ScUndoImportTab::CanRepeat(SfxRepeatTarget& rTarget) const { return (rTarget.ISA(ScTabViewTarget)); } // ----------------------------------------------------------------------- // // Tabellen-Verknuepfung aufheben // ScUndoRemoveLink::ScUndoRemoveLink( ScDocShell* pShell, const String& rDoc ) : ScSimpleUndo( pShell ), aDocName( rDoc ), nCount( 0 ) { ScDocument* pDoc = pDocShell->GetDocument(); SCTAB nTabCount = pDoc->GetTableCount(); pTabs = new SCTAB[nTabCount]; pModes = new sal_uInt8[nTabCount]; pTabNames = new String[nTabCount]; for (SCTAB i=0; iGetLinkMode(i); if (nMode) if (pDoc->GetLinkDoc(i) == aDocName) { if (!nCount) { aFltName = pDoc->GetLinkFlt(i); aOptions = pDoc->GetLinkOpt(i); nRefreshDelay = pDoc->GetLinkRefreshDelay(i); } else { DBG_ASSERT(aFltName == pDoc->GetLinkFlt(i) && aOptions == pDoc->GetLinkOpt(i), "verschiedene Filter fuer ein Dokument?"); } pTabs[nCount] = i; pModes[nCount] = nMode; pTabNames[nCount] = pDoc->GetLinkTab(i); ++nCount; } } } ScUndoRemoveLink::~ScUndoRemoveLink() { delete pTabs; delete pModes; delete[] pTabNames; } String ScUndoRemoveLink::GetComment() const { return ScGlobal::GetRscString( STR_UNDO_REMOVELINK ); } void ScUndoRemoveLink::DoChange( sal_Bool bLink ) const { ScDocument* pDoc = pDocShell->GetDocument(); String aEmpty; for (sal_uInt16 i=0; iSetLink( pTabs[i], pModes[i], aDocName, aFltName, aOptions, pTabNames[i], nRefreshDelay ); else // remove link pDoc->SetLink( pTabs[i], SC_LINK_NONE, aEmpty, aEmpty, aEmpty, aEmpty, 0 ); pDocShell->UpdateLinks(); } void ScUndoRemoveLink::Undo() { DoChange( sal_True ); } void ScUndoRemoveLink::Redo() { DoChange( sal_False ); } void ScUndoRemoveLink::Repeat(SfxRepeatTarget& /* rTarget */) { // gippsnich } sal_Bool ScUndoRemoveLink::CanRepeat(SfxRepeatTarget& /* rTarget */) const { return sal_False; } // ----------------------------------------------------------------------- // // Tabellen ein-/ausblenden // ScUndoShowHideTab::ScUndoShowHideTab( ScDocShell* pShell, SCTAB nNewTab, sal_Bool bNewShow ) : ScSimpleUndo( pShell ), nTab( nNewTab ), bShow( bNewShow ) { } ScUndoShowHideTab::~ScUndoShowHideTab() { } void ScUndoShowHideTab::DoChange( sal_Bool bShowP ) const { ScDocument* pDoc = pDocShell->GetDocument(); pDoc->SetVisible( nTab, bShowP ); ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell(); if (pViewShell) pViewShell->SetTabNo(nTab,sal_True); SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) ); pDocShell->SetDocumentModified(); } void ScUndoShowHideTab::Undo() { DoChange(!bShow); } void ScUndoShowHideTab::Redo() { DoChange(bShow); } void ScUndoShowHideTab::Repeat(SfxRepeatTarget& rTarget) { if (rTarget.ISA(ScTabViewTarget)) ((ScTabViewTarget&)rTarget).GetViewShell()->GetViewData()->GetDispatcher(). Execute( bShow ? FID_TABLE_SHOW : FID_TABLE_HIDE, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD); } sal_Bool ScUndoShowHideTab::CanRepeat(SfxRepeatTarget& rTarget) const { return (rTarget.ISA(ScTabViewTarget)); } String ScUndoShowHideTab::GetComment() const { sal_uInt16 nId = bShow ? STR_UNDO_SHOWTAB : STR_UNDO_HIDETAB; return ScGlobal::GetRscString( nId ); } // ============================================================================ ScUndoDocProtect::ScUndoDocProtect(ScDocShell* pShell, auto_ptr pProtectSettings) : ScSimpleUndo(pShell), mpProtectSettings(pProtectSettings) { } ScUndoDocProtect::~ScUndoDocProtect() { } void ScUndoDocProtect::DoProtect(bool bProtect) { ScDocument* pDoc = pDocShell->GetDocument(); if (bProtect) { // set protection. auto_ptr pCopy(new ScDocProtection(*mpProtectSettings)); pCopy->setProtected(true); pDoc->SetDocProtection(pCopy.get()); } else { // remove protection. pDoc->SetDocProtection(NULL); } ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell(); if (pViewShell) { pViewShell->UpdateLayerLocks(); pViewShell->UpdateInputHandler(sal_True); // damit sofort wieder eingegeben werden kann } pDocShell->PostPaintGridAll(); } void ScUndoDocProtect::Undo() { BeginUndo(); DoProtect(!mpProtectSettings->isProtected()); EndUndo(); } void ScUndoDocProtect::Redo() { BeginRedo(); DoProtect(mpProtectSettings->isProtected()); EndRedo(); } void ScUndoDocProtect::Repeat(SfxRepeatTarget& /* rTarget */) { // gippsnich } sal_Bool ScUndoDocProtect::CanRepeat(SfxRepeatTarget& /* rTarget */) const { return sal_False; // gippsnich } String ScUndoDocProtect::GetComment() const { sal_uInt16 nId = mpProtectSettings->isProtected() ? STR_UNDO_PROTECT_DOC : STR_UNDO_UNPROTECT_DOC; return ScGlobal::GetRscString( nId ); } // ============================================================================ ScUndoTabProtect::ScUndoTabProtect(ScDocShell* pShell, SCTAB nTab, auto_ptr pProtectSettings) : ScSimpleUndo(pShell), mnTab(nTab), mpProtectSettings(pProtectSettings) { } ScUndoTabProtect::~ScUndoTabProtect() { } void ScUndoTabProtect::DoProtect(bool bProtect) { ScDocument* pDoc = pDocShell->GetDocument(); if (bProtect) { // set protection. auto_ptr pCopy(new ScTableProtection(*mpProtectSettings)); pCopy->setProtected(true); pDoc->SetTabProtection(mnTab, pCopy.get()); } else { // remove protection. pDoc->SetTabProtection(mnTab, NULL); } ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell(); if (pViewShell) { pViewShell->UpdateLayerLocks(); pViewShell->UpdateInputHandler(sal_True); // damit sofort wieder eingegeben werden kann } pDocShell->PostPaintGridAll(); } void ScUndoTabProtect::Undo() { BeginUndo(); DoProtect(!mpProtectSettings->isProtected()); EndUndo(); } void ScUndoTabProtect::Redo() { BeginRedo(); DoProtect(mpProtectSettings->isProtected()); EndRedo(); } void ScUndoTabProtect::Repeat(SfxRepeatTarget& /* rTarget */) { // gippsnich } sal_Bool ScUndoTabProtect::CanRepeat(SfxRepeatTarget& /* rTarget */) const { return sal_False; // gippsnich } String ScUndoTabProtect::GetComment() const { sal_uInt16 nId = mpProtectSettings->isProtected() ? STR_UNDO_PROTECT_TAB : STR_UNDO_UNPROTECT_TAB; return ScGlobal::GetRscString( nId ); } // ----------------------------------------------------------------------- // // Druck-/Wiederholungsbereiche aendern // ScUndoPrintRange::ScUndoPrintRange( ScDocShell* pShell, SCTAB nNewTab, ScPrintRangeSaver* pOld, ScPrintRangeSaver* pNew ) : ScSimpleUndo( pShell ), nTab( nNewTab ), pOldRanges( pOld ), pNewRanges( pNew ) { } ScUndoPrintRange::~ScUndoPrintRange() { delete pOldRanges; delete pNewRanges; } void ScUndoPrintRange::DoChange(sal_Bool bUndo) { ScDocument* pDoc = pDocShell->GetDocument(); if (bUndo) pDoc->RestorePrintRanges( *pOldRanges ); else pDoc->RestorePrintRanges( *pNewRanges ); ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell(); if (pViewShell) pViewShell->SetTabNo( nTab ); ScPrintFunc( pDocShell, pDocShell->GetPrinter(), nTab ).UpdatePages(); pDocShell->PostPaint( ScRange(0,0,nTab,MAXCOL,MAXROW,nTab), PAINT_GRID ); } void ScUndoPrintRange::Undo() { BeginUndo(); DoChange( sal_True ); EndUndo(); } void ScUndoPrintRange::Redo() { BeginRedo(); DoChange( sal_False ); EndRedo(); } void ScUndoPrintRange::Repeat(SfxRepeatTarget& /* rTarget */) { // gippsnich } sal_Bool ScUndoPrintRange::CanRepeat(SfxRepeatTarget& /* rTarget */) const { return sal_False; // gippsnich } String ScUndoPrintRange::GetComment() const { return ScGlobal::GetRscString( STR_UNDO_PRINTRANGES ); } //------------------------------------------------------------------------ //--------------------------------------------------------------------------------- // // Szenario-Flags // ScUndoScenarioFlags::ScUndoScenarioFlags( ScDocShell* pNewDocShell, SCTAB nT, const String& rON, const String& rNN, const String& rOC, const String& rNC, const Color& rOCol, const Color& rNCol, sal_uInt16 nOF, sal_uInt16 nNF ) : ScSimpleUndo( pNewDocShell ), nTab ( nT ), aOldName ( rON ), aNewName ( rNN ), aOldComment ( rOC ), aNewComment ( rNC ), aOldColor ( rOCol ), aNewColor ( rNCol ), nOldFlags ( nOF ), nNewFlags ( nNF ) { } ScUndoScenarioFlags::~ScUndoScenarioFlags() { } String ScUndoScenarioFlags::GetComment() const { return ScGlobal::GetRscString( STR_UNDO_EDITSCENARIO ); } void ScUndoScenarioFlags::Undo() { ScDocument* pDoc = pDocShell->GetDocument(); pDoc->RenameTab( nTab, aOldName ); pDoc->SetScenarioData( nTab, aOldComment, aOldColor, nOldFlags ); pDocShell->PostPaintGridAll(); // Der Tabellenname koennte in einer Formel vorkommen... ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell(); if (pViewShell) pViewShell->UpdateInputHandler(); if ( aOldName != aNewName ) SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) ); } void ScUndoScenarioFlags::Redo() { ScDocument* pDoc = pDocShell->GetDocument(); pDoc->RenameTab( nTab, aNewName ); pDoc->SetScenarioData( nTab, aNewComment, aNewColor, nNewFlags ); pDocShell->PostPaintGridAll(); // Der Tabellenname koennte in einer Formel vorkommen... ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell(); if (pViewShell) pViewShell->UpdateInputHandler(); if ( aOldName != aNewName ) SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) ); } void ScUndoScenarioFlags::Repeat(SfxRepeatTarget& /* rTarget */) { // Repeat macht keinen Sinn } sal_Bool ScUndoScenarioFlags::CanRepeat(SfxRepeatTarget& /* rTarget */) const { return sal_False; } //--------------------------------------------------------------------------------- // // rename object // (move to different file?) // ScUndoRenameObject::ScUndoRenameObject( ScDocShell* pNewDocShell, const String& rPN, const String& rON, const String& rNN ) : ScSimpleUndo( pNewDocShell ), aPersistName( rPN ), aOldName ( rON ), aNewName ( rNN ) { } ScUndoRenameObject::~ScUndoRenameObject() { } String ScUndoRenameObject::GetComment() const { // string resource shared with title for dialog return String( ScResId(SCSTR_RENAMEOBJECT) ); } SdrObject* ScUndoRenameObject::GetObject() { ScDocument* pDoc = pDocShell->GetDocument(); ScDrawLayer* pDrawLayer = pDoc->GetDrawLayer(); if ( pDrawLayer ) { sal_uInt16 nCount = pDrawLayer->GetPageCount(); for (sal_uInt16 nTab=0; nTabGetPage(nTab); DBG_ASSERT(pPage,"Page ?"); SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS ); SdrObject* pObject = aIter.Next(); while (pObject) { if ( pObject->GetObjIdentifier() == OBJ_OLE2 && ((SdrOle2Obj*)pObject)->GetPersistName() == aPersistName ) { return pObject; } pObject = aIter.Next(); } } } DBG_ERROR("Object not found"); return NULL; } void ScUndoRenameObject::Undo() { BeginUndo(); SdrObject* pObj = GetObject(); if ( pObj ) pObj->SetName( aOldName ); EndUndo(); } void ScUndoRenameObject::Redo() { BeginRedo(); SdrObject* pObj = GetObject(); if ( pObj ) pObj->SetName( aNewName ); EndRedo(); } void ScUndoRenameObject::Repeat(SfxRepeatTarget& /* rTarget */) { } sal_Bool ScUndoRenameObject::CanRepeat(SfxRepeatTarget& /* rTarget */) const { return sal_False; } // ----------------------------------------------------------------------- // // Switch sheet between left-to-right and right-to-left // ScUndoLayoutRTL::ScUndoLayoutRTL( ScDocShell* pShell, SCTAB nNewTab, sal_Bool bNewRTL ) : ScSimpleUndo( pShell ), nTab( nNewTab ), bRTL( bNewRTL ) { } ScUndoLayoutRTL::~ScUndoLayoutRTL() { } void ScUndoLayoutRTL::DoChange( sal_Bool bNew ) { pDocShell->SetInUndo( sal_True ); ScDocument* pDoc = pDocShell->GetDocument(); pDoc->SetLayoutRTL( nTab, bNew ); ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell(); if (pViewShell) pViewShell->SetTabNo(nTab,sal_True); pDocShell->SetDocumentModified(); pDocShell->SetInUndo( sal_False ); } void ScUndoLayoutRTL::Undo() { DoChange(!bRTL); } void ScUndoLayoutRTL::Redo() { DoChange(bRTL); } void ScUndoLayoutRTL::Repeat(SfxRepeatTarget& rTarget) { if (rTarget.ISA(ScTabViewTarget)) ((ScTabViewTarget&)rTarget).GetViewShell()->GetViewData()->GetDispatcher(). Execute( FID_TAB_RTL, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD); } sal_Bool ScUndoLayoutRTL::CanRepeat(SfxRepeatTarget& rTarget) const { return (rTarget.ISA(ScTabViewTarget)); } String ScUndoLayoutRTL::GetComment() const { return ScGlobal::GetRscString( STR_UNDO_TAB_RTL ); } // ----------------------------------------------------------------------- // // Set the grammar used for the sheet // //UNUSED2009-05 ScUndoSetGrammar::ScUndoSetGrammar( ScDocShell* pShell, //UNUSED2009-05 formula::FormulaGrammar::Grammar eGrammar ) : //UNUSED2009-05 ScSimpleUndo( pShell ), //UNUSED2009-05 meNewGrammar( eGrammar ) //UNUSED2009-05 { //UNUSED2009-05 meOldGrammar = pDocShell->GetDocument()->GetGrammar(); //UNUSED2009-05 } //UNUSED2009-05 //UNUSED2009-05 __EXPORT ScUndoSetGrammar::~ScUndoSetGrammar() //UNUSED2009-05 { //UNUSED2009-05 } //UNUSED2009-05 //UNUSED2009-05 void ScUndoSetGrammar::DoChange( formula::FormulaGrammar::Grammar eGrammar ) //UNUSED2009-05 { //UNUSED2009-05 pDocShell->SetInUndo( sal_True ); //UNUSED2009-05 ScDocument* pDoc = pDocShell->GetDocument(); //UNUSED2009-05 pDoc->SetGrammar( eGrammar ); //UNUSED2009-05 pDocShell->SetDocumentModified(); //UNUSED2009-05 pDocShell->SetInUndo( sal_False ); //UNUSED2009-05 } //UNUSED2009-05 //UNUSED2009-05 void __EXPORT ScUndoSetGrammar::Undo() //UNUSED2009-05 { //UNUSED2009-05 DoChange( meOldGrammar ); //UNUSED2009-05 } //UNUSED2009-05 //UNUSED2009-05 void __EXPORT ScUndoSetGrammar::Redo() //UNUSED2009-05 { //UNUSED2009-05 DoChange( meNewGrammar ); //UNUSED2009-05 } //UNUSED2009-05 //UNUSED2009-05 void __EXPORT ScUndoSetGrammar::Repeat(SfxRepeatTarget& /* rTarget */) //UNUSED2009-05 { //UNUSED2009-05 #if 0 //UNUSED2009-05 // erAck: 2006-09-07T23:00+0200 commented out in CWS scr1c1 //UNUSED2009-05 if (rTarget.ISA(ScTabViewTarget)) //UNUSED2009-05 ((ScTabViewTarget&)rTarget).GetViewShell()->GetViewData()->GetDispatcher(). //UNUSED2009-05 Execute( FID_TAB_USE_R1C1, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD); //UNUSED2009-05 #endif //UNUSED2009-05 } //UNUSED2009-05 //UNUSED2009-05 sal_Bool __EXPORT ScUndoSetGrammar::CanRepeat(SfxRepeatTarget& rTarget) const //UNUSED2009-05 { //UNUSED2009-05 return (rTarget.ISA(ScTabViewTarget)); //UNUSED2009-05 } //UNUSED2009-05 //UNUSED2009-05 String __EXPORT ScUndoSetGrammar::GetComment() const //UNUSED2009-05 { //UNUSED2009-05 return ScGlobal::GetRscString( STR_UNDO_TAB_R1C1 ); //UNUSED2009-05 }