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