vcl/source/gdi/alpha.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: alpha.cxx,v $
  10  * $Revision: 1.11 $
  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 <tools/debug.hxx>
  34 #include <vcl/bmpacc.hxx>
  35 #include <tools/color.hxx>
  36 #include <vcl/alpha.hxx>
  37
  38 // -------------
  39 // - AlphaMask -
  40 // -------------
  41
  42 AlphaMask::AlphaMask()
  43 {
  44 }
  45
  46 // -----------------------------------------------------------------------------
  47
  48 AlphaMask::AlphaMask( const Bitmap& rBitmap ) :
  49     Bitmap( rBitmap )
  50 {
  51     if( !!rBitmap )
  52         Bitmap::Convert( BMP_CONVERSION_8BIT_GREYS );
  53 }
  54
  55 // -----------------------------------------------------------------------------
  56
  57 AlphaMask::AlphaMask( const AlphaMask& rAlphaMask ) :
  58     Bitmap( rAlphaMask )
  59 {
  60 }
  61
  62 // -----------------------------------------------------------------------------
  63
  64 AlphaMask::AlphaMask( const Size& rSizePixel, BYTE* pEraseTransparency ) :
  65     Bitmap( rSizePixel, 8, &Bitmap::GetGreyPalette( 256 ) )
  66 {
  67     if( pEraseTransparency )
  68         Bitmap::Erase( Color( *pEraseTransparency, *pEraseTransparency, *pEraseTransparency ) );
  69 }
  70
  71 // -----------------------------------------------------------------------------
  72
  73 AlphaMask::~AlphaMask()
  74 {
  75 }
  76
  77 // -----------------------------------------------------------------------------
  78
  79 AlphaMask& AlphaMask::operator=( const Bitmap& rBitmap )
  80 {
  81     *(Bitmap*) this = rBitmap;
  82
  83     if( !!rBitmap )
  84         Bitmap::Convert( BMP_CONVERSION_8BIT_GREYS );
  85
  86     return *this;
  87 }
  88
  89 // -----------------------------------------------------------------------------
  90
  91 const Bitmap& AlphaMask::ImplGetBitmap() const
  92 {
  93     return( (const Bitmap&) *this );
  94 }
  95
  96 // -----------------------------------------------------------------------------
  97
  98 void AlphaMask::ImplSetBitmap( const Bitmap& rBitmap )
  99 {
 100     DBG_ASSERT( ( 8 == rBitmap.GetBitCount() ) && rBitmap.HasGreyPalette(), "AlphaMask::ImplSetBitmap: invalid bitmap" );
 101     *(Bitmap*) this = rBitmap;
 102 }
 103
 104 // -----------------------------------------------------------------------------
 105
 106 Bitmap AlphaMask::GetBitmap() const
 107 {
 108     return ImplGetBitmap();
 109 }
 110
 111 // -----------------------------------------------------------------------------
 112
 113 BOOL AlphaMask::Crop( const Rectangle& rRectPixel )
 114 {
 115     return Bitmap::Crop( rRectPixel );
 116 }
 117
 118 // -----------------------------------------------------------------------------
 119
 120 BOOL AlphaMask::Expand( ULONG nDX, ULONG nDY, BYTE* pInitTransparency )
 121 {
 122     Color aColor;
 123
 124     if( pInitTransparency )
 125         aColor = Color( *pInitTransparency, *pInitTransparency, *pInitTransparency );
 126
 127     return Bitmap::Expand( nDX, nDY, pInitTransparency ? &aColor : NULL );
 128 }
 129
 130 // -----------------------------------------------------------------------------
 131
 132 BOOL AlphaMask::CopyPixel( const Rectangle& rRectDst, const Rectangle& rRectSrc,
 133                            const AlphaMask* pAlphaSrc )
 134 {
 135     // Note: this code is copied from Bitmap::CopyPixel but avoids any palette lookups
 136     // this optimization is possible because the palettes of AlphaMasks are always identical (8bit GreyPalette, see ctor)
 137
 138     const Size  aSizePix( GetSizePixel() );
 139     Rectangle   aRectDst( rRectDst );
 140     BOOL                bRet = FALSE;
 141
 142     aRectDst.Intersection( Rectangle( Point(), aSizePix ) );
 143
 144     if( !aRectDst.IsEmpty() )
 145     {
 146         if( pAlphaSrc && ( *pAlphaSrc != *this ) )
 147         {
 148             Bitmap*             pSrc = (Bitmap*) pAlphaSrc;
 149             const Size          aCopySizePix( pSrc->GetSizePixel() );
 150             Rectangle           aRectSrc( rRectSrc );
 151
 152             aRectSrc.Intersection( Rectangle( Point(), aCopySizePix ) );
 153
 154             if( !aRectSrc.IsEmpty() )
 155             {
 156                 BitmapReadAccess* pReadAcc = pSrc->AcquireReadAccess();
 157
 158                 if( pReadAcc )
 159                 {
 160                     BitmapWriteAccess* pWriteAcc = AcquireWriteAccess();
 161
 162                     if( pWriteAcc )
 163                     {
 164                         const long      nWidth = Min( aRectSrc.GetWidth(), aRectDst.GetWidth() );
 165                         const long      nHeight = Min( aRectSrc.GetHeight(), aRectDst.GetHeight() );
 166                         const long      nSrcEndX = aRectSrc.Left() + nWidth;
 167                         const long      nSrcEndY = aRectSrc.Top() + nHeight;
 168                         long            nDstY = aRectDst.Top();
 169
 170                         for( long nSrcY = aRectSrc.Top(); nSrcY < nSrcEndY; nSrcY++, nDstY++ )
 171                             for( long nSrcX = aRectSrc.Left(), nDstX = aRectDst.Left(); nSrcX < nSrcEndX; nSrcX++, nDstX++ )
 172                                 pWriteAcc->SetPixel( nDstY, nDstX, pReadAcc->GetPixel( nSrcY, nSrcX ) );
 173
 174                         ReleaseAccess( pWriteAcc );
 175                         bRet = ( nWidth > 0L ) && ( nHeight > 0L );
 176                     }
 177
 178                     pSrc->ReleaseAccess( pReadAcc );
 179                 }
 180             }
 181         }
 182         else
 183         {
 184             Rectangle aRectSrc( rRectSrc );
 185
 186             aRectSrc.Intersection( Rectangle( Point(), aSizePix ) );
 187
 188             if( !aRectSrc.IsEmpty() && ( aRectSrc != aRectDst ) )
 189             {
 190                 BitmapWriteAccess*      pWriteAcc = AcquireWriteAccess();
 191
 192                 if( pWriteAcc )
 193                 {
 194                     const long  nWidth = Min( aRectSrc.GetWidth(), aRectDst.GetWidth() );
 195                     const long  nHeight = Min( aRectSrc.GetHeight(), aRectDst.GetHeight() );
 196                     const long  nSrcX = aRectSrc.Left();
 197                     const long  nSrcY = aRectSrc.Top();
 198                     const long  nSrcEndX1 = nSrcX + nWidth - 1L;
 199                     const long  nSrcEndY1 = nSrcY + nHeight - 1L;
 200                     const long  nDstX = aRectDst.Left();
 201                     const long  nDstY = aRectDst.Top();
 202                     const long  nDstEndX1 = nDstX + nWidth - 1L;
 203                     const long  nDstEndY1 = nDstY + nHeight - 1L;
 204
 205                     if( ( nDstX <= nSrcX ) && ( nDstY <= nSrcY ) )
 206                     {
 207                         for( long nY = nSrcY, nYN = nDstY; nY <= nSrcEndY1; nY++, nYN++ )
 208                             for( long nX = nSrcX, nXN = nDstX; nX <= nSrcEndX1; nX++, nXN++ )
 209                                 pWriteAcc->SetPixel( nYN, nXN, pWriteAcc->GetPixel( nY, nX ) );
 210                     }
 211                     else if( ( nDstX <= nSrcX ) && ( nDstY >= nSrcY ) )
 212                     {
 213                         for( long nY = nSrcEndY1, nYN = nDstEndY1; nY >= nSrcY; nY--, nYN-- )
 214                             for( long nX = nSrcX, nXN = nDstX; nX <= nSrcEndX1; nX++, nXN++ )
 215                                 pWriteAcc->SetPixel( nYN, nXN, pWriteAcc->GetPixel( nY, nX ) );
 216                     }
 217                     else if( ( nDstX >= nSrcX ) && ( nDstY <= nSrcY ) )
 218                     {
 219                         for( long nY = nSrcY, nYN = nDstY; nY <= nSrcEndY1; nY++, nYN++ )
 220                             for( long nX = nSrcEndX1, nXN = nDstEndX1; nX >= nSrcX; nX--, nXN-- )
 221                                 pWriteAcc->SetPixel( nYN, nXN, pWriteAcc->GetPixel( nY, nX ) );
 222                     }
 223                     else
 224                     {
 225                         for( long nY = nSrcEndY1, nYN = nDstEndY1; nY >= nSrcY; nY--, nYN-- )
 226                             for( long nX = nSrcEndX1, nXN = nDstEndX1; nX >= nSrcX; nX--, nXN-- )
 227                                 pWriteAcc->SetPixel( nYN, nXN, pWriteAcc->GetPixel( nY, nX ) );
 228                     }
 229
 230                     ReleaseAccess( pWriteAcc );
 231                     bRet = TRUE;
 232                 }
 233             }
 234         }
 235     }
 236
 237     return bRet;
 238
 239 }
 240
 241 // -----------------------------------------------------------------------------
 242
 243 BOOL AlphaMask::Erase( BYTE cTransparency )
 244 {
 245     return Bitmap::Erase( Color( cTransparency, cTransparency, cTransparency ) );
 246 }
 247
 248 // -----------------------------------------------------------------------------
 249
 250 BOOL AlphaMask::Invert()
 251 {
 252     BitmapWriteAccess*  pAcc = AcquireWriteAccess();
 253     BOOL                                bRet = FALSE;
 254
 255     if( pAcc && pAcc->GetBitCount() == 8 )
 256     {
 257         BitmapColor     aCol( 0 );
 258         const long      nWidth = pAcc->Width(), nHeight = pAcc->Height();
 259         BYTE*           pMap = new BYTE[ 256 ];
 260
 261         for( long i = 0; i < 256; i++ )
 262             pMap[ i ] = ~(BYTE) i;
 263
 264         for( long nY = 0L; nY < nHeight; nY++ )
 265         {
 266             for( long nX = 0L; nX < nWidth; nX++ )
 267             {
 268                 aCol.SetIndex( pMap[ pAcc->GetPixel( nY, nX ).GetIndex() ] );
 269                 pAcc->SetPixel( nY, nX, aCol );
 270             }
 271         }
 272
 273         delete[] pMap;
 274         bRet = TRUE;
 275     }
 276
 277     if( pAcc )
 278         ReleaseAccess( pAcc );
 279
 280     return bRet;
 281 }
 282
 283 // -----------------------------------------------------------------------------
 284
 285 BOOL AlphaMask::Mirror( ULONG nMirrorFlags )
 286 {
 287     return Bitmap::Mirror( nMirrorFlags );
 288 }
 289
 290 // -----------------------------------------------------------------------------
 291
 292 BOOL AlphaMask::Scale( const Size& rNewSize, ULONG nScaleFlag )
 293 {
 294     BOOL bRet = Bitmap::Scale( rNewSize, nScaleFlag );
 295
 296     if( bRet && ( nScaleFlag == BMP_SCALE_INTERPOLATE ) )
 297         Bitmap::Convert( BMP_CONVERSION_8BIT_GREYS );
 298
 299     return bRet;
 300 }
 301
 302 // -----------------------------------------------------------------------------
 303
 304 BOOL AlphaMask::Scale( const double& rScaleX, const double& rScaleY, ULONG nScaleFlag )
 305 {
 306     BOOL bRet = Bitmap::Scale( rScaleX, rScaleY, nScaleFlag );
 307
 308     if( bRet && ( nScaleFlag == BMP_SCALE_INTERPOLATE ) )
 309         Bitmap::Convert( BMP_CONVERSION_8BIT_GREYS );
 310
 311     return bRet;
 312 }
 313
 314 // -----------------------------------------------------------------------------
 315
 316 BOOL AlphaMask::Rotate( long nAngle10, BYTE cFillTransparency )
 317 {
 318     return Bitmap::Rotate( nAngle10, Color( cFillTransparency, cFillTransparency, cFillTransparency ) );
 319 }
 320
 321 // -----------------------------------------------------------------------------
 322
 323 BOOL AlphaMask::Replace( const Bitmap& rMask, BYTE cReplaceTransparency )
 324 {
 325     BitmapReadAccess*   pMaskAcc = ( (Bitmap&) rMask ).AcquireReadAccess();
 326     BitmapWriteAccess*  pAcc = AcquireWriteAccess();
 327     BOOL                                bRet = FALSE;
 328
 329     if( pMaskAcc && pAcc )
 330     {
 331         const BitmapColor       aReplace( cReplaceTransparency );
 332         const long                      nWidth = Min( pMaskAcc->Width(), pAcc->Width() );
 333         const long                      nHeight = Min( pMaskAcc->Height(), pAcc->Height() );
 334         const BitmapColor       aMaskWhite( pMaskAcc->GetBestMatchingColor( Color( COL_WHITE ) ) );
 335
 336         for( long nY = 0L; nY < nHeight; nY++ )
 337             for( long nX = 0L; nX < nWidth; nX++ )
 338                 if( pMaskAcc->GetPixel( nY, nX ) == aMaskWhite )
 339                     pAcc->SetPixel( nY, nX, aReplace );
 340     }
 341
 342     ( (Bitmap&) rMask ).ReleaseAccess( pMaskAcc );
 343     ReleaseAccess( pAcc );
 344
 345     return bRet;
 346 }
 347
 348 // -----------------------------------------------------------------------------
 349
 350 BOOL AlphaMask::Replace( BYTE cSearchTransparency, BYTE cReplaceTransparency, ULONG
 351 #ifdef DBG_UTIL
 352 nTol
 353 #endif
 354 )
 355 {
 356     BitmapWriteAccess*  pAcc = AcquireWriteAccess();
 357     BOOL                                bRet = FALSE;
 358
 359     DBG_ASSERT( !nTol, "AlphaMask::Replace: nTol not used yet" );
 360
 361     if( pAcc && pAcc->GetBitCount() == 8 )
 362     {
 363         const long nWidth = pAcc->Width(), nHeight = pAcc->Height();
 364
 365         if( pAcc->GetScanlineFormat() == BMP_FORMAT_8BIT_PAL )
 366         {
 367             for( long nY = 0L; nY < nHeight; nY++ )
 368             {
 369                 Scanline pScan = pAcc->GetScanline( nY );
 370
 371                 for( long nX = 0L; nX < nWidth; nX++, pScan++ )
 372                 {
 373                     if( *pScan == cSearchTransparency )
 374                         *pScan = cReplaceTransparency;
 375                 }
 376             }
 377         }
 378         else
 379         {
 380             BitmapColor aReplace( cReplaceTransparency );
 381
 382             for( long nY = 0L; nY < nHeight; nY++ )
 383             {
 384                 for( long nX = 0L; nX < nWidth; nX++ )
 385                 {
 386                     if( pAcc->GetPixel( nY, nX ).GetIndex() == cSearchTransparency )
 387                         pAcc->SetPixel( nY, nX, aReplace );
 388                 }
 389             }
 390         }
 391
 392         bRet = TRUE;
 393     }
 394
 395     if( pAcc )
 396         ReleaseAccess( pAcc );
 397
 398     return bRet;
 399 }
 400
 401 // -----------------------------------------------------------------------------
 402
 403 BOOL AlphaMask::Replace( BYTE* pSearchTransparencies, BYTE* pReplaceTransparencies,
 404                          ULONG nColorCount, ULONG* pTols )
 405 {
 406     Color*      pSearchColors = new Color[ nColorCount ];
 407     Color*      pReplaceColors = new Color[ nColorCount ];
 408     BOOL        bRet;
 409
 410     for( ULONG i = 0; i < nColorCount; i++ )
 411     {
 412         const BYTE cSearchTransparency = pSearchTransparencies[ i ];
 413         const BYTE cReplaceTransparency = pReplaceTransparencies[ i ];
 414
 415         pSearchColors[ i ] = Color( cSearchTransparency, cSearchTransparency, cSearchTransparency );
 416         pReplaceColors[ i ] = Color( cReplaceTransparency, cReplaceTransparency, cReplaceTransparency );
 417     }
 418
 419     bRet = Bitmap::Replace( pSearchColors, pReplaceColors, nColorCount, pTols ) &&
 420            Bitmap::Convert( BMP_CONVERSION_8BIT_GREYS );
 421
 422     delete[] pSearchColors;
 423     delete[] pReplaceColors;
 424
 425     return bRet;
 426 }
 427
 428 // -----------------------------------------------------------------------------
 429
 430 void AlphaMask::ReleaseAccess( BitmapReadAccess* pAccess )
 431 {
 432     if( pAccess )
 433     {
 434         Bitmap::ReleaseAccess( pAccess );
 435         Bitmap::Convert( BMP_CONVERSION_8BIT_GREYS );
 436     }
 437 }