?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Version 4.0.2.1, tag libreoffice-4.0.2.1
[LibreOffice.git] / basic / source / sbx / sbxobj.cxx
blobe72a2821c5f0aceebaa08b43b9f8a3896b97195b
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 = ::rtl::OUString::createFromAscii(GetSbxRes( STRING_NAMEPROP ));
43 pParentProp = ::rtl::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 // Did 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 through!
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 rtl::OString aNameStr1(rtl::OUStringToOString(rName, RTL_TEXTENCODING_ASCII_US));
218 rtl::OString aNameStr2(rtl::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(), aNameStr1.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, "Ungueltige SBX-Klasse" ); break;
253 }
254 if( pArray )
255 {
256 pRes = pArray->Find( rName, t );
257 }
258 }
259 // ExtendedsSearch in the Object-Array?
260 // For objects and DontCare is the array of objects already
261 // searched through
262 if( !pRes && ( t == SbxCLASS_METHOD || t == SbxCLASS_PROPERTY ) )
263 pRes = pObjs->Find( rName, t );
264 // Search in the parents?
265 if( !pRes && IsSet( SBX_GBLSEARCH ) )
266 {
267 SbxObject* pCur = this;
268 while( !pRes && pCur->pParent )
269 {
270 // I myself was already searched through!
271 sal_uInt16 nOwn = pCur->GetFlags();
272 pCur->ResetFlag( SBX_EXTSEARCH );
273 // I search already global!
274 sal_uInt16 nPar = pCur->pParent->GetFlags();
275 pCur->pParent->ResetFlag( SBX_GBLSEARCH );
276 pRes = pCur->pParent->Find( rName, t );
277 pCur->SetFlags( nOwn );
278 pCur->pParent->SetFlags( nPar );
279 pCur = pCur->pParent;
280 }
281 }
282 #ifdef DBG_UTIL
283 nLvl--;
284 if( pRes )
285 {
286 rtl::OString aNameStr3(rtl::OUStringToOString(rName, RTL_TEXTENCODING_ASCII_US));
287 rtl::OString aNameStr4(rtl::OUStringToOString(SbxVariable::GetName(), RTL_TEXTENCODING_ASCII_US));
288 DbgOutf( "SBX: Found %.*s %s in %s",
289 nLvl, " ", aNameStr3.getStr(), aNameStr4.getStr() );
290 }
291 #endif
292 return pRes;
293 }
294
295 // Abbreviated version: The parent-string will be searched through
296 // The whole thing recursive, because Call() might be overloaded
297 // Qualified names are allowed
298
299 sal_Bool SbxObject::Call( const OUString& rName, SbxArray* pParam )
300 {
301 SbxVariable* pMeth = FindQualified( rName, SbxCLASS_DONTCARE);
302 if( pMeth && pMeth->ISA(SbxMethod) )
303 {
304 // FindQualified() might have been stroked!
305 if( pParam )
306 {
307 pMeth->SetParameters( pParam );
308 }
309 pMeth->Broadcast( SBX_HINT_DATAWANTED );
310 pMeth->SetParameters( NULL );
311 return sal_True;
312 }
313 SetError( SbxERR_NO_METHOD );
314 return sal_False;
315 }
316
317 SbxProperty* SbxObject::GetDfltProperty()
318 {
319 if ( !pDfltProp && !aDfltPropName.isEmpty() )
320 {
321 pDfltProp = (SbxProperty*) Find( aDfltPropName, SbxCLASS_PROPERTY );
322 if( !pDfltProp )
323 {
324 pDfltProp = (SbxProperty*) Make( aDfltPropName, SbxCLASS_PROPERTY, SbxVARIANT );
325 }
326 }
327 return pDfltProp;
328 }
329 void SbxObject::SetDfltProperty( const OUString& rName )
330 {
331 if ( rName != aDfltPropName )
332 {
333 pDfltProp = NULL;
334 }
335 aDfltPropName = rName;
336 SetModified( sal_True );
337 }
338
339 // Search of a already available variable. If she was located,
340 // the index will be set, elsewise will be delivered the Count of the Array.
341 // In any case it will be delivered the correct Array.
342
343 SbxArray* SbxObject::FindVar( SbxVariable* pVar, sal_uInt16& nArrayIdx )
344 {
345 SbxArray* pArray = NULL;
346 if( pVar ) switch( pVar->GetClass() )
347 {
348 case SbxCLASS_VARIABLE:
349 case SbxCLASS_PROPERTY: pArray = pProps; break;
350 case SbxCLASS_METHOD: pArray = pMethods; break;
351 case SbxCLASS_OBJECT: pArray = pObjs; break;
352 default: DBG_ASSERT( !this, "Ungueltige SBX-Klasse" ); break;
353 }
354 if( pArray )
355 {
356 nArrayIdx = pArray->Count();
357 // Is the variable per name available?
358 pArray->ResetFlag( SBX_EXTSEARCH );
359 SbxVariable* pOld = pArray->Find( pVar->GetName(), pVar->GetClass() );
360 if( pOld )
361 {
362 for( sal_uInt16 i = 0; i < pArray->Count(); i++ )
363 {
364 SbxVariableRef& rRef = pArray->GetRef( i );
365 if( (SbxVariable*) rRef == pOld )
366 {
367 nArrayIdx = i; break;
368 }
369 }
370 }
371 }
372 return pArray;
373 }
374
375 // If a new object will be established, this object will be indexed,
376 // if an object of this name exists already.
377
378 SbxVariable* SbxObject::Make( const OUString& rName, SbxClassType ct, SbxDataType dt )
379 {
380 // Is the object already available?
381 SbxArray* pArray = NULL;
382 switch( ct )
383 {
384 case SbxCLASS_VARIABLE:
385 case SbxCLASS_PROPERTY: pArray = pProps; break;
386 case SbxCLASS_METHOD: pArray = pMethods; break;
387 case SbxCLASS_OBJECT: pArray = pObjs; break;
388 default: DBG_ASSERT( !this, "Ungueltige SBX-Klasse" ); break;
389 }
390 if( !pArray )
391 {
392 return NULL;
393 }
394 // Collections may contain objects of the same name
395 if( !( ct == SbxCLASS_OBJECT && ISA(SbxCollection) ) )
396 {
397 SbxVariable* pRes = pArray->Find( rName, ct );
398 if( pRes )
399 {
400 return pRes;
401 }
402 }
403 SbxVariable* pVar = NULL;
404 switch( ct )
405 {
406 case SbxCLASS_VARIABLE:
407 case SbxCLASS_PROPERTY:
408 pVar = new SbxProperty( rName, dt );
409 break;
410 case SbxCLASS_METHOD:
411 pVar = new SbxMethod( rName, dt );
412 break;
413 case SbxCLASS_OBJECT:
414 pVar = CreateObject( rName );
415 break;
416 default:
417 break;
418 }
419 pVar->SetParent( this );
420 pArray->Put( pVar, pArray->Count() );
421 SetModified( sal_True );
422 // The object listen always
423 StartListening( pVar->GetBroadcaster(), sal_True );
424 Broadcast( SBX_HINT_OBJECTCHANGED );
425 return pVar;
426 }
427
428 SbxObject* SbxObject::MakeObject( const OUString& rName, const OUString& rClass )
429 {
430 // Is the object already available?
431 if( !ISA(SbxCollection) )
432 {
433 SbxVariable* pRes = pObjs->Find( rName, SbxCLASS_OBJECT );
434 if( pRes )
435 {
436 return PTR_CAST(SbxObject,pRes);
437 }
438 }
439 SbxObject* pVar = CreateObject( rClass );
440 if( pVar )
441 {
442 pVar->SetName( rName );
443 pVar->SetParent( this );
444 pObjs->Put( pVar, pObjs->Count() );
445 SetModified( sal_True );
446 // The object listen always
447 StartListening( pVar->GetBroadcaster(), sal_True );
448 Broadcast( SBX_HINT_OBJECTCHANGED );
449 }
450 return pVar;
451 }
452
453 void SbxObject::Insert( SbxVariable* pVar )
454 {
455 sal_uInt16 nIdx;
456 SbxArray* pArray = FindVar( pVar, nIdx );
457 if( pArray )
458 {
459 // Into with it. But you should pay attention at the Pointer!
460 if( nIdx < pArray->Count() )
461 {
462 // Then this element exists already
463 // There are objects of the same name allowed at collections
464 if( pArray == pObjs && ISA(SbxCollection) )
465 {
466 nIdx = pArray->Count();
467 }
468 else
469 {
470 SbxVariable* pOld = pArray->Get( nIdx );
471 // already inside: overwrite
472 if( pOld == pVar )
473 {
474 return;
475 }
476 EndListening( pOld->GetBroadcaster(), sal_True );
477 if( pVar->GetClass() == SbxCLASS_PROPERTY )
478 {
479 if( pOld == pDfltProp )
480 {
481 pDfltProp = (SbxProperty*) pVar;
482 }
483 }
484 }
485 }
486 StartListening( pVar->GetBroadcaster(), sal_True );
487 pArray->Put( pVar, nIdx );
488 if( pVar->GetParent() != this )
489 {
490 pVar->SetParent( this );
491 }
492 SetModified( sal_True );
493 Broadcast( SBX_HINT_OBJECTCHANGED );
494 #ifdef DBG_UTIL
495 static const char* pCls[] =
496 { "DontCare","Array","Value","Variable","Method","Property","Object" };
497 OUString aVarName( pVar->GetName() );
498 if ( aVarName.isEmpty() && pVar->ISA(SbxObject) )
499 {
500 aVarName = PTR_CAST(SbxObject,pVar)->GetClassName();
501 }
502 rtl::OString aNameStr1(rtl::OUStringToOString(aVarName, RTL_TEXTENCODING_ASCII_US));
503 rtl::OString aNameStr2(rtl::OUStringToOString(SbxVariable::GetName(), RTL_TEXTENCODING_ASCII_US));
504 DbgOutf( "SBX: Insert %s %s in %s",
505 ( pVar->GetClass() >= SbxCLASS_DONTCARE &&
506 pVar->GetClass() <= SbxCLASS_OBJECT )
507 ? pCls[ pVar->GetClass()-1 ] : "Unknown class", aNameStr1.getStr(), aNameStr1.getStr() );
508 #endif
509 }
510 }
511
512 // Optimisation, Insertion without checking about
513 // double entry and without broadcasts, will only be used in SO2/auto.cxx
514 void SbxObject::QuickInsert( SbxVariable* pVar )
515 {
516 SbxArray* pArray = NULL;
517 if( pVar )
518 {
519 switch( pVar->GetClass() )
520 {
521 case SbxCLASS_VARIABLE:
522 case SbxCLASS_PROPERTY: pArray = pProps; break;
523 case SbxCLASS_METHOD: pArray = pMethods; break;
524 case SbxCLASS_OBJECT: pArray = pObjs; break;
525 default: DBG_ASSERT( !this, "Ungueltige SBX-Klasse" ); break;
526 }
527 }
528 if( pArray )
529 {
530 StartListening( pVar->GetBroadcaster(), sal_True );
531 pArray->Put( pVar, pArray->Count() );
532 if( pVar->GetParent() != this )
533 {
534 pVar->SetParent( this );
535 }
536 SetModified( sal_True );
537 #ifdef DBG_UTIL
538 static const char* pCls[] =
539 { "DontCare","Array","Value","Variable","Method","Property","Object" };
540 OUString aVarName( pVar->GetName() );
541 if ( aVarName.isEmpty() && pVar->ISA(SbxObject) )
542 {
543 aVarName = PTR_CAST(SbxObject,pVar)->GetClassName();
544 }
545 rtl::OString aNameStr1(rtl::OUStringToOString(aVarName, RTL_TEXTENCODING_ASCII_US));
546 rtl::OString aNameStr2(rtl::OUStringToOString(SbxVariable::GetName(), RTL_TEXTENCODING_ASCII_US));
547 DbgOutf( "SBX: Insert %s %s in %s",
548 ( pVar->GetClass() >= SbxCLASS_DONTCARE &&
549 pVar->GetClass() <= SbxCLASS_OBJECT )
550 ? pCls[ pVar->GetClass()-1 ] : "Unknown class", aNameStr1.getStr(), aNameStr1.getStr() );
551 #endif
552 }
553 }
554
555 void SbxObject::Remove( const OUString& rName, SbxClassType t )
556 {
557 Remove( SbxObject::Find( rName, t ) );
558 }
559
560 void SbxObject::Remove( SbxVariable* pVar )
561 {
562 sal_uInt16 nIdx;
563 SbxArray* pArray = FindVar( pVar, nIdx );
564 if( pArray && nIdx < pArray->Count() )
565 {
566 #ifdef DBG_UTIL
567 OUString aVarName( pVar->GetName() );
568 if ( aVarName.isEmpty() && pVar->ISA(SbxObject) )
569 {
570 aVarName = PTR_CAST(SbxObject,pVar)->GetClassName();
571 }
572 rtl::OString aNameStr1(rtl::OUStringToOString(aVarName, RTL_TEXTENCODING_ASCII_US));
573 rtl::OString aNameStr2(rtl::OUStringToOString(SbxVariable::GetName(), RTL_TEXTENCODING_ASCII_US));
574 #endif
575 SbxVariableRef pVar_ = pArray->Get( nIdx );
576 if( pVar_->IsBroadcaster() )
577 {
578 EndListening( pVar_->GetBroadcaster(), sal_True );
579 }
580 if( (SbxVariable*) pVar_ == pDfltProp )
581 {
582 pDfltProp = NULL;
583 }
584 pArray->Remove( nIdx );
585 if( pVar_->GetParent() == this )
586 {
587 pVar_->SetParent( NULL );
588 }
589 SetModified( sal_True );
590 Broadcast( SBX_HINT_OBJECTCHANGED );
591 }
592 }
593
594 static sal_Bool LoadArray( SvStream& rStrm, SbxObject* pThis, SbxArray* pArray )
595 {
596 SbxArrayRef p = (SbxArray*) SbxBase::Load( rStrm );
597 if( !p.Is() )
598 {
599 return sal_False;
600 }
601 for( sal_uInt16 i = 0; i < p->Count(); i++ )
602 {
603 SbxVariableRef& r = p->GetRef( i );
604 SbxVariable* pVar = r;
605 if( pVar )
606 {
607 pVar->SetParent( pThis );
608 pThis->StartListening( pVar->GetBroadcaster(), sal_True );
609 }
610 }
611 pArray->Merge( p );
612 return sal_True;
613 }
614
615 // The load of an object is additive!
616
617 sal_Bool SbxObject::LoadData( SvStream& rStrm, sal_uInt16 nVer )
618 {
619 // Help for the read in of old objects: just TRUE back,
620 // LoadPrivateData() had to set the default status up
621 if( !nVer )
622 {
623 return sal_True;
624 }
625 pDfltProp = NULL;
626 if( !SbxVariable::LoadData( rStrm, nVer ) )
627 {
628 return sal_False;
629 }
630 // If it contains no alien object, insert ourselves
631 if( aData.eType == SbxOBJECT && !aData.pObj )
632 {
633 aData.pObj = this;
634 }
635 sal_uInt32 nSize;
636 OUString aDfltProp;
637 aClassName = read_lenPrefixed_uInt8s_ToOUString<sal_uInt16>(rStrm, RTL_TEXTENCODING_ASCII_US);
638 aDfltProp = read_lenPrefixed_uInt8s_ToOUString<sal_uInt16>(rStrm, RTL_TEXTENCODING_ASCII_US);
639 sal_uIntPtr nPos = rStrm.Tell();
640 rStrm >> nSize;
641 if( !LoadPrivateData( rStrm, nVer ) )
642 {
643 return sal_False;
644 }
645 sal_uIntPtr nNewPos = rStrm.Tell();
646 nPos += nSize;
647 DBG_ASSERT( nPos >= nNewPos, "SBX: Zu viele Daten eingelesen" );
648 if( nPos != nNewPos )
649 {
650 rStrm.Seek( nPos );
651 }
652 if( !LoadArray( rStrm, this, pMethods ) ||
653 !LoadArray( rStrm, this, pProps ) ||
654 !LoadArray( rStrm, this, pObjs ) )
655 {
656 return sal_False;
657 }
658 // Set properties
659 if( !aDfltProp.isEmpty() )
660 {
661 pDfltProp = (SbxProperty*) pProps->Find( aDfltProp, SbxCLASS_PROPERTY );
662 }
663 SetModified( sal_False );
664 return sal_True;
665 }
666
667 sal_Bool SbxObject::StoreData( SvStream& rStrm ) const
668 {
669 if( !SbxVariable::StoreData( rStrm ) )
670 {
671 return sal_False;
672 }
673 OUString aDfltProp;
674 if( pDfltProp )
675 {
676 aDfltProp = pDfltProp->GetName();
677 }
678 write_lenPrefixed_uInt8s_FromOUString<sal_uInt16>(rStrm, aClassName, RTL_TEXTENCODING_ASCII_US);
679 write_lenPrefixed_uInt8s_FromOUString<sal_uInt16>(rStrm, aDfltProp, RTL_TEXTENCODING_ASCII_US);
680 sal_uIntPtr nPos = rStrm.Tell();
681 rStrm << (sal_uInt32) 0L;
682 if( !StorePrivateData( rStrm ) )
683 {
684 return sal_False;
685 }
686 sal_uIntPtr nNew = rStrm.Tell();
687 rStrm.Seek( nPos );
688 rStrm << (sal_uInt32) ( nNew - nPos );
689 rStrm.Seek( nNew );
690 if( !pMethods->Store( rStrm ) )
691 {
692 return sal_False;
693 }
694 if( !pProps->Store( rStrm ) )
695 {
696 return sal_False;
697 }
698 if( !pObjs->Store( rStrm ) )
699 {
700 return sal_False;
701 }
702 ((SbxObject*) this)->SetModified( sal_False );
703 return sal_True;
704 }
705
706 OUString SbxObject::GenerateSource( const OUString &rLinePrefix,
707 const SbxObject* )
708 {
709 // Collect the properties in a String
710 OUString aSource;
711 SbxArrayRef xProps( GetProperties() );
712 bool bLineFeed = false;
713 for ( sal_uInt16 nProp = 0; nProp < xProps->Count(); ++nProp )
714 {
715 SbxPropertyRef xProp = (SbxProperty*) xProps->Get(nProp);
716 OUString aPropName( xProp->GetName() );
717 if ( xProp->CanWrite() &&
718 !( xProp->GetHashCode() == nNameHash &&
719 aPropName.equalsIgnoreAsciiCase(pNameProp)))
720 {
721 // Insert a break except in front of the first property
722 if ( bLineFeed )
723 {
724 aSource += "\n";
725 }
726 else
727 {
728 bLineFeed = true;
729 }
730 aSource += rLinePrefix;
731 aSource += ".";
732 aSource += aPropName;
733 aSource += " = ";
734
735 // Display the property value textual
736 switch ( xProp->GetType() )
737 {
738 case SbxEMPTY:
739 case SbxNULL:
740 // no value
741 break;
742
743 case SbxSTRING:
744 // Strings in quotation mark
745 aSource += "\"";
746 aSource += xProp->GetOUString();
747 aSource += "\"";
748 break;
749
750 default:
751 // miscellaneous, such as e.g.numerary directly
752 aSource += xProp->GetOUString();
753 break;
754 }
755 }
756 }
757 return aSource;
758 }
759
760 static sal_Bool CollectAttrs( const SbxBase* p, OUString& rRes )
761 {
762 OUString aAttrs;
763 if( p->IsHidden() )
764 {
765 aAttrs = "Hidden";
766 }
767 if( p->IsSet( SBX_EXTSEARCH ) )
768 {
769 if( !aAttrs.isEmpty() )
770 {
771 aAttrs += ",";
772 }
773 aAttrs += "ExtSearch";
774 }
775 if( !p->IsVisible() )
776 {
777 if( !aAttrs.isEmpty() )
778 {
779 aAttrs += ",";
780 }
781 aAttrs += "Invisible";
782 }
783 if( p->IsSet( SBX_DONTSTORE ) )
784 {
785 if( !aAttrs.isEmpty() )
786 {
787 aAttrs += ",";
788 }
789 aAttrs += "DontStore";
790 }
791 if( !aAttrs.isEmpty() )
792 {
793 rRes = " (";
794 rRes += aAttrs;
795 rRes += ")";
796 return sal_True;
797 }
798 else
799 {
800 rRes = "";
801 return sal_False;
802 }
803 }
804
805 void SbxObject::Dump( SvStream& rStrm, sal_Bool bFill )
806 {
807 // Shifting
808 static sal_uInt16 nLevel = 0;
809 if ( nLevel > 10 )
810 {
811 rStrm << "<too deep>" << endl;
812 return;
813 }
814 ++nLevel;
815 OUString aIndent("");
816 for ( sal_uInt16 n = 1; n < nLevel; ++n )
817 {
818 aIndent += " ";
819 }
820 // if necessary complete the object
821 if ( bFill )
822 {
823 GetAll( SbxCLASS_DONTCARE );
824 }
825 // Output the data of the object itself
826 rtl::OString aNameStr(rtl::OUStringToOString(GetName(), RTL_TEXTENCODING_ASCII_US));
827 rtl::OString aClassNameStr(rtl::OUStringToOString(aClassName, RTL_TEXTENCODING_ASCII_US));
828 rStrm << "Object( "
829 << rtl::OString::valueOf(reinterpret_cast<sal_Int64>(this)).getStr()<< "=='"
830 << ( aNameStr.isEmpty() ? "<unnamed>" : aNameStr.getStr() ) << "', "
831 << "of class '" << aClassNameStr.getStr() << "', "
832 << "counts "
833 << rtl::OString::valueOf(static_cast<sal_Int64>(GetRefCount())).getStr()
834 << " refs, ";
835 if ( GetParent() )
836 {
837 rtl::OString aParentNameStr(rtl::OUStringToOString(GetName(), RTL_TEXTENCODING_ASCII_US));
838 rStrm << "in parent "
839 << rtl::OString::valueOf(reinterpret_cast<sal_Int64>(GetParent())).getStr()
840 << "=='" << ( aParentNameStr.isEmpty() ? "<unnamed>" : aParentNameStr.getStr() ) << "'";
841 }
842 else
843 {
844 rStrm << "no parent ";
845 }
846 rStrm << " )" << endl;
847 rtl::OString aIndentNameStr(rtl::OUStringToOString(aIndent, RTL_TEXTENCODING_ASCII_US));
848 rStrm << aIndentNameStr.getStr() << "{" << endl;
849
850 // Flags
851 OUString aAttrs;
852 if( CollectAttrs( this, aAttrs ) )
853 {
854 rtl::OString aAttrStr(rtl::OUStringToOString(aAttrs, RTL_TEXTENCODING_ASCII_US));
855 rStrm << aIndentNameStr.getStr() << "- Flags: " << aAttrStr.getStr() << endl;
856 }
857
858 // Methods
859 rStrm << aIndentNameStr.getStr() << "- Methods:" << endl;
860 for( sal_uInt16 i = 0; i < pMethods->Count(); i++ )
861 {
862 SbxVariableRef& r = pMethods->GetRef( i );
863 SbxVariable* pVar = r;
864 if( pVar )
865 {
866 OUString aLine( aIndent );
867 aLine += " - ";
868 aLine += pVar->GetName( SbxNAME_SHORT_TYPES );
869 OUString aAttrs2;
870 if( CollectAttrs( pVar, aAttrs2 ) )
871 {
872 aLine += aAttrs2;
873 }
874 if( !pVar->IsA( TYPE(SbxMethod) ) )
875 {
876 aLine += " !! Not a Method !!";
877 }
878 write_lenPrefixed_uInt8s_FromOUString<sal_uInt16>(rStrm, aLine, RTL_TEXTENCODING_ASCII_US);
879
880 // Output also the object at object-methods
881 if ( pVar->GetValues_Impl().eType == SbxOBJECT &&
882 pVar->GetValues_Impl().pObj &&
883 pVar->GetValues_Impl().pObj != this &&
884 pVar->GetValues_Impl().pObj != GetParent() )
885 {
886 rStrm << " contains ";
887 ((SbxObject*) pVar->GetValues_Impl().pObj)->Dump( rStrm, bFill );
888 }
889 else
890 {
891 rStrm << endl;
892 }
893 }
894 }
895
896 // Properties
897 rStrm << aIndentNameStr.getStr() << "- Properties:" << endl;
898 {
899 for( sal_uInt16 i = 0; i < pProps->Count(); i++ )
900 {
901 SbxVariableRef& r = pProps->GetRef( i );
902 SbxVariable* pVar = r;
903 if( pVar )
904 {
905 OUString aLine( aIndent );
906 aLine += " - ";
907 aLine += pVar->GetName( SbxNAME_SHORT_TYPES );
908 OUString aAttrs3;
909 if( CollectAttrs( pVar, aAttrs3 ) )
910 {
911 aLine += aAttrs3;
912 }
913 if( !pVar->IsA( TYPE(SbxProperty) ) )
914 {
915 aLine += " !! Not a Property !!";
916 }
917 write_lenPrefixed_uInt8s_FromOUString<sal_uInt16>(rStrm, aLine, RTL_TEXTENCODING_ASCII_US);
918
919 // output also the object at object properties
920 if ( pVar->GetValues_Impl().eType == SbxOBJECT &&
921 pVar->GetValues_Impl().pObj &&
922 pVar->GetValues_Impl().pObj != this &&
923 pVar->GetValues_Impl().pObj != GetParent() )
924 {
925 rStrm << " contains ";
926 ((SbxObject*) pVar->GetValues_Impl().pObj)->Dump( rStrm, bFill );
927 }
928 else
929 {
930 rStrm << endl;
931 }
932 }
933 }
934 }
935
936 // Objects
937 rStrm << aIndentNameStr.getStr() << "- Objects:" << endl;
938 {
939 for( sal_uInt16 i = 0; i < pObjs->Count(); i++ )
940 {
941 SbxVariableRef& r = pObjs->GetRef( i );
942 SbxVariable* pVar = r;
943 if ( pVar )
944 {
945 rStrm << aIndentNameStr.getStr() << " - Sub";
946 if ( pVar->ISA(SbxObject) )
947 {
948 ((SbxObject*) pVar)->Dump( rStrm, bFill );
949 }
950 else if ( pVar->ISA(SbxVariable) )
951 {
952 ((SbxVariable*) pVar)->Dump( rStrm, bFill );
953 }
954 }
955 }
956 }
957
958 rStrm << aIndentNameStr.getStr() << "}" << endl << endl;
959 --nLevel;
960 }
961
962 SbxMethod::SbxMethod( const OUString& r, SbxDataType t )
963 : SbxVariable( t )
964 {
965 SetName( r );
966 }
967
968 SbxMethod::SbxMethod( const SbxMethod& r )
969 : SvRefBase( r ), SbxVariable( r )
970 {
971 }
972
973 SbxMethod::~SbxMethod()
974 {
975 }
976
977 SbxClassType SbxMethod::GetClass() const
978 {
979 return SbxCLASS_METHOD;
980 }
981
982 SbxProperty::SbxProperty( const OUString& r, SbxDataType t )
983 : SbxVariable( t )
984 {
985 SetName( r );
986 }
987
988 SbxProperty::~SbxProperty()
989 {
990 }
991
992 SbxClassType SbxProperty::GetClass() const
993 {
994 return SbxCLASS_PROPERTY;
995 }
996
997 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE