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