?  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 / sbx / sbxobj.cxx
blob625917eb2fab357bfc31baa1586d7b25ddac1e5b
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 // 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 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 // 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 OString aNameStr3(OUStringToOString(rName, RTL_TEXTENCODING_ASCII_US));
287 OString aNameStr4(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, "Invalid SBX-Class" ); 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, "Invalid SBX-Class" ); 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 OString aNameStr1(OUStringToOString(aVarName, RTL_TEXTENCODING_ASCII_US));
503 OString aNameStr2(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(), aNameStr2.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, "Invalid SBX-Class" ); 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 OString aNameStr1(OUStringToOString(aVarName, RTL_TEXTENCODING_ASCII_US));
546 OString aNameStr2(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(), aNameStr2.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 OString aNameStr1(OUStringToOString(aVarName, RTL_TEXTENCODING_ASCII_US));
573 OString aNameStr2(OUStringToOString(SbxVariable::GetName(), RTL_TEXTENCODING_ASCII_US));
574 DbgOutf( "SBX: Remove %s in %s",
575 aNameStr1.getStr(), aNameStr2.getStr() );
576 #endif
577 SbxVariableRef pVar_ = pArray->Get( nIdx );
578 if( pVar_->IsBroadcaster() )
579 {
580 EndListening( pVar_->GetBroadcaster(), sal_True );
581 }
582 if( (SbxVariable*) pVar_ == pDfltProp )
583 {
584 pDfltProp = NULL;
585 }
586 pArray->Remove( nIdx );
587 if( pVar_->GetParent() == this )
588 {
589 pVar_->SetParent( NULL );
590 }
591 SetModified( sal_True );
592 Broadcast( SBX_HINT_OBJECTCHANGED );
593 }
594 }
595
596 static sal_Bool LoadArray( SvStream& rStrm, SbxObject* pThis, SbxArray* pArray )
597 {
598 SbxArrayRef p = (SbxArray*) SbxBase::Load( rStrm );
599 if( !p.Is() )
600 {
601 return sal_False;
602 }
603 for( sal_uInt16 i = 0; i < p->Count(); i++ )
604 {
605 SbxVariableRef& r = p->GetRef( i );
606 SbxVariable* pVar = r;
607 if( pVar )
608 {
609 pVar->SetParent( pThis );
610 pThis->StartListening( pVar->GetBroadcaster(), sal_True );
611 }
612 }
613 pArray->Merge( p );
614 return sal_True;
615 }
616
617 // The load of an object is additive!
618
619 sal_Bool SbxObject::LoadData( SvStream& rStrm, sal_uInt16 nVer )
620 {
621 // Help for the read in of old objects: just TRUE back,
622 // LoadPrivateData() had to set the default status up
623 if( !nVer )
624 {
625 return sal_True;
626 }
627 pDfltProp = NULL;
628 if( !SbxVariable::LoadData( rStrm, nVer ) )
629 {
630 return sal_False;
631 }
632 // If it contains no alien object, insert ourselves
633 if( aData.eType == SbxOBJECT && !aData.pObj )
634 {
635 aData.pObj = this;
636 }
637 sal_uInt32 nSize;
638 OUString aDfltProp;
639 aClassName = read_lenPrefixed_uInt8s_ToOUString<sal_uInt16>(rStrm, RTL_TEXTENCODING_ASCII_US);
640 aDfltProp = read_lenPrefixed_uInt8s_ToOUString<sal_uInt16>(rStrm, RTL_TEXTENCODING_ASCII_US);
641 sal_uIntPtr nPos = rStrm.Tell();
642 rStrm >> nSize;
643 if( !LoadPrivateData( rStrm, nVer ) )
644 {
645 return sal_False;
646 }
647 sal_uIntPtr nNewPos = rStrm.Tell();
648 nPos += nSize;
649 DBG_ASSERT( nPos >= nNewPos, "SBX: Loaded too much data" );
650 if( nPos != nNewPos )
651 {
652 rStrm.Seek( nPos );
653 }
654 if( !LoadArray( rStrm, this, pMethods ) ||
655 !LoadArray( rStrm, this, pProps ) ||
656 !LoadArray( rStrm, this, pObjs ) )
657 {
658 return sal_False;
659 }
660 // Set properties
661 if( !aDfltProp.isEmpty() )
662 {
663 pDfltProp = (SbxProperty*) pProps->Find( aDfltProp, SbxCLASS_PROPERTY );
664 }
665 SetModified( sal_False );
666 return sal_True;
667 }
668
669 sal_Bool SbxObject::StoreData( SvStream& rStrm ) const
670 {
671 if( !SbxVariable::StoreData( rStrm ) )
672 {
673 return sal_False;
674 }
675 OUString aDfltProp;
676 if( pDfltProp )
677 {
678 aDfltProp = pDfltProp->GetName();
679 }
680 write_lenPrefixed_uInt8s_FromOUString<sal_uInt16>(rStrm, aClassName, RTL_TEXTENCODING_ASCII_US);
681 write_lenPrefixed_uInt8s_FromOUString<sal_uInt16>(rStrm, aDfltProp, RTL_TEXTENCODING_ASCII_US);
682 sal_uIntPtr nPos = rStrm.Tell();
683 rStrm << (sal_uInt32) 0L;
684 if( !StorePrivateData( rStrm ) )
685 {
686 return sal_False;
687 }
688 sal_uIntPtr nNew = rStrm.Tell();
689 rStrm.Seek( nPos );
690 rStrm << (sal_uInt32) ( nNew - nPos );
691 rStrm.Seek( nNew );
692 if( !pMethods->Store( rStrm ) )
693 {
694 return sal_False;
695 }
696 if( !pProps->Store( rStrm ) )
697 {
698 return sal_False;
699 }
700 if( !pObjs->Store( rStrm ) )
701 {
702 return sal_False;
703 }
704 ((SbxObject*) this)->SetModified( sal_False );
705 return sal_True;
706 }
707
708 OUString SbxObject::GenerateSource( const OUString &rLinePrefix,
709 const SbxObject* )
710 {
711 // Collect the properties in a String
712 OUString aSource;
713 SbxArrayRef xProps( GetProperties() );
714 bool bLineFeed = false;
715 for ( sal_uInt16 nProp = 0; nProp < xProps->Count(); ++nProp )
716 {
717 SbxPropertyRef xProp = (SbxProperty*) xProps->Get(nProp);
718 OUString aPropName( xProp->GetName() );
719 if ( xProp->CanWrite() &&
720 !( xProp->GetHashCode() == nNameHash &&
721 aPropName.equalsIgnoreAsciiCase(pNameProp)))
722 {
723 // Insert a break except in front of the first property
724 if ( bLineFeed )
725 {
726 aSource += "\n";
727 }
728 else
729 {
730 bLineFeed = true;
731 }
732 aSource += rLinePrefix;
733 aSource += ".";
734 aSource += aPropName;
735 aSource += " = ";
736
737 // Display the property value textual
738 switch ( xProp->GetType() )
739 {
740 case SbxEMPTY:
741 case SbxNULL:
742 // no value
743 break;
744
745 case SbxSTRING:
746 // Strings in quotation mark
747 aSource += "\"";
748 aSource += xProp->GetOUString();
749 aSource += "\"";
750 break;
751
752 default:
753 // miscellaneous, such as e.g.numerary directly
754 aSource += xProp->GetOUString();
755 break;
756 }
757 }
758 }
759 return aSource;
760 }
761
762 static sal_Bool CollectAttrs( const SbxBase* p, OUString& rRes )
763 {
764 OUString aAttrs;
765 if( p->IsHidden() )
766 {
767 aAttrs = "Hidden";
768 }
769 if( p->IsSet( SBX_EXTSEARCH ) )
770 {
771 if( !aAttrs.isEmpty() )
772 {
773 aAttrs += ",";
774 }
775 aAttrs += "ExtSearch";
776 }
777 if( !p->IsVisible() )
778 {
779 if( !aAttrs.isEmpty() )
780 {
781 aAttrs += ",";
782 }
783 aAttrs += "Invisible";
784 }
785 if( p->IsSet( SBX_DONTSTORE ) )
786 {
787 if( !aAttrs.isEmpty() )
788 {
789 aAttrs += ",";
790 }
791 aAttrs += "DontStore";
792 }
793 if( !aAttrs.isEmpty() )
794 {
795 rRes = " (";
796 rRes += aAttrs;
797 rRes += ")";
798 return sal_True;
799 }
800 else
801 {
802 rRes = "";
803 return sal_False;
804 }
805 }
806
807 void SbxObject::Dump( SvStream& rStrm, sal_Bool bFill )
808 {
809 // Shifting
810 static sal_uInt16 nLevel = 0;
811 if ( nLevel > 10 )
812 {
813 rStrm << "<too deep>" << endl;
814 return;
815 }
816 ++nLevel;
817 OUString aIndent("");
818 for ( sal_uInt16 n = 1; n < nLevel; ++n )
819 {
820 aIndent += " ";
821 }
822 // if necessary complete the object
823 if ( bFill )
824 {
825 GetAll( SbxCLASS_DONTCARE );
826 }
827 // Output the data of the object itself
828 OString aNameStr(OUStringToOString(GetName(), RTL_TEXTENCODING_ASCII_US));
829 OString aClassNameStr(OUStringToOString(aClassName, RTL_TEXTENCODING_ASCII_US));
830 rStrm << "Object( "
831 << OString::valueOf(reinterpret_cast<sal_Int64>(this)).getStr()<< "=='"
832 << ( aNameStr.isEmpty() ? "<unnamed>" : aNameStr.getStr() ) << "', "
833 << "of class '" << aClassNameStr.getStr() << "', "
834 << "counts "
835 << OString::number(GetRefCount()).getStr()
836 << " refs, ";
837 if ( GetParent() )
838 {
839 OString aParentNameStr(OUStringToOString(GetName(), RTL_TEXTENCODING_ASCII_US));
840 rStrm << "in parent "
841 << OString::valueOf(reinterpret_cast<sal_Int64>(GetParent())).getStr()
842 << "=='" << ( aParentNameStr.isEmpty() ? "<unnamed>" : aParentNameStr.getStr() ) << "'";
843 }
844 else
845 {
846 rStrm << "no parent ";
847 }
848 rStrm << " )" << endl;
849 OString aIndentNameStr(OUStringToOString(aIndent, RTL_TEXTENCODING_ASCII_US));
850 rStrm << aIndentNameStr.getStr() << "{" << endl;
851
852 // Flags
853 OUString aAttrs;
854 if( CollectAttrs( this, aAttrs ) )
855 {
856 OString aAttrStr(OUStringToOString(aAttrs, RTL_TEXTENCODING_ASCII_US));
857 rStrm << aIndentNameStr.getStr() << "- Flags: " << aAttrStr.getStr() << endl;
858 }
859
860 // Methods
861 rStrm << aIndentNameStr.getStr() << "- Methods:" << endl;
862 for( sal_uInt16 i = 0; i < pMethods->Count(); i++ )
863 {
864 SbxVariableRef& r = pMethods->GetRef( i );
865 SbxVariable* pVar = r;
866 if( pVar )
867 {
868 OUString aLine( aIndent );
869 aLine += " - ";
870 aLine += pVar->GetName( SbxNAME_SHORT_TYPES );
871 OUString aAttrs2;
872 if( CollectAttrs( pVar, aAttrs2 ) )
873 {
874 aLine += aAttrs2;
875 }
876 if( !pVar->IsA( TYPE(SbxMethod) ) )
877 {
878 aLine += " !! Not a Method !!";
879 }
880 write_lenPrefixed_uInt8s_FromOUString<sal_uInt16>(rStrm, aLine, RTL_TEXTENCODING_ASCII_US);
881
882 // Output also the object at object-methods
883 if ( pVar->GetValues_Impl().eType == SbxOBJECT &&
884 pVar->GetValues_Impl().pObj &&
885 pVar->GetValues_Impl().pObj != this &&
886 pVar->GetValues_Impl().pObj != GetParent() )
887 {
888 rStrm << " contains ";
889 ((SbxObject*) pVar->GetValues_Impl().pObj)->Dump( rStrm, bFill );
890 }
891 else
892 {
893 rStrm << endl;
894 }
895 }
896 }
897
898 // Properties
899 rStrm << aIndentNameStr.getStr() << "- Properties:" << endl;
900 {
901 for( sal_uInt16 i = 0; i < pProps->Count(); i++ )
902 {
903 SbxVariableRef& r = pProps->GetRef( i );
904 SbxVariable* pVar = r;
905 if( pVar )
906 {
907 OUString aLine( aIndent );
908 aLine += " - ";
909 aLine += pVar->GetName( SbxNAME_SHORT_TYPES );
910 OUString aAttrs3;
911 if( CollectAttrs( pVar, aAttrs3 ) )
912 {
913 aLine += aAttrs3;
914 }
915 if( !pVar->IsA( TYPE(SbxProperty) ) )
916 {
917 aLine += " !! Not a Property !!";
918 }
919 write_lenPrefixed_uInt8s_FromOUString<sal_uInt16>(rStrm, aLine, RTL_TEXTENCODING_ASCII_US);
920
921 // output also the object at object properties
922 if ( pVar->GetValues_Impl().eType == SbxOBJECT &&
923 pVar->GetValues_Impl().pObj &&
924 pVar->GetValues_Impl().pObj != this &&
925 pVar->GetValues_Impl().pObj != GetParent() )
926 {
927 rStrm << " contains ";
928 ((SbxObject*) pVar->GetValues_Impl().pObj)->Dump( rStrm, bFill );
929 }
930 else
931 {
932 rStrm << endl;
933 }
934 }
935 }
936 }
937
938 // Objects
939 rStrm << aIndentNameStr.getStr() << "- Objects:" << endl;
940 {
941 for( sal_uInt16 i = 0; i < pObjs->Count(); i++ )
942 {
943 SbxVariableRef& r = pObjs->GetRef( i );
944 SbxVariable* pVar = r;
945 if ( pVar )
946 {
947 rStrm << aIndentNameStr.getStr() << " - Sub";
948 if ( pVar->ISA(SbxObject) )
949 {
950 ((SbxObject*) pVar)->Dump( rStrm, bFill );
951 }
952 else if ( pVar->ISA(SbxVariable) )
953 {
954 ((SbxVariable*) pVar)->Dump( rStrm, bFill );
955 }
956 }
957 }
958 }
959
960 rStrm << aIndentNameStr.getStr() << "}" << endl << endl;
961 --nLevel;
962 }
963
964 SbxMethod::SbxMethod( const OUString& r, SbxDataType t )
965 : SbxVariable( t )
966 {
967 SetName( r );
968 }
969
970 SbxMethod::SbxMethod( const SbxMethod& r )
971 : SvRefBase( r ), SbxVariable( r )
972 {
973 }
974
975 SbxMethod::~SbxMethod()
976 {
977 }
978
979 SbxClassType SbxMethod::GetClass() const
980 {
981 return SbxCLASS_METHOD;
982 }
983
984 SbxProperty::SbxProperty( const OUString& r, SbxDataType t )
985 : SbxVariable( t )
986 {
987 SetName( r );
988 }
989
990 SbxProperty::~SbxProperty()
991 {
992 }
993
994 SbxClassType SbxProperty::GetClass() const
995 {
996 return SbxCLASS_PROPERTY;
997 }
998
999 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE