vcl/source/gdi/impimage.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <vcl/outdev.hxx>
  22 #include <vcl/bitmapex.hxx>
  23 #include <vcl/alpha.hxx>
  24 #include <vcl/window.hxx>
  25 #include <vcl/bmpacc.hxx>
  26 #include <vcl/virdev.hxx>
  27 #include <vcl/image.hxx>
  28
  29 #include <image.h>
  30
  31 #define IMPSYSIMAGEITEM_MASK        ( 0x01 )
  32 #define IMPSYSIMAGEITEM_ALPHA       ( 0x02 )
  33
  34 ImageAryData::ImageAryData( const ImageAryData& rData ) :
  35     maName( rData.maName ),
  36     mnId( rData.mnId ),
  37     maBitmapEx( rData.maBitmapEx )
  38 {
  39 }
  40
  41 ImageAryData::ImageAryData( const OUString &aName,
  42                             sal_uInt16 nId, const BitmapEx &aBitmap )
  43         : maName( aName ), mnId( nId ), maBitmapEx( aBitmap )
  44 {
  45 }
  46
  47 ImageAryData::~ImageAryData()
  48 {
  49 }
  50
  51 ImageAryData& ImageAryData::operator=( const ImageAryData& rData )
  52 {
  53     maName = rData.maName;
  54     mnId = rData.mnId;
  55     maBitmapEx = rData.maBitmapEx;
  56
  57     return *this;
  58 }
  59
  60 ImplImageList::ImplImageList()
  61 {
  62 }
  63
  64 ImplImageList::ImplImageList( const ImplImageList &aSrc ) :
  65     maPrefix( aSrc.maPrefix ),
  66     maImageSize( aSrc.maImageSize ),
  67     mnRefCount( 1 )
  68 {
  69     maImages.reserve( aSrc.maImages.size() );
  70     for ( ImageAryDataVec::const_iterator aIt = aSrc.maImages.begin(), aEnd = aSrc.maImages.end(); aIt != aEnd; ++aIt )
  71     {
  72         ImageAryData* pAryData = new ImageAryData( **aIt );
  73         maImages.push_back( pAryData );
  74         if( !pAryData->maName.isEmpty() )
  75             maNameHash [ pAryData->maName ] = pAryData;
  76     }
  77 }
  78
  79 ImplImageList::~ImplImageList()
  80 {
  81     for ( ImageAryDataVec::iterator aIt = maImages.begin(), aEnd = maImages.end(); aIt != aEnd; ++aIt )
  82         delete *aIt;
  83 }
  84
  85 void ImplImageList::AddImage( const OUString &aName,
  86                               sal_uInt16 nId, const BitmapEx &aBitmapEx )
  87 {
  88     ImageAryData *pImg = new ImageAryData( aName, nId, aBitmapEx );
  89     maImages.push_back( pImg );
  90     if( !aName.isEmpty() )
  91         maNameHash [ aName ] = pImg;
  92 }
  93
  94 void ImplImageList::RemoveImage( sal_uInt16 nPos )
  95 {
  96     ImageAryData *pImg = maImages[ nPos ];
  97     if( !pImg->maName.isEmpty() )
  98         maNameHash.erase( pImg->maName );
  99     maImages.erase( maImages.begin() + nPos );
 100 }
 101
 102 ImplImageData::ImplImageData( const BitmapEx& rBmpEx ) :
 103     mpImageBitmap( NULL ),
 104     maBmpEx( rBmpEx )
 105 {
 106 }
 107
 108 ImplImageData::~ImplImageData()
 109 {
 110     delete mpImageBitmap;
 111 }
 112
 113 sal_Bool ImplImageData::IsEqual( const ImplImageData& rData )
 114 {
 115     return( maBmpEx == rData.maBmpEx );
 116 }
 117
 118 ImplImage::ImplImage()
 119 {
 120 }
 121
 122 ImplImage::~ImplImage()
 123 {
 124     switch( meType )
 125     {
 126         case IMAGETYPE_BITMAP:
 127             delete static_cast< Bitmap* >( mpData );
 128         break;
 129
 130         case IMAGETYPE_IMAGE:
 131             delete static_cast< ImplImageData* >( mpData );
 132         break;
 133     }
 134 }
 135
 136 ImplImageBmp::ImplImageBmp() :
 137     mpDisplayBmp( NULL ),
 138     mpInfoAry( NULL ),
 139     mnSize( 0 )
 140 {
 141 }
 142
 143 ImplImageBmp::~ImplImageBmp()
 144 {
 145     delete[] mpInfoAry;
 146     delete mpDisplayBmp;
 147 }
 148
 149 void ImplImageBmp::Create( const BitmapEx& rBmpEx, long nItemWidth, long nItemHeight, sal_uInt16 nInitSize )
 150 {
 151     maBmpEx = rBmpEx;
 152     maDisabledBmpEx.SetEmpty();
 153
 154     delete mpDisplayBmp;
 155     mpDisplayBmp = NULL;
 156
 157     maSize = Size( nItemWidth, nItemHeight );
 158     mnSize = nInitSize;
 159
 160     delete[] mpInfoAry;
 161     mpInfoAry = new sal_uInt8[ mnSize ];
 162     memset( mpInfoAry,
 163             rBmpEx.IsAlpha() ? IMPSYSIMAGEITEM_ALPHA : ( rBmpEx.IsTransparent() ? IMPSYSIMAGEITEM_MASK : 0 ),
 164             mnSize );
 165 }
 166
 167 void ImplImageBmp::Draw( sal_uInt16 nPos, OutputDevice* pOutDev,
 168                          const Point& rPos, sal_uInt16 nStyle,
 169                          const Size* pSize )
 170 {
 171     if( pOutDev->IsDeviceOutputNecessary() )
 172     {
 173         const Point aSrcPos( nPos * maSize.Width(), 0 );
 174         Size        aOutSize;
 175
 176         aOutSize = ( pSize ? *pSize : pOutDev->PixelToLogic( maSize ) );
 177
 178         if( nStyle & IMAGE_DRAW_DISABLE )
 179         {
 180             ImplUpdateDisabledBmpEx( nPos);
 181             pOutDev->DrawBitmapEx( rPos, aOutSize, aSrcPos, maSize, maDisabledBmpEx );
 182         }
 183         else
 184         {
 185             if( nStyle & ( IMAGE_DRAW_COLORTRANSFORM |
 186                            IMAGE_DRAW_HIGHLIGHT | IMAGE_DRAW_DEACTIVE | IMAGE_DRAW_SEMITRANSPARENT ) )
 187             {
 188                 BitmapEx        aTmpBmpEx;
 189                 const Rectangle aCropRect( aSrcPos, maSize );
 190
 191                 if( mpInfoAry[ nPos ] & ( IMPSYSIMAGEITEM_MASK | IMPSYSIMAGEITEM_ALPHA ) )
 192                     aTmpBmpEx = maBmpEx;
 193                 else
 194                     aTmpBmpEx = maBmpEx.GetBitmap();
 195
 196                 aTmpBmpEx.Crop( aCropRect );
 197
 198                 Bitmap aTmpBmp( aTmpBmpEx.GetBitmap() );
 199
 200                 if( nStyle & ( IMAGE_DRAW_HIGHLIGHT | IMAGE_DRAW_DEACTIVE ) )
 201                 {
 202                     BitmapWriteAccess* pAcc = aTmpBmp.AcquireWriteAccess();
 203
 204                     if( pAcc )
 205                     {
 206                         const StyleSettings&    rSettings = pOutDev->GetSettings().GetStyleSettings();
 207                         Color                   aColor;
 208                         BitmapColor             aCol;
 209                         const long              nW = pAcc->Width();
 210                         const long              nH = pAcc->Height();
 211                         sal_uInt8*                  pMapR = new sal_uInt8[ 256 ];
 212                         sal_uInt8*                  pMapG = new sal_uInt8[ 256 ];
 213                         sal_uInt8*                  pMapB = new sal_uInt8[ 256 ];
 214                         long                    nX, nY;
 215
 216                         if( nStyle & IMAGE_DRAW_HIGHLIGHT )
 217                             aColor = rSettings.GetHighlightColor();
 218                         else
 219                             aColor = rSettings.GetDeactiveColor();
 220
 221                         const sal_uInt8 cR = aColor.GetRed();
 222                         const sal_uInt8 cG = aColor.GetGreen();
 223                         const sal_uInt8 cB = aColor.GetBlue();
 224
 225                         for( nX = 0L; nX < 256L; nX++ )
 226                         {
 227                             pMapR[ nX ] = (sal_uInt8) ( ( ( nY = ( nX + cR ) >> 1 ) > 255 ) ? 255 : nY );
 228                             pMapG[ nX ] = (sal_uInt8) ( ( ( nY = ( nX + cG ) >> 1 ) > 255 ) ? 255 : nY );
 229                             pMapB[ nX ] = (sal_uInt8) ( ( ( nY = ( nX + cB ) >> 1 ) > 255 ) ? 255 : nY );
 230                         }
 231
 232                         if( pAcc->HasPalette() )
 233                         {
 234                             for( sal_uInt16 i = 0, nCount = pAcc->GetPaletteEntryCount(); i < nCount; i++ )
 235                             {
 236                                 const BitmapColor& rCol = pAcc->GetPaletteColor( i );
 237                                 aCol.SetRed( pMapR[ rCol.GetRed() ] );
 238                                 aCol.SetGreen( pMapG[ rCol.GetGreen() ] );
 239                                 aCol.SetBlue( pMapB[ rCol.GetBlue() ] );
 240                                 pAcc->SetPaletteColor( i, aCol );
 241                             }
 242                         }
 243                         else if( pAcc->GetScanlineFormat() == BMP_FORMAT_24BIT_TC_BGR )
 244                         {
 245                             for( nY = 0L; nY < nH; nY++ )
 246                             {
 247                                 Scanline pScan = pAcc->GetScanline( nY );
 248
 249                                 for( nX = 0L; nX < nW; nX++ )
 250                                 {
 251                                     *pScan = pMapB[ *pScan ]; pScan++;
 252                                     *pScan = pMapG[ *pScan ]; pScan++;
 253                                     *pScan = pMapR[ *pScan ]; pScan++;
 254                                 }
 255                             }
 256                         }
 257                         else
 258                         {
 259                             for( nY = 0L; nY < nH; nY++ )
 260                             {
 261                                 for( nX = 0L; nX < nW; nX++ )
 262                                 {
 263                                     aCol = pAcc->GetPixel( nY, nX );
 264                                     aCol.SetRed( pMapR[ aCol.GetRed() ] );
 265                                     aCol.SetGreen( pMapG[ aCol.GetGreen() ] );
 266                                     aCol.SetBlue( pMapB[ aCol.GetBlue() ] );
 267                                     pAcc->SetPixel( nY, nX, aCol );
 268                                 }
 269                             }
 270                         }
 271
 272                         delete[] pMapR;
 273                         delete[] pMapG;
 274                         delete[] pMapB;
 275                         aTmpBmp.ReleaseAccess( pAcc );
 276                     }
 277                 }
 278
 279                 if( nStyle & IMAGE_DRAW_SEMITRANSPARENT )
 280                 {
 281                     if( aTmpBmpEx.IsTransparent()  )
 282                     {
 283                         Bitmap aAlphaBmp( aTmpBmpEx.GetAlpha().GetBitmap() );
 284
 285                         aAlphaBmp.Adjust( 50 );
 286                         aTmpBmpEx = BitmapEx( aTmpBmp, AlphaMask( aAlphaBmp ) );
 287                     }
 288                     else
 289                     {
 290                         sal_uInt8 cErase = 128;
 291                         aTmpBmpEx = BitmapEx( aTmpBmp, AlphaMask( aTmpBmp.GetSizePixel(),  &cErase ) );
 292                     }
 293                 }
 294                 else
 295                 {
 296                     if( aTmpBmpEx.IsAlpha() )
 297                         aTmpBmpEx = BitmapEx( aTmpBmp, aTmpBmpEx.GetAlpha() );
 298                     else if( aTmpBmpEx.IsAlpha() )
 299                         aTmpBmpEx = BitmapEx( aTmpBmp, aTmpBmpEx.GetMask() );
 300                 }
 301
 302                 pOutDev->DrawBitmapEx( rPos, aOutSize, aTmpBmpEx );
 303             }
 304             else
 305             {
 306                 const BitmapEx* pOutputBmp;
 307
 308                 if( pOutDev->GetOutDevType() == OUTDEV_WINDOW )
 309                 {
 310                     ImplUpdateDisplayBmp( pOutDev );
 311                     pOutputBmp = mpDisplayBmp;
 312                 }
 313                 else
 314                     pOutputBmp = &maBmpEx;
 315
 316                 if( pOutputBmp )
 317                     pOutDev->DrawBitmapEx( rPos, aOutSize, aSrcPos, maSize, *pOutputBmp );
 318             }
 319         }
 320     }
 321 }
 322
 323 void ImplImageBmp::ImplUpdateDisplayBmp( OutputDevice*
 324 #if defined WNT
 325 pOutDev
 326 #endif
 327 )
 328 {
 329     if( !mpDisplayBmp && !maBmpEx.IsEmpty() )
 330     {
 331 #if defined WNT
 332         if( maBmpEx.IsAlpha() )
 333             mpDisplayBmp = new BitmapEx( maBmpEx );
 334         else
 335         {
 336             const Bitmap aBmp( maBmpEx.GetBitmap().CreateDisplayBitmap( pOutDev ) );
 337
 338             if( maBmpEx.IsTransparent() )
 339                 mpDisplayBmp = new BitmapEx( aBmp, maBmpEx.GetMask().CreateDisplayBitmap( pOutDev ) );
 340             else
 341                 mpDisplayBmp = new BitmapEx( aBmp );
 342         }
 343 #else
 344         mpDisplayBmp = new BitmapEx( maBmpEx );
 345 #endif
 346     }
 347 }
 348
 349 void ImplImageBmp::ImplUpdateDisabledBmpEx( int nPos )
 350 {
 351     const Size aTotalSize( maBmpEx.GetSizePixel() );
 352
 353     if( maDisabledBmpEx.IsEmpty() )
 354     {
 355         Bitmap      aGrey( aTotalSize, 8, &Bitmap::GetGreyPalette( 256 ) );
 356         AlphaMask   aGreyAlphaMask( aTotalSize );
 357
 358         maDisabledBmpEx = BitmapEx( aGrey, aGreyAlphaMask );
 359         nPos = -1;
 360     }
 361
 362     Bitmap              aBmp( maBmpEx.GetBitmap() );
 363     BitmapReadAccess*   pBmp( aBmp.AcquireReadAccess() );
 364     AlphaMask           aBmpAlphaMask( maBmpEx.GetAlpha() );
 365     BitmapReadAccess*   pBmpAlphaMask( aBmpAlphaMask.AcquireReadAccess() );
 366     Bitmap              aGrey( maDisabledBmpEx.GetBitmap() );
 367     BitmapWriteAccess*  pGrey( aGrey.AcquireWriteAccess() );
 368     AlphaMask           aGreyAlphaMask( maDisabledBmpEx.GetAlpha() );
 369     BitmapWriteAccess*  pGreyAlphaMask( aGreyAlphaMask.AcquireWriteAccess() );
 370
 371     if( pBmp && pBmpAlphaMask && pGrey && pGreyAlphaMask )
 372     {
 373         BitmapColor aGreyVal( 0 );
 374         BitmapColor aGreyAlphaMaskVal( 0 );
 375         const Point aPos( ( nPos < 0 ) ? 0 : ( nPos * maSize.Width() ), 0 );
 376         const int  nLeft = aPos.X(), nRight = nLeft + ( ( nPos < 0 ) ? aTotalSize.Width() : maSize.Width() );
 377         const int  nTop = aPos.Y(), nBottom = nTop + maSize.Height();
 378
 379         for( int nY = nTop; nY < nBottom; ++nY )
 380         {
 381             for( int nX = nLeft; nX < nRight; ++nX )
 382             {
 383                 aGreyVal.SetIndex( pBmp->GetLuminance( nY, nX ) );
 384                 pGrey->SetPixel( nY, nX, aGreyVal );
 385
 386                 const BitmapColor aBmpAlphaMaskVal( pBmpAlphaMask->GetPixel( nY, nX ) );
 387
 388                 aGreyAlphaMaskVal.SetIndex( static_cast< sal_uInt8 >( ::std::min( aBmpAlphaMaskVal.GetIndex() + 178ul, 255ul ) ) );
 389                 pGreyAlphaMask->SetPixel( nY, nX, aGreyAlphaMaskVal );
 390             }
 391         }
 392     }
 393
 394     aBmp.ReleaseAccess( pBmp );
 395     aBmpAlphaMask.ReleaseAccess( pBmpAlphaMask );
 396     aGrey.ReleaseAccess( pGrey );
 397     aGreyAlphaMask.ReleaseAccess( pGreyAlphaMask );
 398
 399     maDisabledBmpEx = BitmapEx( aGrey, aGreyAlphaMask );
 400 }
 401
 402 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */