sfx2/source/notify/eventsupplier.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 <com/sun/star/beans/PropertyValue.hpp>
  21
  22 #include <com/sun/star/document/XEmbeddedScripts.hpp>
  23 #include <com/sun/star/document/XScriptInvocationContext.hpp>
  24 #include <com/sun/star/util/URL.hpp>
  25 #include <com/sun/star/frame/Desktop.hpp>
  26 #include <com/sun/star/util/URLTransformer.hpp>
  27 #include <com/sun/star/util/XURLTransformer.hpp>
  28 #include <com/sun/star/uno/XInterface.hpp>
  29 #include <tools/urlobj.hxx>
  30 #include <tools/diagnose_ex.h>
  31 #include <svl/macitem.hxx>
  32 #include <sfx2/objsh.hxx>
  33 #include <sfx2/evntconf.hxx>
  34 #include <unotools/eventcfg.hxx>
  35 #include <sal/log.hxx>
  36
  37 #include <comphelper/processfactory.hxx>
  38 #include <comphelper/namedvaluecollection.hxx>
  39 #include <comphelper/sequence.hxx>
  40 #include <eventsupplier.hxx>
  41
  42 #include <sfx2/app.hxx>
  43
  44 #include <sfx2/viewfrm.hxx>
  45 #include <sfx2/frame.hxx>
  46 #include <macroloader.hxx>
  47
  48 using namespace css;
  49 using namespace ::com::sun::star;
  50
  51
  52
  53     //  --- XNameReplace ---
  54
  55 void SAL_CALL SfxEvents_Impl::replaceByName( const OUString & aName, const uno::Any & rElement )
  56 {
  57     ::osl::MutexGuard aGuard( maMutex );
  58
  59     // find the event in the list and replace the data
  60     auto nIndex = comphelper::findValue(maEventNames, aName);
  61     if (nIndex != -1)
  62     {
  63         // check for correct type of the element
  64         if ( !::comphelper::NamedValueCollection::canExtractFrom( rElement ) )
  65             throw lang::IllegalArgumentException();
  66         ::comphelper::NamedValueCollection const aEventDescriptor( rElement );
  67
  68         // create Configuration at first, creation might call this method also and that would overwrite everything
  69         // we might have stored before!
  70         if ( mpObjShell && !mpObjShell->IsLoading() )
  71             mpObjShell->SetModified();
  72
  73         ::comphelper::NamedValueCollection aNormalizedDescriptor;
  74         NormalizeMacro( aEventDescriptor, aNormalizedDescriptor, mpObjShell );
  75
  76         OUString sType;
  77         if  (   ( aNormalizedDescriptor.size() == 1 )
  78             &&  !aNormalizedDescriptor.has( PROP_EVENT_TYPE ) //TODO
  79             &&  ( aNormalizedDescriptor.get( PROP_EVENT_TYPE ) >>= sType )
  80             &&  ( sType.isEmpty() )
  81             )
  82         {
  83             // An empty event type means no binding. Therefore reset data
  84             // to reflect that state.
  85             // (that's for compatibility only. Nowadays, the Tools/Customize dialog should
  86             // set an empty sequence to indicate the request for resetting the assignment.)
  87             OSL_ENSURE( false, "legacy event assignment format detected" );
  88             aNormalizedDescriptor.clear();
  89         }
  90
  91         if ( !aNormalizedDescriptor.empty() )
  92         {
  93             maEventData[nIndex] <<= aNormalizedDescriptor.getPropertyValues();
  94         }
  95         else
  96         {
  97             maEventData[nIndex].clear();
  98         }
  99         return;
 100     }
 101
 102     throw container::NoSuchElementException();
 103 }
 104
 105
 106 //  --- XNameAccess ---
 107
 108 uno::Any SAL_CALL SfxEvents_Impl::getByName( const OUString& aName )
 109 {
 110     ::osl::MutexGuard aGuard( maMutex );
 111
 112     // find the event in the list and return the data
 113
 114     auto nIndex = comphelper::findValue(maEventNames, aName);
 115     if (nIndex != -1)
 116         return maEventData[nIndex];
 117
 118     throw container::NoSuchElementException();
 119 }
 120
 121
 122 uno::Sequence< OUString > SAL_CALL SfxEvents_Impl::getElementNames()
 123 {
 124     return maEventNames;
 125 }
 126
 127
 128 sal_Bool SAL_CALL SfxEvents_Impl::hasByName( const OUString& aName )
 129 {
 130     ::osl::MutexGuard aGuard( maMutex );
 131
 132     // find the event in the list and return the data
 133
 134     return comphelper::findValue(maEventNames, aName) != -1;
 135 }
 136
 137
 138 //  --- XElementAccess ( parent of XNameAccess ) ---
 139
 140 uno::Type SAL_CALL SfxEvents_Impl::getElementType()
 141 {
 142     uno::Type aElementType = cppu::UnoType<uno::Sequence < beans::PropertyValue >>::get();
 143     return aElementType;
 144 }
 145
 146
 147 sal_Bool SAL_CALL SfxEvents_Impl::hasElements()
 148 {
 149     ::osl::MutexGuard aGuard( maMutex );
 150
 151     return maEventNames.hasElements();
 152 }
 153
 154 void SfxEvents_Impl::Execute( uno::Any const & aEventData, const document::DocumentEvent& aTrigger, SfxObjectShell* pDoc )
 155 {
 156     uno::Sequence < beans::PropertyValue > aProperties;
 157     if ( !(aEventData >>= aProperties) )
 158         return;
 159
 160     OUString aType;
 161     OUString aScript;
 162     OUString aLibrary;
 163     OUString aMacroName;
 164
 165     if ( !aProperties.hasElements() )
 166         return;
 167
 168     for ( const auto& rProp : std::as_const(aProperties) )
 169     {
 170         if ( rProp.Name == PROP_EVENT_TYPE )
 171             rProp.Value >>= aType;
 172         else if ( rProp.Name == PROP_SCRIPT )
 173             rProp.Value >>= aScript;
 174         else if ( rProp.Name == PROP_LIBRARY )
 175             rProp.Value >>= aLibrary;
 176         else if ( rProp.Name == PROP_MACRO_NAME )
 177             rProp.Value >>= aMacroName;
 178         else {
 179             OSL_FAIL("Unknown property value!");
 180         }
 181     }
 182
 183     if (aType.isEmpty())
 184     {
 185         // Empty type means no active binding for the event. Just ignore do nothing.
 186         return;
 187     }
 188
 189     if (aScript.isEmpty())
 190         return;
 191
 192     if (!pDoc)
 193         pDoc = SfxObjectShell::Current();
 194
 195     if (pDoc && !SfxObjectShell::isScriptAccessAllowed(pDoc->GetModel()))
 196         return;
 197
 198     if (aType == STAR_BASIC)
 199     {
 200         uno::Any aAny;
 201         SfxMacroLoader::loadMacro( aScript, aAny, pDoc );
 202     }
 203     else if (aType == "Service" || aType == "Script")
 204     {
 205         util::URL aURL;
 206         uno::Reference < util::XURLTransformer > xTrans( util::URLTransformer::create( ::comphelper::getProcessComponentContext() ) );
 207
 208         aURL.Complete = aScript;
 209         xTrans->parseStrict( aURL );
 210
 211         bool bAllowed = !SfxObjectShell::UnTrustedScript(aURL.Complete);
 212
 213         if (bAllowed)
 214         {
 215             SfxViewFrame* pView = SfxViewFrame::GetFirst(pDoc);
 216
 217             uno::Reference
 218                 < frame::XDispatchProvider > xProv;
 219
 220             if ( pView != nullptr )
 221             {
 222                 xProv = uno::Reference
 223                     < frame::XDispatchProvider > (
 224                         pView->GetFrame().GetFrameInterface(), uno::UNO_QUERY );
 225             }
 226             else
 227             {
 228                 xProv = frame::Desktop::create( ::comphelper::getProcessComponentContext() );
 229             }
 230
 231             uno::Reference < frame::XDispatch > xDisp;
 232             if ( xProv.is() )
 233                 xDisp = xProv->queryDispatch( aURL, OUString(), 0 );
 234
 235             if ( xDisp.is() )
 236             {
 237                 beans::PropertyValue aEventParam;
 238                 aEventParam.Value <<= aTrigger;
 239                 uno::Sequence< beans::PropertyValue > aDispatchArgs( &aEventParam, 1 );
 240                 xDisp->dispatch( aURL, aDispatchArgs );
 241             }
 242         }
 243     }
 244     else
 245     {
 246         SAL_WARN( "sfx.notify", "notifyEvent(): Unsupported event type" );
 247     }
 248 }
 249
 250
 251 // --- ::document::XEventListener ---
 252
 253 void SAL_CALL SfxEvents_Impl::notifyEvent( const document::EventObject& aEvent )
 254 {
 255     ::osl::ClearableMutexGuard aGuard( maMutex );
 256
 257     // get the event name, find the corresponding data, execute the data
 258
 259     auto nIndex = comphelper::findValue(maEventNames, aEvent.EventName);
 260     if ( nIndex == -1 )
 261         return;
 262
 263     uno::Any aEventData = maEventData[ nIndex ];
 264     aGuard.clear();
 265     Execute( aEventData, document::DocumentEvent(aEvent.Source, aEvent.EventName, nullptr, uno::Any()), mpObjShell );
 266 }
 267
 268
 269 // --- ::lang::XEventListener ---
 270
 271 void SAL_CALL SfxEvents_Impl::disposing( const lang::EventObject& /*Source*/ )
 272 {
 273     ::osl::MutexGuard aGuard( maMutex );
 274
 275     if ( mxBroadcaster.is() )
 276     {
 277         mxBroadcaster->removeEventListener( this );
 278         mxBroadcaster = nullptr;
 279     }
 280 }
 281
 282
 283 SfxEvents_Impl::SfxEvents_Impl( SfxObjectShell* pShell,
 284                                 uno::Reference< document::XEventBroadcaster > const & xBroadcaster )
 285 {
 286     // get the list of supported events and store it
 287     if ( pShell )
 288         maEventNames = pShell->GetEventNames();
 289     else
 290         maEventNames = rtl::Reference<GlobalEventConfig>(new GlobalEventConfig)->getElementNames();
 291
 292     maEventData = uno::Sequence < uno::Any > ( maEventNames.getLength() );
 293
 294     mpObjShell      = pShell;
 295     mxBroadcaster   = xBroadcaster;
 296
 297     if ( mxBroadcaster.is() )
 298         mxBroadcaster->addEventListener( this );
 299 }
 300
 301
 302 SfxEvents_Impl::~SfxEvents_Impl()
 303 {
 304 }
 305
 306
 307 std::unique_ptr<SvxMacro> SfxEvents_Impl::ConvertToMacro( const uno::Any& rElement, SfxObjectShell* pObjShell )
 308 {
 309     std::unique_ptr<SvxMacro> pMacro;
 310     uno::Sequence < beans::PropertyValue > aProperties;
 311     uno::Any aAny;
 312     NormalizeMacro( rElement, aAny, pObjShell );
 313
 314     if ( aAny >>= aProperties )
 315     {
 316         OUString aType;
 317         OUString aScriptURL;
 318         OUString aLibrary;
 319         OUString aMacroName;
 320
 321         if ( !aProperties.hasElements() )
 322             return pMacro;
 323
 324         for ( const auto& rProp : std::as_const(aProperties) )
 325         {
 326             if ( rProp.Name == PROP_EVENT_TYPE )
 327                 rProp.Value >>= aType;
 328             else if ( rProp.Name == PROP_SCRIPT )
 329                 rProp.Value >>= aScriptURL;
 330             else if ( rProp.Name == PROP_LIBRARY )
 331                 rProp.Value >>= aLibrary;
 332             else if ( rProp.Name == PROP_MACRO_NAME )
 333                 rProp.Value >>= aMacroName;
 334             else {
 335                 OSL_FAIL("Unknown property value!");
 336             }
 337         }
 338
 339         // Get the type
 340         ScriptType  eType( STARBASIC );
 341         if ( aType == STAR_BASIC )
 342             eType = STARBASIC;
 343         else if (aType == "Script" && !aScriptURL.isEmpty())
 344             eType = EXTENDED_STYPE;
 345         else if ( aType == SVX_MACRO_LANGUAGE_JAVASCRIPT )
 346             eType = JAVASCRIPT;
 347         else {
 348             SAL_WARN( "sfx.notify", "ConvertToMacro: Unknown macro type" );
 349         }
 350
 351         if ( !aMacroName.isEmpty() )
 352         {
 353             if ( aLibrary == "application" )
 354                 aLibrary = SfxGetpApp()->GetName();
 355             else
 356                 aLibrary.clear();
 357             pMacro.reset(new SvxMacro( aMacroName, aLibrary, eType ));
 358         }
 359         else if ( eType == EXTENDED_STYPE )
 360             pMacro.reset(new SvxMacro( aScriptURL, aType ));
 361     }
 362
 363     return pMacro;
 364 }
 365
 366 void SfxEvents_Impl::NormalizeMacro( const uno::Any& rEvent, uno::Any& rRet, SfxObjectShell* pDoc )
 367 {
 368     const ::comphelper::NamedValueCollection aEventDescriptor( rEvent );
 369     ::comphelper::NamedValueCollection aEventDescriptorOut;
 370
 371     NormalizeMacro( aEventDescriptor, aEventDescriptorOut, pDoc );
 372
 373     rRet <<= aEventDescriptorOut.getPropertyValues();
 374 }
 375
 376 void SfxEvents_Impl::NormalizeMacro( const ::comphelper::NamedValueCollection& i_eventDescriptor,
 377         ::comphelper::NamedValueCollection& o_normalizedDescriptor, SfxObjectShell* i_document )
 378 {
 379     SfxObjectShell* pDoc = i_document;
 380     if ( !pDoc )
 381         pDoc = SfxObjectShell::Current();
 382
 383     OUString aType = i_eventDescriptor.getOrDefault( PROP_EVENT_TYPE, OUString() );
 384     OUString aScript = i_eventDescriptor.getOrDefault( PROP_SCRIPT, OUString() );
 385     OUString aLibrary = i_eventDescriptor.getOrDefault( PROP_LIBRARY, OUString() );
 386     OUString aMacroName = i_eventDescriptor.getOrDefault( PROP_MACRO_NAME, OUString() );
 387
 388     if ( !aType.isEmpty() )
 389         o_normalizedDescriptor.put( PROP_EVENT_TYPE, aType );
 390     if ( !aScript.isEmpty() )
 391         o_normalizedDescriptor.put( PROP_SCRIPT, aScript );
 392
 393     if ( aType != STAR_BASIC )
 394         return;
 395
 396     if ( !aScript.isEmpty() )
 397     {
 398         if ( aMacroName.isEmpty() || aLibrary.isEmpty() )
 399         {
 400             sal_Int32 nThirdSlashPos = aScript.indexOf( '/', 8 );
 401             sal_Int32 nArgsPos = aScript.indexOf( '(' );
 402             if ( ( nThirdSlashPos != -1 ) && ( nArgsPos == -1 || nThirdSlashPos < nArgsPos ) )
 403             {
 404                 OUString aBasMgrName( INetURLObject::decode( aScript.copy( 8, nThirdSlashPos-8 ), INetURLObject::DecodeMechanism::WithCharset ) );
 405                 if (pDoc && aBasMgrName == ".")
 406                     aLibrary = pDoc->GetTitle();
 407                 else
 408                     aLibrary = SfxGetpApp()->GetName();
 409
 410                 // Get the macro name
 411                 aMacroName = aScript.copy( nThirdSlashPos+1, nArgsPos - nThirdSlashPos - 1 );
 412             }
 413             else
 414             {
 415                 SAL_WARN( "sfx.notify", "ConvertToMacro: Unknown macro url format" );
 416             }
 417         }
 418     }
 419     else if ( !aMacroName.isEmpty() )
 420     {
 421         aScript = "macro://";
 422         if ( aLibrary != SfxGetpApp()->GetName() && aLibrary != "StarDesktop" && aLibrary != "application" )
 423             aScript += ".";
 424         aScript += "/" + aMacroName + "()";
 425     }
 426     else
 427         // wrong properties
 428         return;
 429
 430     if (aLibrary != "document")
 431     {
 432         if ( aLibrary.isEmpty() || (pDoc && ( aLibrary == pDoc->GetTitle( SFX_TITLE_APINAME ) || aLibrary == pDoc->GetTitle() )) )
 433             aLibrary = "document";
 434         else
 435             aLibrary = "application";
 436     }
 437
 438     o_normalizedDescriptor.put( PROP_SCRIPT, aScript );
 439     o_normalizedDescriptor.put( PROP_LIBRARY, aLibrary );
 440     o_normalizedDescriptor.put( PROP_MACRO_NAME, aMacroName );
 441 }
 442
 443 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */