text: /**************************************************************
   * 
   * 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_forms.hxx"
  
  #include "imgprod.hxx"
  
  #include <vcl/bmpacc.hxx>
  #include <vcl/cvtgrf.hxx>
  #include <vcl/svapp.hxx>
  #include <unotools/ucbstreamhelper.hxx>
  #include <svtools/filter.hxx>
  #include <com/sun/star/io/XInputStream.hpp>
  
  #ifndef SVTOOLS_SOURCE_MISC_IMAGERESOURCEACCESS_HXX
  #include "svtools/imageresourceaccess.hxx"
  #endif
  #include <comphelper/processfactory.hxx>
  
  // --------------------
  // - ImgProdLockBytes -
  // --------------------
  
  class ImgProdLockBytes : public SvLockBytes
  {
  	::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream > 		xStmRef;
  	::com::sun::star::uno::Sequence<sal_Int8>		maSeq;
  
  						ImgProdLockBytes() {};
  
  public:
  
  						ImgProdLockBytes( SvStream* pStm, sal_Bool bOwner );
  						ImgProdLockBytes( ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream > & rStreamRef );
  	virtual				~ImgProdLockBytes();
  
  	virtual ErrCode		ReadAt( sal_Size nPos, void* pBuffer, sal_Size nCount, sal_Size* pRead ) const;
  	virtual ErrCode		WriteAt( sal_Size nPos, const void* pBuffer, sal_Size nCount, sal_Size* pWritten );
  	virtual ErrCode		Flush() const;
  	virtual ErrCode		SetSize( sal_Size nSize );
  	virtual ErrCode		Stat( SvLockBytesStat*, SvLockBytesStatFlag ) const;
  };
  
  // ------------------------------------------------------------------------
  
  ImgProdLockBytes::ImgProdLockBytes( SvStream* pStm, sal_Bool bOwner ) :
  		SvLockBytes( pStm, bOwner )
  {
  }
  
  // ------------------------------------------------------------------------
  
  ImgProdLockBytes::ImgProdLockBytes( ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream > & rStmRef ) :
  		xStmRef( rStmRef )
  {
  	if( xStmRef.is() )
  	{
  		const sal_uInt32	nBytesToRead = 65535;
  		sal_uInt32			nRead;
  
  		do
  		{
  			::com::sun::star::uno::Sequence< sal_Int8 > aReadSeq;
  			
  			nRead = xStmRef->readSomeBytes( aReadSeq, nBytesToRead );
  
  			if( nRead )
  			{
  				const sal_uInt32 nOldLength = maSeq.getLength();
  				maSeq.realloc( nOldLength + nRead );
  				rtl_copyMemory( maSeq.getArray() + nOldLength, aReadSeq.getConstArray(), aReadSeq.getLength() );
  			}
  		}
  		while( nBytesToRead == nRead );
  	}
  }
  
  // ------------------------------------------------------------------------
  
  ImgProdLockBytes::~ImgProdLockBytes()
  {
  }
  
  // ------------------------------------------------------------------------
  
  ErrCode ImgProdLockBytes::ReadAt( sal_Size nPos, void* pBuffer, sal_Size nCount, sal_Size* pRead ) const
  {
  	if( GetStream() )
  	{
  		( (SvStream*) GetStream() )->ResetError();
  		const ErrCode nErr = SvLockBytes::ReadAt( nPos, pBuffer, nCount, pRead );
  		( (SvStream*) GetStream() )->ResetError();
  		return nErr;
  	}
  	else
  	{
  		const sal_Size nSeqLen = maSeq.getLength();
  		ErrCode nErr = ERRCODE_NONE;
  
  		if( nPos < nSeqLen )
  		{
  			if( ( nPos + nCount ) > nSeqLen )
  				nCount = nSeqLen - nPos;
  
  			memcpy( pBuffer, maSeq.getConstArray() + nPos, nCount );
  			*pRead = nCount;
  		}
  		else
  			*pRead = 0UL;
  
  		return nErr;
  	}
  }
  
  // ------------------------------------------------------------------------
  
  ErrCode ImgProdLockBytes::WriteAt( sal_Size nPos, const void* pBuffer, sal_Size nCount, sal_Size* pWritten )
  {
  	if( GetStream() )
  		return SvLockBytes::WriteAt( nPos, pBuffer, nCount, pWritten );
  	else
  	{
  		DBG_ASSERT( xStmRef.is(), "ImgProdLockBytes::WriteAt: xInputStream has no reference..." );
  		return ERRCODE_IO_CANTWRITE;
  	}
  }
  
  // ------------------------------------------------------------------------
  
  ErrCode ImgProdLockBytes::Flush() const
  {
  	return ERRCODE_NONE;
  }
  
  // ------------------------------------------------------------------------
  
  ErrCode ImgProdLockBytes::SetSize( sal_Size nSize )
  {
  	if( GetStream() )
  		return SvLockBytes::SetSize( nSize );
  	else
  	{
  		DBG_ERROR( "ImgProdLockBytes::SetSize not supported for xInputStream..." );
  		return ERRCODE_IO_CANTWRITE;
  	}
  }
  
  // ------------------------------------------------------------------------
  
  ErrCode ImgProdLockBytes::Stat( SvLockBytesStat* pStat, SvLockBytesStatFlag eFlag ) const
  {
  	if( GetStream() )
  		return SvLockBytes::Stat( pStat, eFlag );
  	else
  	{
  		DBG_ASSERT( xStmRef.is(), "ImgProdLockBytes::Stat: xInputStream has no reference..." );
  		pStat->nSize = maSeq.getLength();
  		return ERRCODE_NONE;
  	}
  }
  
  // -----------------
  // - ImageProducer -
  // -----------------
  
  ImageProducer::ImageProducer() :
  	mpStm		( NULL ),
  	mbConsInit	( sal_False )
  {
  	mpGraphic = new Graphic;
  	DBG_ASSERT( Application::GetFilterHdl().IsSet(), "ImageProducer::ImageProducer(): No filter handler set" );
  }
  
  // ------------------------------------------------------------
  
  ImageProducer::~ImageProducer()
  {
  	delete mpGraphic;
  	mpGraphic = NULL;
  
  	delete mpStm;
  	mpStm = NULL;
  
  	for( void* pCons = maConsList.First(); pCons; pCons = maConsList.Next() )
  		delete (::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons;
  }
  
  // ------------------------------------------------------------
  
  // ::com::sun::star::uno::XInterface
  ::com::sun::star::uno::Any ImageProducer::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
  {
  	::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
  										SAL_STATIC_CAST( ::com::sun::star::lang::XInitialization*, this ),
  										SAL_STATIC_CAST( ::com::sun::star::awt::XImageProducer*, this ) );
  	return (aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType ));
  }
  
  // ------------------------------------------------------------
  
  void ImageProducer::addConsumer( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer >& rxConsumer ) throw(::com::sun::star::uno::RuntimeException)
  {
  	DBG_ASSERT( rxConsumer.is(), "::AddConsumer(...): No consumer referenced!" );
  	if( rxConsumer.is() )
  		maConsList.Insert( new ::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > ( rxConsumer ), LIST_APPEND );
  }
  
  // ------------------------------------------------------------
  
  void ImageProducer::removeConsumer( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer >& rxConsumer ) throw(::com::sun::star::uno::RuntimeException)
  {
  	for( sal_uInt32 n = maConsList.Count(); n; )
  	{
  		::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > * pRef = (::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) maConsList.GetObject( --n );
  
  		if( *pRef == rxConsumer )
  		{
  			delete pRef;
  			maConsList.Remove( n );
  			break;
  		}
  	}
  }
  
  // ------------------------------------------------------------
  
  void ImageProducer::SetImage( const ::rtl::OUString& rPath )
  {
  	maURL = rPath;
  	mpGraphic->Clear();
  	mbConsInit = sal_False;
  	delete mpStm;
  
      if ( ::svt::GraphicAccess::isSupportedURL( maURL ) )
      {
          mpStm = ::svt::GraphicAccess::getImageStream( ::comphelper::getProcessServiceFactory(), maURL );
      }
      else if( maURL.getLength() )
  	{
  		SvStream* pIStm = ::utl::UcbStreamHelper::CreateStream( maURL, STREAM_STD_READ );
  		mpStm = pIStm ? new SvStream( new ImgProdLockBytes( pIStm, sal_True ) ) : NULL;
  	}
  	else
  		mpStm = NULL;
  }
  
  // ------------------------------------------------------------
  
  void ImageProducer::SetImage( SvStream& rStm )
  {
  	maURL = ::rtl::OUString();
  	mpGraphic->Clear();
  	mbConsInit = sal_False;
  
  	delete mpStm;
  	mpStm = new SvStream( new ImgProdLockBytes( &rStm, sal_False ) );
  }
  
  // ------------------------------------------------------------
  
  void ImageProducer::setImage( ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream > & rInputStmRef )
  {
  	maURL = ::rtl::OUString();
  	mpGraphic->Clear();
  	mbConsInit = sal_False;
  	delete mpStm;
  
  	if( rInputStmRef.is() )
  		mpStm = new SvStream( new ImgProdLockBytes( rInputStmRef ) );
  	else
  		mpStm = NULL;
  }
  
  // ------------------------------------------------------------
  
  void ImageProducer::NewDataAvailable()
  {
  	if( ( GRAPHIC_NONE == mpGraphic->GetType() ) || mpGraphic->GetContext() )
  		startProduction();
  }
  
  // ------------------------------------------------------------
  
  void ImageProducer::startProduction() throw(::com::sun::star::uno::RuntimeException)
  {
  	if( maConsList.Count() || maDoneHdl.IsSet() )
  	{
          bool bNotifyEmptyGraphics = false;
  
  		// valid stream or filled graphic? => update consumers
  		if( mpStm || ( mpGraphic->GetType() != GRAPHIC_NONE ) )
  		{
  			// if we already have a graphic, we don't have to import again;
  			// graphic is cleared if a new Stream is set
  			if( ( mpGraphic->GetType() == GRAPHIC_NONE ) || mpGraphic->GetContext() )
  			{
  				if ( ImplImportGraphic( *mpGraphic ) && maDoneHdl.IsSet() )
                      maDoneHdl.Call( mpGraphic );
  			}
  
  			if( mpGraphic->GetType() != GRAPHIC_NONE )
  				ImplUpdateData( *mpGraphic );
              else
                  bNotifyEmptyGraphics = true;
  		}
  		else
              bNotifyEmptyGraphics = true;
  
          if ( bNotifyEmptyGraphics )
  		{
  			// reset image
  			List	aTmp;
  			void*	pCons;
  
  			// create temporary list to hold interfaces
  			for( pCons = maConsList.First(); pCons; pCons = maConsList.Next() )
  				aTmp.Insert( new ::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons ), LIST_APPEND );
  
  			// iterate through interfaces
  			for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() )
  			{
  				( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->init( 0, 0 );
  				( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->complete( ::com::sun::star::awt::ImageStatus::IMAGESTATUS_STATICIMAGEDONE, this );
  			}
  
  			// delete interfaces in temporary list
  			for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() )
  				delete (::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons;
  
              if ( maDoneHdl.IsSet() )
                  maDoneHdl.Call( NULL );
  		}
  	}
  }
  
  // ------------------------------------------------------------
  
  sal_Bool ImageProducer::ImplImportGraphic( Graphic& rGraphic )
  {
      if( ERRCODE_IO_PENDING == mpStm->GetError() )
  		mpStm->ResetError();
  
  	mpStm->Seek( 0UL );
  
  	sal_Bool bRet = GraphicConverter::Import( *mpStm, rGraphic ) == ERRCODE_NONE;
  
  	if( ERRCODE_IO_PENDING == mpStm->GetError() )
  		mpStm->ResetError();
  
  	return bRet;
  }
  
  // ------------------------------------------------------------
  
  void ImageProducer::ImplUpdateData( const Graphic& rGraphic )
  {
  	ImplInitConsumer( rGraphic );
  
  	if( mbConsInit && maConsList.Count() )
  	{
  		List	aTmp;
  		void*	pCons;
  
  		ImplUpdateConsumer( rGraphic );
  		mbConsInit = sal_False;
  
  		// create temporary list to hold interfaces
  		for( pCons = maConsList.First(); pCons; pCons = maConsList.Next() )
  			aTmp.Insert( new ::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons ), LIST_APPEND );
  
  		// iterate through interfaces
  		for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() )
  			( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->complete( ::com::sun::star::awt::ImageStatus::IMAGESTATUS_STATICIMAGEDONE, this );
  
  		// delete interfaces in temporary list
  		for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() )
  			delete (::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons;
  	}
  }
  
  // ------------------------------------------------------------
  
  void ImageProducer::ImplInitConsumer( const Graphic& rGraphic )
  {
  	Bitmap				aBmp( rGraphic.GetBitmapEx().GetBitmap() );
  	BitmapReadAccess*	pBmpAcc = aBmp.AcquireReadAccess();
  
  	if(	pBmpAcc )
  	{
  		List             aTmp;
  		void *           pCons;
  		sal_uInt16       nPalCount = 0;
  		sal_uInt32       nRMask = 0;
  		sal_uInt32       nGMask = 0;
  		sal_uInt32       nBMask = 0;
  		sal_uInt32       nAMask = 0;
  		::com::sun::star::uno::Sequence< sal_Int32 >	aRGBPal;
  
  		if( pBmpAcc->HasPalette() )
  		{
  			nPalCount = pBmpAcc->GetPaletteEntryCount();
  
  			if( nPalCount )
  			{
  				aRGBPal = ::com::sun::star::uno::Sequence< sal_Int32 >( nPalCount + 1 );
  				
  				sal_Int32* pTmp = aRGBPal.getArray();
  
  				for( sal_uInt32 i = 0; i < nPalCount; i++, pTmp++ )
  				{
  					const BitmapColor& rCol = pBmpAcc->GetPaletteColor( (sal_uInt16) i );
  
  					*pTmp = ( (sal_Int32) rCol.GetRed() ) << (sal_Int32)(24L);
  					*pTmp |= ( (sal_Int32) rCol.GetGreen() ) << (sal_Int32)(16L);
  					*pTmp |= ( (sal_Int32) rCol.GetBlue() ) << (sal_Int32)(8L);
  					*pTmp |= (sal_Int32)(0x000000ffL);
  				}
  
  				if( rGraphic.IsTransparent() )
  				{
  					// append transparent entry
  					*pTmp = (sal_Int32)(0xffffff00L);
  					mnTransIndex = nPalCount;
  					nPalCount++;
  				}
  				else
  					mnTransIndex = 0;
  
  			}
  		}
  		else
  		{
  			nRMask = 0xff000000UL;
  			nGMask = 0x00ff0000UL;
  			nBMask = 0x0000ff00UL;
  			nAMask = 0x000000ffUL;
  		}
  
  		// create temporary list to hold interfaces
  		for( pCons = maConsList.First(); pCons; pCons = maConsList.Next() )
  			aTmp.Insert( new ::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons ), LIST_APPEND );
  
  		// iterate through interfaces
  		for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() )
  		{
  			( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->init( pBmpAcc->Width(), pBmpAcc->Height() );
  			( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->setColorModel( pBmpAcc->GetBitCount(),
  													   aRGBPal, nRMask, nGMask, nBMask, nAMask );
  		}
  
  		// delete interfaces in temporary list
  		for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() )
  			delete (::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons;
  
  		aBmp.ReleaseAccess( pBmpAcc );
  		mbConsInit = sal_True;
  	}
  }
  
  // ------------------------------------------------------------
  
  void ImageProducer::ImplUpdateConsumer( const Graphic& rGraphic )
  {
  	BitmapEx			aBmpEx( rGraphic.GetBitmapEx() );
  	Bitmap				aBmp( aBmpEx.GetBitmap() );
  	BitmapReadAccess*	pBmpAcc = aBmp.AcquireReadAccess();
  
  	if( pBmpAcc )
  	{
  		List				aTmp;
  		void*				pCons;
  		Bitmap				aMask( aBmpEx.GetMask() );
  		BitmapReadAccess*	pMskAcc = !!aMask ? aMask.AcquireReadAccess() : NULL;
  		const long			nWidth = pBmpAcc->Width();
  		const long			nHeight = pBmpAcc->Height();
  		const long			nStartX = 0L;
  		const long			nEndX = nWidth - 1L;
  		const long			nStartY = 0L;
  		const long			nEndY = nHeight - 1L;
  		const long			nPartWidth = nEndX - nStartX + 1;
  		const long			nPartHeight = nEndY - nStartY + 1;
  
  		if( !pMskAcc )
  		{
  			aMask = Bitmap( aBmp.GetSizePixel(), 1 );
  			aMask.Erase( COL_BLACK );
  			pMskAcc = aMask.AcquireReadAccess();
  		}
  
  		// create temporary list to hold interfaces
  		for( pCons = maConsList.First(); pCons; pCons = maConsList.Next() )
  			aTmp.Insert( new ::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons ), LIST_APPEND );
  
  		if( pBmpAcc->HasPalette() )
  		{
  			const BitmapColor aWhite( pMskAcc->GetBestMatchingColor( Color( COL_WHITE ) ) );
  
  			if( mnTransIndex < 256 )
  			{
  				::com::sun::star::uno::Sequence<sal_Int8>	aData( nPartWidth * nPartHeight );
  				sal_Int8*									pTmp = aData.getArray();
  
  				for( long nY = nStartY; nY <= nEndY; nY++ )
  				{
  					for( long nX = nStartX; nX <= nEndX; nX++ )
  					{
  						if( pMskAcc->GetPixel( nY, nX ) == aWhite )
  							*pTmp++ = sal::static_int_cast< sal_Int8 >(
                                  mnTransIndex );
  						else
  							*pTmp++ = pBmpAcc->GetPixel( nY, nX ).GetIndex();
  					}
  				}
  
  				// iterate through interfaces
  				for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() )
  					( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->setPixelsByBytes( nStartX, nStartY, nPartWidth, nPartHeight,
  																	   aData, 0UL, nPartWidth );
  			}
  			else
  			{
  				::com::sun::star::uno::Sequence<sal_Int32>	aData( nPartWidth * nPartHeight );
  				sal_Int32*									pTmp = aData.getArray();
  
  				for( long nY = nStartY; nY <= nEndY; nY++ )
  				{
  					for( long nX = nStartX; nX <= nEndX; nX++ )
  					{
  						if( pMskAcc->GetPixel( nY, nX ) == aWhite )
  							*pTmp++ = mnTransIndex;
  						else
  							*pTmp++ = pBmpAcc->GetPixel( nY, nX ).GetIndex();
  					}
  				}
  
  				// iterate through interfaces
  				for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() )
  					( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->setPixelsByLongs( nStartX, nStartY, nPartWidth, nPartHeight,
  																	   aData, 0UL, nPartWidth );
  			}
  		}
  		else
  		{
  			::com::sun::star::uno::Sequence<sal_Int32> 	aData( nPartWidth * nPartHeight );
  			const BitmapColor							aWhite( pMskAcc->GetBestMatchingColor( Color( COL_WHITE ) ) );
  			sal_Int32*									pTmp = aData.getArray();
  
  			for( long nY = nStartY; nY <= nEndY; nY++ )
  			{
  				for( long nX = nStartX; nX <= nEndX; nX++, pTmp++ )
  				{
  					const BitmapColor aCol( pBmpAcc->GetPixel( nY, nX ) );
  
  					*pTmp = ( (sal_Int32) aCol.GetRed() ) << (sal_Int32)(24L);
  					*pTmp |= ( (sal_Int32) aCol.GetGreen() ) << (sal_Int32)(16L);
  					*pTmp |= ( (sal_Int32) aCol.GetBlue() ) << (sal_Int32)(8L);
  
  					if( pMskAcc->GetPixel( nY, nX ) != aWhite )
  						*pTmp |= 0x000000ffUL;
  				}
  			}
  
  			// iterate through interfaces
  			for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() )
  				( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->setPixelsByLongs( nStartX, nStartY, nPartWidth, nPartHeight,
  																   aData, 0UL, nPartWidth );
  		}
  
  		// delete interfaces in temporary list
  		for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() )
  			delete (::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons;
  
  		aBmp.ReleaseAccess( pBmpAcc );
  		aMask.ReleaseAccess( pMskAcc );
  	}
  }
  
  void ImageProducer::initialize( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& aArguments ) throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException)
  {
  	if ( aArguments.getLength() == 1 )
  	{
  		::com::sun::star::uno::Any aArg = aArguments.getConstArray()[0];
  		rtl::OUString aURL;
  		if ( aArg >>= aURL )
  		{
  			SetImage( aURL );
  		}
  	}
  }
  
  namespace frm
  {
  ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >
  SAL_CALL ImageProducer_CreateInstance(
  	const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& )
  {
  	return ::com::sun::star::uno::Reference < ::com::sun::star::uno::XInterface >(
  		( ::cppu::OWeakObject* ) new ImageProducer );
  }
  } // namespace frm
  