vcl/source/gdi/bitmapex.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: bitmapex.cxx,v $
  10  * $Revision: 1.27 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_vcl.hxx"
  33 #include <ctype.h>
  34 #include <rtl/crc.h>
  35 #include <vcl/salbtype.hxx>
  36 #include <tools/stream.hxx>
  37 #include <tools/debug.hxx>
  38 #include <vcl/outdev.hxx>
  39 #include <vcl/alpha.hxx>
  40 #include <vcl/image.h>
  41 #include <vcl/bitmapex.hxx>
  42 #include <vcl/pngread.hxx>
  43 #ifndef _SV_IMPIMAGETREE_H
  44 #include <vcl/impimagetree.hxx>
  45 #endif
  46 #ifndef _SV_RC_H
  47 #include <tools/rc.h>
  48 #endif
  49 #include <vcl/svapp.hxx>
  50 #include <vcl/virdev.hxx>
  51
  52 // ------------
  53 // - BitmapEx -
  54 // ------------
  55
  56 BitmapEx::BitmapEx() :
  57         eTransparent( TRANSPARENT_NONE ),
  58         bAlpha          ( FALSE )
  59 {
  60 }
  61
  62 // ------------------------------------------------------------------
  63
  64 BitmapEx::BitmapEx( const BitmapEx& rBitmapEx ) :
  65         aBitmap                         ( rBitmapEx.aBitmap ),
  66         aMask                           ( rBitmapEx.aMask ),
  67         aBitmapSize                     ( rBitmapEx.aBitmapSize ),
  68         aTransparentColor       ( rBitmapEx.aTransparentColor ),
  69         eTransparent            ( rBitmapEx.eTransparent ),
  70         bAlpha                          ( rBitmapEx.bAlpha )
  71 {
  72 }
  73
  74 BitmapEx::BitmapEx( const BitmapEx& rBitmapEx, Point aSrc, Size aSize ) :
  75         eTransparent( TRANSPARENT_NONE ),
  76         bAlpha          ( FALSE )
  77 {
  78     if( rBitmapEx.IsEmpty() )
  79         return;
  80
  81     aBitmap = Bitmap( aSize, rBitmapEx.aBitmap.GetBitCount() );
  82     aBitmapSize = aSize;
  83     if( rBitmapEx.IsAlpha() )
  84     {
  85         bAlpha = TRUE;
  86         aMask = AlphaMask( aSize ).ImplGetBitmap();
  87     }
  88     else if( rBitmapEx.IsTransparent() )
  89         aMask = Bitmap( aSize, rBitmapEx.aMask.GetBitCount() );
  90
  91     Rectangle aDestRect( Point( 0, 0 ), aSize );
  92     Rectangle aSrcRect( aSrc, aSize );
  93     CopyPixel( aDestRect, aSrcRect, &rBitmapEx );
  94 }
  95
  96 // ------------------------------------------------------------------
  97
  98 BitmapEx::BitmapEx( const ResId& rResId ) :
  99         eTransparent( TRANSPARENT_NONE ),
 100         bAlpha          ( FALSE )
 101 {
 102     static ImplImageTreeSingletonRef    aImageTree;
 103     ResMgr*                                                     pResMgr = NULL;
 104
 105     ResMgr::GetResourceSkipHeader( rResId.SetRT( RSC_BITMAP ), &pResMgr );
 106     pResMgr->ReadLong();
 107     pResMgr->ReadLong();
 108
 109     const String aFileName( pResMgr->ReadString() );
 110     ::rtl::OUString aCurrentSymbolsStyle = Application::GetSettings().GetStyleSettings().GetCurrentSymbolsStyleName();
 111
 112     if( !aImageTree->loadImage( aFileName, aCurrentSymbolsStyle, *this ) )
 113     {
 114 #ifdef DBG_UTIL
 115         ByteString aErrorStr( "BitmapEx::BitmapEx( const ResId& rResId ): could not load image <" );
 116         DBG_ERROR( ( ( aErrorStr += ByteString( aFileName, RTL_TEXTENCODING_ASCII_US ) ) += '>' ).GetBuffer() );
 117 #endif
 118     }
 119 }
 120
 121 // ------------------------------------------------------------------
 122
 123 BitmapEx::BitmapEx( const Bitmap& rBmp ) :
 124         aBitmap         ( rBmp ),
 125         aBitmapSize     ( aBitmap.GetSizePixel() ),
 126         eTransparent( TRANSPARENT_NONE ),
 127         bAlpha          ( FALSE )
 128 {
 129 }
 130
 131 // ------------------------------------------------------------------
 132
 133 BitmapEx::BitmapEx( const Bitmap& rBmp, const Bitmap& rMask ) :
 134         aBitmap                 ( rBmp ),
 135         aMask                   ( rMask ),
 136         aBitmapSize             ( aBitmap.GetSizePixel() ),
 137         eTransparent    ( !rMask ? TRANSPARENT_NONE : TRANSPARENT_BITMAP ),
 138         bAlpha                  ( FALSE )
 139 {
 140     DBG_ASSERT( !rMask || rBmp.GetSizePixel() == rMask.GetSizePixel(),
 141                 "BitmapEx::BitmapEx(): size mismatch for bitmap and mask." );
 142
 143     // #105489# Ensure a mask is exactly one bit deep
 144     if( !!aMask && aMask.GetBitCount() != 1 )
 145     {
 146         OSL_TRACE("BitmapEx: forced mask to monochrome");
 147         aMask.ImplMakeMono( 255 );
 148     }
 149 }
 150
 151 // ------------------------------------------------------------------
 152
 153 BitmapEx::BitmapEx( const Bitmap& rBmp, const AlphaMask& rAlphaMask ) :
 154         aBitmap                 ( rBmp ),
 155         aMask                   ( rAlphaMask.ImplGetBitmap() ),
 156         aBitmapSize             ( aBitmap.GetSizePixel() ),
 157         eTransparent    ( !rAlphaMask ? TRANSPARENT_NONE : TRANSPARENT_BITMAP ),
 158         bAlpha                  ( !rAlphaMask ? FALSE : TRUE )
 159 {
 160     DBG_ASSERT( !rAlphaMask || rBmp.GetSizePixel() == rAlphaMask.GetSizePixel(),
 161                 "BitmapEx::BitmapEx(): size mismatch for bitmap and alpha mask." );
 162
 163     // #i75531# the workaround below can go when
 164     // X11SalGraphics::drawAlphaBitmap()'s render acceleration
 165     // can handle the bitmap depth mismatch directly
 166     if( aBitmap.GetBitCount() < aMask.GetBitCount() )
 167         aBitmap.Convert( BMP_CONVERSION_24BIT );
 168 }
 169
 170 // ------------------------------------------------------------------
 171
 172 BitmapEx::BitmapEx( const Bitmap& rBmp, const Color& rTransparentColor ) :
 173         aBitmap                         ( rBmp ),
 174         aBitmapSize                     ( aBitmap.GetSizePixel() ),
 175         aTransparentColor       ( rTransparentColor ),
 176         eTransparent            ( TRANSPARENT_BITMAP ),
 177         bAlpha                          ( FALSE )
 178 {
 179     aMask = aBitmap.CreateMask( aTransparentColor );
 180
 181     DBG_ASSERT( rBmp.GetSizePixel() == aMask.GetSizePixel(),
 182                 "BitmapEx::BitmapEx(): size mismatch for bitmap and alpha mask." );
 183 }
 184
 185 // ------------------------------------------------------------------
 186
 187 BitmapEx::~BitmapEx()
 188 {
 189 }
 190
 191 // ------------------------------------------------------------------
 192
 193 // ------------------------------------------------------------------
 194
 195 BitmapEx& BitmapEx::operator=( const BitmapEx& rBitmapEx )
 196 {
 197     if( &rBitmapEx != this )
 198     {
 199         aBitmap = rBitmapEx.aBitmap;
 200         aMask = rBitmapEx.aMask;
 201         aBitmapSize = rBitmapEx.aBitmapSize;
 202         aTransparentColor = rBitmapEx.aTransparentColor;
 203         eTransparent = rBitmapEx.eTransparent;
 204         bAlpha = rBitmapEx.bAlpha;
 205     }
 206
 207     return *this;
 208 }
 209
 210 // ------------------------------------------------------------------
 211
 212 BOOL BitmapEx::operator==( const BitmapEx& rBitmapEx ) const
 213 {
 214     if( eTransparent != rBitmapEx.eTransparent )
 215         return FALSE;
 216
 217     if( aBitmap != rBitmapEx.aBitmap )
 218         return FALSE;
 219
 220     if( aBitmapSize != rBitmapEx.aBitmapSize )
 221         return FALSE;
 222
 223     if( eTransparent == TRANSPARENT_NONE )
 224         return TRUE;
 225
 226     if( eTransparent == TRANSPARENT_COLOR )
 227         return aTransparentColor == rBitmapEx.aTransparentColor;
 228
 229     return( ( aMask == rBitmapEx.aMask ) && ( bAlpha == rBitmapEx.bAlpha ) );
 230 }
 231
 232 // ------------------------------------------------------------------
 233
 234 BOOL BitmapEx::IsEqual( const BitmapEx& rBmpEx ) const
 235 {
 236     return( rBmpEx.eTransparent == eTransparent &&
 237             rBmpEx.bAlpha == bAlpha &&
 238             rBmpEx.aBitmap.IsEqual( aBitmap ) &&
 239             rBmpEx.aMask.IsEqual( aMask ) );
 240 }
 241
 242 // ------------------------------------------------------------------
 243
 244 BOOL BitmapEx::IsEmpty() const
 245 {
 246     return( aBitmap.IsEmpty() && aMask.IsEmpty() );
 247 }
 248
 249 // ------------------------------------------------------------------
 250
 251 void BitmapEx::SetEmpty()
 252 {
 253     aBitmap.SetEmpty();
 254     aMask.SetEmpty();
 255     eTransparent = TRANSPARENT_NONE;
 256     bAlpha = FALSE;
 257 }
 258
 259 // ------------------------------------------------------------------
 260
 261 void BitmapEx::Clear()
 262 {
 263     SetEmpty();
 264 }
 265
 266 // ------------------------------------------------------------------
 267
 268 BOOL BitmapEx::IsTransparent() const
 269 {
 270     return( eTransparent != TRANSPARENT_NONE );
 271 }
 272
 273 // ------------------------------------------------------------------
 274
 275 BOOL BitmapEx::IsAlpha() const
 276 {
 277     return( IsTransparent() && bAlpha );
 278 }
 279
 280 // ------------------------------------------------------------------
 281
 282 Bitmap BitmapEx::GetBitmap( const Color* pTransReplaceColor ) const
 283 {
 284     Bitmap aRetBmp( aBitmap );
 285
 286     if( pTransReplaceColor && ( eTransparent != TRANSPARENT_NONE ) )
 287     {
 288         Bitmap aTempMask;
 289
 290         if( eTransparent == TRANSPARENT_COLOR )
 291             aTempMask = aBitmap.CreateMask( aTransparentColor );
 292         else
 293             aTempMask = aMask;
 294
 295         if( !IsAlpha() )
 296             aRetBmp.Replace( aTempMask, *pTransReplaceColor );
 297         else
 298             aRetBmp.Replace( GetAlpha(), *pTransReplaceColor );
 299     }
 300
 301     return aRetBmp;
 302 }
 303
 304 // ------------------------------------------------------------------
 305
 306 BitmapEx BitmapEx::GetColorTransformedBitmapEx( BmpColorMode eColorMode ) const
 307 {
 308     BitmapEx aRet;
 309
 310     if( BMP_COLOR_HIGHCONTRAST == eColorMode )
 311     {
 312         aRet = *this;
 313         aRet.aBitmap = aBitmap.GetColorTransformedBitmap( eColorMode );
 314     }
 315     else if( BMP_COLOR_MONOCHROME_BLACK == eColorMode ||
 316              BMP_COLOR_MONOCHROME_WHITE == eColorMode )
 317     {
 318         aRet = *this;
 319         aRet.aBitmap = aRet.aBitmap.GetColorTransformedBitmap( eColorMode );
 320
 321         if( !aRet.aMask.IsEmpty() )
 322         {
 323             aRet.aMask.CombineSimple( aRet.aBitmap, BMP_COMBINE_OR );
 324             aRet.aBitmap.Erase( ( BMP_COLOR_MONOCHROME_BLACK == eColorMode ) ? COL_BLACK : COL_WHITE );
 325
 326             DBG_ASSERT( aRet.aBitmap.GetSizePixel() == aRet.aMask.GetSizePixel(),
 327                         "BitmapEx::GetColorTransformedBitmapEx(): size mismatch for bitmap and alpha mask." );
 328         }
 329     }
 330
 331     return aRet;
 332 }
 333
 334 // ------------------------------------------------------------------
 335
 336 Bitmap BitmapEx::GetMask() const
 337 {
 338     Bitmap aRet( aMask );
 339
 340     if( IsAlpha() )
 341         aRet.ImplMakeMono( 255 );
 342
 343     return aRet;
 344 }
 345
 346 // ------------------------------------------------------------------
 347
 348 AlphaMask BitmapEx::GetAlpha() const
 349 {
 350     AlphaMask aAlpha;
 351
 352     if( IsAlpha() )
 353         aAlpha.ImplSetBitmap( aMask );
 354     else
 355         aAlpha = aMask;
 356
 357     return aAlpha;
 358 }
 359
 360 // ------------------------------------------------------------------
 361
 362 ULONG BitmapEx::GetSizeBytes() const
 363 {
 364     ULONG nSizeBytes = aBitmap.GetSizeBytes();
 365
 366     if( eTransparent == TRANSPARENT_BITMAP )
 367         nSizeBytes += aMask.GetSizeBytes();
 368
 369     return nSizeBytes;
 370 }
 371
 372 // ------------------------------------------------------------------
 373
 374 ULONG BitmapEx::GetChecksum() const
 375 {
 376     sal_uInt32  nCrc = aBitmap.GetChecksum();
 377     SVBT32              aBT32;
 378
 379     UInt32ToSVBT32( (long) eTransparent, aBT32 );
 380     nCrc = rtl_crc32( nCrc, aBT32, 4 );
 381
 382     UInt32ToSVBT32( (long) bAlpha, aBT32 );
 383     nCrc = rtl_crc32( nCrc, aBT32, 4 );
 384
 385     if( ( TRANSPARENT_BITMAP == eTransparent ) && !aMask.IsEmpty() )
 386     {
 387         UInt32ToSVBT32( aMask.GetChecksum(), aBT32 );
 388         nCrc = rtl_crc32( nCrc, aBT32, 4 );
 389     }
 390
 391     return nCrc;
 392 }
 393
 394 // ------------------------------------------------------------------
 395
 396 void BitmapEx::SetSizePixel( const Size& rNewSize )
 397 {
 398     Scale( rNewSize );
 399 }
 400
 401 // ------------------------------------------------------------------
 402
 403 BOOL BitmapEx::Invert()
 404 {
 405     BOOL bRet = FALSE;
 406
 407     if( !!aBitmap )
 408     {
 409         bRet = aBitmap.Invert();
 410
 411         if( bRet && ( eTransparent == TRANSPARENT_COLOR ) )
 412             aTransparentColor = BitmapColor( aTransparentColor ).Invert();
 413     }
 414
 415     return bRet;
 416 }
 417
 418 // ------------------------------------------------------------------
 419
 420 BOOL BitmapEx::Mirror( ULONG nMirrorFlags )
 421 {
 422     BOOL bRet = FALSE;
 423
 424     if( !!aBitmap )
 425     {
 426         bRet = aBitmap.Mirror( nMirrorFlags );
 427
 428         if( bRet && ( eTransparent == TRANSPARENT_BITMAP ) && !!aMask )
 429             aMask.Mirror( nMirrorFlags );
 430     }
 431
 432     return bRet;
 433 }
 434
 435 // ------------------------------------------------------------------
 436
 437 BOOL BitmapEx::Scale( const double& rScaleX, const double& rScaleY, ULONG nScaleFlag )
 438 {
 439     BOOL bRet = FALSE;
 440
 441     if( !!aBitmap )
 442     {
 443         bRet = aBitmap.Scale( rScaleX, rScaleY, nScaleFlag );
 444
 445         if( bRet && ( eTransparent == TRANSPARENT_BITMAP ) && !!aMask )
 446             aMask.Scale( rScaleX, rScaleY, BMP_SCALE_FAST );
 447
 448         aBitmapSize = aBitmap.GetSizePixel();
 449
 450         DBG_ASSERT( !aMask || aBitmap.GetSizePixel() == aMask.GetSizePixel(),
 451                     "BitmapEx::Scale(): size mismatch for bitmap and alpha mask." );
 452     }
 453
 454     return bRet;
 455 }
 456
 457 // ------------------------------------------------------------------------
 458
 459 BOOL BitmapEx::Scale( const Size& rNewSize, ULONG nScaleFlag )
 460 {
 461     BOOL bRet;
 462
 463     if( aBitmapSize.Width() && aBitmapSize.Height() )
 464     {
 465         bRet = Scale( (double) rNewSize.Width() / aBitmapSize.Width(),
 466                       (double) rNewSize.Height() / aBitmapSize.Height(),
 467                       nScaleFlag );
 468     }
 469     else
 470         bRet = TRUE;
 471
 472     return bRet;
 473 }
 474
 475 // ------------------------------------------------------------------
 476
 477 BOOL BitmapEx::Rotate( long nAngle10, const Color& rFillColor )
 478 {
 479     BOOL bRet = FALSE;
 480
 481     if( !!aBitmap )
 482     {
 483         const BOOL bTransRotate = ( Color( COL_TRANSPARENT ) == rFillColor );
 484
 485         if( bTransRotate )
 486         {
 487             if( eTransparent == TRANSPARENT_COLOR )
 488                 bRet = aBitmap.Rotate( nAngle10, aTransparentColor );
 489             else
 490             {
 491                 bRet = aBitmap.Rotate( nAngle10, COL_BLACK );
 492
 493                 if( eTransparent == TRANSPARENT_NONE )
 494                 {
 495                     aMask = Bitmap( aBitmapSize, 1 );
 496                     aMask.Erase( COL_BLACK );
 497                     eTransparent = TRANSPARENT_BITMAP;
 498                 }
 499
 500                 if( bRet && !!aMask )
 501                     aMask.Rotate( nAngle10, COL_WHITE );
 502             }
 503         }
 504         else
 505         {
 506             bRet = aBitmap.Rotate( nAngle10, rFillColor );
 507
 508             if( bRet && ( eTransparent == TRANSPARENT_BITMAP ) && !!aMask )
 509                 aMask.Rotate( nAngle10, COL_WHITE );
 510         }
 511
 512         aBitmapSize = aBitmap.GetSizePixel();
 513
 514         DBG_ASSERT( !aMask || aBitmap.GetSizePixel() == aMask.GetSizePixel(),
 515                     "BitmapEx::Rotate(): size mismatch for bitmap and alpha mask." );
 516     }
 517
 518     return bRet;
 519 }
 520
 521 // ------------------------------------------------------------------
 522
 523 BOOL BitmapEx::Crop( const Rectangle& rRectPixel )
 524 {
 525     BOOL bRet = FALSE;
 526
 527     if( !!aBitmap )
 528     {
 529         bRet = aBitmap.Crop( rRectPixel );
 530
 531         if( bRet && ( eTransparent == TRANSPARENT_BITMAP ) && !!aMask )
 532             aMask.Crop( rRectPixel );
 533
 534         aBitmapSize = aBitmap.GetSizePixel();
 535
 536         DBG_ASSERT( !aMask || aBitmap.GetSizePixel() == aMask.GetSizePixel(),
 537                     "BitmapEx::Crop(): size mismatch for bitmap and alpha mask." );
 538     }
 539
 540     return bRet;
 541 }
 542
 543 // ------------------------------------------------------------------
 544
 545 BOOL BitmapEx::Convert( BmpConversion eConversion )
 546 {
 547     return( !!aBitmap ? aBitmap.Convert( eConversion ) : FALSE );
 548 }
 549
 550 // ------------------------------------------------------------------
 551
 552 BOOL BitmapEx::ReduceColors( USHORT nNewColorCount, BmpReduce eReduce )
 553 {
 554     return( !!aBitmap ? aBitmap.ReduceColors( nNewColorCount, eReduce ) : FALSE );
 555 }
 556
 557 // ------------------------------------------------------------------
 558
 559 BOOL BitmapEx::Expand( ULONG nDX, ULONG nDY, const Color* pInitColor, BOOL bExpandTransparent )
 560 {
 561     BOOL bRet = FALSE;
 562
 563     if( !!aBitmap )
 564     {
 565         bRet = aBitmap.Expand( nDX, nDY, pInitColor );
 566
 567         if( bRet && ( eTransparent == TRANSPARENT_BITMAP ) && !!aMask )
 568         {
 569             Color aColor( bExpandTransparent ? COL_WHITE : COL_BLACK );
 570             aMask.Expand( nDX, nDY, &aColor );
 571         }
 572
 573         aBitmapSize = aBitmap.GetSizePixel();
 574
 575         DBG_ASSERT( !aMask || aBitmap.GetSizePixel() == aMask.GetSizePixel(),
 576                     "BitmapEx::Expand(): size mismatch for bitmap and alpha mask." );
 577     }
 578
 579     return bRet;
 580 }
 581
 582 // ------------------------------------------------------------------
 583
 584 BOOL BitmapEx::CopyPixel( const Rectangle& rRectDst, const Rectangle& rRectSrc,
 585                           const BitmapEx* pBmpExSrc )
 586 {
 587     BOOL bRet = FALSE;
 588
 589     if( !pBmpExSrc || pBmpExSrc->IsEmpty() )
 590     {
 591         if( !aBitmap.IsEmpty() )
 592         {
 593             bRet = aBitmap.CopyPixel( rRectDst, rRectSrc );
 594
 595             if( bRet && ( eTransparent == TRANSPARENT_BITMAP ) && !!aMask )
 596                 aMask.CopyPixel( rRectDst, rRectSrc );
 597         }
 598     }
 599     else
 600     {
 601         if( !aBitmap.IsEmpty() )
 602         {
 603             bRet = aBitmap.CopyPixel( rRectDst, rRectSrc, &pBmpExSrc->aBitmap );
 604
 605             if( bRet )
 606             {
 607                 if( pBmpExSrc->IsAlpha() )
 608                 {
 609                     if( IsAlpha() )
 610                         // cast to use the optimized AlphaMask::CopyPixel
 611                         ((AlphaMask*) &aMask)->CopyPixel( rRectDst, rRectSrc, (AlphaMask*)&pBmpExSrc->aMask );
 612                     else if( IsTransparent() )
 613                     {
 614                         AlphaMask* pAlpha = new AlphaMask( aMask );
 615
 616                         aMask = pAlpha->ImplGetBitmap();
 617                         delete pAlpha;
 618                         bAlpha = TRUE;
 619                         aMask.CopyPixel( rRectDst, rRectSrc, &pBmpExSrc->aMask );
 620                     }
 621                     else
 622                     {
 623                         sal_uInt8       cBlack = 0;
 624                         AlphaMask*      pAlpha = new AlphaMask( GetSizePixel(), &cBlack );
 625
 626                         aMask = pAlpha->ImplGetBitmap();
 627                         delete pAlpha;
 628                         eTransparent = TRANSPARENT_BITMAP;
 629                         bAlpha = TRUE;
 630                         aMask.CopyPixel( rRectDst, rRectSrc, &pBmpExSrc->aMask );
 631                     }
 632                 }
 633                 else if( pBmpExSrc->IsTransparent() )
 634                 {
 635                     if( IsAlpha() )
 636                     {
 637                         AlphaMask aAlpha( pBmpExSrc->aMask );
 638                         aMask.CopyPixel( rRectDst, rRectSrc, &aAlpha.ImplGetBitmap() );
 639                     }
 640                     else if( IsTransparent() )
 641                         aMask.CopyPixel( rRectDst, rRectSrc, &pBmpExSrc->aMask );
 642                     else
 643                     {
 644                         aMask = Bitmap( GetSizePixel(), 1 );
 645                         aMask.Erase( Color( COL_BLACK ) );
 646                         eTransparent = TRANSPARENT_BITMAP;
 647                         aMask.CopyPixel( rRectDst, rRectSrc, &pBmpExSrc->aMask );
 648                     }
 649                 }
 650                 else if( IsAlpha() )
 651                 {
 652                     sal_uInt8         cBlack = 0;
 653                     const AlphaMask   aAlphaSrc( pBmpExSrc->GetSizePixel(), &cBlack );
 654
 655                     aMask.CopyPixel( rRectDst, rRectSrc, &aAlphaSrc.ImplGetBitmap() );
 656                 }
 657                 else if( IsTransparent() )
 658                 {
 659                     Bitmap aMaskSrc( pBmpExSrc->GetSizePixel(), 1 );
 660
 661                     aMaskSrc.Erase( Color( COL_BLACK ) );
 662                     aMask.CopyPixel( rRectDst, rRectSrc, &aMaskSrc );
 663                 }
 664             }
 665         }
 666     }
 667
 668     return bRet;
 669 }
 670
 671 // ------------------------------------------------------------------
 672
 673 BOOL BitmapEx::Erase( const Color& rFillColor )
 674 {
 675     BOOL bRet = FALSE;
 676
 677     if( !!aBitmap )
 678     {
 679         bRet = aBitmap.Erase( rFillColor );
 680
 681         if( bRet && ( eTransparent == TRANSPARENT_BITMAP ) && !!aMask )
 682         {
 683             // #104416# Respect transparency on fill color
 684             if( rFillColor.GetTransparency() )
 685             {
 686                 const Color aFill( rFillColor.GetTransparency(), rFillColor.GetTransparency(), rFillColor.GetTransparency() );
 687                 aMask.Erase( aFill );
 688             }
 689             else
 690             {
 691                 const Color aBlack( COL_BLACK );
 692                 aMask.Erase( aBlack );
 693             }
 694         }
 695     }
 696
 697     return bRet;
 698 }
 699
 700 // ------------------------------------------------------------------
 701
 702 BOOL BitmapEx::Dither( ULONG nDitherFlags )
 703 {
 704     return( !!aBitmap ? aBitmap.Dither( nDitherFlags ) : FALSE );
 705 }
 706
 707 // ------------------------------------------------------------------
 708
 709 BOOL BitmapEx::Replace( const Color& rSearchColor, const Color& rReplaceColor, ULONG nTol )
 710 {
 711     return( !!aBitmap ? aBitmap.Replace( rSearchColor, rReplaceColor, nTol ) : FALSE );
 712 }
 713
 714 // ------------------------------------------------------------------
 715
 716 BOOL BitmapEx::Replace( const Color* pSearchColors, const Color* pReplaceColors, ULONG nColorCount, const ULONG* pTols )
 717 {
 718     return( !!aBitmap ? aBitmap.Replace( pSearchColors, pReplaceColors, nColorCount, (ULONG*) pTols ) : FALSE );
 719 }
 720
 721 // ------------------------------------------------------------------
 722
 723 BOOL BitmapEx::Adjust( short nLuminancePercent, short nContrastPercent,
 724                        short nChannelRPercent, short nChannelGPercent, short nChannelBPercent,
 725                        double fGamma, BOOL bInvert )
 726 {
 727     return( !!aBitmap ? aBitmap.Adjust( nLuminancePercent, nContrastPercent,
 728                                         nChannelRPercent, nChannelGPercent, nChannelBPercent,
 729                                         fGamma, bInvert ) : FALSE );
 730 }
 731
 732 // ------------------------------------------------------------------
 733
 734 BOOL BitmapEx::Filter( BmpFilter eFilter, const BmpFilterParam* pFilterParam, const Link* pProgress )
 735 {
 736     return( !!aBitmap ? aBitmap.Filter( eFilter, pFilterParam, pProgress ) : FALSE );
 737 }
 738
 739 // ------------------------------------------------------------------
 740
 741 void BitmapEx::Draw( OutputDevice* pOutDev, const Point& rDestPt ) const
 742 {
 743     pOutDev->DrawBitmapEx( rDestPt, *this );
 744 }
 745
 746 // ------------------------------------------------------------------
 747
 748 void BitmapEx::Draw( OutputDevice* pOutDev,
 749                      const Point& rDestPt, const Size& rDestSize ) const
 750 {
 751     pOutDev->DrawBitmapEx( rDestPt, rDestSize, *this );
 752 }
 753
 754 // ------------------------------------------------------------------
 755
 756 void BitmapEx::Draw( OutputDevice* pOutDev,
 757                      const Point& rDestPt, const Size& rDestSize,
 758                      const Point& rSrcPtPixel, const Size& rSrcSizePixel ) const
 759 {
 760     pOutDev->DrawBitmapEx( rDestPt, rDestSize, rSrcPtPixel, rSrcSizePixel, *this );
 761 }
 762
 763 BitmapEx BitmapEx:: AutoScaleBitmap(BitmapEx & aBitmap, const long aStandardSize)
 764 {
 765         Point aEmptyPoint(0,0);
 766         sal_Int32 imgNewWidth = 0;
 767         sal_Int32 imgNewHeight = 0;
 768         double imgposX = 0;
 769         double imgposY = 0;
 770     BitmapEx  aRet = aBitmap;
 771         double imgOldWidth = aRet.GetSizePixel().Width();
 772         double imgOldHeight =aRet.GetSizePixel().Height();
 773
 774     Size aScaledSize;
 775     if (imgOldWidth >= aStandardSize || imgOldHeight >= aStandardSize)
 776         {
 777                 if (imgOldWidth >= imgOldHeight)
 778                 {
 779                         imgNewWidth = aStandardSize;
 780                         imgNewHeight = sal_Int32(imgOldHeight / (imgOldWidth / aStandardSize) + 0.5);
 781                         imgposX = 0;
 782                         imgposY = (aStandardSize - (imgOldHeight / (imgOldWidth / aStandardSize) + 0.5)) / 2 + 0.5;
 783                 }
 784                 else
 785                 {
 786                         imgNewHeight = aStandardSize;
 787                         imgNewWidth = sal_Int32(imgOldWidth / (imgOldHeight / aStandardSize) + 0.5);
 788                         imgposY = 0;
 789                         imgposX = (aStandardSize - (imgOldWidth / (imgOldHeight / aStandardSize) + 0.5)) / 2 + 0.5;
 790                 }
 791
 792                 aScaledSize = Size( imgNewWidth, imgNewHeight );
 793         aRet.Scale( aScaledSize, BMP_SCALE_INTERPOLATE );
 794         }
 795         else
 796         {
 797                 imgposX = (aStandardSize - imgOldWidth) / 2 + 0.5;
 798                 imgposY = (aStandardSize - imgOldHeight) / 2 + 0.5;
 799         }
 800
 801     Size aBmpSize = aRet.GetSizePixel();
 802     Size aStdSize( aStandardSize, aStandardSize );
 803     Rectangle aRect(aEmptyPoint, aStdSize );
 804
 805     VirtualDevice aVirDevice( *Application::GetDefaultDevice(), 0, 1 );
 806         aVirDevice.SetOutputSizePixel( aStdSize );
 807         aVirDevice.SetFillColor( COL_TRANSPARENT );
 808     aVirDevice.SetLineColor( COL_TRANSPARENT );
 809
 810     //draw a rect into virDevice
 811         aVirDevice.DrawRect( aRect );
 812         Point aPointPixel( (long)imgposX, (long)imgposY );
 813         aVirDevice.DrawBitmapEx( aPointPixel, aRet );
 814         aRet = aVirDevice.GetBitmapEx( aEmptyPoint, aStdSize );
 815
 816         return aRet;
 817 }
 818 // ------------------------------------------------------------------
 819
 820 SvStream& operator<<( SvStream& rOStm, const BitmapEx& rBitmapEx )
 821 {
 822     rBitmapEx.aBitmap.Write( rOStm );
 823
 824     rOStm << (UINT32) 0x25091962;
 825     rOStm << (UINT32) 0xACB20201;
 826     rOStm << (BYTE) rBitmapEx.eTransparent;
 827
 828     if( rBitmapEx.eTransparent == TRANSPARENT_BITMAP )
 829         rBitmapEx.aMask.Write( rOStm );
 830     else if( rBitmapEx.eTransparent == TRANSPARENT_COLOR )
 831         rOStm << rBitmapEx.aTransparentColor;
 832
 833     return rOStm;
 834 }
 835
 836 // ------------------------------------------------------------------
 837
 838 SvStream& operator>>( SvStream& rIStm, BitmapEx& rBitmapEx )
 839 {
 840     Bitmap aBmp;
 841
 842     rIStm >> aBmp;
 843
 844     if( !rIStm.GetError() )
 845     {
 846         const ULONG nStmPos = rIStm.Tell();
 847         UINT32          nMagic1 = 0;
 848         UINT32          nMagic2 = 0;
 849
 850         rIStm >> nMagic1 >> nMagic2;
 851
 852         if( ( nMagic1 != 0x25091962 ) || ( nMagic2 != 0xACB20201 ) || rIStm.GetError() )
 853         {
 854             rIStm.ResetError();
 855             rIStm.Seek( nStmPos );
 856             rBitmapEx = aBmp;
 857         }
 858         else
 859         {
 860             BYTE bTransparent = false;
 861
 862             rIStm >> bTransparent;
 863
 864             if( bTransparent == (BYTE) TRANSPARENT_BITMAP )
 865             {
 866                 Bitmap aMask;
 867
 868                 rIStm >> aMask;
 869
 870                 if( !!aMask)
 871                 {
 872                     // do we have an alpha mask?
 873                     if( ( 8 == aMask.GetBitCount() ) && aMask.HasGreyPalette() )
 874                     {
 875                         AlphaMask aAlpha;
 876
 877                         // create alpha mask quickly (without greyscale conversion)
 878                         aAlpha.ImplSetBitmap( aMask );
 879                         rBitmapEx = BitmapEx( aBmp, aAlpha );
 880                     }
 881                     else
 882                         rBitmapEx = BitmapEx( aBmp, aMask );
 883                 }
 884                 else
 885                     rBitmapEx = aBmp;
 886             }
 887             else if( bTransparent == (BYTE) TRANSPARENT_COLOR )
 888             {
 889                 Color aTransparentColor;
 890
 891                 rIStm >> aTransparentColor;
 892                 rBitmapEx = BitmapEx( aBmp, aTransparentColor );
 893             }
 894             else
 895                 rBitmapEx = aBmp;
 896         }
 897     }
 898
 899     return rIStm;
 900 }