/************************************************************** * * 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 #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, 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: */