Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <config_features.h>
21 :
22 : #include <tools/debug.hxx>
23 : #include <tools/stream.hxx>
24 : #include <svl/SfxBroadcaster.hxx>
25 :
26 : #include <basic/sbx.hxx>
27 : #include "runtime.hxx"
28 : #include "sbxres.hxx"
29 : #include "sbxconv.hxx"
30 : #include "sbunoobj.hxx"
31 : #include <math.h>
32 : #include <ctype.h>
33 :
34 : #include <com/sun/star/uno/XInterface.hpp>
35 : using namespace com::sun::star::uno;
36 :
37 : ///////////////////////////// SbxVariable
38 :
39 934000 : TYPEINIT1(SbxVariable,SbxValue)
40 :
41 : ///////////////////////////// SbxVariableImpl
42 :
43 540 : class SbxVariableImpl
44 : {
45 : friend class SbxVariable;
46 : OUString m_aDeclareClassName;
47 : Reference< XInterface > m_xComListener;
48 : StarBASIC* m_pComListenerParentBasic;
49 :
50 270 : SbxVariableImpl( void )
51 270 : : m_pComListenerParentBasic( NULL )
52 270 : {}
53 270 : SbxVariableImpl( const SbxVariableImpl& r )
54 : : m_aDeclareClassName( r.m_aDeclareClassName )
55 : , m_xComListener( r.m_xComListener )
56 270 : , m_pComListenerParentBasic( r.m_pComListenerParentBasic )
57 : {
58 270 : }
59 : };
60 :
61 :
62 : ///////////////////////////// Constructors
63 :
64 12914 : SbxVariable::SbxVariable() : SbxValue()
65 : {
66 12914 : mpSbxVariableImpl = NULL;
67 12914 : pCst = NULL;
68 12914 : pParent = NULL;
69 12914 : nUserData = 0;
70 12914 : nHash = 0;
71 12914 : }
72 :
73 15302 : SbxVariable::SbxVariable( const SbxVariable& r )
74 : : SvRefBase( r ),
75 : SbxValue( r ),
76 : mpPar( r.mpPar ),
77 15302 : pInfo( r.pInfo )
78 : {
79 15302 : mpSbxVariableImpl = NULL;
80 15302 : if( r.mpSbxVariableImpl != NULL )
81 : {
82 0 : mpSbxVariableImpl = new SbxVariableImpl( *r.mpSbxVariableImpl );
83 : #if HAVE_FEATURE_SCRIPTING
84 0 : if( mpSbxVariableImpl->m_xComListener.is() )
85 : {
86 0 : registerComListenerVariableForBasic( this, mpSbxVariableImpl->m_pComListenerParentBasic );
87 : }
88 : #endif
89 : }
90 15302 : pCst = NULL;
91 15302 : if( r.CanRead() )
92 : {
93 15302 : pParent = r.pParent;
94 15302 : nUserData = r.nUserData;
95 15302 : maName = r.maName;
96 15302 : nHash = r.nHash;
97 : }
98 : else
99 : {
100 0 : pParent = NULL;
101 0 : nUserData = 0;
102 0 : nHash = 0;
103 : }
104 15302 : }
105 :
106 245052 : SbxVariable::SbxVariable( SbxDataType t, void* p ) : SbxValue( t, p )
107 : {
108 245052 : mpSbxVariableImpl = NULL;
109 245052 : pCst = NULL;
110 245052 : pParent = NULL;
111 245052 : nUserData = 0;
112 245052 : nHash = 0;
113 245052 : }
114 :
115 548898 : SbxVariable::~SbxVariable()
116 : {
117 : #if HAVE_FEATURE_SCRIPTING
118 258958 : if( IsSet( SBX_DIM_AS_NEW ))
119 : {
120 2 : removeDimAsNewRecoverItem( this );
121 : }
122 : #endif
123 258958 : delete mpSbxVariableImpl;
124 258958 : delete pCst;
125 289940 : }
126 :
127 : ////////////////////////////// Broadcasting
128 :
129 414012 : SfxBroadcaster& SbxVariable::GetBroadcaster()
130 : {
131 414012 : if( !pCst )
132 : {
133 212952 : pCst = new SfxBroadcaster;
134 : }
135 414012 : return *pCst;
136 : }
137 :
138 22254 : SbxArray* SbxVariable::GetParameters() const
139 : {
140 22254 : return mpPar;
141 : }
142 :
143 :
144 : // Perhaps some day one could cut the parameter 0.
145 : // then the copying will be dropped ...
146 :
147 573434 : void SbxVariable::Broadcast( sal_uIntPtr nHintId )
148 : {
149 573434 : if( pCst && !IsSet( SBX_NO_BROADCAST ) )
150 : {
151 : // Because the method could be called from outside, check the
152 : // rights here again
153 164566 : if( nHintId & SBX_HINT_DATAWANTED )
154 : {
155 160728 : if( !CanRead() )
156 : {
157 0 : return;
158 : }
159 : }
160 164566 : if( nHintId & SBX_HINT_DATACHANGED )
161 : {
162 3836 : if( !CanWrite() )
163 : {
164 0 : return;
165 : }
166 : }
167 : // Avoid further broadcasting
168 164566 : SfxBroadcaster* pSave = pCst;
169 164566 : pCst = NULL;
170 164566 : SbxFlagBits nSaveFlags = GetFlags();
171 164566 : SetFlag( SBX_READWRITE );
172 164566 : if( mpPar.Is() )
173 : {
174 : // Register this as element 0, but don't change over the parent!
175 4446 : mpPar->GetRef( 0 ) = this;
176 : }
177 164566 : pSave->Broadcast( SbxHint( nHintId, this ) );
178 164566 : delete pCst; // who knows already, onto which thoughts someone comes?
179 164566 : pCst = pSave;
180 164566 : SetFlags( nSaveFlags );
181 : }
182 : }
183 :
184 2 : SbxInfo* SbxVariable::GetInfo()
185 : {
186 2 : if( !pInfo )
187 : {
188 2 : Broadcast( SBX_HINT_INFOWANTED );
189 2 : if( pInfo.Is() )
190 : {
191 2 : SetModified( true );
192 : }
193 : }
194 2 : return pInfo;
195 : }
196 :
197 820 : void SbxVariable::SetInfo( SbxInfo* p )
198 : {
199 820 : pInfo = p;
200 820 : }
201 :
202 60204 : void SbxVariable::SetParameters( SbxArray* p )
203 : {
204 60204 : mpPar = p;
205 60204 : }
206 :
207 :
208 : /////////////////////////// Name of the variables
209 :
210 239948 : void SbxVariable::SetName( const OUString& rName )
211 : {
212 239948 : maName = rName;
213 239948 : nHash = MakeHashCode( rName );
214 239948 : }
215 :
216 679944 : const OUString& SbxVariable::GetName( SbxNameType t ) const
217 : {
218 : static const char cSuffixes[] = " %&!#@ $";
219 679944 : if( t == SbxNAME_NONE )
220 : {
221 679944 : return maName;
222 : }
223 : // Request parameter-information (not for objects)
224 0 : ((SbxVariable*)this)->GetInfo();
225 : // Append nothing, if it is a simple property (no empty brackets)
226 0 : if( !pInfo || ( pInfo->aParams.empty() && GetClass() == SbxCLASS_PROPERTY ))
227 : {
228 0 : return maName;
229 : }
230 0 : sal_Unicode cType = ' ';
231 0 : OUString aTmp( maName );
232 : // short type? Then fetch it, posible this is 0.
233 0 : SbxDataType et = GetType();
234 0 : if( t == SbxNAME_SHORT_TYPES )
235 : {
236 0 : if( et <= SbxSTRING )
237 : {
238 0 : cType = cSuffixes[ et ];
239 : }
240 0 : if( cType != ' ' )
241 : {
242 0 : aTmp += OUString(sal_Unicode(cType));
243 : }
244 : }
245 0 : aTmp += "(";
246 :
247 0 : for(SbxParams::const_iterator i = pInfo->aParams.begin(); i != pInfo->aParams.end(); ++i)
248 : {
249 0 : int nt = i->eType & 0x0FFF;
250 0 : if( i != pInfo->aParams.begin() )
251 : {
252 0 : aTmp += ",";
253 : }
254 0 : if( (i->nFlags & SBX_OPTIONAL) != SBX_NONE )
255 : {
256 0 : aTmp += OUString( SbxRes( STRING_OPTIONAL ) );
257 : }
258 0 : if( i->eType & SbxBYREF )
259 : {
260 0 : aTmp += OUString( SbxRes( STRING_BYREF ) );
261 : }
262 0 : aTmp += i->aName;
263 0 : cType = ' ';
264 : // short type? Then fetch it, posible this is 0.
265 0 : if( t == SbxNAME_SHORT_TYPES )
266 : {
267 0 : if( nt <= SbxSTRING )
268 : {
269 0 : cType = cSuffixes[ nt ];
270 : }
271 : }
272 0 : if( cType != ' ' )
273 : {
274 0 : aTmp += OUString((sal_Unicode)cType);
275 0 : if( i->eType & SbxARRAY )
276 : {
277 0 : aTmp += "()";
278 : }
279 : }
280 : else
281 : {
282 0 : if( i->eType & SbxARRAY )
283 : {
284 0 : aTmp += "()";
285 : }
286 : // long type?
287 0 : if( t != SbxNAME_SHORT )
288 : {
289 0 : aTmp += OUString( SbxRes( STRING_AS ) );
290 0 : if( nt < 32 )
291 : {
292 0 : aTmp += OUString( SbxRes( sal::static_int_cast< sal_uInt16 >( STRING_TYPES + nt ) ) );
293 : }
294 : else
295 : {
296 0 : aTmp += OUString( SbxRes( STRING_ANY ) );
297 : }
298 : }
299 : }
300 : }
301 0 : aTmp += ")";
302 : // Long type? Then fetch it
303 0 : if( t == SbxNAME_LONG_TYPES && et != SbxEMPTY )
304 : {
305 0 : aTmp += OUString( SbxRes( STRING_AS ) );
306 0 : if( et < 32 )
307 : {
308 0 : aTmp += OUString( SbxRes( sal::static_int_cast< sal_uInt16 >( STRING_TYPES + et ) ) );
309 : }
310 : else
311 : {
312 0 : aTmp += OUString( SbxRes( STRING_ANY ) );
313 : }
314 : }
315 0 : ((SbxVariable*) this)->aToolString = aTmp;
316 0 : return aToolString;
317 : }
318 :
319 : // Create a simple hashcode: the first six characters were evaluated.
320 :
321 4047546 : sal_uInt16 SbxVariable::MakeHashCode( const OUString& rName )
322 : {
323 4047546 : sal_uInt16 n = 0;
324 4047546 : sal_Int32 i = 0;
325 4047546 : sal_uInt16 nLen = rName.getLength();
326 4047546 : if( nLen > 6 )
327 : {
328 3555154 : nLen = 6;
329 : }
330 31870288 : while( nLen-- )
331 : {
332 23775196 : sal_uInt8 c = (sal_uInt8)rName[i++];
333 : // If we have a commen sigen break!!
334 23775196 : if( c >= 0x80 )
335 : {
336 0 : return 0;
337 : }
338 23775196 : n = sal::static_int_cast< sal_uInt16 >( ( n << 3 ) + toupper( c ) );
339 : }
340 4047546 : return n;
341 : }
342 :
343 : ////////////////////////////// Operators
344 :
345 11486 : SbxVariable& SbxVariable::operator=( const SbxVariable& r )
346 : {
347 11486 : SbxValue::operator=( r );
348 11486 : delete mpSbxVariableImpl;
349 11486 : if( r.mpSbxVariableImpl != NULL )
350 : {
351 270 : mpSbxVariableImpl = new SbxVariableImpl( *r.mpSbxVariableImpl );
352 : #if HAVE_FEATURE_SCRIPTING
353 270 : if( mpSbxVariableImpl->m_xComListener.is() )
354 : {
355 0 : registerComListenerVariableForBasic( this, mpSbxVariableImpl->m_pComListenerParentBasic );
356 : }
357 : #endif
358 : }
359 : else
360 : {
361 11216 : mpSbxVariableImpl = NULL;
362 : }
363 11486 : return *this;
364 : }
365 :
366 : //////////////////////////////// Conversion
367 :
368 276340 : SbxDataType SbxVariable::GetType() const
369 : {
370 276340 : if( aData.eType == SbxOBJECT )
371 : {
372 25002 : return aData.pObj ? aData.pObj->GetType() : SbxOBJECT;
373 : }
374 251338 : else if( aData.eType == SbxVARIANT )
375 : {
376 0 : return aData.pObj ? aData.pObj->GetType() : SbxVARIANT;
377 : }
378 : else
379 : {
380 251338 : return aData.eType;
381 : }
382 : }
383 :
384 18 : SbxClassType SbxVariable::GetClass() const
385 : {
386 18 : return SbxCLASS_VARIABLE;
387 : }
388 :
389 384936 : void SbxVariable::SetModified( bool b )
390 : {
391 384936 : if( IsSet( SBX_NO_MODIFY ) )
392 : {
393 393264 : return;
394 : }
395 376608 : SbxBase::SetModified( b );
396 376608 : if( pParent && pParent != this ) //??? HotFix: Recursion out here MM
397 : {
398 18046 : pParent->SetModified( b );
399 : }
400 : }
401 :
402 323304 : void SbxVariable::SetParent( SbxObject* p )
403 : {
404 : #ifdef DBG_UTIL
405 : // Will the parent of a SbxObject be set?
406 : if ( p && ISA(SbxObject) )
407 : {
408 : // then this had to be a child of the new parent
409 : bool bFound = false;
410 : SbxArray *pChildren = p->GetObjects();
411 : if ( pChildren )
412 : {
413 : for ( sal_uInt16 nIdx = 0; !bFound && nIdx < pChildren->Count(); ++nIdx )
414 : {
415 : bFound = ( this == pChildren->Get(nIdx) );
416 : }
417 : }
418 : SAL_INFO_IF(
419 : !bFound, "basic.sbx",
420 : "dangling: [" << GetName() << "].SetParent([" << p->GetName()
421 : << "])");
422 : }
423 : #endif
424 :
425 323304 : pParent = p;
426 323304 : }
427 :
428 270 : SbxVariableImpl* SbxVariable::getImpl( void )
429 : {
430 270 : if( mpSbxVariableImpl == NULL )
431 : {
432 270 : mpSbxVariableImpl = new SbxVariableImpl();
433 : }
434 270 : return mpSbxVariableImpl;
435 : }
436 :
437 0 : const OUString& SbxVariable::GetDeclareClassName( void )
438 : {
439 0 : SbxVariableImpl* pImpl = getImpl();
440 0 : return pImpl->m_aDeclareClassName;
441 : }
442 :
443 270 : void SbxVariable::SetDeclareClassName( const OUString& rDeclareClassName )
444 : {
445 270 : SbxVariableImpl* pImpl = getImpl();
446 270 : pImpl->m_aDeclareClassName = rDeclareClassName;
447 270 : }
448 :
449 0 : void SbxVariable::SetComListener( ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xComListener,
450 : StarBASIC* pParentBasic )
451 : {
452 0 : SbxVariableImpl* pImpl = getImpl();
453 0 : pImpl->m_xComListener = xComListener;
454 0 : pImpl->m_pComListenerParentBasic = pParentBasic;
455 : #if HAVE_FEATURE_SCRIPTING
456 0 : registerComListenerVariableForBasic( this, pParentBasic );
457 : #endif
458 0 : }
459 :
460 0 : void SbxVariable::ClearComListener( void )
461 : {
462 0 : SbxVariableImpl* pImpl = getImpl();
463 0 : pImpl->m_xComListener.clear();
464 0 : }
465 :
466 :
467 : ////////////////////////////// Loading/Saving
468 :
469 0 : bool SbxVariable::LoadData( SvStream& rStrm, sal_uInt16 nVer )
470 : {
471 : sal_uInt16 nType;
472 : sal_uInt8 cMark;
473 0 : rStrm.ReadUChar( cMark );
474 0 : if( cMark == 0xFF )
475 : {
476 0 : if( !SbxValue::LoadData( rStrm, nVer ) )
477 : {
478 0 : return false;
479 : }
480 0 : maName = read_uInt16_lenPrefixed_uInt8s_ToOUString(rStrm,
481 0 : RTL_TEXTENCODING_ASCII_US);
482 : sal_uInt32 nTemp;
483 0 : rStrm.ReadUInt32( nTemp );
484 0 : nUserData = nTemp;
485 : }
486 : else
487 : {
488 0 : rStrm.SeekRel( -1L );
489 0 : rStrm.ReadUInt16( nType );
490 0 : maName = read_uInt16_lenPrefixed_uInt8s_ToOUString(rStrm,
491 0 : RTL_TEXTENCODING_ASCII_US);
492 : sal_uInt32 nTemp;
493 0 : rStrm.ReadUInt32( nTemp );
494 0 : nUserData = nTemp;
495 : // correction: old methods have instead of SbxNULL now SbxEMPTY
496 0 : if( nType == SbxNULL && GetClass() == SbxCLASS_METHOD )
497 : {
498 0 : nType = SbxEMPTY;
499 : }
500 0 : SbxValues aTmp;
501 0 : OUString aTmpString;
502 0 : OUString aVal;
503 0 : aTmp.eType = aData.eType = (SbxDataType) nType;
504 0 : aTmp.pOUString = &aVal;
505 0 : switch( nType )
506 : {
507 : case SbxBOOL:
508 : case SbxERROR:
509 : case SbxINTEGER:
510 0 : rStrm.ReadInt16( aTmp.nInteger ); break;
511 : case SbxLONG:
512 0 : rStrm.ReadInt32( aTmp.nLong ); break;
513 : case SbxSINGLE:
514 : {
515 : // Floats as ASCII
516 0 : aTmpString = read_uInt16_lenPrefixed_uInt8s_ToOUString(
517 0 : rStrm, RTL_TEXTENCODING_ASCII_US);
518 : double d;
519 : SbxDataType t;
520 0 : if( ImpScan( aTmpString, d, t, NULL ) != SbxERR_OK || t == SbxDOUBLE )
521 : {
522 0 : aTmp.nSingle = 0;
523 0 : return false;
524 : }
525 0 : aTmp.nSingle = (float) d;
526 0 : break;
527 : }
528 : case SbxDATE:
529 : case SbxDOUBLE:
530 : {
531 : // Floats as ASCII
532 0 : aTmpString = read_uInt16_lenPrefixed_uInt8s_ToOUString(rStrm,
533 0 : RTL_TEXTENCODING_ASCII_US);
534 : SbxDataType t;
535 0 : if( ImpScan( aTmpString, aTmp.nDouble, t, NULL ) != SbxERR_OK )
536 : {
537 0 : aTmp.nDouble = 0;
538 0 : return false;
539 : }
540 0 : break;
541 : }
542 : case SbxSTRING:
543 0 : aVal = read_uInt16_lenPrefixed_uInt8s_ToOUString(rStrm,
544 0 : RTL_TEXTENCODING_ASCII_US);
545 0 : break;
546 : case SbxEMPTY:
547 : case SbxNULL:
548 0 : break;
549 : default:
550 0 : aData.eType = SbxNULL;
551 : DBG_ASSERT( false, "Loaded a non-supported data type" );
552 0 : return false;
553 : }
554 : // putt value
555 0 : if( nType != SbxNULL && nType != SbxEMPTY && !Put( aTmp ) )
556 : {
557 0 : return false;
558 0 : }
559 : }
560 0 : rStrm.ReadUChar( cMark );
561 : // cMark is also a version number!
562 : // 1: initial version
563 : // 2: with nUserData
564 0 : if( cMark )
565 : {
566 0 : if( cMark > 2 )
567 : {
568 0 : return false;
569 : }
570 0 : pInfo = new SbxInfo;
571 0 : pInfo->LoadData( rStrm, (sal_uInt16) cMark );
572 : }
573 : // Load private data only, if it is a SbxVariable
574 0 : if( GetClass() == SbxCLASS_VARIABLE && !LoadPrivateData( rStrm, nVer ) )
575 : {
576 0 : return false;
577 : }
578 0 : ((SbxVariable*) this)->Broadcast( SBX_HINT_DATACHANGED );
579 0 : nHash = MakeHashCode( maName );
580 0 : SetModified( true );
581 0 : return true;
582 : }
583 :
584 0 : bool SbxVariable::StoreData( SvStream& rStrm ) const
585 : {
586 0 : rStrm.WriteUChar( 0xFF ); // Marker
587 : bool bValStore;
588 0 : if( this->IsA( TYPE(SbxMethod) ) )
589 : {
590 : // #50200 Avoid that objects , which during the runtime
591 : // as return-value are saved in the method as a value were saved
592 0 : SbxVariable* pThis = (SbxVariable*)this;
593 0 : SbxFlagBits nSaveFlags = GetFlags();
594 0 : pThis->SetFlag( SBX_WRITE );
595 0 : pThis->SbxValue::Clear();
596 0 : pThis->SetFlags( nSaveFlags );
597 :
598 : // So that the method will not be executed in any case!
599 : // CAST, to avoid const!
600 0 : pThis->SetFlag( SBX_NO_BROADCAST );
601 0 : bValStore = SbxValue::StoreData( rStrm );
602 0 : pThis->ResetFlag( SBX_NO_BROADCAST );
603 : }
604 : else
605 : {
606 0 : bValStore = SbxValue::StoreData( rStrm );
607 : }
608 0 : if( !bValStore )
609 : {
610 0 : return false;
611 : }
612 : write_uInt16_lenPrefixed_uInt8s_FromOUString(rStrm, maName,
613 0 : RTL_TEXTENCODING_ASCII_US);
614 0 : rStrm.WriteUInt32( nUserData );
615 0 : if( pInfo.Is() )
616 : {
617 0 : rStrm.WriteUChar( 2 ); // Version 2: with UserData!
618 0 : pInfo->StoreData( rStrm );
619 : }
620 : else
621 : {
622 0 : rStrm.WriteUChar( 0 );
623 : }
624 : // Save private data only, if it is a SbxVariable
625 0 : if( GetClass() == SbxCLASS_VARIABLE )
626 : {
627 0 : return StorePrivateData( rStrm );
628 : }
629 : else
630 : {
631 0 : return true;
632 : }
633 : }
634 :
635 : ////////////////////////////// SbxInfo
636 :
637 118 : SbxInfo::SbxInfo() : aHelpFile(), nHelpId( 0 ), aParams()
638 118 : {}
639 :
640 818 : SbxInfo::SbxInfo( const OUString& r, sal_uInt32 n )
641 818 : : aHelpFile( r ), nHelpId( n ), aParams()
642 818 : {}
643 :
644 : ////////////////////////////// SbxAlias
645 :
646 0 : SbxAlias::SbxAlias( const SbxAlias& r )
647 : : SvRefBase( r ), SbxVariable( r ),
648 0 : SfxListener( r ), xAlias( r.xAlias )
649 0 : {}
650 :
651 0 : SbxAlias& SbxAlias::operator=( const SbxAlias& r )
652 : {
653 0 : xAlias = r.xAlias;
654 0 : return *this;
655 : }
656 :
657 0 : SbxAlias::~SbxAlias()
658 : {
659 0 : if( xAlias.Is() )
660 : {
661 0 : EndListening( xAlias->GetBroadcaster() );
662 : }
663 0 : }
664 :
665 0 : void SbxAlias::Broadcast( sal_uIntPtr nHt )
666 : {
667 0 : if( xAlias.Is() )
668 : {
669 0 : xAlias->SetParameters( GetParameters() );
670 0 : if( nHt == SBX_HINT_DATAWANTED )
671 : {
672 0 : SbxVariable::operator=( *xAlias );
673 : }
674 0 : else if( nHt == SBX_HINT_DATACHANGED || nHt == SBX_HINT_CONVERTED )
675 : {
676 0 : *xAlias = *this;
677 : }
678 0 : else if( nHt == SBX_HINT_INFOWANTED )
679 : {
680 0 : xAlias->Broadcast( nHt );
681 0 : pInfo = xAlias->GetInfo();
682 : }
683 : }
684 0 : }
685 :
686 0 : void SbxAlias::SFX_NOTIFY( SfxBroadcaster&, const TypeId&,
687 : const SfxHint& rHint, const TypeId& )
688 : {
689 0 : const SbxHint* p = dynamic_cast<const SbxHint*>(&rHint);
690 0 : if( p && p->GetId() == SBX_HINT_DYING )
691 : {
692 0 : xAlias.Clear();
693 : // delete the alias?
694 0 : if( pParent )
695 : {
696 0 : pParent->Remove( this );
697 : }
698 : }
699 0 : }
700 :
701 0 : void SbxVariable::Dump( SvStream& rStrm, bool bFill )
702 : {
703 0 : OString aBNameStr(OUStringToOString(GetName( SbxNAME_SHORT_TYPES ), RTL_TEXTENCODING_ASCII_US));
704 0 : rStrm.WriteCharPtr( "Variable( " )
705 0 : .WriteCharPtr( OString::number(reinterpret_cast<sal_Int64>(this)).getStr() ).WriteCharPtr( "==" )
706 0 : .WriteCharPtr( aBNameStr.getStr() );
707 0 : OString aBParentNameStr(OUStringToOString(GetParent()->GetName(), RTL_TEXTENCODING_ASCII_US));
708 0 : if ( GetParent() )
709 : {
710 0 : rStrm.WriteCharPtr( " in parent '" ).WriteCharPtr( aBParentNameStr.getStr() ).WriteCharPtr( "'" );
711 : }
712 : else
713 : {
714 0 : rStrm.WriteCharPtr( " no parent" );
715 : }
716 0 : rStrm.WriteCharPtr( " ) " );
717 :
718 : // output also the object at object-vars
719 0 : if ( GetValues_Impl().eType == SbxOBJECT &&
720 0 : GetValues_Impl().pObj &&
721 0 : GetValues_Impl().pObj != this &&
722 0 : GetValues_Impl().pObj != GetParent() )
723 : {
724 0 : rStrm.WriteCharPtr( " contains " );
725 0 : static_cast<SbxObject*>(GetValues_Impl().pObj)->Dump( rStrm, bFill );
726 : }
727 : else
728 : {
729 0 : rStrm << endl;
730 0 : }
731 0 : }
732 :
733 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
