basic/source/uno/scriptcont.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: scriptcont.cxx,v $
  10  * $Revision: 1.11 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_basic.hxx"
  33 #include "scriptcont.hxx"
  34 #include "sbmodule.hxx"
  35 #include <com/sun/star/container/XNameContainer.hpp>
  36 #include <com/sun/star/xml/sax/XParser.hpp>
  37 #include <com/sun/star/xml/sax/InputSource.hpp>
  38 #include <com/sun/star/io/XOutputStream.hpp>
  39 #include <com/sun/star/io/XInputStream.hpp>
  40 #include <com/sun/star/io/XActiveDataSource.hpp>
  41 #include <com/sun/star/ucb/XSimpleFileAccess.hpp>
  42 #include <com/sun/star/embed/ElementModes.hpp>
  43 #include <com/sun/star/embed/XEncryptionProtectedSource.hpp>
  44 #include <com/sun/star/beans/XPropertySet.hpp>
  45 #include <com/sun/star/embed/XTransactedObject.hpp>
  46 #include <com/sun/star/task/ErrorCodeIOException.hpp>
  47 #include <comphelper/processfactory.hxx>
  48 #ifndef _COMPHELPER_STORAGEHELPER_HXX_
  49 #include <comphelper/storagehelper.hxx>
  50 #endif
  51 #include <unotools/streamwrap.hxx>
  52 #include <unotools/ucbstreamhelper.hxx>
  53 #include <osl/mutex.hxx>
  54 #include <rtl/digest.h>
  55 #include <rtl/strbuf.hxx>
  56
  57 // For password functionality
  58 #include <tools/urlobj.hxx>
  59
  60
  61 #include <svtools/pathoptions.hxx>
  62 #include <svtools/sfxecode.hxx>
  63 #include <svtools/ehdl.hxx>
  64 #include <basic/basmgr.hxx>
  65 #include <basic/sbmod.hxx>
  66 #include "modsizeexceeded.hxx"
  67 #include <xmlscript/xmlmod_imexp.hxx>
  68 #include <cppuhelper/factory.hxx>
  69 #include <com/sun/star/util/VetoException.hpp>
  70 #include <com/sun/star/script/XLibraryQueryExecutable.hpp>
  71 #include <cppuhelper/implbase1.hxx>
  72 namespace basic
  73 {
  74
  75 using namespace com::sun::star::document;
  76 using namespace com::sun::star::container;
  77 using namespace com::sun::star::io;
  78 using namespace com::sun::star::uno;
  79 using namespace com::sun::star::ucb;
  80 using namespace com::sun::star::lang;
  81 using namespace com::sun::star::script;
  82 using namespace com::sun::star::xml::sax;
  83 using namespace com::sun::star;
  84 using namespace cppu;
  85 using namespace rtl;
  86 using namespace osl;
  87
  88 using com::sun::star::uno::Reference;
  89
  90 //============================================================================
  91 // Implementation class SfxScriptLibraryContainer
  92
  93 const sal_Char* SAL_CALL SfxScriptLibraryContainer::getInfoFileName() const { return "script"; }
  94 const sal_Char* SAL_CALL SfxScriptLibraryContainer::getOldInfoFileName() const { return "script"; }
  95 const sal_Char* SAL_CALL SfxScriptLibraryContainer::getLibElementFileExtension() const { return "xba"; }
  96 const sal_Char* SAL_CALL SfxScriptLibraryContainer::getLibrariesDir() const { return "Basic"; }
  97
  98 // OldBasicPassword interface
  99 void SfxScriptLibraryContainer::setLibraryPassword
 100     ( const String& rLibraryName, const String& rPassword )
 101 {
 102     try
 103     {
 104         SfxLibrary* pImplLib = getImplLib( rLibraryName );
 105         if( rPassword.Len() )
 106         {
 107             pImplLib->mbDoc50Password = sal_True;
 108             pImplLib->mbPasswordProtected = sal_True;
 109             pImplLib->maPassword = rPassword;
 110         }
 111     }
 112     catch( NoSuchElementException& ) {}
 113 }
 114
 115 String SfxScriptLibraryContainer::getLibraryPassword( const String& rLibraryName )
 116 {
 117     SfxLibrary* pImplLib = getImplLib( rLibraryName );
 118     String aPassword;
 119     if( pImplLib->mbPasswordVerified )
 120         aPassword = pImplLib->maPassword;
 121     return aPassword;
 122 }
 123
 124 void SfxScriptLibraryContainer::clearLibraryPassword( const String& rLibraryName )
 125 {
 126     try
 127     {
 128         SfxLibrary* pImplLib = getImplLib( rLibraryName );
 129         pImplLib->mbDoc50Password = sal_False;
 130         pImplLib->mbPasswordProtected = sal_False;
 131         pImplLib->maPassword = OUString();
 132     }
 133     catch( NoSuchElementException& ) {}
 134 }
 135
 136 sal_Bool SfxScriptLibraryContainer::hasLibraryPassword( const String& rLibraryName )
 137 {
 138     SfxLibrary* pImplLib = getImplLib( rLibraryName );
 139     return pImplLib->mbPasswordProtected;
 140 }
 141
 142 // Ctor for service
 143 SfxScriptLibraryContainer::SfxScriptLibraryContainer( void )
 144     :maScriptLanguage( RTL_CONSTASCII_USTRINGPARAM( "StarBasic" ) )
 145 {
 146     // all initialisation has to be done
 147     // by calling XInitialization::initialize
 148 }
 149
 150 SfxScriptLibraryContainer::SfxScriptLibraryContainer( const uno::Reference< embed::XStorage >& xStorage )
 151     :maScriptLanguage( RTL_CONSTASCII_USTRINGPARAM( "StarBasic" ) )
 152 {
 153     init( OUString(), xStorage );
 154 }
 155
 156 // Methods to get library instances of the correct type
 157 SfxLibrary* SfxScriptLibraryContainer::implCreateLibrary( const OUString& aName )
 158 {
 159     (void)aName;        // Only needed for SfxDialogLibrary
 160     SfxLibrary* pRet = new SfxScriptLibrary( maModifiable, mxMSF, mxSFI );
 161     return pRet;
 162 }
 163
 164 SfxLibrary* SfxScriptLibraryContainer::implCreateLibraryLink
 165     ( const OUString& aName, const OUString& aLibInfoFileURL,
 166       const OUString& StorageURL, sal_Bool ReadOnly )
 167 {
 168     (void)aName;        // Only needed for SfxDialogLibrary
 169     SfxLibrary* pRet =
 170         new SfxScriptLibrary
 171             ( maModifiable, mxMSF, mxSFI, aLibInfoFileURL, StorageURL, ReadOnly );
 172     return pRet;
 173 }
 174
 175 Any SAL_CALL SfxScriptLibraryContainer::createEmptyLibraryElement( void )
 176 {
 177     OUString aMod;
 178     Any aRetAny;
 179     aRetAny <<= aMod;
 180     return aRetAny;
 181 }
 182
 183 bool SAL_CALL SfxScriptLibraryContainer::isLibraryElementValid( Any aElement ) const
 184 {
 185     return SfxScriptLibrary::containsValidModule( aElement );
 186 }
 187
 188 void SAL_CALL SfxScriptLibraryContainer::writeLibraryElement
 189 (
 190     Any aElement,
 191     const OUString& aElementName,
 192     Reference< XOutputStream > xOutput
 193 )
 194     throw(Exception)
 195 {
 196     // Create sax writer
 197     Reference< XExtendedDocumentHandler > xHandler(
 198         mxMSF->createInstance(
 199             OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.xml.sax.Writer") ) ), UNO_QUERY );
 200     if( !xHandler.is() )
 201     {
 202         OSL_ENSURE( 0, "### couln't create sax-writer component\n" );
 203         return;
 204     }
 205
 206     Reference< XTruncate > xTruncate( xOutput, UNO_QUERY );
 207     OSL_ENSURE( xTruncate.is(), "Currently only the streams that can be truncated are expected!" );
 208     if ( xTruncate.is() )
 209         xTruncate->truncate();
 210
 211     Reference< XActiveDataSource > xSource( xHandler, UNO_QUERY );
 212     xSource->setOutputStream( xOutput );
 213
 214     xmlscript::ModuleDescriptor aMod;
 215     aMod.aName = aElementName;
 216     aMod.aLanguage = maScriptLanguage;
 217         // make sure we export source
 218         ::com::sun::star::script::ModuleInfo mInfo;
 219         if ( aElement >>= mInfo )
 220                 aMod.aCode = mInfo.ModuleSource;
 221         else
 222     aElement >>= aMod.aCode;
 223     xmlscript::exportScriptModule( xHandler, aMod );
 224 }
 225
 226
 227 Any SAL_CALL SfxScriptLibraryContainer::importLibraryElement
 228     ( const OUString& aFile, const uno::Reference< io::XInputStream >& xInStream )
 229 {
 230     Any aRetAny;
 231
 232     Reference< XParser > xParser( mxMSF->createInstance(
 233         OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.xml.sax.Parser") ) ), UNO_QUERY );
 234     if( !xParser.is() )
 235     {
 236         OSL_ENSURE( 0, "### couln't create sax parser component\n" );
 237         return aRetAny;
 238     }
 239
 240
 241     // Read from storage?
 242     sal_Bool bStorage = xInStream.is();
 243     Reference< XInputStream > xInput;
 244
 245     if( bStorage )
 246     {
 247         xInput = xInStream;
 248     }
 249     else
 250     {
 251         try
 252         {
 253             xInput = mxSFI->openFileRead( aFile );
 254         }
 255         catch( Exception& )
 256         //catch( Exception& e )
 257         {
 258             // TODO:
 259             //throw WrappedTargetException( e );
 260         }
 261     }
 262
 263     if( !xInput.is() )
 264         return aRetAny;
 265
 266     InputSource source;
 267     source.aInputStream = xInput;
 268     source.sSystemId    = aFile;
 269
 270     // start parsing
 271     xmlscript::ModuleDescriptor aMod;
 272
 273     try
 274     {
 275         xParser->setDocumentHandler( ::xmlscript::importScriptModule( aMod ) );
 276         xParser->parseStream( source );
 277     }
 278     catch( Exception& )
 279     {
 280         SfxErrorContext aEc( ERRCTX_SFX_LOADBASIC, aFile );
 281         ULONG nErrorCode = ERRCODE_IO_GENERAL;
 282         ErrorHandler::HandleError( nErrorCode );
 283     }
 284
 285     aRetAny <<= aMod.aCode;
 286
 287     // TODO: Check language
 288     // aMod.aLanguage
 289     // aMod.aName ignored
 290
 291     return aRetAny;
 292 }
 293
 294 SfxLibraryContainer* SfxScriptLibraryContainer::createInstanceImpl( void )
 295 {
 296     return new SfxScriptLibraryContainer();
 297 }
 298
 299 void SAL_CALL SfxScriptLibraryContainer::importFromOldStorage( const ::rtl::OUString& aFile )
 300 {
 301     // TODO: move loading from old storage to binary filters?
 302     SotStorageRef xStorage = new SotStorage( sal_False, aFile );
 303     if( xStorage.Is() && xStorage->GetError() == ERRCODE_NONE )
 304     {
 305         // We need a BasicManager to avoid problems
 306         // StarBASIC* pBas = new StarBASIC();
 307         BasicManager* pBasicManager = new BasicManager( *(SotStorage*)xStorage, aFile );
 308
 309         // Set info
 310         LibraryContainerInfo aInfo( this, NULL, static_cast< OldBasicPassword* >( this ) );
 311         pBasicManager->SetLibraryContainerInfo( aInfo );
 312
 313         // Now the libraries should be copied to this SfxScriptLibraryContainer
 314         BasicManager::LegacyDeleteBasicManager( pBasicManager );
 315     }
 316 }
 317
 318
 319 // Storing with password encryption
 320
 321 // Methods XLibraryContainerPassword
 322 sal_Bool SAL_CALL SfxScriptLibraryContainer::isLibraryPasswordProtected( const OUString& Name )
 323     throw (NoSuchElementException, RuntimeException)
 324 {
 325     LibraryContainerMethodGuard aGuard( *this );
 326     SfxLibrary* pImplLib = getImplLib( Name );
 327     sal_Bool bRet = pImplLib->mbPasswordProtected;
 328     return bRet;
 329 }
 330
 331 sal_Bool SAL_CALL SfxScriptLibraryContainer::isLibraryPasswordVerified( const OUString& Name )
 332     throw (IllegalArgumentException, NoSuchElementException, RuntimeException)
 333 {
 334     LibraryContainerMethodGuard aGuard( *this );
 335     SfxLibrary* pImplLib = getImplLib( Name );
 336     if( !pImplLib->mbPasswordProtected )
 337         throw IllegalArgumentException();
 338     sal_Bool bRet = pImplLib->mbPasswordVerified;
 339     return bRet;
 340 }
 341
 342 sal_Bool SAL_CALL SfxScriptLibraryContainer::verifyLibraryPassword
 343     ( const OUString& Name, const OUString& Password )
 344         throw (IllegalArgumentException, NoSuchElementException, RuntimeException)
 345 {
 346     LibraryContainerMethodGuard aGuard( *this );
 347     SfxLibrary* pImplLib = getImplLib( Name );
 348     if( !pImplLib->mbPasswordProtected || pImplLib->mbPasswordVerified )
 349         throw IllegalArgumentException();
 350
 351     // Test password
 352     sal_Bool bSuccess = sal_False;
 353     if( pImplLib->mbDoc50Password )
 354     {
 355         bSuccess = ( Password == pImplLib->maPassword );
 356         if( bSuccess )
 357             pImplLib->mbPasswordVerified = sal_True;
 358     }
 359     else
 360     {
 361         pImplLib->maPassword = Password;
 362         bSuccess = implLoadPasswordLibrary( pImplLib, Name, sal_True );
 363         if( bSuccess )
 364         {
 365             // The library gets modified by verifiying the password, because other-
 366             // wise for saving the storage would be copied and that doesn't work
 367             // with mtg's storages when the password is verified
 368             pImplLib->implSetModified( sal_True );
 369             pImplLib->mbPasswordVerified = sal_True;
 370
 371             // Reload library to get source
 372             if( pImplLib->mbLoaded )
 373                 implLoadPasswordLibrary( pImplLib, Name );
 374         }
 375     }
 376     return bSuccess;
 377 }
 378
 379 void SAL_CALL SfxScriptLibraryContainer::changeLibraryPassword( const OUString& Name,
 380     const OUString& OldPassword, const OUString& NewPassword )
 381         throw (IllegalArgumentException, NoSuchElementException, RuntimeException)
 382 {
 383     LibraryContainerMethodGuard aGuard( *this );
 384     SfxLibrary* pImplLib = getImplLib( Name );
 385     if( OldPassword == NewPassword )
 386         return;
 387
 388     sal_Bool bOldPassword = ( OldPassword.getLength() > 0 );
 389     sal_Bool bNewPassword = ( NewPassword.getLength() > 0 );
 390     sal_Bool bStorage = mxStorage.is() && !pImplLib->mbLink;
 391
 392     if( pImplLib->mbReadOnly || (bOldPassword && !pImplLib->mbPasswordProtected) )
 393         throw IllegalArgumentException();
 394
 395     // Library must be loaded
 396     loadLibrary( Name );
 397
 398     sal_Bool bKillCryptedFiles = sal_False;
 399     sal_Bool bKillUncryptedFiles = sal_False;
 400
 401     // Remove or change password?
 402     if( bOldPassword )
 403     {
 404         if( isLibraryPasswordVerified( Name ) )
 405         {
 406             if( pImplLib->maPassword != OldPassword )
 407                    throw IllegalArgumentException();
 408         }
 409         else
 410         {
 411             if( !verifyLibraryPassword( Name, OldPassword ) )
 412                    throw IllegalArgumentException();
 413
 414             // Reload library to get source
 415             // Should be done in verifyLibraryPassword loadLibrary( Name );
 416         }
 417
 418         if( !bNewPassword )
 419         {
 420             pImplLib->mbPasswordProtected = sal_False;
 421             pImplLib->mbPasswordVerified = sal_False;
 422             pImplLib->maPassword = OUString();
 423
 424             maModifiable.setModified( sal_True );
 425             pImplLib->implSetModified( sal_True );
 426
 427             if( !bStorage && !pImplLib->mbDoc50Password )
 428             {
 429                 // Store application basic uncrypted
 430                 uno::Reference< embed::XStorage > xStorage;
 431                 storeLibraries_Impl( xStorage, sal_False );
 432                 bKillCryptedFiles = sal_True;
 433             }
 434         }
 435     }
 436
 437     // Set new password?
 438     if( bNewPassword )
 439     {
 440         pImplLib->mbPasswordProtected = sal_True;
 441         pImplLib->mbPasswordVerified = sal_True;
 442         pImplLib->maPassword = NewPassword;
 443
 444         maModifiable.setModified( sal_True );
 445         pImplLib->implSetModified( sal_True );
 446
 447         if( !bStorage && !pImplLib->mbDoc50Password )
 448         {
 449             // Store applictaion basic crypted
 450             uno::Reference< embed::XStorage > xStorage;
 451             storeLibraries_Impl( xStorage, sal_False );
 452             bKillUncryptedFiles = sal_True;
 453         }
 454     }
 455
 456     if( bKillCryptedFiles || bKillUncryptedFiles )
 457     {
 458         Sequence< OUString > aElementNames = pImplLib->getElementNames();
 459         sal_Int32 nNameCount = aElementNames.getLength();
 460         const OUString* pNames = aElementNames.getConstArray();
 461         OUString aLibDirPath = createAppLibraryFolder( pImplLib, Name );
 462         try
 463         {
 464             for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
 465             {
 466                 OUString aElementName = pNames[ i ];
 467
 468                 INetURLObject aElementInetObj( aLibDirPath );
 469                 aElementInetObj.insertName( aElementName, sal_False,
 470                     INetURLObject::LAST_SEGMENT, sal_True, INetURLObject::ENCODE_ALL );
 471                 if( bKillUncryptedFiles )
 472                     aElementInetObj.setExtension( maLibElementFileExtension );
 473                 else
 474                     aElementInetObj.setExtension( OUString( RTL_CONSTASCII_USTRINGPARAM("pba") ) );
 475                 String aElementPath( aElementInetObj.GetMainURL( INetURLObject::NO_DECODE ) );
 476
 477                 if( mxSFI->exists( aElementPath ) )
 478                     mxSFI->kill( aElementPath );
 479             }
 480         }
 481         catch( Exception& ) {}
 482     }
 483 }
 484
 485
 486 void setStreamKey( uno::Reference< io::XStream > xStream, const ::rtl::OUString& aPass )
 487 {
 488     uno::Reference< embed::XEncryptionProtectedSource > xEncrStream( xStream, uno::UNO_QUERY );
 489     if ( xEncrStream.is() )
 490         xEncrStream->setEncryptionPassword( aPass );
 491 }
 492
 493
 494 // Impl methods
 495 sal_Bool SfxScriptLibraryContainer::implStorePasswordLibrary( SfxLibrary* pLib,
 496     const ::rtl::OUString& aName, const uno::Reference< embed::XStorage >& xStorage, const ::com::sun::star::uno::Reference< ::com::sun::star::task::XInteractionHandler >& xHandler )
 497 {
 498     OUString aDummyLocation;
 499     Reference< XSimpleFileAccess > xDummySFA;
 500     return implStorePasswordLibrary( pLib, aName, xStorage, aDummyLocation, xDummySFA, xHandler );
 501 }
 502
 503 sal_Bool SfxScriptLibraryContainer::implStorePasswordLibrary( SfxLibrary* pLib, const ::rtl::OUString& aName,
 504                         const ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >& xStorage,
 505                         const ::rtl::OUString& aTargetURL, const Reference< XSimpleFileAccess > xToUseSFI, const ::com::sun::star::uno::Reference< ::com::sun::star::task::XInteractionHandler >& xHandler )
 506 {
 507     bool bExport = aTargetURL.getLength();
 508
 509     BasicManager* pBasicMgr = getBasicManager();
 510     OSL_ENSURE( pBasicMgr, "SfxScriptLibraryContainer::implStorePasswordLibrary: cannot do this without a BasicManager!" );
 511     if ( !pBasicMgr )
 512         return sal_False;
 513
 514     // Only need to handle the export case here,
 515     // save/saveas etc are handled in sfxbasemodel::storeSelf &
 516     // sfxbasemodel::impl_store
 517     uno::Sequence<rtl::OUString> aNames;
 518     if ( bExport && pBasicMgr->LegacyPsswdBinaryLimitExceeded(aNames) )
 519     {
 520         if ( xHandler.is() )
 521         {
 522             ModuleSizeExceeded* pReq =  new ModuleSizeExceeded( aNames );
 523             uno::Reference< task::XInteractionRequest > xReq( pReq );
 524             xHandler->handle( xReq );
 525             if ( pReq->isAbort() )
 526                 throw util::VetoException();
 527         }
 528     }
 529
 530     StarBASIC* pBasicLib = pBasicMgr->GetLib( aName );
 531     if( !pBasicLib )
 532         return sal_False;
 533
 534     Sequence< OUString > aElementNames = pLib->getElementNames();
 535     sal_Int32 nNameCount = aElementNames.getLength();
 536     const OUString* pNames = aElementNames.getConstArray();
 537
 538     sal_Bool bLink = pLib->mbLink;
 539     sal_Bool bStorage = xStorage.is() && !bLink;
 540     if( bStorage )
 541     {
 542         for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
 543         {
 544             OUString aElementName = pNames[ i ];
 545
 546             // Write binary image stream
 547             SbModule* pMod = pBasicLib->FindModule( aElementName );
 548             if( pMod )
 549             {
 550                 //OUString aCodeStreamName( RTL_CONSTASCII_USTRINGPARAM("code.bin") );
 551                 OUString aCodeStreamName = aElementName;
 552                 aCodeStreamName += String( RTL_CONSTASCII_USTRINGPARAM(".bin") );
 553
 554                 try {
 555                     uno::Reference< io::XStream > xCodeStream = xStorage->openStreamElement(
 556                                         aCodeStreamName,
 557                                         embed::ElementModes::READWRITE | embed::ElementModes::TRUNCATE );
 558
 559                     if ( !xCodeStream.is() )
 560                         throw uno::RuntimeException();
 561
 562                     SvMemoryStream aMemStream;
 563                     /*BOOL bStore = */pMod->StoreBinaryData( aMemStream );
 564
 565                     sal_Int32 nSize = (sal_Int32)aMemStream.Tell();
 566                     Sequence< sal_Int8 > aBinSeq( nSize );
 567                     sal_Int8* pData = aBinSeq.getArray();
 568                     ::rtl_copyMemory( pData, aMemStream.GetData(), nSize );
 569
 570                        Reference< XOutputStream > xOut = xCodeStream->getOutputStream();
 571                     if ( !xOut.is() )
 572                         throw io::IOException(); // access denied because the stream is readonly
 573
 574                        xOut->writeBytes( aBinSeq );
 575                     xOut->closeOutput();
 576                 }
 577                 catch( uno::Exception& )
 578                 {
 579                     // TODO: handle error
 580                 }
 581             }
 582
 583             if( pLib->mbPasswordVerified || pLib->mbDoc50Password )
 584             {
 585                 Any aElement = pLib->getByName( aElementName );
 586                 if( !isLibraryElementValid( aElement ) )
 587                 {
 588                 #if OSL_DEBUG_LEVEL > 0
 589                     ::rtl::OStringBuffer aMessage;
 590                     aMessage.append( "invalid library element '" );
 591                     aMessage.append( ::rtl::OUStringToOString( aElementName, osl_getThreadTextEncoding() ) );
 592                     aMessage.append( "'." );
 593                     OSL_ENSURE( false, aMessage.makeStringAndClear().getStr() );
 594                 #endif
 595                     continue;
 596                 }
 597
 598                 OUString aSourceStreamName = aElementName;
 599                 aSourceStreamName += String( RTL_CONSTASCII_USTRINGPARAM(".xml") );
 600
 601                 try {
 602                     uno::Reference< io::XStream > xSourceStream = xStorage->openStreamElement(
 603                                                                 aSourceStreamName,
 604                                                                 embed::ElementModes::READWRITE );
 605                     uno::Reference< beans::XPropertySet > xProps( xSourceStream, uno::UNO_QUERY );
 606                     if ( !xProps.is() )
 607                         throw uno::RuntimeException();
 608
 609                     String aPropName( String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM("MediaType") ) );
 610                     OUString aMime( RTL_CONSTASCII_USTRINGPARAM("text/xml") );
 611                     xProps->setPropertyValue( aPropName, uno::makeAny( aMime ) );
 612
 613                     // Set encryption key
 614                     setStreamKey( xSourceStream, pLib->maPassword );
 615
 616                     Reference< XOutputStream > xOutput = xSourceStream->getOutputStream();
 617                     writeLibraryElement( aElement, aElementName, xOutput );
 618                     // writeLibraryElement should have the stream already closed
 619                     // xOutput->closeOutput();
 620                 }
 621                 catch( uno::Exception& )
 622                 {
 623                     OSL_ENSURE( sal_False, "Problem on storing of password library!\n" );
 624                     // TODO: error handling
 625                 }
 626             }
 627             else    // !mbPasswordVerified
 628             {
 629                 // TODO
 630                 // What to do if not verified?! In any case it's already loaded here
 631             }
 632         }
 633
 634     }
 635     // Application libraries have only to be saved if the password
 636     // is verified because otherwise they can't be modified
 637     else if( pLib->mbPasswordVerified || bExport )
 638     {
 639         try
 640         {
 641             Reference< XSimpleFileAccess > xSFI = mxSFI;
 642             if( xToUseSFI.is() )
 643                 xSFI = xToUseSFI;
 644
 645             OUString aLibDirPath;
 646             if( bExport )
 647             {
 648                 INetURLObject aInetObj( aTargetURL );
 649                 aInetObj.insertName( aName, sal_True, INetURLObject::LAST_SEGMENT, sal_True, INetURLObject::ENCODE_ALL );
 650                 aLibDirPath = aInetObj.GetMainURL( INetURLObject::NO_DECODE );
 651
 652                 if( !xSFI->isFolder( aLibDirPath ) )
 653                     xSFI->createFolder( aLibDirPath );
 654             }
 655             else
 656             {
 657                 aLibDirPath = createAppLibraryFolder( pLib, aName );
 658             }
 659
 660             for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
 661             {
 662                 OUString aElementName = pNames[ i ];
 663
 664                 INetURLObject aElementInetObj( aLibDirPath );
 665                 aElementInetObj.insertName( aElementName, sal_False,
 666                     INetURLObject::LAST_SEGMENT, sal_True, INetURLObject::ENCODE_ALL );
 667                 aElementInetObj.setExtension( OUString( RTL_CONSTASCII_USTRINGPARAM("pba") ) );
 668                 String aElementPath = aElementInetObj.GetMainURL( INetURLObject::NO_DECODE );
 669
 670                 Any aElement = pLib->getByName( aElementName );
 671                 if( !isLibraryElementValid( aElement ) )
 672                 {
 673                 #if OSL_DEBUG_LEVEL > 0
 674                     ::rtl::OStringBuffer aMessage;
 675                     aMessage.append( "invalid library element '" );
 676                     aMessage.append( ::rtl::OUStringToOString( aElementName, osl_getThreadTextEncoding() ) );
 677                     aMessage.append( "'." );
 678                     OSL_ENSURE( false, aMessage.makeStringAndClear().getStr() );
 679                 #endif
 680                     continue;
 681                 }
 682
 683                 try
 684                 {
 685                     uno::Reference< embed::XStorage > xElementRootStorage =
 686                                                             ::comphelper::OStorageHelper::GetStorageFromURL(
 687                                                                     aElementPath,
 688                                                                     embed::ElementModes::READWRITE );
 689                     if ( !xElementRootStorage.is() )
 690                         throw uno::RuntimeException();
 691
 692                     // Write binary image stream
 693                     SbModule* pMod = pBasicLib->FindModule( aElementName );
 694                     if( pMod )
 695                     {
 696                         OUString aCodeStreamName( RTL_CONSTASCII_USTRINGPARAM("code.bin") );
 697
 698                         uno::Reference< io::XStream > xCodeStream = xElementRootStorage->openStreamElement(
 699                                             aCodeStreamName,
 700                                             embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE );
 701
 702                         SvMemoryStream aMemStream;
 703                         /*BOOL bStore = */pMod->StoreBinaryData( aMemStream );
 704
 705                         sal_Int32 nSize = (sal_Int32)aMemStream.Tell();
 706                         Sequence< sal_Int8 > aBinSeq( nSize );
 707                         sal_Int8* pData = aBinSeq.getArray();
 708                         ::rtl_copyMemory( pData, aMemStream.GetData(), nSize );
 709
 710                         Reference< XOutputStream > xOut = xCodeStream->getOutputStream();
 711                         if ( xOut.is() )
 712                         {
 713                             xOut->writeBytes( aBinSeq );
 714                             xOut->closeOutput();
 715                         }
 716                     }
 717
 718                     // Write encrypted source stream
 719                     OUString aSourceStreamName( RTL_CONSTASCII_USTRINGPARAM("source.xml") );
 720
 721                     uno::Reference< io::XStream > xSourceStream;
 722                     try
 723                     {
 724                         xSourceStream = xElementRootStorage->openStreamElement(
 725                             aSourceStreamName,
 726                             embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE );
 727
 728                         // #87671 Allow encryption
 729                         uno::Reference< embed::XEncryptionProtectedSource > xEncr( xSourceStream, uno::UNO_QUERY );
 730                         OSL_ENSURE( xEncr.is(),
 731                                     "StorageStream opened for writing must implement XEncryptionProtectedSource!\n" );
 732                         if ( !xEncr.is() )
 733                             throw uno::RuntimeException();
 734                         xEncr->setEncryptionPassword( pLib->maPassword );
 735                     }
 736                     catch( ::com::sun::star::packages::WrongPasswordException& )
 737                     {
 738                         xSourceStream = xElementRootStorage->openEncryptedStreamElement(
 739                             aSourceStreamName,
 740                             embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE,
 741                             pLib->maPassword );
 742                     }
 743
 744                     uno::Reference< beans::XPropertySet > xProps( xSourceStream, uno::UNO_QUERY );
 745                     if ( !xProps.is() )
 746                         throw uno::RuntimeException();
 747                     String aPropName( String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM("MediaType") ) );
 748                     OUString aMime( RTL_CONSTASCII_USTRINGPARAM("text/xml") );
 749                     xProps->setPropertyValue( aPropName, uno::makeAny( aMime ) );
 750
 751                     Reference< XOutputStream > xOut = xSourceStream->getOutputStream();
 752                     writeLibraryElement( aElement, aElementName, xOut );
 753                     // i50568: sax writer already closes stream
 754                     // xOut->closeOutput();
 755
 756                     uno::Reference< embed::XTransactedObject > xTransact( xElementRootStorage, uno::UNO_QUERY );
 757                     OSL_ENSURE( xTransact.is(), "The storage must implement XTransactedObject!\n" );
 758                     if ( !xTransact.is() )
 759                         throw uno::RuntimeException();
 760
 761                     xTransact->commit();
 762                 }
 763                 catch( uno::Exception& )
 764                 {
 765                     // TODO: handle error
 766                 }
 767
 768                 // Storage Dtor commits too, that makes problems
 769                 // xElementRootStorage->Commit();
 770             }
 771         }
 772         catch( Exception& )
 773         {
 774             //throw e;
 775         }
 776     }
 777     return sal_True;
 778 }
 779
 780 sal_Bool SfxScriptLibraryContainer::implLoadPasswordLibrary
 781     ( SfxLibrary* pLib, const OUString& Name, sal_Bool bVerifyPasswordOnly )
 782         throw(WrappedTargetException, RuntimeException)
 783 {
 784     sal_Bool bRet = sal_True;
 785
 786     sal_Bool bLink = pLib->mbLink;
 787     sal_Bool bStorage = mxStorage.is() && !bLink;
 788
 789     // Already loaded? Then only verifiedPassword can change something
 790     SfxScriptLibrary* pScriptLib = static_cast< SfxScriptLibrary* >( pLib );
 791     if( pScriptLib->mbLoaded )
 792     {
 793         if( pScriptLib->mbLoadedBinary && !bVerifyPasswordOnly &&
 794             (pScriptLib->mbLoadedSource || !pLib->mbPasswordVerified) )
 795                 return sal_False;
 796     }
 797
 798     StarBASIC* pBasicLib = NULL;
 799     sal_Bool bLoadBinary = sal_False;
 800     if( !pScriptLib->mbLoadedBinary && !bVerifyPasswordOnly && !pLib->mbPasswordVerified )
 801     {
 802         BasicManager* pBasicMgr = getBasicManager();
 803         OSL_ENSURE( pBasicMgr, "SfxScriptLibraryContainer::implLoadPasswordLibrary: cannot do this without a BasicManager!" );
 804         sal_Bool bLoaded = pScriptLib->mbLoaded;
 805         pScriptLib->mbLoaded = sal_True;        // Necessary to get lib
 806         pBasicLib = pBasicMgr ? pBasicMgr->GetLib( Name ) : NULL;
 807         pScriptLib->mbLoaded = bLoaded;    // Restore flag
 808         if( !pBasicLib )
 809             return sal_False;
 810
 811         bLoadBinary = sal_True;
 812         pScriptLib->mbLoadedBinary = sal_True;
 813     }
 814
 815     sal_Bool bLoadSource = sal_False;
 816     if( !pScriptLib->mbLoadedSource && pLib->mbPasswordVerified && !bVerifyPasswordOnly )
 817     {
 818         bLoadSource = sal_True;
 819         pScriptLib->mbLoadedSource = sal_True;
 820     }
 821
 822     Sequence< OUString > aElementNames = pLib->getElementNames();
 823     sal_Int32 nNameCount = aElementNames.getLength();
 824     const OUString* pNames = aElementNames.getConstArray();
 825
 826     if( bStorage )
 827     {
 828         uno::Reference< embed::XStorage > xLibrariesStor;
 829         uno::Reference< embed::XStorage > xLibraryStor;
 830         if( bStorage )
 831         {
 832             try {
 833                 xLibrariesStor = mxStorage->openStorageElement( maLibrariesDir, embed::ElementModes::READ );
 834                 if ( !xLibrariesStor.is() )
 835                     throw uno::RuntimeException();
 836
 837                 xLibraryStor = xLibrariesStor->openStorageElement( Name, embed::ElementModes::READ );
 838                 if ( !xLibraryStor.is() )
 839                     throw uno::RuntimeException();
 840             }
 841             catch( uno::Exception& )
 842             {
 843                 OSL_ENSURE( 0, "### couln't open sub storage for library\n" );
 844                 return sal_False;
 845             }
 846         }
 847
 848         for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
 849         {
 850             OUString aElementName = pNames[ i ];
 851
 852             // Load binary
 853             if( bLoadBinary )
 854             {
 855                 SbModule* pMod = pBasicLib->FindModule( aElementName );
 856                 if( !pMod )
 857                 {
 858                     pMod = pBasicLib->MakeModule( aElementName, String() );
 859                     pBasicLib->SetModified( FALSE );
 860                 }
 861
 862                 //OUString aCodeStreamName( RTL_CONSTASCII_USTRINGPARAM("code.bin") );
 863                 OUString aCodeStreamName= aElementName;
 864                 aCodeStreamName += String( RTL_CONSTASCII_USTRINGPARAM(".bin") );
 865
 866                 try {
 867                     uno::Reference< io::XStream > xCodeStream = xLibraryStor->openStreamElement(
 868                                                                                         aCodeStreamName,
 869                                                                                         embed::ElementModes::READ );
 870                     if ( !xCodeStream.is() )
 871                         throw uno::RuntimeException();
 872
 873                     SvStream* pStream = ::utl::UcbStreamHelper::CreateStream( xCodeStream );
 874                     if ( !pStream || pStream->GetError() )
 875                     {
 876                         sal_Int32 nError = pStream ? pStream->GetError() : ERRCODE_IO_GENERAL;
 877                         delete pStream;
 878                         throw task::ErrorCodeIOException( ::rtl::OUString(), uno::Reference< uno::XInterface >(), nError );
 879                     }
 880
 881                     /*BOOL bRet = */pMod->LoadBinaryData( *pStream );
 882                     // TODO: Check return value
 883
 884                     delete pStream;
 885                 }
 886                 catch( uno::Exception& )
 887                 {
 888                     // TODO: error handling
 889                 }
 890             }
 891
 892             // Load source
 893             if( bLoadSource || bVerifyPasswordOnly )
 894             {
 895                 // Access encrypted source stream
 896                 OUString aSourceStreamName = aElementName;
 897                 aSourceStreamName += String( RTL_CONSTASCII_USTRINGPARAM(".xml") );
 898
 899                 try {
 900                     uno::Reference< io::XStream > xSourceStream = xLibraryStor->openEncryptedStreamElement(
 901                                                                     aSourceStreamName,
 902                                                                     embed::ElementModes::READ,
 903                                                                     pLib->maPassword );
 904                     if ( !xSourceStream.is() )
 905                         throw uno::RuntimeException();
 906
 907                     // if this point is reached then the password is correct
 908                     if ( !bVerifyPasswordOnly )
 909                     {
 910                         uno::Reference< io::XInputStream > xInStream = xSourceStream->getInputStream();
 911                         if ( !xInStream.is() )
 912                             throw io::IOException(); // read access denied, seems to be impossible
 913
 914                         Any aAny = importLibraryElement( aSourceStreamName, xInStream );
 915                         if( pLib->hasByName( aElementName ) )
 916                         {
 917                             if( aAny.hasValue() )
 918                                 pLib->maNameContainer.replaceByName( aElementName, aAny );
 919                         }
 920                         else
 921                         {
 922                             pLib->maNameContainer.insertByName( aElementName, aAny );
 923                         }
 924                     }
 925                 }
 926                 catch( uno::Exception& )
 927                 {
 928                     bRet = sal_False;
 929                 }
 930             }
 931         }
 932     }
 933     else
 934     {
 935         try
 936         {
 937             OUString aLibDirPath = createAppLibraryFolder( pLib, Name );
 938
 939             for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
 940             {
 941                 OUString aElementName = pNames[ i ];
 942
 943                 INetURLObject aElementInetObj( aLibDirPath );
 944                 aElementInetObj.insertName( aElementName, sal_False,
 945                     INetURLObject::LAST_SEGMENT, sal_True, INetURLObject::ENCODE_ALL );
 946                 aElementInetObj.setExtension( OUString( RTL_CONSTASCII_USTRINGPARAM("pba") ) );
 947                 String aElementPath = aElementInetObj.GetMainURL( INetURLObject::NO_DECODE );
 948
 949                 uno::Reference< embed::XStorage > xElementRootStorage;
 950                 try {
 951                     xElementRootStorage = ::comphelper::OStorageHelper::GetStorageFromURL(
 952                                                                     aElementPath,
 953                                                                     embed::ElementModes::READWRITE );
 954                 } catch( uno::Exception& )
 955                 {
 956                     // TODO: error handling
 957                 }
 958
 959                 if ( xElementRootStorage.is() )
 960                 {
 961                     // Load binary
 962                     if( bLoadBinary )
 963                     {
 964                         SbModule* pMod = pBasicLib->FindModule( aElementName );
 965                         if( !pMod )
 966                         {
 967                             pMod = pBasicLib->MakeModule( aElementName, String() );
 968                             pBasicLib->SetModified( FALSE );
 969                         }
 970
 971                         try {
 972                             OUString aCodeStreamName( RTL_CONSTASCII_USTRINGPARAM("code.bin") );
 973                             uno::Reference< io::XStream > xCodeStream = xElementRootStorage->openStreamElement(
 974                                                                         aCodeStreamName,
 975                                                                         embed::ElementModes::READ );
 976
 977                             SvStream* pStream = ::utl::UcbStreamHelper::CreateStream( xCodeStream );
 978                             if ( !pStream || pStream->GetError() )
 979                             {
 980                                 sal_Int32 nError = pStream ? pStream->GetError() : ERRCODE_IO_GENERAL;
 981                                 delete pStream;
 982                                 throw task::ErrorCodeIOException( ::rtl::OUString(),
 983                                                                     uno::Reference< uno::XInterface >(),
 984                                                                     nError );
 985                             }
 986
 987                             /*BOOL bRet = */pMod->LoadBinaryData( *pStream );
 988                             // TODO: Check return value
 989
 990                             delete pStream;
 991                         }
 992                         catch( uno::Exception& )
 993                         {
 994                             // TODO: error handling
 995                         }
 996                     }
 997
 998                     // Load source
 999                     if( bLoadSource || bVerifyPasswordOnly )
1000                     {
1001                         // Access encrypted source stream
1002                         OUString aSourceStreamName( RTL_CONSTASCII_USTRINGPARAM("source.xml") );
1003                         try {
1004                             uno::Reference< io::XStream > xSourceStream = xElementRootStorage->openEncryptedStreamElement(
1005                                                                     aSourceStreamName,
1006                                                                     embed::ElementModes::READ,
1007                                                                     pLib->maPassword );
1008                             if ( !xSourceStream.is() )
1009                                 throw uno::RuntimeException();
1010
1011                             if ( !bVerifyPasswordOnly )
1012                             {
1013                                 uno::Reference< io::XInputStream > xInStream = xSourceStream->getInputStream();
1014                                 if ( !xInStream.is() )
1015                                     throw io::IOException(); // read access denied, seems to be impossible
1016
1017                                 Any aAny = importLibraryElement( aSourceStreamName, xInStream );
1018                                 if( pLib->hasByName( aElementName ) )
1019                                 {
1020                                     if( aAny.hasValue() )
1021                                         pLib->maNameContainer.replaceByName( aElementName, aAny );
1022                                 }
1023                                 else
1024                                 {
1025                                     pLib->maNameContainer.insertByName( aElementName, aAny );
1026                                 }
1027                             }
1028                         }
1029                         catch ( uno::Exception& )
1030                         {
1031                             bRet = sal_False;
1032                         }
1033                     }
1034                 }
1035             }
1036
1037         }
1038         catch( Exception& )
1039         {
1040             // TODO
1041             //throw e;
1042         }
1043     }
1044
1045 //REMOVE            // If the password is verified the library must remain modified, because
1046 //REMOVE            // otherwise for saving the storage would be copied and that doesn't work
1047 //REMOVE            // with mtg's storages when the password is verified
1048 //REMOVE            if( !pLib->mbPasswordVerified )
1049 //REMOVE                pLib->mbModified = sal_False;
1050     return bRet;
1051 }
1052
1053
1054 void SfxScriptLibraryContainer::onNewRootStorage()
1055 {
1056 }
1057
1058 sal_Bool SAL_CALL
1059 SfxScriptLibraryContainer:: HasExecutableCode( const ::rtl::OUString& Library ) throw (uno::RuntimeException)
1060 {
1061         BasicManager* pBasicMgr = getBasicManager();
1062         OSL_ENSURE( pBasicMgr, "we need a basicmanager, really we do" );
1063         if ( pBasicMgr )
1064                 return pBasicMgr->HasExeCode( Library ); // need to change this to take name
1065         // default to it has code if we can't decide
1066         return sal_True;
1067 }
1068
1069 //============================================================================
1070 // Service
1071 void createRegistryInfo_SfxScriptLibraryContainer()
1072 {
1073     static OAutoRegistration< SfxScriptLibraryContainer > aAutoRegistration;
1074 }
1075
1076 ::rtl::OUString SAL_CALL SfxScriptLibraryContainer::getImplementationName( ) throw (RuntimeException)
1077 {
1078     return getImplementationName_static();
1079 }
1080
1081 Sequence< ::rtl::OUString > SAL_CALL SfxScriptLibraryContainer::getSupportedServiceNames( ) throw (RuntimeException)
1082 {
1083     return getSupportedServiceNames_static();
1084 }
1085
1086 Sequence< OUString > SfxScriptLibraryContainer::getSupportedServiceNames_static()
1087 {
1088     Sequence< OUString > aServiceNames( 2 );
1089     aServiceNames[0] = OUString::createFromAscii( "com.sun.star.script.DocumentScriptLibraryContainer" );
1090     // plus, for compatibility:
1091     aServiceNames[1] = OUString::createFromAscii( "com.sun.star.script.ScriptLibraryContainer" );
1092     return aServiceNames;
1093 }
1094
1095 OUString SfxScriptLibraryContainer::getImplementationName_static()
1096 {
1097     static OUString aImplName;
1098     static sal_Bool bNeedsInit = sal_True;
1099
1100     MutexGuard aGuard( Mutex::getGlobalMutex() );
1101     if( bNeedsInit )
1102     {
1103         aImplName = OUString::createFromAscii( "com.sun.star.comp.sfx2.ScriptLibraryContainer" );
1104         bNeedsInit = sal_False;
1105     }
1106     return aImplName;
1107 }
1108
1109 Reference< XInterface > SAL_CALL SfxScriptLibraryContainer::Create
1110     ( const Reference< XComponentContext >& )
1111         throw( Exception )
1112 {
1113     Reference< XInterface > xRet =
1114         static_cast< XInterface* >( static_cast< OWeakObject* >(new SfxScriptLibraryContainer()) );
1115     return xRet;
1116 }
1117
1118 //============================================================================
1119 // Implementation class SfxScriptLibrary
1120
1121 // Ctor
1122 SfxScriptLibrary::SfxScriptLibrary( ModifiableHelper& _rModifiable,
1123                                     const Reference< XMultiServiceFactory >& xMSF,
1124                                     const Reference< XSimpleFileAccess >& xSFI )
1125     : SfxLibrary( _rModifiable, getCppuType( (const OUString *)0 ), xMSF, xSFI )
1126     , mbLoadedSource( sal_False )
1127     , mbLoadedBinary( sal_False )
1128 {
1129 }
1130
1131 SfxScriptLibrary::SfxScriptLibrary( ModifiableHelper& _rModifiable,
1132                                     const Reference< XMultiServiceFactory >& xMSF,
1133                                     const Reference< XSimpleFileAccess >& xSFI,
1134                                     const OUString& aLibInfoFileURL,
1135                                     const OUString& aStorageURL,
1136                                     sal_Bool ReadOnly )
1137     : SfxLibrary( _rModifiable, getCppuType( (const OUString *)0 ), xMSF, xSFI,
1138                         aLibInfoFileURL, aStorageURL, ReadOnly)
1139     , mbLoadedSource( sal_False )
1140     , mbLoadedBinary( sal_False )
1141 {
1142 }
1143
1144 // Provide modify state including resources
1145 sal_Bool SfxScriptLibrary::isModified( void )
1146 {
1147     return implIsModified();    // No resources
1148 }
1149
1150 void SfxScriptLibrary::storeResources( void )
1151 {
1152     // No resources
1153 }
1154
1155 void SfxScriptLibrary::storeResourcesToURL( const ::rtl::OUString& URL,
1156     const Reference< task::XInteractionHandler >& Handler )
1157 {
1158     (void)URL;
1159     (void)Handler;
1160 }
1161
1162 void SfxScriptLibrary::storeResourcesAsURL
1163     ( const ::rtl::OUString& URL, const ::rtl::OUString& NewName )
1164 {
1165     (void)URL;
1166     (void)NewName;
1167 }
1168
1169 void SfxScriptLibrary::storeResourcesToStorage( const ::com::sun::star::uno::Reference
1170     < ::com::sun::star::embed::XStorage >& xStorage )
1171 {
1172     // No resources
1173     (void)xStorage;
1174 }
1175
1176 bool SfxScriptLibrary::containsValidModule( const Any& aElement )
1177 {
1178     OUString sModuleText;
1179         ::com::sun::star::script::ModuleInfo mInfo;
1180         if ( aElement >>= mInfo )
1181                 sModuleText = mInfo.ModuleSource;
1182         else
1183     aElement >>= sModuleText;
1184     return ( sModuleText.getLength() > 0 );
1185 }
1186
1187 bool SAL_CALL SfxScriptLibrary::isLibraryElementValid( ::com::sun::star::uno::Any aElement ) const
1188 {
1189     return SfxScriptLibrary::containsValidModule( aElement );
1190 }
1191
1192 //============================================================================
1193
1194 }   // namespace basic