vcl/source/gdi/image.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: image.cxx,v $
  10  * $Revision: 1.35 $
  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 // MARKER(update_precomp.py): autogen include statement, do not remove
  31 #include "precompiled_vcl.hxx"
  32
  33 #include <boost/scoped_ptr.hpp>
  34 #include <boost/scoped_array.hpp>
  35
  36 #include <rtl/logfile.hxx>
  37 #include <tools/debug.hxx>
  38 #include <tools/stream.hxx>
  39 #ifndef _SV_RC_H
  40 #include <tools/rc.h>
  41 #endif
  42 #include <tools/rc.hxx>
  43 #ifndef _SV_RESMGR_HXX
  44 #include <tools/resmgr.hxx>
  45 #endif
  46 #include <vcl/settings.hxx>
  47 #include <vcl/outdev.hxx>
  48 #include <vcl/graph.hxx>
  49 #include <vcl/svapp.hxx>
  50 #ifndef _SV_IMPIMAGETREE_H
  51 #include <vcl/impimagetree.hxx>
  52 #endif
  53 #include <vcl/image.h>
  54 #include <vcl/image.hxx>
  55
  56 DBG_NAME( Image )
  57 DBG_NAME( ImageList )
  58
  59 #define IMAGE_FILE_VERSION 100
  60
  61 using namespace ::com::sun::star;
  62
  63 // ---------
  64 // - Image -
  65 // ---------
  66
  67 Image::Image() :
  68     mpImplData( NULL )
  69 {
  70     DBG_CTOR( Image, NULL );
  71 }
  72
  73 // -----------------------------------------------------------------------
  74
  75 Image::Image( const ResId& rResId ) :
  76     mpImplData( NULL )
  77 {
  78     DBG_CTOR( Image, NULL );
  79
  80     rResId.SetRT( RSC_IMAGE );
  81
  82     ResMgr* pResMgr = rResId.GetResMgr();
  83     if( pResMgr && pResMgr->GetResource( rResId ) )
  84     {
  85         pResMgr->Increment( sizeof( RSHEADER_TYPE ) );
  86
  87         BitmapEx        aBmpEx;
  88         ULONG           nObjMask = pResMgr->ReadLong();
  89
  90         if( nObjMask & RSC_IMAGE_IMAGEBITMAP )
  91         {
  92             aBmpEx = BitmapEx( ResId( (RSHEADER_TYPE*)pResMgr->GetClass(), *pResMgr ) );
  93             pResMgr->Increment( pResMgr->GetObjSize( (RSHEADER_TYPE*)pResMgr->GetClass() ) );
  94         }
  95
  96         if( nObjMask & RSC_IMAGE_MASKBITMAP )
  97         {
  98             if( !aBmpEx.IsEmpty() && aBmpEx.GetTransparentType() == TRANSPARENT_NONE )
  99             {
 100                 const Bitmap aMaskBitmap( ResId( (RSHEADER_TYPE*)pResMgr->GetClass(), *pResMgr ) );
 101                 aBmpEx = BitmapEx( aBmpEx.GetBitmap(), aMaskBitmap );
 102             }
 103
 104             pResMgr->Increment( pResMgr->GetObjSize( (RSHEADER_TYPE*)pResMgr->GetClass() ) );
 105         }
 106
 107         if( nObjMask & RSC_IMAGE_MASKCOLOR )
 108         {
 109             if( !aBmpEx.IsEmpty() && aBmpEx.GetTransparentType() == TRANSPARENT_NONE )
 110             {
 111                 const Color aMaskColor( ResId( (RSHEADER_TYPE*)pResMgr->GetClass(), *pResMgr ) );
 112                 aBmpEx = BitmapEx( aBmpEx.GetBitmap(), aMaskColor );
 113             }
 114
 115             pResMgr->Increment( pResMgr->GetObjSize( (RSHEADER_TYPE*)pResMgr->GetClass() ) );
 116         }
 117         if( ! aBmpEx.IsEmpty() )
 118             ImplInit( aBmpEx );
 119     }
 120 }
 121
 122 // -----------------------------------------------------------------------
 123
 124 Image::Image( const Image& rImage ) :
 125     mpImplData( rImage.mpImplData )
 126 {
 127     DBG_CTOR( Image, NULL );
 128
 129     if( mpImplData )
 130         ++mpImplData->mnRefCount;
 131 }
 132
 133 // -----------------------------------------------------------------------
 134
 135 Image::Image( const BitmapEx& rBitmapEx ) :
 136     mpImplData( NULL )
 137 {
 138     DBG_CTOR( Image, NULL );
 139
 140     ImplInit( rBitmapEx );
 141 }
 142
 143 // -----------------------------------------------------------------------
 144
 145 Image::Image( const Bitmap& rBitmap ) :
 146     mpImplData( NULL )
 147 {
 148     DBG_CTOR( Image, NULL );
 149
 150     ImplInit( rBitmap );
 151 }
 152
 153 // -----------------------------------------------------------------------
 154
 155 Image::Image( const Bitmap& rBitmap, const Bitmap& rMaskBitmap ) :
 156     mpImplData( NULL )
 157 {
 158     DBG_CTOR( Image, NULL );
 159
 160     const BitmapEx aBmpEx( rBitmap, rMaskBitmap );
 161
 162     ImplInit( aBmpEx );
 163 }
 164
 165 // -----------------------------------------------------------------------
 166
 167 Image::Image( const Bitmap& rBitmap, const Color& rColor ) :
 168     mpImplData( NULL )
 169 {
 170     DBG_CTOR( Image, NULL );
 171
 172     const BitmapEx aBmpEx( rBitmap, rColor );
 173
 174     ImplInit( aBmpEx );
 175 }
 176
 177 // -----------------------------------------------------------------------
 178
 179 Image::Image( const uno::Reference< graphic::XGraphic >& rxGraphic ) :
 180     mpImplData( NULL )
 181 {
 182     DBG_CTOR( Image, NULL );
 183
 184     const Graphic aGraphic( rxGraphic );
 185     ImplInit( aGraphic.GetBitmapEx() );
 186 }
 187
 188 // -----------------------------------------------------------------------
 189
 190 Image::~Image()
 191 {
 192     DBG_DTOR( Image, NULL );
 193
 194     if( mpImplData && ( 0 == --mpImplData->mnRefCount ) )
 195         delete mpImplData;
 196 }
 197
 198 // -----------------------------------------------------------------------
 199
 200 void Image::ImplInit( const BitmapEx& rBmpEx )
 201 {
 202     if( !rBmpEx.IsEmpty() )
 203     {
 204         mpImplData = new ImplImage;
 205         mpImplData->mnRefCount = 1;
 206
 207         if( rBmpEx.GetTransparentType() == TRANSPARENT_NONE )
 208         {
 209             mpImplData->meType = IMAGETYPE_BITMAP;
 210             mpImplData->mpData = new Bitmap( rBmpEx.GetBitmap() );
 211         }
 212         else
 213         {
 214             mpImplData->meType = IMAGETYPE_IMAGE;
 215             mpImplData->mpData = new ImplImageData( rBmpEx );
 216         }
 217     }
 218 }
 219
 220 // -----------------------------------------------------------------------
 221
 222 Size Image::GetSizePixel() const
 223 {
 224     DBG_CHKTHIS( Image, NULL );
 225
 226     Size aRet;
 227
 228     if( mpImplData )
 229     {
 230         switch( mpImplData->meType )
 231         {
 232             case IMAGETYPE_BITMAP:
 233                 aRet = static_cast< Bitmap* >( mpImplData->mpData )->GetSizePixel();
 234             break;
 235
 236             case IMAGETYPE_IMAGE:
 237                 aRet = static_cast< ImplImageData* >( mpImplData->mpData )->maBmpEx.GetSizePixel();
 238             break;
 239         }
 240     }
 241
 242     return aRet;
 243 }
 244
 245 // -----------------------------------------------------------------------
 246
 247 BitmapEx Image::GetBitmapEx() const
 248 {
 249     DBG_CHKTHIS( Image, NULL );
 250
 251     BitmapEx aRet;
 252
 253     if( mpImplData )
 254     {
 255         switch( mpImplData->meType )
 256         {
 257             case IMAGETYPE_BITMAP:
 258                 aRet = *static_cast< Bitmap* >( mpImplData->mpData );
 259             break;
 260
 261             case IMAGETYPE_IMAGE:
 262                 aRet = static_cast< ImplImageData* >( mpImplData->mpData )->maBmpEx;
 263             break;
 264         }
 265     }
 266
 267     return aRet;
 268 }
 269
 270 // -----------------------------------------------------------------------
 271
 272 uno::Reference< graphic::XGraphic > Image::GetXGraphic() const
 273 {
 274     const Graphic aGraphic( GetBitmapEx() );
 275
 276     return aGraphic.GetXGraphic();
 277 }
 278
 279 // -----------------------------------------------------------------------
 280
 281 Image Image::GetColorTransformedImage( ImageColorTransform eColorTransform ) const
 282 {
 283     DBG_CHKTHIS( Image, NULL );
 284
 285     Image aRet;
 286
 287     if( IMAGECOLORTRANSFORM_HIGHCONTRAST == eColorTransform )
 288     {
 289         BitmapEx aBmpEx( GetBitmapEx() );
 290
 291         if( !aBmpEx.IsEmpty() )
 292         {
 293             Color*  pSrcColors = NULL;
 294             Color*  pDstColors = NULL;
 295             ULONG   nColorCount = 0;
 296
 297             Image::GetColorTransformArrays( eColorTransform, pSrcColors, pDstColors, nColorCount );
 298
 299             if( nColorCount && pSrcColors && pDstColors )
 300             {
 301                 aBmpEx.Replace( pSrcColors, pDstColors, nColorCount );
 302                 aRet = Image( aBmpEx );
 303             }
 304
 305             delete[] pSrcColors;
 306             delete[] pDstColors;
 307         }
 308     }
 309     else if( IMAGECOLORTRANSFORM_MONOCHROME_BLACK == eColorTransform ||
 310              IMAGECOLORTRANSFORM_MONOCHROME_WHITE == eColorTransform  )
 311     {
 312         BitmapEx aBmpEx( GetBitmapEx() );
 313
 314         if( !aBmpEx.IsEmpty() )
 315             aRet = Image( aBmpEx.GetColorTransformedBitmapEx( ( BmpColorMode )( eColorTransform ) ) );
 316     }
 317
 318     if( !aRet )
 319         aRet = *this;
 320
 321     return aRet;
 322 }
 323
 324 // -----------------------------------------------------------------------
 325
 326 void Image::Invert()
 327 {
 328     BitmapEx aInvertedBmp( GetBitmapEx() );
 329     aInvertedBmp.Invert();
 330     *this = aInvertedBmp;
 331 }
 332
 333 // -----------------------------------------------------------------------
 334
 335 void Image::GetColorTransformArrays( ImageColorTransform eColorTransform,
 336                                      Color*& rpSrcColor, Color*& rpDstColor, ULONG& rColorCount )
 337 {
 338     if( IMAGECOLORTRANSFORM_HIGHCONTRAST == eColorTransform )
 339     {
 340         rpSrcColor = new Color[ 4 ];
 341         rpDstColor = new Color[ 4 ];
 342         rColorCount = 4;
 343
 344         rpSrcColor[ 0 ] = Color( COL_BLACK );
 345         rpDstColor[ 0 ] = Color( COL_WHITE );
 346
 347         rpSrcColor[ 1 ] = Color( COL_WHITE );
 348         rpDstColor[ 1 ] = Color( COL_BLACK );
 349
 350         rpSrcColor[ 2 ] = Color( COL_BLUE );
 351         rpDstColor[ 2 ] = Color( COL_WHITE );
 352
 353         rpSrcColor[ 3 ] = Color( COL_LIGHTBLUE );
 354         rpDstColor[ 3 ] = Color( COL_WHITE );
 355     }
 356     else
 357     {
 358         rpSrcColor = rpDstColor = NULL;
 359         rColorCount = 0;
 360     }
 361 }
 362
 363 // -----------------------------------------------------------------------
 364
 365 Image& Image::operator=( const Image& rImage )
 366 {
 367     DBG_CHKTHIS( Image, NULL );
 368     DBG_CHKOBJ( &rImage, Image, NULL );
 369
 370     if( rImage.mpImplData )
 371         ++rImage.mpImplData->mnRefCount;
 372
 373     if( mpImplData && ( 0 == --mpImplData->mnRefCount ) )
 374         delete mpImplData;
 375
 376     mpImplData = rImage.mpImplData;
 377
 378     return *this;
 379 }
 380
 381 // -----------------------------------------------------------------------
 382
 383 BOOL Image::operator==( const Image& rImage ) const
 384 {
 385     DBG_CHKTHIS( Image, NULL );
 386     DBG_CHKOBJ( &rImage, Image, NULL );
 387
 388     bool bRet = false;
 389
 390     if( rImage.mpImplData == mpImplData )
 391         bRet = true;
 392     else if( !rImage.mpImplData || !mpImplData )
 393         bRet = false;
 394     else if( rImage.mpImplData->mpData == mpImplData->mpData )
 395         bRet = true;
 396     else if( rImage.mpImplData->meType == mpImplData->meType )
 397     {
 398         switch( mpImplData->meType )
 399         {
 400             case IMAGETYPE_BITMAP:
 401                 bRet = ( *static_cast< Bitmap* >( rImage.mpImplData->mpData ) == *static_cast< Bitmap* >( mpImplData->mpData ) );
 402             break;
 403
 404             case IMAGETYPE_IMAGE:
 405                 bRet = static_cast< ImplImageData* >( rImage.mpImplData->mpData )->IsEqual( *static_cast< ImplImageData* >( mpImplData->mpData ) );
 406             break;
 407
 408             default:
 409                 bRet = false;
 410             break;
 411         }
 412     }
 413
 414     return bRet;
 415 }
 416
 417 // -------------
 418 // - ImageList -
 419 // -------------
 420
 421 ImageList::ImageList( USHORT nInit, USHORT nGrow ) :
 422     mpImplData( NULL ),
 423     mnInitSize( nInit ),
 424     mnGrowSize( nGrow )
 425 {
 426     DBG_CTOR( ImageList, NULL );
 427 }
 428
 429 // -----------------------------------------------------------------------
 430
 431 ImageList::ImageList( const ResId& rResId ) :
 432     mpImplData( NULL ),
 433     mnInitSize( 1 ),
 434     mnGrowSize( 4 )
 435 {
 436     RTL_LOGFILE_CONTEXT( aLog, "vcl: ImageList::ImageList( const ResId& rResId )" );
 437
 438     DBG_CTOR( ImageList, NULL );
 439
 440     rResId.SetRT( RSC_IMAGELIST );
 441
 442     ResMgr* pResMgr = rResId.GetResMgr();
 443
 444     if( pResMgr && pResMgr->GetResource( rResId ) )
 445     {
 446         pResMgr->Increment( sizeof( RSHEADER_TYPE ) );
 447
 448         ULONG                                                           nObjMask = pResMgr->ReadLong();
 449         const String                                            aPrefix( pResMgr->ReadString() );
 450         ::boost::scoped_ptr< Color >        spMaskColor;
 451
 452         if( nObjMask & RSC_IMAGE_MASKCOLOR )
 453             spMaskColor.reset( new Color( ResId( (RSHEADER_TYPE*)pResMgr->GetClass(), *pResMgr ) ) );
 454
 455         pResMgr->Increment( pResMgr->GetObjSize( (RSHEADER_TYPE*)pResMgr->GetClass() ) );
 456
 457         if( nObjMask & RSC_IMAGELIST_IDLIST )
 458         {
 459             for( sal_Int32 i = 0, nCount = pResMgr->ReadLong(); i < nCount; ++i )
 460                 pResMgr->ReadLong();
 461         }
 462
 463         sal_Int32 nCount = pResMgr->ReadLong();
 464         ImplInit( static_cast< USHORT >( nCount ), Size() );
 465
 466         BitmapEx aEmpty;
 467         for( sal_Int32 i = 0; i < nCount; ++i )
 468         {
 469             rtl::OUString aName = pResMgr->ReadString();
 470             USHORT nId = static_cast< USHORT >( pResMgr->ReadLong() );
 471             mpImplData->AddImage( aName, nId, aEmpty );
 472         }
 473
 474         if( nObjMask & RSC_IMAGELIST_IDCOUNT )
 475             pResMgr->ReadShort();
 476     }
 477 }
 478
 479 // -----------------------------------------------------------------------
 480
 481 ImageList::ImageList( const ::std::vector< ::rtl::OUString >& rNameVector,
 482                       const ::rtl::OUString& rPrefix,
 483                       const Color* ) :
 484     mpImplData( NULL ),
 485     mnInitSize( 1 ),
 486     mnGrowSize( 4 )
 487 {
 488     RTL_LOGFILE_CONTEXT( aLog, "vcl: ImageList::ImageList(const vector< OUString >& ..." );
 489
 490     DBG_CTOR( ImageList, NULL );
 491
 492     ImplInit( sal::static_int_cast< USHORT >( rNameVector.size() ), Size() );
 493
 494     mpImplData->maPrefix = rPrefix;
 495     for( sal_uInt32 i = 0; i < rNameVector.size(); ++i )
 496     {
 497 //              fprintf (stderr, "List %p [%d]: '%s'\n",
 498 //                               this, i, rtl::OUStringToOString( rNameVector[i], RTL_TEXTENCODING_UTF8 ).getStr() );
 499         mpImplData->AddImage( rNameVector[ i ], static_cast< USHORT >( i ) + 1, BitmapEx() );
 500     }
 501 }
 502
 503 // -----------------------------------------------------------------------
 504
 505 ImageList::ImageList( const ImageList& rImageList ) :
 506     mpImplData( rImageList.mpImplData ),
 507     mnInitSize( rImageList.mnInitSize ),
 508     mnGrowSize( rImageList.mnGrowSize )
 509 {
 510     DBG_CTOR( ImageList, NULL );
 511
 512     if( mpImplData )
 513         ++mpImplData->mnRefCount;
 514 }
 515
 516 // -----------------------------------------------------------------------
 517
 518 ImageList::~ImageList()
 519 {
 520     DBG_DTOR( ImageList, NULL );
 521
 522     if( mpImplData && ( 0 == --mpImplData->mnRefCount ) )
 523         delete mpImplData;
 524 }
 525
 526 void ImageList::ImplInit( USHORT nItems, const Size &rSize )
 527 {
 528     mpImplData = new ImplImageList;
 529     mpImplData->mnRefCount = 1;
 530     mpImplData->maImages.reserve( nItems );
 531     mpImplData->maImageSize = rSize;
 532 }
 533
 534 // -----------------------------------------------------------------------
 535
 536 void ImageAryData::Load(const rtl::OUString &rPrefix)
 537 {
 538     static ImplImageTreeSingletonRef aImageTree;
 539
 540     ::rtl::OUString aSymbolsStyle = Application::GetSettings().GetStyleSettings().GetCurrentSymbolsStyleName();
 541
 542     BitmapEx aBmpEx;
 543
 544 //      fprintf (stderr, "Attempt load of '%s'\n",
 545 //                       rtl::OUStringToOString( maName, RTL_TEXTENCODING_UTF8 ).getStr() );
 546
 547     rtl::OUString aFileName = rPrefix;
 548     aFileName += maName;
 549 #ifdef DBG_UTIL
 550     bool bSuccess = aImageTree->loadImage( aFileName, aSymbolsStyle, maBitmapEx, true );
 551     DBG_ASSERT (bSuccess, "ImageAryData::Failed to load image");
 552 #else
 553     aImageTree->loadImage( aFileName, aSymbolsStyle, maBitmapEx, true );
 554 #endif
 555 }
 556
 557 // -----------------------------------------------------------------------
 558
 559 void ImageList::ImplMakeUnique()
 560 {
 561     if( mpImplData && mpImplData->mnRefCount > 1 )
 562     {
 563         --mpImplData->mnRefCount;
 564         mpImplData = new ImplImageList( *mpImplData ) ;
 565     }
 566 }
 567
 568 // -----------------------------------------------------------------------
 569 // Rather a performance hazard:
 570 BitmapEx ImageList::GetAsHorizontalStrip() const
 571 {
 572     Size aSize( mpImplData->maImageSize );
 573     USHORT nCount = GetImageCount();
 574     if( !nCount )
 575         return BitmapEx();
 576     aSize.Width() *= nCount;
 577
 578     // Load any stragglers
 579     for (USHORT nIdx = 0; nIdx < nCount; nIdx++)
 580     {
 581         ImageAryData *pData = mpImplData->maImages[ nIdx ];
 582         if( pData->IsLoadable() )
 583             pData->Load( mpImplData->maPrefix );
 584     }
 585
 586     BitmapEx aTempl = mpImplData->maImages[ 0 ]->maBitmapEx;
 587     BitmapEx aResult;
 588     Bitmap aPixels( aSize, aTempl.GetBitmap().GetBitCount() );
 589     if( aTempl.IsAlpha() )
 590         aResult = BitmapEx( aPixels, AlphaMask( aSize ) );
 591     else if( aTempl.IsTransparent() )
 592         aResult = BitmapEx( aPixels, Bitmap( aSize, aTempl.GetMask().GetBitCount() ) );
 593     else
 594         aResult = BitmapEx( aPixels );
 595
 596     Rectangle aSrcRect( Point( 0, 0 ), mpImplData->maImageSize );
 597     for (USHORT nIdx = 0; nIdx < nCount; nIdx++)
 598     {
 599         Rectangle aDestRect( Point( nIdx * mpImplData->maImageSize.Width(), 0 ),
 600                              mpImplData->maImageSize );
 601         ImageAryData *pData = mpImplData->maImages[ nIdx ];
 602         aResult.CopyPixel( aDestRect, aSrcRect, &pData->maBitmapEx);
 603     }
 604
 605     return aResult;
 606 }
 607
 608 // -----------------------------------------------------------------------
 609
 610 void ImageList::InsertFromHorizontalStrip( const BitmapEx &rBitmapEx,
 611                                            const std::vector< rtl::OUString > &rNameVector )
 612 {
 613     USHORT nItems = sal::static_int_cast< USHORT >( rNameVector.size() );
 614
 615 //      fprintf (stderr, "InsertFromHorizontalStrip (1) [%d items]\n", nItems);
 616
 617     if (!nItems)
 618             return;
 619
 620     Size aSize( rBitmapEx.GetSizePixel() );
 621     DBG_ASSERT (rBitmapEx.GetSizePixel().Width() % nItems == 0,
 622                 "ImageList::InsertFromHorizontalStrip - very odd size");
 623     aSize.Width() /= nItems;
 624     ImplInit( nItems, aSize );
 625
 626     for (USHORT nIdx = 0; nIdx < nItems; nIdx++)
 627     {
 628         BitmapEx aBitmap( rBitmapEx, Point( nIdx * aSize.Width(), 0 ), aSize );
 629         mpImplData->AddImage( rNameVector[ nIdx ], nIdx + 1, aBitmap );
 630     }
 631 }
 632
 633 // -----------------------------------------------------------------------
 634
 635 void ImageList::InsertFromHorizontalBitmap( const ResId& rResId,
 636                                             USHORT       nCount,
 637                                             const Color *pMaskColor,
 638                                             const Color *pSearchColors,
 639                                             const Color *pReplaceColors,
 640                                             ULONG        nColorCount)
 641 {
 642     BitmapEx aBmpEx( rResId );
 643     if (!aBmpEx.IsTransparent())
 644     {
 645         if( pMaskColor )
 646             aBmpEx = BitmapEx( aBmpEx.GetBitmap(), *pMaskColor );
 647         else
 648             aBmpEx = BitmapEx( aBmpEx.GetBitmap() );
 649     }
 650     if ( nColorCount && pSearchColors && pReplaceColors )
 651         aBmpEx.Replace( pSearchColors, pReplaceColors, nColorCount );
 652
 653     std::vector< rtl::OUString > aNames( nCount );
 654     InsertFromHorizontalStrip( aBmpEx, aNames );
 655 }
 656
 657 // -----------------------------------------------------------------------
 658
 659 USHORT ImageList::ImplGetImageId( const ::rtl::OUString& rImageName ) const
 660 {
 661     DBG_CHKTHIS( ImageList, NULL );
 662
 663     ImageAryData *pImg = mpImplData->maNameHash[ rImageName ];
 664     if( pImg )
 665         return pImg->mnId;
 666     else
 667         return 0;
 668 }
 669
 670 // -----------------------------------------------------------------------
 671
 672 void ImageList::AddImage( USHORT nId, const Image& rImage )
 673 {
 674     DBG_CHKTHIS( ImageList, NULL );
 675     DBG_CHKOBJ( &rImage, Image, NULL );
 676     DBG_ASSERT( nId, "ImageList::AddImage(): ImageId == 0" );
 677     DBG_ASSERT( GetImagePos( nId ) == IMAGELIST_IMAGE_NOTFOUND, "ImageList::AddImage() - ImageId already exists" );
 678     DBG_ASSERT( rImage.mpImplData, "ImageList::AddImage(): Wrong Size" );
 679     DBG_ASSERT( !mpImplData || (rImage.GetSizePixel() == mpImplData->maImageSize), "ImageList::AddImage(): Wrong Size" );
 680
 681     if( !mpImplData )
 682         ImplInit( 0, rImage.GetSizePixel() );
 683
 684     mpImplData->AddImage( rtl::OUString(), nId, rImage.GetBitmapEx());
 685 }
 686
 687 // -----------------------------------------------------------------------
 688
 689 void ImageList::AddImage( const ::rtl::OUString& rImageName, const Image& rImage )
 690 {
 691     DBG_ASSERT( GetImagePos( rImageName ) == IMAGELIST_IMAGE_NOTFOUND, "ImageList::AddImage() - ImageName already exists" );
 692
 693     if( !mpImplData )
 694         ImplInit( 0, rImage.GetSizePixel() );
 695
 696     mpImplData->AddImage( rImageName, GetImageCount() + 1,
 697                           rImage.GetBitmapEx() );
 698 }
 699
 700 // -----------------------------------------------------------------------
 701
 702 void ImageList::ReplaceImage( USHORT nId, const Image& rImage )
 703 {
 704     DBG_CHKTHIS( ImageList, NULL );
 705     DBG_CHKOBJ( &rImage, Image, NULL );
 706     DBG_ASSERT( GetImagePos( nId ) != IMAGELIST_IMAGE_NOTFOUND, "ImageList::ReplaceImage(): Unknown nId" );
 707
 708     RemoveImage( nId );
 709     AddImage( nId, rImage );
 710 }
 711
 712 // -----------------------------------------------------------------------
 713
 714 void ImageList::ReplaceImage( const ::rtl::OUString& rImageName, const Image& rImage )
 715 {
 716     const USHORT nId = ImplGetImageId( rImageName );
 717
 718     if( nId )
 719     {
 720         RemoveImage( nId );
 721
 722         if( !mpImplData )
 723             ImplInit( 0, rImage.GetSizePixel() );
 724         mpImplData->AddImage( rImageName, nId, rImage.GetBitmapEx());
 725     }
 726 }
 727
 728 // -----------------------------------------------------------------------
 729
 730 void ImageList::ReplaceImage( USHORT nId, USHORT nReplaceId )
 731 {
 732     DBG_CHKTHIS( ImageList, NULL );
 733     DBG_ASSERT( GetImagePos( nId ) != IMAGELIST_IMAGE_NOTFOUND, "ImageList::ReplaceImage(): Unknown nId" );
 734     DBG_ASSERT( GetImagePos( nReplaceId ) != IMAGELIST_IMAGE_NOTFOUND, "ImageList::ReplaceImage(): Unknown nReplaceId" );
 735
 736     ULONG nPosDest = GetImagePos( nId );
 737     ULONG nPosSrc = GetImagePos( nReplaceId );
 738     if( nPosDest != IMAGELIST_IMAGE_NOTFOUND &&
 739         nPosSrc != IMAGELIST_IMAGE_NOTFOUND )
 740     {
 741         ImplMakeUnique();
 742         mpImplData->maImages[nPosDest] = mpImplData->maImages[nPosSrc];
 743     }
 744 }
 745
 746 // -----------------------------------------------------------------------
 747
 748 void ImageList::ReplaceImage( const ::rtl::OUString& rImageName, const ::rtl::OUString& rReplaceName )
 749 {
 750     const USHORT nId1 = ImplGetImageId( rImageName ), nId2 = ImplGetImageId( rReplaceName );
 751
 752     if( nId1 && nId2 )
 753         ReplaceImage( nId1, nId2 );
 754 }
 755
 756 // -----------------------------------------------------------------------
 757
 758 void ImageList::RemoveImage( USHORT nId )
 759 {
 760     DBG_CHKTHIS( ImageList, NULL );
 761
 762     for( sal_uInt32 i = 0; i < mpImplData->maImages.size(); ++i )
 763     {
 764         if( mpImplData->maImages[ i ]->mnId == nId )
 765         {
 766             mpImplData->RemoveImage( static_cast< USHORT >( i ) );
 767             break;
 768         }
 769     }
 770 }
 771
 772 // -----------------------------------------------------------------------
 773
 774 void ImageList::RemoveImage( const ::rtl::OUString& rImageName )
 775 {
 776     const USHORT nId = ImplGetImageId( rImageName );
 777
 778     if( nId )
 779         RemoveImage( nId );
 780 }
 781
 782 // -----------------------------------------------------------------------
 783
 784 Image ImageList::GetImage( USHORT nId ) const
 785 {
 786     DBG_CHKTHIS( ImageList, NULL );
 787
 788 //      fprintf (stderr, "GetImage %d\n", nId);
 789
 790     Image aRet;
 791
 792     if( mpImplData )
 793     {
 794         std::vector<ImageAryData *>::iterator aIter;
 795         for( aIter = mpImplData->maImages.begin();
 796              aIter != mpImplData->maImages.end(); aIter++)
 797         {
 798             if ((*aIter)->mnId == nId)
 799             {
 800                 if( (*aIter)->IsLoadable() )
 801                     (*aIter)->Load( mpImplData->maPrefix );
 802
 803                 aRet = Image( (*aIter)->maBitmapEx );
 804             }
 805         }
 806     }
 807
 808     return aRet;
 809 }
 810
 811 // -----------------------------------------------------------------------
 812
 813 Image ImageList::GetImage( const ::rtl::OUString& rImageName ) const
 814 {
 815 //      fprintf (stderr, "GetImage '%s'\n",
 816 //                       rtl::OUStringToOString( rImageName, RTL_TEXTENCODING_UTF8 ).getStr() );
 817
 818     if( mpImplData )
 819     {
 820         ImageAryData *pImg = mpImplData->maNameHash[ rImageName ];
 821
 822         if( pImg )
 823         {
 824             if( pImg->IsLoadable() )
 825                 pImg->Load( mpImplData->maPrefix );
 826             return Image( pImg->maBitmapEx );
 827         }
 828     }
 829 //      fprintf (stderr, "no such image\n");
 830
 831     return Image();
 832 }
 833
 834 // -----------------------------------------------------------------------
 835
 836 void ImageList::Clear()
 837 {
 838     DBG_CHKTHIS( ImageList, NULL );
 839
 840     if( mpImplData && ( 0 == --mpImplData->mnRefCount ) )
 841         delete mpImplData;
 842
 843     mpImplData = NULL;
 844 }
 845
 846 // -----------------------------------------------------------------------
 847
 848 USHORT ImageList::GetImageCount() const
 849 {
 850     DBG_CHKTHIS( ImageList, NULL );
 851
 852     return mpImplData ? static_cast< USHORT >( mpImplData->maImages.size() ) : 0;
 853 }
 854
 855 // -----------------------------------------------------------------------
 856
 857 USHORT ImageList::GetImagePos( USHORT nId ) const
 858 {
 859     DBG_CHKTHIS( ImageList, NULL );
 860
 861     if( mpImplData && nId )
 862     {
 863         for( sal_uInt32 i = 0; i < mpImplData->maImages.size(); ++i )
 864         {
 865             if (mpImplData->maImages[ i ]->mnId == nId)
 866                 return static_cast< USHORT >( i );
 867         }
 868     }
 869
 870     return IMAGELIST_IMAGE_NOTFOUND;
 871 }
 872
 873 bool ImageList::HasImageAtPos( USHORT nId ) const
 874 {
 875     return GetImagePos( nId ) != IMAGELIST_IMAGE_NOTFOUND;
 876 }
 877
 878 // -----------------------------------------------------------------------
 879
 880 USHORT ImageList::GetImagePos( const ::rtl::OUString& rImageName ) const
 881 {
 882     DBG_CHKTHIS( ImageList, NULL );
 883
 884     if( mpImplData && rImageName.getLength() )
 885     {
 886         for( sal_uInt32 i = 0; i < mpImplData->maImages.size(); i++ )
 887         {
 888             if (mpImplData->maImages[i]->maName == rImageName)
 889                 return static_cast< USHORT >( i );
 890         }
 891     }
 892
 893     return IMAGELIST_IMAGE_NOTFOUND;
 894 }
 895
 896 // -----------------------------------------------------------------------
 897
 898 USHORT ImageList::GetImageId( USHORT nPos ) const
 899 {
 900     DBG_CHKTHIS( ImageList, NULL );
 901
 902     if( mpImplData && (nPos < GetImageCount()) )
 903         return mpImplData->maImages[ nPos ]->mnId;
 904
 905     return 0;
 906 }
 907
 908 // -----------------------------------------------------------------------
 909
 910 void ImageList::GetImageIds( ::std::vector< USHORT >& rIds ) const
 911 {
 912     RTL_LOGFILE_CONTEXT( aLog, "vcl: ImageList::GetImageIds" );
 913
 914     DBG_CHKTHIS( ImageList, NULL );
 915
 916     rIds = ::std::vector< USHORT >();
 917
 918     if( mpImplData )
 919     {
 920         for( sal_uInt32 i = 0; i < mpImplData->maImages.size(); i++ )
 921             rIds.push_back( mpImplData->maImages[i]->mnId );
 922     }
 923 }
 924
 925 // -----------------------------------------------------------------------
 926
 927 ::rtl::OUString ImageList::GetImageName( USHORT nPos ) const
 928 {
 929     DBG_CHKTHIS( ImageList, NULL );
 930
 931     if( mpImplData && (nPos < GetImageCount()) )
 932         return mpImplData->maImages[ nPos ]->maName;
 933
 934     return ::rtl::OUString();
 935 }
 936
 937 // -----------------------------------------------------------------------
 938
 939 void ImageList::GetImageNames( ::std::vector< ::rtl::OUString >& rNames ) const
 940 {
 941     RTL_LOGFILE_CONTEXT( aLog, "vcl: ImageList::GetImageNames" );
 942
 943     DBG_CHKTHIS( ImageList, NULL );
 944
 945     rNames = ::std::vector< ::rtl::OUString >();
 946
 947     if( mpImplData )
 948     {
 949         for( sal_uInt32 i = 0; i < mpImplData->maImages.size(); i++ )
 950         {
 951             const rtl::OUString& rName( mpImplData->maImages[ i ]->maName );
 952             if( rName.getLength() != 0 )
 953                 rNames.push_back( rName );
 954         }
 955     }
 956 }
 957
 958 // -----------------------------------------------------------------------
 959
 960 Size ImageList::GetImageSize() const
 961 {
 962     DBG_CHKTHIS( ImageList, NULL );
 963
 964     Size aRet;
 965
 966     if( mpImplData )
 967     {
 968         aRet = mpImplData->maImageSize;
 969
 970         // force load of 1st image to see - uncommon case.
 971         if( aRet.Width() == 0 && aRet.Height() == 0 &&
 972             !mpImplData->maImages.empty() )
 973         {
 974             Image aTmp = GetImage( mpImplData->maImages[ 0 ]->mnId );
 975             aRet = mpImplData->maImageSize = aTmp.GetSizePixel();
 976         }
 977     }
 978 //      fprintf (stderr, "GetImageSize returns %d, %d\n",
 979 //                       aRet.Width(), aRet.Height());
 980
 981     return aRet;
 982 }
 983
 984 // -----------------------------------------------------------------------
 985
 986 ImageList& ImageList::operator=( const ImageList& rImageList )
 987 {
 988     DBG_CHKTHIS( ImageList, NULL );
 989     DBG_CHKOBJ( &rImageList, ImageList, NULL );
 990
 991     if( rImageList.mpImplData )
 992         ++rImageList.mpImplData->mnRefCount;
 993
 994     if( mpImplData && ( 0 == --mpImplData->mnRefCount ) )
 995         delete mpImplData;
 996
 997     mpImplData = rImageList.mpImplData;
 998
 999     return *this;
1000 }
1001
1002 // -----------------------------------------------------------------------
1003
1004 BOOL ImageList::operator==( const ImageList& rImageList ) const
1005 {
1006     DBG_CHKTHIS( ImageList, NULL );
1007     DBG_CHKOBJ( &rImageList, ImageList, NULL );
1008
1009     bool bRet = false;
1010
1011     if( rImageList.mpImplData == mpImplData )
1012         bRet = true;
1013     else if( !rImageList.mpImplData || !mpImplData )
1014         bRet = false;
1015     else if( rImageList.GetImageCount() == GetImageCount() &&
1016               rImageList.mpImplData->maImageSize == mpImplData->maImageSize )
1017         bRet = true; // strange semantic
1018
1019     return bRet;
1020 }