| /************************************************************** |
| * |
| * 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; |
| |
| // substract 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 coordiates 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 explicitely |
| 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; |
| } |
| |
| // ------------------------------------------------------------------ |
| // eof |
