sfx2/source/control/shell.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <com/sun/star/embed/VerbDescriptor.hpp>
  21 #include <com/sun/star/embed/VerbAttributes.hpp>
  22 #include <officecfg/Office/Common.hxx>
  23 #include <rtl/ustring.hxx>
  24 #include <sal/log.hxx>
  25 #include <osl/diagnose.h>
  26 #include <svl/itempool.hxx>
  27 #include <svl/undo.hxx>
  28 #include <itemdel.hxx>
  29 #include <svtools/asynclink.hxx>
  30 #include <unotools/configmgr.hxx>
  31 #include <comphelper/lok.hxx>
  32 #include <sfx2/shell.hxx>
  33 #include <sfx2/bindings.hxx>
  34 #include <sfx2/dispatch.hxx>
  35 #include <sfx2/viewfrm.hxx>
  36 #include <sfx2/objface.hxx>
  37 #include <sfx2/objsh.hxx>
  38 #include <sfx2/viewsh.hxx>
  39 #include <sfx2/request.hxx>
  40 #include <sfx2/sfxsids.hrc>
  41 #include <statcach.hxx>
  42 #include <sidebar/ContextChangeBroadcaster.hxx>
  43 #include <com/sun/star/ui/dialogs/XSLTFilterDialog.hpp>
  44 #include <tools/debug.hxx>
  45
  46 #include <memory>
  47 #include <vector>
  48 #include <map>
  49
  50 using namespace com::sun::star;
  51
  52 struct SfxShell_Impl: public SfxBroadcaster
  53 {
  54     OUString                    aObjectName;   // Name of Sbx-Objects
  55     // Maps the Which() field to a pointer to a SfxPoolItem
  56     std::map<sal_uInt16, std::unique_ptr<SfxPoolItem>>
  57                                 m_Items;       // Data exchange on Item level
  58     SfxViewShell*               pViewSh;       // SfxViewShell if Shell is
  59                                                // ViewFrame/ViewShell/SubShell list
  60     SfxViewFrame*               pFrame;        // Frame, if  <UI-active>
  61     SfxRepeatTarget*            pRepeatTarget; // SbxObjectRef xParent;
  62     bool                        bActive;
  63     SfxDisableFlags             nDisableFlags;
  64     std::unique_ptr<svtools::AsynchronLink> pExecuter;
  65     std::unique_ptr<svtools::AsynchronLink> pUpdater;
  66     std::vector<std::unique_ptr<SfxSlot> >  aSlotArr;
  67
  68     css::uno::Sequence < css::embed::VerbDescriptor > aVerbList;
  69     ::sfx2::sidebar::ContextChangeBroadcaster maContextChangeBroadcaster;
  70
  71     SfxShell_Impl()
  72         : pViewSh(nullptr)
  73         , pFrame(nullptr)
  74         , pRepeatTarget(nullptr)
  75         , bActive(false)
  76         , nDisableFlags(SfxDisableFlags::NONE)
  77     {
  78     }
  79
  80     virtual ~SfxShell_Impl() override { pExecuter.reset(); pUpdater.reset();}
  81 };
  82
  83
  84 void SfxShell::EmptyExecStub(SfxShell *, SfxRequest &)
  85 {
  86 }
  87
  88 void SfxShell::EmptyStateStub(SfxShell *, SfxItemSet &)
  89 {
  90 }
  91
  92 SfxShell::SfxShell()
  93 :   pImpl(new SfxShell_Impl),
  94     pPool(nullptr),
  95     pUndoMgr(nullptr)
  96 {
  97 }
  98
  99 SfxShell::SfxShell( SfxViewShell *pViewSh )
 100 :   pImpl(new SfxShell_Impl),
 101     pPool(nullptr),
 102     pUndoMgr(nullptr)
 103 {
 104     pImpl->pViewSh = pViewSh;
 105 }
 106
 107 SfxShell::~SfxShell()
 108 {
 109 }
 110
 111 void SfxShell::SetName( const OUString &rName )
 112 {
 113     pImpl->aObjectName = rName;
 114 }
 115
 116 const OUString& SfxShell::GetName() const
 117 {
 118     return pImpl->aObjectName;
 119 }
 120
 121 SfxDispatcher* SfxShell::GetDispatcher() const
 122 {
 123     return pImpl->pFrame ? pImpl->pFrame->GetDispatcher() : nullptr;
 124 }
 125
 126 SfxViewShell* SfxShell::GetViewShell() const
 127 {
 128     return pImpl->pViewSh;
 129 }
 130
 131 SfxViewFrame* SfxShell::GetFrame() const
 132 {
 133     if ( pImpl->pFrame )
 134         return pImpl->pFrame;
 135     if ( pImpl->pViewSh )
 136         return pImpl->pViewSh->GetViewFrame();
 137     return nullptr;
 138 }
 139
 140 const SfxPoolItem* SfxShell::GetItem
 141 (
 142     sal_uInt16  nSlotId         // Slot-Id of the querying <SfxPoolItem>s
 143 )   const
 144 {
 145     auto const it = pImpl->m_Items.find( nSlotId );
 146     if (it != pImpl->m_Items.end())
 147         return it->second.get();
 148     return nullptr;
 149 }
 150
 151 void SfxShell::PutItem
 152 (
 153     const SfxPoolItem&  rItem  /* Instance, of which a copy is created,
 154                                   which is stored in the SfxShell in a list. */
 155 )
 156 {
 157     DBG_ASSERT( dynamic_cast< const SfxSetItem* >( &rItem) ==  nullptr, "SetItems aren't allowed here" );
 158     DBG_ASSERT( SfxItemPool::IsSlot( rItem.Which() ),
 159                 "items with Which-Ids aren't allowed here" );
 160
 161     // MSC made a mess here of WNT/W95, beware of changes
 162     SfxPoolItem *pItem = rItem.Clone();
 163     SfxPoolItemHint aItemHint( pItem );
 164     sal_uInt16 nWhich = rItem.Which();
 165
 166     auto const it = pImpl->m_Items.find(nWhich);
 167     if (it != pImpl->m_Items.end())
 168     {
 169         // Replace Item
 170         pImpl->m_Items.erase( it );
 171         pImpl->m_Items.insert(std::make_pair(nWhich, std::unique_ptr<SfxPoolItem>(pItem)));
 172
 173         // if active, notify Bindings
 174         SfxDispatcher *pDispat = GetDispatcher();
 175         if ( pDispat )
 176         {
 177             SfxBindings* pBindings = pDispat->GetBindings();
 178             pBindings->Broadcast( aItemHint );
 179             sal_uInt16 nSlotId = nWhich; //pItem->GetSlotId();
 180             SfxStateCache* pCache = pBindings->GetStateCache( nSlotId );
 181             if ( pCache )
 182             {
 183                 pCache->SetState( SfxItemState::DEFAULT, pItem, true );
 184                 pCache->SetCachedState( true );
 185             }
 186         }
 187         return;
 188     }
 189     else
 190     {
 191         Broadcast( aItemHint );
 192         pImpl->m_Items.insert(std::make_pair(nWhich, std::unique_ptr<SfxPoolItem>(pItem)));
 193     }
 194 }
 195
 196 SfxInterface* SfxShell::GetInterface() const
 197 {
 198     return GetStaticInterface();
 199 }
 200
 201 SfxUndoManager* SfxShell::GetUndoManager()
 202 {
 203     return pUndoMgr;
 204 }
 205
 206 void SfxShell::SetUndoManager( SfxUndoManager *pNewUndoMgr )
 207 {
 208     OSL_ENSURE( ( pUndoMgr == nullptr ) || ( pNewUndoMgr == nullptr ) || ( pUndoMgr == pNewUndoMgr ),
 209         "SfxShell::SetUndoManager: exchanging one non-NULL manager with another non-NULL manager? Suspicious!" );
 210     // there's at least one client of our UndoManager - the DocumentUndoManager at the SfxBaseModel - which
 211     // caches the UndoManager, and registers itself as listener. If exchanging non-NULL UndoManagers is really
 212     // a supported scenario (/me thinks it is not), then we would need to notify all such clients instances.
 213
 214     pUndoMgr = pNewUndoMgr;
 215     if (pUndoMgr && !utl::ConfigManager::IsFuzzing())
 216     {
 217         pUndoMgr->SetMaxUndoActionCount(
 218             officecfg::Office::Common::Undo::Steps::get());
 219     }
 220 }
 221
 222 SfxRepeatTarget* SfxShell::GetRepeatTarget() const
 223 {
 224     return pImpl->pRepeatTarget;
 225 }
 226
 227 void SfxShell::SetRepeatTarget( SfxRepeatTarget *pTarget )
 228 {
 229     pImpl->pRepeatTarget = pTarget;
 230 }
 231
 232 void SfxShell::Invalidate
 233 (
 234     sal_uInt16          nId     /* Invalidated Slot-Id or Which-Id.
 235                                If these are 0 (default), then all
 236                                by this Shell currently handled Slot-Ids are
 237                                invalidated. */
 238 )
 239 {
 240     if ( !GetViewShell() )
 241     {
 242         OSL_FAIL( "wrong Invalidate method called!" );
 243         return;
 244     }
 245
 246     Invalidate_Impl( GetViewShell()->GetViewFrame()->GetBindings(), nId );
 247 }
 248
 249 void SfxShell::Invalidate_Impl( SfxBindings& rBindings, sal_uInt16 nId )
 250 {
 251     if ( nId == 0 )
 252     {
 253         rBindings.InvalidateShell( *this );
 254     }
 255     else
 256     {
 257         const SfxInterface *pIF = GetInterface();
 258         do
 259         {
 260             const SfxSlot *pSlot = pIF->GetSlot(nId);
 261             if ( pSlot )
 262             {
 263                 // Invalidate the Slot itself
 264                 rBindings.Invalidate( pSlot->GetSlotId() );
 265                 return;
 266             }
 267
 268             pIF = pIF->GetGenoType();
 269         }
 270
 271         while ( pIF );
 272
 273         SAL_INFO( "sfx.control", "W3: invalidating slot-id unknown in shell" );
 274     }
 275 }
 276
 277 void SfxShell::HandleOpenXmlFilterSettings(SfxRequest & rReq)
 278 {
 279     try
 280     {
 281         uno::Reference < ui::dialogs::XExecutableDialog > xDialog = ui::dialogs::XSLTFilterDialog::create( ::comphelper::getProcessComponentContext() );
 282         xDialog->execute();
 283     }
 284     catch (const uno::Exception&)
 285     {
 286     }
 287     rReq.Ignore ();
 288 }
 289
 290 void SfxShell::DoActivate_Impl( SfxViewFrame *pFrame, bool bMDI )
 291 {
 292 #ifdef DBG_UTIL
 293     const SfxInterface *p_IF = GetInterface();
 294     if ( !p_IF )
 295         return;
 296 #endif
 297     SAL_INFO(
 298         "sfx.control",
 299         "SfxShell::DoActivate() " << this << "  " << GetInterface()->GetClassName()
 300             << " bMDI " << (bMDI ? "MDI" : ""));
 301
 302     if ( bMDI )
 303     {
 304         // Remember Frame, in which it was activated
 305         pImpl->pFrame = pFrame;
 306         pImpl->bActive = true;
 307     }
 308
 309     // Notify Subclass
 310     Activate(bMDI);
 311 }
 312
 313 void SfxShell::DoDeactivate_Impl( SfxViewFrame const *pFrame, bool bMDI )
 314 {
 315 #ifdef DBG_UTIL
 316     const SfxInterface *p_IF = GetInterface();
 317     if ( !p_IF )
 318         return;
 319 #endif
 320     SAL_INFO(
 321         "sfx.control",
 322         "SfxShell::DoDeactivate()" << this << "  " << GetInterface()->GetClassName()
 323             << " bMDI " << (bMDI ? "MDI" : ""));
 324
 325     // Only when it comes from a Frame
 326     // (not when for instance by popping BASIC-IDE from AppDisp)
 327     if ( bMDI && pImpl->pFrame == pFrame )
 328     {
 329         // deliver
 330         pImpl->pFrame = nullptr;
 331         pImpl->bActive = false;
 332     }
 333
 334     // Notify Subclass
 335     Deactivate(bMDI);
 336 }
 337
 338 bool SfxShell::IsActive() const
 339 {
 340     return pImpl->bActive;
 341 }
 342
 343 void SfxShell::Activate
 344 (
 345     bool    /*bMDI*/        /*  TRUE
 346                             the <SfxDispatcher>, on which the SfxShell is
 347                             located, is activated or the SfxShell instance
 348                             was pushed on an active SfxDispatcher.
 349                             (compare with SystemWindow::IsMDIActivate())
 350
 351                             FALSE
 352                             the <SfxViewFrame>, on which SfxDispatcher
 353                             the SfxShell instance is located, was
 354                             activated. (for example by a closing dialog) */
 355 )
 356 {
 357     BroadcastContextForActivation(true);
 358 }
 359
 360 void SfxShell::Deactivate
 361 (
 362     bool    /*bMDI*/        /*  TRUE
 363                             the <SfxDispatcher>, on which the SfxShell is
 364                             located, is inactivated or the SfxShell instance
 365                             was popped on an active SfxDispatcher.
 366                             (compare with SystemWindow::IsMDIActivate())
 367
 368                             FALSE
 369                             the <SfxViewFrame>, on which SfxDispatcher
 370                             the SfxShell instance is located, was
 371                             deactivated. (for example by a dialog) */
 372 )
 373 {
 374     BroadcastContextForActivation(false);
 375 }
 376
 377 bool SfxShell::CanExecuteSlot_Impl( const SfxSlot &rSlot )
 378 {
 379     // Get Slot status
 380     SfxItemPool &rPool = GetPool();
 381     const sal_uInt16 nId = rSlot.GetWhich( rPool );
 382     SfxItemSet aSet(rPool, {{nId, nId}});
 383     SfxStateFunc pFunc = rSlot.GetStateFnc();
 384     CallState( pFunc, aSet );
 385     return aSet.GetItemState(nId) != SfxItemState::DISABLED;
 386 }
 387
 388 bool SfxShell::IsConditionalFastCall( const SfxRequest &rReq )
 389 {
 390     sal_uInt16 nId = rReq.GetSlot();
 391     bool bRet = false;
 392
 393     if (nId == SID_UNDO || nId == SID_REDO)
 394     {
 395         const SfxItemSet* pArgs = rReq.GetArgs();
 396         if (pArgs && pArgs->HasItem(SID_REPAIRPACKAGE))
 397             bRet = true;
 398     }
 399     return bRet;
 400 }
 401
 402
 403 static void ShellCall_Impl( void* pObj, void* pArg )
 404 {
 405     static_cast<SfxShell*>(pObj)->ExecuteSlot( *static_cast<SfxRequest*>(pArg) );
 406 }
 407
 408 void SfxShell::ExecuteSlot( SfxRequest& rReq, bool bAsync )
 409 {
 410     if( !bAsync )
 411         ExecuteSlot( rReq );
 412     else
 413     {
 414         if( !pImpl->pExecuter )
 415             pImpl->pExecuter.reset( new svtools::AsynchronLink(
 416                 Link<void*,void>( this, ShellCall_Impl ) ) );
 417         pImpl->pExecuter->Call( new SfxRequest( rReq ) );
 418     }
 419 }
 420
 421 const SfxPoolItem* SfxShell::ExecuteSlot
 422 (
 423     SfxRequest          &rReq,  // the relayed <SfxRequest>
 424     const SfxInterface* pIF     // default = 0 means get virtually
 425 )
 426 {
 427     if ( !pIF )
 428         pIF = GetInterface();
 429
 430     sal_uInt16 nSlot = rReq.GetSlot();
 431     const SfxSlot* pSlot = nullptr;
 432     if ( nSlot >= SID_VERB_START && nSlot <= SID_VERB_END )
 433         pSlot = GetVerbSlot_Impl(nSlot);
 434     if ( !pSlot )
 435         pSlot = pIF->GetSlot(nSlot);
 436     DBG_ASSERT( pSlot, "slot not supported" );
 437
 438     SfxExecFunc pFunc = pSlot->GetExecFnc();
 439     if ( pFunc )
 440         CallExec( pFunc, rReq );
 441
 442     return rReq.GetReturnValue();
 443 }
 444
 445 const SfxPoolItem* SfxShell::GetSlotState
 446 (
 447     sal_uInt16              nSlotId,    // Slot-Id to the Slots in question
 448     const SfxInterface* pIF,        // default = 0 means get virtually
 449     SfxItemSet*         pStateSet   // SfxItemSet of the Slot-State method
 450 )
 451 {
 452     // Get Slot on the given Interface
 453     if ( !pIF )
 454         pIF = GetInterface();
 455     SfxItemState eState = SfxItemState::UNKNOWN;
 456     SfxItemPool &rPool = GetPool();
 457
 458     const SfxSlot* pSlot = nullptr;
 459     if ( nSlotId >= SID_VERB_START && nSlotId <= SID_VERB_END )
 460         pSlot = GetVerbSlot_Impl(nSlotId);
 461     if ( !pSlot )
 462         pSlot = pIF->GetSlot(nSlotId);
 463     if ( pSlot )
 464         // Map on Which-Id if possible
 465         nSlotId = pSlot->GetWhich( rPool );
 466
 467     // Get Item and Item status
 468     const SfxPoolItem *pItem = nullptr;
 469     SfxItemSet aSet( rPool, {{nSlotId, nSlotId}} ); // else pItem dies too soon
 470     if ( pSlot )
 471     {
 472         // Call Status method
 473         SfxStateFunc pFunc = pSlot->GetStateFnc();
 474         if ( pFunc )
 475             CallState( pFunc, aSet );
 476         eState = aSet.GetItemState( nSlotId, true, &pItem );
 477
 478         // get default Item if possible
 479         if ( eState == SfxItemState::DEFAULT )
 480         {
 481             if ( SfxItemPool::IsWhich(nSlotId) )
 482                 pItem = &rPool.GetDefaultItem(nSlotId);
 483             else
 484                 eState = SfxItemState::DONTCARE;
 485         }
 486     }
 487     else
 488         eState = SfxItemState::UNKNOWN;
 489
 490     // Evaluate Item and item status and possibly maintain them in pStateSet
 491     std::unique_ptr<SfxPoolItem> pRetItem;
 492     if ( eState <= SfxItemState::DISABLED )
 493     {
 494         if ( pStateSet )
 495             pStateSet->DisableItem(nSlotId);
 496         return nullptr;
 497     }
 498     else if ( eState == SfxItemState::DONTCARE )
 499     {
 500         if ( pStateSet )
 501             pStateSet->ClearItem(nSlotId);
 502         pRetItem.reset( new SfxVoidItem(0) );
 503     }
 504     else
 505     {
 506         if ( pStateSet && pStateSet->Put( *pItem ) )
 507             return &pStateSet->Get( pItem->Which() );
 508         pRetItem.reset(pItem->Clone());
 509     }
 510     auto pTemp = pRetItem.get();
 511     DeleteItemOnIdle(std::move(pRetItem));
 512
 513     return pTemp;
 514 }
 515
 516 static SFX_EXEC_STUB(SfxShell, VerbExec)
 517 static void SfxStubSfxShellVerbState(SfxShell *, SfxItemSet& rSet)
 518 {
 519     SfxShell::VerbState( rSet );
 520 }
 521
 522 void SfxShell::SetVerbs(const css::uno::Sequence < css::embed::VerbDescriptor >& aVerbs)
 523 {
 524     SfxViewShell *pViewSh = dynamic_cast<SfxViewShell*>( this );
 525
 526     DBG_ASSERT(pViewSh, "Only call SetVerbs at the ViewShell!");
 527     if ( !pViewSh )
 528         return;
 529
 530     // First make all Statecaches dirty, so that no-one no longer tries to use
 531     // the Slots
 532     {
 533         SfxBindings *pBindings =
 534             pViewSh->GetViewFrame()->GetDispatcher()->GetBindings();
 535         sal_uInt16 nCount = pImpl->aSlotArr.size();
 536         for (sal_uInt16 n1=0; n1<nCount ; n1++)
 537         {
 538             sal_uInt16 nId = SID_VERB_START + n1;
 539             pBindings->Invalidate(nId, false, true);
 540         }
 541     }
 542
 543     sal_uInt16 nr=0;
 544     for (sal_Int32 n=0; n<aVerbs.getLength(); n++)
 545     {
 546         sal_uInt16 nSlotId = SID_VERB_START + nr++;
 547         DBG_ASSERT(nSlotId <= SID_VERB_END, "Too many Verbs!");
 548         if (nSlotId > SID_VERB_END)
 549             break;
 550
 551         SfxSlot *pNewSlot = new SfxSlot;
 552         pNewSlot->nSlotId = nSlotId;
 553         pNewSlot->nGroupId = SfxGroupId::NONE;
 554
 555         // Verb slots must be executed asynchronously, so that they can be
 556         // destroyed while executing.
 557         pNewSlot->nFlags = SfxSlotMode::ASYNCHRON | SfxSlotMode::CONTAINER;
 558         pNewSlot->nMasterSlotId = 0;
 559         pNewSlot->nValue = 0;
 560         pNewSlot->fnExec = SFX_STUB_PTR(SfxShell,VerbExec);
 561         pNewSlot->fnState = SFX_STUB_PTR(SfxShell,VerbState);
 562         pNewSlot->pType = nullptr; // HACK(SFX_TYPE(SfxVoidItem)) ???
 563         pNewSlot->nArgDefCount = 0;
 564         pNewSlot->pFirstArgDef = nullptr;
 565         pNewSlot->pUnoName = nullptr;
 566
 567         if (!pImpl->aSlotArr.empty())
 568         {
 569             SfxSlot& rSlot = *pImpl->aSlotArr[0];
 570             pNewSlot->pNextSlot = rSlot.pNextSlot;
 571             rSlot.pNextSlot = pNewSlot;
 572         }
 573         else
 574             pNewSlot->pNextSlot = pNewSlot;
 575
 576         pImpl->aSlotArr.insert(pImpl->aSlotArr.begin() + static_cast<sal_uInt16>(n), std::unique_ptr<SfxSlot>(pNewSlot));
 577     }
 578
 579     pImpl->aVerbList = aVerbs;
 580
 581     // The status of SID_OBJECT is collected in the controller directly on
 582     // the Shell, it is thus enough to encourage a new status update
 583     SfxBindings* pBindings = pViewSh->GetViewFrame()->GetDispatcher()->GetBindings();
 584     pBindings->Invalidate(SID_OBJECT, true, true);
 585 }
 586
 587 const css::uno::Sequence < css::embed::VerbDescriptor >& SfxShell::GetVerbs() const
 588 {
 589     return pImpl->aVerbList;
 590 }
 591
 592 void SfxShell::VerbExec(SfxRequest& rReq)
 593 {
 594     sal_uInt16 nId = rReq.GetSlot();
 595     SfxViewShell *pViewShell = GetViewShell();
 596     if ( !pViewShell )
 597         return;
 598
 599     bool bReadOnly = pViewShell->GetObjectShell()->IsReadOnly();
 600     const css::uno::Sequence < css::embed::VerbDescriptor > aList = pViewShell->GetVerbs();
 601     sal_Int32 nVerb = 0;
 602     for (const auto& rVerb : aList)
 603     {
 604         // check for ReadOnly verbs
 605         if ( bReadOnly && !(rVerb.VerbAttributes & embed::VerbAttributes::MS_VERBATTR_NEVERDIRTIES) )
 606             continue;
 607
 608         // check for verbs that shouldn't appear in the menu
 609         if ( !(rVerb.VerbAttributes & embed::VerbAttributes::MS_VERBATTR_ONCONTAINERMENU) )
 610             continue;
 611
 612         if (nId == SID_VERB_START + nVerb++)
 613         {
 614             pViewShell->DoVerb(rVerb.VerbID);
 615             rReq.Done();
 616             return;
 617         }
 618     }
 619 }
 620
 621 void SfxShell::VerbState(SfxItemSet& )
 622 {
 623 }
 624
 625 const SfxSlot* SfxShell::GetVerbSlot_Impl(sal_uInt16 nId) const
 626 {
 627     css::uno::Sequence < css::embed::VerbDescriptor > rList = pImpl->aVerbList;
 628
 629     DBG_ASSERT(nId >= SID_VERB_START && nId <= SID_VERB_END,"Wrong VerbId!");
 630     sal_uInt16 nIndex = nId - SID_VERB_START;
 631     DBG_ASSERT(nIndex < rList.getLength(),"Wrong VerbId!");
 632
 633     if (nIndex < rList.getLength())
 634         return pImpl->aSlotArr[nIndex].get();
 635     else
 636         return nullptr;
 637 }
 638
 639 SfxObjectShell* SfxShell::GetObjectShell()
 640 {
 641     if ( GetViewShell() )
 642         return GetViewShell()->GetViewFrame()->GetObjectShell();
 643     else
 644         return nullptr;
 645 }
 646
 647 bool SfxShell::HasUIFeature(SfxShellFeature) const
 648 {
 649     return false;
 650 }
 651
 652 static void DispatcherUpdate_Impl( void*, void* pArg )
 653 {
 654     static_cast<SfxDispatcher*>(pArg)->Update_Impl( true );
 655     static_cast<SfxDispatcher*>(pArg)->GetBindings()->InvalidateAll(false);
 656 }
 657
 658 void SfxShell::UIFeatureChanged()
 659 {
 660     SfxViewFrame *pFrame = GetFrame();
 661     if ( pFrame && pFrame->IsVisible() )
 662     {
 663         // Also force an update, if dispatcher is already updated otherwise
 664         // something my get stuck in the bunkered tools. Asynchronous call to
 665         // prevent recursion.
 666         if ( !pImpl->pUpdater )
 667             pImpl->pUpdater.reset( new svtools::AsynchronLink( Link<void*,void>( this, DispatcherUpdate_Impl ) ) );
 668
 669         // Multiple views allowed
 670         pImpl->pUpdater->Call( pFrame->GetDispatcher(), true );
 671     }
 672 }
 673
 674 void SfxShell::SetDisableFlags( SfxDisableFlags nFlags )
 675 {
 676     pImpl->nDisableFlags = nFlags;
 677 }
 678
 679 SfxDisableFlags SfxShell::GetDisableFlags() const
 680 {
 681     return pImpl->nDisableFlags;
 682 }
 683
 684 std::unique_ptr<SfxItemSet> SfxShell::CreateItemSet( sal_uInt16 )
 685 {
 686     return nullptr;
 687 }
 688
 689 void SfxShell::ApplyItemSet( sal_uInt16, const SfxItemSet& )
 690 {
 691 }
 692
 693 void SfxShell::SetContextName (const OUString& rsContextName)
 694 {
 695     pImpl->maContextChangeBroadcaster.Initialize(rsContextName);
 696 }
 697
 698 void SfxShell::SetViewShell_Impl( SfxViewShell* pView )
 699 {
 700     pImpl->pViewSh = pView;
 701 }
 702
 703 void SfxShell::BroadcastContextForActivation (const bool bIsActivated)
 704 {
 705     // Avoids activation and de-activation (can be seen on switching view) from causing
 706     // the sidebar to re-build. Such switching can happen as we change view to render
 707     // using LOK for example, and is un-necessary for Online.
 708     if (comphelper::LibreOfficeKit::isDialogPainting())
 709         return;
 710
 711     SfxViewFrame* pViewFrame = GetFrame();
 712     if (pViewFrame != nullptr)
 713     {
 714         if (bIsActivated)
 715             pImpl->maContextChangeBroadcaster.Activate(pViewFrame->GetFrame().GetFrameInterface());
 716         else
 717             pImpl->maContextChangeBroadcaster.Deactivate(pViewFrame->GetFrame().GetFrameInterface());
 718    }
 719 }
 720
 721 bool SfxShell::SetContextBroadcasterEnabled (const bool bIsEnabled)
 722 {
 723     return pImpl->maContextChangeBroadcaster.SetBroadcasterEnabled(bIsEnabled);
 724 }
 725
 726 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */