?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fdo#74697 Add Bluez 5 support for impress remote.
[LibreOffice.git] / basic / source / classes / sb.cxx
blob09746adfe1316d0570d27c0de195a35c47d10f3d
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
21 #include <stdio.h>
22
23 #include "sb.hxx"
24 #include <tools/rcid.h>
25 #include <tools/stream.hxx>
26 #include <tools/errinf.hxx>
27 #include <basic/sbx.hxx>
28 #include <tools/rc.hxx>
29 #include <vcl/svapp.hxx>
30 #include <comphelper/processfactory.hxx>
31 #include "image.hxx"
32 #include "sbunoobj.hxx"
33 #include "sbjsmeth.hxx"
34 #include "sbjsmod.hxx"
35 #include "sbintern.hxx"
36 #include "runtime.hxx"
37 #include <basic/sbuno.hxx>
38 #include <basic/sbobjmod.hxx>
39 #include "stdobj.hxx"
40 #include "filefmt.hxx"
41 #include "sb.hrc"
42 #include <basrid.hxx>
43 #include <osl/mutex.hxx>
44 #include <cppuhelper/implbase1.hxx>
45 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
46 #include <com/sun/star/util/XCloseBroadcaster.hpp>
47 #include <com/sun/star/util/XCloseListener.hpp>
48 #include "errobject.hxx"
49 #include <boost/unordered_map.hpp>
50
51 #include <com/sun/star/script/ModuleType.hpp>
52 #include <com/sun/star/script/ModuleInfo.hpp>
53 using namespace ::com::sun::star::script;
54
55 TYPEINIT1(StarBASIC,SbxObject)
56
57 #define RTLNAME "@SBRTL"
58 // i#i68894#
59 using namespace ::com::sun::star;
60 using namespace ::com::sun::star::uno;
61 using com::sun::star::uno::Reference;
62 using com::sun::star::uno::Any;
63 using com::sun::star::uno::UNO_QUERY;
64 using com::sun::star::lang::XMultiServiceFactory;
65
66 // ============================================================================
67
68 class DocBasicItem : public ::cppu::WeakImplHelper1< util::XCloseListener >
69 {
70 public:
71 explicit DocBasicItem( StarBASIC& rDocBasic );
72 virtual ~DocBasicItem();
73
74 inline const SbxObjectRef& getClassModules() const { return mxClassModules; }
75 inline bool isDocClosed() const { return mbDocClosed; }
76
77 void clearDependingVarsOnDelete( StarBASIC& rDeletedBasic );
78
79 void startListening();
80 void stopListening();
81
82 virtual void SAL_CALL queryClosing( const lang::EventObject& rSource, sal_Bool bGetsOwnership ) throw (util::CloseVetoException, uno::RuntimeException);
83 virtual void SAL_CALL notifyClosing( const lang::EventObject& rSource ) throw (uno::RuntimeException);
84 virtual void SAL_CALL disposing( const lang::EventObject& rSource ) throw (uno::RuntimeException);
85
86 private:
87 StarBASIC& mrDocBasic;
88 SbxObjectRef mxClassModules;
89 bool mbDocClosed;
90 bool mbDisposed;
91 };
92
93 // ----------------------------------------------------------------------------
94
95 DocBasicItem::DocBasicItem( StarBASIC& rDocBasic ) :
96 mrDocBasic( rDocBasic ),
97 mxClassModules( new SbxObject( OUString() ) ),
98 mbDocClosed( false ),
99 mbDisposed( false )
100 {
101 }
102
103 DocBasicItem::~DocBasicItem()
104 {
105 stopListening();
106 }
107
108 void DocBasicItem::clearDependingVarsOnDelete( StarBASIC& rDeletedBasic )
109 {
110 mrDocBasic.implClearDependingVarsOnDelete( &rDeletedBasic );
111 }
112
113 void DocBasicItem::startListening()
114 {
115 Any aThisComp;
116 mrDocBasic.GetUNOConstant( "ThisComponent", aThisComp );
117 Reference< util::XCloseBroadcaster > xCloseBC( aThisComp, UNO_QUERY );
118 mbDisposed = !xCloseBC.is();
119 if( xCloseBC.is() )
120 {
121 try { xCloseBC->addCloseListener( this ); } catch(const uno::Exception& ) {}
122 }
123 }
124
125 void DocBasicItem::stopListening()
126 {
127 if( mbDisposed ) return;
128 mbDisposed = true;
129 Any aThisComp;
130 mrDocBasic.GetUNOConstant( "ThisComponent", aThisComp );
131 Reference< util::XCloseBroadcaster > xCloseBC( aThisComp, UNO_QUERY );
132 if( xCloseBC.is() )
133 {
134 try { xCloseBC->removeCloseListener( this ); } catch(const uno::Exception& ) {}
135 }
136 }
137
138 void SAL_CALL DocBasicItem::queryClosing( const lang::EventObject& /*rSource*/, sal_Bool /*bGetsOwnership*/ ) throw (util::CloseVetoException, uno::RuntimeException)
139 {
140 }
141
142 void SAL_CALL DocBasicItem::notifyClosing( const lang::EventObject& /*rEvent*/ ) throw (uno::RuntimeException)
143 {
144 stopListening();
145 mbDocClosed = true;
146 }
147
148 void SAL_CALL DocBasicItem::disposing( const lang::EventObject& /*rEvent*/ ) throw (uno::RuntimeException)
149 {
150 stopListening();
151 }
152
153 // ----------------------------------------------------------------------------
154
155 namespace {
156
157 typedef ::rtl::Reference< DocBasicItem > DocBasicItemRef;
158 typedef boost::unordered_map< const StarBASIC *, DocBasicItemRef > DocBasicItemMap;
159
160 class GaDocBasicItems : public rtl::Static<DocBasicItemMap,GaDocBasicItems> {};
161
162 const DocBasicItem* lclFindDocBasicItem( const StarBASIC* pDocBasic )
163 {
164 DocBasicItemMap::iterator it = GaDocBasicItems::get().find( pDocBasic );
165 DocBasicItemMap::iterator end = GaDocBasicItems::get().end();
166 return (it != end) ? it->second.get() : 0;
167 }
168
169 void lclInsertDocBasicItem( StarBASIC& rDocBasic )
170 {
171 DocBasicItemRef& rxDocBasicItem = GaDocBasicItems::get()[ &rDocBasic ];
172 rxDocBasicItem.set( new DocBasicItem( rDocBasic ) );
173 rxDocBasicItem->startListening();
174 }
175
176 void lclRemoveDocBasicItem( StarBASIC& rDocBasic )
177 {
178 DocBasicItemMap::iterator it = GaDocBasicItems::get().find( &rDocBasic );
179 if( it != GaDocBasicItems::get().end() )
180 {
181 it->second->stopListening();
182 GaDocBasicItems::get().erase( it );
183 }
184 DocBasicItemMap::iterator it_end = GaDocBasicItems::get().end();
185 for( it = GaDocBasicItems::get().begin(); it != it_end; ++it )
186 {
187 it->second->clearDependingVarsOnDelete( rDocBasic );
188 }
189 }
190
191 StarBASIC* lclGetDocBasicForModule( SbModule* pModule )
192 {
193 StarBASIC* pRetBasic = NULL;
194 SbxObject* pCurParent = pModule;
195 while( pCurParent->GetParent() != NULL )
196 {
197 pCurParent = pCurParent->GetParent();
198 StarBASIC* pDocBasic = PTR_CAST( StarBASIC, pCurParent );
199 if( pDocBasic != NULL && pDocBasic->IsDocBasic() )
200 {
201 pRetBasic = pDocBasic;
202 break;
203 }
204 }
205 return pRetBasic;
206 }
207
208 } // namespace
209
210 // ============================================================================
211
212 SbxObject* StarBASIC::getVBAGlobals( )
213 {
214 if ( !pVBAGlobals )
215 {
216 Any aThisDoc;
217 if ( GetUNOConstant("ThisComponent", aThisDoc) )
218 {
219 Reference< XMultiServiceFactory > xDocFac( aThisDoc, UNO_QUERY );
220 if ( xDocFac.is() )
221 {
222 try
223 {
224 xDocFac->createInstance( OUString( "ooo.vba.VBAGlobals" ) );
225 }
226 catch(const Exception& )
227 {
228 // Ignore
229 }
230 }
231 }
232 const OUString aVBAHook("VBAGlobals");
233 pVBAGlobals = (SbUnoObject*)Find( aVBAHook , SbxCLASS_DONTCARE );
234 }
235 return pVBAGlobals;
236 }
237
238 // i#i68894#
239 SbxVariable* StarBASIC::VBAFind( const OUString& rName, SbxClassType t )
240 {
241 if( rName == "ThisComponent" )
242 {
243 return NULL;
244 }
245 // rename to init globals
246 if ( getVBAGlobals( ) )
247 {
248 return pVBAGlobals->Find( rName, t );
249 }
250 return NULL;
251 }
252
253 // Create array for conversion SFX <-> VB error code
254 struct SFX_VB_ErrorItem
255 {
256 sal_uInt16 nErrorVB;
257 SbError nErrorSFX;
258 };
259
260 const SFX_VB_ErrorItem SFX_VB_ErrorTab[] =
261 {
262 { 1, SbERR_BASIC_EXCEPTION }, // #87844 Map exception to error code 1
263 { 2, SbERR_SYNTAX },
264 { 3, SbERR_NO_GOSUB },
265 { 4, SbERR_REDO_FROM_START },
266 { 5, SbERR_BAD_ARGUMENT },
267 { 6, SbERR_MATH_OVERFLOW },
268 { 7, SbERR_NO_MEMORY },
269 { 8, SbERR_ALREADY_DIM },
270 { 9, SbERR_OUT_OF_RANGE },
271 { 10, SbERR_DUPLICATE_DEF },
272 { 11, SbERR_ZERODIV },
273 { 12, SbERR_VAR_UNDEFINED },
274 { 13, SbERR_CONVERSION },
275 { 14, SbERR_BAD_PARAMETER },
276 { 18, SbERR_USER_ABORT },
277 { 20, SbERR_BAD_RESUME },
278 { 28, SbERR_STACK_OVERFLOW },
279 { 35, SbERR_PROC_UNDEFINED },
280 { 48, SbERR_BAD_DLL_LOAD },
281 { 49, SbERR_BAD_DLL_CALL },
282 { 51, SbERR_INTERNAL_ERROR },
283 { 52, SbERR_BAD_CHANNEL },
284 { 53, SbERR_FILE_NOT_FOUND },
285 { 54, SbERR_BAD_FILE_MODE },
286 { 55, SbERR_FILE_ALREADY_OPEN },
287 { 57, SbERR_IO_ERROR },
288 { 58, SbERR_FILE_EXISTS },
289 { 59, SbERR_BAD_RECORD_LENGTH },
290 { 61, SbERR_DISK_FULL },
291 { 62, SbERR_READ_PAST_EOF },
292 { 63, SbERR_BAD_RECORD_NUMBER },
293 { 67, SbERR_TOO_MANY_FILES },
294 { 68, SbERR_NO_DEVICE },
295 { 70, SbERR_ACCESS_DENIED },
296 { 71, SbERR_NOT_READY },
297 { 73, SbERR_NOT_IMPLEMENTED },
298 { 74, SbERR_DIFFERENT_DRIVE },
299 { 75, SbERR_ACCESS_ERROR },
300 { 76, SbERR_PATH_NOT_FOUND },
301 { 91, SbERR_NO_OBJECT },
302 { 93, SbERR_BAD_PATTERN },
303 { 94, SBERR_IS_NULL },
304 { 250, SbERR_DDE_ERROR },
305 { 280, SbERR_DDE_WAITINGACK },
306 { 281, SbERR_DDE_OUTOFCHANNELS },
307 { 282, SbERR_DDE_NO_RESPONSE },
308 { 283, SbERR_DDE_MULT_RESPONSES },
309 { 284, SbERR_DDE_CHANNEL_LOCKED },
310 { 285, SbERR_DDE_NOTPROCESSED },
311 { 286, SbERR_DDE_TIMEOUT },
312 { 287, SbERR_DDE_USER_INTERRUPT },
313 { 288, SbERR_DDE_BUSY },
314 { 289, SbERR_DDE_NO_DATA },
315 { 290, SbERR_DDE_WRONG_DATA_FORMAT },
316 { 291, SbERR_DDE_PARTNER_QUIT },
317 { 292, SbERR_DDE_CONV_CLOSED },
318 { 293, SbERR_DDE_NO_CHANNEL },
319 { 294, SbERR_DDE_INVALID_LINK },
320 { 295, SbERR_DDE_QUEUE_OVERFLOW },
321 { 296, SbERR_DDE_LINK_ALREADY_EST },
322 { 297, SbERR_DDE_LINK_INV_TOPIC },
323 { 298, SbERR_DDE_DLL_NOT_FOUND },
324 { 323, SbERR_CANNOT_LOAD },
325 { 341, SbERR_BAD_INDEX },
326 { 366, SbERR_NO_ACTIVE_OBJECT },
327 { 380, SbERR_BAD_PROP_VALUE },
328 { 382, SbERR_PROP_READONLY },
329 { 394, SbERR_PROP_WRITEONLY },
330 { 420, SbERR_INVALID_OBJECT },
331 { 423, SbERR_NO_METHOD },
332 { 424, SbERR_NEEDS_OBJECT },
333 { 425, SbERR_INVALID_USAGE_OBJECT },
334 { 430, SbERR_NO_OLE },
335 { 438, SbERR_BAD_METHOD },
336 { 440, SbERR_OLE_ERROR },
337 { 445, SbERR_BAD_ACTION },
338 { 446, SbERR_NO_NAMED_ARGS },
339 { 447, SbERR_BAD_LOCALE },
340 { 448, SbERR_NAMED_NOT_FOUND },
341 { 449, SbERR_NOT_OPTIONAL },
342 { 450, SbERR_WRONG_ARGS },
343 { 451, SbERR_NOT_A_COLL },
344 { 452, SbERR_BAD_ORDINAL },
345 { 453, SbERR_DLLPROC_NOT_FOUND },
346 { 460, SbERR_BAD_CLIPBD_FORMAT },
347 { 951, SbERR_UNEXPECTED },
348 { 952, SbERR_EXPECTED },
349 { 953, SbERR_SYMBOL_EXPECTED },
350 { 954, SbERR_VAR_EXPECTED },
351 { 955, SbERR_LABEL_EXPECTED },
352 { 956, SbERR_LVALUE_EXPECTED },
353 { 957, SbERR_VAR_DEFINED },
354 { 958, SbERR_PROC_DEFINED },
355 { 959, SbERR_LABEL_DEFINED },
356 { 960, SbERR_UNDEF_VAR },
357 { 961, SbERR_UNDEF_ARRAY },
358 { 962, SbERR_UNDEF_PROC },
359 { 963, SbERR_UNDEF_LABEL },
360 { 964, SbERR_UNDEF_TYPE },
361 { 965, SbERR_BAD_EXIT },
362 { 966, SbERR_BAD_BLOCK },
363 { 967, SbERR_BAD_BRACKETS },
364 { 968, SbERR_BAD_DECLARATION },
365 { 969, SbERR_BAD_PARAMETERS },
366 { 970, SbERR_BAD_CHAR_IN_NUMBER },
367 { 971, SbERR_MUST_HAVE_DIMS },
368 { 972, SbERR_NO_IF },
369 { 973, SbERR_NOT_IN_SUBR },
370 { 974, SbERR_NOT_IN_MAIN },
371 { 975, SbERR_WRONG_DIMS },
372 { 976, SbERR_BAD_OPTION },
373 { 977, SbERR_CONSTANT_REDECLARED },
374 { 978, SbERR_PROG_TOO_LARGE },
375 { 979, SbERR_NO_STRINGS_ARRAYS },
376 { 1000, SbERR_PROPERTY_NOT_FOUND },
377 { 1001, SbERR_METHOD_NOT_FOUND },
378 { 1002, SbERR_ARG_MISSING },
379 { 1003, SbERR_BAD_NUMBER_OF_ARGS },
380 { 1004, SbERR_METHOD_FAILED },
381 { 1005, SbERR_SETPROP_FAILED },
382 { 1006, SbERR_GETPROP_FAILED },
383 { 1007, SbERR_BASIC_COMPAT },
384 { 0xFFFF, 0xFFFFFFFFL } // End mark
385 };
386
387 // The StarBASIC factory is a hack. When a SbModule is created, its pointer
388 // is saved and given to the following SbProperties/SbMethods. This restores
389 // the Modul-relationshop. But it works only when a modul is loaded.
390 // Can cause troubles with separately loaded properties!
391
392 SbxBase* SbiFactory::Create( sal_uInt16 nSbxId, sal_uInt32 nCreator )
393 {
394 if( nCreator == SBXCR_SBX )
395 {
396 OUString aEmpty;
397 switch( nSbxId )
398 {
399 case SBXID_BASIC:
400 return new StarBASIC( NULL );
401 case SBXID_BASICMOD:
402 return new SbModule( aEmpty );
403 case SBXID_BASICPROP:
404 return new SbProperty( aEmpty, SbxVARIANT, NULL );
405 case SBXID_BASICMETHOD:
406 return new SbMethod( aEmpty, SbxVARIANT, NULL );
407 case SBXID_JSCRIPTMOD:
408 return new SbJScriptModule( aEmpty );
409 case SBXID_JSCRIPTMETH:
410 return new SbJScriptMethod( aEmpty, SbxVARIANT, NULL );
411 }
412 }
413 return NULL;
414 }
415
416 SbxObject* SbiFactory::CreateObject( const OUString& rClass )
417 {
418 if( rClass.equalsIgnoreAsciiCase( "StarBASIC" ) )
419 {
420 return new StarBASIC( NULL );
421 }
422 else if( rClass.equalsIgnoreAsciiCase( "StarBASICModule" ) )
423 {
424 return new SbModule( OUString() );
425 }
426 else if( rClass.equalsIgnoreAsciiCase( "Collection" ) )
427 {
428 return new BasicCollection( OUString("Collection"));
429 }
430 else if( rClass.equalsIgnoreAsciiCase( "FileSystemObject" ) )
431 {
432 try
433 {
434 Reference< XMultiServiceFactory > xFactory( comphelper::getProcessServiceFactory(), UNO_SET_THROW );
435 OUString aServiceName("ooo.vba.FileSystemObject");
436 Reference< XInterface > xInterface( xFactory->createInstance( aServiceName ), UNO_SET_THROW );
437 return new SbUnoObject( aServiceName, uno::makeAny( xInterface ) );
438 }
439 catch(const Exception& )
440 {
441 }
442 }
443 return NULL;
444 }
445
446
447 // Factory class to create OLE objects
448 class SbOLEFactory : public SbxFactory
449 {
450 public:
451 virtual SbxBase* Create( sal_uInt16 nSbxId, sal_uInt32 = SBXCR_SBX );
452 virtual SbxObject* CreateObject( const OUString& );
453 };
454
455 SbxBase* SbOLEFactory::Create( sal_uInt16, sal_uInt32 )
456 {
457 // Not supported
458 return NULL;
459 }
460
461 SbUnoObject* createOLEObject_Impl( const OUString& aType ); // sbunoobj.cxx
462
463 SbxObject* SbOLEFactory::CreateObject( const OUString& rClassName )
464 {
465 SbxObject* pRet = createOLEObject_Impl( rClassName );
466 return pRet;
467 }
468
469
470 //========================================================================
471 // SbFormFactory, show user forms by: dim as new <user form name>
472
473 class SbFormFactory : public SbxFactory
474 {
475 public:
476 virtual SbxBase* Create( sal_uInt16 nSbxId, sal_uInt32 = SBXCR_SBX );
477 virtual SbxObject* CreateObject( const OUString& );
478 };
479
480 SbxBase* SbFormFactory::Create( sal_uInt16, sal_uInt32 )
481 {
482 // Not supported
483 return NULL;
484 }
485
486 SbxObject* SbFormFactory::CreateObject( const OUString& rClassName )
487 {
488 if( SbModule* pMod = GetSbData()->pMod )
489 {
490 if( SbxVariable* pVar = pMod->Find( rClassName, SbxCLASS_OBJECT ) )
491 {
492 if( SbUserFormModule* pFormModule = PTR_CAST( SbUserFormModule, pVar->GetObject() ) )
493 {
494 bool bInitState = pFormModule->getInitState();
495 if( bInitState )
496 {
497 // Not the first instantiate, reset
498 bool bTriggerTerminateEvent = false;
499 pFormModule->ResetApiObj( bTriggerTerminateEvent );
500 pFormModule->setInitState( false );
501 }
502 else
503 {
504 pFormModule->Load();
505 }
506 return pFormModule->CreateInstance();
507 }
508 }
509 }
510 return 0;
511 }
512
513
514 //========================================================================
515 // SbTypeFactory
516
517 SbxObject* cloneTypeObjectImpl( const SbxObject& rTypeObj )
518 {
519 SbxObject* pRet = new SbxObject( rTypeObj );
520 pRet->PutObject( pRet );
521
522 // Copy the properties, not only the reference to them
523 SbxArray* pProps = pRet->GetProperties();
524 sal_uInt32 nCount = pProps->Count32();
525 for( sal_uInt32 i = 0 ; i < nCount ; i++ )
526 {
527 SbxVariable* pVar = pProps->Get32( i );
528 SbxProperty* pProp = PTR_CAST( SbxProperty, pVar );
529 if( pProp )
530 {
531 SbxProperty* pNewProp = new SbxProperty( *pProp );
532 SbxDataType eVarType = pVar->GetType();
533 if( eVarType & SbxARRAY )
534 {
535 SbxBase* pParObj = pVar->GetObject();
536 SbxDimArray* pSource = PTR_CAST(SbxDimArray,pParObj);
537 SbxDimArray* pDest = new SbxDimArray( pVar->GetType() );
538
539 pDest->setHasFixedSize( pSource->hasFixedSize() );
540 if ( pSource->GetDims() && pSource->hasFixedSize() )
541 {
542 sal_Int32 lb = 0;
543 sal_Int32 ub = 0;
544 for ( sal_Int32 j = 1 ; j <= pSource->GetDims(); ++j )
545 {
546 pSource->GetDim32( (sal_Int32)j, lb, ub );
547 pDest->AddDim32( lb, ub );
548 }
549 }
550 else
551 {
552 pDest->unoAddDim( 0, -1 ); // variant array
553 }
554 sal_uInt16 nSavFlags = pVar->GetFlags();
555 pNewProp->ResetFlag( SBX_FIXED );
556 // need to reset the FIXED flag
557 // when calling PutObject ( because the type will not match Object )
558 pNewProp->PutObject( pDest );
559 pNewProp->SetFlags( nSavFlags );
560 }
561 if( eVarType == SbxOBJECT )
562 {
563 SbxBase* pObjBase = pVar->GetObject();
564 SbxObject* pSrcObj = PTR_CAST(SbxObject,pObjBase);
565 SbxObject* pDestObj = NULL;
566 if( pSrcObj != NULL )
567 pDestObj = cloneTypeObjectImpl( *pSrcObj );
568 pNewProp->PutObject( pDestObj );
569 }
570 pProps->PutDirect( pNewProp, i );
571 }
572 }
573 return pRet;
574 }
575
576 // Factory class to create user defined objects (type command)
577 class SbTypeFactory : public SbxFactory
578 {
579 public:
580 virtual SbxBase* Create( sal_uInt16 nSbxId, sal_uInt32 = SBXCR_SBX );
581 virtual SbxObject* CreateObject( const OUString& );
582 };
583
584 SbxBase* SbTypeFactory::Create( sal_uInt16, sal_uInt32 )
585 {
586 // Not supported
587 return NULL;
588 }
589
590 SbxObject* SbTypeFactory::CreateObject( const OUString& rClassName )
591 {
592 SbxObject* pRet = NULL;
593 SbModule* pMod = GetSbData()->pMod;
594 if( pMod )
595 {
596 const SbxObject* pObj = pMod->FindType( rClassName );
597 if( pObj )
598 {
599 pRet = cloneTypeObjectImpl( *pObj );
600 }
601 }
602 return pRet;
603 }
604
605 SbxObject* createUserTypeImpl( const OUString& rClassName )
606 {
607 SbxObject* pRetObj = GetSbData()->pTypeFac->CreateObject( rClassName );
608 return pRetObj;
609 }
610
611
612 TYPEINIT1(SbClassModuleObject,SbModule)
613
614 SbClassModuleObject::SbClassModuleObject( SbModule* pClassModule )
615 : SbModule( pClassModule->GetName() )
616 , mpClassModule( pClassModule )
617 , mbInitializeEventDone( false )
618 {
619 aOUSource = pClassModule->aOUSource;
620 aComment = pClassModule->aComment;
621 pImage = pClassModule->pImage;
622 pBreaks = pClassModule->pBreaks;
623
624 SetClassName( pClassModule->GetName() );
625
626 // Allow search only internally
627 ResetFlag( SBX_GBLSEARCH );
628
629 // Copy the methods from original class module
630 SbxArray* pClassMethods = pClassModule->GetMethods();
631 sal_uInt32 nMethodCount = pClassMethods->Count32();
632 sal_uInt32 i;
633 for( i = 0 ; i < nMethodCount ; i++ )
634 {
635 SbxVariable* pVar = pClassMethods->Get32( i );
636
637 // Exclude SbIfaceMapperMethod to copy them in a second step
638 SbIfaceMapperMethod* pIfaceMethod = PTR_CAST( SbIfaceMapperMethod, pVar );
639 if( !pIfaceMethod )
640 {
641 SbMethod* pMethod = PTR_CAST(SbMethod, pVar );
642 if( pMethod )
643 {
644 sal_uInt16 nFlags_ = pMethod->GetFlags();
645 pMethod->SetFlag( SBX_NO_BROADCAST );
646 SbMethod* pNewMethod = new SbMethod( *pMethod );
647 pNewMethod->ResetFlag( SBX_NO_BROADCAST );
648 pMethod->SetFlags( nFlags_ );
649 pNewMethod->pMod = this;
650 pNewMethod->SetParent( this );
651 pMethods->PutDirect( pNewMethod, i );
652 StartListening( pNewMethod->GetBroadcaster(), sal_True );
653 }
654 }
655 }
656
657 // Copy SbIfaceMapperMethod in a second step to ensure that
658 // the corresponding base methods have already been copied
659 for( i = 0 ; i < nMethodCount ; i++ )
660 {
661 SbxVariable* pVar = pClassMethods->Get32( i );
662
663 SbIfaceMapperMethod* pIfaceMethod = PTR_CAST( SbIfaceMapperMethod, pVar );
664 if( pIfaceMethod )
665 {
666 SbMethod* pImplMethod = pIfaceMethod->getImplMethod();
667 if( !pImplMethod )
668 {
669 OSL_FAIL( "No ImplMethod" );
670 continue;
671 }
672
673 // Search for own copy of ImplMethod
674 SbxVariable* p = pMethods->Find( pImplMethod->GetName(), SbxCLASS_METHOD );
675 SbMethod* pImplMethodCopy = p ? PTR_CAST(SbMethod,p) : NULL;
676 if( !pImplMethodCopy )
677 {
678 OSL_FAIL( "Found no ImplMethod copy" );
679 continue;
680 }
681 SbIfaceMapperMethod* pNewIfaceMethod =
682 new SbIfaceMapperMethod( pIfaceMethod->GetName(), pImplMethodCopy );
683 pMethods->PutDirect( pNewIfaceMethod, i );
684 }
685 }
686
687 // Copy the properties from original class module
688 SbxArray* pClassProps = pClassModule->GetProperties();
689 sal_uInt32 nPropertyCount = pClassProps->Count32();
690 for( i = 0 ; i < nPropertyCount ; i++ )
691 {
692 SbxVariable* pVar = pClassProps->Get32( i );
693 SbProcedureProperty* pProcedureProp = PTR_CAST( SbProcedureProperty, pVar );
694 if( pProcedureProp )
695 {
696 sal_uInt16 nFlags_ = pProcedureProp->GetFlags();
697 pProcedureProp->SetFlag( SBX_NO_BROADCAST );
698 SbProcedureProperty* pNewProp = new SbProcedureProperty
699 ( pProcedureProp->GetName(), pProcedureProp->GetType() );
700 pNewProp->SetFlags( nFlags_ ); // Copy flags
701 pNewProp->ResetFlag( SBX_NO_BROADCAST ); // except the Broadcast if it was set
702 pProcedureProp->SetFlags( nFlags_ );
703 pProps->PutDirect( pNewProp, i );
704 StartListening( pNewProp->GetBroadcaster(), sal_True );
705 }
706 else
707 {
708 SbxProperty* pProp = PTR_CAST( SbxProperty, pVar );
709 if( pProp )
710 {
711 sal_uInt16 nFlags_ = pProp->GetFlags();
712 pProp->SetFlag( SBX_NO_BROADCAST );
713 SbxProperty* pNewProp = new SbxProperty( *pProp );
714
715 // Special handling for modules instances and collections, they need
716 // to be instantiated, otherwise all refer to the same base object
717 SbxDataType eVarType = pProp->GetType();
718 if( eVarType == SbxOBJECT )
719 {
720 SbxBase* pObjBase = pProp->GetObject();
721 SbxObject* pObj = PTR_CAST(SbxObject,pObjBase);
722 if( pObj != NULL )
723 {
724 OUString aObjClass = pObj->GetClassName();
725
726 SbClassModuleObject* pClassModuleObj = PTR_CAST(SbClassModuleObject,pObjBase);
727 if( pClassModuleObj != NULL )
728 {
729 SbModule* pLclClassModule = pClassModuleObj->getClassModule();
730 SbClassModuleObject* pNewObj = new SbClassModuleObject( pLclClassModule );
731 pNewObj->SetName( pProp->GetName() );
732 pNewObj->SetParent( pLclClassModule->pParent );
733 pNewProp->PutObject( pNewObj );
734 }
735 else if( aObjClass.equalsIgnoreAsciiCase( "Collection" ) )
736 {
737 OUString aCollectionName("Collection");
738 BasicCollection* pNewCollection = new BasicCollection( aCollectionName );
739 pNewCollection->SetName( pProp->GetName() );
740 pNewCollection->SetParent( pClassModule->pParent );
741 pNewProp->PutObject( pNewCollection );
742 }
743 }
744 }
745
746 pNewProp->ResetFlag( SBX_NO_BROADCAST );
747 pNewProp->SetParent( this );
748 pProps->PutDirect( pNewProp, i );
749 pProp->SetFlags( nFlags_ );
750 }
751 }
752 }
753 SetModuleType( ModuleType::CLASS );
754 mbVBACompat = pClassModule->mbVBACompat;
755 }
756
757 SbClassModuleObject::~SbClassModuleObject()
758 {
759 // do not trigger termination event when document is already closed
760 if( StarBASIC::IsRunning() )
761 if( StarBASIC* pDocBasic = lclGetDocBasicForModule( this ) )
762 if( const DocBasicItem* pDocBasicItem = lclFindDocBasicItem( pDocBasic ) )
763 if( !pDocBasicItem->isDocClosed() )
764 triggerTerminateEvent();
765
766 // Must be deleted by base class dtor because this data
767 // is not owned by the SbClassModuleObject object
768 pImage = NULL;
769 pBreaks = NULL;
770 }
771
772 void SbClassModuleObject::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCType,
773 const SfxHint& rHint, const TypeId& rHintType )
774 {
775 handleProcedureProperties( rBC, rHint );
776 }
777
778 SbxVariable* SbClassModuleObject::Find( const OUString& rName, SbxClassType t )
779 {
780 SbxVariable* pRes = SbxObject::Find( rName, t );
781 if( pRes )
782 {
783 triggerInitializeEvent();
784
785 SbIfaceMapperMethod* pIfaceMapperMethod = PTR_CAST(SbIfaceMapperMethod,pRes);
786 if( pIfaceMapperMethod )
787 {
788 pRes = pIfaceMapperMethod->getImplMethod();
789 pRes->SetFlag( SBX_EXTFOUND );
790 }
791 }
792 return pRes;
793 }
794
795 void SbClassModuleObject::triggerInitializeEvent( void )
796 {
797 if( mbInitializeEventDone )
798 {
799 return;
800 }
801
802 mbInitializeEventDone = true;
803
804 // Search method
805 SbxVariable* pMeth = SbxObject::Find(OUString("Class_Initialize"), SbxCLASS_METHOD);
806 if( pMeth )
807 {
808 SbxValues aVals;
809 pMeth->Get( aVals );
810 }
811 }
812
813 void SbClassModuleObject::triggerTerminateEvent( void )
814 {
815 if( !mbInitializeEventDone || GetSbData()->bRunInit )
816 {
817 return;
818 }
819 // Search method
820 SbxVariable* pMeth = SbxObject::Find(OUString("Class_Terminate"), SbxCLASS_METHOD );
821 if( pMeth )
822 {
823 SbxValues aVals;
824 pMeth->Get( aVals );
825 }
826 }
827
828
829 SbClassData::SbClassData( void )
830 {
831 mxIfaces = new SbxArray();
832 }
833
834 void SbClassData::clear( void )
835 {
836 mxIfaces->Clear();
837 maRequiredTypes.clear();
838 }
839
840 SbClassFactory::SbClassFactory( void )
841 {
842 OUString aDummyName;
843 xClassModules = new SbxObject( aDummyName );
844 }
845
846 SbClassFactory::~SbClassFactory()
847 {}
848
849 void SbClassFactory::AddClassModule( SbModule* pClassModule )
850 {
851 SbxObjectRef xToUseClassModules = xClassModules;
852
853 if( StarBASIC* pDocBasic = lclGetDocBasicForModule( pClassModule ) )
854 if( const DocBasicItem* pDocBasicItem = lclFindDocBasicItem( pDocBasic ) )
855 xToUseClassModules = pDocBasicItem->getClassModules();
856
857 SbxObject* pParent = pClassModule->GetParent();
858 xToUseClassModules->Insert( pClassModule );
859 pClassModule->SetParent( pParent );
860 }
861
862 void SbClassFactory::RemoveClassModule( SbModule* pClassModule )
863 {
864 xClassModules->Remove( pClassModule );
865 }
866
867 SbxBase* SbClassFactory::Create( sal_uInt16, sal_uInt32 )
868 {
869 // Not supported
870 return NULL;
871 }
872
873 SbxObject* SbClassFactory::CreateObject( const OUString& rClassName )
874 {
875 SbxObjectRef xToUseClassModules = xClassModules;
876
877 if( SbModule* pMod = GetSbData()->pMod )
878 {
879 if( StarBASIC* pDocBasic = lclGetDocBasicForModule( pMod ) )
880 {
881 if( const DocBasicItem* pDocBasicItem = lclFindDocBasicItem( pDocBasic ) )
882 {
883 xToUseClassModules = pDocBasicItem->getClassModules();
884 }
885 }
886 }
887 SbxVariable* pVar = xToUseClassModules->Find( rClassName, SbxCLASS_OBJECT );
888 SbxObject* pRet = NULL;
889 if( pVar )
890 {
891 SbModule* pVarMod = (SbModule*)pVar;
892 pRet = new SbClassModuleObject( pVarMod );
893 }
894 return pRet;
895 }
896
897 SbModule* SbClassFactory::FindClass( const OUString& rClassName )
898 {
899 SbxVariable* pVar = xClassModules->Find( rClassName, SbxCLASS_DONTCARE );
900 SbModule* pMod = pVar ? (SbModule*)pVar : NULL;
901 return pMod;
902 }
903
904 StarBASIC::StarBASIC( StarBASIC* p, bool bIsDocBasic )
905 : SbxObject( OUString("StarBASIC") ), bDocBasic( bIsDocBasic )
906 {
907 SetParent( p );
908 pLibInfo = NULL;
909 bNoRtl = bBreak = false;
910 bVBAEnabled = false;
911 pModules = new SbxArray;
912
913 if( !GetSbData()->nInst++ )
914 {
915 GetSbData()->pSbFac = new SbiFactory;
916 AddFactory( GetSbData()->pSbFac );
917 GetSbData()->pTypeFac = new SbTypeFactory;
918 AddFactory( GetSbData()->pTypeFac );
919 GetSbData()->pClassFac = new SbClassFactory;
920 AddFactory( GetSbData()->pClassFac );
921 GetSbData()->pOLEFac = new SbOLEFactory;
922 AddFactory( GetSbData()->pOLEFac );
923 GetSbData()->pFormFac = new SbFormFactory;
924 AddFactory( GetSbData()->pFormFac );
925 GetSbData()->pUnoFac = new SbUnoFactory;
926 AddFactory( GetSbData()->pUnoFac );
927 }
928 pRtl = new SbiStdObject(OUString(RTLNAME), this );
929 // Search via StarBasic is always global
930 SetFlag( SBX_GBLSEARCH );
931 pVBAGlobals = NULL;
932 bQuit = false;
933
934 if( bDocBasic )
935 {
936 lclInsertDocBasicItem( *this );
937 }
938 }
939
940 // #51727 Override SetModified so that the modified state
941 // is not given to the parent
942 void StarBASIC::SetModified( sal_Bool b )
943 {
944 SbxBase::SetModified( b );
945 }
946
947 StarBASIC::~StarBASIC()
948 {
949 // Needs to be first action as it can trigger events
950 disposeComVariablesForBasic( this );
951
952 if( !--GetSbData()->nInst )
953 {
954 RemoveFactory( GetSbData()->pSbFac );
955 delete GetSbData()->pSbFac; GetSbData()->pSbFac = NULL;
956 RemoveFactory( GetSbData()->pUnoFac );
957 delete GetSbData()->pUnoFac; GetSbData()->pUnoFac = NULL;
958 RemoveFactory( GetSbData()->pTypeFac );
959 delete GetSbData()->pTypeFac; GetSbData()->pTypeFac = NULL;
960 RemoveFactory( GetSbData()->pClassFac );
961 delete GetSbData()->pClassFac; GetSbData()->pClassFac = NULL;
962 RemoveFactory( GetSbData()->pOLEFac );
963 delete GetSbData()->pOLEFac; GetSbData()->pOLEFac = NULL;
964 RemoveFactory( GetSbData()->pFormFac );
965 delete GetSbData()->pFormFac; GetSbData()->pFormFac = NULL;
966
967 if( SbiGlobals::pGlobals )
968 {
969 delete SbiGlobals::pGlobals;
970 SbiGlobals::pGlobals = 0;
971 }
972 }
973 else if( bDocBasic )
974 {
975 SbxError eOld = SbxBase::GetError();
976
977 lclRemoveDocBasicItem( *this );
978
979 SbxBase::ResetError();
980 if( eOld != SbxERR_OK )
981 {
982 SbxBase::SetError( eOld );
983 }
984 }
985
986 // #100326 Set Parent NULL in registered listeners
987 if( xUnoListeners.Is() )
988 {
989 sal_uInt16 uCount = xUnoListeners->Count();
990 for( sal_uInt16 i = 0 ; i < uCount ; i++ )
991 {
992 SbxVariable* pListenerObj = xUnoListeners->Get( i );
993 pListenerObj->SetParent( NULL );
994 }
995 xUnoListeners = NULL;
996 }
997
998 clearUnoMethodsForBasic( this );
999 }
1000
1001 // Override new() operator, so that everyone can create a new instance
1002 void* StarBASIC::operator new( size_t n )
1003 {
1004 if( n < sizeof( StarBASIC ) )
1005 {
1006 n = sizeof( StarBASIC );
1007 }
1008 return ::operator new( n );
1009 }
1010
1011 void StarBASIC::operator delete( void* p )
1012 {
1013 ::operator delete( p );
1014 }
1015
1016 void StarBASIC::implClearDependingVarsOnDelete( StarBASIC* pDeletedBasic )
1017 {
1018 if( this != pDeletedBasic )
1019 {
1020 for( sal_uInt16 i = 0; i < pModules->Count(); i++ )
1021 {
1022 SbModule* p = (SbModule*)pModules->Get( i );
1023 p->ClearVarsDependingOnDeletedBasic( pDeletedBasic );
1024 }
1025 }
1026
1027 for( sal_uInt16 nObj = 0; nObj < pObjs->Count(); nObj++ )
1028 {
1029 SbxVariable* pVar = pObjs->Get( nObj );
1030 StarBASIC* pBasic = PTR_CAST(StarBASIC,pVar);
1031 if( pBasic && pBasic != pDeletedBasic )
1032 {
1033 pBasic->implClearDependingVarsOnDelete( pDeletedBasic );
1034 }
1035 }
1036 }
1037
1038
1039 /**************************************************************************
1040 *
1041 * Creation/Managment of modules
1042 *
1043 **************************************************************************/
1044
1045 SbModule* StarBASIC::MakeModule( const OUString& rName, const OUString& rSrc )
1046 {
1047 return MakeModule32( rName, rSrc );
1048 }
1049
1050 SbModule* StarBASIC::MakeModule32( const OUString& rName, const OUString& rSrc )
1051 {
1052 ModuleInfo mInfo;
1053 mInfo.ModuleType = ModuleType::NORMAL;
1054 return MakeModule32( rName, mInfo, rSrc );
1055 }
1056 SbModule* StarBASIC::MakeModule32( const OUString& rName, const ModuleInfo& mInfo, const OUString& rSrc )
1057 {
1058
1059 OSL_TRACE("create module %s type mInfo %d", OUStringToOString( rName, RTL_TEXTENCODING_UTF8 ).getStr(), mInfo.ModuleType );
1060 SbModule* p = NULL;
1061 switch ( mInfo.ModuleType )
1062 {
1063 case ModuleType::DOCUMENT:
1064 // In theory we should be able to create Object modules
1065 // in ordinary basic ( in vba mode thought these are create
1066 // by the application/basic and not by the user )
1067 p = new SbObjModule( rName, mInfo, isVBAEnabled() );
1068 break;
1069 case ModuleType::CLASS:
1070 p = new SbModule( rName, isVBAEnabled() );
1071 p->SetModuleType( ModuleType::CLASS );
1072 break;
1073 case ModuleType::FORM:
1074 p = new SbUserFormModule( rName, mInfo, isVBAEnabled() );
1075 break;
1076 default:
1077 p = new SbModule( rName, isVBAEnabled() );
1078 break;
1079 }
1080 p->SetSource32( rSrc );
1081 p->SetParent( this );
1082 pModules->Insert( p, pModules->Count() );
1083 SetModified( sal_True );
1084 return p;
1085 }
1086
1087 void StarBASIC::Insert( SbxVariable* pVar )
1088 {
1089 if( pVar->IsA( TYPE(SbModule) ) )
1090 {
1091 pModules->Insert( pVar, pModules->Count() );
1092 pVar->SetParent( this );
1093 StartListening( pVar->GetBroadcaster(), sal_True );
1094 }
1095 else
1096 {
1097 sal_Bool bWasModified = IsModified();
1098 SbxObject::Insert( pVar );
1099 if( !bWasModified && pVar->IsSet( SBX_DONTSTORE ) )
1100 {
1101 SetModified( sal_False );
1102 }
1103 }
1104 }
1105
1106 void StarBASIC::Remove( SbxVariable* pVar )
1107 {
1108 if( pVar->IsA( TYPE(SbModule) ) )
1109 {
1110 // #87540 Can be last reference!
1111 SbxVariableRef xVar = pVar;
1112 pModules->Remove( pVar );
1113 pVar->SetParent( 0 );
1114 EndListening( pVar->GetBroadcaster() );
1115 }
1116 else
1117 {
1118 SbxObject::Remove( pVar );
1119 }
1120 }
1121
1122 sal_Bool StarBASIC::Compile( SbModule* pMod )
1123 {
1124 return pMod ? pMod->Compile() : sal_False;
1125 }
1126
1127 void StarBASIC::Clear()
1128 {
1129 while( pModules->Count() )
1130 {
1131 pModules->Remove( pModules->Count() - 1 );
1132 }
1133 }
1134
1135 SbModule* StarBASIC::FindModule( const OUString& rName )
1136 {
1137 for( sal_uInt16 i = 0; i < pModules->Count(); i++ )
1138 {
1139 SbModule* p = (SbModule*) pModules->Get( i );
1140 if( p->GetName().equalsIgnoreAsciiCase( rName ) )
1141 {
1142 return p;
1143 }
1144 }
1145 return NULL;
1146 }
1147
1148
1149 struct ClassModuleRunInitItem
1150 {
1151 SbModule* m_pModule;
1152 bool m_bProcessing;
1153 bool m_bRunInitDone;
1154
1155 ClassModuleRunInitItem( void )
1156 : m_pModule( NULL )
1157 , m_bProcessing( false )
1158 , m_bRunInitDone( false )
1159 {}
1160 ClassModuleRunInitItem( SbModule* pModule )
1161 : m_pModule( pModule )
1162 , m_bProcessing( false )
1163 , m_bRunInitDone( false )
1164 {}
1165 };
1166
1167 // Derive from unordered_map type instead of typedef
1168 // to allow forward declaration in sbmod.hxx
1169 class ModuleInitDependencyMap : public
1170 boost::unordered_map< OUString, ClassModuleRunInitItem,
1171 OUStringHash, ::std::equal_to< OUString > >
1172 {};
1173
1174 void SbModule::implProcessModuleRunInit( ModuleInitDependencyMap& rMap, ClassModuleRunInitItem& rItem )
1175 {
1176 rItem.m_bProcessing = true;
1177
1178 SbModule* pModule = rItem.m_pModule;
1179 if( pModule->pClassData != NULL )
1180 {
1181 StringVector& rReqTypes = pModule->pClassData->maRequiredTypes;
1182 if( rReqTypes.size() > 0 )
1183 {
1184 for( StringVector::iterator it = rReqTypes.begin() ; it != rReqTypes.end() ; ++it )
1185 {
1186 OUString& rStr = *it;
1187
1188 // Is required type a class module?
1189 ModuleInitDependencyMap::iterator itFind = rMap.find( rStr );
1190 if( itFind != rMap.end() )
1191 {
1192 ClassModuleRunInitItem& rParentItem = itFind->second;
1193 if( rParentItem.m_bProcessing )
1194 {
1195 // TODO: raise error?
1196 OSL_FAIL( "Cyclic module dependency detected" );
1197 continue;
1198 }
1199
1200 if( !rParentItem.m_bRunInitDone )
1201 {
1202 implProcessModuleRunInit( rMap, rParentItem );
1203 }
1204 }
1205 }
1206 }
1207 }
1208
1209 pModule->RunInit();
1210 rItem.m_bRunInitDone = true;
1211 rItem.m_bProcessing = false;
1212 }
1213
1214 // Run Init-Code of all modules (including inserted libraries)
1215 void StarBASIC::InitAllModules( StarBASIC* pBasicNotToInit )
1216 {
1217 SolarMutexGuard guard;
1218
1219 // Init own modules
1220 for ( sal_uInt16 nMod = 0; nMod < pModules->Count(); nMod++ )
1221 {
1222 SbModule* pModule = (SbModule*)pModules->Get( nMod );
1223 if( !pModule->IsCompiled() )
1224 {
1225 pModule->Compile();
1226 }
1227 }
1228 // compile modules first then RunInit ( otherwise there is
1229 // can be order dependency, e.g. classmodule A has a member
1230 // of of type classmodule B and classmodule B hasn't been compiled yet )
1231
1232 // Consider required types to init in right order. Class modules
1233 // that are required by other modules have to be initialized first.
1234 ModuleInitDependencyMap aMIDMap;
1235 for ( sal_uInt16 nMod = 0; nMod < pModules->Count(); nMod++ )
1236 {
1237 SbModule* pModule = (SbModule*)pModules->Get( nMod );
1238 OUString aModuleName = pModule->GetName();
1239 if( pModule->isProxyModule() )
1240 {
1241 aMIDMap[aModuleName] = ClassModuleRunInitItem( pModule );
1242 }
1243 }
1244
1245 ModuleInitDependencyMap::iterator it;
1246 for( it = aMIDMap.begin() ; it != aMIDMap.end(); ++it )
1247 {
1248 ClassModuleRunInitItem& rItem = it->second;
1249 SbModule::implProcessModuleRunInit( aMIDMap, rItem );
1250 }
1251
1252 // Call RunInit on standard modules
1253 for ( sal_uInt16 nMod = 0; nMod < pModules->Count(); nMod++ )
1254 {
1255 SbModule* pModule = (SbModule*)pModules->Get( nMod );
1256 if( !pModule->isProxyModule() )
1257 {
1258 pModule->RunInit();
1259 }
1260 }
1261
1262 // Check all objects if they are BASIC,
1263 // if yes initialize
1264 for ( sal_uInt16 nObj = 0; nObj < pObjs->Count(); nObj++ )
1265 {
1266 SbxVariable* pVar = pObjs->Get( nObj );
1267 StarBASIC* pBasic = PTR_CAST(StarBASIC,pVar);
1268 if( pBasic && pBasic != pBasicNotToInit )
1269 {
1270 pBasic->InitAllModules();
1271 }
1272 }
1273 }
1274
1275 // #88329 Put modules back to not initialised state to
1276 // force reinitialisation at next start
1277 void StarBASIC::DeInitAllModules( void )
1278 {
1279 // Deinit own modules
1280 for ( sal_uInt16 nMod = 0; nMod < pModules->Count(); nMod++ )
1281 {
1282 SbModule* pModule = (SbModule*)pModules->Get( nMod );
1283 if( pModule->pImage && !pModule->isProxyModule() && !pModule->ISA(SbObjModule) )
1284 {
1285 pModule->pImage->bInit = false;
1286 }
1287 }
1288
1289 for ( sal_uInt16 nObj = 0; nObj < pObjs->Count(); nObj++ )
1290 {
1291 SbxVariable* pVar = pObjs->Get( nObj );
1292 StarBASIC* pBasic = PTR_CAST(StarBASIC,pVar);
1293 if( pBasic )
1294 {
1295 pBasic->DeInitAllModules();
1296 }
1297 }
1298 }
1299
1300 // This implementation at first searches within the runtime library,
1301 // then it looks for an element within one module. This moudle can be
1302 // a public var or an entrypoint. If it is not found and we look for a
1303 // method and a module with the given name is found the search continues
1304 // for entrypoint "Main".
1305 // If this fails again a conventional search over objects is performend.
1306 SbxVariable* StarBASIC::Find( const OUString& rName, SbxClassType t )
1307 {
1308 SbxVariable* pRes = NULL;
1309 SbModule* pNamed = NULL;
1310 // "Extended" search in Runtime Lib
1311 // but only if SbiRuntime has not set the flag
1312 if( !bNoRtl )
1313 {
1314 if( t == SbxCLASS_DONTCARE || t == SbxCLASS_OBJECT )
1315 {
1316 if( rName.equalsIgnoreAsciiCase( RTLNAME ) )
1317 {
1318 pRes = pRtl;
1319 }
1320 }
1321 if( !pRes )
1322 {
1323 pRes = ((SbiStdObject*) (SbxObject*) pRtl)->Find( rName, t );
1324 }
1325 if( pRes )
1326 {
1327 pRes->SetFlag( SBX_EXTFOUND );
1328 }
1329 }
1330 // Search module
1331 if( !pRes )
1332 {
1333 for( sal_uInt16 i = 0; i < pModules->Count(); i++ )
1334 {
1335 SbModule* p = (SbModule*) pModules->Get( i );
1336 if( p->IsVisible() )
1337 {
1338 // Remember modul fpr Main() call
1339 // or is the name equal?!?
1340 if( p->GetName().equalsIgnoreAsciiCase( rName ) )
1341 {
1342 if( t == SbxCLASS_OBJECT || t == SbxCLASS_DONTCARE )
1343 {
1344 pRes = p; break;
1345 }
1346 pNamed = p;
1347 }
1348 // Only variables qualified by the Module Name e.g. Sheet1.foo
1349 // should work for Documant && Class type Modules
1350 sal_Int32 nType = p->GetModuleType();
1351 if ( nType == ModuleType::DOCUMENT || nType == ModuleType::FORM )
1352 {
1353 continue;
1354 }
1355 // otherwise check if the element is available
1356 // unset GBLSEARCH-Flag (due to Rekursion)
1357 sal_uInt16 nGblFlag = p->GetFlags() & SBX_GBLSEARCH;
1358 p->ResetFlag( SBX_GBLSEARCH );
1359 pRes = p->Find( rName, t );
1360 p->SetFlag( nGblFlag );
1361 if( pRes )
1362 {
1363 break;
1364 }
1365 }
1366 }
1367 }
1368 OUString aMainStr("Main");
1369 if( !pRes && pNamed && ( t == SbxCLASS_METHOD || t == SbxCLASS_DONTCARE ) &&
1370 !pNamed->GetName().equalsIgnoreAsciiCase( aMainStr ) )
1371 {
1372 pRes = pNamed->Find( aMainStr, SbxCLASS_METHOD );
1373 }
1374 if( !pRes )
1375 {
1376 pRes = SbxObject::Find( rName, t );
1377 }
1378 return pRes;
1379 }
1380
1381 sal_Bool StarBASIC::Call( const OUString& rName, SbxArray* pParam )
1382 {
1383 sal_Bool bRes = SbxObject::Call( rName, pParam );
1384 if( !bRes )
1385 {
1386 SbxError eErr = SbxBase::GetError();
1387 SbxBase::ResetError();
1388 if( eErr != SbxERR_OK )
1389 {
1390 RTError( (SbError)eErr, 0, 0, 0 );
1391 }
1392 }
1393 return bRes;
1394 }
1395
1396 // Find method via name (e.g. query via BASIC IDE)
1397 SbxBase* StarBASIC::FindSBXInCurrentScope( const OUString& rName )
1398 {
1399 if( !GetSbData()->pInst )
1400 {
1401 return NULL;
1402 }
1403 if( !GetSbData()->pInst->pRun )
1404 {
1405 return NULL;
1406 }
1407 return GetSbData()->pInst->pRun->FindElementExtern( rName );
1408 }
1409
1410 void StarBASIC::QuitAndExitApplication()
1411 {
1412 Stop();
1413 bQuit = true;
1414 }
1415
1416 void StarBASIC::Stop()
1417 {
1418 SbiInstance* p = GetSbData()->pInst;
1419 while( p )
1420 {
1421 p->Stop();
1422 p = p->pNext;
1423 }
1424 }
1425
1426 bool StarBASIC::IsRunning()
1427 {
1428 return GetSbData()->pInst != NULL;
1429 }
1430
1431 /**************************************************************************
1432 *
1433 * Debugging and error handling
1434 *
1435 **************************************************************************/
1436
1437 SbMethod* StarBASIC::GetActiveMethod( sal_uInt16 nLevel )
1438 {
1439 if( GetSbData()->pInst )
1440 {
1441 return GetSbData()->pInst->GetCaller( nLevel );
1442 }
1443 else
1444 {
1445 return NULL;
1446 }
1447 }
1448
1449 SbModule* StarBASIC::GetActiveModule()
1450 {
1451 if( GetSbData()->pInst && !IsCompilerError() )
1452 {
1453 return GetSbData()->pInst->GetActiveModule();
1454 }
1455 else
1456 {
1457 return GetSbData()->pCompMod;
1458 }
1459 }
1460
1461 sal_uInt16 StarBASIC::BreakPoint( sal_Int32 l, sal_Int32 c1, sal_Int32 c2 )
1462 {
1463 SetErrorData( 0, l, c1, c2 );
1464 bBreak = true;
1465 if( GetSbData()->aBreakHdl.IsSet() )
1466 {
1467 return (sal_uInt16) GetSbData()->aBreakHdl.Call( this );
1468 }
1469 else
1470 {
1471 return BreakHdl();
1472 }
1473 }
1474
1475 sal_uInt16 StarBASIC::StepPoint( sal_Int32 l, sal_Int32 c1, sal_Int32 c2 )
1476 {
1477 SetErrorData( 0, l, c1, c2 );
1478 bBreak = false;
1479 if( GetSbData()->aBreakHdl.IsSet() )
1480 {
1481 return (sal_uInt16) GetSbData()->aBreakHdl.Call( this );
1482 }
1483 else
1484 {
1485 return BreakHdl();
1486 }
1487 }
1488
1489 sal_uInt16 StarBASIC::BreakHdl()
1490 {
1491 return (sal_uInt16) ( aBreakHdl.IsSet() ? aBreakHdl.Call( this ) : SbDEBUG_CONTINUE );
1492 }
1493
1494 // Calls for error handler and break handler
1495 sal_uInt16 StarBASIC::GetLine() { return GetSbData()->nLine; }
1496 sal_uInt16 StarBASIC::GetCol1() { return GetSbData()->nCol1; }
1497 sal_uInt16 StarBASIC::GetCol2() { return GetSbData()->nCol2; }
1498
1499 // Specific to error handler
1500 SbError StarBASIC::GetErrorCode() { return GetSbData()->nCode; }
1501 const OUString& StarBASIC::GetErrorText() { return GetSbData()->aErrMsg; }
1502 bool StarBASIC::IsCompilerError() { return GetSbData()->bCompiler; }
1503
1504 // From 1996-03-29:
1505 // The mapping between the old and the new error codes take place by searching
1506 // through the table SFX_VB_ErrorTab[]. This is indeed not with good performance,
1507 // but it consumes much less memory than corresponding switch blocs.
1508 // Because the conversion of error codes has not to be fast. there is no
1509 // binary search by VB Error -> Error SFX.
1510
1511 // Map back new error codes to old, Sbx-compatible
1512 sal_uInt16 StarBASIC::GetVBErrorCode( SbError nError )
1513 {
1514 sal_uInt16 nRet = 0;
1515
1516 if( SbiRuntime::isVBAEnabled() )
1517 {
1518 switch( nError )
1519 {
1520 case SbERR_BASIC_ARRAY_FIX:
1521 return 10;
1522 case SbERR_BASIC_STRING_OVERFLOW:
1523 return 14;
1524 case SbERR_BASIC_EXPR_TOO_COMPLEX:
1525 return 16;
1526 case SbERR_BASIC_OPER_NOT_PERFORM:
1527 return 17;
1528 case SbERR_BASIC_TOO_MANY_DLL:
1529 return 47;
1530 case SbERR_BASIC_LOOP_NOT_INIT:
1531 return 92;
1532 default:
1533 nRet = 0;
1534 }
1535 }
1536
1537 // search loop
1538 const SFX_VB_ErrorItem* pErrItem;
1539 sal_uInt16 nIndex = 0;
1540 do
1541 {
1542 pErrItem = SFX_VB_ErrorTab + nIndex;
1543 if( pErrItem->nErrorSFX == nError )
1544 {
1545 nRet = pErrItem->nErrorVB;
1546 break;
1547 }
1548 nIndex++;
1549 }
1550 while( pErrItem->nErrorVB != 0xFFFF ); // up to end mark
1551 return nRet;
1552 }
1553
1554 SbError StarBASIC::GetSfxFromVBError( sal_uInt16 nError )
1555 {
1556 SbError nRet = 0L;
1557
1558 if( SbiRuntime::isVBAEnabled() )
1559 {
1560 switch( nError )
1561 {
1562 case 1:
1563 case 2:
1564 case 4:
1565 case 8:
1566 case 12:
1567 case 73:
1568 return 0L;
1569 case 10:
1570 return SbERR_BASIC_ARRAY_FIX;
1571 case 14:
1572 return SbERR_BASIC_STRING_OVERFLOW;
1573 case 16:
1574 return SbERR_BASIC_EXPR_TOO_COMPLEX;
1575 case 17:
1576 return SbERR_BASIC_OPER_NOT_PERFORM;
1577 case 47:
1578 return SbERR_BASIC_TOO_MANY_DLL;
1579 case 92:
1580 return SbERR_BASIC_LOOP_NOT_INIT;
1581 default:
1582 nRet = 0L;
1583 }
1584 }
1585 const SFX_VB_ErrorItem* pErrItem;
1586 sal_uInt16 nIndex = 0;
1587 do
1588 {
1589 pErrItem = SFX_VB_ErrorTab + nIndex;
1590 if( pErrItem->nErrorVB == nError )
1591 {
1592 nRet = pErrItem->nErrorSFX;
1593 break;
1594 }
1595 else if( pErrItem->nErrorVB > nError )
1596 {
1597 break; // couldn't found anymore
1598 }
1599 nIndex++;
1600 }
1601 while( pErrItem->nErrorVB != 0xFFFF ); // up to end mark
1602 return nRet;
1603 }
1604
1605 // set Error- / Break-data
1606 void StarBASIC::SetErrorData( SbError nCode, sal_uInt16 nLine,
1607 sal_uInt16 nCol1, sal_uInt16 nCol2 )
1608 {
1609 SbiGlobals& aGlobals = *GetSbData();
1610 aGlobals.nCode = nCode;
1611 aGlobals.nLine = nLine;
1612 aGlobals.nCol1 = nCol1;
1613 aGlobals.nCol2 = nCol2;
1614 }
1615
1616 //----------------------------------------------------------------
1617 // help class for access to string SubResource of a Resource.
1618 // Source: sfx2\source\doc\docfile.cxx (TLX)
1619 struct BasicStringList_Impl : private Resource
1620 {
1621 ResId aResId;
1622
1623 BasicStringList_Impl( ResId& rErrIdP, sal_uInt16 nId)
1624 : Resource( rErrIdP ),aResId(nId, *rErrIdP.GetResMgr() ){}
1625 ~BasicStringList_Impl() { FreeResource(); }
1626
1627 OUString GetString(){ return aResId.toString(); }
1628 sal_Bool IsErrorTextAvailable( void )
1629 { return IsAvailableRes(aResId.SetRT(RSC_STRING)); }
1630 };
1631 //----------------------------------------------------------------
1632
1633 void StarBASIC::MakeErrorText( SbError nId, const OUString& aMsg )
1634 {
1635 SolarMutexGuard aSolarGuard;
1636 sal_uInt16 nOldID = GetVBErrorCode( nId );
1637
1638 // intantiate the help class
1639 BasResId aId( RID_BASIC_START );
1640 BasicStringList_Impl aMyStringList( aId, sal_uInt16(nId & ERRCODE_RES_MASK) );
1641
1642 if( aMyStringList.IsErrorTextAvailable() )
1643 {
1644 // merge message with additional text
1645 OUStringBuffer aMsg1(aMyStringList.GetString());
1646 // replace argument placeholder with %s
1647 OUString aSrgStr( "$(ARG1)" );
1648 sal_Int32 nResult = aMyStringList.GetString().indexOf( aSrgStr );
1649
1650 if( nResult >= 0 )
1651 {
1652 aMsg1.remove(nResult, aSrgStr.getLength());
1653 aMsg1.insert(nResult, aMsg);
1654 }
1655 GetSbData()->aErrMsg = aMsg1.makeStringAndClear();
1656 }
1657 else if( nOldID != 0 )
1658 {
1659 OUString aStdMsg = "Fehler " + OUString::number(nOldID) +
1660 ": Kein Fehlertext verfuegbar!";
1661 GetSbData()->aErrMsg = aStdMsg;
1662 }
1663 else
1664 {
1665 GetSbData()->aErrMsg = "";
1666 }
1667 }
1668
1669 sal_Bool StarBASIC::CError( SbError code, const OUString& rMsg,
1670 sal_Int32 l, sal_Int32 c1, sal_Int32 c2 )
1671 {
1672 SolarMutexGuard aSolarGuard;
1673
1674 // compiler error during runtime -> stop programm
1675 if( IsRunning() )
1676 {
1677 // #109018 Check if running Basic is affected
1678 StarBASIC* pStartedBasic = GetSbData()->pInst->GetBasic();
1679 if( pStartedBasic != this )
1680 {
1681 return sal_False;
1682 }
1683 Stop();
1684 }
1685
1686 // set flag, so that GlobalRunInit notice the error
1687 GetSbData()->bGlobalInitErr = true;
1688
1689 // tinker the error message
1690 MakeErrorText( code, rMsg );
1691
1692 // Implementation of the code for the string transport to SFX-Error
1693 if( !rMsg.isEmpty() )
1694 {
1695 code = (sal_uIntPtr)*new StringErrorInfo( code, rMsg );
1696 }
1697 SetErrorData( code, l, c1, c2 );
1698 GetSbData()->bCompiler = true;
1699 sal_Bool bRet;
1700 if( GetSbData()->aErrHdl.IsSet() )
1701 {
1702 bRet = (sal_Bool) GetSbData()->aErrHdl.Call( this );
1703 }
1704 else
1705 {
1706 bRet = ErrorHdl();
1707 }
1708 GetSbData()->bCompiler = false; // only true for error handler
1709 return bRet;
1710 }
1711
1712 sal_Bool StarBASIC::RTError( SbError code, sal_Int32 l, sal_Int32 c1, sal_Int32 c2 )
1713 {
1714 return RTError( code, OUString(), l, c1, c2 );
1715 }
1716
1717 sal_Bool StarBASIC::RTError( SbError code, const OUString& rMsg, sal_Int32 l, sal_Int32 c1, sal_Int32 c2 )
1718 {
1719 SolarMutexGuard aSolarGuard;
1720
1721 SbError c = code;
1722 if( (c & ERRCODE_CLASS_MASK) == ERRCODE_CLASS_COMPILER )
1723 {
1724 c = 0;
1725 }
1726 MakeErrorText( c, rMsg );
1727
1728 // Implementation of the code for the string transport to SFX-Error
1729 if( !rMsg.isEmpty() )
1730 {
1731 // very confusing, even though MakeErrorText sets up the error text
1732 // seems that this is not used ( if rMsg already has content )
1733 // In the case of VBA MakeErrorText also formats the error to be alittle more
1734 // like vba ( adds an error number etc )
1735 if ( SbiRuntime::isVBAEnabled() && ( code == SbERR_BASIC_COMPAT ) )
1736 {
1737 OUString aTmp = "\'" + OUString::valueOf(SbxErrObject::getUnoErrObject()->getNumber()) +
1738 "\'\n" + OUString(!GetSbData()->aErrMsg.isEmpty() ? GetSbData()->aErrMsg : rMsg);
1739 code = (sal_uIntPtr)*new StringErrorInfo( code, aTmp );
1740 }
1741 else
1742 {
1743 code = (sal_uIntPtr)*new StringErrorInfo( code, rMsg );
1744 }
1745 }
1746
1747 SetErrorData( code, l, c1, c2 );
1748 if( GetSbData()->aErrHdl.IsSet() )
1749 {
1750 return (sal_Bool) GetSbData()->aErrHdl.Call( this );
1751 }
1752 else
1753 {
1754 return ErrorHdl();
1755 }
1756 }
1757
1758 void StarBASIC::Error( SbError n )
1759 {
1760 Error( n, OUString() );
1761 }
1762
1763 void StarBASIC::Error( SbError n, const OUString& rMsg )
1764 {
1765 if( GetSbData()->pInst )
1766 {
1767 GetSbData()->pInst->Error( n, rMsg );
1768 }
1769 }
1770
1771 void StarBASIC::FatalError( SbError n )
1772 {
1773 if( GetSbData()->pInst )
1774 {
1775 GetSbData()->pInst->FatalError( n );
1776 }
1777 }
1778
1779 void StarBASIC::FatalError( SbError _errCode, const OUString& _details )
1780 {
1781 if( GetSbData()->pInst )
1782 {
1783 GetSbData()->pInst->FatalError( _errCode, _details );
1784 }
1785 }
1786
1787 SbError StarBASIC::GetErrBasic()
1788 {
1789 if( GetSbData()->pInst )
1790 {
1791 return GetSbData()->pInst->GetErr();
1792 }
1793 else
1794 {
1795 return 0;
1796 }
1797 }
1798
1799 // make the additional message for the RTL function error accessible
1800 OUString StarBASIC::GetErrorMsg()
1801 {
1802 if( GetSbData()->pInst )
1803 {
1804 return GetSbData()->pInst->GetErrorMsg();
1805 }
1806 else
1807 {
1808 return OUString();
1809 }
1810 }
1811
1812 sal_Int32 StarBASIC::GetErl()
1813 {
1814 if( GetSbData()->pInst )
1815 {
1816 return GetSbData()->pInst->GetErl();
1817 }
1818 else
1819 {
1820 return 0;
1821 }
1822 }
1823
1824 sal_Bool StarBASIC::ErrorHdl()
1825 {
1826 return (sal_Bool) ( aErrorHdl.IsSet()
1827 ? aErrorHdl.Call( this ) : sal_False );
1828 }
1829
1830 Link StarBASIC::GetGlobalErrorHdl()
1831 {
1832 return GetSbData()->aErrHdl;
1833 }
1834
1835 void StarBASIC::SetGlobalErrorHdl( const Link& rLink )
1836 {
1837 GetSbData()->aErrHdl = rLink;
1838 }
1839
1840 void StarBASIC::SetGlobalBreakHdl( const Link& rLink )
1841 {
1842 GetSbData()->aBreakHdl = rLink;
1843 }
1844
1845 SbxArrayRef StarBASIC::getUnoListeners( void )
1846 {
1847 if( !xUnoListeners.Is() )
1848 {
1849 xUnoListeners = new SbxArray();
1850 }
1851 return xUnoListeners;
1852 }
1853
1854
1855 /**************************************************************************
1856 *
1857 * load and save
1858 *
1859 **************************************************************************/
1860
1861 sal_Bool StarBASIC::LoadData( SvStream& r, sal_uInt16 nVer )
1862 {
1863 if( !SbxObject::LoadData( r, nVer ) )
1864 {
1865 return sal_False;
1866 }
1867 // #95459 Delete dialogs, otherwise endless recursion
1868 // in SbxVarable::GetType() if dialogs are accessed
1869 sal_uInt16 nObjCount = pObjs->Count();
1870 SbxVariable** ppDeleteTab = new SbxVariable*[ nObjCount ];
1871 sal_uInt16 nObj;
1872
1873 for( nObj = 0 ; nObj < nObjCount ; nObj++ )
1874 {
1875 SbxVariable* pVar = pObjs->Get( nObj );
1876 StarBASIC* pBasic = PTR_CAST( StarBASIC, pVar );
1877 ppDeleteTab[nObj] = pBasic ? NULL : pVar;
1878 }
1879 for( nObj = 0 ; nObj < nObjCount ; nObj++ )
1880 {
1881 SbxVariable* pVar = ppDeleteTab[nObj];
1882 if( pVar )
1883 {
1884 pObjs->Remove( pVar );
1885 }
1886 }
1887 delete[] ppDeleteTab;
1888
1889 sal_uInt16 nMod;
1890 pModules->Clear();
1891 r >> nMod;
1892 for( sal_uInt16 i = 0; i < nMod; i++ )
1893 {
1894 SbModule* pMod = (SbModule*) SbxBase::Load( r );
1895 if( !pMod )
1896 {
1897 return sal_False;
1898 }
1899 else if( pMod->ISA(SbJScriptModule) )
1900 {
1901 // assign Ref, so that pMod will be deleted
1902 SbModuleRef xRef = pMod;
1903 }
1904 else
1905 {
1906 pMod->SetParent( this );
1907 pModules->Put( pMod, i );
1908 }
1909 }
1910 // HACK for SFX-Bullshit!
1911 SbxVariable* p = Find( OUString("FALSE"), SbxCLASS_PROPERTY );
1912 if( p )
1913 {
1914 Remove( p );
1915 }
1916 p = Find( OUString("TRUE"), SbxCLASS_PROPERTY );
1917 if( p )
1918 {
1919 Remove( p );
1920 }
1921 // End of the hacks!
1922 // Search via StarBASIC is at all times global
1923 DBG_ASSERT( IsSet( SBX_GBLSEARCH ), "Basic loaded without GBLSEARCH" );
1924 SetFlag( SBX_GBLSEARCH );
1925 return sal_True;
1926 }
1927
1928 sal_Bool StarBASIC::StoreData( SvStream& r ) const
1929 {
1930 if( !SbxObject::StoreData( r ) )
1931 {
1932 return sal_False;
1933 }
1934 r << (sal_uInt16) pModules->Count();
1935 for( sal_uInt16 i = 0; i < pModules->Count(); i++ )
1936 {
1937 SbModule* p = (SbModule*) pModules->Get( i );
1938 if( !p->Store( r ) )
1939 {
1940 return sal_False;
1941 }
1942 }
1943 return sal_True;
1944 }
1945
1946 bool StarBASIC::GetUNOConstant( const sal_Char* _pAsciiName, ::com::sun::star::uno::Any& aOut )
1947 {
1948 bool bRes = false;
1949 OUString sVarName( OUString::createFromAscii( _pAsciiName ) );
1950 SbUnoObject* pGlobs = dynamic_cast<SbUnoObject*>( Find( sVarName, SbxCLASS_DONTCARE ) );
1951 if ( pGlobs )
1952 {
1953 aOut = pGlobs->getUnoAny();
1954 bRes = true;
1955 }
1956 return bRes;
1957 }
1958
1959 Reference< frame::XModel > StarBASIC::GetModelFromBasic( SbxObject* pBasic )
1960 {
1961 OSL_PRECOND( pBasic != NULL, "getModelFromBasic: illegal call!" );
1962 if ( !pBasic )
1963 {
1964 return NULL;
1965 }
1966 // look for the ThisComponent variable, first in the parent (which
1967 // might be the document's Basic), then in the parent's parent (which might be
1968 // the application Basic)
1969 const OUString sThisComponent( "ThisComponent");
1970 SbxVariable* pThisComponent = NULL;
1971
1972 SbxObject* pLookup = pBasic->GetParent();
1973 while ( pLookup && !pThisComponent )
1974 {
1975 pThisComponent = pLookup->Find( sThisComponent, SbxCLASS_OBJECT );
1976 pLookup = pLookup->GetParent();
1977 }
1978 if ( !pThisComponent )
1979 {
1980 OSL_TRACE("Failed to get ThisComponent");
1981 // the application Basic, at the latest, should have this variable
1982 return NULL;
1983 }
1984
1985 Any aThisComponentAny( sbxToUnoValue( pThisComponent ) );
1986 Reference< frame::XModel > xModel( aThisComponentAny, UNO_QUERY );
1987 if ( !xModel.is() )
1988 {
1989 // it's no XModel. Okay, ThisComponent nowadays is allowed to be a controller.
1990 Reference< frame::XController > xController( aThisComponentAny, UNO_QUERY );
1991 if ( xController.is() )
1992 {
1993 xModel = xController->getModel();
1994 }
1995 }
1996 if ( !xModel.is() )
1997 {
1998 return NULL;
1999 }
2000 #if OSL_DEBUG_LEVEL > 0
2001 OSL_TRACE("Have model ThisComponent points to url %s",
2002 OUStringToOString( xModel->getURL(),
2003 RTL_TEXTENCODING_ASCII_US ).pData->buffer );
2004 #endif
2005
2006 return xModel;
2007 }
2008
2009
2010 //========================================================================
2011 // #118116 Implementation Collection object
2012
2013 TYPEINIT1(BasicCollection,SbxObject)
2014
2015 static const char pCountStr[] = "Count";
2016 static const char pAddStr[] = "Add";
2017 static const char pItemStr[] = "Item";
2018 static const char pRemoveStr[] = "Remove";
2019 static sal_uInt16 nCountHash = 0, nAddHash, nItemHash, nRemoveHash;
2020
2021 SbxInfoRef BasicCollection::xAddInfo = NULL;
2022 SbxInfoRef BasicCollection::xItemInfo = NULL;
2023
2024 BasicCollection::BasicCollection( const OUString& rClass )
2025 : SbxObject( rClass )
2026 {
2027 if( !nCountHash )
2028 {
2029 nCountHash = MakeHashCode( OUString::createFromAscii( pCountStr ) );
2030 nAddHash = MakeHashCode( OUString::createFromAscii( pAddStr ) );
2031 nItemHash = MakeHashCode( OUString::createFromAscii( pItemStr ) );
2032 nRemoveHash = MakeHashCode( OUString::createFromAscii( pRemoveStr ) );
2033 }
2034 Initialize();
2035
2036 }
2037
2038 BasicCollection::~BasicCollection()
2039 {}
2040
2041 void BasicCollection::Clear()
2042 {
2043 SbxObject::Clear();
2044 Initialize();
2045 }
2046
2047 void BasicCollection::Initialize()
2048 {
2049 xItemArray = new SbxArray();
2050 SetType( SbxOBJECT );
2051 SetFlag( SBX_FIXED );
2052 ResetFlag( SBX_WRITE );
2053 SbxVariable* p;
2054 p = Make( OUString::createFromAscii( pCountStr ), SbxCLASS_PROPERTY, SbxINTEGER );
2055 p->ResetFlag( SBX_WRITE );
2056 p->SetFlag( SBX_DONTSTORE );
2057 p = Make( OUString::createFromAscii( pAddStr ), SbxCLASS_METHOD, SbxEMPTY );
2058 p->SetFlag( SBX_DONTSTORE );
2059 p = Make( OUString::createFromAscii( pItemStr ), SbxCLASS_METHOD, SbxVARIANT );
2060 p->SetFlag( SBX_DONTSTORE );
2061 p = Make( OUString::createFromAscii( pRemoveStr ), SbxCLASS_METHOD, SbxEMPTY );
2062 p->SetFlag( SBX_DONTSTORE );
2063 if ( !xAddInfo.Is() )
2064 {
2065 xAddInfo = new SbxInfo;
2066 xAddInfo->AddParam( OUString( "Item" ), SbxVARIANT, SBX_READ );
2067 xAddInfo->AddParam( OUString( "Key" ), SbxVARIANT, SBX_READ | SBX_OPTIONAL );
2068 xAddInfo->AddParam( OUString( "Before" ), SbxVARIANT, SBX_READ | SBX_OPTIONAL );
2069 xAddInfo->AddParam( OUString( "After" ), SbxVARIANT, SBX_READ | SBX_OPTIONAL );
2070 }
2071 if ( !xItemInfo.Is() )
2072 {
2073 xItemInfo = new SbxInfo;
2074 xItemInfo->AddParam( OUString( "Index" ), SbxVARIANT, SBX_READ | SBX_OPTIONAL);
2075 }
2076 }
2077
2078 SbxVariable* BasicCollection::Find( const OUString& rName, SbxClassType t )
2079 {
2080 SbxVariable* pFind = SbxObject::Find( rName, t );
2081 return pFind;
2082 }
2083
2084 void BasicCollection::SFX_NOTIFY( SfxBroadcaster& rCst, const TypeId& rId1,
2085 const SfxHint& rHint, const TypeId& rId2 )
2086 {
2087 const SbxHint* p = PTR_CAST(SbxHint,&rHint);
2088 if( p )
2089 {
2090 sal_uIntPtr nId = p->GetId();
2091 sal_Bool bRead = sal_Bool( nId == SBX_HINT_DATAWANTED );
2092 sal_Bool bWrite = sal_Bool( nId == SBX_HINT_DATACHANGED );
2093 sal_Bool bRequestInfo = sal_Bool( nId == SBX_HINT_INFOWANTED );
2094 SbxVariable* pVar = p->GetVar();
2095 SbxArray* pArg = pVar->GetParameters();
2096 OUString aVarName( pVar->GetName() );
2097 if( bRead || bWrite )
2098 {
2099 if( pVar->GetHashCode() == nCountHash
2100 && aVarName.equalsIgnoreAsciiCaseAscii( pCountStr ) )
2101 {
2102 pVar->PutLong( xItemArray->Count32() );
2103 }
2104 else if( pVar->GetHashCode() == nAddHash
2105 && aVarName.equalsIgnoreAsciiCaseAscii( pAddStr ) )
2106 {
2107 CollAdd( pArg );
2108 }
2109 else if( pVar->GetHashCode() == nItemHash
2110 && aVarName.equalsIgnoreAsciiCaseAscii( pItemStr ) )
2111 {
2112 CollItem( pArg );
2113 }
2114 else if( pVar->GetHashCode() == nRemoveHash
2115 && aVarName.equalsIgnoreAsciiCaseAscii( pRemoveStr ) )
2116 {
2117 CollRemove( pArg );
2118 }
2119 else
2120 {
2121 SbxObject::SFX_NOTIFY( rCst, rId1, rHint, rId2 );
2122 }
2123 return;
2124 }
2125 else if ( bRequestInfo )
2126 {
2127 if( pVar->GetHashCode() == nAddHash
2128 && aVarName.equalsIgnoreAsciiCaseAscii( pAddStr ) )
2129 {
2130 pVar->SetInfo( xAddInfo );
2131 }
2132 else if( pVar->GetHashCode() == nItemHash
2133 && aVarName.equalsIgnoreAsciiCaseAscii( pItemStr ) )
2134 {
2135 pVar->SetInfo( xItemInfo );
2136 }
2137 }
2138 }
2139 SbxObject::SFX_NOTIFY( rCst, rId1, rHint, rId2 );
2140 }
2141
2142 sal_Int32 BasicCollection::implGetIndex( SbxVariable* pIndexVar )
2143 {
2144 sal_Int32 nIndex = -1;
2145 if( pIndexVar->GetType() == SbxSTRING )
2146 {
2147 nIndex = implGetIndexForName( pIndexVar->GetOUString() );
2148 }
2149 else
2150 {
2151 nIndex = pIndexVar->GetLong() - 1;
2152 }
2153 return nIndex;
2154 }
2155
2156 sal_Int32 BasicCollection::implGetIndexForName( const OUString& rName )
2157 {
2158 sal_Int32 nIndex = -1;
2159 sal_Int32 nCount = xItemArray->Count32();
2160 sal_Int32 nNameHash = MakeHashCode( rName );
2161 for( sal_Int32 i = 0 ; i < nCount ; i++ )
2162 {
2163 SbxVariable* pVar = xItemArray->Get32( i );
2164 if( pVar->GetHashCode() == nNameHash &&
2165 pVar->GetName().equalsIgnoreAsciiCase( rName ) )
2166 {
2167 nIndex = i;
2168 break;
2169 }
2170 }
2171 return nIndex;
2172 }
2173
2174 void BasicCollection::CollAdd( SbxArray* pPar_ )
2175 {
2176 sal_uInt16 nCount = pPar_->Count();
2177 if( nCount < 2 || nCount > 5 )
2178 {
2179 SetError( SbxERR_WRONG_ARGS );
2180 return;
2181 }
2182
2183 SbxVariable* pItem = pPar_->Get(1);
2184 if( pItem )
2185 {
2186 int nNextIndex;
2187 if( nCount < 4 )
2188 {
2189 nNextIndex = xItemArray->Count();
2190 }
2191 else
2192 {
2193 SbxVariable* pBefore = pPar_->Get(3);
2194 if( nCount == 5 )
2195 {
2196 if( !( pBefore->IsErr() || ( pBefore->GetType() == SbxEMPTY ) ) )
2197 {
2198 SetError( SbERR_BAD_ARGUMENT );
2199 return;
2200 }
2201 SbxVariable* pAfter = pPar_->Get(4);
2202 sal_Int32 nAfterIndex = implGetIndex( pAfter );
2203 if( nAfterIndex == -1 )
2204 {
2205 SetError( SbERR_BAD_ARGUMENT );
2206 return;
2207 }
2208 nNextIndex = nAfterIndex + 1;
2209 }
2210 else // if( nCount == 4 )
2211 {
2212 sal_Int32 nBeforeIndex = implGetIndex( pBefore );
2213 if( nBeforeIndex == -1 )
2214 {
2215 SetError( SbERR_BAD_ARGUMENT );
2216 return;
2217 }
2218 nNextIndex = nBeforeIndex;
2219 }
2220 }
2221
2222 SbxVariableRef pNewItem = new SbxVariable( *pItem );
2223 if( nCount >= 3 )
2224 {
2225 SbxVariable* pKey = pPar_->Get(2);
2226 if( !( pKey->IsErr() || ( pKey->GetType() == SbxEMPTY ) ) )
2227 {
2228 if( pKey->GetType() != SbxSTRING )
2229 {
2230 SetError( SbERR_BAD_ARGUMENT );
2231 return;
2232 }
2233 OUString aKey = pKey->GetOUString();
2234 if( implGetIndexForName( aKey ) != -1 )
2235 {
2236 SetError( SbERR_BAD_ARGUMENT );
2237 return;
2238 }
2239 pNewItem->SetName( aKey );
2240 }
2241 }
2242 pNewItem->SetFlag( SBX_READWRITE );
2243 xItemArray->Insert32( pNewItem, nNextIndex );
2244 }
2245 else
2246 {
2247 SetError( SbERR_BAD_ARGUMENT );
2248 return;
2249 }
2250 }
2251
2252 void BasicCollection::CollItem( SbxArray* pPar_ )
2253 {
2254 if( pPar_->Count() != 2 )
2255 {
2256 SetError( SbxERR_WRONG_ARGS );
2257 return;
2258 }
2259 SbxVariable* pRes = NULL;
2260 SbxVariable* p = pPar_->Get( 1 );
2261 sal_Int32 nIndex = implGetIndex( p );
2262 if( nIndex >= 0 && nIndex < (sal_Int32)xItemArray->Count32() )
2263 {
2264 pRes = xItemArray->Get32( nIndex );
2265 }
2266 if( !pRes )
2267 {
2268 SetError( SbERR_BAD_ARGUMENT );
2269 }
2270 else
2271 {
2272 *(pPar_->Get(0)) = *pRes;
2273 }
2274 }
2275
2276 void BasicCollection::CollRemove( SbxArray* pPar_ )
2277 {
2278 if( pPar_ == NULL || pPar_->Count() != 2 )
2279 {
2280 SetError( SbxERR_WRONG_ARGS );
2281 return;
2282 }
2283
2284 SbxVariable* p = pPar_->Get( 1 );
2285 sal_Int32 nIndex = implGetIndex( p );
2286 if( nIndex >= 0 && nIndex < (sal_Int32)xItemArray->Count32() )
2287 {
2288 xItemArray->Remove32( nIndex );
2289
2290 // Correct for stack if necessary
2291 SbiInstance* pInst = GetSbData()->pInst;
2292 SbiRuntime* pRT = pInst ? pInst->pRun : NULL;
2293 if( pRT )
2294 {
2295 SbiForStack* pStack = pRT->FindForStackItemForCollection( this );
2296 if( pStack != NULL )
2297 {
2298 if( pStack->nCurCollectionIndex >= nIndex )
2299 {
2300 --pStack->nCurCollectionIndex;
2301 }
2302 }
2303 }
2304 }
2305 else
2306 {
2307 SetError( SbERR_BAD_ARGUMENT );
2308 }
2309 }
2310
2311 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE