AOO410/main/sfx2/source/appl/linksrc.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_sfx2.hxx"

 #include <sfx2/linksrc.hxx>
 #include <sfx2/lnkbase.hxx>
 //#include <sot/exchange.hxx>
 #include <com/sun/star/uno/Any.hxx>
 #include <com/sun/star/uno/Sequence.hxx>

 #include <tools/debug.hxx>
 #include <vcl/timer.hxx>
 #include <svl/svarray.hxx>


 using namespace ::com::sun::star::uno;

 namespace sfx2
 {

 TYPEINIT0( SvLinkSource )

 /************** class SvLinkSourceTimer *********************************/
 class SvLinkSourceTimer : public Timer
 {
 	SvLinkSource *  pOwner;
 	virtual void    Timeout();
 public:
 			SvLinkSourceTimer( SvLinkSource * pOwn );
 };

 SvLinkSourceTimer::SvLinkSourceTimer( SvLinkSource * pOwn )
 	: pOwner( pOwn )
 {
 }

 void SvLinkSourceTimer::Timeout()
 {
 	// sicher gegen zerstoeren im Handler
 	SvLinkSourceRef aAdv( pOwner );
 	pOwner->SendDataChanged();
 }

 static void StartTimer( SvLinkSourceTimer ** ppTimer, SvLinkSource * pOwner,
 						sal_uIntPtr nTimeout )
 {
 	if( !*ppTimer )
 	{
 		*ppTimer = new SvLinkSourceTimer( pOwner );
 		(*ppTimer)->SetTimeout( nTimeout );
 		(*ppTimer)->Start();
 	}
 }


 struct SvLinkSource_Entry_Impl
 {
 	SvBaseLinkRef		xSink;
 	String				aDataMimeType;
 	sal_uInt16				nAdviseModes;
 	sal_Bool 				bIsDataSink;

 	SvLinkSource_Entry_Impl( SvBaseLink* pLink, const String& rMimeType,
 								sal_uInt16 nAdvMode )
 		: xSink( pLink ), aDataMimeType( rMimeType ),
 			nAdviseModes( nAdvMode ), bIsDataSink( sal_True )
 	{}

 	SvLinkSource_Entry_Impl( SvBaseLink* pLink )
 		: xSink( pLink ), nAdviseModes( 0 ), bIsDataSink( sal_False )
 	{}

 	~SvLinkSource_Entry_Impl();
 };

 SvLinkSource_Entry_Impl::~SvLinkSource_Entry_Impl()
 {
 }

 typedef SvLinkSource_Entry_Impl* SvLinkSource_Entry_ImplPtr;
 SV_DECL_PTRARR_DEL( SvLinkSource_Array_Impl, SvLinkSource_Entry_ImplPtr, 4, 4 )
 SV_IMPL_PTRARR( SvLinkSource_Array_Impl, SvLinkSource_Entry_ImplPtr );

 class SvLinkSource_EntryIter_Impl
 {
 	SvLinkSource_Array_Impl aArr;
 	const SvLinkSource_Array_Impl& rOrigArr;
 	sal_uInt16 nPos;
 public:
 	SvLinkSource_EntryIter_Impl( const SvLinkSource_Array_Impl& rArr );
 	~SvLinkSource_EntryIter_Impl();
 	SvLinkSource_Entry_Impl* Curr()
 							{ return nPos < aArr.Count() ? aArr[ nPos ] : 0; }
 	SvLinkSource_Entry_Impl* Next();
 	sal_Bool IsValidCurrValue( SvLinkSource_Entry_Impl* pEntry );
 };

 SvLinkSource_EntryIter_Impl::SvLinkSource_EntryIter_Impl(
 		const SvLinkSource_Array_Impl& rArr )
 	: rOrigArr( rArr ), nPos( 0 )
 {
 	aArr.Insert( &rArr, 0 );
 }
 SvLinkSource_EntryIter_Impl::~SvLinkSource_EntryIter_Impl()
 {
 	aArr.Remove( 0, aArr.Count() );
 }

 sal_Bool SvLinkSource_EntryIter_Impl::IsValidCurrValue( SvLinkSource_Entry_Impl* pEntry )
 {
 	return ( nPos < aArr.Count() && aArr[nPos] == pEntry && USHRT_MAX != rOrigArr.GetPos( pEntry ) );
 }

 SvLinkSource_Entry_Impl* SvLinkSource_EntryIter_Impl::Next()
 {
 	SvLinkSource_Entry_ImplPtr pRet = 0;
 	if( nPos + 1 < aArr.Count() )
 	{
 		++nPos;
 		if( rOrigArr.Count() == aArr.Count() &&
 			rOrigArr[ nPos ] == aArr[ nPos ] )
 			pRet = aArr[ nPos ];
 		else
 		{
 			// then we must search the current (or the next) in the orig
 			do {
 				pRet = aArr[ nPos ];
 				if( USHRT_MAX != rOrigArr.GetPos( pRet ))
 					break;
 				pRet = 0;
 				++nPos;
 			} while( nPos < aArr.Count() );

 			if( nPos >= aArr.Count() )
 				pRet = 0;
 		}
 	}
 	return pRet;
 }

 struct SvLinkSource_Impl
 {
 	SvLinkSource_Array_Impl aArr;
 	String				aDataMimeType;
 	SvLinkSourceTimer *	pTimer;
 	sal_uIntPtr				nTimeout;
     com::sun::star::uno::Reference<com::sun::star::io::XInputStream>
     m_xInputStreamToLoadFrom;
     sal_Bool m_bIsReadOnly;

 	SvLinkSource_Impl() : pTimer( 0 ), nTimeout( 3000 ) {}
 	~SvLinkSource_Impl();

 	void Closed();
 };

 SvLinkSource_Impl::~SvLinkSource_Impl()
 {
 	delete pTimer;
 }

 SvLinkSource::SvLinkSource()
  	: pImpl( new SvLinkSource_Impl )
 {
 }

 SvLinkSource::~SvLinkSource()
 {
 	delete pImpl;
 }


 SvLinkSource::StreamToLoadFrom SvLinkSource::getStreamToLoadFrom()
 {
     return StreamToLoadFrom(
         pImpl->m_xInputStreamToLoadFrom,
         pImpl->m_bIsReadOnly);
 }

 void SvLinkSource::setStreamToLoadFrom(const com::sun::star::uno::Reference<com::sun::star::io::XInputStream>& xInputStream,sal_Bool bIsReadOnly )
 {
     pImpl->m_xInputStreamToLoadFrom = xInputStream;
     pImpl->m_bIsReadOnly = bIsReadOnly;
 }

 // --> OD 2008-06-18 #i88291#
 void SvLinkSource::clearStreamToLoadFrom()
 {
     pImpl->m_xInputStreamToLoadFrom.clear();
 }
 // <--

 void  SvLinkSource::Closed()
 {
 	SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
 	for( SvLinkSource_Entry_Impl* p = aIter.Curr(); p; p = aIter.Next() )
 		if( !p->bIsDataSink )
 			p->xSink->Closed();
 }

 sal_uIntPtr SvLinkSource::GetUpdateTimeout() const
 {
 	return pImpl->nTimeout;
 }

 void SvLinkSource::SetUpdateTimeout( sal_uIntPtr nTimeout )
 {
 	pImpl->nTimeout = nTimeout;
 	if( pImpl->pTimer )
 		pImpl->pTimer->SetTimeout( nTimeout );
 }

 void SvLinkSource::SendDataChanged()
 {
 	SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
 	for( SvLinkSource_Entry_ImplPtr p = aIter.Curr(); p; p = aIter.Next() )
 	{
 		if( p->bIsDataSink )
 		{
 			String sDataMimeType( pImpl->aDataMimeType );
 			if( !sDataMimeType.Len() )
 				sDataMimeType = p->aDataMimeType;

 			Any aVal;
 			if( ( p->nAdviseModes & ADVISEMODE_NODATA ) ||
 				GetData( aVal, sDataMimeType, sal_True ) )
 			{
 				p->xSink->DataChanged( sDataMimeType, aVal );

 				if ( !aIter.IsValidCurrValue( p ) )
 					continue;

 				if( p->nAdviseModes & ADVISEMODE_ONLYONCE )
 				{
 					sal_uInt16 nFndPos = pImpl->aArr.GetPos( p );
 					if( USHRT_MAX != nFndPos )
 						pImpl->aArr.DeleteAndDestroy( nFndPos );
 				}

 			}
 		}
 	}
 	if( pImpl->pTimer )
 	{
 		delete pImpl->pTimer;
 		pImpl->pTimer = NULL;
 	}
 	pImpl->aDataMimeType.Erase();
 }

 void SvLinkSource::NotifyDataChanged()
 {
 	if( pImpl->nTimeout )
 		StartTimer( &pImpl->pTimer, this, pImpl->nTimeout ); // Timeout neu
 	else
 	{
 		SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
 		for( SvLinkSource_Entry_ImplPtr p = aIter.Curr(); p; p = aIter.Next() )
 			if( p->bIsDataSink )
 			{
 				Any aVal;
 				if( ( p->nAdviseModes & ADVISEMODE_NODATA ) ||
 					GetData( aVal, p->aDataMimeType, sal_True ) )
 				{
 					p->xSink->DataChanged( p->aDataMimeType, aVal );

 					if ( !aIter.IsValidCurrValue( p ) )
 						continue;

 					if( p->nAdviseModes & ADVISEMODE_ONLYONCE )
 					{
 						sal_uInt16 nFndPos = pImpl->aArr.GetPos( p );
 						if( USHRT_MAX != nFndPos )
 							pImpl->aArr.DeleteAndDestroy( nFndPos );
 					}
 				}
 			}

 			if( pImpl->pTimer )
 			{
 				delete pImpl->pTimer;
 				pImpl->pTimer = NULL;
 			}
 	}
 }

 // notify the sink, the mime type is not
 // a selection criterion
 void SvLinkSource::DataChanged( const String & rMimeType,
 								const ::com::sun::star::uno::Any & rVal )
 {
 	if( pImpl->nTimeout && !rVal.hasValue() )
 	{   // nur wenn keine Daten mitgegeben wurden
 		// fire all data to the sink, independent of the requested format
 		pImpl->aDataMimeType = rMimeType;
 		StartTimer( &pImpl->pTimer, this, pImpl->nTimeout ); // Timeout neu
 	}
 	else
 	{
 		SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
 		for( SvLinkSource_Entry_ImplPtr p = aIter.Curr(); p; p = aIter.Next() )
 		{
 			if( p->bIsDataSink )
 			{
 				p->xSink->DataChanged( rMimeType, rVal );

 				if ( !aIter.IsValidCurrValue( p ) )
 					continue;

 				if( p->nAdviseModes & ADVISEMODE_ONLYONCE )
 				{
 					sal_uInt16 nFndPos = pImpl->aArr.GetPos( p );
 					if( USHRT_MAX != nFndPos )
 						pImpl->aArr.DeleteAndDestroy( nFndPos );
 				}
 			}
 		}

 		if( pImpl->pTimer )
 		{
 			delete pImpl->pTimer;
 			pImpl->pTimer = NULL;
 		}
 	}
 }


 // only one link is correct
 void SvLinkSource::AddDataAdvise( SvBaseLink * pLink, const String& rMimeType,
 									sal_uInt16 nAdviseModes )
 {
 	SvLinkSource_Entry_ImplPtr pNew = new SvLinkSource_Entry_Impl(
 					pLink, rMimeType, nAdviseModes );
 	pImpl->aArr.Insert( pNew, pImpl->aArr.Count() );
 }

 void SvLinkSource::RemoveAllDataAdvise( SvBaseLink * pLink )
 {
 	SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
 	for( SvLinkSource_Entry_ImplPtr p = aIter.Curr(); p; p = aIter.Next() )
 		if( p->bIsDataSink && &p->xSink == pLink )
 		{
 			sal_uInt16 nFndPos = pImpl->aArr.GetPos( p );
 			if( USHRT_MAX != nFndPos )
 				pImpl->aArr.DeleteAndDestroy( nFndPos );
 		}
 }

 // only one link is correct
 void SvLinkSource::AddConnectAdvise( SvBaseLink * pLink )
 {
 	SvLinkSource_Entry_ImplPtr pNew = new SvLinkSource_Entry_Impl( pLink );
 	pImpl->aArr.Insert( pNew, pImpl->aArr.Count() );
 }

 void SvLinkSource::RemoveConnectAdvise( SvBaseLink * pLink )
 {
 	SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
 	for( SvLinkSource_Entry_ImplPtr p = aIter.Curr(); p; p = aIter.Next() )
 		if( !p->bIsDataSink && &p->xSink == pLink )
 		{
 			sal_uInt16 nFndPos = pImpl->aArr.GetPos( p );
 			if( USHRT_MAX != nFndPos )
 				pImpl->aArr.DeleteAndDestroy( nFndPos );
 		}
 }

 sal_Bool SvLinkSource::HasDataLinks( const SvBaseLink* pLink ) const
 {
 	sal_Bool bRet = sal_False;
 	const SvLinkSource_Entry_Impl* p;
 	for( sal_uInt16 n = 0, nEnd = pImpl->aArr.Count(); n < nEnd; ++n )
 		if( ( p = pImpl->aArr[ n ] )->bIsDataSink &&
 			( !pLink || &p->xSink == pLink ) )
 		{
 			bRet = sal_True;
 			break;
 		}
 	return bRet;
 }

 // sal_True => waitinmg for data
 sal_Bool SvLinkSource::IsPending() const
 {
 	return sal_False;
 }

 // sal_True => data complete loaded
 sal_Bool SvLinkSource::IsDataComplete() const
 {
 	return sal_True;
 }

 sal_Bool SvLinkSource::Connect( SvBaseLink* )
 {
 	return sal_True;
 }

 sal_Bool SvLinkSource::GetData( ::com::sun::star::uno::Any &, const String &, sal_Bool )
 {
 	return sal_False;
 }

 void SvLinkSource::Edit( Window *, SvBaseLink *, const Link& )
 {
 }

 }
	/**************************************************************
	*
	* 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_sfx2.hxx"

	#include <sfx2/linksrc.hxx>
	#include <sfx2/lnkbase.hxx>
	//#include <sot/exchange.hxx>
	#include <com/sun/star/uno/Any.hxx>
	#include <com/sun/star/uno/Sequence.hxx>

	#include <tools/debug.hxx>
	#include <vcl/timer.hxx>
	#include <svl/svarray.hxx>


	using namespace ::com::sun::star::uno;

	namespace sfx2
	{

	TYPEINIT0( SvLinkSource )

	/************ class SvLinkSourceTimer *******************************/
	class SvLinkSourceTimer : public Timer
	{
	SvLinkSource * pOwner;
	virtual void Timeout();
	public:
	SvLinkSourceTimer( SvLinkSource * pOwn );
	};

	SvLinkSourceTimer::SvLinkSourceTimer( SvLinkSource * pOwn )
	: pOwner( pOwn )
	{
	}

	void SvLinkSourceTimer::Timeout()
	{
	// sicher gegen zerstoeren im Handler
	SvLinkSourceRef aAdv( pOwner );
	pOwner->SendDataChanged();
	}

	static void StartTimer( SvLinkSourceTimer ** ppTimer, SvLinkSource * pOwner,
	sal_uIntPtr nTimeout )
	{
	if( !*ppTimer )
	{
	*ppTimer = new SvLinkSourceTimer( pOwner );
	(*ppTimer)->SetTimeout( nTimeout );
	(*ppTimer)->Start();
	}
	}


	struct SvLinkSource_Entry_Impl
	{
	SvBaseLinkRef xSink;
	String aDataMimeType;
	sal_uInt16 nAdviseModes;
	sal_Bool bIsDataSink;

	SvLinkSource_Entry_Impl( SvBaseLink* pLink, const String& rMimeType,
	sal_uInt16 nAdvMode )
	: xSink( pLink ), aDataMimeType( rMimeType ),
	nAdviseModes( nAdvMode ), bIsDataSink( sal_True )
	{}

	SvLinkSource_Entry_Impl( SvBaseLink* pLink )
	: xSink( pLink ), nAdviseModes( 0 ), bIsDataSink( sal_False )
	{}

	~SvLinkSource_Entry_Impl();
	};

	SvLinkSource_Entry_Impl::~SvLinkSource_Entry_Impl()
	{
	}

	typedef SvLinkSource_Entry_Impl* SvLinkSource_Entry_ImplPtr;
	SV_DECL_PTRARR_DEL( SvLinkSource_Array_Impl, SvLinkSource_Entry_ImplPtr, 4, 4 )
	SV_IMPL_PTRARR( SvLinkSource_Array_Impl, SvLinkSource_Entry_ImplPtr );

	class SvLinkSource_EntryIter_Impl
	{
	SvLinkSource_Array_Impl aArr;
	const SvLinkSource_Array_Impl& rOrigArr;
	sal_uInt16 nPos;
	public:
	SvLinkSource_EntryIter_Impl( const SvLinkSource_Array_Impl& rArr );
	~SvLinkSource_EntryIter_Impl();
	SvLinkSource_Entry_Impl* Curr()
	{ return nPos < aArr.Count() ? aArr[ nPos ] : 0; }
	SvLinkSource_Entry_Impl* Next();
	sal_Bool IsValidCurrValue( SvLinkSource_Entry_Impl* pEntry );
	};

	SvLinkSource_EntryIter_Impl::SvLinkSource_EntryIter_Impl(
	const SvLinkSource_Array_Impl& rArr )
	: rOrigArr( rArr ), nPos( 0 )
	{
	aArr.Insert( &rArr, 0 );
	}
	SvLinkSource_EntryIter_Impl::~SvLinkSource_EntryIter_Impl()
	{
	aArr.Remove( 0, aArr.Count() );
	}

	sal_Bool SvLinkSource_EntryIter_Impl::IsValidCurrValue( SvLinkSource_Entry_Impl* pEntry )
	{
	return ( nPos < aArr.Count() && aArr[nPos] == pEntry && USHRT_MAX != rOrigArr.GetPos( pEntry ) );
	}

	SvLinkSource_Entry_Impl* SvLinkSource_EntryIter_Impl::Next()
	{
	SvLinkSource_Entry_ImplPtr pRet = 0;
	if( nPos + 1 < aArr.Count() )
	{
	++nPos;
	if( rOrigArr.Count() == aArr.Count() &&
	rOrigArr[ nPos ] == aArr[ nPos ] )
	pRet = aArr[ nPos ];
	else
	{
	// then we must search the current (or the next) in the orig
	do {
	pRet = aArr[ nPos ];
	if( USHRT_MAX != rOrigArr.GetPos( pRet ))
	break;
	pRet = 0;
	++nPos;
	} while( nPos < aArr.Count() );

	if( nPos >= aArr.Count() )
	pRet = 0;
	}
	}
	return pRet;
	}

	struct SvLinkSource_Impl
	{
	SvLinkSource_Array_Impl aArr;
	String aDataMimeType;
	SvLinkSourceTimer * pTimer;
	sal_uIntPtr nTimeout;
	com::sun::star::uno::Reference<com::sun::star::io::XInputStream>
	m_xInputStreamToLoadFrom;
	sal_Bool m_bIsReadOnly;

	SvLinkSource_Impl() : pTimer( 0 ), nTimeout( 3000 ) {}
	~SvLinkSource_Impl();

	void Closed();
	};

	SvLinkSource_Impl::~SvLinkSource_Impl()
	{
	delete pTimer;
	}

	SvLinkSource::SvLinkSource()
	: pImpl( new SvLinkSource_Impl )
	{
	}

	SvLinkSource::~SvLinkSource()
	{
	delete pImpl;
	}


	SvLinkSource::StreamToLoadFrom SvLinkSource::getStreamToLoadFrom()
	{
	return StreamToLoadFrom(
	pImpl->m_xInputStreamToLoadFrom,
	pImpl->m_bIsReadOnly);
	}

	void SvLinkSource::setStreamToLoadFrom(const com::sun::star::uno::Reference<com::sun::star::io::XInputStream>& xInputStream,sal_Bool bIsReadOnly )
	{
	pImpl->m_xInputStreamToLoadFrom = xInputStream;
	pImpl->m_bIsReadOnly = bIsReadOnly;
	}

	// --> OD 2008-06-18 #i88291#
	void SvLinkSource::clearStreamToLoadFrom()
	{
	pImpl->m_xInputStreamToLoadFrom.clear();
	}
	// <--

	void SvLinkSource::Closed()
	{
	SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
	for( SvLinkSource_Entry_Impl* p = aIter.Curr(); p; p = aIter.Next() )
	if( !p->bIsDataSink )
	p->xSink->Closed();
	}

	sal_uIntPtr SvLinkSource::GetUpdateTimeout() const
	{
	return pImpl->nTimeout;
	}

	void SvLinkSource::SetUpdateTimeout( sal_uIntPtr nTimeout )
	{
	pImpl->nTimeout = nTimeout;
	if( pImpl->pTimer )
	pImpl->pTimer->SetTimeout( nTimeout );
	}

	void SvLinkSource::SendDataChanged()
	{
	SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
	for( SvLinkSource_Entry_ImplPtr p = aIter.Curr(); p; p = aIter.Next() )
	{
	if( p->bIsDataSink )
	{
	String sDataMimeType( pImpl->aDataMimeType );
	if( !sDataMimeType.Len() )
	sDataMimeType = p->aDataMimeType;

	Any aVal;
	if( ( p->nAdviseModes & ADVISEMODE_NODATA ) \|\|
	GetData( aVal, sDataMimeType, sal_True ) )
	{
	p->xSink->DataChanged( sDataMimeType, aVal );

	if ( !aIter.IsValidCurrValue( p ) )
	continue;

	if( p->nAdviseModes & ADVISEMODE_ONLYONCE )
	{
	sal_uInt16 nFndPos = pImpl->aArr.GetPos( p );
	if( USHRT_MAX != nFndPos )
	pImpl->aArr.DeleteAndDestroy( nFndPos );
	}

	}
	}
	}
	if( pImpl->pTimer )
	{
	delete pImpl->pTimer;
	pImpl->pTimer = NULL;
	}
	pImpl->aDataMimeType.Erase();
	}

	void SvLinkSource::NotifyDataChanged()
	{
	if( pImpl->nTimeout )
	StartTimer( &pImpl->pTimer, this, pImpl->nTimeout ); // Timeout neu
	else
	{
	SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
	for( SvLinkSource_Entry_ImplPtr p = aIter.Curr(); p; p = aIter.Next() )
	if( p->bIsDataSink )
	{
	Any aVal;
	if( ( p->nAdviseModes & ADVISEMODE_NODATA ) \|\|
	GetData( aVal, p->aDataMimeType, sal_True ) )
	{
	p->xSink->DataChanged( p->aDataMimeType, aVal );

	if ( !aIter.IsValidCurrValue( p ) )
	continue;

	if( p->nAdviseModes & ADVISEMODE_ONLYONCE )
	{
	sal_uInt16 nFndPos = pImpl->aArr.GetPos( p );
	if( USHRT_MAX != nFndPos )
	pImpl->aArr.DeleteAndDestroy( nFndPos );
	}
	}
	}

	if( pImpl->pTimer )
	{
	delete pImpl->pTimer;
	pImpl->pTimer = NULL;
	}
	}
	}

	// notify the sink, the mime type is not
	// a selection criterion
	void SvLinkSource::DataChanged( const String & rMimeType,
	const ::com::sun::star::uno::Any & rVal )
	{
	if( pImpl->nTimeout && !rVal.hasValue() )
	{ // nur wenn keine Daten mitgegeben wurden
	// fire all data to the sink, independent of the requested format
	pImpl->aDataMimeType = rMimeType;
	StartTimer( &pImpl->pTimer, this, pImpl->nTimeout ); // Timeout neu
	}
	else
	{
	SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
	for( SvLinkSource_Entry_ImplPtr p = aIter.Curr(); p; p = aIter.Next() )
	{
	if( p->bIsDataSink )
	{
	p->xSink->DataChanged( rMimeType, rVal );

	if ( !aIter.IsValidCurrValue( p ) )
	continue;

	if( p->nAdviseModes & ADVISEMODE_ONLYONCE )
	{
	sal_uInt16 nFndPos = pImpl->aArr.GetPos( p );
	if( USHRT_MAX != nFndPos )
	pImpl->aArr.DeleteAndDestroy( nFndPos );
	}
	}
	}

	if( pImpl->pTimer )
	{
	delete pImpl->pTimer;
	pImpl->pTimer = NULL;
	}
	}
	}


	// only one link is correct
	void SvLinkSource::AddDataAdvise( SvBaseLink * pLink, const String& rMimeType,
	sal_uInt16 nAdviseModes )
	{
	SvLinkSource_Entry_ImplPtr pNew = new SvLinkSource_Entry_Impl(
	pLink, rMimeType, nAdviseModes );
	pImpl->aArr.Insert( pNew, pImpl->aArr.Count() );
	}

	void SvLinkSource::RemoveAllDataAdvise( SvBaseLink * pLink )
	{
	SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
	for( SvLinkSource_Entry_ImplPtr p = aIter.Curr(); p; p = aIter.Next() )
	if( p->bIsDataSink && &p->xSink == pLink )
	{
	sal_uInt16 nFndPos = pImpl->aArr.GetPos( p );
	if( USHRT_MAX != nFndPos )
	pImpl->aArr.DeleteAndDestroy( nFndPos );
	}
	}

	// only one link is correct
	void SvLinkSource::AddConnectAdvise( SvBaseLink * pLink )
	{
	SvLinkSource_Entry_ImplPtr pNew = new SvLinkSource_Entry_Impl( pLink );
	pImpl->aArr.Insert( pNew, pImpl->aArr.Count() );
	}

	void SvLinkSource::RemoveConnectAdvise( SvBaseLink * pLink )
	{
	SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
	for( SvLinkSource_Entry_ImplPtr p = aIter.Curr(); p; p = aIter.Next() )
	if( !p->bIsDataSink && &p->xSink == pLink )
	{
	sal_uInt16 nFndPos = pImpl->aArr.GetPos( p );
	if( USHRT_MAX != nFndPos )
	pImpl->aArr.DeleteAndDestroy( nFndPos );
	}
	}

	sal_Bool SvLinkSource::HasDataLinks( const SvBaseLink* pLink ) const
	{
	sal_Bool bRet = sal_False;
	const SvLinkSource_Entry_Impl* p;
	for( sal_uInt16 n = 0, nEnd = pImpl->aArr.Count(); n < nEnd; ++n )
	if( ( p = pImpl->aArr[ n ] )->bIsDataSink &&
	( !pLink \|\| &p->xSink == pLink ) )
	{
	bRet = sal_True;
	break;
	}
	return bRet;
	}

	// sal_True => waitinmg for data
	sal_Bool SvLinkSource::IsPending() const
	{
	return sal_False;
	}

	// sal_True => data complete loaded
	sal_Bool SvLinkSource::IsDataComplete() const
	{
	return sal_True;
	}

	sal_Bool SvLinkSource::Connect( SvBaseLink* )
	{
	return sal_True;
	}

	sal_Bool SvLinkSource::GetData( ::com::sun::star::uno::Any &, const String &, sal_Bool )
	{
	return sal_False;
	}

	void SvLinkSource::Edit( Window , SvBaseLink , const Link& )
	{
	}

	}