?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bump product version to 4.2.0.1
[LibreOffice.git] / basic / source / sbx / sbxobj.cxx
blob46244abd3be7119732b91779dfd04806628f1165
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 <basic/sbx.hxx>
22 #include "sbxres.hxx"
23 #include <svl/brdcst.hxx>
24
25 TYPEINIT1(SbxMethod,SbxVariable)
26 TYPEINIT1(SbxProperty,SbxVariable)
27 TYPEINIT2(SbxObject,SbxVariable,SfxListener)
28
29 static OUString pNameProp; // Name-Property
30 static OUString pParentProp; // Parent-Property
31
32 static sal_uInt16 nNameHash = 0, nParentHash = 0;
33
34
35
36 SbxObject::SbxObject( const OUString& rClass )
37 : SbxVariable( SbxOBJECT ), aClassName( rClass )
38 {
39 aData.pObj = this;
40 if( !nNameHash )
41 {
42 pNameProp = OUString::createFromAscii(GetSbxRes( STRING_NAMEPROP ));
43 pParentProp = OUString::createFromAscii(GetSbxRes( STRING_PARENTPROP ));
44 nNameHash = MakeHashCode( pNameProp );
45 nParentHash = MakeHashCode( pParentProp );
46 }
47 SbxObject::Clear();
48 SbxObject::SetName( rClass );
49 }
50
51 SbxObject::SbxObject( const SbxObject& rObj )
52 : SvRefBase( rObj ), SbxVariable( rObj.GetType() ),
53 SfxListener( rObj )
54 {
55 *this = rObj;
56 }
57
58 SbxObject& SbxObject::operator=( const SbxObject& r )
59 {
60 if( &r != this )
61 {
62 SbxVariable::operator=( r );
63 aClassName = r.aClassName;
64 pMethods = new SbxArray;
65 pProps = new SbxArray;
66 pObjs = new SbxArray( SbxOBJECT );
67 // The arrays were copied, the content taken over
68 *pMethods = *r.pMethods;
69 *pProps = *r.pProps;
70 *pObjs = *r.pObjs;
71 // Because the variables were taken over, this is OK
72 pDfltProp = r.pDfltProp;
73 SetName( r.GetName() );
74 SetFlags( r.GetFlags() );
75 SetModified( sal_True );
76 }
77 return *this;
78 }
79
80 static void CheckParentsOnDelete( SbxObject* pObj, SbxArray* p )
81 {
82 for( sal_uInt16 i = 0; i < p->Count(); i++ )
83 {
84 SbxVariableRef& rRef = p->GetRef( i );
85 if( rRef->IsBroadcaster() )
86 {
87 pObj->EndListening( rRef->GetBroadcaster(), sal_True );
88 }
89 // does the element have more then one reference and still a Listener?
90 if( rRef->GetRefCount() > 1 )
91 {
92 rRef->SetParent( NULL );
93 DBG_ASSERT( !rRef->IsBroadcaster() || rRef->GetBroadcaster().GetListenerCount(), "Object element with dangling parent" );
94 }
95 }
96 }
97
98 SbxObject::~SbxObject()
99 {
100 CheckParentsOnDelete( this, pProps );
101 CheckParentsOnDelete( this, pMethods );
102 CheckParentsOnDelete( this, pObjs );
103
104 // avoid handling in ~SbxVariable as SBX_DIM_AS_NEW == SBX_GBLSEARCH
105 ResetFlag( SBX_DIM_AS_NEW );
106 }
107
108 SbxDataType SbxObject::GetType() const
109 {
110 return SbxOBJECT;
111 }
112
113 SbxClassType SbxObject::GetClass() const
114 {
115 return SbxCLASS_OBJECT;
116 }
117
118 void SbxObject::Clear()
119 {
120 pMethods = new SbxArray;
121 pProps = new SbxArray;
122 pObjs = new SbxArray( SbxOBJECT );
123 SbxVariable* p;
124 p = Make( pNameProp, SbxCLASS_PROPERTY, SbxSTRING );
125 p->SetFlag( SBX_DONTSTORE );
126 p = Make( pParentProp, SbxCLASS_PROPERTY, SbxOBJECT );
127 p->ResetFlag( SBX_WRITE );
128 p->SetFlag( SBX_DONTSTORE );
129 pDfltProp = NULL;
130 SetModified( sal_False );
131 }
132
133 void SbxObject::SFX_NOTIFY( SfxBroadcaster&, const TypeId&,
134 const SfxHint& rHint, const TypeId& )
135 {
136 const SbxHint* p = PTR_CAST(SbxHint,&rHint);
137 if( p )
138 {
139 sal_uIntPtr nId = p->GetId();
140 bool bRead = ( nId == SBX_HINT_DATAWANTED );
141 bool bWrite = ( nId == SBX_HINT_DATACHANGED );
142 SbxVariable* pVar = p->GetVar();
143 if( bRead || bWrite )
144 {
145 OUString aVarName( pVar->GetName() );
146 sal_uInt16 nHash_ = MakeHashCode( aVarName );
147 if( nHash_ == nNameHash && aVarName.equalsIgnoreAsciiCase( pNameProp ) )
148 {
149 if( bRead )
150 {
151 pVar->PutString( GetName() );
152 }
153 else
154 {
155 SetName( pVar->GetOUString() );
156 }
157 }
158 else if( nHash_ == nParentHash && aVarName.equalsIgnoreAsciiCase( pParentProp ) )
159 {
160 SbxObject* p_ = GetParent();
161 if( !p_ )
162 {
163 p_ = this;
164 }
165 pVar->PutObject( p_ );
166 }
167 }
168 }
169 }
170
171 sal_Bool SbxObject::IsClass( const OUString& rName ) const
172 {
173 return sal_Bool( aClassName.equalsIgnoreAsciiCase( rName ) );
174 }
175
176 SbxVariable* SbxObject::FindUserData( sal_uInt32 nData )
177 {
178 if( !GetAll( SbxCLASS_DONTCARE ) )
179 {
180 return NULL;
181 }
182 SbxVariable* pRes = pMethods->FindUserData( nData );
183 if( !pRes )
184 {
185 pRes = pProps->FindUserData( nData );
186 }
187 if( !pRes )
188 {
189 pRes = pObjs->FindUserData( nData );
190 }
191 // Search in the parents?
192 if( !pRes && IsSet( SBX_GBLSEARCH ) )
193 {
194 SbxObject* pCur = this;
195 while( !pRes && pCur->pParent )
196 {
197 // I myself was already searched!
198 sal_uInt16 nOwn = pCur->GetFlags();
199 pCur->ResetFlag( SBX_EXTSEARCH );
200 // I search already global!
201 sal_uInt16 nPar = pCur->pParent->GetFlags();
202 pCur->pParent->ResetFlag( SBX_GBLSEARCH );
203 pRes = pCur->pParent->FindUserData( nData );
204 pCur->SetFlags( nOwn );
205 pCur->pParent->SetFlags( nPar );
206 pCur = pCur->pParent;
207 }
208 }
209 return pRes;
210 }
211
212 SbxVariable* SbxObject::Find( const OUString& rName, SbxClassType t )
213 {
214 #ifdef DBG_UTIL
215 static sal_uInt16 nLvl = 0;
216 static const char* pCls[] = { "DontCare","Array","Value","Variable","Method","Property","Object" };
217 OString aNameStr1(OUStringToOString(rName, RTL_TEXTENCODING_ASCII_US));
218 OString aNameStr2(OUStringToOString(SbxVariable::GetName(), RTL_TEXTENCODING_ASCII_US));
219 DbgOutf( "SBX: Search %.*s %s %s in %s",
220 nLvl++, " ",
221 ( t >= SbxCLASS_DONTCARE && t <= SbxCLASS_OBJECT )
222 ? pCls[ t-1 ] : "Unknown class", aNameStr1.getStr(), aNameStr2.getStr() );
223 #endif
224
225 if( !GetAll( t ) )
226 {
227 return NULL;
228 }
229 SbxVariable* pRes = NULL;
230 pObjs->SetFlag( SBX_EXTSEARCH );
231 if( t == SbxCLASS_DONTCARE )
232 {
233 pRes = pMethods->Find( rName, SbxCLASS_METHOD );
234 if( !pRes )
235 {
236 pRes = pProps->Find( rName, SbxCLASS_PROPERTY );
237 }
238 if( !pRes )
239 {
240 pRes = pObjs->Find( rName, t );
241 }
242 }
243 else
244 {
245 SbxArray* pArray = NULL;
246 switch( t )
247 {
248 case SbxCLASS_VARIABLE:
249 case SbxCLASS_PROPERTY: pArray = pProps; break;
250 case SbxCLASS_METHOD: pArray = pMethods; break;
251 case SbxCLASS_OBJECT: pArray = pObjs; break;
252 default: DBG_ASSERT( !this, "Invalid SBX-Class" ); break;
253 }
254 if( pArray )
255 {
256 pRes = pArray->Find( rName, t );
257 }
258 }
259 // Extended Search in the Object-Array?
260 // For objects and DontCare the array of objects has already been searched
261 if( !pRes && ( t == SbxCLASS_METHOD || t == SbxCLASS_PROPERTY ) )
262 pRes = pObjs->Find( rName, t );
263 // Search in the parents?
264 if( !pRes && IsSet( SBX_GBLSEARCH ) )
265 {
266 SbxObject* pCur = this;
267 while( !pRes && pCur->pParent )
268 {
269 // I myself was already searched!
270 sal_uInt16 nOwn = pCur->GetFlags();
271 pCur->ResetFlag( SBX_EXTSEARCH );
272 // I search already global!
273 sal_uInt16 nPar = pCur->pParent->GetFlags();
274 pCur->pParent->ResetFlag( SBX_GBLSEARCH );
275 pRes = pCur->pParent->Find( rName, t );
276 pCur->SetFlags( nOwn );
277 pCur->pParent->SetFlags( nPar );
278 pCur = pCur->pParent;
279 }
280 }
281 #ifdef DBG_UTIL
282 nLvl--;
283 if( pRes )
284 {
285 OString aNameStr3(OUStringToOString(rName, RTL_TEXTENCODING_ASCII_US));
286 OString aNameStr4(OUStringToOString(SbxVariable::GetName(), RTL_TEXTENCODING_ASCII_US));
287 DbgOutf( "SBX: Found %.*s %s in %s",
288 nLvl, " ", aNameStr3.getStr(), aNameStr4.getStr() );
289 }
290 #endif
291 return pRes;
292 }
293
294 // Abbreviated version: The parent-string will be searched
295 // The whole thing recursive, because Call() might be overloaded
296 // Qualified names are allowed
297
298 sal_Bool SbxObject::Call( const OUString& rName, SbxArray* pParam )
299 {
300 SbxVariable* pMeth = FindQualified( rName, SbxCLASS_DONTCARE);
301 if( pMeth && pMeth->ISA(SbxMethod) )
302 {
303 // FindQualified() might have struck already!
304 if( pParam )
305 {
306 pMeth->SetParameters( pParam );
307 }
308 pMeth->Broadcast( SBX_HINT_DATAWANTED );
309 pMeth->SetParameters( NULL );
310 return sal_True;
311 }
312 SetError( SbxERR_NO_METHOD );
313 return sal_False;
314 }
315
316 SbxProperty* SbxObject::GetDfltProperty()
317 {
318 if ( !pDfltProp && !aDfltPropName.isEmpty() )
319 {
320 pDfltProp = (SbxProperty*) Find( aDfltPropName, SbxCLASS_PROPERTY );
321 if( !pDfltProp )
322 {
323 pDfltProp = (SbxProperty*) Make( aDfltPropName, SbxCLASS_PROPERTY, SbxVARIANT );
324 }
325 }
326 return pDfltProp;
327 }
328 void SbxObject::SetDfltProperty( const OUString& rName )
329 {
330 if ( rName != aDfltPropName )
331 {
332 pDfltProp = NULL;
333 }
334 aDfltPropName = rName;
335 SetModified( sal_True );
336 }
337
338 // Search of an already available variable. If it was located,
339 // the index will be set, otherwise the Count of the Array will be returned.
340 // In any case the correct Array will be returned.
341
342 SbxArray* SbxObject::FindVar( SbxVariable* pVar, sal_uInt16& nArrayIdx )
343 {
344 SbxArray* pArray = NULL;
345 if( pVar ) switch( pVar->GetClass() )
346 {
347 case SbxCLASS_VARIABLE:
348 case SbxCLASS_PROPERTY: pArray = pProps; break;
349 case SbxCLASS_METHOD: pArray = pMethods; break;
350 case SbxCLASS_OBJECT: pArray = pObjs; break;
351 default: DBG_ASSERT( !this, "Invalid SBX-Class" ); break;
352 }
353 if( pArray )
354 {
355 nArrayIdx = pArray->Count();
356 // Is the variable per name available?
357 pArray->ResetFlag( SBX_EXTSEARCH );
358 SbxVariable* pOld = pArray->Find( pVar->GetName(), pVar->GetClass() );
359 if( pOld )
360 {
361 for( sal_uInt16 i = 0; i < pArray->Count(); i++ )
362 {
363 SbxVariableRef& rRef = pArray->GetRef( i );
364 if( (SbxVariable*) rRef == pOld )
365 {
366 nArrayIdx = i; break;
367 }
368 }
369 }
370 }
371 return pArray;
372 }
373
374 // If a new object will be established, this object will be indexed,
375 // if an object of this name exists already.
376
377 SbxVariable* SbxObject::Make( const OUString& rName, SbxClassType ct, SbxDataType dt )
378 {
379 // Is the object already available?
380 SbxArray* pArray = NULL;
381 switch( ct )
382 {
383 case SbxCLASS_VARIABLE:
384 case SbxCLASS_PROPERTY: pArray = pProps; break;
385 case SbxCLASS_METHOD: pArray = pMethods; break;
386 case SbxCLASS_OBJECT: pArray = pObjs; break;
387 default: DBG_ASSERT( !this, "Invalid SBX-Class" ); break;
388 }
389 if( !pArray )
390 {
391 return NULL;
392 }
393 // Collections may contain objects of the same name
394 if( !( ct == SbxCLASS_OBJECT && ISA(SbxCollection) ) )
395 {
396 SbxVariable* pRes = pArray->Find( rName, ct );
397 if( pRes )
398 {
399 return pRes;
400 }
401 }
402 SbxVariable* pVar = NULL;
403 switch( ct )
404 {
405 case SbxCLASS_VARIABLE:
406 case SbxCLASS_PROPERTY:
407 pVar = new SbxProperty( rName, dt );
408 break;
409 case SbxCLASS_METHOD:
410 pVar = new SbxMethod( rName, dt );
411 break;
412 case SbxCLASS_OBJECT:
413 pVar = CreateObject( rName );
414 break;
415 default:
416 break;
417 }
418 pVar->SetParent( this );
419 pArray->Put( pVar, pArray->Count() );
420 SetModified( sal_True );
421 // The object listen always
422 StartListening( pVar->GetBroadcaster(), sal_True );
423 Broadcast( SBX_HINT_OBJECTCHANGED );
424 return pVar;
425 }
426
427 SbxObject* SbxObject::MakeObject( const OUString& rName, const OUString& rClass )
428 {
429 // Is the object already available?
430 if( !ISA(SbxCollection) )
431 {
432 SbxVariable* pRes = pObjs->Find( rName, SbxCLASS_OBJECT );
433 if( pRes )
434 {
435 return PTR_CAST(SbxObject,pRes);
436 }
437 }
438 SbxObject* pVar = CreateObject( rClass );
439 if( pVar )
440 {
441 pVar->SetName( rName );
442 pVar->SetParent( this );
443 pObjs->Put( pVar, pObjs->Count() );
444 SetModified( sal_True );
445 // The object listen always
446 StartListening( pVar->GetBroadcaster(), sal_True );
447 Broadcast( SBX_HINT_OBJECTCHANGED );
448 }
449 return pVar;
450 }
451
452 void SbxObject::Insert( SbxVariable* pVar )
453 {
454 sal_uInt16 nIdx;
455 SbxArray* pArray = FindVar( pVar, nIdx );
456 if( pArray )
457 {
458 // Into with it. But you should pay attention at the Pointer!
459 if( nIdx < pArray->Count() )
460 {
461 // Then this element exists already
462 // There are objects of the same name allowed at collections
463 if( pArray == pObjs && ISA(SbxCollection) )
464 {
465 nIdx = pArray->Count();
466 }
467 else
468 {
469 SbxVariable* pOld = pArray->Get( nIdx );
470 // already inside: overwrite
471 if( pOld == pVar )
472 {
473 return;
474 }
475 EndListening( pOld->GetBroadcaster(), sal_True );
476 if( pVar->GetClass() == SbxCLASS_PROPERTY )
477 {
478 if( pOld == pDfltProp )
479 {
480 pDfltProp = (SbxProperty*) pVar;
481 }
482 }
483 }
484 }
485 StartListening( pVar->GetBroadcaster(), sal_True );
486 pArray->Put( pVar, nIdx );
487 if( pVar->GetParent() != this )
488 {
489 pVar->SetParent( this );
490 }
491 SetModified( sal_True );
492 Broadcast( SBX_HINT_OBJECTCHANGED );
493 #ifdef DBG_UTIL
494 static const char* pCls[] =
495 { "DontCare","Array","Value","Variable","Method","Property","Object" };
496 OUString aVarName( pVar->GetName() );
497 if ( aVarName.isEmpty() && pVar->ISA(SbxObject) )
498 {
499 aVarName = PTR_CAST(SbxObject,pVar)->GetClassName();
500 }
501 OString aNameStr1(OUStringToOString(aVarName, RTL_TEXTENCODING_ASCII_US));
502 OString aNameStr2(OUStringToOString(SbxVariable::GetName(), RTL_TEXTENCODING_ASCII_US));
503 DbgOutf( "SBX: Insert %s %s in %s",
504 ( pVar->GetClass() >= SbxCLASS_DONTCARE &&
505 pVar->GetClass() <= SbxCLASS_OBJECT )
506 ? pCls[ pVar->GetClass()-1 ] : "Unknown class", aNameStr1.getStr(), aNameStr2.getStr() );
507 #endif
508 }
509 }
510
511 // Optimisation, Insertion without checking about
512 // double entry and without broadcasts, will only be used in SO2/auto.cxx
513 void SbxObject::QuickInsert( SbxVariable* pVar )
514 {
515 SbxArray* pArray = NULL;
516 if( pVar )
517 {
518 switch( pVar->GetClass() )
519 {
520 case SbxCLASS_VARIABLE:
521 case SbxCLASS_PROPERTY: pArray = pProps; break;
522 case SbxCLASS_METHOD: pArray = pMethods; break;
523 case SbxCLASS_OBJECT: pArray = pObjs; break;
524 default: DBG_ASSERT( !this, "Invalid SBX-Class" ); break;
525 }
526 }
527 if( pArray )
528 {
529 StartListening( pVar->GetBroadcaster(), sal_True );
530 pArray->Put( pVar, pArray->Count() );
531 if( pVar->GetParent() != this )
532 {
533 pVar->SetParent( this );
534 }
535 SetModified( sal_True );
536 #ifdef DBG_UTIL
537 static const char* pCls[] =
538 { "DontCare","Array","Value","Variable","Method","Property","Object" };
539 OUString aVarName( pVar->GetName() );
540 if ( aVarName.isEmpty() && pVar->ISA(SbxObject) )
541 {
542 aVarName = PTR_CAST(SbxObject,pVar)->GetClassName();
543 }
544 OString aNameStr1(OUStringToOString(aVarName, RTL_TEXTENCODING_ASCII_US));
545 OString aNameStr2(OUStringToOString(SbxVariable::GetName(), RTL_TEXTENCODING_ASCII_US));
546 DbgOutf( "SBX: Insert %s %s in %s",
547 ( pVar->GetClass() >= SbxCLASS_DONTCARE &&
548 pVar->GetClass() <= SbxCLASS_OBJECT )
549 ? pCls[ pVar->GetClass()-1 ] : "Unknown class", aNameStr1.getStr(), aNameStr2.getStr() );
550 #endif
551 }
552 }
553
554 void SbxObject::Remove( const OUString& rName, SbxClassType t )
555 {
556 Remove( SbxObject::Find( rName, t ) );
557 }
558
559 void SbxObject::Remove( SbxVariable* pVar )
560 {
561 sal_uInt16 nIdx;
562 SbxArray* pArray = FindVar( pVar, nIdx );
563 if( pArray && nIdx < pArray->Count() )
564 {
565 #ifdef DBG_UTIL
566 OUString aVarName( pVar->GetName() );
567 if ( aVarName.isEmpty() && pVar->ISA(SbxObject) )
568 {
569 aVarName = PTR_CAST(SbxObject,pVar)->GetClassName();
570 }
571 OString aNameStr1(OUStringToOString(aVarName, RTL_TEXTENCODING_ASCII_US));
572 OString aNameStr2(OUStringToOString(SbxVariable::GetName(), RTL_TEXTENCODING_ASCII_US));
573 DbgOutf( "SBX: Remove %s in %s",
574 aNameStr1.getStr(), aNameStr2.getStr() );
575 #endif
576 SbxVariableRef pVar_ = pArray->Get( nIdx );
577 if( pVar_->IsBroadcaster() )
578 {
579 EndListening( pVar_->GetBroadcaster(), sal_True );
580 }
581 if( (SbxVariable*) pVar_ == pDfltProp )
582 {
583 pDfltProp = NULL;
584 }
585 pArray->Remove( nIdx );
586 if( pVar_->GetParent() == this )
587 {
588 pVar_->SetParent( NULL );
589 }
590 SetModified( sal_True );
591 Broadcast( SBX_HINT_OBJECTCHANGED );
592 }
593 }
594
595 static bool LoadArray( SvStream& rStrm, SbxObject* pThis, SbxArray* pArray )
596 {
597 SbxArrayRef p = (SbxArray*) SbxBase::Load( rStrm );
598 if( !p.Is() )
599 {
600 return false;
601 }
602 for( sal_uInt16 i = 0; i < p->Count(); i++ )
603 {
604 SbxVariableRef& r = p->GetRef( i );
605 SbxVariable* pVar = r;
606 if( pVar )
607 {
608 pVar->SetParent( pThis );
609 pThis->StartListening( pVar->GetBroadcaster(), sal_True );
610 }
611 }
612 pArray->Merge( p );
613 return true;
614 }
615
616 // The load of an object is additive!
617
618 sal_Bool SbxObject::LoadData( SvStream& rStrm, sal_uInt16 nVer )
619 {
620 // Help for the read in of old objects: just return TRUE,
621 // LoadPrivateData() has to set the default status up
622 if( !nVer )
623 {
624 return sal_True;
625 }
626 pDfltProp = NULL;
627 if( !SbxVariable::LoadData( rStrm, nVer ) )
628 {
629 return sal_False;
630 }
631 // If it contains no alien object, insert ourselves
632 if( aData.eType == SbxOBJECT && !aData.pObj )
633 {
634 aData.pObj = this;
635 }
636 sal_uInt32 nSize;
637 OUString aDfltProp;
638 aClassName = read_lenPrefixed_uInt8s_ToOUString<sal_uInt16>(rStrm, RTL_TEXTENCODING_ASCII_US);
639 aDfltProp = read_lenPrefixed_uInt8s_ToOUString<sal_uInt16>(rStrm, RTL_TEXTENCODING_ASCII_US);
640 sal_uIntPtr nPos = rStrm.Tell();
641 rStrm >> nSize;
642 if( !LoadPrivateData( rStrm, nVer ) )
643 {
644 return sal_False;
645 }
646 sal_uIntPtr nNewPos = rStrm.Tell();
647 nPos += nSize;
648 DBG_ASSERT( nPos >= nNewPos, "SBX: Loaded too much data" );
649 if( nPos != nNewPos )
650 {
651 rStrm.Seek( nPos );
652 }
653 if( !LoadArray( rStrm, this, pMethods ) ||
654 !LoadArray( rStrm, this, pProps ) ||
655 !LoadArray( rStrm, this, pObjs ) )
656 {
657 return sal_False;
658 }
659 // Set properties
660 if( !aDfltProp.isEmpty() )
661 {
662 pDfltProp = (SbxProperty*) pProps->Find( aDfltProp, SbxCLASS_PROPERTY );
663 }
664 SetModified( sal_False );
665 return sal_True;
666 }
667
668 sal_Bool SbxObject::StoreData( SvStream& rStrm ) const
669 {
670 if( !SbxVariable::StoreData( rStrm ) )
671 {
672 return sal_False;
673 }
674 OUString aDfltProp;
675 if( pDfltProp )
676 {
677 aDfltProp = pDfltProp->GetName();
678 }
679 write_lenPrefixed_uInt8s_FromOUString<sal_uInt16>(rStrm, aClassName, RTL_TEXTENCODING_ASCII_US);
680 write_lenPrefixed_uInt8s_FromOUString<sal_uInt16>(rStrm, aDfltProp, RTL_TEXTENCODING_ASCII_US);
681 sal_uIntPtr nPos = rStrm.Tell();
682 rStrm << (sal_uInt32) 0L;
683 if( !StorePrivateData( rStrm ) )
684 {
685 return sal_False;
686 }
687 sal_uIntPtr nNew = rStrm.Tell();
688 rStrm.Seek( nPos );
689 rStrm << (sal_uInt32) ( nNew - nPos );
690 rStrm.Seek( nNew );
691 if( !pMethods->Store( rStrm ) )
692 {
693 return sal_False;
694 }
695 if( !pProps->Store( rStrm ) )
696 {
697 return sal_False;
698 }
699 if( !pObjs->Store( rStrm ) )
700 {
701 return sal_False;
702 }
703 ((SbxObject*) this)->SetModified( sal_False );
704 return sal_True;
705 }
706
707 OUString SbxObject::GenerateSource( const OUString &rLinePrefix,
708 const SbxObject* )
709 {
710 // Collect the properties in a String
711 OUString aSource;
712 SbxArrayRef xProps( GetProperties() );
713 bool bLineFeed = false;
714 for ( sal_uInt16 nProp = 0; nProp < xProps->Count(); ++nProp )
715 {
716 SbxPropertyRef xProp = (SbxProperty*) xProps->Get(nProp);
717 OUString aPropName( xProp->GetName() );
718 if ( xProp->CanWrite() &&
719 !( xProp->GetHashCode() == nNameHash &&
720 aPropName.equalsIgnoreAsciiCase(pNameProp)))
721 {
722 // Insert a break except in front of the first property
723 if ( bLineFeed )
724 {
725 aSource += "\n";
726 }
727 else
728 {
729 bLineFeed = true;
730 }
731 aSource += rLinePrefix;
732 aSource += ".";
733 aSource += aPropName;
734 aSource += " = ";
735
736 // convert the property value to text
737 switch ( xProp->GetType() )
738 {
739 case SbxEMPTY:
740 case SbxNULL:
741 // no value
742 break;
743
744 case SbxSTRING:
745 // Strings in quotation mark
746 aSource += "\"";
747 aSource += xProp->GetOUString();
748 aSource += "\"";
749 break;
750
751 default:
752 // miscellaneous, such as e.g. numbers directly
753 aSource += xProp->GetOUString();
754 break;
755 }
756 }
757 }
758 return aSource;
759 }
760
761 static bool CollectAttrs( const SbxBase* p, OUString& rRes )
762 {
763 OUString aAttrs;
764 if( p->IsHidden() )
765 {
766 aAttrs = "Hidden";
767 }
768 if( p->IsSet( SBX_EXTSEARCH ) )
769 {
770 if( !aAttrs.isEmpty() )
771 {
772 aAttrs += ",";
773 }
774 aAttrs += "ExtSearch";
775 }
776 if( !p->IsVisible() )
777 {
778 if( !aAttrs.isEmpty() )
779 {
780 aAttrs += ",";
781 }
782 aAttrs += "Invisible";
783 }
784 if( p->IsSet( SBX_DONTSTORE ) )
785 {
786 if( !aAttrs.isEmpty() )
787 {
788 aAttrs += ",";
789 }
790 aAttrs += "DontStore";
791 }
792 if( !aAttrs.isEmpty() )
793 {
794 rRes = " (";
795 rRes += aAttrs;
796 rRes += ")";
797 return true;
798 }
799 else
800 {
801 rRes = "";
802 return false;
803 }
804 }
805
806 void SbxObject::Dump( SvStream& rStrm, sal_Bool bFill )
807 {
808 // Shifting
809 static sal_uInt16 nLevel = 0;
810 if ( nLevel > 10 )
811 {
812 rStrm << "<too deep>" << endl;
813 return;
814 }
815 ++nLevel;
816 OUString aIndent("");
817 for ( sal_uInt16 n = 1; n < nLevel; ++n )
818 {
819 aIndent += " ";
820 }
821 // if necessary complete the object
822 if ( bFill )
823 {
824 GetAll( SbxCLASS_DONTCARE );
825 }
826 // Output the data of the object itself
827 OString aNameStr(OUStringToOString(GetName(), RTL_TEXTENCODING_ASCII_US));
828 OString aClassNameStr(OUStringToOString(aClassName, RTL_TEXTENCODING_ASCII_US));
829 rStrm << "Object( "
830 << OString::number(reinterpret_cast<sal_Int64>(this)).getStr()<< "=='"
831 << ( aNameStr.isEmpty() ? "<unnamed>" : aNameStr.getStr() ) << "', "
832 << "of class '" << aClassNameStr.getStr() << "', "
833 << "counts "
834 << OString::number(GetRefCount()).getStr()
835 << " refs, ";
836 if ( GetParent() )
837 {
838 OString aParentNameStr(OUStringToOString(GetName(), RTL_TEXTENCODING_ASCII_US));
839 rStrm << "in parent "
840 << OString::number(reinterpret_cast<sal_Int64>(GetParent())).getStr()
841 << "=='" << ( aParentNameStr.isEmpty() ? "<unnamed>" : aParentNameStr.getStr() ) << "'";
842 }
843 else
844 {
845 rStrm << "no parent ";
846 }
847 rStrm << " )" << endl;
848 OString aIndentNameStr(OUStringToOString(aIndent, RTL_TEXTENCODING_ASCII_US));
849 rStrm << aIndentNameStr.getStr() << "{" << endl;
850
851 // Flags
852 OUString aAttrs;
853 if( CollectAttrs( this, aAttrs ) )
854 {
855 OString aAttrStr(OUStringToOString(aAttrs, RTL_TEXTENCODING_ASCII_US));
856 rStrm << aIndentNameStr.getStr() << "- Flags: " << aAttrStr.getStr() << endl;
857 }
858
859 // Methods
860 rStrm << aIndentNameStr.getStr() << "- Methods:" << endl;
861 for( sal_uInt16 i = 0; i < pMethods->Count(); i++ )
862 {
863 SbxVariableRef& r = pMethods->GetRef( i );
864 SbxVariable* pVar = r;
865 if( pVar )
866 {
867 OUString aLine( aIndent );
868 aLine += " - ";
869 aLine += pVar->GetName( SbxNAME_SHORT_TYPES );
870 OUString aAttrs2;
871 if( CollectAttrs( pVar, aAttrs2 ) )
872 {
873 aLine += aAttrs2;
874 }
875 if( !pVar->IsA( TYPE(SbxMethod) ) )
876 {
877 aLine += " !! Not a Method !!";
878 }
879 write_lenPrefixed_uInt8s_FromOUString<sal_uInt16>(rStrm, aLine, RTL_TEXTENCODING_ASCII_US);
880
881 // Output also the object at object-methods
882 if ( pVar->GetValues_Impl().eType == SbxOBJECT &&
883 pVar->GetValues_Impl().pObj &&
884 pVar->GetValues_Impl().pObj != this &&
885 pVar->GetValues_Impl().pObj != GetParent() )
886 {
887 rStrm << " contains ";
888 ((SbxObject*) pVar->GetValues_Impl().pObj)->Dump( rStrm, bFill );
889 }
890 else
891 {
892 rStrm << endl;
893 }
894 }
895 }
896
897 // Properties
898 rStrm << aIndentNameStr.getStr() << "- Properties:" << endl;
899 {
900 for( sal_uInt16 i = 0; i < pProps->Count(); i++ )
901 {
902 SbxVariableRef& r = pProps->GetRef( i );
903 SbxVariable* pVar = r;
904 if( pVar )
905 {
906 OUString aLine( aIndent );
907 aLine += " - ";
908 aLine += pVar->GetName( SbxNAME_SHORT_TYPES );
909 OUString aAttrs3;
910 if( CollectAttrs( pVar, aAttrs3 ) )
911 {
912 aLine += aAttrs3;
913 }
914 if( !pVar->IsA( TYPE(SbxProperty) ) )
915 {
916 aLine += " !! Not a Property !!";
917 }
918 write_lenPrefixed_uInt8s_FromOUString<sal_uInt16>(rStrm, aLine, RTL_TEXTENCODING_ASCII_US);
919
920 // output also the object at object properties
921 if ( pVar->GetValues_Impl().eType == SbxOBJECT &&
922 pVar->GetValues_Impl().pObj &&
923 pVar->GetValues_Impl().pObj != this &&
924 pVar->GetValues_Impl().pObj != GetParent() )
925 {
926 rStrm << " contains ";
927 ((SbxObject*) pVar->GetValues_Impl().pObj)->Dump( rStrm, bFill );
928 }
929 else
930 {
931 rStrm << endl;
932 }
933 }
934 }
935 }
936
937 // Objects
938 rStrm << aIndentNameStr.getStr() << "- Objects:" << endl;
939 {
940 for( sal_uInt16 i = 0; i < pObjs->Count(); i++ )
941 {
942 SbxVariableRef& r = pObjs->GetRef( i );
943 SbxVariable* pVar = r;
944 if ( pVar )
945 {
946 rStrm << aIndentNameStr.getStr() << " - Sub";
947 if ( pVar->ISA(SbxObject) )
948 {
949 ((SbxObject*) pVar)->Dump( rStrm, bFill );
950 }
951 else if ( pVar->ISA(SbxVariable) )
952 {
953 ((SbxVariable*) pVar)->Dump( rStrm, bFill );
954 }
955 }
956 }
957 }
958
959 rStrm << aIndentNameStr.getStr() << "}" << endl << endl;
960 --nLevel;
961 }
962
963 SbxMethod::SbxMethod( const OUString& r, SbxDataType t )
964 : SbxVariable( t )
965 {
966 SetName( r );
967 }
968
969 SbxMethod::SbxMethod( const SbxMethod& r )
970 : SvRefBase( r ), SbxVariable( r )
971 {
972 }
973
974 SbxMethod::~SbxMethod()
975 {
976 }
977
978 SbxClassType SbxMethod::GetClass() const
979 {
980 return SbxCLASS_METHOD;
981 }
982
983 SbxProperty::SbxProperty( const OUString& r, SbxDataType t )
984 : SbxVariable( t )
985 {
986 SetName( r );
987 }
988
989 SbxProperty::~SbxProperty()
990 {
991 }
992
993 SbxClassType SbxProperty::GetClass() const
994 {
995 return SbxCLASS_PROPERTY;
996 }
997
998 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE