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