svtools/source/uno/popupmenucontrollerbase.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 <svtools/popupmenucontrollerbase.hxx>
  21
  22 #include <com/sun/star/beans/PropertyValue.hpp>
  23 #include <com/sun/star/frame/XDispatchProvider.hpp>
  24 #include <com/sun/star/frame/XFrame.hpp>
  25 #include <com/sun/star/lang/DisposedException.hpp>
  26 #include <com/sun/star/util/URLTransformer.hpp>
  27
  28 #include <vcl/svapp.hxx>
  29 #include <osl/mutex.hxx>
  30 #include <cppuhelper/supportsservice.hxx>
  31
  32 using namespace com::sun::star;
  33 using namespace css::uno;
  34 using namespace css::lang;
  35 using namespace css::frame;
  36 using namespace css::beans;
  37 using namespace css::util;
  38
  39 namespace svt
  40 {
  41
  42 namespace {
  43
  44 struct PopupMenuControllerBaseDispatchInfo
  45 {
  46     Reference< XDispatch > mxDispatch;
  47     const URL maURL;
  48     const Sequence< PropertyValue > maArgs;
  49
  50     PopupMenuControllerBaseDispatchInfo( const Reference< XDispatch >& xDispatch, const URL& rURL, const Sequence< PropertyValue >& rArgs )
  51         : mxDispatch( xDispatch ), maURL( rURL ), maArgs( rArgs ) {}
  52 };
  53
  54 }
  55
  56 PopupMenuControllerBase::PopupMenuControllerBase( const Reference< XComponentContext >& xContext ) :
  57     ::cppu::BaseMutex(),
  58     PopupMenuControllerBaseType(m_aMutex),
  59     m_bInitialized( false )
  60 {
  61     if ( xContext.is() )
  62         m_xURLTransformer.set( util::URLTransformer::create( xContext ) );
  63 }
  64
  65 PopupMenuControllerBase::~PopupMenuControllerBase()
  66 {
  67 }
  68
  69 // protected function
  70 void PopupMenuControllerBase::throwIfDisposed()
  71 {
  72     if (rBHelper.bDisposed || rBHelper.bInDispose)
  73         throw css::lang::DisposedException();
  74 }
  75
  76 // protected function
  77 void PopupMenuControllerBase::resetPopupMenu( css::uno::Reference< css::awt::XPopupMenu > const & rPopupMenu )
  78 {
  79     if ( rPopupMenu.is() && rPopupMenu->getItemCount() > 0 )
  80     {
  81         rPopupMenu->clear();
  82     }
  83 }
  84
  85 void SAL_CALL PopupMenuControllerBase::disposing()
  86 {
  87     // Reset our members and set disposed flag
  88     osl::MutexGuard aLock( m_aMutex );
  89     m_xFrame.clear();
  90     m_xDispatch.clear();
  91     m_xPopupMenu.clear();
  92 }
  93
  94 // XServiceInfo
  95 sal_Bool SAL_CALL PopupMenuControllerBase::supportsService( const OUString& ServiceName )
  96 {
  97     return cppu::supportsService(this, ServiceName);
  98 }
  99
 100 // XEventListener
 101 void SAL_CALL PopupMenuControllerBase::disposing( const EventObject& )
 102 {
 103     osl::MutexGuard aLock( m_aMutex );
 104     m_xFrame.clear();
 105     m_xDispatch.clear();
 106     m_xPopupMenu.clear();
 107 }
 108
 109 // XMenuListener
 110 void SAL_CALL PopupMenuControllerBase::itemHighlighted( const awt::MenuEvent& )
 111 {
 112 }
 113
 114 void SAL_CALL PopupMenuControllerBase::itemSelected( const awt::MenuEvent& rEvent )
 115 {
 116     throwIfDisposed();
 117
 118     osl::MutexGuard aLock( m_aMutex );
 119
 120     if( m_xPopupMenu.is() )
 121     {
 122         Sequence<PropertyValue> aArgs;
 123         dispatchCommand( m_xPopupMenu->getCommand( rEvent.MenuId ), aArgs );
 124     }
 125 }
 126
 127 void PopupMenuControllerBase::dispatchCommand( const OUString& sCommandURL,
 128                                                const css::uno::Sequence< css::beans::PropertyValue >& rArgs,
 129                                                const OUString& sTarget )
 130 {
 131     osl::MutexGuard aLock( m_aMutex );
 132
 133     throwIfDisposed();
 134
 135     try
 136     {
 137         Reference< XDispatchProvider > xDispatchProvider( m_xFrame, UNO_QUERY_THROW );
 138         URL aURL;
 139         aURL.Complete = sCommandURL;
 140         m_xURLTransformer->parseStrict( aURL );
 141
 142         Reference< XDispatch > xDispatch( xDispatchProvider->queryDispatch( aURL, sTarget, 0 ), UNO_SET_THROW );
 143
 144         Application::PostUserEvent( LINK(nullptr, PopupMenuControllerBase, ExecuteHdl_Impl), new PopupMenuControllerBaseDispatchInfo( xDispatch, aURL, rArgs ) );
 145
 146     }
 147     catch( Exception& )
 148     {
 149     }
 150
 151 }
 152
 153 IMPL_STATIC_LINK( PopupMenuControllerBase, ExecuteHdl_Impl, void*, p, void )
 154 {
 155     PopupMenuControllerBaseDispatchInfo* pDispatchInfo = static_cast<PopupMenuControllerBaseDispatchInfo*>(p);
 156     pDispatchInfo->mxDispatch->dispatch( pDispatchInfo->maURL, pDispatchInfo->maArgs );
 157     delete pDispatchInfo;
 158 }
 159
 160 void SAL_CALL PopupMenuControllerBase::itemActivated( const awt::MenuEvent& )
 161 {
 162 }
 163
 164 void SAL_CALL PopupMenuControllerBase::itemDeactivated( const awt::MenuEvent& )
 165 {
 166 }
 167
 168 void SAL_CALL PopupMenuControllerBase::updatePopupMenu()
 169 {
 170     {
 171         osl::MutexGuard aLock(m_aMutex);
 172         throwIfDisposed();
 173     }
 174
 175     updateCommand( m_aCommandURL );
 176 }
 177
 178 void PopupMenuControllerBase::updateCommand( const OUString& rCommandURL )
 179 {
 180     osl::ClearableMutexGuard aLock( m_aMutex );
 181     Reference< XStatusListener > xStatusListener( static_cast< OWeakObject* >( this ), UNO_QUERY );
 182     Reference< XDispatch > xDispatch( m_xDispatch );
 183     URL aTargetURL;
 184     aTargetURL.Complete = rCommandURL;
 185     m_xURLTransformer->parseStrict( aTargetURL );
 186     aLock.clear();
 187
 188     // Add/remove status listener to get a status update once
 189     if ( xDispatch.is() )
 190     {
 191         xDispatch->addStatusListener( xStatusListener, aTargetURL );
 192         xDispatch->removeStatusListener( xStatusListener, aTargetURL );
 193     }
 194 }
 195
 196
 197 // XDispatchProvider
 198 Reference< XDispatch > SAL_CALL
 199 PopupMenuControllerBase::queryDispatch(
 200     const URL& /*aURL*/,
 201     const OUString& /*sTarget*/,
 202     sal_Int32 /*nFlags*/ )
 203 {
 204     // must be implemented by subclass
 205     osl::MutexGuard aLock( m_aMutex );
 206     throwIfDisposed();
 207
 208     return Reference< XDispatch >();
 209 }
 210
 211 Sequence< Reference< XDispatch > > SAL_CALL PopupMenuControllerBase::queryDispatches( const Sequence< DispatchDescriptor >& lDescriptor )
 212 {
 213     // Create return list - which must have same size then the given descriptor
 214     // It's not allowed to pack it!
 215     {
 216         osl::MutexGuard aLock(m_aMutex);
 217         throwIfDisposed();
 218     }
 219
 220     sal_Int32                                                          nCount = lDescriptor.getLength();
 221     uno::Sequence< uno::Reference< frame::XDispatch > > lDispatcher( nCount );
 222
 223     // Step over all descriptors and try to get any dispatcher for it.
 224     std::transform(lDescriptor.begin(), lDescriptor.end(), lDispatcher.begin(),
 225         [this](const DispatchDescriptor& rDesc) -> uno::Reference< frame::XDispatch > {
 226             return queryDispatch(rDesc.FeatureURL, rDesc.FrameName, rDesc.SearchFlags); });
 227
 228     return lDispatcher;
 229 }
 230
 231 // XDispatch
 232 void SAL_CALL
 233 PopupMenuControllerBase::dispatch(
 234     const URL& /*aURL*/,
 235     const Sequence< PropertyValue >& /*seqProperties*/ )
 236 {
 237     // must be implemented by subclass
 238     osl::MutexGuard aLock( m_aMutex );
 239     throwIfDisposed();
 240 }
 241
 242 void SAL_CALL
 243 PopupMenuControllerBase::addStatusListener(
 244     const Reference< XStatusListener >& xControl,
 245     const URL& aURL )
 246 {
 247     osl::ResettableMutexGuard aLock( m_aMutex );
 248     throwIfDisposed();
 249     aLock.clear();
 250
 251     bool bStatusUpdate( false );
 252     rBHelper.addListener( cppu::UnoType<decltype(xControl)>::get(), xControl );
 253
 254     aLock.reset();
 255     if ( aURL.Complete.startsWith( m_aBaseURL ) )
 256         bStatusUpdate = true;
 257     aLock.clear();
 258
 259     if ( bStatusUpdate )
 260     {
 261         // Dummy update for popup menu controllers
 262         FeatureStateEvent aEvent;
 263         aEvent.FeatureURL = aURL;
 264         aEvent.IsEnabled  = true;
 265         aEvent.Requery    = false;
 266         aEvent.State      = Any();
 267         xControl->statusChanged( aEvent );
 268     }
 269 }
 270
 271 void SAL_CALL PopupMenuControllerBase::removeStatusListener(
 272     const Reference< XStatusListener >& xControl,
 273     const URL& /*aURL*/ )
 274 {
 275     rBHelper.removeListener( cppu::UnoType<decltype(xControl)>::get(), xControl );
 276 }
 277
 278 OUString PopupMenuControllerBase::determineBaseURL( const OUString& aURL )
 279 {
 280     // Just use the main part of the URL for popup menu controllers
 281     sal_Int32     nSchemePart( 0 );
 282     OUString aMainURL( "vnd.sun.star.popup:" );
 283
 284     nSchemePart = aURL.indexOf( ':' );
 285     if (( nSchemePart > 0 ) &&
 286         ( aURL.getLength() > ( nSchemePart+1 )))
 287     {
 288         sal_Int32 nQueryPart = aURL.indexOf( '?', nSchemePart );
 289         if ( nQueryPart > 0 )
 290             aMainURL += aURL.subView( nSchemePart, nQueryPart-nSchemePart );
 291         else if ( nQueryPart == -1 )
 292             aMainURL += aURL.subView( nSchemePart+1 );
 293     }
 294
 295     return aMainURL;
 296 }
 297
 298 // XInitialization
 299 void SAL_CALL PopupMenuControllerBase::initialize( const Sequence< Any >& aArguments )
 300 {
 301     osl::MutexGuard aLock( m_aMutex );
 302
 303     bool bInitalized( m_bInitialized );
 304     if ( bInitalized )
 305         return;
 306
 307     PropertyValue       aPropValue;
 308     OUString       aCommandURL;
 309     Reference< XFrame > xFrame;
 310
 311     for ( const auto& rArgument : aArguments )
 312     {
 313         if ( rArgument >>= aPropValue )
 314         {
 315             if ( aPropValue.Name == "Frame" )
 316                 aPropValue.Value >>= xFrame;
 317             else if ( aPropValue.Name == "CommandURL" )
 318                 aPropValue.Value >>= aCommandURL;
 319             else if ( aPropValue.Name == "ModuleIdentifier" )
 320                 aPropValue.Value >>= m_aModuleName;
 321         }
 322     }
 323
 324     if ( xFrame.is() && !aCommandURL.isEmpty() )
 325     {
 326         m_xFrame        = xFrame;
 327         m_aCommandURL   = aCommandURL;
 328         m_aBaseURL      = determineBaseURL( aCommandURL );
 329         m_bInitialized  = true;
 330     }
 331 }
 332 // XPopupMenuController
 333 void SAL_CALL PopupMenuControllerBase::setPopupMenu( const Reference< awt::XPopupMenu >& xPopupMenu )
 334 {
 335     osl::MutexGuard aLock( m_aMutex );
 336     throwIfDisposed();
 337
 338     if ( !m_xFrame.is() || m_xPopupMenu.is() )
 339         return;
 340
 341     // Create popup menu on demand
 342     SolarMutexGuard aSolarMutexGuard;
 343
 344     m_xPopupMenu = xPopupMenu;
 345     m_xPopupMenu->addMenuListener( Reference< awt::XMenuListener >( static_cast<OWeakObject*>(this), UNO_QUERY ));
 346
 347     Reference< XDispatchProvider > xDispatchProvider( m_xFrame, UNO_QUERY );
 348
 349     URL aTargetURL;
 350     aTargetURL.Complete = m_aCommandURL;
 351     m_xURLTransformer->parseStrict( aTargetURL );
 352     m_xDispatch = xDispatchProvider->queryDispatch( aTargetURL, OUString(), 0 );
 353
 354     impl_setPopupMenu();
 355
 356     updatePopupMenu();
 357 }
 358 void PopupMenuControllerBase::impl_setPopupMenu()
 359 {
 360 }
 361 }
 362
 363 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */