forms/source/component/imgprod.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: imgprod.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_forms.hxx"
  33
  34 #include "imgprod.hxx"
  35
  36 #include <vcl/bmpacc.hxx>
  37 #include <vcl/cvtgrf.hxx>
  38 #include <vcl/svapp.hxx>
  39 #include <unotools/ucbstreamhelper.hxx>
  40 #include <svtools/filter.hxx>
  41 #include <com/sun/star/io/XInputStream.hpp>
  42
  43 #ifndef SVTOOLS_SOURCE_MISC_IMAGERESOURCEACCESS_HXX
  44 #include "svtools/imageresourceaccess.hxx"
  45 #endif
  46 #include <comphelper/processfactory.hxx>
  47
  48 // --------------------
  49 // - ImgProdLockBytes -
  50 // --------------------
  51
  52 class ImgProdLockBytes : public SvLockBytes
  53 {
  54     ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream >              xStmRef;
  55     ::com::sun::star::uno::Sequence<sal_Int8>           maSeq;
  56
  57                         ImgProdLockBytes() {};
  58
  59 public:
  60
  61                         ImgProdLockBytes( SvStream* pStm, sal_Bool bOwner );
  62                         ImgProdLockBytes( ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream > & rStreamRef );
  63     virtual                             ~ImgProdLockBytes();
  64
  65     virtual ErrCode             ReadAt( sal_Size nPos, void* pBuffer, sal_Size nCount, sal_Size* pRead ) const;
  66     virtual ErrCode             WriteAt( sal_Size nPos, const void* pBuffer, sal_Size nCount, sal_Size* pWritten );
  67     virtual ErrCode             Flush() const;
  68     virtual ErrCode             SetSize( sal_Size nSize );
  69     virtual ErrCode             Stat( SvLockBytesStat*, SvLockBytesStatFlag ) const;
  70 };
  71
  72 // ------------------------------------------------------------------------
  73
  74 ImgProdLockBytes::ImgProdLockBytes( SvStream* pStm, sal_Bool bOwner ) :
  75         SvLockBytes( pStm, bOwner )
  76 {
  77 }
  78
  79 // ------------------------------------------------------------------------
  80
  81 ImgProdLockBytes::ImgProdLockBytes( ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream > & rStmRef ) :
  82         xStmRef( rStmRef )
  83 {
  84     if( xStmRef.is() )
  85     {
  86         const sal_uInt32        nBytesToRead = 65535;
  87         sal_uInt32                      nRead;
  88
  89         do
  90         {
  91             ::com::sun::star::uno::Sequence< sal_Int8 > aReadSeq;
  92
  93             nRead = xStmRef->readSomeBytes( aReadSeq, nBytesToRead );
  94
  95             if( nRead )
  96             {
  97                 const sal_uInt32 nOldLength = maSeq.getLength();
  98                 maSeq.realloc( nOldLength + nRead );
  99                 rtl_copyMemory( maSeq.getArray() + nOldLength, aReadSeq.getConstArray(), aReadSeq.getLength() );
 100             }
 101         }
 102         while( nBytesToRead == nRead );
 103     }
 104 }
 105
 106 // ------------------------------------------------------------------------
 107
 108 ImgProdLockBytes::~ImgProdLockBytes()
 109 {
 110 }
 111
 112 // ------------------------------------------------------------------------
 113
 114 ErrCode ImgProdLockBytes::ReadAt( sal_Size nPos, void* pBuffer, sal_Size nCount, sal_Size* pRead ) const
 115 {
 116     if( GetStream() )
 117     {
 118         ( (SvStream*) GetStream() )->ResetError();
 119         const ErrCode nErr = SvLockBytes::ReadAt( nPos, pBuffer, nCount, pRead );
 120         ( (SvStream*) GetStream() )->ResetError();
 121         return nErr;
 122     }
 123     else
 124     {
 125         const sal_Size nSeqLen = maSeq.getLength();
 126         ErrCode nErr = ERRCODE_NONE;
 127
 128         if( nPos < nSeqLen )
 129         {
 130             if( ( nPos + nCount ) > nSeqLen )
 131                 nCount = nSeqLen - nPos;
 132
 133             memcpy( pBuffer, maSeq.getConstArray() + nPos, nCount );
 134             *pRead = nCount;
 135         }
 136         else
 137             *pRead = 0UL;
 138
 139         return nErr;
 140     }
 141 }
 142
 143 // ------------------------------------------------------------------------
 144
 145 ErrCode ImgProdLockBytes::WriteAt( sal_Size nPos, const void* pBuffer, sal_Size nCount, sal_Size* pWritten )
 146 {
 147     if( GetStream() )
 148         return SvLockBytes::WriteAt( nPos, pBuffer, nCount, pWritten );
 149     else
 150     {
 151         DBG_ASSERT( xStmRef.is(), "ImgProdLockBytes::WriteAt: xInputStream has no reference..." );
 152         return ERRCODE_IO_CANTWRITE;
 153     }
 154 }
 155
 156 // ------------------------------------------------------------------------
 157
 158 ErrCode ImgProdLockBytes::Flush() const
 159 {
 160     return ERRCODE_NONE;
 161 }
 162
 163 // ------------------------------------------------------------------------
 164
 165 ErrCode ImgProdLockBytes::SetSize( sal_Size nSize )
 166 {
 167     if( GetStream() )
 168         return SvLockBytes::SetSize( nSize );
 169     else
 170     {
 171         DBG_ERROR( "ImgProdLockBytes::SetSize not supported for xInputStream..." );
 172         return ERRCODE_IO_CANTWRITE;
 173     }
 174 }
 175
 176 // ------------------------------------------------------------------------
 177
 178 ErrCode ImgProdLockBytes::Stat( SvLockBytesStat* pStat, SvLockBytesStatFlag eFlag ) const
 179 {
 180     if( GetStream() )
 181         return SvLockBytes::Stat( pStat, eFlag );
 182     else
 183     {
 184         DBG_ASSERT( xStmRef.is(), "ImgProdLockBytes::Stat: xInputStream has no reference..." );
 185         pStat->nSize = maSeq.getLength();
 186         return ERRCODE_NONE;
 187     }
 188 }
 189
 190 // -----------------
 191 // - ImageProducer -
 192 // -----------------
 193
 194 ImageProducer::ImageProducer() :
 195     mpStm               ( NULL ),
 196     mpFilter    ( NULL ),
 197     mnStatus    ( 0UL ),
 198     mbConsInit  ( sal_False ),
 199     mnLastError ( 0UL ),
 200     mbAsync             ( sal_False )
 201 {
 202     mpGraphic = new Graphic;
 203     DBG_ASSERT( Application::GetFilterHdl().IsSet(), "ImageProducer::ImageProducer(): No filter handler set" );
 204 }
 205
 206 // ------------------------------------------------------------
 207
 208 ImageProducer::~ImageProducer()
 209 {
 210     delete mpGraphic;
 211     mpGraphic = NULL;
 212
 213     delete mpFilter;
 214     mpFilter = NULL;
 215
 216     delete mpStm;
 217     mpStm = NULL;
 218
 219     for( void* pCons = maConsList.First(); pCons; pCons = maConsList.Next() )
 220         delete (::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons;
 221 }
 222
 223 // ------------------------------------------------------------
 224
 225 // ::com::sun::star::uno::XInterface
 226 ::com::sun::star::uno::Any ImageProducer::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
 227 {
 228     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
 229                                         SAL_STATIC_CAST( ::com::sun::star::lang::XInitialization*, this ),
 230                                         SAL_STATIC_CAST( ::com::sun::star::awt::XImageProducer*, this ) );
 231     return (aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType ));
 232 }
 233
 234 // ------------------------------------------------------------
 235
 236 void ImageProducer::addConsumer( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer >& rxConsumer ) throw(::com::sun::star::uno::RuntimeException)
 237 {
 238     DBG_ASSERT( rxConsumer.is(), "::AddConsumer(...): No consumer referenced!" );
 239     if( rxConsumer.is() )
 240         maConsList.Insert( new ::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > ( rxConsumer ), LIST_APPEND );
 241 }
 242
 243 // ------------------------------------------------------------
 244
 245 void ImageProducer::removeConsumer( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer >& rxConsumer ) throw(::com::sun::star::uno::RuntimeException)
 246 {
 247     for( sal_uInt32 n = maConsList.Count(); n; )
 248     {
 249         ::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > * pRef = (::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) maConsList.GetObject( --n );
 250
 251         if( *pRef == rxConsumer )
 252         {
 253             delete pRef;
 254             maConsList.Remove( n );
 255             break;
 256         }
 257     }
 258 }
 259
 260 // ------------------------------------------------------------
 261
 262 void ImageProducer::SetImage( const ::rtl::OUString& rPath )
 263 {
 264     maURL = rPath;
 265     mpGraphic->Clear();
 266     mbConsInit = sal_False;
 267     mbAsync = sal_False;
 268     delete mpStm;
 269
 270     if ( ::svt::GraphicAccess::isSupportedURL( maURL ) )
 271     {
 272         mpStm = ::svt::GraphicAccess::getImageStream( ::comphelper::getProcessServiceFactory(), maURL );
 273     }
 274     else if( maURL.getLength() )
 275     {
 276         SvStream* pIStm = ::utl::UcbStreamHelper::CreateStream( maURL, STREAM_STD_READ );
 277         mpStm = pIStm ? new SvStream( new ImgProdLockBytes( pIStm, sal_True ) ) : NULL;
 278     }
 279     else
 280         mpStm = NULL;
 281 }
 282
 283 // ------------------------------------------------------------
 284
 285 void ImageProducer::SetImage( SvStream& rStm )
 286 {
 287     maURL = ::rtl::OUString();
 288     mpGraphic->Clear();
 289     mbConsInit = sal_False;
 290     mbAsync = sal_False;
 291
 292     delete mpStm;
 293     mpStm = new SvStream( new ImgProdLockBytes( &rStm, sal_False ) );
 294 }
 295
 296 // ------------------------------------------------------------
 297
 298 void ImageProducer::setImage( ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream > & rInputStmRef )
 299 {
 300     maURL = ::rtl::OUString();
 301     mpGraphic->Clear();
 302     mbConsInit = sal_False;
 303     mbAsync = sal_False;
 304     delete mpStm;
 305
 306     if( rInputStmRef.is() )
 307         mpStm = new SvStream( new ImgProdLockBytes( rInputStmRef ) );
 308     else
 309         mpStm = NULL;
 310 }
 311
 312 // ------------------------------------------------------------
 313
 314 void ImageProducer::NewDataAvailable()
 315 {
 316     if( ( GRAPHIC_NONE == mpGraphic->GetType() ) || mpGraphic->GetContext() )
 317         startProduction();
 318 }
 319
 320 // ------------------------------------------------------------
 321
 322 void ImageProducer::startProduction() throw(::com::sun::star::uno::RuntimeException)
 323 {
 324     ResetLastError();
 325
 326     if( maConsList.Count() )
 327     {
 328         bool bNotifyEmptyGraphics = false;
 329
 330         // valid stream or filled graphic? => update consumers
 331         if( mpStm || ( mpGraphic->GetType() != GRAPHIC_NONE ) )
 332         {
 333             // if we already have a graphic, we don't have to import again;
 334             // graphic is cleared if a new Stream is set
 335             if( ( mpGraphic->GetType() == GRAPHIC_NONE ) || mpGraphic->GetContext() )
 336             {
 337                 if( !ImplImportGraphic( *mpGraphic ) && maErrorHdl.IsSet() )
 338                     maErrorHdl.Call( this );
 339             }
 340
 341             if( mpGraphic->GetType() != GRAPHIC_NONE )
 342                 ImplUpdateData( *mpGraphic );
 343             else
 344                 bNotifyEmptyGraphics = true;
 345         }
 346         else
 347             bNotifyEmptyGraphics = true;
 348
 349         if ( bNotifyEmptyGraphics )
 350         {
 351             // reset image
 352             List        aTmp;
 353             void*       pCons;
 354
 355             // create temporary list to hold interfaces
 356             for( pCons = maConsList.First(); pCons; pCons = maConsList.Next() )
 357                 aTmp.Insert( new ::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons ), LIST_APPEND );
 358
 359             // iterate through interfaces
 360             for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() )
 361             {
 362                 ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->init( 0, 0 );
 363                 ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->complete( ::com::sun::star::awt::ImageStatus::IMAGESTATUS_STATICIMAGEDONE, this );
 364             }
 365
 366             // delete interfaces in temporary list
 367             for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() )
 368                 delete (::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons;
 369         }
 370     }
 371 }
 372
 373 // ------------------------------------------------------------
 374
 375 sal_Bool ImageProducer::ImplImportGraphic( Graphic& rGraphic )
 376 {
 377     USHORT      nFilter = GRFILTER_FORMAT_DONTKNOW;
 378     short       nRet;
 379     sal_Bool    bRet = sal_False;
 380
 381     if( ERRCODE_IO_PENDING == mpStm->GetError() )
 382         mpStm->ResetError();
 383
 384     mpStm->Seek( 0UL );
 385
 386     if( mpFilter )
 387         nRet = mpFilter->ImportGraphic( rGraphic, String(), *mpStm, nFilter );
 388     else
 389     {
 390         if( GraphicConverter::Import( *mpStm, rGraphic ) == ERRCODE_NONE )
 391             nRet = GRFILTER_OK;
 392         else
 393             nRet = GRFILTER_FILTERERROR;
 394     }
 395
 396     if( ERRCODE_IO_PENDING == mpStm->GetError() )
 397         mpStm->ResetError();
 398
 399     if( nRet == GRFILTER_OK )
 400         bRet = sal_True;
 401     else
 402         mnLastError = nRet;
 403
 404     return bRet;
 405 }
 406
 407 // ------------------------------------------------------------
 408
 409 void ImageProducer::ImplUpdateData( const Graphic& rGraphic )
 410 {
 411     // asynchronous?
 412     if( mpGraphic->GetContext() )
 413         mbAsync = sal_True;
 414
 415     ImplInitConsumer( rGraphic );
 416
 417     if( mbConsInit && maConsList.Count() )
 418     {
 419         List    aTmp;
 420         void*   pCons;
 421
 422         ImplUpdateConsumer( rGraphic );
 423         mbConsInit = sal_False;
 424
 425         // create temporary list to hold interfaces
 426         for( pCons = maConsList.First(); pCons; pCons = maConsList.Next() )
 427             aTmp.Insert( new ::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons ), LIST_APPEND );
 428
 429         // iterate through interfaces
 430         for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() )
 431             ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->complete( mnStatus = ::com::sun::star::awt::ImageStatus::IMAGESTATUS_STATICIMAGEDONE, this );
 432
 433         // delete interfaces in temporary list
 434         for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() )
 435             delete (::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons;
 436     }
 437 }
 438
 439 // ------------------------------------------------------------
 440
 441 void ImageProducer::ImplInitConsumer( const Graphic& rGraphic )
 442 {
 443     Bitmap                              aBmp( rGraphic.GetBitmapEx().GetBitmap() );
 444     BitmapReadAccess*   pBmpAcc = aBmp.AcquireReadAccess();
 445
 446     if( pBmpAcc )
 447     {
 448         List             aTmp;
 449         void *           pCons;
 450         sal_uInt16       nPalCount = 0;
 451         sal_uInt32       nRMask = 0;
 452         sal_uInt32       nGMask = 0;
 453         sal_uInt32       nBMask = 0;
 454         sal_uInt32       nAMask = 0;
 455         ::com::sun::star::uno::Sequence< sal_Int32 >    aRGBPal;
 456
 457         if( pBmpAcc->HasPalette() )
 458         {
 459             nPalCount = pBmpAcc->GetPaletteEntryCount();
 460
 461             if( nPalCount )
 462             {
 463                 aRGBPal = ::com::sun::star::uno::Sequence< sal_Int32 >( nPalCount + 1 );
 464
 465                 sal_Int32* pTmp = aRGBPal.getArray();
 466
 467                 for( sal_uInt32 i = 0; i < nPalCount; i++, pTmp++ )
 468                 {
 469                     const BitmapColor& rCol = pBmpAcc->GetPaletteColor( (sal_uInt16) i );
 470
 471                     *pTmp = ( (sal_Int32) rCol.GetRed() ) << (sal_Int32)(24L);
 472                     *pTmp |= ( (sal_Int32) rCol.GetGreen() ) << (sal_Int32)(16L);
 473                     *pTmp |= ( (sal_Int32) rCol.GetBlue() ) << (sal_Int32)(8L);
 474                     *pTmp |= (sal_Int32)(0x000000ffL);
 475                 }
 476
 477                 if( rGraphic.IsTransparent() )
 478                 {
 479                     // append transparent entry
 480                     *pTmp = (sal_Int32)(0xffffff00L);
 481                     mnTransIndex = nPalCount;
 482                     nPalCount++;
 483                 }
 484                 else
 485                     mnTransIndex = 0;
 486
 487             }
 488         }
 489         else
 490         {
 491             nRMask = 0xff000000UL;
 492             nGMask = 0x00ff0000UL;
 493             nBMask = 0x0000ff00UL;
 494             nAMask = 0x000000ffUL;
 495         }
 496
 497         // create temporary list to hold interfaces
 498         for( pCons = maConsList.First(); pCons; pCons = maConsList.Next() )
 499             aTmp.Insert( new ::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons ), LIST_APPEND );
 500
 501         // iterate through interfaces
 502         for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() )
 503         {
 504             ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->init( pBmpAcc->Width(), pBmpAcc->Height() );
 505             ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->setColorModel( pBmpAcc->GetBitCount(),
 506                                                        aRGBPal, nRMask, nGMask, nBMask, nAMask );
 507         }
 508
 509         // delete interfaces in temporary list
 510         for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() )
 511             delete (::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons;
 512
 513         aBmp.ReleaseAccess( pBmpAcc );
 514         mbConsInit = sal_True;
 515     }
 516 }
 517
 518 // ------------------------------------------------------------
 519
 520 void ImageProducer::ImplUpdateConsumer( const Graphic& rGraphic )
 521 {
 522     BitmapEx                    aBmpEx( rGraphic.GetBitmapEx() );
 523     Bitmap                              aBmp( aBmpEx.GetBitmap() );
 524     BitmapReadAccess*   pBmpAcc = aBmp.AcquireReadAccess();
 525
 526     if( pBmpAcc )
 527     {
 528         List                            aTmp;
 529         void*                           pCons;
 530         Bitmap                          aMask( aBmpEx.GetMask() );
 531         BitmapReadAccess*       pMskAcc = !!aMask ? aMask.AcquireReadAccess() : NULL;
 532         const long                      nWidth = pBmpAcc->Width();
 533         const long                      nHeight = pBmpAcc->Height();
 534         const long                      nStartX = 0L;
 535         const long                      nEndX = nWidth - 1L;
 536         const long                      nStartY = 0L;
 537         const long                      nEndY = nHeight - 1L;
 538         const long                      nPartWidth = nEndX - nStartX + 1;
 539         const long                      nPartHeight = nEndY - nStartY + 1;
 540
 541         if( !pMskAcc )
 542         {
 543             aMask = Bitmap( aBmp.GetSizePixel(), 1 );
 544             aMask.Erase( COL_BLACK );
 545             pMskAcc = aMask.AcquireReadAccess();
 546         }
 547
 548         // create temporary list to hold interfaces
 549         for( pCons = maConsList.First(); pCons; pCons = maConsList.Next() )
 550             aTmp.Insert( new ::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons ), LIST_APPEND );
 551
 552         if( pBmpAcc->HasPalette() )
 553         {
 554             const BitmapColor aWhite( pMskAcc->GetBestMatchingColor( Color( COL_WHITE ) ) );
 555
 556             if( mnTransIndex < 256 )
 557             {
 558                 ::com::sun::star::uno::Sequence<sal_Int8>       aData( nPartWidth * nPartHeight );
 559                 sal_Int8*                                                                       pTmp = aData.getArray();
 560
 561                 for( long nY = nStartY; nY <= nEndY; nY++ )
 562                 {
 563                     for( long nX = nStartX; nX <= nEndX; nX++ )
 564                     {
 565                         if( pMskAcc->GetPixel( nY, nX ) == aWhite )
 566                             *pTmp++ = sal::static_int_cast< sal_Int8 >(
 567                                 mnTransIndex );
 568                         else
 569                             *pTmp++ = pBmpAcc->GetPixel( nY, nX ).GetIndex();
 570                     }
 571                 }
 572
 573                 // iterate through interfaces
 574                 for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() )
 575                     ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->setPixelsByBytes( nStartX, nStartY, nPartWidth, nPartHeight,
 576                                                                        aData, 0UL, nPartWidth );
 577             }
 578             else
 579             {
 580                 ::com::sun::star::uno::Sequence<sal_Int32>      aData( nPartWidth * nPartHeight );
 581                 sal_Int32*                                                                      pTmp = aData.getArray();
 582
 583                 for( long nY = nStartY; nY <= nEndY; nY++ )
 584                 {
 585                     for( long nX = nStartX; nX <= nEndX; nX++ )
 586                     {
 587                         if( pMskAcc->GetPixel( nY, nX ) == aWhite )
 588                             *pTmp++ = mnTransIndex;
 589                         else
 590                             *pTmp++ = pBmpAcc->GetPixel( nY, nX ).GetIndex();
 591                     }
 592                 }
 593
 594                 // iterate through interfaces
 595                 for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() )
 596                     ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->setPixelsByLongs( nStartX, nStartY, nPartWidth, nPartHeight,
 597                                                                        aData, 0UL, nPartWidth );
 598             }
 599         }
 600         else
 601         {
 602             ::com::sun::star::uno::Sequence<sal_Int32>  aData( nPartWidth * nPartHeight );
 603             const BitmapColor                                                   aWhite( pMskAcc->GetBestMatchingColor( Color( COL_WHITE ) ) );
 604             sal_Int32*                                                                  pTmp = aData.getArray();
 605
 606             for( long nY = nStartY; nY <= nEndY; nY++ )
 607             {
 608                 for( long nX = nStartX; nX <= nEndX; nX++, pTmp++ )
 609                 {
 610                     const BitmapColor aCol( pBmpAcc->GetPixel( nY, nX ) );
 611
 612                     *pTmp = ( (sal_Int32) aCol.GetRed() ) << (sal_Int32)(24L);
 613                     *pTmp |= ( (sal_Int32) aCol.GetGreen() ) << (sal_Int32)(16L);
 614                     *pTmp |= ( (sal_Int32) aCol.GetBlue() ) << (sal_Int32)(8L);
 615
 616                     if( pMskAcc->GetPixel( nY, nX ) != aWhite )
 617                         *pTmp |= 0x000000ffUL;
 618                 }
 619             }
 620
 621             // iterate through interfaces
 622             for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() )
 623                 ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->setPixelsByLongs( nStartX, nStartY, nPartWidth, nPartHeight,
 624                                                                    aData, 0UL, nPartWidth );
 625         }
 626
 627         // delete interfaces in temporary list
 628         for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() )
 629             delete (::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons;
 630
 631         aBmp.ReleaseAccess( pBmpAcc );
 632         aMask.ReleaseAccess( pMskAcc );
 633     }
 634 }
 635
 636 void ImageProducer::initialize( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& aArguments ) throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException)
 637 {
 638     if ( aArguments.getLength() == 1 )
 639     {
 640         ::com::sun::star::uno::Any aArg = aArguments.getConstArray()[0];
 641         rtl::OUString aURL;
 642         if ( aArg >>= aURL )
 643         {
 644             SetImage( aURL );
 645         }
 646     }
 647 }
 648
 649 namespace frm
 650 {
 651 ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >
 652 SAL_CALL ImageProducer_CreateInstance(
 653     const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& )
 654 {
 655     return ::com::sun::star::uno::Reference < ::com::sun::star::uno::XInterface >(
 656         ( ::cppu::OWeakObject* ) new ImageProducer );
 657 }
 658 } // namespace frm