sfx2/source/control/sfxstatuslistener.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 <sfx2/sfxstatuslistener.hxx>
  21 #include <svl/poolitem.hxx>
  22 #include <svl/eitem.hxx>
  23 #include <svl/stritem.hxx>
  24 #include <svl/intitem.hxx>
  25 #include <svl/itemset.hxx>
  26 #include "itemdel.hxx"
  27 #include <svl/visitem.hxx>
  28 #include <cppuhelper/weak.hxx>
  29 #include <comphelper/processfactory.hxx>
  30 #include <osl/mutex.hxx>
  31 #include <vcl/svapp.hxx>
  32 #include <com/sun/star/util/URLTransformer.hpp>
  33 #include <com/sun/star/util/XURLTransformer.hpp>
  34 #include <com/sun/star/lang/XUnoTunnel.hpp>
  35 #include <com/sun/star/frame/status/ItemStatus.hpp>
  36 #include <com/sun/star/frame/status/ItemState.hpp>
  37 #include <com/sun/star/frame/status/Visibility.hpp>
  38
  39 #include <sfx2/viewfrm.hxx>
  40 #include <sfx2/dispatch.hxx>
  41 #include <sfx2/unoctitm.hxx>
  42 #include <sfx2/msgpool.hxx>
  43
  44 using namespace ::cppu;
  45 using namespace ::com::sun::star::uno;
  46 using namespace ::com::sun::star::frame;
  47 using namespace ::com::sun::star::frame::status;
  48 using namespace ::com::sun::star::lang;
  49 using namespace ::com::sun::star::util;
  50
  51 SfxStatusListener::SfxStatusListener( const Reference< XDispatchProvider >& rDispatchProvider, sal_uInt16 nSlotId, const OUString& rCommand ) :
  52     m_nSlotID( nSlotId ),
  53     m_xDispatchProvider( rDispatchProvider )
  54 {
  55     m_aCommand.Complete = rCommand;
  56     Reference< XURLTransformer > xTrans( URLTransformer::create( ::comphelper::getProcessComponentContext() ) );
  57     xTrans->parseStrict( m_aCommand );
  58     if ( rDispatchProvider.is() )
  59         m_xDispatch = rDispatchProvider->queryDispatch( m_aCommand, OUString(), 0 );
  60 }
  61
  62 SfxStatusListener::~SfxStatusListener()
  63 {
  64 }
  65
  66 // old sfx controller item C++ API
  67 void SfxStatusListener::StateChanged( sal_uInt16, SfxItemState, const SfxPoolItem* )
  68 {
  69     // must be implemented by sub class
  70 }
  71
  72 void SfxStatusListener::UnBind()
  73 {
  74     if ( m_xDispatch.is() )
  75     {
  76         Reference< XStatusListener > aStatusListener( static_cast< OWeakObject* >( this ), UNO_QUERY );
  77         m_xDispatch->removeStatusListener( aStatusListener, m_aCommand );
  78         m_xDispatch.clear();
  79     }
  80 }
  81
  82 void SfxStatusListener::ReBind()
  83 {
  84     Reference< XStatusListener > aStatusListener( static_cast< OWeakObject* >( this ), UNO_QUERY );
  85     if ( m_xDispatch.is() )
  86         m_xDispatch->removeStatusListener( aStatusListener, m_aCommand );
  87     if ( m_xDispatchProvider.is() )
  88     {
  89         try
  90         {
  91             m_xDispatch = m_xDispatchProvider->queryDispatch( m_aCommand, OUString(), 0 );
  92             if ( m_xDispatch.is() )
  93                 m_xDispatch->addStatusListener( aStatusListener, m_aCommand );
  94         }
  95         catch( Exception& )
  96         {
  97         }
  98     }
  99 }
 100
 101 // new UNO API
 102 void SAL_CALL SfxStatusListener::dispose() throw( ::com::sun::star::uno::RuntimeException, std::exception )
 103 {
 104     if ( m_xDispatch.is() && !m_aCommand.Complete.isEmpty() )
 105     {
 106         try
 107         {
 108             Reference< XStatusListener > aStatusListener( static_cast< OWeakObject* >( this ), UNO_QUERY );
 109             m_xDispatch->removeStatusListener( aStatusListener, m_aCommand );
 110         }
 111         catch ( Exception& )
 112         {
 113         }
 114     }
 115
 116     m_xDispatch.clear();
 117     m_xDispatchProvider.clear();
 118 }
 119
 120 void SAL_CALL SfxStatusListener::addEventListener( const Reference< XEventListener >& )
 121 throw ( RuntimeException, std::exception )
 122 {
 123     // do nothing - this is a wrapper class which does not support listeners
 124 }
 125
 126 void SAL_CALL SfxStatusListener::removeEventListener( const Reference< XEventListener >& )
 127 throw ( RuntimeException, std::exception )
 128 {
 129     // do nothing - this is a wrapper class which does not support listeners
 130 }
 131
 132 void SAL_CALL SfxStatusListener::disposing( const EventObject& Source )
 133 throw( RuntimeException, std::exception )
 134 {
 135     SolarMutexGuard aGuard;
 136
 137     if ( Source.Source == Reference< XInterface >( m_xDispatch, UNO_QUERY ))
 138         m_xDispatch.clear();
 139     else if ( Source.Source == Reference< XInterface >( m_xDispatchProvider, UNO_QUERY ))
 140         m_xDispatchProvider.clear();
 141 }
 142
 143 void SAL_CALL SfxStatusListener::statusChanged( const FeatureStateEvent& rEvent)
 144 throw( RuntimeException, std::exception )
 145 {
 146     SolarMutexGuard aGuard;
 147
 148     SfxViewFrame* pViewFrame = NULL;
 149     if ( m_xDispatch.is() )
 150     {
 151         Reference< XUnoTunnel > xTunnel( m_xDispatch, UNO_QUERY );
 152         SfxOfficeDispatch* pDisp = NULL;
 153         if ( xTunnel.is() )
 154         {
 155             sal_Int64 nImplementation = xTunnel->getSomething(SfxOfficeDispatch::impl_getStaticIdentifier());
 156             pDisp = reinterpret_cast< SfxOfficeDispatch* >(sal::static_int_cast< sal_IntPtr >( nImplementation ));
 157         }
 158
 159         if ( pDisp )
 160             pViewFrame = pDisp->GetDispatcher_Impl()->GetFrame();
 161     }
 162
 163     SfxSlotPool& rPool = SfxSlotPool::GetSlotPool( pViewFrame );
 164     const SfxSlot* pSlot = rPool.GetSlot( m_nSlotID );
 165
 166     SfxItemState eState = SfxItemState::DISABLED;
 167     SfxPoolItem* pItem = NULL;
 168     if ( rEvent.IsEnabled )
 169     {
 170         eState = SfxItemState::DEFAULT;
 171         ::com::sun::star::uno::Type pType = rEvent.State.getValueType();
 172
 173         if ( pType == ::cppu::UnoType<void>::get() )
 174         {
 175             pItem = new SfxVoidItem( m_nSlotID );
 176             eState = SfxItemState::UNKNOWN;
 177         }
 178         else if ( pType == cppu::UnoType< bool >::get() )
 179         {
 180             bool bTemp = false;
 181             rEvent.State >>= bTemp ;
 182             pItem = new SfxBoolItem( m_nSlotID, bTemp );
 183         }
 184         else if ( pType == cppu::UnoType< ::cppu::UnoUnsignedShortType >::get() )
 185         {
 186             sal_uInt16 nTemp = 0;
 187             rEvent.State >>= nTemp ;
 188             pItem = new SfxUInt16Item( m_nSlotID, nTemp );
 189         }
 190         else if ( pType == cppu::UnoType<sal_uInt32>::get() )
 191         {
 192             sal_uInt32 nTemp = 0;
 193             rEvent.State >>= nTemp ;
 194             pItem = new SfxUInt32Item( m_nSlotID, nTemp );
 195         }
 196         else if ( pType == cppu::UnoType<OUString>::get() )
 197         {
 198             OUString sTemp ;
 199             rEvent.State >>= sTemp ;
 200             pItem = new SfxStringItem( m_nSlotID, sTemp );
 201         }
 202         else if ( pType == cppu::UnoType< ::com::sun::star::frame::status::ItemStatus >::get() )
 203         {
 204             ItemStatus aItemStatus;
 205             rEvent.State >>= aItemStatus;
 206             eState = (SfxItemState) aItemStatus.State;
 207             pItem = new SfxVoidItem( m_nSlotID );
 208         }
 209         else if ( pType == cppu::UnoType< ::com::sun::star::frame::status::Visibility >::get() )
 210         {
 211             Visibility aVisibilityStatus;
 212             rEvent.State >>= aVisibilityStatus;
 213             pItem = new SfxVisibilityItem( m_nSlotID, aVisibilityStatus.bVisible );
 214         }
 215         else
 216         {
 217             if ( pSlot )
 218                 pItem = pSlot->GetType()->CreateItem();
 219             if ( pItem )
 220             {
 221                 pItem->SetWhich( m_nSlotID );
 222                 pItem->PutValue( rEvent.State );
 223             }
 224             else
 225                 pItem = new SfxVoidItem( m_nSlotID );
 226         }
 227     }
 228
 229     StateChanged( m_nSlotID, eState, pItem );
 230     delete pItem;
 231 }
 232
 233 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */