strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
office-gobmx/sfx2/source/notify/eventsupplier.cxx
Noel Grandin ce214d5672 bypass some unnecessary wrapping in Any in SfxEvents_Impl 
Change-Id: I96d1194253207642e7abe83b0b18c82eb3782824
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/134316
Tested-by: Jenkins
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>
2022-05-14 17:30:08 +02:00

471 lines
14 KiB
C++
Raw Blame History

/* -*- 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 <com/sun/star/beans/PropertyValue.hpp>
#include <com/sun/star/util/URL.hpp>
#include <com/sun/star/frame/Desktop.hpp>
#include <com/sun/star/uno/Sequence.hxx>
#include <com/sun/star/util/URLTransformer.hpp>
#include <com/sun/star/util/XURLTransformer.hpp>
#include <tools/urlobj.hxx>
#include <svl/macitem.hxx>
#include <sfx2/objsh.hxx>
#include <sfx2/evntconf.hxx>
#include <unotools/eventcfg.hxx>
#include <sal/log.hxx>
#include <comphelper/processfactory.hxx>
#include <comphelper/namedvaluecollection.hxx>
#include <comphelper/sequence.hxx>
#include <officecfg/Office/Common.hxx>
#include <eventsupplier.hxx>
#include <sfx2/app.hxx>
#include <sfx2/viewfrm.hxx>
#include <sfx2/frame.hxx>
#include <macroloader.hxx>
#include <unicode/errorcode.h>
#include <unicode/regex.h>
#include <unicode/unistr.h>
using namespace css;
using namespace ::com::sun::star;
// --- XNameReplace ---
void SAL_CALL SfxEvents_Impl::replaceByName( const OUString & aName, const uno::Any & rElement )
{
std::unique_lock aGuard( maMutex );
// find the event in the list and replace the data
auto nIndex = comphelper::findValue(maEventNames, aName);
if (nIndex == -1)
throw container::NoSuchElementException();
// check for correct type of the element
if ( !::comphelper::NamedValueCollection::canExtractFrom( rElement ) )
throw lang::IllegalArgumentException();
::comphelper::NamedValueCollection const aEventDescriptor( rElement );
// create Configuration at first, creation might call this method also and that would overwrite everything
// we might have stored before!
if ( mpObjShell && !mpObjShell->IsLoading() )
{
// SetModified will end up calling into our documentEventOccured method
aGuard.unlock();
mpObjShell->SetModified();
aGuard.lock();
}
::comphelper::NamedValueCollection aNormalizedDescriptor;
NormalizeMacro( aEventDescriptor, aNormalizedDescriptor, mpObjShell );
OUString sType;
if ( ( aNormalizedDescriptor.size() == 1 )
&& !aNormalizedDescriptor.has( PROP_EVENT_TYPE ) //TODO
&& ( aNormalizedDescriptor.get( PROP_EVENT_TYPE ) >>= sType )
&& ( sType.isEmpty() )
)
{
// An empty event type means no binding. Therefore reset data
// to reflect that state.
// (that's for compatibility only. Nowadays, the Tools/Customize dialog should
// set an empty sequence to indicate the request for resetting the assignment.)
OSL_ENSURE( false, "legacy event assignment format detected" );
aNormalizedDescriptor.clear();
}
if ( !aNormalizedDescriptor.empty() )
{
maEventData[nIndex] = aNormalizedDescriptor.getPropertyValues();
}
else
{
maEventData[nIndex] = {};
}
}
// --- XNameAccess ---
uno::Any SAL_CALL SfxEvents_Impl::getByName( const OUString& aName )
{
std::unique_lock aGuard( maMutex );
// find the event in the list and return the data
auto nIndex = comphelper::findValue(maEventNames, aName);
if (nIndex != -1)
return uno::Any(maEventData[nIndex]);
throw container::NoSuchElementException();
}
uno::Sequence< OUString > SAL_CALL SfxEvents_Impl::getElementNames()
{
return maEventNames;
}
sal_Bool SAL_CALL SfxEvents_Impl::hasByName( const OUString& aName )
{
std::unique_lock aGuard( maMutex );
// find the event in the list and return the data
return comphelper::findValue(maEventNames, aName) != -1;
}
// --- XElementAccess ( parent of XNameAccess ) ---
uno::Type SAL_CALL SfxEvents_Impl::getElementType()
{
uno::Type aElementType = cppu::UnoType<uno::Sequence < beans::PropertyValue >>::get();
return aElementType;
}
sal_Bool SAL_CALL SfxEvents_Impl::hasElements()
{
std::unique_lock aGuard( maMutex );
return maEventNames.hasElements();
}
bool SfxEvents_Impl::isScriptURLAllowed(const OUString& aScriptURL)
{
std::optional<css::uno::Sequence<OUString>> allowedEvents(
officecfg::Office::Common::Security::Scripting::AllowedDocumentEventURLs::get());
// When AllowedDocumentEventURLs is empty, all event URLs are allowed
if (!allowedEvents)
return true;
icu::ErrorCode status;
const uint32_t rMatcherFlags = UREGEX_CASE_INSENSITIVE;
icu::UnicodeString usInput(aScriptURL.getStr());
const css::uno::Sequence<OUString>& rAllowedEvents = *allowedEvents;
for (auto const& allowedEvent : rAllowedEvents)
{
icu::UnicodeString usRegex(allowedEvent.getStr());
icu::RegexMatcher rmatch1(usRegex, usInput, rMatcherFlags, status);
if (aScriptURL.startsWith(allowedEvent) || rmatch1.matches(status))
{
return true;
}
}
return false;
}
void SfxEvents_Impl::Execute( css::uno::Sequence < css::beans::PropertyValue > const & aProperties, const document::DocumentEvent& aTrigger, SfxObjectShell* pDoc )
{
OUString aType;
OUString aScript;
OUString aLibrary;
OUString aMacroName;
if ( !aProperties.hasElements() )
return;
for ( const auto& rProp : std::as_const(aProperties) )
{
if ( rProp.Name == PROP_EVENT_TYPE )
rProp.Value >>= aType;
else if ( rProp.Name == PROP_SCRIPT )
rProp.Value >>= aScript;
else if ( rProp.Name == PROP_LIBRARY )
rProp.Value >>= aLibrary;
else if ( rProp.Name == PROP_MACRO_NAME )
rProp.Value >>= aMacroName;
else {
OSL_FAIL("Unknown property value!");
}
}
if (aType.isEmpty())
{
// Empty type means no active binding for the event. Just ignore do nothing.
return;
}
if (aScript.isEmpty())
return;
if (!isScriptURLAllowed(aScript))
return;
if (!pDoc)
pDoc = SfxObjectShell::Current();
if (pDoc && !SfxObjectShell::isScriptAccessAllowed(pDoc->GetModel()))
return;
if (aType == STAR_BASIC)
{
uno::Any aAny;
SfxMacroLoader::loadMacro( aScript, aAny, pDoc );
}
else if (aType == "Service" || aType == "Script")
{
util::URL aURL;
uno::Reference < util::XURLTransformer > xTrans( util::URLTransformer::create( ::comphelper::getProcessComponentContext() ) );
aURL.Complete = aScript;
xTrans->parseStrict( aURL );
bool bAllowed = !SfxObjectShell::UnTrustedScript(aURL.Complete);
if (bAllowed)
{
SfxViewFrame* pView = SfxViewFrame::GetFirst(pDoc);
uno::Reference
< frame::XDispatchProvider > xProv;
if ( pView != nullptr )
{
xProv = uno::Reference
< frame::XDispatchProvider > (
pView->GetFrame().GetFrameInterface(), uno::UNO_QUERY );
}
else
{
xProv = frame::Desktop::create( ::comphelper::getProcessComponentContext() );
}
uno::Reference < frame::XDispatch > xDisp;
if ( xProv.is() )
xDisp = xProv->queryDispatch( aURL, OUString(), 0 );
if ( xDisp.is() )
{
beans::PropertyValue aEventParam;
aEventParam.Value <<= aTrigger;
uno::Sequence< beans::PropertyValue > aDispatchArgs( &aEventParam, 1 );
xDisp->dispatch( aURL, aDispatchArgs );
}
}
}
else
{
SAL_WARN( "sfx.notify", "notifyEvent(): Unsupported event type" );
}
}
// --- ::document::XEventListener ---
void SAL_CALL SfxEvents_Impl::documentEventOccured( const document::DocumentEvent& aEvent )
{
std::unique_lock aGuard( maMutex );
// get the event name, find the corresponding data, execute the data
auto nIndex = comphelper::findValue(maEventNames, aEvent.EventName);
if ( nIndex == -1 )
return;
css::uno::Sequence < css::beans::PropertyValue > aEventData = maEventData[ nIndex ];
aGuard.unlock();
Execute( aEventData, aEvent, mpObjShell );
}
// --- ::lang::XEventListener ---
void SAL_CALL SfxEvents_Impl::disposing( const lang::EventObject& /*Source*/ )
{
std::unique_lock aGuard( maMutex );
if ( mxBroadcaster.is() )
{
mxBroadcaster->removeDocumentEventListener( this );
mxBroadcaster = nullptr;
}
}
SfxEvents_Impl::SfxEvents_Impl( SfxObjectShell* pShell,
uno::Reference< document::XDocumentEventBroadcaster > const & xBroadcaster )
{
// get the list of supported events and store it
if ( pShell )
maEventNames = pShell->GetEventNames();
else
maEventNames = rtl::Reference<GlobalEventConfig>(new GlobalEventConfig)->getElementNames();
maEventData.resize( maEventNames.getLength() );
mpObjShell = pShell;
mxBroadcaster = xBroadcaster;
if ( mxBroadcaster.is() )
mxBroadcaster->addDocumentEventListener( this );
}
SfxEvents_Impl::~SfxEvents_Impl()
{
}
std::unique_ptr<SvxMacro> SfxEvents_Impl::ConvertToMacro( const uno::Any& rElement, SfxObjectShell* pObjShell )
{
std::unique_ptr<SvxMacro> pMacro;
uno::Sequence < beans::PropertyValue > aProperties;
uno::Any aAny;
NormalizeMacro( rElement, aAny, pObjShell );
if ( aAny >>= aProperties )
{
OUString aType;
OUString aScriptURL;
OUString aLibrary;
OUString aMacroName;
if ( !aProperties.hasElements() )
return pMacro;
for ( const auto& rProp : std::as_const(aProperties) )
{
if ( rProp.Name == PROP_EVENT_TYPE )
rProp.Value >>= aType;
else if ( rProp.Name == PROP_SCRIPT )
rProp.Value >>= aScriptURL;
else if ( rProp.Name == PROP_LIBRARY )
rProp.Value >>= aLibrary;
else if ( rProp.Name == PROP_MACRO_NAME )
rProp.Value >>= aMacroName;
else {
OSL_FAIL("Unknown property value!");
}
}
// Get the type
ScriptType eType( STARBASIC );
if ( aType == STAR_BASIC )
eType = STARBASIC;
else if (aType == "Script" && !aScriptURL.isEmpty())
eType = EXTENDED_STYPE;
else if ( aType == SVX_MACRO_LANGUAGE_JAVASCRIPT )
eType = JAVASCRIPT;
else {
SAL_WARN( "sfx.notify", "ConvertToMacro: Unknown macro type" );
}
if ( !aMacroName.isEmpty() )
{
if ( aLibrary == "application" )
aLibrary = SfxGetpApp()->GetName();
else
aLibrary.clear();
pMacro.reset(new SvxMacro( aMacroName, aLibrary, eType ));
}
else if ( eType == EXTENDED_STYPE )
pMacro.reset(new SvxMacro( aScriptURL, aType ));
}
return pMacro;
}
void SfxEvents_Impl::NormalizeMacro( const uno::Any& rEvent, uno::Any& rRet, SfxObjectShell* pDoc )
{
const ::comphelper::NamedValueCollection aEventDescriptor( rEvent );
::comphelper::NamedValueCollection aEventDescriptorOut;
NormalizeMacro( aEventDescriptor, aEventDescriptorOut, pDoc );
rRet <<= aEventDescriptorOut.getPropertyValues();
}
void SfxEvents_Impl::NormalizeMacro( const ::comphelper::NamedValueCollection& i_eventDescriptor,
::comphelper::NamedValueCollection& o_normalizedDescriptor, SfxObjectShell* i_document )
{
SfxObjectShell* pDoc = i_document;
if ( !pDoc )
pDoc = SfxObjectShell::Current();
OUString aType = i_eventDescriptor.getOrDefault( PROP_EVENT_TYPE, OUString() );
OUString aScript = i_eventDescriptor.getOrDefault( PROP_SCRIPT, OUString() );
OUString aLibrary = i_eventDescriptor.getOrDefault( PROP_LIBRARY, OUString() );
OUString aMacroName = i_eventDescriptor.getOrDefault( PROP_MACRO_NAME, OUString() );
if ( !aType.isEmpty() )
o_normalizedDescriptor.put( PROP_EVENT_TYPE, aType );
if ( !aScript.isEmpty() )
o_normalizedDescriptor.put( PROP_SCRIPT, aScript );
if ( aType != STAR_BASIC )
return;
if ( !aScript.isEmpty() )
{
if ( aMacroName.isEmpty() || aLibrary.isEmpty() )
{
sal_Int32 nThirdSlashPos = aScript.indexOf( '/', 8 );
sal_Int32 nArgsPos = aScript.indexOf( '(' );
if ( ( nThirdSlashPos != -1 ) && ( nArgsPos == -1 || nThirdSlashPos < nArgsPos ) )
{
OUString aBasMgrName( INetURLObject::decode( aScript.subView( 8, nThirdSlashPos-8 ), INetURLObject::DecodeMechanism::WithCharset ) );
if (pDoc && aBasMgrName == ".")
aLibrary = pDoc->GetTitle();
else
aLibrary = SfxGetpApp()->GetName();
// Get the macro name
aMacroName = aScript.copy( nThirdSlashPos+1, nArgsPos - nThirdSlashPos - 1 );
}
else
{
SAL_WARN( "sfx.notify", "ConvertToMacro: Unknown macro url format" );
}
}
}
else if ( !aMacroName.isEmpty() )
{
aScript = "macro://";
if ( aLibrary != SfxGetpApp()->GetName() && aLibrary != "StarDesktop" && aLibrary != "application" )
aScript += ".";
aScript += "/" + aMacroName + "()";
}
else
// wrong properties
return;
if (aLibrary != "document")
{
if ( aLibrary.isEmpty() || (pDoc && ( aLibrary == pDoc->GetTitle( SFX_TITLE_APINAME ) || aLibrary == pDoc->GetTitle() )) )
aLibrary = "document";
else
aLibrary = "application";
}
o_normalizedDescriptor.put( PROP_SCRIPT, aScript );
o_normalizedDescriptor.put( PROP_LIBRARY, aLibrary );
o_normalizedDescriptor.put( PROP_MACRO_NAME, aMacroName );
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Reference in a new issue View git blame Copy permalink