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 <osl/file.hxx>
24 : #include <tools/debug.hxx>
25 : #include <tools/stream.hxx>
26 : #include <tools/rc.h>
27 : #include <tools/rc.hxx>
28 : #include <tools/resmgr.hxx>
29 : #include <vcl/settings.hxx>
30 : #include <vcl/outdev.hxx>
31 : #include <vcl/graph.hxx>
32 : #include <vcl/graphicfilter.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 : using namespace ::com::sun::star;
44 :
45 1408510 : Image::Image() :
46 1408510 : mpImplData( NULL )
47 : {
48 1408510 : }
49 :
50 10962 : Image::Image( const ResId& rResId ) :
51 10962 : mpImplData( NULL )
52 : {
53 :
54 10962 : rResId.SetRT( RSC_IMAGE );
55 :
56 10962 : ResMgr* pResMgr = rResId.GetResMgr();
57 10962 : if( pResMgr && pResMgr->GetResource( rResId ) )
58 : {
59 10962 : pResMgr->Increment( sizeof( RSHEADER_TYPE ) );
60 :
61 10962 : BitmapEx aBmpEx;
62 10962 : sal_uLong nObjMask = pResMgr->ReadLong();
63 :
64 10962 : if( nObjMask & RSC_IMAGE_IMAGEBITMAP )
65 : {
66 10962 : aBmpEx = BitmapEx( ResId( (RSHEADER_TYPE*)pResMgr->GetClass(), *pResMgr ) );
67 10962 : pResMgr->Increment( pResMgr->GetObjSize( (RSHEADER_TYPE*)pResMgr->GetClass() ) );
68 : }
69 :
70 10962 : if( nObjMask & RSC_IMAGE_MASKBITMAP )
71 : {
72 0 : if( !aBmpEx.IsEmpty() && aBmpEx.GetTransparentType() == TRANSPARENT_NONE )
73 : {
74 0 : const Bitmap aMaskBitmap( ResId( (RSHEADER_TYPE*)pResMgr->GetClass(), *pResMgr ) );
75 0 : aBmpEx = BitmapEx( aBmpEx.GetBitmap(), aMaskBitmap );
76 : }
77 :
78 0 : pResMgr->Increment( pResMgr->GetObjSize( (RSHEADER_TYPE*)pResMgr->GetClass() ) );
79 : }
80 :
81 10962 : if( nObjMask & RSC_IMAGE_MASKCOLOR )
82 : {
83 10074 : if( !aBmpEx.IsEmpty() && aBmpEx.GetTransparentType() == TRANSPARENT_NONE )
84 : {
85 122 : const Color aMaskColor( ResId( (RSHEADER_TYPE*)pResMgr->GetClass(), *pResMgr ) );
86 122 : aBmpEx = BitmapEx( aBmpEx.GetBitmap(), aMaskColor );
87 : }
88 :
89 10074 : pResMgr->Increment( pResMgr->GetObjSize( (RSHEADER_TYPE*)pResMgr->GetClass() ) );
90 : }
91 10962 : if( ! aBmpEx.IsEmpty() )
92 10962 : ImplInit( aBmpEx );
93 : }
94 10962 : }
95 :
96 1121416 : Image::Image( const Image& rImage ) :
97 1121416 : mpImplData( rImage.mpImplData )
98 : {
99 :
100 1121416 : if( mpImplData )
101 333752 : ++mpImplData->mnRefCount;
102 1121416 : }
103 :
104 74692 : Image::Image( const BitmapEx& rBitmapEx ) :
105 74692 : mpImplData( NULL )
106 : {
107 :
108 74692 : ImplInit( rBitmapEx );
109 74692 : }
110 :
111 3155 : Image::Image( const Bitmap& rBitmap ) :
112 3155 : mpImplData( NULL )
113 : {
114 :
115 3155 : ImplInit( rBitmap );
116 3155 : }
117 :
118 0 : Image::Image( const Bitmap& rBitmap, const Bitmap& rMaskBitmap ) :
119 0 : mpImplData( NULL )
120 : {
121 :
122 0 : const BitmapEx aBmpEx( rBitmap, rMaskBitmap );
123 :
124 0 : ImplInit( aBmpEx );
125 0 : }
126 :
127 0 : Image::Image( const Bitmap& rBitmap, const Color& rColor ) :
128 0 : mpImplData( NULL )
129 : {
130 :
131 0 : const BitmapEx aBmpEx( rBitmap, rColor );
132 :
133 0 : ImplInit( aBmpEx );
134 0 : }
135 :
136 120971 : Image::Image( const uno::Reference< graphic::XGraphic >& rxGraphic ) :
137 120971 : mpImplData( NULL )
138 : {
139 :
140 120971 : const Graphic aGraphic( rxGraphic );
141 120971 : ImplInit( aGraphic.GetBitmapEx() );
142 120971 : }
143 :
144 0 : Image::Image( const OUString &rFileUrl ) :
145 0 : mpImplData( NULL )
146 : {
147 0 : OUString aTmp;
148 0 : osl::FileBase::getSystemPathFromFileURL( rFileUrl, aTmp );
149 0 : Graphic aGraphic;
150 0 : const OUString aFilterName( IMP_PNG );
151 0 : if( GRFILTER_OK == GraphicFilter::LoadGraphic( aTmp, aFilterName, aGraphic ) )
152 : {
153 0 : ImplInit( aGraphic.GetBitmapEx() );
154 0 : }
155 0 : }
156 :
157 2739112 : Image::~Image()
158 : {
159 :
160 2739112 : if( mpImplData && ( 0 == --mpImplData->mnRefCount ) )
161 130012 : delete mpImplData;
162 2739112 : }
163 :
164 209780 : void Image::ImplInit( const BitmapEx& rBmpEx )
165 : {
166 209780 : if( !rBmpEx.IsEmpty() )
167 : {
168 134111 : mpImplData = new ImplImage;
169 :
170 134111 : if( rBmpEx.GetTransparentType() == TRANSPARENT_NONE )
171 : {
172 5430 : mpImplData->meType = IMAGETYPE_BITMAP;
173 5430 : mpImplData->mpData = new Bitmap( rBmpEx.GetBitmap() );
174 : }
175 : else
176 : {
177 128681 : mpImplData->meType = IMAGETYPE_IMAGE;
178 128681 : mpImplData->mpData = new ImplImageData( rBmpEx );
179 : }
180 : }
181 209780 : }
182 :
183 270812 : Size Image::GetSizePixel() const
184 : {
185 :
186 270812 : Size aRet;
187 :
188 270812 : if( mpImplData )
189 : {
190 198660 : switch( mpImplData->meType )
191 : {
192 : case IMAGETYPE_BITMAP:
193 5769 : aRet = static_cast< Bitmap* >( mpImplData->mpData )->GetSizePixel();
194 5769 : break;
195 :
196 : case IMAGETYPE_IMAGE:
197 192891 : aRet = static_cast< ImplImageData* >( mpImplData->mpData )->maBmpEx.GetSizePixel();
198 192891 : break;
199 : }
200 : }
201 :
202 270812 : return aRet;
203 : }
204 :
205 125780 : BitmapEx Image::GetBitmapEx() const
206 : {
207 :
208 125780 : BitmapEx aRet;
209 :
210 125780 : if( mpImplData )
211 : {
212 49654 : switch( mpImplData->meType )
213 : {
214 : case IMAGETYPE_BITMAP:
215 1361 : aRet = *static_cast< Bitmap* >( mpImplData->mpData );
216 1361 : break;
217 :
218 : case IMAGETYPE_IMAGE:
219 48293 : aRet = static_cast< ImplImageData* >( mpImplData->mpData )->maBmpEx;
220 48293 : break;
221 : }
222 : }
223 :
224 125780 : return aRet;
225 : }
226 :
227 121727 : uno::Reference< graphic::XGraphic > Image::GetXGraphic() const
228 : {
229 121727 : const Graphic aGraphic( GetBitmapEx() );
230 :
231 121729 : return aGraphic.GetXGraphic();
232 : }
233 :
234 787310 : Image& Image::operator=( const Image& rImage )
235 : {
236 :
237 787310 : if( rImage.mpImplData )
238 217504 : ++rImage.mpImplData->mnRefCount;
239 :
240 787310 : if( mpImplData && ( 0 == --mpImplData->mnRefCount ) )
241 4046 : delete mpImplData;
242 :
243 787310 : mpImplData = rImage.mpImplData;
244 :
245 787310 : return *this;
246 : }
247 :
248 43602 : bool Image::operator==( const Image& rImage ) const
249 : {
250 :
251 43602 : bool bRet = false;
252 :
253 43602 : if( rImage.mpImplData == mpImplData )
254 43466 : bRet = true;
255 136 : else if( !rImage.mpImplData || !mpImplData )
256 134 : bRet = false;
257 2 : else if( rImage.mpImplData->mpData == mpImplData->mpData )
258 0 : bRet = true;
259 2 : else if( rImage.mpImplData->meType == mpImplData->meType )
260 : {
261 2 : switch( mpImplData->meType )
262 : {
263 : case IMAGETYPE_BITMAP:
264 0 : bRet = ( *static_cast< Bitmap* >( rImage.mpImplData->mpData ) == *static_cast< Bitmap* >( mpImplData->mpData ) );
265 0 : break;
266 :
267 : case IMAGETYPE_IMAGE:
268 2 : bRet = static_cast< ImplImageData* >( rImage.mpImplData->mpData )->IsEqual( *static_cast< ImplImageData* >( mpImplData->mpData ) );
269 2 : break;
270 :
271 : default:
272 0 : bRet = false;
273 0 : break;
274 : }
275 : }
276 :
277 43602 : return bRet;
278 : }
279 :
280 11906 : ImageList::ImageList( sal_uInt16 nInit, sal_uInt16 nGrow ) :
281 : mpImplData( NULL ),
282 : mnInitSize( nInit ),
283 11906 : mnGrowSize( nGrow )
284 : {
285 11906 : }
286 :
287 355 : ImageList::ImageList( const ResId& rResId ) :
288 : mpImplData( NULL ),
289 : mnInitSize( 1 ),
290 355 : mnGrowSize( 4 )
291 : {
292 : SAL_INFO( "vcl.gdi", "vcl: ImageList::ImageList( const ResId& rResId )" );
293 :
294 355 : rResId.SetRT( RSC_IMAGELIST );
295 :
296 355 : ResMgr* pResMgr = rResId.GetResMgr();
297 :
298 355 : if( pResMgr && pResMgr->GetResource( rResId ) )
299 : {
300 355 : pResMgr->Increment( sizeof( RSHEADER_TYPE ) );
301 :
302 355 : sal_uLong nObjMask = pResMgr->ReadLong();
303 355 : pResMgr->ReadString(); //skip string
304 355 : ::boost::scoped_ptr< Color > spMaskColor;
305 :
306 355 : if( nObjMask & RSC_IMAGE_MASKCOLOR )
307 355 : spMaskColor.reset( new Color( ResId( (RSHEADER_TYPE*)pResMgr->GetClass(), *pResMgr ) ) );
308 :
309 355 : pResMgr->Increment( pResMgr->GetObjSize( (RSHEADER_TYPE*)pResMgr->GetClass() ) );
310 :
311 355 : if( nObjMask & RSC_IMAGELIST_IDLIST )
312 : {
313 0 : for( sal_Int32 i = 0, nCount = pResMgr->ReadLong(); i < nCount; ++i )
314 0 : pResMgr->ReadLong();
315 : }
316 :
317 355 : sal_Int32 nCount = pResMgr->ReadLong();
318 355 : ImplInit( static_cast< sal_uInt16 >( nCount ), Size() );
319 :
320 710 : BitmapEx aEmpty;
321 3914 : for( sal_Int32 i = 0; i < nCount; ++i )
322 : {
323 3559 : OUString aName = pResMgr->ReadString();
324 3559 : sal_uInt16 nId = static_cast< sal_uInt16 >( pResMgr->ReadLong() );
325 3559 : mpImplData->AddImage( aName, nId, aEmpty );
326 3559 : }
327 :
328 355 : if( nObjMask & RSC_IMAGELIST_IDCOUNT )
329 710 : pResMgr->ReadShort();
330 : }
331 355 : }
332 :
333 81 : ImageList::ImageList( const ::std::vector< OUString >& rNameVector,
334 : const OUString& rPrefix,
335 : const Color* ) :
336 : mpImplData( NULL ),
337 : mnInitSize( 1 ),
338 81 : mnGrowSize( 4 )
339 : {
340 : SAL_INFO( "vcl.gdi", "vcl: ImageList::ImageList(const vector< OUString >& ..." );
341 :
342 81 : ImplInit( sal::static_int_cast< sal_uInt16 >( rNameVector.size() ), Size() );
343 :
344 81 : mpImplData->maPrefix = rPrefix;
345 22911 : for( sal_uInt32 i = 0; i < rNameVector.size(); ++i )
346 : {
347 22830 : mpImplData->AddImage( rNameVector[ i ], static_cast< sal_uInt16 >( i ) + 1, BitmapEx() );
348 : }
349 81 : }
350 :
351 0 : ImageList::ImageList( const ImageList& rImageList ) :
352 : mpImplData( rImageList.mpImplData ),
353 : mnInitSize( rImageList.mnInitSize ),
354 0 : mnGrowSize( rImageList.mnGrowSize )
355 : {
356 :
357 0 : if( mpImplData )
358 0 : ++mpImplData->mnRefCount;
359 0 : }
360 :
361 12268 : ImageList::~ImageList()
362 : {
363 12268 : if( mpImplData && ( 0 == --mpImplData->mnRefCount ) )
364 368 : delete mpImplData;
365 12268 : }
366 :
367 454 : void ImageList::ImplInit( sal_uInt16 nItems, const Size &rSize )
368 : {
369 454 : mpImplData = new ImplImageList;
370 454 : mpImplData->maImages.reserve( nItems );
371 454 : mpImplData->maImageSize = rSize;
372 454 : }
373 :
374 4257 : void ImageAryData::Load(const OUString &rPrefix)
375 : {
376 4257 : static ImplImageTreeSingletonRef aImageTree;
377 :
378 4257 : OUString aIconTheme = Application::GetSettings().GetStyleSettings().DetermineIconTheme();
379 :
380 8514 : BitmapEx aBmpEx;
381 :
382 8514 : OUString aFileName = rPrefix;
383 4257 : aFileName += maName;
384 : #if OSL_DEBUG_LEVEL > 0
385 : bool bSuccess =
386 : #endif
387 8514 : aImageTree->loadImage( aFileName, aIconTheme, maBitmapEx, true );
388 : #if OSL_DEBUG_LEVEL > 0
389 : if ( !bSuccess )
390 : {
391 : OStringBuffer aMessage;
392 : aMessage.append( "ImageAryData::Load: failed to load image '" );
393 : aMessage.append( OUStringToOString( aFileName, RTL_TEXTENCODING_UTF8 ).getStr() );
394 : aMessage.append( "'" );
395 : OSL_FAIL( aMessage.makeStringAndClear().getStr() );
396 : }
397 : #endif
398 4257 : }
399 :
400 : // FIXME: Rather a performance hazard
401 0 : BitmapEx ImageList::GetAsHorizontalStrip() const
402 : {
403 0 : Size aSize( mpImplData->maImageSize );
404 0 : sal_uInt16 nCount = GetImageCount();
405 0 : if( !nCount )
406 0 : return BitmapEx();
407 0 : aSize.Width() *= nCount;
408 :
409 : // Load any stragglers
410 0 : for (sal_uInt16 nIdx = 0; nIdx < nCount; nIdx++)
411 : {
412 0 : ImageAryData *pData = mpImplData->maImages[ nIdx ];
413 0 : if( pData->IsLoadable() )
414 0 : pData->Load( mpImplData->maPrefix );
415 : }
416 :
417 0 : BitmapEx aTempl = mpImplData->maImages[ 0 ]->maBitmapEx;
418 0 : BitmapEx aResult;
419 0 : Bitmap aPixels( aSize, aTempl.GetBitmap().GetBitCount() );
420 0 : if( aTempl.IsAlpha() )
421 0 : aResult = BitmapEx( aPixels, AlphaMask( aSize ) );
422 0 : else if( aTempl.IsTransparent() )
423 0 : aResult = BitmapEx( aPixels, Bitmap( aSize, aTempl.GetMask().GetBitCount() ) );
424 : else
425 0 : aResult = BitmapEx( aPixels );
426 :
427 0 : Rectangle aSrcRect( Point( 0, 0 ), mpImplData->maImageSize );
428 0 : for (sal_uInt16 nIdx = 0; nIdx < nCount; nIdx++)
429 : {
430 0 : Rectangle aDestRect( Point( nIdx * mpImplData->maImageSize.Width(), 0 ),
431 0 : mpImplData->maImageSize );
432 0 : ImageAryData *pData = mpImplData->maImages[ nIdx ];
433 0 : aResult.CopyPixel( aDestRect, aSrcRect, &pData->maBitmapEx);
434 : }
435 :
436 0 : return aResult;
437 : }
438 :
439 18 : void ImageList::InsertFromHorizontalStrip( const BitmapEx &rBitmapEx,
440 : const std::vector< OUString > &rNameVector )
441 : {
442 18 : sal_uInt16 nItems = sal::static_int_cast< sal_uInt16 >( rNameVector.size() );
443 :
444 18 : if (!nItems)
445 18 : return;
446 :
447 18 : Size aSize( rBitmapEx.GetSizePixel() );
448 : DBG_ASSERT (rBitmapEx.GetSizePixel().Width() % nItems == 0,
449 : "ImageList::InsertFromHorizontalStrip - very odd size");
450 18 : aSize.Width() /= nItems;
451 18 : ImplInit( nItems, aSize );
452 :
453 153 : for (sal_uInt16 nIdx = 0; nIdx < nItems; nIdx++)
454 : {
455 135 : BitmapEx aBitmap( rBitmapEx, Point( nIdx * aSize.Width(), 0 ), aSize );
456 135 : mpImplData->AddImage( rNameVector[ nIdx ], nIdx + 1, aBitmap );
457 135 : }
458 : }
459 :
460 18 : void ImageList::InsertFromHorizontalBitmap( const ResId& rResId,
461 : sal_uInt16 nCount,
462 : const Color *pMaskColor,
463 : const Color *pSearchColors,
464 : const Color *pReplaceColors,
465 : sal_uLong nColorCount)
466 : {
467 18 : BitmapEx aBmpEx( rResId );
468 18 : if (!aBmpEx.IsTransparent())
469 : {
470 18 : if( pMaskColor )
471 18 : aBmpEx = BitmapEx( aBmpEx.GetBitmap(), *pMaskColor );
472 : else
473 0 : aBmpEx = BitmapEx( aBmpEx.GetBitmap() );
474 : }
475 18 : if ( nColorCount && pSearchColors && pReplaceColors )
476 18 : aBmpEx.Replace( pSearchColors, pReplaceColors, nColorCount );
477 :
478 36 : std::vector< OUString > aNames( nCount );
479 36 : InsertFromHorizontalStrip( aBmpEx, aNames );
480 18 : }
481 :
482 0 : sal_uInt16 ImageList::ImplGetImageId( const OUString& rImageName ) const
483 : {
484 :
485 0 : ImageAryData *pImg = mpImplData->maNameHash[ rImageName ];
486 0 : if( pImg )
487 0 : return pImg->mnId;
488 : else
489 0 : return 0;
490 : }
491 :
492 0 : void ImageList::AddImage( const OUString& rImageName, const Image& rImage )
493 : {
494 : DBG_ASSERT( GetImagePos( rImageName ) == IMAGELIST_IMAGE_NOTFOUND, "ImageList::AddImage() - ImageName already exists" );
495 :
496 0 : if( !mpImplData )
497 0 : ImplInit( 0, rImage.GetSizePixel() );
498 :
499 0 : mpImplData->AddImage( rImageName, GetImageCount() + 1,
500 0 : rImage.GetBitmapEx() );
501 0 : }
502 :
503 0 : void ImageList::ReplaceImage( const OUString& rImageName, const Image& rImage )
504 : {
505 0 : const sal_uInt16 nId = ImplGetImageId( rImageName );
506 :
507 0 : if( nId )
508 : {
509 : //Just replace the bitmap rather than doing RemoveImage / AddImage
510 : //which breaks index-based iteration.
511 0 : ImageAryData *pImg = mpImplData->maNameHash[ rImageName ];
512 0 : pImg->maBitmapEx = rImage.GetBitmapEx();
513 : }
514 0 : }
515 :
516 0 : void ImageList::RemoveImage( sal_uInt16 nId )
517 : {
518 :
519 0 : for( sal_uInt32 i = 0; i < mpImplData->maImages.size(); ++i )
520 : {
521 0 : if( mpImplData->maImages[ i ]->mnId == nId )
522 : {
523 0 : mpImplData->RemoveImage( static_cast< sal_uInt16 >( i ) );
524 0 : break;
525 : }
526 : }
527 0 : }
528 :
529 22536 : Image ImageList::GetImage( sal_uInt16 nId ) const
530 : {
531 :
532 22536 : Image aRet;
533 :
534 22536 : if( mpImplData )
535 : {
536 18541 : std::vector<ImageAryData *>::iterator aIter;
537 2914296 : for( aIter = mpImplData->maImages.begin();
538 1942864 : aIter != mpImplData->maImages.end(); ++aIter)
539 : {
540 952891 : if ((*aIter)->mnId == nId)
541 : {
542 19892 : if( (*aIter)->IsLoadable() )
543 1799 : (*aIter)->Load( mpImplData->maPrefix );
544 :
545 19892 : aRet = Image( (*aIter)->maBitmapEx );
546 : }
547 : }
548 : }
549 :
550 22536 : if (!aRet)
551 : {
552 3995 : BitmapEx rBitmap;
553 3995 : bool res = ::vcl::ImageRepository::loadDefaultImage(rBitmap);
554 3995 : if (res)
555 3995 : aRet = Image(rBitmap);
556 : }
557 :
558 22536 : return aRet;
559 : }
560 :
561 165138 : Image ImageList::GetImage( const OUString& rImageName ) const
562 : {
563 165138 : if( mpImplData )
564 : {
565 44506 : ImageAryData *pImg = mpImplData->maNameHash[ rImageName ];
566 :
567 44506 : if( pImg )
568 : {
569 44506 : if( pImg->IsLoadable() )
570 2458 : pImg->Load( mpImplData->maPrefix );
571 44506 : return Image( pImg->maBitmapEx );
572 : }
573 : }
574 :
575 120632 : return Image();
576 : }
577 :
578 736 : sal_uInt16 ImageList::GetImageCount() const
579 : {
580 :
581 736 : return mpImplData ? static_cast< sal_uInt16 >( mpImplData->maImages.size() ) : 0;
582 : }
583 :
584 17860 : sal_uInt16 ImageList::GetImagePos( sal_uInt16 nId ) const
585 : {
586 :
587 17860 : if( mpImplData && nId )
588 : {
589 676302 : for( sal_uInt32 i = 0; i < mpImplData->maImages.size(); ++i )
590 : {
591 674952 : if (mpImplData->maImages[ i ]->mnId == nId)
592 16510 : return static_cast< sal_uInt16 >( i );
593 : }
594 : }
595 :
596 1350 : return IMAGELIST_IMAGE_NOTFOUND;
597 : }
598 :
599 17860 : bool ImageList::HasImageAtPos( sal_uInt16 nId ) const
600 : {
601 17860 : return GetImagePos( nId ) != IMAGELIST_IMAGE_NOTFOUND;
602 : }
603 :
604 0 : sal_uInt16 ImageList::GetImagePos( const OUString& rImageName ) const
605 : {
606 :
607 0 : if( mpImplData && !rImageName.isEmpty() )
608 : {
609 0 : for( sal_uInt32 i = 0; i < mpImplData->maImages.size(); i++ )
610 : {
611 0 : if (mpImplData->maImages[i]->maName == rImageName)
612 0 : return static_cast< sal_uInt16 >( i );
613 : }
614 : }
615 :
616 0 : return IMAGELIST_IMAGE_NOTFOUND;
617 : }
618 :
619 594 : sal_uInt16 ImageList::GetImageId( sal_uInt16 nPos ) const
620 : {
621 :
622 594 : if( mpImplData && (nPos < GetImageCount()) )
623 594 : return mpImplData->maImages[ nPos ]->mnId;
624 :
625 0 : return 0;
626 : }
627 :
628 0 : OUString ImageList::GetImageName( sal_uInt16 nPos ) const
629 : {
630 :
631 0 : if( mpImplData && (nPos < GetImageCount()) )
632 0 : return mpImplData->maImages[ nPos ]->maName;
633 :
634 0 : return OUString();
635 : }
636 :
637 0 : void ImageList::GetImageNames( ::std::vector< OUString >& rNames ) const
638 : {
639 : SAL_INFO( "vcl.gdi", "vcl: ImageList::GetImageNames" );
640 :
641 0 : rNames = ::std::vector< OUString >();
642 :
643 0 : if( mpImplData )
644 : {
645 0 : for( sal_uInt32 i = 0; i < mpImplData->maImages.size(); i++ )
646 : {
647 0 : const OUString& rName( mpImplData->maImages[ i ]->maName );
648 0 : if( !rName.isEmpty())
649 0 : rNames.push_back( rName );
650 : }
651 : }
652 0 : }
653 :
654 0 : Size ImageList::GetImageSize() const
655 : {
656 :
657 0 : Size aRet;
658 :
659 0 : if( mpImplData )
660 : {
661 0 : aRet = mpImplData->maImageSize;
662 :
663 : // force load of 1st image to see - uncommon case.
664 0 : if( aRet.Width() == 0 && aRet.Height() == 0 &&
665 0 : !mpImplData->maImages.empty() )
666 : {
667 0 : Image aTmp = GetImage( mpImplData->maImages[ 0 ]->mnId );
668 0 : aRet = mpImplData->maImageSize = aTmp.GetSizePixel();
669 : }
670 : }
671 0 : return aRet;
672 : }
673 :
674 174 : ImageList& ImageList::operator=( const ImageList& rImageList )
675 : {
676 :
677 174 : if( rImageList.mpImplData )
678 174 : ++rImageList.mpImplData->mnRefCount;
679 :
680 174 : if( mpImplData && ( 0 == --mpImplData->mnRefCount ) )
681 60 : delete mpImplData;
682 :
683 174 : mpImplData = rImageList.mpImplData;
684 :
685 174 : return *this;
686 : }
687 :
688 0 : bool ImageList::operator==( const ImageList& rImageList ) const
689 : {
690 :
691 0 : bool bRet = false;
692 :
693 0 : if( rImageList.mpImplData == mpImplData )
694 0 : bRet = true;
695 0 : else if( !rImageList.mpImplData || !mpImplData )
696 0 : bRet = false;
697 0 : else if( rImageList.GetImageCount() == GetImageCount() &&
698 0 : rImageList.mpImplData->maImageSize == mpImplData->maImageSize )
699 0 : bRet = true; // strange semantic
700 :
701 0 : return bRet;
702 : }
703 :
704 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
