vcl/source/gdi/imgcons.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: imgcons.cxx,v $
  10  * $Revision: 1.8 $
  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
  34 #include <tools/stream.hxx>
  35 #include <vcl/bmpacc.hxx>
  36 #include <vcl/bitmapex.hxx>
  37 #include <vcl/image.hxx>
  38 #include <vcl/imgcons.hxx>
  39
  40 // -------------------
  41 // - ImplColorMapper -
  42 // -------------------
  43
  44 class ImplColorMapper
  45 {
  46     Color                               maCol;
  47     ULONG                               mnR;
  48     ULONG                               mnG;
  49     ULONG                               mnB;
  50     ULONG                               mnT;
  51     ULONG                               mnRShift;
  52     ULONG                               mnGShift;
  53     ULONG                               mnBShift;
  54     ULONG                               mnTShift;
  55
  56     ULONG                               ImplCalcMaskShift( ULONG nVal );
  57
  58 public:
  59
  60                         ImplColorMapper( ULONG nRMask, ULONG nGMask, ULONG nBMask, ULONG nTMask );
  61                         ~ImplColorMapper();
  62
  63     const Color&                ImplGetColor( ULONG nColor )
  64                         {
  65                             maCol.SetRed( (UINT8) ( ( nColor & mnR ) >> mnRShift ) );
  66                             maCol.SetGreen( (UINT8) ( ( nColor & mnG ) >> mnGShift ) );
  67                             maCol.SetBlue( (UINT8) ( ( nColor & mnB ) >> mnBShift ) );
  68                             maCol.SetTransparency( (UINT8) ( ( nColor & mnT ) >> mnTShift ) );
  69                             return maCol;
  70                         }
  71 };
  72
  73 // -----------------------------------------------------------------------------
  74
  75 ImplColorMapper::ImplColorMapper( ULONG nRMask, ULONG nGMask, ULONG nBMask, ULONG nTMask ) :
  76         mnR( nRMask ),
  77         mnG( nGMask ),
  78         mnB( nBMask ),
  79         mnT( nTMask )
  80 {
  81     mnRShift = ImplCalcMaskShift( mnR );
  82     mnGShift = ImplCalcMaskShift( mnG );
  83     mnBShift = ImplCalcMaskShift( mnB );
  84     mnTShift = ImplCalcMaskShift( mnT );
  85 }
  86
  87 // -----------------------------------------------------------------------------
  88
  89 ImplColorMapper::~ImplColorMapper()
  90 {
  91 }
  92
  93 // -----------------------------------------------------------------------------
  94
  95 ULONG ImplColorMapper::ImplCalcMaskShift( ULONG nVal )
  96 {
  97     DBG_ASSERT( nVal > 0, "Mask has no value!" );
  98
  99     ULONG nRet = 0UL;
 100
 101     for( ULONG i = 0UL; i < 32; i++ )
 102     {
 103         if( nVal & ( 1UL << i ) )
 104         {
 105             nRet = i;
 106             break;
 107         }
 108     }
 109
 110     return nRet;
 111 }
 112
 113 // -----------------
 114 // - ImageConsumer -
 115 // -----------------
 116
 117 ImageConsumer::ImageConsumer() :
 118     mpMapper( NULL ),
 119     mpPal       ( NULL ),
 120     mnStatus( 0UL ),
 121     mbTrans     ( FALSE )
 122 {
 123 }
 124
 125 // -----------------------------------------------------------------------------
 126
 127 ImageConsumer::~ImageConsumer()
 128 {
 129     delete[] mpPal;
 130     delete mpMapper;
 131 }
 132
 133 // -----------------------------------------------------------------------------
 134
 135 void ImageConsumer::Init( sal_uInt32 nWidth, sal_uInt32 nHeight )
 136 {
 137     maSize = Size( nWidth, nHeight );
 138     maBitmap = maMask = Bitmap();
 139     mnStatus = 0UL;
 140     mbTrans = FALSE;
 141 }
 142
 143 // -----------------------------------------------------------------------------
 144
 145 void ImageConsumer::SetColorModel( USHORT nBitCount,
 146                                    sal_uInt32 nPalEntries, const sal_uInt32* pRGBAPal,
 147                                    sal_uInt32 nRMask, sal_uInt32 nGMask, sal_uInt32 nBMask, sal_uInt32 nAMask )
 148 {
 149     DBG_ASSERT( maSize.Width() && maSize.Height(), "Missing call to ImageConsumer::Init(...)!" );
 150
 151     BitmapPalette aPal( Min( (USHORT) nPalEntries, (USHORT) 256 ) );
 152
 153     if( nPalEntries )
 154     {
 155         BitmapColor     aCol;
 156         const sal_Int32* pTmp = (sal_Int32*) pRGBAPal;
 157
 158         delete mpMapper;
 159         mpMapper = NULL;
 160
 161         delete[] mpPal;
 162         mpPal = new Color[ nPalEntries ];
 163
 164         for( ULONG i = 0; i < nPalEntries; i++, pTmp++ )
 165         {
 166             Color&      rCol = mpPal[ i ];
 167             BYTE        cVal;
 168
 169             cVal = (BYTE) ( ( *pTmp & 0xff000000UL ) >> 24L );
 170             rCol.SetRed( cVal );
 171
 172             if( i < (ULONG) aPal.GetEntryCount() )
 173                 aPal[ (USHORT) i ].SetRed( cVal );
 174
 175             cVal = (BYTE) ( ( *pTmp & 0x00ff0000UL ) >> 16L );
 176             rCol.SetGreen( cVal );
 177
 178             if( i < (ULONG) aPal.GetEntryCount() )
 179                 aPal[ (USHORT) i ].SetGreen( cVal );
 180
 181             cVal = (BYTE) ( ( *pTmp & 0x0000ff00UL ) >> 8L );
 182             rCol.SetBlue( cVal );
 183
 184             if( i < (ULONG) aPal.GetEntryCount() )
 185                 aPal[ (USHORT) i ].SetBlue( cVal );
 186
 187             rCol.SetTransparency( (BYTE) ( ( *pTmp & 0x000000ffL ) ) );
 188         }
 189
 190         if( nBitCount <= 1 )
 191             nBitCount = 1;
 192         else if( nBitCount <= 4 )
 193             nBitCount = 4;
 194         else if( nBitCount <= 8 )
 195             nBitCount = 8;
 196         else
 197             nBitCount = 24;
 198     }
 199     else
 200     {
 201         delete mpMapper;
 202         mpMapper = new ImplColorMapper( nRMask, nGMask, nBMask, nAMask );
 203
 204         delete[] mpPal;
 205         mpPal = NULL;
 206
 207         nBitCount = 24;
 208     }
 209
 210     if( !maBitmap )
 211     {
 212
 213         maBitmap = Bitmap( maSize, nBitCount, &aPal );
 214         maMask = Bitmap( maSize, 1 );
 215         maMask.Erase( COL_BLACK );
 216         mbTrans = FALSE;
 217     }
 218 }
 219
 220 // -----------------------------------------------------------------------------
 221
 222 void ImageConsumer::SetPixelsByBytes( sal_uInt32 nConsX, sal_uInt32 nConsY,
 223                                       sal_uInt32 nConsWidth, sal_uInt32 nConsHeight,
 224                                       const BYTE* pData, sal_uInt32 nOffset, sal_uInt32 nScanSize )
 225 {
 226     DBG_ASSERT( !!maBitmap && !!maMask, "Missing call to ImageConsumer::SetColorModel(...)!" );
 227
 228     BitmapWriteAccess*  pBmpAcc = maBitmap.AcquireWriteAccess();
 229     BitmapWriteAccess*  pMskAcc = maMask.AcquireWriteAccess();
 230     sal_Bool                    bDataChanged = sal_False;
 231
 232     if( pBmpAcc && pMskAcc )
 233     {
 234         const long      nWidth = pBmpAcc->Width();
 235         const long      nHeight = pBmpAcc->Height();
 236
 237         maChangedRect = Rectangle( Point(), Size( nWidth, nHeight ) );
 238         maChangedRect.Intersection( Rectangle( Point( nConsX, nConsY ), Size( nConsWidth, nConsHeight ) ) );
 239
 240         if( !maChangedRect.IsEmpty() )
 241         {
 242             const long nStartX = maChangedRect.Left();
 243             const long nEndX = maChangedRect.Right();
 244             const long nStartY = maChangedRect.Top();
 245             const long nEndY = maChangedRect.Bottom();
 246
 247             if( mpMapper && ( pBmpAcc->GetBitCount() > 8 ) )
 248             {
 249                 BitmapColor aCol;
 250                 BitmapColor     aMskWhite( pMskAcc->GetBestMatchingColor( Color( COL_WHITE ) ) );
 251
 252                 for( long nY = nStartY; nY <= nEndY; nY++ )
 253                 {
 254                     const BYTE* pTmp = pData + ( nY - nStartY ) * nScanSize + nOffset;
 255
 256                     for( long nX = nStartX; nX <= nEndX; nX++ )
 257                     {
 258                         const Color& rCol = mpMapper->ImplGetColor( *pTmp++ );
 259
 260                         // 0: Transparent; >0: Non-Transparent
 261                         if( !rCol.GetTransparency() )
 262                         {
 263                             pMskAcc->SetPixel( nY, nX, aMskWhite );
 264                             mbTrans = TRUE;
 265                         }
 266                         else
 267                         {
 268                             aCol.SetRed( rCol.GetRed() );
 269                             aCol.SetGreen( rCol.GetGreen() );
 270                             aCol.SetBlue( rCol.GetBlue() );
 271                             pBmpAcc->SetPixel( nY, nX, aCol );
 272                         }
 273                     }
 274                 }
 275
 276                 bDataChanged = sal_True;
 277             }
 278             else if( mpPal && ( pBmpAcc->GetBitCount() <= 8 ) )
 279             {
 280                 BitmapColor aIndex( (BYTE) 0 );
 281                 BitmapColor     aMskWhite( pMskAcc->GetBestMatchingColor( Color( COL_WHITE ) ) );
 282
 283                 for( long nY = nStartY; nY <= nEndY; nY++ )
 284                 {
 285                     const BYTE* pTmp = pData + ( nY - nStartY ) * nScanSize + nOffset;
 286
 287                     for( long nX = nStartX; nX <= nEndX; nX++ )
 288                     {
 289                         const BYTE              cIndex = *pTmp++;
 290                         const Color&    rCol = mpPal[ cIndex ];
 291
 292                         // 0: Transparent; >0: Non-Transparent
 293                         if( !rCol.GetTransparency() )
 294                         {
 295                             pMskAcc->SetPixel( nY, nX, aMskWhite );
 296                             mbTrans = TRUE;
 297                         }
 298                         else
 299                         {
 300                             aIndex.SetIndex( cIndex );
 301                             pBmpAcc->SetPixel( nY, nX, aIndex );
 302                         }
 303                     }
 304                 }
 305
 306                 bDataChanged = sal_True;
 307             }
 308             else if( mpPal && ( pBmpAcc->GetBitCount() > 8 ) )
 309             {
 310                 BitmapColor aCol;
 311                 BitmapColor     aMskWhite( pMskAcc->GetBestMatchingColor( Color( COL_WHITE ) ) );
 312
 313                 for( long nY = nStartY; nY <= nEndY; nY++ )
 314                 {
 315                     const BYTE* pTmp = pData + ( nY - nStartY ) * nScanSize + nOffset;
 316
 317                     for( long nX = nStartX; nX <= nEndX; nX++ )
 318                     {
 319                         const BYTE              cIndex = *pTmp++;
 320                         const Color&    rCol = mpPal[ cIndex ];
 321
 322                         // 0: Transparent; >0: Non-Transparent
 323                         if( !rCol.GetTransparency() )
 324                         {
 325                             pMskAcc->SetPixel( nY, nX, aMskWhite );
 326                             mbTrans = TRUE;
 327                         }
 328                         else
 329                         {
 330                             aCol.SetRed( rCol.GetRed() );
 331                             aCol.SetGreen( rCol.GetGreen() );
 332                             aCol.SetBlue( rCol.GetBlue() );
 333                             pBmpAcc->SetPixel( nY, nX, aCol );
 334                         }
 335                     }
 336                 }
 337
 338                 bDataChanged = sal_True;
 339             }
 340             else
 341             {
 342                 DBG_ERROR( "Producer format error!" );
 343                 maChangedRect.SetEmpty();
 344             }
 345         }
 346     }
 347     else
 348         maChangedRect.SetEmpty();
 349
 350     maBitmap.ReleaseAccess( pBmpAcc );
 351     maMask.ReleaseAccess( pMskAcc );
 352
 353     if( bDataChanged )
 354         DataChanged();
 355 }
 356
 357 // -----------------------------------------------------------------------------
 358
 359 void ImageConsumer::SetPixelsByLongs( sal_uInt32 nConsX, sal_uInt32 nConsY,
 360                                       sal_uInt32 nConsWidth, sal_uInt32 nConsHeight,
 361                                       const sal_uInt32* pData, sal_uInt32 nOffset, sal_uInt32 nScanSize )
 362 {
 363     DBG_ASSERT( !!maBitmap && !!maMask, "Missing call to ImageConsumer::SetColorModel(...)!" );
 364
 365     BitmapWriteAccess*  pBmpAcc = maBitmap.AcquireWriteAccess();
 366     BitmapWriteAccess*  pMskAcc = maMask.AcquireWriteAccess();
 367     sal_Bool                    bDataChanged = sal_False;
 368
 369     if( pBmpAcc && pMskAcc )
 370     {
 371         const long      nWidth = pBmpAcc->Width();
 372         const long      nHeight = pBmpAcc->Height();
 373
 374         maChangedRect = Rectangle( Point(), Size( nWidth, nHeight ) );
 375         maChangedRect.Intersection( Rectangle( Point( nConsX, nConsY ), Size( nConsWidth, nConsHeight ) ) );
 376
 377         if( !maChangedRect.IsEmpty() )
 378         {
 379             const long nStartX = maChangedRect.Left();
 380             const long nEndX = maChangedRect.Right();
 381             const long nStartY = maChangedRect.Top();
 382             const long nEndY = maChangedRect.Bottom();
 383
 384             if( mpMapper && ( pBmpAcc->GetBitCount() > 8 ) )
 385             {
 386                 BitmapColor aCol;
 387                 BitmapColor     aMskWhite( pMskAcc->GetBestMatchingColor( Color( COL_WHITE ) ) );
 388
 389                 for( long nY = nStartY; nY <= nEndY; nY++ )
 390                 {
 391                     const sal_Int32* pTmp = (sal_Int32*) pData + ( nY - nStartY ) * nScanSize + nOffset;
 392
 393                     for( long nX = nStartX; nX <= nEndX; nX++ )
 394                     {
 395                         const Color& rCol = mpMapper->ImplGetColor( *pTmp++ );
 396
 397                         // 0: Transparent; >0: Non-Transparent
 398                         if( !rCol.GetTransparency() )
 399                         {
 400                             pMskAcc->SetPixel( nY, nX, aMskWhite );
 401                             mbTrans = TRUE;
 402                         }
 403                         else
 404                         {
 405                             aCol.SetRed( rCol.GetRed() );
 406                             aCol.SetGreen( rCol.GetGreen() );
 407                             aCol.SetBlue( rCol.GetBlue() );
 408                             pBmpAcc->SetPixel( nY, nX, aCol );
 409                         }
 410                     }
 411                 }
 412
 413                 bDataChanged = sal_True;
 414             }
 415             else if( mpPal && ( pBmpAcc->GetBitCount() <= 8 ) )
 416             {
 417                 BitmapColor aIndex( (BYTE) 0 );
 418                 BitmapColor     aMskWhite( pMskAcc->GetBestMatchingColor( Color( COL_WHITE ) ) );
 419
 420                 for( long nY = nStartY; nY <= nEndY; nY++ )
 421                 {
 422                     const sal_Int32* pTmp = (sal_Int32*) pData + ( nY - nStartY ) * nScanSize + nOffset;
 423
 424                     for( long nX = nStartX; nX <= nEndX; nX++ )
 425                     {
 426                         const sal_Int32 nIndex = *pTmp++;
 427                         const Color&    rCol = mpPal[ nIndex ];
 428
 429                         // 0: Transparent; >0: Non-Transparent
 430                         if( !rCol.GetTransparency() )
 431                         {
 432                             pMskAcc->SetPixel( nY, nX, aMskWhite );
 433                             mbTrans = TRUE;
 434                         }
 435                         else
 436                         {
 437                             aIndex.SetIndex( (BYTE) nIndex );
 438                             pBmpAcc->SetPixel( nY, nX, aIndex );
 439                         }
 440                     }
 441                 }
 442
 443                 bDataChanged = sal_True;
 444             }
 445             else if( mpPal && ( pBmpAcc->GetBitCount() > 8 ) )
 446             {
 447                 BitmapColor aCol;
 448                 BitmapColor     aMskWhite( pMskAcc->GetBestMatchingColor( Color( COL_WHITE ) ) );
 449
 450                 for( long nY = nStartY; nY <= nEndY; nY++ )
 451                 {
 452                     const sal_Int32* pTmp = (sal_Int32*) pData + ( nY - nStartY ) * nScanSize + nOffset;
 453
 454                     for( long nX = nStartX; nX <= nEndX; nX++ )
 455                     {
 456                         const sal_Int32 nIndex = *pTmp++;
 457                         const Color&    rCol = mpPal[ nIndex ];
 458
 459                         // 0: Transparent; >0: Non-Transparent
 460                         if( !rCol.GetTransparency() )
 461                         {
 462                             pMskAcc->SetPixel( nY, nX, aMskWhite );
 463                             mbTrans = TRUE;
 464                         }
 465                         else
 466                         {
 467                             aCol.SetRed( rCol.GetRed() );
 468                             aCol.SetGreen( rCol.GetGreen() );
 469                             aCol.SetBlue( rCol.GetBlue() );
 470                             pBmpAcc->SetPixel( nY, nX, aCol );
 471                         }
 472                     }
 473                 }
 474
 475                 bDataChanged = sal_True;
 476             }
 477             else
 478             {
 479                 DBG_ERROR( "Producer format error!" );
 480                 maChangedRect.SetEmpty();
 481             }
 482         }
 483     }
 484     else
 485         maChangedRect.SetEmpty();
 486
 487     maBitmap.ReleaseAccess( pBmpAcc );
 488     maMask.ReleaseAccess( pMskAcc );
 489
 490     if( bDataChanged )
 491         DataChanged();
 492 }
 493
 494 // -----------------------------------------------------------------------------
 495
 496 void ImageConsumer::Completed( sal_uInt32 nStatus /*, ImageProducer& rProducer */ )
 497 {
 498     delete mpMapper;
 499     mpMapper = NULL;
 500     delete[] mpPal;
 501     mpPal = NULL;
 502     maSize = Size();
 503     mnStatus = nStatus;
 504
 505     switch( nStatus )
 506     {
 507         case( SINGLEFRAMEDONE ):
 508         case( STATICIMAGEDONE ):
 509         {
 510             if( !mbTrans )
 511                 maMask = Bitmap();
 512         }
 513         break;
 514
 515         case( IMAGEERROR ):
 516         case( IMAGEABORTED ):
 517             maBitmap = maMask = Bitmap();
 518         break;
 519
 520         default:
 521         break;
 522     }
 523
 524 //      rProducer.RemoveConsumer( *this );
 525
 526     if( maDoneLink.IsSet() )
 527         maDoneLink.Call( this );
 528 }
 529
 530 // -----------------------------------------------------------------------------
 531
 532 void ImageConsumer::DataChanged()
 533 {
 534     if( maChgLink.IsSet() )
 535         maChgLink.Call( this );
 536 }
 537
 538 // -----------------------------------------------------------------------------
 539
 540 sal_uInt32 ImageConsumer::GetStatus() const
 541 {
 542     return mnStatus;
 543 }
 544
 545 // -----------------------------------------------------------------------------
 546
 547 BOOL ImageConsumer::GetData( BitmapEx& rBmpEx ) const
 548 {
 549     const BOOL bRet = ( SINGLEFRAMEDONE == mnStatus || STATICIMAGEDONE == mnStatus );
 550
 551     if( bRet )
 552     {
 553         if( !!maMask )
 554             rBmpEx = BitmapEx( maBitmap, maMask );
 555         else
 556             rBmpEx = BitmapEx( maBitmap );
 557     }
 558
 559     return bRet;
 560 }
 561
 562 // -----------------------------------------------------------------------------
 563
 564 BOOL ImageConsumer::GetData( Image& rImage ) const
 565 {
 566     const BOOL bRet = ( SINGLEFRAMEDONE == mnStatus || STATICIMAGEDONE == mnStatus );
 567
 568     if( bRet )
 569     {
 570         if( !!maMask )
 571             rImage = Image( maBitmap, maMask );
 572         else
 573             rImage = Image( maBitmap );
 574     }
 575
 576     return bRet;
 577 }