| /************************************************************** |
| * |
| * 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 <boost/scoped_ptr.hpp> |
| |
| #include "scitems.hxx" |
| #include <sfx2/request.hxx> |
| #include <sfx2/viewfrm.hxx> |
| #include <basic/sbstar.hxx> |
| #include <layout/layout.hxx> |
| #include <svl/languageoptions.hxx> |
| #include <svl/stritem.hxx> |
| #include <svl/whiter.hxx> |
| #include <vcl/msgbox.hxx> |
| #include <sfx2/objface.hxx> |
| #include <svx/svxdlg.hxx> |
| #include <editeng/colritem.hxx> |
| |
| #include "tabvwsh.hxx" |
| #include "sc.hrc" |
| #include "docsh.hxx" |
| #include "document.hxx" |
| #include "shtabdlg.hxx" |
| #include "scresid.hxx" |
| //CHINA001 #include "instbdlg.hxx" |
| #include "globstr.hrc" |
| //CHINA001 #include "strindlg.hxx" |
| //CHINA001 #include "mvtabdlg.hxx" |
| #include "docfunc.hxx" |
| #include "eventuno.hxx" |
| |
| #include "scabstdlg.hxx" //CHINA001 |
| |
| #include "tabbgcolor.hxx" |
| #include "tabbgcolordlg.hxx" |
| #include "sccommands.h" |
| |
| using ::boost::scoped_ptr; |
| using namespace com::sun::star; |
| |
| #define IS_AVAILABLE(WhichId,ppItem) \ |
| (pReqArgs->GetItemState((WhichId), sal_True, ppItem ) == SFX_ITEM_SET) |
| |
| //------------------------------------------------------------------ |
| |
| void ScTabViewShell::ExecuteTable( SfxRequest& rReq ) |
| { |
| ScViewData* pViewData = GetViewData(); |
| ScDocument* pDoc = pViewData->GetDocument(); |
| |
| SCTAB nCurrentTab = pViewData->GetTabNo(); |
| SCTAB nTabCount = pDoc->GetTableCount(); |
| sal_uInt16 nSlot = rReq.GetSlot(); |
| const SfxItemSet* pReqArgs = rReq.GetArgs(); |
| |
| HideListBox(); // Autofilter-DropDown-Listbox |
| |
| switch ( nSlot ) |
| { |
| case FID_TABLE_VISIBLE: |
| { |
| String aName; |
| pDoc->GetName( nCurrentTab, aName ); |
| |
| sal_Bool bVisible=sal_True; |
| if( pReqArgs != NULL ) |
| { |
| const SfxPoolItem* pItem; |
| if( IS_AVAILABLE( FID_TABLE_VISIBLE, &pItem ) ) |
| bVisible = ((const SfxBoolItem*)pItem)->GetValue(); |
| } |
| |
| if( ! bVisible ) // ausblenden |
| { |
| ScMarkData& rMark = pViewData->GetMarkData(); |
| SCTAB nTabSelCount = rMark.GetSelectCount(); |
| sal_uInt16 nVis = 0; |
| for ( SCTAB i=0; i < nTabCount && nVis<2; i++ ) |
| if (pDoc->IsVisible(i)) |
| ++nVis; |
| if ( nVis<2 || !pDoc->IsDocEditable() || nTabSelCount > 1 ) |
| break; |
| |
| SCTAB nHideTab; |
| if (pDoc->GetTable( aName, nHideTab )) |
| HideTable( nHideTab ); |
| } |
| else // einblenden |
| { |
| ShowTable( aName ); |
| } |
| } |
| break; |
| |
| case FID_TABLE_HIDE: |
| { |
| ScMarkData& rMark = pViewData->GetMarkData(); |
| SCTAB nTabSelCount = rMark.GetSelectCount(); |
| sal_uInt16 nVis = 0; |
| for ( SCTAB i=0; i < nTabCount && nVis<2; i++ ) |
| if (pDoc->IsVisible(i)) |
| ++nVis; |
| if ( nVis<2 || !pDoc->IsDocEditable() || nTabSelCount > 1 ) |
| break; |
| |
| |
| String aName; |
| if( pReqArgs != NULL ) |
| { |
| const SfxPoolItem* pItem; |
| if( IS_AVAILABLE( FID_TABLE_HIDE, &pItem ) ) |
| aName = ((const SfxStringItem*)pItem)->GetValue(); |
| } |
| |
| if (!aName.Len()) |
| { |
| pDoc->GetName( nCurrentTab, aName ); // aktuelle Tabelle |
| rReq.AppendItem( SfxStringItem( FID_TABLE_HIDE, aName ) ); |
| } |
| |
| SCTAB nHideTab; |
| if (pDoc->GetTable( aName, nHideTab )) |
| HideTable( nHideTab ); |
| |
| if( ! rReq.IsAPI() ) |
| rReq.Done(); |
| } |
| break; |
| |
| case FID_TABLE_SHOW: |
| { |
| String aName; |
| if ( pReqArgs ) |
| { |
| const SfxPoolItem* pItem; |
| if( IS_AVAILABLE( FID_TABLE_SHOW, &pItem ) ) |
| { |
| aName = ((const SfxStringItem*)pItem)->GetValue(); |
| |
| ShowTable( aName ); |
| |
| if( ! rReq.IsAPI() ) |
| rReq.Done(); |
| } |
| } |
| else |
| { |
| //CHINA001 ScShowTabDlg* pDlg = new ScShowTabDlg( GetDialogParent() ); |
| ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create(); |
| DBG_ASSERT(pFact, "ScAbstractFactory create fail!");//CHINA001 |
| |
| AbstractScShowTabDlg* pDlg = pFact->CreateScShowTabDlg( GetDialogParent(), RID_SCDLG_SHOW_TAB); |
| DBG_ASSERT(pDlg, "Dialog create fail!");//CHINA001 |
| |
| String aTabName; |
| sal_Bool bFirst = sal_True; |
| for ( SCTAB i=0; i != nTabCount; i++ ) |
| { |
| if (!pDoc->IsVisible(i)) |
| { |
| pDoc->GetName( i, aTabName ); |
| pDlg->Insert( aTabName, bFirst ); |
| bFirst = sal_False; |
| } |
| } |
| |
| if ( pDlg->Execute() == RET_OK ) |
| { |
| sal_uInt16 nCount = pDlg->GetSelectEntryCount(); |
| for (sal_uInt16 nPos=0; nPos<nCount; nPos++) |
| { |
| aName = pDlg->GetSelectEntry(nPos); |
| ShowTable( aName ); |
| } |
| rReq.AppendItem( SfxStringItem( FID_TABLE_SHOW, aName ) ); |
| rReq.Done(); |
| } |
| delete pDlg; |
| } |
| } |
| break; |
| |
| case FID_INS_TABLE: |
| case FID_INS_TABLE_EXT: |
| { |
| ScMarkData& rMark = pViewData->GetMarkData(); |
| SCTAB nTabSelCount = rMark.GetSelectCount(); |
| SCTAB nTabNr = nCurrentTab; |
| |
| if ( !pDoc->IsDocEditable() ) |
| break; // gesperrt |
| |
| if ( pReqArgs != NULL ) // von Basic |
| { |
| sal_Bool bOk = sal_False; |
| const SfxPoolItem* pTabItem; |
| const SfxPoolItem* pNameItem; |
| String aName; |
| |
| if ( IS_AVAILABLE( FN_PARAM_1, &pTabItem ) && |
| IS_AVAILABLE( nSlot, &pNameItem ) ) |
| { |
| // Tabellennr. von Basic: 1-basiert |
| |
| aName = ((const SfxStringItem*)pNameItem)->GetValue(); |
| nTabNr = ((const SfxUInt16Item*)pTabItem)->GetValue() - 1; |
| if ( nTabNr < nTabCount ) |
| bOk = InsertTable( aName, nTabNr ); |
| } |
| |
| if (bOk) |
| rReq.Done( *pReqArgs ); |
| //! sonst Fehler setzen |
| } |
| else // Dialog |
| { |
| //CHINA001 ScInsertTableDlg* pDlg = new ScInsertTableDlg( |
| //CHINA001 GetDialogParent(), |
| //CHINA001 *pViewData,nTabSelCount); |
| ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create(); |
| DBG_ASSERT(pFact, "ScAbstractFactory create fail!");//CHINA001 |
| |
| AbstractScInsertTableDlg* pDlg = pFact->CreateScInsertTableDlg( GetDialogParent(), *pViewData, |
| nTabSelCount, nSlot == FID_INS_TABLE_EXT, |
| RID_SCDLG_INSERT_TABLE); |
| DBG_ASSERT(pDlg, "Dialog create fail!");//CHINA001 |
| if ( RET_OK == pDlg->Execute() ) |
| { |
| if (pDlg->GetTablesFromFile()) |
| { |
| SCTAB nTabs[MAXTABCOUNT]; |
| SCTAB nCount = 0; |
| sal_uInt16 n = 0; |
| const String* pStr = pDlg->GetFirstTable( &n ); |
| while ( pStr ) |
| { |
| nTabs[nCount++] = static_cast<SCTAB>(n); |
| pStr = pDlg->GetNextTable( &n ); |
| } |
| sal_Bool bLink = pDlg->GetTablesAsLink(); |
| if (nCount != 0) |
| { |
| if(pDlg->IsTableBefore()) |
| { |
| ImportTables( pDlg->GetDocShellTables(), nCount, nTabs, |
| bLink,nTabNr ); |
| } |
| else |
| { |
| SCTAB nTabAfter = nTabNr+1; |
| |
| for(SCTAB j=nCurrentTab+1;j<nTabCount;j++) |
| { |
| if(!pDoc->IsScenario(j)) |
| { |
| nTabAfter=j; |
| break; |
| } |
| } |
| |
| ImportTables( pDlg->GetDocShellTables(), nCount, nTabs, |
| bLink,nTabAfter ); |
| } |
| } |
| } |
| else |
| { |
| SCTAB nCount=pDlg->GetTableCount(); |
| if(pDlg->IsTableBefore()) |
| { |
| if(nCount==1 && pDlg->GetFirstTable()->Len()>0) |
| { |
| rReq.AppendItem( SfxStringItem( FID_INS_TABLE, *pDlg->GetFirstTable() ) ); |
| rReq.AppendItem( SfxUInt16Item( FN_PARAM_1, static_cast<sal_uInt16>(nTabNr) + 1 ) ); // 1-based |
| rReq.Done(); |
| |
| InsertTable( *pDlg->GetFirstTable(), nTabNr ); |
| } |
| else |
| InsertTables( NULL, nTabNr,nCount ); |
| } |
| else |
| { |
| SCTAB nTabAfter = nTabNr+1; |
| SCTAB nSelHigh=0; |
| |
| for(SCTAB i=0;i<nTabCount;i++) |
| { |
| if(rMark.GetTableSelect(i)) |
| { |
| nSelHigh=i; |
| } |
| } |
| |
| for(SCTAB j=nSelHigh+1;j<nTabCount;j++) |
| { |
| if(!pDoc->IsScenario(j)) |
| { |
| nTabAfter=j; |
| break; |
| } |
| else // #101672#; increase nTabAfter, because it is possible that the scenario tables are the last |
| nTabAfter = j + 1; |
| } |
| |
| if(nCount==1 && pDlg->GetFirstTable()->Len()>0) |
| { |
| rReq.AppendItem( SfxStringItem( FID_INS_TABLE, *pDlg->GetFirstTable() ) ); |
| rReq.AppendItem( SfxUInt16Item( FN_PARAM_1, static_cast<sal_uInt16>(nTabAfter) + 1 ) ); // 1-based |
| rReq.Done(); |
| |
| InsertTable( *pDlg->GetFirstTable(), nTabAfter); |
| } |
| else |
| { |
| InsertTables( NULL, nTabAfter,nCount); |
| } |
| } |
| } |
| } |
| |
| delete pDlg; |
| } |
| } |
| break; |
| |
| case FID_TAB_APPEND: |
| case FID_TAB_RENAME: |
| case FID_TAB_MENU_RENAME: |
| { |
| // FID_TAB_MENU_RENAME - "umbenennen" im Menu |
| // FID_TAB_RENAME - "Name"-Property fuer Basic |
| // Execute ist gleich, aber im GetState wird MENU_RENAME evtl. disabled |
| |
| if ( nSlot == FID_TAB_MENU_RENAME ) |
| nSlot = FID_TAB_RENAME; // Execute ist gleich |
| |
| SCTAB nTabNr = pViewData->GetTabNo(); |
| ScMarkData& rMark = pViewData->GetMarkData(); |
| SCTAB nTabSelCount = rMark.GetSelectCount(); |
| |
| if ( !pDoc->IsDocEditable() ) |
| break; // alles gesperrt |
| |
| if ( nSlot != FID_TAB_APPEND && |
| ( pDoc->IsTabProtected( nTabNr ) || nTabSelCount > 1 ) ) |
| break; // kein Rename |
| |
| #if 0 |
| // ScSbxObject wird nicht mehr benutzt, stattdessen aus dem |
| // ScSbxTable::Notify die richtige Tabelle an der Basic-View eingestellt |
| if( rReq.IsAPI() ) |
| { |
| SbxObject* pObj = GetScSbxObject(); |
| ScSbxTable* pSbxTab = PTR_CAST( ScSbxTable, pObj ); |
| DBG_ASSERT( pSbxTab, "pSbxTab???" ); |
| |
| if( pSbxTab ) |
| nTabNr = pSbxTab->GetTableNr(); |
| } |
| #endif |
| |
| if( pReqArgs != NULL ) |
| { |
| sal_Bool bDone = sal_False; |
| const SfxPoolItem* pItem; |
| String aName; |
| |
| if( IS_AVAILABLE( FN_PARAM_1, &pItem ) ) |
| nTabNr = ((const SfxUInt16Item*)pItem)->GetValue(); |
| |
| if( IS_AVAILABLE( nSlot, &pItem ) ) |
| aName = ((const SfxStringItem*)pItem)->GetValue(); |
| |
| switch ( nSlot ) |
| { |
| case FID_TAB_APPEND: |
| bDone = AppendTable( aName ); |
| break; |
| case FID_TAB_RENAME: |
| bDone = RenameTable( aName, nTabNr ); |
| break; |
| } |
| |
| if( bDone ) |
| { |
| rReq.Done( *pReqArgs ); |
| } |
| } |
| else |
| { |
| sal_uInt16 nRet = RET_OK; |
| sal_Bool bDone = sal_False; |
| String aErrMsg ( ScGlobal::GetRscString( STR_INVALIDTABNAME ) ); |
| String aName; |
| String aDlgTitle; |
| const sal_Char* pHelpId = 0; |
| |
| switch ( nSlot ) |
| { |
| case FID_TAB_APPEND: |
| aDlgTitle = String(ScResId(SCSTR_APDTABLE)); |
| pDoc->CreateValidTabName( aName ); |
| pHelpId = HID_SC_APPEND_NAME; |
| break; |
| |
| case FID_TAB_RENAME: |
| aDlgTitle = String(ScResId(SCSTR_RENAMETAB)); |
| pDoc->GetName( pViewData->GetTabNo(), aName ); |
| pHelpId = HID_SC_RENAME_NAME; |
| break; |
| } |
| |
| ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create(); |
| DBG_ASSERT(pFact, "ScAbstractFactory create fail!");//CHINA001 |
| |
| AbstractScStringInputDlg* pDlg = pFact->CreateScStringInputDlg( GetDialogParent(), |
| aDlgTitle, |
| String(ScResId(SCSTR_NAME)), |
| aName, |
| GetStaticInterface()->GetSlot(nSlot)->GetCommand(), pHelpId, RID_SCDLG_STRINPUT); |
| DBG_ASSERT(pDlg, "Dialog create fail!");//CHINA001 |
| |
| while ( !bDone && nRet == RET_OK ) |
| { |
| nRet = pDlg->Execute(); |
| |
| if ( nRet == RET_OK ) |
| { |
| pDlg->GetInputString( aName ); |
| |
| |
| switch ( nSlot ) |
| { |
| case FID_TAB_APPEND: |
| bDone = AppendTable( aName ); |
| break; |
| case FID_TAB_RENAME: |
| bDone = RenameTable( aName, nTabNr ); |
| break; |
| } |
| |
| if ( bDone ) |
| { |
| rReq.AppendItem( SfxStringItem( nSlot, aName ) ); |
| rReq.Done(); |
| } |
| else |
| { |
| if( rReq.IsAPI() ) |
| { |
| StarBASIC::Error( SbERR_SETPROP_FAILED ); // XXX Fehlerbehandlung??? |
| } |
| else |
| { |
| nRet = ErrorBox( GetDialogParent(), |
| WinBits( WB_OK | WB_DEF_OK ), |
| aErrMsg |
| ).Execute(); |
| } |
| } |
| } |
| } |
| delete pDlg; |
| } |
| } |
| break; |
| |
| case FID_TAB_MOVE: |
| { |
| if ( pDoc->GetChangeTrack() != NULL ) |
| break; // bei aktiviertem ChangeTracking kein TabMove |
| |
| sal_Bool bDoIt = sal_False; |
| sal_uInt16 nDoc = 0; |
| SCTAB nTab = pViewData->GetTabNo(); |
| sal_Bool bCpy = sal_False; |
| String aDocName; |
| |
| if( pReqArgs != NULL ) |
| { |
| SCTAB nTableCount = pDoc->GetTableCount(); |
| const SfxPoolItem* pItem; |
| |
| if( IS_AVAILABLE( FID_TAB_MOVE, &pItem ) ) |
| aDocName = ((const SfxStringItem*)pItem)->GetValue(); |
| if( IS_AVAILABLE( FN_PARAM_1, &pItem ) ) |
| { |
| // Tabelle ist 1-basiert |
| nTab = ((const SfxUInt16Item*)pItem)->GetValue() - 1; |
| if ( nTab >= nTableCount ) |
| nTab = SC_TAB_APPEND; |
| } |
| if( IS_AVAILABLE( FN_PARAM_2, &pItem ) ) |
| bCpy = ((const SfxBoolItem*)pItem)->GetValue(); |
| |
| if( aDocName.Len() ) |
| { |
| SfxObjectShell* pSh = SfxObjectShell::GetFirst(); |
| ScDocShell* pScSh = NULL; |
| sal_uInt16 i=0; |
| |
| while ( pSh ) |
| { |
| pScSh = PTR_CAST( ScDocShell, pSh ); |
| |
| if( pScSh ) |
| { |
| pScSh->GetTitle(); |
| |
| if( pScSh->GetTitle() == aDocName ) |
| { |
| nDoc = i; |
| ScDocument* pDestDoc = pScSh->GetDocument(); |
| nTableCount = pDestDoc->GetTableCount(); |
| bDoIt = pDestDoc->IsDocEditable(); |
| break; |
| } |
| |
| i++; // nur die ScDocShell's zaehlen |
| } |
| pSh = SfxObjectShell::GetNext( *pSh ); |
| } |
| } |
| else // Kein Dokumentname -> neues Dokument |
| { |
| nDoc = SC_DOC_NEW; |
| bDoIt = sal_True; |
| } |
| |
| if ( bDoIt && nTab >= nTableCount ) // ggf. anhaengen |
| nTab = SC_TAB_APPEND; |
| } |
| else |
| { |
| //CHINA001 ScMoveTableDlg* pDlg = new ScMoveTableDlg( GetDialogParent() ); |
| ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create(); |
| DBG_ASSERT(pFact, "ScAbstractFactory create fail!");//CHINA001 |
| |
| AbstractScMoveTableDlg* pDlg = pFact->CreateScMoveTableDlg( GetDialogParent(), RID_SCDLG_MOVETAB ); |
| DBG_ASSERT(pDlg, "Dialog create fail!");//CHINA001 |
| |
| SCTAB nTableCount = pDoc->GetTableCount(); |
| ScMarkData& rMark = GetViewData()->GetMarkData(); |
| SCTAB nTabSelCount = rMark.GetSelectCount(); |
| |
| |
| if(nTableCount==nTabSelCount) |
| { |
| pDlg->SetCopyTable(); |
| pDlg->EnableCopyTable(sal_False); |
| } |
| if ( pDlg->Execute() == RET_OK ) |
| { |
| nDoc = pDlg->GetSelectedDocument(); |
| nTab = pDlg->GetSelectedTable(); |
| bCpy = pDlg->GetCopyTable(); |
| bDoIt = sal_True; |
| |
| String aFoundDocName; |
| if ( nDoc != SC_DOC_NEW ) |
| { |
| ScDocShell* pSh = ScDocShell::GetShellByNum( nDoc ); |
| if (pSh) |
| { |
| aFoundDocName = pSh->GetTitle(); |
| if ( !pSh->GetDocument()->IsDocEditable() ) |
| { |
| ErrorMessage(STR_READONLYERR); |
| bDoIt = sal_False; |
| } |
| } |
| } |
| rReq.AppendItem( SfxStringItem( FID_TAB_MOVE, aFoundDocName ) ); |
| // Tabelle ist 1-basiert, wenn nicht APPEND |
| SCTAB nBasicTab = ( nTab <= MAXTAB ) ? (nTab+1) : nTab; |
| rReq.AppendItem( SfxUInt16Item( FN_PARAM_1, static_cast<sal_uInt16>(nBasicTab) ) ); |
| rReq.AppendItem( SfxBoolItem( FN_PARAM_2, bCpy ) ); |
| } |
| delete pDlg; |
| } |
| |
| if( bDoIt ) |
| { |
| rReq.Done(); // aufzeichnen, solange das Dokument noch aktiv ist |
| |
| MoveTable( nDoc, nTab, bCpy ); |
| } |
| } |
| break; |
| |
| case FID_DELETE_TABLE: |
| { |
| // Parameter war ueberfluessig, weil die Methode an der Table haengt |
| |
| sal_Bool bDoIt = rReq.IsAPI(); |
| if( !bDoIt ) |
| { |
| // wenn's nicht von Basic kommt, nochmal nachfragen: |
| |
| #if ENABLE_LAYOUT |
| // Using layout::QueryBox without client code modification is |
| // deprecated, rather add HIG-complient buttons with verbs. |
| #define QueryBox( parent, winbits, question ) layout::QueryBox (parent, question, ScGlobal::GetRscString (STR_UNDO_DELETE_TAB)) |
| #endif /* ENABLE_LAYOUT */ |
| |
| bDoIt = ( RET_YES == |
| QueryBox( GetDialogParent(), |
| WinBits( WB_YES_NO | WB_DEF_YES ), |
| ScGlobal::GetRscString(STR_QUERY_DELTAB) |
| ).Execute() ); |
| } |
| if( bDoIt ) |
| { |
| SCTAB nNewTab = nCurrentTab; |
| SCTAB nFirstTab=0; |
| sal_Bool bTabFlag=sal_False; |
| ScMarkData& rMark = pViewData->GetMarkData(); |
| SvShorts TheTabs; |
| for(SCTAB i=0;i<nTabCount;i++) |
| { |
| if(rMark.GetTableSelect(i) &&!pDoc->IsTabProtected(i)) |
| { |
| TheTabs.push_back(i); |
| bTabFlag=sal_True; |
| if(nNewTab==i) nNewTab++; |
| } |
| if(!bTabFlag) nFirstTab=i; |
| } |
| if(nNewTab>=nTabCount) nNewTab=nFirstTab; |
| |
| pViewData->SetTabNo(nNewTab); |
| DeleteTables(TheTabs); |
| TheTabs.clear(); |
| rReq.Done(); |
| } |
| } |
| break; |
| |
| case FID_TAB_RTL: |
| { |
| ScDocShell* pDocSh = pViewData->GetDocShell(); |
| ScDocFunc aFunc(*pDocSh); |
| sal_Bool bSet = !pDoc->IsLayoutRTL( nCurrentTab ); |
| |
| const ScMarkData& rMark = pViewData->GetMarkData(); |
| if ( rMark.GetSelectCount() != 0 ) |
| { |
| // handle several sheets |
| |
| ::svl::IUndoManager* pUndoManager = pDocSh->GetUndoManager(); |
| String aUndo = ScGlobal::GetRscString( STR_UNDO_TAB_RTL ); |
| pUndoManager->EnterListAction( aUndo, aUndo ); |
| |
| for (SCTAB nTab=0; nTab<nTabCount; nTab++) |
| if ( rMark.GetTableSelect(nTab) ) |
| aFunc.SetLayoutRTL( nTab, bSet, sal_False ); |
| |
| pUndoManager->LeaveListAction(); |
| } |
| else |
| aFunc.SetLayoutRTL( nCurrentTab, bSet, sal_False ); |
| } |
| break; |
| |
| case FID_TAB_SET_TAB_BG_COLOR: |
| case FID_TAB_MENU_SET_TAB_BG_COLOR: |
| { |
| if ( nSlot == FID_TAB_MENU_SET_TAB_BG_COLOR ) |
| nSlot = FID_TAB_SET_TAB_BG_COLOR; |
| SCTAB nTabNr = pViewData->GetTabNo(); |
| ScMarkData& rMark = pViewData->GetMarkData(); |
| SCTAB nTabSelCount = rMark.GetSelectCount(); |
| if ( !pDoc->IsDocEditable() ) |
| break; |
| |
| if ( pDoc->IsTabProtected( nTabNr ) ) // ||nTabSelCount > 1 |
| break; |
| |
| if( pReqArgs != NULL ) |
| { |
| sal_Bool bDone = sal_False; |
| const SfxPoolItem* pItem; |
| Color aColor; |
| if( IS_AVAILABLE( FN_PARAM_1, &pItem ) ) |
| nTabNr = ((const SfxUInt16Item*)pItem)->GetValue(); |
| |
| if( IS_AVAILABLE( nSlot, &pItem ) ) |
| aColor = ((const SvxColorItem*)pItem)->GetValue(); |
| |
| if ( nTabSelCount > 1 ) |
| { |
| scoped_ptr<ScUndoTabColorInfo::List> |
| pTabColorList(new ScUndoTabColorInfo::List); |
| for (SCTAB nTab=0; nTab<nTabCount; nTab++) |
| { |
| if ( rMark.GetTableSelect(nTab) && !pDoc->IsTabProtected(nTab) ) |
| { |
| ScUndoTabColorInfo aTabColorInfo(nTab); |
| aTabColorInfo.maNewTabBgColor = aColor; |
| pTabColorList->push_back(aTabColorInfo); |
| } |
| } |
| bDone = SetTabBgColor( *pTabColorList ); |
| } |
| else |
| { |
| bDone = SetTabBgColor( aColor, nCurrentTab ); //ScViewFunc.SetTabBgColor |
| } |
| if( bDone ) |
| { |
| rReq.Done( *pReqArgs ); |
| } |
| } |
| else |
| { |
| sal_uInt16 nRet = RET_OK; /// temp |
| sal_Bool bDone = sal_False; /// temp |
| Color aTabBgColor; |
| Color aNewTabBgColor; |
| |
| aTabBgColor = pDoc->GetTabBgColor( nCurrentTab ); |
| ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create(); |
| DBG_ASSERT(pFact, "ScAbstractFactory create fail!"); |
| AbstractScTabBgColorDlg* pDlg = pFact->CreateScTabBgColorDlg( |
| GetDialogParent(), |
| String(ScResId(SCSTR_SET_TAB_BG_COLOR)), |
| String(ScResId(SCSTR_NO_TAB_BG_COLOR)), |
| aTabBgColor, |
| CMD_FID_TAB_SET_TAB_BG_COLOR, |
| RID_SCDLG_TAB_BG_COLOR); |
| while ( !bDone && nRet == RET_OK ) |
| { |
| nRet = pDlg->Execute(); |
| if( nRet == RET_OK ) |
| { |
| Color aSelectedColor; |
| pDlg->GetSelectedColor(aSelectedColor); |
| scoped_ptr<ScUndoTabColorInfo::List> |
| pTabColorList(new ScUndoTabColorInfo::List); |
| if ( nTabSelCount > 1 ) |
| { |
| for (SCTAB nTab=0; nTab<nTabCount; nTab++) |
| { |
| if ( rMark.GetTableSelect(nTab) && !pDoc->IsTabProtected(nTab) ) |
| { |
| ScUndoTabColorInfo aTabColorInfo(nTab); |
| aTabColorInfo.maNewTabBgColor = aSelectedColor; |
| pTabColorList->push_back(aTabColorInfo); |
| } |
| } |
| bDone = SetTabBgColor( *pTabColorList ); |
| } |
| else |
| { |
| bDone = SetTabBgColor( aSelectedColor, nCurrentTab ); //ScViewFunc.SetTabBgColor |
| } |
| if ( bDone ) |
| { |
| rReq.AppendItem( SvxColorItem( aTabBgColor, nSlot ) ); |
| rReq.Done(); |
| } |
| else |
| { |
| if( rReq.IsAPI() ) |
| { |
| StarBASIC::Error( SbERR_SETPROP_FAILED ); |
| } |
| } |
| } |
| } |
| delete( pDlg ); |
| } |
| } |
| break; |
| |
| case FID_TAB_EVENTS: |
| { |
| ScDocShell* pDocSh = pViewData->GetDocShell(); |
| uno::Reference<container::XNameReplace> xEvents( new ScSheetEventsObj( pDocSh, nCurrentTab ) ); |
| uno::Reference<frame::XFrame> xFrame = GetViewFrame()->GetFrame().GetFrameInterface(); |
| SvxAbstractDialogFactory* pDlgFactory = SvxAbstractDialogFactory::Create(); |
| if (pDlgFactory) |
| { |
| std::auto_ptr<VclAbstractDialog> pDialog( pDlgFactory->CreateSvxMacroAssignDlg( |
| GetDialogParent(), xFrame, false, xEvents, 0 ) ); |
| if ( pDialog.get() && pDialog->Execute() == RET_OK ) |
| { |
| // the dialog modifies the settings directly |
| } |
| } |
| } |
| break; |
| |
| default: |
| DBG_ERROR("Unbekannte Message bei ViewShell"); |
| break; |
| } |
| } |
| |
| //------------------------------------------------------------------ |
| |
| void ScTabViewShell::GetStateTable( SfxItemSet& rSet ) |
| { |
| ScViewData* pViewData = GetViewData(); |
| ScDocument* pDoc = pViewData->GetDocument(); |
| ScDocShell* pDocShell = pViewData->GetDocShell(); |
| ScMarkData& rMark = GetViewData()->GetMarkData(); |
| SCTAB nTab = pViewData->GetTabNo(); |
| |
| SCTAB nTabCount = pDoc->GetTableCount(); |
| SCTAB nTabSelCount = rMark.GetSelectCount(); |
| |
| SfxWhichIter aIter(rSet); |
| sal_uInt16 nWhich = aIter.FirstWhich(); |
| |
| while ( nWhich ) |
| { |
| switch ( nWhich ) |
| { |
| |
| case FID_TABLE_VISIBLE: |
| rSet.Put( SfxBoolItem( nWhich, pDoc->IsVisible(nTab) )); |
| break; |
| |
| case FID_TABLE_HIDE: |
| { |
| sal_uInt16 nVis = 0; |
| for ( SCTAB i=0; i < nTabCount && nVis<2; i++ ) |
| if (pDoc->IsVisible(i)) |
| ++nVis; |
| |
| if ( nVis<2 || !pDoc->IsDocEditable() || nTabSelCount > 1 ) |
| rSet.DisableItem( nWhich ); |
| } |
| break; |
| |
| case FID_TABLE_SHOW: |
| { |
| sal_Bool bHasHidden = sal_False; |
| for ( SCTAB i=0; i < nTabCount && !bHasHidden; i++ ) |
| if (!pDoc->IsVisible(i)) |
| bHasHidden = sal_True; |
| if ( !bHasHidden || pDoc->IsDocProtected() || nTabSelCount > 1 ) |
| rSet.DisableItem( nWhich ); |
| } |
| break; |
| |
| case FID_DELETE_TABLE: |
| { |
| if ( pDoc->GetChangeTrack() ) |
| rSet.DisableItem( nWhich ); |
| else |
| { |
| sal_uInt16 nVis = 0; |
| for ( SCTAB i=0; i < nTabCount && nVis<2; i++ ) |
| if (pDoc->IsVisible(i)) |
| ++nVis; |
| if ( pDoc->IsTabProtected(nTab) |
| || !pDoc->IsDocEditable() |
| || nVis < 2 |
| || nTabSelCount == nTabCount) |
| rSet.DisableItem( nWhich ); |
| } |
| } |
| break; |
| |
| case FID_INS_TABLE: |
| case FID_INS_TABLE_EXT: |
| case FID_TAB_APPEND: |
| if ( !pDoc->IsDocEditable() || |
| nTabCount > MAXTAB || |
| ( nWhich == FID_INS_TABLE_EXT && pDocShell && pDocShell->IsDocShared() ) ) |
| rSet.DisableItem( nWhich ); |
| break; |
| |
| case FID_TAB_MOVE: |
| if ( !pDoc->IsDocEditable() |
| || pDoc->GetChangeTrack() != NULL |
| || nTabCount > MAXTAB) |
| rSet.DisableItem( nWhich ); |
| break; |
| |
| // FID_TAB_MENU_RENAME - "umbenennen" im Menu |
| // FID_TAB_RENAME - "Name"-Property fuer Basic |
| |
| case FID_TAB_MENU_RENAME: |
| if ( !pDoc->IsDocEditable() || |
| pDoc->IsTabProtected(nTab) ||nTabSelCount > 1 || |
| ( pDocShell && pDocShell->IsDocShared() ) ) |
| rSet.DisableItem( nWhich ); |
| break; |
| |
| case FID_TAB_RENAME: |
| { |
| String aTabName; |
| pDoc->GetName( nTab, aTabName ); |
| |
| rSet.Put( SfxStringItem( nWhich, aTabName )); |
| |
| } |
| break; |
| |
| case FID_TAB_RTL: |
| { |
| SvtLanguageOptions aLangOpt; |
| if ( !aLangOpt.IsCTLFontEnabled() ) |
| rSet.DisableItem( nWhich ); |
| else |
| rSet.Put( SfxBoolItem( nWhich, pDoc->IsLayoutRTL( nTab ) ) ); |
| } |
| break; |
| |
| case FID_TAB_MENU_SET_TAB_BG_COLOR: |
| { |
| if ( !pDoc->IsDocEditable() |
| || ( pDocShell && pDocShell->IsDocShared() ) |
| || pDoc->IsTabProtected(nTab) ) |
| rSet.DisableItem( nWhich ); |
| } |
| break; |
| |
| case FID_TAB_SET_TAB_BG_COLOR: |
| { |
| Color aColor; |
| aColor = pDoc->GetTabBgColor( nTab ); |
| rSet.Put( SvxColorItem( aColor, nWhich ) ); |
| } |
| break; |
| } |
| nWhich = aIter.NextWhich(); |
| } |
| } |
| |
| |
| |
| |
