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