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