LCOV - code coverage report
Current view: top level - sc/source/ui/view - tabvwshf.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 17 446 3.8 %
Date: 2015-06-13 12:38:46 Functions: 3 4 75.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <config_features.h>
      21             : 
      22             : #include <boost/scoped_ptr.hpp>
      23             : 
      24             : #include "scitems.hxx"
      25             : #include <sfx2/request.hxx>
      26             : #include <sfx2/bindings.hxx>
      27             : #include <sfx2/viewfrm.hxx>
      28             : #include <basic/sbstar.hxx>
      29             : #include <svl/languageoptions.hxx>
      30             : #include <svl/stritem.hxx>
      31             : #include <svl/whiter.hxx>
      32             : #include <vcl/msgbox.hxx>
      33             : #include <sfx2/objface.hxx>
      34             : #include <svx/svxdlg.hxx>
      35             : #include <editeng/colritem.hxx>
      36             : 
      37             : #include "tabvwsh.hxx"
      38             : #include "sc.hrc"
      39             : #include "docsh.hxx"
      40             : #include "document.hxx"
      41             : #include "shtabdlg.hxx"
      42             : #include "scresid.hxx"
      43             : #include "globstr.hrc"
      44             : #include "docfunc.hxx"
      45             : #include "eventuno.hxx"
      46             : 
      47             : #include "scabstdlg.hxx"
      48             : 
      49             : #include "tabbgcolor.hxx"
      50             : #include "tabbgcolordlg.hxx"
      51             : #include "sccommands.h"
      52             : #include "markdata.hxx"
      53             : 
      54             : #include <vector>
      55             : 
      56             : using ::boost::scoped_ptr;
      57             : using namespace com::sun::star;
      58             : 
      59           0 : void ScTabViewShell::ExecuteTable( SfxRequest& rReq )
      60             : {
      61           0 :     ScViewData& rViewData   = GetViewData();
      62           0 :     ScDocument* pDoc        = rViewData.GetDocument();
      63             : 
      64           0 :     SCTAB       nCurrentTab = rViewData.GetTabNo();
      65           0 :     SCTAB       nTabCount   = pDoc->GetTableCount();
      66           0 :     sal_uInt16  nSlot       = rReq.GetSlot();
      67           0 :     const SfxItemSet* pReqArgs = rReq.GetArgs();
      68             : 
      69           0 :     HideListBox();                  // Autofilter-DropDown-Listbox
      70             : 
      71           0 :     switch ( nSlot )
      72             :     {
      73             :         case FID_TABLE_VISIBLE:
      74             :             {
      75           0 :                 OUString aName;
      76           0 :                 pDoc->GetName( nCurrentTab, aName );
      77             : 
      78           0 :                 bool bVisible=true;
      79           0 :                 if( pReqArgs != NULL )
      80             :                 {
      81             :                     const SfxPoolItem* pItem;
      82           0 :                     if( pReqArgs->HasItem( FID_TABLE_VISIBLE, &pItem ) )
      83           0 :                         bVisible = static_cast<const SfxBoolItem*>(pItem)->GetValue();
      84             :                 }
      85             : 
      86           0 :                 if( ! bVisible )            // fade out
      87             :                 {
      88           0 :                     if ( pDoc->IsDocEditable() )
      89             :                     {
      90           0 :                         ScMarkData& rMark = rViewData.GetMarkData();
      91           0 :                         HideTable( rMark );
      92             :                     }
      93             :                 }
      94             :                 else                        // fade in
      95             :                 {
      96           0 :                     std::vector<OUString> rNames;
      97           0 :                     rNames.push_back(aName);
      98           0 :                     ShowTable( rNames );
      99           0 :                 }
     100             :             }
     101           0 :             break;
     102             : 
     103             :         case FID_TABLE_HIDE:
     104             :             {
     105           0 :                 if ( pDoc->IsDocEditable() )
     106             :                 {
     107           0 :                     ScMarkData& rMark = rViewData.GetMarkData();
     108           0 :                     HideTable( rMark );
     109             :                 }
     110             :             }
     111           0 :             break;
     112             : 
     113             :         case FID_TABLE_SHOW:
     114             :             {
     115           0 :                 OUString aName;
     116           0 :                 std::vector<OUString> rNames;
     117           0 :                 if ( pReqArgs )
     118             :                 {
     119             :                     const SfxPoolItem* pItem;
     120           0 :                     if( pReqArgs->HasItem( FID_TABLE_SHOW, &pItem ) )
     121             :                     {
     122           0 :                         aName = static_cast<const SfxStringItem*>(pItem)->GetValue();
     123           0 :                         rNames.push_back(aName);
     124           0 :                         ShowTable( rNames );
     125             : 
     126           0 :                         if( ! rReq.IsAPI() )
     127           0 :                             rReq.Done();
     128             :                     }
     129             :                 }
     130             :                 else
     131             :                 {
     132           0 :                     ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
     133             :                     OSL_ENSURE(pFact, "ScAbstractFactory create fail!");
     134             : 
     135           0 :                     boost::scoped_ptr<AbstractScShowTabDlg> pDlg(pFact->CreateScShowTabDlg(GetDialogParent()));
     136             :                     OSL_ENSURE(pDlg, "Dialog create fail!");
     137             : 
     138           0 :                     OUString aTabName;
     139           0 :                     bool bFirst = true;
     140           0 :                     for ( SCTAB i=0; i != nTabCount; i++ )
     141             :                     {
     142           0 :                         if (!pDoc->IsVisible(i))
     143             :                         {
     144           0 :                             pDoc->GetName( i, aTabName );
     145           0 :                             pDlg->Insert( aTabName, bFirst );
     146           0 :                             bFirst = false;
     147             :                         }
     148             :                     }
     149             : 
     150           0 :                     if ( pDlg->Execute() == RET_OK )
     151             :                     {
     152           0 :                         sal_uInt16 nCount = pDlg->GetSelectEntryCount();
     153           0 :                         for (sal_uInt16 nPos=0; nPos<nCount; nPos++)
     154             :                         {
     155           0 :                             aName = pDlg->GetSelectEntry(nPos);
     156           0 :                             rReq.AppendItem( SfxStringItem( FID_TABLE_SHOW, aName ) );
     157           0 :                             rNames.push_back(aName);
     158             :                         }
     159           0 :                         ShowTable( rNames );
     160           0 :                         rReq.Done();
     161           0 :                     }
     162           0 :                 }
     163             :             }
     164           0 :             break;
     165             : 
     166             :         case FID_INS_TABLE:
     167             :         case FID_INS_TABLE_EXT:
     168             :             {
     169           0 :                 ScMarkData& rMark    = rViewData.GetMarkData();
     170           0 :                 SCTAB   nTabSelCount = rMark.GetSelectCount();
     171           0 :                 SCTAB   nTabNr       = nCurrentTab;
     172             : 
     173           0 :                 if ( !pDoc->IsDocEditable() )
     174           0 :                     break;                          // locked
     175             : 
     176           0 :                 if ( pReqArgs != NULL )             // from basic
     177             :                 {
     178           0 :                     bool bOk = false;
     179             :                     const SfxPoolItem*  pTabItem;
     180             :                     const SfxPoolItem*  pNameItem;
     181           0 :                     OUString            aName;
     182             : 
     183           0 :                     if ( pReqArgs->HasItem( FN_PARAM_1, &pTabItem ) &&
     184           0 :                          pReqArgs->HasItem( nSlot, &pNameItem ) )
     185             :                     {
     186             :                         //  tablenumber from basic: 1-based
     187             : 
     188           0 :                         aName = static_cast<const SfxStringItem*>(pNameItem)->GetValue();
     189           0 :                         nTabNr = static_cast<const SfxUInt16Item*>(pTabItem)->GetValue() - 1;
     190           0 :                         if ( nTabNr < nTabCount )
     191           0 :                             bOk = InsertTable( aName, nTabNr );
     192             :                     }
     193             : 
     194           0 :                     if (bOk)
     195           0 :                         rReq.Done( *pReqArgs );
     196             :                     //! else set error
     197             :                 }
     198             :                 else                                // dialog
     199             :                 {
     200           0 :                     ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
     201             :                     OSL_ENSURE(pFact, "ScAbstractFactory create fail!");
     202             : 
     203             :                     boost::scoped_ptr<AbstractScInsertTableDlg> pDlg(pFact->CreateScInsertTableDlg(GetDialogParent(), rViewData,
     204           0 :                         nTabSelCount, nSlot == FID_INS_TABLE_EXT));
     205             :                     OSL_ENSURE(pDlg, "Dialog create fail!");
     206           0 :                     if ( RET_OK == pDlg->Execute() )
     207             :                     {
     208           0 :                         if (pDlg->GetTablesFromFile())
     209             :                         {
     210           0 :                             std::vector<SCTAB> nTabs;
     211           0 :                             sal_uInt16 n = 0;
     212           0 :                             const OUString* pStr = pDlg->GetFirstTable( &n );
     213           0 :                             while ( pStr )
     214             :                             {
     215           0 :                                 nTabs.push_back( static_cast<SCTAB>(n) );
     216           0 :                                 pStr = pDlg->GetNextTable( &n );
     217             :                             }
     218           0 :                             bool bLink = pDlg->GetTablesAsLink();
     219           0 :                             if (!nTabs.empty())
     220             :                             {
     221           0 :                                 if(pDlg->IsTableBefore())
     222             :                                 {
     223           0 :                                     ImportTables( pDlg->GetDocShellTables(), nTabs.size(), &nTabs[0],
     224           0 :                                                 bLink,nTabNr );
     225             :                                 }
     226             :                                 else
     227             :                                 {
     228           0 :                                     SCTAB   nTabAfter    = nTabNr+1;
     229             : 
     230           0 :                                     for(SCTAB j=nCurrentTab+1;j<nTabCount;j++)
     231             :                                     {
     232           0 :                                         if(!pDoc->IsScenario(j))
     233             :                                         {
     234           0 :                                             nTabAfter=j;
     235           0 :                                             break;
     236             :                                         }
     237             :                                     }
     238             : 
     239           0 :                                     ImportTables( pDlg->GetDocShellTables(), nTabs.size(), &nTabs[0],
     240           0 :                                                 bLink,nTabAfter );
     241             :                                 }
     242           0 :                             }
     243             :                         }
     244             :                         else
     245             :                         {
     246           0 :                             SCTAB nCount=pDlg->GetTableCount();
     247           0 :                             if(pDlg->IsTableBefore())
     248             :                             {
     249           0 :                                 if(nCount==1 && !pDlg->GetFirstTable()->isEmpty())
     250             :                                 {
     251           0 :                                     rReq.AppendItem( SfxStringItem( FID_INS_TABLE, *pDlg->GetFirstTable() ) );
     252           0 :                                     rReq.AppendItem( SfxUInt16Item( FN_PARAM_1, static_cast<sal_uInt16>(nTabNr) + 1 ) );        // 1-based
     253           0 :                                     rReq.Done();
     254             : 
     255           0 :                                     InsertTable( *pDlg->GetFirstTable(), nTabNr );
     256             :                                 }
     257             :                                 else
     258             :                                 {
     259           0 :                                     std::vector<OUString> aNames(0);
     260           0 :                                     InsertTables( aNames, nTabNr,nCount );
     261             :                                 }
     262             :                             }
     263             :                             else
     264             :                             {
     265           0 :                                 SCTAB   nTabAfter    = nTabNr+1;
     266           0 :                                 SCTAB nSelHigh = rMark.GetLastSelected();
     267             : 
     268           0 :                                 for(SCTAB j=nSelHigh+1;j<nTabCount;j++)
     269             :                                 {
     270           0 :                                     if(!pDoc->IsScenario(j))
     271             :                                     {
     272           0 :                                         nTabAfter=j;
     273           0 :                                         break;
     274             :                                     }
     275             :                                     else // #101672#; increase nTabAfter, because it is possible that the scenario tables are the last
     276           0 :                                         nTabAfter = j + 1;
     277             :                                 }
     278             : 
     279           0 :                                 if(nCount==1 && !pDlg->GetFirstTable()->isEmpty())
     280             :                                 {
     281           0 :                                     rReq.AppendItem( SfxStringItem( FID_INS_TABLE, *pDlg->GetFirstTable() ) );
     282           0 :                                     rReq.AppendItem( SfxUInt16Item( FN_PARAM_1, static_cast<sal_uInt16>(nTabAfter) + 1 ) );     // 1-based
     283           0 :                                     rReq.Done();
     284             : 
     285           0 :                                     InsertTable( *pDlg->GetFirstTable(), nTabAfter);
     286             :                                 }
     287             :                                 else
     288             :                                 {
     289           0 :                                     std::vector<OUString> aNames(0);
     290           0 :                                     InsertTables( aNames, nTabAfter,nCount);
     291             :                                 }
     292             :                             }
     293             :                         }
     294           0 :                     }
     295             :                 }
     296             :             }
     297           0 :             break;
     298             : 
     299             :         case FID_TAB_APPEND:
     300             :         case FID_TAB_RENAME:
     301             :         case FID_TAB_MENU_RENAME:
     302             :             {
     303             :                 //  FID_TAB_MENU_RENAME - "rename" in menu
     304             :                 //  FID_TAB_RENAME      - "name"-property for basic
     305             :                 //  equal execute, but MENU_RENAME may be disabled inside GetState
     306             : 
     307           0 :                 if ( nSlot == FID_TAB_MENU_RENAME )
     308           0 :                     nSlot = FID_TAB_RENAME;             // equal execute
     309             : 
     310           0 :                 SCTAB nTabNr = rViewData.GetTabNo();
     311           0 :                 ScMarkData& rMark = rViewData.GetMarkData();
     312           0 :                 SCTAB nTabSelCount = rMark.GetSelectCount();
     313             : 
     314           0 :                 if ( !pDoc->IsDocEditable() )
     315           0 :                     break; // evrything locked
     316             : 
     317           0 :                 if ( nSlot != FID_TAB_APPEND &&
     318           0 :                         ( pDoc->IsTabProtected( nTabNr ) || nTabSelCount > 1 ) )
     319           0 :                     break; // no rename
     320             : 
     321           0 :                 if( pReqArgs != NULL )
     322             :                 {
     323           0 :                     bool        bDone   = false;
     324             :                     const SfxPoolItem* pItem;
     325           0 :                     OUString      aName;
     326             : 
     327           0 :                     if( pReqArgs->HasItem( FN_PARAM_1, &pItem ) )
     328           0 :                         nTabNr = static_cast<const SfxUInt16Item*>(pItem)->GetValue();
     329             : 
     330           0 :                     if( pReqArgs->HasItem( nSlot, &pItem ) )
     331           0 :                         aName = static_cast<const SfxStringItem*>(pItem)->GetValue();
     332             : 
     333           0 :                     switch ( nSlot )
     334             :                     {
     335             :                         case FID_TAB_APPEND:
     336           0 :                             bDone = AppendTable( aName );
     337           0 :                             break;
     338             :                         case FID_TAB_RENAME:
     339           0 :                             bDone = RenameTable( aName, nTabNr );
     340           0 :                             break;
     341             :                     }
     342             : 
     343           0 :                     if( bDone )
     344             :                     {
     345           0 :                         rReq.Done( *pReqArgs );
     346           0 :                     }
     347             :                 }
     348             :                 else
     349             :                 {
     350           0 :                     sal_uInt16      nRet    = RET_OK;
     351           0 :                     bool        bDone   = false;
     352           0 :                     OUString      aErrMsg ( ScGlobal::GetRscString( STR_INVALIDTABNAME ) );
     353           0 :                     OUString aName;
     354           0 :                     OUString      aDlgTitle;
     355           0 :                     const sal_Char* pHelpId = 0;
     356             : 
     357           0 :                     switch ( nSlot )
     358             :                     {
     359             :                         case FID_TAB_APPEND:
     360           0 :                             aDlgTitle = OUString(ScResId(SCSTR_APDTABLE));
     361           0 :                             pDoc->CreateValidTabName( aName );
     362           0 :                             pHelpId = HID_SC_APPEND_NAME;
     363           0 :                             break;
     364             : 
     365             :                         case FID_TAB_RENAME:
     366           0 :                             aDlgTitle = OUString(ScResId(SCSTR_RENAMETAB));
     367           0 :                             pDoc->GetName( rViewData.GetTabNo(), aName );
     368           0 :                             pHelpId = HID_SC_RENAME_NAME;
     369           0 :                             break;
     370             :                     }
     371             : 
     372           0 :                     ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
     373             :                     OSL_ENSURE(pFact, "ScAbstractFactory create fail!");
     374             : 
     375             :                     boost::scoped_ptr<AbstractScStringInputDlg> pDlg(pFact->CreateScStringInputDlg(
     376             :                         GetDialogParent(), aDlgTitle, OUString(ScResId(SCSTR_NAME)),
     377             :                         aName, GetStaticInterface()->GetSlot(nSlot)->GetCommand(),
     378           0 :                         pHelpId));
     379             : 
     380             :                     OSL_ENSURE(pDlg, "Dialog create fail!");
     381             : 
     382           0 :                     while ( !bDone && nRet == RET_OK )
     383             :                     {
     384           0 :                         nRet = pDlg->Execute();
     385             : 
     386           0 :                         if ( nRet == RET_OK )
     387             :                         {
     388           0 :                             aName = pDlg->GetInputString();
     389             : 
     390           0 :                             switch ( nSlot )
     391             :                             {
     392             :                                 case FID_TAB_APPEND:
     393           0 :                                     bDone = AppendTable( aName );
     394           0 :                                     break;
     395             :                                 case FID_TAB_RENAME:
     396           0 :                                     bDone = RenameTable( aName, nTabNr );
     397           0 :                                     break;
     398             :                             }
     399             : 
     400           0 :                             if ( bDone )
     401             :                             {
     402           0 :                                 rReq.AppendItem( SfxStringItem( nSlot, aName ) );
     403           0 :                                 rReq.Done();
     404             :                             }
     405             :                             else
     406             :                             {
     407           0 :                                 if( rReq.IsAPI() )
     408             :                                 {
     409             : #if HAVE_FEATURE_SCRIPTING
     410           0 :                                     StarBASIC::Error( SbERR_SETPROP_FAILED ); // XXX error handling???
     411             : #endif
     412             :                                 }
     413             :                                 else
     414             :                                 {
     415           0 :                                     nRet = ScopedVclPtr<MessageDialog>::Create(GetDialogParent(),
     416             :                                                      aErrMsg
     417           0 :                                                    )->Execute();
     418             :                                 }
     419             :                             }
     420             :                         }
     421           0 :                     }
     422             :                 }
     423             :             }
     424           0 :             break;
     425             : 
     426             :         case FID_TAB_MOVE:
     427             :             {
     428           0 :                 if ( pDoc->GetChangeTrack() != NULL )
     429           0 :                     break;    // if ChangeTracking is active, then no TabMove
     430             : 
     431           0 :                 bool   bDoIt = false;
     432           0 :                 sal_uInt16 nDoc = 0;
     433           0 :                 SCTAB nTab = rViewData.GetTabNo();
     434           0 :                 bool   bCpy = false;
     435           0 :                 OUString aDocName;
     436           0 :                 OUString aTabName;
     437             : 
     438           0 :                 if( pReqArgs != NULL )
     439             :                 {
     440           0 :                     SCTAB nTableCount = pDoc->GetTableCount();
     441             :                     const SfxPoolItem* pItem;
     442             : 
     443           0 :                     if( pReqArgs->HasItem( FID_TAB_MOVE, &pItem ) )
     444           0 :                         aDocName = static_cast<const SfxStringItem*>(pItem)->GetValue();
     445           0 :                     if( pReqArgs->HasItem( FN_PARAM_1, &pItem ) )
     446             :                     {
     447             :                         //  table is 1-based
     448           0 :                         nTab = static_cast<const SfxUInt16Item*>(pItem)->GetValue() - 1;
     449           0 :                         if ( nTab >= nTableCount )
     450           0 :                             nTab = SC_TAB_APPEND;
     451             :                     }
     452           0 :                     if( pReqArgs->HasItem( FN_PARAM_2, &pItem ) )
     453           0 :                         bCpy = static_cast<const SfxBoolItem*>(pItem)->GetValue();
     454             : 
     455           0 :                     if (!aDocName.isEmpty())
     456             :                     {
     457           0 :                         SfxObjectShell* pSh     = SfxObjectShell::GetFirst();
     458           0 :                         ScDocShell*     pScSh   = NULL;
     459           0 :                         sal_uInt16          i=0;
     460             : 
     461           0 :                         while ( pSh )
     462             :                         {
     463           0 :                             pScSh = PTR_CAST( ScDocShell, pSh );
     464             : 
     465           0 :                             if( pScSh )
     466             :                             {
     467           0 :                                 pScSh->GetTitle();
     468             : 
     469           0 :                                 if (aDocName.equals(pScSh->GetTitle()))
     470             :                                 {
     471           0 :                                     nDoc = i;
     472           0 :                                     ScDocument& rDestDoc = pScSh->GetDocument();
     473           0 :                                     nTableCount = rDestDoc.GetTableCount();
     474           0 :                                     bDoIt = rDestDoc.IsDocEditable();
     475           0 :                                     break;
     476             :                                 }
     477             : 
     478           0 :                                 i++;        // only count ScDocShell
     479             :                             }
     480           0 :                             pSh = SfxObjectShell::GetNext( *pSh );
     481             :                         }
     482             :                     }
     483             :                     else // no doc-name -> new doc
     484             :                     {
     485           0 :                         nDoc = SC_DOC_NEW;
     486           0 :                         bDoIt = true;
     487             :                     }
     488             : 
     489           0 :                     if ( bDoIt && nTab >= nTableCount )     // if necessary append
     490           0 :                         nTab = SC_TAB_APPEND;
     491             :                 }
     492             :                 else
     493             :                 {
     494           0 :                     OUString aDefaultName;
     495           0 :                     pDoc->GetName( rViewData.GetTabNo(), aDefaultName );
     496             : 
     497           0 :                     ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
     498             :                     OSL_ENSURE(pFact, "ScAbstractFactory create fail!");
     499             : 
     500             :                     boost::scoped_ptr<AbstractScMoveTableDlg> pDlg(pFact->CreateScMoveTableDlg(GetDialogParent(),
     501           0 :                         aDefaultName));
     502             :                     OSL_ENSURE(pDlg, "Dialog create fail!");
     503             : 
     504           0 :                     SCTAB nTableCount = pDoc->GetTableCount();
     505           0 :                     ScMarkData& rMark       = GetViewData().GetMarkData();
     506           0 :                     SCTAB       nTabSelCount = rMark.GetSelectCount();
     507             : 
     508           0 :                     if(nTableCount==nTabSelCount)
     509             :                     {
     510           0 :                         pDlg->SetForceCopyTable();
     511             :                     }
     512             : 
     513             :                     // We support direct renaming of sheet only when one sheet
     514             :                     // is selected.
     515           0 :                     pDlg->EnableRenameTable(nTabSelCount == 1);
     516             : 
     517           0 :                     if ( pDlg->Execute() == RET_OK )
     518             :                     {
     519           0 :                         nDoc = pDlg->GetSelectedDocument();
     520           0 :                         nTab = pDlg->GetSelectedTable();
     521           0 :                         bCpy = pDlg->GetCopyTable();
     522           0 :                         bool bRna = pDlg->GetRenameTable();
     523             :                         // Leave aTabName string empty, when Rename is FALSE.
     524           0 :                         if( bRna )
     525             :                         {
     526           0 :                            pDlg->GetTabNameString( aTabName );
     527             :                         }
     528           0 :                         bDoIt = true;
     529             : 
     530           0 :                         OUString aFoundDocName;
     531           0 :                         if ( nDoc != SC_DOC_NEW )
     532             :                         {
     533           0 :                             ScDocShell* pSh = ScDocShell::GetShellByNum( nDoc );
     534           0 :                             if (pSh)
     535             :                             {
     536           0 :                                 aFoundDocName = pSh->GetTitle();
     537           0 :                                 if ( !pSh->GetDocument().IsDocEditable() )
     538             :                                 {
     539           0 :                                     ErrorMessage(STR_READONLYERR);
     540           0 :                                     bDoIt = false;
     541             :                                 }
     542             :                             }
     543             :                         }
     544           0 :                         rReq.AppendItem( SfxStringItem( FID_TAB_MOVE, aFoundDocName ) );
     545             :                         // 1-based table, if not APPEND
     546           0 :                         SCTAB nBasicTab = ( nTab <= MAXTAB ) ? (nTab+1) : nTab;
     547           0 :                         rReq.AppendItem( SfxUInt16Item( FN_PARAM_1, static_cast<sal_uInt16>(nBasicTab) ) );
     548           0 :                         rReq.AppendItem( SfxBoolItem( FN_PARAM_2, bCpy ) );
     549           0 :                     }
     550             :                 }
     551             : 
     552           0 :                 if( bDoIt )
     553             :                 {
     554           0 :                     rReq.Done();        // record, while doc is active
     555             : 
     556           0 :                     MoveTable( nDoc, nTab, bCpy, &aTabName );
     557           0 :                 }
     558             :             }
     559           0 :             break;
     560             : 
     561             :         case FID_DELETE_TABLE:
     562             :             {
     563             :                 //  unnecessary parameter ->  method depends on table
     564             : 
     565           0 :                 bool bDoIt = rReq.IsAPI();
     566           0 :                 if( !bDoIt )
     567             :                 {
     568             :                     //  source isn't basic -> ask again
     569             : 
     570             :                         bDoIt = ( RET_YES ==
     571           0 :                                   ScopedVclPtr<QueryBox>::Create( GetDialogParent(),
     572             :                                             WinBits( WB_YES_NO | WB_DEF_YES ),
     573           0 :                                             ScGlobal::GetRscString(STR_QUERY_DELTAB)
     574           0 :                                       )->Execute() );
     575             :                 }
     576           0 :                 if( bDoIt )
     577             :                 {
     578           0 :                     SCTAB nNewTab   = nCurrentTab;
     579           0 :                     SCTAB nFirstTab=0;
     580           0 :                     bool   bTabFlag=false;
     581           0 :                     ScMarkData& rMark = rViewData.GetMarkData();
     582           0 :                     std::vector<SCTAB> TheTabs;
     583           0 :                     for(SCTAB i=0;i<nTabCount;i++)
     584             :                     {
     585           0 :                         if(rMark.GetTableSelect(i) &&!pDoc->IsTabProtected(i))
     586             :                         {
     587           0 :                             TheTabs.push_back(i);
     588           0 :                             bTabFlag=true;
     589           0 :                             if(nNewTab==i) nNewTab++;
     590             :                         }
     591           0 :                         if(!bTabFlag) nFirstTab=i;
     592             :                     }
     593           0 :                     if(nNewTab>=nTabCount) nNewTab=nFirstTab;
     594             : 
     595           0 :                     rViewData.SetTabNo(nNewTab);
     596           0 :                     DeleteTables(TheTabs);
     597           0 :                     TheTabs.clear();
     598           0 :                     rReq.Done();
     599             :                 }
     600             :             }
     601           0 :             break;
     602             : 
     603             :         case FID_TAB_RTL:
     604             :             {
     605           0 :                 ScDocShell* pDocSh = rViewData.GetDocShell();
     606           0 :                 ScDocFunc &rFunc = pDocSh->GetDocFunc();
     607           0 :                 bool bSet = !pDoc->IsLayoutRTL( nCurrentTab );
     608             : 
     609           0 :                 const ScMarkData& rMark = rViewData.GetMarkData();
     610           0 :                 if ( rMark.GetSelectCount() != 0 )
     611             :                 {
     612             :                     //  handle several sheets
     613             : 
     614           0 :                     ::svl::IUndoManager* pUndoManager = pDocSh->GetUndoManager();
     615           0 :                     OUString aUndo = ScGlobal::GetRscString( STR_UNDO_TAB_RTL );
     616           0 :                     pUndoManager->EnterListAction( aUndo, aUndo );
     617             : 
     618           0 :                     ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
     619           0 :                     for (; itr != itrEnd; ++itr)
     620           0 :                         rFunc.SetLayoutRTL( *itr, bSet, false );
     621             : 
     622           0 :                     pUndoManager->LeaveListAction();
     623             :                 }
     624             :                 else
     625           0 :                     rFunc.SetLayoutRTL( nCurrentTab, bSet, false );
     626             :             }
     627           0 :             break;
     628             : 
     629             :         case FID_TAB_TOGGLE_GRID:
     630             :             {
     631           0 :                 bool bShowGrid = rViewData.GetShowGrid();
     632           0 :                 rViewData.SetShowGrid(!bShowGrid);
     633           0 :                 SfxBindings& rBindings = GetViewFrame()->GetBindings();
     634           0 :                 rBindings.Invalidate( FID_TAB_TOGGLE_GRID );
     635           0 :                 PaintGrid();
     636           0 :                 rReq.Done();
     637             :             }
     638           0 :             break;
     639             : 
     640             :         case FID_TAB_SET_TAB_BG_COLOR:
     641             :         case FID_TAB_MENU_SET_TAB_BG_COLOR:
     642             :             {
     643           0 :                 if ( nSlot == FID_TAB_MENU_SET_TAB_BG_COLOR )
     644           0 :                     nSlot = FID_TAB_SET_TAB_BG_COLOR;
     645           0 :                 SCTAB nTabNr = rViewData.GetTabNo();
     646           0 :                 ScMarkData& rMark = rViewData.GetMarkData();
     647           0 :                 SCTAB nTabSelCount = rMark.GetSelectCount();
     648           0 :                 if ( !pDoc->IsDocEditable() )
     649           0 :                     break;
     650             : 
     651           0 :                 if ( pDoc->IsTabProtected( nTabNr ) ) // ||nTabSelCount > 1
     652           0 :                     break;
     653             : 
     654           0 :                 if( pReqArgs != NULL )
     655             :                 {
     656           0 :                     bool                bDone = false;
     657             :                     const SfxPoolItem*  pItem;
     658           0 :                     Color               aColor;
     659           0 :                     if( pReqArgs->HasItem( FN_PARAM_1, &pItem ) )
     660           0 :                         nTabNr = static_cast<const SfxUInt16Item*>(pItem)->GetValue();
     661             : 
     662           0 :                     if( pReqArgs->HasItem( nSlot, &pItem ) )
     663           0 :                         aColor = static_cast<const SvxColorItem*>(pItem)->GetValue();
     664             : 
     665           0 :                     if ( nTabSelCount > 1 )
     666             :                     {
     667             :                         scoped_ptr<ScUndoTabColorInfo::List>
     668           0 :                             pTabColorList(new ScUndoTabColorInfo::List);
     669           0 :                         ScMarkData::iterator itr = rMark.begin(), itrEnd = rMark.end();
     670           0 :                         for (; itr != itrEnd; ++itr)
     671             :                         {
     672           0 :                             if ( !pDoc->IsTabProtected(*itr) )
     673             :                             {
     674           0 :                                 ScUndoTabColorInfo aTabColorInfo(*itr);
     675           0 :                                 aTabColorInfo.maNewTabBgColor = aColor;
     676           0 :                                 pTabColorList->push_back(aTabColorInfo);
     677             :                             }
     678             :                         }
     679           0 :                         bDone = SetTabBgColor( *pTabColorList );
     680             :                     }
     681             :                     else
     682             :                     {
     683           0 :                         bDone = SetTabBgColor( aColor, nCurrentTab ); //ScViewFunc.SetTabBgColor
     684             :                     }
     685           0 :                     if( bDone )
     686             :                     {
     687           0 :                         rReq.Done( *pReqArgs );
     688             :                     }
     689             :                 }
     690             :                 else
     691             :                 {
     692           0 :                     sal_uInt16      nRet    = RET_OK; /// temp
     693           0 :                     bool        bDone   = false; /// temp
     694           0 :                     Color       aTabBgColor;
     695             : 
     696           0 :                     aTabBgColor = pDoc->GetTabBgColor( nCurrentTab );
     697           0 :                     ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
     698             :                     OSL_ENSURE(pFact, "ScAbstractFactory create fail!");
     699             :                     boost::scoped_ptr<AbstractScTabBgColorDlg> pDlg(pFact->CreateScTabBgColorDlg(
     700             :                                                                 GetDialogParent(),
     701             :                                                                 OUString(ScResId(SCSTR_SET_TAB_BG_COLOR)),
     702             :                                                                 OUString(ScResId(SCSTR_NO_TAB_BG_COLOR)),
     703             :                                                                 aTabBgColor,
     704           0 :                                                                 CMD_FID_TAB_SET_TAB_BG_COLOR));
     705           0 :                     while ( !bDone && nRet == RET_OK )
     706             :                     {
     707           0 :                         nRet = pDlg->Execute();
     708           0 :                         if( nRet == RET_OK )
     709             :                         {
     710           0 :                             Color aSelectedColor;
     711           0 :                             pDlg->GetSelectedColor(aSelectedColor);
     712             :                             scoped_ptr<ScUndoTabColorInfo::List>
     713           0 :                                 pTabColorList(new ScUndoTabColorInfo::List);
     714           0 :                             if ( nTabSelCount > 1 )
     715             :                             {
     716           0 :                                 ScMarkData::iterator itr = rMark.begin(), itrEnd = rMark.end();
     717           0 :                                 for (; itr != itrEnd; ++itr)
     718             :                                     {
     719           0 :                                         if ( !pDoc->IsTabProtected(*itr) )
     720             :                                         {
     721           0 :                                             ScUndoTabColorInfo aTabColorInfo(*itr);
     722           0 :                                             aTabColorInfo.maNewTabBgColor = aSelectedColor;
     723           0 :                                             pTabColorList->push_back(aTabColorInfo);
     724             :                                         }
     725             :                                     }
     726           0 :                                     bDone = SetTabBgColor( *pTabColorList );
     727             :                                 }
     728             :                                 else
     729             :                                 {
     730           0 :                                     bDone = SetTabBgColor( aSelectedColor, nCurrentTab ); //ScViewFunc.SetTabBgColor
     731             :                                 }
     732           0 :                                 if ( bDone )
     733             :                                 {
     734           0 :                                     rReq.AppendItem( SvxColorItem( aTabBgColor, nSlot ) );
     735           0 :                                     rReq.Done();
     736             :                                 }
     737             :                                 else
     738             :                                 {
     739           0 :                                     if( rReq.IsAPI() )
     740             :                                     {
     741             : #if HAVE_FEATURE_SCRIPTING
     742           0 :                                         StarBASIC::Error( SbERR_SETPROP_FAILED );
     743             : #endif
     744             :                                     }
     745           0 :                                 }
     746             :                             }
     747           0 :                         }
     748             :                     }
     749             :                 }
     750           0 :                 break;
     751             : 
     752             :         case FID_TAB_EVENTS:
     753             :                 {
     754           0 :                     ScDocShell* pDocSh = rViewData.GetDocShell();
     755           0 :                     uno::Reference<container::XNameReplace> xEvents( new ScSheetEventsObj( pDocSh, nCurrentTab ) );
     756           0 :                     uno::Reference<frame::XFrame> xFrame = GetViewFrame()->GetFrame().GetFrameInterface();
     757           0 :                     SvxAbstractDialogFactory* pDlgFactory = SvxAbstractDialogFactory::Create();
     758           0 :                     if (pDlgFactory)
     759             :                     {
     760             :                         boost::scoped_ptr<VclAbstractDialog> pDialog( pDlgFactory->CreateSvxMacroAssignDlg(
     761           0 :                             GetDialogParent(), xFrame, false, xEvents, 0 ) );
     762           0 :                         if ( pDialog.get() && pDialog->Execute() == RET_OK )
     763             :                         {
     764             :                             // the dialog modifies the settings directly
     765           0 :                         }
     766           0 :                     }
     767             :                 }
     768           0 :                 break;
     769             : 
     770             :         default:
     771             :                 OSL_FAIL("Unbekannte Message bei ViewShell");
     772           0 :                 break;
     773             :     }
     774           0 : }
     775             : 
     776         185 : void ScTabViewShell::GetStateTable( SfxItemSet& rSet )
     777             : {
     778         185 :     ScViewData& rViewData   = GetViewData();
     779         185 :     ScDocument* pDoc        = rViewData.GetDocument();
     780         185 :     ScDocShell* pDocShell   = rViewData.GetDocShell();
     781         185 :     ScMarkData& rMark       = GetViewData().GetMarkData();
     782         185 :     SCTAB       nTab        = rViewData.GetTabNo();
     783             : 
     784         185 :     SCTAB nTabCount = pDoc->GetTableCount();
     785         185 :     SCTAB nTabSelCount = rMark.GetSelectCount();
     786             : 
     787         185 :     SfxWhichIter    aIter(rSet);
     788         185 :     sal_uInt16          nWhich = aIter.FirstWhich();
     789             : 
     790         555 :     while ( nWhich )
     791             :     {
     792         185 :         switch ( nWhich )
     793             :         {
     794             : 
     795             :             case FID_TABLE_VISIBLE:
     796           0 :                 rSet.Put( SfxBoolItem( nWhich, pDoc->IsVisible(nTab) ));
     797           0 :                 break;
     798             : 
     799             :             case FID_TABLE_HIDE:
     800             :                 {
     801           0 :                     sal_uInt16 nVis = 0;
     802             :                     // enable menu : check to make sure we won't hide all sheets. we need at least one visible at all times.
     803           0 :                     for ( SCTAB i=0; i < nTabCount && nVis<nTabSelCount + 1; i++ )
     804           0 :                         if (pDoc->IsVisible(i))
     805           0 :                             ++nVis;
     806           0 :                     if ( nVis<=nTabSelCount || !pDoc->IsDocEditable() )
     807           0 :                         rSet.DisableItem( nWhich );
     808             :                 }
     809           0 :                 break;
     810             : 
     811             :             case FID_TABLE_SHOW:
     812             :                 {
     813           0 :                     bool bHasHidden = false;
     814           0 :                     for ( SCTAB i=0; i < nTabCount && !bHasHidden; i++ )
     815           0 :                         if (!pDoc->IsVisible(i))
     816           0 :                             bHasHidden = true;
     817           0 :                     if ( !bHasHidden || pDoc->IsDocProtected() || nTabSelCount > 1 )
     818           0 :                         rSet.DisableItem( nWhich );
     819             :                 }
     820           0 :                 break;
     821             : 
     822             :             case FID_DELETE_TABLE:
     823             :                 {
     824           0 :                     if ( pDoc->GetChangeTrack() )
     825           0 :                         rSet.DisableItem( nWhich );
     826             :                     else
     827             :                     {
     828           0 :                         sal_uInt16 nVis = 0;
     829           0 :                         for ( SCTAB i=0; i < nTabCount && nVis<2; i++ )
     830           0 :                             if (pDoc->IsVisible(i))
     831           0 :                                 ++nVis;
     832           0 :                         if (   pDoc->IsTabProtected(nTab)
     833           0 :                             || !pDoc->IsDocEditable()
     834           0 :                             || nVis < 2
     835           0 :                             || nTabSelCount == nTabCount)
     836           0 :                         rSet.DisableItem( nWhich );
     837             :                     }
     838             :                 }
     839           0 :                 break;
     840             : 
     841             :             case FID_INS_TABLE:
     842             :             case FID_INS_TABLE_EXT:
     843             :             case FID_TAB_APPEND:
     844           0 :                 if ( !pDoc->IsDocEditable() ||
     845           0 :                      nTabCount > MAXTAB ||
     846           0 :                      ( nWhich == FID_INS_TABLE_EXT && pDocShell && pDocShell->IsDocShared() ) )
     847           0 :                     rSet.DisableItem( nWhich );
     848           0 :                 break;
     849             : 
     850             :             case FID_TAB_MOVE:
     851           0 :                 if (   !pDoc->IsDocEditable()
     852           0 :                     || pDoc->GetChangeTrack() != NULL
     853           0 :                     || nTabCount > MAXTAB)
     854           0 :                     rSet.DisableItem( nWhich );
     855           0 :                 break;
     856             : 
     857             :             //  FID_TAB_MENU_RENAME - "rename" from Menu
     858             :             //  FID_TAB_RENAME      - "name"-property for Basic
     859             : 
     860             :             case FID_TAB_MENU_RENAME:
     861           0 :                 if ( !pDoc->IsDocEditable() ||
     862           0 :                      pDoc->IsTabProtected(nTab) ||nTabSelCount > 1 ||
     863           0 :                      ( pDocShell && pDocShell->IsDocShared() ) )
     864           0 :                     rSet.DisableItem( nWhich );
     865           0 :                 break;
     866             : 
     867             :             case FID_TAB_RENAME:
     868             :                 {
     869           0 :                     OUString aTabName;
     870           0 :                     pDoc->GetName( nTab, aTabName );
     871             : 
     872           0 :                     rSet.Put( SfxStringItem( nWhich, aTabName ));
     873             : 
     874             :                 }
     875           0 :                 break;
     876             : 
     877             :             case FID_TAB_RTL:
     878             :                 {
     879           0 :                     SvtLanguageOptions aLangOpt;
     880           0 :                     if ( !aLangOpt.IsCTLFontEnabled() )
     881           0 :                         rSet.DisableItem( nWhich );
     882             :                     else
     883           0 :                         rSet.Put( SfxBoolItem( nWhich, pDoc->IsLayoutRTL( nTab ) ) );
     884             :                 }
     885           0 :                 break;
     886             : 
     887             :             case FID_TAB_MENU_SET_TAB_BG_COLOR:
     888             :                 {
     889           0 :                     if ( !pDoc->IsDocEditable()
     890           0 :                         || ( pDocShell && pDocShell->IsDocShared() )
     891           0 :                         || pDoc->IsTabProtected(nTab) )
     892           0 :                         rSet.DisableItem( nWhich );
     893             :                 }
     894           0 :                 break;
     895             : 
     896             :             case FID_TAB_SET_TAB_BG_COLOR:
     897             :                 {
     898           0 :                     Color aColor;
     899           0 :                     aColor = pDoc->GetTabBgColor( nTab );
     900           0 :                     rSet.Put( SvxColorItem( aColor, nWhich ) );
     901             :                 }
     902           0 :                 break;
     903             : 
     904             :             case FID_TAB_TOGGLE_GRID:
     905         185 :                 rSet.Put( SfxBoolItem(nWhich, rViewData.GetShowGrid()) );
     906         185 :                 break;
     907             :         }
     908         185 :         nWhich = aIter.NextWhich();
     909         185 :     }
     910         341 : }
     911             : 
     912             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11