sc/source/ui/docshell/docsh4.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 <config_features.h>
  21
  22 #include <com/sun/star/embed/XEmbeddedObject.hpp>
  23 #include <com/sun/star/frame/Desktop.hpp>
  24 #include <com/sun/star/frame/XComponentLoader.hpp>
  25
  26 using namespace ::com::sun::star;
  27
  28 #include <math.h>
  29
  30 #include "scitems.hxx"
  31 #include <editeng/flstitem.hxx>
  32 #include <sfx2/fcontnr.hxx>
  33 #include <sfx2/linkmgr.hxx>
  34 #include <sfx2/objface.hxx>
  35 #include <sfx2/docfile.hxx>
  36 #include <svtools/ehdl.hxx>
  37 #include <basic/sbxcore.hxx>
  38 #include <svtools/sfxecode.hxx>
  39 #include <svx/ofaitem.hxx>
  40 #include <svl/whiter.hxx>
  41 #include <vcl/msgbox.hxx>
  42 #include <vcl/waitobj.hxx>
  43 #include <svx/dataaccessdescriptor.hxx>
  44 #include <svx/drawitem.hxx>
  45 #include <svx/fmshell.hxx>
  46 #include <svtools/xwindowitem.hxx>
  47 #include <svx/svdoole2.hxx>
  48 #include <sfx2/passwd.hxx>
  49 #include <sfx2/filedlghelper.hxx>
  50 #include <sfx2/dispatch.hxx>
  51 #include <svl/PasswordHelper.hxx>
  52 #include <svl/documentlockfile.hxx>
  53 #include <svl/sharecontrolfile.hxx>
  54 #include <unotools/securityoptions.hxx>
  55
  56 #include <comphelper/processfactory.hxx>
  57 #include "docuno.hxx"
  58
  59 #include <com/sun/star/sdbc/XResultSet.hpp>
  60 #include "docsh.hxx"
  61 #include "docshimp.hxx"
  62 #include "docfunc.hxx"
  63 #include "sc.hrc"
  64 #include "stlsheet.hxx"
  65 #include "stlpool.hxx"
  66 #include "appoptio.hxx"
  67 #include "globstr.hrc"
  68 #include "global.hxx"
  69 #include "dbdocfun.hxx"
  70 #include "printfun.hxx"
  71 #include "viewdata.hxx"
  72 #include "tabvwsh.hxx"
  73 #include "impex.hxx"
  74 #include "attrib.hxx"
  75 #include "undodat.hxx"
  76 #include "autostyl.hxx"
  77 #include "undocell.hxx"
  78 #include "undotab.hxx"
  79 #include "inputhdl.hxx"
  80 #include "dbdata.hxx"
  81 #include "servobj.hxx"
  82 #include "rangenam.hxx"
  83 #include "scmod.hxx"
  84 #include "chgviset.hxx"
  85 #include "reffact.hxx"
  86 #include "chartlis.hxx"
  87 #include "chartpos.hxx"
  88 #include "waitoff.hxx"
  89 #include "tablink.hxx"
  90 #include "drwlayer.hxx"
  91 #include "docoptio.hxx"
  92 #include "undostyl.hxx"
  93 #include "rangeseq.hxx"
  94 #include "chgtrack.hxx"
  95 #include "printopt.hxx"
  96 #include <com/sun/star/document/UpdateDocMode.hpp>
  97 #include "scresid.hxx"
  98 #include "scabstdlg.hxx"
  99 #include "externalrefmgr.hxx"
 100 #include "sharedocdlg.hxx"
 101 #include "conditio.hxx"
 102 #include "sheetevents.hxx"
 103 #include "formulacell.hxx"
 104 #include <documentlinkmgr.hxx>
 105 #include <memory>
 106 #include <sfx2/notebookbar/SfxNotebookBar.hxx>
 107
 108 void ScDocShell::Execute( SfxRequest& rReq )
 109 {
 110     //  SID_SC_RANGE (Range),
 111     //  SID_SC_CELLTEXT (CellText),
 112     //  SID_SC_CELLS (Cells) - removed (old Basic)
 113
 114     const SfxItemSet* pReqArgs = rReq.GetArgs();
 115     SfxBindings* pBindings = GetViewBindings();
 116     bool bUndo (aDocument.IsUndoEnabled());
 117
 118     sal_uInt16 nSlot = rReq.GetSlot();
 119     switch ( nSlot )
 120     {
 121         case SID_SC_SETTEXT:
 122         {
 123             const SfxPoolItem* pColItem;
 124             const SfxPoolItem* pRowItem;
 125             const SfxPoolItem* pTabItem;
 126             const SfxPoolItem* pTextItem;
 127             if( pReqArgs && pReqArgs->HasItem( FN_PARAM_1, &pColItem ) &&
 128                             pReqArgs->HasItem( FN_PARAM_2, &pRowItem ) &&
 129                             pReqArgs->HasItem( FN_PARAM_3, &pTabItem ) &&
 130                             pReqArgs->HasItem( SID_SC_SETTEXT, &pTextItem ) )
 131             {
 132                 //  Parameter sind 1-based !!!
 133                 SCCOL nCol = static_cast<const SfxInt16Item*>(pColItem)->GetValue() - 1;
 134                 SCROW nRow = static_cast<const SfxInt32Item*>(pRowItem)->GetValue() - 1;
 135                 SCTAB nTab = static_cast<const SfxInt16Item*>(pTabItem)->GetValue() - 1;
 136
 137                 SCTAB nTabCount = aDocument.GetTableCount();
 138                 if ( ValidCol(nCol) && ValidRow(nRow) && ValidTab(nTab,nTabCount) )
 139                 {
 140                     if ( aDocument.IsBlockEditable( nTab, nCol,nRow, nCol, nRow ) )
 141                     {
 142                         OUString aVal = static_cast<const SfxStringItem*>(pTextItem)->GetValue();
 143                         aDocument.SetString( nCol, nRow, nTab, aVal );
 144
 145                         PostPaintCell( nCol, nRow, nTab );
 146                         SetDocumentModified();
 147
 148                         rReq.Done();
 149                         break;
 150                     }
 151                     else                // geschuetzte Zelle
 152                     {
 153 #if HAVE_FEATURE_SCRIPTING
 154                         SbxBase::SetError( ERRCODE_SBX_BAD_PARAMETER );      //! welchen Fehler ?
 155 #endif
 156                         break;
 157                     }
 158                 }
 159             }
 160 #if HAVE_FEATURE_SCRIPTING
 161             SbxBase::SetError( ERRCODE_SBX_NO_OBJECT );
 162 #endif
 163         }
 164         break;
 165
 166         case SID_SBA_IMPORT:
 167         {
 168             if (pReqArgs)
 169             {
 170                 const SfxPoolItem* pItem;
 171                 svx::ODataAccessDescriptor aDesc;
 172                 if ( pReqArgs->GetItemState( nSlot, true, &pItem ) == SfxItemState::SET )
 173                 {
 174                     uno::Any aAny = static_cast<const SfxUsrAnyItem*>(pItem)->GetValue();
 175                     uno::Sequence<beans::PropertyValue> aProperties;
 176                     if ( aAny >>= aProperties )
 177                         aDesc.initializeFrom( aProperties );
 178                 }
 179
 180                 OUString sTarget;
 181                 if ( pReqArgs->GetItemState( FN_PARAM_1, true, &pItem ) == SfxItemState::SET )
 182                     sTarget = static_cast<const SfxStringItem*>(pItem)->GetValue();
 183
 184                 bool bIsNewArea = true;         // Default sal_True (keine Nachfrage)
 185                 if ( pReqArgs->GetItemState( FN_PARAM_2, true, &pItem ) == SfxItemState::SET )
 186                     bIsNewArea = static_cast<const SfxBoolItem*>(pItem)->GetValue();
 187
 188                 // bei Bedarf neuen Datenbankbereich anlegen
 189                 bool bMakeArea = false;
 190                 if (bIsNewArea)
 191                 {
 192                     ScDBCollection* pDBColl = aDocument.GetDBCollection();
 193                     if ( !pDBColl || !pDBColl->getNamedDBs().findByUpperName(ScGlobal::pCharClass->uppercase(sTarget)) )
 194                     {
 195                         ScAddress aPos;
 196                         if ( aPos.Parse( sTarget, &aDocument, aDocument.GetAddressConvention() ) & ScRefFlags::VALID )
 197                         {
 198                             bMakeArea = true;
 199                             if (bUndo)
 200                             {
 201                                 OUString aStrImport = ScGlobal::GetRscString( STR_UNDO_IMPORTDATA );
 202                                 GetUndoManager()->EnterListAction( aStrImport, aStrImport );
 203                             }
 204
 205                             ScDBData* pDBData = GetDBData( ScRange(aPos), SC_DB_IMPORT, SC_DBSEL_KEEP );
 206                             OSL_ENSURE(pDBData, "kann DB-Daten nicht anlegen");
 207                             sTarget = pDBData->GetName();
 208                         }
 209                     }
 210                 }
 211
 212                 // nachfragen, bevor alter DB-Bereich ueberschrieben wird
 213                 bool bDo = true;
 214                 if (!bIsNewArea)
 215                 {
 216                     OUString aTemplate = ScGlobal::GetRscString( STR_IMPORT_REPLACE );
 217                     OUString aMessage = aTemplate.getToken( 0, '#' );
 218                     aMessage += sTarget;
 219                     aMessage += aTemplate.getToken( 1, '#' );
 220
 221                     ScopedVclPtrInstance< QueryBox > aBox( nullptr, WinBits(WB_YES_NO | WB_DEF_YES), aMessage );
 222                     bDo = ( aBox->Execute() == RET_YES );
 223                 }
 224
 225                 if (bDo)
 226                 {
 227                     ScDBDocFunc(*this).UpdateImport( sTarget, aDesc );
 228                     rReq.Done();
 229
 230                     //  UpdateImport aktualisiert auch die internen Operationen
 231                 }
 232                 else
 233                     rReq.Ignore();
 234
 235                 if ( bMakeArea && bUndo)
 236                     GetUndoManager()->LeaveListAction();
 237             }
 238             else
 239             {
 240                 OSL_FAIL( "arguments expected" );
 241             }
 242         }
 243         break;
 244
 245         case SID_CHART_SOURCE:
 246         case SID_CHART_ADDSOURCE:
 247             if (pReqArgs)
 248             {
 249                 ScDocument& rDoc = GetDocument();
 250                 const   SfxPoolItem* pItem;
 251                 OUString  aChartName, aRangeName;
 252
 253                 ScRange         aSingleRange;
 254                 ScRangeListRef  aRangeListRef;
 255                 bool            bMultiRange = false;
 256
 257                 bool bColHeaders = true;
 258                 bool bRowHeaders = true;
 259                 bool bColInit = false;
 260                 bool bRowInit = false;
 261                 bool bAddRange = (nSlot == SID_CHART_ADDSOURCE);
 262
 263                 if( pReqArgs->HasItem( SID_CHART_NAME, &pItem ) )
 264                     aChartName = static_cast<const SfxStringItem*>(pItem)->GetValue();
 265
 266                 if( pReqArgs->HasItem( SID_CHART_SOURCE, &pItem ) )
 267                     aRangeName = static_cast<const SfxStringItem*>(pItem)->GetValue();
 268
 269                 if( pReqArgs->HasItem( FN_PARAM_1, &pItem ) )
 270                 {
 271                     bColHeaders = static_cast<const SfxBoolItem*>(pItem)->GetValue();
 272                     bColInit = true;
 273                 }
 274                 if( pReqArgs->HasItem( FN_PARAM_2, &pItem ) )
 275                 {
 276                     bRowHeaders = static_cast<const SfxBoolItem*>(pItem)->GetValue();
 277                     bRowInit = true;
 278                 }
 279
 280                 ScAddress::Details aDetails(rDoc.GetAddressConvention(), 0, 0);
 281                 bool bValid = (aSingleRange.ParseAny(aRangeName, &rDoc, aDetails) & ScRefFlags::VALID) == ScRefFlags::ZERO;
 282                 if (!bValid)
 283                 {
 284                     aRangeListRef = new ScRangeList;
 285                     aRangeListRef->Parse( aRangeName, &rDoc );
 286                     if ( !aRangeListRef->empty() )
 287                     {
 288                         bMultiRange = true;
 289                         aSingleRange = *aRangeListRef->front(); // fuer Header
 290                         bValid = true;
 291                     }
 292                     else
 293                         aRangeListRef.Clear();
 294                 }
 295
 296                 ScTabViewShell* pViewSh = ScTabViewShell::GetActiveViewShell();
 297                 if (pViewSh && bValid && !aChartName.isEmpty() )
 298                 {
 299                     vcl::Window* pParent = pViewSh->GetDialogParent();
 300
 301                     SCCOL nCol1 = aSingleRange.aStart.Col();
 302                     SCROW nRow1 = aSingleRange.aStart.Row();
 303                     SCCOL nCol2 = aSingleRange.aEnd.Col();
 304                     SCROW nRow2 = aSingleRange.aEnd.Row();
 305                     SCTAB nTab = aSingleRange.aStart.Tab();
 306
 307                     //! immer oder gar nicht begrenzen ???
 308                     if (!bMultiRange)
 309                         aDocument.LimitChartArea( nTab, nCol1,nRow1, nCol2,nRow2 );
 310
 311                                         // Dialog fuer Spalten/Zeilenkoepfe
 312                     bool bOk = true;
 313                     if ( !bAddRange && ( !bColInit || !bRowInit ) )
 314                     {
 315                         ScChartPositioner aChartPositioner( &aDocument, nTab, nCol1,nRow1, nCol2,nRow2 );
 316                         if (!bColInit)
 317                             bColHeaders = aChartPositioner.HasColHeaders();
 318                         if (!bRowInit)
 319                             bRowHeaders = aChartPositioner.HasRowHeaders();
 320
 321                         ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
 322                         OSL_ENSURE(pFact, "ScAbstractFactory create fail!");
 323
 324                         std::unique_ptr<AbstractScColRowLabelDlg> pDlg(pFact->CreateScColRowLabelDlg(pParent, bRowHeaders, bColHeaders));
 325                         OSL_ENSURE(pDlg, "Dialog create fail!");
 326                         if ( pDlg->Execute() == RET_OK )
 327                         {
 328                             bColHeaders = pDlg->IsRow();
 329                             bRowHeaders = pDlg->IsCol();
 330
 331                             rReq.AppendItem(SfxBoolItem(FN_PARAM_1, bColHeaders));
 332                             rReq.AppendItem(SfxBoolItem(FN_PARAM_2, bRowHeaders));
 333                         }
 334                         else
 335                             bOk = false;
 336                     }
 337
 338                     if (bOk)            // ausfuehren
 339                     {
 340                         if (bMultiRange)
 341                         {
 342                             if (bUndo)
 343                             {
 344                                 GetUndoManager()->AddUndoAction(
 345                                     new ScUndoChartData( this, aChartName, aRangeListRef,
 346                                                             bColHeaders, bRowHeaders, bAddRange ) );
 347                             }
 348                             aDocument.UpdateChartArea( aChartName, aRangeListRef,
 349                                                         bColHeaders, bRowHeaders, bAddRange );
 350                         }
 351                         else
 352                         {
 353                             ScRange aNewRange( nCol1,nRow1,nTab, nCol2,nRow2,nTab );
 354                             if (bUndo)
 355                             {
 356                                 GetUndoManager()->AddUndoAction(
 357                                     new ScUndoChartData( this, aChartName, aNewRange,
 358                                                             bColHeaders, bRowHeaders, bAddRange ) );
 359                             }
 360                             aDocument.UpdateChartArea( aChartName, aNewRange,
 361                                                         bColHeaders, bRowHeaders, bAddRange );
 362                         }
 363                     }
 364                 }
 365                 else
 366                 {
 367                     OSL_FAIL("UpdateChartArea: keine ViewShell oder falsche Daten");
 368                 }
 369                 rReq.Done();
 370             }
 371             else
 372             {
 373                 OSL_FAIL("SID_CHART_SOURCE ohne Argumente");
 374             }
 375             break;
 376
 377         case FID_AUTO_CALC:
 378             {
 379                 bool bNewVal;
 380                 const SfxPoolItem* pItem;
 381                 if ( pReqArgs && SfxItemState::SET == pReqArgs->GetItemState( nSlot, true, &pItem ) )
 382                     bNewVal = static_cast<const SfxBoolItem*>(pItem)->GetValue();
 383                 else
 384                     bNewVal = !aDocument.GetAutoCalc();     // Toggle fuer Menue
 385                 aDocument.SetAutoCalc( bNewVal );
 386                 SetDocumentModified();
 387                 if (pBindings)
 388                 {
 389                     pBindings->Invalidate( FID_AUTO_CALC );
 390                 }
 391                 rReq.AppendItem( SfxBoolItem( FID_AUTO_CALC, bNewVal ) );
 392                 rReq.Done();
 393             }
 394             break;
 395         case FID_RECALC:
 396             DoRecalc( rReq.IsAPI() );
 397             rReq.Done();
 398             break;
 399         case FID_HARD_RECALC:
 400             DoHardRecalc( rReq.IsAPI() );
 401             rReq.Done();
 402             break;
 403         case SID_UPDATETABLINKS:
 404             {
 405                 comphelper::EmbeddedObjectContainer& rEmbeddedObjectContainer = getEmbeddedObjectContainer();
 406                 rEmbeddedObjectContainer.setUserAllowsLinkUpdate(true);
 407
 408                 ScDocument& rDoc = GetDocument();
 409
 410                 ScLkUpdMode nSet = rDoc.GetLinkMode();
 411
 412                 sal_uInt16 nDlgRet=RET_NO;
 413                 if(nSet==LM_UNKNOWN)
 414                 {
 415                     ScAppOptions aAppOptions=SC_MOD()->GetAppOptions();
 416                     nSet=aAppOptions.GetLinkMode();
 417                 }
 418
 419                 if (nCanUpdate == css::document::UpdateDocMode::NO_UPDATE)
 420                     nSet = LM_NEVER;
 421                 else if (nCanUpdate == css::document::UpdateDocMode::FULL_UPDATE)
 422                     nSet = LM_ALWAYS;
 423
 424                 if (nSet == LM_ALWAYS
 425                     && !(SvtSecurityOptions()
 426                          .isTrustedLocationUriForUpdatingLinks(
 427                              GetMedium() == nullptr
 428                              ? OUString() : GetMedium()->GetName())))
 429                 {
 430                     nSet = LM_ON_DEMAND;
 431                 }
 432                 if (nCanUpdate == css::document::UpdateDocMode::QUIET_UPDATE
 433                     && nSet == LM_ON_DEMAND)
 434                 {
 435                     nSet = LM_NEVER;
 436                 }
 437
 438                 if(nSet==LM_ON_DEMAND)
 439                 {
 440                     ScopedVclPtrInstance<QueryBox> aBox( GetActiveDialogParent(), WinBits(WB_YES_NO | WB_DEF_YES),
 441                                              ScGlobal::GetRscString(STR_RELOAD_TABLES) );
 442
 443                     nDlgRet=aBox->Execute();
 444                 }
 445
 446                 if (nDlgRet == RET_YES || nSet==LM_ALWAYS)
 447                 {
 448                     ReloadTabLinks();
 449                     aDocument.UpdateExternalRefLinks(GetActiveDialogParent());
 450
 451                     bool bAnyDde = aDocument.GetDocLinkManager().updateDdeOrOleLinks(GetActiveDialogParent());
 452
 453                     if (bAnyDde)
 454                     {
 455                         //  Formeln berechnen und painten wie im TrackTimeHdl
 456                         aDocument.TrackFormulas();
 457                         Broadcast(SfxSimpleHint(FID_DATACHANGED));
 458
 459                         //  wenn FID_DATACHANGED irgendwann mal asynchron werden sollte
 460                         //  (z.B. mit Invalidate am Window), muss hier ein Update erzwungen werden.
 461                     }
 462
 463                     aDocument.UpdateAreaLinks();
 464
 465                     //! Test, ob Fehler
 466                     rReq.Done();
 467                 }
 468                 else
 469                 {
 470                     rEmbeddedObjectContainer.setUserAllowsLinkUpdate(false);
 471                     rReq.Ignore();
 472                 }
 473             }
 474             break;
 475
 476         case SID_REIMPORT_AFTER_LOAD:
 477             {
 478                 //  wird nach dem Laden aufgerufen, wenn DB-Bereiche mit
 479                 //  weggelassenen Daten enthalten sind
 480
 481                 bool bDone = false;
 482                 ScDBCollection* pDBColl = aDocument.GetDBCollection();
 483
 484                 if ((nCanUpdate != css::document::UpdateDocMode::NO_UPDATE) &&
 485                    (nCanUpdate != css::document::UpdateDocMode::QUIET_UPDATE))
 486                 {
 487                     ScRange aRange;
 488                     ScTabViewShell* pViewSh = GetBestViewShell();
 489                     OSL_ENSURE(pViewSh,"SID_REIMPORT_AFTER_LOAD: keine View");
 490                     if (pViewSh && pDBColl)
 491                     {
 492                         ScopedVclPtrInstance<QueryBox> aBox( GetActiveDialogParent(), WinBits(WB_YES_NO | WB_DEF_YES),
 493                                                 ScGlobal::GetRscString(STR_REIMPORT_AFTER_LOAD) );
 494                         if (aBox->Execute() == RET_YES)
 495                         {
 496                             ScDBCollection::NamedDBs& rDBs = pDBColl->getNamedDBs();
 497                             ScDBCollection::NamedDBs::iterator itr = rDBs.begin(), itrEnd = rDBs.end();
 498                             for (; itr != itrEnd; ++itr)
 499                             {
 500                                 ScDBData& rDBData = **itr;
 501                                 if ( rDBData.IsStripData() &&
 502                                      rDBData.HasImportParam() && !rDBData.HasImportSelection() )
 503                                 {
 504                                     rDBData.GetArea(aRange);
 505                                     pViewSh->MarkRange(aRange);
 506
 507                                     //  Import und interne Operationen wie SID_REFRESH_DBAREA
 508                                     //  (Abfrage auf Import hier nicht noetig)
 509
 510                                     ScImportParam aImportParam;
 511                                     rDBData.GetImportParam( aImportParam );
 512                                     bool bContinue = pViewSh->ImportData( aImportParam );
 513                                     rDBData.SetImportParam( aImportParam );
 514
 515                                     //  markieren (Groesse kann sich geaendert haben)
 516                                     rDBData.GetArea(aRange);
 517                                     pViewSh->MarkRange(aRange);
 518
 519                                     if ( bContinue )    // Fehler beim Import -> Abbruch
 520                                     {
 521                                         //  interne Operationen, wenn welche gespeichert
 522
 523                                         if ( rDBData.HasQueryParam() || rDBData.HasSortParam() ||
 524                                              rDBData.HasSubTotalParam() )
 525                                             pViewSh->RepeatDB();
 526
 527                                         //  Pivottabellen die den Bereich als Quelldaten haben
 528
 529                                         RefreshPivotTables(aRange);
 530                                     }
 531                                 }
 532                             }
 533                             bDone = true;
 534                         }
 535                     }
 536                 }
 537
 538                 if ( !bDone && pDBColl )
 539                 {
 540                     //  wenn nicht, dann aber die abhaengigen Formeln updaten
 541                     //! auch fuer einzelne Bereiche, die nicht aktualisiert werden koennen
 542
 543                     aDocument.CalcAll();        //! nur die abhaengigen
 544                     PostDataChanged();
 545                 }
 546
 547                 if (bDone)
 548                     rReq.Done();
 549                 else
 550                     rReq.Ignore();
 551             }
 552             break;
 553
 554         case SID_AUTO_STYLE:
 555             OSL_FAIL("use ScAutoStyleHint instead of SID_AUTO_STYLE");
 556             break;
 557
 558         case SID_GET_COLORLIST:
 559             {
 560                 const SvxColorListItem* pColItem = static_cast<const SvxColorListItem*>(GetItem(SID_COLOR_TABLE));
 561                 XColorListRef pList = pColItem->GetColorList();
 562                 rReq.SetReturnValue(OfaRefItem<XColorList>(SID_GET_COLORLIST, pList));
 563             }
 564             break;
 565
 566         case FID_CHG_RECORD:
 567             {
 568                 ScDocument& rDoc = GetDocument();
 569                 // get argument (recorded macro)
 570                 const SfxBoolItem* pItem = rReq.GetArg<SfxBoolItem>(FID_CHG_RECORD);
 571                 bool bDo = true;
 572
 573                 // xmlsec05/06:
 574                 // getting real parent window when called from Security-Options TP
 575                 vcl::Window* pParent = nullptr;
 576                 const SfxPoolItem* pParentItem;
 577                 if( pReqArgs && SfxItemState::SET == pReqArgs->GetItemState( SID_ATTR_XWINDOW, false, &pParentItem ) )
 578                     pParent = static_cast<const XWindowItem*>( pParentItem )->GetWindowPtr();
 579
 580                 // desired state
 581                 ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
 582                 bool bActivateTracking = (pChangeTrack == nullptr);   // toggle
 583                 if ( pItem )
 584                     bActivateTracking = pItem->GetValue();      // from argument
 585
 586                 if ( !bActivateTracking )
 587                 {
 588                     if ( !pItem )
 589                     {
 590                         // no dialog on playing the macro
 591                         ScopedVclPtrInstance<WarningBox> aBox( pParent ? pParent : GetActiveDialogParent(),
 592                             WinBits(WB_YES_NO | WB_DEF_NO),
 593                             ScGlobal::GetRscString( STR_END_REDLINING ) );
 594                         bDo = ( aBox->Execute() == RET_YES );
 595                     }
 596
 597                     if ( bDo )
 598                     {
 599                         if (pChangeTrack)
 600                         {
 601                             if ( pChangeTrack->IsProtected() )
 602                                 bDo = ExecuteChangeProtectionDialog( nullptr );
 603                         }
 604                         if ( bDo )
 605                         {
 606                             rDoc.EndChangeTracking();
 607                             PostPaintGridAll();
 608                         }
 609                     }
 610                 }
 611                 else
 612                 {
 613                     rDoc.StartChangeTracking();
 614                     ScChangeViewSettings aChangeViewSet;
 615                     aChangeViewSet.SetShowChanges(true);
 616                     rDoc.SetChangeViewSettings(aChangeViewSet);
 617                 }
 618
 619                 if ( bDo )
 620                 {
 621                     UpdateAcceptChangesDialog();
 622
 623                     // Slots invalidieren
 624                     if (pBindings)
 625                         pBindings->InvalidateAll(false);
 626                     if ( !pItem )
 627                         rReq.AppendItem( SfxBoolItem( FID_CHG_RECORD, bActivateTracking ) );
 628                     rReq.Done();
 629                 }
 630                 else
 631                     rReq.Ignore();
 632             }
 633             break;
 634
 635         case SID_CHG_PROTECT :
 636             {
 637                 vcl::Window* pParent = nullptr;
 638                 const SfxPoolItem* pParentItem;
 639                 if( pReqArgs && SfxItemState::SET == pReqArgs->GetItemState( SID_ATTR_XWINDOW, false, &pParentItem ) )
 640                     pParent = static_cast<const XWindowItem*>( pParentItem )->GetWindowPtr();
 641                 if ( ExecuteChangeProtectionDialog( pParent ) )
 642                 {
 643                     rReq.Done();
 644                     SetDocumentModified();
 645                 }
 646                 else
 647                     rReq.Ignore();
 648             }
 649             break;
 650
 651         case SID_DOCUMENT_MERGE:
 652         case SID_DOCUMENT_COMPARE:
 653             {
 654                 bool bDo = true;
 655                 ScChangeTrack* pChangeTrack = aDocument.GetChangeTrack();
 656                 if ( pChangeTrack && !pImpl->bIgnoreLostRedliningWarning )
 657                 {
 658                     if ( nSlot == SID_DOCUMENT_COMPARE )
 659                     {   //! old changes trace will be lost
 660                         ScopedVclPtrInstance<WarningBox> aBox( GetActiveDialogParent(),
 661                             WinBits(WB_YES_NO | WB_DEF_NO),
 662                             ScGlobal::GetRscString( STR_END_REDLINING ) );
 663                         if( aBox->Execute() == RET_YES )
 664                             bDo = ExecuteChangeProtectionDialog( nullptr, true );
 665                         else
 666                             bDo = false;
 667                     }
 668                     else    // merge might reject some actions
 669                         bDo = ExecuteChangeProtectionDialog( nullptr, true );
 670                 }
 671                 if ( !bDo )
 672                 {
 673                     rReq.Ignore();
 674                     break;
 675                 }
 676                 SfxApplication* pApp = SfxGetpApp();
 677                 const SfxPoolItem* pItem;
 678                 const SfxStringItem* pStringItem(nullptr);
 679                 SfxMedium* pMed = nullptr;
 680                 if (pReqArgs && pReqArgs->GetItemState(SID_FILE_NAME, true, &pItem) == SfxItemState::SET)
 681                 {
 682                     pStringItem = dynamic_cast<const SfxStringItem*>(pItem);
 683                 }
 684                 if (pStringItem)
 685                 {
 686                     OUString aFileName = pStringItem->GetValue();
 687
 688                     OUString aFilterName;
 689                     pStringItem = nullptr;
 690                     if (pReqArgs->GetItemState(SID_FILTER_NAME, true, &pItem) == SfxItemState::SET)
 691                         pStringItem = dynamic_cast<const SfxStringItem*>(pItem);
 692                     if (pStringItem)
 693                     {
 694                         aFilterName = pStringItem->GetValue();
 695                     }
 696                     OUString aOptions;
 697                     pStringItem = nullptr;
 698                     if (pReqArgs->GetItemState(SID_FILE_FILTEROPTIONS, true, &pItem) == SfxItemState::SET)
 699                         pStringItem = dynamic_cast<const SfxStringItem*>(pItem);
 700                     if (pStringItem)
 701                     {
 702                         aOptions = pStringItem->GetValue();
 703                     }
 704                     short nVersion = 0;
 705                     const SfxInt16Item* pInt16Item(nullptr);
 706                     if (pReqArgs->GetItemState(SID_VERSION, true, &pItem) == SfxItemState::SET)
 707                         pInt16Item = dynamic_cast<const SfxInt16Item*>(pItem);
 708                     if (pInt16Item)
 709                     {
 710                         nVersion = pInt16Item->GetValue();
 711                     }
 712
 713                     //  kein Filter angegeben -> Detection
 714                     if (aFilterName.isEmpty())
 715                         ScDocumentLoader::GetFilterName( aFileName, aFilterName, aOptions, true, false );
 716
 717                     //  filter name from dialog contains application prefix,
 718                     //  GetFilter needs name without the prefix.
 719                     ScDocumentLoader::RemoveAppPrefix( aFilterName );
 720
 721                     std::shared_ptr<const SfxFilter> pFilter = ScDocShell::Factory().GetFilterContainer()->GetFilter4FilterName( aFilterName );
 722                     SfxItemSet* pSet = new SfxAllItemSet( pApp->GetPool() );
 723                     if (!aOptions.isEmpty())
 724                         pSet->Put( SfxStringItem( SID_FILE_FILTEROPTIONS, aOptions ) );
 725                     if ( nVersion != 0 )
 726                         pSet->Put( SfxInt16Item( SID_VERSION, nVersion ) );
 727                     pMed = new SfxMedium( aFileName, STREAM_STD_READ, pFilter, pSet );
 728                 }
 729                 else
 730                 {
 731                     // start file dialog asynchronous
 732                     pImpl->bIgnoreLostRedliningWarning = true;
 733                     delete pImpl->pRequest;
 734                     pImpl->pRequest = new SfxRequest( rReq );
 735                     delete pImpl->pDocInserter;
 736                     pImpl->pDocInserter = new ::sfx2::DocumentInserter(
 737                         OUString::createFromAscii( ScDocShell::Factory().GetShortName() ), false );
 738                     pImpl->pDocInserter->StartExecuteModal( LINK( this, ScDocShell, DialogClosedHdl ) );
 739                     return ;
 740                 }
 741
 742                 if ( pMed )     // nun wirklich ausfuehren...
 743                 {
 744                     SfxErrorContext aEc( ERRCTX_SFX_OPENDOC, pMed->GetName() );
 745
 746                     // pOtherDocSh->DoClose() will be called explicitly later, but it is still more safe to use SfxObjectShellLock here
 747                     ScDocShell* pOtherDocSh = new ScDocShell;
 748                     SfxObjectShellLock aDocShTablesRef = pOtherDocSh;
 749                     pOtherDocSh->DoLoad( pMed );
 750                     sal_uLong nErr = pOtherDocSh->GetErrorCode();
 751                     if (nErr)
 752                         ErrorHandler::HandleError( nErr );          // auch Warnings
 753
 754                     if ( !pOtherDocSh->GetError() )                 // nur Errors
 755                     {
 756                         bool bHadTrack = ( aDocument.GetChangeTrack() != nullptr );
 757 #if HAVE_FEATURE_MULTIUSER_ENVIRONMENT
 758                         sal_uLong nStart = 0;
 759                         if ( nSlot == SID_DOCUMENT_MERGE && pChangeTrack )
 760                         {
 761                             nStart = pChangeTrack->GetActionMax() + 1;
 762                         }
 763 #endif
 764                         if ( nSlot == SID_DOCUMENT_COMPARE )
 765                             CompareDocument( pOtherDocSh->GetDocument() );
 766                         else
 767                             MergeDocument( pOtherDocSh->GetDocument() );
 768
 769                         //  show "accept changes" dialog
 770                         //! get view for this document!
 771                         if ( !IsDocShared() )
 772                         {
 773                             SfxViewFrame* pViewFrm = SfxViewFrame::Current();
 774                             if ( pViewFrm )
 775                             {
 776                                 pViewFrm->ShowChildWindow( ScAcceptChgDlgWrapper::GetChildWindowId() ); //@51669
 777                             }
 778                             if ( pBindings )
 779                             {
 780                                 pBindings->Invalidate( FID_CHG_ACCEPT );
 781                             }
 782                         }
 783
 784                         rReq.SetReturnValue( SfxInt32Item( nSlot, 0 ) );        //! ???????
 785                         rReq.Done();
 786
 787                         if (!bHadTrack)         //  neu eingeschaltet -> auch anzeigen
 788                         {
 789                             ScChangeViewSettings* pOldSet = aDocument.GetChangeViewSettings();
 790                             if ( !pOldSet || !pOldSet->ShowChanges() )
 791                             {
 792                                 ScChangeViewSettings aChangeViewSet;
 793                                 aChangeViewSet.SetShowChanges(true);
 794                                 aDocument.SetChangeViewSettings(aChangeViewSet);
 795                             }
 796                         }
 797 #if HAVE_FEATURE_MULTIUSER_ENVIRONMENT
 798                         else if ( nSlot == SID_DOCUMENT_MERGE && IsDocShared() && pChangeTrack )
 799                         {
 800                             sal_uLong nEnd = pChangeTrack->GetActionMax();
 801                             if ( nEnd >= nStart )
 802                             {
 803                                 // only show changes from merged document
 804                                 ScChangeViewSettings aChangeViewSet;
 805                                 aChangeViewSet.SetShowChanges( true );
 806                                 aChangeViewSet.SetShowAccepted( true );
 807                                 aChangeViewSet.SetHasActionRange();
 808                                 aChangeViewSet.SetTheActionRange( nStart, nEnd );
 809                                 aDocument.SetChangeViewSettings( aChangeViewSet );
 810
 811                                 // update view
 812                                 PostPaintExtras();
 813                                 PostPaintGridAll();
 814                             }
 815                         }
 816 #endif
 817                     }
 818                     pOtherDocSh->DoClose();     // delete passiert mit der Ref
 819                 }
 820             }
 821             break;
 822
 823         case SID_DELETE_SCENARIO:
 824             if (pReqArgs)
 825             {
 826                 const SfxPoolItem* pItem;
 827                 if ( pReqArgs->GetItemState( nSlot, true, &pItem ) == SfxItemState::SET )
 828                 {
 829                     if (const SfxStringItem* pStringItem = dynamic_cast<const SfxStringItem*>(pItem))
 830                     {
 831                         OUString aName = pStringItem->GetValue();
 832                         SCTAB nTab;
 833                         if (aDocument.GetTable( aName, nTab ))
 834                         {
 835                             //  DeleteTable von viewfunc nach docfunc verschieben!
 836
 837                             ScTabViewShell* pSh = GetBestViewShell();
 838                             if ( pSh )
 839                             {
 840                                 //! SetTabNo in DeleteTable weglassen?
 841                                 SCTAB nDispTab = pSh->GetViewData().GetTabNo();
 842                                 pSh->DeleteTable( nTab );
 843                                 pSh->SetTabNo(nDispTab);
 844                                 rReq.Done();
 845                             }
 846                         }
 847                     }
 848                 }
 849             }
 850             break;
 851
 852         case SID_EDIT_SCENARIO:
 853             {
 854                 const SfxPoolItem* pItem;
 855                 if ( pReqArgs->GetItemState( nSlot, true, &pItem ) == SfxItemState::SET )
 856                 {
 857                     if (const SfxStringItem* pStringItem = dynamic_cast<const SfxStringItem*>(pItem))
 858                     {
 859                         OUString aName = pStringItem->GetValue();
 860                         SCTAB nTab;
 861                         if (aDocument.GetTable( aName, nTab ))
 862                         {
 863                             if (aDocument.IsScenario(nTab))
 864                             {
 865                                 OUString aComment;
 866                                 Color aColor;
 867                                 sal_uInt16 nFlags;
 868                                 aDocument.GetScenarioData( nTab, aComment, aColor, nFlags );
 869
 870                                 // Determine if the Sheet that the Scenario was created on
 871                                 // is protected. But first we need to find that Sheet.
 872                                 // Rewind back to the actual sheet.
 873                                 SCTAB nActualTab = nTab;
 874                                 do
 875                                 {
 876                                     nActualTab--;
 877                                 }
 878                                 while(aDocument.IsScenario(nActualTab));
 879                                 bool bSheetProtected = aDocument.IsTabProtected(nActualTab);
 880
 881                                 ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
 882                                 OSL_ENSURE(pFact, "ScAbstractFactory create fail!");
 883
 884                                 std::unique_ptr<AbstractScNewScenarioDlg> pNewDlg(pFact->CreateScNewScenarioDlg(GetActiveDialogParent(), aName, true, bSheetProtected));
 885                                 OSL_ENSURE(pNewDlg, "Dialog create fail!");
 886                                 pNewDlg->SetScenarioData( aName, aComment, aColor, nFlags );
 887                                 if ( pNewDlg->Execute() == RET_OK )
 888                                 {
 889                                     pNewDlg->GetScenarioData( aName, aComment, aColor, nFlags );
 890                                     ModifyScenario( nTab, aName, aComment, aColor, nFlags );
 891                                     rReq.Done();
 892                                 }
 893                             }
 894                         }
 895                     }
 896                 }
 897             }
 898             break;
 899
 900         case SID_ATTR_YEAR2000 :
 901         {
 902             const SfxPoolItem* pItem;
 903             if ( pReqArgs->GetItemState( nSlot, true, &pItem ) == SfxItemState::SET )
 904             {
 905                 if (const SfxUInt16Item* pInt16Item = dynamic_cast<const SfxUInt16Item*>(pItem))
 906                 {
 907                     sal_uInt16 nY2k = pInt16Item->GetValue();
 908                     // immer an den DocOptions setzen, damit das auch fuer SO50
 909                     // gespeichert wird (und alle Abfragen bisher auch darauf laufen).
 910                     // SetDocOptions propagiert das an den NumberFormatter
 911                     ScDocOptions aDocOpt( aDocument.GetDocOptions() );
 912                     aDocOpt.SetYear2000( nY2k );
 913                     aDocument.SetDocOptions( aDocOpt );
 914                     // die FormShell soll es mitbekommen
 915                     ScTabViewShell* pSh = GetBestViewShell();
 916                     if ( pSh )
 917                     {
 918                         FmFormShell* pFSh = pSh->GetFormShell();
 919                         if ( pFSh )
 920                             pFSh->SetY2KState( nY2k );
 921                     }
 922                 }
 923             }
 924         }
 925         break;
 926
 927 #if HAVE_FEATURE_MULTIUSER_ENVIRONMENT
 928         case SID_SHARE_DOC:
 929             {
 930                 ScViewData* pViewData = GetViewData();
 931                 if ( !pViewData )
 932                 {
 933                     rReq.Ignore();
 934                     break;
 935                 }
 936
 937                 ScopedVclPtrInstance< ScShareDocumentDlg > aDlg( GetActiveDialogParent(), pViewData );
 938                 if ( aDlg->Execute() == RET_OK )
 939                 {
 940                     bool bSetShared = aDlg->IsShareDocumentChecked();
 941                     if ( bSetShared != static_cast< bool >( IsDocShared() ) )
 942                     {
 943                         if ( bSetShared )
 944                         {
 945                             bool bContinue = true;
 946                             if ( HasName() )
 947                             {
 948                                 ScopedVclPtrInstance<QueryBox> aBox(
 949                                     GetActiveDialogParent(),
 950                                     WinBits( WB_YES_NO | WB_DEF_YES ),
 951                                     ScGlobal::GetRscString( STR_DOC_WILLBESAVED ) );
 952                                 if ( aBox->Execute() == RET_NO )
 953                                 {
 954                                     bContinue = false;
 955                                 }
 956                             }
 957                             if ( bContinue )
 958                             {
 959                                 EnableSharedSettings( true );
 960
 961                                 SC_MOD()->SetInSharedDocSaving( true );
 962                                 if ( !SwitchToShared( true, true ) )
 963                                 {
 964                                     // TODO/LATER: what should be done in case the switch has failed?
 965                                     // for example in case the user has cancelled the saveAs operation
 966                                 }
 967
 968                                 SC_MOD()->SetInSharedDocSaving( false );
 969
 970                                 InvalidateName();
 971                                 GetUndoManager()->Clear();
 972
 973                                 ScTabView* pTabView = dynamic_cast< ScTabView* >( pViewData->GetView() );
 974                                 if ( pTabView )
 975                                 {
 976                                     pTabView->UpdateLayerLocks();
 977                                 }
 978                             }
 979                         }
 980                         else
 981                         {
 982                             uno::Reference< frame::XModel > xModel;
 983                             try
 984                             {
 985                                 // load shared file
 986                                 xModel.set( LoadSharedDocument(), uno::UNO_QUERY_THROW );
 987                                 uno::Reference< util::XCloseable > xCloseable( xModel, uno::UNO_QUERY_THROW );
 988
 989                                 // check if shared flag is set in shared file
 990                                 bool bShared = false;
 991                                 ScModelObj* pDocObj = ScModelObj::getImplementation( xModel );
 992                                 if ( pDocObj )
 993                                 {
 994                                     ScDocShell* pDocShell = dynamic_cast< ScDocShell* >( pDocObj->GetEmbeddedObject() );
 995                                     if ( pDocShell )
 996                                     {
 997                                         bShared = pDocShell->HasSharedXMLFlagSet();
 998                                     }
 999                                 }
1000
1001                                 // #i87870# check if shared status was disabled and enabled again
1002                                 bool bOwnEntry = false;
1003                                 try
1004                                 {
1005                                     ::svt::ShareControlFile aControlFile( GetSharedFileURL() );
1006                                     bOwnEntry = aControlFile.HasOwnEntry();
1007                                 }
1008                                 catch ( uno::Exception& )
1009                                 {
1010                                 }
1011
1012                                 if ( bShared && bOwnEntry )
1013                                 {
1014                                     uno::Reference< frame::XStorable > xStorable( xModel, uno::UNO_QUERY_THROW );
1015                                     if ( xStorable->isReadonly() )
1016                                     {
1017                                         xCloseable->close( true );
1018
1019                                         OUString aUserName( ScGlobal::GetRscString( STR_UNKNOWN_USER ) );
1020                                         try
1021                                         {
1022                                             ::svt::DocumentLockFile aLockFile( GetSharedFileURL() );
1023                                             LockFileEntry aData = aLockFile.GetLockData();
1024                                             if ( !aData[LockFileComponent::OOOUSERNAME].isEmpty() )
1025                                             {
1026                                                 aUserName = aData[LockFileComponent::OOOUSERNAME];
1027                                             }
1028                                             else if ( !aData[LockFileComponent::SYSUSERNAME].isEmpty() )
1029                                             {
1030                                                 aUserName = aData[LockFileComponent::SYSUSERNAME];
1031                                             }
1032                                         }
1033                                         catch ( uno::Exception& )
1034                                         {
1035                                         }
1036                                         OUString aMessage( ScGlobal::GetRscString( STR_FILE_LOCKED_TRY_LATER ) );
1037                                         aMessage = aMessage.replaceFirst( "%1", aUserName );
1038
1039                                         ScopedVclPtrInstance< WarningBox > aBox( GetActiveDialogParent(), WinBits( WB_OK ), aMessage );
1040                                         aBox->Execute();
1041                                     }
1042                                     else
1043                                     {
1044                                         ScopedVclPtrInstance<WarningBox> aBox(
1045                                             GetActiveDialogParent(),
1046                                             WinBits( WB_YES_NO | WB_DEF_YES ),
1047                                             ScGlobal::GetRscString( STR_DOC_DISABLESHARED ) );
1048                                         if ( aBox->Execute() == RET_YES )
1049                                         {
1050                                             xCloseable->close( true );
1051
1052                                             if ( !SwitchToShared( false, true ) )
1053                                             {
1054                                                 // TODO/LATER: what should be done in case the switch has failed?
1055                                                 // for example in case the user has cancelled the saveAs operation
1056                                             }
1057
1058                                             EnableSharedSettings( false );
1059
1060                                             if ( pBindings )
1061                                             {
1062                                                 pBindings->ExecuteSynchron( SID_SAVEDOC );
1063                                             }
1064
1065                                             ScTabView* pTabView = dynamic_cast< ScTabView* >( pViewData->GetView() );
1066                                             if ( pTabView )
1067                                             {
1068                                                 pTabView->UpdateLayerLocks();
1069                                             }
1070                                         }
1071                                         else
1072                                         {
1073                                             xCloseable->close( true );
1074                                         }
1075                                     }
1076                                 }
1077                                 else
1078                                 {
1079                                     xCloseable->close( true );
1080                                     ScopedVclPtrInstance<WarningBox> aBox( GetActiveDialogParent(), WinBits( WB_OK ),
1081                                         ScGlobal::GetRscString( STR_DOC_NOLONGERSHARED ) );
1082                                     aBox->Execute();
1083                                 }
1084                             }
1085                             catch ( uno::Exception& )
1086                             {
1087                                 OSL_FAIL( "SID_SHARE_DOC: caught exception\n" );
1088                                 SC_MOD()->SetInSharedDocSaving( false );
1089
1090                                 try
1091                                 {
1092                                     uno::Reference< util::XCloseable > xClose( xModel, uno::UNO_QUERY_THROW );
1093                                     xClose->close( true );
1094                                 }
1095                                 catch ( uno::Exception& )
1096                                 {
1097                                 }
1098                             }
1099                         }
1100                     }
1101                 }
1102                 rReq.Done();
1103             }
1104             break;
1105 #endif
1106         case SID_OPEN_CALC:
1107         {
1108             SfxStringItem aApp(SID_DOC_SERVICE, OUString("com.sun.star.sheet.SpreadsheetDocument"));
1109             SfxStringItem aTarget(SID_TARGETNAME, OUString("_blank"));
1110             GetViewData()->GetDispatcher().ExecuteList(
1111                 SID_OPENDOC, SfxCallMode::API|SfxCallMode::SYNCHRON,
1112                 { &aApp, &aTarget });
1113         }
1114         break;
1115         case SID_NOTEBOOKBAR:
1116         {
1117             if (pBindings)
1118                 sfx2::SfxNotebookBar::ExecMethod(*pBindings);
1119         }
1120         break;
1121         default:
1122         {
1123             // kleiner (?) Hack -> forward der Slots an TabViewShell
1124             ScTabViewShell* pSh = GetBestViewShell();
1125             if ( pSh )
1126                 pSh->Execute( rReq );
1127 #if HAVE_FEATURE_SCRIPTING
1128             else
1129                 SbxBase::SetError( ERRCODE_SBX_NO_ACTIVE_OBJECT );
1130 #endif
1131         }
1132     }
1133 }
1134
1135 void UpdateAcceptChangesDialog()
1136 {
1137     //  update "accept changes" dialog
1138     //! notify all views
1139     SfxViewFrame* pViewFrm = SfxViewFrame::Current();
1140     if ( pViewFrm && pViewFrm->HasChildWindow( FID_CHG_ACCEPT ) )
1141     {
1142         SfxChildWindow* pChild = pViewFrm->GetChildWindow( FID_CHG_ACCEPT );
1143         if ( pChild )
1144             static_cast<ScAcceptChgDlgWrapper*>(pChild)->ReInitDlg();
1145     }
1146 }
1147
1148 bool ScDocShell::ExecuteChangeProtectionDialog( vcl::Window* _pParent, bool bJustQueryIfProtected )
1149 {
1150     bool bDone = false;
1151     ScChangeTrack* pChangeTrack = aDocument.GetChangeTrack();
1152     if ( pChangeTrack )
1153     {
1154         bool bProtected = pChangeTrack->IsProtected();
1155         if ( bJustQueryIfProtected && !bProtected )
1156             return true;
1157
1158         OUString aTitle( ScResId( bProtected ? SCSTR_CHG_UNPROTECT : SCSTR_CHG_PROTECT ) );
1159         OUString aText( ScResId( SCSTR_PASSWORD ) );
1160         OUString aPassword;
1161
1162         ScopedVclPtrInstance<SfxPasswordDialog> pDlg(
1163             _pParent ? _pParent : GetActiveDialogParent(), &aText );
1164         pDlg->SetText( aTitle );
1165         pDlg->SetMinLen( 1 );
1166         pDlg->SetHelpId( GetStaticInterface()->GetSlot(SID_CHG_PROTECT)->GetCommand() );
1167         pDlg->SetEditHelpId( HID_CHG_PROTECT );
1168         if ( !bProtected )
1169             pDlg->ShowExtras( SfxShowExtras::CONFIRM );
1170         if ( pDlg->Execute() == RET_OK )
1171             aPassword = pDlg->GetPassword();
1172         pDlg.disposeAndClear();
1173
1174         if (!aPassword.isEmpty())
1175         {
1176             if ( bProtected )
1177             {
1178                 if ( SvPasswordHelper::CompareHashPassword(pChangeTrack->GetProtection(), aPassword) )
1179                 {
1180                     if ( bJustQueryIfProtected )
1181                         bDone = true;
1182                     else
1183                         pChangeTrack->SetProtection(
1184                             css::uno::Sequence< sal_Int8 > (0) );
1185                 }
1186                 else
1187                 {
1188                     ScopedVclPtrInstance<InfoBox> aBox( GetActiveDialogParent(),
1189                         OUString( ScResId( SCSTR_WRONGPASSWORD ) ) );
1190                     aBox->Execute();
1191                 }
1192             }
1193             else
1194             {
1195                 css::uno::Sequence< sal_Int8 > aPass;
1196                 SvPasswordHelper::GetHashPassword( aPass, aPassword );
1197                 pChangeTrack->SetProtection( aPass );
1198             }
1199             if ( bProtected != pChangeTrack->IsProtected() )
1200             {
1201                 UpdateAcceptChangesDialog();
1202                 bDone = true;
1203             }
1204         }
1205     }
1206     else if ( bJustQueryIfProtected )
1207         bDone = true;
1208     return bDone;
1209 }
1210
1211 void ScDocShell::DoRecalc( bool bApi )
1212 {
1213     bool bDone = false;
1214     ScTabViewShell* pSh = GetBestViewShell();
1215     ScInputHandler* pHdl = ( pSh ? SC_MOD()->GetInputHdl( pSh ) : nullptr );
1216     if ( pSh )
1217     {
1218         if ( pHdl && pHdl->IsInputMode() && pHdl->IsFormulaMode() && !bApi )
1219         {
1220             pHdl->FormulaPreview();     // Teilergebnis als QuickHelp
1221             bDone = true;
1222         }
1223         else
1224         {
1225             ScTabView::UpdateInputLine();     // InputEnterHandler
1226             pSh->UpdateInputHandler();
1227         }
1228     }
1229     if (!bDone)                         // sonst Dokument neu berechnen
1230     {
1231         WaitObject aWaitObj( GetActiveDialogParent() );
1232         if ( pHdl )
1233         {
1234             // tdf97897 set current cell to Dirty to force recalculation of cell
1235             ScFormulaCell* pFC = aDocument.GetFormulaCell( pHdl->GetCursorPos());
1236             if (pFC)
1237                 pFC->SetDirty();
1238         }
1239         aDocument.CalcFormulaTree();
1240         if ( pSh )
1241             pSh->UpdateCharts(true);
1242
1243         aDocument.BroadcastUno( SfxSimpleHint( SFX_HINT_DATACHANGED ) );
1244
1245         //  Wenn es Charts gibt, dann alles painten, damit nicht
1246         //  PostDataChanged und die Charts nacheinander kommen und Teile
1247         //  doppelt gepainted werden.
1248
1249         ScChartListenerCollection* pCharts = aDocument.GetChartListenerCollection();
1250         if ( pCharts && pCharts->hasListeners() )
1251             PostPaintGridAll();
1252         else
1253             PostDataChanged();
1254     }
1255 }
1256
1257 void ScDocShell::DoHardRecalc( bool /* bApi */ )
1258 {
1259     WaitObject aWaitObj( GetActiveDialogParent() );
1260     ScTabViewShell* pSh = GetBestViewShell();
1261     if ( pSh )
1262     {
1263         ScTabView::UpdateInputLine();     // InputEnterHandler
1264         pSh->UpdateInputHandler();
1265     }
1266     aDocument.CalcAll();
1267     GetDocFunc().DetectiveRefresh();    // erzeugt eigenes Undo
1268     if ( pSh )
1269         pSh->UpdateCharts(true);
1270
1271     // set notification flags for "calculate" event (used in SFX_HINT_DATACHANGED broadcast)
1272     // (might check for the presence of any formulas on each sheet)
1273     SCTAB nTabCount = aDocument.GetTableCount();
1274     if (aDocument.HasAnySheetEventScript( ScSheetEventId::CALCULATE, true )) // search also for VBA handler
1275         for (SCTAB nTab=0; nTab<nTabCount; nTab++)
1276             aDocument.SetCalcNotification(nTab);
1277
1278     // CalcAll doesn't broadcast value changes, so SC_HINT_CALCALL is broadcasted globally
1279     // in addition to SFX_HINT_DATACHANGED.
1280     aDocument.BroadcastUno( SfxSimpleHint( SC_HINT_CALCALL ) );
1281     aDocument.BroadcastUno( SfxSimpleHint( SFX_HINT_DATACHANGED ) );
1282
1283     // use hard recalc also to disable stream-copying of all sheets
1284     // (somewhat consistent with charts)
1285     for (SCTAB nTab=0; nTab<nTabCount; nTab++)
1286         if (aDocument.IsStreamValid(nTab))
1287             aDocument.SetStreamValid(nTab, false);
1288
1289     PostPaintGridAll();
1290 }
1291
1292 void ScDocShell::DoAutoStyle( const ScRange& rRange, const OUString& rStyle )
1293 {
1294     ScStyleSheetPool* pStylePool = aDocument.GetStyleSheetPool();
1295     ScStyleSheet* pStyleSheet =
1296         pStylePool->FindCaseIns( rStyle, SfxStyleFamily::Para );
1297     if (!pStyleSheet)
1298         pStyleSheet = static_cast<ScStyleSheet*>(
1299             pStylePool->Find( ScGlobal::GetRscString(STR_STYLENAME_STANDARD), SfxStyleFamily::Para ));
1300     if (pStyleSheet)
1301     {
1302         OSL_ENSURE(rRange.aStart.Tab() == rRange.aEnd.Tab(),
1303                         "DoAutoStyle mit mehreren Tabellen");
1304         SCTAB nTab = rRange.aStart.Tab();
1305         SCCOL nStartCol = rRange.aStart.Col();
1306         SCROW nStartRow = rRange.aStart.Row();
1307         SCCOL nEndCol = rRange.aEnd.Col();
1308         SCROW nEndRow = rRange.aEnd.Row();
1309         aDocument.ApplyStyleAreaTab( nStartCol, nStartRow, nEndCol, nEndRow, nTab, *pStyleSheet );
1310         aDocument.ExtendMerge( nStartCol, nStartRow, nEndCol, nEndRow, nTab );
1311         PostPaint( nStartCol, nStartRow, nTab, nEndCol, nEndRow, nTab, PAINT_GRID );
1312     }
1313 }
1314
1315 void ScDocShell::NotifyStyle( const SfxStyleSheetHint& rHint )
1316 {
1317     sal_uInt16 nId = rHint.GetHint();
1318     const SfxStyleSheetBase* pStyle = rHint.GetStyleSheet();
1319     if (!pStyle)
1320         return;
1321
1322     if ( pStyle->GetFamily() == SfxStyleFamily::Page )
1323     {
1324         if ( nId == SfxStyleSheetHintId::MODIFIED )
1325         {
1326             ScDocShellModificator aModificator( *this );
1327
1328             OUString aNewName = pStyle->GetName();
1329             OUString aOldName = aNewName;
1330             const SfxStyleSheetHintExtended* pExtendedHint = dynamic_cast<const SfxStyleSheetHintExtended*>(&rHint); // Name geaendert?
1331             if (pExtendedHint)
1332                 aOldName = pExtendedHint->GetOldName();
1333
1334             if ( aNewName != aOldName )
1335                 aDocument.RenamePageStyleInUse( aOldName, aNewName );
1336
1337             SCTAB nTabCount = aDocument.GetTableCount();
1338             for (SCTAB nTab=0; nTab<nTabCount; nTab++)
1339                 if (aDocument.GetPageStyle(nTab) == aNewName)   // schon auf neu angepasst
1340                 {
1341                     aDocument.PageStyleModified( nTab, aNewName );
1342                     ScPrintFunc aPrintFunc( this, GetPrinter(), nTab );
1343                     aPrintFunc.UpdatePages();
1344                 }
1345
1346             aModificator.SetDocumentModified();
1347
1348             if (pExtendedHint)
1349             {
1350                 SfxBindings* pBindings = GetViewBindings();
1351                 if (pBindings)
1352                 {
1353                     pBindings->Invalidate( SID_STATUS_PAGESTYLE );
1354                     pBindings->Invalidate( SID_STYLE_FAMILY4 );
1355                     pBindings->Invalidate( FID_RESET_PRINTZOOM );
1356                     pBindings->Invalidate( SID_ATTR_PARA_LEFT_TO_RIGHT );
1357                     pBindings->Invalidate( SID_ATTR_PARA_RIGHT_TO_LEFT );
1358                 }
1359             }
1360         }
1361     }
1362     else if ( pStyle->GetFamily() == SfxStyleFamily::Para )
1363     {
1364         if ( nId == SfxStyleSheetHintId::MODIFIED)
1365         {
1366             OUString aNewName = pStyle->GetName();
1367             OUString aOldName = aNewName;
1368             const SfxStyleSheetHintExtended* pExtendedHint = dynamic_cast<const SfxStyleSheetHintExtended*>(&rHint);
1369             if (pExtendedHint)
1370                 aOldName = pExtendedHint->GetOldName();
1371             if ( aNewName != aOldName )
1372             {
1373                 for(SCTAB i = 0; i < aDocument.GetTableCount(); ++i)
1374                 {
1375                     ScConditionalFormatList* pList = aDocument.GetCondFormList(i);
1376                     if (pList)
1377                         pList->RenameCellStyle( aOldName,aNewName );
1378                 }
1379             }
1380         }
1381     }
1382
1383     //  alles andere geht ueber Slots...
1384 }
1385
1386 //  wie in printfun.cxx
1387 #define ZOOM_MIN    10
1388
1389 void ScDocShell::SetPrintZoom( SCTAB nTab, sal_uInt16 nScale, sal_uInt16 nPages )
1390 {
1391     OUString aStyleName = aDocument.GetPageStyle( nTab );
1392     ScStyleSheetPool* pStylePool = aDocument.GetStyleSheetPool();
1393     SfxStyleSheetBase* pStyleSheet = pStylePool->Find( aStyleName, SfxStyleFamily::Page );
1394     OSL_ENSURE( pStyleSheet, "PageStyle not found" );
1395     if ( pStyleSheet )
1396     {
1397         ScDocShellModificator aModificator( *this );
1398
1399         SfxItemSet& rSet = pStyleSheet->GetItemSet();
1400         const bool bUndo(aDocument.IsUndoEnabled());
1401         if (bUndo)
1402         {
1403             sal_uInt16 nOldScale = static_cast<const SfxUInt16Item&>(rSet.Get(ATTR_PAGE_SCALE)).GetValue();
1404             sal_uInt16 nOldPages = static_cast<const SfxUInt16Item&>(rSet.Get(ATTR_PAGE_SCALETOPAGES)).GetValue();
1405             GetUndoManager()->AddUndoAction( new ScUndoPrintZoom(
1406                             this, nTab, nOldScale, nOldPages, nScale, nPages ) );
1407         }
1408
1409         rSet.Put( SfxUInt16Item( ATTR_PAGE_SCALE, nScale ) );
1410         rSet.Put( SfxUInt16Item( ATTR_PAGE_SCALETOPAGES, nPages ) );
1411
1412         ScPrintFunc aPrintFunc( this, GetPrinter(), nTab );
1413         aPrintFunc.UpdatePages();
1414         aModificator.SetDocumentModified();
1415
1416         SfxBindings* pBindings = GetViewBindings();
1417         if (pBindings)
1418             pBindings->Invalidate( FID_RESET_PRINTZOOM );
1419     }
1420 }
1421
1422 bool ScDocShell::AdjustPrintZoom( const ScRange& rRange )
1423 {
1424     bool bChange = false;
1425     SCTAB nTab = rRange.aStart.Tab();
1426
1427     OUString aStyleName = aDocument.GetPageStyle( nTab );
1428     ScStyleSheetPool* pStylePool = aDocument.GetStyleSheetPool();
1429     SfxStyleSheetBase* pStyleSheet = pStylePool->Find( aStyleName, SfxStyleFamily::Page );
1430     OSL_ENSURE( pStyleSheet, "PageStyle not found" );
1431     if ( pStyleSheet )
1432     {
1433         SfxItemSet& rSet = pStyleSheet->GetItemSet();
1434         bool bHeaders = static_cast<const SfxBoolItem&>(rSet.Get(ATTR_PAGE_HEADERS)).GetValue();
1435         sal_uInt16 nOldScale = static_cast<const SfxUInt16Item&>(rSet.Get(ATTR_PAGE_SCALE)).GetValue();
1436         sal_uInt16 nOldPages = static_cast<const SfxUInt16Item&>(rSet.Get(ATTR_PAGE_SCALETOPAGES)).GetValue();
1437         const ScRange* pRepeatCol = aDocument.GetRepeatColRange( nTab );
1438         const ScRange* pRepeatRow = aDocument.GetRepeatRowRange( nTab );
1439
1440         //  benoetigte Skalierung fuer Selektion ausrechnen
1441
1442         sal_uInt16 nNewScale = nOldScale;
1443
1444         long nBlkTwipsX = 0;
1445         if (bHeaders)
1446             nBlkTwipsX += (long) PRINT_HEADER_WIDTH;
1447         SCCOL nStartCol = rRange.aStart.Col();
1448         SCCOL nEndCol = rRange.aEnd.Col();
1449         if ( pRepeatCol && nStartCol >= pRepeatCol->aStart.Col() )
1450         {
1451             for (SCCOL i=pRepeatCol->aStart.Col(); i<=pRepeatCol->aEnd.Col(); i++ )
1452                 nBlkTwipsX += aDocument.GetColWidth( i, nTab );
1453             if ( nStartCol <= pRepeatCol->aEnd.Col() )
1454                 nStartCol = pRepeatCol->aEnd.Col() + 1;
1455         }
1456         // legacy compilers' own scope for i
1457         {
1458             for ( SCCOL i=nStartCol; i<=nEndCol; i++ )
1459                 nBlkTwipsX += aDocument.GetColWidth( i, nTab );
1460         }
1461
1462         long nBlkTwipsY = 0;
1463         if (bHeaders)
1464             nBlkTwipsY += (long) PRINT_HEADER_HEIGHT;
1465         SCROW nStartRow = rRange.aStart.Row();
1466         SCROW nEndRow = rRange.aEnd.Row();
1467         if ( pRepeatRow && nStartRow >= pRepeatRow->aStart.Row() )
1468         {
1469             nBlkTwipsY += aDocument.GetRowHeight( pRepeatRow->aStart.Row(),
1470                     pRepeatRow->aEnd.Row(), nTab );
1471             if ( nStartRow <= pRepeatRow->aEnd.Row() )
1472                 nStartRow = pRepeatRow->aEnd.Row() + 1;
1473         }
1474         nBlkTwipsY += aDocument.GetRowHeight( nStartRow, nEndRow, nTab );
1475
1476         Size aPhysPage;
1477         long nHdr, nFtr;
1478         ScPrintFunc aOldPrFunc( this, GetPrinter(), nTab );
1479         aOldPrFunc.GetScaleData( aPhysPage, nHdr, nFtr );
1480         nBlkTwipsY += nHdr + nFtr;
1481
1482         if ( nBlkTwipsX == 0 )      // hidden columns/rows may lead to 0
1483             nBlkTwipsX = 1;
1484         if ( nBlkTwipsY == 0 )
1485             nBlkTwipsY = 1;
1486
1487         long nNeeded = std::min( aPhysPage.Width()  * 100 / nBlkTwipsX,
1488                             aPhysPage.Height() * 100 / nBlkTwipsY );
1489         if ( nNeeded < ZOOM_MIN )
1490             nNeeded = ZOOM_MIN;         // Begrenzung
1491         if ( nNeeded < (long) nNewScale )
1492             nNewScale = (sal_uInt16) nNeeded;
1493
1494         bChange = ( nNewScale != nOldScale || nOldPages != 0 );
1495         if ( bChange )
1496             SetPrintZoom( nTab, nNewScale, 0 );
1497     }
1498     return bChange;
1499 }
1500
1501 void ScDocShell::PageStyleModified( const OUString& rStyleName, bool bApi )
1502 {
1503     ScDocShellModificator aModificator( *this );
1504
1505     SCTAB nTabCount = aDocument.GetTableCount();
1506     SCTAB nUseTab = MAXTAB+1;
1507     for (SCTAB nTab=0; nTab<nTabCount && nUseTab>MAXTAB; nTab++)
1508         if ( aDocument.GetPageStyle(nTab) == rStyleName &&
1509                 ( !bApi || aDocument.GetPageSize(nTab).Width() ) )
1510             nUseTab = nTab;
1511                                 // bei bApi nur, wenn Umbrueche schon angezeigt
1512
1513     if (ValidTab(nUseTab))      // nicht verwendet -> nichts zu tun
1514     {
1515         bool bWarn = false;
1516
1517         ScPrintFunc aPrintFunc( this, GetPrinter(), nUseTab );  //! ohne CountPages auskommen
1518         if (!aPrintFunc.UpdatePages())                          //  setzt Umbrueche auf allen Tabs
1519             bWarn = true;
1520
1521         if (bWarn && !bApi)
1522         {
1523             ScWaitCursorOff aWaitOff( GetActiveDialogParent() );
1524             ScopedVclPtrInstance<InfoBox> aInfoBox(GetActiveDialogParent(),
1525                                                    ScGlobal::GetRscString(STR_PRINT_INVALID_AREA));
1526             aInfoBox->Execute();
1527         }
1528     }
1529
1530     aModificator.SetDocumentModified();
1531
1532     SfxBindings* pBindings = GetViewBindings();
1533     if (pBindings)
1534     {
1535         pBindings->Invalidate( FID_RESET_PRINTZOOM );
1536         pBindings->Invalidate( SID_ATTR_PARA_LEFT_TO_RIGHT );
1537         pBindings->Invalidate( SID_ATTR_PARA_RIGHT_TO_LEFT );
1538     }
1539 }
1540
1541 void ScDocShell::ExecutePageStyle( SfxViewShell& rCaller,
1542                                    SfxRequest&   rReq,
1543                                    SCTAB         nCurTab )
1544 {
1545     const SfxItemSet* pReqArgs = rReq.GetArgs();
1546
1547     switch ( rReq.GetSlot() )
1548     {
1549         case SID_STATUS_PAGESTYLE:  // Click auf StatusBar-Control
1550         case SID_FORMATPAGE:
1551             {
1552                 if ( pReqArgs == nullptr )
1553                 {
1554                     OUString aOldName = aDocument.GetPageStyle( nCurTab );
1555                     ScStyleSheetPool* pStylePool = aDocument.GetStyleSheetPool();
1556                     SfxStyleSheetBase* pStyleSheet
1557                         = pStylePool->Find( aOldName, SfxStyleFamily::Page );
1558
1559                     OSL_ENSURE( pStyleSheet, "PageStyle not found! :-/" );
1560
1561                     if ( pStyleSheet )
1562                     {
1563                         ScStyleSaveData aOldData;
1564                         const bool bUndo(aDocument.IsUndoEnabled());
1565                         if (bUndo)
1566                             aOldData.InitFromStyle( pStyleSheet );
1567
1568                         SfxItemSet&     rStyleSet = pStyleSheet->GetItemSet();
1569
1570                         ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
1571                         OSL_ENSURE(pFact, "ScAbstractFactory create fail!");
1572
1573                         std::unique_ptr<SfxAbstractTabDialog> pDlg(pFact->CreateScStyleDlg( GetActiveDialogParent(), *pStyleSheet, RID_SCDLG_STYLES_PAGE, RID_SCDLG_STYLES_PAGE ));
1574                         OSL_ENSURE(pDlg, "Dialog create fail!");
1575
1576                         if ( pDlg->Execute() == RET_OK )
1577                         {
1578                             const SfxItemSet* pOutSet = pDlg->GetOutputItemSet();
1579
1580                             WaitObject aWait( GetActiveDialogParent() );
1581
1582                             OUString aNewName = pStyleSheet->GetName();
1583                             if ( aNewName != aOldName &&
1584                                 aDocument.RenamePageStyleInUse( aOldName, aNewName ) )
1585                             {
1586                                 SfxBindings* pBindings = GetViewBindings();
1587                                 if (pBindings)
1588                                 {
1589                                     pBindings->Invalidate( SID_STATUS_PAGESTYLE );
1590                                     pBindings->Invalidate( FID_RESET_PRINTZOOM );
1591                                 }
1592                             }
1593
1594                             if ( pOutSet )
1595                                 aDocument.ModifyStyleSheet( *pStyleSheet, *pOutSet );
1596
1597                             // merken fuer GetState():
1598                             GetPageOnFromPageStyleSet( &rStyleSet, nCurTab, bHeaderOn, bFooterOn );
1599                             rCaller.GetViewFrame()->GetBindings().Invalidate( SID_HFEDIT );
1600
1601                             ScStyleSaveData aNewData;
1602                             aNewData.InitFromStyle( pStyleSheet );
1603                             if (bUndo)
1604                             {
1605                                 GetUndoManager()->AddUndoAction(
1606                                         new ScUndoModifyStyle( this, SfxStyleFamily::Page,
1607                                                     aOldData, aNewData ) );
1608                             }
1609
1610                             PageStyleModified( aNewName, false );
1611                             rReq.Done();
1612                         }
1613                         pDlg.reset();
1614
1615                         rStyleSet.ClearItem( ATTR_PAGE_PAPERTRAY );
1616                     }
1617                 }
1618             }
1619             break;
1620
1621         case SID_HFEDIT:
1622             {
1623                 if ( pReqArgs == nullptr )
1624                 {
1625                     OUString aStr( aDocument.GetPageStyle( nCurTab ) );
1626
1627                     ScStyleSheetPool* pStylePool
1628                         = aDocument.GetStyleSheetPool();
1629
1630                     SfxStyleSheetBase* pStyleSheet
1631                         = pStylePool->Find( aStr, SfxStyleFamily::Page );
1632
1633                     OSL_ENSURE( pStyleSheet, "PageStyle not found! :-/" );
1634
1635                     if ( pStyleSheet )
1636                     {
1637                         SfxItemSet&  rStyleSet = pStyleSheet->GetItemSet();
1638
1639                         SvxPageUsage eUsage =
1640                             SvxPageUsage( static_cast<const SvxPageItem&>(
1641                                             rStyleSet.Get( ATTR_PAGE )).
1642                                                 GetPageUsage() );
1643                         bool bShareHeader = static_cast<const SfxBoolItem&>(
1644                                                 static_cast<const SvxSetItem&>(rStyleSet
1645                                                         .Get(ATTR_PAGE_HEADERSET))
1646                                                     .GetItemSet()
1647                                                     .Get(ATTR_PAGE_SHARED))
1648                                                 .GetValue();
1649                         bool bShareFooter = static_cast<const SfxBoolItem&>(
1650                                                 static_cast<const SvxSetItem&>(rStyleSet
1651                                                         .Get(ATTR_PAGE_FOOTERSET))
1652                                                     .GetItemSet()
1653                                                     .Get(ATTR_PAGE_SHARED))
1654                                                 .GetValue();
1655                         sal_uInt16 nResId = 0;
1656
1657                         switch ( eUsage )
1658                         {
1659                             case SVX_PAGE_LEFT:
1660                             case SVX_PAGE_RIGHT:
1661                             {
1662                                 if ( bHeaderOn && bFooterOn )
1663                                     nResId = RID_SCDLG_HFEDIT;
1664                                 else if ( SVX_PAGE_RIGHT == eUsage )
1665                                 {
1666                                     if ( !bHeaderOn && bFooterOn )
1667                                         nResId = RID_SCDLG_HFEDIT_RIGHTFOOTER;
1668                                     else if ( bHeaderOn && !bFooterOn )
1669                                         nResId = RID_SCDLG_HFEDIT_RIGHTHEADER;
1670                                 }
1671                                 else
1672                                 {
1673                                     //  #69193a# respect "shared" setting
1674                                     if ( !bHeaderOn && bFooterOn )
1675                                         nResId = bShareFooter ?
1676                                                     RID_SCDLG_HFEDIT_RIGHTFOOTER :
1677                                                     RID_SCDLG_HFEDIT_LEFTFOOTER;
1678                                     else if ( bHeaderOn && !bFooterOn )
1679                                         nResId = bShareHeader ?
1680                                                     RID_SCDLG_HFEDIT_RIGHTHEADER :
1681                                                     RID_SCDLG_HFEDIT_LEFTHEADER;
1682                                 }
1683                             }
1684                             break;
1685
1686                             case SVX_PAGE_MIRROR:
1687                             case SVX_PAGE_ALL:
1688                             default:
1689                             {
1690                                 if ( !bShareHeader && !bShareFooter )
1691                                 {
1692                                     if ( bHeaderOn && bFooterOn )
1693                                         nResId = RID_SCDLG_HFEDIT_ALL;
1694                                     else if ( !bHeaderOn && bFooterOn )
1695                                         nResId = RID_SCDLG_HFEDIT_FOOTER;
1696                                     else if ( bHeaderOn && !bFooterOn )
1697                                         nResId = RID_SCDLG_HFEDIT_HEADER;
1698                                 }
1699                                 else if ( bShareHeader && bShareFooter )
1700                                 {
1701                                     if ( bHeaderOn && bFooterOn )
1702                                         nResId = RID_SCDLG_HFEDIT;
1703                                     else
1704                                     {
1705                                         if ( !bHeaderOn && bFooterOn )
1706                                             nResId = RID_SCDLG_HFEDIT_RIGHTFOOTER;
1707                                         else if ( bHeaderOn && !bFooterOn )
1708                                             nResId = RID_SCDLG_HFEDIT_RIGHTHEADER;
1709                                     }
1710                                 }
1711                                 else if ( !bShareHeader &&  bShareFooter )
1712                                 {
1713                                     if ( bHeaderOn && bFooterOn )
1714                                         nResId = RID_SCDLG_HFEDIT_SFTR;
1715                                     else if ( !bHeaderOn && bFooterOn )
1716                                         nResId = RID_SCDLG_HFEDIT_RIGHTFOOTER;
1717                                     else if ( bHeaderOn && !bFooterOn )
1718                                         nResId = RID_SCDLG_HFEDIT_HEADER;
1719                                 }
1720                                 else if (  bShareHeader && !bShareFooter )
1721                                 {
1722                                     if ( bHeaderOn && bFooterOn )
1723                                         nResId = RID_SCDLG_HFEDIT_SHDR;
1724                                     else if ( !bHeaderOn && bFooterOn )
1725                                         nResId = RID_SCDLG_HFEDIT_FOOTER;
1726                                     else if ( bHeaderOn && !bFooterOn )
1727                                         nResId = RID_SCDLG_HFEDIT_RIGHTHEADER;
1728                                 }
1729                             }
1730                         }
1731
1732                         ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
1733                         OSL_ENSURE(pFact, "ScAbstractFactory create fail!");
1734
1735                         std::unique_ptr<SfxAbstractTabDialog> pDlg(pFact->CreateScHFEditDlg(
1736                                                                                 GetActiveDialogParent(),
1737                                                                                 rStyleSet,
1738                                                                                 aStr,
1739                                                                                 nResId));
1740                         OSL_ENSURE(pDlg, "Dialog create fail!");
1741                         if ( pDlg->Execute() == RET_OK )
1742                         {
1743                             const SfxItemSet* pOutSet = pDlg->GetOutputItemSet();
1744
1745                             if ( pOutSet )
1746                                 aDocument.ModifyStyleSheet( *pStyleSheet, *pOutSet );
1747
1748                             SetDocumentModified();
1749                             rReq.Done();
1750                         }
1751                     }
1752                 }
1753             }
1754             break;
1755
1756         default:
1757         break;
1758     }
1759 }
1760
1761 void ScDocShell::GetStatePageStyle( SfxViewShell&   /* rCaller */,
1762                                     SfxItemSet&     rSet,
1763                                     SCTAB           nCurTab )
1764 {
1765     SfxWhichIter aIter(rSet);
1766     sal_uInt16 nWhich = aIter.FirstWhich();
1767     while ( nWhich )
1768     {
1769         switch (nWhich)
1770         {
1771             case SID_STATUS_PAGESTYLE:
1772                 rSet.Put( SfxStringItem( nWhich, aDocument.GetPageStyle( nCurTab ) ) );
1773                 break;
1774
1775             case SID_HFEDIT:
1776                 {
1777                     OUString            aStr        = aDocument.GetPageStyle( nCurTab );
1778                     ScStyleSheetPool*   pStylePool  = aDocument.GetStyleSheetPool();
1779                     SfxStyleSheetBase*  pStyleSheet = pStylePool->Find( aStr, SfxStyleFamily::Page );
1780
1781                     OSL_ENSURE( pStyleSheet, "PageStyle not found! :-/" );
1782
1783                     if ( pStyleSheet )
1784                     {
1785                         SfxItemSet& rStyleSet = pStyleSheet->GetItemSet();
1786                         GetPageOnFromPageStyleSet( &rStyleSet, nCurTab, bHeaderOn, bFooterOn );
1787
1788                         if ( !bHeaderOn && !bFooterOn )
1789                             rSet.DisableItem( nWhich );
1790                     }
1791                 }
1792                 break;
1793         }
1794
1795         nWhich = aIter.NextWhich();
1796     }
1797 }
1798
1799 void ScDocShell::GetState( SfxItemSet &rSet )
1800 {
1801     bool bTabView = GetBestViewShell() != nullptr;
1802
1803     SfxWhichIter aIter(rSet);
1804     for (sal_uInt16 nWhich = aIter.FirstWhich(); nWhich; nWhich = aIter.NextWhich())
1805     {
1806         if (!bTabView)
1807         {
1808             rSet.DisableItem(nWhich);
1809             continue;
1810         }
1811
1812         switch (nWhich)
1813         {
1814             case FID_AUTO_CALC:
1815                 if ( aDocument.GetHardRecalcState() != ScDocument::HARDRECALCSTATE_OFF )
1816                     rSet.DisableItem( nWhich );
1817                 else
1818                     rSet.Put( SfxBoolItem( nWhich, aDocument.GetAutoCalc() ) );
1819                 break;
1820
1821             case FID_CHG_RECORD:
1822                 if ( IsDocShared() )
1823                     rSet.DisableItem( nWhich );
1824                 else
1825                     rSet.Put( SfxBoolItem( nWhich,
1826                         aDocument.GetChangeTrack() != nullptr ) );
1827                 break;
1828
1829             case SID_CHG_PROTECT:
1830                 {
1831                     ScChangeTrack* pChangeTrack = aDocument.GetChangeTrack();
1832                     if ( pChangeTrack && !IsDocShared() )
1833                         rSet.Put( SfxBoolItem( nWhich,
1834                             pChangeTrack->IsProtected() ) );
1835                     else
1836                         rSet.DisableItem( nWhich );
1837                 }
1838                 break;
1839
1840             case SID_DOCUMENT_COMPARE:
1841                 {
1842                     if ( IsDocShared() )
1843                     {
1844                         rSet.DisableItem( nWhich );
1845                     }
1846                 }
1847                 break;
1848
1849             //  Wenn eine Formel editiert wird, muss FID_RECALC auf jeden Fall enabled sein.
1850             //  Recalc fuer das Doc war mal wegen eines Bugs disabled, wenn AutoCalc an war,
1851             //  ist jetzt wegen eines anderen Bugs aber auch immer enabled.
1852
1853             case SID_TABLES_COUNT:
1854                 rSet.Put( SfxInt16Item( nWhich, aDocument.GetTableCount() ) );
1855                 break;
1856
1857             case SID_ATTR_YEAR2000 :
1858                 rSet.Put( SfxUInt16Item( nWhich,
1859                     aDocument.GetDocOptions().GetYear2000() ) );
1860             break;
1861
1862             case SID_SHARE_DOC:
1863                 {
1864                     if ( IsReadOnly() )
1865                     {
1866                         rSet.DisableItem( nWhich );
1867                     }
1868                 }
1869                 break;
1870
1871             case SID_ATTR_CHAR_FONTLIST:
1872                 rSet.Put( SvxFontListItem( pImpl->pFontList, nWhich ) );
1873                 break;
1874
1875             case SID_NOTEBOOKBAR:
1876                 {
1877                     if (GetViewBindings())
1878                         sfx2::SfxNotebookBar::StateMethod(*GetViewBindings(), "modules/scalc/ui/notebookbar.ui");
1879                 }
1880                 break;
1881
1882             default:
1883                 {
1884                 }
1885                 break;
1886         }
1887     }
1888 }
1889
1890 void ScDocShell::GetSbxState( SfxItemSet &rSet )
1891 {
1892     //  SID_SC_SELECTION (Selection),
1893     //  SID_SC_ACTIVECELL (ActiveCell),
1894     //  SID_SC_ACTIVETAB (ActiveTable),
1895     //  SID_TABLES_GET (Tables),
1896     //  SID_PIVOT_GET (DataPilotTables) - removed (old Basic)
1897
1898         //  Wenn hier Slots von der View-Shell executed werden, muss auch der
1899         //  GetState weitergeleitet werden!
1900
1901     ScTabViewShell* pVisibleSh = GetBestViewShell();        // sichtbare View
1902     if ( pVisibleSh )
1903         pVisibleSh->GetState( rSet );
1904 }
1905
1906 void ScDocShell::Draw( OutputDevice* pDev, const JobSetup & /* rSetup */, sal_uInt16 nAspect )
1907 {
1908
1909     SCTAB nVisTab = aDocument.GetVisibleTab();
1910     if (!aDocument.HasTable(nVisTab))
1911         return;
1912
1913     ComplexTextLayoutMode nOldLayoutMode = pDev->GetLayoutMode();
1914     pDev->SetLayoutMode( TEXT_LAYOUT_DEFAULT );     // even if it's the same, to get the metafile action
1915
1916     if ( nAspect == ASPECT_THUMBNAIL )
1917     {
1918         Rectangle aBoundRect = GetVisArea( ASPECT_THUMBNAIL );
1919         ScViewData aTmpData( this, nullptr );
1920         aTmpData.SetTabNo(nVisTab);
1921         SnapVisArea( aBoundRect );
1922         aTmpData.SetScreen( aBoundRect );
1923         ScPrintFunc::DrawToDev( &aDocument, pDev, 1.0, aBoundRect, &aTmpData, true );
1924     }
1925     else
1926     {
1927         Rectangle aBoundRect = SfxObjectShell::GetVisArea();
1928         ScViewData aTmpData( this, nullptr );
1929         aTmpData.SetTabNo(nVisTab);
1930         SnapVisArea( aBoundRect );
1931         aTmpData.SetScreen( aBoundRect );
1932         ScPrintFunc::DrawToDev( &aDocument, pDev, 1.0, aBoundRect, &aTmpData, true );
1933     }
1934
1935     pDev->SetLayoutMode( nOldLayoutMode );
1936 }
1937
1938 Rectangle ScDocShell::GetVisArea( sal_uInt16 nAspect ) const
1939 {
1940     SfxObjectCreateMode eShellMode = GetCreateMode();
1941     if ( eShellMode == SfxObjectCreateMode::ORGANIZER )
1942     {
1943         //  ohne Inhalte wissen wir auch nicht, wie gross die Inhalte sind
1944         //  leeres Rechteck zurueckgeben, das wird dann nach dem Laden berechnet
1945         return Rectangle();
1946     }
1947
1948     if( nAspect == ASPECT_THUMBNAIL )
1949     {
1950         SCTAB nVisTab = aDocument.GetVisibleTab();
1951         if (!aDocument.HasTable(nVisTab))
1952         {
1953             nVisTab = 0;
1954             const_cast<ScDocShell*>(this)->aDocument.SetVisibleTab(nVisTab);
1955         }
1956         Size aSize = aDocument.GetPageSize(nVisTab);
1957         const long SC_PREVIEW_SIZE_X = 10000;
1958         const long SC_PREVIEW_SIZE_Y = 12400;
1959         Rectangle aArea( 0,0, SC_PREVIEW_SIZE_X, SC_PREVIEW_SIZE_Y);
1960         if (aSize.Width() > aSize.Height())
1961         {
1962             aArea.Right() = SC_PREVIEW_SIZE_Y;
1963             aArea.Bottom() = SC_PREVIEW_SIZE_X;
1964         }
1965
1966         bool bNegativePage = aDocument.IsNegativePage( aDocument.GetVisibleTab() );
1967         if ( bNegativePage )
1968             ScDrawLayer::MirrorRectRTL( aArea );
1969         SnapVisArea( aArea );
1970         return aArea;
1971     }
1972     else if( nAspect == ASPECT_CONTENT && eShellMode != SfxObjectCreateMode::EMBEDDED )
1973     {
1974         //  Visarea holen wie nach Load
1975
1976         SCTAB nVisTab = aDocument.GetVisibleTab();
1977         if (!aDocument.HasTable(nVisTab))
1978         {
1979             nVisTab = 0;
1980             const_cast<ScDocShell*>(this)->aDocument.SetVisibleTab(nVisTab);
1981         }
1982         SCCOL nStartCol;
1983         SCROW nStartRow;
1984         aDocument.GetDataStart( nVisTab, nStartCol, nStartRow );
1985         SCCOL nEndCol;
1986         SCROW nEndRow;
1987         aDocument.GetPrintArea( nVisTab, nEndCol, nEndRow );
1988         if (nStartCol>nEndCol)
1989             nStartCol = nEndCol;
1990         if (nStartRow>nEndRow)
1991             nStartRow = nEndRow;
1992         Rectangle aNewArea = ((ScDocument&)aDocument)
1993                                 .GetMMRect( nStartCol,nStartRow, nEndCol,nEndRow, nVisTab );
1994         //TODO/LATER: different methods for setting VisArea?!
1995         const_cast<ScDocShell*>(this)->SfxObjectShell::SetVisArea( aNewArea );
1996         return aNewArea;
1997     }
1998     else
1999         return SfxObjectShell::GetVisArea( nAspect );
2000 }
2001
2002 namespace {
2003
2004 void SnapHor( const ScDocument& rDoc, SCTAB nTab, long& rVal, SCCOL& rStartCol )
2005 {
2006     SCCOL nCol = 0;
2007     long nTwips = (long) (rVal / HMM_PER_TWIPS);
2008     long nSnap = 0;
2009     while ( nCol<MAXCOL )
2010     {
2011         long nAdd = rDoc.GetColWidth(nCol, nTab);
2012         if ( nSnap + nAdd/2 < nTwips || nCol < rStartCol )
2013         {
2014             nSnap += nAdd;
2015             ++nCol;
2016         }
2017         else
2018             break;
2019     }
2020     rVal = (long) ( nSnap * HMM_PER_TWIPS );
2021     rStartCol = nCol;
2022 }
2023
2024 void SnapVer( const ScDocument& rDoc, SCTAB nTab, long& rVal, SCROW& rStartRow )
2025 {
2026     SCROW nRow = 0;
2027     long nTwips = (long) (rVal / HMM_PER_TWIPS);
2028     long nSnap = 0;
2029
2030     bool bFound = false;
2031     for (SCROW i = nRow; i <= MAXROW; ++i)
2032     {
2033         SCROW nLastRow;
2034         if (rDoc.RowHidden(i, nTab, nullptr, &nLastRow))
2035         {
2036             i = nLastRow;
2037             continue;
2038         }
2039
2040         nRow = i;
2041         long nAdd = rDoc.GetRowHeight(i, nTab);
2042         if ( nSnap + nAdd/2 < nTwips || nRow < rStartRow )
2043         {
2044             nSnap += nAdd;
2045             ++nRow;
2046         }
2047         else
2048         {
2049             bFound = true;
2050             break;
2051         }
2052     }
2053     if (!bFound)
2054         nRow = MAXROW;  // all hidden down to the bottom
2055
2056     rVal = (long) ( nSnap * HMM_PER_TWIPS );
2057     rStartRow = nRow;
2058 }
2059
2060 }
2061
2062 void ScDocShell::SnapVisArea( Rectangle& rRect ) const
2063 {
2064     SCTAB nTab = aDocument.GetVisibleTab();
2065     bool bNegativePage = aDocument.IsNegativePage( nTab );
2066     if ( bNegativePage )
2067         ScDrawLayer::MirrorRectRTL( rRect );        // calculate with positive (LTR) values
2068
2069     SCCOL nCol = 0;
2070     SnapHor( aDocument, nTab, rRect.Left(), nCol );
2071     ++nCol;                                         // mindestens eine Spalte
2072     SnapHor( aDocument, nTab, rRect.Right(), nCol );
2073
2074     SCROW nRow = 0;
2075     SnapVer( aDocument, nTab, rRect.Top(), nRow );
2076     ++nRow;                                         // mindestens eine Zeile
2077     SnapVer( aDocument, nTab, rRect.Bottom(), nRow );
2078
2079     if ( bNegativePage )
2080         ScDrawLayer::MirrorRectRTL( rRect );        // back to real rectangle
2081 }
2082
2083 void ScDocShell::GetPageOnFromPageStyleSet( const SfxItemSet* pStyleSet,
2084                                             SCTAB             nCurTab,
2085                                             bool&             rbHeader,
2086                                             bool&             rbFooter )
2087 {
2088     if ( !pStyleSet )
2089     {
2090         ScStyleSheetPool*  pStylePool  = aDocument.GetStyleSheetPool();
2091         SfxStyleSheetBase* pStyleSheet = pStylePool->
2092                                             Find( aDocument.GetPageStyle( nCurTab ),
2093                                                   SfxStyleFamily::Page );
2094
2095         OSL_ENSURE( pStyleSheet, "PageStyle not found! :-/" );
2096
2097         if ( pStyleSheet )
2098             pStyleSet = &pStyleSheet->GetItemSet();
2099         else
2100             rbHeader = rbFooter = false;
2101     }
2102
2103     OSL_ENSURE( pStyleSet, "PageStyle-Set not found! :-(" );
2104     if (!pStyleSet)
2105         return;
2106
2107     const SvxSetItem*   pSetItem = nullptr;
2108     const SfxItemSet*   pSet     = nullptr;
2109
2110     pSetItem = static_cast<const SvxSetItem*>( &pStyleSet->Get( ATTR_PAGE_HEADERSET ) );
2111     pSet     = &pSetItem->GetItemSet();
2112     rbHeader = static_cast<const SfxBoolItem&>(pSet->Get(ATTR_PAGE_ON)).GetValue();
2113
2114     pSetItem = static_cast<const SvxSetItem*>( &pStyleSet->Get( ATTR_PAGE_FOOTERSET ) );
2115     pSet     = &pSetItem->GetItemSet();
2116     rbFooter = static_cast<const SfxBoolItem&>(pSet->Get(ATTR_PAGE_ON)).GetValue();
2117 }
2118
2119 #if defined(_WIN32)
2120 bool ScDocShell::DdeGetData( const OUString& rItem,
2121                              const OUString& rMimeType,
2122                              css::uno::Any & rValue )
2123 {
2124     if( SotClipboardFormatId::STRING == SotExchange::GetFormatIdFromMimeType( rMimeType ) )
2125     {
2126         if( rItem.equalsIgnoreAsciiCase( "Format" ) )
2127         {
2128             OString aFmtByte(OUStringToOString(aDdeTextFmt,
2129                 osl_getThreadTextEncoding()));
2130             rValue <<= css::uno::Sequence< sal_Int8 >(
2131                                         reinterpret_cast<const sal_Int8*>(aFmtByte.getStr()),
2132                                         aFmtByte.getLength() + 1 );
2133             return true;
2134         }
2135         ScImportExport aObj( &aDocument, rItem );
2136         if ( !aObj.IsRef() )
2137             return false;                           // ungueltiger Bereich
2138
2139         if( aDdeTextFmt[0] == 'F' )
2140             aObj.SetFormulas( true );
2141         if( aDdeTextFmt == "SYLK" ||
2142             aDdeTextFmt == "FSYLK" )
2143         {
2144             OString aData;
2145             if( aObj.ExportByteString( aData, osl_getThreadTextEncoding(),
2146                                         SotClipboardFormatId::SYLK ) )
2147             {
2148                 rValue <<= css::uno::Sequence< sal_Int8 >(
2149                                             reinterpret_cast<const sal_Int8*>(aData.getStr()),
2150                                             aData.getLength() + 1 );
2151                 return true;
2152             }
2153             else
2154                 return false;
2155         }
2156         if( aDdeTextFmt == "CSV" ||
2157             aDdeTextFmt == "FCSV" )
2158             aObj.SetSeparator( ',' );
2159         aObj.SetExportTextOptions( ScExportTextOptions( ScExportTextOptions::ToSpace, 0, false ) );
2160         return aObj.ExportData( rMimeType, rValue );
2161     }
2162
2163     ScImportExport aObj( &aDocument, rItem );
2164     aObj.SetExportTextOptions( ScExportTextOptions( ScExportTextOptions::ToSpace, 0, false ) );
2165     return aObj.IsRef() && aObj.ExportData( rMimeType, rValue );
2166 }
2167
2168 bool ScDocShell::DdeSetData( const OUString& rItem,
2169                              const OUString& rMimeType,
2170                              const css::uno::Any & rValue )
2171 {
2172     if( SotClipboardFormatId::STRING == SotExchange::GetFormatIdFromMimeType( rMimeType ))
2173     {
2174         if( rItem.equalsIgnoreAsciiCase( "Format" ) )
2175         {
2176             if ( ScByteSequenceToString::GetString( aDdeTextFmt, rValue, osl_getThreadTextEncoding() ) )
2177             {
2178                 aDdeTextFmt = aDdeTextFmt.toAsciiUpperCase();
2179                 return true;
2180             }
2181             return false;
2182         }
2183         ScImportExport aObj( &aDocument, rItem );
2184         if( aDdeTextFmt[0] == 'F' )
2185             aObj.SetFormulas( true );
2186         if( aDdeTextFmt == "SYLK" ||
2187             aDdeTextFmt == "FSYLK" )
2188         {
2189             OUString aData;
2190             if ( ScByteSequenceToString::GetString( aData, rValue, osl_getThreadTextEncoding() ) )
2191             {
2192                 return aObj.ImportString( aData, SotClipboardFormatId::SYLK );
2193             }
2194             return false;
2195         }
2196         if( aDdeTextFmt == "CSV" ||
2197             aDdeTextFmt == "FCSV" )
2198             aObj.SetSeparator( ',' );
2199         return aObj.ImportData( rMimeType, rValue );
2200     }
2201     ScImportExport aObj( &aDocument, rItem );
2202     return aObj.IsRef() && aObj.ImportData( rMimeType, rValue );
2203 }
2204 #endif
2205
2206 ::sfx2::SvLinkSource* ScDocShell::DdeCreateLinkSource( const OUString& rItem )
2207 {
2208     //  only check for valid item string - range is parsed again in ScServerObject ctor
2209
2210     //  named range?
2211     OUString aPos = rItem;
2212     ScRangeName* pRange = aDocument.GetRangeName();
2213     if( pRange )
2214     {
2215         const ScRangeData* pData = pRange->findByUpperName(ScGlobal::pCharClass->uppercase(aPos));
2216         if (pData)
2217         {
2218             if( pData->HasType( ScRangeData::Type::RefArea    )
2219                 || pData->HasType( ScRangeData::Type::AbsArea )
2220                 || pData->HasType( ScRangeData::Type::AbsPos  ) )
2221                 pData->GetSymbol( aPos );           // continue with the name's contents
2222         }
2223     }
2224
2225     // Address in DDE function must be always parsed as CONV_OOO so that it
2226     // would always work regardless of current address conversion.  We do this
2227     // because the address item in a DDE entry is *not* normalized when saved
2228     // into ODF.
2229     ScRange aRange;
2230     bool bValid = ( (aRange.Parse(aPos, &aDocument, formula::FormulaGrammar::CONV_OOO ) & ScRefFlags::VALID) ||
2231                     (aRange.aStart.Parse(aPos, &aDocument, formula::FormulaGrammar::CONV_OOO) & ScRefFlags::VALID) );
2232
2233     ScServerObject* pObj = nullptr;            // NULL = error
2234     if ( bValid )
2235         pObj = new ScServerObject( this, rItem );
2236
2237     //  GetLinkManager()->InsertServer() is in the ScServerObject ctor
2238
2239     return pObj;
2240 }
2241
2242 ScViewData* ScDocShell::GetViewData()
2243 {
2244     SfxViewShell* pCur = SfxViewShell::Current();
2245     ScTabViewShell* pViewSh = dynamic_cast< ScTabViewShell *>( pCur );
2246     return pViewSh ? &pViewSh->GetViewData() : nullptr;
2247 }
2248
2249 SCTAB ScDocShell::GetCurTab()
2250 {
2251     //! this must be made non-static and use a ViewShell from this document!
2252
2253     ScViewData* pViewData = GetViewData();
2254
2255     return pViewData ? pViewData->GetTabNo() : static_cast<SCTAB>(0);
2256 }
2257
2258 ScTabViewShell* ScDocShell::GetBestViewShell( bool bOnlyVisible )
2259 {
2260     ScTabViewShell* pViewSh = ScTabViewShell::GetActiveViewShell();
2261     // falsches Doc?
2262     if( pViewSh && pViewSh->GetViewData().GetDocShell() != this )
2263         pViewSh = nullptr;
2264     if( !pViewSh )
2265     {
2266         // 1. ViewShell suchen
2267         SfxViewFrame* pFrame = SfxViewFrame::GetFirst( this, bOnlyVisible );
2268         if( pFrame )
2269         {
2270             SfxViewShell* p = pFrame->GetViewShell();
2271             pViewSh = dynamic_cast< ScTabViewShell *>( p );
2272         }
2273     }
2274     return pViewSh;
2275 }
2276
2277 SfxBindings* ScDocShell::GetViewBindings()
2278 {
2279     //  used to invalidate slots after changes to this document
2280
2281     SfxViewShell* pViewSh = GetBestViewShell();
2282     if (pViewSh)
2283         return &pViewSh->GetViewFrame()->GetBindings();
2284     else
2285         return nullptr;
2286 }
2287
2288 ScDocShell* ScDocShell::GetShellByNum( sal_uInt16 nDocNo )      // static
2289 {
2290     ScDocShell* pFound = nullptr;
2291     SfxObjectShell* pShell = SfxObjectShell::GetFirst();
2292     sal_uInt16 nShellCnt = 0;
2293
2294     while ( pShell && !pFound )
2295     {
2296         if ( dynamic_cast<const ScDocShell*>(pShell) != nullptr )
2297         {
2298             if ( nShellCnt == nDocNo )
2299                 pFound = static_cast<ScDocShell*>(pShell);
2300             else
2301                 ++nShellCnt;
2302         }
2303         pShell = SfxObjectShell::GetNext( *pShell );
2304     }
2305
2306     return pFound;
2307 }
2308
2309 IMPL_LINK_TYPED( ScDocShell, DialogClosedHdl, sfx2::FileDialogHelper*, _pFileDlg, void )
2310 {
2311     OSL_ENSURE( _pFileDlg, "ScDocShell::DialogClosedHdl(): no file dialog" );
2312     OSL_ENSURE( pImpl->pDocInserter, "ScDocShell::DialogClosedHdl(): no document inserter" );
2313
2314     if ( ERRCODE_NONE == _pFileDlg->GetError() )
2315     {
2316         sal_uInt16 nSlot = pImpl->pRequest->GetSlot();
2317         SfxMedium* pMed = pImpl->pDocInserter->CreateMedium();
2318         // #i87094# If a .odt was selected pMed is NULL.
2319         if (pMed)
2320         {
2321             pImpl->pRequest->AppendItem( SfxStringItem( SID_FILE_NAME, pMed->GetName() ) );
2322             if ( SID_DOCUMENT_COMPARE == nSlot )
2323             {
2324                 if ( pMed->GetFilter() )
2325                     pImpl->pRequest->AppendItem(
2326                             SfxStringItem( SID_FILTER_NAME, pMed->GetFilter()->GetFilterName() ) );
2327                 OUString sOptions = ScDocumentLoader::GetOptions( *pMed );
2328                 if ( !sOptions.isEmpty() )
2329                     pImpl->pRequest->AppendItem( SfxStringItem( SID_FILE_FILTEROPTIONS, sOptions ) );
2330             }
2331             const SfxPoolItem* pItem = nullptr;
2332             const SfxInt16Item* pInt16Item(nullptr);
2333             SfxItemSet* pSet = pMed->GetItemSet();
2334             if (pSet && pSet->GetItemState(SID_VERSION, true, &pItem) == SfxItemState::SET)
2335             {
2336                 pInt16Item = dynamic_cast<const SfxInt16Item*>(pItem);
2337             }
2338             if (pInt16Item)
2339             {
2340                 pImpl->pRequest->AppendItem( *pItem );
2341             }
2342
2343             Execute( *(pImpl->pRequest) );
2344         }
2345     }
2346
2347     pImpl->bIgnoreLostRedliningWarning = false;
2348 }
2349
2350 #if HAVE_FEATURE_MULTIUSER_ENVIRONMENT
2351
2352 void ScDocShell::EnableSharedSettings( bool bEnable )
2353 {
2354     SetDocumentModified();
2355
2356     if ( bEnable )
2357     {
2358         aDocument.EndChangeTracking();
2359         aDocument.StartChangeTracking();
2360
2361         // hide accept or reject changes dialog
2362         sal_uInt16 nId = ScAcceptChgDlgWrapper::GetChildWindowId();
2363         SfxViewFrame* pViewFrame = SfxViewFrame::Current();
2364         if ( pViewFrame && pViewFrame->HasChildWindow( nId ) )
2365         {
2366             pViewFrame->ToggleChildWindow( nId );
2367             SfxBindings* pBindings = GetViewBindings();
2368             if ( pBindings )
2369             {
2370                 pBindings->Invalidate( FID_CHG_ACCEPT );
2371             }
2372         }
2373     }
2374     else
2375     {
2376         aDocument.EndChangeTracking();
2377     }
2378
2379     ScChangeViewSettings aChangeViewSet;
2380     aChangeViewSet.SetShowChanges( false );
2381     aDocument.SetChangeViewSettings( aChangeViewSet );
2382 }
2383
2384 uno::Reference< frame::XModel > ScDocShell::LoadSharedDocument()
2385 {
2386     uno::Reference< frame::XModel > xModel;
2387     try
2388     {
2389         SC_MOD()->SetInSharedDocLoading( true );
2390         uno::Reference< frame::XDesktop2 > xLoader = frame::Desktop::create( ::comphelper::getProcessComponentContext() );
2391         uno::Sequence < beans::PropertyValue > aArgs( 1 );
2392         aArgs[0].Name = "Hidden";
2393         aArgs[0].Value <<= true;
2394
2395         if ( GetMedium() )
2396         {
2397             const SfxStringItem* pPasswordItem = SfxItemSet::GetItem<SfxStringItem>(GetMedium()->GetItemSet(), SID_PASSWORD, false);
2398             if ( pPasswordItem && !pPasswordItem->GetValue().isEmpty() )
2399             {
2400                 aArgs.realloc( 2 );
2401                 aArgs[1].Name = "Password";
2402                 aArgs[1].Value <<= pPasswordItem->GetValue();
2403             }
2404         }
2405
2406         xModel.set(
2407             xLoader->loadComponentFromURL( GetSharedFileURL(), "_blank", 0, aArgs ),
2408             uno::UNO_QUERY_THROW );
2409         SC_MOD()->SetInSharedDocLoading( false );
2410     }
2411     catch ( uno::Exception& )
2412     {
2413         OSL_FAIL( "ScDocShell::LoadSharedDocument(): caught exception\n" );
2414         SC_MOD()->SetInSharedDocLoading( false );
2415         try
2416         {
2417             uno::Reference< util::XCloseable > xClose( xModel, uno::UNO_QUERY_THROW );
2418             xClose->close( true );
2419             return uno::Reference< frame::XModel >();
2420         }
2421         catch ( uno::Exception& )
2422         {
2423             return uno::Reference< frame::XModel >();
2424         }
2425     }
2426     return xModel;
2427 }
2428
2429 #endif
2430
2431 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */