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