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