sc/source/ui/view/tabvwsha.cxx

   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/table/BorderLineStyle.hpp>
  21 #include <officecfg/Office/Calc.hxx>
  22
  23 #include <comphelper/lok.hxx>
  24 #include <editeng/boxitem.hxx>
  25 #include <editeng/langitem.hxx>
  26 #include <o3tl/temporary.hxx>
  27 #include <sfx2/bindings.hxx>
  28 #include <sfx2/request.hxx>
  29 #include <sfx2/sfxdlg.hxx>
  30 #include <sfx2/sidebar/Sidebar.hxx>
  31 #include <sfx2/viewfrm.hxx>
  32 #include <sfx2/dispatch.hxx>
  33 #include <sfx2/newstyle.hxx>
  34 #include <sfx2/tplpitem.hxx>
  35 #include <svl/ilstitem.hxx>
  36 #include <svl/numformat.hxx>
  37 #include <svl/zformat.hxx>
  38 #include <svl/int64item.hxx>
  39 #include <svl/ptitem.hxx>
  40 #include <svl/srchitem.hxx>
  41 #include <svl/srchdefs.hxx>
  42 #include <svl/stritem.hxx>
  43 #include <svl/whiter.hxx>
  44 #include <svx/numinf.hxx>
  45 #include <svx/xbtmpit.hxx>
  46 #include <svx/xlndsit.hxx>
  47 #include <svx/xlnstit.hxx>
  48 #include <svx/xlnedit.hxx>
  49 #include <svx/xflgrit.hxx>
  50 #include <svx/xflftrit.hxx>
  51 #include <svx/xflhtit.hxx>
  52 #include <svx/zoomslideritem.hxx>
  53
  54 #include <global.hxx>
  55 #include <appoptio.hxx>
  56 #include <attrib.hxx>
  57 #include <cellform.hxx>
  58 #include <cellvalue.hxx>
  59 #include <compiler.hxx>
  60 #include <docsh.hxx>
  61 #include <document.hxx>
  62 #include <formulacell.hxx>
  63 #include <globstr.hrc>
  64 #include <inputhdl.hxx>
  65 #include <inputwin.hxx>
  66 #include <markdata.hxx>
  67 #include <patattr.hxx>
  68 #include <sc.hrc>
  69 #include <scabstdlg.hxx>
  70 #include <scitems.hxx>
  71 #include <scmod.hxx>
  72 #include <scresid.hxx>
  73 #include <stlpool.hxx>
  74 #include <tabvwsh.hxx>
  75 #include <tokenarray.hxx>
  76 #include <viewdata.hxx>
  77 #include <printfun.hxx>
  78 #include <undostyl.hxx>
  79 #include <futext.hxx>
  80
  81 #include <memory>
  82
  83 using namespace com::sun::star;
  84
  85 bool ScTabViewShell::GetFunction( OUString& rFuncStr, FormulaError nErrCode )
  86 {
  87     sal_uInt32 nFuncs = ScModule::get()->GetAppOptions().GetStatusFunc();
  88     ScViewData& rViewData   = GetViewData();
  89     ScMarkData& rMark       = rViewData.GetMarkData();
  90     bool bIgnoreError = (rMark.IsMarked() || rMark.IsMultiMarked());
  91     bool bFirst = true;
  92     for ( sal_uInt16 nFunc = 0; nFunc < 32; nFunc++ )
  93     {
  94         if ( !(nFuncs & (1U << nFunc)) )
  95             continue;
  96         ScSubTotalFunc eFunc = static_cast<ScSubTotalFunc>(nFunc);
  97
  98         if (bIgnoreError && (eFunc == SUBTOTAL_FUNC_CNT || eFunc == SUBTOTAL_FUNC_CNT2))
  99             nErrCode = FormulaError::NONE;
 100
 101         if (nErrCode != FormulaError::NONE)
 102         {
 103             rFuncStr = ScGlobal::GetLongErrorString(nErrCode);
 104             return true;
 105         }
 106
 107         TranslateId pGlobStrId;
 108         switch (eFunc)
 109         {
 110             case SUBTOTAL_FUNC_AVE:  pGlobStrId = STR_FUN_TEXT_AVG; break;
 111             case SUBTOTAL_FUNC_CNT:  pGlobStrId = STR_FUN_TEXT_COUNT; break;
 112             case SUBTOTAL_FUNC_CNT2: pGlobStrId = STR_FUN_TEXT_COUNT2; break;
 113             case SUBTOTAL_FUNC_MAX:  pGlobStrId = STR_FUN_TEXT_MAX; break;
 114             case SUBTOTAL_FUNC_MIN:  pGlobStrId = STR_FUN_TEXT_MIN; break;
 115             case SUBTOTAL_FUNC_SUM:  pGlobStrId = STR_FUN_TEXT_SUM; break;
 116             case SUBTOTAL_FUNC_SELECTION_COUNT: pGlobStrId = STR_FUN_TEXT_SELECTION_COUNT; break;
 117
 118             default:
 119             {
 120                 // added to avoid warnings
 121             }
 122         }
 123         if (pGlobStrId)
 124         {
 125             ScDocument& rDoc        = rViewData.GetDocument();
 126             SCCOL       nPosX       = rViewData.GetCurX();
 127             SCROW       nPosY       = rViewData.GetCurY();
 128             SCTAB       nTab        = rViewData.GetTabNo();
 129
 130             OUString aStr = ScResId(pGlobStrId) + ": ";
 131
 132             ScAddress aCursor( nPosX, nPosY, nTab );
 133             double nVal;
 134             if ( rDoc.GetSelectionFunction( eFunc, aCursor, rMark, nVal ) )
 135             {
 136                 if ( nVal == 0.0 )
 137                     aStr += "0";
 138                 else
 139                 {
 140                     // Number in the standard format, the other on the cursor position
 141                     ScInterpreterContext& rContext = rDoc.GetNonThreadedContext();
 142                     sal_uInt32 nNumFmt = 0;
 143                     if ( eFunc != SUBTOTAL_FUNC_CNT && eFunc != SUBTOTAL_FUNC_CNT2 && eFunc != SUBTOTAL_FUNC_SELECTION_COUNT)
 144                     {
 145                         // number format from attributes or formula
 146                         nNumFmt = rDoc.GetNumberFormat( nPosX, nPosY, nTab );
 147                         // If the number format is time (without date) and the
 148                         // result is not within 24 hours, use a duration
 149                         // format. Summing date+time doesn't make much sense
 150                         // otherwise but we also don't want to display duration
 151                         // for a single date+time value.
 152                         if (nVal < 0.0 || nVal >= 1.0)
 153                         {
 154                             const SvNumberformat* pFormat = rContext.NFGetFormatEntry(nNumFmt);
 155                             if (pFormat && (pFormat->GetType() == SvNumFormatType::TIME))
 156                                 nNumFmt = rContext.NFGetTimeFormat( nVal, pFormat->GetLanguage(), true);
 157                         }
 158                     }
 159
 160                     OUString aValStr;
 161                     const Color* pDummy;
 162                     rContext.NFGetOutputString( nVal, nNumFmt, aValStr, &pDummy );
 163                     aStr += aValStr;
 164                 }
 165             }
 166             if ( bFirst )
 167             {
 168                 rFuncStr += aStr;
 169                 bFirst = false;
 170             }
 171             else
 172                 rFuncStr += "; " + aStr;
 173         }
 174     }
 175
 176     return !rFuncStr.isEmpty();
 177 }
 178
 179 //  Functions that are disabled, depending on the selection
 180 //  Default:
 181 //      SID_DELETE,
 182 //      SID_DELETE_CONTENTS,
 183 //      FID_DELETE_CELL
 184 //      FID_VALIDATION
 185
 186 void ScTabViewShell::GetState( SfxItemSet& rSet )
 187 {
 188     ScViewData& rViewData   = GetViewData();
 189     ScDocument& rDoc        = rViewData.GetDocument();
 190     ScDocShell* pDocShell   = rViewData.GetDocShell();
 191     ScMarkData& rMark       = rViewData.GetMarkData();
 192     SCCOL       nPosX       = rViewData.GetCurX();
 193     SCROW       nPosY       = rViewData.GetCurY();
 194     SCTAB       nTab        = rViewData.GetTabNo();
 195
 196     SfxViewFrame& rThisFrame = GetViewFrame();
 197     bool bOle = GetViewFrame().GetFrame().IsInPlace();
 198
 199     SCTAB nTabSelCount = rMark.GetSelectCount();
 200
 201     SfxWhichIter    aIter(rSet);
 202     sal_uInt16          nWhich = aIter.FirstWhich();
 203
 204     while ( nWhich )
 205     {
 206         switch ( nWhich )
 207         {
 208             case FID_CHG_COMMENT:
 209                 {
 210                     ScDocShell* pDocSh = GetViewData().GetDocShell();
 211                     ScAddress aPos( nPosX, nPosY, nTab );
 212                     if ( pDocSh->IsReadOnly() || !pDocSh->GetChangeAction(aPos) || pDocSh->IsDocShared() )
 213                         rSet.DisableItem( nWhich );
 214                 }
 215                 break;
 216
 217             case SID_OPENDLG_EDIT_PRINTAREA:
 218             case SID_ADD_PRINTAREA:
 219             case SID_DEFINE_PRINTAREA:
 220                 {
 221                     if ( pDocShell && pDocShell->IsDocShared() )
 222                     {
 223                         rSet.DisableItem( nWhich );
 224                     }
 225                 }
 226                 break;
 227
 228             case SID_DELETE_PRINTAREA:
 229                 if ( pDocShell && pDocShell->IsDocShared() )
 230                 {
 231                     rSet.DisableItem( nWhich );
 232                 }
 233                 else if (rDoc.IsPrintEntireSheet(nTab))
 234                     rSet.DisableItem(nWhich);
 235                 break;
 236
 237             case SID_STATUS_PAGESTYLE:
 238             case SID_HFEDIT:
 239                 GetViewData().GetDocShell()->GetStatePageStyle( rSet, nTab );
 240                 break;
 241
 242             case SID_SEARCH_ITEM:
 243             {
 244                 SvxSearchItem aItem(ScGlobal::GetSearchItem()); // make a copy.
 245                 // Search on current selection if a range is marked.
 246                 aItem.SetSelection(rMark.IsMarked());
 247                 rSet.Put(aItem);
 248                 break;
 249             }
 250
 251             case SID_SEARCH_OPTIONS:
 252                 {
 253                     // Anything goes
 254                     SearchOptionFlags nOptions = SearchOptionFlags::ALL;
 255
 256                     // No replacement if ReadOnly
 257                     if (GetViewData().GetDocShell()->IsReadOnly())
 258                         nOptions &= ~SearchOptionFlags( SearchOptionFlags::REPLACE | SearchOptionFlags::REPLACE_ALL );
 259                     rSet.Put( SfxUInt16Item( nWhich, static_cast<sal_uInt16>(nOptions) ) );
 260                 }
 261                 break;
 262
 263             case SID_CURRENTCELL:
 264                 {
 265                     ScAddress aScAddress( GetViewData().GetCurX(), GetViewData().GetCurY(), 0 );
 266                     OUString  aAddr(aScAddress.Format(ScRefFlags::ADDR_ABS, nullptr, rDoc.GetAddressConvention()));
 267                     SfxStringItem   aPosItem( SID_CURRENTCELL, aAddr );
 268
 269                     rSet.Put( aPosItem );
 270                 }
 271                 break;
 272
 273             case SID_CURRENTTAB:
 274                 // Table for Basic is 1-based
 275                 rSet.Put( SfxUInt16Item( nWhich, static_cast<sal_uInt16>(GetViewData().GetTabNo()) + 1 ) );
 276                 break;
 277
 278             case SID_CURRENTDOC:
 279                 rSet.Put( SfxStringItem( nWhich, GetViewData().GetDocShell()->GetTitle() ) );
 280                 break;
 281
 282             case FID_TOGGLEINPUTLINE:
 283                 {
 284                     sal_uInt16 nId = ScInputWindowWrapper::GetChildWindowId();
 285
 286                     if ( rThisFrame.KnowsChildWindow( nId ) )
 287                     {
 288                         SfxChildWindow* pWnd = rThisFrame.GetChildWindow( nId );
 289                         rSet.Put( SfxBoolItem( nWhich, pWnd != nullptr ) );
 290                     }
 291                     else
 292                         rSet.DisableItem( nWhich );
 293                 }
 294                 break;
 295
 296             case FID_DEL_MANUALBREAKS:
 297                 if (!rDoc.HasManualBreaks(nTab))
 298                     rSet.DisableItem( nWhich );
 299                 break;
 300
 301             case FID_RESET_PRINTZOOM:
 302                 {
 303                     // disable if already set to default
 304
 305                     OUString aStyleName = rDoc.GetPageStyle( nTab );
 306                     ScStyleSheetPool* pStylePool = rDoc.GetStyleSheetPool();
 307                     SfxStyleSheetBase* pStyleSheet = pStylePool->Find( aStyleName,
 308                                                     SfxStyleFamily::Page );
 309                     OSL_ENSURE( pStyleSheet, "PageStyle not found" );
 310                     if ( pStyleSheet )
 311                     {
 312                         SfxItemSet& rStyleSet = pStyleSheet->GetItemSet();
 313                         sal_uInt16 nScale = rStyleSet.Get(ATTR_PAGE_SCALE).GetValue();
 314                         sal_uInt16 nPages = rStyleSet.Get(ATTR_PAGE_SCALETOPAGES).GetValue();
 315                         if ( nScale == 100 && nPages == 0 )
 316                             rSet.DisableItem( nWhich );
 317                     }
 318                 }
 319                 break;
 320
 321             case SID_ZOOM_IN:
 322                 {
 323                     const Fraction& rZoomY = GetViewData().GetZoomY();
 324                     tools::Long nZoom = tools::Long(rZoomY * 100);
 325                     if (nZoom >= MAXZOOM)
 326                         rSet.DisableItem(nWhich);
 327                 }
 328                 break;
 329             case SID_ZOOM_OUT:
 330                 {
 331                     const Fraction& rZoomY = GetViewData().GetZoomY();
 332                     tools::Long nZoom = tools::Long(rZoomY * 100);
 333                     if (nZoom <= MINZOOM)
 334                         rSet.DisableItem(nWhich);
 335                 }
 336                 break;
 337
 338             case FID_SCALE:
 339             case SID_ATTR_ZOOM:
 340                 if ( bOle )
 341                     rSet.DisableItem( nWhich );
 342                 else
 343                 {
 344                     const Fraction& rOldY = GetViewData().GetZoomY();
 345                     sal_uInt16 nZoom = static_cast<sal_uInt16>(tools::Long( rOldY * 100 ));
 346                     rSet.Put( SvxZoomItem( SvxZoomType::PERCENT, nZoom, TypedWhichId<SvxZoomItem>(nWhich) ) );
 347                 }
 348                 break;
 349
 350             case SID_ATTR_ZOOMSLIDER:
 351                 {
 352                     if ( bOle )
 353                         rSet.DisableItem( nWhich );
 354                     else
 355                     {
 356                         const Fraction& rOldY = GetViewData().GetZoomY();
 357                         sal_uInt16 nCurrentZoom = static_cast<sal_uInt16>(tools::Long( rOldY * 100 ));
 358
 359                         if( nCurrentZoom )
 360                         {
 361                             SvxZoomSliderItem aZoomSliderItem( nCurrentZoom, MINZOOM, MAXZOOM, SID_ATTR_ZOOMSLIDER );
 362                             aZoomSliderItem.AddSnappingPoint( 100 );
 363                             rSet.Put( aZoomSliderItem );
 364                         }
 365                     }
 366                 }
 367                 break;
 368
 369             case FID_FUNCTION_BOX:
 370             {
 371                 const bool bBoxOpen = ::sfx2::sidebar::Sidebar::IsPanelVisible(u"ScFunctionsPanel",
 372                                                     rThisFrame.GetFrame().GetFrameInterface());
 373                 rSet.Put(SfxBoolItem(nWhich, bBoxOpen));
 374                 break;
 375             }
 376
 377             case FID_TOGGLESYNTAX:
 378                 rSet.Put(SfxBoolItem(nWhich, GetViewData().IsSyntaxMode()));
 379                 break;
 380
 381             case FID_TOGGLECOLROWHIGHLIGHTING:
 382                 rSet.Put(SfxBoolItem(
 383                     nWhich,
 384                     officecfg::Office::Calc::Content::Display::ColumnRowHighlighting::get()));
 385                 break;
 386
 387             case FID_TOGGLEHEADERS:
 388                 rSet.Put(SfxBoolItem(nWhich, GetViewData().IsHeaderMode()));
 389                 break;
 390
 391             case FID_TOGGLEFORMULA:
 392                 {
 393                     const ScViewOptions& rOpts = rViewData.GetOptions();
 394                     bool bFormulaMode = rOpts.GetOption( VOPT_FORMULAS );
 395                     rSet.Put(SfxBoolItem(nWhich, bFormulaMode ));
 396                 }
 397                 break;
 398
 399             case FID_NORMALVIEWMODE:
 400             case FID_PAGEBREAKMODE:
 401                 // always handle both slots - they exclude each other
 402                 if ( bOle )
 403                 {
 404                     rSet.DisableItem( FID_NORMALVIEWMODE );
 405                     rSet.DisableItem( FID_PAGEBREAKMODE );
 406                 }
 407                 else
 408                 {
 409                     rSet.Put(SfxBoolItem(FID_NORMALVIEWMODE, !GetViewData().IsPagebreakMode()));
 410                     rSet.Put(SfxBoolItem(FID_PAGEBREAKMODE, GetViewData().IsPagebreakMode()));
 411                 }
 412                 break;
 413
 414             case FID_PROTECT_DOC:
 415                 {
 416                     if ( pDocShell && pDocShell->IsDocShared() )
 417                     {
 418                         rSet.DisableItem( nWhich );
 419                     }
 420                     else
 421                     {
 422                         rSet.Put( SfxBoolItem( nWhich, rDoc.IsDocProtected() ) );
 423                     }
 424                 }
 425                 break;
 426
 427             case FID_PROTECT_TABLE:
 428                 {
 429                     if ( pDocShell && pDocShell->IsDocShared() )
 430                     {
 431                         rSet.DisableItem( nWhich );
 432                     }
 433                     else
 434                     {
 435                         rSet.Put( SfxBoolItem( nWhich, rDoc.IsTabProtected( nTab ) ) );
 436                     }
 437                 }
 438                 break;
 439
 440             case SID_AUTO_OUTLINE:
 441                 {
 442                     if (rDoc.GetChangeTrack()!=nullptr || GetViewData().IsMultiMarked())
 443                     {
 444                         rSet.DisableItem( nWhich );
 445                     }
 446                 }
 447                 break;
 448
 449             case SID_OUTLINE_DELETEALL:
 450                 {
 451                     SCTAB nOlTab = GetViewData().GetTabNo();
 452                     ScOutlineTable* pOlTable = rDoc.GetOutlineTable( nOlTab );
 453                     if (pOlTable == nullptr)
 454                         rSet.DisableItem( nWhich );
 455                 }
 456                 break;
 457
 458             case SID_WINDOW_SPLIT:
 459                 rSet.Put(SfxBoolItem(nWhich,
 460                             rViewData.GetHSplitMode() == SC_SPLIT_NORMAL ||
 461                             rViewData.GetVSplitMode() == SC_SPLIT_NORMAL ));
 462                 break;
 463
 464             case SID_WINDOW_FIX:
 465                 if(!comphelper::LibreOfficeKit::isActive())
 466                 {
 467                     rSet.Put(SfxBoolItem(nWhich,
 468                                 rViewData.GetHSplitMode() == SC_SPLIT_FIX ||
 469                                 rViewData.GetVSplitMode() == SC_SPLIT_FIX ));
 470                 }
 471                 else
 472                 {
 473                     rSet.Put(SfxBoolItem(nWhich,
 474                             rViewData.GetLOKSheetFreezeIndex(true) > 0 ||
 475                             rViewData.GetLOKSheetFreezeIndex(false) > 0 ));
 476                 }
 477                 break;
 478
 479             case SID_WINDOW_FIX_COL:
 480             case SID_WINDOW_FIX_ROW:
 481                 {
 482                     Point aPos;
 483                     bool bIsCol = (nWhich == SID_WINDOW_FIX_COL);
 484                     aPos.setX(rViewData.GetLOKSheetFreezeIndex(bIsCol));
 485                     aPos.setY(rViewData.GetTabNo());
 486                     rSet.Put(SfxPointItem(nWhich, aPos));
 487                 }
 488                 break;
 489
 490             case FID_CHG_SHOW:
 491                 {
 492                     if ( rDoc.GetChangeTrack() == nullptr || ( pDocShell && pDocShell->IsDocShared() ) )
 493                         rSet.DisableItem( nWhich );
 494                 }
 495                 break;
 496             case FID_CHG_ACCEPT:
 497                 {
 498                     if(
 499                        ( !rDoc.GetChangeTrack() && !rThisFrame.HasChildWindow(FID_CHG_ACCEPT) )
 500                        ||
 501                        ( pDocShell && pDocShell->IsDocShared() )
 502                       )
 503                     {
 504                         rSet.DisableItem( nWhich);
 505                     }
 506                     else
 507                     {
 508                         rSet.Put(SfxBoolItem(FID_CHG_ACCEPT,
 509                             rThisFrame.HasChildWindow(FID_CHG_ACCEPT)));
 510                     }
 511                 }
 512                 break;
 513
 514             case SID_FORMATPAGE:
 515                 // in protected tables
 516                 if ( pDocShell && ( pDocShell->IsReadOnly() || pDocShell->IsDocShared() ) )
 517                     rSet.DisableItem( nWhich );
 518                 break;
 519
 520             case SID_PRINTPREVIEW:
 521                 // Toggle slot needs a State
 522                 rSet.Put( SfxBoolItem( nWhich, false ) );
 523                 break;
 524
 525             case SID_READONLY_MODE:
 526                 rSet.Put( SfxBoolItem( nWhich, GetViewData().GetDocShell()->IsReadOnly() ) );
 527                 break;
 528
 529             case FID_TAB_DESELECTALL:
 530                 if ( nTabSelCount == 1 )
 531                     rSet.DisableItem( nWhich );     // enabled only if several sheets are selected
 532                 break;
 533
 534             case FID_TOGGLEHIDDENCOLROW:
 535                 const svtools::ColorConfig& rColorCfg = ScModule::get()->GetColorConfig();
 536                 rSet.Put( SfxBoolItem( nWhich, rColorCfg.GetColorValue(svtools::CALCHIDDENROWCOL).bIsVisible) );
 537                 break;
 538
 539         } // switch ( nWitch )
 540         nWhich = aIter.NextWhich();
 541     } // while ( nWitch )
 542 }
 543
 544 void ScTabViewShell::ExecuteCellFormatDlg(SfxRequest& rReq, const OUString &rName)
 545 {
 546     ScDocument& rDoc = GetViewData().GetDocument();
 547
 548     std::shared_ptr<SvxBoxItem> aLineOuter(std::make_shared<SvxBoxItem>(ATTR_BORDER));
 549     std::shared_ptr<SvxBoxInfoItem> aLineInner(std::make_shared<SvxBoxInfoItem>(ATTR_BORDER_INNER));
 550
 551     const ScPatternAttr*    pOldAttrs       = GetSelectionPattern();
 552
 553     auto xOldSet = std::make_shared<SfxItemSet>(pOldAttrs->GetItemSet());
 554
 555     xOldSet->MergeRange(XATTR_FILLSTYLE, XATTR_FILLCOLOR);
 556
 557     xOldSet->MergeRange(SID_ATTR_BORDER_STYLES, SID_ATTR_BORDER_DEFAULT_WIDTH);
 558
 559     // We only allow these border line types.
 560     std::vector<sal_Int32> aBorderStyles{
 561         table::BorderLineStyle::SOLID,
 562         table::BorderLineStyle::DOTTED,
 563         table::BorderLineStyle::DASHED,
 564         table::BorderLineStyle::FINE_DASHED,
 565         table::BorderLineStyle::DASH_DOT,
 566         table::BorderLineStyle::DASH_DOT_DOT,
 567         table::BorderLineStyle::DOUBLE_THIN };
 568
 569     xOldSet->Put(SfxIntegerListItem(SID_ATTR_BORDER_STYLES, std::move(aBorderStyles)));
 570
 571     // Set the default border width to 0.75 points.
 572     SfxInt64Item aBorderWidthItem(SID_ATTR_BORDER_DEFAULT_WIDTH, 75);
 573     xOldSet->Put(aBorderWidthItem);
 574
 575     // Get border items and put them in the set:
 576     GetSelectionFrame( aLineOuter, aLineInner );
 577
 578     //Fix border incorrect for RTL fdo#62399
 579     if( rDoc.IsLayoutRTL( GetViewData().GetTabNo() ) )
 580     {
 581         std::unique_ptr<SvxBoxItem> aNewFrame(aLineOuter->Clone());
 582         std::unique_ptr<SvxBoxInfoItem> aTempInfo(aLineInner->Clone());
 583
 584         if ( aLineInner->IsValid(SvxBoxInfoItemValidFlags::LEFT) )
 585             aNewFrame->SetLine( aLineOuter->GetLeft(), SvxBoxItemLine::RIGHT );
 586         if ( aLineInner->IsValid(SvxBoxInfoItemValidFlags::RIGHT) )
 587             aNewFrame->SetLine( aLineOuter->GetRight(), SvxBoxItemLine::LEFT );
 588
 589         aLineInner->SetValid( SvxBoxInfoItemValidFlags::LEFT, aTempInfo->IsValid(SvxBoxInfoItemValidFlags::RIGHT));
 590         aLineInner->SetValid( SvxBoxInfoItemValidFlags::RIGHT, aTempInfo->IsValid(SvxBoxInfoItemValidFlags::LEFT));
 591
 592         xOldSet->Put( std::move(aNewFrame) );
 593     }
 594     else
 595     {
 596         xOldSet->Put( *aLineOuter );
 597     }
 598
 599     xOldSet->Put( *aLineInner );
 600
 601     // Generate NumberFormat Value from Value and Language and box it.
 602     xOldSet->Put( SfxUInt32Item( ATTR_VALUE_FORMAT,
 603         pOldAttrs->GetNumberFormat( rDoc.GetFormatTable() ) ) );
 604
 605     std::unique_ptr<SvxNumberInfoItem> pNumberInfoItem = MakeNumberInfoItem(rDoc, GetViewData());
 606     xOldSet->MergeRange( SID_ATTR_NUMBERFORMAT_INFO, SID_ATTR_NUMBERFORMAT_INFO );
 607     xOldSet->Put( std::move(pNumberInfoItem) );
 608
 609     bInFormatDialog = true;
 610     ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
 611
 612     VclPtr<SfxAbstractTabDialog> pDlg(pFact->CreateScAttrDlg(GetFrameWeld(), xOldSet.get()));
 613
 614     if (!rName.isEmpty())
 615         pDlg->SetCurPageId(rName);
 616
 617     auto xRequest = std::make_shared<SfxRequest>(rReq);
 618     rReq.Ignore(); // the 'old' request is not relevant any more
 619
 620     pDlg->StartExecuteAsync([pDlg, xOldSet=std::move(xOldSet), xRequest=std::move(xRequest), this](sal_Int32 nResult){
 621         bInFormatDialog = false;
 622
 623         if ( nResult == RET_OK )
 624         {
 625             const SfxItemSet* pOutSet = pDlg->GetOutputItemSet();
 626             if(const SvxNumberInfoItem* pItem = pOutSet->GetItemIfSet(SID_ATTR_NUMBERFORMAT_INFO))
 627             {
 628                 UpdateNumberFormatter(*pItem);
 629             }
 630
 631             ApplyAttributes(*pOutSet, *xOldSet);
 632
 633             xRequest->Done(*pOutSet);
 634         }
 635
 636         pDlg->disposeOnce();
 637     });
 638 }
 639
 640 const OUString* ScTabViewShell::GetEditString() const
 641 {
 642     if (mpInputHandler)
 643         return &mpInputHandler->GetEditString();
 644
 645     return nullptr;
 646 }
 647
 648 bool ScTabViewShell::IsRefInputMode() const
 649 {
 650     if (ScModule* pScMod = ScModule::get())
 651     {
 652         if( pScMod->IsRefDialogOpen() )
 653             return pScMod->IsFormulaMode();
 654         if( pScMod->IsFormulaMode() )
 655         {
 656             ScInputHandler* pHdl = pScMod->GetInputHdl();
 657             if ( pHdl )
 658             {
 659                 const ScViewData& rViewData = GetViewData();
 660                 ScDocument& rDoc = rViewData.GetDocument();
 661                 const ScAddress aPos( rViewData.GetCurPos() );
 662                 const sal_uInt32 nIndex = rDoc.GetAttr(aPos, ATTR_VALUE_FORMAT )->GetValue();
 663                 const SvNumFormatType nType = rDoc.GetFormatTable()->GetType(nIndex);
 664                 if (nType == SvNumFormatType::TEXT)
 665                 {
 666                     return false;
 667                 }
 668                 OUString aString = pHdl->GetEditString();
 669                 if ( !pHdl->GetSelIsRef() && aString.getLength() > 1 &&
 670                      ( aString[0] == '+' || aString[0] == '-' ) )
 671                 {
 672                     ScCompiler aComp( rDoc, aPos, rDoc.GetGrammar() );
 673                     aComp.SetCloseBrackets( false );
 674                     std::unique_ptr<ScTokenArray> pArr(aComp.CompileString(aString));
 675                     if ( pArr && pArr->MayReferenceFollow() )
 676                     {
 677                         return true;
 678                     }
 679                 }
 680                 else
 681                 {
 682                     return true;
 683                 }
 684             }
 685         }
 686     }
 687
 688     return false;
 689 }
 690
 691 void ScTabViewShell::ExecuteInputDirect()
 692 {
 693     if ( !IsRefInputMode() )
 694     {
 695         if (ScModule* pScMod = ScModule::get())
 696         {
 697             pScMod->InputEnterHandler();
 698         }
 699     }
 700 }
 701
 702 void ScTabViewShell::UpdateInputHandler( bool bForce /* = sal_False */, bool bStopEditing /* = sal_True */ )
 703 {
 704     ScInputHandler* pHdl = mpInputHandler ? mpInputHandler.get() : ScModule::get()->GetInputHdl();
 705
 706     if ( pHdl )
 707     {
 708         OUString                aString;
 709         const EditTextObject*   pObject     = nullptr;
 710         ScViewData&             rViewData   = GetViewData();
 711         ScDocument&             rDoc        = rViewData.GetDocument();
 712         SCCOL                   nPosX       = rViewData.GetCurX();
 713         SCROW                   nPosY       = rViewData.GetCurY();
 714         SCTAB                   nTab        = rViewData.GetTabNo();
 715         SCTAB                   nStartTab   = 0;
 716         SCTAB                   nEndTab     = 0;
 717         SCCOL                   nStartCol   = 0;
 718         SCROW                   nStartRow   = 0;
 719         SCCOL                   nEndCol     = 0;
 720         SCROW                   nEndRow     = 0;
 721         ScAddress aPos = rViewData.GetCurPos();
 722
 723         rViewData.GetSimpleArea( nStartCol, nStartRow, nStartTab,
 724                                   nEndCol,   nEndRow,   nEndTab );
 725
 726         PutInOrder( nStartCol, nEndCol );
 727         PutInOrder( nStartRow, nEndRow );
 728         PutInOrder( nStartTab, nEndTab );
 729
 730         bool bHideFormula = false;
 731         bool bHideAll     = false;
 732
 733         if (rDoc.IsTabProtected(nTab))
 734         {
 735             const ScProtectionAttr* pProt = rDoc.GetAttr( nPosX,nPosY,nTab,
 736                                                            ATTR_PROTECTION);
 737             bHideFormula = pProt->GetHideFormula();
 738             bHideAll     = pProt->GetHideCell();
 739         }
 740
 741         if (!bHideAll)
 742         {
 743             ScRefCellValue rCell(rDoc, aPos);
 744             if (rCell.getType() == CELLTYPE_FORMULA)
 745             {
 746                 if (!bHideFormula)
 747                     aString = rCell.getFormula()->GetFormula();
 748             }
 749             else if (rCell.getType() == CELLTYPE_EDIT)
 750             {
 751                 pObject = rCell.getEditText();
 752             }
 753             else
 754             {
 755                 ScInterpreterContext& rContext = rDoc.GetNonThreadedContext();
 756                 sal_uInt32 nNumFmt = rDoc.GetNumberFormat( ScRange(aPos) );
 757
 758                 aString = ScCellFormat::GetInputString( rCell, nNumFmt, &rContext, rDoc );
 759                 if (rCell.getType() == CELLTYPE_STRING)
 760                 {
 761                     // Put a ' in front if necessary, so that the string is not
 762                     // unintentionally interpreted as a number, and to show the
 763                     // user that it is a string (#35060#).
 764                     // If cell is not formatted as Text, a leading apostrophe
 765                     // needs another prepended, also '=' or '+' or '-'
 766                     // otherwise starting a formula.
 767                     // NOTE: this corresponds with
 768                     // sc/source/core/data/column3.cxx ScColumn::ParseString()
 769                     // removing one apostrophe.
 770                     // For number format Text IsNumberFormat() would never
 771                     // result in numeric anyway.
 772                     if (!rContext.NFIsTextFormat(nNumFmt) && (aString.startsWith("'")
 773                                 || aString.startsWith("=") || aString.startsWith("+") || aString.startsWith("-")
 774                                 || rContext.NFIsNumberFormat(aString, nNumFmt, o3tl::temporary(double()))))
 775                         aString = "'" + aString;
 776                 }
 777             }
 778         }
 779
 780         ScInputHdlState aState( ScAddress( nPosX,     nPosY,     nTab ),
 781                                 ScAddress( nStartCol, nStartRow, nTab ),
 782                                 ScAddress( nEndCol,   nEndRow,   nTab ),
 783                                 aString,
 784                                 pObject );
 785
 786         //  if using the view's local input handler, this view can always be set
 787         //  as current view inside NotifyChange.
 788         ScTabViewShell* pSourceSh = mpInputHandler ? this : nullptr;
 789
 790         pHdl->NotifyChange( &aState, bForce, pSourceSh, bStopEditing );
 791     }
 792
 793     SfxBindings& rBindings = GetViewFrame().GetBindings();
 794     rBindings.Invalidate( SID_STATUS_SUM );         // always together with the input row
 795     rBindings.Invalidate( SID_ATTR_SIZE );
 796     rBindings.Invalidate( SID_TABLE_CELL );
 797 }
 798
 799 void ScTabViewShell::UpdateInputHandlerCellAdjust( SvxCellHorJustify eJust )
 800 {
 801     if( ScInputHandler* pHdl = mpInputHandler ? mpInputHandler.get() : ScModule::get()->GetInputHdl() )
 802         pHdl->UpdateCellAdjust( eJust );
 803 }
 804
 805 void ScTabViewShell::ExecuteSave( SfxRequest& rReq )
 806 {
 807     // only SID_SAVEDOC / SID_SAVEASDOC
 808     bool bCommitChanges = true;
 809     const SfxItemSet* pReqArgs = rReq.GetArgs();
 810     const SfxPoolItem* pItem;
 811
 812     if (pReqArgs && pReqArgs->HasItem(FN_PARAM_1, &pItem))
 813         bCommitChanges = !static_cast<const SfxBoolItem*>(pItem)->GetValue();
 814
 815     // Finish entering unless 'DontTerminateEdit' is specified, even if a formula is being processed
 816     if (bCommitChanges)
 817     {
 818         bool bLOKActive = comphelper::LibreOfficeKit::isActive();
 819
 820         // Disable error dialog box when about to save in lok mode as
 821         // this ultimately invokes SvpSalInstance::DoYield() when we want
 822         // to save immediately without committing any erroneous input in possibly
 823         // a cell with validation rules. After save is complete the user
 824         // can continue editing.
 825         ScModule::get()->InputEnterHandler(ScEnterMode::NORMAL, bLOKActive /* bBeforeSavingInLOK */);
 826
 827         if (bLOKActive)
 828         {
 829             // Normally this isn't needed, but in Calc when editing a cell formula
 830             // and manually saving (without changing cells or hitting enter), while
 831             // InputEnterHandler will mark the doc as modified (when it is), because
 832             // we will save the doc immediately afterwards, the modified state event
 833             // is clobbered. To avoid that, we need to update SID_DOC_MODIFIED so that
 834             // a possible state of "true" after "InputEnterHandler" will be sent
 835             // as a notification. It is important that the notification goes through
 836             // normal process (cache) rather than directly notifying the views.
 837             // Otherwise, because there is a previous state of "false" in cache, the
 838             // "false" state after saving will be ignored.
 839             // This will work only if .uno:ModifiedStatus message will be removed from
 840             // the mechanism that keeps in the message queue only last message of
 841             // a particular status even if the values are different.
 842             if (SfxBindings* pBindings = GetViewData().GetDocShell()->GetViewBindings())
 843                 pBindings->Update(SID_DOC_MODIFIED);
 844         }
 845     }
 846
 847     if ( GetViewData().GetDocShell()->IsDocShared() )
 848     {
 849         GetViewData().GetDocShell()->SetDocumentModified();
 850     }
 851
 852     // otherwise as normal
 853     GetViewData().GetDocShell()->ExecuteSlot( rReq );
 854 }
 855
 856 void ScTabViewShell::GetSaveState( SfxItemSet& rSet )
 857 {
 858     SfxShell* pDocSh = GetViewData().GetDocShell();
 859
 860     SfxWhichIter aIter(rSet);
 861     sal_uInt16 nWhich = aIter.FirstWhich();
 862     while( nWhich )
 863     {
 864         if ( nWhich != SID_SAVEDOC || !GetViewData().GetDocShell()->IsDocShared() )
 865         {
 866             // get state from DocShell
 867             pDocSh->GetSlotState( nWhich, nullptr, &rSet );
 868         }
 869         nWhich = aIter.NextWhich();
 870     }
 871 }
 872
 873 void ScTabViewShell::ExecDrawOpt( const SfxRequest& rReq )
 874 {
 875     ScViewOptions aViewOptions = GetViewData().GetOptions();
 876     ScGridOptions aGridOptions = aViewOptions.GetGridOptions();
 877
 878     SfxBindings& rBindings = GetViewFrame().GetBindings();
 879     const SfxItemSet* pArgs = rReq.GetArgs();
 880     const SfxPoolItem* pItem;
 881     sal_uInt16 nSlotId = rReq.GetSlot();
 882     switch (nSlotId)
 883     {
 884         case SID_GRID_VISIBLE:
 885             if ( pArgs && pArgs->GetItemState(nSlotId,true,&pItem) == SfxItemState::SET )
 886             {
 887                 aGridOptions.SetGridVisible( static_cast<const SfxBoolItem*>(pItem)->GetValue() );
 888                 aViewOptions.SetGridOptions(aGridOptions);
 889                 rBindings.Invalidate(SID_GRID_VISIBLE);
 890             }
 891             break;
 892
 893         case SID_GRID_USE:
 894             if ( pArgs && pArgs->GetItemState(nSlotId,true,&pItem) == SfxItemState::SET )
 895             {
 896                 aGridOptions.SetUseGridSnap( static_cast<const SfxBoolItem*>(pItem)->GetValue() );
 897                 aViewOptions.SetGridOptions(aGridOptions);
 898                 rBindings.Invalidate(SID_GRID_USE);
 899             }
 900             break;
 901
 902         case SID_HELPLINES_MOVE:
 903             if ( pArgs && pArgs->GetItemState(nSlotId,true,&pItem) == SfxItemState::SET )
 904             {
 905                 aViewOptions.SetOption( VOPT_HELPLINES, static_cast<const SfxBoolItem*>(pItem)->GetValue() );
 906                 rBindings.Invalidate(SID_HELPLINES_MOVE);
 907             }
 908             break;
 909     }
 910
 911     GetViewData().SetOptions(aViewOptions);
 912 }
 913
 914 void ScTabViewShell::GetDrawOptState( SfxItemSet& rSet )
 915 {
 916     SfxBoolItem aBool;
 917
 918     const ScViewOptions& rViewOptions = GetViewData().GetOptions();
 919     const ScGridOptions& rGridOptions = rViewOptions.GetGridOptions();
 920
 921     aBool.SetValue(rGridOptions.GetGridVisible());
 922     aBool.SetWhich( SID_GRID_VISIBLE );
 923     rSet.Put( aBool );
 924
 925     aBool.SetValue(rGridOptions.GetUseGridSnap());
 926     aBool.SetWhich( SID_GRID_USE );
 927     rSet.Put( aBool );
 928
 929     aBool.SetValue(rViewOptions.GetOption( VOPT_HELPLINES ));
 930     aBool.SetWhich( SID_HELPLINES_MOVE );
 931     rSet.Put( aBool );
 932 }
 933
 934 void ScTabViewShell::ExecStyle( SfxRequest& rReq )
 935 {
 936     const SfxItemSet* pArgs = rReq.GetArgs();
 937     const sal_uInt16  nSlotId = rReq.GetSlot();
 938     if ( !pArgs && nSlotId != SID_STYLE_NEW_BY_EXAMPLE && nSlotId != SID_STYLE_UPDATE_BY_EXAMPLE )
 939     {
 940         // in case of vertical toolbar
 941         GetDispatcher()->Execute( SID_STYLE_DESIGNER, SfxCallMode::ASYNCHRON | SfxCallMode::RECORD );
 942         return;
 943     }
 944
 945     SfxBindings&        rBindings   = GetViewData().GetBindings();
 946     const SCTAB         nCurTab     = GetViewData().GetTabNo();
 947     ScDocShell*         pDocSh      = GetViewData().GetDocShell();
 948     ScDocument&         rDoc        = pDocSh->GetDocument();
 949     ScMarkData&         rMark       = GetViewData().GetMarkData();
 950     ScModule*           pScMod      = ScModule::get();
 951     SdrObject*          pEditObject = GetDrawView()->GetTextEditObject();
 952     OutlinerView*       pOLV        = GetDrawView()->GetTextEditOutlinerView();
 953     ESelection          aSelection  = pOLV ? pOLV->GetSelection() : ESelection();
 954     OUString            aRefName;
 955     bool                bUndo       = rDoc.IsUndoEnabled();
 956
 957     SfxStyleSheetBasePool*  pStylePool  = rDoc.GetStyleSheetPool();
 958     SfxStyleSheetBase*      pStyleSheet = nullptr;
 959
 960     bool bStyleToMarked = false;
 961     bool bListAction = false;
 962     bool bAddUndo = false;          // add ScUndoModifyStyle (style modified)
 963     auto xOldData = std::make_shared<ScStyleSaveData>();       // for undo/redo
 964     auto xNewData = std::make_shared<ScStyleSaveData>();
 965
 966     SfxStyleFamily eFamily = SfxStyleFamily::Para;
 967     const SfxUInt16Item* pFamItem;
 968     const SfxStringItem* pFamilyNameItem;
 969     if ( pArgs && (pFamItem = pArgs->GetItemIfSet( SID_STYLE_FAMILY )) )
 970         eFamily = static_cast<SfxStyleFamily>(pFamItem->GetValue());
 971     else if ( pArgs && (pFamilyNameItem = pArgs->GetItemIfSet( SID_STYLE_FAMILYNAME )) )
 972     {
 973         const OUString& sFamily = pFamilyNameItem->GetValue();
 974         if (sFamily == "CellStyles")
 975             eFamily = SfxStyleFamily::Para;
 976         else if (sFamily == "PageStyles")
 977             eFamily = SfxStyleFamily::Page;
 978         else if (sFamily == "GraphicStyles")
 979             eFamily = SfxStyleFamily::Frame;
 980     }
 981
 982     OUString                aStyleName;
 983     sal_uInt16              nRetMask = 0xffff;
 984
 985     switch ( nSlotId )
 986     {
 987         case SID_STYLE_NEW:
 988             {
 989                 const SfxPoolItem* pNameItem;
 990                 if (pArgs && SfxItemState::SET == pArgs->GetItemState( nSlotId, true, &pNameItem ))
 991                     aStyleName  = static_cast<const SfxStringItem*>(pNameItem)->GetValue();
 992
 993                 const SfxStringItem* pRefItem=nullptr;
 994                 if (pArgs && (pRefItem = pArgs->GetItemIfSet( SID_STYLE_REFERENCE )))
 995                 {
 996                     aRefName  = pRefItem->GetValue();
 997                 }
 998
 999                 pStyleSheet = &(pStylePool->Make( aStyleName, eFamily,
1000                                                   SfxStyleSearchBits::UserDefined ) );
1001
1002                 if (pStyleSheet->HasParentSupport())
1003                     pStyleSheet->SetParent(aRefName);
1004             }
1005             break;
1006
1007         case SID_STYLE_APPLY:
1008         {
1009             const SfxStringItem* pNameItem = rReq.GetArg<SfxStringItem>(SID_APPLY_STYLE);
1010             const SfxStringItem* pFamilyItem = rReq.GetArg<SfxStringItem>(SID_STYLE_FAMILYNAME);
1011             if ( pFamilyItem && pNameItem )
1012             {
1013                 try
1014                 {
1015                     css::uno::Reference< css::container::XNameAccess > xStyles;
1016                     css::uno::Reference< css::container::XNameAccess > xCont = pDocSh->GetModel()->getStyleFamilies();
1017                     xCont->getByName(pFamilyItem->GetValue()) >>= xStyles;
1018                     css::uno::Reference< css::beans::XPropertySet > xInfo;
1019                     xStyles->getByName( pNameItem->GetValue() ) >>= xInfo;
1020                     OUString aUIName;
1021                     xInfo->getPropertyValue(u"DisplayName"_ustr) >>= aUIName;
1022                     if ( !aUIName.isEmpty() )
1023                         rReq.AppendItem( SfxStringItem( SID_STYLE_APPLY, aUIName ) );
1024                 }
1025                 catch( css::uno::Exception& )
1026                 {
1027                 }
1028             }
1029             [[fallthrough]];
1030         }
1031         case SID_STYLE_EDIT:
1032         case SID_STYLE_DELETE:
1033         case SID_STYLE_HIDE:
1034         case SID_STYLE_SHOW:
1035         case SID_STYLE_NEW_BY_EXAMPLE:
1036             {
1037                 const SfxPoolItem* pNameItem;
1038                 if (pArgs && SfxItemState::SET == pArgs->GetItemState(nSlotId, true, &pNameItem))
1039                     aStyleName = static_cast<const SfxStringItem*>(pNameItem)->GetValue();
1040                 else if ( nSlotId == SID_STYLE_NEW_BY_EXAMPLE )
1041                 {
1042                     weld::Window* pDialogParent = rReq.GetFrameWeld();
1043                     if (!pDialogParent)
1044                         pDialogParent = GetFrameWeld();
1045                     SfxNewStyleDlg aDlg(pDialogParent, *pStylePool, eFamily);
1046                     if (aDlg.run() != RET_OK)
1047                         return;
1048                     aStyleName = aDlg.GetName();
1049                 }
1050
1051                 pStyleSheet = pStylePool->Find( aStyleName, eFamily );
1052
1053                 xOldData->InitFromStyle( pStyleSheet );
1054             }
1055             break;
1056
1057         case SID_STYLE_WATERCAN:
1058         {
1059             bool bWaterCan = pScMod->GetIsWaterCan();
1060
1061             if( !bWaterCan )
1062             {
1063                 const SfxPoolItem* pItem;
1064
1065                 if (pArgs && SfxItemState::SET == pArgs->GetItemState(nSlotId, true, &pItem))
1066                 {
1067                     const SfxStringItem* pStrItem = dynamic_cast< const SfxStringItem *>( pItem );
1068                     if ( pStrItem )
1069                     {
1070                         aStyleName  = pStrItem->GetValue();
1071                         pStyleSheet = pStylePool->Find( aStyleName, eFamily );
1072
1073                         if ( pStyleSheet )
1074                         {
1075                             static_cast<ScStyleSheetPool*>(pStylePool)->
1076                                     SetActualStyleSheet( pStyleSheet );
1077                             rReq.Done();
1078                         }
1079                     }
1080                 }
1081             }
1082
1083             if ( !bWaterCan && pStyleSheet )
1084             {
1085                 pScMod->SetWaterCan( true );
1086                 SetActivePointer( PointerStyle::Fill );
1087                 rReq.Done();
1088             }
1089             else
1090             {
1091                 pScMod->SetWaterCan( false );
1092                 SetActivePointer( PointerStyle::Arrow );
1093                 rReq.Done();
1094             }
1095         }
1096         break;
1097
1098         default:
1099             break;
1100     }
1101
1102     // set new style for paintbrush format mode
1103     if ( nSlotId == SID_STYLE_APPLY && pScMod->GetIsWaterCan() && pStyleSheet )
1104         static_cast<ScStyleSheetPool*>(pStylePool)->SetActualStyleSheet( pStyleSheet );
1105
1106     switch ( eFamily )
1107     {
1108         case SfxStyleFamily::Para:
1109         {
1110             switch ( nSlotId )
1111             {
1112                 case SID_STYLE_DELETE:
1113                 {
1114                     if ( pStyleSheet )
1115                     {
1116                         RemoveStyleSheetInUse( pStyleSheet );
1117                         pStylePool->Remove( pStyleSheet );
1118                         InvalidateAttribs();
1119                         nRetMask = sal_uInt16(true);
1120                         bAddUndo = true;
1121                         rReq.Done();
1122                     }
1123                     else
1124                         nRetMask = sal_uInt16(false);
1125                 }
1126                 break;
1127
1128                 case SID_STYLE_HIDE:
1129                 case SID_STYLE_SHOW:
1130                 {
1131                     if ( pStyleSheet )
1132                     {
1133                         pStyleSheet->SetHidden( nSlotId == SID_STYLE_HIDE );
1134                         InvalidateAttribs();
1135                         rReq.Done();
1136                     }
1137                     else
1138                         nRetMask = sal_uInt16(false);
1139                 }
1140                 break;
1141
1142                 case SID_STYLE_APPLY:
1143                 {
1144                     if ( pStyleSheet && !pScMod->GetIsWaterCan() )
1145                     {
1146                         // apply style sheet to document
1147                         SetStyleSheetToMarked( static_cast<SfxStyleSheet*>(pStyleSheet) );
1148                         InvalidateAttribs();
1149                         rReq.Done();
1150                     }
1151                 }
1152                 break;
1153
1154                 case SID_STYLE_NEW_BY_EXAMPLE:
1155                 case SID_STYLE_UPDATE_BY_EXAMPLE:
1156                 {
1157                     // create/replace style sheet by attributes
1158                     // at cursor position:
1159
1160                     const ScPatternAttr* pAttrItem = nullptr;
1161
1162                     // The query if marked, was always wrong here,
1163                     // so now no more, and just from the cursor.
1164                     // If attributes are to be removed from the selection, still need to be
1165                     // cautious not to adopt items from templates
1166                     // (GetSelectionPattern also collects items from originals) (# 44748 #)
1167                     SCCOL       nCol = GetViewData().GetCurX();
1168                     SCROW       nRow = GetViewData().GetCurY();
1169                     pAttrItem = rDoc.GetPattern( nCol, nRow, nCurTab );
1170
1171                     SfxItemSet aAttrSet = pAttrItem->GetItemSet();
1172                     aAttrSet.ClearItem( ATTR_MERGE );
1173                     aAttrSet.ClearItem( ATTR_MERGE_FLAG );
1174
1175                     // Do not adopt conditional formatting and validity,
1176                     // because they can not be edited in the template
1177                     aAttrSet.ClearItem( ATTR_VALIDDATA );
1178                     aAttrSet.ClearItem( ATTR_CONDITIONAL );
1179
1180                     if ( SID_STYLE_NEW_BY_EXAMPLE == nSlotId )
1181                     {
1182                         if ( bUndo )
1183                         {
1184                             OUString aUndo = ScResId( STR_UNDO_EDITCELLSTYLE );
1185                             pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo, 0, GetViewShellId() );
1186                             bListAction = true;
1187                         }
1188
1189                         bool bConvertBack = false;
1190                         SfxStyleSheet*  pSheetInUse = const_cast<SfxStyleSheet*>(GetStyleSheetFromMarked());
1191
1192                         // when a new style is present and is used in the selection,
1193                         // then the parent can not be adopted:
1194                         if ( pStyleSheet && pSheetInUse && pStyleSheet == pSheetInUse )
1195                             pSheetInUse = nullptr;
1196
1197                         // if already present, first remove ...
1198                         if ( pStyleSheet )
1199                         {
1200                             // style pointer to names before erase,
1201                             // otherwise cells will get invalid pointer
1202                             //!!! As it happens, a method that does it for a particular style
1203                             rDoc.getCellAttributeHelper().AllStylesToNames();
1204                             bConvertBack = true;
1205                             pStylePool->Remove(pStyleSheet);
1206                         }
1207
1208                         // ...and create new
1209                         pStyleSheet = &pStylePool->Make( aStyleName, eFamily,
1210                                                          SfxStyleSearchBits::UserDefined );
1211
1212                         // when a style is present, then this will become
1213                         // the parent of the new style:
1214                         if ( pSheetInUse && pStyleSheet->HasParentSupport() )
1215                             pStyleSheet->SetParent( pSheetInUse->GetName() );
1216
1217                         if ( bConvertBack )
1218                             // Name to style pointer
1219                             rDoc.getCellAttributeHelper().UpdateAllStyleSheets(rDoc);
1220                         else
1221                             rDoc.getCellAttributeHelper().CellStyleCreated(rDoc, aStyleName);
1222
1223                         // Adopt attribute and use style
1224                         pStyleSheet->GetItemSet().Put( aAttrSet );
1225                         UpdateStyleSheetInUse( pStyleSheet );
1226
1227                         //  call SetStyleSheetToMarked after adding the ScUndoModifyStyle
1228                         //  (pStyleSheet pointer is used!)
1229                         bStyleToMarked = true;
1230                     }
1231                     else // ( nSlotId == SID_STYLE_UPDATE_BY_EXAMPLE )
1232                     {
1233                         pStyleSheet = const_cast<SfxStyleSheet*>(GetStyleSheetFromMarked());
1234
1235                         if ( pStyleSheet )
1236                         {
1237                             xOldData->InitFromStyle( pStyleSheet );
1238
1239                             if ( bUndo )
1240                             {
1241                                 OUString aUndo = ScResId( STR_UNDO_EDITCELLSTYLE );
1242                                 pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo, 0, GetViewShellId() );
1243                                 bListAction = true;
1244                             }
1245
1246                             pStyleSheet->GetItemSet().Put( aAttrSet );
1247                             UpdateStyleSheetInUse( pStyleSheet );
1248
1249                             //  call SetStyleSheetToMarked after adding the ScUndoModifyStyle
1250                             //  (pStyleSheet pointer is used!)
1251                             bStyleToMarked = true;
1252                         }
1253                     }
1254
1255                     xNewData->InitFromStyle( pStyleSheet );
1256                     bAddUndo = true;
1257                     rReq.Done();
1258                 }
1259                 break;
1260
1261                 default:
1262                     break;
1263             }
1264         } // case SfxStyleFamily::Para:
1265         break;
1266
1267         case SfxStyleFamily::Page:
1268         {
1269             switch ( nSlotId )
1270             {
1271                 case SID_STYLE_DELETE:
1272                 {
1273                     nRetMask = sal_uInt16( nullptr != pStyleSheet );
1274                     if ( pStyleSheet )
1275                     {
1276                         if ( rDoc.RemovePageStyleInUse( pStyleSheet->GetName() ) )
1277                         {
1278                             ScPrintFunc( pDocSh, GetPrinter(true), nCurTab ).UpdatePages();
1279                             rBindings.Invalidate( SID_STATUS_PAGESTYLE );
1280                             rBindings.Invalidate( FID_RESET_PRINTZOOM );
1281                         }
1282                         pStylePool->Remove( pStyleSheet );
1283                         rBindings.Invalidate( SID_STYLE_FAMILY4 );
1284                         pDocSh->SetDocumentModified();
1285                         bAddUndo = true;
1286                         rReq.Done();
1287                     }
1288                 }
1289                 break;
1290
1291                 case SID_STYLE_HIDE:
1292                 case SID_STYLE_SHOW:
1293                 {
1294                     nRetMask = sal_uInt16( nullptr != pStyleSheet );
1295                     if ( pStyleSheet )
1296                     {
1297                         pStyleSheet->SetHidden( nSlotId == SID_STYLE_HIDE );
1298                         rBindings.Invalidate( SID_STYLE_FAMILY4 );
1299                         pDocSh->SetDocumentModified();
1300                         rReq.Done();
1301                     }
1302                 }
1303                 break;
1304
1305                 case SID_STYLE_APPLY:
1306                 {
1307                     nRetMask = sal_uInt16( nullptr != pStyleSheet );
1308                     if ( pStyleSheet && !pScMod->GetIsWaterCan() )
1309                     {
1310                         std::unique_ptr<ScUndoApplyPageStyle> pUndoAction;
1311                         SCTAB nTabCount = rDoc.GetTableCount();
1312                         for (const auto& rTab : rMark)
1313                         {
1314                             if (rTab >= nTabCount)
1315                                 break;
1316                             OUString aOldName = rDoc.GetPageStyle( rTab );
1317                             if ( aOldName != aStyleName )
1318                             {
1319                                 rDoc.SetPageStyle( rTab, aStyleName );
1320                                 ScPrintFunc( pDocSh, GetPrinter(true), rTab ).UpdatePages();
1321                                 if( !pUndoAction )
1322                                     pUndoAction.reset(new ScUndoApplyPageStyle( pDocSh, aStyleName ));
1323                                 pUndoAction->AddSheetAction( rTab, aOldName );
1324                             }
1325                         }
1326                         if( pUndoAction )
1327                         {
1328                             pDocSh->GetUndoManager()->AddUndoAction( std::move(pUndoAction) );
1329                             pDocSh->SetDocumentModified();
1330                             rBindings.Invalidate( SID_STYLE_FAMILY4 );
1331                             rBindings.Invalidate( SID_STATUS_PAGESTYLE );
1332                             rBindings.Invalidate( FID_RESET_PRINTZOOM );
1333                         }
1334                         rReq.Done();
1335                     }
1336                 }
1337                 break;
1338
1339                 case SID_STYLE_NEW_BY_EXAMPLE:
1340                 {
1341                     const OUString aStrCurStyle = rDoc.GetPageStyle( nCurTab );
1342
1343                     if ( aStrCurStyle != aStyleName )
1344                     {
1345                         SfxStyleSheetBase*  pCurStyle = pStylePool->Find( aStrCurStyle, eFamily );
1346                         SfxItemSet          aAttrSet  = pCurStyle->GetItemSet();
1347                         SCTAB               nInTab;
1348                         bool                bUsed = rDoc.IsPageStyleInUse( aStyleName, &nInTab );
1349
1350                         // if already present, first remove...
1351                         if ( pStyleSheet )
1352                             pStylePool->Remove( pStyleSheet );
1353
1354                         // ...and create new
1355                         pStyleSheet = &pStylePool->Make( aStyleName, eFamily,
1356                                                          SfxStyleSearchBits::UserDefined );
1357
1358                         // Adopt attribute
1359                         pStyleSheet->GetItemSet().Put( aAttrSet );
1360                         pDocSh->SetDocumentModified();
1361
1362                         // If being used -> Update
1363                         if ( bUsed )
1364                             ScPrintFunc( pDocSh, GetPrinter(true), nInTab ).UpdatePages();
1365
1366                         xNewData->InitFromStyle( pStyleSheet );
1367                         bAddUndo = true;
1368                         rReq.Done();
1369                         nRetMask = sal_uInt16(true);
1370                     }
1371                 }
1372                 break;
1373
1374                 default:
1375                     break;
1376             } // switch ( nSlotId )
1377         } // case SfxStyleFamily::Page:
1378         break;
1379
1380         case SfxStyleFamily::Frame:
1381         {
1382             switch ( nSlotId )
1383             {
1384                 case SID_STYLE_DELETE:
1385                 {
1386                     if ( pStyleSheet )
1387                     {
1388                         pStylePool->Remove( pStyleSheet );
1389                         InvalidateAttribs();
1390                         pDocSh->SetDocumentModified();
1391                         nRetMask = sal_uInt16(true);
1392                         bAddUndo = true;
1393                         rReq.Done();
1394                     }
1395                     else
1396                         nRetMask = sal_uInt16(false);
1397                 }
1398                 break;
1399
1400                 case SID_STYLE_HIDE:
1401                 case SID_STYLE_SHOW:
1402                 {
1403                     if ( pStyleSheet )
1404                     {
1405                         pStyleSheet->SetHidden( nSlotId == SID_STYLE_HIDE );
1406                         InvalidateAttribs();
1407                         rReq.Done();
1408                     }
1409                     else
1410                         nRetMask = sal_uInt16(false);
1411                 }
1412                 break;
1413
1414                 case SID_STYLE_APPLY:
1415                 {
1416                     if ( pStyleSheet && !pScMod->GetIsWaterCan() )
1417                     {
1418                         GetScDrawView()->ScEndTextEdit();
1419                         GetScDrawView()->SetStyleSheet(static_cast<SfxStyleSheet*>(pStyleSheet), false);
1420
1421                         GetScDrawView()->InvalidateAttribs();
1422                         InvalidateAttribs();
1423                         rReq.Done();
1424                     }
1425                 }
1426                 break;
1427
1428                 case SID_STYLE_NEW_BY_EXAMPLE:
1429                 case SID_STYLE_UPDATE_BY_EXAMPLE:
1430                 {
1431                     if (nSlotId == SID_STYLE_NEW_BY_EXAMPLE)
1432                     {
1433                         pStyleSheet = &pStylePool->Make( aStyleName, eFamily, SfxStyleSearchBits::UserDefined );
1434
1435                         // when a style is present, then this will become
1436                         // the parent of the new style:
1437                         if (SfxStyleSheet* pOldStyle = GetDrawView()->GetStyleSheet())
1438                             pStyleSheet->SetParent(pOldStyle->GetName());
1439                     }
1440                     else
1441                     {
1442                         pStyleSheet = GetDrawView()->GetStyleSheet();
1443                         xOldData->InitFromStyle( pStyleSheet );
1444                     }
1445
1446                     if ( bUndo )
1447                     {
1448                         OUString aUndo = ScResId( STR_UNDO_EDITGRAPHICSTYLE );
1449                         pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo, 0, GetViewShellId() );
1450                         bListAction = true;
1451                     }
1452
1453                     SfxItemSet aCoreSet(GetDrawView()->GetModel().GetItemPool());
1454                     GetDrawView()->GetAttributes(aCoreSet, true);
1455
1456                     SfxItemSet* pStyleSet = &pStyleSheet->GetItemSet();
1457                     pStyleSet->Put(aCoreSet);
1458                     static_cast<SfxStyleSheet*>(pStyleSheet)->Broadcast(SfxHint(SfxHintId::DataChanged));
1459
1460                     xNewData->InitFromStyle( pStyleSheet );
1461                     bAddUndo = true;
1462
1463                     //  call SetStyleSheet after adding the ScUndoModifyStyle
1464                     //  (pStyleSheet pointer is used!)
1465                     bStyleToMarked = true;
1466                     rReq.Done();
1467                 }
1468                 break;
1469                 default:
1470                     break;
1471             }
1472         }
1473         break;
1474         default:
1475             break;
1476     } // switch ( eFamily )
1477
1478     // create new or process through Dialog:
1479     if ( nSlotId == SID_STYLE_NEW || nSlotId == SID_STYLE_EDIT )
1480     {
1481         if (pStyleSheet)
1482         {
1483             ExecuteStyleEdit(rReq, pStyleSheet, nRetMask, nSlotId, bAddUndo, bUndo,
1484                     xOldData, xNewData, eFamily, bStyleToMarked, bListAction, pEditObject, aSelection);
1485             return; // skip calling ExecuteStyleEditPost because we invoked an async dialog
1486         }
1487     }
1488
1489     ExecuteStyleEditPost(rReq, pStyleSheet, nSlotId, nRetMask, bAddUndo, bUndo,
1490             eFamily, *xOldData, *xNewData, bStyleToMarked, bListAction, pEditObject, aSelection);
1491 }
1492
1493 void ScTabViewShell::ExecuteStyleEdit(SfxRequest& rReq, SfxStyleSheetBase* pStyleSheet, sal_uInt16 nRetMask,
1494                         sal_uInt16 nSlotId, bool bAddUndo, bool bUndo,
1495                         const std::shared_ptr<ScStyleSaveData>& rOldData,
1496                         const std::shared_ptr<ScStyleSaveData>& rNewData, SfxStyleFamily eFamily,
1497                         bool bStyleToMarked, bool bListAction,
1498                         SdrObject* pEditObject, ESelection aSelection)
1499 {
1500     ScDocShell*     pDocSh      = GetViewData().GetDocShell();
1501     ScDocument&     rDoc        = pDocSh->GetDocument();
1502     SfxStyleFamily  eFam = pStyleSheet->GetFamily();
1503     VclPtr<SfxAbstractTabDialog> pDlg;
1504     bool bPage = false;
1505
1506     // Store old Items from the style
1507     std::shared_ptr<SfxItemSet> xOldSet = std::make_shared<SfxItemSet>(pStyleSheet->GetItemSet());
1508     OUString aOldName = pStyleSheet->GetName();
1509
1510     switch ( eFam )
1511     {
1512         case SfxStyleFamily::Page:
1513             bPage = true;
1514             break;
1515
1516         case SfxStyleFamily::Para:
1517             {
1518                 SfxItemSet& rSet = pStyleSheet->GetItemSet();
1519
1520                 if ( const SfxUInt32Item* pItem = rSet.GetItemIfSet( ATTR_VALUE_FORMAT,
1521                         false ) )
1522                 {
1523                     // Produce and format NumberFormat Value from Value and Language
1524                     sal_uLong nFormat = pItem->GetValue();
1525                     LanguageType eLang =
1526                         rSet.Get(ATTR_LANGUAGE_FORMAT ).GetLanguage();
1527                     sal_uLong nLangFormat = rDoc.GetFormatTable()->
1528                         GetFormatForLanguageIfBuiltIn( nFormat, eLang );
1529                     if ( nLangFormat != nFormat )
1530                     {
1531                         SfxUInt32Item aNewItem( ATTR_VALUE_FORMAT, nLangFormat );
1532                         rSet.Put( aNewItem );
1533                         xOldSet->Put( aNewItem );
1534                         // Also in aOldSet for comparison after the  dialog,
1535                         // Otherwise might miss a language change
1536                     }
1537                 }
1538
1539                 std::unique_ptr<SvxNumberInfoItem> pNumberInfoItem(
1540                     ScTabViewShell::MakeNumberInfoItem(rDoc, GetViewData()));
1541
1542                 pDocSh->PutItem( *pNumberInfoItem );
1543                 bPage = false;
1544
1545                 // Definitely a SvxBoxInfoItem with Table = sal_False in set:
1546                 // (If there is no item, the dialogue will also delete the
1547                 // BORDER_OUTER SvxBoxItem from the Template Set)
1548                 if ( rSet.GetItemState( ATTR_BORDER_INNER, false ) != SfxItemState::SET )
1549                 {
1550                     SvxBoxInfoItem aBoxInfoItem( ATTR_BORDER_INNER );
1551                     aBoxInfoItem.SetTable(false);       // no inner lines
1552                     aBoxInfoItem.SetDist(true);
1553                     aBoxInfoItem.SetMinDist(false);
1554                     rSet.Put( aBoxInfoItem );
1555                 }
1556             }
1557             break;
1558
1559         case SfxStyleFamily::Frame:
1560         default:
1561             break;
1562     }
1563
1564     SetInFormatDialog(true);
1565
1566     SfxItemSet& rStyleSet = pStyleSheet->GetItemSet();
1567     rStyleSet.MergeRange( XATTR_FILL_FIRST, XATTR_FILL_LAST );
1568
1569     ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
1570
1571     weld::Window* pDialogParent = rReq.GetFrameWeld();
1572     if (!pDialogParent)
1573         pDialogParent = GetFrameWeld();
1574
1575     if (eFam == SfxStyleFamily::Frame)
1576         pDlg = pFact->CreateScDrawStyleDlg(pDialogParent, *pStyleSheet, GetDrawView());
1577     else
1578         pDlg = pFact->CreateScStyleDlg(pDialogParent, *pStyleSheet, bPage);
1579
1580     auto xRequest = std::make_shared<SfxRequest>(rReq);
1581     rReq.Ignore(); // the 'old' request is not relevant any more
1582     pDlg->StartExecuteAsync(
1583         [this, pDlg, xRequest=std::move(xRequest), pStyleSheet,
1584             nRetMask, xOldSet=std::move(xOldSet), nSlotId, bAddUndo, bUndo,
1585             xOldData = rOldData, xNewData = rNewData, aOldName, eFamily, bStyleToMarked,
1586             bListAction, pEditObject, aSelection]
1587         (sal_Int32 nResult) mutable -> void
1588         {
1589             SetInFormatDialog(false);
1590             ExecuteStyleEditDialog(pDlg, pStyleSheet, nResult, nRetMask, xOldSet, nSlotId,
1591                     bAddUndo, *xNewData, aOldName);
1592             pDlg->disposeOnce();
1593             ExecuteStyleEditPost(*xRequest, pStyleSheet, nSlotId, nRetMask, bAddUndo, bUndo, eFamily,
1594                     *xOldData, *xNewData, bStyleToMarked, bListAction, pEditObject, aSelection);
1595         }
1596     );
1597 }
1598
1599 void ScTabViewShell::ExecuteStyleEditDialog(VclPtr<SfxAbstractTabDialog> pDlg,
1600                         SfxStyleSheetBase* pStyleSheet, sal_uInt16 nResult,
1601                         sal_uInt16& rnRetMask, std::shared_ptr<SfxItemSet> xOldSet, const sal_uInt16 nSlotId,
1602                         bool& rbAddUndo, ScStyleSaveData& rNewData, std::u16string_view aOldName)
1603 {
1604     ScDocShell*     pDocSh = GetViewData().GetDocShell();
1605     ScDocument&     rDoc = pDocSh->GetDocument();
1606     SfxBindings&    rBindings = GetViewData().GetBindings();
1607     SfxStyleSheetBasePool* pStylePool = rDoc.GetStyleSheetPool();
1608     SfxStyleFamily  eFam = pStyleSheet->GetFamily();
1609     if ( nResult == RET_OK )
1610     {
1611         const SfxItemSet* pOutSet = pDlg->GetOutputItemSet();
1612
1613         if ( pOutSet )
1614         {
1615             rnRetMask = sal_uInt16(pStyleSheet->GetMask());
1616
1617             // Attribute comparisons (earlier in ModifyStyleSheet) now here
1618             // with the old values (the style is already changed)
1619             if ( SfxStyleFamily::Para == eFam )
1620             {
1621                 SfxItemSet& rNewSet = pStyleSheet->GetItemSet();
1622                 bool bNumFormatChanged;
1623                 if ( ScGlobal::CheckWidthInvalidate(
1624                                     bNumFormatChanged, rNewSet, *xOldSet ) )
1625                     rDoc.InvalidateTextWidth( nullptr, nullptr, bNumFormatChanged );
1626
1627                 SCTAB nTabCount = rDoc.GetTableCount();
1628                 for (SCTAB nTab=0; nTab<nTabCount; nTab++)
1629                     rDoc.SetStreamValid(nTab, false);
1630
1631                 sal_uLong nOldFormat = xOldSet->Get( ATTR_VALUE_FORMAT ).GetValue();
1632                 sal_uLong nNewFormat = rNewSet.Get( ATTR_VALUE_FORMAT ).GetValue();
1633                 if ( nNewFormat != nOldFormat )
1634                 {
1635                     ScInterpreterContext& rContext = rDoc.GetNonThreadedContext();
1636                     const SvNumberformat* pOld = rContext.NFGetFormatEntry( nOldFormat );
1637                     const SvNumberformat* pNew = rContext.NFGetFormatEntry( nNewFormat );
1638                     if ( pOld && pNew && pOld->GetLanguage() != pNew->GetLanguage() )
1639                         rNewSet.Put( SvxLanguageItem(
1640                                         pNew->GetLanguage(), ATTR_LANGUAGE_FORMAT ) );
1641                 }
1642
1643                 rDoc.getCellAttributeHelper().CellStyleCreated(rDoc, pStyleSheet->GetName());
1644             }
1645             else if ( SfxStyleFamily::Page == eFam )
1646             {
1647                 //! Here also queries for Page Styles
1648
1649                 OUString aNewName = pStyleSheet->GetName();
1650                 if ( aNewName != aOldName &&
1651                         rDoc.RenamePageStyleInUse( aOldName, aNewName ) )
1652                 {
1653                     rBindings.Invalidate( SID_STATUS_PAGESTYLE );
1654                     rBindings.Invalidate( FID_RESET_PRINTZOOM );
1655                 }
1656
1657                 rDoc.ModifyStyleSheet( *pStyleSheet, *pOutSet );
1658                 rBindings.Invalidate( FID_RESET_PRINTZOOM );
1659             }
1660             else
1661             {
1662                 SfxItemSet& rAttr = pStyleSheet->GetItemSet();
1663                 sdr::properties::CleanupFillProperties(rAttr);
1664
1665                 // check for unique names of named items for xml
1666                 auto checkForUniqueItem = [&] (auto nWhichId)
1667                 {
1668                     if (auto pOldItem = rAttr.GetItemIfSet(nWhichId, false))
1669                     {
1670                         if (auto pNewItem = pOldItem->checkForUniqueItem(GetDrawView()->GetModel()))
1671                             rAttr.Put(std::move(pNewItem));
1672                     }
1673                 };
1674
1675                 checkForUniqueItem(XATTR_FILLBITMAP);
1676                 checkForUniqueItem(XATTR_LINEDASH);
1677                 checkForUniqueItem(XATTR_LINESTART);
1678                 checkForUniqueItem(XATTR_LINEEND);
1679                 checkForUniqueItem(XATTR_FILLGRADIENT);
1680                 checkForUniqueItem(XATTR_FILLFLOATTRANSPARENCE);
1681                 checkForUniqueItem(XATTR_FILLHATCH);
1682
1683                 static_cast<SfxStyleSheet*>(pStyleSheet)->Broadcast(SfxHint(SfxHintId::DataChanged));
1684                 GetScDrawView()->InvalidateAttribs();
1685             }
1686
1687             pDocSh->SetDocumentModified();
1688
1689             if ( SfxStyleFamily::Para == eFam )
1690             {
1691                 ScTabViewShell::UpdateNumberFormatter(
1692                         *( pDocSh->GetItem(SID_ATTR_NUMBERFORMAT_INFO) ));
1693
1694                 UpdateStyleSheetInUse( pStyleSheet );
1695                 InvalidateAttribs();
1696             }
1697
1698             rNewData.InitFromStyle( pStyleSheet );
1699             rbAddUndo = true;
1700         }
1701     }
1702     else
1703     {
1704         if ( nSlotId == SID_STYLE_NEW )
1705             pStylePool->Remove( pStyleSheet );
1706         else
1707         {
1708             // If in the meantime something was painted with the
1709             // temporary changed item set
1710             pDocSh->PostPaintGridAll();
1711         }
1712     }
1713 }
1714
1715 void ScTabViewShell::ExecuteStyleEditPost(SfxRequest& rReq, SfxStyleSheetBase* pStyleSheet,
1716                         sal_uInt16 nSlotId, sal_uInt16 nRetMask, bool bAddUndo, bool bUndo,
1717                         const SfxStyleFamily eFamily,
1718                         ScStyleSaveData& rOldData, ScStyleSaveData& rNewData,
1719                         bool bStyleToMarked, bool bListAction,
1720                         SdrObject* pEditObject, ESelection aSelection)
1721 {
1722     ScDocShell*     pDocSh = GetViewData().GetDocShell();
1723
1724     rReq.SetReturnValue( SfxUInt16Item( nSlotId, nRetMask ) );
1725
1726     if ( bAddUndo && bUndo)
1727         pDocSh->GetUndoManager()->AddUndoAction(
1728                     std::make_unique<ScUndoModifyStyle>( pDocSh, eFamily, rOldData, rNewData ) );
1729
1730     if ( bStyleToMarked )
1731     {
1732         //  call SetStyleSheetToMarked after adding the ScUndoModifyStyle,
1733         //  so redo will find the modified style
1734         if (eFamily == SfxStyleFamily::Para)
1735         {
1736             SetStyleSheetToMarked( static_cast<SfxStyleSheet*>(pStyleSheet) );
1737         }
1738         else if (eFamily == SfxStyleFamily::Frame)
1739         {
1740             GetScDrawView()->ScEndTextEdit();
1741             GetScDrawView()->SetStyleSheet( static_cast<SfxStyleSheet*>(pStyleSheet), false );
1742         }
1743         InvalidateAttribs();
1744     }
1745
1746     if ( bListAction )
1747         pDocSh->GetUndoManager()->LeaveListAction();
1748
1749     // The above call to ScEndTextEdit left us in an inconsistent state:
1750     // Text editing isn't active, but the text edit shell still is. And we
1751     // couldn't just deactivate it fully, because in case of editing a
1752     // comment, that will make the comment disappear. So let's try to
1753     // reactivate text editing instead:
1754     auto pFuText = dynamic_cast<FuText*>(GetDrawFuncPtr());
1755     if (pFuText && pEditObject != GetDrawView()->GetTextEditObject())
1756     {
1757         pFuText->SetInEditMode(pEditObject);
1758         if (GetDrawView()->GetTextEditOutlinerView())
1759             GetDrawView()->GetTextEditOutlinerView()->SetSelection(aSelection);
1760     }
1761 }
1762
1763 void ScTabViewShell::GetStyleState( SfxItemSet& rSet )
1764 {
1765     ScDocument&             rDoc          = GetViewData().GetDocument();
1766     SfxStyleSheetBasePool*  pStylePool    = rDoc.GetStyleSheetPool();
1767
1768     bool bProtected = false;
1769     SCTAB nTabCount = rDoc.GetTableCount();
1770     for (SCTAB i=0; i<nTabCount && !bProtected; i++)
1771         if (rDoc.IsTabProtected(i))                // look after protected table
1772             bProtected = true;
1773
1774     SfxWhichIter    aIter(rSet);
1775     sal_uInt16          nWhich = aIter.FirstWhich();
1776     sal_uInt16          nSlotId = 0;
1777
1778     while ( nWhich )
1779     {
1780         nSlotId = SfxItemPool::IsWhich( nWhich )
1781                     ? GetPool().GetSlotId( nWhich )
1782                     : nWhich;
1783
1784         switch ( nSlotId )
1785         {
1786             case SID_STYLE_APPLY:
1787                 if ( !pStylePool )
1788                     rSet.DisableItem( nSlotId );
1789                 break;
1790
1791             case SID_STYLE_FAMILY2:     // cell style sheets
1792             {
1793                 SfxStyleSheet* pStyleSheet = const_cast<SfxStyleSheet*>(GetStyleSheetFromMarked());
1794
1795                 if ( pStyleSheet )
1796                     rSet.Put( SfxTemplateItem( nSlotId, pStyleSheet->GetName() ) );
1797                 else
1798                     rSet.Put( SfxTemplateItem( nSlotId, OUString() ) );
1799             }
1800             break;
1801
1802             case SID_STYLE_FAMILY3:     // drawing style sheets
1803             {
1804                 SfxStyleSheet* pStyleSheet = GetDrawView()->GetStyleSheet();
1805
1806                 if ( pStyleSheet )
1807                     rSet.Put( SfxTemplateItem( nSlotId, pStyleSheet->GetName() ) );
1808                 else
1809                     rSet.Put( SfxTemplateItem( nSlotId, OUString() ) );
1810             }
1811             break;
1812
1813             case SID_STYLE_FAMILY4:     // page style sheets
1814             {
1815                 SCTAB           nCurTab     = GetViewData().GetTabNo();
1816                 OUString        aPageStyle  = rDoc.GetPageStyle( nCurTab );
1817                 SfxStyleSheet*  pStyleSheet = pStylePool ? static_cast<SfxStyleSheet*>(pStylePool->
1818                                     Find( aPageStyle, SfxStyleFamily::Page )) : nullptr;
1819
1820                 if ( pStyleSheet )
1821                     rSet.Put( SfxTemplateItem( nSlotId, aPageStyle ) );
1822                 else
1823                     rSet.Put( SfxTemplateItem( nSlotId, OUString() ) );
1824             }
1825             break;
1826
1827             case SID_STYLE_WATERCAN:
1828             {
1829                 rSet.Put(SfxBoolItem(nSlotId, ScModule::get()->GetIsWaterCan()));
1830             }
1831             break;
1832
1833             case SID_STYLE_UPDATE_BY_EXAMPLE:
1834             {
1835                 std::unique_ptr<SfxUInt16Item> pFamilyItem;
1836                 GetViewFrame().GetBindings().QueryState(SID_STYLE_FAMILY, pFamilyItem);
1837
1838                 bool bPage = pFamilyItem && SfxStyleFamily::Page == static_cast<SfxStyleFamily>(pFamilyItem->GetValue());
1839
1840                 if ( bProtected || bPage )
1841                     rSet.DisableItem( nSlotId );
1842             }
1843             break;
1844
1845             case SID_STYLE_EDIT:
1846             case SID_STYLE_DELETE:
1847             case SID_STYLE_HIDE:
1848             case SID_STYLE_SHOW:
1849             {
1850                 std::unique_ptr<SfxUInt16Item> pFamilyItem;
1851                 GetViewFrame().GetBindings().QueryState(SID_STYLE_FAMILY, pFamilyItem);
1852                 bool bPage = pFamilyItem && SfxStyleFamily::Page == static_cast<SfxStyleFamily>(pFamilyItem->GetValue());
1853
1854                 if ( bProtected && !bPage )
1855                     rSet.DisableItem( nSlotId );
1856             }
1857             break;
1858
1859             default:
1860                 break;
1861         }
1862
1863         nWhich = aIter.NextWhich();
1864     }
1865 }
1866
1867 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */