Line data Source code
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 : #include <boost/scoped_ptr.hpp>
21 : #include <boost/scoped_array.hpp>
22 :
23 : #include <rtl/logfile.hxx>
24 :
25 : #include <tools/debug.hxx>
26 : #include <tools/stream.hxx>
27 : #include <tools/rc.h>
28 : #include <tools/rc.hxx>
29 : #include <tools/resmgr.hxx>
30 : #include <vcl/settings.hxx>
31 : #include <vcl/outdev.hxx>
32 : #include <vcl/graph.hxx>
33 : #include <vcl/svapp.hxx>
34 : #include <vcl/image.hxx>
35 : #include <vcl/imagerepository.hxx>
36 : #include <impimagetree.hxx>
37 : #include <image.h>
38 :
39 : #if OSL_DEBUG_LEVEL > 0
40 : #include <rtl/strbuf.hxx>
41 : #endif
42 :
43 : DBG_NAME( Image )
44 : DBG_NAME( ImageList )
45 :
46 : using namespace ::com::sun::star;
47 :
48 : // ---------
49 : // - Image -
50 : // ---------
51 :
52 19779 : Image::Image() :
53 19779 : mpImplData( NULL )
54 : {
55 : DBG_CTOR( Image, NULL );
56 19779 : }
57 :
58 : // -----------------------------------------------------------------------
59 :
60 236 : Image::Image( const ResId& rResId ) :
61 236 : mpImplData( NULL )
62 : {
63 : DBG_CTOR( Image, NULL );
64 :
65 236 : rResId.SetRT( RSC_IMAGE );
66 :
67 236 : ResMgr* pResMgr = rResId.GetResMgr();
68 236 : if( pResMgr && pResMgr->GetResource( rResId ) )
69 : {
70 236 : pResMgr->Increment( sizeof( RSHEADER_TYPE ) );
71 :
72 236 : BitmapEx aBmpEx;
73 236 : sal_uLong nObjMask = pResMgr->ReadLong();
74 :
75 236 : if( nObjMask & RSC_IMAGE_IMAGEBITMAP )
76 : {
77 236 : aBmpEx = BitmapEx( ResId( (RSHEADER_TYPE*)pResMgr->GetClass(), *pResMgr ) );
78 236 : pResMgr->Increment( pResMgr->GetObjSize( (RSHEADER_TYPE*)pResMgr->GetClass() ) );
79 : }
80 :
81 236 : if( nObjMask & RSC_IMAGE_MASKBITMAP )
82 : {
83 0 : if( !aBmpEx.IsEmpty() && aBmpEx.GetTransparentType() == TRANSPARENT_NONE )
84 : {
85 0 : const Bitmap aMaskBitmap( ResId( (RSHEADER_TYPE*)pResMgr->GetClass(), *pResMgr ) );
86 0 : aBmpEx = BitmapEx( aBmpEx.GetBitmap(), aMaskBitmap );
87 : }
88 :
89 0 : pResMgr->Increment( pResMgr->GetObjSize( (RSHEADER_TYPE*)pResMgr->GetClass() ) );
90 : }
91 :
92 236 : if( nObjMask & RSC_IMAGE_MASKCOLOR )
93 : {
94 236 : if( !aBmpEx.IsEmpty() && aBmpEx.GetTransparentType() == TRANSPARENT_NONE )
95 : {
96 0 : const Color aMaskColor( ResId( (RSHEADER_TYPE*)pResMgr->GetClass(), *pResMgr ) );
97 0 : aBmpEx = BitmapEx( aBmpEx.GetBitmap(), aMaskColor );
98 : }
99 :
100 236 : pResMgr->Increment( pResMgr->GetObjSize( (RSHEADER_TYPE*)pResMgr->GetClass() ) );
101 : }
102 236 : if( ! aBmpEx.IsEmpty() )
103 0 : ImplInit( aBmpEx );
104 : }
105 236 : }
106 :
107 : // -----------------------------------------------------------------------
108 :
109 13266 : Image::Image( const Image& rImage ) :
110 13266 : mpImplData( rImage.mpImplData )
111 : {
112 : DBG_CTOR( Image, NULL );
113 :
114 13266 : if( mpImplData )
115 0 : ++mpImplData->mnRefCount;
116 13266 : }
117 :
118 : // -----------------------------------------------------------------------
119 :
120 247 : Image::Image( const BitmapEx& rBitmapEx ) :
121 247 : mpImplData( NULL )
122 : {
123 : DBG_CTOR( Image, NULL );
124 :
125 247 : ImplInit( rBitmapEx );
126 247 : }
127 :
128 : // -----------------------------------------------------------------------
129 :
130 236 : Image::Image( const Bitmap& rBitmap ) :
131 236 : mpImplData( NULL )
132 : {
133 : DBG_CTOR( Image, NULL );
134 :
135 236 : ImplInit( rBitmap );
136 236 : }
137 :
138 : // -----------------------------------------------------------------------
139 :
140 0 : Image::Image( const Bitmap& rBitmap, const Bitmap& rMaskBitmap ) :
141 0 : mpImplData( NULL )
142 : {
143 : DBG_CTOR( Image, NULL );
144 :
145 0 : const BitmapEx aBmpEx( rBitmap, rMaskBitmap );
146 :
147 0 : ImplInit( aBmpEx );
148 0 : }
149 :
150 : // -----------------------------------------------------------------------
151 :
152 0 : Image::Image( const Bitmap& rBitmap, const Color& rColor ) :
153 0 : mpImplData( NULL )
154 : {
155 : DBG_CTOR( Image, NULL );
156 :
157 0 : const BitmapEx aBmpEx( rBitmap, rColor );
158 :
159 0 : ImplInit( aBmpEx );
160 0 : }
161 :
162 : // -----------------------------------------------------------------------
163 :
164 2360 : Image::Image( const uno::Reference< graphic::XGraphic >& rxGraphic ) :
165 2360 : mpImplData( NULL )
166 : {
167 : DBG_CTOR( Image, NULL );
168 :
169 2360 : const Graphic aGraphic( rxGraphic );
170 2360 : ImplInit( aGraphic.GetBitmapEx() );
171 2360 : }
172 :
173 : // -----------------------------------------------------------------------
174 :
175 29625 : Image::~Image()
176 : {
177 : DBG_DTOR( Image, NULL );
178 :
179 29625 : if( mpImplData && ( 0 == --mpImplData->mnRefCount ) )
180 0 : delete mpImplData;
181 29625 : }
182 :
183 : // -----------------------------------------------------------------------
184 :
185 2843 : void Image::ImplInit( const BitmapEx& rBmpEx )
186 : {
187 2843 : if( !rBmpEx.IsEmpty() )
188 : {
189 0 : mpImplData = new ImplImage;
190 0 : mpImplData->mnRefCount = 1;
191 :
192 0 : if( rBmpEx.GetTransparentType() == TRANSPARENT_NONE )
193 : {
194 0 : mpImplData->meType = IMAGETYPE_BITMAP;
195 0 : mpImplData->mpData = new Bitmap( rBmpEx.GetBitmap() );
196 : }
197 : else
198 : {
199 0 : mpImplData->meType = IMAGETYPE_IMAGE;
200 0 : mpImplData->mpData = new ImplImageData( rBmpEx );
201 : }
202 : }
203 2843 : }
204 :
205 : // -----------------------------------------------------------------------
206 :
207 930 : Size Image::GetSizePixel() const
208 : {
209 : DBG_CHKTHIS( Image, NULL );
210 :
211 930 : Size aRet;
212 :
213 930 : if( mpImplData )
214 : {
215 0 : switch( mpImplData->meType )
216 : {
217 : case IMAGETYPE_BITMAP:
218 0 : aRet = static_cast< Bitmap* >( mpImplData->mpData )->GetSizePixel();
219 0 : break;
220 :
221 : case IMAGETYPE_IMAGE:
222 0 : aRet = static_cast< ImplImageData* >( mpImplData->mpData )->maBmpEx.GetSizePixel();
223 0 : break;
224 : }
225 : }
226 :
227 930 : return aRet;
228 : }
229 :
230 : // -----------------------------------------------------------------------
231 :
232 2371 : BitmapEx Image::GetBitmapEx() const
233 : {
234 : DBG_CHKTHIS( Image, NULL );
235 :
236 2371 : BitmapEx aRet;
237 :
238 2371 : if( mpImplData )
239 : {
240 0 : switch( mpImplData->meType )
241 : {
242 : case IMAGETYPE_BITMAP:
243 0 : aRet = *static_cast< Bitmap* >( mpImplData->mpData );
244 0 : break;
245 :
246 : case IMAGETYPE_IMAGE:
247 0 : aRet = static_cast< ImplImageData* >( mpImplData->mpData )->maBmpEx;
248 0 : break;
249 : }
250 : }
251 :
252 2371 : return aRet;
253 : }
254 :
255 : // -----------------------------------------------------------------------
256 :
257 2360 : uno::Reference< graphic::XGraphic > Image::GetXGraphic() const
258 : {
259 2360 : const Graphic aGraphic( GetBitmapEx() );
260 :
261 2360 : return aGraphic.GetXGraphic();
262 : }
263 :
264 : // -----------------------------------------------------------------------
265 :
266 5023 : Image& Image::operator=( const Image& rImage )
267 : {
268 : DBG_CHKTHIS( Image, NULL );
269 : DBG_CHKOBJ( &rImage, Image, NULL );
270 :
271 5023 : if( rImage.mpImplData )
272 0 : ++rImage.mpImplData->mnRefCount;
273 :
274 5023 : if( mpImplData && ( 0 == --mpImplData->mnRefCount ) )
275 0 : delete mpImplData;
276 :
277 5023 : mpImplData = rImage.mpImplData;
278 :
279 5023 : return *this;
280 : }
281 :
282 : // -----------------------------------------------------------------------
283 :
284 236 : sal_Bool Image::operator==( const Image& rImage ) const
285 : {
286 : DBG_CHKTHIS( Image, NULL );
287 : DBG_CHKOBJ( &rImage, Image, NULL );
288 :
289 236 : bool bRet = false;
290 :
291 236 : if( rImage.mpImplData == mpImplData )
292 236 : bRet = true;
293 0 : else if( !rImage.mpImplData || !mpImplData )
294 0 : bRet = false;
295 0 : else if( rImage.mpImplData->mpData == mpImplData->mpData )
296 0 : bRet = true;
297 0 : else if( rImage.mpImplData->meType == mpImplData->meType )
298 : {
299 0 : switch( mpImplData->meType )
300 : {
301 : case IMAGETYPE_BITMAP:
302 0 : bRet = ( *static_cast< Bitmap* >( rImage.mpImplData->mpData ) == *static_cast< Bitmap* >( mpImplData->mpData ) );
303 0 : break;
304 :
305 : case IMAGETYPE_IMAGE:
306 0 : bRet = static_cast< ImplImageData* >( rImage.mpImplData->mpData )->IsEqual( *static_cast< ImplImageData* >( mpImplData->mpData ) );
307 0 : break;
308 :
309 : default:
310 0 : bRet = false;
311 0 : break;
312 : }
313 : }
314 :
315 236 : return bRet;
316 : }
317 :
318 : // -------------
319 : // - ImageList -
320 : // -------------
321 :
322 1439 : ImageList::ImageList( sal_uInt16 nInit, sal_uInt16 nGrow ) :
323 : mpImplData( NULL ),
324 : mnInitSize( nInit ),
325 1439 : mnGrowSize( nGrow )
326 : {
327 : DBG_CTOR( ImageList, NULL );
328 1439 : }
329 :
330 : // -----------------------------------------------------------------------
331 :
332 0 : ImageList::ImageList( const ResId& rResId ) :
333 : mpImplData( NULL ),
334 : mnInitSize( 1 ),
335 0 : mnGrowSize( 4 )
336 : {
337 : RTL_LOGFILE_CONTEXT( aLog, "vcl: ImageList::ImageList( const ResId& rResId )" );
338 :
339 : DBG_CTOR( ImageList, NULL );
340 :
341 0 : rResId.SetRT( RSC_IMAGELIST );
342 :
343 0 : ResMgr* pResMgr = rResId.GetResMgr();
344 :
345 0 : if( pResMgr && pResMgr->GetResource( rResId ) )
346 : {
347 0 : pResMgr->Increment( sizeof( RSHEADER_TYPE ) );
348 :
349 0 : sal_uLong nObjMask = pResMgr->ReadLong();
350 0 : const String aPrefix( pResMgr->ReadString() );
351 0 : ::boost::scoped_ptr< Color > spMaskColor;
352 :
353 0 : if( nObjMask & RSC_IMAGE_MASKCOLOR )
354 0 : spMaskColor.reset( new Color( ResId( (RSHEADER_TYPE*)pResMgr->GetClass(), *pResMgr ) ) );
355 :
356 0 : pResMgr->Increment( pResMgr->GetObjSize( (RSHEADER_TYPE*)pResMgr->GetClass() ) );
357 :
358 0 : if( nObjMask & RSC_IMAGELIST_IDLIST )
359 : {
360 0 : for( sal_Int32 i = 0, nCount = pResMgr->ReadLong(); i < nCount; ++i )
361 0 : pResMgr->ReadLong();
362 : }
363 :
364 0 : sal_Int32 nCount = pResMgr->ReadLong();
365 0 : ImplInit( static_cast< sal_uInt16 >( nCount ), Size() );
366 :
367 0 : BitmapEx aEmpty;
368 0 : for( sal_Int32 i = 0; i < nCount; ++i )
369 : {
370 0 : rtl::OUString aName = pResMgr->ReadString();
371 0 : sal_uInt16 nId = static_cast< sal_uInt16 >( pResMgr->ReadLong() );
372 0 : mpImplData->AddImage( aName, nId, aEmpty );
373 0 : }
374 :
375 0 : if( nObjMask & RSC_IMAGELIST_IDCOUNT )
376 0 : pResMgr->ReadShort();
377 : }
378 0 : }
379 :
380 : // -----------------------------------------------------------------------
381 :
382 0 : ImageList::ImageList( const ::std::vector< ::rtl::OUString >& rNameVector,
383 : const ::rtl::OUString& rPrefix,
384 : const Color* ) :
385 : mpImplData( NULL ),
386 : mnInitSize( 1 ),
387 0 : mnGrowSize( 4 )
388 : {
389 : RTL_LOGFILE_CONTEXT( aLog, "vcl: ImageList::ImageList(const vector< OUString >& ..." );
390 :
391 : DBG_CTOR( ImageList, NULL );
392 :
393 0 : ImplInit( sal::static_int_cast< sal_uInt16 >( rNameVector.size() ), Size() );
394 :
395 0 : mpImplData->maPrefix = rPrefix;
396 0 : for( sal_uInt32 i = 0; i < rNameVector.size(); ++i )
397 : {
398 0 : mpImplData->AddImage( rNameVector[ i ], static_cast< sal_uInt16 >( i ) + 1, BitmapEx() );
399 : }
400 0 : }
401 :
402 : // -----------------------------------------------------------------------
403 :
404 0 : ImageList::ImageList( const ImageList& rImageList ) :
405 : mpImplData( rImageList.mpImplData ),
406 : mnInitSize( rImageList.mnInitSize ),
407 0 : mnGrowSize( rImageList.mnGrowSize )
408 : {
409 : DBG_CTOR( ImageList, NULL );
410 :
411 0 : if( mpImplData )
412 0 : ++mpImplData->mnRefCount;
413 0 : }
414 :
415 : // -----------------------------------------------------------------------
416 :
417 552 : ImageList::~ImageList()
418 : {
419 : DBG_DTOR( ImageList, NULL );
420 :
421 552 : if( mpImplData && ( 0 == --mpImplData->mnRefCount ) )
422 0 : delete mpImplData;
423 552 : }
424 :
425 0 : void ImageList::ImplInit( sal_uInt16 nItems, const Size &rSize )
426 : {
427 0 : mpImplData = new ImplImageList;
428 0 : mpImplData->mnRefCount = 1;
429 0 : mpImplData->maImages.reserve( nItems );
430 0 : mpImplData->maImageSize = rSize;
431 0 : }
432 :
433 : // -----------------------------------------------------------------------
434 :
435 0 : void ImageAryData::Load(const rtl::OUString &rPrefix)
436 : {
437 0 : static ImplImageTreeSingletonRef aImageTree;
438 :
439 0 : ::rtl::OUString aSymbolsStyle = Application::GetSettings().GetStyleSettings().GetCurrentSymbolsStyleName();
440 :
441 0 : BitmapEx aBmpEx;
442 :
443 0 : rtl::OUString aFileName = rPrefix;
444 0 : aFileName += maName;
445 : #if OSL_DEBUG_LEVEL > 0
446 : bool bSuccess =
447 : #endif
448 0 : aImageTree->loadImage( aFileName, aSymbolsStyle, maBitmapEx, true );
449 : #if OSL_DEBUG_LEVEL > 0
450 : if ( !bSuccess )
451 : {
452 : ::rtl::OStringBuffer aMessage;
453 : aMessage.append( "ImageAryData::Load: failed to load image '" );
454 : aMessage.append( ::rtl::OUStringToOString( aFileName, RTL_TEXTENCODING_UTF8 ).getStr() );
455 : aMessage.append( "'" );
456 : OSL_FAIL( aMessage.makeStringAndClear().getStr() );
457 : }
458 : #endif
459 0 : }
460 :
461 : // -----------------------------------------------------------------------
462 : // Rather a performance hazard:
463 0 : BitmapEx ImageList::GetAsHorizontalStrip() const
464 : {
465 0 : Size aSize( mpImplData->maImageSize );
466 0 : sal_uInt16 nCount = GetImageCount();
467 0 : if( !nCount )
468 0 : return BitmapEx();
469 0 : aSize.Width() *= nCount;
470 :
471 : // Load any stragglers
472 0 : for (sal_uInt16 nIdx = 0; nIdx < nCount; nIdx++)
473 : {
474 0 : ImageAryData *pData = mpImplData->maImages[ nIdx ];
475 0 : if( pData->IsLoadable() )
476 0 : pData->Load( mpImplData->maPrefix );
477 : }
478 :
479 0 : BitmapEx aTempl = mpImplData->maImages[ 0 ]->maBitmapEx;
480 0 : BitmapEx aResult;
481 0 : Bitmap aPixels( aSize, aTempl.GetBitmap().GetBitCount() );
482 0 : if( aTempl.IsAlpha() )
483 0 : aResult = BitmapEx( aPixels, AlphaMask( aSize ) );
484 0 : else if( aTempl.IsTransparent() )
485 0 : aResult = BitmapEx( aPixels, Bitmap( aSize, aTempl.GetMask().GetBitCount() ) );
486 : else
487 0 : aResult = BitmapEx( aPixels );
488 :
489 0 : Rectangle aSrcRect( Point( 0, 0 ), mpImplData->maImageSize );
490 0 : for (sal_uInt16 nIdx = 0; nIdx < nCount; nIdx++)
491 : {
492 0 : Rectangle aDestRect( Point( nIdx * mpImplData->maImageSize.Width(), 0 ),
493 0 : mpImplData->maImageSize );
494 0 : ImageAryData *pData = mpImplData->maImages[ nIdx ];
495 0 : aResult.CopyPixel( aDestRect, aSrcRect, &pData->maBitmapEx);
496 : }
497 :
498 0 : return aResult;
499 : }
500 :
501 : // -----------------------------------------------------------------------
502 :
503 0 : void ImageList::InsertFromHorizontalStrip( const BitmapEx &rBitmapEx,
504 : const std::vector< rtl::OUString > &rNameVector )
505 : {
506 0 : sal_uInt16 nItems = sal::static_int_cast< sal_uInt16 >( rNameVector.size() );
507 :
508 0 : if (!nItems)
509 0 : return;
510 :
511 0 : Size aSize( rBitmapEx.GetSizePixel() );
512 : DBG_ASSERT (rBitmapEx.GetSizePixel().Width() % nItems == 0,
513 : "ImageList::InsertFromHorizontalStrip - very odd size");
514 0 : aSize.Width() /= nItems;
515 0 : ImplInit( nItems, aSize );
516 :
517 0 : for (sal_uInt16 nIdx = 0; nIdx < nItems; nIdx++)
518 : {
519 0 : BitmapEx aBitmap( rBitmapEx, Point( nIdx * aSize.Width(), 0 ), aSize );
520 0 : mpImplData->AddImage( rNameVector[ nIdx ], nIdx + 1, aBitmap );
521 0 : }
522 : }
523 :
524 : // -----------------------------------------------------------------------
525 :
526 0 : void ImageList::InsertFromHorizontalBitmap( const ResId& rResId,
527 : sal_uInt16 nCount,
528 : const Color *pMaskColor,
529 : const Color *pSearchColors,
530 : const Color *pReplaceColors,
531 : sal_uLong nColorCount)
532 : {
533 0 : BitmapEx aBmpEx( rResId );
534 0 : if (!aBmpEx.IsTransparent())
535 : {
536 0 : if( pMaskColor )
537 0 : aBmpEx = BitmapEx( aBmpEx.GetBitmap(), *pMaskColor );
538 : else
539 0 : aBmpEx = BitmapEx( aBmpEx.GetBitmap() );
540 : }
541 0 : if ( nColorCount && pSearchColors && pReplaceColors )
542 0 : aBmpEx.Replace( pSearchColors, pReplaceColors, nColorCount );
543 :
544 0 : std::vector< rtl::OUString > aNames( nCount );
545 0 : InsertFromHorizontalStrip( aBmpEx, aNames );
546 0 : }
547 :
548 : // -----------------------------------------------------------------------
549 :
550 0 : sal_uInt16 ImageList::ImplGetImageId( const ::rtl::OUString& rImageName ) const
551 : {
552 : DBG_CHKTHIS( ImageList, NULL );
553 :
554 0 : ImageAryData *pImg = mpImplData->maNameHash[ rImageName ];
555 0 : if( pImg )
556 0 : return pImg->mnId;
557 : else
558 0 : return 0;
559 : }
560 :
561 : // -----------------------------------------------------------------------
562 :
563 0 : void ImageList::AddImage( const ::rtl::OUString& rImageName, const Image& rImage )
564 : {
565 : DBG_ASSERT( GetImagePos( rImageName ) == IMAGELIST_IMAGE_NOTFOUND, "ImageList::AddImage() - ImageName already exists" );
566 :
567 0 : if( !mpImplData )
568 0 : ImplInit( 0, rImage.GetSizePixel() );
569 :
570 0 : mpImplData->AddImage( rImageName, GetImageCount() + 1,
571 0 : rImage.GetBitmapEx() );
572 0 : }
573 :
574 : // -----------------------------------------------------------------------
575 :
576 0 : void ImageList::ReplaceImage( const ::rtl::OUString& rImageName, const Image& rImage )
577 : {
578 0 : const sal_uInt16 nId = ImplGetImageId( rImageName );
579 :
580 0 : if( nId )
581 : {
582 0 : RemoveImage( nId );
583 :
584 0 : if( !mpImplData )
585 0 : ImplInit( 0, rImage.GetSizePixel() );
586 0 : mpImplData->AddImage( rImageName, nId, rImage.GetBitmapEx());
587 : }
588 0 : }
589 :
590 : // -----------------------------------------------------------------------
591 :
592 0 : void ImageList::RemoveImage( sal_uInt16 nId )
593 : {
594 : DBG_CHKTHIS( ImageList, NULL );
595 :
596 0 : for( sal_uInt32 i = 0; i < mpImplData->maImages.size(); ++i )
597 : {
598 0 : if( mpImplData->maImages[ i ]->mnId == nId )
599 : {
600 0 : mpImplData->RemoveImage( static_cast< sal_uInt16 >( i ) );
601 0 : break;
602 : }
603 : }
604 0 : }
605 :
606 : // -----------------------------------------------------------------------
607 :
608 0 : Image ImageList::GetImage( sal_uInt16 nId ) const
609 : {
610 : DBG_CHKTHIS( ImageList, NULL );
611 :
612 0 : Image aRet;
613 :
614 0 : if( mpImplData )
615 : {
616 0 : std::vector<ImageAryData *>::iterator aIter;
617 0 : for( aIter = mpImplData->maImages.begin();
618 0 : aIter != mpImplData->maImages.end(); ++aIter)
619 : {
620 0 : if ((*aIter)->mnId == nId)
621 : {
622 0 : if( (*aIter)->IsLoadable() )
623 0 : (*aIter)->Load( mpImplData->maPrefix );
624 :
625 0 : aRet = Image( (*aIter)->maBitmapEx );
626 : }
627 : }
628 : }
629 :
630 0 : if (!aRet)
631 : {
632 0 : BitmapEx rBitmap;
633 0 : bool res = ::vcl::ImageRepository::loadDefaultImage(rBitmap);
634 0 : if (res)
635 0 : aRet = Image(rBitmap);
636 : }
637 :
638 0 : return aRet;
639 : }
640 :
641 : // -----------------------------------------------------------------------
642 :
643 2360 : Image ImageList::GetImage( const ::rtl::OUString& rImageName ) const
644 : {
645 2360 : if( mpImplData )
646 : {
647 0 : ImageAryData *pImg = mpImplData->maNameHash[ rImageName ];
648 :
649 0 : if( pImg )
650 : {
651 0 : if( pImg->IsLoadable() )
652 0 : pImg->Load( mpImplData->maPrefix );
653 0 : return Image( pImg->maBitmapEx );
654 : }
655 : }
656 :
657 2360 : return Image();
658 : }
659 :
660 : // -----------------------------------------------------------------------
661 :
662 0 : sal_uInt16 ImageList::GetImageCount() const
663 : {
664 : DBG_CHKTHIS( ImageList, NULL );
665 :
666 0 : return mpImplData ? static_cast< sal_uInt16 >( mpImplData->maImages.size() ) : 0;
667 : }
668 :
669 : // -----------------------------------------------------------------------
670 :
671 0 : sal_uInt16 ImageList::GetImagePos( sal_uInt16 nId ) const
672 : {
673 : DBG_CHKTHIS( ImageList, NULL );
674 :
675 0 : if( mpImplData && nId )
676 : {
677 0 : for( sal_uInt32 i = 0; i < mpImplData->maImages.size(); ++i )
678 : {
679 0 : if (mpImplData->maImages[ i ]->mnId == nId)
680 0 : return static_cast< sal_uInt16 >( i );
681 : }
682 : }
683 :
684 0 : return IMAGELIST_IMAGE_NOTFOUND;
685 : }
686 :
687 0 : bool ImageList::HasImageAtPos( sal_uInt16 nId ) const
688 : {
689 0 : return GetImagePos( nId ) != IMAGELIST_IMAGE_NOTFOUND;
690 : }
691 :
692 : // -----------------------------------------------------------------------
693 :
694 0 : sal_uInt16 ImageList::GetImagePos( const ::rtl::OUString& rImageName ) const
695 : {
696 : DBG_CHKTHIS( ImageList, NULL );
697 :
698 0 : if( mpImplData && !rImageName.isEmpty() )
699 : {
700 0 : for( sal_uInt32 i = 0; i < mpImplData->maImages.size(); i++ )
701 : {
702 0 : if (mpImplData->maImages[i]->maName == rImageName)
703 0 : return static_cast< sal_uInt16 >( i );
704 : }
705 : }
706 :
707 0 : return IMAGELIST_IMAGE_NOTFOUND;
708 : }
709 :
710 : // -----------------------------------------------------------------------
711 :
712 0 : sal_uInt16 ImageList::GetImageId( sal_uInt16 nPos ) const
713 : {
714 : DBG_CHKTHIS( ImageList, NULL );
715 :
716 0 : if( mpImplData && (nPos < GetImageCount()) )
717 0 : return mpImplData->maImages[ nPos ]->mnId;
718 :
719 0 : return 0;
720 : }
721 :
722 : // -----------------------------------------------------------------------
723 :
724 0 : ::rtl::OUString ImageList::GetImageName( sal_uInt16 nPos ) const
725 : {
726 : DBG_CHKTHIS( ImageList, NULL );
727 :
728 0 : if( mpImplData && (nPos < GetImageCount()) )
729 0 : return mpImplData->maImages[ nPos ]->maName;
730 :
731 0 : return ::rtl::OUString();
732 : }
733 :
734 : // -----------------------------------------------------------------------
735 :
736 0 : void ImageList::GetImageNames( ::std::vector< ::rtl::OUString >& rNames ) const
737 : {
738 : RTL_LOGFILE_CONTEXT( aLog, "vcl: ImageList::GetImageNames" );
739 :
740 : DBG_CHKTHIS( ImageList, NULL );
741 :
742 0 : rNames = ::std::vector< ::rtl::OUString >();
743 :
744 0 : if( mpImplData )
745 : {
746 0 : for( sal_uInt32 i = 0; i < mpImplData->maImages.size(); i++ )
747 : {
748 0 : const rtl::OUString& rName( mpImplData->maImages[ i ]->maName );
749 0 : if( !rName.isEmpty())
750 0 : rNames.push_back( rName );
751 : }
752 : }
753 0 : }
754 :
755 : // -----------------------------------------------------------------------
756 :
757 0 : Size ImageList::GetImageSize() const
758 : {
759 : DBG_CHKTHIS( ImageList, NULL );
760 :
761 0 : Size aRet;
762 :
763 0 : if( mpImplData )
764 : {
765 0 : aRet = mpImplData->maImageSize;
766 :
767 : // force load of 1st image to see - uncommon case.
768 0 : if( aRet.Width() == 0 && aRet.Height() == 0 &&
769 0 : !mpImplData->maImages.empty() )
770 : {
771 0 : Image aTmp = GetImage( mpImplData->maImages[ 0 ]->mnId );
772 0 : aRet = mpImplData->maImageSize = aTmp.GetSizePixel();
773 : }
774 : }
775 0 : return aRet;
776 : }
777 :
778 : // -----------------------------------------------------------------------
779 :
780 0 : ImageList& ImageList::operator=( const ImageList& rImageList )
781 : {
782 : DBG_CHKTHIS( ImageList, NULL );
783 : DBG_CHKOBJ( &rImageList, ImageList, NULL );
784 :
785 0 : if( rImageList.mpImplData )
786 0 : ++rImageList.mpImplData->mnRefCount;
787 :
788 0 : if( mpImplData && ( 0 == --mpImplData->mnRefCount ) )
789 0 : delete mpImplData;
790 :
791 0 : mpImplData = rImageList.mpImplData;
792 :
793 0 : return *this;
794 : }
795 :
796 : // -----------------------------------------------------------------------
797 :
798 0 : sal_Bool ImageList::operator==( const ImageList& rImageList ) const
799 : {
800 : DBG_CHKTHIS( ImageList, NULL );
801 : DBG_CHKOBJ( &rImageList, ImageList, NULL );
802 :
803 0 : bool bRet = false;
804 :
805 0 : if( rImageList.mpImplData == mpImplData )
806 0 : bRet = true;
807 0 : else if( !rImageList.mpImplData || !mpImplData )
808 0 : bRet = false;
809 0 : else if( rImageList.GetImageCount() == GetImageCount() &&
810 0 : rImageList.mpImplData->maImageSize == mpImplData->maImageSize )
811 0 : bRet = true; // strange semantic
812 :
813 0 : return bRet;
814 : }
815 :
816 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
