AOO410/main/basic/source/sbx/sbxbase.cxx - openoffice - Git at Google

 /**************************************************************
  *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  *
  *************************************************************/


 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_basic.hxx"


 #include <tools/shl.hxx>
 #include <tools/stream.hxx>

 #include <basic/sbx.hxx>
 #include <basic/sbxfac.hxx>
 #include <basic/sbxbase.hxx>

 // AppData-Struktur fuer SBX:

 SV_IMPL_PTRARR(SbxParams,SbxParamInfo*);
 SV_IMPL_PTRARR(SbxFacs,SbxFactory*);

 TYPEINIT0(SbxBase)

 // SBX-Daten anfordern oder ggf. anlegen
 // wir legen den Bereich einfach an und verzichten auf die Freigabe!

 SbxAppData* GetSbxData_Impl()
 {
 	SbxAppData** ppData = (SbxAppData**) ::GetAppData( SHL_SBX );
 	SbxAppData* p = *ppData;
 	if( !p )
 		p = *ppData  = new SbxAppData;
 	return p;
 }

 SbxAppData::~SbxAppData()
 {
 	if( pBasicFormater )
 		delete pBasicFormater;
 }


 //////////////////////////////// SbxBase /////////////////////////////////

 DBG_NAME(SbxBase);

 SbxBase::SbxBase()
 {
 	DBG_CTOR( SbxBase, 0 );
 	nFlags  = SBX_READWRITE;
 }

 SbxBase::SbxBase( const SbxBase& r )
     : SvRefBase( r )
 {
 	DBG_CTOR( SbxBase, 0 );
 	nFlags  = r.nFlags;
 }

 SbxBase::~SbxBase()
 {
 	DBG_DTOR(SbxBase,0);
 }

 SbxBase& SbxBase::operator=( const SbxBase& r )
 {
 	DBG_CHKTHIS( SbxBase, 0 );
 	nFlags = r.nFlags;
 	return *this;
 }

 SbxDataType SbxBase::GetType() const
 {
 	DBG_CHKTHIS( SbxBase, 0 );
 	return SbxEMPTY;
 }

 SbxClassType SbxBase::GetClass() const
 {
 	DBG_CHKTHIS( SbxBase, 0 );
 	return SbxCLASS_DONTCARE;
 }

 void SbxBase::Clear()
 {
 	DBG_CHKTHIS( SbxBase, 0 );
 }

 sal_Bool SbxBase::IsFixed() const
 {
 	DBG_CHKTHIS( SbxBase, 0 );
 	return IsSet( SBX_FIXED );
 }

 void SbxBase::SetModified( sal_Bool b )
 {
 	DBG_CHKTHIS( SbxBase, 0 );
 	if( IsSet( SBX_NO_MODIFY ) )
 		return;
 	if( b )
 		SetFlag( SBX_MODIFIED );
 	else
 		ResetFlag( SBX_MODIFIED );
 }

 SbxError SbxBase::GetError()
 {
 	return GetSbxData_Impl()->eSbxError;
 }

 void SbxBase::SetError( SbxError e )
 {
 	SbxAppData* p = GetSbxData_Impl();
 	if( e && p->eSbxError == SbxERR_OK )
 		p->eSbxError = e;
 }

 sal_Bool SbxBase::IsError()
 {
 	return sal_Bool( GetSbxData_Impl()->eSbxError != SbxERR_OK );
 }

 void SbxBase::ResetError()
 {
 	GetSbxData_Impl()->eSbxError = SbxERR_OK;
 }

 void SbxBase::AddFactory( SbxFactory* pFac )
 {
 	SbxAppData* p = GetSbxData_Impl();
 	const SbxFactory* pTemp = pFac;

 	// AB, 6.3.96: HandleLast-Flag beruecksichtigen
 	sal_uInt16 nPos = p->aFacs.Count();		// Einfuege-Position
 	if( !pFac->IsHandleLast() )			// Nur, wenn nicht selbst HandleLast
 	{
 		// Neue Factory vor Factories mit HandleLast einordnen
 		while( nPos > 0 &&
 				(static_cast<SbxFactory*>(p->aFacs.GetObject( nPos-1 )))->IsHandleLast() )
 			nPos--;
 	}
 	p->aFacs.Insert( pTemp, nPos );
 }

 void SbxBase::RemoveFactory( SbxFactory* pFac )
 {
 	SbxAppData* p = GetSbxData_Impl();
 	for( sal_uInt16 i = 0; i < p->aFacs.Count(); i++ )
 	{
 		if( p->aFacs.GetObject( i ) == pFac )
 		{
 			p->aFacs.Remove( i, 1 ); break;
 		}
 	}
 }


 SbxBase* SbxBase::Create( sal_uInt16 nSbxId, sal_uInt32 nCreator )
 {
     // #91626: Hack to skip old Basic dialogs
     // Problem: There does not exist a factory any more,
     // so we have to create a dummy SbxVariable instead
 	if( nSbxId == 0x65 )    // Dialog Id
         return new SbxVariable;

 	XubString aEmptyStr;
 	if( nCreator == SBXCR_SBX )
 	  switch( nSbxId )
 	{
 		case SBXID_VALUE:		return new SbxValue;
 		case SBXID_VARIABLE:	return new SbxVariable;
 		case SBXID_ARRAY:  		return new SbxArray;
 		case SBXID_DIMARRAY:	return new SbxDimArray;
 		case SBXID_OBJECT:		return new SbxObject( aEmptyStr );
 		case SBXID_COLLECTION:	return new SbxCollection( aEmptyStr );
 		case SBXID_FIXCOLLECTION:
 								return new SbxStdCollection( aEmptyStr, aEmptyStr );
 		case SBXID_METHOD:		return new SbxMethod( aEmptyStr, SbxEMPTY );
 		case SBXID_PROPERTY:	return new SbxProperty( aEmptyStr, SbxEMPTY );
 	}
 	// Unbekanter Typ: ber die Factories gehen!
 	SbxAppData* p = GetSbxData_Impl();
 	SbxBase* pNew = NULL;
 	for( sal_uInt16 i = 0; i < p->aFacs.Count(); i++ )
 	{
 		SbxFactory* pFac = p->aFacs.GetObject( i );
 		pNew = pFac->Create( nSbxId, nCreator );
 		if( pNew )
 			break;
 	}
 #ifdef DBG_UTIL
 	if( !pNew )
 	{
 		ByteString aMsg( "SBX: Keine Factory fuer SBX-ID " );
 		aMsg += ByteString::CreateFromInt32(nSbxId);
 		DbgError( aMsg.GetBuffer() );
 	}
 #endif
 	return pNew;
 }

 SbxObject* SbxBase::CreateObject( const XubString& rClass )
 {
 	SbxAppData* p = GetSbxData_Impl();
 	SbxObject* pNew = NULL;
 	for( sal_uInt16 i = 0; i < p->aFacs.Count(); i++ )
 	{
 		pNew = p->aFacs.GetObject( i )->CreateObject( rClass );
 		if( pNew )
 			break;
 	}
 #ifdef DBG_UTIL
 	if( !pNew )
 	{
 		ByteString aMsg( "SBX: Keine Factory fuer Objektklasse " );
 		ByteString aClassStr( (const UniString&)rClass, RTL_TEXTENCODING_ASCII_US );
 		aMsg += aClassStr;
 		DbgError( (const char*)aMsg.GetBuffer() );
 	}
 #endif
 	return pNew;
 }

 static sal_Bool bStaticEnableBroadcasting = sal_True;

 // Sbx-Loesung als Ersatz fuer SfxBroadcaster::Enable()
 void SbxBase::StaticEnableBroadcasting( sal_Bool bEnable )
 {
 	bStaticEnableBroadcasting = bEnable;
 }

 sal_Bool SbxBase::StaticIsEnabledBroadcasting( void )
 {
 	return bStaticEnableBroadcasting;
 }


 SbxBase* SbxBase::Load( SvStream& rStrm )
 {
 	sal_uInt16 nSbxId, nFlags, nVer;
 	sal_uInt32 nCreator, nSize;
 	rStrm >> nCreator >> nSbxId >> nFlags >> nVer;

 	// Eine Dummheit meinerseits korrigieren:
 	if( nFlags & SBX_RESERVED )
 		nFlags = ( nFlags & ~SBX_RESERVED ) | SBX_GBLSEARCH;

 	sal_uIntPtr nOldPos = rStrm.Tell();
 	rStrm >> nSize;
 	SbxBase* p = Create( nSbxId, nCreator );
 	if( p )
 	{
 		p->nFlags = nFlags;
 		if( p->LoadData( rStrm, nVer ) )
 		{
 			sal_uIntPtr nNewPos = rStrm.Tell();
 			nOldPos += nSize;
 			DBG_ASSERT( nOldPos >= nNewPos, "SBX: Zu viele Daten eingelesen" );
 			if( nOldPos != nNewPos )
 				rStrm.Seek( nOldPos );
 			if( !p->LoadCompleted() )
 			{
 				// Loeschen des Objekts
 				SbxBaseRef aRef( p );
 				p = NULL;
 			}
 		}
 		else
 		{
 			rStrm.SetError( SVSTREAM_FILEFORMAT_ERROR );
 			// Loeschen des Objekts
 			SbxBaseRef aRef( p );
 			p = NULL;
 		}
 	}
 	else
 		rStrm.SetError( SVSTREAM_FILEFORMAT_ERROR );
 	return p;
 }

 // Sbx-Objekt im Stream ueberspringen
 void SbxBase::Skip( SvStream& rStrm )
 {
 	sal_uInt16 nSbxId, nFlags, nVer;
 	sal_uInt32 nCreator, nSize;
 	rStrm >> nCreator >> nSbxId >> nFlags >> nVer;

 	sal_uIntPtr nStartPos = rStrm.Tell();
 	rStrm >> nSize;

 	rStrm.Seek( nStartPos + nSize );
 }

 sal_Bool SbxBase::Store( SvStream& rStrm )
 {
 	DBG_CHKTHIS( SbxBase, 0 );
 	if( !( nFlags & SBX_DONTSTORE ) )
 	{
 		rStrm << (sal_uInt32) GetCreator()
 			  << (sal_uInt16) GetSbxId()
 			  << (sal_uInt16) GetFlags()
 			  << (sal_uInt16) GetVersion();
 		sal_uIntPtr nOldPos = rStrm.Tell();
 		rStrm << (sal_uInt32) 0L;
 		sal_Bool bRes = StoreData( rStrm );
 		sal_uIntPtr nNewPos = rStrm.Tell();
 		rStrm.Seek( nOldPos );
 		rStrm << (sal_uInt32) ( nNewPos - nOldPos );
 		rStrm.Seek( nNewPos );
 		if( rStrm.GetError() != SVSTREAM_OK )
 			bRes = sal_False;
 		if( bRes )
 			bRes = StoreCompleted();
 		return bRes;
 	}
 	else
 		return sal_True;
 }

 sal_Bool SbxBase::LoadData( SvStream&, sal_uInt16 )
 {
 	DBG_CHKTHIS( SbxBase, 0 );
 	return sal_False;
 }

 sal_Bool SbxBase::StoreData( SvStream& ) const
 {
 	DBG_CHKTHIS( SbxBase, 0 );
 	return sal_False;
 }

 sal_Bool SbxBase::LoadPrivateData( SvStream&, sal_uInt16 )
 {
 	DBG_CHKTHIS( SbxBase, 0 );
 	return sal_True;
 }

 sal_Bool SbxBase::StorePrivateData( SvStream& ) const
 {
 	DBG_CHKTHIS( SbxBase, 0 );
 	return sal_True;
 }

 sal_Bool SbxBase::LoadCompleted()
 {
 	DBG_CHKTHIS( SbxBase, 0 );
 	return sal_True;
 }

 sal_Bool SbxBase::StoreCompleted()
 {
 	DBG_CHKTHIS( SbxBase, 0 );
 	return sal_True;
 }

 //////////////////////////////// SbxFactory ////////////////////////////////

 SbxBase* SbxFactory::Create( sal_uInt16, sal_uInt32 )
 {
 	return NULL;
 }

 SbxObject* SbxFactory::CreateObject( const XubString& )
 {
 	return NULL;
 }

 ///////////////////////////////// SbxInfo //////////////////////////////////

 SbxInfo::~SbxInfo()
 {}

 void SbxInfo::AddParam
 		( const XubString& rName, SbxDataType eType, sal_uInt16 nFlags )
 {
 	const SbxParamInfo* p = new SbxParamInfo( rName, eType, nFlags );
 	aParams.Insert( p, aParams.Count() );
 }

 void SbxInfo::AddParam( const SbxParamInfo& r )
 {
 	const SbxParamInfo* p = new SbxParamInfo
 		( r.aName, r.eType, r.nFlags, r.aTypeRef );
 	aParams.Insert( p, aParams.Count() );
 }

 const SbxParamInfo* SbxInfo::GetParam( sal_uInt16 n ) const
 {
 	if( n < 1 || n > aParams.Count() )
 		return NULL;
 	else
 		return aParams.GetObject( n-1 );
 }

 sal_Bool SbxInfo::LoadData( SvStream& rStrm, sal_uInt16 nVer )
 {
 	aParams.Remove( 0, aParams.Count() );
 	sal_uInt16 nParam;
 	rStrm.ReadByteString( aComment, RTL_TEXTENCODING_ASCII_US );
 	rStrm.ReadByteString( aHelpFile, RTL_TEXTENCODING_ASCII_US );
 	rStrm >> nHelpId >> nParam;
 	while( nParam-- )
 	{
 		XubString aName;
 		sal_uInt16 nType, nFlags;
 		sal_uInt32 nUserData = 0;
 		rStrm.ReadByteString( aName, RTL_TEXTENCODING_ASCII_US );
 		rStrm >> nType >> nFlags;
 		if( nVer > 1 )
 			rStrm >> nUserData;
 		AddParam( aName, (SbxDataType) nType, nFlags );
 		SbxParamInfo* p = aParams.GetObject( aParams.Count() - 1 );
 		p->nUserData = nUserData;
 	}
 	return sal_True;
 }

 sal_Bool SbxInfo::StoreData( SvStream& rStrm ) const
 {
 	rStrm.WriteByteString( aComment, RTL_TEXTENCODING_ASCII_US );
 	rStrm.WriteByteString( aHelpFile, RTL_TEXTENCODING_ASCII_US );
 	rStrm << nHelpId << aParams.Count();
 	for( sal_uInt16 i = 0; i < aParams.Count(); i++ )
 	{
 		SbxParamInfo* p = aParams.GetObject( i );
 		rStrm.WriteByteString( p->aName, RTL_TEXTENCODING_ASCII_US );
 		rStrm << (sal_uInt16) p->eType
 			  << (sal_uInt16) p->nFlags
 			  << (sal_uInt32) p->nUserData;
 	}
 	return sal_True;
 }
	/**************************************************************
	*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*
	*************************************************************/



	// MARKER(update_precomp.py): autogen include statement, do not remove
	#include "precompiled_basic.hxx"


	#include <tools/shl.hxx>
	#include <tools/stream.hxx>

	#include <basic/sbx.hxx>
	#include <basic/sbxfac.hxx>
	#include <basic/sbxbase.hxx>

	// AppData-Struktur fuer SBX:

	SV_IMPL_PTRARR(SbxParams,SbxParamInfo*);
	SV_IMPL_PTRARR(SbxFacs,SbxFactory*);

	TYPEINIT0(SbxBase)

	// SBX-Daten anfordern oder ggf. anlegen
	// wir legen den Bereich einfach an und verzichten auf die Freigabe!

	SbxAppData* GetSbxData_Impl()
	{
	SbxAppData ppData = (SbxAppData) ::GetAppData( SHL_SBX );
	SbxAppData* p = *ppData;
	if( !p )
	p = *ppData = new SbxAppData;
	return p;
	}

	SbxAppData::~SbxAppData()
	{
	if( pBasicFormater )
	delete pBasicFormater;
	}


	//////////////////////////////// SbxBase /////////////////////////////////

	DBG_NAME(SbxBase);

	SbxBase::SbxBase()
	{
	DBG_CTOR( SbxBase, 0 );
	nFlags = SBX_READWRITE;
	}

	SbxBase::SbxBase( const SbxBase& r )
	: SvRefBase( r )
	{
	DBG_CTOR( SbxBase, 0 );
	nFlags = r.nFlags;
	}

	SbxBase::~SbxBase()
	{
	DBG_DTOR(SbxBase,0);
	}

	SbxBase& SbxBase::operator=( const SbxBase& r )
	{
	DBG_CHKTHIS( SbxBase, 0 );
	nFlags = r.nFlags;
	return *this;
	}

	SbxDataType SbxBase::GetType() const
	{
	DBG_CHKTHIS( SbxBase, 0 );
	return SbxEMPTY;
	}

	SbxClassType SbxBase::GetClass() const
	{
	DBG_CHKTHIS( SbxBase, 0 );
	return SbxCLASS_DONTCARE;
	}

	void SbxBase::Clear()
	{
	DBG_CHKTHIS( SbxBase, 0 );
	}

	sal_Bool SbxBase::IsFixed() const
	{
	DBG_CHKTHIS( SbxBase, 0 );
	return IsSet( SBX_FIXED );
	}

	void SbxBase::SetModified( sal_Bool b )
	{
	DBG_CHKTHIS( SbxBase, 0 );
	if( IsSet( SBX_NO_MODIFY ) )
	return;
	if( b )
	SetFlag( SBX_MODIFIED );
	else
	ResetFlag( SBX_MODIFIED );
	}

	SbxError SbxBase::GetError()
	{
	return GetSbxData_Impl()->eSbxError;
	}

	void SbxBase::SetError( SbxError e )
	{
	SbxAppData* p = GetSbxData_Impl();
	if( e && p->eSbxError == SbxERR_OK )
	p->eSbxError = e;
	}

	sal_Bool SbxBase::IsError()
	{
	return sal_Bool( GetSbxData_Impl()->eSbxError != SbxERR_OK );
	}

	void SbxBase::ResetError()
	{
	GetSbxData_Impl()->eSbxError = SbxERR_OK;
	}

	void SbxBase::AddFactory( SbxFactory* pFac )
	{
	SbxAppData* p = GetSbxData_Impl();
	const SbxFactory* pTemp = pFac;

	// AB, 6.3.96: HandleLast-Flag beruecksichtigen
	sal_uInt16 nPos = p->aFacs.Count(); // Einfuege-Position
	if( !pFac->IsHandleLast() ) // Nur, wenn nicht selbst HandleLast
	{
	// Neue Factory vor Factories mit HandleLast einordnen
	while( nPos > 0 &&
	(static_cast<SbxFactory*>(p->aFacs.GetObject( nPos-1 )))->IsHandleLast() )
	nPos--;
	}
	p->aFacs.Insert( pTemp, nPos );
	}

	void SbxBase::RemoveFactory( SbxFactory* pFac )
	{
	SbxAppData* p = GetSbxData_Impl();
	for( sal_uInt16 i = 0; i < p->aFacs.Count(); i++ )
	{
	if( p->aFacs.GetObject( i ) == pFac )
	{
	p->aFacs.Remove( i, 1 ); break;
	}
	}
	}


	SbxBase* SbxBase::Create( sal_uInt16 nSbxId, sal_uInt32 nCreator )
	{
	// #91626: Hack to skip old Basic dialogs
	// Problem: There does not exist a factory any more,
	// so we have to create a dummy SbxVariable instead
	if( nSbxId == 0x65 ) // Dialog Id
	return new SbxVariable;

	XubString aEmptyStr;
	if( nCreator == SBXCR_SBX )
	switch( nSbxId )
	{
	case SBXID_VALUE: return new SbxValue;
	case SBXID_VARIABLE: return new SbxVariable;
	case SBXID_ARRAY: return new SbxArray;
	case SBXID_DIMARRAY: return new SbxDimArray;
	case SBXID_OBJECT: return new SbxObject( aEmptyStr );
	case SBXID_COLLECTION: return new SbxCollection( aEmptyStr );
	case SBXID_FIXCOLLECTION:
	return new SbxStdCollection( aEmptyStr, aEmptyStr );
	case SBXID_METHOD: return new SbxMethod( aEmptyStr, SbxEMPTY );
	case SBXID_PROPERTY: return new SbxProperty( aEmptyStr, SbxEMPTY );
	}
	// Unbekanter Typ: ber die Factories gehen!
	SbxAppData* p = GetSbxData_Impl();
	SbxBase* pNew = NULL;
	for( sal_uInt16 i = 0; i < p->aFacs.Count(); i++ )
	{
	SbxFactory* pFac = p->aFacs.GetObject( i );
	pNew = pFac->Create( nSbxId, nCreator );
	if( pNew )
	break;
	}
	#ifdef DBG_UTIL
	if( !pNew )
	{
	ByteString aMsg( "SBX: Keine Factory fuer SBX-ID " );
	aMsg += ByteString::CreateFromInt32(nSbxId);
	DbgError( aMsg.GetBuffer() );
	}
	#endif
	return pNew;
	}

	SbxObject* SbxBase::CreateObject( const XubString& rClass )
	{
	SbxAppData* p = GetSbxData_Impl();
	SbxObject* pNew = NULL;
	for( sal_uInt16 i = 0; i < p->aFacs.Count(); i++ )
	{
	pNew = p->aFacs.GetObject( i )->CreateObject( rClass );
	if( pNew )
	break;
	}
	#ifdef DBG_UTIL
	if( !pNew )
	{
	ByteString aMsg( "SBX: Keine Factory fuer Objektklasse " );
	ByteString aClassStr( (const UniString&)rClass, RTL_TEXTENCODING_ASCII_US );
	aMsg += aClassStr;
	DbgError( (const char*)aMsg.GetBuffer() );
	}
	#endif
	return pNew;
	}

	static sal_Bool bStaticEnableBroadcasting = sal_True;

	// Sbx-Loesung als Ersatz fuer SfxBroadcaster::Enable()
	void SbxBase::StaticEnableBroadcasting( sal_Bool bEnable )
	{
	bStaticEnableBroadcasting = bEnable;
	}

	sal_Bool SbxBase::StaticIsEnabledBroadcasting( void )
	{
	return bStaticEnableBroadcasting;
	}


	SbxBase* SbxBase::Load( SvStream& rStrm )
	{
	sal_uInt16 nSbxId, nFlags, nVer;
	sal_uInt32 nCreator, nSize;
	rStrm >> nCreator >> nSbxId >> nFlags >> nVer;

	// Eine Dummheit meinerseits korrigieren:
	if( nFlags & SBX_RESERVED )
	nFlags = ( nFlags & ~SBX_RESERVED ) \| SBX_GBLSEARCH;

	sal_uIntPtr nOldPos = rStrm.Tell();
	rStrm >> nSize;
	SbxBase* p = Create( nSbxId, nCreator );
	if( p )
	{
	p->nFlags = nFlags;
	if( p->LoadData( rStrm, nVer ) )
	{
	sal_uIntPtr nNewPos = rStrm.Tell();
	nOldPos += nSize;
	DBG_ASSERT( nOldPos >= nNewPos, "SBX: Zu viele Daten eingelesen" );
	if( nOldPos != nNewPos )
	rStrm.Seek( nOldPos );
	if( !p->LoadCompleted() )
	{
	// Loeschen des Objekts
	SbxBaseRef aRef( p );
	p = NULL;
	}
	}
	else
	{
	rStrm.SetError( SVSTREAM_FILEFORMAT_ERROR );
	// Loeschen des Objekts
	SbxBaseRef aRef( p );
	p = NULL;
	}
	}
	else
	rStrm.SetError( SVSTREAM_FILEFORMAT_ERROR );
	return p;
	}

	// Sbx-Objekt im Stream ueberspringen
	void SbxBase::Skip( SvStream& rStrm )
	{
	sal_uInt16 nSbxId, nFlags, nVer;
	sal_uInt32 nCreator, nSize;
	rStrm >> nCreator >> nSbxId >> nFlags >> nVer;

	sal_uIntPtr nStartPos = rStrm.Tell();
	rStrm >> nSize;

	rStrm.Seek( nStartPos + nSize );
	}

	sal_Bool SbxBase::Store( SvStream& rStrm )
	{
	DBG_CHKTHIS( SbxBase, 0 );
	if( !( nFlags & SBX_DONTSTORE ) )
	{
	rStrm << (sal_uInt32) GetCreator()
	<< (sal_uInt16) GetSbxId()
	<< (sal_uInt16) GetFlags()
	<< (sal_uInt16) GetVersion();
	sal_uIntPtr nOldPos = rStrm.Tell();
	rStrm << (sal_uInt32) 0L;
	sal_Bool bRes = StoreData( rStrm );
	sal_uIntPtr nNewPos = rStrm.Tell();
	rStrm.Seek( nOldPos );
	rStrm << (sal_uInt32) ( nNewPos - nOldPos );
	rStrm.Seek( nNewPos );
	if( rStrm.GetError() != SVSTREAM_OK )
	bRes = sal_False;
	if( bRes )
	bRes = StoreCompleted();
	return bRes;
	}
	else
	return sal_True;
	}

	sal_Bool SbxBase::LoadData( SvStream&, sal_uInt16 )
	{
	DBG_CHKTHIS( SbxBase, 0 );
	return sal_False;
	}

	sal_Bool SbxBase::StoreData( SvStream& ) const
	{
	DBG_CHKTHIS( SbxBase, 0 );
	return sal_False;
	}

	sal_Bool SbxBase::LoadPrivateData( SvStream&, sal_uInt16 )
	{
	DBG_CHKTHIS( SbxBase, 0 );
	return sal_True;
	}

	sal_Bool SbxBase::StorePrivateData( SvStream& ) const
	{
	DBG_CHKTHIS( SbxBase, 0 );
	return sal_True;
	}

	sal_Bool SbxBase::LoadCompleted()
	{
	DBG_CHKTHIS( SbxBase, 0 );
	return sal_True;
	}

	sal_Bool SbxBase::StoreCompleted()
	{
	DBG_CHKTHIS( SbxBase, 0 );
	return sal_True;
	}

	//////////////////////////////// SbxFactory ////////////////////////////////

	SbxBase* SbxFactory::Create( sal_uInt16, sal_uInt32 )
	{
	return NULL;
	}

	SbxObject* SbxFactory::CreateObject( const XubString& )
	{
	return NULL;
	}

	///////////////////////////////// SbxInfo //////////////////////////////////

	SbxInfo::~SbxInfo()
	{}

	void SbxInfo::AddParam
	( const XubString& rName, SbxDataType eType, sal_uInt16 nFlags )
	{
	const SbxParamInfo* p = new SbxParamInfo( rName, eType, nFlags );
	aParams.Insert( p, aParams.Count() );
	}

	void SbxInfo::AddParam( const SbxParamInfo& r )
	{
	const SbxParamInfo* p = new SbxParamInfo
	( r.aName, r.eType, r.nFlags, r.aTypeRef );
	aParams.Insert( p, aParams.Count() );
	}

	const SbxParamInfo* SbxInfo::GetParam( sal_uInt16 n ) const
	{
	if( n < 1 \|\| n > aParams.Count() )
	return NULL;
	else
	return aParams.GetObject( n-1 );
	}

	sal_Bool SbxInfo::LoadData( SvStream& rStrm, sal_uInt16 nVer )
	{
	aParams.Remove( 0, aParams.Count() );
	sal_uInt16 nParam;
	rStrm.ReadByteString( aComment, RTL_TEXTENCODING_ASCII_US );
	rStrm.ReadByteString( aHelpFile, RTL_TEXTENCODING_ASCII_US );
	rStrm >> nHelpId >> nParam;
	while( nParam-- )
	{
	XubString aName;
	sal_uInt16 nType, nFlags;
	sal_uInt32 nUserData = 0;
	rStrm.ReadByteString( aName, RTL_TEXTENCODING_ASCII_US );
	rStrm >> nType >> nFlags;
	if( nVer > 1 )
	rStrm >> nUserData;
	AddParam( aName, (SbxDataType) nType, nFlags );
	SbxParamInfo* p = aParams.GetObject( aParams.Count() - 1 );
	p->nUserData = nUserData;
	}
	return sal_True;
	}

	sal_Bool SbxInfo::StoreData( SvStream& rStrm ) const
	{
	rStrm.WriteByteString( aComment, RTL_TEXTENCODING_ASCII_US );
	rStrm.WriteByteString( aHelpFile, RTL_TEXTENCODING_ASCII_US );
	rStrm << nHelpId << aParams.Count();
	for( sal_uInt16 i = 0; i < aParams.Count(); i++ )
	{
	SbxParamInfo* p = aParams.GetObject( i );
	rStrm.WriteByteString( p->aName, RTL_TEXTENCODING_ASCII_US );
	rStrm << (sal_uInt16) p->eType
	<< (sal_uInt16) p->nFlags
	<< (sal_uInt32) p->nUserData;
	}
	return sal_True;
	}