/************************************************************** * * 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 #include #include #include #include #include #include #include #include #include #include #include #include #include // ------------ // - 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 ) { Scale( rNewSize ); } // ------------------------------------------------------------------ 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_uLong nScaleFlag ) { sal_Bool bRet = sal_False; if( !!aBitmap ) { bRet = aBitmap.Scale( rScaleX, rScaleY, nScaleFlag ); if( bRet && ( eTransparent == TRANSPARENT_BITMAP ) && !!aMask ) aMask.Scale( rScaleX, rScaleY, BMP_SCALE_FAST ); 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_uLong 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; } // ------------------------------------------------------------------ SvStream& operator<<( SvStream& rOStm, const BitmapEx& rBitmapEx ) { rBitmapEx.aBitmap.Write( rOStm ); rOStm << (sal_uInt32) 0x25091962; rOStm << (sal_uInt32) 0xACB20201; rOStm << (sal_uInt8) rBitmapEx.eTransparent; if( rBitmapEx.eTransparent == TRANSPARENT_BITMAP ) rBitmapEx.aMask.Write( rOStm ); else if( rBitmapEx.eTransparent == TRANSPARENT_COLOR ) rOStm << rBitmapEx.aTransparentColor; return rOStm; } // ------------------------------------------------------------------ SvStream& operator>>( SvStream& rIStm, BitmapEx& rBitmapEx ) { Bitmap aBmp; rIStm >> aBmp; if( !rIStm.GetError() ) { const sal_uLong nStmPos = rIStm.Tell(); sal_uInt32 nMagic1 = 0; sal_uInt32 nMagic2 = 0; rIStm >> nMagic1 >> nMagic2; if( ( nMagic1 != 0x25091962 ) || ( nMagic2 != 0xACB20201 ) || rIStm.GetError() ) { rIStm.ResetError(); rIStm.Seek( nStmPos ); rBitmapEx = aBmp; } else { sal_uInt8 bTransparent = false; rIStm >> bTransparent; if( bTransparent == (sal_uInt8) TRANSPARENT_BITMAP ) { Bitmap aMask; rIStm >> aMask; if( !!aMask) { // do we have an alpha mask? if( ( 8 == aMask.GetBitCount() ) && aMask.HasGreyPalette() ) { AlphaMask aAlpha; // create alpha mask quickly (without greyscale conversion) aAlpha.ImplSetBitmap( aMask ); rBitmapEx = BitmapEx( aBmp, aAlpha ); } else rBitmapEx = BitmapEx( aBmp, aMask ); } else rBitmapEx = aBmp; } else if( bTransparent == (sal_uInt8) TRANSPARENT_COLOR ) { Color aTransparentColor; rIStm >> aTransparentColor; rBitmapEx = BitmapEx( aBmp, aTransparentColor ); } else rBitmapEx = aBmp; } } return rIStm; }