| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_forms.hxx" | |
| #include "imgprod.hxx" | |
| #include <vcl/bmpacc.hxx> | |
| #include <vcl/cvtgrf.hxx> | |
| #include <vcl/svapp.hxx> | |
| #include <unotools/ucbstreamhelper.hxx> | |
| #include <svtools/filter.hxx> | |
| #include <com/sun/star/io/XInputStream.hpp> | |
| #ifndef SVTOOLS_SOURCE_MISC_IMAGERESOURCEACCESS_HXX | |
| #include "svtools/imageresourceaccess.hxx" | |
| #endif | |
| #include <comphelper/processfactory.hxx> | |
| // -------------------- | |
| // - ImgProdLockBytes - | |
| // -------------------- | |
| class ImgProdLockBytes : public SvLockBytes | |
| { | |
| ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream > xStmRef; | |
| ::com::sun::star::uno::Sequence<sal_Int8> maSeq; | |
| ImgProdLockBytes() {}; | |
| public: | |
| ImgProdLockBytes( SvStream* pStm, sal_Bool bOwner ); | |
| ImgProdLockBytes( ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream > & rStreamRef ); | |
| virtual ~ImgProdLockBytes(); | |
| virtual ErrCode ReadAt( sal_Size nPos, void* pBuffer, sal_Size nCount, sal_Size* pRead ) const; | |
| virtual ErrCode WriteAt( sal_Size nPos, const void* pBuffer, sal_Size nCount, sal_Size* pWritten ); | |
| virtual ErrCode Flush() const; | |
| virtual ErrCode SetSize( sal_Size nSize ); | |
| virtual ErrCode Stat( SvLockBytesStat*, SvLockBytesStatFlag ) const; | |
| }; | |
| // ------------------------------------------------------------------------ | |
| ImgProdLockBytes::ImgProdLockBytes( SvStream* pStm, sal_Bool bOwner ) : | |
| SvLockBytes( pStm, bOwner ) | |
| { | |
| } | |
| // ------------------------------------------------------------------------ | |
| ImgProdLockBytes::ImgProdLockBytes( ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream > & rStmRef ) : | |
| xStmRef( rStmRef ) | |
| { | |
| if( xStmRef.is() ) | |
| { | |
| const sal_uInt32 nBytesToRead = 65535; | |
| sal_uInt32 nRead; | |
| do | |
| { | |
| ::com::sun::star::uno::Sequence< sal_Int8 > aReadSeq; | |
| nRead = xStmRef->readSomeBytes( aReadSeq, nBytesToRead ); | |
| if( nRead ) | |
| { | |
| const sal_uInt32 nOldLength = maSeq.getLength(); | |
| maSeq.realloc( nOldLength + nRead ); | |
| rtl_copyMemory( maSeq.getArray() + nOldLength, aReadSeq.getConstArray(), aReadSeq.getLength() ); | |
| } | |
| } | |
| while( nBytesToRead == nRead ); | |
| } | |
| } | |
| // ------------------------------------------------------------------------ | |
| ImgProdLockBytes::~ImgProdLockBytes() | |
| { | |
| } | |
| // ------------------------------------------------------------------------ | |
| ErrCode ImgProdLockBytes::ReadAt( sal_Size nPos, void* pBuffer, sal_Size nCount, sal_Size* pRead ) const | |
| { | |
| if( GetStream() ) | |
| { | |
| ( (SvStream*) GetStream() )->ResetError(); | |
| const ErrCode nErr = SvLockBytes::ReadAt( nPos, pBuffer, nCount, pRead ); | |
| ( (SvStream*) GetStream() )->ResetError(); | |
| return nErr; | |
| } | |
| else | |
| { | |
| const sal_Size nSeqLen = maSeq.getLength(); | |
| ErrCode nErr = ERRCODE_NONE; | |
| if( nPos < nSeqLen ) | |
| { | |
| if( ( nPos + nCount ) > nSeqLen ) | |
| nCount = nSeqLen - nPos; | |
| memcpy( pBuffer, maSeq.getConstArray() + nPos, nCount ); | |
| *pRead = nCount; | |
| } | |
| else | |
| *pRead = 0UL; | |
| return nErr; | |
| } | |
| } | |
| // ------------------------------------------------------------------------ | |
| ErrCode ImgProdLockBytes::WriteAt( sal_Size nPos, const void* pBuffer, sal_Size nCount, sal_Size* pWritten ) | |
| { | |
| if( GetStream() ) | |
| return SvLockBytes::WriteAt( nPos, pBuffer, nCount, pWritten ); | |
| else | |
| { | |
| DBG_ASSERT( xStmRef.is(), "ImgProdLockBytes::WriteAt: xInputStream has no reference..." ); | |
| return ERRCODE_IO_CANTWRITE; | |
| } | |
| } | |
| // ------------------------------------------------------------------------ | |
| ErrCode ImgProdLockBytes::Flush() const | |
| { | |
| return ERRCODE_NONE; | |
| } | |
| // ------------------------------------------------------------------------ | |
| ErrCode ImgProdLockBytes::SetSize( sal_Size nSize ) | |
| { | |
| if( GetStream() ) | |
| return SvLockBytes::SetSize( nSize ); | |
| else | |
| { | |
| DBG_ERROR( "ImgProdLockBytes::SetSize not supported for xInputStream..." ); | |
| return ERRCODE_IO_CANTWRITE; | |
| } | |
| } | |
| // ------------------------------------------------------------------------ | |
| ErrCode ImgProdLockBytes::Stat( SvLockBytesStat* pStat, SvLockBytesStatFlag eFlag ) const | |
| { | |
| if( GetStream() ) | |
| return SvLockBytes::Stat( pStat, eFlag ); | |
| else | |
| { | |
| DBG_ASSERT( xStmRef.is(), "ImgProdLockBytes::Stat: xInputStream has no reference..." ); | |
| pStat->nSize = maSeq.getLength(); | |
| return ERRCODE_NONE; | |
| } | |
| } | |
| // ----------------- | |
| // - ImageProducer - | |
| // ----------------- | |
| ImageProducer::ImageProducer() : | |
| mpStm ( NULL ), | |
| mbConsInit ( sal_False ) | |
| { | |
| mpGraphic = new Graphic; | |
| DBG_ASSERT( Application::GetFilterHdl().IsSet(), "ImageProducer::ImageProducer(): No filter handler set" ); | |
| } | |
| // ------------------------------------------------------------ | |
| ImageProducer::~ImageProducer() | |
| { | |
| delete mpGraphic; | |
| mpGraphic = NULL; | |
| delete mpStm; | |
| mpStm = NULL; | |
| for( void* pCons = maConsList.First(); pCons; pCons = maConsList.Next() ) | |
| delete (::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons; | |
| } | |
| // ------------------------------------------------------------ | |
| // ::com::sun::star::uno::XInterface | |
| ::com::sun::star::uno::Any ImageProducer::queryInterface( const ::com::sun::star::uno::Type & rType ) | |
| { | |
| ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType, | |
| SAL_STATIC_CAST( ::com::sun::star::lang::XInitialization*, this ), | |
| SAL_STATIC_CAST( ::com::sun::star::awt::XImageProducer*, this ) ); | |
| return (aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType )); | |
| } | |
| // ------------------------------------------------------------ | |
| void ImageProducer::addConsumer( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer >& rxConsumer ) | |
| { | |
| DBG_ASSERT( rxConsumer.is(), "::AddConsumer(...): No consumer referenced!" ); | |
| if( rxConsumer.is() ) | |
| maConsList.Insert( new ::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > ( rxConsumer ), LIST_APPEND ); | |
| } | |
| // ------------------------------------------------------------ | |
| void ImageProducer::removeConsumer( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer >& rxConsumer ) | |
| { | |
| for( sal_uInt32 n = maConsList.Count(); n; ) | |
| { | |
| ::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > * pRef = (::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) maConsList.GetObject( --n ); | |
| if( *pRef == rxConsumer ) | |
| { | |
| delete pRef; | |
| maConsList.Remove( n ); | |
| break; | |
| } | |
| } | |
| } | |
| // ------------------------------------------------------------ | |
| void ImageProducer::SetImage( const ::rtl::OUString& rPath ) | |
| { | |
| maURL = rPath; | |
| mpGraphic->Clear(); | |
| mbConsInit = sal_False; | |
| delete mpStm; | |
| if ( ::svt::GraphicAccess::isSupportedURL( maURL ) ) | |
| { | |
| mpStm = ::svt::GraphicAccess::getImageStream( ::comphelper::getProcessServiceFactory(), maURL ); | |
| } | |
| else if( maURL.getLength() ) | |
| { | |
| SvStream* pIStm = ::utl::UcbStreamHelper::CreateStream( maURL, STREAM_STD_READ ); | |
| mpStm = pIStm ? new SvStream( new ImgProdLockBytes( pIStm, sal_True ) ) : NULL; | |
| } | |
| else | |
| mpStm = NULL; | |
| } | |
| // ------------------------------------------------------------ | |
| void ImageProducer::SetImage( SvStream& rStm ) | |
| { | |
| maURL = ::rtl::OUString(); | |
| mpGraphic->Clear(); | |
| mbConsInit = sal_False; | |
| delete mpStm; | |
| mpStm = new SvStream( new ImgProdLockBytes( &rStm, sal_False ) ); | |
| } | |
| // ------------------------------------------------------------ | |
| void ImageProducer::setImage( ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream > & rInputStmRef ) | |
| { | |
| maURL = ::rtl::OUString(); | |
| mpGraphic->Clear(); | |
| mbConsInit = sal_False; | |
| delete mpStm; | |
| if( rInputStmRef.is() ) | |
| mpStm = new SvStream( new ImgProdLockBytes( rInputStmRef ) ); | |
| else | |
| mpStm = NULL; | |
| } | |
| // ------------------------------------------------------------ | |
| void ImageProducer::NewDataAvailable() | |
| { | |
| if( ( GRAPHIC_NONE == mpGraphic->GetType() ) || mpGraphic->GetContext() ) | |
| startProduction(); | |
| } | |
| // ------------------------------------------------------------ | |
| void ImageProducer::startProduction() | |
| { | |
| if( maConsList.Count() || maDoneHdl.IsSet() ) | |
| { | |
| bool bNotifyEmptyGraphics = false; | |
| // valid stream or filled graphic? => update consumers | |
| if( mpStm || ( mpGraphic->GetType() != GRAPHIC_NONE ) ) | |
| { | |
| // if we already have a graphic, we don't have to import again; | |
| // graphic is cleared if a new Stream is set | |
| if( ( mpGraphic->GetType() == GRAPHIC_NONE ) || mpGraphic->GetContext() ) | |
| { | |
| if ( ImplImportGraphic( *mpGraphic ) && maDoneHdl.IsSet() ) | |
| maDoneHdl.Call( mpGraphic ); | |
| } | |
| if( mpGraphic->GetType() != GRAPHIC_NONE ) | |
| ImplUpdateData( *mpGraphic ); | |
| else | |
| bNotifyEmptyGraphics = true; | |
| } | |
| else | |
| bNotifyEmptyGraphics = true; | |
| if ( bNotifyEmptyGraphics ) | |
| { | |
| // reset image | |
| List aTmp; | |
| void* pCons; | |
| // create temporary list to hold interfaces | |
| for( pCons = maConsList.First(); pCons; pCons = maConsList.Next() ) | |
| 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 ); | |
| // iterate through interfaces | |
| for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() ) | |
| { | |
| ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->init( 0, 0 ); | |
| ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->complete( ::com::sun::star::awt::ImageStatus::IMAGESTATUS_STATICIMAGEDONE, this ); | |
| } | |
| // delete interfaces in temporary list | |
| for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() ) | |
| delete (::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons; | |
| if ( maDoneHdl.IsSet() ) | |
| maDoneHdl.Call( NULL ); | |
| } | |
| } | |
| } | |
| // ------------------------------------------------------------ | |
| sal_Bool ImageProducer::ImplImportGraphic( Graphic& rGraphic ) | |
| { | |
| if( ERRCODE_IO_PENDING == mpStm->GetError() ) | |
| mpStm->ResetError(); | |
| mpStm->Seek( 0UL ); | |
| sal_Bool bRet = GraphicConverter::Import( *mpStm, rGraphic ) == ERRCODE_NONE; | |
| if( ERRCODE_IO_PENDING == mpStm->GetError() ) | |
| mpStm->ResetError(); | |
| return bRet; | |
| } | |
| // ------------------------------------------------------------ | |
| void ImageProducer::ImplUpdateData( const Graphic& rGraphic ) | |
| { | |
| ImplInitConsumer( rGraphic ); | |
| if( mbConsInit && maConsList.Count() ) | |
| { | |
| List aTmp; | |
| void* pCons; | |
| ImplUpdateConsumer( rGraphic ); | |
| mbConsInit = sal_False; | |
| // create temporary list to hold interfaces | |
| for( pCons = maConsList.First(); pCons; pCons = maConsList.Next() ) | |
| 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 ); | |
| // iterate through interfaces | |
| for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() ) | |
| ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->complete( ::com::sun::star::awt::ImageStatus::IMAGESTATUS_STATICIMAGEDONE, this ); | |
| // delete interfaces in temporary list | |
| for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() ) | |
| delete (::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons; | |
| } | |
| } | |
| // ------------------------------------------------------------ | |
| void ImageProducer::ImplInitConsumer( const Graphic& rGraphic ) | |
| { | |
| Bitmap aBmp( rGraphic.GetBitmapEx().GetBitmap() ); | |
| BitmapReadAccess* pBmpAcc = aBmp.AcquireReadAccess(); | |
| if( pBmpAcc ) | |
| { | |
| List aTmp; | |
| void * pCons; | |
| sal_uInt16 nPalCount = 0; | |
| sal_uInt32 nRMask = 0; | |
| sal_uInt32 nGMask = 0; | |
| sal_uInt32 nBMask = 0; | |
| sal_uInt32 nAMask = 0; | |
| ::com::sun::star::uno::Sequence< sal_Int32 > aRGBPal; | |
| if( pBmpAcc->HasPalette() ) | |
| { | |
| nPalCount = pBmpAcc->GetPaletteEntryCount(); | |
| if( nPalCount ) | |
| { | |
| aRGBPal = ::com::sun::star::uno::Sequence< sal_Int32 >( nPalCount + 1 ); | |
| sal_Int32* pTmp = aRGBPal.getArray(); | |
| for( sal_uInt32 i = 0; i < nPalCount; i++, pTmp++ ) | |
| { | |
| const BitmapColor& rCol = pBmpAcc->GetPaletteColor( (sal_uInt16) i ); | |
| *pTmp = ( (sal_Int32) rCol.GetRed() ) << (sal_Int32)(24L); | |
| *pTmp |= ( (sal_Int32) rCol.GetGreen() ) << (sal_Int32)(16L); | |
| *pTmp |= ( (sal_Int32) rCol.GetBlue() ) << (sal_Int32)(8L); | |
| *pTmp |= (sal_Int32)(0x000000ffL); | |
| } | |
| if( rGraphic.IsTransparent() ) | |
| { | |
| // append transparent entry | |
| *pTmp = (sal_Int32)(0xffffff00L); | |
| mnTransIndex = nPalCount; | |
| nPalCount++; | |
| } | |
| else | |
| mnTransIndex = 0; | |
| } | |
| } | |
| else | |
| { | |
| nRMask = 0xff000000UL; | |
| nGMask = 0x00ff0000UL; | |
| nBMask = 0x0000ff00UL; | |
| nAMask = 0x000000ffUL; | |
| } | |
| // create temporary list to hold interfaces | |
| for( pCons = maConsList.First(); pCons; pCons = maConsList.Next() ) | |
| 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 ); | |
| // iterate through interfaces | |
| for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() ) | |
| { | |
| ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->init( pBmpAcc->Width(), pBmpAcc->Height() ); | |
| ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->setColorModel( pBmpAcc->GetBitCount(), | |
| aRGBPal, nRMask, nGMask, nBMask, nAMask ); | |
| } | |
| // delete interfaces in temporary list | |
| for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() ) | |
| delete (::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons; | |
| aBmp.ReleaseAccess( pBmpAcc ); | |
| mbConsInit = sal_True; | |
| } | |
| } | |
| // ------------------------------------------------------------ | |
| void ImageProducer::ImplUpdateConsumer( const Graphic& rGraphic ) | |
| { | |
| BitmapEx aBmpEx( rGraphic.GetBitmapEx() ); | |
| Bitmap aBmp( aBmpEx.GetBitmap() ); | |
| BitmapReadAccess* pBmpAcc = aBmp.AcquireReadAccess(); | |
| if( pBmpAcc ) | |
| { | |
| List aTmp; | |
| void* pCons; | |
| Bitmap aMask( aBmpEx.GetMask() ); | |
| BitmapReadAccess* pMskAcc = !!aMask ? aMask.AcquireReadAccess() : NULL; | |
| const long nWidth = pBmpAcc->Width(); | |
| const long nHeight = pBmpAcc->Height(); | |
| const long nStartX = 0L; | |
| const long nEndX = nWidth - 1L; | |
| const long nStartY = 0L; | |
| const long nEndY = nHeight - 1L; | |
| const long nPartWidth = nEndX - nStartX + 1; | |
| const long nPartHeight = nEndY - nStartY + 1; | |
| if( !pMskAcc ) | |
| { | |
| aMask = Bitmap( aBmp.GetSizePixel(), 1 ); | |
| aMask.Erase( COL_BLACK ); | |
| pMskAcc = aMask.AcquireReadAccess(); | |
| } | |
| // create temporary list to hold interfaces | |
| for( pCons = maConsList.First(); pCons; pCons = maConsList.Next() ) | |
| 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 ); | |
| if( pBmpAcc->HasPalette() ) | |
| { | |
| const BitmapColor aWhite( pMskAcc->GetBestMatchingColor( Color( COL_WHITE ) ) ); | |
| if( mnTransIndex < 256 ) | |
| { | |
| ::com::sun::star::uno::Sequence<sal_Int8> aData( nPartWidth * nPartHeight ); | |
| sal_Int8* pTmp = aData.getArray(); | |
| for( long nY = nStartY; nY <= nEndY; nY++ ) | |
| { | |
| for( long nX = nStartX; nX <= nEndX; nX++ ) | |
| { | |
| if( pMskAcc->GetPixel( nY, nX ) == aWhite ) | |
| *pTmp++ = sal::static_int_cast< sal_Int8 >( | |
| mnTransIndex ); | |
| else | |
| *pTmp++ = pBmpAcc->GetPixel( nY, nX ).GetIndex(); | |
| } | |
| } | |
| // iterate through interfaces | |
| for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() ) | |
| ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->setPixelsByBytes( nStartX, nStartY, nPartWidth, nPartHeight, | |
| aData, 0UL, nPartWidth ); | |
| } | |
| else | |
| { | |
| ::com::sun::star::uno::Sequence<sal_Int32> aData( nPartWidth * nPartHeight ); | |
| sal_Int32* pTmp = aData.getArray(); | |
| for( long nY = nStartY; nY <= nEndY; nY++ ) | |
| { | |
| for( long nX = nStartX; nX <= nEndX; nX++ ) | |
| { | |
| if( pMskAcc->GetPixel( nY, nX ) == aWhite ) | |
| *pTmp++ = mnTransIndex; | |
| else | |
| *pTmp++ = pBmpAcc->GetPixel( nY, nX ).GetIndex(); | |
| } | |
| } | |
| // iterate through interfaces | |
| for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() ) | |
| ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->setPixelsByLongs( nStartX, nStartY, nPartWidth, nPartHeight, | |
| aData, 0UL, nPartWidth ); | |
| } | |
| } | |
| else | |
| { | |
| ::com::sun::star::uno::Sequence<sal_Int32> aData( nPartWidth * nPartHeight ); | |
| const BitmapColor aWhite( pMskAcc->GetBestMatchingColor( Color( COL_WHITE ) ) ); | |
| sal_Int32* pTmp = aData.getArray(); | |
| for( long nY = nStartY; nY <= nEndY; nY++ ) | |
| { | |
| for( long nX = nStartX; nX <= nEndX; nX++, pTmp++ ) | |
| { | |
| const BitmapColor aCol( pBmpAcc->GetPixel( nY, nX ) ); | |
| *pTmp = ( (sal_Int32) aCol.GetRed() ) << (sal_Int32)(24L); | |
| *pTmp |= ( (sal_Int32) aCol.GetGreen() ) << (sal_Int32)(16L); | |
| *pTmp |= ( (sal_Int32) aCol.GetBlue() ) << (sal_Int32)(8L); | |
| if( pMskAcc->GetPixel( nY, nX ) != aWhite ) | |
| *pTmp |= 0x000000ffUL; | |
| } | |
| } | |
| // iterate through interfaces | |
| for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() ) | |
| ( *(::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons )->setPixelsByLongs( nStartX, nStartY, nPartWidth, nPartHeight, | |
| aData, 0UL, nPartWidth ); | |
| } | |
| // delete interfaces in temporary list | |
| for( pCons = aTmp.First(); pCons; pCons = aTmp.Next() ) | |
| delete (::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageConsumer > *) pCons; | |
| aBmp.ReleaseAccess( pBmpAcc ); | |
| aMask.ReleaseAccess( pMskAcc ); | |
| } | |
| } | |
| void ImageProducer::initialize( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& aArguments ) | |
| { | |
| if ( aArguments.getLength() == 1 ) | |
| { | |
| ::com::sun::star::uno::Any aArg = aArguments.getConstArray()[0]; | |
| rtl::OUString aURL; | |
| if ( aArg >>= aURL ) | |
| { | |
| SetImage( aURL ); | |
| } | |
| } | |
| } | |
| namespace frm | |
| { | |
| ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > | |
| SAL_CALL ImageProducer_CreateInstance( | |
| const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& ) | |
| { | |
| return ::com::sun::star::uno::Reference < ::com::sun::star::uno::XInterface >( | |
| ( ::cppu::OWeakObject* ) new ImageProducer ); | |
| } | |
| } // namespace frm |