1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_basic.hxx" 26 #include <tools/stream.hxx> 27 #include <sot/storage.hxx> 28 #include <tools/urlobj.hxx> 29 #include <svl/smplhint.hxx> 30 #include <vcl/svapp.hxx> 31 #include <vcl/window.hxx> 32 #include <vcl/wrkwin.hxx> 33 #include <vcl/msgbox.hxx> 34 #include <basic/sbx.hxx> 35 #include <sot/storinfo.hxx> 36 #include <unotools/pathoptions.hxx> 37 #include <tools/debug.hxx> 38 #include <tools/diagnose_ex.h> 39 #include <basic/sbmod.hxx> 40 #include <basic/sbobjmod.hxx> 41 #include <unotools/intlwrapper.hxx> 42 #include <comphelper/processfactory.hxx> 43 44 #include <basic/sbuno.hxx> 45 #include <basic/basmgr.hxx> 46 #include <sbunoobj.hxx> 47 #include "basrid.hxx" 48 #include "sbintern.hxx" 49 #include <sb.hrc> 50 51 52 #define LIB_SEP 0x01 53 #define LIBINFO_SEP 0x02 54 #define LIBINFO_ID 0x1491 55 #define PASSWORD_MARKER 0x31452134 56 57 58 // Library API, implemented for XML import/export 59 60 #include <com/sun/star/container/XNameContainer.hpp> 61 #include <com/sun/star/container/XContainer.hpp> 62 #include <com/sun/star/script/XStarBasicAccess.hpp> 63 #include <com/sun/star/script/XStarBasicModuleInfo.hpp> 64 #include <com/sun/star/script/XStarBasicDialogInfo.hpp> 65 #include <com/sun/star/script/XStarBasicLibraryInfo.hpp> 66 #include <com/sun/star/script/XLibraryContainerPassword.hpp> 67 #include <com/sun/star/script/ModuleInfo.hpp> 68 #include <com/sun/star/script/vba/XVBACompatibility.hpp> 69 #include <com/sun/star/script/vba/XVBAModuleInfo.hpp> 70 71 #include <cppuhelper/implbase1.hxx> 72 73 using com::sun::star::uno::Reference; 74 using namespace com::sun::star::container; 75 using namespace com::sun::star::uno; 76 using namespace com::sun::star::lang; 77 using namespace com::sun::star::script; 78 using namespace cppu; 79 80 typedef WeakImplHelper1< XNameContainer > NameContainerHelper; 81 typedef WeakImplHelper1< XStarBasicModuleInfo > ModuleInfoHelper; 82 typedef WeakImplHelper1< XStarBasicDialogInfo > DialogInfoHelper; 83 typedef WeakImplHelper1< XStarBasicLibraryInfo > LibraryInfoHelper; 84 typedef WeakImplHelper1< XStarBasicAccess > StarBasicAccessHelper; 85 86 87 88 #define CURR_VER 2 89 90 // Version 1 91 // sal_uIntPtr nEndPos 92 // sal_uInt16 nId 93 // sal_uInt16 nVer 94 // sal_Bool bDoLoad 95 // String LibName 96 // String AbsStorageName 97 // String RelStorageName 98 // Version 2 99 // + sal_Bool bReference 100 101 static const char* szStdLibName = "Standard"; 102 static const char szBasicStorage[] = "StarBASIC"; 103 static const char* szOldManagerStream = "BasicManager"; 104 static const char szManagerStream[] = "BasicManager2"; 105 static const char* szImbedded = "LIBIMBEDDED"; 106 static const char* szCryptingKey = "CryptedBasic"; 107 static const char* szScriptLanguage = "StarBasic"; 108 109 TYPEINIT1( BasicManager, SfxBroadcaster ); 110 DBG_NAME( BasicManager ); 111 112 StreamMode eStreamReadMode = STREAM_READ | STREAM_NOCREATE | STREAM_SHARE_DENYALL; 113 StreamMode eStorageReadMode = STREAM_READ | STREAM_SHARE_DENYWRITE; 114 115 DECLARE_LIST( BasErrorLst, BasicError* ) 116 117 //---------------------------------------------------------------------------- 118 // BasicManager impl data 119 struct BasicManagerImpl 120 { 121 LibraryContainerInfo maContainerInfo; 122 123 // Save stream data 124 SvMemoryStream* mpManagerStream; 125 SvMemoryStream** mppLibStreams; 126 sal_Int32 mnLibStreamCount; 127 sal_Bool mbModifiedByLibraryContainer; 128 sal_Bool mbError; 129 130 BasicManagerImpl( void ) 131 : mpManagerStream( NULL ) 132 , mppLibStreams( NULL ) 133 , mnLibStreamCount( 0 ) 134 , mbModifiedByLibraryContainer( sal_False ) 135 , mbError( sal_False ) 136 {} 137 ~BasicManagerImpl(); 138 }; 139 140 BasicManagerImpl::~BasicManagerImpl() 141 { 142 delete mpManagerStream; 143 if( mppLibStreams ) 144 { 145 for( sal_Int32 i = 0 ; i < mnLibStreamCount ; i++ ) 146 delete mppLibStreams[i]; 147 delete[] mppLibStreams; 148 } 149 } 150 151 //============================================================================ 152 // BasMgrContainerListenerImpl 153 //============================================================================ 154 155 typedef ::cppu::WeakImplHelper1< ::com::sun::star::container::XContainerListener > ContainerListenerHelper; 156 157 class BasMgrContainerListenerImpl: public ContainerListenerHelper 158 { 159 BasicManager* mpMgr; 160 ::rtl::OUString maLibName; // empty -> no lib, but lib container 161 162 public: 163 BasMgrContainerListenerImpl( BasicManager* pMgr, ::rtl::OUString aLibName ) 164 : mpMgr( pMgr ) 165 , maLibName( aLibName ) {} 166 167 static void insertLibraryImpl( const Reference< XLibraryContainer >& xScriptCont, BasicManager* pMgr, 168 Any aLibAny, ::rtl::OUString aLibName ); 169 static void addLibraryModulesImpl( BasicManager* pMgr, Reference< XNameAccess > xLibNameAccess, 170 ::rtl::OUString aLibName ); 171 172 173 // XEventListener 174 virtual void SAL_CALL disposing( const ::com::sun::star::lang::EventObject& Source ) 175 throw(::com::sun::star::uno::RuntimeException); 176 177 // XContainerListener 178 virtual void SAL_CALL elementInserted( const ::com::sun::star::container::ContainerEvent& Event ) 179 throw(::com::sun::star::uno::RuntimeException); 180 virtual void SAL_CALL elementReplaced( const ::com::sun::star::container::ContainerEvent& Event ) 181 throw(::com::sun::star::uno::RuntimeException); 182 virtual void SAL_CALL elementRemoved( const ::com::sun::star::container::ContainerEvent& Event ) 183 throw(::com::sun::star::uno::RuntimeException); 184 }; 185 186 187 //============================================================================ 188 // BasMgrContainerListenerImpl 189 //============================================================================ 190 191 void BasMgrContainerListenerImpl::insertLibraryImpl( const Reference< XLibraryContainer >& xScriptCont, 192 BasicManager* pMgr, Any aLibAny, ::rtl::OUString aLibName ) 193 { 194 Reference< XNameAccess > xLibNameAccess; 195 aLibAny >>= xLibNameAccess; 196 197 if( !pMgr->GetLib( aLibName ) ) 198 { 199 BasicManager* pBasMgr = static_cast< BasicManager* >( pMgr ); 200 #ifdef DBG_UTIL 201 StarBASIC* pLib = 202 #endif 203 pBasMgr->CreateLibForLibContainer( aLibName, xScriptCont ); 204 DBG_ASSERT( pLib, "XML Import: Basic library could not be created"); 205 } 206 207 Reference< XContainer> xLibContainer( xLibNameAccess, UNO_QUERY ); 208 if( xLibContainer.is() ) 209 { 210 // Register listener for library 211 Reference< XContainerListener > xLibraryListener 212 = static_cast< XContainerListener* > 213 ( new BasMgrContainerListenerImpl( pMgr, aLibName ) ); 214 xLibContainer->addContainerListener( xLibraryListener ); 215 } 216 217 if( xScriptCont->isLibraryLoaded( aLibName ) ) 218 { 219 addLibraryModulesImpl( pMgr, xLibNameAccess, aLibName ); 220 } 221 } 222 223 224 void BasMgrContainerListenerImpl::addLibraryModulesImpl( BasicManager* pMgr, 225 Reference< XNameAccess > xLibNameAccess, ::rtl::OUString aLibName ) 226 { 227 Sequence< ::rtl::OUString > aModuleNames = xLibNameAccess->getElementNames(); 228 sal_Int32 nModuleCount = aModuleNames.getLength(); 229 230 StarBASIC* pLib = pMgr->GetLib( aLibName ); 231 DBG_ASSERT( pLib, "BasMgrContainerListenerImpl::addLibraryModulesImpl: Unknown lib!"); 232 if( pLib ) 233 { 234 const ::rtl::OUString* pNames = aModuleNames.getConstArray(); 235 for( sal_Int32 j = 0 ; j < nModuleCount ; j++ ) 236 { 237 ::rtl::OUString aModuleName = pNames[ j ]; 238 Any aElement = xLibNameAccess->getByName( aModuleName ); 239 ::rtl::OUString aMod; 240 aElement >>= aMod; 241 Reference< vba::XVBAModuleInfo > xVBAModuleInfo( xLibNameAccess, UNO_QUERY ); 242 if ( xVBAModuleInfo.is() && xVBAModuleInfo->hasModuleInfo( aModuleName ) ) 243 { 244 ModuleInfo mInfo = xVBAModuleInfo->getModuleInfo( aModuleName ); 245 OSL_TRACE("#addLibraryModulesImpl - aMod"); 246 pLib->MakeModule32( aModuleName, mInfo, aMod ); 247 } 248 else 249 pLib->MakeModule32( aModuleName, aMod ); 250 } 251 } 252 253 pLib->SetModified( sal_False ); 254 } 255 256 257 258 // XEventListener 259 //---------------------------------------------------------------------------- 260 261 void SAL_CALL BasMgrContainerListenerImpl::disposing( const EventObject& Source ) 262 throw( RuntimeException ) 263 { 264 (void)Source; 265 } 266 267 // XContainerListener 268 //---------------------------------------------------------------------------- 269 270 void SAL_CALL BasMgrContainerListenerImpl::elementInserted( const ContainerEvent& Event ) 271 throw( RuntimeException ) 272 { 273 sal_Bool bLibContainer = maLibName.isEmpty(); 274 ::rtl::OUString aName; 275 Event.Accessor >>= aName; 276 277 mpMgr->mpImpl->mbModifiedByLibraryContainer = sal_True; 278 279 if( bLibContainer ) 280 { 281 Reference< XLibraryContainer > xScriptCont( Event.Source, UNO_QUERY ); 282 insertLibraryImpl( xScriptCont, mpMgr, Event.Element, aName ); 283 StarBASIC* pLib = mpMgr->GetLib( aName ); 284 if ( pLib ) 285 { 286 Reference< vba::XVBACompatibility > xVBACompat( xScriptCont, UNO_QUERY ); 287 if ( xVBACompat.is() ) 288 pLib->SetVBAEnabled( xVBACompat->getVBACompatibilityMode() ); 289 } 290 } 291 else 292 { 293 294 StarBASIC* pLib = mpMgr->GetLib( maLibName ); 295 DBG_ASSERT( pLib, "BasMgrContainerListenerImpl::elementInserted: Unknown lib!"); 296 if( pLib ) 297 { 298 SbModule* pMod = pLib->FindModule( aName ); 299 if( !pMod ) 300 { 301 ::rtl::OUString aMod; 302 Event.Element >>= aMod; 303 Reference< vba::XVBAModuleInfo > xVBAModuleInfo( Event.Source, UNO_QUERY ); 304 if ( xVBAModuleInfo.is() && xVBAModuleInfo->hasModuleInfo( aName ) ) 305 { 306 ModuleInfo mInfo = xVBAModuleInfo->getModuleInfo( aName ); 307 pLib->MakeModule32( aName, mInfo, aMod ); 308 } 309 else 310 pLib->MakeModule32( aName, aMod ); 311 pLib->SetModified( sal_False ); 312 } 313 } 314 } 315 } 316 317 //---------------------------------------------------------------------------- 318 319 void SAL_CALL BasMgrContainerListenerImpl::elementReplaced( const ContainerEvent& Event ) 320 throw( RuntimeException ) 321 { 322 ::rtl::OUString aName; 323 Event.Accessor >>= aName; 324 325 mpMgr->mpImpl->mbModifiedByLibraryContainer = sal_True; 326 327 // Replace not possible for library container 328 #ifdef DBG_UTIL 329 sal_Bool bLibContainer = maLibName.isEmpty(); 330 #endif 331 DBG_ASSERT( !bLibContainer, "library container fired elementReplaced()"); 332 333 StarBASIC* pLib = mpMgr->GetLib( maLibName ); 334 if( pLib ) 335 { 336 SbModule* pMod = pLib->FindModule( aName ); 337 ::rtl::OUString aMod; 338 Event.Element >>= aMod; 339 340 if( pMod ) 341 pMod->SetSource32( aMod ); 342 else 343 pLib->MakeModule32( aName, aMod ); 344 345 pLib->SetModified( sal_False ); 346 } 347 } 348 349 //---------------------------------------------------------------------------- 350 351 void SAL_CALL BasMgrContainerListenerImpl::elementRemoved( const ContainerEvent& Event ) 352 throw( RuntimeException ) 353 { 354 ::rtl::OUString aName; 355 Event.Accessor >>= aName; 356 357 mpMgr->mpImpl->mbModifiedByLibraryContainer = sal_True; 358 359 sal_Bool bLibContainer = maLibName.isEmpty(); 360 if( bLibContainer ) 361 { 362 StarBASIC* pLib = mpMgr->GetLib( aName ); 363 if( pLib ) 364 { 365 sal_uInt16 nLibId = mpMgr->GetLibId( aName ); 366 mpMgr->RemoveLib( nLibId, sal_False ); 367 } 368 } 369 else 370 { 371 StarBASIC* pLib = mpMgr->GetLib( maLibName ); 372 SbModule* pMod = pLib ? pLib->FindModule( aName ) : NULL; 373 if( pMod ) 374 { 375 pLib->Remove( pMod ); 376 pLib->SetModified( sal_False ); 377 } 378 } 379 } 380 381 382 //===================================================================== 383 384 class BasicErrorManager 385 { 386 private: 387 BasErrorLst aErrorList; 388 389 public: 390 ~BasicErrorManager(); 391 392 void Reset(); 393 void InsertError( const BasicError& rError ); 394 395 sal_Bool HasErrors() { return (sal_Bool)aErrorList.Count(); } 396 BasicError* GetFirstError() { return aErrorList.First(); } 397 BasicError* GetNextError() { return aErrorList.Next(); } 398 }; 399 400 401 BasicErrorManager::~BasicErrorManager() 402 { 403 Reset(); 404 } 405 406 void BasicErrorManager::Reset() 407 { 408 BasicError* pError = (BasicError*)aErrorList.First(); 409 while ( pError ) 410 { 411 delete pError; 412 pError = (BasicError*)aErrorList.Next(); 413 } 414 aErrorList.Clear(); 415 } 416 417 void BasicErrorManager::InsertError( const BasicError& rError ) 418 { 419 aErrorList.Insert( new BasicError( rError ), LIST_APPEND ); 420 } 421 422 423 BasicError::BasicError() 424 { 425 nErrorId = 0; 426 nReason = 0; 427 } 428 429 BasicError::BasicError( sal_uIntPtr nId, sal_uInt16 nR, const String& rErrStr ) : 430 aErrStr( rErrStr ) 431 { 432 nErrorId = nId; 433 nReason = nR; 434 } 435 436 BasicError::BasicError( const BasicError& rErr ) : 437 aErrStr( rErr.aErrStr ) 438 { 439 nErrorId = rErr.nErrorId; 440 nReason = rErr.nReason; 441 } 442 443 444 class BasicLibInfo 445 { 446 private: 447 StarBASICRef xLib; 448 String aLibName; 449 String aStorageName; // String is sufficient, unique at runtime 450 String aRelStorageName; 451 String aPassword; 452 453 sal_Bool bDoLoad; 454 sal_Bool bReference; 455 sal_Bool bPasswordVerified; 456 sal_Bool bFoundInPath; // Must not relativated again! 457 458 // Lib represents library in new UNO library container 459 Reference< XLibraryContainer > mxScriptCont; 460 461 public: 462 BasicLibInfo(); 463 BasicLibInfo( const String& rStorageName ); 464 465 sal_Bool IsReference() const { return bReference; } 466 sal_Bool& IsReference() { return bReference; } 467 468 sal_Bool IsExtern() const { return ! aStorageName.EqualsAscii(szImbedded); } 469 470 void SetStorageName( const String& rName ) { aStorageName = rName; } 471 const String& GetStorageName() const { return aStorageName; } 472 473 void SetRelStorageName( const String& rN ) { aRelStorageName = rN; } 474 const String& GetRelStorageName() const { return aRelStorageName; } 475 void CalcRelStorageName( const String& rMgrStorageName ); 476 477 StarBASICRef GetLib() const 478 { 479 if( mxScriptCont.is() && mxScriptCont->hasByName( aLibName ) && 480 !mxScriptCont->isLibraryLoaded( aLibName ) ) 481 return StarBASICRef(); 482 return xLib; 483 } 484 StarBASICRef& GetLibRef() { return xLib; } 485 void SetLib( StarBASIC* pBasic ) { xLib = pBasic; } 486 487 const String& GetLibName() const { return aLibName; } 488 void SetLibName( const String& rName ) { aLibName = rName; } 489 490 // Only temporary for Load/Save 491 sal_Bool DoLoad() { return bDoLoad; } 492 493 sal_Bool HasPassword() const { return aPassword.Len() != 0; } 494 const String& GetPassword() const { return aPassword; } 495 void SetPassword( const String& rNewPassword ) 496 { aPassword = rNewPassword; } 497 sal_Bool IsPasswordVerified() const { return bPasswordVerified; } 498 void SetPasswordVerified() { bPasswordVerified = sal_True; } 499 500 sal_Bool IsFoundInPath() const { return bFoundInPath; } 501 void SetFoundInPath( sal_Bool bInPath ) { bFoundInPath = bInPath; } 502 503 void Store( SotStorageStream& rSStream, const String& rBasMgrStorageName, sal_Bool bUseOldReloadInfo ); 504 static BasicLibInfo* Create( SotStorageStream& rSStream ); 505 506 Reference< XLibraryContainer > GetLibraryContainer( void ) 507 { return mxScriptCont; } 508 void SetLibraryContainer( const Reference< XLibraryContainer >& xScriptCont ) 509 { mxScriptCont = xScriptCont; } 510 }; 511 512 DECLARE_LIST( BasicLibsBase, BasicLibInfo* ) 513 514 class BasicLibs : public BasicLibsBase 515 { 516 public: 517 String aBasicLibPath; // TODO: Should be member of manager, but currently not incompatible 518 }; 519 520 BasicLibInfo::BasicLibInfo() 521 { 522 bReference = sal_False; 523 bPasswordVerified = sal_False; 524 bDoLoad = sal_False; 525 bFoundInPath = sal_False; 526 mxScriptCont = NULL; 527 aStorageName = String::CreateFromAscii(szImbedded); 528 aRelStorageName = String::CreateFromAscii(szImbedded); 529 } 530 531 BasicLibInfo::BasicLibInfo( const String& rStorageName ) 532 { 533 bReference = sal_True; 534 bPasswordVerified = sal_False; 535 bDoLoad = sal_False; 536 mxScriptCont = NULL; 537 aStorageName = rStorageName; 538 } 539 540 void BasicLibInfo::Store( SotStorageStream& rSStream, const String& rBasMgrStorageName, sal_Bool bUseOldReloadInfo ) 541 { 542 sal_uIntPtr nStartPos = rSStream.Tell(); 543 sal_uInt32 nEndPos = 0; 544 545 sal_uInt16 nId = LIBINFO_ID; 546 sal_uInt16 nVer = CURR_VER; 547 548 rSStream << nEndPos; 549 rSStream << nId; 550 rSStream << nVer; 551 552 String aCurStorageName = INetURLObject(rBasMgrStorageName, INET_PROT_FILE).GetMainURL( INetURLObject::NO_DECODE ); 553 DBG_ASSERT(aCurStorageName.Len() != 0, "Bad storage name"); 554 555 // If not set initialize StorageName 556 if ( aStorageName.Len() == 0 ) 557 aStorageName = aCurStorageName; 558 559 // Load again? 560 sal_Bool bDoLoad_ = xLib.Is(); 561 if ( bUseOldReloadInfo ) 562 bDoLoad_ = DoLoad(); 563 rSStream << bDoLoad_; 564 565 // The name of the lib... 566 rSStream.WriteByteString(GetLibName()); 567 568 // Absolute path... 569 if ( ! GetStorageName().EqualsAscii(szImbedded) ) 570 { 571 String aSName = INetURLObject( GetStorageName(), INET_PROT_FILE).GetMainURL( INetURLObject::NO_DECODE ); 572 DBG_ASSERT(aSName.Len() != 0, "Bad storage name"); 573 rSStream.WriteByteString( aSName ); 574 } 575 else 576 rSStream.WriteByteString( szImbedded ); 577 578 // Relative path... 579 if ( ( aStorageName == aCurStorageName ) || ( aStorageName.EqualsAscii(szImbedded) ) ) 580 rSStream.WriteByteString( szImbedded ); 581 else 582 { 583 // Do not determine the relative path if the file was only found in path: 584 // because the relative path would change and after moving the lib the 585 // the file cannot be found. 586 if ( !IsFoundInPath() ) 587 CalcRelStorageName( aCurStorageName ); 588 rSStream.WriteByteString(aRelStorageName); 589 } 590 591 // ------------------------------ 592 // Version 2 593 // ------------------------------ 594 595 // reference... 596 rSStream << bReference; 597 598 // ------------------------------ 599 // End 600 // ------------------------------ 601 602 nEndPos = rSStream.Tell(); 603 rSStream.Seek( nStartPos ); 604 rSStream << nEndPos; 605 rSStream.Seek( nEndPos ); 606 } 607 608 BasicLibInfo* BasicLibInfo::Create( SotStorageStream& rSStream ) 609 { 610 BasicLibInfo* pInfo = new BasicLibInfo; 611 612 sal_uInt32 nEndPos; 613 sal_uInt16 nId; 614 sal_uInt16 nVer; 615 616 rSStream >> nEndPos; 617 rSStream >> nId; 618 rSStream >> nVer; 619 620 DBG_ASSERT( nId == LIBINFO_ID, "Keine BasicLibInfo !?" ); 621 if( nId == LIBINFO_ID ) 622 { 623 // Reload? 624 sal_Bool bDoLoad; 625 rSStream >> bDoLoad; 626 pInfo->bDoLoad = bDoLoad; 627 628 // The name of the lib... 629 String aName; 630 rSStream.ReadByteString(aName); 631 pInfo->SetLibName( aName ); 632 633 // Absolute path... 634 String aStorageName; 635 rSStream.ReadByteString(aStorageName); 636 pInfo->SetStorageName( aStorageName ); 637 638 // Relative path... 639 String aRelStorageName; 640 rSStream.ReadByteString(aRelStorageName); 641 pInfo->SetRelStorageName( aRelStorageName ); 642 643 if ( nVer >= 2 ) 644 { 645 sal_Bool bReferenz; 646 rSStream >> bReferenz; 647 pInfo->IsReference() = bReferenz; 648 } 649 650 rSStream.Seek( nEndPos ); 651 } 652 return pInfo; 653 } 654 655 void BasicLibInfo::CalcRelStorageName( const String& rMgrStorageName ) 656 { 657 if ( rMgrStorageName.Len() ) 658 { 659 INetURLObject aAbsURLObj( rMgrStorageName ); 660 aAbsURLObj.removeSegment(); 661 String aPath = aAbsURLObj.GetMainURL( INetURLObject::NO_DECODE ); 662 UniString aRelURL = INetURLObject::GetRelURL( aPath, GetStorageName() ); 663 SetRelStorageName( aRelURL ); 664 } 665 else 666 SetRelStorageName( String() ); 667 } 668 BasicManager::BasicManager( SotStorage& rStorage, const String& rBaseURL, StarBASIC* pParentFromStdLib, String* pLibPath, sal_Bool bDocMgr ) : mbDocMgr( bDocMgr ) 669 { 670 DBG_CTOR( BasicManager, 0 ); 671 672 Init(); 673 674 if( pLibPath ) 675 pLibs->aBasicLibPath = *pLibPath; 676 677 String aStorName( rStorage.GetName() ); 678 maStorageName = INetURLObject(aStorName, INET_PROT_FILE).GetMainURL( INetURLObject::NO_DECODE ); 679 680 // #91251: Storage name not longer available for documents < 5.0 681 // Should be no real problem, because only relative storage names 682 // (links) can be affected. 683 // DBG_ASSERT( aStorName.Len(), "No Storage Name!" ); 684 // DBG_ASSERT(aStorageName.Len() != 0, "Bad storage name"); 685 686 // If there is no Manager Stream, no further actions are necessary 687 if ( rStorage.IsStream( String(RTL_CONSTASCII_USTRINGPARAM(szManagerStream)) ) ) 688 { 689 LoadBasicManager( rStorage, rBaseURL ); 690 // StdLib contains Parent: 691 StarBASIC* pStdLib = GetStdLib(); 692 DBG_ASSERT( pStdLib, "Standard-Lib not loaded?" ); 693 if ( !pStdLib ) 694 { 695 // Should never happen, but if it happens we won't crash... 696 pStdLib = new StarBASIC( NULL, mbDocMgr ); 697 BasicLibInfo* pStdLibInfo = pLibs->GetObject( 0 ); 698 if ( !pStdLibInfo ) 699 pStdLibInfo = CreateLibInfo(); 700 pStdLibInfo->SetLib( pStdLib ); 701 StarBASICRef xStdLib = pStdLibInfo->GetLib(); 702 xStdLib->SetName( String::CreateFromAscii(szStdLibName) ); 703 pStdLibInfo->SetLibName( String::CreateFromAscii(szStdLibName) ); 704 xStdLib->SetFlag( SBX_DONTSTORE | SBX_EXTSEARCH ); 705 xStdLib->SetModified( sal_False ); 706 } 707 else 708 { 709 pStdLib->SetParent( pParentFromStdLib ); 710 // The other get StdLib as parent: 711 for ( sal_uInt16 nBasic = 1; nBasic < GetLibCount(); nBasic++ ) 712 { 713 StarBASIC* pBasic = GetLib( nBasic ); 714 if ( pBasic ) 715 { 716 // pBasic->SetParent( pStdLib ); 717 pStdLib->Insert( pBasic ); 718 pBasic->SetFlag( SBX_EXTSEARCH ); 719 } 720 } 721 // Modified through insert 722 pStdLib->SetModified( sal_False ); 723 } 724 725 // #91626 Save all stream data to save it unmodified if basic isn't modified 726 // in an 6.0+ office. So also the old basic dialogs can be saved. 727 SotStorageStreamRef xManagerStream = rStorage.OpenSotStream 728 ( String(RTL_CONSTASCII_USTRINGPARAM(szManagerStream)), eStreamReadMode ); 729 mpImpl->mpManagerStream = new SvMemoryStream(); 730 *static_cast<SvStream*>(&xManagerStream) >> *mpImpl->mpManagerStream; 731 732 SotStorageRef xBasicStorage = rStorage.OpenSotStorage 733 ( String(RTL_CONSTASCII_USTRINGPARAM(szBasicStorage)), eStorageReadMode, sal_False ); 734 if( xBasicStorage.Is() && !xBasicStorage->GetError() ) 735 { 736 sal_uInt16 nLibs = GetLibCount(); 737 mpImpl->mppLibStreams = new SvMemoryStream*[ nLibs ]; 738 for( sal_uInt16 nL = 0; nL < nLibs; nL++ ) 739 { 740 BasicLibInfo* pInfo = pLibs->GetObject( nL ); 741 DBG_ASSERT( pInfo, "pInfo?!" ); 742 SotStorageStreamRef xBasicStream = xBasicStorage->OpenSotStream( pInfo->GetLibName(), eStreamReadMode ); 743 mpImpl->mppLibStreams[nL] = new SvMemoryStream(); 744 *static_cast<SvStream*>(&xBasicStream) >> *( mpImpl->mppLibStreams[nL] ); 745 } 746 } 747 else 748 mpImpl->mbError = sal_True; 749 } 750 else 751 { 752 ImpCreateStdLib( pParentFromStdLib ); 753 if ( rStorage.IsStream( String::CreateFromAscii(szOldManagerStream) ) ) 754 LoadOldBasicManager( rStorage ); 755 } 756 757 bBasMgrModified = sal_False; 758 } 759 760 void copyToLibraryContainer( StarBASIC* pBasic, const LibraryContainerInfo& rInfo ) 761 { 762 Reference< XLibraryContainer > xScriptCont( rInfo.mxScriptCont.get() ); 763 if ( !xScriptCont.is() ) 764 return; 765 766 String aLibName = pBasic->GetName(); 767 if( !xScriptCont->hasByName( aLibName ) ) 768 xScriptCont->createLibrary( aLibName ); 769 770 Any aLibAny = xScriptCont->getByName( aLibName ); 771 Reference< XNameContainer > xLib; 772 aLibAny >>= xLib; 773 if ( !xLib.is() ) 774 return; 775 776 sal_uInt16 nModCount = pBasic->GetModules()->Count(); 777 for ( sal_uInt16 nMod = 0 ; nMod < nModCount ; nMod++ ) 778 { 779 SbModule* pModule = (SbModule*)pBasic->GetModules()->Get( nMod ); 780 DBG_ASSERT( pModule, "Modul nicht erhalten!" ); 781 782 String aModName = pModule->GetName(); 783 if( !xLib->hasByName( aModName ) ) 784 { 785 ::rtl::OUString aSource = pModule->GetSource32(); 786 Any aSourceAny; 787 aSourceAny <<= aSource; 788 xLib->insertByName( aModName, aSourceAny ); 789 } 790 } 791 } 792 793 const Reference< XPersistentLibraryContainer >& BasicManager::GetDialogLibraryContainer() const 794 { 795 return mpImpl->maContainerInfo.mxDialogCont; 796 } 797 798 const Reference< XPersistentLibraryContainer >& BasicManager::GetScriptLibraryContainer() const 799 { 800 return mpImpl->maContainerInfo.mxScriptCont; 801 } 802 803 void BasicManager::SetLibraryContainerInfo( const LibraryContainerInfo& rInfo ) 804 { 805 mpImpl->maContainerInfo = rInfo; 806 807 Reference< XLibraryContainer > xScriptCont( mpImpl->maContainerInfo.mxScriptCont.get() ); 808 StarBASIC* pStdLib = GetStdLib(); 809 String aLibName = pStdLib->GetName(); 810 if( xScriptCont.is() ) 811 { 812 // Register listener for lib container 813 ::rtl::OUString aEmptyLibName; 814 Reference< XContainerListener > xLibContainerListener 815 = static_cast< XContainerListener* > 816 ( new BasMgrContainerListenerImpl( this, aEmptyLibName ) ); 817 818 Reference< XContainer> xLibContainer( xScriptCont, UNO_QUERY ); 819 xLibContainer->addContainerListener( xLibContainerListener ); 820 821 Sequence< ::rtl::OUString > aScriptLibNames = xScriptCont->getElementNames(); 822 const ::rtl::OUString* pScriptLibName = aScriptLibNames.getConstArray(); 823 sal_Int32 i, nNameCount = aScriptLibNames.getLength(); 824 825 if( nNameCount ) 826 { 827 for( i = 0 ; i < nNameCount ; ++i, ++pScriptLibName ) 828 { 829 Any aLibAny = xScriptCont->getByName( *pScriptLibName ); 830 831 if ( pScriptLibName->equalsAscii( "Standard" ) ) 832 xScriptCont->loadLibrary( *pScriptLibName ); 833 834 BasMgrContainerListenerImpl::insertLibraryImpl 835 ( xScriptCont, this, aLibAny, *pScriptLibName ); 836 } 837 } 838 else 839 { 840 // No libs? Maybe an 5.2 document already loaded 841 sal_uInt16 nLibs = GetLibCount(); 842 for( sal_uInt16 nL = 0; nL < nLibs; nL++ ) 843 { 844 BasicLibInfo* pBasLibInfo = pLibs->GetObject( nL ); 845 StarBASIC* pLib = pBasLibInfo->GetLib(); 846 if( !pLib ) 847 { 848 sal_Bool bLoaded = ImpLoadLibary( pBasLibInfo, NULL, sal_False ); 849 if( bLoaded ) 850 pLib = pBasLibInfo->GetLib(); 851 } 852 if( pLib ) 853 { 854 copyToLibraryContainer( pLib, mpImpl->maContainerInfo ); 855 if( pBasLibInfo->HasPassword() ) 856 { 857 OldBasicPassword* pOldBasicPassword = 858 mpImpl->maContainerInfo.mpOldBasicPassword; 859 if( pOldBasicPassword ) 860 { 861 pOldBasicPassword->setLibraryPassword 862 ( pLib->GetName(), pBasLibInfo->GetPassword() ); 863 pBasLibInfo->SetPasswordVerified(); 864 } 865 } 866 } 867 } 868 869 mpImpl->mbModifiedByLibraryContainer = sal_False; 870 } 871 } 872 873 SetGlobalUNOConstant( "BasicLibraries", makeAny( mpImpl->maContainerInfo.mxScriptCont ) ); 874 SetGlobalUNOConstant( "DialogLibraries", makeAny( mpImpl->maContainerInfo.mxDialogCont ) ); 875 } 876 877 BasicManager::BasicManager( StarBASIC* pSLib, String* pLibPath, sal_Bool bDocMgr ) : mbDocMgr( bDocMgr ) 878 { 879 DBG_CTOR( BasicManager, 0 ); 880 Init(); 881 DBG_ASSERT( pSLib, "BasicManager cannot be created with a NULL-Pointer!" ); 882 883 if( pLibPath ) 884 pLibs->aBasicLibPath = *pLibPath; 885 886 BasicLibInfo* pStdLibInfo = CreateLibInfo(); 887 pStdLibInfo->SetLib( pSLib ); 888 StarBASICRef xStdLib = pStdLibInfo->GetLib(); 889 xStdLib->SetName( String::CreateFromAscii(szStdLibName)); 890 pStdLibInfo->SetLibName( String::CreateFromAscii(szStdLibName) ); 891 pSLib->SetFlag( SBX_DONTSTORE | SBX_EXTSEARCH ); 892 893 // Save is only necessary if basic has changed 894 xStdLib->SetModified( sal_False ); 895 bBasMgrModified = sal_False; 896 } 897 898 BasicManager::BasicManager() 899 { 900 DBG_CTOR( BasicManager, 0 ); 901 // This ctor may only be used to adapt relative paths for 'Save As'. 902 // There is no AppBasic so libs must not be loaded... 903 Init(); 904 } 905 906 void BasicManager::ImpMgrNotLoaded( const String& rStorageName ) 907 { 908 // pErrInf is only destroyed if the error os processed by an 909 // ErrorHandler 910 StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_MGROPEN, rStorageName, ERRCODE_BUTTON_OK ); 911 pErrorMgr->InsertError( BasicError( *pErrInf, BASERR_REASON_OPENMGRSTREAM, rStorageName ) ); 912 913 // Create a stdlib otherwise we crash! 914 BasicLibInfo* pStdLibInfo = CreateLibInfo(); 915 pStdLibInfo->SetLib( new StarBASIC( NULL, mbDocMgr ) ); 916 StarBASICRef xStdLib = pStdLibInfo->GetLib(); 917 xStdLib->SetName( String::CreateFromAscii(szStdLibName) ); 918 pStdLibInfo->SetLibName( String::CreateFromAscii(szStdLibName) ); 919 xStdLib->SetFlag( SBX_DONTSTORE | SBX_EXTSEARCH ); 920 xStdLib->SetModified( sal_False ); 921 } 922 923 924 void BasicManager::ImpCreateStdLib( StarBASIC* pParentFromStdLib ) 925 { 926 BasicLibInfo* pStdLibInfo = CreateLibInfo(); 927 StarBASIC* pStdLib = new StarBASIC( pParentFromStdLib, mbDocMgr ); 928 pStdLibInfo->SetLib( pStdLib ); 929 pStdLib->SetName( String::CreateFromAscii(szStdLibName) ); 930 pStdLibInfo->SetLibName( String::CreateFromAscii(szStdLibName) ); 931 pStdLib->SetFlag( SBX_DONTSTORE | SBX_EXTSEARCH ); 932 } 933 934 935 void BasicManager::LoadBasicManager( SotStorage& rStorage, const String& rBaseURL, sal_Bool bLoadLibs ) 936 { 937 DBG_CHKTHIS( BasicManager, 0 ); 938 939 // StreamMode eStreamMode = STREAM_READ | STREAM_NOCREATE | STREAM_SHARE_DENYWRITE; 940 941 SotStorageStreamRef xManagerStream = rStorage.OpenSotStream 942 ( String(RTL_CONSTASCII_USTRINGPARAM(szManagerStream)), eStreamReadMode ); 943 944 String aStorName( rStorage.GetName() ); 945 // #i13114 removed, DBG_ASSERT( aStorName.Len(), "No Storage Name!" ); 946 947 if ( !xManagerStream.Is() || xManagerStream->GetError() || ( xManagerStream->Seek( STREAM_SEEK_TO_END ) == 0 ) ) 948 { 949 ImpMgrNotLoaded( aStorName ); 950 return; 951 } 952 953 maStorageName = INetURLObject(aStorName, INET_PROT_FILE).GetMainURL( INetURLObject::NO_DECODE ); 954 // #i13114 removed, DBG_ASSERT(aStorageName.Len() != 0, "Bad storage name"); 955 956 String aRealStorageName = maStorageName; // for relative paths, can be modified through BaseURL 957 958 // If loaded from template, only BaseURL is used: 959 //String aBaseURL = INetURLObject::GetBaseURL(); 960 if ( rBaseURL.Len() ) 961 { 962 INetURLObject aObj( rBaseURL ); 963 if ( aObj.GetProtocol() == INET_PROT_FILE ) 964 aRealStorageName = aObj.PathToFileName(); 965 } 966 967 xManagerStream->SetBufferSize( 1024 ); 968 xManagerStream->Seek( STREAM_SEEK_TO_BEGIN ); 969 970 sal_uInt32 nEndPos; 971 *xManagerStream >> nEndPos; 972 973 sal_uInt16 nLibs; 974 *xManagerStream >> nLibs; 975 // Plausi! 976 if( nLibs & 0xF000 ) 977 { 978 DBG_ASSERT( !this, "BasicManager-Stream defect!" ); 979 return; 980 } 981 for ( sal_uInt16 nL = 0; nL < nLibs; nL++ ) 982 { 983 BasicLibInfo* pInfo = BasicLibInfo::Create( *xManagerStream ); 984 985 // Correct absolute pathname if relative is existing. 986 // Always try relative first if there are two stands on disk 987 if ( pInfo->GetRelStorageName().Len() && ( ! pInfo->GetRelStorageName().EqualsAscii(szImbedded) ) ) 988 { 989 INetURLObject aObj( aRealStorageName, INET_PROT_FILE ); 990 aObj.removeSegment(); 991 bool bWasAbsolute = sal_False; 992 aObj = aObj.smartRel2Abs( pInfo->GetRelStorageName(), bWasAbsolute ); 993 994 //*** TODO: Replace if still necessary 995 /* if ( SfxContentHelper::Exists( aObj.GetMainURL() ) ) 996 pInfo->SetStorageName( aObj.GetMainURL() ); 997 else */ 998 //*** TODO-End 999 if ( pLibs->aBasicLibPath.Len() ) 1000 { 1001 // Search lib in path 1002 String aSearchFile = pInfo->GetRelStorageName(); 1003 SvtPathOptions aPathCFG; 1004 if( aPathCFG.SearchFile( aSearchFile, SvtPathOptions::PATH_BASIC ) ) 1005 { 1006 pInfo->SetStorageName( aSearchFile ); 1007 pInfo->SetFoundInPath( sal_True ); 1008 } 1009 } 1010 } 1011 1012 pLibs->Insert( pInfo, LIST_APPEND ); 1013 // Libs from external files should be loaded only when necessary. 1014 // But references are loaded at once, otherwise some big customers get into trouble 1015 if ( bLoadLibs && pInfo->DoLoad() && 1016 ( ( !pInfo->IsExtern() ) || ( pInfo->IsReference() ) ) ) 1017 { 1018 ImpLoadLibary( pInfo, &rStorage ); 1019 } 1020 } 1021 1022 xManagerStream->Seek( nEndPos ); 1023 xManagerStream->SetBufferSize( 0 ); 1024 xManagerStream.Clear(); 1025 } 1026 1027 void BasicManager::LoadOldBasicManager( SotStorage& rStorage ) 1028 { 1029 DBG_CHKTHIS( BasicManager, 0 ); 1030 1031 // StreamMode eStreamMode = STREAM_READ | STREAM_NOCREATE | STREAM_SHARE_DENYWRITE; 1032 1033 SotStorageStreamRef xManagerStream = rStorage.OpenSotStream 1034 ( String::CreateFromAscii(szOldManagerStream), eStreamReadMode ); 1035 1036 String aStorName( rStorage.GetName() ); 1037 DBG_ASSERT( aStorName.Len(), "No Storage Name!" ); 1038 1039 if ( !xManagerStream.Is() || xManagerStream->GetError() || ( xManagerStream->Seek( STREAM_SEEK_TO_END ) == 0 ) ) 1040 { 1041 ImpMgrNotLoaded( aStorName ); 1042 return; 1043 } 1044 1045 xManagerStream->SetBufferSize( 1024 ); 1046 xManagerStream->Seek( STREAM_SEEK_TO_BEGIN ); 1047 sal_uInt32 nBasicStartOff, nBasicEndOff; 1048 *xManagerStream >> nBasicStartOff; 1049 *xManagerStream >> nBasicEndOff; 1050 1051 DBG_ASSERT( !xManagerStream->GetError(), "Ungueltiger Manager-Stream!" ); 1052 1053 xManagerStream->Seek( nBasicStartOff ); 1054 if( !ImplLoadBasic( *xManagerStream, pLibs->GetObject(0)->GetLibRef() ) ) 1055 { 1056 // String aErrorText( BasicResId( IDS_SBERR_MGROPEN ) ); 1057 // aErrorText.SearchAndReplace( "XX", aStorName ); 1058 StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_MGROPEN, aStorName, ERRCODE_BUTTON_OK ); 1059 pErrorMgr->InsertError( BasicError( *pErrInf, BASERR_REASON_OPENMGRSTREAM, aStorName ) ); 1060 // und es geht weiter... 1061 } 1062 xManagerStream->Seek( nBasicEndOff+1 ); // +1: 0x00 as separator 1063 String aLibs; 1064 xManagerStream->ReadByteString(aLibs); 1065 xManagerStream->SetBufferSize( 0 ); 1066 xManagerStream.Clear(); // Close stream 1067 1068 if ( aLibs.Len() ) 1069 { 1070 String aCurStorageName( aStorName ); 1071 INetURLObject aCurStorage( aCurStorageName, INET_PROT_FILE ); 1072 sal_uInt16 nLibs = aLibs.GetTokenCount( LIB_SEP ); 1073 for ( sal_uInt16 nLib = 0; nLib < nLibs; nLib++ ) 1074 { 1075 String aLibInfo( aLibs.GetToken( nLib, LIB_SEP ) ); 1076 // TODO: Remove == 2 1077 DBG_ASSERT( ( aLibInfo.GetTokenCount( LIBINFO_SEP ) == 2 ) || ( aLibInfo.GetTokenCount( LIBINFO_SEP ) == 3 ), "Ungueltige Lib-Info!" ); 1078 String aLibName( aLibInfo.GetToken( 0, LIBINFO_SEP ) ); 1079 String aLibAbsStorageName( aLibInfo.GetToken( 1, LIBINFO_SEP ) ); 1080 String aLibRelStorageName( aLibInfo.GetToken( 2, LIBINFO_SEP ) ); 1081 INetURLObject aLibAbsStorage( aLibAbsStorageName, INET_PROT_FILE ); 1082 1083 INetURLObject aLibRelStorage( aStorName ); 1084 aLibRelStorage.removeSegment(); 1085 bool bWasAbsolute = sal_False; 1086 aLibRelStorage = aLibRelStorage.smartRel2Abs( aLibRelStorageName, bWasAbsolute); 1087 DBG_ASSERT(!bWasAbsolute, "RelStorageName was absolute!" ); 1088 1089 SotStorageRef xStorageRef; 1090 if ( ( aLibAbsStorage == aCurStorage ) || ( aLibRelStorageName.EqualsAscii(szImbedded) ) ) 1091 xStorageRef = &rStorage; 1092 else 1093 { 1094 xStorageRef = new SotStorage( sal_False, aLibAbsStorage.GetMainURL 1095 ( INetURLObject::NO_DECODE ), eStorageReadMode, sal_True ); 1096 if ( xStorageRef->GetError() != ERRCODE_NONE ) 1097 xStorageRef = new SotStorage( sal_False, aLibRelStorage. 1098 GetMainURL( INetURLObject::NO_DECODE ), eStorageReadMode, sal_True ); 1099 } 1100 if ( xStorageRef.Is() ) 1101 AddLib( *xStorageRef, aLibName, sal_False ); 1102 else 1103 { 1104 // String aErrorText( BasicResId( IDS_SBERR_LIBLOAD ) ); 1105 // aErrorText.SearchAndReplace( "XX", aLibName ); 1106 StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_LIBLOAD, aStorName, ERRCODE_BUTTON_OK ); 1107 pErrorMgr->InsertError( BasicError( *pErrInf, BASERR_REASON_STORAGENOTFOUND, aStorName ) ); 1108 } 1109 } 1110 } 1111 } 1112 1113 BasicManager::~BasicManager() 1114 { 1115 DBG_DTOR( BasicManager, 0 ); 1116 1117 // Notify listener if something needs to be saved 1118 Broadcast( SfxSimpleHint( SFX_HINT_DYING) ); 1119 1120 // Destroy Basic-Infos... 1121 // In reverse order 1122 BasicLibInfo* pInf = pLibs->Last(); 1123 while ( pInf ) 1124 { 1125 delete pInf; 1126 pInf = pLibs->Prev(); 1127 } 1128 pLibs->Clear(); 1129 delete pLibs; 1130 delete pErrorMgr; 1131 delete mpImpl; 1132 } 1133 1134 void BasicManager::LegacyDeleteBasicManager( BasicManager*& _rpManager ) 1135 { 1136 delete _rpManager; 1137 _rpManager = NULL; 1138 } 1139 1140 void BasicManager::Init() 1141 { 1142 DBG_CHKTHIS( BasicManager, 0 ); 1143 1144 bBasMgrModified = sal_False; 1145 pErrorMgr = new BasicErrorManager; 1146 pLibs = new BasicLibs; 1147 mpImpl = new BasicManagerImpl(); 1148 } 1149 1150 BasicLibInfo* BasicManager::CreateLibInfo() 1151 { 1152 DBG_CHKTHIS( BasicManager, 0 ); 1153 1154 BasicLibInfo* pInf = new BasicLibInfo; 1155 pLibs->Insert( pInf, LIST_APPEND ); 1156 return pInf; 1157 } 1158 1159 sal_Bool BasicManager::ImpLoadLibary( BasicLibInfo* pLibInfo, SotStorage* pCurStorage, sal_Bool bInfosOnly ) const 1160 { 1161 DBG_CHKTHIS( BasicManager, 0 ); 1162 1163 DBG_ASSERT( pLibInfo, "LibInfo!?" ); 1164 1165 String aStorageName( pLibInfo->GetStorageName() ); 1166 if ( !aStorageName.Len() || ( aStorageName.EqualsAscii(szImbedded) ) ) 1167 aStorageName = GetStorageName(); 1168 1169 SotStorageRef xStorage; 1170 // The current must not be opened again... 1171 if ( pCurStorage ) 1172 { 1173 String aStorName( pCurStorage->GetName() ); 1174 // #i13114 removed, DBG_ASSERT( aStorName.Len(), "No Storage Name!" ); 1175 1176 INetURLObject aCurStorageEntry(aStorName, INET_PROT_FILE); 1177 // #i13114 removed, DBG_ASSERT(aCurStorageEntry.GetMainURL( INetURLObject::NO_DECODE ).Len() != 0, "Bad storage name"); 1178 1179 INetURLObject aStorageEntry(aStorageName, INET_PROT_FILE); 1180 // #i13114 removed, DBG_ASSERT(aCurStorageEntry.GetMainURL( INetURLObject::NO_DECODE ).Len() != 0, "Bad storage name"); 1181 1182 if ( aCurStorageEntry == aStorageEntry ) 1183 xStorage = pCurStorage; 1184 } 1185 1186 if ( !xStorage.Is() ) 1187 xStorage = new SotStorage( sal_False, aStorageName, eStorageReadMode ); 1188 1189 SotStorageRef xBasicStorage = xStorage->OpenSotStorage 1190 ( String(RTL_CONSTASCII_USTRINGPARAM(szBasicStorage)), eStorageReadMode, sal_False ); 1191 1192 if ( !xBasicStorage.Is() || xBasicStorage->GetError() ) 1193 { 1194 StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_MGROPEN, xStorage->GetName(), ERRCODE_BUTTON_OK ); 1195 pErrorMgr->InsertError( BasicError( *pErrInf, BASERR_REASON_OPENLIBSTORAGE, pLibInfo->GetLibName() ) ); 1196 } 1197 else 1198 { 1199 // In the Basic-Storage every lib is in a Stream... 1200 SotStorageStreamRef xBasicStream = xBasicStorage->OpenSotStream( pLibInfo->GetLibName(), eStreamReadMode ); 1201 if ( !xBasicStream.Is() || xBasicStream->GetError() ) 1202 { 1203 StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_LIBLOAD , pLibInfo->GetLibName(), ERRCODE_BUTTON_OK ); 1204 pErrorMgr->InsertError( BasicError( *pErrInf, BASERR_REASON_OPENLIBSTREAM, pLibInfo->GetLibName() ) ); 1205 } 1206 else 1207 { 1208 sal_Bool bLoaded = sal_False; 1209 if ( xBasicStream->Seek( STREAM_SEEK_TO_END ) != 0 ) 1210 { 1211 if ( !bInfosOnly ) 1212 { 1213 if ( !pLibInfo->GetLib().Is() ) 1214 pLibInfo->SetLib( new StarBASIC( GetStdLib(), mbDocMgr ) ); 1215 xBasicStream->SetBufferSize( 1024 ); 1216 xBasicStream->Seek( STREAM_SEEK_TO_BEGIN ); 1217 bLoaded = ImplLoadBasic( *xBasicStream, pLibInfo->GetLibRef() ); 1218 xBasicStream->SetBufferSize( 0 ); 1219 StarBASICRef xStdLib = pLibInfo->GetLib(); 1220 xStdLib->SetName( pLibInfo->GetLibName() ); 1221 xStdLib->SetModified( sal_False ); 1222 xStdLib->SetFlag( SBX_DONTSTORE ); 1223 } 1224 else 1225 { 1226 // Skip Basic... 1227 xBasicStream->Seek( STREAM_SEEK_TO_BEGIN ); 1228 ImplEncryptStream( *xBasicStream ); 1229 SbxBase::Skip( *xBasicStream ); 1230 bLoaded = sal_True; 1231 } 1232 } 1233 if ( !bLoaded ) 1234 { 1235 StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_LIBLOAD, pLibInfo->GetLibName(), ERRCODE_BUTTON_OK ); 1236 pErrorMgr->InsertError( BasicError( *pErrInf, BASERR_REASON_BASICLOADERROR, pLibInfo->GetLibName() ) ); 1237 } 1238 else 1239 { 1240 // Perhaps there are additional information in the stream... 1241 xBasicStream->SetKey( szCryptingKey ); 1242 xBasicStream->RefreshBuffer(); 1243 sal_uInt32 nPasswordMarker = 0; 1244 *xBasicStream >> nPasswordMarker; 1245 if ( ( nPasswordMarker == PASSWORD_MARKER ) && !xBasicStream->IsEof() ) 1246 { 1247 String aPassword; 1248 xBasicStream->ReadByteString(aPassword); 1249 pLibInfo->SetPassword( aPassword ); 1250 } 1251 xBasicStream->SetKey( ByteString() ); 1252 CheckModules( pLibInfo->GetLib(), pLibInfo->IsReference() ); 1253 } 1254 return bLoaded; 1255 } 1256 } 1257 return sal_False; 1258 } 1259 1260 sal_Bool BasicManager::ImplEncryptStream( SvStream& rStrm ) const 1261 { 1262 sal_uIntPtr nPos = rStrm.Tell(); 1263 sal_uInt32 nCreator; 1264 rStrm >> nCreator; 1265 rStrm.Seek( nPos ); 1266 sal_Bool bProtected = sal_False; 1267 if ( nCreator != SBXCR_SBX ) 1268 { 1269 // Should only be the case for encrypted Streams 1270 bProtected = sal_True; 1271 rStrm.SetKey( szCryptingKey ); 1272 rStrm.RefreshBuffer(); 1273 } 1274 return bProtected; 1275 } 1276 1277 // This code is necessary to load the BASIC of Beta 1 1278 // TODO: Which Beta 1? 1279 sal_Bool BasicManager::ImplLoadBasic( SvStream& rStrm, StarBASICRef& rOldBasic ) const 1280 { 1281 sal_Bool bProtected = ImplEncryptStream( rStrm ); 1282 SbxBaseRef xNew = SbxBase::Load( rStrm ); 1283 sal_Bool bLoaded = sal_False; 1284 if( xNew.Is() ) 1285 { 1286 if( xNew->IsA( TYPE(StarBASIC) ) ) 1287 { 1288 StarBASIC* pNew = (StarBASIC*)(SbxBase*) xNew; 1289 // Use the Parent of the old BASICs 1290 if( rOldBasic.Is() ) 1291 { 1292 pNew->SetParent( rOldBasic->GetParent() ); 1293 if( pNew->GetParent() ) 1294 pNew->GetParent()->Insert( pNew ); 1295 pNew->SetFlag( SBX_EXTSEARCH ); 1296 } 1297 rOldBasic = pNew; 1298 1299 // Fill new libray container (5.2 -> 6.0) 1300 copyToLibraryContainer( pNew, mpImpl->maContainerInfo ); 1301 1302 /* 1303 if( rOldBasic->GetParent() ) 1304 { 1305 rOldBasic->GetParent()->Insert( rOldBasic ); 1306 rOldBasic->SetFlag( SBX_EXTSEARCH ); 1307 } 1308 */ 1309 pNew->SetModified( sal_False ); 1310 bLoaded = sal_True; 1311 } 1312 } 1313 if ( bProtected ) 1314 rStrm.SetKey( ByteString() ); 1315 return bLoaded; 1316 } 1317 1318 void BasicManager::CheckModules( StarBASIC* pLib, sal_Bool bReference ) const 1319 { 1320 if ( !pLib ) 1321 return; 1322 1323 sal_Bool bModified = pLib->IsModified(); 1324 1325 for ( sal_uInt16 nMod = 0; nMod < pLib->GetModules()->Count(); nMod++ ) 1326 { 1327 SbModule* pModule = (SbModule*)pLib->GetModules()->Get( nMod ); 1328 DBG_ASSERT( pModule, "Modul nicht erhalten!" ); 1329 if ( !pModule->IsCompiled() && !StarBASIC::GetErrorCode() ) 1330 pLib->Compile( pModule ); 1331 } 1332 1333 // #67477, AB 8.12.99 On demand compile in referenced libs should not 1334 // cause modified 1335 if( !bModified && bReference ) 1336 { 1337 DBG_ERROR( "Per Reference eingebundene Basic-Library ist nicht compiliert!" ); 1338 pLib->SetModified( sal_False ); 1339 } 1340 } 1341 1342 StarBASIC* BasicManager::AddLib( SotStorage& rStorage, const String& rLibName, sal_Bool bReference ) 1343 { 1344 DBG_CHKTHIS( BasicManager, 0 ); 1345 1346 String aStorName( rStorage.GetName() ); 1347 DBG_ASSERT( aStorName.Len(), "No Storage Name!" ); 1348 1349 String aStorageName = INetURLObject(aStorName, INET_PROT_FILE).GetMainURL( INetURLObject::NO_DECODE ); 1350 DBG_ASSERT(aStorageName.Len() != 0, "Bad storage name"); 1351 1352 String aNewLibName( rLibName ); 1353 while ( HasLib( aNewLibName ) ) 1354 aNewLibName += '_'; 1355 1356 BasicLibInfo* pLibInfo = CreateLibInfo(); 1357 // Use original name otherwise ImpLoadLibary failes... 1358 pLibInfo->SetLibName( rLibName ); 1359 // Funktioniert so aber nicht, wenn Name doppelt 1360 // sal_uInt16 nLibId = GetLibId( rLibName ); 1361 sal_uInt16 nLibId = (sal_uInt16) pLibs->GetPos( pLibInfo ); 1362 1363 // Set StorageName before load because it is compared with pCurStorage 1364 pLibInfo->SetStorageName( aStorageName ); 1365 sal_Bool bLoaded = ImpLoadLibary( pLibInfo, &rStorage ); 1366 1367 if ( bLoaded ) 1368 { 1369 if ( aNewLibName != rLibName ) 1370 SetLibName( nLibId, aNewLibName ); 1371 1372 if ( bReference ) 1373 { 1374 pLibInfo->GetLib()->SetModified( sal_False ); // Don't save in this case 1375 pLibInfo->SetRelStorageName( String() ); 1376 // pLibInfo->CalcRelStorageName( GetStorageName() ); 1377 pLibInfo->IsReference() = sal_True; 1378 } 1379 else 1380 { 1381 pLibInfo->GetLib()->SetModified( sal_True ); // Must be saved after Add! 1382 pLibInfo->SetStorageName( String::CreateFromAscii(szImbedded) ); // Save in BasicManager-Storage 1383 } 1384 bBasMgrModified = sal_True; 1385 } 1386 else 1387 { 1388 RemoveLib( nLibId, sal_False ); 1389 pLibInfo = 0; 1390 } 1391 1392 if( pLibInfo ) 1393 return &*pLibInfo->GetLib() ; 1394 else 1395 return 0; 1396 } 1397 1398 sal_Bool BasicManager::IsReference( sal_uInt16 nLib ) 1399 { 1400 DBG_CHKTHIS( BasicManager, 0 ); 1401 1402 BasicLibInfo* pLibInfo = pLibs->GetObject( nLib ); 1403 DBG_ASSERT( pLibInfo, "Lib?!" ); 1404 if ( pLibInfo ) 1405 return pLibInfo->IsReference(); 1406 1407 return sal_False; 1408 } 1409 1410 sal_Bool BasicManager::RemoveLib( sal_uInt16 nLib ) 1411 { 1412 // Only pyhsical deletion if no reference 1413 return RemoveLib( nLib, !IsReference( nLib ) ); 1414 } 1415 1416 sal_Bool BasicManager::RemoveLib( sal_uInt16 nLib, sal_Bool bDelBasicFromStorage ) 1417 { 1418 DBG_CHKTHIS( BasicManager, 0 ); 1419 DBG_ASSERT( nLib, "Standard-Lib cannot be removed!" ); 1420 1421 BasicLibInfo* pLibInfo = pLibs->GetObject( nLib ); 1422 DBG_ASSERT( pLibInfo, "Lib not found!" ); 1423 1424 if ( !pLibInfo || !nLib ) 1425 { 1426 // String aErrorText( BasicResId( IDS_SBERR_REMOVELIB ) ); 1427 StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_REMOVELIB, String(), ERRCODE_BUTTON_OK ); 1428 pErrorMgr->InsertError( BasicError( *pErrInf, BASERR_REASON_STDLIB, pLibInfo->GetLibName() ) ); 1429 return sal_False; 1430 } 1431 1432 // If one of the streams cannot be opened, this is not an error, 1433 // because BASIC was never written before... 1434 if ( bDelBasicFromStorage && !pLibInfo->IsReference() && 1435 ( !pLibInfo->IsExtern() || SotStorage::IsStorageFile( pLibInfo->GetStorageName() ) ) ) 1436 { 1437 SotStorageRef xStorage; 1438 if ( !pLibInfo->IsExtern() ) 1439 xStorage = new SotStorage( sal_False, GetStorageName() ); 1440 else 1441 xStorage = new SotStorage( sal_False, pLibInfo->GetStorageName() ); 1442 1443 if ( xStorage->IsStorage( String(RTL_CONSTASCII_USTRINGPARAM(szBasicStorage)) ) ) 1444 { 1445 SotStorageRef xBasicStorage = xStorage->OpenSotStorage 1446 ( String(RTL_CONSTASCII_USTRINGPARAM(szBasicStorage)), STREAM_STD_READWRITE, sal_False ); 1447 1448 if ( !xBasicStorage.Is() || xBasicStorage->GetError() ) 1449 { 1450 // String aErrorText( BasicResId( IDS_SBERR_REMOVELIB ) ); 1451 StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_REMOVELIB, String(), ERRCODE_BUTTON_OK ); 1452 pErrorMgr->InsertError( BasicError( *pErrInf, BASERR_REASON_OPENLIBSTORAGE, pLibInfo->GetLibName() ) ); 1453 } 1454 else if ( xBasicStorage->IsStream( pLibInfo->GetLibName() ) ) 1455 { 1456 xBasicStorage->Remove( pLibInfo->GetLibName() ); 1457 xBasicStorage->Commit(); 1458 1459 // If no further stream available, 1460 // delete the SubStorage. 1461 SvStorageInfoList aInfoList( 0, 4 ); 1462 xBasicStorage->FillInfoList( &aInfoList ); 1463 if ( !aInfoList.Count() ) 1464 { 1465 xBasicStorage.Clear(); 1466 xStorage->Remove( String(RTL_CONSTASCII_USTRINGPARAM(szBasicStorage)) ); 1467 xStorage->Commit(); 1468 // If no further Streams or SubStorages available, 1469 // delete the Storage, too. 1470 aInfoList.Clear(); 1471 xStorage->FillInfoList( &aInfoList ); 1472 if ( !aInfoList.Count() ) 1473 { 1474 String aName_( xStorage->GetName() ); 1475 xStorage.Clear(); 1476 //*** TODO: Replace if still necessary 1477 //SfxContentHelper::Kill( aName ); 1478 //*** TODO-End 1479 } 1480 } 1481 } 1482 } 1483 } 1484 bBasMgrModified = sal_True; 1485 if ( pLibInfo->GetLib().Is() ) 1486 GetStdLib()->Remove( pLibInfo->GetLib() ); 1487 delete pLibs->Remove( pLibInfo ); 1488 return sal_True; // Remove was successful, del unimportant 1489 } 1490 1491 sal_uInt16 BasicManager::GetLibCount() const 1492 { 1493 DBG_CHKTHIS( BasicManager, 0 ); 1494 return (sal_uInt16)pLibs->Count(); 1495 } 1496 1497 StarBASIC* BasicManager::GetLib( sal_uInt16 nLib ) const 1498 { 1499 DBG_CHKTHIS( BasicManager, 0 ); 1500 BasicLibInfo* pInf = pLibs->GetObject( nLib ); 1501 DBG_ASSERT( pInf, "Lib existiert nicht!" ); 1502 if ( pInf ) 1503 return pInf->GetLib(); 1504 return 0; 1505 } 1506 1507 StarBASIC* BasicManager::GetStdLib() const 1508 { 1509 DBG_CHKTHIS( BasicManager, 0 ); 1510 StarBASIC* pLib = GetLib( 0 ); 1511 return pLib; 1512 } 1513 1514 StarBASIC* BasicManager::GetLib( const String& rName ) const 1515 { 1516 DBG_CHKTHIS( BasicManager, 0 ); 1517 1518 BasicLibInfo* pInf = pLibs->First(); 1519 while ( pInf ) 1520 { 1521 if ( pInf->GetLibName().CompareIgnoreCaseToAscii( rName ) == COMPARE_EQUAL )// Check if available... 1522 return pInf->GetLib(); 1523 1524 pInf = pLibs->Next(); 1525 } 1526 return 0; 1527 } 1528 1529 sal_uInt16 BasicManager::GetLibId( const String& rName ) const 1530 { 1531 DBG_CHKTHIS( BasicManager, 0 ); 1532 1533 BasicLibInfo* pInf = pLibs->First(); 1534 while ( pInf ) 1535 { 1536 if ( pInf->GetLibName().CompareIgnoreCaseToAscii( rName ) == COMPARE_EQUAL ) 1537 return (sal_uInt16)pLibs->GetCurPos(); 1538 1539 pInf = pLibs->Next(); 1540 } 1541 return LIB_NOTFOUND; 1542 } 1543 1544 sal_Bool BasicManager::HasLib( const String& rName ) const 1545 { 1546 DBG_CHKTHIS( BasicManager, 0 ); 1547 1548 BasicLibInfo* pInf = pLibs->First(); 1549 while ( pInf ) 1550 { 1551 if ( pInf->GetLibName().CompareIgnoreCaseToAscii( rName ) == COMPARE_EQUAL ) 1552 return sal_True; 1553 1554 pInf = pLibs->Next(); 1555 } 1556 return sal_False; 1557 } 1558 1559 sal_Bool BasicManager::SetLibName( sal_uInt16 nLib, const String& rName ) 1560 { 1561 DBG_CHKTHIS( BasicManager, 0 ); 1562 1563 BasicLibInfo* pLibInfo = pLibs->GetObject( nLib ); 1564 DBG_ASSERT( pLibInfo, "Lib?!" ); 1565 if ( pLibInfo ) 1566 { 1567 pLibInfo->SetLibName( rName ); 1568 if ( pLibInfo->GetLib().Is() ) 1569 { 1570 StarBASICRef xStdLib = pLibInfo->GetLib(); 1571 xStdLib->SetName( rName ); 1572 xStdLib->SetModified( sal_True ); 1573 } 1574 bBasMgrModified = sal_True; 1575 return sal_True; 1576 } 1577 return sal_False; 1578 } 1579 1580 String BasicManager::GetLibName( sal_uInt16 nLib ) 1581 { 1582 DBG_CHKTHIS( BasicManager, 0 ); 1583 1584 BasicLibInfo* pLibInfo = pLibs->GetObject( nLib ); 1585 DBG_ASSERT( pLibInfo, "Lib?!" ); 1586 if ( pLibInfo ) 1587 return pLibInfo->GetLibName(); 1588 return String(); 1589 } 1590 1591 sal_Bool BasicManager::LoadLib( sal_uInt16 nLib ) 1592 { 1593 DBG_CHKTHIS( BasicManager, 0 ); 1594 1595 sal_Bool bDone = sal_False; 1596 BasicLibInfo* pLibInfo = pLibs->GetObject( nLib ); 1597 DBG_ASSERT( pLibInfo, "Lib?!" ); 1598 if ( pLibInfo ) 1599 { 1600 Reference< XLibraryContainer > xLibContainer = pLibInfo->GetLibraryContainer(); 1601 if( xLibContainer.is() ) 1602 { 1603 String aLibName = pLibInfo->GetLibName(); 1604 xLibContainer->loadLibrary( aLibName ); 1605 bDone = xLibContainer->isLibraryLoaded( aLibName );; 1606 } 1607 else 1608 { 1609 bDone = ImpLoadLibary( pLibInfo, NULL, sal_False ); 1610 StarBASIC* pLib = GetLib( nLib ); 1611 if ( pLib ) 1612 { 1613 // pLib->SetParent( GetStdLib() ); 1614 GetStdLib()->Insert( pLib ); 1615 pLib->SetFlag( SBX_EXTSEARCH ); 1616 } 1617 } 1618 } 1619 else 1620 { 1621 // String aErrorText( BasicResId( IDS_SBERR_LIBLOAD ) ); 1622 // aErrorText.SearchAndReplace( "XX", "" ); 1623 StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_LIBLOAD, String(), ERRCODE_BUTTON_OK ); 1624 pErrorMgr->InsertError( BasicError( *pErrInf, BASERR_REASON_LIBNOTFOUND, String::CreateFromInt32(nLib) ) ); 1625 } 1626 return bDone; 1627 } 1628 1629 StarBASIC* BasicManager::CreateLib( const String& rLibName ) 1630 { 1631 DBG_CHKTHIS( BasicManager, 0 ); 1632 if ( GetLib( rLibName ) ) 1633 return 0; 1634 1635 BasicLibInfo* pLibInfo = CreateLibInfo(); 1636 StarBASIC* pNew = new StarBASIC( GetStdLib(), mbDocMgr ); 1637 GetStdLib()->Insert( pNew ); 1638 pNew->SetFlag( SBX_EXTSEARCH | SBX_DONTSTORE ); 1639 pLibInfo->SetLib( pNew ); 1640 pLibInfo->SetLibName( rLibName ); 1641 pLibInfo->GetLib()->SetName( rLibName ); 1642 return pLibInfo->GetLib(); 1643 } 1644 1645 // For XML import/export: 1646 StarBASIC* BasicManager::CreateLib 1647 ( const String& rLibName, const String& Password, const String& LinkTargetURL ) 1648 { 1649 // Ask if lib exists because standard lib is always there 1650 StarBASIC* pLib = GetLib( rLibName ); 1651 if( !pLib ) 1652 { 1653 if( LinkTargetURL.Len() != 0 ) 1654 { 1655 SotStorageRef xStorage = new SotStorage( sal_False, LinkTargetURL, STREAM_READ | STREAM_SHARE_DENYWRITE ); 1656 if( !xStorage->GetError() ) 1657 { 1658 pLib = AddLib( *xStorage, rLibName, sal_True ); 1659 1660 //if( !pLibInfo ) 1661 //pLibInfo = FindLibInfo( pLib ); 1662 //pLibInfo->SetStorageName( LinkTargetURL ); 1663 //pLibInfo->GetLib()->SetModified( sal_False ); // Dann nicht speichern 1664 //pLibInfo->SetRelStorageName( String() ); 1665 //pLibInfo->IsReference() = sal_True; 1666 } 1667 //else 1668 //Message? 1669 1670 DBG_ASSERT( pLib, "XML Import: Linked basic library could not be loaded"); 1671 } 1672 else 1673 { 1674 pLib = CreateLib( rLibName ); 1675 if( Password.Len() != 0 ) 1676 { 1677 BasicLibInfo* pLibInfo = FindLibInfo( pLib ); 1678 pLibInfo ->SetPassword( Password ); 1679 } 1680 } 1681 //ExternalSourceURL ? 1682 } 1683 return pLib; 1684 } 1685 1686 StarBASIC* BasicManager::CreateLibForLibContainer( const String& rLibName, 1687 const Reference< XLibraryContainer >& xScriptCont ) 1688 { 1689 DBG_CHKTHIS( BasicManager, 0 ); 1690 if ( GetLib( rLibName ) ) 1691 return 0; 1692 1693 BasicLibInfo* pLibInfo = CreateLibInfo(); 1694 StarBASIC* pNew = new StarBASIC( GetStdLib(), mbDocMgr ); 1695 GetStdLib()->Insert( pNew ); 1696 pNew->SetFlag( SBX_EXTSEARCH | SBX_DONTSTORE ); 1697 pLibInfo->SetLib( pNew ); 1698 pLibInfo->SetLibName( rLibName ); 1699 pLibInfo->GetLib()->SetName( rLibName ); 1700 pLibInfo->SetLibraryContainer( xScriptCont ); 1701 return pNew; 1702 } 1703 1704 1705 BasicLibInfo* BasicManager::FindLibInfo( StarBASIC* pBasic ) const 1706 { 1707 DBG_CHKTHIS( BasicManager, 0 ); 1708 1709 BasicLibInfo* pInf = ((BasicManager*)this)->pLibs->First(); 1710 while ( pInf ) 1711 { 1712 if ( pInf->GetLib() == pBasic ) 1713 return pInf; 1714 1715 pInf = ((BasicManager*)this)->pLibs->Next(); 1716 } 1717 return 0; 1718 } 1719 1720 1721 sal_Bool BasicManager::IsModified() const 1722 { 1723 DBG_CHKTHIS( BasicManager, 0 ); 1724 1725 if ( bBasMgrModified ) 1726 return sal_True; 1727 return IsBasicModified(); 1728 } 1729 1730 sal_Bool BasicManager::IsBasicModified() const 1731 { 1732 DBG_CHKTHIS( BasicManager, 0 ); 1733 1734 BasicLibInfo* pInf = pLibs->First(); 1735 while ( pInf ) 1736 { 1737 if ( pInf->GetLib().Is() && pInf->GetLib()->IsModified() ) 1738 return sal_True; 1739 1740 pInf = pLibs->Next(); 1741 } 1742 return sal_False; 1743 } 1744 1745 void BasicManager::SetFlagToAllLibs( short nFlag, sal_Bool bSet ) const 1746 { 1747 sal_uInt16 nLibs = GetLibCount(); 1748 for ( sal_uInt16 nL = 0; nL < nLibs; nL++ ) 1749 { 1750 BasicLibInfo* pInfo = pLibs->GetObject( nL ); 1751 DBG_ASSERT( pInfo, "Info?!" ); 1752 StarBASIC* pLib = pInfo->GetLib(); 1753 if ( pLib ) 1754 { 1755 if ( bSet ) 1756 pLib->SetFlag( nFlag ); 1757 else 1758 pLib->ResetFlag( nFlag ); 1759 } 1760 } 1761 } 1762 1763 sal_Bool BasicManager::HasErrors() 1764 { 1765 DBG_CHKTHIS( BasicManager, 0 ); 1766 return pErrorMgr->HasErrors(); 1767 } 1768 1769 void BasicManager::ClearErrors() 1770 { 1771 DBG_CHKTHIS( BasicManager, 0 ); 1772 pErrorMgr->Reset(); 1773 } 1774 1775 BasicError* BasicManager::GetFirstError() 1776 { 1777 DBG_CHKTHIS( BasicManager, 0 ); 1778 return pErrorMgr->GetFirstError(); 1779 } 1780 1781 BasicError* BasicManager::GetNextError() 1782 { 1783 DBG_CHKTHIS( BasicManager, 0 ); 1784 return pErrorMgr->GetNextError(); 1785 } 1786 bool BasicManager::GetGlobalUNOConstant( const sal_Char* _pAsciiName, ::com::sun::star::uno::Any& aOut ) 1787 { 1788 bool bRes = false; 1789 StarBASIC* pStandardLib = GetStdLib(); 1790 OSL_PRECOND( pStandardLib, "BasicManager::GetGlobalUNOConstant: no lib to read from!" ); 1791 if ( pStandardLib ) 1792 bRes = pStandardLib->GetUNOConstant( _pAsciiName, aOut ); 1793 return bRes; 1794 } 1795 1796 Any BasicManager::SetGlobalUNOConstant( const sal_Char* _pAsciiName, const Any& _rValue ) 1797 { 1798 Any aOldValue; 1799 1800 StarBASIC* pStandardLib = GetStdLib(); 1801 OSL_PRECOND( pStandardLib, "BasicManager::SetGlobalUNOConstant: no lib to insert into!" ); 1802 if ( !pStandardLib ) 1803 return aOldValue; 1804 1805 ::rtl::OUString sVarName( ::rtl::OUString::createFromAscii( _pAsciiName ) ); 1806 1807 // obtain the old value 1808 SbxVariable* pVariable = pStandardLib->Find( sVarName, SbxCLASS_OBJECT ); 1809 if ( pVariable ) 1810 aOldValue = sbxToUnoValue( pVariable ); 1811 1812 SbxObjectRef xUnoObj = GetSbUnoObject( sVarName, _rValue ); 1813 xUnoObj->SetFlag( SBX_DONTSTORE ); 1814 pStandardLib->Insert( xUnoObj ); 1815 1816 return aOldValue; 1817 } 1818 1819 bool BasicManager::LegacyPsswdBinaryLimitExceeded( ::com::sun::star::uno::Sequence< rtl::OUString >& _out_rModuleNames ) 1820 { 1821 try 1822 { 1823 Reference< XNameAccess > xScripts( GetScriptLibraryContainer(), UNO_QUERY_THROW ); 1824 Reference< XLibraryContainerPassword > xPassword( GetScriptLibraryContainer(), UNO_QUERY_THROW ); 1825 1826 Sequence< ::rtl::OUString > aNames( xScripts->getElementNames() ); 1827 const ::rtl::OUString* pNames = aNames.getConstArray(); 1828 const ::rtl::OUString* pNamesEnd = aNames.getConstArray() + aNames.getLength(); 1829 for ( ; pNames != pNamesEnd; ++pNames ) 1830 { 1831 if( /*pLib->mbSharedIndexFile ||*/ !xPassword->isLibraryPasswordProtected( *pNames ) ) 1832 continue; 1833 1834 StarBASIC* pBasicLib = GetLib( *pNames ); 1835 if ( !pBasicLib ) 1836 continue; 1837 1838 Reference< XNameAccess > xScriptLibrary( xScripts->getByName( *pNames ), UNO_QUERY_THROW ); 1839 Sequence< ::rtl::OUString > aElementNames( xScriptLibrary->getElementNames() ); 1840 sal_Int32 nLen = aElementNames.getLength(); 1841 1842 Sequence< ::rtl::OUString > aBigModules( nLen ); 1843 sal_Int32 nBigModules = 0; 1844 1845 const ::rtl::OUString* pElementNames = aElementNames.getConstArray(); 1846 const ::rtl::OUString* pElementNamesEnd = aElementNames.getConstArray() + aElementNames.getLength(); 1847 for ( ; pElementNames != pElementNamesEnd; ++pElementNames ) 1848 { 1849 SbModule* pMod = pBasicLib->FindModule( *pElementNames ); 1850 if ( pMod && pMod->ExceedsLegacyModuleSize() ) 1851 aBigModules[ nBigModules++ ] = *pElementNames; 1852 } 1853 1854 if ( nBigModules ) 1855 { 1856 aBigModules.realloc( nBigModules ); 1857 _out_rModuleNames = aBigModules; 1858 return true; 1859 } 1860 } 1861 } 1862 catch( const Exception& ) 1863 { 1864 DBG_UNHANDLED_EXCEPTION(); 1865 } 1866 return false; 1867 } 1868 1869 1870 namespace 1871 { 1872 SbMethod* lcl_queryMacro( BasicManager* i_manager, String const& i_fullyQualifiedName ) 1873 { 1874 sal_uInt16 nLast = 0; 1875 String sMacro = i_fullyQualifiedName; 1876 String sLibName = sMacro.GetToken( 0, '.', nLast ); 1877 String sModule = sMacro.GetToken( 0, '.', nLast ); 1878 sMacro.Erase( 0, nLast ); 1879 1880 IntlWrapper aIntlWrapper( ::comphelper::getProcessServiceFactory(), Application::GetSettings().GetLocale() ); 1881 const CollatorWrapper* pCollator = aIntlWrapper.getCollator(); 1882 sal_uInt16 nLibCount = i_manager->GetLibCount(); 1883 for ( sal_uInt16 nLib = 0; nLib < nLibCount; ++nLib ) 1884 { 1885 if ( COMPARE_EQUAL == pCollator->compareString( i_manager->GetLibName( nLib ), sLibName ) ) 1886 { 1887 StarBASIC* pLib = i_manager->GetLib( nLib ); 1888 if( !pLib ) 1889 { 1890 i_manager->LoadLib( nLib ); 1891 pLib = i_manager->GetLib( nLib ); 1892 } 1893 1894 if( pLib ) 1895 { 1896 sal_uInt16 nModCount = pLib->GetModules()->Count(); 1897 for( sal_uInt16 nMod = 0; nMod < nModCount; ++nMod ) 1898 { 1899 SbModule* pMod = (SbModule*)pLib->GetModules()->Get( nMod ); 1900 if ( pMod && COMPARE_EQUAL == pCollator->compareString( pMod->GetName(), sModule ) ) 1901 { 1902 SbMethod* pMethod = (SbMethod*)pMod->Find( sMacro, SbxCLASS_METHOD ); 1903 if( pMethod ) 1904 return pMethod; 1905 } 1906 } 1907 } 1908 } 1909 } 1910 return 0; 1911 } 1912 } 1913 1914 bool BasicManager::HasMacro( String const& i_fullyQualifiedName ) const 1915 { 1916 return ( NULL != lcl_queryMacro( const_cast< BasicManager* >( this ), i_fullyQualifiedName ) ); 1917 } 1918 1919 ErrCode BasicManager::ExecuteMacro( String const& i_fullyQualifiedName, SbxArray* i_arguments, SbxValue* i_retValue ) 1920 { 1921 SbMethod* pMethod = lcl_queryMacro( this, i_fullyQualifiedName ); 1922 ErrCode nError = 0; 1923 if ( pMethod ) 1924 { 1925 if ( i_arguments ) 1926 pMethod->SetParameters( i_arguments ); 1927 nError = pMethod->Call( i_retValue ); 1928 } 1929 else 1930 nError = ERRCODE_BASIC_PROC_UNDEFINED; 1931 return nError; 1932 } 1933 1934 ErrCode BasicManager::ExecuteMacro( String const& i_fullyQualifiedName, String const& i_commaSeparatedArgs, SbxValue* i_retValue ) 1935 { 1936 SbMethod* pMethod = lcl_queryMacro( this, i_fullyQualifiedName ); 1937 if ( !pMethod ) 1938 return ERRCODE_BASIC_PROC_UNDEFINED; 1939 1940 // arguments must be quoted 1941 String sQuotedArgs; 1942 String sArgs( i_commaSeparatedArgs ); 1943 if ( sArgs.Len()<2 || sArgs.GetBuffer()[1] == '\"') 1944 // no args or already quoted args 1945 sQuotedArgs = sArgs; 1946 else 1947 { 1948 // quote parameters 1949 sArgs.Erase( 0, 1 ); 1950 sArgs.Erase( sArgs.Len()-1, 1 ); 1951 1952 sQuotedArgs = '('; 1953 1954 sal_uInt16 nCount = sArgs.GetTokenCount(','); 1955 for ( sal_uInt16 n=0; n<nCount; ++n ) 1956 { 1957 sQuotedArgs += '\"'; 1958 sQuotedArgs += sArgs.GetToken( n, ',' ); 1959 sQuotedArgs += '\"'; 1960 if ( n<nCount-1 ) 1961 sQuotedArgs += ','; 1962 } 1963 1964 sQuotedArgs += ')'; 1965 } 1966 1967 // add quoted arguments and do the call 1968 String sCall( '[' ); 1969 sCall += pMethod->GetName(); 1970 sCall += sQuotedArgs; 1971 sCall += ']'; 1972 1973 SbxVariable* pRet = pMethod->GetParent()->Execute( sCall ); 1974 if ( pRet && ( pRet != pMethod ) ) 1975 *i_retValue = *pRet; 1976 return SbxBase::GetError(); 1977 } 1978 1979 //===================================================================== 1980 1981 class ModuleInfo_Impl : public ModuleInfoHelper 1982 { 1983 ::rtl::OUString maName; 1984 ::rtl::OUString maLanguage; 1985 ::rtl::OUString maSource; 1986 1987 public: 1988 ModuleInfo_Impl( const ::rtl::OUString& aName, const ::rtl::OUString& aLanguage, const ::rtl::OUString& aSource ) 1989 : maName( aName ), maLanguage( aLanguage), maSource( aSource ) {} 1990 1991 // Methods XStarBasicModuleInfo 1992 virtual ::rtl::OUString SAL_CALL getName() throw(RuntimeException) 1993 { return maName; } 1994 virtual ::rtl::OUString SAL_CALL getLanguage() throw(RuntimeException) 1995 { return maLanguage; } 1996 virtual ::rtl::OUString SAL_CALL getSource() throw(RuntimeException) 1997 { return maSource; } 1998 }; 1999 2000 2001 //===================================================================== 2002 2003 class DialogInfo_Impl : public DialogInfoHelper 2004 { 2005 ::rtl::OUString maName; 2006 Sequence< sal_Int8 > mData; 2007 2008 public: 2009 DialogInfo_Impl( const ::rtl::OUString& aName, Sequence< sal_Int8 > Data ) 2010 : maName( aName ), mData( Data ) {} 2011 2012 // Methods XStarBasicDialogInfo 2013 virtual ::rtl::OUString SAL_CALL getName() throw(RuntimeException) 2014 { return maName; } 2015 virtual Sequence< sal_Int8 > SAL_CALL getData() throw(RuntimeException) 2016 { return mData; } 2017 }; 2018 2019 2020 //===================================================================== 2021 2022 class LibraryInfo_Impl : public LibraryInfoHelper 2023 { 2024 ::rtl::OUString maName; 2025 Reference< XNameContainer > mxModuleContainer; 2026 Reference< XNameContainer > mxDialogContainer; 2027 ::rtl::OUString maPassword; 2028 ::rtl::OUString maExternaleSourceURL; 2029 ::rtl::OUString maLinkTargetURL; 2030 2031 public: 2032 LibraryInfo_Impl 2033 ( 2034 const ::rtl::OUString& aName, 2035 Reference< XNameContainer > xModuleContainer, 2036 Reference< XNameContainer > xDialogContainer, 2037 const ::rtl::OUString& aPassword, 2038 const ::rtl::OUString& aExternaleSourceURL, 2039 const ::rtl::OUString& aLinkTargetURL 2040 ) 2041 : maName( aName ) 2042 , mxModuleContainer( xModuleContainer ) 2043 , mxDialogContainer( xDialogContainer ) 2044 , maPassword( aPassword ) 2045 , maExternaleSourceURL( aExternaleSourceURL ) 2046 , maLinkTargetURL( aLinkTargetURL ) 2047 {} 2048 2049 // Methods XStarBasicLibraryInfo 2050 virtual ::rtl::OUString SAL_CALL getName() throw(RuntimeException) 2051 { return maName; } 2052 virtual Reference< XNameContainer > SAL_CALL getModuleContainer() throw(RuntimeException) 2053 { return mxModuleContainer; } 2054 virtual Reference< XNameContainer > SAL_CALL getDialogContainer() throw(RuntimeException) 2055 { return mxDialogContainer; } 2056 virtual ::rtl::OUString SAL_CALL getPassword() throw(RuntimeException) 2057 { return maPassword; } 2058 virtual ::rtl::OUString SAL_CALL getExternalSourceURL() throw(RuntimeException) 2059 { return maExternaleSourceURL; } 2060 virtual ::rtl::OUString SAL_CALL getLinkTargetURL() throw(RuntimeException) 2061 { return maLinkTargetURL; } 2062 }; 2063 2064 //===================================================================== 2065 2066 class ModuleContainer_Impl : public NameContainerHelper 2067 { 2068 StarBASIC* mpLib; 2069 2070 public: 2071 ModuleContainer_Impl( StarBASIC* pLib ) 2072 :mpLib( pLib ) {} 2073 2074 // Methods XElementAccess 2075 virtual Type SAL_CALL getElementType() 2076 throw(RuntimeException); 2077 virtual sal_Bool SAL_CALL hasElements() 2078 throw(RuntimeException); 2079 2080 // Methods XNameAccess 2081 virtual Any SAL_CALL getByName( const ::rtl::OUString& aName ) 2082 throw(NoSuchElementException, WrappedTargetException, RuntimeException); 2083 virtual Sequence< ::rtl::OUString > SAL_CALL getElementNames() 2084 throw(RuntimeException); 2085 virtual sal_Bool SAL_CALL hasByName( const ::rtl::OUString& aName ) 2086 throw(RuntimeException); 2087 2088 // Methods XNameReplace 2089 virtual void SAL_CALL replaceByName( const ::rtl::OUString& aName, const Any& aElement ) 2090 throw(IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException); 2091 2092 // Methods XNameContainer 2093 virtual void SAL_CALL insertByName( const ::rtl::OUString& aName, const Any& aElement ) 2094 throw(IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException); 2095 virtual void SAL_CALL removeByName( const ::rtl::OUString& Name ) 2096 throw(NoSuchElementException, WrappedTargetException, RuntimeException); 2097 }; 2098 2099 // Methods XElementAccess 2100 Type ModuleContainer_Impl::getElementType() 2101 throw(RuntimeException) 2102 { 2103 Type aModuleType = ::getCppuType( (const Reference< XStarBasicModuleInfo > *)0 ); 2104 return aModuleType; 2105 } 2106 2107 sal_Bool ModuleContainer_Impl::hasElements() 2108 throw(RuntimeException) 2109 { 2110 SbxArray* pMods = mpLib ? mpLib->GetModules() : NULL; 2111 return pMods && pMods->Count() > 0; 2112 } 2113 2114 // Methods XNameAccess 2115 Any ModuleContainer_Impl::getByName( const ::rtl::OUString& aName ) 2116 throw(NoSuchElementException, WrappedTargetException, RuntimeException) 2117 { 2118 SbModule* pMod = mpLib ? mpLib->FindModule( aName ) : NULL; 2119 if( !pMod ) 2120 throw NoSuchElementException(); 2121 Reference< XStarBasicModuleInfo > xMod = (XStarBasicModuleInfo*)new ModuleInfo_Impl 2122 ( aName, ::rtl::OUString::createFromAscii( szScriptLanguage ), pMod->GetSource32() ); 2123 Any aRetAny; 2124 aRetAny <<= xMod; 2125 return aRetAny; 2126 } 2127 2128 Sequence< ::rtl::OUString > ModuleContainer_Impl::getElementNames() 2129 throw(RuntimeException) 2130 { 2131 SbxArray* pMods = mpLib ? mpLib->GetModules() : NULL; 2132 sal_uInt16 nMods = pMods ? pMods->Count() : 0; 2133 Sequence< ::rtl::OUString > aRetSeq( nMods ); 2134 ::rtl::OUString* pRetSeq = aRetSeq.getArray(); 2135 for( sal_uInt16 i = 0 ; i < nMods ; i++ ) 2136 { 2137 SbxVariable* pMod = pMods->Get( i ); 2138 pRetSeq[i] = ::rtl::OUString( pMod->GetName() ); 2139 } 2140 return aRetSeq; 2141 } 2142 2143 sal_Bool ModuleContainer_Impl::hasByName( const ::rtl::OUString& aName ) 2144 throw(RuntimeException) 2145 { 2146 SbModule* pMod = mpLib ? mpLib->FindModule( aName ) : NULL; 2147 sal_Bool bRet = (pMod != NULL); 2148 return bRet; 2149 } 2150 2151 2152 // Methods XNameReplace 2153 void ModuleContainer_Impl::replaceByName( const ::rtl::OUString& aName, const Any& aElement ) 2154 throw(IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException) 2155 { 2156 removeByName( aName ); 2157 insertByName( aName, aElement ); 2158 } 2159 2160 2161 // Methods XNameContainer 2162 void ModuleContainer_Impl::insertByName( const ::rtl::OUString& aName, const Any& aElement ) 2163 throw(IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException) 2164 { 2165 Type aModuleType = ::getCppuType( (const Reference< XStarBasicModuleInfo > *)0 ); 2166 Type aAnyType = aElement.getValueType(); 2167 if( aModuleType != aAnyType ) 2168 throw IllegalArgumentException(); 2169 Reference< XStarBasicModuleInfo > xMod; 2170 aElement >>= xMod; 2171 mpLib->MakeModule32( aName, xMod->getSource() ); 2172 } 2173 2174 void ModuleContainer_Impl::removeByName( const ::rtl::OUString& Name ) 2175 throw(NoSuchElementException, WrappedTargetException, RuntimeException) 2176 { 2177 SbModule* pMod = mpLib ? mpLib->FindModule( Name ) : NULL; 2178 if( !pMod ) 2179 throw NoSuchElementException(); 2180 mpLib->Remove( pMod ); 2181 } 2182 2183 2184 //===================================================================== 2185 2186 Sequence< sal_Int8 > implGetDialogData( SbxObject* pDialog ) 2187 { 2188 SvMemoryStream aMemStream; 2189 pDialog->Store( aMemStream ); 2190 sal_Int32 nLen = aMemStream.Tell(); 2191 Sequence< sal_Int8 > aData( nLen ); 2192 sal_Int8* pDestData = aData.getArray(); 2193 const sal_Int8* pSrcData = (const sal_Int8*)aMemStream.GetData(); 2194 rtl_copyMemory( pDestData, pSrcData, nLen ); 2195 return aData; 2196 } 2197 2198 SbxObject* implCreateDialog( Sequence< sal_Int8 > aData ) 2199 { 2200 sal_Int8* pData = aData.getArray(); 2201 SvMemoryStream aMemStream( pData, aData.getLength(), STREAM_READ ); 2202 SbxObject* pDialog = (SbxObject*)SbxBase::Load( aMemStream ); 2203 return pDialog; 2204 } 2205 2206 // HACK! Because this value is defined in basctl/inc/vcsbxdef.hxx 2207 // which we can't include here, we have to use the value directly 2208 #define SBXID_DIALOG 101 2209 2210 2211 class DialogContainer_Impl : public NameContainerHelper 2212 { 2213 StarBASIC* mpLib; 2214 2215 public: 2216 DialogContainer_Impl( StarBASIC* pLib ) 2217 :mpLib( pLib ) {} 2218 2219 // Methods XElementAccess 2220 virtual Type SAL_CALL getElementType() 2221 throw(RuntimeException); 2222 virtual sal_Bool SAL_CALL hasElements() 2223 throw(RuntimeException); 2224 2225 // Methods XNameAccess 2226 virtual Any SAL_CALL getByName( const ::rtl::OUString& aName ) 2227 throw(NoSuchElementException, WrappedTargetException, RuntimeException); 2228 virtual Sequence< ::rtl::OUString > SAL_CALL getElementNames() 2229 throw(RuntimeException); 2230 virtual sal_Bool SAL_CALL hasByName( const ::rtl::OUString& aName ) 2231 throw(RuntimeException); 2232 2233 // Methods XNameReplace 2234 virtual void SAL_CALL replaceByName( const ::rtl::OUString& aName, const Any& aElement ) 2235 throw(IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException); 2236 2237 // Methods XNameContainer 2238 virtual void SAL_CALL insertByName( const ::rtl::OUString& aName, const Any& aElement ) 2239 throw(IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException); 2240 virtual void SAL_CALL removeByName( const ::rtl::OUString& Name ) 2241 throw(NoSuchElementException, WrappedTargetException, RuntimeException); 2242 }; 2243 2244 // Methods XElementAccess 2245 Type DialogContainer_Impl::getElementType() 2246 throw(RuntimeException) 2247 { 2248 Type aModuleType = ::getCppuType( (const Reference< XStarBasicDialogInfo > *)0 ); 2249 return aModuleType; 2250 } 2251 2252 sal_Bool DialogContainer_Impl::hasElements() 2253 throw(RuntimeException) 2254 { 2255 sal_Bool bRet = sal_False; 2256 2257 mpLib->GetAll( SbxCLASS_OBJECT ); 2258 sal_Int16 nCount = mpLib->GetObjects()->Count(); 2259 for( sal_Int16 nObj = 0; nObj < nCount ; nObj++ ) 2260 { 2261 SbxVariable* pVar = mpLib->GetObjects()->Get( nObj ); 2262 if ( pVar->ISA( SbxObject ) && ( ((SbxObject*)pVar)->GetSbxId() == SBXID_DIALOG ) ) 2263 { 2264 bRet = sal_True; 2265 break; 2266 } 2267 } 2268 return bRet; 2269 } 2270 2271 // Methods XNameAccess 2272 Any DialogContainer_Impl::getByName( const ::rtl::OUString& aName ) 2273 throw(NoSuchElementException, WrappedTargetException, RuntimeException) 2274 { 2275 SbxVariable* pVar = mpLib->GetObjects()->Find( aName, SbxCLASS_DONTCARE ); 2276 if( !( pVar && pVar->ISA( SbxObject ) && 2277 ( ((SbxObject*)pVar)->GetSbxId() == SBXID_DIALOG ) ) ) 2278 { 2279 throw NoSuchElementException(); 2280 } 2281 2282 Reference< XStarBasicDialogInfo > xDialog = 2283 (XStarBasicDialogInfo*)new DialogInfo_Impl 2284 ( aName, implGetDialogData( (SbxObject*)pVar ) ); 2285 2286 Any aRetAny; 2287 aRetAny <<= xDialog; 2288 return aRetAny; 2289 } 2290 2291 Sequence< ::rtl::OUString > DialogContainer_Impl::getElementNames() 2292 throw(RuntimeException) 2293 { 2294 mpLib->GetAll( SbxCLASS_OBJECT ); 2295 sal_Int16 nCount = mpLib->GetObjects()->Count(); 2296 Sequence< ::rtl::OUString > aRetSeq( nCount ); 2297 ::rtl::OUString* pRetSeq = aRetSeq.getArray(); 2298 sal_Int32 nDialogCounter = 0; 2299 2300 for( sal_Int16 nObj = 0; nObj < nCount ; nObj++ ) 2301 { 2302 SbxVariable* pVar = mpLib->GetObjects()->Get( nObj ); 2303 if ( pVar->ISA( SbxObject ) && ( ((SbxObject*)pVar)->GetSbxId() == SBXID_DIALOG ) ) 2304 { 2305 pRetSeq[ nDialogCounter ] = ::rtl::OUString( pVar->GetName() ); 2306 nDialogCounter++; 2307 } 2308 } 2309 aRetSeq.realloc( nDialogCounter ); 2310 return aRetSeq; 2311 } 2312 2313 sal_Bool DialogContainer_Impl::hasByName( const ::rtl::OUString& aName ) 2314 throw(RuntimeException) 2315 { 2316 sal_Bool bRet = sal_False; 2317 SbxVariable* pVar = mpLib->GetObjects()->Find( aName, SbxCLASS_DONTCARE ); 2318 if( pVar && pVar->ISA( SbxObject ) && 2319 ( ((SbxObject*)pVar)->GetSbxId() == SBXID_DIALOG ) ) 2320 { 2321 bRet = sal_True; 2322 } 2323 return bRet; 2324 } 2325 2326 2327 // Methods XNameReplace 2328 void DialogContainer_Impl::replaceByName( const ::rtl::OUString& aName, const Any& aElement ) 2329 throw(IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException) 2330 { 2331 removeByName( aName ); 2332 insertByName( aName, aElement ); 2333 } 2334 2335 2336 // Methods XNameContainer 2337 void DialogContainer_Impl::insertByName( const ::rtl::OUString& aName, const Any& aElement ) 2338 throw(IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException) 2339 { 2340 (void)aName; 2341 Type aModuleType = ::getCppuType( (const Reference< XStarBasicDialogInfo > *)0 ); 2342 Type aAnyType = aElement.getValueType(); 2343 if( aModuleType != aAnyType ) 2344 throw IllegalArgumentException(); 2345 Reference< XStarBasicDialogInfo > xMod; 2346 aElement >>= xMod; 2347 SbxObjectRef xDialog = implCreateDialog( xMod->getData() ); 2348 mpLib->Insert( xDialog ); 2349 } 2350 2351 void DialogContainer_Impl::removeByName( const ::rtl::OUString& Name ) 2352 throw(NoSuchElementException, WrappedTargetException, RuntimeException) 2353 { 2354 (void)Name; 2355 SbxVariable* pVar = mpLib->GetObjects()->Find( Name, SbxCLASS_DONTCARE ); 2356 if( !( pVar && pVar->ISA( SbxObject ) && 2357 ( ((SbxObject*)pVar)->GetSbxId() == SBXID_DIALOG ) ) ) 2358 { 2359 throw NoSuchElementException(); 2360 } 2361 mpLib->Remove( pVar ); 2362 } 2363 2364 2365 //===================================================================== 2366 2367 2368 class LibraryContainer_Impl : public NameContainerHelper 2369 { 2370 BasicManager* mpMgr; 2371 2372 public: 2373 LibraryContainer_Impl( BasicManager* pMgr ) 2374 :mpMgr( pMgr ) {} 2375 2376 // Methods XElementAccess 2377 virtual Type SAL_CALL getElementType() 2378 throw(RuntimeException); 2379 virtual sal_Bool SAL_CALL hasElements() 2380 throw(RuntimeException); 2381 2382 // Methods XNameAccess 2383 virtual Any SAL_CALL getByName( const ::rtl::OUString& aName ) 2384 throw(NoSuchElementException, WrappedTargetException, RuntimeException); 2385 virtual Sequence< ::rtl::OUString > SAL_CALL getElementNames() 2386 throw(RuntimeException); 2387 virtual sal_Bool SAL_CALL hasByName( const ::rtl::OUString& aName ) 2388 throw(RuntimeException); 2389 2390 // Methods XNameReplace 2391 virtual void SAL_CALL replaceByName( const ::rtl::OUString& aName, const Any& aElement ) 2392 throw(IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException); 2393 2394 // Methods XNameContainer 2395 virtual void SAL_CALL insertByName( const ::rtl::OUString& aName, const Any& aElement ) 2396 throw(IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException); 2397 virtual void SAL_CALL removeByName( const ::rtl::OUString& Name ) 2398 throw(NoSuchElementException, WrappedTargetException, RuntimeException); 2399 }; 2400 2401 2402 // Methods XElementAccess 2403 Type LibraryContainer_Impl::getElementType() 2404 throw(RuntimeException) 2405 { 2406 Type aType = ::getCppuType( (const Reference< XStarBasicLibraryInfo > *)0 ); 2407 return aType; 2408 } 2409 2410 sal_Bool LibraryContainer_Impl::hasElements() 2411 throw(RuntimeException) 2412 { 2413 sal_Int32 nLibs = mpMgr->GetLibCount(); 2414 sal_Bool bRet = (nLibs > 0); 2415 return bRet; 2416 } 2417 2418 // Methods XNameAccess 2419 Any LibraryContainer_Impl::getByName( const ::rtl::OUString& aName ) 2420 throw(NoSuchElementException, WrappedTargetException, RuntimeException) 2421 { 2422 Any aRetAny; 2423 if( !mpMgr->HasLib( aName ) ) 2424 throw NoSuchElementException(); 2425 StarBASIC* pLib = mpMgr->GetLib( aName ); 2426 2427 Reference< XNameContainer > xModuleContainer = 2428 (XNameContainer*)new ModuleContainer_Impl( pLib ); 2429 2430 Reference< XNameContainer > xDialogContainer; 2431 (XNameContainer*)new DialogContainer_Impl( pLib ); 2432 2433 BasicLibInfo* pLibInfo = mpMgr->FindLibInfo( pLib ); 2434 2435 ::rtl::OUString aPassword = pLibInfo->GetPassword(); 2436 2437 // TODO Only provide extern info! 2438 ::rtl::OUString aExternaleSourceURL; 2439 ::rtl::OUString aLinkTargetURL; 2440 if( pLibInfo->IsReference() ) 2441 aLinkTargetURL = pLibInfo->GetStorageName(); 2442 else if( pLibInfo->IsExtern() ) 2443 aExternaleSourceURL = pLibInfo->GetStorageName(); 2444 2445 Reference< XStarBasicLibraryInfo > xLibInfo = new LibraryInfo_Impl 2446 ( 2447 aName, 2448 xModuleContainer, 2449 xDialogContainer, 2450 aPassword, 2451 aExternaleSourceURL, 2452 aLinkTargetURL 2453 ); 2454 2455 aRetAny <<= xLibInfo; 2456 return aRetAny; 2457 } 2458 2459 Sequence< ::rtl::OUString > LibraryContainer_Impl::getElementNames() 2460 throw(RuntimeException) 2461 { 2462 sal_uInt16 nLibs = mpMgr->GetLibCount(); 2463 Sequence< ::rtl::OUString > aRetSeq( nLibs ); 2464 ::rtl::OUString* pRetSeq = aRetSeq.getArray(); 2465 for( sal_uInt16 i = 0 ; i < nLibs ; i++ ) 2466 { 2467 pRetSeq[i] = ::rtl::OUString( mpMgr->GetLibName( i ) ); 2468 } 2469 return aRetSeq; 2470 } 2471 2472 sal_Bool LibraryContainer_Impl::hasByName( const ::rtl::OUString& aName ) 2473 throw(RuntimeException) 2474 { 2475 sal_Bool bRet = mpMgr->HasLib( aName ); 2476 return bRet; 2477 } 2478 2479 // Methods XNameReplace 2480 void LibraryContainer_Impl::replaceByName( const ::rtl::OUString& aName, const Any& aElement ) 2481 throw(IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException) 2482 { 2483 removeByName( aName ); 2484 insertByName( aName, aElement ); 2485 } 2486 2487 // Methods XNameContainer 2488 void LibraryContainer_Impl::insertByName( const ::rtl::OUString& aName, const Any& aElement ) 2489 throw(IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException) 2490 { 2491 (void)aName; 2492 (void)aElement; 2493 // TODO: Insert a complete Library?! 2494 } 2495 2496 void LibraryContainer_Impl::removeByName( const ::rtl::OUString& Name ) 2497 throw(NoSuchElementException, WrappedTargetException, RuntimeException) 2498 { 2499 StarBASIC* pLib = mpMgr->GetLib( Name ); 2500 if( !pLib ) 2501 throw NoSuchElementException(); 2502 sal_uInt16 nLibId = mpMgr->GetLibId( Name ); 2503 mpMgr->RemoveLib( nLibId ); 2504 } 2505 2506 //===================================================================== 2507 2508 typedef WeakImplHelper1< XStarBasicAccess > StarBasicAccessHelper; 2509 2510 2511 class StarBasicAccess_Impl : public StarBasicAccessHelper 2512 { 2513 BasicManager* mpMgr; 2514 Reference< XNameContainer > mxLibContainer; 2515 2516 public: 2517 StarBasicAccess_Impl( BasicManager* pMgr ) 2518 :mpMgr( pMgr ) {} 2519 2520 public: 2521 2522 // Methods 2523 virtual Reference< XNameContainer > SAL_CALL getLibraryContainer() 2524 throw(RuntimeException); 2525 virtual void SAL_CALL createLibrary( const ::rtl::OUString& LibName, const ::rtl::OUString& Password, 2526 const ::rtl::OUString& ExternalSourceURL, const ::rtl::OUString& LinkTargetURL ) 2527 throw(ElementExistException, RuntimeException); 2528 virtual void SAL_CALL addModule( const ::rtl::OUString& LibraryName, const ::rtl::OUString& ModuleName, 2529 const ::rtl::OUString& Language, const ::rtl::OUString& Source ) 2530 throw(NoSuchElementException, RuntimeException); 2531 virtual void SAL_CALL addDialog( const ::rtl::OUString& LibraryName, const ::rtl::OUString& DialogName, 2532 const Sequence< sal_Int8 >& Data ) 2533 throw(NoSuchElementException, RuntimeException); 2534 2535 }; 2536 2537 Reference< XNameContainer > SAL_CALL StarBasicAccess_Impl::getLibraryContainer() 2538 throw(RuntimeException) 2539 { 2540 if( !mxLibContainer.is() ) 2541 mxLibContainer = (XNameContainer*)new LibraryContainer_Impl( mpMgr ); 2542 return mxLibContainer; 2543 } 2544 2545 void SAL_CALL StarBasicAccess_Impl::createLibrary 2546 ( 2547 const ::rtl::OUString& LibName, 2548 const ::rtl::OUString& Password, 2549 const ::rtl::OUString& ExternalSourceURL, 2550 const ::rtl::OUString& LinkTargetURL 2551 ) 2552 throw(ElementExistException, RuntimeException) 2553 { 2554 (void)ExternalSourceURL; 2555 #ifdef DBG_UTIL 2556 StarBASIC* pLib = 2557 #endif 2558 mpMgr->CreateLib( LibName, Password, LinkTargetURL ); 2559 DBG_ASSERT( pLib, "XML Import: Basic library could not be created"); 2560 } 2561 2562 void SAL_CALL StarBasicAccess_Impl::addModule 2563 ( 2564 const ::rtl::OUString& LibraryName, 2565 const ::rtl::OUString& ModuleName, 2566 const ::rtl::OUString& Language, 2567 const ::rtl::OUString& Source 2568 ) 2569 throw(NoSuchElementException, RuntimeException) 2570 { 2571 (void)Language; 2572 StarBASIC* pLib = mpMgr->GetLib( LibraryName ); 2573 DBG_ASSERT( pLib, "XML Import: Lib for module unknown"); 2574 if( pLib ) 2575 pLib->MakeModule32( ModuleName, Source ); 2576 } 2577 2578 void SAL_CALL StarBasicAccess_Impl::addDialog 2579 ( 2580 const ::rtl::OUString& LibraryName, 2581 const ::rtl::OUString& DialogName, 2582 const Sequence< sal_Int8 >& Data 2583 ) 2584 throw(NoSuchElementException, RuntimeException) 2585 { 2586 (void)LibraryName; 2587 (void)DialogName; 2588 (void)Data; 2589 } 2590 2591 // Basic XML Import/Export 2592 Reference< XStarBasicAccess > getStarBasicAccess( BasicManager* pMgr ) 2593 { 2594 Reference< XStarBasicAccess > xRet = 2595 new StarBasicAccess_Impl( (BasicManager*)pMgr ); 2596 return xRet; 2597 } 2598 2599