AOO410/main/forms/source/component/imgprod.cxx

/**************************************************************
 * 
 * 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