LibreOffice Module sc (master)  1
formatsh.cxx
Go to the documentation of this file.
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 <com/sun/star/style/XStyleFamiliesSupplier.hpp>
21 #include <com/sun/star/beans/XPropertySet.hpp>
22 #include <com/sun/star/container/XNameAccess.hpp>
23 
24 #include <scitems.hxx>
25 #include <editeng/borderline.hxx>
26 
27 #include <sfx2/viewfrm.hxx>
28 #include <sfx2/bindings.hxx>
29 #include <sfx2/newstyle.hxx>
30 #include <sfx2/objface.hxx>
31 #include <sfx2/request.hxx>
32 #include <sfx2/sfxdlg.hxx>
33 #include <svl/whiter.hxx>
34 
35 #include <svl/stritem.hxx>
36 #include <svl/zformat.hxx>
37 #include <svl/languageoptions.hxx>
38 #include <editeng/boxitem.hxx>
39 #include <editeng/langitem.hxx>
40 #include <svx/numinf.hxx>
41 #include <sfx2/dispatch.hxx>
42 #include <sfx2/tplpitem.hxx>
43 #include <editeng/svxenum.hxx>
44 #include <editeng/wghtitem.hxx>
45 #include <editeng/postitem.hxx>
46 #include <editeng/udlnitem.hxx>
47 #include <editeng/lineitem.hxx>
48 #include <editeng/colritem.hxx>
49 #include <editeng/brushitem.hxx>
50 #include <editeng/frmdiritem.hxx>
51 #include <editeng/scripttypeitem.hxx>
52 #include <editeng/shaditem.hxx>
53 #include <editeng/justifyitem.hxx>
54 #include <editeng/fhgtitem.hxx>
55 #include <sal/log.hxx>
56 #include <comphelper/lok.hxx>
57 #include <LibreOfficeKit/LibreOfficeKitEnums.h>
58 #include <editeng/itemtype.hxx>
59 
60 #include <formatsh.hxx>
61 #include <sc.hrc>
62 #include <globstr.hrc>
63 #include <scresid.hxx>
64 #include <docsh.hxx>
65 #include <patattr.hxx>
66 #include <scmod.hxx>
67 #include <stlpool.hxx>
68 #include <stlsheet.hxx>
69 #include <printfun.hxx>
70 #include <docpool.hxx>
71 #include <tabvwsh.hxx>
72 #include <undostyl.hxx>
73 #include <markdata.hxx>
74 #include <attrib.hxx>
75 
76 #define ShellClass_ScFormatShell
77 #define ShellClass_TableFont
78 #define ShellClass_FormatForSelection
79 #include <scslots.hxx>
80 
81 #include <scabstdlg.hxx>
82 #include <editeng/fontitem.hxx>
83 #include <sfx2/classificationhelper.hxx>
84 
85 #include <memory>
86 
87 using namespace ::com::sun::star;
88 
89 namespace {
90 
91 SvxCellHorJustify lclConvertSlotToHAlign( sal_uInt16 nSlot )
92 {
93  SvxCellHorJustify eHJustify = SvxCellHorJustify::Standard;
94  switch( nSlot )
95  {
96  case SID_ALIGN_ANY_HDEFAULT: eHJustify = SvxCellHorJustify::Standard; break;
97  case SID_ALIGN_ANY_LEFT: eHJustify = SvxCellHorJustify::Left; break;
98  case SID_ALIGN_ANY_HCENTER: eHJustify = SvxCellHorJustify::Center; break;
99  case SID_ALIGN_ANY_RIGHT: eHJustify = SvxCellHorJustify::Right; break;
100  case SID_ALIGN_ANY_JUSTIFIED: eHJustify = SvxCellHorJustify::Block; break;
101  default: OSL_FAIL( "lclConvertSlotToHAlign - invalid slot" );
102  }
103  return eHJustify;
104 }
105 
106 SvxCellVerJustify lclConvertSlotToVAlign( sal_uInt16 nSlot )
107 {
108  SvxCellVerJustify eVJustify = SvxCellVerJustify::Standard;
109  switch( nSlot )
110  {
111  case SID_ALIGN_ANY_VDEFAULT: eVJustify = SvxCellVerJustify::Standard; break;
112  case SID_ALIGN_ANY_TOP: eVJustify = SvxCellVerJustify::Top; break;
113  case SID_ALIGN_ANY_VCENTER: eVJustify = SvxCellVerJustify::Center; break;
114  case SID_ALIGN_ANY_BOTTOM: eVJustify = SvxCellVerJustify::Bottom; break;
115  default: OSL_FAIL( "lclConvertSlotToVAlign - invalid slot" );
116  }
117  return eVJustify;
118 }
119 
120 } // namespace
121 
122 
123 SFX_IMPL_INTERFACE(ScFormatShell, SfxShell)
124 
125 void ScFormatShell::InitInterface_Impl()
126 {
127  GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_OBJECT,
128  SfxVisibilityFlags::Standard | SfxVisibilityFlags::Server,
129  ToolbarId::Objectbar_Format);
130 }
131 
132 ScFormatShell::ScFormatShell(ScViewData* pData) :
133  SfxShell(pData->GetViewShell()),
134  pViewData(pData)
135 {
136  ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
137 
138  SetPool( &pTabViewShell->GetPool() );
139  SfxUndoManager* pMgr = pViewData->GetSfxDocShell()->GetUndoManager();
140  SetUndoManager( pMgr );
141  if ( !pViewData->GetDocument().IsUndoEnabled() )
142  {
143  pMgr->SetMaxUndoActionCount( 0 );
144  }
145  SetName("Format");
146 }
147 
148 ScFormatShell::~ScFormatShell()
149 {
150 }
151 
152 void ScFormatShell::GetStyleState( SfxItemSet& rSet )
153 {
154  ScDocument& rDoc = GetViewData()->GetDocument();
155  ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
156  SfxStyleSheetBasePool* pStylePool = rDoc.GetStyleSheetPool();
157 
158  bool bProtected = false;
159  SCTAB nTabCount = rDoc.GetTableCount();
160  for (SCTAB i=0; i<nTabCount && !bProtected; i++)
161  if (rDoc.IsTabProtected(i)) // look after protected table
162  bProtected = true;
163 
164  SfxWhichIter aIter(rSet);
165  sal_uInt16 nWhich = aIter.FirstWhich();
166  sal_uInt16 nSlotId = 0;
167 
168  while ( nWhich )
169  {
170  nSlotId = SfxItemPool::IsWhich( nWhich )
171  ? GetPool().GetSlotId( nWhich )
172  : nWhich;
173 
174  switch ( nSlotId )
175  {
176  case SID_STYLE_APPLY:
177  if ( !pStylePool )
178  rSet.DisableItem( nSlotId );
179  break;
180 
181  case SID_STYLE_FAMILY2: // cell style sheets
182  {
183  SfxStyleSheet* pStyleSheet = const_cast<SfxStyleSheet*>(
184  pTabViewShell->GetStyleSheetFromMarked());
185 
186  if ( pStyleSheet )
187  rSet.Put( SfxTemplateItem( nSlotId, pStyleSheet->GetName() ) );
188  else
189  rSet.Put( SfxTemplateItem( nSlotId, OUString() ) );
190  }
191  break;
192 
193  case SID_STYLE_FAMILY4: // page style sheets
194  {
195  SCTAB nCurTab = GetViewData()->GetTabNo();
196  OUString aPageStyle = rDoc.GetPageStyle( nCurTab );
197  SfxStyleSheet* pStyleSheet = pStylePool ? static_cast<SfxStyleSheet*>(pStylePool->
198  Find( aPageStyle, SfxStyleFamily::Page )) : nullptr;
199 
200  if ( pStyleSheet )
201  rSet.Put( SfxTemplateItem( nSlotId, aPageStyle ) );
202  else
203  rSet.Put( SfxTemplateItem( nSlotId, OUString() ) );
204  }
205  break;
206 
207  case SID_STYLE_WATERCAN:
208  {
209  rSet.Put( SfxBoolItem( nSlotId, SC_MOD()->GetIsWaterCan() ) );
210  }
211  break;
212 
213  case SID_STYLE_UPDATE_BY_EXAMPLE:
214  {
215  std::unique_ptr<SfxPoolItem> pItem;
216  pTabViewShell->GetViewFrame()->GetBindings().QueryState(SID_STYLE_FAMILY, pItem);
217  SfxUInt16Item* pFamilyItem = dynamic_cast<SfxUInt16Item*>(pItem.get());
218 
219  bool bPage = pFamilyItem && SfxStyleFamily::Page == static_cast<SfxStyleFamily>(pFamilyItem->GetValue());
220 
221  if ( bProtected || bPage )
222  rSet.DisableItem( nSlotId );
223  }
224  break;
225 
226  case SID_STYLE_EDIT:
227  case SID_STYLE_DELETE:
228  case SID_STYLE_HIDE:
229  case SID_STYLE_SHOW:
230  {
231  std::unique_ptr<SfxPoolItem> pItem;
232  pTabViewShell->GetViewFrame()->GetBindings().QueryState(SID_STYLE_FAMILY, pItem);
233  SfxUInt16Item* pFamilyItem = dynamic_cast<SfxUInt16Item*>(pItem.get());
234  bool bPage = pFamilyItem && SfxStyleFamily::Page == static_cast<SfxStyleFamily>(pFamilyItem->GetValue());
235 
236  if ( bProtected && !bPage )
237  rSet.DisableItem( nSlotId );
238  }
239  break;
240 
241  default:
242  break;
243  }
244 
245  nWhich = aIter.NextWhich();
246  }
247 }
248 
249 void ScFormatShell::ExecuteStyle( SfxRequest& rReq )
250 {
251  const SfxItemSet* pArgs = rReq.GetArgs();
252  const sal_uInt16 nSlotId = rReq.GetSlot();
253  if ( !pArgs && nSlotId != SID_STYLE_NEW_BY_EXAMPLE && nSlotId != SID_STYLE_UPDATE_BY_EXAMPLE )
254  {
255  // in case of vertical toolbar
256  pViewData->GetDispatcher().Execute( SID_STYLE_DESIGNER, SfxCallMode::ASYNCHRON | SfxCallMode::RECORD );
257  return;
258  }
259 
260  SfxBindings& rBindings = pViewData->GetBindings();
261  const SCTAB nCurTab = GetViewData()->GetTabNo();
262  ScDocShell* pDocSh = GetViewData()->GetDocShell();
263  ScTabViewShell* pTabViewShell= GetViewData()->GetViewShell();
264  ScDocument& rDoc = pDocSh->GetDocument();
265  ScMarkData& rMark = GetViewData()->GetMarkData();
266  ScModule* pScMod = SC_MOD();
267  OUString aRefName;
268  bool bUndo = rDoc.IsUndoEnabled();
269  SfxStyleSheetBasePool* pStylePool = rDoc.GetStyleSheetPool();
270 
271  if ( (nSlotId == SID_STYLE_PREVIEW)
272  || (nSlotId == SID_STYLE_END_PREVIEW) )
273  {
274  if (nSlotId == SID_STYLE_PREVIEW)
275  {
276  SfxStyleFamily eFamily = SfxStyleFamily::Para;
277  const SfxPoolItem* pFamItem;
278  if ( pArgs && SfxItemState::SET == pArgs->GetItemState( SID_STYLE_FAMILY, true, &pFamItem ) )
279  eFamily = static_cast<SfxStyleFamily>(static_cast<const SfxUInt16Item*>(pFamItem)->GetValue());
280  const SfxPoolItem* pNameItem;
281  OUString aStyleName;
282  if (pArgs && SfxItemState::SET == pArgs->GetItemState( nSlotId, true, &pNameItem ))
283  aStyleName = static_cast<const SfxStringItem*>(pNameItem)->GetValue();
284  if ( eFamily == SfxStyleFamily::Para ) // CellStyles
285  {
286  ScMarkData aFuncMark( pViewData->GetMarkData() );
287  ScViewUtil::UnmarkFiltered( aFuncMark, rDoc );
288  aFuncMark.MarkToMulti();
289 
290  if ( !aFuncMark.IsMarked() && !aFuncMark.IsMultiMarked() )
291  {
292  SCCOL nCol = pViewData->GetCurX();
293  SCROW nRow = pViewData->GetCurY();
294  SCTAB nTab = pViewData->GetTabNo();
295  ScRange aRange( nCol, nRow, nTab );
296  aFuncMark.SetMarkArea( aRange );
297  }
298  rDoc.SetPreviewSelection( aFuncMark );
299  ScStyleSheet* pPreviewStyle = static_cast<ScStyleSheet*>( pStylePool->Find( aStyleName, eFamily ) );
300  rDoc.SetPreviewCellStyle( pPreviewStyle );
301  ScPatternAttr aAttr( *rDoc.GetSelectionPattern( aFuncMark ) );
302  aAttr.SetStyleSheet( pPreviewStyle );
303 
304  SfxItemSet aItemSet( GetPool() );
305 
306  ScPatternAttr aNewAttrs( GetViewData()->GetDocument().GetPool() );
307  SfxItemSet& rNewSet = aNewAttrs.GetItemSet();
308  rNewSet.Put( aItemSet, false );
309 
310  rDoc.ApplySelectionPattern( aNewAttrs, rDoc.GetPreviewSelection() );
311  pTabViewShell->UpdateSelectionArea( aFuncMark, &aAttr );
312  }
313  }
314  else
315  {
316  // No mark at all happens when creating a new document, in which
317  // case the selection pattern obtained would be empty (created of
318  // GetPool()) anyway and nothing needs to be applied.
319  ScMarkData aPreviewMark( rDoc.GetPreviewSelection());
320  if (aPreviewMark.IsMarked() || aPreviewMark.IsMultiMarked())
321  {
322  ScPatternAttr aAttr( *rDoc.GetSelectionPattern( aPreviewMark ) );
323  if ( ScStyleSheet* pPreviewStyle = rDoc.GetPreviewCellStyle() )
324  aAttr.SetStyleSheet( pPreviewStyle );
325  rDoc.SetPreviewCellStyle(nullptr);
326 
327  SfxItemSet aItemSet( GetPool() );
328 
329  ScPatternAttr aNewAttrs( GetViewData()->GetDocument().GetPool() );
330  SfxItemSet& rNewSet = aNewAttrs.GetItemSet();
331  rNewSet.Put( aItemSet, false );
332  rDoc.ApplySelectionPattern( aNewAttrs, aPreviewMark );
333  pTabViewShell->UpdateSelectionArea( aPreviewMark, &aAttr );
334  }
335  }
336  }
337  else if ( (nSlotId == SID_STYLE_NEW)
338  || (nSlotId == SID_STYLE_EDIT)
339  || (nSlotId == SID_STYLE_DELETE)
340  || (nSlotId == SID_STYLE_HIDE)
341  || (nSlotId == SID_STYLE_SHOW)
342  || (nSlotId == SID_STYLE_APPLY)
343  || (nSlotId == SID_STYLE_WATERCAN)
344  || (nSlotId == SID_STYLE_FAMILY)
345  || (nSlotId == SID_STYLE_NEW_BY_EXAMPLE)
346  || (nSlotId == SID_STYLE_UPDATE_BY_EXAMPLE) )
347  {
348  SfxStyleSheetBase* pStyleSheet = nullptr;
349 
350  bool bStyleToMarked = false;
351  bool bListAction = false;
352  bool bAddUndo = false; // add ScUndoModifyStyle (style modified)
353  ScStyleSaveData aOldData; // for undo/redo
354  ScStyleSaveData aNewData;
355 
356  SfxStyleFamily eFamily = SfxStyleFamily::Para;
357  const SfxPoolItem* pFamItem;
358  if ( pArgs && SfxItemState::SET == pArgs->GetItemState( SID_STYLE_FAMILY, true, &pFamItem ) )
359  eFamily = static_cast<SfxStyleFamily>(static_cast<const SfxUInt16Item*>(pFamItem)->GetValue());
360  else if ( pArgs && SfxItemState::SET == pArgs->GetItemState( SID_STYLE_FAMILYNAME, true, &pFamItem ) )
361  {
362  OUString sFamily = static_cast<const SfxStringItem*>(pFamItem)->GetValue();
363  if (sFamily == "CellStyles")
364  eFamily = SfxStyleFamily::Para;
365  else if (sFamily == "PageStyles")
366  eFamily = SfxStyleFamily::Page;
367  }
368 
369  OUString aStyleName;
370  sal_uInt16 nRetMask = 0xffff;
371 
372  switch ( nSlotId )
373  {
374  case SID_STYLE_NEW:
375  {
376  const SfxPoolItem* pNameItem;
377  if (pArgs && SfxItemState::SET == pArgs->GetItemState( nSlotId, true, &pNameItem ))
378  aStyleName = static_cast<const SfxStringItem*>(pNameItem)->GetValue();
379 
380  const SfxPoolItem* pRefItem=nullptr;
381  if (pArgs && SfxItemState::SET == pArgs->GetItemState( SID_STYLE_REFERENCE, true, &pRefItem ))
382  {
383  if(pRefItem!=nullptr)
384  aRefName = static_cast<const SfxStringItem*>(pRefItem)->GetValue();
385  }
386 
387  pStyleSheet = &(pStylePool->Make( aStyleName, eFamily,
388  SfxStyleSearchBits::UserDefined ) );
389 
390  if (pStyleSheet->HasParentSupport())
391  pStyleSheet->SetParent(aRefName);
392  }
393  break;
394 
395  case SID_STYLE_APPLY:
396  {
397  const SfxStringItem* pNameItem = rReq.GetArg<SfxStringItem>(SID_APPLY_STYLE);
398  const SfxStringItem* pFamilyItem = rReq.GetArg<SfxStringItem>(SID_STYLE_FAMILYNAME);
399  if ( pFamilyItem && pNameItem )
400  {
401  css::uno::Reference< css::style::XStyleFamiliesSupplier > xModel(pDocSh->GetModel(), css::uno::UNO_QUERY);
402  try
403  {
404  css::uno::Reference< css::container::XNameAccess > xStyles;
405  css::uno::Reference< css::container::XNameAccess > xCont = xModel->getStyleFamilies();
406  xCont->getByName(pFamilyItem->GetValue()) >>= xStyles;
407  css::uno::Reference< css::beans::XPropertySet > xInfo;
408  xStyles->getByName( pNameItem->GetValue() ) >>= xInfo;
409  OUString aUIName;
410  xInfo->getPropertyValue("DisplayName") >>= aUIName;
411  if ( !aUIName.isEmpty() )
412  rReq.AppendItem( SfxStringItem( SID_STYLE_APPLY, aUIName ) );
413  }
414  catch( css::uno::Exception& )
415  {
416  }
417  }
418  [[fallthrough]];
419  }
420  case SID_STYLE_EDIT:
421  case SID_STYLE_DELETE:
422  case SID_STYLE_HIDE:
423  case SID_STYLE_SHOW:
424  case SID_STYLE_NEW_BY_EXAMPLE:
425  {
426  const SfxPoolItem* pNameItem;
427  if (pArgs && SfxItemState::SET == pArgs->GetItemState( nSlotId, true, &pNameItem ))
428  aStyleName = static_cast<const SfxStringItem*>(pNameItem)->GetValue();
429  else if ( nSlotId == SID_STYLE_NEW_BY_EXAMPLE )
430  {
431  weld::Window* pDialogParent = rReq.GetFrameWeld();
432  if (!pDialogParent)
433  pDialogParent = pTabViewShell->GetFrameWeld();
434  SfxNewStyleDlg aDlg(pDialogParent, *pStylePool, eFamily);
435  if (aDlg.run() != RET_OK)
436  return;
437  aStyleName = aDlg.GetName();
438  }
439 
440  pStyleSheet = pStylePool->Find( aStyleName, eFamily );
441 
442  aOldData.InitFromStyle( pStyleSheet );
443  }
444  break;
445 
446  case SID_STYLE_WATERCAN:
447  {
448  bool bWaterCan = pScMod->GetIsWaterCan();
449 
450  if( !bWaterCan )
451  {
452  const SfxPoolItem* pItem;
453 
454  if ( SfxItemState::SET ==
455  pArgs->GetItemState( nSlotId, true, &pItem ) )
456  {
457  const SfxStringItem* pStrItem = dynamic_cast< const SfxStringItem *>( pItem );
458  if ( pStrItem )
459  {
460  aStyleName = pStrItem->GetValue();
461  pStyleSheet = pStylePool->Find( aStyleName, eFamily );
462 
463  if ( pStyleSheet )
464  {
465  static_cast<ScStyleSheetPool*>(pStylePool)->
466  SetActualStyleSheet( pStyleSheet );
467  rReq.Done();
468  }
469  }
470  }
471  }
472 
473  if ( !bWaterCan && pStyleSheet )
474  {
475  pScMod->SetWaterCan( true );
476  pTabViewShell->SetActivePointer( PointerStyle::Fill );
477  rReq.Done();
478  }
479  else
480  {
481  pScMod->SetWaterCan( false );
482  pTabViewShell->SetActivePointer( PointerStyle::Arrow );
483  rReq.Done();
484  }
485  }
486  break;
487 
488  default:
489  break;
490  }
491 
492  // set new style for paintbrush format mode
493  if ( nSlotId == SID_STYLE_APPLY && pScMod->GetIsWaterCan() && pStyleSheet )
494  static_cast<ScStyleSheetPool*>(pStylePool)->SetActualStyleSheet( pStyleSheet );
495 
496  switch ( eFamily )
497  {
498  case SfxStyleFamily::Para:
499  {
500  switch ( nSlotId )
501  {
502  case SID_STYLE_DELETE:
503  {
504  if ( pStyleSheet )
505  {
506  pTabViewShell->RemoveStyleSheetInUse( pStyleSheet );
507  pStylePool->Remove( pStyleSheet );
508  pTabViewShell->InvalidateAttribs();
509  nRetMask = sal_uInt16(true);
510  bAddUndo = true;
511  rReq.Done();
512  }
513  else
514  nRetMask = sal_uInt16(false);
515  }
516  break;
517 
518  case SID_STYLE_HIDE:
519  case SID_STYLE_SHOW:
520  {
521  if ( pStyleSheet )
522  {
523  pStyleSheet->SetHidden( nSlotId == SID_STYLE_HIDE );
524  pTabViewShell->InvalidateAttribs();
525  rReq.Done();
526  }
527  else
528  nRetMask = sal_uInt16(false);
529  }
530  break;
531 
532  case SID_STYLE_APPLY:
533  {
534  if ( pStyleSheet && !pScMod->GetIsWaterCan() )
535  {
536  // apply style sheet to document
537  pTabViewShell->SetStyleSheetToMarked( static_cast<SfxStyleSheet*>(pStyleSheet) );
538  pTabViewShell->InvalidateAttribs();
539  rReq.Done();
540  }
541  }
542  break;
543 
544  case SID_STYLE_NEW_BY_EXAMPLE:
545  case SID_STYLE_UPDATE_BY_EXAMPLE:
546  {
547  // create/replace style sheet by attributes
548  // at cursor position:
549 
550  const ScPatternAttr* pAttrItem = nullptr;
551 
552  // The query if marked, was always wrong here,
553  // so now no more, and just from the cursor.
554  // If attributes are to be removed from the selection, still need to be
555  // cautious not to adopt items from templates
556  // (GetSelectionPattern also collects items from originals) (# 44748 #)
557  SCCOL nCol = pViewData->GetCurX();
558  SCROW nRow = pViewData->GetCurY();
559  pAttrItem = rDoc.GetPattern( nCol, nRow, nCurTab );
560 
561  SfxItemSet aAttrSet = pAttrItem->GetItemSet();
562  aAttrSet.ClearItem( ATTR_MERGE );
563  aAttrSet.ClearItem( ATTR_MERGE_FLAG );
564 
565  // Do not adopt conditional formatting and validity,
566  // because they can not be edited in the template
567  aAttrSet.ClearItem( ATTR_VALIDDATA );
568  aAttrSet.ClearItem( ATTR_CONDITIONAL );
569 
570  if ( SID_STYLE_NEW_BY_EXAMPLE == nSlotId )
571  {
572  if ( bUndo )
573  {
574  OUString aUndo = ScResId( STR_UNDO_EDITCELLSTYLE );
575  pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo, 0, pTabViewShell->GetViewShellId() );
576  bListAction = true;
577  }
578 
579  bool bConvertBack = false;
580  SfxStyleSheet* pSheetInUse = const_cast<SfxStyleSheet*>(
581  pTabViewShell->GetStyleSheetFromMarked());
582 
583  // when a new style is present and is used in the selection,
584  // then the parent can not be adopted:
585  if ( pStyleSheet && pSheetInUse && pStyleSheet == pSheetInUse )
586  pSheetInUse = nullptr;
587 
588  // if already present, first remove ...
589  if ( pStyleSheet )
590  {
591  // style pointer to names before erase,
592  // otherwise cells will get invalid pointer
594  rDoc.StylesToNames();
595  bConvertBack = true;
596  pStylePool->Remove(pStyleSheet);
597  }
598 
599  // ...and create new
600  pStyleSheet = &pStylePool->Make( aStyleName, eFamily,
601  SfxStyleSearchBits::UserDefined );
602 
603  // when a style is present, then this will become
604  // the parent of the new style:
605  if ( pSheetInUse && pStyleSheet->HasParentSupport() )
606  pStyleSheet->SetParent( pSheetInUse->GetName() );
607 
608  if ( bConvertBack )
609  // Name to style pointer
610  rDoc.UpdStlShtPtrsFrmNms();
611  else
612  rDoc.GetPool()->CellStyleCreated( aStyleName, rDoc );
613 
614  // Adopt attribute and use style
615  pStyleSheet->GetItemSet().Put( aAttrSet );
616  pTabViewShell->UpdateStyleSheetInUse( pStyleSheet );
617 
618  // call SetStyleSheetToMarked after adding the ScUndoModifyStyle
619  // (pStyleSheet pointer is used!)
620  bStyleToMarked = true;
621  }
622  else // ( nSlotId == SID_STYLE_UPDATE_BY_EXAMPLE )
623  {
624  pStyleSheet = const_cast<SfxStyleSheet*>(pTabViewShell->GetStyleSheetFromMarked());
625 
626  if ( pStyleSheet )
627  {
628  aOldData.InitFromStyle( pStyleSheet );
629 
630  if ( bUndo )
631  {
632  OUString aUndo = ScResId( STR_UNDO_EDITCELLSTYLE );
633  pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo, 0, pTabViewShell->GetViewShellId() );
634  bListAction = true;
635  }
636 
637  pStyleSheet->GetItemSet().Put( aAttrSet );
638  pTabViewShell->UpdateStyleSheetInUse( pStyleSheet );
639 
640  // call SetStyleSheetToMarked after adding the ScUndoModifyStyle
641  // (pStyleSheet pointer is used!)
642  bStyleToMarked = true;
643  }
644  }
645 
646  aNewData.InitFromStyle( pStyleSheet );
647  bAddUndo = true;
648  rReq.Done();
649  }
650  break;
651 
652  default:
653  break;
654  }
655  } // case SfxStyleFamily::Para:
656  break;
657 
658  case SfxStyleFamily::Page:
659  {
660  switch ( nSlotId )
661  {
662  case SID_STYLE_DELETE:
663  {
664  nRetMask = sal_uInt16( nullptr != pStyleSheet );
665  if ( pStyleSheet )
666  {
667  if ( rDoc.RemovePageStyleInUse( pStyleSheet->GetName() ) )
668  {
669  ScPrintFunc( pDocSh, pTabViewShell->GetPrinter(true), nCurTab ).UpdatePages();
670  rBindings.Invalidate( SID_STATUS_PAGESTYLE );
671  rBindings.Invalidate( FID_RESET_PRINTZOOM );
672  }
673  pStylePool->Remove( pStyleSheet );
674  rBindings.Invalidate( SID_STYLE_FAMILY4 );
675  pDocSh->SetDocumentModified();
676  bAddUndo = true;
677  rReq.Done();
678  }
679  }
680  break;
681 
682  case SID_STYLE_HIDE:
683  case SID_STYLE_SHOW:
684  {
685  nRetMask = sal_uInt16( nullptr != pStyleSheet );
686  if ( pStyleSheet )
687  {
688  pStyleSheet->SetHidden( nSlotId == SID_STYLE_HIDE );
689  rBindings.Invalidate( SID_STYLE_FAMILY4 );
690  pDocSh->SetDocumentModified();
691  rReq.Done();
692  }
693  }
694  break;
695 
696  case SID_STYLE_APPLY:
697  {
698  nRetMask = sal_uInt16( nullptr != pStyleSheet );
699  if ( pStyleSheet && !pScMod->GetIsWaterCan() )
700  {
701  std::unique_ptr<ScUndoApplyPageStyle> pUndoAction;
702  SCTAB nTabCount = rDoc.GetTableCount();
703  for (const auto& rTab : rMark)
704  {
705  if (rTab >= nTabCount)
706  break;
707  OUString aOldName = rDoc.GetPageStyle( rTab );
708  if ( aOldName != aStyleName )
709  {
710  rDoc.SetPageStyle( rTab, aStyleName );
711  ScPrintFunc( pDocSh, pTabViewShell->GetPrinter(true), rTab ).UpdatePages();
712  if( !pUndoAction )
713  pUndoAction.reset(new ScUndoApplyPageStyle( pDocSh, aStyleName ));
714  pUndoAction->AddSheetAction( rTab, aOldName );
715  }
716  }
717  if( pUndoAction )
718  {
719  pDocSh->GetUndoManager()->AddUndoAction( std::move(pUndoAction) );
720  pDocSh->SetDocumentModified();
721  rBindings.Invalidate( SID_STYLE_FAMILY4 );
722  rBindings.Invalidate( SID_STATUS_PAGESTYLE );
723  rBindings.Invalidate( FID_RESET_PRINTZOOM );
724  }
725  rReq.Done();
726  }
727  }
728  break;
729 
730  case SID_STYLE_NEW_BY_EXAMPLE:
731  {
732  const OUString& rStrCurStyle = rDoc.GetPageStyle( nCurTab );
733 
734  if ( rStrCurStyle != aStyleName )
735  {
736  SfxStyleSheetBase* pCurStyle = pStylePool->Find( rStrCurStyle, eFamily );
737  SfxItemSet aAttrSet = pCurStyle->GetItemSet();
738  SCTAB nInTab;
739  bool bUsed = rDoc.IsPageStyleInUse( aStyleName, &nInTab );
740 
741  // if already present, first remove...
742  if ( pStyleSheet )
743  pStylePool->Remove( pStyleSheet );
744 
745  // ...and create new
746  pStyleSheet = &pStylePool->Make( aStyleName, eFamily,
747  SfxStyleSearchBits::UserDefined );
748 
749  // Adopt attribute
750  pStyleSheet->GetItemSet().Put( aAttrSet );
751  pDocSh->SetDocumentModified();
752 
753  // If being used -> Update
754  if ( bUsed )
755  ScPrintFunc( pDocSh, pTabViewShell->GetPrinter(true), nInTab ).UpdatePages();
756 
757  aNewData.InitFromStyle( pStyleSheet );
758  bAddUndo = true;
759  rReq.Done();
760  nRetMask = sal_uInt16(true);
761  }
762  }
763  break;
764 
765  default:
766  break;
767  } // switch ( nSlotId )
768  } // case SfxStyleFamily::Page:
769  break;
770 
771  default:
772  break;
773  } // switch ( eFamily )
774 
775  // create new or process through Dialog:
776  if ( nSlotId == SID_STYLE_NEW || nSlotId == SID_STYLE_EDIT )
777  {
778  if ( pStyleSheet )
779  {
780  SfxStyleFamily eFam = pStyleSheet->GetFamily();
781  ScopedVclPtr<SfxAbstractTabDialog> pDlg;
782  bool bPage = false;
783 
784  // Store old Items from the style
785  SfxItemSet aOldSet = pStyleSheet->GetItemSet();
786  OUString aOldName = pStyleSheet->GetName();
787 
788  switch ( eFam )
789  {
790  case SfxStyleFamily::Page:
791  bPage = true;
792  break;
793 
794  case SfxStyleFamily::Para:
795  default:
796  {
797  SfxItemSet& rSet = pStyleSheet->GetItemSet();
798 
799  const SfxPoolItem* pItem;
800  if ( rSet.GetItemState( ATTR_VALUE_FORMAT,
801  false, &pItem ) == SfxItemState::SET )
802  {
803  // Produce and format NumberFormat Value from Value and Language
804  sal_uLong nFormat =
805  static_cast<const SfxUInt32Item*>(pItem)->GetValue();
806  LanguageType eLang =
807  rSet.Get(ATTR_LANGUAGE_FORMAT ).GetLanguage();
808  sal_uLong nLangFormat = rDoc.GetFormatTable()->
809  GetFormatForLanguageIfBuiltIn( nFormat, eLang );
810  if ( nLangFormat != nFormat )
811  {
812  SfxUInt32Item aNewItem( ATTR_VALUE_FORMAT, nLangFormat );
813  rSet.Put( aNewItem );
814  aOldSet.Put( aNewItem );
815  // Also in aOldSet for comparison after the dialog,
816  // Otherwise might miss a language change
817  }
818  }
819 
820  std::unique_ptr<SvxNumberInfoItem> pNumberInfoItem(
821  ScTabViewShell::MakeNumberInfoItem(rDoc, GetViewData()));
822 
823  pDocSh->PutItem( *pNumberInfoItem );
824  bPage = false;
825 
826  // Definitely a SvxBoxInfoItem with Table = sal_False in set:
827  // (If there is no item, the dialogue will also delete the
828  // BORDER_OUTER SvxBoxItem from the Template Set)
829  if ( rSet.GetItemState( ATTR_BORDER_INNER, false ) != SfxItemState::SET )
830  {
831  SvxBoxInfoItem aBoxInfoItem( ATTR_BORDER_INNER );
832  aBoxInfoItem.SetTable(false); // no inner lines
833  aBoxInfoItem.SetDist(true);
834  aBoxInfoItem.SetMinDist(false);
835  rSet.Put( aBoxInfoItem );
836  }
837  }
838  break;
839  }
840 
841  pTabViewShell->SetInFormatDialog(true);
842 
843  SfxItemSet& rStyleSet = pStyleSheet->GetItemSet();
844  rStyleSet.MergeRange( XATTR_FILL_FIRST, XATTR_FILL_LAST );
845 
846  ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
847 
848  weld::Window* pDialogParent = rReq.GetFrameWeld();
849  if (!pDialogParent)
850  pDialogParent = pTabViewShell->GetFrameWeld();
851  pDlg.disposeAndReset(pFact->CreateScStyleDlg(pDialogParent, *pStyleSheet, bPage));
852  short nResult = pDlg->Execute();
853  pTabViewShell->SetInFormatDialog(false);
854 
855  if ( nResult == RET_OK )
856  {
857  const SfxItemSet* pOutSet = pDlg->GetOutputItemSet();
858 
859  if ( pOutSet )
860  {
861  nRetMask = sal_uInt16(pStyleSheet->GetMask());
862 
863  // Attribute comparisons (earlier in ModifyStyleSheet) now here
864  // with the old values (the style is already changed)
865  if ( SfxStyleFamily::Para == eFam )
866  {
867  SfxItemSet& rNewSet = pStyleSheet->GetItemSet();
868  bool bNumFormatChanged;
869  if ( ScGlobal::CheckWidthInvalidate(
870  bNumFormatChanged, rNewSet, aOldSet ) )
871  rDoc.InvalidateTextWidth( nullptr, nullptr, bNumFormatChanged );
872 
873  SCTAB nTabCount = rDoc.GetTableCount();
874  for (SCTAB nTab=0; nTab<nTabCount; nTab++)
875  rDoc.SetStreamValid(nTab, false);
876 
877  sal_uLong nOldFormat = aOldSet.Get( ATTR_VALUE_FORMAT ).GetValue();
878  sal_uLong nNewFormat = rNewSet.Get( ATTR_VALUE_FORMAT ).GetValue();
879  if ( nNewFormat != nOldFormat )
880  {
881  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
882  const SvNumberformat* pOld = pFormatter->GetEntry( nOldFormat );
883  const SvNumberformat* pNew = pFormatter->GetEntry( nNewFormat );
884  if ( pOld && pNew && pOld->GetLanguage() != pNew->GetLanguage() )
885  rNewSet.Put( SvxLanguageItem(
886  pNew->GetLanguage(), ATTR_LANGUAGE_FORMAT ) );
887  }
888 
889  rDoc.GetPool()->CellStyleCreated( pStyleSheet->GetName(), rDoc );
890  }
891  else
892  {
894 
895  OUString aNewName = pStyleSheet->GetName();
896  if ( aNewName != aOldName &&
897  rDoc.RenamePageStyleInUse( aOldName, aNewName ) )
898  {
899  rBindings.Invalidate( SID_STATUS_PAGESTYLE );
900  rBindings.Invalidate( FID_RESET_PRINTZOOM );
901  }
902 
903  rDoc.ModifyStyleSheet( *pStyleSheet, *pOutSet );
904  rBindings.Invalidate( FID_RESET_PRINTZOOM );
905  }
906 
907  pDocSh->SetDocumentModified();
908 
909  if ( SfxStyleFamily::Para == eFam )
910  {
911  ScTabViewShell::UpdateNumberFormatter(
912  *( pDocSh->GetItem(SID_ATTR_NUMBERFORMAT_INFO) ));
913 
914  pTabViewShell->UpdateStyleSheetInUse( pStyleSheet );
915  pTabViewShell->InvalidateAttribs();
916  }
917 
918  aNewData.InitFromStyle( pStyleSheet );
919  bAddUndo = true;
920  }
921  }
922  else
923  {
924  if ( nSlotId == SID_STYLE_NEW )
925  pStylePool->Remove( pStyleSheet );
926  else
927  {
928  // If in the meantime something was painted with the
929  // temporary changed item set
930  pDocSh->PostPaintGridAll();
931  }
932  }
933  }
934  }
935 
936  rReq.SetReturnValue( SfxUInt16Item( nSlotId, nRetMask ) );
937 
938  if ( bAddUndo && bUndo)
939  pDocSh->GetUndoManager()->AddUndoAction(
940  std::make_unique<ScUndoModifyStyle>( pDocSh, eFamily, aOldData, aNewData ) );
941 
942  if ( bStyleToMarked )
943  {
944  // call SetStyleSheetToMarked after adding the ScUndoModifyStyle,
945  // so redo will find the modified style
946  pTabViewShell->SetStyleSheetToMarked( static_cast<SfxStyleSheet*>(pStyleSheet) );
947  pTabViewShell->InvalidateAttribs();
948  }
949 
950  if ( bListAction )
951  pDocSh->GetUndoManager()->LeaveListAction();
952  }
953  else if (nSlotId == SID_CLASSIFICATION_APPLY)
954  {
955  const SfxPoolItem* pItem = nullptr;
956  if (pArgs && pArgs->GetItemState(nSlotId, false, &pItem) == SfxItemState::SET)
957  {
958  const OUString& rName = static_cast<const SfxStringItem*>(pItem)->GetValue();
959  SfxClassificationHelper aHelper(pDocSh->getDocProperties());
960  auto eType = SfxClassificationPolicyType::IntellectualProperty;
961  if (pArgs->GetItemState(SID_TYPE_NAME, false, &pItem) == SfxItemState::SET)
962  {
963  const OUString& rType = static_cast<const SfxStringItem*>(pItem)->GetValue();
964  eType = SfxClassificationHelper::stringToPolicyType(rType);
965  }
966  aHelper.SetBACName(rName, eType);
967  }
968  else
969  SAL_WARN("sc.ui", "missing parameter for SID_CLASSIFICATION_APPLY");
970  }
971  else
972  {
973  OSL_FAIL( "Unknown slot (ScViewShell::ExecuteStyle)" );
974  }
975 }
976 
977 void ScFormatShell::ExecuteNumFormat( SfxRequest& rReq )
978 {
979  ScModule* pScMod = SC_MOD();
980  ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
981  const SfxItemSet* pReqArgs = rReq.GetArgs();
982  sal_uInt16 nSlot = rReq.GetSlot();
983  SfxBindings& rBindings = pTabViewShell->GetViewFrame()->GetBindings();
984 
985  pTabViewShell->HideListBox(); // Autofilter-DropDown-Listbox
986 
987  // End input
988  if ( GetViewData()->HasEditView( GetViewData()->GetActivePart() ) )
989  {
990  switch ( nSlot )
991  {
992  case SID_NUMBER_TYPE_FORMAT:
993  case SID_NUMBER_TWODEC:
994  case SID_NUMBER_SCIENTIFIC:
995  case SID_NUMBER_DATE:
996  case SID_NUMBER_CURRENCY:
997  case SID_NUMBER_PERCENT:
998  case SID_NUMBER_STANDARD:
999  case SID_NUMBER_FORMAT:
1000  case SID_NUMBER_INCDEC:
1001  case SID_NUMBER_DECDEC:
1002  case SID_NUMBER_THOUSANDS:
1003  case FID_DEFINE_NAME:
1004  case FID_ADD_NAME:
1005  case FID_USE_NAME:
1006  case FID_INSERT_NAME:
1007  case SID_SPELL_DIALOG:
1008  case SID_HANGUL_HANJA_CONVERSION:
1009 
1010  pScMod->InputEnterHandler();
1011  pTabViewShell->UpdateInputHandler();
1012  break;
1013 
1014  default:
1015  break;
1016  }
1017  }
1018 
1019  SvNumFormatType nType = GetCurrentNumberFormatType();
1020  switch ( nSlot )
1021  {
1022  case SID_NUMBER_TWODEC:
1023  {
1024  const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
1025  sal_uInt32 nNumberFormat = rAttrSet.Get(ATTR_VALUE_FORMAT).GetValue();
1026 
1027  if ((nType & SvNumFormatType::NUMBER) && nNumberFormat == 4)
1028  pTabViewShell->SetNumberFormat( SvNumFormatType::NUMBER );
1029  else
1030  pTabViewShell->SetNumberFormat( SvNumFormatType::NUMBER, 4 );
1031  rBindings.Invalidate( nSlot );
1032  rReq.Done();
1033  }
1034  break;
1035  case SID_NUMBER_SCIENTIFIC:
1036  if (nType & SvNumFormatType::SCIENTIFIC)
1037  pTabViewShell->SetNumberFormat( SvNumFormatType::NUMBER );
1038  else
1039  pTabViewShell->SetNumberFormat( SvNumFormatType::SCIENTIFIC );
1040  rBindings.Invalidate( nSlot );
1041  rReq.Done();
1042  break;
1043  case SID_NUMBER_DATE:
1044  if (nType & SvNumFormatType::DATE)
1045  pTabViewShell->SetNumberFormat( SvNumFormatType::NUMBER );
1046  else
1047  pTabViewShell->SetNumberFormat( SvNumFormatType::DATE );
1048  rBindings.Invalidate( nSlot );
1049  rReq.Done();
1050  break;
1051  case SID_NUMBER_TIME:
1052  if (nType & SvNumFormatType::TIME)
1053  pTabViewShell->SetNumberFormat( SvNumFormatType::NUMBER );
1054  else
1055  pTabViewShell->SetNumberFormat( SvNumFormatType::TIME );
1056  rBindings.Invalidate( nSlot );
1057  rReq.Done();
1058  break;
1059  case SID_NUMBER_CURRENCY:
1060  if(pReqArgs)
1061  {
1062  const SfxPoolItem* pItem;
1063  if ( pReqArgs->HasItem( SID_NUMBER_CURRENCY, &pItem ) )
1064  {
1065  sal_uInt32 nNewFormat = static_cast<const SfxUInt32Item*>(pItem)->GetValue();
1066  ScDocument& rDoc = pViewData->GetDocument();
1067  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
1068  const SfxItemSet& rOldSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
1069 
1070  LanguageType eOldLang = rOldSet.Get( ATTR_LANGUAGE_FORMAT ).GetLanguage();
1071  sal_uInt32 nOldFormat = rOldSet.Get( ATTR_VALUE_FORMAT ).GetValue();
1072 
1073  if ( nOldFormat != nNewFormat )
1074  {
1075  const SvNumberformat* pNewEntry = pFormatter->GetEntry( nNewFormat );
1076  ScPatternAttr aNewAttrs( rDoc.GetPool() );
1077  SfxItemSet& rSet = aNewAttrs.GetItemSet();
1078  LanguageType eNewLang = pNewEntry ? pNewEntry->GetLanguage() : LANGUAGE_DONTKNOW;
1079  if ( eNewLang != eOldLang && eNewLang != LANGUAGE_DONTKNOW )
1080  rSet.Put( SvxLanguageItem( eNewLang, ATTR_LANGUAGE_FORMAT ) );
1081  rSet.Put( SfxUInt32Item( ATTR_VALUE_FORMAT, nNewFormat ) );
1082  pTabViewShell->ApplySelectionPattern( aNewAttrs );
1083  }
1084  else
1085  pTabViewShell->SetNumberFormat( SvNumFormatType::NUMBER );
1086  }
1087  }
1088  else
1089  {
1090  if ( nType & SvNumFormatType::CURRENCY )
1091  pTabViewShell->SetNumberFormat( SvNumFormatType::NUMBER );
1092  else
1093  pTabViewShell->SetNumberFormat( SvNumFormatType::CURRENCY );
1094  }
1095  rBindings.Invalidate( nSlot );
1096  rReq.Done();
1097  break;
1098  case SID_NUMBER_PERCENT:
1099  if (nType & SvNumFormatType::PERCENT)
1100  pTabViewShell->SetNumberFormat( SvNumFormatType::NUMBER );
1101  else
1102  pTabViewShell->SetNumberFormat( SvNumFormatType::PERCENT );
1103  rBindings.Invalidate( nSlot );
1104  rReq.Done();
1105  break;
1106  case SID_NUMBER_STANDARD:
1107  pTabViewShell->SetNumberFormat( SvNumFormatType::NUMBER );
1108  rReq.Done();
1109  break;
1110  case SID_NUMBER_INCDEC:
1111  pTabViewShell->ChangeNumFmtDecimals( true );
1112  rReq.Done();
1113  break;
1114  case SID_NUMBER_DECDEC:
1115  pTabViewShell->ChangeNumFmtDecimals( false );
1116  rReq.Done();
1117  break;
1118  case SID_NUMBER_THOUSANDS:
1119  {
1120  ScDocument& rDoc = pViewData->GetDocument();
1121  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
1122  sal_uInt32 nCurrentNumberFormat;
1123  bool bThousand(false);
1124  bool bNegRed(false);
1125  sal_uInt16 nPrecision(0);
1126  sal_uInt16 nLeadZeroes(0);
1127  LanguageType eLanguage = ScGlobal::eLnge;
1128 
1129  rDoc.GetNumberFormat(pViewData->GetCurX(), pViewData->GetCurY(), pViewData->GetTabNo(), nCurrentNumberFormat);
1130  const SvNumberformat* pEntry = pFormatter->GetEntry(nCurrentNumberFormat);
1131 
1132  if (pEntry)
1133  eLanguage = pEntry->GetLanguage();
1134 
1135  pFormatter->GetFormatSpecialInfo(nCurrentNumberFormat, bThousand, bNegRed, nPrecision, nLeadZeroes);
1136  bThousand = !bThousand;
1137  OUString aCode = pFormatter->GenerateFormat(
1138  nCurrentNumberFormat,
1139  eLanguage,
1140  bThousand,
1141  bNegRed,
1142  nPrecision,
1143  nLeadZeroes);
1144  pTabViewShell->SetNumFmtByStr(aCode);
1145 
1146  rBindings.Invalidate(nSlot);
1147  rReq.Done();
1148  }
1149  break;
1150  case SID_NUMBER_FORMAT:
1151  // symphony version with format interpretation
1152  if(pReqArgs)
1153  {
1154  const SfxPoolItem* pItem;
1155  ScDocument& rDoc = pViewData->GetDocument();
1156  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
1157  sal_uInt32 nCurrentNumberFormat;
1158 
1159  rDoc.GetNumberFormat(pViewData->GetCurX(), pViewData->GetCurY(), pViewData->GetTabNo(), nCurrentNumberFormat);
1160  const SvNumberformat* pEntry = pFormatter->GetEntry(nCurrentNumberFormat);
1161 
1162  if(!pEntry)
1163  break;
1164 
1165  LanguageType eLanguage = pEntry->GetLanguage();
1166  SvNumFormatType eType = pEntry->GetMaskedType();
1167 
1168  //Just use eType to judge whether the command is fired for NUMBER/PERCENT/CURRENCY/SCIENTIFIC/FRACTION/TIME
1169  //In sidebar, users can fire SID_NUMBER_FORMAT command by operating the related UI controls before they are disable
1170  if(!(eType == SvNumFormatType::ALL
1171  || eType == SvNumFormatType::NUMBER
1172  || eType == SvNumFormatType::PERCENT
1173  || eType == SvNumFormatType::CURRENCY
1174  || eType == SvNumFormatType::SCIENTIFIC
1175  || eType == SvNumFormatType::TIME
1176  || eType == SvNumFormatType::FRACTION))
1177  pEntry = nullptr;
1178 
1179  if(SfxItemState::SET == pReqArgs->GetItemState(nSlot, true, &pItem) && pEntry)
1180  {
1181  OUString aCode = static_cast<const SfxStringItem*>(pItem)->GetValue();
1182  sal_uInt16 aLen = aCode.getLength();
1183  std::unique_ptr<OUString[]> sFormat( new OUString[4] );
1184  OUStringBuffer sTmpStr;
1185  sal_uInt16 nCount(0);
1186  sal_uInt16 nStrCount(0);
1187 
1188  while(nCount < aLen)
1189  {
1190  sal_Unicode cChar = aCode[nCount];
1191 
1192  if(cChar == ',')
1193  {
1194  sFormat[nStrCount] = sTmpStr.makeStringAndClear();
1195  nStrCount++;
1196  }
1197  else
1198  {
1199  sTmpStr.append(cChar);
1200  }
1201 
1202  nCount++;
1203 
1204  if(nStrCount > 3)
1205  break;
1206  }
1207 
1208  const bool bThousand = static_cast<bool>(sFormat[0].toInt32());
1209  const bool bNegRed = static_cast<bool>(sFormat[1].toInt32());
1210  const sal_uInt16 nPrecision = static_cast<sal_uInt16>(sFormat[2].toInt32());
1211  const sal_uInt16 nLeadZeroes = static_cast<sal_uInt16>(sFormat[3].toInt32());
1212 
1213  aCode = pFormatter->GenerateFormat(
1214  nCurrentNumberFormat,//modify
1215  eLanguage,
1216  bThousand,
1217  bNegRed,
1218  nPrecision,
1219  nLeadZeroes);
1220  pTabViewShell->SetNumFmtByStr(aCode);
1221  }
1222  }
1223  break;
1224 
1225  case SID_ATTR_NUMBERFORMAT_VALUE:
1226  if ( pReqArgs )
1227  {
1228  const SfxPoolItem* pItem;
1229  if ( pReqArgs->GetItemState( ATTR_VALUE_FORMAT, true, &pItem ) == SfxItemState::SET )
1230  {
1231  // We have to accomplish this using ApplyAttributes()
1232  // because we also need the language information to be
1233  // considered.
1234  const SfxItemSet& rOldSet =
1235  pTabViewShell->GetSelectionPattern()->GetItemSet();
1236  SfxItemPool* pDocPool = GetViewData()->GetDocument().GetPool();
1237  SfxItemSet aNewSet( *pDocPool, svl::Items<ATTR_PATTERN_START, ATTR_PATTERN_END>{} );
1238  aNewSet.Put( *pItem );
1239  pTabViewShell->ApplyAttributes( &aNewSet, &rOldSet );
1240  }
1241  }
1242  break;
1243 
1244  case SID_NUMBER_TYPE_FORMAT:
1245  if ( pReqArgs )
1246  {
1247  const SfxPoolItem* pItem;
1248  if ( pReqArgs->GetItemState( nSlot, true, &pItem ) == SfxItemState::SET )
1249  {
1250  sal_uInt16 nFormat = static_cast<const SfxInt16Item *>(pItem)->GetValue();
1251  switch(nFormat)
1252  {
1253  case 0:
1254  pTabViewShell->SetNumberFormat( SvNumFormatType::NUMBER); //Modify
1255  break;
1256  case 1:
1257  pTabViewShell->SetNumberFormat( SvNumFormatType::NUMBER, 2 ); //Modify
1258  break;
1259  case 2:
1260  pTabViewShell->SetNumberFormat( SvNumFormatType::PERCENT );
1261  break;
1262  case 3:
1263  pTabViewShell->SetNumberFormat( SvNumFormatType::CURRENCY );
1264  break;
1265  case 4:
1266  pTabViewShell->SetNumberFormat( SvNumFormatType::DATE );
1267  break;
1268  case 5:
1269  pTabViewShell->SetNumberFormat( SvNumFormatType::TIME );
1270  break;
1271  case 6:
1272  pTabViewShell->SetNumberFormat( SvNumFormatType::SCIENTIFIC );
1273  break;
1274  case 7:
1275  pTabViewShell->SetNumberFormat( SvNumFormatType::FRACTION );
1276  break;
1277  case 8:
1278  pTabViewShell->SetNumberFormat( SvNumFormatType::LOGICAL );
1279  break;
1280  case 9:
1281  pTabViewShell->SetNumberFormat( SvNumFormatType::TEXT );
1282  break;
1283  default:
1284  ;
1285  }
1286  rReq.Done();
1287  }
1288  }
1289  break;
1290 
1291  default:
1292  OSL_FAIL("ExecuteEdit: invalid slot");
1293  break;
1294  }
1295 }
1296 
1297 void ScFormatShell::ExecuteAlignment( SfxRequest& rReq )
1298 {
1299  ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
1300  SfxBindings& rBindings = pViewData->GetBindings();
1301  const SfxItemSet* pSet = rReq.GetArgs();
1302  sal_uInt16 nSlot = rReq.GetSlot();
1303 
1304  pTabViewShell->HideListBox(); // Autofilter-DropDown-Listbox
1305 
1306  switch( nSlot )
1307  {
1308  // pseudo slots for Format menu
1309  case SID_ALIGN_ANY_HDEFAULT:
1310  case SID_ALIGN_ANY_LEFT:
1311  case SID_ALIGN_ANY_HCENTER:
1312  case SID_ALIGN_ANY_RIGHT:
1313  case SID_ALIGN_ANY_JUSTIFIED:
1314  pTabViewShell->ApplyAttr( SvxHorJustifyItem( lclConvertSlotToHAlign( nSlot ), ATTR_HOR_JUSTIFY ) );
1315  break;
1316  case SID_ALIGN_ANY_VDEFAULT:
1317  case SID_ALIGN_ANY_TOP:
1318  case SID_ALIGN_ANY_VCENTER:
1319  case SID_ALIGN_ANY_BOTTOM:
1320  pTabViewShell->ApplyAttr( SvxVerJustifyItem( lclConvertSlotToVAlign( nSlot ), ATTR_VER_JUSTIFY ) );
1321  break;
1322 
1323  default:
1324  if( pSet )
1325  {
1326  const SfxPoolItem* pItem = nullptr;
1327  if( pSet->GetItemState(GetPool().GetWhich(nSlot), true, &pItem ) == SfxItemState::SET )
1328  {
1329 
1330  switch ( nSlot )
1331  {
1332  case SID_ATTR_ALIGN_HOR_JUSTIFY:
1333  case SID_ATTR_ALIGN_VER_JUSTIFY:
1334  case SID_ATTR_ALIGN_INDENT:
1335  case SID_ATTR_ALIGN_HYPHENATION:
1336  case SID_ATTR_ALIGN_DEGREES:
1337  case SID_ATTR_ALIGN_LOCKPOS:
1338  case SID_ATTR_ALIGN_MARGIN:
1339  case SID_ATTR_ALIGN_STACKED:
1340  pTabViewShell->ApplyAttr( *pItem );
1341  break;
1342 
1343  case SID_H_ALIGNCELL:
1344  {
1345  SvxCellHorJustify eJust = static_cast<const SvxHorJustifyItem*>(pItem)->GetValue();
1346  // #i78476# update alignment of text in cell edit mode
1347  pTabViewShell->UpdateInputHandlerCellAdjust( eJust );
1348  pTabViewShell->ApplyAttr( SvxHorJustifyItem( eJust, ATTR_HOR_JUSTIFY ) );
1349  }
1350  break;
1351  case SID_V_ALIGNCELL:
1352  pTabViewShell->ApplyAttr( SvxVerJustifyItem( static_cast<const SvxVerJustifyItem*>(pItem)->GetValue(), ATTR_VER_JUSTIFY ) );
1353  break;
1354  default:
1355  OSL_FAIL( "ExecuteAlignment: invalid slot" );
1356  return;
1357  }
1358  }
1359  }
1360  }
1361  rBindings.Invalidate( SID_ATTR_PARA_ADJUST_LEFT );
1362  rBindings.Invalidate( SID_ATTR_PARA_ADJUST_RIGHT );
1363  rBindings.Invalidate( SID_ATTR_PARA_ADJUST_BLOCK );
1364  rBindings.Invalidate( SID_ATTR_PARA_ADJUST_CENTER);
1365  rBindings.Invalidate( SID_ALIGNLEFT );
1366  rBindings.Invalidate( SID_ALIGNRIGHT );
1367  rBindings.Invalidate( SID_ALIGNCENTERHOR );
1368  rBindings.Invalidate( SID_ALIGNBLOCK );
1369  rBindings.Invalidate( SID_ALIGNTOP );
1370  rBindings.Invalidate( SID_ALIGNBOTTOM );
1371  rBindings.Invalidate( SID_ALIGNCENTERVER );
1372  rBindings.Invalidate( SID_V_ALIGNCELL );
1373  rBindings.Invalidate( SID_H_ALIGNCELL );
1374  // pseudo slots for Format menu
1375  rBindings.Invalidate( SID_ALIGN_ANY_HDEFAULT );
1376  rBindings.Invalidate( SID_ALIGN_ANY_LEFT );
1377  rBindings.Invalidate( SID_ALIGN_ANY_HCENTER );
1378  rBindings.Invalidate( SID_ALIGN_ANY_RIGHT );
1379  rBindings.Invalidate( SID_ALIGN_ANY_JUSTIFIED );
1380  rBindings.Invalidate( SID_ALIGN_ANY_VDEFAULT );
1381  rBindings.Invalidate( SID_ALIGN_ANY_TOP );
1382  rBindings.Invalidate( SID_ALIGN_ANY_VCENTER );
1383  rBindings.Invalidate( SID_ALIGN_ANY_BOTTOM );
1384  rBindings.Update();
1385 
1386  if( ! rReq.IsAPI() )
1387  rReq.Done();
1388 }
1389 
1390 void ScFormatShell::ExecuteTextAttr( SfxRequest& rReq )
1391 {
1392  ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
1393  SfxBindings& rBindings = pViewData->GetBindings();
1394  const ScPatternAttr* pAttrs = pTabViewShell->GetSelectionPattern();
1395  const SfxItemSet* pSet = rReq.GetArgs();
1396  sal_uInt16 nSlot = rReq.GetSlot();
1397  std::unique_ptr<SfxAllItemSet> pNewSet;
1398 
1399  pTabViewShell->HideListBox(); // Autofilter-DropDown-Listbox
1400 
1401  if ( (nSlot == SID_ATTR_CHAR_WEIGHT)
1402  ||(nSlot == SID_ATTR_CHAR_POSTURE)
1403  ||(nSlot == SID_ATTR_CHAR_UNDERLINE)
1404  ||(nSlot == SID_ULINE_VAL_NONE)
1405  ||(nSlot == SID_ULINE_VAL_SINGLE)
1406  ||(nSlot == SID_ULINE_VAL_DOUBLE)
1407  ||(nSlot == SID_ULINE_VAL_DOTTED) )
1408  {
1409  pNewSet.reset(new SfxAllItemSet( GetPool() ));
1410 
1411  switch ( nSlot )
1412  {
1413  case SID_ATTR_CHAR_WEIGHT:
1414  {
1415  // #i78017 establish the same behaviour as in Writer
1416  SvtScriptType nScript = SvtScriptType::LATIN | SvtScriptType::ASIAN | SvtScriptType::COMPLEX;
1417 
1418  SfxItemPool& rPool = GetPool();
1419  SvxScriptSetItem aSetItem( nSlot, rPool );
1420  if ( pSet )
1421  aSetItem.PutItemForScriptType( nScript, pSet->Get( ATTR_FONT_WEIGHT ) );
1422  else
1423  {
1424  // toggle manually
1425 
1426  FontWeight eWeight = WEIGHT_BOLD;
1427  SvxScriptSetItem aOldSetItem( nSlot, rPool );
1428  aOldSetItem.GetItemSet().Put( pAttrs->GetItemSet(), false );
1429  const SfxPoolItem* pCore = aOldSetItem.GetItemOfScript( nScript );
1430  if ( pCore && static_cast<const SvxWeightItem*>(pCore)->GetWeight() == WEIGHT_BOLD )
1431  eWeight = WEIGHT_NORMAL;
1432 
1433  aSetItem.PutItemForScriptType( nScript, SvxWeightItem( eWeight, ATTR_FONT_WEIGHT ) );
1434  }
1435  pTabViewShell->ApplyUserItemSet( aSetItem.GetItemSet() );
1436  pNewSet->Put( aSetItem.GetItemSet(), false );
1437  }
1438  break;
1439 
1440  case SID_ATTR_CHAR_POSTURE:
1441  {
1442  // #i78017 establish the same behaviour as in Writer
1443  SvtScriptType nScript = SvtScriptType::LATIN | SvtScriptType::ASIAN | SvtScriptType::COMPLEX;
1444 
1445  SfxItemPool& rPool = GetPool();
1446  SvxScriptSetItem aSetItem( nSlot, rPool );
1447  if ( pSet )
1448  aSetItem.PutItemForScriptType( nScript, pSet->Get( ATTR_FONT_POSTURE ) );
1449  else
1450  {
1451  // toggle manually
1452 
1453  FontItalic eItalic = ITALIC_NORMAL;
1454  SvxScriptSetItem aOldSetItem( nSlot, rPool );
1455  aOldSetItem.GetItemSet().Put( pAttrs->GetItemSet(), false );
1456  const SfxPoolItem* pCore = aOldSetItem.GetItemOfScript( nScript );
1457  if ( pCore && static_cast<const SvxPostureItem*>(pCore)->GetPosture() == ITALIC_NORMAL )
1458  eItalic = ITALIC_NONE;
1459 
1460  aSetItem.PutItemForScriptType( nScript, SvxPostureItem( eItalic, ATTR_FONT_POSTURE ) );
1461  }
1462  pTabViewShell->ApplyUserItemSet( aSetItem.GetItemSet() );
1463  pNewSet->Put( aSetItem.GetItemSet(), false );
1464  }
1465  break;
1466 
1467  case SID_ATTR_CHAR_UNDERLINE:
1468  {
1469  if( pSet )
1470  {
1471  const SfxPoolItem& rUnderline = pSet->Get( ATTR_FONT_UNDERLINE );
1472 
1473  if( dynamic_cast<const SvxUnderlineItem*>( &rUnderline) != nullptr )
1474  {
1475  pTabViewShell->ApplyAttr( rUnderline );
1476  pNewSet->Put( rUnderline,rUnderline.Which() );
1477  }
1478  else if ( dynamic_cast<const SvxTextLineItem*>( &rUnderline) != nullptr )
1479  {
1480  // #i106580# also allow SvxTextLineItem (base class of SvxUnderlineItem)
1481  const SvxTextLineItem& rTextLineItem = static_cast<const SvxTextLineItem&>(rUnderline);
1482  SvxUnderlineItem aNewItem( rTextLineItem.GetLineStyle(), rTextLineItem.Which() );
1483  aNewItem.SetColor( rTextLineItem.GetColor() );
1484  pTabViewShell->ApplyAttr( aNewItem );
1485  pNewSet->Put( aNewItem, aNewItem.Which() );
1486  }
1487  }
1488  else
1489  {
1490  SvxUnderlineItem aUnderline( pAttrs->GetItem( ATTR_FONT_UNDERLINE ) );
1491  FontLineStyle eUnderline = (LINESTYLE_NONE != aUnderline.GetLineStyle())
1492  ? LINESTYLE_NONE
1493  : LINESTYLE_SINGLE;
1494  aUnderline.SetLineStyle( eUnderline );
1495  pTabViewShell->ApplyAttr( aUnderline );
1496  pNewSet->Put( aUnderline,aUnderline.Which() );
1497  }
1498  }
1499  break;
1500 
1501  case SID_ULINE_VAL_NONE:
1502  pTabViewShell->ApplyAttr( SvxUnderlineItem( LINESTYLE_NONE, ATTR_FONT_UNDERLINE ) );
1503  break;
1504  case SID_ULINE_VAL_SINGLE: // Toggles
1505  case SID_ULINE_VAL_DOUBLE:
1506  case SID_ULINE_VAL_DOTTED:
1507  {
1508  FontLineStyle eOld = pAttrs->GetItem(ATTR_FONT_UNDERLINE).GetLineStyle();
1509  FontLineStyle eNew = eOld;
1510  switch (nSlot)
1511  {
1512  case SID_ULINE_VAL_SINGLE:
1513  eNew = ( eOld == LINESTYLE_SINGLE ) ? LINESTYLE_NONE : LINESTYLE_SINGLE;
1514  break;
1515  case SID_ULINE_VAL_DOUBLE:
1516  eNew = ( eOld == LINESTYLE_DOUBLE ) ? LINESTYLE_NONE : LINESTYLE_DOUBLE;
1517  break;
1518  case SID_ULINE_VAL_DOTTED:
1519  eNew = ( eOld == LINESTYLE_DOTTED ) ? LINESTYLE_NONE : LINESTYLE_DOTTED;
1520  break;
1521  }
1522  pTabViewShell->ApplyAttr( SvxUnderlineItem( eNew, ATTR_FONT_UNDERLINE ) );
1523  }
1524  break;
1525 
1526  default:
1527  break;
1528  }
1529  rBindings.Invalidate( nSlot );
1530  }
1531  else
1532  {
1533  /*
1534  * "Self-made" functionality of radio buttons
1535  * At the toggle the default state is used, this means
1536  * no button was clicked.
1537  */
1538 
1539  const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
1540  const SfxPoolItem* pItem = nullptr;
1541  const SvxHorJustifyItem* pHorJustify = nullptr;
1542  const SvxVerJustifyItem* pVerJustify = nullptr;
1543  SvxCellHorJustify eHorJustify = SvxCellHorJustify::Standard;
1544  SvxCellVerJustify eVerJustify = SvxCellVerJustify::Standard;
1545 
1546  if (rAttrSet.GetItemState(ATTR_HOR_JUSTIFY, true,&pItem ) == SfxItemState::SET)
1547  {
1548  pHorJustify = static_cast<const SvxHorJustifyItem*>(pItem);
1549  eHorJustify = pHorJustify->GetValue();
1550  }
1551  if (rAttrSet.GetItemState(ATTR_VER_JUSTIFY, true,&pItem ) == SfxItemState::SET)
1552  {
1553  pVerJustify = static_cast<const SvxVerJustifyItem*>(pItem);
1554  eVerJustify = pVerJustify->GetValue();
1555  }
1556 
1557  switch ( nSlot )
1558  {
1559  case SID_ALIGNLEFT:
1560  rReq.SetSlot( SID_H_ALIGNCELL );
1561  rReq.AppendItem( SvxHorJustifyItem(
1562  !pHorJustify || (eHorJustify != SvxCellHorJustify::Left) ?
1563  SvxCellHorJustify::Left : SvxCellHorJustify::Standard, SID_H_ALIGNCELL ) );
1564  ExecuteSlot( rReq, GetInterface() );
1565  return;
1566 
1567  case SID_ALIGNRIGHT:
1568  rReq.SetSlot( SID_H_ALIGNCELL );
1569  rReq.AppendItem( SvxHorJustifyItem(
1570  !pHorJustify || (eHorJustify != SvxCellHorJustify::Right) ?
1571  SvxCellHorJustify::Right : SvxCellHorJustify::Standard, SID_H_ALIGNCELL ) );
1572  ExecuteSlot( rReq, GetInterface() );
1573  return;
1574 
1575  case SID_ALIGNCENTERHOR:
1576  rReq.SetSlot( SID_H_ALIGNCELL );
1577  rReq.AppendItem( SvxHorJustifyItem(
1578  !pHorJustify || (eHorJustify != SvxCellHorJustify::Center) ?
1579  SvxCellHorJustify::Center : SvxCellHorJustify::Standard, SID_H_ALIGNCELL ) );
1580  ExecuteSlot( rReq, GetInterface() );
1581  return;
1582 
1583  case SID_ALIGNBLOCK:
1584  rReq.SetSlot( SID_H_ALIGNCELL );
1585  rReq.AppendItem( SvxHorJustifyItem(
1586  !pHorJustify || (eHorJustify != SvxCellHorJustify::Block) ?
1587  SvxCellHorJustify::Block : SvxCellHorJustify::Standard, SID_H_ALIGNCELL ) );
1588  ExecuteSlot( rReq, GetInterface() );
1589  return;
1590 
1591  case SID_ALIGNTOP:
1592  rReq.SetSlot( SID_V_ALIGNCELL );
1593  rReq.AppendItem( SvxVerJustifyItem(
1594  !pVerJustify || (eVerJustify != SvxCellVerJustify::Top) ?
1595  SvxCellVerJustify::Top : SvxCellVerJustify::Standard, SID_V_ALIGNCELL ) );
1596  ExecuteSlot( rReq, GetInterface() );
1597  return;
1598 
1599  case SID_ALIGNBOTTOM:
1600  rReq.SetSlot( SID_V_ALIGNCELL );
1601  rReq.AppendItem( SvxVerJustifyItem(
1602  !pVerJustify || (eVerJustify != SvxCellVerJustify::Bottom) ?
1603  SvxCellVerJustify::Bottom : SvxCellVerJustify::Standard, SID_V_ALIGNCELL ) );
1604  ExecuteSlot( rReq, GetInterface() );
1605  return;
1606 
1607  case SID_ALIGNCENTERVER:
1608  rReq.SetSlot( SID_V_ALIGNCELL );
1609  rReq.AppendItem( SvxVerJustifyItem(
1610  !pVerJustify || (eVerJustify != SvxCellVerJustify::Center) ?
1611  SvxCellVerJustify::Center : SvxCellVerJustify::Standard, SID_V_ALIGNCELL ) );
1612  ExecuteSlot( rReq, GetInterface() );
1613  return;
1614 
1615  default:
1616  break;
1617  }
1618 
1619  }
1620 
1621  rBindings.Update();
1622 
1623  if( pNewSet )
1624  {
1625  rReq.Done( *pNewSet );
1626  pNewSet.reset();
1627  }
1628  else
1629  {
1630  rReq.Done();
1631  }
1632 
1633 }
1634 
1635 namespace
1636 {
1637  bool lcl_getColorFromStr(const SfxItemSet *pArgs, Color &rColor)
1638  {
1639  const SfxPoolItem* pColorStringItem = nullptr;
1640 
1641  if (pArgs && SfxItemState::SET == pArgs->GetItemState(SID_ATTR_COLOR_STR, false, &pColorStringItem) && pColorStringItem)
1642  {
1643  OUString sColor;
1644  sColor = static_cast<const SfxStringItem*>(pColorStringItem)->GetValue();
1645 
1646  if (sColor == "transparent")
1647  rColor = COL_TRANSPARENT;
1648  else
1649  rColor = Color(sColor.toInt32(16));
1650  return true;
1651  }
1652  return false;
1653  }
1654 }
1655 
1656 void ScFormatShell::ExecuteAttr( SfxRequest& rReq )
1657 {
1658  ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
1659  SfxBindings& rBindings = pViewData->GetBindings();
1660  const SfxItemSet* pNewAttrs = rReq.GetArgs();
1661  sal_uInt16 nSlot = rReq.GetSlot();
1662 
1663  pTabViewShell->HideListBox(); // Autofilter-DropDown-Listbox
1664  ScDocument& rDoc = GetViewData()->GetDocument();
1665  if ( !pNewAttrs )
1666  {
1667  switch ( nSlot )
1668  {
1669  case SID_GROW_FONT_SIZE:
1670  case SID_SHRINK_FONT_SIZE:
1671  {
1672  SfxItemPool& rPool = GetPool();
1673  SvxScriptSetItem aSetItem( SID_ATTR_CHAR_FONTHEIGHT, rPool );
1674  aSetItem.GetItemSet().Put( pTabViewShell->GetSelectionPattern()->GetItemSet(), false );
1675 
1676  SvtScriptType nScriptTypes = pTabViewShell->GetSelectionScriptType();
1677  const SvxFontHeightItem* pSize( static_cast<const SvxFontHeightItem*>( aSetItem.GetItemOfScript( nScriptTypes ) ) );
1678 
1679  if ( pSize )
1680  {
1681  SvxFontHeightItem aSize( *pSize );
1682  sal_uInt32 nSize = aSize.GetHeight();
1683 
1684  const sal_uInt32 nFontInc = 40; // 2pt
1685  const sal_uInt32 nFontMaxSz = 19998; // 999.9pt
1686  if ( nSlot == SID_GROW_FONT_SIZE )
1687  nSize = std::min< sal_uInt32 >( nSize + nFontInc, nFontMaxSz );
1688  else
1689  nSize = std::max< sal_Int32 >( nSize - nFontInc, nFontInc );
1690 
1691  aSize.SetHeight( nSize );
1692  aSetItem.PutItemForScriptType( nScriptTypes, aSize );
1693  pTabViewShell->ApplyUserItemSet( aSetItem.GetItemSet() );
1694  }
1695  rBindings.Invalidate( SID_ATTR_CHAR_FONTHEIGHT );
1696  }
1697  break;
1698 
1699  case SID_ATTR_CHAR_ENDPREVIEW_FONT:
1700  {
1701  rDoc.SetPreviewFont(nullptr);
1702  pTabViewShell->UpdateSelectionArea( rDoc.GetPreviewSelection() );
1703  break;
1704  }
1705  case SID_ATTR_CHAR_COLOR:
1706  case SID_ATTR_CHAR_FONT:
1707  case SID_ATTR_CHAR_FONTHEIGHT:
1708  pTabViewShell->ExecuteCellFormatDlg(rReq, "font"); // when ToolBar is vertical
1709  break;
1710 
1711  case SID_BACKGROUND_COLOR:
1712  {
1713  SvxBrushItem aBrushItem(
1714  pTabViewShell->GetSelectionPattern()->GetItem( ATTR_BACKGROUND ) );
1715  aBrushItem.SetColor( COL_TRANSPARENT );
1716  pTabViewShell->ApplyAttr( aBrushItem, false );
1717  }
1718  break;
1719 
1720  case SID_ATTR_ALIGN_LINEBREAK: // without parameter as toggle
1721  {
1722  const ScPatternAttr* pAttrs = pTabViewShell->GetSelectionPattern();
1723  bool bOld = pAttrs->GetItem(ATTR_LINEBREAK).GetValue();
1724  ScLineBreakCell aBreakItem(!bOld);
1725  pTabViewShell->ApplyAttr( aBreakItem );
1726 
1727  SfxAllItemSet aNewSet( GetPool() );
1728  aNewSet.Put( aBreakItem,aBreakItem.Which() );
1729  rReq.Done( aNewSet );
1730 
1731  rBindings.Invalidate( nSlot );
1732  }
1733  break;
1734 
1735  case SID_SCATTR_CELLPROTECTION: // without parameter as toggle
1736  {
1737  const ScPatternAttr* pAttrs = pTabViewShell->GetSelectionPattern();
1738  bool bProtect = pAttrs->GetItem(ATTR_PROTECTION).GetProtection();
1739  bool bHideFormula = pAttrs->GetItem(ATTR_PROTECTION).GetHideFormula();
1740  bool bHideCell = pAttrs->GetItem(ATTR_PROTECTION).GetHideCell();
1741  bool bHidePrint = pAttrs->GetItem(ATTR_PROTECTION).GetHidePrint();
1742 
1743  ScProtectionAttr aProtectionItem( !bProtect, bHideFormula, bHideCell, bHidePrint );
1744  pTabViewShell->ApplyAttr( aProtectionItem );
1745 
1746  SfxAllItemSet aNewSet( GetPool() );
1747  aNewSet.Put( aProtectionItem, aProtectionItem.Which());
1748  aNewSet.Put( SfxBoolItem( SID_SCATTR_CELLPROTECTION, !bProtect ) );
1749  rReq.Done( aNewSet );
1750 
1751  rBindings.Invalidate( nSlot );
1752  }
1753  break;
1754  }
1755  }
1756  else
1757  {
1758  switch ( nSlot )
1759  {
1760  case SID_ATTR_CHAR_PREVIEW_FONT:
1761  {
1762  SfxItemPool& rPool = GetPool();
1763  sal_uInt16 nWhich = rPool.GetWhich( nSlot );
1764  const SvxFontItem& rFont = static_cast<const SvxFontItem&>(pNewAttrs->Get( nWhich ));
1765  SvxScriptSetItem aSetItem( SID_ATTR_CHAR_FONT, rPool );
1766  SvtScriptType nScript = pTabViewShell->GetSelectionScriptType();
1767  aSetItem.PutItemForScriptType( nScript, rFont );
1768 
1769  ScMarkData aFuncMark( pViewData->GetMarkData() );
1770  ScViewUtil::UnmarkFiltered( aFuncMark, rDoc );
1771  rDoc.SetPreviewFont( aSetItem.GetItemSet().Clone() );
1772  aFuncMark.MarkToMulti();
1773 
1774  if ( !aFuncMark.IsMarked() && !aFuncMark.IsMultiMarked() )
1775  {
1776  SCCOL nCol = pViewData->GetCurX();
1777  SCROW nRow = pViewData->GetCurY();
1778  SCTAB nTab = pViewData->GetTabNo();
1779  ScRange aRange( nCol, nRow, nTab );
1780  aFuncMark.SetMarkArea( aRange );
1781  }
1782  rDoc.SetPreviewSelection( aFuncMark );
1783  pTabViewShell->UpdateSelectionArea( aFuncMark );
1784  break;
1785  }
1786  case SID_ATTR_CHAR_OVERLINE:
1787  case SID_ATTR_CHAR_STRIKEOUT:
1788  case SID_ATTR_ALIGN_LINEBREAK:
1789  case SID_ATTR_CHAR_CONTOUR:
1790  case SID_ATTR_CHAR_SHADOWED:
1791  case SID_ATTR_CHAR_RELIEF:
1792  pTabViewShell->ApplyAttr( pNewAttrs->Get( pNewAttrs->GetPool()->GetWhich( nSlot ) ) );
1793  rBindings.Invalidate( nSlot );
1794  rBindings.Update( nSlot );
1795  break;
1796  case SID_ATTR_CHAR_COLOR:
1797  case SID_SCATTR_PROTECTION :
1798  {
1799  Color aColor;
1800  if (lcl_getColorFromStr(pNewAttrs, aColor))
1801  {
1802  SvxColorItem aColorItem(pTabViewShell->GetSelectionPattern()->
1803  GetItem( ATTR_FONT_COLOR ) );
1804  aColorItem.SetValue(aColor);
1805  pTabViewShell->ApplyAttr(aColorItem, false);
1806  }
1807  else
1808  {
1809  pTabViewShell->ApplyAttr( pNewAttrs->Get( pNewAttrs->GetPool()->GetWhich( nSlot) ), false);
1810  }
1811 
1812  rBindings.Invalidate( nSlot );
1813  rBindings.Update( nSlot );
1814  }
1815 
1816  break;
1817 
1818  case SID_ATTR_CHAR_FONT:
1819  case SID_ATTR_CHAR_FONTHEIGHT:
1820  {
1821  // #i78017 establish the same behaviour as in Writer
1822  SvtScriptType nScript = SvtScriptType::LATIN | SvtScriptType::ASIAN | SvtScriptType::COMPLEX;
1823  if (nSlot == SID_ATTR_CHAR_FONT)
1824  nScript = pTabViewShell->GetSelectionScriptType();
1825 
1826  SfxItemPool& rPool = GetPool();
1827  SvxScriptSetItem aSetItem( nSlot, rPool );
1828  sal_uInt16 nWhich = rPool.GetWhich( nSlot );
1829  aSetItem.PutItemForScriptType( nScript, pNewAttrs->Get( nWhich ) );
1830 
1831  pTabViewShell->ApplyUserItemSet( aSetItem.GetItemSet() );
1832 
1833  rBindings.Invalidate( nSlot );
1834  rBindings.Update( nSlot );
1835  }
1836  break;
1837 
1838  case SID_FRAME_LINESTYLE:
1839  {
1840  // Update default line
1841  const ::editeng::SvxBorderLine* pLine =
1842  pNewAttrs->Get( SID_FRAME_LINESTYLE ).
1843  GetLine();
1844 
1845  if ( pLine )
1846  {
1847  ::editeng::SvxBorderLine* pDefLine = pTabViewShell->GetDefaultFrameLine();
1848 
1849  if ( pDefLine )
1850  {
1851  pDefLine->SetBorderLineStyle(
1852  pLine->GetBorderLineStyle());
1853  pDefLine->SetWidth( pLine->GetWidth( ) );
1854  pTabViewShell->SetSelectionFrameLines( pDefLine, false );
1855  }
1856  else
1857  {
1858  pTabViewShell->SetDefaultFrameLine( pLine );
1859  pTabViewShell->GetDefaultFrameLine()->SetColor( COL_BLACK );
1860  pTabViewShell->SetSelectionFrameLines( pLine, false );
1861  }
1862  }
1863  else
1864  {
1865  Color aColorBlack( COL_BLACK );
1866  ::editeng::SvxBorderLine aDefLine( &aColorBlack, 20,
1867  SvxBorderLineStyle::SOLID );
1868  pTabViewShell->SetDefaultFrameLine( &aDefLine );
1869  pTabViewShell->SetSelectionFrameLines( nullptr, false );
1870  }
1871  }
1872  break;
1873 
1874  case SID_FRAME_LINECOLOR:
1875  {
1876  ::editeng::SvxBorderLine* pDefLine = pTabViewShell->GetDefaultFrameLine();
1877 
1878  Color aColor;
1879  if (!lcl_getColorFromStr(pNewAttrs, aColor))
1880  aColor = pNewAttrs->Get( SID_FRAME_LINECOLOR ).GetValue();
1881 
1882  // Update default line
1883  if ( pDefLine )
1884  {
1885  pDefLine->SetColor( aColor );
1886  pTabViewShell->SetSelectionFrameLines( pDefLine, true );
1887  }
1888  else
1889  {
1890  ::editeng::SvxBorderLine aDefLine( &aColor, 20, SvxBorderLineStyle::SOLID );
1891  pTabViewShell->SetDefaultFrameLine( &aDefLine );
1892  pTabViewShell->SetSelectionFrameLines( &aDefLine, false );
1893  }
1894  }
1895  break;
1896 
1897  case SID_ATTR_BORDER_OUTER:
1898  case SID_ATTR_BORDER:
1899  {
1900  ::editeng::SvxBorderLine* pDefLine = pTabViewShell->GetDefaultFrameLine();
1901  const ScPatternAttr* pOldAttrs = pTabViewShell->GetSelectionPattern();
1902  std::unique_ptr<SfxItemSet> pOldSet(
1903  new SfxItemSet(
1904  *rDoc.GetPool(),
1905  svl::Items<ATTR_PATTERN_START,
1906  ATTR_PATTERN_END>{} ));
1907  std::unique_ptr<SfxItemSet> pNewSet(
1908  new SfxItemSet(
1909  *rDoc.GetPool(),
1910  svl::Items<ATTR_PATTERN_START,
1911  ATTR_PATTERN_END>{} ));
1912  const SfxPoolItem& rBorderAttr =
1913  pOldAttrs->GetItemSet().
1914  Get( ATTR_BORDER );
1915 
1916  // Evaluate border items from controller:
1917  const SfxPoolItem* pItem = nullptr;
1918 
1919  if ( pNewAttrs->GetItemState( ATTR_BORDER, true, &pItem )
1920  == SfxItemState::SET )
1921  {
1922  // The SvxFrameToolBoxControl toolbox controller uses a default
1923  // SvxBorderLine (all widths 0) to mark the lines that should be set.
1924  // Macro recording uses a SvxBoxItem with the real values (OutWidth > 0)
1925  // or NULL pointers for no lines.
1926  // -> Substitute existing lines with pDefLine only if widths are 0.
1927  SvxBoxItem aBoxItem ( *static_cast<const SvxBoxItem*>(pItem ));
1928  if ( aBoxItem.GetTop() && aBoxItem.GetTop()->GetOutWidth() == 0 )
1929  aBoxItem.SetLine( pDefLine, SvxBoxItemLine::TOP );
1930  if ( aBoxItem.GetBottom() && aBoxItem.GetBottom()->GetOutWidth() == 0 )
1931  aBoxItem.SetLine( pDefLine, SvxBoxItemLine::BOTTOM );
1932  if ( aBoxItem.GetLeft() && aBoxItem.GetLeft()->GetOutWidth() == 0 )
1933  aBoxItem.SetLine( pDefLine, SvxBoxItemLine::LEFT );
1934  if ( aBoxItem.GetRight() && aBoxItem.GetRight()->GetOutWidth() == 0 )
1935  aBoxItem.SetLine( pDefLine, SvxBoxItemLine::RIGHT );
1936  pNewSet->Put( aBoxItem );
1937  rReq.AppendItem( aBoxItem );
1938  }
1939 
1940  if ( pNewAttrs->GetItemState( ATTR_BORDER_INNER, true, &pItem )
1941  == SfxItemState::SET )
1942  {
1943  SvxBoxInfoItem aBoxInfoItem( *static_cast<const SvxBoxInfoItem*>(pItem) );
1944  if ( aBoxInfoItem.GetHori() && aBoxInfoItem.GetHori()->GetOutWidth() == 0 )
1945  aBoxInfoItem.SetLine( pDefLine, SvxBoxInfoItemLine::HORI );
1946  if ( aBoxInfoItem.GetVert() && aBoxInfoItem.GetVert()->GetOutWidth() == 0 )
1947  aBoxInfoItem.SetLine( pDefLine, SvxBoxInfoItemLine::VERT );
1948  pNewSet->Put( aBoxInfoItem );
1949  rReq.AppendItem( aBoxInfoItem );
1950  }
1951  else
1952  {
1953  SvxBoxInfoItem aBoxInfoItem( ATTR_BORDER_INNER );
1954  aBoxInfoItem.SetLine( nullptr, SvxBoxInfoItemLine::HORI );
1955  aBoxInfoItem.SetLine( nullptr, SvxBoxInfoItemLine::VERT );
1956  pNewSet->Put( aBoxInfoItem );
1957  }
1958 
1959  pOldSet->Put( rBorderAttr );
1960  pTabViewShell->ApplyAttributes( pNewSet.get(), pOldSet.get() );
1961  }
1962  break;
1963 
1964  case SID_ATTR_BORDER_DIAG_TLBR:
1965  case SID_ATTR_BORDER_DIAG_BLTR:
1966  {
1967  const ScPatternAttr* pOldAttrs = pTabViewShell->GetSelectionPattern();
1968  std::unique_ptr<SfxItemSet> pOldSet(new SfxItemSet(pOldAttrs->GetItemSet()));
1969  std::unique_ptr<SfxItemSet> pNewSet(new SfxItemSet(pOldAttrs->GetItemSet()));
1970  const SfxPoolItem* pItem = nullptr;
1971 
1972  if(SID_ATTR_BORDER_DIAG_TLBR == nSlot)
1973  {
1974  if(SfxItemState::SET == pNewAttrs->GetItemState(ATTR_BORDER_TLBR, true, &pItem))
1975  {
1976  SvxLineItem aItem(ATTR_BORDER_TLBR);
1977  aItem.SetLine(pNewAttrs->Get(ATTR_BORDER_TLBR).GetLine());
1978  pNewSet->Put(aItem);
1979  rReq.AppendItem(aItem);
1980  pTabViewShell->ApplyAttributes(pNewSet.get(), pOldSet.get());
1981  }
1982  }
1983  else // if( nSlot == SID_ATTR_BORDER_DIAG_BLTR )
1984  {
1985  if(SfxItemState::SET == pNewAttrs->GetItemState(ATTR_BORDER_BLTR, true, &pItem ))
1986  {
1987  SvxLineItem aItem(ATTR_BORDER_BLTR);
1988  aItem.SetLine(pNewAttrs->Get(ATTR_BORDER_BLTR).GetLine());
1989  pNewSet->Put(aItem);
1990  rReq.AppendItem(aItem);
1991  pTabViewShell->ApplyAttributes(pNewSet.get(), pOldSet.get());
1992  }
1993  }
1994 
1995  rBindings.Invalidate(nSlot);
1996  }
1997  break;
1998 
1999  // ATTR_BACKGROUND (=SID_ATTR_BRUSH) has to be set to two IDs:
2000  case SID_BACKGROUND_COLOR:
2001  {
2002  Color aColor;
2003 
2004  if (!lcl_getColorFromStr(pNewAttrs, aColor))
2005  {
2006  const SvxColorItem& rNewColorItem = pNewAttrs->Get( SID_BACKGROUND_COLOR );
2007  aColor = rNewColorItem.GetValue();
2008  }
2009 
2010  SvxBrushItem aBrushItem(
2011  pTabViewShell->GetSelectionPattern()->GetItem( ATTR_BACKGROUND ) );
2012  aBrushItem.SetColor( aColor );
2013 
2014  pTabViewShell->ApplyAttr( aBrushItem, false );
2015  }
2016  break;
2017 
2018  case SID_ATTR_BRUSH:
2019  {
2020  SvxBrushItem aBrushItem( pTabViewShell->GetSelectionPattern()->
2021  GetItem( ATTR_BACKGROUND ) );
2022  const SvxBrushItem& rNewBrushItem = static_cast<const SvxBrushItem&>(
2023  pNewAttrs->Get( GetPool().GetWhich(nSlot) ) );
2024  aBrushItem.SetColor(rNewBrushItem.GetColor());
2025  pTabViewShell->ApplyAttr( aBrushItem );
2026  }
2027  break;
2028 
2029  case SID_ATTR_BORDER_SHADOW:
2030  {
2031  const SvxShadowItem& rNewShadowItem =
2032  pNewAttrs->Get( ATTR_SHADOW );
2033  pTabViewShell->ApplyAttr( rNewShadowItem );
2034  }
2035  break;
2036 
2037  default:
2038  break;
2039  }
2040 
2041  if( ! rReq.IsAPI() && ! rReq.IsDone() )
2042  rReq.Done();
2043  }
2044 }
2045 
2046 void ScFormatShell::GetAttrState( SfxItemSet& rSet )
2047 {
2048  ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
2049  const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
2050  const SvxBrushItem& rBrushItem = rAttrSet.Get( ATTR_BACKGROUND );
2051  SfxWhichIter aIter( rSet );
2052  sal_uInt16 nWhich = aIter.FirstWhich();
2053 
2054  rSet.Put( rAttrSet, false );
2055 
2056  // choose font info according to selection script type
2057  SvtScriptType nScript = SvtScriptType::NONE; // GetSelectionScriptType never returns 0
2058  if ( rSet.GetItemState( ATTR_FONT ) != SfxItemState::UNKNOWN )
2059  {
2060  nScript = pTabViewShell->GetSelectionScriptType();
2061  ScViewUtil::PutItemScript( rSet, rAttrSet, ATTR_FONT, nScript );
2062  }
2063  if ( rSet.GetItemState( ATTR_FONT_HEIGHT ) != SfxItemState::UNKNOWN )
2064  {
2065  if (nScript == SvtScriptType::NONE) nScript = pTabViewShell->GetSelectionScriptType();
2066  ScViewUtil::PutItemScript( rSet, rAttrSet, ATTR_FONT_HEIGHT, nScript );
2067  }
2068 
2069  while ( nWhich )
2070  {
2071  switch(nWhich)
2072  {
2073  case SID_BACKGROUND_COLOR:
2074  {
2075  rSet.Put( SvxColorItem( rBrushItem.GetColor(), SID_BACKGROUND_COLOR ) );
2076  if(SfxItemState::DONTCARE == rAttrSet.GetItemState(ATTR_BACKGROUND))
2077  {
2078  rSet.InvalidateItem(SID_BACKGROUND_COLOR);
2079  }
2080  }
2081  break;
2082  case SID_FRAME_LINESTYLE:
2083  case SID_FRAME_LINECOLOR:
2084  {
2085  // handled together because both need the cell border information for decisions
2086  Color aCol;
2087  editeng::SvxBorderLine aLine(nullptr,0,SvxBorderLineStyle::SOLID);
2088  bool bCol = false;
2089  bool bColDisable = false, bStyleDisable = false;
2090  std::shared_ptr<SvxBoxItem> aBoxItem(std::make_shared<SvxBoxItem>(ATTR_BORDER));
2091  std::shared_ptr<SvxBoxInfoItem> aInfoItem(std::make_shared<SvxBoxInfoItem>(ATTR_BORDER_INNER));
2092 
2093  pTabViewShell->GetSelectionFrame(aBoxItem, aInfoItem);
2094 
2095  if( aBoxItem->GetTop() )
2096  {
2097  bCol = true;
2098  aCol = aBoxItem->GetTop()->GetColor() ;
2099  aLine.SetColor(aCol);
2100  aLine.SetWidth( aBoxItem->GetTop()->GetWidth());
2101  aLine.SetBorderLineStyle( aBoxItem->GetTop()->GetBorderLineStyle());
2102  }
2103 
2104  if( aBoxItem->GetBottom() )
2105  {
2106  if(!bCol)
2107  {
2108  bCol = true;
2109  aCol = aBoxItem->GetBottom()->GetColor() ;
2110  aLine.SetColor(aCol);
2111  aLine.SetWidth( aBoxItem->GetBottom()->GetWidth());
2112  aLine.SetBorderLineStyle( aBoxItem->GetBottom()->GetBorderLineStyle());
2113  }
2114  else
2115  {
2116  if(aCol != aBoxItem->GetBottom()->GetColor() )
2117  bColDisable = true;
2118  if( aLine != *aBoxItem->GetBottom() )
2119  bStyleDisable = true;
2120  }
2121  }
2122 
2123  if( aBoxItem->GetLeft() )
2124  {
2125  if(!bCol)
2126  {
2127  bCol = true;
2128  aCol = aBoxItem->GetLeft()->GetColor() ;
2129  aLine.SetColor(aCol);
2130  aLine.SetWidth( aBoxItem->GetLeft()->GetWidth());
2131  aLine.SetBorderLineStyle( aBoxItem->GetLeft()->GetBorderLineStyle());
2132  }
2133  else
2134  {
2135  if(aCol != aBoxItem->GetLeft()->GetColor() )
2136  bColDisable = true;
2137  if( aLine != *aBoxItem->GetLeft() )
2138  bStyleDisable = true;
2139  }
2140  }
2141 
2142  if( aBoxItem->GetRight() )
2143  {
2144  if(!bCol)
2145  {
2146  bCol = true;
2147  aCol = aBoxItem->GetRight()->GetColor() ;
2148  aLine.SetColor(aCol);
2149  aLine.SetWidth( aBoxItem->GetRight()->GetWidth());
2150  aLine.SetBorderLineStyle( aBoxItem->GetRight()->GetBorderLineStyle());
2151  }
2152  else
2153  {
2154  if(aCol != aBoxItem->GetRight()->GetColor() )
2155  bColDisable = true;
2156  if( aLine != *aBoxItem->GetRight() )
2157  bStyleDisable = true;
2158  }
2159  }
2160 
2161  if( aInfoItem->GetVert())
2162  {
2163  if(!bCol)
2164  {
2165  bCol = true;
2166  aCol = aInfoItem->GetVert()->GetColor() ;
2167  aLine.SetColor(aCol);
2168  aLine.SetWidth( aInfoItem->GetVert()->GetWidth());
2169  aLine.SetBorderLineStyle( aInfoItem->GetVert()->GetBorderLineStyle());
2170  }
2171  else
2172  {
2173  if(aCol != aInfoItem->GetVert()->GetColor() )
2174  bColDisable = true;
2175  if( aLine != *aInfoItem->GetVert() )
2176  bStyleDisable = true;
2177  }
2178  }
2179 
2180  if( aInfoItem->GetHori())
2181  {
2182  if(!bCol)
2183  {
2184  bCol = true;
2185  aCol = aInfoItem->GetHori()->GetColor() ;
2186  aLine.SetColor(aCol);
2187  aLine.SetWidth( aInfoItem->GetHori()->GetWidth());
2188  aLine.SetBorderLineStyle( aInfoItem->GetHori()->GetBorderLineStyle());
2189  }
2190  else
2191  {
2192  if(aCol != aInfoItem->GetHori()->GetColor() )
2193  bColDisable = true;
2194  if( aLine != *aInfoItem->GetHori() )
2195  bStyleDisable = true;
2196  }
2197  }
2198 
2199  if( !aInfoItem->IsValid( SvxBoxInfoItemValidFlags::VERT )
2200  || !aInfoItem->IsValid( SvxBoxInfoItemValidFlags::HORI )
2201  || !aInfoItem->IsValid( SvxBoxInfoItemValidFlags::LEFT )
2202  || !aInfoItem->IsValid( SvxBoxInfoItemValidFlags::RIGHT )
2203  || !aInfoItem->IsValid( SvxBoxInfoItemValidFlags::TOP )
2204  || !aInfoItem->IsValid( SvxBoxInfoItemValidFlags::BOTTOM ) )
2205  {
2206  bColDisable = true;
2207  bStyleDisable = true;
2208  }
2209 
2210  if(SID_FRAME_LINECOLOR == nWhich)
2211  {
2212  if(bColDisable) // if different lines have different colors
2213  {
2214  aCol = COL_TRANSPARENT;
2215  rSet.Put( SvxColorItem(aCol, SID_FRAME_LINECOLOR ) );
2216  rSet.InvalidateItem(SID_FRAME_LINECOLOR);
2217  }
2218  else if (!bCol) // if no line available
2219  {
2220  aCol = COL_AUTO;
2221  rSet.Put( SvxColorItem(aCol, SID_FRAME_LINECOLOR ) );
2222  }
2223  else
2224  rSet.Put( SvxColorItem(aCol, SID_FRAME_LINECOLOR ) );
2225  }
2226  else // if( nWhich == SID_FRAME_LINESTYLE)
2227  {
2228  if(bStyleDisable) // if have several lines but don't have same style
2229  {
2230  aLine.SetWidth( 1 );
2231  SvxLineItem aItem(SID_FRAME_LINESTYLE);
2232  aItem.SetLine(&aLine);
2233  rSet.Put( aItem );
2234  rSet.InvalidateItem(SID_FRAME_LINESTYLE);
2235  }
2236  else // all the lines have same style or no line available, use initial value (0,0,0,0)
2237  {
2238  SvxLineItem aItem(SID_FRAME_LINESTYLE);
2239  aItem.SetLine(&aLine);
2240  rSet.Put( aItem );
2241  }
2242  }
2243  }
2244  break;
2245  case SID_ATTR_BRUSH:
2246  {
2247  rSet.Put( rBrushItem.CloneSetWhich(GetPool().GetWhich(nWhich)) );
2248  }
2249  break;
2250  case SID_SCATTR_CELLPROTECTION:
2251  {
2252  bool bProtect = rAttrSet.Get( ATTR_PROTECTION ).GetProtection();
2253  rSet.Put( SfxBoolItem(SID_SCATTR_CELLPROTECTION, bProtect) );
2254  }
2255  break;
2256  }
2257  nWhich = aIter.NextWhich();
2258  }
2259 
2260  // stuff for sidebar panels
2261  Invalidate(SID_ATTR_ALIGN_DEGREES);
2262  Invalidate(SID_ATTR_ALIGN_LOCKPOS);
2263  Invalidate(SID_ATTR_ALIGN_STACKED);
2264 }
2265 
2266 void ScFormatShell::GetTextAttrState( SfxItemSet& rSet )
2267 {
2268  ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
2269  const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
2270  rSet.Put( rAttrSet, false ); // Include ItemStates in copy
2271 
2272  // choose font info according to selection script type
2273  SvtScriptType nScript = SvtScriptType::NONE; // GetSelectionScriptType never returns 0
2274  if ( rSet.GetItemState( ATTR_FONT_WEIGHT ) != SfxItemState::UNKNOWN )
2275  {
2276  nScript = pTabViewShell->GetSelectionScriptType();
2277  ScViewUtil::PutItemScript( rSet, rAttrSet, ATTR_FONT_WEIGHT, nScript );
2278  }
2279  if ( rSet.GetItemState( ATTR_FONT_POSTURE ) != SfxItemState::UNKNOWN )
2280  {
2281  if (nScript == SvtScriptType::NONE) nScript = pTabViewShell->GetSelectionScriptType();
2282  ScViewUtil::PutItemScript( rSet, rAttrSet, ATTR_FONT_POSTURE, nScript );
2283  }
2284 
2285  SfxItemState eState;
2286 
2287  // own control on radio button functionality:
2288 
2289  // underline
2290 
2291  eState = rAttrSet.GetItemState( ATTR_FONT_UNDERLINE );
2292  if ( eState == SfxItemState::DONTCARE )
2293  {
2294  rSet.InvalidateItem( SID_ULINE_VAL_NONE );
2295  rSet.InvalidateItem( SID_ULINE_VAL_SINGLE );
2296  rSet.InvalidateItem( SID_ULINE_VAL_DOUBLE );
2297  rSet.InvalidateItem( SID_ULINE_VAL_DOTTED );
2298  }
2299  else
2300  {
2301  FontLineStyle eUnderline =
2302  rAttrSet.Get(ATTR_FONT_UNDERLINE).GetLineStyle();
2303  rSet.Put(SfxBoolItem(SID_ULINE_VAL_SINGLE, eUnderline == LINESTYLE_SINGLE));
2304  rSet.Put(SfxBoolItem(SID_ULINE_VAL_DOUBLE, eUnderline == LINESTYLE_DOUBLE));
2305  rSet.Put(SfxBoolItem(SID_ULINE_VAL_DOTTED, eUnderline == LINESTYLE_DOTTED));
2306  rSet.Put(SfxBoolItem(SID_ULINE_VAL_NONE, eUnderline == LINESTYLE_NONE));
2307  }
2308 
2309  // horizontal alignment
2310 
2311  const SvxHorJustifyItem* pHorJustify = nullptr;
2312  const SvxVerJustifyItem* pVerJustify = nullptr;
2313  SvxCellVerJustify eVerJustify = SvxCellVerJustify::Standard;
2314  sal_uInt16 nWhich = 0;
2315  bool bJustifyStd = false;
2316  SfxBoolItem aBoolItem ( 0, true );
2317 
2318  eState = rAttrSet.GetItemState( ATTR_HOR_JUSTIFY, true,
2319  reinterpret_cast<const SfxPoolItem**>(&pHorJustify) );
2320  switch ( eState )
2321  {
2322  case SfxItemState::SET:
2323  {
2324  switch ( pHorJustify->GetValue() )
2325  {
2326  case SvxCellHorJustify::Standard:
2327  break;
2328 
2329  case SvxCellHorJustify::Left:
2330  nWhich = SID_ALIGNLEFT;
2331  break;
2332 
2333  case SvxCellHorJustify::Right:
2334  nWhich = SID_ALIGNRIGHT;
2335  break;
2336 
2337  case SvxCellHorJustify::Center:
2338  nWhich = SID_ALIGNCENTERHOR;
2339  break;
2340 
2341  case SvxCellHorJustify::Block:
2342  nWhich = SID_ALIGNBLOCK;
2343  break;
2344 
2345  case SvxCellHorJustify::Repeat:
2346  default:
2347  bJustifyStd = true;
2348  break;
2349  }
2350  }
2351  break;
2352 
2353  case SfxItemState::DONTCARE:
2354  rSet.InvalidateItem( SID_ALIGNLEFT );
2355  rSet.InvalidateItem( SID_ALIGNRIGHT );
2356  rSet.InvalidateItem( SID_ALIGNCENTERHOR );
2357  rSet.InvalidateItem( SID_ALIGNBLOCK );
2358  break;
2359 
2360  default:
2361  bJustifyStd = true;
2362  break;
2363  }
2364 
2365  if ( nWhich )
2366  {
2367  aBoolItem.SetWhich( nWhich );
2368  rSet.Put( aBoolItem );
2369  }
2370  else if ( bJustifyStd )
2371  {
2372  aBoolItem.SetValue( false );
2373  aBoolItem.SetWhich( SID_ALIGNLEFT ); rSet.Put( aBoolItem );
2374  aBoolItem.SetWhich( SID_ALIGNRIGHT ); rSet.Put( aBoolItem );
2375  aBoolItem.SetWhich( SID_ALIGNCENTERHOR ); rSet.Put( aBoolItem );
2376  aBoolItem.SetWhich( SID_ALIGNBLOCK ); rSet.Put( aBoolItem );
2377  bJustifyStd = false;
2378  }
2379 
2380  // vertical alignment
2381 
2382  nWhich = 0;
2383  aBoolItem.SetValue( true );
2384 
2385  eState = rAttrSet.GetItemState( ATTR_VER_JUSTIFY, true,
2386  reinterpret_cast<const SfxPoolItem**>(&pVerJustify) );
2387 
2388  switch ( eState )
2389  {
2390  case SfxItemState::SET:
2391  {
2392  eVerJustify = pVerJustify->GetValue();
2393 
2394  switch ( eVerJustify )
2395  {
2396  case SvxCellVerJustify::Top:
2397  nWhich = SID_ALIGNTOP;
2398  break;
2399 
2400  case SvxCellVerJustify::Bottom:
2401  nWhich = SID_ALIGNBOTTOM;
2402  break;
2403 
2404  case SvxCellVerJustify::Center:
2405  nWhich = SID_ALIGNCENTERVER;
2406  break;
2407 
2408  case SvxCellVerJustify::Standard:
2409  default:
2410  bJustifyStd = true;
2411  break;
2412  }
2413  }
2414  break;
2415 
2416  case SfxItemState::DONTCARE:
2417  rSet.InvalidateItem( SID_ALIGNTOP );
2418  rSet.InvalidateItem( SID_ALIGNBOTTOM );
2419  rSet.InvalidateItem( SID_ALIGNCENTERVER );
2420  break;
2421 
2422  default:
2423  bJustifyStd = true;
2424  break;
2425  }
2426 
2427  if ( nWhich )
2428  {
2429  aBoolItem.SetWhich( nWhich );
2430  rSet.Put( aBoolItem );
2431  }
2432  else if ( bJustifyStd )
2433  {
2434  aBoolItem.SetValue( false );
2435  aBoolItem.SetWhich( SID_ALIGNTOP ); rSet.Put( aBoolItem );
2436  aBoolItem.SetWhich( SID_ALIGNBOTTOM ); rSet.Put( aBoolItem );
2437  aBoolItem.SetWhich( SID_ALIGNCENTERVER ); rSet.Put( aBoolItem );
2438  }
2439 }
2440 
2441 void ScFormatShell::GetBorderState( SfxItemSet& rSet )
2442 {
2443  ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
2444  std::shared_ptr<SvxBoxItem> aBoxItem(std::make_shared<SvxBoxItem>(ATTR_BORDER));
2445  std::shared_ptr<SvxBoxInfoItem> aInfoItem(std::make_shared<SvxBoxInfoItem>(ATTR_BORDER_INNER));
2446 
2447  pTabViewShell->GetSelectionFrame( aBoxItem, aInfoItem );
2448 
2449  if ( rSet.GetItemState( ATTR_BORDER ) != SfxItemState::UNKNOWN )
2450  rSet.Put( *aBoxItem );
2451  if ( rSet.GetItemState( ATTR_BORDER_INNER ) != SfxItemState::UNKNOWN )
2452  rSet.Put( *aInfoItem );
2453 }
2454 
2455 void ScFormatShell::GetAlignState( SfxItemSet& rSet )
2456 {
2457  ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
2458  const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
2459  SfxWhichIter aIter(rSet);
2460  sal_uInt16 nWhich = aIter.FirstWhich();
2461 
2462  SvxCellHorJustify eHAlign = SvxCellHorJustify::Standard;
2463  bool bHasHAlign = rAttrSet.GetItemState( ATTR_HOR_JUSTIFY ) != SfxItemState::DONTCARE;
2464  if( bHasHAlign )
2465  eHAlign = rAttrSet.Get( ATTR_HOR_JUSTIFY ).GetValue();
2466 
2467  SvxCellVerJustify eVAlign = SvxCellVerJustify::Standard;
2468  bool bHasVAlign = rAttrSet.GetItemState( ATTR_VER_JUSTIFY ) != SfxItemState::DONTCARE;
2469  if( bHasVAlign )
2470  eVAlign = rAttrSet.Get( ATTR_VER_JUSTIFY ).GetValue();
2471 
2472  while ( nWhich )
2473  {
2474  switch ( nWhich )
2475  {
2476  case SID_H_ALIGNCELL:
2477  if ( bHasHAlign )
2478  rSet.Put( SvxHorJustifyItem( eHAlign, nWhich ));
2479  break;
2480  case SID_V_ALIGNCELL:
2481  if ( bHasVAlign )
2482  rSet.Put( SvxVerJustifyItem( eVAlign, nWhich ));
2483  break;
2484 
2485  // pseudo slots for Format menu
2486  case SID_ALIGN_ANY_HDEFAULT:
2487  case SID_ALIGN_ANY_LEFT:
2488  case SID_ALIGN_ANY_HCENTER:
2489  case SID_ALIGN_ANY_RIGHT:
2490  case SID_ALIGN_ANY_JUSTIFIED:
2491  rSet.Put( SfxBoolItem( nWhich, bHasHAlign && (eHAlign == lclConvertSlotToHAlign( nWhich )) ) );
2492  break;
2493  case SID_ALIGN_ANY_VDEFAULT:
2494  case SID_ALIGN_ANY_TOP:
2495  case SID_ALIGN_ANY_VCENTER:
2496  case SID_ALIGN_ANY_BOTTOM:
2497  rSet.Put( SfxBoolItem( nWhich, bHasVAlign && (eVAlign == lclConvertSlotToVAlign( nWhich )) ) );
2498  break;
2499  }
2500  nWhich = aIter.NextWhich();
2501  }
2502 }
2503 
2504 void ScFormatShell::GetNumFormatState( SfxItemSet& rSet )
2505 {
2506  ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
2507  ScDocument& rDoc = pViewData->GetDocument();
2508  const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
2509  const SfxItemState eItemState = rAttrSet.GetItemState( ATTR_VALUE_FORMAT );
2510  sal_uInt32 nNumberFormat = rAttrSet.Get(ATTR_VALUE_FORMAT).GetValue();
2511  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
2512  // If item state is default or set it
2513  // indicates one number format so we
2514  // don't have to iterate over all
2515  // selected cells' attribute ranges to
2516  // determine selected types.
2517  // Does *NOT* include the
2518  // SvNumFormatType::DEFINED bit.
2519  const SvNumFormatType nType = (eItemState >= SfxItemState::DEFAULT ? pFormatter->GetType( nNumberFormat) :
2520  GetCurrentNumberFormatType());
2521  NfIndexTableOffset nOffset = pFormatter->GetIndexTableOffset(nNumberFormat);
2522 
2523  SfxWhichIter aIter(rSet);
2524  sal_uInt16 nWhich = aIter.FirstWhich();
2525 
2526  while ( nWhich )
2527  {
2528  switch ( nWhich )
2529  {
2530  case SID_NUMBER_THOUSANDS:
2531  {
2532  bool bEnable = (SfxItemState::DONTCARE != eItemState);
2533  if (bEnable)
2534  {
2535  bEnable = ((nType != SvNumFormatType::ALL) && (nType &
2536  (SvNumFormatType::NUMBER |
2537  SvNumFormatType::PERCENT |
2538  SvNumFormatType::CURRENCY |
2539  SvNumFormatType::FRACTION)));
2540  if (bEnable)
2541  {
2542  bool bThousand( false );
2543  bool bNegRed( false );
2544  sal_uInt16 nPrecision( 0 );
2545  sal_uInt16 nLeadZeroes( 0 );
2546  pFormatter->GetFormatSpecialInfo( nNumberFormat, bThousand, bNegRed, nPrecision, nLeadZeroes);
2547  rSet.Put( SfxBoolItem( nWhich, bThousand));
2548  }
2549  }
2550  if (!bEnable)
2551  {
2552  rSet.DisableItem( nWhich );
2553  }
2554  }
2555  break;
2556  case SID_NUMBER_FORMAT:
2557  // symphony version with format interpretation
2558  {
2559  if(SfxItemState::DONTCARE != eItemState)
2560  {
2561  bool bThousand(false);
2562  bool bNegRed(false);
2563  sal_uInt16 nPrecision(0);
2564  sal_uInt16 nLeadZeroes(0);
2565 
2566  pFormatter->GetFormatSpecialInfo(nNumberFormat,bThousand, bNegRed, nPrecision, nLeadZeroes);
2567 
2568  const SvNumberformat* pFormatEntry = pFormatter->GetEntry( nNumberFormat );
2569  if (pFormatEntry && (pFormatEntry->GetType() & SvNumFormatType::SCIENTIFIC))
2570  {
2571  // if scientific, bThousand is used for engineering notation
2572  const sal_uInt16 nIntegerDigits = pFormatEntry->GetFormatIntegerDigits();
2573  bThousand = nIntegerDigits > 0 && ((nIntegerDigits % 3) == 0);
2574  }
2575  OUString aFormat;
2576  static constexpr OUStringLiteral sBreak = u",";
2577  const OUString sThousand = OUString::number(static_cast<sal_Int32>(bThousand));
2578  const OUString sNegRed = OUString::number(static_cast<sal_Int32>(bNegRed));
2579  const OUString sPrecision = OUString::number(nPrecision);
2580  const OUString sLeadZeroes = OUString::number(nLeadZeroes);
2581 
2582  aFormat += sThousand +
2583  sBreak +
2584  sNegRed +
2585  sBreak +
2586  sPrecision +
2587  sBreak +
2588  sLeadZeroes +
2589  sBreak;
2590 
2591  rSet.Put(SfxStringItem(nWhich, aFormat));
2592 
2593  if (comphelper::LibreOfficeKit::isActive())
2594  {
2595  OUString sPayload = ".uno:NumberFormat=" + aFormat;
2596  GetViewShell()->libreOfficeKitViewCallback(LOK_CALLBACK_STATE_CHANGED,
2597  OUStringToOString(sPayload, RTL_TEXTENCODING_ASCII_US).getStr());
2598  }
2599  }
2600  else
2601  {
2602  rSet.InvalidateItem( nWhich );
2603  }
2604  }
2605  break;
2606 
2607  case SID_NUMBER_TYPE_FORMAT:
2608  {
2609  sal_Int16 nFormatCategory = -1;
2610  if ( eItemState >= SfxItemState::DEFAULT ) //Modify for more robust
2611  {
2612  switch(nType)
2613  {
2614  case SvNumFormatType::NUMBER:
2615  // Determine if General format.
2616  if ((nNumberFormat % SV_COUNTRY_LANGUAGE_OFFSET) == 0)
2617  nFormatCategory = 0;
2618  else
2619  nFormatCategory = 1;
2620  break;
2621  case SvNumFormatType::PERCENT:
2622  nFormatCategory = 2;
2623  break;
2624  case SvNumFormatType::CURRENCY:
2625  nFormatCategory = 3;
2626  break;
2627  case SvNumFormatType::DATE:
2628  //Add
2629  case SvNumFormatType::DATETIME:
2630  nFormatCategory = 4;
2631  break;
2632  case SvNumFormatType::TIME:
2633  nFormatCategory = 5;
2634  break;
2635  case SvNumFormatType::SCIENTIFIC:
2636  nFormatCategory = 6;
2637  break;
2638  case SvNumFormatType::FRACTION:
2639  nFormatCategory = 7;
2640  break;
2641  case SvNumFormatType::LOGICAL:
2642  nFormatCategory = 8;
2643  break;
2644  case SvNumFormatType::TEXT:
2645  nFormatCategory = 9;
2646  break;
2647  default:
2648  nFormatCategory = -1; //for more robust
2649  }
2650  if( nFormatCategory == -1 )
2651  rSet.InvalidateItem( nWhich );
2652  else
2653  rSet.Put( SfxInt16Item( nWhich, nFormatCategory ) );
2654  }
2655  else
2656  {
2657  rSet.InvalidateItem( nWhich );
2658  }
2659 
2660  }
2661  break;
2662  case SID_NUMBER_CURRENCY:
2663  rSet.Put( SfxBoolItem(nWhich, bool(nType & SvNumFormatType::CURRENCY)) );
2664  break;
2665  case SID_NUMBER_SCIENTIFIC:
2666  rSet.Put( SfxBoolItem(nWhich, bool(nType & SvNumFormatType::SCIENTIFIC)) );
2667  break;
2668  case SID_NUMBER_DATE:
2669  rSet.Put( SfxBoolItem(nWhich, bool(nType & SvNumFormatType::DATE)) );
2670  break;
2671  case SID_NUMBER_PERCENT:
2672  rSet.Put( SfxBoolItem(nWhich, bool(nType & SvNumFormatType::PERCENT)) );
2673  break;
2674  case SID_NUMBER_TIME:
2675  rSet.Put( SfxBoolItem(nWhich, bool(nType & SvNumFormatType::TIME)) );
2676  break;
2677  case SID_NUMBER_TWODEC:
2678  rSet.Put( SfxBoolItem(nWhich, (nType & SvNumFormatType::NUMBER) && nOffset == NF_NUMBER_1000DEC2 ) );
2679  break;
2680  case SID_NUMBER_STANDARD:
2681  rSet.Put( SfxBoolItem(nWhich, (nType & SvNumFormatType::NUMBER) && (nNumberFormat % SV_COUNTRY_LANGUAGE_OFFSET) == 0) );
2682  break;
2683  }
2684  nWhich = aIter.NextWhich();
2685  }
2686 }
2687 
2688 void ScFormatShell::ExecuteTextDirection( const SfxRequest& rReq )
2689 {
2690  ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
2691  pTabViewShell->HideListBox(); // Autofilter-DropDown-Listbox
2692  bool bEditMode = false;
2693  if ( GetViewData()->HasEditView( GetViewData()->GetActivePart() ) )
2694  {
2695  bEditMode=true;
2696  SC_MOD()->InputEnterHandler();
2697  pTabViewShell->UpdateInputHandler();
2698  }
2699  sal_uInt16 nSlot = rReq.GetSlot();
2700  switch( nSlot )
2701  {
2702  case SID_TEXTDIRECTION_LEFT_TO_RIGHT:
2703  case SID_TEXTDIRECTION_TOP_TO_BOTTOM:
2704  {
2705  bool bVert = (nSlot == SID_TEXTDIRECTION_TOP_TO_BOTTOM);
2706  ScPatternAttr aAttr( GetViewData()->GetDocument().GetPool() );
2707  SfxItemSet& rItemSet = aAttr.GetItemSet();
2708  rItemSet.Put( ScVerticalStackCell( bVert ) );
2709  rItemSet.Put( SfxBoolItem( ATTR_VERTICAL_ASIAN, bVert ) );
2710  pTabViewShell->ApplySelectionPattern( aAttr );
2711  pTabViewShell->AdjustBlockHeight();
2712  }
2713  break;
2714 
2715  case SID_ATTR_PARA_LEFT_TO_RIGHT:
2716  case SID_ATTR_PARA_RIGHT_TO_LEFT:
2717  {
2718  SvxFrameDirection eDirection = ( nSlot == SID_ATTR_PARA_LEFT_TO_RIGHT ) ?
2719  SvxFrameDirection::Horizontal_LR_TB : SvxFrameDirection::Horizontal_RL_TB;
2720  pTabViewShell->ApplyAttr( SvxFrameDirectionItem( eDirection, ATTR_WRITINGDIR ) );
2721  }
2722  break;
2723  }
2724  if (bEditMode)
2725  SC_MOD()->SetInputMode( SC_INPUT_TABLE );
2726 }
2727 
2728 void ScFormatShell::GetTextDirectionState( SfxItemSet& rSet )
2729 {
2730  ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
2731  const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
2732 
2733  bool bVertDontCare =
2734  (rAttrSet.GetItemState( ATTR_VERTICAL_ASIAN ) == SfxItemState::DONTCARE) ||
2735  (rAttrSet.GetItemState( ATTR_STACKED ) == SfxItemState::DONTCARE);
2736  bool bLeftRight = !bVertDontCare &&
2737  !rAttrSet.Get( ATTR_STACKED ).GetValue();
2738  bool bTopBottom = !bVertDontCare && !bLeftRight &&
2739  rAttrSet.Get( ATTR_VERTICAL_ASIAN ).GetValue();
2740 
2741  bool bBidiDontCare = (rAttrSet.GetItemState( ATTR_WRITINGDIR ) == SfxItemState::DONTCARE);
2742  EEHorizontalTextDirection eBidiDir = EEHorizontalTextDirection::Default;
2743  if ( !bBidiDontCare )
2744  {
2745  SvxFrameDirection eCellDir = rAttrSet.Get( ATTR_WRITINGDIR ).GetValue();
2746  if ( eCellDir == SvxFrameDirection::Environment )
2747  eBidiDir = GetViewData()->GetDocument().
2748  GetEditTextDirection( GetViewData()->GetTabNo() );
2749  else if ( eCellDir == SvxFrameDirection::Horizontal_RL_TB )
2750  eBidiDir = EEHorizontalTextDirection::R2L;
2751  else
2752  eBidiDir = EEHorizontalTextDirection::L2R;
2753  }
2754 
2755  SvtLanguageOptions aLangOpt;
2756  bool bDisableCTLFont = !aLangOpt.IsCTLFontEnabled();
2757  bool bDisableVerticalText = !aLangOpt.IsVerticalTextEnabled();
2758 
2759  SfxWhichIter aIter( rSet );
2760  sal_uInt16 nWhich = aIter.FirstWhich();
2761  while( nWhich )
2762  {
2763  switch( nWhich )
2764  {
2765  case SID_TEXTDIRECTION_LEFT_TO_RIGHT:
2766  case SID_TEXTDIRECTION_TOP_TO_BOTTOM:
2767  if ( bDisableVerticalText )
2768  rSet.DisableItem( nWhich );
2769  else
2770  {
2771  if( bVertDontCare )
2772  rSet.InvalidateItem( nWhich );
2773  else if ( nWhich == SID_TEXTDIRECTION_LEFT_TO_RIGHT )
2774  rSet.Put( SfxBoolItem( nWhich, bLeftRight ) );
2775  else
2776  rSet.Put( SfxBoolItem( nWhich, bTopBottom ) );
2777  }
2778  break;
2779 
2780  case SID_ATTR_PARA_LEFT_TO_RIGHT:
2781  case SID_ATTR_PARA_RIGHT_TO_LEFT:
2782  if ( bDisableCTLFont )
2783  rSet.DisableItem( nWhich );
2784  else
2785  {
2786  if ( bTopBottom )
2787  rSet.DisableItem( nWhich );
2788  else if ( bBidiDontCare )
2789  rSet.InvalidateItem( nWhich );
2790  else if ( nWhich == SID_ATTR_PARA_LEFT_TO_RIGHT )
2791  rSet.Put( SfxBoolItem( nWhich, eBidiDir == EEHorizontalTextDirection::L2R ) );
2792  else
2793  rSet.Put( SfxBoolItem( nWhich, eBidiDir == EEHorizontalTextDirection::R2L ) );
2794  }
2795  }
2796  nWhich = aIter.NextWhich();
2797  }
2798 }
2799 
2800 void ScFormatShell::ExecFormatPaintbrush( const SfxRequest& rReq )
2801 {
2802  ScViewFunc* pView = pViewData->GetView();
2803  if ( pView->HasPaintBrush() )
2804  {
2805  // cancel paintbrush mode
2806  pView->ResetBrushDocument();
2807  }
2808  else
2809  {
2810  bool bLock = false;
2811  const SfxItemSet *pArgs = rReq.GetArgs();
2812  if( pArgs && pArgs->Count() >= 1 )
2813  bLock = pArgs->Get(SID_FORMATPAINTBRUSH).GetValue();
2814 
2815  // in case of multi selection, deselect all and use the cursor position
2816  ScRange aDummy;
2817  if ( pViewData->GetSimpleArea(aDummy) != SC_MARK_SIMPLE )
2818  pView->Unmark();
2819 
2820  ScDocumentUniquePtr pBrushDoc(new ScDocument( SCDOCMODE_CLIP ));
2821  pView->CopyToClip( pBrushDoc.get(), false, true );
2822  pView->SetBrushDocument( std::move(pBrushDoc), bLock );
2823  }
2824 }
2825 
2826 void ScFormatShell::StateFormatPaintbrush( SfxItemSet& rSet )
2827 {
2828  if ( pViewData->HasEditView( pViewData->GetActivePart() ) )
2829  rSet.DisableItem( SID_FORMATPAINTBRUSH );
2830  else
2831  rSet.Put( SfxBoolItem( SID_FORMATPAINTBRUSH, pViewData->GetView()->HasPaintBrush() ) );
2832 }
2833 
2834 SvNumFormatType ScFormatShell::GetCurrentNumberFormatType()
2835 {
2836  SvNumFormatType nType = SvNumFormatType::ALL;
2837  ScDocument& rDoc = GetViewData()->GetDocument();
2838  ScMarkData aMark(GetViewData()->GetMarkData());
2839  const SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
2840  if (!pFormatter)
2841  return nType;
2842 
2843  // TODO: Find out how to get a selected table range in case multiple tables
2844  // are selected. Currently we only check for the current active table.
2845 
2846  if ( aMark.IsMarked() || aMark.IsMultiMarked() )
2847  {
2848  aMark.MarkToMulti();
2849  ScRange aRange;
2850  aMark.GetMultiMarkArea(aRange);
2851 
2852  const ScMultiSel& rMultiSel = aMark.GetMultiSelData();
2853 
2854  SvNumFormatType nComboType = SvNumFormatType::ALL;
2855  bool bFirstItem = true;
2856  for (SCCOL nCol = aRange.aStart.Col(); nCol <= aRange.aEnd.Col(); ++nCol)
2857  {
2858  if (!rMultiSel.HasMarks(nCol))
2859  continue;
2860 
2861  SCROW nRow1, nRow2;
2862  ScMultiSelIter aMultiIter(rMultiSel, nCol);
2863  while (aMultiIter.Next(nRow1, nRow2))
2864  {
2865  ScRange aColRange(nCol, nRow1, aRange.aStart.Tab());
2866  aColRange.aEnd.SetRow(nRow2);
2867  sal_uInt32 nNumFmt = rDoc.GetNumberFormat(aColRange);
2868  SvNumFormatType nThisType = pFormatter->GetType(nNumFmt);
2869  if (bFirstItem)
2870  {
2871  bFirstItem = false;
2872  nComboType = nThisType;
2873  }
2874  else if (nComboType != nThisType)
2875  // mixed number format type.
2876  return SvNumFormatType::ALL;
2877  }
2878  }
2879  nType = nComboType;
2880  }
2881  else
2882  {
2883  sal_uInt32 nNumFmt;
2884  rDoc.GetNumberFormat( pViewData->GetCurX(), pViewData->GetCurY(),
2885  pViewData->GetTabNo(), nNumFmt );
2886  nType = pFormatter->GetType( nNumFmt );
2887  }
2888  return nType;
2889 }
2890 
2891 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
ScViewData::GetMarkData
ScMarkData & GetMarkData()
Definition: viewdata.cxx:3046
ScFormatShell::ExecuteTextAttr
void ExecuteTextAttr(SfxRequest &rReq)
Definition: formatsh.cxx:1390
SfxShell::ExecuteSlot
const SfxPoolItem * ExecuteSlot(SfxRequest &rReq, const SfxInterface *pIF=nullptr)
ScModule::GetIsWaterCan
bool GetIsWaterCan() const
Definition: scmod.hxx:159
SfxViewShell::GetViewFrame
SfxViewFrame * GetViewFrame() const
ScFormatShell::~ScFormatShell
virtual ~ScFormatShell() override
Definition: formatsh.cxx:148
SvxCellHorJustify
SvxCellHorJustify
editeng::SvxBorderLine::SetBorderLineStyle
void SetBorderLineStyle(SvxBorderLineStyle nNew)
ScTabView::ResetBrushDocument
void ResetBrushDocument()
Definition: tabview5.cxx:640
ScTabViewShell::UpdateNumberFormatter
static void UpdateNumberFormatter(const SvxNumberInfoItem &rInfoItem)
Definition: tabvwsh5.cxx:384
ScRange::aStart
ScAddress aStart
Definition: address.hxx:500
ScViewData::GetDocShell
ScDocShell * GetDocShell() const
Definition: viewdata.hxx:354
ScViewFunc::AdjustBlockHeight
bool AdjustBlockHeight(bool bPaint=true, ScMarkData *pMarkData=nullptr)
Definition: viewfun2.cxx:113
editeng::SvxBorderLine::SetWidth
void SetWidth(tools::Long nWidth)
ScViewFunc::SetSelectionFrameLines
void SetSelectionFrameLines(const ::editeng::SvxBorderLine *pLine, bool bColorOnly)
Definition: viewfun2.cxx:3268
ScDocument::IsTabProtected
SC_DLLPUBLIC bool IsTabProtected(SCTAB nTab) const
Definition: documen3.cxx:1890
ScMarkData
todo: It should be possible to have MarkArrays for each table, in order to enable "search all" across...
Definition: markdata.hxx:43
ScDocument::InvalidateTextWidth
void InvalidateTextWidth(const OUString &rStyleName)
Definition: documen8.cxx:295
ATTR_LANGUAGE_FORMAT
constexpr TypedWhichId< SvxLanguageItem > ATTR_LANGUAGE_FORMAT(147)
SvxScriptSetItem::PutItemForScriptType
void PutItemForScriptType(SvtScriptType nScriptType, const SfxPoolItem &rItem)
SFX_IMPL_INTERFACE
#define SFX_IMPL_INTERFACE(Class, SuperClass)
ScViewFunc::CopyToClip
SC_DLLPUBLIC bool CopyToClip(ScDocument *pClipDoc, bool bCut, bool bApi=false, bool bIncludeObjects=false, bool bStopEdit=true)
Definition: viewfun3.cxx:165
ATTR_BORDER
constexpr TypedWhichId< SvxBoxItem > ATTR_BORDER(150)
ScDocShell::PostPaintGridAll
void PostPaintGridAll()
Definition: docsh3.cxx:181
ScViewUtil::PutItemScript
static void PutItemScript(SfxItemSet &rShellSet, const SfxItemSet &rCoreSet, sal_uInt16 nWhichId, SvtScriptType nScript)
Definition: viewutil.cxx:49
ScMarkData::MarkToMulti
void MarkToMulti()
Definition: markdata.cxx:224
ScDocument::SetPreviewSelection
void SetPreviewSelection(const ScMarkData &rSel)
Definition: documen2.cxx:1357
ScFormatShell::GetAttrState
void GetAttrState(SfxItemSet &rSet)
Definition: formatsh.cxx:2046
ATTR_PATTERN_START
constexpr sal_uInt16 ATTR_PATTERN_START(100)
SfxAbstractDialog::GetOutputItemSet
virtual const SfxItemSet * GetOutputItemSet() const =0
GetValue
std::string GetValue
Definition: opinlinefun_statistical.cxx:22
ScTabView::SetBrushDocument
void SetBrushDocument(ScDocumentUniquePtr pNew, bool bLock)
Definition: tabview5.cxx:620
ATTR_VERTICAL_ASIAN
constexpr TypedWhichId< SfxBoolItem > ATTR_VERTICAL_ASIAN(137)
SvxTextLineItem::SetColor
void SetColor(const Color &rCol)
ScFormatShell::GetViewData
ScViewData * GetViewData()
Definition: formatsh.hxx:35
SfxStyleSheetBase::SetParent
virtual bool SetParent(const OUString &)
ScViewFunc::ApplyAttr
void ApplyAttr(const SfxPoolItem &rAttrItem, bool bAdjustBlockHeight=true)
Definition: viewfunc.cxx:998
ScFormatShell::StateFormatPaintbrush
void StateFormatPaintbrush(SfxItemSet &rSet)
Definition: formatsh.cxx:2826
ScFormatShell::GetNumFormatState
void GetNumFormatState(SfxItemSet &rSet)
Definition: formatsh.cxx:2504
SvxBoxInfoItem::SetMinDist
void SetMinDist(bool bNew)
ScTabViewShell::UpdateInputHandlerCellAdjust
void UpdateInputHandlerCellAdjust(SvxCellHorJustify eJust)
Definition: tabvwsha.cxx:726
SfxStyleSheetBasePool::Remove
virtual void Remove(SfxStyleSheetBase *)
sal_uLong
sal_uIntPtr sal_uLong
SvxBoxInfoItem::SetTable
void SetTable(bool bNew)
SvxBoxInfoItem::GetVert
const editeng::SvxBorderLine * GetVert() const
ScViewData::GetCurY
SCROW GetCurY() const
Definition: viewdata.hxx:402
SfxRequest::IsDone
bool IsDone() const
ScDocument::ModifyStyleSheet
void ModifyStyleSheet(SfxStyleSheetBase &rPageStyle, const SfxItemSet &rChanges)
Definition: documen8.cxx:209
ScDocument::GetPreviewSelection
const ScMarkData & GetPreviewSelection() const
Definition: document.hxx:1342
CntUInt16Item::GetValue
sal_uInt16 GetValue() const
SvNumberFormatter::GetType
SvNumFormatType GetType(sal_uInt32 nFIndex) const
SvxFontHeightItem::SetHeight
void SetHeight(sal_uInt32 nNewHeight, const sal_uInt16 nNewProp=100, MapUnit eUnit=MapUnit::MapRelative)
SfxItemSet::InvalidateItem
void InvalidateItem(sal_uInt16 nWhich)
ScDocShell::SetDocumentModified
void SetDocumentModified()
Definition: docsh.cxx:2819
SfxSetItem::GetItemSet
const SfxItemSet & GetItemSet() const
SfxWhichIter::FirstWhich
sal_uInt16 FirstWhich()
ScViewData::HasEditView
bool HasEditView(ScSplitPos eWhich) const
Definition: viewdata.hxx:564
ScViewData::GetTabNo
SCTAB GetTabNo() const
Definition: viewdata.hxx:395
ScDocument::GetNumberFormat
SC_DLLPUBLIC void GetNumberFormat(SCCOL nCol, SCROW nRow, SCTAB nTab, sal_uInt32 &rFormat) const
Definition: document.cxx:3641
SvNumberFormatter::GetIndexTableOffset
NfIndexTableOffset GetIndexTableOffset(sal_uInt32 nFormat) const
ATTR_BORDER_INNER
constexpr TypedWhichId< SvxBoxInfoItem > ATTR_BORDER_INNER(151)
ScTabView::Unmark
void Unmark()
Definition: tabview3.cxx:1718
ScRange::aEnd
ScAddress aEnd
Definition: address.hxx:501
ScViewData::GetActivePart
ScSplitPos GetActivePart() const
Definition: viewdata.hxx:398
SvxFrameDirection
SvxFrameDirection
SfxRequest::Done
void Done(bool bRemove=false)
ScViewData::GetDocument
ScDocument & GetDocument() const
Definition: viewdata.hxx:380
NF_NUMBER_1000DEC2
NF_NUMBER_1000DEC2
ATTR_FONT
constexpr TypedWhichId< SvxFontItem > ATTR_FONT(100)
SfxShell::GetUndoManager
virtual SfxUndoManager * GetUndoManager()
SfxStyleSheetBase::GetItemSet
virtual SfxItemSet & GetItemSet()
ATTR_LINEBREAK
constexpr TypedWhichId< ScLineBreakCell > ATTR_LINEBREAK(139)
SvxLineItem::SetLine
void SetLine(const editeng::SvxBorderLine *pNew)
ATTR_PROTECTION
constexpr TypedWhichId< ScProtectionAttr > ATTR_PROTECTION(149)
SfxObjectShell::GetModel
css::uno::Reference< css::frame::XModel > GetModel() const
SfxRequest::GetArgs
const SfxItemSet * GetArgs() const
SfxBindings::Invalidate
void Invalidate(sal_uInt16 nId)
ScDocument::SetPreviewFont
void SetPreviewFont(std::unique_ptr< SfxItemSet > pFontSet)
Definition: documen2.cxx:1352
SvxBoxItem::GetRight
const editeng::SvxBorderLine * GetRight() const
SfxStyleSheetBase::GetFamily
SfxStyleFamily GetFamily() const
SfxShell::PutItem
void PutItem(const SfxPoolItem &rItem)
SvtLanguageOptions::IsVerticalTextEnabled
bool IsVerticalTextEnabled() const
SfxStyleSheetBase::GetMask
SfxStyleSearchBits GetMask() const
ATTR_MERGE
constexpr TypedWhichId< ScMergeAttr > ATTR_MERGE(144)
SfxObjectShell::getDocProperties
css::uno::Reference< css::document::XDocumentProperties > getDocProperties() const
ScModule::InputEnterHandler
SC_DLLPUBLIC void InputEnterHandler(ScEnterMode nBlockMode=ScEnterMode::NORMAL)
Definition: scmod.cxx:1359
SfxWhichIter::NextWhich
sal_uInt16 NextWhich()
ScFormatShell::GetStyleState
void GetStyleState(SfxItemSet &rSet)
Definition: formatsh.cxx:152
ScDocument::GetPool
SC_DLLPUBLIC ScDocumentPool * GetPool()
Definition: document.cxx:6061
WEIGHT_BOLD
WEIGHT_BOLD
ScDocShell::GetUndoManager
virtual SfxUndoManager * GetUndoManager() override
Definition: docsh.cxx:2805
COL_AUTO
constexpr::Color COL_AUTO(0xFF, 0xFF, 0xFF, 0xFF)
ScMultiSelIter::Next
bool Next(SCROW &rTop, SCROW &rBottom)
Definition: markmulti.cxx:454
ScViewFunc::GetStyleSheetFromMarked
const SfxStyleSheet * GetStyleSheetFromMarked()
Definition: viewfunc.cxx:1295
ScMultiSel::HasMarks
bool HasMarks(SCCOL nCol) const
Definition: markmulti.cxx:69
sal_Unicode
sal_uInt16 sal_Unicode
COL_TRANSPARENT
constexpr::Color COL_TRANSPARENT(0xFF, 0xFF, 0xFF, 0xFF)
ScopedVclPtr::disposeAndReset
void disposeAndReset(reference_type *pBody)
SfxRequest::SetSlot
void SetSlot(sal_uInt16 nNewSlot)
SfxItemSet::MergeRange
void MergeRange(sal_uInt16 nFrom, sal_uInt16 nTo)
SvxTextLineItem::GetColor
const Color & GetColor() const
SfxStyleSheetBase::SetHidden
virtual void SetHidden(bool bValue)
SvxCellVerJustify
SvxCellVerJustify
SfxStyleSheetBase::GetName
const OUString & GetName() const
ScViewFunc::RemoveStyleSheetInUse
void RemoveStyleSheetInUse(const SfxStyleSheetBase *pStyleSheet)
Definition: viewfunc.cxx:1411
LINESTYLE_NONE
LINESTYLE_NONE
editeng::SvxBorderLine::GetOutWidth
sal_uInt16 GetOutWidth() const
editeng::SvxBorderLine::SetColor
void SetColor(const Color &rColor)
ATTR_SHADOW
constexpr TypedWhichId< SvxShadowItem > ATTR_SHADOW(152)
ScDocument::GetTableCount
SC_DLLPUBLIC SCTAB GetTableCount() const
Definition: document.cxx:314
ScDocument::GetSelectionPattern
const ScPatternAttr * GetSelectionPattern(const ScMarkData &rMark)
Definition: document.cxx:5100
ScMarkData::IsMultiMarked
bool IsMultiMarked() const
Definition: markdata.hxx:83
nCount
int nCount
SfxViewShell::libreOfficeKitViewCallback
void libreOfficeKitViewCallback(int nType, const char *pPayload) const override
SfxNewStyleDlg::GetName
OUString GetName() const
NfIndexTableOffset
NfIndexTableOffset
ScTabViewShell::UpdateInputHandler
void UpdateInputHandler(bool bForce=false, bool bStopEditing=true)
Definition: tabvwsha.cxx:638
ScAddress::Tab
SCTAB Tab() const
Definition: address.hxx:271
ScAddress::SetRow
void SetRow(SCROW nRowP)
Definition: address.hxx:275
ScDocument::RenamePageStyleInUse
bool RenamePageStyleInUse(const OUString &rOld, const OUString &rNew)
Definition: documen8.cxx:340
o3tl::strong_int< sal_uInt16, struct LanguageTypeTag >
SfxShell::SetUndoManager
void SetUndoManager(SfxUndoManager *pNewUndoMgr)
SfxStyleFamily
SfxStyleFamily
SvNumberFormatter::GetFormatSpecialInfo
void GetFormatSpecialInfo(sal_uInt32 nFormat, bool &bThousand, bool &IsRed, sal_uInt16 &nPrecision, sal_uInt16 &nLeadingCnt)
ScDocument::GetPattern
SC_DLLPUBLIC const ScPatternAttr * GetPattern(SCCOL nCol, SCROW nRow, SCTAB nTab) const
Definition: document.cxx:4735
ScViewFunc::GetSelectionScriptType
SvtScriptType GetSelectionScriptType()
Definition: viewfunc.cxx:803
SvxBrushItem::SetColor
void SetColor(const Color &rCol)
ScDocument::StylesToNames
void StylesToNames()
Definition: document.cxx:6122
ScDocumentPool::CellStyleCreated
void CellStyleCreated(const OUString &rName, const ScDocument &rDoc)
Definition: docpool.cxx:361
SfxShell::GetPool
SfxItemPool & GetPool() const
ATTR_FONT_UNDERLINE
constexpr TypedWhichId< SvxUnderlineItem > ATTR_FONT_UNDERLINE(104)
ScPatternAttr::GetItem
const SfxPoolItem & GetItem(sal_uInt16 nWhichP) const
Definition: patattr.hxx:70
ScDocument::GetPreviewCellStyle
ScStyleSheet * GetPreviewCellStyle()
Definition: document.hxx:1344
eType
DocumentType eType
ScViewData::GetViewShell
ScTabViewShell * GetViewShell() const
Definition: viewdata.hxx:357
ATTR_BORDER_TLBR
constexpr TypedWhichId< SvxLineItem > ATTR_BORDER_TLBR(141)
SvxBrushItem::GetColor
const Color & GetColor() const
ATTR_VALIDDATA
constexpr TypedWhichId< SfxUInt32Item > ATTR_VALIDDATA(153)
ScFormatShell::GetAlignState
void GetAlignState(SfxItemSet &rSet)
Definition: formatsh.cxx:2455
ScStyleSaveData::InitFromStyle
void InitFromStyle(const SfxStyleSheetBase *pSource)
Definition: undostyl.cxx:59
SfxShell::GetItem
const SfxPoolItem * GetItem(sal_uInt16 nSlotId) const
SvxBoxInfoItem::GetHori
const editeng::SvxBorderLine * GetHori() const
ScFormatShell::GetCurrentNumberFormatType
SvNumFormatType GetCurrentNumberFormatType()
Definition: formatsh.cxx:2834
SvxBoxItem::GetTop
const editeng::SvxBorderLine * GetTop() const
ATTR_FONT_POSTURE
constexpr TypedWhichId< SvxPostureItem > ATTR_FONT_POSTURE(103)
nFontInc
const sal_uInt32 nFontInc
ScDocument::GetFormatTable
SC_DLLPUBLIC SvNumberFormatter * GetFormatTable() const
Definition: documen2.cxx:438
SfxUndoManager::AddUndoAction
virtual void AddUndoAction(std::unique_ptr< SfxUndoAction > pAction, bool bTryMerg=false)
SvNumberformat::GetType
SvNumFormatType GetType() const
SfxItemSet::ClearItem
sal_uInt16 ClearItem(sal_uInt16 nWhich=0)
SvtScriptType
SvtScriptType
nFontMaxSz
const sal_uInt32 nFontMaxSz
ScTabViewShell::GetDefaultFrameLine
::editeng::SvxBorderLine * GetDefaultFrameLine() const
Definition: tabvwsh.hxx:242
ScMarkData::IsMarked
bool IsMarked() const
Definition: markdata.hxx:82
ScTabViewShell::MakeNumberInfoItem
static std::unique_ptr< SvxNumberInfoItem > MakeNumberInfoItem(ScDocument &rDoc, const ScViewData *pViewData)
Definition: tabvwsh5.cxx:314
SvxBoxItem::GetLeft
const editeng::SvxBorderLine * GetLeft() const
SfxItemSet::GetItemState
SfxItemState GetItemState(sal_uInt16 nWhich, bool bSrchInParent=true, const SfxPoolItem **ppItem=nullptr) const
i
int i
ScFormatShell::ScFormatShell
ScFormatShell(ScViewData *pData)
Definition: formatsh.cxx:132
ScViewData::GetBindings
SfxBindings & GetBindings()
Definition: viewdata.cxx:3034
ScDocumentUniquePtr
std::unique_ptr< ScDocument, o3tl::default_delete< ScDocument > > ScDocumentUniquePtr
Definition: document.hxx:2613
SfxStyleSheetBasePool::Make
virtual SfxStyleSheetBase & Make(const OUString &, SfxStyleFamily eFam, SfxStyleSearchBits nMask=SfxStyleSearchBits::All)
SCCOL
sal_Int16 SCCOL
Definition: types.hxx:22
ScTabView::SetActivePointer
void SetActivePointer(PointerStyle nPointer)
Definition: tabview.cxx:890
ATTR_VER_JUSTIFY
constexpr TypedWhichId< SvxVerJustifyItem > ATTR_VER_JUSTIFY(132)
SC_MOD
#define SC_MOD()
Definition: scmod.hxx:253
ScViewFunc::UpdateStyleSheetInUse
void UpdateStyleSheetInUse(const SfxStyleSheetBase *pStyleSheet)
Definition: viewfunc.cxx:1437
SfxViewFrame::GetBindings
SfxBindings & GetBindings()
aHelper
Any aHelper
ScTabViewShell::ExecuteCellFormatDlg
void ExecuteCellFormatDlg(SfxRequest &rReq, const OString &rTabPage)
Definition: tabvwsha.cxx:487
CntUnencodedStringItem::GetValue
const OUString & GetValue() const
SfxItemSet::Count
sal_uInt16 Count() const
SfxClassificationHelper::stringToPolicyType
static SfxClassificationPolicyType stringToPolicyType(const OUString &rType)
SfxRequest::GetArg
const T * GetArg(sal_uInt16 nSlotId) const
SvxBoxInfoItem::SetLine
void SetLine(const editeng::SvxBorderLine *pNew, SvxBoxInfoItemLine nLine)
XATTR_FILL_FIRST
constexpr sal_uInt16 XATTR_FILL_FIRST(XATTRSET_LINE+1)
SfxShell::SetPool
void SetPool(SfxItemPool *pNewPool)
EEHorizontalTextDirection
EEHorizontalTextDirection
WEIGHT_NORMAL
WEIGHT_NORMAL
LINESTYLE_SINGLE
LINESTYLE_SINGLE
u
float u
ScResId
OUString ScResId(const char *pId)
Definition: scdll.cxx:95
ScViewData::GetSimpleArea
ScMarkType GetSimpleArea(SCCOL &rStartCol, SCROW &rStartRow, SCTAB &rStartTab, SCCOL &rEndCol, SCROW &rEndRow, SCTAB &rEndTab) const
Definition: viewdata.cxx:1170
ScViewFunc::SetNumFmtByStr
void SetNumFmtByStr(const OUString &rCode)
Definition: viewfunc.cxx:2643
LANGUAGE_DONTKNOW
#define LANGUAGE_DONTKNOW
ATTR_VALUE_FORMAT
constexpr TypedWhichId< SfxUInt32Item > ATTR_VALUE_FORMAT(146)
SvNumFormatType
SvNumFormatType
ScDocument::GetPageStyle
SC_DLLPUBLIC OUString GetPageStyle(SCTAB nTab) const
Definition: document.cxx:6186
SfxBindings::QueryState
SfxItemState QueryState(sal_uInt16 nSID, std::unique_ptr< SfxPoolItem > &rpState)
ScViewFunc::ApplySelectionPattern
void ApplySelectionPattern(const ScPatternAttr &rAttr, bool bCursorOnly=false)
Definition: viewfunc.cxx:1108
ATTR_STACKED
constexpr TypedWhichId< ScVerticalStackCell > ATTR_STACKED(134)
SfxItemPool::GetSlotId
sal_uInt16 GetSlotId(sal_uInt16 nWhich) const
SfxShell::SetName
void SetName(const OUString &rName)
SV_COUNTRY_LANGUAGE_OFFSET
#define SV_COUNTRY_LANGUAGE_OFFSET
ScViewFunc::SetNumberFormat
void SetNumberFormat(SvNumFormatType nFormatType, sal_uLong nAdd=0)
Definition: viewfunc.cxx:2607
ITALIC_NONE
ITALIC_NONE
ScViewUtil::UnmarkFiltered
static void UnmarkFiltered(ScMarkData &rMark, const ScDocument &rDoc)
Definition: viewutil.cxx:223
ScGlobal::eLnge
static SC_DLLPUBLIC LanguageType eLnge
Definition: global.hxx:548
ScDocument::UpdStlShtPtrsFrmNms
void UpdStlShtPtrsFrmNms()
Definition: document.cxx:6109
SvxScriptSetItem::Clone
virtual SvxScriptSetItem * Clone(SfxItemPool *pPool=nullptr) const override
SfxItemSet::GetPool
SfxItemPool * GetPool() const
SfxShell::GetViewShell
SfxViewShell * GetViewShell() const
ScTabView::InvalidateAttribs
void InvalidateAttribs()
Definition: tabview3.cxx:247
ScPatternAttr::SetStyleSheet
void SetStyleSheet(ScStyleSheet *pNewStyle, bool bClearDirectFormat=true)
Definition: patattr.cxx:1170
SfxBoolItem::SetValue
void SetValue(bool const bTheValue)
ScAddress::Col
SCCOL Col() const
Definition: address.hxx:267
ScViewFunc::GetSelectionPattern
SC_DLLPUBLIC const ScPatternAttr * GetSelectionPattern()
Definition: viewfunc.cxx:829
SFX_OBJECTBAR_OBJECT
#define SFX_OBJECTBAR_OBJECT
SfxUndoManager::LeaveListAction
size_t LeaveListAction()
ScViewData::GetView
ScDBFunc * GetView() const
Definition: viewdata.cxx:852
ATTR_BACKGROUND
constexpr TypedWhichId< SvxBrushItem > ATTR_BACKGROUND(148)
OUStringToOString
OString OUStringToOString(const OUString &str, ConnectionSettings const *settings)
SfxRequest::SetReturnValue
void SetReturnValue(const SfxPoolItem &)
SfxRequest::GetFrameWeld
weld::Window * GetFrameWeld() const
SvxTextLineItem::GetLineStyle
FontLineStyle GetLineStyle() const
SfxBindings::Update
void Update(sal_uInt16 nId)
ScTabView::HasPaintBrush
bool HasPaintBrush() const
Definition: tabview.hxx:584
ScFormatShell::GetTextDirectionState
void GetTextDirectionState(SfxItemSet &rSet)
Definition: formatsh.cxx:2728
SvNumberFormatter::GenerateFormat
OUString GenerateFormat(sal_uInt32 nIndex, LanguageType eLnge=LANGUAGE_DONTKNOW, bool bThousand=false, bool IsRed=false, sal_uInt16 nPrecision=0, sal_uInt16 nLeadingCnt=1)
ATTR_WRITINGDIR
constexpr TypedWhichId< SvxFrameDirectionItem > ATTR_WRITINGDIR(138)
ScDocument::SetPageStyle
SC_DLLPUBLIC void SetPageStyle(SCTAB nTab, const OUString &rName)
Definition: document.cxx:6180
ATTR_MERGE_FLAG
constexpr TypedWhichId< ScMergeFlagAttr > ATTR_MERGE_FLAG(145)
SfxItemSet::Put
const SfxPoolItem * Put(const SfxPoolItem &rItem, sal_uInt16 nWhich)
SCROW
sal_Int32 SCROW
Definition: types.hxx:18
SfxRequest::GetSlot
sal_uInt16 GetSlot() const
FontWeight
FontWeight
ScAbstractDialogFactory::CreateScStyleDlg
virtual VclPtr< SfxAbstractTabDialog > CreateScStyleDlg(weld::Window *pParent, SfxStyleSheetBase &rStyleBase, bool bPage)=0
ScFormatShell::GetBorderState
void GetBorderState(SfxItemSet &rSet)
Definition: formatsh.cxx:2441
SvxFontHeightItem::GetHeight
sal_uInt32 GetHeight() const
ScDocument::SetStreamValid
void SetStreamValid(SCTAB nTab, bool bSet, bool bIgnoreLock=false)
Definition: document.cxx:925
SfxItemState
SfxItemState
SfxItemSet::DisableItem
void DisableItem(sal_uInt16 nWhich)
SfxViewShell::GetFrameWeld
weld::Window * GetFrameWeld() const
SvNumberformat::GetFormatIntegerDigits
sal_uInt16 GetFormatIntegerDigits(sal_uInt16 nIx=0) const
SfxItemSet::Get
const SfxPoolItem & Get(sal_uInt16 nWhich, bool bSrchInParent=true) const
SfxItemPool::GetWhich
sal_uInt16 GetWhich(sal_uInt16 nSlot, bool bDeep=true) const
ITALIC_NORMAL
ITALIC_NORMAL
SvNumberFormatter::GetEntry
const SvNumberformat * GetEntry(sal_uInt32 nKey) const
GetWhich
#define GetWhich(nSlot)
aUIName
OUString aUIName
LINESTYLE_DOTTED
LINESTYLE_DOTTED
SfxShell::Invalidate
virtual void Invalidate(sal_uInt16 nId=0)
ScViewFunc::ChangeNumFmtDecimals
void ChangeNumFmtDecimals(bool bIncrement)
Definition: viewfunc.cxx:2691
SfxPoolItem::SetWhich
void SetWhich(sal_uInt16 nId)
ScAbstractDialogFactory::Create
static SC_DLLPUBLIC ScAbstractDialogFactory * Create()
Definition: scabstdlg.cxx:38
ScViewData::GetDispatcher
SfxDispatcher & GetDispatcher()
Definition: viewdata.cxx:3040
RET_OK
RET_OK
SvtLanguageOptions::IsCTLFontEnabled
bool IsCTLFontEnabled() const
ScDocument::ApplySelectionPattern
SC_DLLPUBLIC void ApplySelectionPattern(const ScPatternAttr &rAttr, const ScMarkData &rMark, ScEditDataArray *pDataArray=nullptr, bool *pIsChanged=nullptr)
Definition: document.cxx:5874
ScGlobal::CheckWidthInvalidate
static bool CheckWidthInvalidate(bool &bNumFormatChanged, const SfxItemSet &rNewAttrs, const SfxItemSet &rOldAttrs)
Definition: global.cxx:178
ATTR_FONT_WEIGHT
constexpr TypedWhichId< SvxWeightItem > ATTR_FONT_WEIGHT(102)
SfxItemSet::HasItem
bool HasItem(sal_uInt16 nWhich, const SfxPoolItem **ppItem=nullptr) const
ATTR_HOR_JUSTIFY
constexpr TypedWhichId< SvxHorJustifyItem > ATTR_HOR_JUSTIFY(129)
ScViewFunc::SetStyleSheetToMarked
void SetStyleSheetToMarked(const SfxStyleSheet *pStyleSheet)
Definition: viewfunc.cxx:1315
SfxUndoManager::EnterListAction
virtual void EnterListAction(const OUString &rComment, const OUString &rRepeatComment, sal_uInt16 nId, ViewShellId nViewShellId)
SvNumberformat::GetMaskedType
SvNumFormatType GetMaskedType() const
ATTR_CONDITIONAL
constexpr TypedWhichId< ScCondFormatItem > ATTR_CONDITIONAL(154)
nType
QPRO_FUNC_TYPE nType
Definition: qproform.cxx:401
COL_BLACK
const ::std::vector< Color > ImpSvNumberformatScan::StandardColor COL_BLACK
ATTR_PATTERN_END
constexpr sal_uInt16 ATTR_PATTERN_END(155)
ScDocShell::GetDocument
const ScDocument & GetDocument() const
Definition: docsh.hxx:216
ScModule::SetWaterCan
void SetWaterCan(bool bNew)
Definition: scmod.hxx:158
ScDocument::GetStyleSheetPool
SC_DLLPUBLIC ScStyleSheetPool * GetStyleSheetPool() const
Definition: document.cxx:6066
ScDocument::SetPreviewCellStyle
void SetPreviewCellStyle(ScStyleSheet *pStyle)
Definition: document.hxx:1346
ScTabView::HideListBox
void HideListBox()
Definition: tabview3.cxx:2957
ScViewFunc::UpdateSelectionArea
void UpdateSelectionArea(const ScMarkData &rSel, ScPatternAttr *pAttr=nullptr)
Definition: viewfunc.cxx:2988
ScFormatShell::ExecuteAlignment
void ExecuteAlignment(SfxRequest &rReq)
Definition: formatsh.cxx:1297
SfxShell::GetInterface
virtual SfxInterface * GetInterface() const
ScViewFunc::ApplyUserItemSet
void ApplyUserItemSet(const SfxItemSet &rItemSet)
Definition: viewfunc.cxx:1276
ScFormatShell::ExecuteTextDirection
void ExecuteTextDirection(const SfxRequest &rReq)
Definition: formatsh.cxx:2688
SfxRequest::AppendItem
void AppendItem(const SfxPoolItem &)
SAL_WARN
#define SAL_WARN(area, stream)
ScViewData::GetSfxDocShell
SfxObjectShell * GetSfxDocShell() const
Definition: viewdata.hxx:358
ScMarkData::GetMultiSelData
const ScMultiSel & GetMultiSelData() const
Definition: markdata.hxx:107
ScDocument::IsUndoEnabled
bool IsUndoEnabled() const
Definition: document.hxx:1531
xModel
Reference< XModel > xModel
Get
SVXCORE_DLLPUBLIC MSO_SPT Get(const OUString &)
ScViewFunc::ApplyAttributes
void ApplyAttributes(const SfxItemSet *pDialogSet, const SfxItemSet *pOldSet, bool bAdjustBlockHeight=true)
Definition: viewfunc.cxx:886
XATTR_FILL_LAST
constexpr sal_uInt16 XATTR_FILL_LAST(XATTR_FILLBACKGROUND)
ScMarkData::GetMultiMarkArea
void GetMultiMarkArea(ScRange &rRange) const
Definition: markdata.cxx:117
SfxRequest::IsAPI
bool IsAPI() const
ScTabViewShell::GetPrinter
virtual SfxPrinter * GetPrinter(bool bCreate=false) override
Definition: tabvwsh4.cxx:1028
SfxDispatcher::Execute
const SfxPoolItem * Execute(sal_uInt16 nSlot, SfxCallMode nCall=SfxCallMode::SLOT, const SfxPoolItem **pArgs=nullptr, sal_uInt16 nModi=0, const SfxPoolItem **pInternalArgs=nullptr)
LINESTYLE_DOUBLE
LINESTYLE_DOUBLE
SfxStyleSheetBase::HasParentSupport
virtual bool HasParentSupport() const
ScFormatShell::GetTextAttrState
void GetTextAttrState(SfxItemSet &rSet)
Definition: formatsh.cxx:2266
ScFormatShell::ExecuteAttr
void ExecuteAttr(SfxRequest &rReq)
Definition: formatsh.cxx:1656
ScFormatShell::ExecuteNumFormat
void ExecuteNumFormat(SfxRequest &rReq)
Definition: formatsh.cxx:977
ScTabViewShell::SetDefaultFrameLine
void SetDefaultFrameLine(const ::editeng::SvxBorderLine *pLine)
Definition: tabvwsh8.cxx:25
FontLineStyle
FontLineStyle
ScFormatShell::ExecFormatPaintbrush
void ExecFormatPaintbrush(const SfxRequest &rReq)
Definition: formatsh.cxx:2800
SfxStyleSheetBasePool::Find
virtual SfxStyleSheetBase * Find(const OUString &, SfxStyleFamily eFam, SfxStyleSearchBits n=SfxStyleSearchBits::All)
ATTR_FONT_COLOR
constexpr TypedWhichId< SvxColorItem > ATTR_FONT_COLOR(109)
ScDocument::IsPageStyleInUse
bool IsPageStyleInUse(const OUString &rStrPageStyle, SCTAB *pInTab)
Definition: documen8.cxx:310
ScFormatShell::pViewData
ScViewData * pViewData
Definition: formatsh.hxx:32
ATTR_FONT_HEIGHT
constexpr TypedWhichId< SvxFontHeightItem > ATTR_FONT_HEIGHT(101)
ScFormatShell::ExecuteStyle
void ExecuteStyle(SfxRequest &rReq)
Definition: formatsh.cxx:249
SvxBoxItem::GetBottom
const editeng::SvxBorderLine * GetBottom() const
ATTR_BORDER_BLTR
constexpr TypedWhichId< SvxLineItem > ATTR_BORDER_BLTR(142)
SvxScriptSetItem::GetItemOfScript
const SfxPoolItem * GetItemOfScript(SvtScriptType nScript) const
ScViewFunc::GetSelectionFrame
void GetSelectionFrame(std::shared_ptr< SvxBoxItem > &rLineOuter, std::shared_ptr< SvxBoxInfoItem > &rLineInner)
Definition: viewfunc.cxx:855
SfxPoolItem::Which
sal_uInt16 Which() const
SfxItemPool::IsWhich
static bool IsWhich(sal_uInt16 nId)
SvNumberformat::GetLanguage
LanguageType GetLanguage() const
SvxColorItem::GetValue
const Color & GetValue() const
SCTAB
sal_Int16 SCTAB
Definition: types.hxx:23
FontItalic
FontItalic
ScDocument::RemovePageStyleInUse
bool RemovePageStyleInUse(const OUString &rStrPageStyle)
Definition: documen8.cxx:325
SvxBoxInfoItem::SetDist
void SetDist(bool bNew)
SvxColorItem::SetValue
void SetValue(const Color &rNewColor)
ScViewData::GetCurX
SCCOL GetCurX() const
Definition: viewdata.hxx:401
SfxViewShell::GetViewShellId
ViewShellId GetViewShellId() const override
SvxBoxItem::SetLine
void SetLine(const editeng::SvxBorderLine *pNew, SvxBoxItemLine nLine)
void
typedef void(CALLTYPE *GetFuncDataPtr)(sal_uInt16 &nNo
ScTabViewShell::SetInFormatDialog
void SetInFormatDialog(bool bFlag)
Definition: tabvwsh.hxx:347
Generated on Mon Oct 26 2020 00:23:34 for LibreOffice Module sc (master) by   doxygen 1.8.10