scripting/source/basprov/basprov.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 "basprov.hxx"
  21 #include "basscript.hxx"
  22 #include "baslibnode.hxx"
  23 #include <com/sun/star/frame/XModel.hpp>
  24 #include <com/sun/star/script/browse/BrowseNodeTypes.hpp>
  25 #include <com/sun/star/script/provider/ScriptFrameworkErrorException.hpp>
  26 #include <com/sun/star/script/provider/ScriptFrameworkErrorType.hpp>
  27 #include <com/sun/star/document/XEmbeddedScripts.hpp>
  28 #include <com/sun/star/uri/UriReferenceFactory.hpp>
  29
  30 #include <cppuhelper/implementationentry.hxx>
  31 #include <cppuhelper/supportsservice.hxx>
  32 #include <rtl/uri.hxx>
  33 #include <osl/process.h>
  34 #include <osl/file.hxx>
  35 #include <osl/mutex.hxx>
  36 #include <vcl/svapp.hxx>
  37 #include <basic/sbx.hxx>
  38 #include <basic/basmgr.hxx>
  39 #include <basic/basicmanagerrepository.hxx>
  40 #include <basic/sbstar.hxx>
  41 #include <basic/sbmod.hxx>
  42 #include <basic/sbmeth.hxx>
  43 #include <sfx2/app.hxx>
  44 #include <sfx2/objsh.hxx>
  45
  46 #include <com/sun/star/util/theMacroExpander.hpp>
  47 #include <com/sun/star/script/XLibraryContainer2.hpp>
  48 #include <com/sun/star/uri/XUriReference.hpp>
  49 #include <com/sun/star/uri/XUriReferenceFactory.hpp>
  50 #include <com/sun/star/uri/XVndSunStarScriptUrl.hpp>
  51
  52 #include <util/MiscUtils.hxx>
  53
  54
  55 using namespace ::com::sun::star;
  56 using namespace ::com::sun::star::lang;
  57 using namespace ::com::sun::star::uno;
  58 using namespace ::com::sun::star::script;
  59 using namespace ::com::sun::star::document;
  60 using namespace ::sf_misc;
  61
  62
  63 namespace basprov
  64 {
  65
  66
  67     // component operations
  68
  69
  70     static OUString getImplementationName_BasicProviderImpl()
  71     {
  72         return OUString( "com.sun.star.comp.scripting.ScriptProviderForBasic"  );
  73     }
  74
  75
  76     static Sequence< OUString > getSupportedServiceNames_BasicProviderImpl()
  77     {
  78         static Sequence< OUString >* pNames = nullptr;
  79         if ( !pNames )
  80         {
  81             ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
  82             if ( !pNames )
  83             {
  84                 static Sequence< OUString > aNames(4);
  85                 aNames.getArray()[0] = "com.sun.star.script.provider.ScriptProviderForBasic";
  86                 aNames.getArray()[1] = "com.sun.star.script.provider.LanguageScriptProvider";
  87                 aNames.getArray()[2] = "com.sun.star.script.provider.ScriptProvider";
  88                 aNames.getArray()[3] = "com.sun.star.script.browse.BrowseNode";
  89                 pNames = &aNames;
  90             }
  91         }
  92         return *pNames;
  93     }
  94
  95
  96     // BasicProviderImpl
  97
  98
  99     BasicProviderImpl::BasicProviderImpl( const Reference< XComponentContext >& xContext )
 100         :m_pAppBasicManager( nullptr )
 101         ,m_pDocBasicManager( nullptr )
 102         ,m_xLibContainerApp( nullptr )
 103         ,m_xLibContainerDoc( nullptr )
 104         ,m_xContext( xContext )
 105         ,m_bIsAppScriptCtx( true )
 106         ,m_bIsUserCtx(true)
 107     {
 108     }
 109
 110
 111     BasicProviderImpl::~BasicProviderImpl()
 112     {
 113     }
 114
 115
 116     bool BasicProviderImpl::isLibraryShared( const Reference< script::XLibraryContainer >& rxLibContainer, const OUString& rLibName )
 117     {
 118         bool bIsShared = false;
 119
 120         Reference< script::XLibraryContainer2 > xLibContainer( rxLibContainer, UNO_QUERY );
 121         if ( xLibContainer.is() && xLibContainer->hasByName( rLibName ) && xLibContainer->isLibraryLink( rLibName ) )
 122         {
 123             OUString aFileURL;
 124             if ( m_xContext.is() )
 125             {
 126                 Reference< uri::XUriReferenceFactory > xUriFac( uri::UriReferenceFactory::create( m_xContext ) );
 127
 128                 OUString aLinkURL( xLibContainer->getLibraryLinkURL( rLibName ) );
 129                 Reference<  uri::XUriReference > xUriRef( xUriFac->parse( aLinkURL ), UNO_QUERY );
 130
 131                 if ( xUriRef.is() )
 132                 {
 133                     OUString aScheme = xUriRef->getScheme();
 134                     if ( aScheme.equalsIgnoreAsciiCase("file") )
 135                     {
 136                         aFileURL = aLinkURL;
 137                     }
 138                     else if ( aScheme.equalsIgnoreAsciiCase("vnd.sun.star.pkg") )
 139                     {
 140                         OUString aAuthority = xUriRef->getAuthority();
 141                         if ( aAuthority.matchIgnoreAsciiCase( "vnd.sun.star.expand:" ) )
 142                         {
 143                             OUString aDecodedURL( aAuthority.copy( sizeof ( "vnd.sun.star.expand:" ) - 1 ) );
 144                             aDecodedURL = ::rtl::Uri::decode( aDecodedURL, rtl_UriDecodeWithCharset, RTL_TEXTENCODING_UTF8 );
 145                             Reference<util::XMacroExpander> xMacroExpander =
 146                                 util::theMacroExpander::get(m_xContext);
 147                             aFileURL = xMacroExpander->expandMacros( aDecodedURL );
 148                         }
 149                     }
 150                 }
 151             }
 152
 153             if ( !aFileURL.isEmpty() )
 154             {
 155                 osl::DirectoryItem aFileItem;
 156                 osl::FileStatus aFileStatus( osl_FileStatus_Mask_FileURL );
 157                 OSL_VERIFY( osl::DirectoryItem::get( aFileURL, aFileItem ) == osl::FileBase::E_None );
 158                 OSL_VERIFY( aFileItem.getFileStatus( aFileStatus ) == osl::FileBase::E_None );
 159                 OUString aCanonicalFileURL( aFileStatus.getFileURL() );
 160
 161                 OUString aSearchURL1( "share/basic"  );
 162                 OUString aSearchURL2( "share/uno_packages"  );
 163                 if( aCanonicalFileURL.indexOf( aSearchURL1 ) != -1 || aCanonicalFileURL.indexOf( aSearchURL2 ) != -1 )
 164                     bIsShared = true;
 165             }
 166         }
 167
 168         return bIsShared;
 169     }
 170
 171     // XServiceInfo
 172     OUString BasicProviderImpl::getImplementationName(  )
 173     {
 174         return getImplementationName_BasicProviderImpl();
 175     }
 176
 177     sal_Bool BasicProviderImpl::supportsService( const OUString& rServiceName )
 178     {
 179         return cppu::supportsService(this, rServiceName);
 180     }
 181
 182     Sequence< OUString > BasicProviderImpl::getSupportedServiceNames(  )
 183     {
 184         return getSupportedServiceNames_BasicProviderImpl();
 185     }
 186
 187
 188     // XInitialization
 189
 190
 191     void BasicProviderImpl::initialize( const Sequence< Any >& aArguments )
 192     {
 193         // TODO
 194
 195         SolarMutexGuard aGuard;
 196
 197         if ( aArguments.getLength() != 1 )
 198         {
 199             throw IllegalArgumentException(
 200                 "BasicProviderImpl::initialize: incorrect argument count.",
 201                 *this,
 202                 1
 203             );
 204         }
 205
 206         Reference< frame::XModel > xModel;
 207
 208         m_xInvocationContext.set( aArguments[0], UNO_QUERY );
 209         if ( m_xInvocationContext.is() )
 210         {
 211             xModel.set( m_xInvocationContext->getScriptContainer(), UNO_QUERY );
 212             if ( !xModel.is() )
 213             {
 214                 throw IllegalArgumentException(
 215                     "BasicProviderImpl::initialize: unable to determine the document model from the script invocation context.",
 216                     *this,
 217                     1
 218                 );
 219             }
 220         }
 221         else
 222         {
 223             if ( !( aArguments[0] >>= m_sScriptingContext ) )
 224             {
 225                 throw IllegalArgumentException(
 226                     "BasicProviderImpl::initialize: incorrect argument type " + aArguments[0].getValueTypeName(),
 227                     *this,
 228                     1
 229                 );
 230             }
 231
 232             OUString sDoc = "vnd.sun.star.tdoc";
 233             if ( m_sScriptingContext.startsWith( sDoc  ) )
 234             {
 235                 xModel = MiscUtils::tDocUrlToModel(  m_sScriptingContext );
 236                 // TODO: use ScriptingContantsPool for SCRIPTING_DOC_REF
 237             }
 238         }
 239
 240         if ( xModel.is() )
 241         {
 242             Reference< XEmbeddedScripts > xDocumentScripts( xModel, UNO_QUERY );
 243             if ( xDocumentScripts.is() )
 244             {
 245                 m_pDocBasicManager = ::basic::BasicManagerRepository::getDocumentBasicManager( xModel );
 246                 m_xLibContainerDoc.set( xDocumentScripts->getBasicLibraries(), UNO_QUERY );
 247                 OSL_ENSURE( m_pDocBasicManager && m_xLibContainerDoc.is(),
 248                     "BasicProviderImpl::initialize: invalid BasicManager, or invalid script container!" );
 249             }
 250             m_bIsAppScriptCtx = false;
 251         }
 252         else
 253         {
 254             // Provider has been created with application context for user
 255             // or share
 256             if ( m_sScriptingContext != "user" )
 257             {
 258                 m_bIsUserCtx = false;
 259             }
 260             else
 261             {
 262                 /*
 263                 throw RuntimeException(
 264                     "BasicProviderImpl::initialize: no scripting context!" );
 265                 */
 266             }
 267         }
 268
 269         // TODO
 270         if ( !m_pAppBasicManager )
 271             m_pAppBasicManager = SfxApplication::GetBasicManager();
 272
 273         if ( !m_xLibContainerApp.is() )
 274             m_xLibContainerApp.set( SfxGetpApp()->GetBasicContainer(), UNO_QUERY );
 275     }
 276
 277
 278     // XScriptProvider
 279
 280
 281     Reference < provider::XScript > BasicProviderImpl::getScript( const OUString& scriptURI )
 282     {
 283         // TODO
 284
 285         SolarMutexGuard aGuard;
 286
 287         Reference< provider::XScript > xScript;
 288         Reference< uri::XUriReferenceFactory > xFac ( uri::UriReferenceFactory::create( m_xContext )  );
 289
 290         Reference<  uri::XUriReference > uriRef(
 291             xFac->parse( scriptURI ), UNO_QUERY );
 292
 293         Reference < uri::XVndSunStarScriptUrl > sfUri( uriRef, UNO_QUERY );
 294
 295         if ( !uriRef.is() || !sfUri.is() )
 296         {
 297             OUString errorMsg("BasicProviderImpl::getScript: failed to parse URI: ");
 298             errorMsg = errorMsg.concat( scriptURI );
 299             throw provider::ScriptFrameworkErrorException(
 300                 errorMsg, Reference< XInterface >(),
 301                 scriptURI, "Basic",
 302                 provider::ScriptFrameworkErrorType::MALFORMED_URL );
 303         }
 304
 305
 306         OUString aDescription = sfUri->getName();
 307         OUString aLocation = sfUri->getParameter( "location" );
 308
 309         sal_Int32 nIndex = 0;
 310         // In some strange circumstances the Library name can have an
 311         // apparently illegal '.' in it ( in imported VBA )
 312
 313         BasicManager* pBasicMgr =  nullptr;
 314         if ( aLocation == "document" )
 315         {
 316             pBasicMgr = m_pDocBasicManager;
 317         }
 318         else if ( aLocation == "application" )
 319         {
 320             pBasicMgr = m_pAppBasicManager;
 321         }
 322         OUString sProjectName;
 323         if (  pBasicMgr )
 324             sProjectName = pBasicMgr->GetName();
 325
 326         OUString aLibrary;
 327         if ( !sProjectName.isEmpty() && aDescription.match( sProjectName ) )
 328         {
 329             SAL_WARN("scripting", "LibraryName " << sProjectName << " is part of the url " << aDescription );
 330             aLibrary = sProjectName;
 331             nIndex = sProjectName.getLength() + 1;
 332         }
 333         else
 334             aLibrary = aDescription.getToken( 0, '.', nIndex );
 335         OUString aModule;
 336         if ( nIndex != -1 )
 337             aModule = aDescription.getToken( 0, '.', nIndex );
 338         OUString aMethod;
 339         if ( nIndex != -1 )
 340             aMethod = aDescription.getToken( 0, '.', nIndex );
 341
 342         if ( !aLibrary.isEmpty() && !aModule.isEmpty() && !aMethod.isEmpty() && !aLocation.isEmpty() )
 343         {
 344
 345             if ( pBasicMgr )
 346             {
 347                 StarBASIC* pBasic = pBasicMgr->GetLib( aLibrary );
 348                 if ( !pBasic )
 349                 {
 350                     sal_uInt16 nId = pBasicMgr->GetLibId( aLibrary );
 351                     if ( nId != LIB_NOTFOUND )
 352                     {
 353                         pBasicMgr->LoadLib( nId );
 354                         pBasic = pBasicMgr->GetLib( aLibrary );
 355                     }
 356                 }
 357                 if ( pBasic )
 358                 {
 359                     SbModule* pModule = pBasic->FindModule( aModule );
 360                     if ( pModule )
 361                     {
 362                         SbMethod* pMethod = pModule->FindMethod( aMethod, SbxClassType::Method );
 363                         if ( pMethod && !pMethod->IsHidden() )
 364                         {
 365                             if ( m_pDocBasicManager == pBasicMgr )
 366                                 xScript = new BasicScriptImpl( aDescription, pMethod, *m_pDocBasicManager, m_xInvocationContext );
 367                             else
 368                                 xScript = new BasicScriptImpl( aDescription, pMethod );
 369                         }
 370                     }
 371                 }
 372             }
 373         }
 374
 375         if ( !xScript.is() )
 376         {
 377             throw provider::ScriptFrameworkErrorException(
 378                 "The following Basic script could not be found:\n"
 379                 "library: '" + aLibrary + "'\n"
 380                 "module: '" + aModule + "'\n"
 381                 "method: '" + aMethod + "'\n"
 382                 "location: '" + aLocation + "'\n",
 383                 Reference< XInterface >(),
 384                 scriptURI, "Basic",
 385                 provider::ScriptFrameworkErrorType::NO_SUCH_SCRIPT );
 386         }
 387
 388         return xScript;
 389     }
 390
 391
 392     // XBrowseNode
 393
 394
 395     OUString BasicProviderImpl::getName(  )
 396     {
 397         return OUString("Basic");
 398     }
 399
 400
 401     Sequence< Reference< browse::XBrowseNode > > BasicProviderImpl::getChildNodes(  )
 402     {
 403         SolarMutexGuard aGuard;
 404
 405         Reference< script::XLibraryContainer > xLibContainer;
 406         BasicManager* pBasicManager = nullptr;
 407
 408         if ( m_bIsAppScriptCtx )
 409         {
 410             xLibContainer = m_xLibContainerApp;
 411             pBasicManager = m_pAppBasicManager;
 412         }
 413         else
 414         {
 415             xLibContainer = m_xLibContainerDoc;
 416             pBasicManager = m_pDocBasicManager;
 417         }
 418
 419         Sequence< Reference< browse::XBrowseNode > > aChildNodes;
 420
 421         if ( pBasicManager && xLibContainer.is() )
 422         {
 423             Sequence< OUString > aLibNames = xLibContainer->getElementNames();
 424             sal_Int32 nLibCount = aLibNames.getLength();
 425             const OUString* pLibNames = aLibNames.getConstArray();
 426             aChildNodes.realloc( nLibCount );
 427             Reference< browse::XBrowseNode >* pChildNodes = aChildNodes.getArray();
 428             sal_Int32 childrenFound = 0;
 429
 430             for ( sal_Int32 i = 0 ; i < nLibCount ; ++i )
 431             {
 432                 bool bCreate = false;
 433                 if ( m_bIsAppScriptCtx )
 434                 {
 435                     bool bShared = isLibraryShared( xLibContainer, pLibNames[i] );
 436                     if ( ( m_bIsUserCtx && !bShared ) || ( !m_bIsUserCtx && bShared ) )
 437                         bCreate = true;
 438                 }
 439                 else
 440                 {
 441                     bCreate = true;
 442                 }
 443                 if ( bCreate )
 444                 {
 445                     pChildNodes[childrenFound++] = static_cast< browse::XBrowseNode* >( new BasicLibraryNodeImpl(
 446                         m_xContext, m_sScriptingContext, pBasicManager, xLibContainer, pLibNames[i], m_bIsAppScriptCtx ) );
 447                 }
 448             }
 449
 450             if ( childrenFound != nLibCount )
 451                 aChildNodes.realloc( childrenFound );
 452         }
 453
 454         return aChildNodes;
 455     }
 456
 457
 458     sal_Bool BasicProviderImpl::hasChildNodes(  )
 459     {
 460         SolarMutexGuard aGuard;
 461
 462         bool bReturn = false;
 463         Reference< script::XLibraryContainer > xLibContainer;
 464         if ( m_bIsAppScriptCtx )
 465         {
 466             xLibContainer = m_xLibContainerApp;
 467         }
 468         else
 469         {
 470              xLibContainer = m_xLibContainerDoc;
 471         }
 472         if ( xLibContainer.is() )
 473             bReturn = xLibContainer->hasElements();
 474
 475         return bReturn;
 476     }
 477
 478
 479     sal_Int16 BasicProviderImpl::getType(  )
 480     {
 481         return browse::BrowseNodeTypes::CONTAINER;
 482     }
 483
 484
 485     // component operations
 486
 487
 488     static Reference< XInterface > SAL_CALL create_BasicProviderImpl(
 489         Reference< XComponentContext > const & xContext )
 490     {
 491         return static_cast< lang::XTypeProvider * >( new BasicProviderImpl( xContext ) );
 492     }
 493
 494
 495     static struct ::cppu::ImplementationEntry s_component_entries [] =
 496     {
 497         {
 498             create_BasicProviderImpl, getImplementationName_BasicProviderImpl,
 499             getSupportedServiceNames_BasicProviderImpl, ::cppu::createSingleComponentFactory,
 500             nullptr, 0
 501         },
 502         { nullptr, nullptr, nullptr, nullptr, nullptr, 0 }
 503     };
 504
 505
 506 }   // namespace basprov
 507
 508
 509 // component exports
 510
 511
 512 extern "C"
 513 {
 514     SAL_DLLPUBLIC_EXPORT void * SAL_CALL basprov_component_getFactory(
 515         const sal_Char * pImplName, void * pServiceManager,
 516         void * pRegistryKey )
 517     {
 518         return ::cppu::component_getFactoryHelper(
 519             pImplName, pServiceManager, pRegistryKey, ::basprov::s_component_entries );
 520     }
 521 }
 522
 523 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */