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