basic/source/uno/scriptcont.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 "scriptcont.hxx"
  21 #include <filefmt.hxx>
  22 #include <com/sun/star/container/XNameContainer.hpp>
  23 #include <com/sun/star/xml/sax/Parser.hpp>
  24 #include <com/sun/star/xml/sax/InputSource.hpp>
  25 #include <com/sun/star/xml/sax/Writer.hpp>
  26 #include <com/sun/star/io/XOutputStream.hpp>
  27 #include <com/sun/star/io/XInputStream.hpp>
  28 #include <com/sun/star/io/XActiveDataSource.hpp>
  29 #include <com/sun/star/ucb/XSimpleFileAccess3.hpp>
  30 #include <com/sun/star/embed/ElementModes.hpp>
  31 #include <com/sun/star/embed/XEncryptionProtectedSource.hpp>
  32 #include <com/sun/star/beans/XPropertySet.hpp>
  33 #include <com/sun/star/embed/XTransactedObject.hpp>
  34 #include <com/sun/star/task/ErrorCodeIOException.hpp>
  35 #include <com/sun/star/script/ModuleType.hpp>
  36 #include <comphelper/processfactory.hxx>
  37 #include <comphelper/storagehelper.hxx>
  38 #include <unotools/streamwrap.hxx>
  39 #include <unotools/ucbstreamhelper.hxx>
  40 #include <osl/mutex.hxx>
  41 #include <osl/thread.h>
  42 #include <rtl/digest.h>
  43 #include <rtl/strbuf.hxx>
  44
  45 // For password functionality
  46 #include <tools/urlobj.hxx>
  47
  48
  49 #include <unotools/pathoptions.hxx>
  50 #include <svtools/sfxecode.hxx>
  51 #include <svtools/ehdl.hxx>
  52 #include <basic/basmgr.hxx>
  53 #include <basic/sbmod.hxx>
  54 #include <basic/basicmanagerrepository.hxx>
  55 #include <basic/modsizeexceeded.hxx>
  56 #include <xmlscript/xmlmod_imexp.hxx>
  57 #include <cppuhelper/factory.hxx>
  58 #include <com/sun/star/util/VetoException.hpp>
  59 #include <com/sun/star/script/XLibraryQueryExecutable.hpp>
  60 #include <cppuhelper/implbase1.hxx>
  61 #include <boost/scoped_ptr.hpp>
  62
  63 namespace basic
  64 {
  65
  66 using namespace com::sun::star::document;
  67 using namespace com::sun::star::container;
  68 using namespace com::sun::star::io;
  69 using namespace com::sun::star::uno;
  70 using namespace com::sun::star::ucb;
  71 using namespace com::sun::star::lang;
  72 using namespace com::sun::star::script;
  73 using namespace com::sun::star::xml::sax;
  74 using namespace com::sun::star;
  75 using namespace cppu;
  76 using namespace osl;
  77
  78
  79 // Implementation class SfxScriptLibraryContainer
  80
  81 const sal_Char* SAL_CALL SfxScriptLibraryContainer::getInfoFileName() const { return "script"; }
  82 const sal_Char* SAL_CALL SfxScriptLibraryContainer::getOldInfoFileName() const { return "script"; }
  83 const sal_Char* SAL_CALL SfxScriptLibraryContainer::getLibElementFileExtension() const { return "xba"; }
  84 const sal_Char* SAL_CALL SfxScriptLibraryContainer::getLibrariesDir() const { return "Basic"; }
  85
  86 // OldBasicPassword interface
  87 void SfxScriptLibraryContainer::setLibraryPassword( const OUString& rLibraryName, const OUString& rPassword )
  88 {
  89     try
  90     {
  91         SfxLibrary* pImplLib = getImplLib( rLibraryName );
  92         if( !rPassword.isEmpty() )
  93         {
  94             pImplLib->mbDoc50Password = true;
  95             pImplLib->mbPasswordProtected = true;
  96             pImplLib->maPassword = rPassword;
  97         }
  98     }
  99     catch(const NoSuchElementException& ) {}
 100 }
 101
 102 OUString SfxScriptLibraryContainer::getLibraryPassword( const OUString& rLibraryName )
 103 {
 104     SfxLibrary* pImplLib = getImplLib( rLibraryName );
 105     OUString aPassword;
 106     if( pImplLib->mbPasswordVerified )
 107     {
 108         aPassword = pImplLib->maPassword;
 109     }
 110     return aPassword;
 111 }
 112
 113 void SfxScriptLibraryContainer::clearLibraryPassword( const OUString& rLibraryName )
 114 {
 115     try
 116     {
 117         SfxLibrary* pImplLib = getImplLib( rLibraryName );
 118         pImplLib->mbDoc50Password = false;
 119         pImplLib->mbPasswordProtected = false;
 120         pImplLib->maPassword.clear();
 121     }
 122     catch(const NoSuchElementException& ) {}
 123 }
 124
 125 bool SfxScriptLibraryContainer::hasLibraryPassword( const OUString& rLibraryName )
 126 {
 127     SfxLibrary* pImplLib = getImplLib( rLibraryName );
 128     return pImplLib->mbPasswordProtected;
 129 }
 130
 131 // Ctor for service
 132 SfxScriptLibraryContainer::SfxScriptLibraryContainer()
 133     :maScriptLanguage( "StarBasic"  )
 134 {
 135     // all initialisation has to be done
 136     // by calling XInitialization::initialize
 137 }
 138
 139 SfxScriptLibraryContainer::SfxScriptLibraryContainer( const uno::Reference< embed::XStorage >& xStorage )
 140     :maScriptLanguage( "StarBasic"  )
 141 {
 142     init( OUString(), xStorage );
 143 }
 144
 145 // Methods to get library instances of the correct type
 146 SfxLibrary* SfxScriptLibraryContainer::implCreateLibrary( const OUString& aName )
 147 {
 148     (void)aName;    // Only needed for SfxDialogLibrary
 149     SfxLibrary* pRet = new SfxScriptLibrary( maModifiable, mxContext, mxSFI );
 150     return pRet;
 151 }
 152
 153 SfxLibrary* SfxScriptLibraryContainer::implCreateLibraryLink( const OUString& aName,
 154                                                               const OUString& aLibInfoFileURL,
 155                                                               const OUString& StorageURL,
 156                                                               bool ReadOnly )
 157 {
 158     (void)aName;    // Only needed for SfxDialogLibrary
 159     SfxLibrary* pRet = new SfxScriptLibrary( maModifiable, mxContext, mxSFI,
 160                                              aLibInfoFileURL, StorageURL, ReadOnly );
 161     return pRet;
 162 }
 163
 164 Any SAL_CALL SfxScriptLibraryContainer::createEmptyLibraryElement()
 165 {
 166     OUString aMod;
 167     Any aRetAny;
 168     aRetAny <<= aMod;
 169     return aRetAny;
 170 }
 171
 172 bool SAL_CALL SfxScriptLibraryContainer::isLibraryElementValid(const Any& rElement) const
 173 {
 174     return SfxScriptLibrary::containsValidModule(rElement);
 175 }
 176
 177 void SAL_CALL SfxScriptLibraryContainer::writeLibraryElement( const Reference < XNameContainer >& xLib,
 178                                                               const OUString& aElementName,
 179                                                               const Reference< XOutputStream >& xOutput)
 180     throw(Exception)
 181 {
 182     // Create sax writer
 183     Reference< XWriter > xWriter = xml::sax::Writer::create(mxContext);
 184
 185     Reference< XTruncate > xTruncate( xOutput, UNO_QUERY );
 186     OSL_ENSURE( xTruncate.is(), "Currently only the streams that can be truncated are expected!" );
 187     if ( xTruncate.is() )
 188     {
 189         xTruncate->truncate();
 190     }
 191     xWriter->setOutputStream( xOutput );
 192
 193     xmlscript::ModuleDescriptor aMod;
 194     aMod.aName = aElementName;
 195     aMod.aLanguage = maScriptLanguage;
 196     Any aElement = xLib->getByName( aElementName );
 197     aElement >>= aMod.aCode;
 198
 199     Reference< script::vba::XVBAModuleInfo > xModInfo( xLib, UNO_QUERY );
 200     if( xModInfo.is() && xModInfo->hasModuleInfo( aElementName ) )
 201     {
 202         script::ModuleInfo aModInfo = xModInfo->getModuleInfo( aElementName );
 203         switch( aModInfo.ModuleType )
 204         {
 205         case ModuleType::NORMAL:
 206             aMod.aModuleType = "normal";
 207             break;
 208         case ModuleType::CLASS:
 209             aMod.aModuleType ="class";
 210             break;
 211         case ModuleType::FORM:
 212             aMod.aModuleType = "form";
 213             break;
 214         case ModuleType::DOCUMENT:
 215             aMod.aModuleType = "document";
 216             break;
 217         case ModuleType::UNKNOWN:
 218             // nothing
 219             break;
 220         }
 221     }
 222
 223     xmlscript::exportScriptModule( xWriter, aMod );
 224 }
 225
 226
 227 Any SAL_CALL SfxScriptLibraryContainer::importLibraryElement
 228     ( const Reference < XNameContainer >& xLib,
 229       const OUString& aElementName, const OUString& aFile,
 230       const uno::Reference< io::XInputStream >& xInStream )
 231 {
 232     Any aRetAny;
 233
 234     Reference< XParser > xParser = xml::sax::Parser::create( mxContext );
 235
 236     // Read from storage?
 237     bool bStorage = xInStream.is();
 238     Reference< XInputStream > xInput;
 239
 240     if( bStorage )
 241     {
 242         xInput = xInStream;
 243     }
 244     else
 245     {
 246         try
 247         {
 248             xInput = mxSFI->openFileRead( aFile );
 249         }
 250         catch(const Exception& )
 251         //catch( Exception& e )
 252         {
 253             // TODO:
 254             //throw WrappedTargetException( e );
 255         }
 256     }
 257
 258     if( !xInput.is() )
 259         return aRetAny;
 260
 261     InputSource source;
 262     source.aInputStream = xInput;
 263     source.sSystemId    = aFile;
 264
 265     // start parsing
 266     xmlscript::ModuleDescriptor aMod;
 267
 268     try
 269     {
 270         xParser->setDocumentHandler( ::xmlscript::importScriptModule( aMod ) );
 271         xParser->parseStream( source );
 272     }
 273     catch(const Exception& )
 274     {
 275         SfxErrorContext aEc( ERRCTX_SFX_LOADBASIC, aFile );
 276         ErrorHandler::HandleError( ERRCODE_IO_GENERAL );
 277     }
 278
 279     aRetAny <<= aMod.aCode;
 280
 281     // TODO: Check language
 282     // aMod.aLanguage
 283     // aMod.aName ignored
 284     if( !aMod.aModuleType.isEmpty() )
 285     {
 286         /*  If in VBA compatibility mode, force creation of the VBA Globals
 287             object. Each application will create an instance of its own
 288             implementation and store it in its Basic manager. Implementations
 289             will do all necessary additional initialization, such as
 290             registering the global "This***Doc" UNO constant, starting the
 291             document events processor etc.
 292          */
 293         if( getVBACompatibilityMode() ) try
 294         {
 295             Reference< frame::XModel > xModel( mxOwnerDocument );   // weak-ref -> ref
 296             Reference< XMultiServiceFactory > xFactory( xModel, UNO_QUERY_THROW );
 297             xFactory->createInstance("ooo.vba.VBAGlobals");
 298         }
 299         catch(const Exception& )
 300         {
 301         }
 302
 303         script::ModuleInfo aModInfo;
 304         aModInfo.ModuleType = ModuleType::UNKNOWN;
 305         if( aMod.aModuleType == "normal" )
 306         {
 307             aModInfo.ModuleType = ModuleType::NORMAL;
 308         }
 309         else if( aMod.aModuleType == "class" )
 310         {
 311             aModInfo.ModuleType = ModuleType::CLASS;
 312         }
 313         else if( aMod.aModuleType == "form" )
 314         {
 315             aModInfo.ModuleType = ModuleType::FORM;
 316             aModInfo.ModuleObject = mxOwnerDocument;
 317         }
 318         else if( aMod.aModuleType == "document" )
 319         {
 320             aModInfo.ModuleType = ModuleType::DOCUMENT;
 321
 322             // #163691# use the same codename access instance for all document modules
 323             if( !mxCodeNameAccess.is() ) try
 324             {
 325                 Reference<frame::XModel > xModel( mxOwnerDocument );
 326                 Reference< XMultiServiceFactory> xSF( xModel, UNO_QUERY_THROW );
 327                 mxCodeNameAccess.set( xSF->createInstance("ooo.vba.VBAObjectModuleObjectProvider"), UNO_QUERY );
 328             }
 329             catch(const Exception& ) {}
 330
 331             if( mxCodeNameAccess.is() )
 332             {
 333                 try
 334                 {
 335                     aModInfo.ModuleObject.set( mxCodeNameAccess->getByName( aElementName), uno::UNO_QUERY );
 336                 }
 337                 catch(const uno::Exception&)
 338                 {
 339                     OSL_TRACE("Failed to get documument object for %s", OUStringToOString( aElementName, RTL_TEXTENCODING_UTF8 ).getStr() );
 340                 }
 341             }
 342         }
 343
 344         Reference< script::vba::XVBAModuleInfo > xVBAModuleInfo( xLib, UNO_QUERY );
 345         if( xVBAModuleInfo.is() )
 346         {
 347             if( xVBAModuleInfo->hasModuleInfo( aElementName ) )
 348             {
 349                 xVBAModuleInfo->removeModuleInfo( aElementName );
 350             }
 351             xVBAModuleInfo->insertModuleInfo( aElementName, aModInfo );
 352         }
 353     }
 354
 355     return aRetAny;
 356 }
 357
 358 SfxLibraryContainer* SfxScriptLibraryContainer::createInstanceImpl()
 359 {
 360     return new SfxScriptLibraryContainer();
 361 }
 362
 363 void SAL_CALL SfxScriptLibraryContainer::importFromOldStorage( const OUString& aFile )
 364 {
 365     // TODO: move loading from old storage to binary filters?
 366     tools::SvRef<SotStorage> xStorage = new SotStorage( false, aFile );
 367     if( xStorage.Is() && xStorage->GetError() == ERRCODE_NONE )
 368     {
 369         BasicManager* pBasicManager = new BasicManager( *(SotStorage*)xStorage, aFile );
 370
 371         // Set info
 372         LibraryContainerInfo aInfo( this, NULL, static_cast< OldBasicPassword* >( this ) );
 373         pBasicManager->SetLibraryContainerInfo( aInfo );
 374
 375         // Now the libraries should be copied to this SfxScriptLibraryContainer
 376         BasicManager::LegacyDeleteBasicManager( pBasicManager );
 377     }
 378 }
 379
 380
 381 // Storing with password encryption
 382
 383 // Methods XLibraryContainerPassword
 384 sal_Bool SAL_CALL SfxScriptLibraryContainer::isLibraryPasswordProtected( const OUString& Name )
 385     throw (NoSuchElementException, RuntimeException, std::exception)
 386 {
 387     LibraryContainerMethodGuard aGuard( *this );
 388     SfxLibrary* pImplLib = getImplLib( Name );
 389     bool bRet = pImplLib->mbPasswordProtected;
 390     return bRet;
 391 }
 392
 393 sal_Bool SAL_CALL SfxScriptLibraryContainer::isLibraryPasswordVerified( const OUString& Name )
 394     throw (IllegalArgumentException, NoSuchElementException, RuntimeException, std::exception)
 395 {
 396     LibraryContainerMethodGuard aGuard( *this );
 397     SfxLibrary* pImplLib = getImplLib( Name );
 398     if( !pImplLib->mbPasswordProtected )
 399     {
 400         throw IllegalArgumentException();
 401     }
 402     bool bRet = pImplLib->mbPasswordVerified;
 403     return bRet;
 404 }
 405
 406 sal_Bool SAL_CALL SfxScriptLibraryContainer::verifyLibraryPassword
 407     ( const OUString& Name, const OUString& Password )
 408         throw (IllegalArgumentException, NoSuchElementException, RuntimeException, std::exception)
 409 {
 410     LibraryContainerMethodGuard aGuard( *this );
 411     SfxLibrary* pImplLib = getImplLib( Name );
 412     if( !pImplLib->mbPasswordProtected || pImplLib->mbPasswordVerified )
 413     {
 414         throw IllegalArgumentException();
 415     }
 416     // Test password
 417     bool bSuccess = false;
 418     if( pImplLib->mbDoc50Password )
 419     {
 420         bSuccess = ( Password == pImplLib->maPassword );
 421         if( bSuccess )
 422         {
 423             pImplLib->mbPasswordVerified = true;
 424         }
 425     }
 426     else
 427     {
 428         pImplLib->maPassword = Password;
 429         bSuccess = implLoadPasswordLibrary( pImplLib, Name, true );
 430         if( bSuccess )
 431         {
 432             // The library gets modified by verifying the password, because other-
 433             // wise for saving the storage would be copied and that doesn't work
 434             // with mtg's storages when the password is verified
 435             pImplLib->implSetModified( true );
 436             pImplLib->mbPasswordVerified = true;
 437
 438             // Reload library to get source
 439             if( pImplLib->mbLoaded )
 440             {
 441                 implLoadPasswordLibrary( pImplLib, Name );
 442             }
 443         }
 444     }
 445     return bSuccess;
 446 }
 447
 448 void SAL_CALL SfxScriptLibraryContainer::changeLibraryPassword( const OUString& Name,
 449                                                                 const OUString& OldPassword,
 450                                                                 const OUString& NewPassword )
 451         throw (IllegalArgumentException, NoSuchElementException, RuntimeException, std::exception)
 452 {
 453     LibraryContainerMethodGuard aGuard( *this );
 454     SfxLibrary* pImplLib = getImplLib( Name );
 455     if( OldPassword == NewPassword )
 456     {
 457         return;
 458     }
 459     bool bOldPassword = !OldPassword.isEmpty();
 460     bool bNewPassword = !NewPassword.isEmpty();
 461     bool bStorage = mxStorage.is() && !pImplLib->mbLink;
 462
 463     if( pImplLib->mbReadOnly || (bOldPassword && !pImplLib->mbPasswordProtected) )
 464     {
 465         throw IllegalArgumentException();
 466     }
 467     // Library must be loaded
 468     loadLibrary( Name );
 469
 470     bool bKillCryptedFiles = false;
 471     bool bKillUncryptedFiles = false;
 472
 473     // Remove or change password?
 474     if( bOldPassword )
 475     {
 476         if( isLibraryPasswordVerified( Name ) )
 477         {
 478             if( pImplLib->maPassword != OldPassword )
 479             {
 480                    throw IllegalArgumentException();
 481             }
 482         }
 483         else
 484         {
 485             if( !verifyLibraryPassword( Name, OldPassword ) )
 486             {
 487                    throw IllegalArgumentException();
 488             }
 489             // Reload library to get source
 490             // Should be done in verifyLibraryPassword loadLibrary( Name );
 491         }
 492
 493         if( !bNewPassword )
 494         {
 495             pImplLib->mbPasswordProtected = false;
 496             pImplLib->mbPasswordVerified = false;
 497             pImplLib->maPassword.clear();
 498
 499             maModifiable.setModified( true );
 500             pImplLib->implSetModified( true );
 501
 502             if( !bStorage && !pImplLib->mbDoc50Password )
 503             {
 504                 // Store application basic uncrypted
 505                 uno::Reference< embed::XStorage > xStorage;
 506                 storeLibraries_Impl( xStorage, false );
 507                 bKillCryptedFiles = true;
 508             }
 509         }
 510     }
 511
 512     // Set new password?
 513     if( bNewPassword )
 514     {
 515         pImplLib->mbPasswordProtected = true;
 516         pImplLib->mbPasswordVerified = true;
 517         pImplLib->maPassword = NewPassword;
 518
 519         maModifiable.setModified( true );
 520         pImplLib->implSetModified( true );
 521
 522         if( !bStorage && !pImplLib->mbDoc50Password )
 523         {
 524             // Store application basic crypted
 525             uno::Reference< embed::XStorage > xStorage;
 526             storeLibraries_Impl( xStorage, false );
 527             bKillUncryptedFiles = true;
 528         }
 529     }
 530
 531     if( bKillCryptedFiles || bKillUncryptedFiles )
 532     {
 533         Sequence< OUString > aElementNames = pImplLib->getElementNames();
 534         sal_Int32 nNameCount = aElementNames.getLength();
 535         const OUString* pNames = aElementNames.getConstArray();
 536         OUString aLibDirPath = createAppLibraryFolder( pImplLib, Name );
 537         try
 538         {
 539             for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
 540             {
 541                 OUString aElementName = pNames[ i ];
 542
 543                 INetURLObject aElementInetObj( aLibDirPath );
 544                 aElementInetObj.insertName( aElementName, false,
 545                                             INetURLObject::LAST_SEGMENT, true,
 546                                             INetURLObject::ENCODE_ALL );
 547                 if( bKillUncryptedFiles )
 548                 {
 549                     aElementInetObj.setExtension( maLibElementFileExtension );
 550                 }
 551                 else
 552                 {
 553                     aElementInetObj.setExtension( OUString( "pba" ) );
 554                 }
 555                 OUString aElementPath( aElementInetObj.GetMainURL( INetURLObject::NO_DECODE ) );
 556
 557                 if( mxSFI->exists( aElementPath ) )
 558                 {
 559                     mxSFI->kill( aElementPath );
 560                 }
 561             }
 562         }
 563         catch(const Exception& ) {}
 564     }
 565 }
 566
 567
 568 void setStreamKey( uno::Reference< io::XStream > xStream, const OUString& aPass )
 569 {
 570     uno::Reference< embed::XEncryptionProtectedSource > xEncrStream( xStream, uno::UNO_QUERY );
 571     if ( xEncrStream.is() )
 572     {
 573         xEncrStream->setEncryptionPassword( aPass );
 574     }
 575 }
 576
 577
 578 // Impl methods
 579 bool SfxScriptLibraryContainer::implStorePasswordLibrary( SfxLibrary* pLib,
 580                                                           const OUString& aName,
 581                                                           const uno::Reference< embed::XStorage >& xStorage,
 582                                                           const ::com::sun::star::uno::Reference< ::com::sun::star::task::XInteractionHandler >& xHandler )
 583 {
 584     OUString aDummyLocation;
 585     Reference< XSimpleFileAccess3 > xDummySFA;
 586     return implStorePasswordLibrary( pLib, aName, xStorage, aDummyLocation, xDummySFA, xHandler );
 587 }
 588
 589 bool SfxScriptLibraryContainer::implStorePasswordLibrary( SfxLibrary* pLib, const OUString& aName,
 590                                                           const ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >& xStorage,
 591                                                           const OUString& aTargetURL,
 592                                                           const Reference< XSimpleFileAccess3 >& rToUseSFI,
 593                                                           const ::com::sun::star::uno::Reference< ::com::sun::star::task::XInteractionHandler >& xHandler )
 594 {
 595     bool bExport = !aTargetURL.isEmpty();
 596
 597     BasicManager* pBasicMgr = getBasicManager();
 598     OSL_ENSURE( pBasicMgr, "SfxScriptLibraryContainer::implStorePasswordLibrary: cannot do this without a BasicManager!" );
 599     if ( !pBasicMgr )
 600     {
 601         return false;
 602     }
 603     // Only need to handle the export case here,
 604     // save/saveas etc are handled in sfxbasemodel::storeSelf &
 605     // sfxbasemodel::impl_store
 606     uno::Sequence<OUString> aNames;
 607     if ( bExport && pBasicMgr->LegacyPsswdBinaryLimitExceeded(aNames) )
 608     {
 609         if ( xHandler.is() )
 610         {
 611             ModuleSizeExceeded* pReq =  new ModuleSizeExceeded( aNames );
 612             uno::Reference< task::XInteractionRequest > xReq( pReq );
 613             xHandler->handle( xReq );
 614             if ( pReq->isAbort() )
 615             {
 616                 throw util::VetoException();
 617             }
 618         }
 619     }
 620
 621     StarBASIC* pBasicLib = pBasicMgr->GetLib( aName );
 622     if( !pBasicLib )
 623     {
 624         return false;
 625     }
 626     Sequence< OUString > aElementNames = pLib->getElementNames();
 627     sal_Int32 nNameCount = aElementNames.getLength();
 628     const OUString* pNames = aElementNames.getConstArray();
 629
 630     bool bLink = pLib->mbLink;
 631     bool bStorage = xStorage.is() && !bLink;
 632     if( bStorage )
 633     {
 634         for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
 635         {
 636             OUString aElementName = pNames[ i ];
 637
 638             // Write binary image stream
 639             SbModule* pMod = pBasicLib->FindModule( aElementName );
 640             if( pMod )
 641             {
 642                 OUString aCodeStreamName = aElementName;
 643                 aCodeStreamName += ".bin";
 644
 645                 try
 646                 {
 647                     uno::Reference< io::XStream > xCodeStream = xStorage->openStreamElement(
 648                             aCodeStreamName,
 649                             embed::ElementModes::READWRITE | embed::ElementModes::TRUNCATE );
 650
 651                     if ( !xCodeStream.is() )
 652                     {
 653                         throw uno::RuntimeException();
 654                     }
 655                     SvMemoryStream aMemStream;
 656                     /*sal_Bool bStore = */pMod->StoreBinaryData( aMemStream, B_CURVERSION );
 657
 658                     sal_Size nSize = aMemStream.Tell();
 659                     Sequence< sal_Int8 > aBinSeq( nSize );
 660                     sal_Int8* pData = aBinSeq.getArray();
 661                     memcpy( pData, aMemStream.GetData(), nSize );
 662
 663                        Reference< XOutputStream > xOut = xCodeStream->getOutputStream();
 664                     if ( !xOut.is() )
 665                     {
 666                         throw io::IOException(); // access denied because the stream is readonly
 667                     }
 668                     xOut->writeBytes( aBinSeq );
 669                     xOut->closeOutput();
 670                 }
 671                 catch(const uno::Exception& )
 672                 {
 673                     // TODO: handle error
 674                 }
 675             }
 676
 677             if( pLib->mbPasswordVerified || pLib->mbDoc50Password )
 678             {
 679                 if( !isLibraryElementValid( pLib->getByName( aElementName ) ) )
 680                 {
 681                     #if OSL_DEBUG_LEVEL > 0
 682                     OString aMessage = "invalid library element '" +
 683                                         OUStringToOString( aElementName, osl_getThreadTextEncoding() ) +
 684                                         "'.";
 685                     OSL_FAIL( aMessage.getStr());
 686                     #endif
 687                     continue;
 688                 }
 689
 690                 OUString aSourceStreamName = aElementName;
 691                 aSourceStreamName += ".xml";
 692
 693                 try
 694                 {
 695                     uno::Reference< io::XStream > xSourceStream = xStorage->openStreamElement(
 696                             aSourceStreamName,
 697                             embed::ElementModes::READWRITE );
 698                     uno::Reference< beans::XPropertySet > xProps( xSourceStream, uno::UNO_QUERY );
 699                     if ( !xProps.is() )
 700                     {
 701                         throw uno::RuntimeException();
 702                     }
 703                     OUString aMime( "text/xml" );
 704                     xProps->setPropertyValue("MediaType", uno::makeAny( aMime ) );
 705
 706                     // Set encryption key
 707                     setStreamKey( xSourceStream, pLib->maPassword );
 708
 709                     Reference< XOutputStream > xOutput = xSourceStream->getOutputStream();
 710                     Reference< XNameContainer > xLib( pLib );
 711                     writeLibraryElement( xLib, aElementName, xOutput );
 712                 }
 713                 catch(const uno::Exception& )
 714                 {
 715                     OSL_FAIL( "Problem on storing of password library!\n" );
 716                     // TODO: error handling
 717                 }
 718             }
 719             else    // !mbPasswordVerified
 720             {
 721                 // TODO
 722                 // What to do if not verified?! In any case it's already loaded here
 723             }
 724         }
 725
 726     }
 727     // Application libraries have only to be saved if the password
 728     // is verified because otherwise they can't be modified
 729     else if( pLib->mbPasswordVerified || bExport )
 730     {
 731         try
 732         {
 733             Reference< XSimpleFileAccess3 > xSFI = mxSFI;
 734             if( rToUseSFI.is() )
 735             {
 736                 xSFI = rToUseSFI;
 737             }
 738             OUString aLibDirPath;
 739             if( bExport )
 740             {
 741                 INetURLObject aInetObj( aTargetURL );
 742                 aInetObj.insertName( aName, true, INetURLObject::LAST_SEGMENT, true,
 743                                      INetURLObject::ENCODE_ALL );
 744                 aLibDirPath = aInetObj.GetMainURL( INetURLObject::NO_DECODE );
 745
 746                 if( !xSFI->isFolder( aLibDirPath ) )
 747                 {
 748                     xSFI->createFolder( aLibDirPath );
 749                 }
 750             }
 751             else
 752             {
 753                 aLibDirPath = createAppLibraryFolder( pLib, aName );
 754             }
 755
 756             for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
 757             {
 758                 OUString aElementName = pNames[ i ];
 759
 760                 INetURLObject aElementInetObj( aLibDirPath );
 761                 aElementInetObj.insertName( aElementName, false,
 762                                             INetURLObject::LAST_SEGMENT, true,
 763                                             INetURLObject::ENCODE_ALL );
 764                 aElementInetObj.setExtension( OUString( "pba" ) );
 765                 OUString aElementPath = aElementInetObj.GetMainURL( INetURLObject::NO_DECODE );
 766
 767                 if( !isLibraryElementValid( pLib->getByName( aElementName ) ) )
 768                 {
 769                     #if OSL_DEBUG_LEVEL > 0
 770                     OString aMessage = "invalid library element '" +
 771                                        OUStringToOString( aElementName, osl_getThreadTextEncoding() ) +
 772                                        "'.";
 773                     OSL_FAIL( aMessage.getStr());
 774                     #endif
 775                     continue;
 776                 }
 777
 778                 try
 779                 {
 780                     uno::Reference< embed::XStorage > xElementRootStorage =
 781                         ::comphelper::OStorageHelper::GetStorageFromURL(
 782                                 aElementPath,
 783                                 embed::ElementModes::READWRITE );
 784                     if ( !xElementRootStorage.is() )
 785                     {
 786                         throw uno::RuntimeException();
 787                     }
 788                     // Write binary image stream
 789                     SbModule* pMod = pBasicLib->FindModule( aElementName );
 790                     if( pMod )
 791                     {
 792                         OUString aCodeStreamName( "code.bin" );
 793
 794                         uno::Reference< io::XStream > xCodeStream = xElementRootStorage->openStreamElement(
 795                                             aCodeStreamName,
 796                                             embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE );
 797
 798                         SvMemoryStream aMemStream;
 799                         /*sal_Bool bStore = */pMod->StoreBinaryData( aMemStream, B_CURVERSION );
 800
 801                         sal_Size nSize = aMemStream.Tell();
 802                         Sequence< sal_Int8 > aBinSeq( nSize );
 803                         sal_Int8* pData = aBinSeq.getArray();
 804                         memcpy( pData, aMemStream.GetData(), nSize );
 805
 806                         Reference< XOutputStream > xOut = xCodeStream->getOutputStream();
 807                         if ( xOut.is() )
 808                         {
 809                             xOut->writeBytes( aBinSeq );
 810                             xOut->closeOutput();
 811                         }
 812                     }
 813
 814                     // Write encrypted source stream
 815                     OUString aSourceStreamName( "source.xml" );
 816
 817                     uno::Reference< io::XStream > xSourceStream;
 818                     try
 819                     {
 820                         xSourceStream = xElementRootStorage->openStreamElement(
 821                             aSourceStreamName,
 822                             embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE );
 823
 824                         // #87671 Allow encryption
 825                         uno::Reference< embed::XEncryptionProtectedSource > xEncr( xSourceStream, uno::UNO_QUERY );
 826                         OSL_ENSURE( xEncr.is(),
 827                                     "StorageStream opened for writing must implement XEncryptionProtectedSource!\n" );
 828                         if ( !xEncr.is() )
 829                         {
 830                             throw uno::RuntimeException();
 831                         }
 832                         xEncr->setEncryptionPassword( pLib->maPassword );
 833                     }
 834                     catch(const ::com::sun::star::packages::WrongPasswordException& )
 835                     {
 836                         xSourceStream = xElementRootStorage->openEncryptedStreamElement(
 837                                 aSourceStreamName,
 838                                 embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE,
 839                                 pLib->maPassword );
 840                     }
 841
 842                     uno::Reference< beans::XPropertySet > xProps( xSourceStream, uno::UNO_QUERY );
 843                     if ( !xProps.is() )
 844                     {
 845                         throw uno::RuntimeException();
 846                     }
 847                     OUString aMime( "text/xml" );
 848                     xProps->setPropertyValue("MediaType", uno::makeAny( aMime ) );
 849
 850                     Reference< XOutputStream > xOut = xSourceStream->getOutputStream();
 851                     Reference< XNameContainer > xLib( pLib );
 852                     writeLibraryElement( xLib, aElementName, xOut );
 853                     // i50568: sax writer already closes stream
 854                     // xOut->closeOutput();
 855
 856                     uno::Reference< embed::XTransactedObject > xTransact( xElementRootStorage, uno::UNO_QUERY );
 857                     OSL_ENSURE( xTransact.is(), "The storage must implement XTransactedObject!\n" );
 858                     if ( !xTransact.is() )
 859                     {
 860                         throw uno::RuntimeException();
 861                     }
 862
 863                     xTransact->commit();
 864                 }
 865                 catch(const uno::Exception& )
 866                 {
 867                     // TODO: handle error
 868                 }
 869
 870             }
 871         }
 872         catch(const Exception& )
 873         {
 874         }
 875     }
 876     return true;
 877 }
 878
 879 bool SfxScriptLibraryContainer::implLoadPasswordLibrary
 880     ( SfxLibrary* pLib, const OUString& Name, bool bVerifyPasswordOnly )
 881         throw(WrappedTargetException, RuntimeException)
 882 {
 883     bool bRet = true;
 884
 885     bool bLink = pLib->mbLink;
 886     bool bStorage = mxStorage.is() && !bLink;
 887
 888     // Already loaded? Then only verifiedPassword can change something
 889     SfxScriptLibrary* pScriptLib = static_cast< SfxScriptLibrary* >( pLib );
 890     if( pScriptLib->mbLoaded )
 891     {
 892         if( pScriptLib->mbLoadedBinary && !bVerifyPasswordOnly &&
 893             (pScriptLib->mbLoadedSource || !pLib->mbPasswordVerified) )
 894         {
 895             return false;
 896         }
 897     }
 898
 899     StarBASIC* pBasicLib = NULL;
 900     bool bLoadBinary = false;
 901     if( !pScriptLib->mbLoadedBinary && !bVerifyPasswordOnly && !pLib->mbPasswordVerified )
 902     {
 903         BasicManager* pBasicMgr = getBasicManager();
 904         OSL_ENSURE( pBasicMgr, "SfxScriptLibraryContainer::implLoadPasswordLibrary: cannot do this without a BasicManager!" );
 905         bool bLoaded = pScriptLib->mbLoaded;
 906         pScriptLib->mbLoaded = true;        // Necessary to get lib
 907         pBasicLib = pBasicMgr ? pBasicMgr->GetLib( Name ) : NULL;
 908         pScriptLib->mbLoaded = bLoaded;    // Restore flag
 909         if( !pBasicLib )
 910         {
 911             return false;
 912         }
 913         bLoadBinary = true;
 914         pScriptLib->mbLoadedBinary = true;
 915     }
 916
 917     bool bLoadSource = false;
 918     if( !pScriptLib->mbLoadedSource && pLib->mbPasswordVerified && !bVerifyPasswordOnly )
 919     {
 920         bLoadSource = true;
 921         pScriptLib->mbLoadedSource = true;
 922     }
 923
 924     Sequence< OUString > aElementNames = pLib->getElementNames();
 925     sal_Int32 nNameCount = aElementNames.getLength();
 926     const OUString* pNames = aElementNames.getConstArray();
 927
 928     if( bStorage )
 929     {
 930         uno::Reference< embed::XStorage > xLibrariesStor;
 931         uno::Reference< embed::XStorage > xLibraryStor;
 932         if( bStorage )
 933         {
 934             try {
 935                 xLibrariesStor = mxStorage->openStorageElement( maLibrariesDir, embed::ElementModes::READ );
 936                 if ( !xLibrariesStor.is() )
 937                 {
 938                     throw uno::RuntimeException();
 939                 }
 940                 xLibraryStor = xLibrariesStor->openStorageElement( Name, embed::ElementModes::READ );
 941                 if ( !xLibraryStor.is() )
 942                 {
 943                     throw uno::RuntimeException();
 944                 }
 945             }
 946             catch(const uno::Exception& )
 947             {
 948                 OSL_FAIL( "### couldn't open sub storage for library\n" );
 949                 return false;
 950             }
 951         }
 952
 953         for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
 954         {
 955             OUString aElementName = pNames[ i ];
 956
 957             // Load binary
 958             if( bLoadBinary )
 959             {
 960                 SbModule* pMod = pBasicLib->FindModule( aElementName );
 961                 if( !pMod )
 962                 {
 963                     pMod = pBasicLib->MakeModule( aElementName, OUString() );
 964                     pBasicLib->SetModified( false );
 965                 }
 966
 967                 OUString aCodeStreamName= aElementName;
 968                 aCodeStreamName += ".bin";
 969
 970                 try
 971                 {
 972                     uno::Reference< io::XStream > xCodeStream = xLibraryStor->openStreamElement(
 973                                                                                         aCodeStreamName,
 974                                                                                         embed::ElementModes::READ );
 975                     if ( !xCodeStream.is() )
 976                     {
 977                         throw uno::RuntimeException();
 978                     }
 979                     boost::scoped_ptr<SvStream> pStream(::utl::UcbStreamHelper::CreateStream( xCodeStream ));
 980                     if ( !pStream || pStream->GetError() )
 981                     {
 982                         sal_Int32 nError = pStream ? pStream->GetError() : ERRCODE_IO_GENERAL;
 983                         throw task::ErrorCodeIOException(
 984                             ("utl::UcbStreamHelper::CreateStream failed for \""
 985                              + aCodeStreamName + "\": 0x"
 986                              + OUString::number(nError, 16)),
 987                             uno::Reference< uno::XInterface >(), nError);
 988                     }
 989
 990                     /*sal_Bool bRet = */pMod->LoadBinaryData( *pStream );
 991                     // TODO: Check return value
 992                 }
 993                 catch(const uno::Exception& )
 994                 {
 995                     // TODO: error handling
 996                 }
 997             }
 998
 999             // Load source
1000             if( bLoadSource || bVerifyPasswordOnly )
1001             {
1002                 // Access encrypted source stream
1003                 OUString aSourceStreamName = aElementName;
1004                 aSourceStreamName += ".xml";
1005
1006                 try
1007                 {
1008                     uno::Reference< io::XStream > xSourceStream = xLibraryStor->openEncryptedStreamElement(
1009                                                                     aSourceStreamName,
1010                                                                     embed::ElementModes::READ,
1011                                                                     pLib->maPassword );
1012                     if ( !xSourceStream.is() )
1013                     {
1014                         throw uno::RuntimeException();
1015                     }
1016                     // if this point is reached then the password is correct
1017                     if ( !bVerifyPasswordOnly )
1018                     {
1019                         uno::Reference< io::XInputStream > xInStream = xSourceStream->getInputStream();
1020                         if ( !xInStream.is() )
1021                         {
1022                             throw io::IOException(); // read access denied, seems to be impossible
1023                         }
1024                         Reference< XNameContainer > xLib( pLib );
1025                         Any aAny = importLibraryElement( xLib,
1026                                                          aElementName, aSourceStreamName,
1027                                                          xInStream );
1028                         if( pLib->hasByName( aElementName ) )
1029                         {
1030                             if( aAny.hasValue() )
1031                             {
1032                                 pLib->maNameContainer.replaceByName( aElementName, aAny );
1033                             }
1034                         }
1035                         else
1036                         {
1037                             pLib->maNameContainer.insertByName( aElementName, aAny );
1038                         }
1039                     }
1040                 }
1041                 catch(const uno::Exception& )
1042                 {
1043                     bRet = false;
1044                 }
1045             }
1046         }
1047     }
1048     else
1049     {
1050         try
1051         {
1052             OUString aLibDirPath = createAppLibraryFolder( pLib, Name );
1053
1054             for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
1055             {
1056                 OUString aElementName = pNames[ i ];
1057
1058                 INetURLObject aElementInetObj( aLibDirPath );
1059                 aElementInetObj.insertName( aElementName, false,
1060                     INetURLObject::LAST_SEGMENT, true, INetURLObject::ENCODE_ALL );
1061                 aElementInetObj.setExtension( OUString( "pba" ) );
1062                 OUString aElementPath = aElementInetObj.GetMainURL( INetURLObject::NO_DECODE );
1063
1064                 uno::Reference< embed::XStorage > xElementRootStorage;
1065                 try
1066                 {
1067                     xElementRootStorage = ::comphelper::OStorageHelper::GetStorageFromURL(
1068                             aElementPath,
1069                             embed::ElementModes::READ );
1070                 } catch(const uno::Exception& )
1071                 {
1072                     // TODO: error handling
1073                 }
1074
1075                 if ( xElementRootStorage.is() )
1076                 {
1077                     // Load binary
1078                     if( bLoadBinary )
1079                     {
1080                         SbModule* pMod = pBasicLib->FindModule( aElementName );
1081                         if( !pMod )
1082                         {
1083                             pMod = pBasicLib->MakeModule( aElementName, OUString() );
1084                             pBasicLib->SetModified( false );
1085                         }
1086
1087                         try
1088                         {
1089                             OUString aCodeStreamName( "code.bin" );
1090                             uno::Reference< io::XStream > xCodeStream = xElementRootStorage->openStreamElement(
1091                                                                         aCodeStreamName,
1092                                                                         embed::ElementModes::READ );
1093
1094                             boost::scoped_ptr<SvStream> pStream(::utl::UcbStreamHelper::CreateStream( xCodeStream ));
1095                             if ( !pStream || pStream->GetError() )
1096                             {
1097                                 sal_Int32 nError = pStream ? pStream->GetError() : ERRCODE_IO_GENERAL;
1098                                 throw task::ErrorCodeIOException(
1099                                     ("utl::UcbStreamHelper::CreateStream failed"
1100                                      " for code.bin: 0x"
1101                                      + OUString::number(nError, 16)),
1102                                     uno::Reference< uno::XInterface >(),
1103                                     nError);
1104                             }
1105
1106                             /*sal_Bool bRet = */pMod->LoadBinaryData( *pStream );
1107                             // TODO: Check return value
1108                         }
1109                         catch(const uno::Exception& )
1110                         {
1111                             // TODO: error handling
1112                         }
1113                     }
1114
1115                     // Load source
1116                     if( bLoadSource || bVerifyPasswordOnly )
1117                     {
1118                         // Access encrypted source stream
1119                         OUString aSourceStreamName( "source.xml" );
1120                         try
1121                         {
1122                             uno::Reference< io::XStream > xSourceStream = xElementRootStorage->openEncryptedStreamElement(
1123                                                                     aSourceStreamName,
1124                                                                     embed::ElementModes::READ,
1125                                                                     pLib->maPassword );
1126                             if ( !xSourceStream.is() )
1127                             {
1128                                 throw uno::RuntimeException();
1129                             }
1130                             if ( !bVerifyPasswordOnly )
1131                             {
1132                                 uno::Reference< io::XInputStream > xInStream = xSourceStream->getInputStream();
1133                                 if ( !xInStream.is() )
1134                                 {
1135                                     throw io::IOException(); // read access denied, seems to be impossible
1136                                 }
1137                                 Reference< XNameContainer > xLib( pLib );
1138                                 Any aAny = importLibraryElement( xLib,
1139                                                                  aElementName,
1140                                                                  aSourceStreamName,
1141                                                                  xInStream );
1142                                 if( pLib->hasByName( aElementName ) )
1143                                 {
1144                                     if( aAny.hasValue() )
1145                                     {
1146                                         pLib->maNameContainer.replaceByName( aElementName, aAny );
1147                                     }
1148                                 }
1149                                 else
1150                                 {
1151                                     pLib->maNameContainer.insertByName( aElementName, aAny );
1152                                 }
1153                             }
1154                         }
1155                         catch (const uno::Exception& )
1156                         {
1157                             bRet = false;
1158                         }
1159                     }
1160                 }
1161             }
1162         }
1163         catch(const Exception& )
1164         {
1165             // TODO
1166             //throw e;
1167         }
1168     }
1169
1170     return bRet;
1171 }
1172
1173
1174 void SfxScriptLibraryContainer::onNewRootStorage()
1175 {
1176 }
1177
1178 sal_Bool SAL_CALL SfxScriptLibraryContainer:: HasExecutableCode( const OUString& Library )
1179     throw (uno::RuntimeException, std::exception)
1180 {
1181     BasicManager* pBasicMgr = getBasicManager();
1182     OSL_ENSURE( pBasicMgr, "we need a basicmanager, really we do" );
1183     if ( pBasicMgr )
1184     {
1185         return pBasicMgr->HasExeCode( Library ); // need to change this to take name
1186     }
1187     // default to it has code if we can't decide
1188     return sal_True;
1189 }
1190
1191
1192 // Service
1193 OUString SAL_CALL SfxScriptLibraryContainer::getImplementationName( )
1194     throw (RuntimeException, std::exception)
1195 {
1196     return OUString("com.sun.star.comp.sfx2.ScriptLibraryContainer" );
1197 }
1198
1199 Sequence< OUString > SAL_CALL SfxScriptLibraryContainer::getSupportedServiceNames( )
1200     throw (RuntimeException, std::exception)
1201 {
1202     Sequence< OUString > aServiceNames( 2 );
1203     aServiceNames[0] = "com.sun.star.script.DocumentScriptLibraryContainer";
1204     // plus, for compatibility:
1205     aServiceNames[1] = "com.sun.star.script.ScriptLibraryContainer";
1206     return aServiceNames;
1207 }
1208
1209 // Implementation class SfxScriptLibrary
1210
1211 // Ctor
1212 SfxScriptLibrary::SfxScriptLibrary( ModifiableHelper& _rModifiable,
1213                                     const Reference< XComponentContext >& xContext,
1214                                     const Reference< XSimpleFileAccess3 >& xSFI )
1215     : SfxLibrary( _rModifiable, cppu::UnoType<OUString>::get(), xContext, xSFI )
1216     , mbLoadedSource( false )
1217     , mbLoadedBinary( false )
1218 {
1219 }
1220
1221 SfxScriptLibrary::SfxScriptLibrary( ModifiableHelper& _rModifiable,
1222                                     const Reference< XComponentContext >& xContext,
1223                                     const Reference< XSimpleFileAccess3 >& xSFI,
1224                                     const OUString& aLibInfoFileURL,
1225                                     const OUString& aStorageURL,
1226                                     bool ReadOnly )
1227     : SfxLibrary( _rModifiable, cppu::UnoType<OUString>::get(), xContext, xSFI,
1228                         aLibInfoFileURL, aStorageURL, ReadOnly)
1229     , mbLoadedSource( false )
1230     , mbLoadedBinary( false )
1231 {
1232 }
1233
1234 bool SfxScriptLibrary::isLoadedStorable()
1235 {
1236     // note: mbLoadedSource can only be true for password-protected lib!
1237     return SfxLibrary::isLoadedStorable() && (!mbPasswordProtected || mbLoadedSource);
1238 }
1239
1240 // Provide modify state including resources
1241 bool SfxScriptLibrary::isModified()
1242 {
1243     return implIsModified();    // No resources
1244 }
1245
1246 void SfxScriptLibrary::storeResources()
1247 {
1248     // No resources
1249 }
1250
1251 void SfxScriptLibrary::storeResourcesToURL( const OUString& URL,
1252     const Reference< task::XInteractionHandler >& Handler )
1253 {
1254     (void)URL;
1255     (void)Handler;
1256 }
1257
1258 void SfxScriptLibrary::storeResourcesAsURL
1259     ( const OUString& URL, const OUString& NewName )
1260 {
1261     (void)URL;
1262     (void)NewName;
1263 }
1264
1265 void SfxScriptLibrary::storeResourcesToStorage( const ::com::sun::star::uno::Reference
1266     < ::com::sun::star::embed::XStorage >& xStorage )
1267 {
1268     // No resources
1269     (void)xStorage;
1270 }
1271
1272 bool SfxScriptLibrary::containsValidModule(const Any& rElement)
1273 {
1274     OUString sModuleText;
1275     rElement >>= sModuleText;
1276     return ( !sModuleText.isEmpty() );
1277 }
1278
1279 bool SAL_CALL SfxScriptLibrary::isLibraryElementValid(const css::uno::Any& rElement) const
1280 {
1281     return SfxScriptLibrary::containsValidModule(rElement);
1282 }
1283
1284 IMPLEMENT_FORWARD_XINTERFACE2( SfxScriptLibrary, SfxLibrary, SfxScriptLibrary_BASE );
1285 IMPLEMENT_FORWARD_XTYPEPROVIDER2( SfxScriptLibrary, SfxLibrary, SfxScriptLibrary_BASE );
1286
1287 script::ModuleInfo SAL_CALL SfxScriptLibrary::getModuleInfo( const OUString& ModuleName )
1288     throw (NoSuchElementException, WrappedTargetException, RuntimeException, std::exception)
1289 {
1290     if ( !hasModuleInfo( ModuleName ) )
1291     {
1292         throw NoSuchElementException();
1293     }
1294     return mModuleInfos[ ModuleName ];
1295 }
1296
1297 sal_Bool SAL_CALL SfxScriptLibrary::hasModuleInfo( const OUString& ModuleName )
1298     throw (RuntimeException, std::exception)
1299 {
1300     bool bRes = false;
1301     ModuleInfoMap::iterator it = mModuleInfos.find( ModuleName );
1302
1303     if ( it != mModuleInfos.end() )
1304     {
1305         bRes = true;
1306     }
1307     return bRes;
1308 }
1309
1310 void SAL_CALL SfxScriptLibrary::insertModuleInfo( const OUString& ModuleName, const script::ModuleInfo& ModuleInfo )
1311     throw (IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException, std::exception)
1312 {
1313     if ( hasModuleInfo( ModuleName ) )
1314     {
1315         throw ElementExistException();
1316     }
1317     mModuleInfos[ ModuleName ] = ModuleInfo;
1318 }
1319
1320 void SAL_CALL SfxScriptLibrary::removeModuleInfo( const OUString& ModuleName )
1321     throw (NoSuchElementException, WrappedTargetException, RuntimeException, std::exception)
1322 {
1323         // #FIXME add NoSuchElementException to the spec
1324     if ( !hasModuleInfo( ModuleName ) )
1325     {
1326         throw NoSuchElementException();
1327     }
1328     mModuleInfos.erase( mModuleInfos.find( ModuleName ) );
1329 }
1330
1331 }   // namespace basic
1332
1333
1334 extern "C" SAL_DLLPUBLIC_EXPORT ::com::sun::star::uno::XInterface* SAL_CALL
1335 com_sun_star_comp_sfx2_ScriptLibraryContainer_get_implementation(::com::sun::star::uno::XComponentContext*,
1336                                                                  ::com::sun::star::uno::Sequence<css::uno::Any> const &)
1337 {
1338     return cppu::acquire(new basic::SfxScriptLibraryContainer());
1339 }
1340
1341
1342 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */