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