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