office-gobmx/svx/source/form/formdispatchinterceptor.cxx
Andrea Gelmini ef67f74b79 Fix typos
Change-Id: Ieccfec878aeaeacc55841f28c7d67cd2bd08556e
Reviewed-on: https://gerrit.libreoffice.org/77284
Tested-by: Jenkins
Reviewed-by: Julien Nabet <serval2412@yahoo.fr>
2019-08-12 11:39:49 +02:00

178 lines
6.8 KiB
C++

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#include <formdispatchinterceptor.hxx>
namespace svxform
{
using ::com::sun::star::uno::Reference;
using ::com::sun::star::uno::UNO_QUERY;
using ::com::sun::star::uno::RuntimeException;
using ::com::sun::star::uno::Sequence;
using ::com::sun::star::frame::XDispatchProviderInterception;
using ::com::sun::star::frame::XDispatchProviderInterceptor;
using ::com::sun::star::lang::XComponent;
using ::com::sun::star::util::URL;
using ::com::sun::star::frame::XDispatch;
using ::com::sun::star::frame::DispatchDescriptor;
using ::com::sun::star::frame::XDispatchProvider;
using ::com::sun::star::lang::EventObject;
DispatchInterceptionMultiplexer::DispatchInterceptionMultiplexer(
const Reference< XDispatchProviderInterception >& _rxToIntercept, DispatchInterceptor* _pMaster )
:DispatchInterceptionMultiplexer_BASE(_pMaster && _pMaster->getInterceptorMutex() ? *_pMaster->getInterceptorMutex() : m_aFallback)
,m_aFallback()
,m_pMutex( _pMaster && _pMaster->getInterceptorMutex() ? _pMaster->getInterceptorMutex() : &m_aFallback )
,m_xIntercepted(_rxToIntercept)
,m_bListening(false)
,m_pMaster(_pMaster)
{
::osl::MutexGuard aGuard( *m_pMutex );
osl_atomic_increment(&m_refCount);
if (_rxToIntercept.is())
{
_rxToIntercept->registerDispatchProviderInterceptor(static_cast<XDispatchProviderInterceptor*>(this));
// this should make us the top-level dispatch-provider for the component, via a call to our
// setDispatchProvider we should have got a fallback for requests we (i.e. our master) cannot fulfill
Reference< XComponent> xInterceptedComponent(_rxToIntercept, UNO_QUERY);
if (xInterceptedComponent.is())
{
xInterceptedComponent->addEventListener(this);
m_bListening = true;
}
}
osl_atomic_decrement(&m_refCount);
}
DispatchInterceptionMultiplexer::~DispatchInterceptionMultiplexer()
{
if (!rBHelper.bDisposed)
dispose();
}
Reference< XDispatch > SAL_CALL DispatchInterceptionMultiplexer::queryDispatch( const URL& aURL, const OUString& aTargetFrameName, sal_Int32 nSearchFlags )
{
::osl::MutexGuard aGuard( *m_pMutex );
Reference< XDispatch> xResult;
// ask our 'real' interceptor
if (m_pMaster)
xResult = m_pMaster->interceptedQueryDispatch( aURL, aTargetFrameName, nSearchFlags);
// ask our slave provider
if (!xResult.is() && m_xSlaveDispatcher.is())
xResult = m_xSlaveDispatcher->queryDispatch(aURL, aTargetFrameName, nSearchFlags);
return xResult;
}
Sequence< Reference< XDispatch > > SAL_CALL
DispatchInterceptionMultiplexer::queryDispatches( const Sequence< DispatchDescriptor >& aDescripts )
{
::osl::MutexGuard aGuard( *m_pMutex );
Sequence< Reference< XDispatch> > aReturn(aDescripts.getLength());
std::transform(aDescripts.begin(), aDescripts.end(), aReturn.begin(),
[this](const DispatchDescriptor& rDescript) -> Reference< XDispatch> {
return queryDispatch(rDescript.FeatureURL, rDescript.FrameName, rDescript.SearchFlags); });
return aReturn;
}
Reference< XDispatchProvider > SAL_CALL DispatchInterceptionMultiplexer::getSlaveDispatchProvider( )
{
::osl::MutexGuard aGuard( *m_pMutex );
return m_xSlaveDispatcher;
}
void SAL_CALL DispatchInterceptionMultiplexer::setSlaveDispatchProvider(const Reference< XDispatchProvider>& xNewDispatchProvider)
{
::osl::MutexGuard aGuard( *m_pMutex );
m_xSlaveDispatcher = xNewDispatchProvider;
}
Reference< XDispatchProvider> SAL_CALL DispatchInterceptionMultiplexer::getMasterDispatchProvider()
{
::osl::MutexGuard aGuard( *m_pMutex );
return m_xMasterDispatcher;
}
void SAL_CALL DispatchInterceptionMultiplexer::setMasterDispatchProvider(const Reference< XDispatchProvider>& xNewSupplier)
{
::osl::MutexGuard aGuard( *m_pMutex );
m_xMasterDispatcher = xNewSupplier;
}
void SAL_CALL DispatchInterceptionMultiplexer::disposing(const EventObject& Source)
{
if (m_bListening)
{
Reference< XDispatchProviderInterception > xIntercepted(m_xIntercepted.get(), UNO_QUERY);
if (Source.Source == xIntercepted)
ImplDetach();
}
}
void DispatchInterceptionMultiplexer::ImplDetach()
{
::osl::MutexGuard aGuard( *m_pMutex );
OSL_ENSURE(m_bListening, "DispatchInterceptionMultiplexer::ImplDetach: invalid call!");
// deregister ourself from the interception component
Reference< XDispatchProviderInterception > xIntercepted(m_xIntercepted.get(), UNO_QUERY);
if (xIntercepted.is())
xIntercepted->releaseDispatchProviderInterceptor(static_cast<XDispatchProviderInterceptor*>(this));
// m_xIntercepted.clear();
// Don't reset m_xIntercepted: It may be needed by our owner to check for which object we were
// responsible. As we hold the object with a weak reference only, this should be no problem.
// 88936 - 23.07.2001 - frank.schoenheit@sun.com
m_pMaster = nullptr;
m_pMutex = &m_aFallback;
m_bListening = false;
}
void DispatchInterceptionMultiplexer::disposing()
{
// remove ourself as event listener from the interception component
if (m_bListening)
{
Reference< XComponent> xInterceptedComponent(m_xIntercepted.get(), UNO_QUERY);
if (xInterceptedComponent.is())
xInterceptedComponent->removeEventListener(static_cast<XEventListener*>(this));
// detach from the interception component
ImplDetach();
}
}
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */