xref: /aoo42x/main/vcl/source/gdi/bitmapex.cxx (revision f2e5373e)

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

#include <ctype.h>
#include <rtl/crc.h>
#include <tools/stream.hxx>
#include <tools/debug.hxx>
#include <tools/rc.h>
#include <vcl/salbtype.hxx>
#include <vcl/outdev.hxx>
#include <vcl/alpha.hxx>
#include <vcl/bitmapex.hxx>
#include <vcl/pngread.hxx>
#include <vcl/svapp.hxx>
#include <vcl/bmpacc.hxx>
#include <vcl/dibtools.hxx>
#include <image.h>
#include <impimagetree.hxx>
#include <basegfx/matrix/b2dhommatrixtools.hxx>

// ------------
// - BitmapEx -
// ------------

BitmapEx::BitmapEx() :
		eTransparent( TRANSPARENT_NONE ),
		bAlpha		( sal_False )
{
}

// ------------------------------------------------------------------

BitmapEx::BitmapEx( const BitmapEx& rBitmapEx ) :
		aBitmap				( rBitmapEx.aBitmap ),
		aMask				( rBitmapEx.aMask ),
		aBitmapSize			( rBitmapEx.aBitmapSize ),
		aTransparentColor	( rBitmapEx.aTransparentColor ),
		eTransparent		( rBitmapEx.eTransparent ),
		bAlpha				( rBitmapEx.bAlpha )
{
}

BitmapEx::BitmapEx( const BitmapEx& rBitmapEx, Point aSrc, Size aSize ) :
		eTransparent( TRANSPARENT_NONE ),
		bAlpha		( sal_False )
{
	if( rBitmapEx.IsEmpty() )
		return;

	aBitmap = Bitmap( aSize, rBitmapEx.aBitmap.GetBitCount() );
	aBitmapSize = aSize;
	if( rBitmapEx.IsAlpha() )
	{
		bAlpha = sal_True;
		aMask = AlphaMask( aSize ).ImplGetBitmap();
	}
	else if( rBitmapEx.IsTransparent() )
		aMask = Bitmap( aSize, rBitmapEx.aMask.GetBitCount() );

	Rectangle aDestRect( Point( 0, 0 ), aSize );
	Rectangle aSrcRect( aSrc, aSize );
	CopyPixel( aDestRect, aSrcRect, &rBitmapEx );
}

// ------------------------------------------------------------------

BitmapEx::BitmapEx( const ResId& rResId ) :
		eTransparent( TRANSPARENT_NONE ),
		bAlpha		( sal_False )
{
	static ImplImageTreeSingletonRef	aImageTree;
	ResMgr* 							pResMgr = NULL;

	ResMgr::GetResourceSkipHeader( rResId.SetRT( RSC_BITMAP ), &pResMgr );
	pResMgr->ReadLong();
	pResMgr->ReadLong();

	const String aFileName( pResMgr->ReadString() );
	::rtl::OUString aCurrentSymbolsStyle = Application::GetSettings().GetStyleSettings().GetCurrentSymbolsStyleName();

	if( !aImageTree->loadImage( aFileName, aCurrentSymbolsStyle, *this ) )
	{
#ifdef DBG_UTIL
		ByteString aErrorStr( "BitmapEx::BitmapEx( const ResId& rResId ): could not load image <" );
		DBG_ERROR( ( ( aErrorStr += ByteString( aFileName, RTL_TEXTENCODING_ASCII_US ) ) += '>' ).GetBuffer() );
#endif
	}
}

// ------------------------------------------------------------------

BitmapEx::BitmapEx( const Bitmap& rBmp ) :
		aBitmap		( rBmp ),
		aBitmapSize	( aBitmap.GetSizePixel() ),
		eTransparent( TRANSPARENT_NONE ),
		bAlpha		( sal_False )
{
}

// ------------------------------------------------------------------

BitmapEx::BitmapEx( const Bitmap& rBmp, const Bitmap& rMask ) :
		aBitmap			( rBmp ),
		aMask			( rMask ),
		aBitmapSize		( aBitmap.GetSizePixel() ),
		eTransparent	( !rMask ? TRANSPARENT_NONE : TRANSPARENT_BITMAP ),
		bAlpha			( sal_False )
{
	if(!!aBitmap && !!aMask && aBitmap.GetSizePixel() != aMask.GetSizePixel())
	{
		OSL_ENSURE(false, "Mask size differs from Bitmap size, corrected Mask (!)");
		aMask.Scale(aBitmap.GetSizePixel());
	}

	// #105489# Ensure a mask is exactly one bit deep
	if( !!aMask && aMask.GetBitCount() != 1 )
	{
		OSL_TRACE("BitmapEx: forced mask to monochrome");
		aMask.ImplMakeMono( 255 );
	}
}

// ------------------------------------------------------------------

BitmapEx::BitmapEx( const Bitmap& rBmp, const AlphaMask& rAlphaMask ) :
		aBitmap			( rBmp ),
		aMask			( rAlphaMask.ImplGetBitmap() ),
		aBitmapSize		( aBitmap.GetSizePixel() ),
		eTransparent	( !rAlphaMask ? TRANSPARENT_NONE : TRANSPARENT_BITMAP ),
		bAlpha			( !rAlphaMask ? sal_False : sal_True )
{
	if(!!aBitmap && !!aMask && aBitmap.GetSizePixel() != aMask.GetSizePixel())
	{
		OSL_ENSURE(false, "Alpha size differs from Bitmap size, corrected Mask (!)");
		aMask.Scale(rBmp.GetSizePixel());
	}

	// #i75531# the workaround below can go when
	// X11SalGraphics::drawAlphaBitmap()'s render acceleration
	// can handle the bitmap depth mismatch directly
	if( aBitmap.GetBitCount() < aMask.GetBitCount() )
		aBitmap.Convert( BMP_CONVERSION_24BIT );
}

// ------------------------------------------------------------------

BitmapEx::BitmapEx( const Bitmap& rBmp, const Color& rTransparentColor ) :
		aBitmap				( rBmp ),
		aBitmapSize			( aBitmap.GetSizePixel() ),
		aTransparentColor	( rTransparentColor ),
		eTransparent		( TRANSPARENT_BITMAP ),
		bAlpha				( sal_False )
{
	aMask = aBitmap.CreateMask( aTransparentColor );

	DBG_ASSERT( rBmp.GetSizePixel() == aMask.GetSizePixel(),
				"BitmapEx::BitmapEx(): size mismatch for bitmap and alpha mask." );
}

// ------------------------------------------------------------------

BitmapEx::~BitmapEx()
{
}

// ------------------------------------------------------------------

// ------------------------------------------------------------------

BitmapEx& BitmapEx::operator=( const BitmapEx& rBitmapEx )
{
	if( &rBitmapEx != this )
	{
		aBitmap = rBitmapEx.aBitmap;
		aMask = rBitmapEx.aMask;
		aBitmapSize = rBitmapEx.aBitmapSize;
		aTransparentColor = rBitmapEx.aTransparentColor;
		eTransparent = rBitmapEx.eTransparent;
		bAlpha = rBitmapEx.bAlpha;
	}

	return *this;
}

// ------------------------------------------------------------------

sal_Bool BitmapEx::operator==( const BitmapEx& rBitmapEx ) const
{
	if( eTransparent != rBitmapEx.eTransparent )
		return sal_False;

	if( aBitmap != rBitmapEx.aBitmap )
		return sal_False;

	if( aBitmapSize != rBitmapEx.aBitmapSize )
		return sal_False;

	if( eTransparent == TRANSPARENT_NONE )
		return sal_True;

	if( eTransparent == TRANSPARENT_COLOR )
		return aTransparentColor == rBitmapEx.aTransparentColor;

	return( ( aMask == rBitmapEx.aMask ) && ( bAlpha == rBitmapEx.bAlpha ) );
}

// ------------------------------------------------------------------

sal_Bool BitmapEx::IsEqual( const BitmapEx& rBmpEx ) const
{
	return( rBmpEx.eTransparent == eTransparent &&
			rBmpEx.bAlpha == bAlpha &&
			rBmpEx.aBitmap.IsEqual( aBitmap ) &&
			rBmpEx.aMask.IsEqual( aMask ) );
}

// ------------------------------------------------------------------

sal_Bool BitmapEx::IsEmpty() const
{
	return( aBitmap.IsEmpty() && aMask.IsEmpty() );
}

// ------------------------------------------------------------------

void BitmapEx::SetEmpty()
{
	aBitmap.SetEmpty();
	aMask.SetEmpty();
	eTransparent = TRANSPARENT_NONE;
	bAlpha = sal_False;
}

// ------------------------------------------------------------------

void BitmapEx::Clear()
{
	SetEmpty();
}

// ------------------------------------------------------------------

sal_Bool BitmapEx::IsTransparent() const
{
	return( eTransparent != TRANSPARENT_NONE );
}

// ------------------------------------------------------------------

sal_Bool BitmapEx::IsAlpha() const
{
	return( IsTransparent() && bAlpha );
}

// ------------------------------------------------------------------

Bitmap BitmapEx::GetBitmap( const Color* pTransReplaceColor ) const
{
	Bitmap aRetBmp( aBitmap );

	if( pTransReplaceColor && ( eTransparent != TRANSPARENT_NONE ) )
	{
		Bitmap aTempMask;

		if( eTransparent == TRANSPARENT_COLOR )
			aTempMask = aBitmap.CreateMask( aTransparentColor );
		else
			aTempMask = aMask;

		if( !IsAlpha() )
			aRetBmp.Replace( aTempMask, *pTransReplaceColor );
		else
			aRetBmp.Replace( GetAlpha(), *pTransReplaceColor );
	}

	return aRetBmp;
}

// ------------------------------------------------------------------

BitmapEx BitmapEx::GetColorTransformedBitmapEx( BmpColorMode eColorMode ) const
{
	BitmapEx aRet;

	if( BMP_COLOR_HIGHCONTRAST == eColorMode )
	{
		aRet = *this;
		aRet.aBitmap = aBitmap.GetColorTransformedBitmap( eColorMode );
	}
	else if( BMP_COLOR_MONOCHROME_BLACK == eColorMode ||
			 BMP_COLOR_MONOCHROME_WHITE == eColorMode )
	{
		aRet = *this;
		aRet.aBitmap = aRet.aBitmap.GetColorTransformedBitmap( eColorMode );

		if( !aRet.aMask.IsEmpty() )
		{
			aRet.aMask.CombineSimple( aRet.aBitmap, BMP_COMBINE_OR );
			aRet.aBitmap.Erase( ( BMP_COLOR_MONOCHROME_BLACK == eColorMode ) ? COL_BLACK : COL_WHITE );

			DBG_ASSERT( aRet.aBitmap.GetSizePixel() == aRet.aMask.GetSizePixel(),
						"BitmapEx::GetColorTransformedBitmapEx(): size mismatch for bitmap and alpha mask." );
		}
	}

	return aRet;
}

// ------------------------------------------------------------------

Bitmap BitmapEx::GetMask() const
{
	Bitmap aRet( aMask );

	if( IsAlpha() )
		aRet.ImplMakeMono( 255 );

	return aRet;
}

// ------------------------------------------------------------------

AlphaMask BitmapEx::GetAlpha() const
{
	AlphaMask aAlpha;

	if( IsAlpha() )
		aAlpha.ImplSetBitmap( aMask );
	else
		aAlpha = aMask;

	return aAlpha;
}

// ------------------------------------------------------------------

sal_uLong BitmapEx::GetSizeBytes() const
{
	sal_uLong nSizeBytes = aBitmap.GetSizeBytes();

	if( eTransparent == TRANSPARENT_BITMAP )
		nSizeBytes += aMask.GetSizeBytes();

	return nSizeBytes;
}

// ------------------------------------------------------------------

sal_uLong BitmapEx::GetChecksum() const
{
	sal_uInt32	nCrc = aBitmap.GetChecksum();
	SVBT32		aBT32;

	UInt32ToSVBT32( (long) eTransparent, aBT32 );
	nCrc = rtl_crc32( nCrc, aBT32, 4 );

	UInt32ToSVBT32( (long) bAlpha, aBT32 );
	nCrc = rtl_crc32( nCrc, aBT32, 4 );

	if( ( TRANSPARENT_BITMAP == eTransparent ) && !aMask.IsEmpty() )
	{
		UInt32ToSVBT32( aMask.GetChecksum(), aBT32 );
		nCrc = rtl_crc32( nCrc, aBT32, 4 );
	}

	return nCrc;
}

// ------------------------------------------------------------------

void BitmapEx::SetSizePixel( const Size& rNewSize, sal_uInt32 nScaleFlag )
{
	if(GetSizePixel() != rNewSize)
	{
		Scale( rNewSize, nScaleFlag );
	}
}

// ------------------------------------------------------------------

sal_Bool BitmapEx::Invert()
{
	sal_Bool bRet = sal_False;

	if( !!aBitmap )
	{
		bRet = aBitmap.Invert();

		if( bRet && ( eTransparent == TRANSPARENT_COLOR ) )
			aTransparentColor = BitmapColor( aTransparentColor ).Invert();
	}

	return bRet;
}

// ------------------------------------------------------------------

sal_Bool BitmapEx::Mirror( sal_uLong nMirrorFlags )
{
	sal_Bool bRet = sal_False;

	if( !!aBitmap )
	{
		bRet = aBitmap.Mirror( nMirrorFlags );

		if( bRet && ( eTransparent == TRANSPARENT_BITMAP ) && !!aMask )
			aMask.Mirror( nMirrorFlags );
	}

	return bRet;
}

// ------------------------------------------------------------------

sal_Bool BitmapEx::Scale( const double& rScaleX, const double& rScaleY, sal_uInt32 nScaleFlag )
{
	sal_Bool bRet = sal_False;

	if( !!aBitmap )
	{
		bRet = aBitmap.Scale( rScaleX, rScaleY, nScaleFlag );

		if( bRet && ( eTransparent == TRANSPARENT_BITMAP ) && !!aMask )
		{
			aMask.Scale( rScaleX, rScaleY, nScaleFlag );
		}

		aBitmapSize = aBitmap.GetSizePixel();

		DBG_ASSERT( !aMask || aBitmap.GetSizePixel() == aMask.GetSizePixel(),
					"BitmapEx::Scale(): size mismatch for bitmap and alpha mask." );
	}

	return bRet;
}

// ------------------------------------------------------------------------

sal_Bool BitmapEx::Scale( const Size& rNewSize, sal_uInt32 nScaleFlag )
{
	sal_Bool bRet;

	if( aBitmapSize.Width() && aBitmapSize.Height() )
	{
		bRet = Scale( (double) rNewSize.Width() / aBitmapSize.Width(),
					  (double) rNewSize.Height() / aBitmapSize.Height(),
					  nScaleFlag );
	}
	else
		bRet = sal_True;

	return bRet;
}

// ------------------------------------------------------------------

sal_Bool BitmapEx::Rotate( long nAngle10, const Color& rFillColor )
{
	sal_Bool bRet = sal_False;

	if( !!aBitmap )
	{
		const sal_Bool bTransRotate = ( Color( COL_TRANSPARENT ) == rFillColor );

		if( bTransRotate )
		{
			if( eTransparent == TRANSPARENT_COLOR )
				bRet = aBitmap.Rotate( nAngle10, aTransparentColor );
			else
			{
				bRet = aBitmap.Rotate( nAngle10, COL_BLACK );

				if( eTransparent == TRANSPARENT_NONE )
				{
					aMask = Bitmap( aBitmapSize, 1 );
					aMask.Erase( COL_BLACK );
					eTransparent = TRANSPARENT_BITMAP;
				}

				if( bRet && !!aMask )
					aMask.Rotate( nAngle10, COL_WHITE );
			}
		}
		else
		{
			bRet = aBitmap.Rotate( nAngle10, rFillColor );

			if( bRet && ( eTransparent == TRANSPARENT_BITMAP ) && !!aMask )
				aMask.Rotate( nAngle10, COL_WHITE );
		}

		aBitmapSize = aBitmap.GetSizePixel();

		DBG_ASSERT( !aMask || aBitmap.GetSizePixel() == aMask.GetSizePixel(),
					"BitmapEx::Rotate(): size mismatch for bitmap and alpha mask." );
	}

	return bRet;
}

// ------------------------------------------------------------------

sal_Bool BitmapEx::Crop( const Rectangle& rRectPixel )
{
	sal_Bool bRet = sal_False;

	if( !!aBitmap )
	{
		bRet = aBitmap.Crop( rRectPixel );

		if( bRet && ( eTransparent == TRANSPARENT_BITMAP ) && !!aMask )
			aMask.Crop( rRectPixel );

		aBitmapSize = aBitmap.GetSizePixel();

		DBG_ASSERT( !aMask || aBitmap.GetSizePixel() == aMask.GetSizePixel(),
					"BitmapEx::Crop(): size mismatch for bitmap and alpha mask." );
	}

	return bRet;
}

// ------------------------------------------------------------------

sal_Bool BitmapEx::Convert( BmpConversion eConversion )
{
	return( !!aBitmap ? aBitmap.Convert( eConversion ) : sal_False );
}

// ------------------------------------------------------------------

sal_Bool BitmapEx::ReduceColors( sal_uInt16 nNewColorCount, BmpReduce eReduce )
{
	return( !!aBitmap ? aBitmap.ReduceColors( nNewColorCount, eReduce ) : sal_False );
}

// ------------------------------------------------------------------

sal_Bool BitmapEx::Expand( sal_uLong nDX, sal_uLong nDY, const Color* pInitColor, sal_Bool bExpandTransparent )
{
	sal_Bool bRet = sal_False;

	if( !!aBitmap )
	{
		bRet = aBitmap.Expand( nDX, nDY, pInitColor );

		if( bRet && ( eTransparent == TRANSPARENT_BITMAP ) && !!aMask )
		{
			Color aColor( bExpandTransparent ? COL_WHITE : COL_BLACK );
			aMask.Expand( nDX, nDY, &aColor );
		}

		aBitmapSize = aBitmap.GetSizePixel();

		DBG_ASSERT( !aMask || aBitmap.GetSizePixel() == aMask.GetSizePixel(),
					"BitmapEx::Expand(): size mismatch for bitmap and alpha mask." );
	}

	return bRet;
}

// ------------------------------------------------------------------

sal_Bool BitmapEx::CopyPixel( const Rectangle& rRectDst, const Rectangle& rRectSrc,
						  const BitmapEx* pBmpExSrc )
{
	sal_Bool bRet = sal_False;

	if( !pBmpExSrc || pBmpExSrc->IsEmpty() )
	{
		if( !aBitmap.IsEmpty() )
		{
			bRet = aBitmap.CopyPixel( rRectDst, rRectSrc );

			if( bRet && ( eTransparent == TRANSPARENT_BITMAP ) && !!aMask )
				aMask.CopyPixel( rRectDst, rRectSrc );
		}
	}
	else
	{
		if( !aBitmap.IsEmpty() )
		{
			bRet = aBitmap.CopyPixel( rRectDst, rRectSrc, &pBmpExSrc->aBitmap );

			if( bRet )
			{
				if( pBmpExSrc->IsAlpha() )
				{
					if( IsAlpha() )
						// cast to use the optimized AlphaMask::CopyPixel
						((AlphaMask*) &aMask)->CopyPixel( rRectDst, rRectSrc, (AlphaMask*)&pBmpExSrc->aMask );
					else if( IsTransparent() )
					{
						AlphaMask* pAlpha = new AlphaMask( aMask );

						aMask = pAlpha->ImplGetBitmap();
						delete pAlpha;
						bAlpha = sal_True;
						aMask.CopyPixel( rRectDst, rRectSrc, &pBmpExSrc->aMask );
					}
					else
					{
						sal_uInt8	cBlack = 0;
						AlphaMask*	pAlpha = new AlphaMask( GetSizePixel(), &cBlack );

						aMask = pAlpha->ImplGetBitmap();
						delete pAlpha;
						eTransparent = TRANSPARENT_BITMAP;
						bAlpha = sal_True;
						aMask.CopyPixel( rRectDst, rRectSrc, &pBmpExSrc->aMask );
					}
				}
				else if( pBmpExSrc->IsTransparent() )
				{
					if( IsAlpha() )
					{
						AlphaMask aAlpha( pBmpExSrc->aMask );
						aMask.CopyPixel( rRectDst, rRectSrc, &aAlpha.ImplGetBitmap() );
					}
					else if( IsTransparent() )
						aMask.CopyPixel( rRectDst, rRectSrc, &pBmpExSrc->aMask );
					else
					{
						aMask = Bitmap( GetSizePixel(), 1 );
						aMask.Erase( Color( COL_BLACK ) );
						eTransparent = TRANSPARENT_BITMAP;
						aMask.CopyPixel( rRectDst, rRectSrc, &pBmpExSrc->aMask );
					}
				}
				else if( IsAlpha() )
				{
					sal_uInt8			cBlack = 0;
					const AlphaMask		aAlphaSrc( pBmpExSrc->GetSizePixel(), &cBlack );

					aMask.CopyPixel( rRectDst, rRectSrc, &aAlphaSrc.ImplGetBitmap() );
				}
				else if( IsTransparent() )
				{
					Bitmap aMaskSrc( pBmpExSrc->GetSizePixel(), 1 );

					aMaskSrc.Erase( Color( COL_BLACK ) );
					aMask.CopyPixel( rRectDst, rRectSrc, &aMaskSrc );
				}
			}
		}
	}

	return bRet;
}

// ------------------------------------------------------------------

sal_Bool BitmapEx::Erase( const Color& rFillColor )
{
	sal_Bool bRet = sal_False;

	if( !!aBitmap )
	{
		bRet = aBitmap.Erase( rFillColor );

		if( bRet && ( eTransparent == TRANSPARENT_BITMAP ) && !!aMask )
		{
			// #104416# Respect transparency on fill color
			if( rFillColor.GetTransparency() )
			{
				const Color aFill( rFillColor.GetTransparency(), rFillColor.GetTransparency(), rFillColor.GetTransparency() );
				aMask.Erase( aFill );
			}
			else
			{
				const Color aBlack( COL_BLACK );
				aMask.Erase( aBlack );
			}
		}
	}

	return bRet;
}

// ------------------------------------------------------------------

sal_Bool BitmapEx::Dither( sal_uLong nDitherFlags )
{
	return( !!aBitmap ? aBitmap.Dither( nDitherFlags ) : sal_False );
}

// ------------------------------------------------------------------

sal_Bool BitmapEx::Replace( const Color& rSearchColor, const Color& rReplaceColor, sal_uLong nTol )
{
	return( !!aBitmap ? aBitmap.Replace( rSearchColor, rReplaceColor, nTol ) : sal_False );
}

// ------------------------------------------------------------------

sal_Bool BitmapEx::Replace( const Color* pSearchColors, const Color* pReplaceColors, sal_uLong nColorCount, const sal_uLong* pTols )
{
	return( !!aBitmap ? aBitmap.Replace( pSearchColors, pReplaceColors, nColorCount, (sal_uLong*) pTols ) : sal_False );
}

// ------------------------------------------------------------------

sal_Bool BitmapEx::Adjust( short nLuminancePercent, short nContrastPercent,
					   short nChannelRPercent, short nChannelGPercent, short nChannelBPercent,
					   double fGamma, sal_Bool bInvert )
{
	return( !!aBitmap ? aBitmap.Adjust( nLuminancePercent, nContrastPercent,
										nChannelRPercent, nChannelGPercent, nChannelBPercent,
										fGamma, bInvert ) : sal_False );
}

// ------------------------------------------------------------------

sal_Bool BitmapEx::Filter( BmpFilter eFilter, const BmpFilterParam* pFilterParam, const Link* pProgress )
{
	return( !!aBitmap ? aBitmap.Filter( eFilter, pFilterParam, pProgress ) : sal_False );
}

// ------------------------------------------------------------------

void BitmapEx::Draw( OutputDevice* pOutDev, const Point& rDestPt ) const
{
	pOutDev->DrawBitmapEx( rDestPt, *this );
}

// ------------------------------------------------------------------

void BitmapEx::Draw( OutputDevice* pOutDev,
					 const Point& rDestPt, const Size& rDestSize ) const
{
	pOutDev->DrawBitmapEx( rDestPt, rDestSize, *this );
}

// ------------------------------------------------------------------

void BitmapEx::Draw( OutputDevice* pOutDev,
					 const Point& rDestPt, const Size& rDestSize,
					 const Point& rSrcPtPixel, const Size& rSrcSizePixel ) const
{
	pOutDev->DrawBitmapEx( rDestPt, rDestSize, rSrcPtPixel, rSrcSizePixel, *this );
}

// ------------------------------------------------------------------

sal_uInt8 BitmapEx::GetTransparency(sal_Int32 nX, sal_Int32 nY) const
{
	sal_uInt8 nTransparency(0xff);

	if(!aBitmap.IsEmpty())
	{
		if(nX >= 0 && nX < aBitmapSize.Width() && nY >= 0 && nY < aBitmapSize.Height())
		{
			switch(eTransparent)
			{
				case TRANSPARENT_NONE:
				{
					// not transparent, ergo all covered
					nTransparency = 0x00;
					break;
				}
				case TRANSPARENT_COLOR:
				{
					Bitmap aTestBitmap(aBitmap);
					BitmapReadAccess* pRead = aTestBitmap.AcquireReadAccess();

					if(pRead)
					{
						const Color aColor = pRead->GetColor(nY, nX);

						// if color is not equal to TransparentColor, we are not transparent
						if(aColor != aTransparentColor)
						{
							nTransparency = 0x00;
						}

						aTestBitmap.ReleaseAccess(pRead);
					}
					break;
				}
				case TRANSPARENT_BITMAP:
				{
					if(!aMask.IsEmpty())
					{
						Bitmap aTestBitmap(aMask);
						BitmapReadAccess* pRead = aTestBitmap.AcquireReadAccess();

						if(pRead)
						{
							const BitmapColor aBitmapColor(pRead->GetPixel(nY, nX));

							if(bAlpha)
							{
								nTransparency = aBitmapColor.GetIndex();
							}
							else
							{
								if(0x00 == aBitmapColor.GetIndex())
								{
									nTransparency = 0x00;
								}
							}

							aTestBitmap.ReleaseAccess(pRead);
						}
					}
					break;
				}
			}
		}
	}

	return nTransparency;
}

// ------------------------------------------------------------------

namespace
{
	Bitmap impTransformBitmap(
		const Bitmap& rSource,
		const Size aDestinationSize,
		const basegfx::B2DHomMatrix& rTransform,
		bool bSmooth)
	{
		Bitmap aDestination(aDestinationSize, 24);
		BitmapWriteAccess* pWrite = aDestination.AcquireWriteAccess();

		if(pWrite)
		{
			//const Size aContentSizePixel(rSource.GetSizePixel());
			BitmapReadAccess* pRead = (const_cast< Bitmap& >(rSource)).AcquireReadAccess();

			if(pRead)
			{
				const Size aDestinationSizePixel(aDestination.GetSizePixel());
				const BitmapColor aOutside(BitmapColor(0xff, 0xff, 0xff));

				for(sal_Int32 y(0L); y < aDestinationSizePixel.getHeight(); y++)
				{
					for(sal_Int32 x(0L); x < aDestinationSizePixel.getWidth(); x++)
					{
						const basegfx::B2DPoint aSourceCoor(rTransform * basegfx::B2DPoint(x, y));

						if(bSmooth)
						{
							pWrite->SetPixel(
								y,
								x,
								pRead->GetInterpolatedColorWithFallback(
									aSourceCoor.getY(),
									aSourceCoor.getX(),
									aOutside));
						}
						else
						{
							// this version does the correct <= 0.0 checks, so no need
							// to do the static_cast< sal_Int32 > self and make an error
							pWrite->SetPixel(
								y,
								x,
								pRead->GetColorWithFallback(
									aSourceCoor.getY(),
									aSourceCoor.getX(),
									aOutside));
						}
					}
				}

				delete pRead;
			}

			delete pWrite;
		}

		rSource.AdaptBitCount(aDestination);

		return aDestination;
	}
} // end of anonymous namespace

BitmapEx BitmapEx::TransformBitmapEx(
	double fWidth,
	double fHeight,
	const basegfx::B2DHomMatrix& rTransformation,
	bool bSmooth) const
{
	if(fWidth <= 1 || fHeight <= 1)
		return BitmapEx();

	// force destination to 24 bit, we want to smooth output
	const Size aDestinationSize(basegfx::fround(fWidth), basegfx::fround(fHeight));
	const Bitmap aDestination(impTransformBitmap(GetBitmap(), aDestinationSize, rTransformation, bSmooth));

	// create mask
	if(IsTransparent())
	{
		if(IsAlpha())
		{
			const Bitmap aAlpha(impTransformBitmap(GetAlpha().GetBitmap(), aDestinationSize, rTransformation, bSmooth));
			return BitmapEx(aDestination, AlphaMask(aAlpha));
		}
		else
		{
			const Bitmap aMask(impTransformBitmap(GetMask(), aDestinationSize, rTransformation, false));
			return BitmapEx(aDestination, aMask);
		}
	}

	return BitmapEx(aDestination);
}

// ------------------------------------------------------------------

BitmapEx BitmapEx::getTransformed(
	const basegfx::B2DHomMatrix& rTransformation,
	const basegfx::B2DRange& rVisibleRange,
	double fMaximumArea,
	bool bSmooth) const
{
	BitmapEx aRetval;

	if(IsEmpty())
		return aRetval;

	const sal_uInt32 nSourceWidth(GetSizePixel().Width());
	const sal_uInt32 nSourceHeight(GetSizePixel().Height());

	if(!nSourceWidth || !nSourceHeight)
		return aRetval;

	// Get aOutlineRange
	basegfx::B2DRange aOutlineRange(0.0, 0.0, 1.0, 1.0);

	aOutlineRange.transform(rTransformation);

	// create visible range from it by moving from relative to absolute
	basegfx::B2DRange aVisibleRange(rVisibleRange);

	aVisibleRange.transform(
		basegfx::tools::createScaleTranslateB2DHomMatrix(
			aOutlineRange.getRange(),
			aOutlineRange.getMinimum()));

	// get target size (which is visible range's size)
	double fWidth(aVisibleRange.getWidth());
	double fHeight(aVisibleRange.getHeight());

	if(fWidth < 1.0 || fHeight < 1.0)
	{
		return aRetval;
	}

	// test if discrete size (pixel) maybe too big and limit it
	const double fArea(fWidth * fHeight);
	const bool bNeedToReduce(basegfx::fTools::more(fArea, fMaximumArea));
	double fReduceFactor(1.0);

	if(bNeedToReduce)
	{
		fReduceFactor = sqrt(fMaximumArea / fArea);
		fWidth *= fReduceFactor;
		fHeight *= fReduceFactor;
	}

	// Build complete transform from source pixels to target pixels.
	// Start by scaling from source pixel size to unit coordinates
	basegfx::B2DHomMatrix aTransform(
		basegfx::tools::createScaleB2DHomMatrix(
			1.0 / nSourceWidth,
			1.0 / nSourceHeight));

	// multiply with given transform which leads from unit coordinates inside
	// aOutlineRange
	aTransform = rTransformation * aTransform;

	// subtract top-left of absolute VisibleRange
	aTransform.translate(
		-aVisibleRange.getMinX(),
		-aVisibleRange.getMinY());

	// scale to target pixels (if needed)
	if(bNeedToReduce)
	{
		aTransform.scale(fReduceFactor, fReduceFactor);
	}

	// invert to get transformation from target pixel coordinates to source pixels
	aTransform.invert();

	// create bitmap using source, destination and linear back-transformation
	aRetval = TransformBitmapEx(fWidth, fHeight, aTransform, bSmooth);

	return aRetval;
}

// ------------------------------------------------------------------

BitmapEx BitmapEx::ModifyBitmapEx(const basegfx::BColorModifierStack& rBColorModifierStack) const
{
	Bitmap aChangedBitmap(GetBitmap());
	bool bDone(false);

	for(sal_uInt32 a(rBColorModifierStack.count()); a && !bDone; )
	{
		const basegfx::BColorModifierSharedPtr& rModifier = rBColorModifierStack.getBColorModifier(--a);
		const basegfx::BColorModifier_replace* pReplace = dynamic_cast< const basegfx::BColorModifier_replace* >(rModifier.get());

		if(pReplace)
		{
			// complete replace
			if(IsTransparent())
			{
				// clear bitmap with dest color
				if(aChangedBitmap.GetBitCount() <= 8)
				{
					// do NOT use erase; for e.g. 8bit Bitmaps, the nearest color to the given
					// erase color is determined and used -> this may be different from what is
					// wanted here. Better create a new bitmap with the needed color explicitly
					BitmapReadAccess* pReadAccess = aChangedBitmap.AcquireReadAccess();
					OSL_ENSURE(pReadAccess, "Got no Bitmap ReadAccess ?!?");

					if(pReadAccess)
					{
						BitmapPalette aNewPalette(pReadAccess->GetPalette());
						aNewPalette[0] = BitmapColor(Color(pReplace->getBColor()));
						aChangedBitmap = Bitmap(
							aChangedBitmap.GetSizePixel(),
							aChangedBitmap.GetBitCount(),
							&aNewPalette);
						delete pReadAccess;
					}
				}
				else
				{
					aChangedBitmap.Erase(Color(pReplace->getBColor()));
				}
			}
			else
			{
				// erase bitmap, caller will know to paint direct
				aChangedBitmap.SetEmpty();
			}

			bDone = true;
		}
		else
		{
			BitmapWriteAccess* pContent = aChangedBitmap.AcquireWriteAccess();

			if(pContent)
			{
				const double fConvertColor(1.0 / 255.0);

				if(pContent->HasPalette())
				{
					const sal_uInt16 nCount(pContent->GetPaletteEntryCount());

					for(sal_uInt16 a(0); a < nCount; a++)
					{
						const BitmapColor& rCol = pContent->GetPaletteColor(a);
						const basegfx::BColor aBSource(
							rCol.GetRed() * fConvertColor,
							rCol.GetGreen() * fConvertColor,
							rCol.GetBlue() * fConvertColor);
						const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource));
						pContent->SetPaletteColor(a, BitmapColor(Color(aBDest)));
					}
				}
				else if(BMP_FORMAT_24BIT_TC_BGR == pContent->GetScanlineFormat())
				{
					for(sal_uInt32 y(0L); y < (sal_uInt32)pContent->Height(); y++)
					{
						Scanline pScan = pContent->GetScanline(y);

						for(sal_uInt32 x(0L); x < (sal_uInt32)pContent->Width(); x++)
						{
							const basegfx::BColor aBSource(
								*(pScan + 2)* fConvertColor,
								*(pScan + 1) * fConvertColor,
								*pScan * fConvertColor);
							const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource));
							*pScan++ = static_cast< sal_uInt8 >(aBDest.getBlue() * 255.0);
							*pScan++ = static_cast< sal_uInt8 >(aBDest.getGreen() * 255.0);
							*pScan++ = static_cast< sal_uInt8 >(aBDest.getRed() * 255.0);
						}
					}
				}
				else if(BMP_FORMAT_24BIT_TC_RGB == pContent->GetScanlineFormat())
				{
					for(sal_uInt32 y(0L); y < (sal_uInt32)pContent->Height(); y++)
					{
						Scanline pScan = pContent->GetScanline(y);

						for(sal_uInt32 x(0L); x < (sal_uInt32)pContent->Width(); x++)
						{
							const basegfx::BColor aBSource(
								*pScan * fConvertColor,
								*(pScan + 1) * fConvertColor,
								*(pScan + 2) * fConvertColor);
							const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource));
							*pScan++ = static_cast< sal_uInt8 >(aBDest.getRed() * 255.0);
							*pScan++ = static_cast< sal_uInt8 >(aBDest.getGreen() * 255.0);
							*pScan++ = static_cast< sal_uInt8 >(aBDest.getBlue() * 255.0);
						}
					}
				}
				else
				{
					for(sal_uInt32 y(0L); y < (sal_uInt32)pContent->Height(); y++)
					{
						for(sal_uInt32 x(0L); x < (sal_uInt32)pContent->Width(); x++)
						{
							const BitmapColor aBMCol(pContent->GetColor(y, x));
							const basegfx::BColor aBSource(
								(double)aBMCol.GetRed() * fConvertColor,
								(double)aBMCol.GetGreen() * fConvertColor,
								(double)aBMCol.GetBlue() * fConvertColor);
							const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource));

							pContent->SetPixel(y, x, BitmapColor(Color(aBDest)));
						}
					}
				}

				delete pContent;
			}
		}
	}

	if(aChangedBitmap.IsEmpty())
	{
		return BitmapEx();
	}
	else
	{
		if(IsTransparent())
		{
			if(IsAlpha())
			{
				return BitmapEx(aChangedBitmap, GetAlpha());
			}
			else
			{
				return BitmapEx(aChangedBitmap, GetMask());
			}
		}
		else
		{
			return BitmapEx(aChangedBitmap);
		}
	}
}

// -----------------------------------------------------------------------------

BitmapEx VCL_DLLPUBLIC createBlendFrame(
	const Size& rSize,
	sal_uInt8 nAlpha,
	Color aColorTopLeft,
	Color aColorBottomRight)
{
	const sal_uInt32 nW(rSize.Width());
	const sal_uInt32 nH(rSize.Height());

	if(nW || nH)
	{
		Color aColTopRight(aColorTopLeft);
		Color aColBottomLeft(aColorTopLeft);
		const sal_uInt32 nDE(nW + nH);

		aColTopRight.Merge(aColorBottomRight, 255 - sal_uInt8((nW * 255) / nDE));
		aColBottomLeft.Merge(aColorBottomRight, 255 - sal_uInt8((nH * 255) / nDE));

		return createBlendFrame(rSize, nAlpha, aColorTopLeft, aColTopRight, aColorBottomRight, aColBottomLeft);
	}

	return BitmapEx();
}

BitmapEx VCL_DLLPUBLIC createBlendFrame(
	const Size& rSize,
	sal_uInt8 nAlpha,
	Color aColorTopLeft,
	Color aColorTopRight,
	Color aColorBottomRight,
	Color aColorBottomLeft)
{
	static Size aLastSize(0, 0);
	static sal_uInt8 nLastAlpha(0);
	static Color aLastColorTopLeft(COL_BLACK);
	static Color aLastColorTopRight(COL_BLACK);
	static Color aLastColorBottomRight(COL_BLACK);
	static Color aLastColorBottomLeft(COL_BLACK);
	static BitmapEx aLastResult;

	if(aLastSize == rSize
		&& nLastAlpha == nAlpha
		&& aLastColorTopLeft == aColorTopLeft
		&& aLastColorTopRight == aColorTopRight
		&& aLastColorBottomRight == aColorBottomRight
		&& aLastColorBottomLeft == aColorBottomLeft)
	{
		return aLastResult;
	}

	aLastSize = rSize;
	nLastAlpha = nAlpha;
	aLastColorTopLeft = aColorTopLeft;
	aLastColorTopRight = aColorTopRight;
	aLastColorBottomRight = aColorBottomRight;
	aLastColorBottomLeft = aColorBottomLeft;
	aLastResult.Clear();

	const long nW(rSize.Width());
	const long nH(rSize.Height());

	if(nW && nH)
	{
		sal_uInt8 aEraseTrans(0xff);
		Bitmap aContent(rSize, 24);
		AlphaMask aAlpha(rSize, &aEraseTrans);

		aContent.Erase(COL_BLACK);

		BitmapWriteAccess* pContent = aContent.AcquireWriteAccess();
		BitmapWriteAccess* pAlpha = aAlpha.AcquireWriteAccess();

		if(pContent && pAlpha)
		{
			long x(0);
			long y(0);

			// x == 0, y == 0, top-left corner
			pContent->SetPixel(0, 0, aColorTopLeft);
			pAlpha->SetPixelIndex(0, 0, nAlpha);

			// y == 0, top line left to right
			for(x = 1; x < nW - 1; x++)
			{
				Color aMix(aColorTopLeft);

				aMix.Merge(aColorTopRight, 255 - sal_uInt8((x * 255) / nW));
				pContent->SetPixel(0, x, aMix);
				pAlpha->SetPixelIndex(0, x, nAlpha);
			}

			// x == nW - 1, y == 0, top-right corner
			// #123690# Caution! When nW is 1, x == nW is possible (!)
			if(x < nW)
			{
				pContent->SetPixel(0, x, aColorTopRight);
				pAlpha->SetPixelIndex(0, x, nAlpha);
			}

			// x == 0 and nW - 1, left and right line top-down
			for(y = 1; y < nH - 1; y++)
			{
				Color aMixA(aColorTopLeft);

				aMixA.Merge(aColorBottomLeft, 255 - sal_uInt8((y * 255) / nH));
				pContent->SetPixel(y, 0, aMixA);
				pAlpha->SetPixelIndex(y, 0, nAlpha);

				// #123690# Caution! When nW is 1, x == nW is possible (!)
				if(x < nW)
				{
					Color aMixB(aColorTopRight);

					aMixB.Merge(aColorBottomRight, 255 - sal_uInt8((y * 255) / nH));
					pContent->SetPixel(y, x, aMixB);
					pAlpha->SetPixelIndex(y, x, nAlpha);
				}
			}

			// #123690# Caution! When nH is 1, y == nH is possible (!)
			if(y < nH)
			{
				// x == 0, y == nH - 1, bottom-left corner
				pContent->SetPixel(y, 0, aColorBottomLeft);
				pAlpha->SetPixelIndex(y, 0, nAlpha);

				// y == nH - 1, bottom line left to right
				for(x = 1; x < nW - 1; x++)
				{
					Color aMix(aColorBottomLeft);

					aMix.Merge(aColorBottomRight, 255 - sal_uInt8(((x - 0)* 255) / nW));
					pContent->SetPixel(y, x, aMix);
					pAlpha->SetPixelIndex(y, x, nAlpha);
				}

				// x == nW - 1, y == nH - 1, bottom-right corner
				// #123690# Caution! When nW is 1, x == nW is possible (!)
				if(x < nW)
				{
					pContent->SetPixel(y, x, aColorBottomRight);
					pAlpha->SetPixelIndex(y, x, nAlpha);
				}
			}

			aContent.ReleaseAccess(pContent);
			aAlpha.ReleaseAccess(pAlpha);

			aLastResult = BitmapEx(aContent, aAlpha);
		}
		else
		{
			if(pContent)
			{
				aContent.ReleaseAccess(pContent);
			}

			if(pAlpha)
			{
				aAlpha.ReleaseAccess(pAlpha);
			}
		}
	}

	return aLastResult;
}

/* vim: set noet sw=4 ts=4: */