sfx2/source/control/statcach.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
  21 #ifdef __sun
  22 #include <ctime>
  23 #endif
  24
  25 #include <framework/dispatchhelper.hxx>
  26 #include <com/sun/star/frame/DispatchResultState.hpp>
  27 #include <com/sun/star/frame/XFrame.hpp>
  28 #include <com/sun/star/beans/PropertyValue.hpp>
  29 #include <comphelper/servicehelper.hxx>
  30 #include <svl/eitem.hxx>
  31 #include <svl/intitem.hxx>
  32 #include <svl/stritem.hxx>
  33 #include <svl/visitem.hxx>
  34 #include <svl/voiditem.hxx>
  35
  36 #include <sfx2/app.hxx>
  37 #include <statcach.hxx>
  38 #include <sfx2/msg.hxx>
  39 #include <sfx2/ctrlitem.hxx>
  40 #include <sfx2/dispatch.hxx>
  41 #include <sfx2/sfxuno.hxx>
  42 #include <unoctitm.hxx>
  43 #include <sfx2/msgpool.hxx>
  44 #include <sfx2/viewfrm.hxx>
  45 #include <utility>
  46 #include <comphelper/diagnose_ex.hxx>
  47
  48 using namespace ::com::sun::star;
  49 using namespace ::com::sun::star::uno;
  50 using namespace ::com::sun::star::util;
  51
  52 BindDispatch_Impl::BindDispatch_Impl( css::uno::Reference< css::frame::XDispatch > _xDisp, css::util::URL _aURL, SfxStateCache *pStateCache, const SfxSlot* pS )
  53     : xDisp(std::move( _xDisp ))
  54     , aURL(std::move( _aURL ))
  55     , pCache( pStateCache )
  56     , pSlot( pS )
  57 {
  58     DBG_ASSERT( pCache && pSlot, "Invalid BindDispatch!");
  59     aStatus.IsEnabled = true;
  60 }
  61
  62 void SAL_CALL BindDispatch_Impl::disposing( const css::lang::EventObject& )
  63 {
  64     if ( xDisp.is() )
  65     {
  66         xDisp->removeStatusListener( static_cast<css::frame::XStatusListener*>(this), aURL );
  67         xDisp.clear();
  68     }
  69 }
  70
  71 void SAL_CALL  BindDispatch_Impl::statusChanged( const css::frame::FeatureStateEvent& rEvent )
  72 {
  73     aStatus = rEvent;
  74     if ( !pCache )
  75         return;
  76
  77     css::uno::Reference< css::frame::XStatusListener >  xKeepAlive(this);
  78     if ( aStatus.Requery )
  79         pCache->Invalidate( true );
  80     else
  81     {
  82         std::unique_ptr<SfxPoolItem> pItem;
  83         sal_uInt16 nId = pCache->GetId();
  84         SfxItemState eState = SfxItemState::DISABLED;
  85         if ( !aStatus.IsEnabled )
  86         {
  87             // default
  88         }
  89         else if (aStatus.State.hasValue())
  90         {
  91             eState = SfxItemState::DEFAULT;
  92             css::uno::Any aAny = aStatus.State;
  93
  94             const css::uno::Type& aType = aAny.getValueType();
  95             if ( aType == cppu::UnoType< bool >::get() )
  96             {
  97                 bool bTemp = false;
  98                 aAny >>= bTemp ;
  99                 pItem.reset( new SfxBoolItem( nId, bTemp ) );
 100             }
 101             else if ( aType == ::cppu::UnoType< ::cppu::UnoUnsignedShortType >::get() )
 102             {
 103                 sal_uInt16 nTemp = 0;
 104                 aAny >>= nTemp ;
 105                 pItem.reset( new SfxUInt16Item( nId, nTemp ) );
 106             }
 107             else if ( aType == cppu::UnoType<sal_uInt32>::get() )
 108             {
 109                 sal_uInt32 nTemp = 0;
 110                 aAny >>= nTemp ;
 111                 pItem.reset( new SfxUInt32Item( nId, nTemp ) );
 112             }
 113             else if ( aType == cppu::UnoType<OUString>::get() )
 114             {
 115                 OUString sTemp ;
 116                 aAny >>= sTemp ;
 117                 pItem.reset( new SfxStringItem( nId, sTemp ) );
 118             }
 119             else
 120             {
 121                 if ( pSlot )
 122                     pItem = pSlot->GetType()->CreateItem();
 123                 if ( pItem )
 124                 {
 125                     pItem->SetWhich( nId );
 126                     pItem->PutValue( aAny, 0 );
 127                 }
 128                 else
 129                     pItem.reset( new SfxVoidItem( nId ) );
 130             }
 131         }
 132         else
 133         {
 134             // DONTCARE status
 135             pItem.reset( new SfxVoidItem(0) );
 136             eState = SfxItemState::UNKNOWN;
 137         }
 138
 139         for ( SfxControllerItem *pCtrl = pCache->GetItemLink();
 140             pCtrl;
 141             pCtrl = pCtrl->GetItemLink() )
 142             pCtrl->StateChangedAtToolBoxControl( nId, eState, pItem.get() );
 143     }
 144 }
 145
 146 void BindDispatch_Impl::Release()
 147 {
 148     if ( xDisp.is() )
 149     {
 150         try
 151         {
 152             xDisp->removeStatusListener(static_cast<css::frame::XStatusListener*>(this), aURL);
 153         }
 154         catch (const lang::DisposedException&)
 155         {
 156             TOOLS_WARN_EXCEPTION("sfx", "BindDispatch_Impl::Release: xDisp is disposed: ");
 157         }
 158         xDisp.clear();
 159     }
 160     pCache = nullptr;
 161 }
 162
 163
 164 sal_Int16 BindDispatch_Impl::Dispatch( const css::uno::Sequence < css::beans::PropertyValue >& aProps, bool bForceSynchron )
 165 {
 166     sal_Int16 eRet = css::frame::DispatchResultState::DONTKNOW;
 167
 168     if ( xDisp.is() && aStatus.IsEnabled )
 169     {
 170         ::rtl::Reference< ::framework::DispatchHelper > xHelper( new ::framework::DispatchHelper(nullptr));
 171         css::uno::Any aResult = xHelper->executeDispatch(xDisp, aURL, bForceSynchron, aProps);
 172
 173         css::frame::DispatchResultEvent aEvent;
 174         aResult >>= aEvent;
 175
 176         eRet = aEvent.State;
 177     }
 178
 179     return eRet;
 180 }
 181
 182
 183 // This constructor for an invalid cache that is updated in the first request.
 184
 185 SfxStateCache::SfxStateCache( sal_uInt16 nFuncId ):
 186     nId(nFuncId),
 187     pInternalController(nullptr),
 188     pController(nullptr),
 189     pLastItem( nullptr ),
 190     eLastState( SfxItemState::UNKNOWN ),
 191     bItemVisible( true )
 192 {
 193     bCtrlDirty = true;
 194     bSlotDirty = true;
 195     bItemDirty = true;
 196 }
 197
 198
 199 // The Destructor checks by assertion, even if controllers are registered.
 200
 201 SfxStateCache::~SfxStateCache()
 202 {
 203     DBG_ASSERT( pController == nullptr && pInternalController == nullptr, "there are still Controllers registered" );
 204     if ( !IsInvalidItem(pLastItem) )
 205         delete pLastItem;
 206     if ( mxDispatch.is() )
 207         mxDispatch->Release();
 208 }
 209
 210
 211 // invalidates the cache (next request will force update)
 212 void SfxStateCache::Invalidate( bool bWithMsg )
 213 {
 214     bCtrlDirty = true;
 215     if ( bWithMsg )
 216     {
 217         bSlotDirty = true;
 218         aSlotServ.SetSlot( nullptr );
 219         if ( mxDispatch.is() )
 220             mxDispatch->Release();
 221         mxDispatch.clear();
 222     }
 223 }
 224
 225
 226 // gets the corresponding function from the dispatcher or the cache
 227
 228 const SfxSlotServer* SfxStateCache::GetSlotServer( SfxDispatcher &rDispat , const css::uno::Reference< css::frame::XDispatchProvider > & xProv )
 229 {
 230
 231     if ( bSlotDirty )
 232     {
 233         // get the SlotServer; we need it for internal controllers anyway, but also in most cases
 234         rDispat.FindServer_( nId, aSlotServ );
 235
 236         DBG_ASSERT( !mxDispatch.is(), "Old Dispatch not removed!" );
 237
 238         // we don't need to check the dispatch provider if we only have an internal controller
 239         if ( xProv.is() )
 240         {
 241             const SfxSlot* pSlot = aSlotServ.GetSlot();
 242             if ( !pSlot )
 243                 // get the slot - even if it is disabled on the dispatcher
 244                 pSlot = SfxSlotPool::GetSlotPool( rDispat.GetFrame() ).GetSlot( nId );
 245
 246             if ( !pSlot || pSlot->pUnoName.isEmpty() )
 247             {
 248                 bSlotDirty = false;
 249                 bCtrlDirty = true;
 250                 return aSlotServ.GetSlot()? &aSlotServ: nullptr;
 251             }
 252
 253             // create the dispatch URL from the slot data
 254             css::util::URL aURL;
 255             OUString aCmd = ".uno:";
 256             aURL.Protocol = aCmd;
 257             aURL.Path = pSlot->GetUnoName();
 258             aCmd += aURL.Path;
 259             aURL.Complete = aCmd;
 260             aURL.Main = aCmd;
 261
 262             // try to get a dispatch object for this command
 263             css::uno::Reference< css::frame::XDispatch >  xDisp = xProv->queryDispatch( aURL, OUString(), 0 );
 264             if ( xDisp.is() )
 265             {
 266                 // test the dispatch object if it is just a wrapper for a SfxDispatcher
 267                 if (auto pDisp = dynamic_cast<SfxOfficeDispatch*>(xDisp.get()))
 268                 {
 269                     // The intercepting object is an SFX component
 270                     // If this dispatch object does not use the wanted dispatcher or the AppDispatcher, it's treated like any other UNO component
 271                     // (intercepting by internal dispatches)
 272                     SfxDispatcher *pDispatcher = pDisp->GetDispatcher_Impl();
 273                     if ( pDispatcher == &rDispat || pDispatcher == SfxGetpApp()->GetAppDispatcher_Impl() )
 274                     {
 275                         // so we can use it directly
 276                         bSlotDirty = false;
 277                         bCtrlDirty = true;
 278                         return aSlotServ.GetSlot()? &aSlotServ: nullptr;
 279                     }
 280                 }
 281
 282                 // so the dispatch object isn't a SfxDispatcher wrapper or it is one, but it uses another dispatcher, but not rDispat
 283                 mxDispatch = new BindDispatch_Impl( xDisp, aURL, this, pSlot );
 284
 285                 // flags must be set before adding StatusListener because the dispatch object will set the state
 286                 bSlotDirty = false;
 287                 bCtrlDirty = true;
 288                 xDisp->addStatusListener( mxDispatch, aURL );
 289             }
 290             else if ( rDispat.GetFrame() )
 291             {
 292                 css::uno::Reference < css::frame::XDispatchProvider > xFrameProv(
 293                         rDispat.GetFrame()->GetFrame().GetFrameInterface(), css::uno::UNO_QUERY );
 294                 if ( xFrameProv != xProv )
 295                     return GetSlotServer( rDispat, xFrameProv );
 296             }
 297         }
 298
 299         bSlotDirty = false;
 300         bCtrlDirty = true;
 301     }
 302
 303     // we *always* return a SlotServer (if there is one); but in case of an external dispatch we might not use it
 304     // for the "real" (non internal) controllers
 305     return aSlotServ.GetSlot()? &aSlotServ: nullptr;
 306 }
 307
 308
 309 // Set Status in all Controllers
 310
 311 void SfxStateCache::SetState
 312 (
 313     SfxItemState        eState,  // <SfxItemState> from 'pState'
 314     const SfxPoolItem*  pState,  // Slot Status, 0 or -1
 315     bool bMaybeDirty
 316 )
 317
 318 /*  [Description]
 319
 320     This method distributes the status of all of this SID bound
 321     <SfxControllerItem>s. If the value is the same as before, and if neither
 322     controller was registered nor invalidated inbetween, then no value is
 323     passed. This way the flickering is for example avoided in ListBoxes.
 324 */
 325 {
 326     SetState_Impl( eState, pState, bMaybeDirty );
 327 }
 328
 329 void SfxStateCache::GetState
 330 (
 331     boost::property_tree::ptree& rState
 332 )
 333 {
 334     if ( !mxDispatch.is() && pController )
 335     {
 336         for ( SfxControllerItem *pCtrl = pController;
 337               pCtrl;
 338               pCtrl = pCtrl->GetItemLink() )
 339         pCtrl->GetControlState( nId, rState );
 340     }
 341 }
 342
 343 void SfxStateCache::SetVisibleState( bool bShow )
 344 {
 345     if ( bShow == bItemVisible )
 346         return;
 347
 348     SfxItemState eState( SfxItemState::DEFAULT );
 349     const SfxPoolItem*  pState( nullptr );
 350     bool bDeleteItem( false );
 351
 352     bItemVisible = bShow;
 353     if ( bShow )
 354     {
 355         if ( IsInvalidItem(pLastItem) || ( pLastItem == nullptr ))
 356         {
 357             pState = new SfxVoidItem( nId );
 358             bDeleteItem = true;
 359         }
 360         else
 361             pState = pLastItem;
 362
 363         eState = eLastState;
 364     }
 365     else
 366     {
 367         pState = new SfxVisibilityItem( nId, false );
 368         bDeleteItem = true;
 369     }
 370
 371     // Update Controller
 372     if ( !mxDispatch.is() && pController )
 373     {
 374         for ( SfxControllerItem *pCtrl = pController;
 375                 pCtrl;
 376                 pCtrl = pCtrl->GetItemLink() )
 377             pCtrl->StateChangedAtToolBoxControl( nId, eState, pState );
 378     }
 379
 380     if ( pInternalController )
 381         pInternalController->StateChangedAtToolBoxControl( nId, eState, pState );
 382
 383     if ( bDeleteItem )
 384         delete pState;
 385 }
 386
 387
 388 void SfxStateCache::SetState_Impl
 389 (
 390     SfxItemState        eState,  // <SfxItemState> from 'pState'
 391     const SfxPoolItem*  pState,  // Slot Status, 0 or -1
 392     bool bMaybeDirty
 393 )
 394 {
 395     // If a hard update occurs between enter- and leave-registrations is a
 396     // can also intermediate Cached exist without controller.
 397     if ( !pController && !pInternalController )
 398         return;
 399
 400     DBG_ASSERT( bMaybeDirty || !bSlotDirty, "setting state of dirty message" );
 401     DBG_ASSERT( SfxControllerItem::GetItemState(pState) == eState, "invalid SfxItemState" );
 402
 403     // does the controller have to be notified at all?
 404     bool bNotify = bItemDirty;
 405     if ( !bItemDirty )
 406     {
 407         bNotify = !SfxPoolItem::areSame(pLastItem, pState) || (eState != eLastState);
 408     }
 409
 410     if ( bNotify )
 411     {
 412         // Update Controller
 413         if ( !mxDispatch.is() && pController )
 414         {
 415             for ( SfxControllerItem *pCtrl = pController;
 416                 pCtrl;
 417                 pCtrl = pCtrl->GetItemLink() )
 418                 pCtrl->StateChangedAtToolBoxControl( nId, eState, pState );
 419         }
 420
 421         if ( pInternalController )
 422             static_cast<SfxDispatchController_Impl *>(pInternalController)->StateChanged( nId, eState, pState, &aSlotServ );
 423
 424         // Remember new value
 425         if ( !IsInvalidItem(pLastItem) )
 426         {
 427             delete pLastItem;
 428             pLastItem = nullptr;
 429         }
 430         if ( pState && !IsInvalidItem(pState) )
 431             pLastItem = pState->Clone();
 432         else
 433             pLastItem = nullptr;
 434         eLastState = eState;
 435         bItemDirty = false;
 436     }
 437
 438     bCtrlDirty = false;
 439 }
 440
 441
 442 // Set old status again in all the controllers
 443
 444 void SfxStateCache::SetCachedState( bool bAlways )
 445 {
 446     DBG_ASSERT(pController==nullptr||pController->GetId()==nId, "Cache with wrong ControllerItem" );
 447
 448     // Only update if cached item exists and also able to process.
 449     // (If the State is sent, it must be ensured that a SlotServer is present,
 450     // see SfxControllerItem:: GetCoreMetric())
 451     if ( !(bAlways || ( !bItemDirty && !bSlotDirty )) )
 452         return;
 453
 454     // Update Controller
 455     if ( !mxDispatch.is() && pController )
 456     {
 457         for ( SfxControllerItem *pCtrl = pController;
 458             pCtrl;
 459             pCtrl = pCtrl->GetItemLink() )
 460             pCtrl->StateChangedAtToolBoxControl( nId, eLastState, pLastItem );
 461     }
 462
 463     if ( pInternalController )
 464         static_cast<SfxDispatchController_Impl *>(pInternalController)->StateChanged( nId, eLastState, pLastItem, &aSlotServ );
 465
 466     // Controller is now ok
 467     bCtrlDirty = true;
 468 }
 469
 470
 471 css::uno::Reference< css::frame::XDispatch >  SfxStateCache::GetDispatch() const
 472 {
 473     if ( mxDispatch.is() )
 474         return mxDispatch->xDisp;
 475     return css::uno::Reference< css::frame::XDispatch > ();
 476 }
 477
 478 sal_Int16 SfxStateCache::Dispatch( const SfxItemSet* pSet, bool bForceSynchron )
 479 {
 480     // protect pDispatch against destruction in the call
 481     rtl::Reference<BindDispatch_Impl> xKeepAlive( mxDispatch );
 482     sal_Int16 eRet = css::frame::DispatchResultState::DONTKNOW;
 483
 484     if ( mxDispatch.is() )
 485     {
 486         uno::Sequence < beans::PropertyValue > aArgs;
 487         if (pSet)
 488             TransformItems( nId, *pSet, aArgs );
 489
 490         eRet = mxDispatch->Dispatch( aArgs, bForceSynchron );
 491     }
 492
 493     return eRet;
 494 }
 495
 496
 497 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */