vcl/source/gdi/impimage.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: impimage.cxx,v $
  10  * $Revision: 1.25 $
  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 <vcl/outdev.hxx>
  34 #include <vcl/bitmapex.hxx>
  35 #include <vcl/alpha.hxx>
  36 #include <vcl/window.hxx>
  37 #include <vcl/bmpacc.hxx>
  38 #include <vcl/virdev.hxx>
  39 #include <vcl/image.h>
  40 #include <vcl/image.hxx>
  41
  42 // -----------
  43 // - Defines -
  44 // -----------
  45
  46 #define IMPSYSIMAGEITEM_MASK            ( 0x01 )
  47 #define IMPSYSIMAGEITEM_ALPHA           ( 0x02 )
  48 #define DISA_ALL                                        ( 0xffff )
  49
  50 // ----------------
  51 // - ImageAryData -
  52 // ----------------
  53
  54 ImageAryData::ImageAryData() :
  55     maName(),
  56     mnId( 0 ),
  57     maBitmapEx()
  58 {
  59 }
  60
  61 // -----------------------------------------------------------------------
  62
  63 ImageAryData::ImageAryData( const ImageAryData& rData ) :
  64     maName( rData.maName ),
  65     mnId( rData.mnId ),
  66     maBitmapEx( rData.maBitmapEx )
  67 {
  68 }
  69
  70 ImageAryData::ImageAryData( const rtl::OUString &aName,
  71                             USHORT nId, const BitmapEx &aBitmap )
  72         : maName( aName ), mnId( nId ), maBitmapEx( aBitmap )
  73 {
  74 }
  75
  76 // -----------------------------------------------------------------------
  77
  78 ImageAryData::~ImageAryData()
  79 {
  80 }
  81
  82 // -----------------------------------------------------------------------
  83
  84 ImageAryData& ImageAryData::operator=( const ImageAryData& rData )
  85 {
  86     maName = rData.maName;
  87     mnId = rData.mnId;
  88     maBitmapEx = rData.maBitmapEx;
  89
  90     return *this;
  91 }
  92
  93 // -----------------
  94 // - ImplImageList -
  95 // -----------------
  96
  97 ImplImageList::ImplImageList()
  98 {
  99 }
 100
 101 ImplImageList::ImplImageList( const ImplImageList &aSrc ) :
 102     maPrefix( aSrc.maPrefix ),
 103     maImageSize( aSrc.maImageSize ),
 104     mnRefCount( 1 )
 105 {
 106     maImages.reserve( aSrc.maImages.size() );
 107     for ( ImageAryDataVec::const_iterator aIt = aSrc.maImages.begin(), aEnd = aSrc.maImages.end(); aIt != aEnd; ++aIt )
 108     {
 109         ImageAryData* pAryData = new ImageAryData( **aIt );
 110         maImages.push_back( pAryData );
 111         if( pAryData->maName.getLength() )
 112             maNameHash [ pAryData->maName ] = pAryData;
 113     }
 114 }
 115
 116 ImplImageList::~ImplImageList()
 117 {
 118     for ( ImageAryDataVec::iterator aIt = maImages.begin(), aEnd = maImages.end(); aIt != aEnd; ++aIt )
 119         delete *aIt;
 120 }
 121
 122 void ImplImageList::AddImage( const ::rtl::OUString &aName,
 123                               USHORT nId, const BitmapEx &aBitmapEx )
 124 {
 125     ImageAryData *pImg = new ImageAryData( aName, nId, aBitmapEx );
 126     maImages.push_back( pImg );
 127     if( aName.getLength() )
 128         maNameHash [ aName ] = pImg;
 129 }
 130
 131 void ImplImageList::RemoveImage( USHORT nPos )
 132 {
 133     ImageAryData *pImg = maImages[ nPos ];
 134     if( pImg->maName.getLength() )
 135         maNameHash.erase( pImg->maName );
 136     maImages.erase( maImages.begin() + nPos );
 137 }
 138
 139 USHORT ImplImageList::GetImageCount() const
 140 {
 141     return sal::static_int_cast< USHORT >( maImages.size() );
 142 }
 143
 144 // -----------------
 145 // - ImplImageData -
 146 // -----------------
 147
 148 ImplImageData::ImplImageData( const BitmapEx& rBmpEx ) :
 149     mpImageBitmap( NULL ),
 150     maBmpEx( rBmpEx )
 151 {
 152 }
 153
 154 // -----------------------------------------------------------------------
 155
 156 ImplImageData::~ImplImageData()
 157 {
 158     delete mpImageBitmap;
 159 }
 160
 161 // -----------------
 162 // - ImplImageData -
 163 // -----------------
 164
 165 BOOL ImplImageData::IsEqual( const ImplImageData& rData )
 166 {
 167     return( maBmpEx == rData.maBmpEx );
 168 }
 169
 170 // -------------
 171 // - ImplImage -
 172 // -------------
 173
 174 ImplImage::ImplImage()
 175 {
 176 }
 177
 178 // ------------------------------------------------------------------------------
 179
 180 ImplImage::~ImplImage()
 181 {
 182     switch( meType )
 183     {
 184         case IMAGETYPE_BITMAP:
 185             delete static_cast< Bitmap* >( mpData );
 186         break;
 187
 188         case IMAGETYPE_IMAGE:
 189             delete static_cast< ImplImageData* >( mpData );
 190         break;
 191     }
 192 }
 193
 194 // ----------------
 195 // - ImplImageBmp -
 196 // ----------------
 197
 198 ImplImageBmp::ImplImageBmp() :
 199     mpDisplayBmp( NULL ),
 200     mpInfoAry( NULL ),
 201     mnSize( 0 )
 202 {
 203 }
 204
 205 // -------------
 206 // - ImplImage -
 207 // -------------
 208
 209 ImplImageBmp::~ImplImageBmp()
 210 {
 211     delete[] mpInfoAry;
 212     delete mpDisplayBmp;
 213 }
 214
 215 // -----------------------------------------------------------------------
 216
 217 void ImplImageBmp::Create( long nItemWidth, long nItemHeight, USHORT nInitSize )
 218 {
 219     const Size aTotalSize( nInitSize * nItemWidth, nItemHeight );
 220
 221     maBmpEx = Bitmap( aTotalSize, 24 );
 222     maDisabledBmpEx.SetEmpty();
 223
 224     delete mpDisplayBmp;
 225     mpDisplayBmp = NULL;
 226
 227     maSize = Size( nItemWidth, nItemHeight );
 228     mnSize = nInitSize;
 229
 230     delete[] mpInfoAry;
 231     mpInfoAry = new BYTE[ mnSize ];
 232     memset( mpInfoAry, 0, mnSize );
 233 }
 234
 235 // -----------------------------------------------------------------------
 236
 237 void ImplImageBmp::Create( const BitmapEx& rBmpEx, long nItemWidth, long nItemHeight, USHORT nInitSize )
 238 {
 239     maBmpEx = rBmpEx;
 240     maDisabledBmpEx.SetEmpty();
 241
 242     delete mpDisplayBmp;
 243     mpDisplayBmp = NULL;
 244
 245     maSize = Size( nItemWidth, nItemHeight );
 246     mnSize = nInitSize;
 247
 248     delete[] mpInfoAry;
 249     mpInfoAry = new BYTE[ mnSize ];
 250     memset( mpInfoAry,
 251             rBmpEx.IsAlpha() ? IMPSYSIMAGEITEM_ALPHA : ( rBmpEx.IsTransparent() ? IMPSYSIMAGEITEM_MASK : 0 ),
 252             mnSize );
 253 }
 254
 255 // -----------------------------------------------------------------------
 256
 257 void ImplImageBmp::Expand( USHORT nGrowSize )
 258 {
 259     const ULONG         nDX = nGrowSize * maSize.Width();
 260     const USHORT        nOldSize = mnSize;
 261     BYTE*                       pNewAry = new BYTE[ mnSize = sal::static_int_cast<USHORT>(mnSize+nGrowSize) ];
 262
 263     maBmpEx.Expand( nDX, 0UL );
 264
 265     if( !maDisabledBmpEx.IsEmpty() )
 266         maDisabledBmpEx.Expand( nDX, 0UL );
 267
 268     delete mpDisplayBmp;
 269     mpDisplayBmp = NULL;
 270
 271     memset( pNewAry, 0, mnSize );
 272     memcpy( pNewAry, mpInfoAry, nOldSize );
 273     delete[] mpInfoAry;
 274     mpInfoAry = pNewAry;
 275 }
 276
 277 // -----------------------------------------------------------------------
 278
 279 void ImplImageBmp::Invert()
 280 {
 281     delete mpDisplayBmp;
 282     mpDisplayBmp = NULL;
 283
 284     maBmpEx.Invert();
 285 }
 286
 287 // -----------------------------------------------------------------------
 288
 289 void ImplImageBmp::Replace( USHORT nPos, USHORT nSrcPos )
 290 {
 291     const Point     aSrcPos( nSrcPos * maSize.Width(), 0L ), aPos( nPos * maSize.Width(), 0L );
 292     const Rectangle aSrcRect( aSrcPos, maSize );
 293     const Rectangle aDstRect( aPos, maSize );
 294
 295     maBmpEx.CopyPixel( aDstRect, aSrcRect );
 296
 297     if( !maDisabledBmpEx.IsEmpty() )
 298         maDisabledBmpEx.CopyPixel( aDstRect, aSrcRect );
 299
 300     delete mpDisplayBmp;
 301     mpDisplayBmp = NULL;
 302
 303     mpInfoAry[ nPos ] = mpInfoAry[ nSrcPos ];
 304 }
 305
 306 // -----------------------------------------------------------------------
 307
 308 void ImplImageBmp::Replace( USHORT nPos, const ImplImageBmp& rImageBmp, USHORT nSrcPos )
 309 {
 310     const Point     aSrcPos( nSrcPos * maSize.Width(), 0L ), aPos( nPos * maSize.Width(), 0L );
 311     const Rectangle aSrcRect( aSrcPos, maSize );
 312     const Rectangle aDstRect( aPos, maSize );
 313
 314     maBmpEx.CopyPixel( aDstRect, aSrcRect, &rImageBmp.maBmpEx );
 315
 316     ImplUpdateDisabledBmpEx( nPos );
 317     delete mpDisplayBmp;
 318     mpDisplayBmp = NULL;
 319
 320     mpInfoAry[ nPos ] = rImageBmp.mpInfoAry[ nSrcPos ];
 321 }
 322
 323 // -----------------------------------------------------------------------
 324
 325 void ImplImageBmp::Replace( USHORT nPos, const BitmapEx& rBmpEx )
 326 {
 327     const Point     aNullPos, aPos( nPos * maSize.Width(), 0L );
 328     const Rectangle aSrcRect( aNullPos, maSize );
 329     const Rectangle aDstRect( aPos, maSize );
 330
 331     maBmpEx.CopyPixel( aDstRect, aSrcRect, &rBmpEx );
 332
 333     ImplUpdateDisabledBmpEx( nPos );
 334     delete mpDisplayBmp;
 335     mpDisplayBmp = NULL;
 336
 337     mpInfoAry[ nPos ] &= ~( IMPSYSIMAGEITEM_MASK | IMPSYSIMAGEITEM_ALPHA );
 338     mpInfoAry[ nPos ] |= ( rBmpEx.IsAlpha() ? IMPSYSIMAGEITEM_ALPHA : ( rBmpEx.IsTransparent() ? IMPSYSIMAGEITEM_MASK : 0 ) );
 339 }
 340
 341 // -----------------------------------------------------------------------
 342
 343 void ImplImageBmp::ReplaceColors( const Color* pSrcColors, const Color* pDstColors, ULONG nColorCount )
 344 {
 345     maBmpEx.Replace( pSrcColors, pDstColors, nColorCount );
 346     delete mpDisplayBmp;
 347     mpDisplayBmp = NULL;
 348 }
 349
 350 // -----------------------------------------------------------------------
 351
 352 void ImplImageBmp::ColorTransform( BmpColorMode eColorMode )
 353 {
 354     maBmpEx = maBmpEx.GetColorTransformedBitmapEx( eColorMode );
 355     delete mpDisplayBmp;
 356     mpDisplayBmp = NULL;
 357 }
 358
 359 // -----------------------------------------------------------------------
 360
 361 BitmapEx ImplImageBmp::GetBitmapEx( USHORT nPosCount, USHORT* pPosAry ) const
 362 {
 363     const Bitmap        aNewBmp( Size( nPosCount * maSize.Width(), maSize.Height() ),  maBmpEx.GetBitmap().GetBitCount() );
 364     BitmapEx            aRet;
 365     if( maBmpEx.IsAlpha() )
 366     {
 367         // initialize target bitmap with an empty alpha mask
 368         // which allows for using an optimized copypixel later on (see AlphaMask::CopyPixel)
 369         // that avoids palette lookups
 370         AlphaMask aAlpha( Size( nPosCount * maSize.Width(), maSize.Height() ) );
 371         aRet = BitmapEx( aNewBmp, aAlpha );
 372     }
 373     else
 374         aRet  = BitmapEx( aNewBmp );
 375
 376     for( USHORT i = 0; i < nPosCount; i++ )
 377     {
 378         const Point     aSrcPos( pPosAry[ i ] * maSize.Width(), 0L );
 379         const Point             aPos( i * maSize.Width(), 0L );
 380         const Rectangle aSrcRect( aSrcPos, maSize );
 381         const Rectangle aDstRect( aPos, maSize );
 382
 383         aRet.CopyPixel( aDstRect, aSrcRect, &maBmpEx );
 384     }
 385
 386     return aRet;
 387 }
 388
 389 // -----------------------------------------------------------------------
 390
 391 void ImplImageBmp::Draw( USHORT nPos, OutputDevice* pOutDev,
 392                          const Point& rPos, USHORT nStyle,
 393                          const Size* pSize )
 394 {
 395     if( pOutDev->IsDeviceOutputNecessary() )
 396     {
 397         const Point aSrcPos( nPos * maSize.Width(), 0 );
 398         Size            aOutSize;
 399
 400         aOutSize = ( pSize ? *pSize : pOutDev->PixelToLogic( maSize ) );
 401
 402         if( nStyle & IMAGE_DRAW_DISABLE )
 403         {
 404             ImplUpdateDisabledBmpEx( nPos);
 405             pOutDev->DrawBitmapEx( rPos, aOutSize, aSrcPos, maSize, maDisabledBmpEx );
 406         }
 407         else
 408         {
 409             if( nStyle & ( IMAGE_DRAW_COLORTRANSFORM |
 410                            IMAGE_DRAW_MONOCHROME_BLACK | IMAGE_DRAW_MONOCHROME_WHITE |
 411                            IMAGE_DRAW_HIGHLIGHT | IMAGE_DRAW_DEACTIVE | IMAGE_DRAW_SEMITRANSPARENT ) )
 412             {
 413                 BitmapEx        aTmpBmpEx;
 414                 const Rectangle aCropRect( aSrcPos, maSize );
 415
 416                 if( mpInfoAry[ nPos ] & ( IMPSYSIMAGEITEM_MASK | IMPSYSIMAGEITEM_ALPHA ) )
 417                     aTmpBmpEx = maBmpEx;
 418                 else
 419                     aTmpBmpEx = maBmpEx.GetBitmap();
 420
 421                 aTmpBmpEx.Crop( aCropRect );
 422
 423                 if( nStyle & ( IMAGE_DRAW_COLORTRANSFORM | IMAGE_DRAW_MONOCHROME_BLACK | IMAGE_DRAW_MONOCHROME_WHITE ) )
 424                 {
 425                     const BmpColorMode eMode = ( nStyle & IMAGE_DRAW_COLORTRANSFORM ) ? BMP_COLOR_HIGHCONTRAST :
 426                                                 ( ( nStyle & IMAGE_DRAW_MONOCHROME_BLACK ) ? BMP_COLOR_MONOCHROME_BLACK : BMP_COLOR_MONOCHROME_WHITE );
 427
 428                     aTmpBmpEx = aTmpBmpEx.GetColorTransformedBitmapEx( eMode );
 429                 }
 430
 431                 Bitmap aTmpBmp( aTmpBmpEx.GetBitmap() );
 432
 433                 if( nStyle & ( IMAGE_DRAW_HIGHLIGHT | IMAGE_DRAW_DEACTIVE ) )
 434                 {
 435                     BitmapWriteAccess* pAcc = aTmpBmp.AcquireWriteAccess();
 436
 437                     if( pAcc )
 438                     {
 439                         const StyleSettings&    rSettings = pOutDev->GetSettings().GetStyleSettings();
 440                         Color                                   aColor;
 441                         BitmapColor                             aCol;
 442                         const long                              nW = pAcc->Width();
 443                         const long                              nH = pAcc->Height();
 444                         BYTE*                                   pMapR = new BYTE[ 256 ];
 445                         BYTE*                                   pMapG = new BYTE[ 256 ];
 446                         BYTE*                                   pMapB = new BYTE[ 256 ];
 447                         long                                    nX, nY;
 448
 449                         if( nStyle & IMAGE_DRAW_HIGHLIGHT )
 450                             aColor = rSettings.GetHighlightColor();
 451                         else
 452                             aColor = rSettings.GetDeactiveColor();
 453
 454                         const BYTE cR = aColor.GetRed();
 455                         const BYTE cG = aColor.GetGreen();
 456                         const BYTE cB = aColor.GetBlue();
 457
 458                         for( nX = 0L; nX < 256L; nX++ )
 459                         {
 460                             pMapR[ nX ] = (BYTE) ( ( ( nY = ( nX + cR ) >> 1 ) > 255 ) ? 255 : nY );
 461                             pMapG[ nX ] = (BYTE) ( ( ( nY = ( nX + cG ) >> 1 ) > 255 ) ? 255 : nY );
 462                             pMapB[ nX ] = (BYTE) ( ( ( nY = ( nX + cB ) >> 1 ) > 255 ) ? 255 : nY );
 463                         }
 464
 465                         if( pAcc->HasPalette() )
 466                         {
 467                             for( USHORT i = 0, nCount = pAcc->GetPaletteEntryCount(); i < nCount; i++ )
 468                             {
 469                                 const BitmapColor& rCol = pAcc->GetPaletteColor( i );
 470                                 aCol.SetRed( pMapR[ rCol.GetRed() ] );
 471                                 aCol.SetGreen( pMapG[ rCol.GetGreen() ] );
 472                                 aCol.SetBlue( pMapB[ rCol.GetBlue() ] );
 473                                 pAcc->SetPaletteColor( i, aCol );
 474                             }
 475                         }
 476                         else if( pAcc->GetScanlineFormat() == BMP_FORMAT_24BIT_TC_BGR )
 477                         {
 478                             for( nY = 0L; nY < nH; nY++ )
 479                             {
 480                                 Scanline pScan = pAcc->GetScanline( nY );
 481
 482                                 for( nX = 0L; nX < nW; nX++ )
 483                                 {
 484                                     *pScan = pMapB[ *pScan ]; pScan++;
 485                                     *pScan = pMapG[ *pScan ]; pScan++;
 486                                     *pScan = pMapR[ *pScan ]; pScan++;
 487                                 }
 488                             }
 489                         }
 490                         else
 491                         {
 492                             for( nY = 0L; nY < nH; nY++ )
 493                             {
 494                                 for( nX = 0L; nX < nW; nX++ )
 495                                 {
 496                                     aCol = pAcc->GetPixel( nY, nX );
 497                                     aCol.SetRed( pMapR[ aCol.GetRed() ] );
 498                                     aCol.SetGreen( pMapG[ aCol.GetGreen() ] );
 499                                     aCol.SetBlue( pMapB[ aCol.GetBlue() ] );
 500                                     pAcc->SetPixel( nY, nX, aCol );
 501                                 }
 502                             }
 503                         }
 504
 505                         delete[] pMapR;
 506                         delete[] pMapG;
 507                         delete[] pMapB;
 508                         aTmpBmp.ReleaseAccess( pAcc );
 509                     }
 510                 }
 511
 512                 if( nStyle & IMAGE_DRAW_SEMITRANSPARENT )
 513                 {
 514                     if( aTmpBmpEx.IsTransparent()  )
 515                     {
 516                         Bitmap aAlphaBmp( aTmpBmpEx.GetAlpha().GetBitmap() );
 517
 518                         aAlphaBmp.Adjust( 50 );
 519                         aTmpBmpEx = BitmapEx( aTmpBmp, AlphaMask( aAlphaBmp ) );
 520                     }
 521                     else
 522                     {
 523                         BYTE cErase = 128;
 524                         aTmpBmpEx = BitmapEx( aTmpBmp, AlphaMask( aTmpBmp.GetSizePixel(),  &cErase ) );
 525                     }
 526                 }
 527                 else
 528                 {
 529                     if( aTmpBmpEx.IsAlpha() )
 530                         aTmpBmpEx = BitmapEx( aTmpBmp, aTmpBmpEx.GetAlpha() );
 531                     else if( aTmpBmpEx.IsAlpha() )
 532                         aTmpBmpEx = BitmapEx( aTmpBmp, aTmpBmpEx.GetMask() );
 533                 }
 534
 535                 pOutDev->DrawBitmapEx( rPos, aOutSize, aTmpBmpEx );
 536             }
 537             else
 538             {
 539                 const BitmapEx* pOutputBmp;
 540
 541                 if( pOutDev->GetOutDevType() == OUTDEV_WINDOW )
 542                 {
 543                     ImplUpdateDisplayBmp( pOutDev );
 544                     pOutputBmp = mpDisplayBmp;
 545                 }
 546                 else
 547                     pOutputBmp = &maBmpEx;
 548
 549                 if( pOutputBmp )
 550                     pOutDev->DrawBitmapEx( rPos, aOutSize, aSrcPos, maSize, *pOutputBmp );
 551             }
 552         }
 553     }
 554 }
 555
 556 // -----------------------------------------------------------------------
 557
 558 void ImplImageBmp::ImplUpdateDisplayBmp( OutputDevice*
 559 #if defined WIN || defined WNT
 560 pOutDev
 561 #endif
 562 )
 563 {
 564     if( !mpDisplayBmp && !maBmpEx.IsEmpty() )
 565     {
 566 #if defined WIN || defined WNT
 567         if( maBmpEx.IsAlpha() )
 568             mpDisplayBmp = new BitmapEx( maBmpEx );
 569         else
 570         {
 571             const Bitmap aBmp( maBmpEx.GetBitmap().CreateDisplayBitmap( pOutDev ) );
 572
 573             if( maBmpEx.IsTransparent() )
 574                 mpDisplayBmp = new BitmapEx( aBmp, maBmpEx.GetMask().CreateDisplayBitmap( pOutDev ) );
 575             else
 576                 mpDisplayBmp = new BitmapEx( aBmp );
 577         }
 578 #else
 579         mpDisplayBmp = new BitmapEx( maBmpEx );
 580 #endif
 581     }
 582 }
 583
 584 // -----------------------------------------------------------------------
 585
 586 void ImplImageBmp::ImplUpdateDisabledBmpEx( int nPos )
 587 {
 588     const Size aTotalSize( maBmpEx.GetSizePixel() );
 589
 590     if( maDisabledBmpEx.IsEmpty() )
 591     {
 592         Bitmap      aGrey( aTotalSize, 8, &Bitmap::GetGreyPalette( 256 ) );
 593         AlphaMask   aGreyAlphaMask( aTotalSize );
 594
 595         maDisabledBmpEx = BitmapEx( aGrey, aGreyAlphaMask );
 596         nPos = -1;
 597     }
 598
 599     Bitmap              aBmp( maBmpEx.GetBitmap() );
 600     BitmapReadAccess*   pBmp( aBmp.AcquireReadAccess() );
 601     AlphaMask           aBmpAlphaMask( maBmpEx.GetAlpha() );
 602     BitmapReadAccess*   pBmpAlphaMask( aBmpAlphaMask.AcquireReadAccess() );
 603     Bitmap              aGrey( maDisabledBmpEx.GetBitmap() );
 604     BitmapWriteAccess*  pGrey( aGrey.AcquireWriteAccess() );
 605     AlphaMask           aGreyAlphaMask( maDisabledBmpEx.GetAlpha() );
 606     BitmapWriteAccess*  pGreyAlphaMask( aGreyAlphaMask.AcquireWriteAccess() );
 607
 608     if( pBmp && pBmpAlphaMask && pGrey && pGreyAlphaMask )
 609     {
 610         BitmapColor     aGreyVal( 0 );
 611         BitmapColor aGreyAlphaMaskVal( 0 );
 612         const Point aPos( ( nPos < 0 ) ? 0 : ( nPos * maSize.Width() ), 0 );
 613         const int  nLeft = aPos.X(), nRight = nLeft + ( ( nPos < 0 ) ? aTotalSize.Width() : maSize.Width() );
 614         const int  nTop = aPos.Y(), nBottom = nTop + maSize.Height();
 615
 616         for( int nY = nTop; nY < nBottom; ++nY )
 617         {
 618             for( int nX = nLeft; nX < nRight; ++nX )
 619             {
 620                 aGreyVal.SetIndex( pBmp->GetLuminance( nY, nX ) );
 621                 pGrey->SetPixel( nY, nX, aGreyVal );
 622
 623                 const BitmapColor aBmpAlphaMaskVal( pBmpAlphaMask->GetPixel( nY, nX ) );
 624
 625                 aGreyAlphaMaskVal.SetIndex( static_cast< sal_uInt8 >( ::std::min( aBmpAlphaMaskVal.GetIndex() + 178ul, 255ul ) ) );
 626                 pGreyAlphaMask->SetPixel( nY, nX, aGreyAlphaMaskVal );
 627             }
 628         }
 629     }
 630
 631     aBmp.ReleaseAccess( pBmp );
 632     aBmpAlphaMask.ReleaseAccess( pBmpAlphaMask );
 633     aGrey.ReleaseAccess( pGrey );
 634     aGreyAlphaMask.ReleaseAccess( pGreyAlphaMask );
 635
 636     maDisabledBmpEx = BitmapEx( aGrey, aGreyAlphaMask );
 637 }