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