sfx2/source/appl/macroloader.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 <config_features.h>
  21
  22 #include <macroloader.hxx>
  23
  24 #include <com/sun/star/frame/DispatchResultState.hpp>
  25 #include <basic/basmgr.hxx>
  26 #include <basic/sbuno.hxx>
  27 #include <basic/sberrors.hxx>
  28 #include <cppuhelper/supportsservice.hxx>
  29 #include <cppuhelper/weak.hxx>
  30 #include <cppuhelper/weakref.hxx>
  31 #include <framework/documentundoguard.hxx>
  32 #include <sfx2/app.hxx>
  33 #include <sfx2/frame.hxx>
  34 #include <sfx2/objsh.hxx>
  35 #include <tools/urlobj.hxx>
  36 #include <vcl/svapp.hxx>
  37
  38 #include <memory>
  39
  40 using namespace ::com::sun::star;
  41 using namespace ::com::sun::star::frame;
  42 using namespace ::com::sun::star::lang;
  43 using namespace ::com::sun::star::uno;
  44 using namespace ::com::sun::star::util;
  45
  46 SfxMacroLoader::SfxMacroLoader(const css::uno::Sequence< css::uno::Any >& aArguments)
  47 {
  48     Reference < XFrame > xFrame;
  49     if ( aArguments.hasElements() )
  50     {
  51         aArguments[0] >>= xFrame;
  52         m_xFrame = xFrame;
  53     }
  54 }
  55
  56 OUString SAL_CALL SfxMacroLoader::getImplementationName()
  57 {
  58     return "com.sun.star.comp.sfx2.SfxMacroLoader";
  59 }
  60
  61 sal_Bool SAL_CALL SfxMacroLoader::supportsService(OUString const & ServiceName)
  62 {
  63     return cppu::supportsService(this, ServiceName);
  64 }
  65
  66 css::uno::Sequence<OUString> SAL_CALL SfxMacroLoader::getSupportedServiceNames()
  67 {
  68     return { "com.sun.star.frame.ProtocolHandler" };
  69 }
  70
  71 SfxObjectShell* SfxMacroLoader::GetObjectShell_Impl()
  72 {
  73     SfxObjectShell* pDocShell = nullptr;
  74     Reference < XFrame > xFrame( m_xFrame.get(), UNO_QUERY );
  75     if ( xFrame.is() )
  76     {
  77         SfxFrame* pFrame=nullptr;
  78         for ( pFrame = SfxFrame::GetFirst(); pFrame; pFrame = SfxFrame::GetNext( *pFrame ) )
  79         {
  80             if ( pFrame->GetFrameInterface() == xFrame )
  81                 break;
  82         }
  83
  84         if ( pFrame )
  85             pDocShell = pFrame->GetCurrentDocument();
  86     }
  87
  88     return pDocShell;
  89 }
  90
  91
  92 uno::Reference<frame::XDispatch> SAL_CALL SfxMacroLoader::queryDispatch(
  93     const util::URL&   aURL            ,
  94     const OUString&               /*sTargetFrameName*/,
  95     sal_Int32                            /*nSearchFlags*/    )
  96 {
  97     uno::Reference<frame::XDispatch> xDispatcher;
  98     if(aURL.Complete.startsWith("macro:"))
  99         xDispatcher = this;
 100     return xDispatcher;
 101 }
 102
 103
 104 uno::Sequence< uno::Reference<frame::XDispatch> > SAL_CALL
 105                 SfxMacroLoader::queryDispatches( const uno::Sequence < frame::DispatchDescriptor >& seqDescriptor )
 106 {
 107     sal_Int32 nCount = seqDescriptor.getLength();
 108     uno::Sequence< uno::Reference<frame::XDispatch> > lDispatcher(nCount);
 109     std::transform(seqDescriptor.begin(), seqDescriptor.end(), lDispatcher.begin(),
 110         [this](const frame::DispatchDescriptor& rDescr) -> uno::Reference<frame::XDispatch> {
 111             return queryDispatch(rDescr.FeatureURL, rDescr.FrameName, rDescr.SearchFlags); });
 112     return lDispatcher;
 113 }
 114
 115
 116 void SAL_CALL SfxMacroLoader::dispatchWithNotification(
 117     const util::URL& aURL, const uno::Sequence<beans::PropertyValue>& /*lArgs*/,
 118     const uno::Reference<frame::XDispatchResultListener>& xListener )
 119 {
 120     SolarMutexGuard aGuard;
 121
 122     uno::Any aAny;
 123     ErrCode nErr = loadMacro( aURL.Complete, aAny, GetObjectShell_Impl() );
 124     if( !xListener.is() )
 125         return;
 126
 127     // always call dispatchFinished(), because we didn't load a document but
 128     // executed a macro instead!
 129     frame::DispatchResultEvent aEvent;
 130
 131     aEvent.Source = static_cast< ::cppu::OWeakObject* >(this);
 132     if( nErr == ERRCODE_NONE )
 133         aEvent.State = frame::DispatchResultState::SUCCESS;
 134     else
 135         aEvent.State = frame::DispatchResultState::FAILURE;
 136
 137     xListener->dispatchFinished( aEvent ) ;
 138 }
 139
 140 uno::Any SAL_CALL SfxMacroLoader::dispatchWithReturnValue(
 141     const util::URL& aURL, const uno::Sequence<beans::PropertyValue>& )
 142 {
 143     uno::Any aRet;
 144     ErrCode nErr = loadMacro( aURL.Complete, aRet, GetObjectShell_Impl() );
 145
 146     // aRet gets set to a different value only if nErr == ERRCODE_NONE
 147     // Return it in such case to preserve the original behaviour
 148
 149     // In all other cases (nErr != ERRCODE_NONE), the calling code gets
 150     // the actual error code back
 151     if ( nErr != ERRCODE_NONE )
 152     {
 153         beans::PropertyValue aErrorCode;
 154
 155         aErrorCode.Name = "ErrorCode";
 156         aErrorCode.Value <<= sal_uInt32(nErr);
 157
 158         aRet <<= aErrorCode;
 159     }
 160
 161     return aRet;
 162 }
 163
 164 void SAL_CALL SfxMacroLoader::dispatch(
 165     const util::URL& aURL, const uno::Sequence<beans::PropertyValue>& /*lArgs*/ )
 166 {
 167     SolarMutexGuard aGuard;
 168
 169     uno::Any aAny;
 170     loadMacro( aURL.Complete, aAny, GetObjectShell_Impl() );
 171 }
 172
 173 void SAL_CALL SfxMacroLoader::addStatusListener(
 174     const uno::Reference< frame::XStatusListener >& ,
 175     const util::URL&                                                    )
 176 {
 177     /* TODO
 178             How we can handle different listener for further coming or currently running dispatch() jobs
 179             without any inconsistency!
 180      */
 181 }
 182
 183
 184 void SAL_CALL SfxMacroLoader::removeStatusListener(
 185     const uno::Reference< frame::XStatusListener >&,
 186     const util::URL&                                                  )
 187 {
 188 }
 189
 190 ErrCode SfxMacroLoader::loadMacro( const OUString& rURL, css::uno::Any& rRetval, SfxObjectShell* pSh )
 191 {
 192 #if !HAVE_FEATURE_SCRIPTING
 193     (void) rURL;
 194     (void) rRetval;
 195     (void) pSh;
 196     return ERRCODE_BASIC_PROC_UNDEFINED;
 197 #else
 198     SfxObjectShell* pCurrent = pSh;
 199     if ( !pCurrent )
 200         // all not full qualified names use the BASIC of the given or current document
 201         pCurrent = SfxObjectShell::Current();
 202
 203     // 'macro:///lib.mod.proc(args)' => macro of App-BASIC
 204     // 'macro://[docname|.]/lib.mod.proc(args)' => macro of current or qualified document
 205     // 'macro://obj.method(args)' => direct API call, execute it via App-BASIC
 206     const OUString& aMacro( rURL );
 207     sal_Int32 nThirdSlashPos = aMacro.indexOf( '/', 8 );
 208     sal_Int32 nArgsPos = aMacro.indexOf( '(' );
 209     BasicManager *pAppMgr = SfxApplication::GetBasicManager();
 210     BasicManager *pBasMgr = nullptr;
 211     ErrCode nErr = ERRCODE_NONE;
 212
 213     // should a macro function be executed ( no direct API call)?
 214     if ( -1 != nThirdSlashPos && ( -1 == nArgsPos || nThirdSlashPos < nArgsPos ) )
 215     {
 216         // find BasicManager
 217         SfxObjectShell* pDoc = nullptr;
 218         OUString aBasMgrName( INetURLObject::decode(aMacro.copy( 8, nThirdSlashPos-8 ), INetURLObject::DecodeMechanism::WithCharset) );
 219         if ( aBasMgrName.isEmpty() )
 220             pBasMgr = pAppMgr;
 221         else if ( aBasMgrName == "." )
 222         {
 223             // current/actual document
 224             pDoc = pCurrent;
 225             if (pDoc)
 226                 pBasMgr = pDoc->GetBasicManager();
 227         }
 228         else
 229         {
 230             // full qualified name, find document by name
 231             for ( SfxObjectShell *pObjSh = SfxObjectShell::GetFirst();
 232                     pObjSh && !pBasMgr;
 233                     pObjSh = SfxObjectShell::GetNext(*pObjSh) )
 234                 if ( aBasMgrName == pObjSh->GetTitle(SFX_TITLE_APINAME) )
 235                 {
 236                     pDoc = pObjSh;
 237                     pBasMgr = pDoc->GetBasicManager();
 238                 }
 239         }
 240
 241         if ( pBasMgr )
 242         {
 243             const bool bIsAppBasic = ( pBasMgr == pAppMgr );
 244             const bool bIsDocBasic = ( pBasMgr != pAppMgr );
 245
 246             if ( pDoc )
 247             {
 248                 // security check for macros from document basic if an SFX doc is given
 249                 if ( !pDoc->AdjustMacroMode() )
 250                     // check forbids execution
 251                     return ERRCODE_IO_ACCESSDENIED;
 252             }
 253
 254             // find BASIC method
 255             OUString aQualifiedMethod( INetURLObject::decode(aMacro.copy( nThirdSlashPos+1 ), INetURLObject::DecodeMechanism::WithCharset) );
 256             OUString aArgs;
 257             if ( -1 != nArgsPos )
 258             {
 259                 // remove arguments from macro name
 260                 aArgs = aQualifiedMethod.copy( nArgsPos - nThirdSlashPos - 1 );
 261                 aQualifiedMethod = aQualifiedMethod.copy( 0, nArgsPos - nThirdSlashPos - 1 );
 262             }
 263
 264             if ( pBasMgr->HasMacro( aQualifiedMethod ) )
 265             {
 266                 Any aOldThisComponent;
 267                 const bool bSetDocMacroMode = ( pDoc != nullptr ) && bIsDocBasic;
 268                 const bool bSetGlobalThisComponent = ( pDoc != nullptr ) && bIsAppBasic;
 269                 if ( bSetDocMacroMode )
 270                 {
 271                     // mark document: it executes an own macro, so it's in a modal mode
 272                     pDoc->SetMacroMode_Impl();
 273                 }
 274
 275                 if ( bSetGlobalThisComponent )
 276                 {
 277                     // document is executed via AppBASIC, adjust ThisComponent variable
 278                     aOldThisComponent = pAppMgr->SetGlobalUNOConstant( "ThisComponent", makeAny( pDoc->GetModel() ) );
 279                 }
 280
 281                 // just to let the shell be alive
 282                 SfxObjectShellRef xKeepDocAlive = pDoc;
 283
 284                 {
 285                     // attempt to protect the document against the script tampering with its Undo Context
 286                     std::unique_ptr< ::framework::DocumentUndoGuard > pUndoGuard;
 287                     if ( bIsDocBasic )
 288                         pUndoGuard.reset( new ::framework::DocumentUndoGuard( pDoc->GetModel() ) );
 289
 290                     // execute the method
 291                     SbxVariableRef retValRef = new SbxVariable;
 292                     nErr = pBasMgr->ExecuteMacro( aQualifiedMethod, aArgs, retValRef.get() );
 293                     if ( nErr == ERRCODE_NONE )
 294                         rRetval = sbxToUnoValue( retValRef.get() );
 295                 }
 296
 297                 if ( bSetGlobalThisComponent )
 298                 {
 299                     pAppMgr->SetGlobalUNOConstant( "ThisComponent", aOldThisComponent );
 300                 }
 301
 302                 if ( bSetDocMacroMode )
 303                 {
 304                     // remove flag for modal mode
 305                     pDoc->SetMacroMode_Impl( false );
 306                 }
 307             }
 308             else
 309                 nErr = ERRCODE_BASIC_PROC_UNDEFINED;
 310         }
 311         else
 312             nErr = ERRCODE_IO_NOTEXISTS;
 313     }
 314     else
 315     {
 316         // direct API call on a specified object
 317         OUStringBuffer aCall;
 318         aCall.append('[').append(INetURLObject::decode(aMacro.copy(6),
 319             INetURLObject::DecodeMechanism::WithCharset));
 320         aCall.append(']');
 321         pAppMgr->GetLib(0)->Execute(aCall.makeStringAndClear());
 322         nErr = SbxBase::GetError();
 323     }
 324
 325     SbxBase::ResetError();
 326     return nErr;
 327 #endif
 328 }
 329
 330 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
 331 com_sun_star_comp_sfx2_SfxMacroLoader_get_implementation(
 332     css::uno::XComponentContext *,
 333     css::uno::Sequence<css::uno::Any> const &arguments)
 334 {
 335     return cppu::acquire(new SfxMacroLoader(arguments));
 336 }
 337
 338 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */