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