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