scripting/source/provider/MasterScriptProvider.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
  21 #include <comphelper/documentinfo.hxx>
  22
  23 #include <cppuhelper/implementationentry.hxx>
  24 #include <cppuhelper/exc_hlp.hxx>
  25 #include <cppuhelper/factory.hxx>
  26 #include <cppuhelper/supportsservice.hxx>
  27 #include <tools/diagnose_ex.h>
  28
  29 #include <com/sun/star/frame/XModel.hpp>
  30 #include <com/sun/star/lang/EventObject.hpp>
  31 #include <com/sun/star/container/XContentEnumerationAccess.hpp>
  32 #include <com/sun/star/document/XScriptInvocationContext.hpp>
  33
  34 #include <com/sun/star/uri/XUriReference.hpp>
  35 #include <com/sun/star/uri/UriReferenceFactory.hpp>
  36 #include <com/sun/star/uri/XVndSunStarScriptUrl.hpp>
  37
  38 #include <com/sun/star/deployment/XPackage.hpp>
  39 #include <com/sun/star/script/browse/BrowseNodeTypes.hpp>
  40 #include <com/sun/star/script/provider/theMasterScriptProviderFactory.hpp>
  41 #include <com/sun/star/script/provider/ScriptFrameworkErrorType.hpp>
  42
  43 #include <util/scriptingconstants.hxx>
  44 #include <util/MiscUtils.hxx>
  45
  46 #include "ActiveMSPList.hxx"
  47 #include "MasterScriptProvider.hxx"
  48 #include "URIHelper.hxx"
  49
  50 using namespace ::com::sun::star;
  51 using namespace ::com::sun::star::uno;
  52 using namespace ::com::sun::star::script;
  53 using namespace ::com::sun::star::document;
  54 using namespace ::sf_misc;
  55
  56 namespace func_provider
  57 {
  58
  59 bool endsWith( const OUString& target,
  60     const OUString& item )
  61 {
  62     sal_Int32 index = 0;
  63     if (  ( index = target.indexOf( item ) ) != -1  &&
  64        ( index == ( target.getLength() - item.getLength() ) ) )
  65     {
  66         return true;
  67     }
  68     return false;
  69 }
  70
  71 /* should be available in some central location. */
  72
  73 // XScriptProvider implementation
  74
  75
  76 MasterScriptProvider::MasterScriptProvider( const Reference< XComponentContext > & xContext ) throw ( RuntimeException ):
  77         m_xContext( xContext ), m_bIsValid( false ), m_bInitialised( false ),
  78         m_bIsPkgMSP( false ), m_pPCache( 0 )
  79 {
  80     ENSURE_OR_THROW( m_xContext.is(), "MasterScriptProvider::MasterScriptProvider: No context available\n" );
  81     m_xMgr = m_xContext->getServiceManager();
  82     ENSURE_OR_THROW( m_xMgr.is(), "MasterScriptProvider::MasterScriptProvider: No service manager available\n" );
  83     m_bIsValid = true;
  84 }
  85
  86
  87 MasterScriptProvider::~MasterScriptProvider()
  88 {
  89     if ( m_pPCache )
  90     {
  91         delete m_pPCache;
  92     }
  93     m_pPCache = 0;
  94 }
  95
  96
  97 void SAL_CALL MasterScriptProvider::initialize( const Sequence < Any >& args )
  98 throw ( Exception, RuntimeException, std::exception )
  99 {
 100     if ( m_bInitialised )
 101         return;
 102
 103     m_bIsValid = false;
 104
 105     sal_Int32 len = args.getLength();
 106     if ( len > 1  )
 107     {
 108         throw RuntimeException(
 109             "MasterScriptProvider::initialize: invalid number of arguments" );
 110     }
 111
 112     Sequence< Any > invokeArgs( len );
 113
 114     if ( len != 0 )
 115     {
 116         // check if first parameter is a string
 117         // if it is, this implies that this is a MSP created
 118         // with a user or share ctx ( used for browse functionality )
 119
 120         if ( args[ 0 ] >>= m_sCtxString )
 121         {
 122             invokeArgs[ 0  ] = args[ 0 ];
 123             if ( m_sCtxString.startsWith( "vnd.sun.star.tdoc" ) )
 124             {
 125                 m_xModel =  MiscUtils::tDocUrlToModel( m_sCtxString );
 126             }
 127         }
 128         else if ( args[ 0 ] >>= m_xInvocationContext )
 129         {
 130             m_xModel.set( m_xInvocationContext->getScriptContainer(), UNO_QUERY_THROW );
 131         }
 132         else
 133         {
 134             args[ 0 ] >>= m_xModel;
 135         }
 136
 137         if ( m_xModel.is() )
 138         {
 139             // from the arguments, we were able to deduce a model. That alone doesn't
 140             // suffice, we also need an XEmbeddedScripts which actually indicates support
 141             // for embeddeding scripts
 142             Reference< XEmbeddedScripts > xScripts( m_xModel, UNO_QUERY );
 143             if ( !xScripts.is() )
 144             {
 145                 throw lang::IllegalArgumentException(
 146                     OUString( "The given document does not support embedding scripts into it, and cannot be associated with such a document."
 147                      ),
 148                     *this,
 149                     1
 150                 );
 151             }
 152
 153             try
 154             {
 155                 m_sCtxString =  MiscUtils::xModelToTdocUrl( m_xModel, m_xContext );
 156             }
 157             catch ( const Exception& )
 158             {
 159                 Any aError( ::cppu::getCaughtException() );
 160
 161                 OUStringBuffer buf;
 162                 buf.appendAscii( "MasterScriptProvider::initialize: caught " );
 163                 buf.append     ( aError.getValueTypeName() );
 164                 buf.appendAscii( ":" );
 165
 166                 Exception aException; aError >>= aException;
 167                 buf.append     ( aException.Message );
 168                 throw lang::WrappedTargetException( buf.makeStringAndClear(), *this, aError );
 169             }
 170
 171             if ( m_xInvocationContext.is() && m_xInvocationContext != m_xModel )
 172                 invokeArgs[ 0 ] <<= m_xInvocationContext;
 173             else
 174                 invokeArgs[ 0 ] <<= m_sCtxString;
 175         }
 176
 177         OUString pkgSpec = "uno_packages";
 178         sal_Int32 indexOfPkgSpec = m_sCtxString.lastIndexOf( pkgSpec );
 179
 180         // if contex string ends with "uno_packages"
 181         if ( indexOfPkgSpec > -1 && m_sCtxString.match( pkgSpec, indexOfPkgSpec ) )
 182         {
 183             m_bIsPkgMSP = true;
 184         }
 185         else
 186         {
 187             m_bIsPkgMSP = false;
 188         }
 189     }
 190     else // no args
 191     {
 192         // use either scriping context or maybe zero args?
 193         invokeArgs = Sequence< Any >( 0 ); // no arguments
 194     }
 195     m_sAargs = invokeArgs;
 196     // don't create pkg mgr MSP for documents, not supported
 197     if ( !m_bIsPkgMSP && !m_xModel.is() )
 198     {
 199         createPkgProvider();
 200     }
 201
 202     m_bInitialised = true;
 203     m_bIsValid = true;
 204 }
 205
 206
 207
 208 void MasterScriptProvider::createPkgProvider()
 209 {
 210     try
 211     {
 212         Any location;
 213         OUString sPkgCtx =  m_sCtxString.concat( ":uno_packages" );
 214         location <<= sPkgCtx;
 215
 216         Reference< provider::XScriptProviderFactory > xFac =
 217             provider::theMasterScriptProviderFactory::get( m_xContext );
 218
 219         m_xMSPPkg.set(
 220             xFac->createScriptProvider( location ), UNO_QUERY_THROW );
 221
 222     }
 223     catch ( const Exception& e )
 224     {
 225         (void)e;
 226         OSL_TRACE("Exception creating MasterScriptProvider for uno_packages in context %s: %s",
 227                 OUStringToOString( m_sCtxString,
 228                     RTL_TEXTENCODING_ASCII_US ).pData->buffer,
 229                 OUStringToOString( e.Message,
 230                     RTL_TEXTENCODING_ASCII_US ).pData->buffer );
 231     }
 232 }
 233
 234
 235 Reference< provider::XScript >
 236 MasterScriptProvider::getScript( const OUString& scriptURI )
 237 throw ( provider::ScriptFrameworkErrorException,
 238         RuntimeException, std::exception )
 239 {
 240     if ( !isValid() )
 241     {
 242         throw provider::ScriptFrameworkErrorException(
 243             "MasterScriptProvider not initialised", Reference< XInterface >(),
 244             scriptURI, "",
 245             provider::ScriptFrameworkErrorType::UNKNOWN );
 246     }
 247
 248     // need to get the language from the string
 249
 250     Reference< uri::XUriReferenceFactory > xFac ( uri::UriReferenceFactory::create( m_xContext )  );
 251
 252     Reference<  uri::XUriReference > uriRef(
 253         xFac->parse( scriptURI ), UNO_QUERY );
 254
 255     Reference < uri::XVndSunStarScriptUrl > sfUri( uriRef, UNO_QUERY );
 256
 257     if ( !uriRef.is() || !sfUri.is() )
 258     {
 259         OUString errorMsg = "Incorrect format for Script URI: ";
 260         errorMsg = errorMsg.concat( scriptURI );
 261         throw provider::ScriptFrameworkErrorException(
 262             errorMsg, Reference< XInterface >(),
 263             scriptURI, "",
 264             provider::ScriptFrameworkErrorType::UNKNOWN );
 265     }
 266
 267     OUString langKey("language");
 268     OUString locKey("location");
 269
 270     if ( sfUri->hasParameter( langKey ) == sal_False ||
 271          sfUri->hasParameter( locKey ) == sal_False ||
 272          ( sfUri->getName().isEmpty()  ) )
 273     {
 274         OUString errorMsg = "Incorrect format for Script URI: ";
 275         errorMsg = errorMsg.concat( scriptURI );
 276         throw provider::ScriptFrameworkErrorException(
 277             errorMsg, Reference< XInterface >(),
 278             scriptURI, "",
 279             provider::ScriptFrameworkErrorType::UNKNOWN );
 280     }
 281
 282     OUString language = sfUri->getParameter( langKey );
 283     OUString location = sfUri->getParameter( locKey );
 284
 285     // if script us located in uno pkg
 286     sal_Int32 index = -1;
 287     OUString pkgTag(":uno_packages");
 288     // for languages other than basic,  scripts located in uno packages
 289     // are merged into the user/share location context.
 290     // For other languages the location attribute in script url has the form
 291     // location = [user|share]:uno_packages or location :uno_pacakges/xxxx.uno.pkg
 292     // we need to extract the value of location part from the
 293     // location attribute of the script, if the script is located in an
 294     // uno package then that is the location part up to and including
 295     // ":uno_packages", if the script is not in an uno package then the
 296     // normal value is used e.g. user or share.
 297     // The value extracted will be used to determine if the script is
 298     // located in the same location context as this MSP.
 299     // For Basic, the language script provider can handle the execution of a
 300     // script in any location context
 301     if ( ( index = location.indexOf( pkgTag ) ) > -1 )
 302     {
 303         location = location.copy( 0, index + pkgTag.getLength() );
 304     }
 305
 306     Reference< provider::XScript > xScript;
 307
 308     // If the script location is in the same location context as this
 309     // MSP then delate to the lanaguage provider controlled by this MSP
 310     // ** Special case is BASIC, all calls to getScript will be handled
 311     // by the language script provider in the current location context
 312     // even if its different
 313     if  (   (   location == "document"
 314             &&  m_xModel.is()
 315             )
 316             ||  ( endsWith( m_sCtxString, location ) )
 317             ||  ( language == "Basic" )
 318          )
 319     {
 320         Reference< provider::XScriptProvider > xScriptProvider;
 321         OUStringBuffer buf( 80 );
 322         buf.appendAscii( "com.sun.star.script.provider.ScriptProviderFor");
 323         buf.append( language );
 324         OUString serviceName = buf.makeStringAndClear();
 325         if ( providerCache() )
 326         {
 327             try
 328             {
 329                 xScriptProvider.set(
 330                     providerCache()->getProvider( serviceName ),
 331                     UNO_QUERY_THROW );
 332             }
 333             catch( const Exception& e )
 334             {
 335                 throw provider::ScriptFrameworkErrorException(
 336                     e.Message, Reference< XInterface >(),
 337                     sfUri->getName(), language,
 338                     provider::ScriptFrameworkErrorType::NOTSUPPORTED );
 339             }
 340         }
 341         else
 342         {
 343             throw provider::ScriptFrameworkErrorException(
 344                 "No LanguageProviders detected",
 345                 Reference< XInterface >(),
 346                 sfUri->getName(), language,
 347                 provider::ScriptFrameworkErrorType::NOTSUPPORTED );
 348         }
 349         xScript=xScriptProvider->getScript( scriptURI );
 350     }
 351     else
 352     {
 353         Reference< provider::XScriptProviderFactory > xFac_ =
 354             provider::theMasterScriptProviderFactory::get( m_xContext );
 355
 356         Reference< provider::XScriptProvider > xSP(
 357             xFac_->createScriptProvider( makeAny( location ) ), UNO_QUERY_THROW );
 358         xScript = xSP->getScript( scriptURI );
 359     }
 360
 361     return xScript;
 362 }
 363
 364
 365
 366 ProviderCache*
 367 MasterScriptProvider::providerCache()
 368 {
 369     if ( !m_pPCache )
 370     {
 371         ::osl::MutexGuard aGuard( m_mutex );
 372         if ( !m_pPCache )
 373         {
 374             OUString serviceName1 = "com.sun.star.script.provider.ScriptProviderForBasic";
 375             Sequence< OUString > blacklist(1);
 376             blacklist[ 0 ] = serviceName1;
 377
 378             if ( !m_bIsPkgMSP )
 379             {
 380                 m_pPCache = new ProviderCache( m_xContext, m_sAargs );
 381             }
 382             else
 383             {
 384                 m_pPCache = new ProviderCache( m_xContext, m_sAargs, blacklist );
 385             }
 386         }
 387     }
 388     return m_pPCache;
 389 }
 390
 391
 392
 393 OUString SAL_CALL
 394 MasterScriptProvider::getName()
 395         throw ( css::uno::RuntimeException, std::exception )
 396 {
 397     if ( !isPkgProvider() )
 398     {
 399         OUString sCtx = getContextString();
 400         if ( sCtx.startsWith( "vnd.sun.star.tdoc" ) )
 401         {
 402             Reference< frame::XModel > xModel = m_xModel;
 403             if ( !xModel.is() )
 404             {
 405                 xModel = MiscUtils::tDocUrlToModel( sCtx );
 406             }
 407
 408             m_sNodeName = ::comphelper::DocumentInfo::getDocumentTitle( xModel );
 409         }
 410         else
 411         {
 412             m_sNodeName = parseLocationName( getContextString() );
 413         }
 414     }
 415     else
 416     {
 417         m_sNodeName = "uno_packages";
 418     }
 419     return m_sNodeName;
 420 }
 421
 422
 423 Sequence< Reference< browse::XBrowseNode > > SAL_CALL
 424 MasterScriptProvider::getChildNodes()
 425         throw ( css::uno::RuntimeException, std::exception )
 426 {
 427     Sequence< Reference< provider::XScriptProvider > > providers = getAllProviders();
 428
 429     Reference< provider::XScriptProvider > pkgProv = getPkgProvider();
 430     sal_Int32 size = providers.getLength();
 431     bool hasPkgs = pkgProv.is();
 432     if ( hasPkgs  )
 433     {
 434         size++;
 435     }
 436     Sequence<  Reference< browse::XBrowseNode > > children( size );
 437     sal_Int32 provIndex = 0;
 438     for ( ; provIndex < providers.getLength(); provIndex++ )
 439     {
 440         children[ provIndex ] = Reference< browse::XBrowseNode >( providers[ provIndex ], UNO_QUERY );
 441     }
 442
 443     if ( hasPkgs  )
 444     {
 445         children[ provIndex ] = Reference< browse::XBrowseNode >( pkgProv, UNO_QUERY );
 446
 447     }
 448
 449     return children;
 450 }
 451
 452
 453 sal_Bool SAL_CALL
 454 MasterScriptProvider::hasChildNodes()
 455         throw ( css::uno::RuntimeException, std::exception )
 456 {
 457     return sal_True;
 458 }
 459
 460
 461 sal_Int16 SAL_CALL
 462 MasterScriptProvider::getType()
 463         throw ( css::uno::RuntimeException, std::exception )
 464 {
 465     return browse::BrowseNodeTypes::CONTAINER;
 466 }
 467
 468
 469
 470 OUString
 471 MasterScriptProvider::parseLocationName( const OUString& location )
 472 {
 473     // strip out the last leaf of location name
 474     // e.g. file://dir1/dir2/Blah.sxw - > Blah.sxw
 475     OUString temp = location;
 476     INetURLObject aURLObj( temp );
 477     if ( !aURLObj.HasError() )
 478         temp = aURLObj.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DECODE_WITH_CHARSET );
 479     return temp;
 480 }
 481
 482
 483 // Register Package
 484 void SAL_CALL
 485 MasterScriptProvider::insertByName( const OUString& aName, const Any& aElement ) throw ( lang::IllegalArgumentException, container::ElementExistException, lang::WrappedTargetException, css::uno::RuntimeException, std::exception)
 486 {
 487     if ( !m_bIsPkgMSP )
 488     {
 489         if ( m_xMSPPkg.is() )
 490         {
 491             Reference< container::XNameContainer > xCont( m_xMSPPkg, UNO_QUERY );
 492             if ( !xCont.is() )
 493             {
 494                 throw RuntimeException(
 495                     "PackageMasterScriptProvider doesn't implement XNameContainer" );
 496             }
 497             xCont->insertByName( aName, aElement );
 498         }
 499         else
 500         {
 501             throw RuntimeException( "PackageMasterScriptProvider is unitialised" );
 502         }
 503
 504     }
 505     else
 506     {
 507         Reference< deployment::XPackage > xPkg( aElement, UNO_QUERY );
 508         if ( !xPkg.is() )
 509         {
 510             throw lang::IllegalArgumentException( "Couldn't convert to XPackage",
 511                                                       Reference < XInterface > (), 2 );
 512         }
 513         if ( aName.isEmpty() )
 514         {
 515             throw lang::IllegalArgumentException( "Name not set!!",
 516                                                       Reference < XInterface > (), 1 );
 517         }
 518         // TODO for library pacakge parse the language, for the moment will try
 519         // to get each provider to process the new Package, the first one the succeeds
 520         // will terminate processing
 521         if ( !providerCache() )
 522         {
 523             throw RuntimeException(
 524                 "insertByName cannot instantiate "
 525                 "child script providers." );
 526         }
 527         Sequence < Reference< provider::XScriptProvider > > xSProviders =
 528             providerCache()->getAllProviders();
 529         sal_Int32 index = 0;
 530
 531         for ( ; index < xSProviders.getLength(); index++ )
 532         {
 533             Reference< container::XNameContainer > xCont( xSProviders[ index ], UNO_QUERY );
 534             if ( !xCont.is() )
 535             {
 536                 continue;
 537             }
 538             try
 539             {
 540                 xCont->insertByName( aName, aElement );
 541                 break;
 542             }
 543             catch ( Exception& e )
 544             {
 545                 SAL_INFO(
 546                     "scripting.provider", "ignoring Exception " << e.Message);
 547             }
 548
 549         }
 550         if ( index == xSProviders.getLength() )
 551         {
 552             // No script providers could process the package
 553             OUString message = "Failed to register package for ";
 554             message = message.concat( aName );
 555             throw lang::IllegalArgumentException( message,
 556                 Reference < XInterface > (), 2 );
 557         }
 558    }
 559 }
 560
 561
 562 // Revoke Package
 563 void SAL_CALL
 564 MasterScriptProvider::removeByName( const OUString& Name ) throw ( container::NoSuchElementException, lang::WrappedTargetException, RuntimeException, std::exception)
 565 {
 566     if ( !m_bIsPkgMSP )
 567     {
 568         if ( m_xMSPPkg.is() )
 569         {
 570             Reference< container::XNameContainer > xCont( m_xMSPPkg, UNO_QUERY );
 571             if ( !xCont.is() )
 572             {
 573                 throw RuntimeException(
 574                     "PackageMasterScriptProvider doesn't implement XNameContainer" );
 575             }
 576             xCont->removeByName( Name );
 577         }
 578         else
 579         {
 580             throw RuntimeException( "PackageMasterScriptProvider is unitialised" );
 581         }
 582
 583    }
 584    else
 585    {
 586         if ( Name.isEmpty() )
 587         {
 588             throw lang::IllegalArgumentException( "Name not set!!",
 589                                                       Reference < XInterface > (), 1 );
 590         }
 591         // TODO for Script library pacakge url parse the language,
 592         // for the moment will just try to get each provider to process remove/revoke
 593         // request, the first one the succeeds will terminate processing
 594
 595         if ( !providerCache() )
 596         {
 597             throw RuntimeException(
 598                 "removeByName() cannot instantiate "
 599                 "child script providers." );
 600         }
 601         Sequence < Reference< provider::XScriptProvider > > xSProviders =
 602             providerCache()->getAllProviders();
 603         sal_Int32 index = 0;
 604         for ( ; index < xSProviders.getLength(); index++ )
 605         {
 606             Reference< container::XNameContainer > xCont( xSProviders[ index ], UNO_QUERY );
 607             if ( !xCont.is() )
 608             {
 609                 continue;
 610             }
 611             try
 612             {
 613                 xCont->removeByName( Name );
 614                 break;
 615             }
 616             catch ( Exception& )
 617             {
 618             }
 619
 620         }
 621         if ( index == xSProviders.getLength() )
 622         {
 623             // No script providers could process the package
 624             OUString message = "Failed to revoke package for ";
 625             message = message.concat( Name );
 626             throw lang::IllegalArgumentException( message,
 627                                                       Reference < XInterface > (), 1 );
 628         }
 629
 630     }
 631 }
 632
 633
 634 void SAL_CALL
 635 MasterScriptProvider::replaceByName( const OUString& aName, const Any& aElement ) throw ( lang::IllegalArgumentException, container::NoSuchElementException, lang::WrappedTargetException, RuntimeException, std::exception)
 636 {
 637     (void)aName;
 638     (void)aElement;
 639
 640     // TODO needs implementing
 641     if ( true )
 642     {
 643         throw RuntimeException( "replaceByName not implemented!!!!" );
 644     }
 645 }
 646
 647 Any SAL_CALL
 648 MasterScriptProvider::getByName( const OUString& aName ) throw ( container::NoSuchElementException, lang::WrappedTargetException, RuntimeException, std::exception)
 649 {
 650     (void)aName;
 651
 652     // TODO needs to be implemented
 653     Any result;
 654     if ( true )
 655     {
 656         throw RuntimeException( "getByName not implemented!!!!" );
 657     }
 658     return result;
 659 }
 660
 661 sal_Bool SAL_CALL
 662 MasterScriptProvider::hasByName( const OUString& aName ) throw (RuntimeException, std::exception)
 663 {
 664     bool result = false;
 665     if ( !m_bIsPkgMSP )
 666     {
 667         if ( m_xMSPPkg.is() )
 668         {
 669             Reference< container::XNameContainer > xCont( m_xMSPPkg, UNO_QUERY );
 670             if ( !xCont.is() )
 671             {
 672                 throw RuntimeException(
 673                     "PackageMasterScriptProvider doesn't implement XNameContainer" );
 674             }
 675
 676             result = xCont->hasByName( aName );
 677         }
 678         // If this is a document provider then we shouldn't
 679         // have a PackageProvider
 680         else if (!m_xModel.is())
 681         {
 682             throw RuntimeException( "PackageMasterScriptProvider is unitialised" );
 683         }
 684
 685    }
 686    else
 687    {
 688         if ( aName.isEmpty() )
 689         {
 690             throw lang::IllegalArgumentException( "Name not set!!",
 691                                                       Reference < XInterface > (), 1 );
 692         }
 693         // TODO for Script library pacakge url parse the language,
 694         // for the moment will just try to get each provider to see if the
 695         // package exists in any provider, first one that succeed will
 696         // terminate the loop
 697
 698         if ( !providerCache() )
 699         {
 700             throw RuntimeException(
 701                 "removeByName() cannot instantiate "
 702                 "child script providers." );
 703         }
 704         Sequence < Reference< provider::XScriptProvider > > xSProviders =
 705             providerCache()->getAllProviders();
 706         for ( sal_Int32 index = 0; index < xSProviders.getLength(); index++ )
 707         {
 708             Reference< container::XNameContainer > xCont( xSProviders[ index ], UNO_QUERY );
 709             if ( !xCont.is() )
 710             {
 711                 continue;
 712             }
 713             try
 714             {
 715                 result = xCont->hasByName( aName );
 716                 if ( result )
 717                 {
 718                     break;
 719                 }
 720             }
 721             catch ( Exception& )
 722             {
 723             }
 724
 725         }
 726     }
 727     return result;
 728 }
 729
 730
 731 Sequence< OUString > SAL_CALL
 732 MasterScriptProvider::getElementNames(  ) throw ( RuntimeException, std::exception)
 733 {
 734     // TODO needs implementing
 735     Sequence< OUString >  names;
 736     if ( true )
 737     {
 738         throw RuntimeException( "getElementNames not implemented!!!!" );
 739     }
 740     return names;
 741 }
 742
 743 Type SAL_CALL
 744 MasterScriptProvider::getElementType(  ) throw ( RuntimeException, std::exception)
 745 {
 746     // TODO needs implementing
 747     Type t;
 748     return t;
 749 }
 750
 751 sal_Bool SAL_CALL MasterScriptProvider::hasElements(  ) throw ( RuntimeException, std::exception)
 752 {
 753     // TODO needs implementing
 754     if ( true )
 755     {
 756         throw RuntimeException( "hasElements not implemented!!!!" );
 757     }
 758     return false;
 759 }
 760
 761
 762 Sequence< Reference< provider::XScriptProvider > > SAL_CALL
 763 MasterScriptProvider::getAllProviders() throw ( css::uno::RuntimeException )
 764 {
 765     if ( providerCache() )
 766     {
 767         return providerCache()->getAllProviders();
 768     }
 769     else
 770     {
 771         OUString errorMsg(
 772             "MasterScriptProvider::getAllProviders, cache not initialised");
 773         throw RuntimeException( errorMsg.concat( errorMsg ) );
 774     }
 775 }
 776
 777
 778
 779 OUString SAL_CALL MasterScriptProvider::getImplementationName( )
 780 throw( RuntimeException, std::exception )
 781 {
 782     return OUString( "com.sun.star.script.provider.MasterScriptProvider"  );
 783 }
 784
 785 sal_Bool SAL_CALL MasterScriptProvider::supportsService( const OUString& serviceName )
 786 throw( RuntimeException, std::exception )
 787 {
 788     return cppu::supportsService(this, serviceName);
 789 }
 790
 791
 792 Sequence< OUString > SAL_CALL MasterScriptProvider::getSupportedServiceNames( )
 793 throw( RuntimeException, std::exception )
 794 {
 795     OUString names[3];
 796
 797     names[0] = "com.sun.star.script.provider.MasterScriptProvider";
 798     names[1] = "com.sun.star.script.browse.BrowseNode";
 799     names[2] = "com.sun.star.script.provider.ScriptProvider";
 800
 801     return Sequence< OUString >( names, 3 );
 802 }
 803
 804 } // namespace func_provider
 805
 806
 807 namespace scripting_runtimemgr
 808 {
 809
 810 Reference< XInterface > SAL_CALL sp_create(
 811     const Reference< XComponentContext > & xCompC )
 812 {
 813     return ( cppu::OWeakObject * ) new ::func_provider::MasterScriptProvider( xCompC );
 814 }
 815
 816
 817 Sequence< OUString > sp_getSupportedServiceNames( )
 818 {
 819     OUString names[3];
 820
 821     names[0] = "com.sun.star.script.provider.MasterScriptProvider";
 822     names[1] = "com.sun.star.script.browse.BrowseNode";
 823     names[2] = "com.sun.star.script.provider.ScriptProvider";
 824
 825     return Sequence< OUString >( names, 3 );
 826 }
 827
 828
 829 OUString sp_getImplementationName( )
 830 {
 831     return OUString( "com.sun.star.script.provider.MasterScriptProvider"  );
 832 }
 833
 834 // ***** registration or ScriptingFrameworkURIHelper
 835 Reference< XInterface > SAL_CALL urihelper_create(
 836     const Reference< XComponentContext > & xCompC )
 837 {
 838     return ( cppu::OWeakObject * )
 839         new ::func_provider::ScriptingFrameworkURIHelper( xCompC );
 840 }
 841
 842 Sequence< OUString > urihelper_getSupportedServiceNames( )
 843 {
 844     OUString serviceNameList[] = {
 845         OUString(
 846             "com.sun.star.script.provider.ScriptURIHelper" ) };
 847
 848     Sequence< OUString > serviceNames = Sequence <
 849         OUString > ( serviceNameList, 1 );
 850
 851     return serviceNames;
 852 }
 853
 854 OUString urihelper_getImplementationName( )
 855 {
 856     return OUString(
 857         "com.sun.star.script.provider.ScriptURIHelper");
 858 }
 859
 860 static const struct cppu::ImplementationEntry s_entries [] =
 861     {
 862         {
 863             sp_create, sp_getImplementationName,
 864             sp_getSupportedServiceNames, cppu::createSingleComponentFactory,
 865             0, 0
 866         },
 867         {
 868             urihelper_create,
 869             urihelper_getImplementationName,
 870             urihelper_getSupportedServiceNames,
 871             cppu::createSingleComponentFactory,
 872             0, 0
 873         },
 874         {
 875             func_provider::mspf_create, func_provider::mspf_getImplementationName,
 876             func_provider::mspf_getSupportedServiceNames, cppu::createSingleComponentFactory,
 877             0, 0
 878         },
 879         {
 880             browsenodefactory::bnf_create, browsenodefactory::bnf_getImplementationName,
 881             browsenodefactory::bnf_getSupportedServiceNames, cppu::createSingleComponentFactory,
 882             0, 0
 883         },
 884         { 0, 0, 0, 0, 0, 0 }
 885     };
 886 }
 887
 888
 889 //#### EXPORTED ##############################################################
 890
 891
 892 extern "C"
 893 {
 894     /**
 895      * This function is called to get service factories for an implementation.
 896      *
 897      * @param pImplName       name of implementation
 898      * @param pServiceManager a service manager, need for component creation
 899      * @param pRegistryKey    the registry key for this component, need for persistent
 900      *                        data
 901      * @return a component factory
 902      */
 903     SAL_DLLPUBLIC_EXPORT void * SAL_CALL scriptframe_component_getFactory(
 904         const sal_Char * pImplName,
 905         void * pServiceManager,
 906         void * pRegistryKey )
 907     {
 908         return ::cppu::component_getFactoryHelper( pImplName, pServiceManager,
 909             pRegistryKey, ::scripting_runtimemgr::s_entries );
 910     }
 911 }
 912
 913 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */