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