diff options
Diffstat (limited to '')
| -rw-r--r-- | sfx2/source/notify/eventsupplier.cxx | 471 |
1 files changed, 471 insertions, 0 deletions
diff --git a/sfx2/source/notify/eventsupplier.cxx b/sfx2/source/notify/eventsupplier.cxx new file mode 100644 index 000000000..d6bff98de --- /dev/null +++ b/sfx2/source/notify/eventsupplier.cxx @@ -0,0 +1,471 @@ +/* -*- 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: */ |