?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Version 5.4.3.2, tag libreoffice-5.4.3.2
[LibreOffice.git] / vcl / source / gdi / bitmapex.cxx
blobfc75f9e5b120aa8ac8210aebf022ddfded17536f
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 <rtl/crc.h>
21 #include <rtl/strbuf.hxx>
22
23 #include <o3tl/any.hxx>
24 #include <tools/debug.hxx>
25 #include <tools/rcid.h>
26 #include <tools/resmgr.hxx>
27 #include <tools/stream.hxx>
28 #include <vcl/ImageTree.hxx>
29 #include <vcl/salbtype.hxx>
30 #include <vcl/outdev.hxx>
31 #include <vcl/alpha.hxx>
32 #include <vcl/bitmapex.hxx>
33 #include <vcl/dibtools.hxx>
34 #include <vcl/pngread.hxx>
35 #include <vcl/svapp.hxx>
36 #include <vcl/bitmapaccess.hxx>
37 #include <vcl/virdev.hxx>
38 #include <vcl/settings.hxx>
39
40 #include <image.h>
41 #include <basegfx/matrix/b2dhommatrixtools.hxx>
42
43 // BitmapEx::Create
44 #include <salbmp.hxx>
45 #include <salinst.hxx>
46 #include <svdata.hxx>
47 #include <com/sun/star/beans/XFastPropertySet.hpp>
48 #include <memory>
49
50 using namespace ::com::sun::star;
51
52 BitmapEx::BitmapEx()
53 : eTransparent(TransparentType::NONE)
54 , bAlpha(false)
55 {
56 }
57
58 BitmapEx::BitmapEx( const BitmapEx& rBitmapEx ) :
59 aBitmap ( rBitmapEx.aBitmap ),
60 aMask ( rBitmapEx.aMask ),
61 aBitmapSize ( rBitmapEx.aBitmapSize ),
62 aTransparentColor ( rBitmapEx.aTransparentColor ),
63 eTransparent ( rBitmapEx.eTransparent ),
64 bAlpha ( rBitmapEx.bAlpha )
65 {
66 }
67
68 BitmapEx::BitmapEx( const BitmapEx& rBitmapEx, Point aSrc, Size aSize )
69 : eTransparent(TransparentType::NONE)
70 , bAlpha(false)
71 {
72 if( rBitmapEx.IsEmpty() )
73 return;
74
75 aBitmap = Bitmap( aSize, rBitmapEx.aBitmap.GetBitCount() );
76 aBitmapSize = aSize;
77 if( rBitmapEx.IsAlpha() )
78 {
79 bAlpha = true;
80 aMask = AlphaMask( aSize ).ImplGetBitmap();
81 }
82 else if( rBitmapEx.IsTransparent() )
83 aMask = Bitmap( aSize, rBitmapEx.aMask.GetBitCount() );
84
85 tools::Rectangle aDestRect( Point( 0, 0 ), aSize );
86 tools::Rectangle aSrcRect( aSrc, aSize );
87 CopyPixel( aDestRect, aSrcRect, &rBitmapEx );
88 }
89
90 BitmapEx::BitmapEx( const OUString& rIconName )
91 : eTransparent(TransparentType::NONE)
92 , bAlpha(false)
93 {
94 loadFromIconTheme( rIconName );
95 }
96
97 void BitmapEx::loadFromIconTheme( const OUString& rIconName )
98 {
99 OUString aIconTheme = Application::GetSettings().GetStyleSettings().DetermineIconTheme();
100
101 if (!ImageTree::get().loadImage(rIconName, aIconTheme, *this, true))
102 {
103 #ifdef DBG_UTIL
104 OStringBuffer aErrorStr(
105 "BitmapEx::BitmapEx(): could not load image <");
106 aErrorStr.append(OUStringToOString(rIconName, RTL_TEXTENCODING_ASCII_US)).append("> via icon theme ");
107 aErrorStr.append(OUStringToOString(aIconTheme, RTL_TEXTENCODING_ASCII_US)).append('.');
108 OSL_FAIL(aErrorStr.getStr());
109 #endif
110 }
111 }
112
113 BitmapEx::BitmapEx( const Bitmap& rBmp ) :
114 aBitmap ( rBmp ),
115 aBitmapSize ( aBitmap.GetSizePixel() ),
116 eTransparent( TransparentType::NONE ),
117 bAlpha ( false )
118 {
119 }
120
121 BitmapEx::BitmapEx( const Bitmap& rBmp, const Bitmap& rMask ) :
122 aBitmap ( rBmp ),
123 aMask ( rMask ),
124 aBitmapSize ( aBitmap.GetSizePixel() ),
125 eTransparent ( !rMask ? TransparentType::NONE : TransparentType::Bitmap ),
126 bAlpha ( false )
127 {
128 // Ensure a mask is exactly one bit deep
129 if( !!aMask && aMask.GetBitCount() != 1 )
130 {
131 SAL_WARN( "vcl", "BitmapEx: forced mask to monochrome");
132 aMask.ImplMakeMono( 255 );
133 }
134
135 if(!!aBitmap && !!aMask && aBitmap.GetSizePixel() != aMask.GetSizePixel())
136 {
137 OSL_ENSURE(false, "Mask size differs from Bitmap size, corrected Mask (!)");
138 aMask.Scale(aBitmap.GetSizePixel());
139 }
140 }
141
142 BitmapEx::BitmapEx( const Bitmap& rBmp, const AlphaMask& rAlphaMask ) :
143 aBitmap ( rBmp ),
144 aMask ( rAlphaMask.ImplGetBitmap() ),
145 aBitmapSize ( aBitmap.GetSizePixel() ),
146 eTransparent ( !rAlphaMask ? TransparentType::NONE : TransparentType::Bitmap ),
147 bAlpha ( !rAlphaMask.IsEmpty() )
148 {
149 if(!!aBitmap && !!aMask && aBitmap.GetSizePixel() != aMask.GetSizePixel())
150 {
151 OSL_ENSURE(false, "Alpha size differs from Bitmap size, corrected Mask (!)");
152 aMask.Scale(rBmp.GetSizePixel());
153 }
154
155 // #i75531# the workaround below can go when
156 // X11SalGraphics::drawAlphaBitmap()'s render acceleration
157 // can handle the bitmap depth mismatch directly
158 if( aBitmap.GetBitCount() < aMask.GetBitCount() )
159 aBitmap.Convert( BmpConversion::N24Bit );
160 }
161
162 BitmapEx::BitmapEx( const Bitmap& rBmp, const Color& rTransparentColor ) :
163 aBitmap ( rBmp ),
164 aBitmapSize ( aBitmap.GetSizePixel() ),
165 aTransparentColor ( rTransparentColor ),
166 eTransparent ( TransparentType::Bitmap ),
167 bAlpha ( false )
168 {
169 aMask = aBitmap.CreateMask( aTransparentColor );
170
171 SAL_WARN_IF( rBmp.GetSizePixel() != aMask.GetSizePixel(), "vcl",
172 "BitmapEx::BitmapEx(): size mismatch for bitmap and alpha mask." );
173 }
174
175 BitmapEx& BitmapEx::operator=( const BitmapEx& rBitmapEx )
176 {
177 if( &rBitmapEx != this )
178 {
179 aBitmap = rBitmapEx.aBitmap;
180 aMask = rBitmapEx.aMask;
181 aBitmapSize = rBitmapEx.aBitmapSize;
182 aTransparentColor = rBitmapEx.aTransparentColor;
183 eTransparent = rBitmapEx.eTransparent;
184 bAlpha = rBitmapEx.bAlpha;
185 }
186
187 return *this;
188 }
189
190 bool BitmapEx::operator==( const BitmapEx& rBitmapEx ) const
191 {
192 if( eTransparent != rBitmapEx.eTransparent )
193 return false;
194
195 if( aBitmap != rBitmapEx.aBitmap )
196 return false;
197
198 if( aBitmapSize != rBitmapEx.aBitmapSize )
199 return false;
200
201 if( eTransparent == TransparentType::NONE )
202 return true;
203
204 if( eTransparent == TransparentType::Color )
205 return aTransparentColor == rBitmapEx.aTransparentColor;
206
207 return( ( aMask == rBitmapEx.aMask ) && ( bAlpha == rBitmapEx.bAlpha ) );
208 }
209
210 bool BitmapEx::IsEmpty() const
211 {
212 return( aBitmap.IsEmpty() && aMask.IsEmpty() );
213 }
214
215 void BitmapEx::SetEmpty()
216 {
217 aBitmap.SetEmpty();
218 aMask.SetEmpty();
219 eTransparent = TransparentType::NONE;
220 bAlpha = false;
221 }
222
223 void BitmapEx::Clear()
224 {
225 SetEmpty();
226 }
227
228 bool BitmapEx::IsTransparent() const
229 {
230 return( eTransparent != TransparentType::NONE );
231 }
232
233 bool BitmapEx::IsAlpha() const
234 {
235 return( IsTransparent() && bAlpha );
236 }
237
238 const Bitmap& BitmapEx::GetBitmapRef() const
239 {
240 return aBitmap;
241 }
242
243 Bitmap BitmapEx::GetBitmap( const Color* pTransReplaceColor ) const
244 {
245 Bitmap aRetBmp( aBitmap );
246
247 if( pTransReplaceColor && ( eTransparent != TransparentType::NONE ) )
248 {
249 Bitmap aTempMask;
250
251 if( eTransparent == TransparentType::Color )
252 aTempMask = aBitmap.CreateMask( aTransparentColor );
253 else
254 aTempMask = aMask;
255
256 if( !IsAlpha() )
257 aRetBmp.Replace( aTempMask, *pTransReplaceColor );
258 else
259 aRetBmp.Replace( GetAlpha(), *pTransReplaceColor );
260 }
261
262 return aRetBmp;
263 }
264
265 Bitmap BitmapEx::GetMask() const
266 {
267 Bitmap aRet( aMask );
268
269 if( IsAlpha() )
270 aRet.ImplMakeMono( 255 );
271
272 return aRet;
273 }
274
275 AlphaMask BitmapEx::GetAlpha() const
276 {
277 if( IsAlpha() )
278 {
279 AlphaMask aAlpha;
280 aAlpha.ImplSetBitmap( aMask );
281 return aAlpha;
282 }
283 else
284 {
285 return aMask;
286 }
287 }
288
289 sal_uLong BitmapEx::GetSizeBytes() const
290 {
291 sal_uLong nSizeBytes = aBitmap.GetSizeBytes();
292
293 if( eTransparent == TransparentType::Bitmap )
294 nSizeBytes += aMask.GetSizeBytes();
295
296 return nSizeBytes;
297 }
298
299 BitmapChecksum BitmapEx::GetChecksum() const
300 {
301 BitmapChecksum nCrc = aBitmap.GetChecksum();
302 SVBT32 aBT32;
303 BitmapChecksumOctetArray aBCOA;
304
305 UInt32ToSVBT32( (long) eTransparent, aBT32 );
306 nCrc = vcl_get_checksum( nCrc, aBT32, 4 );
307
308 UInt32ToSVBT32( (long) bAlpha, aBT32 );
309 nCrc = vcl_get_checksum( nCrc, aBT32, 4 );
310
311 if( ( TransparentType::Bitmap == eTransparent ) && !aMask.IsEmpty() )
312 {
313 BCToBCOA( aMask.GetChecksum(), aBCOA );
314 nCrc = vcl_get_checksum( nCrc, aBCOA, BITMAP_CHECKSUM_SIZE );
315 }
316
317 return nCrc;
318 }
319
320 void BitmapEx::SetSizePixel( const Size& rNewSize, BmpScaleFlag nScaleFlag )
321 {
322 if(GetSizePixel() != rNewSize)
323 {
324 Scale( rNewSize, nScaleFlag );
325 }
326 }
327
328 bool BitmapEx::Invert()
329 {
330 bool bRet = false;
331
332 if( !!aBitmap )
333 {
334 bRet = aBitmap.Invert();
335
336 if( bRet && ( eTransparent == TransparentType::Color ) )
337 aTransparentColor = BitmapColor( aTransparentColor ).Invert();
338 }
339
340 return bRet;
341 }
342
343 bool BitmapEx::Mirror( BmpMirrorFlags nMirrorFlags )
344 {
345 bool bRet = false;
346
347 if( !!aBitmap )
348 {
349 bRet = aBitmap.Mirror( nMirrorFlags );
350
351 if( bRet && ( eTransparent == TransparentType::Bitmap ) && !!aMask )
352 aMask.Mirror( nMirrorFlags );
353 }
354
355 return bRet;
356 }
357
358 bool BitmapEx::Scale( const double& rScaleX, const double& rScaleY, BmpScaleFlag nScaleFlag )
359 {
360 bool bRet = false;
361
362 if( !!aBitmap )
363 {
364 bRet = aBitmap.Scale( rScaleX, rScaleY, nScaleFlag );
365
366 if( bRet && ( eTransparent == TransparentType::Bitmap ) && !!aMask )
367 {
368 aMask.Scale( rScaleX, rScaleY, nScaleFlag );
369 }
370
371 aBitmapSize = aBitmap.GetSizePixel();
372
373 SAL_WARN_IF( !!aMask && aBitmap.GetSizePixel() != aMask.GetSizePixel(), "vcl",
374 "BitmapEx::Scale(): size mismatch for bitmap and alpha mask." );
375 }
376
377 return bRet;
378 }
379
380 bool BitmapEx::Scale( const Size& rNewSize, BmpScaleFlag nScaleFlag )
381 {
382 bool bRet;
383
384 if( aBitmapSize.Width() && aBitmapSize.Height() &&
385 ( rNewSize.Width() != aBitmapSize.Width() ||
386 rNewSize.Height() != aBitmapSize.Height() ) )
387 {
388 bRet = Scale( (double) rNewSize.Width() / aBitmapSize.Width(),
389 (double) rNewSize.Height() / aBitmapSize.Height(),
390 nScaleFlag );
391 }
392 else
393 bRet = true;
394
395 return bRet;
396 }
397
398 bool BitmapEx::Rotate( long nAngle10, const Color& rFillColor )
399 {
400 bool bRet = false;
401
402 if( !!aBitmap )
403 {
404 const bool bTransRotate = ( Color( COL_TRANSPARENT ) == rFillColor );
405
406 if( bTransRotate )
407 {
408 if( eTransparent == TransparentType::Color )
409 bRet = aBitmap.Rotate( nAngle10, aTransparentColor );
410 else
411 {
412 bRet = aBitmap.Rotate( nAngle10, COL_BLACK );
413
414 if( eTransparent == TransparentType::NONE )
415 {
416 aMask = Bitmap( aBitmapSize, 1 );
417 aMask.Erase( COL_BLACK );
418 eTransparent = TransparentType::Bitmap;
419 }
420
421 if( bRet && !!aMask )
422 aMask.Rotate( nAngle10, COL_WHITE );
423 }
424 }
425 else
426 {
427 bRet = aBitmap.Rotate( nAngle10, rFillColor );
428
429 if( bRet && ( eTransparent == TransparentType::Bitmap ) && !!aMask )
430 aMask.Rotate( nAngle10, COL_WHITE );
431 }
432
433 aBitmapSize = aBitmap.GetSizePixel();
434
435 SAL_WARN_IF( !!aMask && aBitmap.GetSizePixel() != aMask.GetSizePixel(), "vcl",
436 "BitmapEx::Rotate(): size mismatch for bitmap and alpha mask." );
437 }
438
439 return bRet;
440 }
441
442 bool BitmapEx::Crop( const tools::Rectangle& rRectPixel )
443 {
444 bool bRet = false;
445
446 if( !!aBitmap )
447 {
448 bRet = aBitmap.Crop( rRectPixel );
449
450 if( bRet && ( eTransparent == TransparentType::Bitmap ) && !!aMask )
451 aMask.Crop( rRectPixel );
452
453 aBitmapSize = aBitmap.GetSizePixel();
454
455 SAL_WARN_IF( !!aMask && aBitmap.GetSizePixel() != aMask.GetSizePixel(), "vcl",
456 "BitmapEx::Crop(): size mismatch for bitmap and alpha mask." );
457 }
458
459 return bRet;
460 }
461
462 bool BitmapEx::Convert( BmpConversion eConversion )
463 {
464 return !!aBitmap && aBitmap.Convert( eConversion );
465 }
466
467 bool BitmapEx::ReduceColors( sal_uInt16 nNewColorCount )
468 {
469 return !!aBitmap && aBitmap.ReduceColors( nNewColorCount, BMP_REDUCE_POPULAR );
470 }
471
472 bool BitmapEx::Expand( sal_uLong nDX, sal_uLong nDY, bool bExpandTransparent )
473 {
474 bool bRet = false;
475
476 if( !!aBitmap )
477 {
478 bRet = aBitmap.Expand( nDX, nDY );
479
480 if( bRet && ( eTransparent == TransparentType::Bitmap ) && !!aMask )
481 {
482 Color aColor( bExpandTransparent ? COL_WHITE : COL_BLACK );
483 aMask.Expand( nDX, nDY, &aColor );
484 }
485
486 aBitmapSize = aBitmap.GetSizePixel();
487
488 SAL_WARN_IF( !!aMask && aBitmap.GetSizePixel() != aMask.GetSizePixel(), "vcl",
489 "BitmapEx::Expand(): size mismatch for bitmap and alpha mask." );
490 }
491
492 return bRet;
493 }
494
495 bool BitmapEx::CopyPixel( const tools::Rectangle& rRectDst, const tools::Rectangle& rRectSrc,
496 const BitmapEx* pBmpExSrc )
497 {
498 bool bRet = false;
499
500 if( !pBmpExSrc || pBmpExSrc->IsEmpty() )
501 {
502 if( !aBitmap.IsEmpty() )
503 {
504 bRet = aBitmap.CopyPixel( rRectDst, rRectSrc );
505
506 if( bRet && ( eTransparent == TransparentType::Bitmap ) && !!aMask )
507 aMask.CopyPixel( rRectDst, rRectSrc );
508 }
509 }
510 else
511 {
512 if( !aBitmap.IsEmpty() )
513 {
514 bRet = aBitmap.CopyPixel( rRectDst, rRectSrc, &pBmpExSrc->aBitmap );
515
516 if( bRet )
517 {
518 if( pBmpExSrc->IsAlpha() )
519 {
520 if( IsAlpha() )
521 // cast to use the optimized AlphaMask::CopyPixel
522 aMask.CopyPixel_AlphaOptimized( rRectDst, rRectSrc, &pBmpExSrc->aMask );
523 else if( IsTransparent() )
524 {
525 AlphaMask* pAlpha = new AlphaMask( aMask );
526
527 aMask = pAlpha->ImplGetBitmap();
528 delete pAlpha;
529 bAlpha = true;
530 aMask.CopyPixel( rRectDst, rRectSrc, &pBmpExSrc->aMask );
531 }
532 else
533 {
534 sal_uInt8 cBlack = 0;
535 AlphaMask* pAlpha = new AlphaMask( GetSizePixel(), &cBlack );
536
537 aMask = pAlpha->ImplGetBitmap();
538 delete pAlpha;
539 eTransparent = TransparentType::Bitmap;
540 bAlpha = true;
541 aMask.CopyPixel( rRectDst, rRectSrc, &pBmpExSrc->aMask );
542 }
543 }
544 else if( pBmpExSrc->IsTransparent() )
545 {
546 if( IsAlpha() )
547 {
548 AlphaMask aAlpha( pBmpExSrc->aMask );
549 aMask.CopyPixel( rRectDst, rRectSrc, &aAlpha.ImplGetBitmap() );
550 }
551 else if( IsTransparent() )
552 aMask.CopyPixel( rRectDst, rRectSrc, &pBmpExSrc->aMask );
553 else
554 {
555 aMask = Bitmap( GetSizePixel(), 1 );
556 aMask.Erase( Color( COL_BLACK ) );
557 eTransparent = TransparentType::Bitmap;
558 aMask.CopyPixel( rRectDst, rRectSrc, &pBmpExSrc->aMask );
559 }
560 }
561 else if( IsAlpha() )
562 {
563 sal_uInt8 cBlack = 0;
564 const AlphaMask aAlphaSrc( pBmpExSrc->GetSizePixel(), &cBlack );
565
566 aMask.CopyPixel( rRectDst, rRectSrc, &aAlphaSrc.ImplGetBitmap() );
567 }
568 else if( IsTransparent() )
569 {
570 Bitmap aMaskSrc( pBmpExSrc->GetSizePixel(), 1 );
571
572 aMaskSrc.Erase( Color( COL_BLACK ) );
573 aMask.CopyPixel( rRectDst, rRectSrc, &aMaskSrc );
574 }
575 }
576 }
577 }
578
579 return bRet;
580 }
581
582 bool BitmapEx::Erase( const Color& rFillColor )
583 {
584 bool bRet = false;
585
586 if( !!aBitmap )
587 {
588 bRet = aBitmap.Erase( rFillColor );
589
590 if( bRet && ( eTransparent == TransparentType::Bitmap ) && !!aMask )
591 {
592 // Respect transparency on fill color
593 if( rFillColor.GetTransparency() )
594 {
595 const Color aFill( rFillColor.GetTransparency(), rFillColor.GetTransparency(), rFillColor.GetTransparency() );
596 aMask.Erase( aFill );
597 }
598 else
599 {
600 const Color aBlack( COL_BLACK );
601 aMask.Erase( aBlack );
602 }
603 }
604 }
605
606 return bRet;
607 }
608
609 bool BitmapEx::Dither()
610 {
611 return !!aBitmap && aBitmap.Dither();
612 }
613
614 bool BitmapEx::Replace( const Color& rSearchColor, const Color& rReplaceColor )
615 {
616 return !!aBitmap && aBitmap.Replace( rSearchColor, rReplaceColor );
617 }
618
619 bool BitmapEx::Replace( const Color* pSearchColors, const Color* pReplaceColors, sal_uLong nColorCount, const sal_uLong* pTols )
620 {
621 return !!aBitmap && aBitmap.Replace( pSearchColors, pReplaceColors, nColorCount, const_cast<sal_uLong*>(pTols) );
622 }
623
624 bool BitmapEx::Adjust( short nLuminancePercent, short nContrastPercent,
625 short nChannelRPercent, short nChannelGPercent, short nChannelBPercent,
626 double fGamma, bool bInvert, bool msoBrightness )
627 {
628 return !!aBitmap && aBitmap.Adjust( nLuminancePercent, nContrastPercent,
629 nChannelRPercent, nChannelGPercent, nChannelBPercent,
630 fGamma, bInvert, msoBrightness );
631 }
632
633 bool BitmapEx::Filter( BmpFilter eFilter, const BmpFilterParam* pFilterParam )
634 {
635 return !!aBitmap && aBitmap.Filter( eFilter, pFilterParam );
636 }
637
638 void BitmapEx::Draw( OutputDevice* pOutDev, const Point& rDestPt ) const
639 {
640 pOutDev->DrawBitmapEx( rDestPt, *this );
641 }
642
643 void BitmapEx::Draw( OutputDevice* pOutDev,
644 const Point& rDestPt, const Size& rDestSize ) const
645 {
646 pOutDev->DrawBitmapEx( rDestPt, rDestSize, *this );
647 }
648
649 BitmapEx BitmapEx:: AutoScaleBitmap(BitmapEx & aBitmap, const long aStandardSize)
650 {
651 Point aEmptyPoint(0,0);
652 double imgposX = 0;
653 double imgposY = 0;
654 BitmapEx aRet = aBitmap;
655 double imgOldWidth = aRet.GetSizePixel().Width();
656 double imgOldHeight =aRet.GetSizePixel().Height();
657
658 Size aScaledSize;
659 if (imgOldWidth >= aStandardSize || imgOldHeight >= aStandardSize)
660 {
661 sal_Int32 imgNewWidth = 0;
662 sal_Int32 imgNewHeight = 0;
663 if (imgOldWidth >= imgOldHeight)
664 {
665 imgNewWidth = aStandardSize;
666 imgNewHeight = sal_Int32(imgOldHeight / (imgOldWidth / aStandardSize) + 0.5);
667 imgposX = 0;
668 imgposY = (aStandardSize - (imgOldHeight / (imgOldWidth / aStandardSize) + 0.5)) / 2 + 0.5;
669 }
670 else
671 {
672 imgNewHeight = aStandardSize;
673 imgNewWidth = sal_Int32(imgOldWidth / (imgOldHeight / aStandardSize) + 0.5);
674 imgposY = 0;
675 imgposX = (aStandardSize - (imgOldWidth / (imgOldHeight / aStandardSize) + 0.5)) / 2 + 0.5;
676 }
677
678 aScaledSize = Size( imgNewWidth, imgNewHeight );
679 aRet.Scale( aScaledSize, BmpScaleFlag::BestQuality );
680 }
681 else
682 {
683 imgposX = (aStandardSize - imgOldWidth) / 2 + 0.5;
684 imgposY = (aStandardSize - imgOldHeight) / 2 + 0.5;
685 }
686
687 Size aStdSize( aStandardSize, aStandardSize );
688 tools::Rectangle aRect(aEmptyPoint, aStdSize );
689
690 ScopedVclPtrInstance< VirtualDevice > aVirDevice(*Application::GetDefaultDevice(),
691 DeviceFormat::DEFAULT, DeviceFormat::BITMASK);
692 aVirDevice->SetOutputSizePixel( aStdSize );
693 aVirDevice->SetFillColor( COL_TRANSPARENT );
694 aVirDevice->SetLineColor( COL_TRANSPARENT );
695
696 // Draw a rect into virDevice
697 aVirDevice->DrawRect( aRect );
698 Point aPointPixel( (long)imgposX, (long)imgposY );
699 aVirDevice->DrawBitmapEx( aPointPixel, aRet );
700 aRet = aVirDevice->GetBitmapEx( aEmptyPoint, aStdSize );
701
702 return aRet;
703 }
704
705 sal_uInt8 BitmapEx::GetTransparency(sal_Int32 nX, sal_Int32 nY) const
706 {
707 sal_uInt8 nTransparency(0xff);
708
709 if(!aBitmap.IsEmpty())
710 {
711 if(nX >= 0 && nX < aBitmapSize.Width() && nY >= 0 && nY < aBitmapSize.Height())
712 {
713 switch(eTransparent)
714 {
715 case TransparentType::NONE:
716 {
717 // Not transparent, ergo all covered
718 nTransparency = 0x00;
719 break;
720 }
721 case TransparentType::Color:
722 {
723 Bitmap aTestBitmap(aBitmap);
724 Bitmap::ScopedReadAccess pRead(aTestBitmap);
725
726 if(pRead)
727 {
728 const Color aColor = pRead->GetColor(nY, nX);
729
730 // If color is not equal to TransparentColor, we are not transparent
731 if(aColor != aTransparentColor)
732 {
733 nTransparency = 0x00;
734 }
735
736 }
737 break;
738 }
739 case TransparentType::Bitmap:
740 {
741 if(!aMask.IsEmpty())
742 {
743 Bitmap aTestBitmap(aMask);
744 Bitmap::ScopedReadAccess pRead(aTestBitmap);
745
746 if(pRead)
747 {
748 const BitmapColor aBitmapColor(pRead->GetPixel(nY, nX));
749
750 if(bAlpha)
751 {
752 nTransparency = aBitmapColor.GetIndex();
753 }
754 else
755 {
756 if(0x00 == aBitmapColor.GetIndex())
757 {
758 nTransparency = 0x00;
759 }
760 }
761 }
762 }
763 break;
764 }
765 }
766 }
767 }
768
769 return nTransparency;
770 }
771
772 // Shift alpha transparent pixels between cppcanvas/ implementations
773 // and vcl in a generally grotesque and under-performing fashion
774 bool BitmapEx::Create( const css::uno::Reference< css::rendering::XBitmapCanvas > &xBitmapCanvas,
775 const Size &rSize )
776 {
777 uno::Reference< beans::XFastPropertySet > xFastPropertySet( xBitmapCanvas, uno::UNO_QUERY );
778 if( xFastPropertySet.get() )
779 {
780 // 0 means get BitmapEx
781 uno::Any aAny = xFastPropertySet->getFastPropertyValue( 0 );
782 std::unique_ptr<BitmapEx> xBitmapEx(reinterpret_cast<BitmapEx*>(*o3tl::doAccess<sal_Int64>(aAny)));
783 if( xBitmapEx )
784 {
785 *this = *xBitmapEx;
786 return true;
787 }
788 }
789
790 SalBitmap* pSalBmp = nullptr;
791 SalBitmap* pSalMask = nullptr;
792
793 pSalBmp = ImplGetSVData()->mpDefInst->CreateSalBitmap();
794
795 Size aLocalSize(rSize);
796 if( pSalBmp->Create( xBitmapCanvas, aLocalSize ) )
797 {
798 pSalMask = ImplGetSVData()->mpDefInst->CreateSalBitmap();
799 if ( pSalMask->Create( xBitmapCanvas, aLocalSize, true ) )
800 {
801 *this = BitmapEx(Bitmap(pSalBmp), Bitmap(pSalMask) );
802 return true;
803 }
804 else
805 {
806 delete pSalMask;
807 *this = BitmapEx(Bitmap(pSalBmp));
808 return true;
809 }
810 }
811
812 delete pSalBmp;
813 delete pSalMask;
814
815 return false;
816 }
817
818 namespace
819 {
820 Bitmap impTransformBitmap(
821 const Bitmap& rSource,
822 const Size& rDestinationSize,
823 const basegfx::B2DHomMatrix& rTransform,
824 bool bSmooth)
825 {
826 Bitmap aDestination(rDestinationSize, 24);
827 Bitmap::ScopedWriteAccess xWrite(aDestination);
828
829 if(xWrite)
830 {
831 Bitmap::ScopedReadAccess xRead(const_cast< Bitmap& >(rSource));
832
833 if (xRead)
834 {
835 const Size aDestinationSizePixel(aDestination.GetSizePixel());
836 const BitmapColor aOutside(BitmapColor(0xff, 0xff, 0xff));
837
838 for(long y(0); y < aDestinationSizePixel.getHeight(); y++)
839 {
840 for(long x(0); x < aDestinationSizePixel.getWidth(); x++)
841 {
842 const basegfx::B2DPoint aSourceCoor(rTransform * basegfx::B2DPoint(x, y));
843
844 if(bSmooth)
845 {
846 xWrite->SetPixel(
847 y,
848 x,
849 xRead->GetInterpolatedColorWithFallback(
850 aSourceCoor.getY(),
851 aSourceCoor.getX(),
852 aOutside));
853 }
854 else
855 {
856 // this version does the correct <= 0.0 checks, so no need
857 // to do the static_cast< sal_Int32 > self and make an error
858 xWrite->SetPixel(
859 y,
860 x,
861 xRead->GetColorWithFallback(
862 aSourceCoor.getY(),
863 aSourceCoor.getX(),
864 aOutside));
865 }
866 }
867 }
868 }
869 }
870
871 rSource.AdaptBitCount(aDestination);
872
873 return aDestination;
874 }
875 } // end of anonymous namespace
876
877 BitmapEx BitmapEx::TransformBitmapEx(
878 double fWidth,
879 double fHeight,
880 const basegfx::B2DHomMatrix& rTransformation,
881 bool bSmooth) const
882 {
883 if(fWidth <= 1 || fHeight <= 1)
884 return BitmapEx();
885
886 // force destination to 24 bit, we want to smooth output
887 const Size aDestinationSize(basegfx::fround(fWidth), basegfx::fround(fHeight));
888 const Bitmap aDestination(impTransformBitmap(GetBitmap(), aDestinationSize, rTransformation, bSmooth));
889
890 // create mask
891 if(IsTransparent())
892 {
893 if(IsAlpha())
894 {
895 const Bitmap aAlpha(impTransformBitmap(GetAlpha().GetBitmap(), aDestinationSize, rTransformation, bSmooth));
896 return BitmapEx(aDestination, AlphaMask(aAlpha));
897 }
898 else
899 {
900 const Bitmap aLclMask(impTransformBitmap(GetMask(), aDestinationSize, rTransformation, false));
901 return BitmapEx(aDestination, aLclMask);
902 }
903 }
904
905 return BitmapEx(aDestination);
906 }
907
908 BitmapEx BitmapEx::getTransformed(
909 const basegfx::B2DHomMatrix& rTransformation,
910 const basegfx::B2DRange& rVisibleRange,
911 double fMaximumArea,
912 bool bSmooth) const
913 {
914 BitmapEx aRetval;
915
916 if(IsEmpty())
917 return aRetval;
918
919 const sal_uInt32 nSourceWidth(GetSizePixel().Width());
920 const sal_uInt32 nSourceHeight(GetSizePixel().Height());
921
922 if(!nSourceWidth || !nSourceHeight)
923 return aRetval;
924
925 // Get aOutlineRange
926 basegfx::B2DRange aOutlineRange(0.0, 0.0, 1.0, 1.0);
927
928 aOutlineRange.transform(rTransformation);
929
930 // create visible range from it by moving from relative to absolute
931 basegfx::B2DRange aVisibleRange(rVisibleRange);
932
933 aVisibleRange.transform(
934 basegfx::tools::createScaleTranslateB2DHomMatrix(
935 aOutlineRange.getRange(),
936 aOutlineRange.getMinimum()));
937
938 // get target size (which is visible range's size)
939 double fWidth(aVisibleRange.getWidth());
940 double fHeight(aVisibleRange.getHeight());
941
942 if(fWidth < 1.0 || fHeight < 1.0)
943 {
944 return aRetval;
945 }
946
947 // test if discrete size (pixel) maybe too big and limit it
948 const double fArea(fWidth * fHeight);
949 const bool bNeedToReduce(basegfx::fTools::more(fArea, fMaximumArea));
950 double fReduceFactor(1.0);
951
952 if(bNeedToReduce)
953 {
954 fReduceFactor = sqrt(fMaximumArea / fArea);
955 fWidth *= fReduceFactor;
956 fHeight *= fReduceFactor;
957 }
958
959 // Build complete transform from source pixels to target pixels.
960 // Start by scaling from source pixel size to unit coordinates
961 basegfx::B2DHomMatrix aTransform(
962 basegfx::tools::createScaleB2DHomMatrix(
963 1.0 / nSourceWidth,
964 1.0 / nSourceHeight));
965
966 // multiply with given transform which leads from unit coordinates inside
967 // aOutlineRange
968 aTransform = rTransformation * aTransform;
969
970 // subtract top-left of absolute VisibleRange
971 aTransform.translate(
972 -aVisibleRange.getMinX(),
973 -aVisibleRange.getMinY());
974
975 // scale to target pixels (if needed)
976 if(bNeedToReduce)
977 {
978 aTransform.scale(fReduceFactor, fReduceFactor);
979 }
980
981 // invert to get transformation from target pixel coordinates to source pixels
982 aTransform.invert();
983
984 // create bitmap using source, destination and linear back-transformation
985 aRetval = TransformBitmapEx(fWidth, fHeight, aTransform, bSmooth);
986
987 return aRetval;
988 }
989
990 BitmapEx BitmapEx::ModifyBitmapEx(const basegfx::BColorModifierStack& rBColorModifierStack) const
991 {
992 Bitmap aChangedBitmap(GetBitmap());
993 bool bDone(false);
994
995 for(sal_uInt32 a(rBColorModifierStack.count()); a && !bDone; )
996 {
997 const basegfx::BColorModifierSharedPtr& rModifier = rBColorModifierStack.getBColorModifier(--a);
998 const basegfx::BColorModifier_replace* pReplace = dynamic_cast< const basegfx::BColorModifier_replace* >(rModifier.get());
999
1000 if(pReplace)
1001 {
1002 // complete replace
1003 if(IsTransparent())
1004 {
1005 // clear bitmap with dest color
1006 if(aChangedBitmap.GetBitCount() <= 8)
1007 {
1008 // do NOT use erase; for e.g. 8bit Bitmaps, the nearest color to the given
1009 // erase color is determined and used -> this may be different from what is
1010 // wanted here. Better create a new bitmap with the needed color explicitly
1011 Bitmap::ScopedReadAccess xReadAccess(aChangedBitmap);
1012 OSL_ENSURE(xReadAccess, "Got no Bitmap ReadAccess ?!?");
1013
1014 if(xReadAccess)
1015 {
1016 BitmapPalette aNewPalette(xReadAccess->GetPalette());
1017 aNewPalette[0] = BitmapColor(Color(pReplace->getBColor()));
1018 aChangedBitmap = Bitmap(
1019 aChangedBitmap.GetSizePixel(),
1020 aChangedBitmap.GetBitCount(),
1021 &aNewPalette);
1022 }
1023 }
1024 else
1025 {
1026 aChangedBitmap.Erase(Color(pReplace->getBColor()));
1027 }
1028 }
1029 else
1030 {
1031 // erase bitmap, caller will know to paint direct
1032 aChangedBitmap.SetEmpty();
1033 }
1034
1035 bDone = true;
1036 }
1037 else
1038 {
1039 Bitmap::ScopedWriteAccess xContent(aChangedBitmap);
1040
1041 if(xContent)
1042 {
1043 const double fConvertColor(1.0 / 255.0);
1044
1045 if(xContent->HasPalette())
1046 {
1047 const sal_uInt16 nCount(xContent->GetPaletteEntryCount());
1048
1049 for(sal_uInt16 b(0); b < nCount; b++)
1050 {
1051 const BitmapColor& rCol = xContent->GetPaletteColor(b);
1052 const basegfx::BColor aBSource(
1053 rCol.GetRed() * fConvertColor,
1054 rCol.GetGreen() * fConvertColor,
1055 rCol.GetBlue() * fConvertColor);
1056 const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource));
1057 xContent->SetPaletteColor(b, BitmapColor(Color(aBDest)));
1058 }
1059 }
1060 else if(ScanlineFormat::N24BitTcBgr == xContent->GetScanlineFormat())
1061 {
1062 for(sal_uInt32 y(0); y < (sal_uInt32)xContent->Height(); y++)
1063 {
1064 Scanline pScan = xContent->GetScanline(y);
1065
1066 for(sal_uInt32 x(0); x < (sal_uInt32)xContent->Width(); x++)
1067 {
1068 const basegfx::BColor aBSource(
1069 *(pScan + 2)* fConvertColor,
1070 *(pScan + 1) * fConvertColor,
1071 *pScan * fConvertColor);
1072 const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource));
1073 *pScan++ = static_cast< sal_uInt8 >(aBDest.getBlue() * 255.0);
1074 *pScan++ = static_cast< sal_uInt8 >(aBDest.getGreen() * 255.0);
1075 *pScan++ = static_cast< sal_uInt8 >(aBDest.getRed() * 255.0);
1076 }
1077 }
1078 }
1079 else if(ScanlineFormat::N24BitTcRgb == xContent->GetScanlineFormat())
1080 {
1081 for(sal_uInt32 y(0); y < (sal_uInt32)xContent->Height(); y++)
1082 {
1083 Scanline pScan = xContent->GetScanline(y);
1084
1085 for(sal_uInt32 x(0); x < (sal_uInt32)xContent->Width(); x++)
1086 {
1087 const basegfx::BColor aBSource(
1088 *pScan * fConvertColor,
1089 *(pScan + 1) * fConvertColor,
1090 *(pScan + 2) * fConvertColor);
1091 const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource));
1092 *pScan++ = static_cast< sal_uInt8 >(aBDest.getRed() * 255.0);
1093 *pScan++ = static_cast< sal_uInt8 >(aBDest.getGreen() * 255.0);
1094 *pScan++ = static_cast< sal_uInt8 >(aBDest.getBlue() * 255.0);
1095 }
1096 }
1097 }
1098 else
1099 {
1100 for(sal_uInt32 y(0); y < (sal_uInt32)xContent->Height(); y++)
1101 {
1102 for(sal_uInt32 x(0); x < (sal_uInt32)xContent->Width(); x++)
1103 {
1104 const BitmapColor aBMCol(xContent->GetColor(y, x));
1105 const basegfx::BColor aBSource(
1106 (double)aBMCol.GetRed() * fConvertColor,
1107 (double)aBMCol.GetGreen() * fConvertColor,
1108 (double)aBMCol.GetBlue() * fConvertColor);
1109 const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource));
1110
1111 xContent->SetPixel(y, x, BitmapColor(Color(aBDest)));
1112 }
1113 }
1114 }
1115 }
1116 }
1117 }
1118
1119 if(aChangedBitmap.IsEmpty())
1120 {
1121 return BitmapEx();
1122 }
1123 else
1124 {
1125 if(IsTransparent())
1126 {
1127 if(IsAlpha())
1128 {
1129 return BitmapEx(aChangedBitmap, GetAlpha());
1130 }
1131 else
1132 {
1133 return BitmapEx(aChangedBitmap, GetMask());
1134 }
1135 }
1136 else
1137 {
1138 return BitmapEx(aChangedBitmap);
1139 }
1140 }
1141 }
1142
1143 BitmapEx createBlendFrame(
1144 const Size& rSize,
1145 sal_uInt8 nAlpha,
1146 Color aColorTopLeft,
1147 Color aColorBottomRight)
1148 {
1149 const sal_uInt32 nW(rSize.Width());
1150 const sal_uInt32 nH(rSize.Height());
1151
1152 if(nW || nH)
1153 {
1154 Color aColTopRight(aColorTopLeft);
1155 Color aColBottomLeft(aColorTopLeft);
1156 const sal_uInt32 nDE(nW + nH);
1157
1158 aColTopRight.Merge(aColorBottomRight, 255 - sal_uInt8((nW * 255) / nDE));
1159 aColBottomLeft.Merge(aColorBottomRight, 255 - sal_uInt8((nH * 255) / nDE));
1160
1161 return createBlendFrame(rSize, nAlpha, aColorTopLeft, aColTopRight, aColorBottomRight, aColBottomLeft);
1162 }
1163
1164 return BitmapEx();
1165 }
1166
1167 BitmapEx createBlendFrame(
1168 const Size& rSize,
1169 sal_uInt8 nAlpha,
1170 Color aColorTopLeft,
1171 Color aColorTopRight,
1172 Color aColorBottomRight,
1173 Color aColorBottomLeft)
1174 {
1175 BlendFrameCache* pBlendFrameCache = ImplGetBlendFrameCache();
1176
1177 if(pBlendFrameCache->m_aLastSize == rSize
1178 && pBlendFrameCache->m_nLastAlpha == nAlpha
1179 && pBlendFrameCache->m_aLastColorTopLeft == aColorTopLeft
1180 && pBlendFrameCache->m_aLastColorTopRight == aColorTopRight
1181 && pBlendFrameCache->m_aLastColorBottomRight == aColorBottomRight
1182 && pBlendFrameCache->m_aLastColorBottomLeft == aColorBottomLeft)
1183 {
1184 return pBlendFrameCache->m_aLastResult;
1185 }
1186
1187 pBlendFrameCache->m_aLastSize = rSize;
1188 pBlendFrameCache->m_nLastAlpha = nAlpha;
1189 pBlendFrameCache->m_aLastColorTopLeft = aColorTopLeft;
1190 pBlendFrameCache->m_aLastColorTopRight = aColorTopRight;
1191 pBlendFrameCache->m_aLastColorBottomRight = aColorBottomRight;
1192 pBlendFrameCache->m_aLastColorBottomLeft = aColorBottomLeft;
1193 pBlendFrameCache->m_aLastResult.Clear();
1194
1195 const long nW(rSize.Width());
1196 const long nH(rSize.Height());
1197
1198 if(nW > 1 && nH > 1)
1199 {
1200 sal_uInt8 aEraseTrans(0xff);
1201 Bitmap aContent(rSize, 24);
1202 AlphaMask aAlpha(rSize, &aEraseTrans);
1203
1204 aContent.Erase(COL_BLACK);
1205
1206 Bitmap::ScopedWriteAccess pContent(aContent);
1207 AlphaMask::ScopedWriteAccess pAlpha(aAlpha);
1208
1209 if(pContent && pAlpha)
1210 {
1211 long x(0);
1212 long y(0);
1213
1214 // x == 0, y == 0, top-left corner
1215 pContent->SetPixel(0, 0, aColorTopLeft);
1216 pAlpha->SetPixelIndex(0, 0, nAlpha);
1217
1218 // y == 0, top line left to right
1219 for(x = 1; x < nW - 1; x++)
1220 {
1221 Color aMix(aColorTopLeft);
1222
1223 aMix.Merge(aColorTopRight, 255 - sal_uInt8((x * 255) / nW));
1224 pContent->SetPixel(0, x, aMix);
1225 pAlpha->SetPixelIndex(0, x, nAlpha);
1226 }
1227
1228 // x == nW - 1, y == 0, top-right corner
1229 // #i123690# Caution! When nW is 1, x == nW is possible (!)
1230 if(x < nW)
1231 {
1232 pContent->SetPixel(0, x, aColorTopRight);
1233 pAlpha->SetPixelIndex(0, x, nAlpha);
1234 }
1235
1236 // x == 0 and nW - 1, left and right line top-down
1237 for(y = 1; y < nH - 1; y++)
1238 {
1239 Color aMixA(aColorTopLeft);
1240
1241 aMixA.Merge(aColorBottomLeft, 255 - sal_uInt8((y * 255) / nH));
1242 pContent->SetPixel(y, 0, aMixA);
1243 pAlpha->SetPixelIndex(y, 0, nAlpha);
1244
1245 // #i123690# Caution! When nW is 1, x == nW is possible (!)
1246 if(x < nW)
1247 {
1248 Color aMixB(aColorTopRight);
1249
1250 aMixB.Merge(aColorBottomRight, 255 - sal_uInt8((y * 255) / nH));
1251 pContent->SetPixel(y, x, aMixB);
1252 pAlpha->SetPixelIndex(y, x, nAlpha);
1253 }
1254 }
1255
1256 // #i123690# Caution! When nH is 1, y == nH is possible (!)
1257 if(y < nH)
1258 {
1259 // x == 0, y == nH - 1, bottom-left corner
1260 pContent->SetPixel(y, 0, aColorBottomLeft);
1261 pAlpha->SetPixelIndex(y, 0, nAlpha);
1262
1263 // y == nH - 1, bottom line left to right
1264 for(x = 1; x < nW - 1; x++)
1265 {
1266 Color aMix(aColorBottomLeft);
1267
1268 aMix.Merge(aColorBottomRight, 255 - sal_uInt8(((x - 0)* 255) / nW));
1269 pContent->SetPixel(y, x, aMix);
1270 pAlpha->SetPixelIndex(y, x, nAlpha);
1271 }
1272
1273 // x == nW - 1, y == nH - 1, bottom-right corner
1274 // #i123690# Caution! When nW is 1, x == nW is possible (!)
1275 if(x < nW)
1276 {
1277 pContent->SetPixel(y, x, aColorBottomRight);
1278 pAlpha->SetPixelIndex(y, x, nAlpha);
1279 }
1280 }
1281
1282 pContent.reset();
1283 pAlpha.reset();
1284
1285 pBlendFrameCache->m_aLastResult = BitmapEx(aContent, aAlpha);
1286 }
1287 }
1288
1289 return pBlendFrameCache->m_aLastResult;
1290 }
1291
1292 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE