?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update emoji autocorrect entries from po-files
[LibreOffice.git] / vcl / source / gdi / bitmap.cxx
blob45ecf09c124af224575d9c4a0373dbf41c2338a7
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 <algorithm>
21 #include <rtl/crc.h>
22 #include <tools/stream.hxx>
23 #include <tools/poly.hxx>
24 #include <tools/rc.h>
25 #include <vcl/salbtype.hxx>
26 #include <vcl/bmpacc.hxx>
27 #include <vcl/outdev.hxx>
28 #include <vcl/bitmap.hxx>
29 #include <vcl/bitmapex.hxx>
30 #include <vcl/svapp.hxx>
31 #include <vcl/image.hxx>
32
33 #include <impbmp.hxx>
34 #include <salbmp.hxx>
35 #include <boost/scoped_array.hpp>
36
37 Bitmap::Bitmap() :
38 mpImpBmp( NULL )
39 {
40 }
41
42 Bitmap::Bitmap( const ResId& rResId ) :
43 mpImpBmp( NULL )
44 {
45 const BitmapEx aBmpEx( rResId );
46
47 if( !aBmpEx.IsEmpty() )
48 *this = aBmpEx.GetBitmap();
49 }
50
51 Bitmap::Bitmap( const Bitmap& rBitmap ) :
52 maPrefMapMode ( rBitmap.maPrefMapMode ),
53 maPrefSize ( rBitmap.maPrefSize )
54 {
55 mpImpBmp = rBitmap.mpImpBmp;
56
57 if ( mpImpBmp )
58 mpImpBmp->ImplIncRefCount();
59 }
60
61 Bitmap::Bitmap( SalBitmap* pSalBitmap )
62 {
63 mpImpBmp = new ImpBitmap(pSalBitmap);
64 maPrefMapMode = MapMode( MAP_PIXEL );
65 maPrefSize = mpImpBmp->ImplGetSize();
66 }
67
68 Bitmap::Bitmap( const Size& rSizePixel, sal_uInt16 nBitCount, const BitmapPalette* pPal )
69 {
70 if( rSizePixel.Width() && rSizePixel.Height() )
71 {
72 BitmapPalette aPal;
73 BitmapPalette* pRealPal = NULL;
74
75 if( nBitCount <= 8 )
76 {
77 if( !pPal )
78 {
79 if( 1 == nBitCount )
80 {
81 aPal.SetEntryCount( 2 );
82 aPal[ 0 ] = Color( COL_BLACK );
83 aPal[ 1 ] = Color( COL_WHITE );
84 }
85 else if( ( 4 == nBitCount ) || ( 8 == nBitCount ) )
86 {
87 aPal.SetEntryCount( 1 << nBitCount );
88 aPal[ 0 ] = Color( COL_BLACK );
89 aPal[ 1 ] = Color( COL_BLUE );
90 aPal[ 2 ] = Color( COL_GREEN );
91 aPal[ 3 ] = Color( COL_CYAN );
92 aPal[ 4 ] = Color( COL_RED );
93 aPal[ 5 ] = Color( COL_MAGENTA );
94 aPal[ 6 ] = Color( COL_BROWN );
95 aPal[ 7 ] = Color( COL_GRAY );
96 aPal[ 8 ] = Color( COL_LIGHTGRAY );
97 aPal[ 9 ] = Color( COL_LIGHTBLUE );
98 aPal[ 10 ] = Color( COL_LIGHTGREEN );
99 aPal[ 11 ] = Color( COL_LIGHTCYAN );
100 aPal[ 12 ] = Color( COL_LIGHTRED );
101 aPal[ 13 ] = Color( COL_LIGHTMAGENTA );
102 aPal[ 14 ] = Color( COL_YELLOW );
103 aPal[ 15 ] = Color( COL_WHITE );
104
105 // Create dither palette
106 if( 8 == nBitCount )
107 {
108 sal_uInt16 nActCol = 16;
109
110 for( sal_uInt16 nB = 0; nB < 256; nB += 51 )
111 for( sal_uInt16 nG = 0; nG < 256; nG += 51 )
112 for( sal_uInt16 nR = 0; nR < 256; nR += 51 )
113 aPal[ nActCol++ ] = BitmapColor( (sal_uInt8) nR, (sal_uInt8) nG, (sal_uInt8) nB );
114
115 // Set standard Office colors
116 aPal[ nActCol++ ] = BitmapColor( 0, 184, 255 );
117 }
118 }
119 }
120 else
121 pRealPal = const_cast<BitmapPalette*>(pPal);
122 }
123
124 mpImpBmp = new ImpBitmap;
125 mpImpBmp->ImplCreate( rSizePixel, nBitCount, pRealPal ? *pRealPal : aPal );
126 }
127 else
128 mpImpBmp = NULL;
129 }
130
131 Bitmap::~Bitmap()
132 {
133 ImplReleaseRef();
134 }
135
136 const BitmapPalette& Bitmap::GetGreyPalette( int nEntries )
137 {
138 static BitmapPalette aGreyPalette2;
139 static BitmapPalette aGreyPalette4;
140 static BitmapPalette aGreyPalette16;
141 static BitmapPalette aGreyPalette256;
142
143 // Create greyscale palette with 2, 4, 16 or 256 entries
144 if( 2 == nEntries || 4 == nEntries || 16 == nEntries || 256 == nEntries )
145 {
146 if( 2 == nEntries )
147 {
148 if( !aGreyPalette2.GetEntryCount() )
149 {
150 aGreyPalette2.SetEntryCount( 2 );
151 aGreyPalette2[ 0 ] = BitmapColor( 0, 0, 0 );
152 aGreyPalette2[ 1 ] = BitmapColor( 255, 255, 255 );
153 }
154
155 return aGreyPalette2;
156 }
157 else if( 4 == nEntries )
158 {
159 if( !aGreyPalette4.GetEntryCount() )
160 {
161 aGreyPalette4.SetEntryCount( 4 );
162 aGreyPalette4[ 0 ] = BitmapColor( 0, 0, 0 );
163 aGreyPalette4[ 1 ] = BitmapColor( 85, 85, 85 );
164 aGreyPalette4[ 2 ] = BitmapColor( 170, 170, 170 );
165 aGreyPalette4[ 3 ] = BitmapColor( 255, 255, 255 );
166 }
167
168 return aGreyPalette4;
169 }
170 else if( 16 == nEntries )
171 {
172 if( !aGreyPalette16.GetEntryCount() )
173 {
174 sal_uInt8 cGrey = 0, cGreyInc = 17;
175
176 aGreyPalette16.SetEntryCount( 16 );
177
178 for( sal_uInt16 i = 0; i < 16; i++, cGrey = sal::static_int_cast<sal_uInt8>(cGrey + cGreyInc) )
179 aGreyPalette16[ i ] = BitmapColor( cGrey, cGrey, cGrey );
180 }
181
182 return aGreyPalette16;
183 }
184 else
185 {
186 if( !aGreyPalette256.GetEntryCount() )
187 {
188 aGreyPalette256.SetEntryCount( 256 );
189
190 for( sal_uInt16 i = 0; i < 256; i++ )
191 aGreyPalette256[ i ] = BitmapColor( (sal_uInt8) i, (sal_uInt8) i, (sal_uInt8) i );
192 }
193
194 return aGreyPalette256;
195 }
196 }
197 else
198 {
199 OSL_FAIL( "Bitmap::GetGreyPalette: invalid entry count (2/4/16/256 allowed)" );
200 return aGreyPalette2;
201 }
202 }
203
204 bool BitmapPalette::IsGreyPalette() const
205 {
206 const int nEntryCount = GetEntryCount();
207 if( !nEntryCount ) // NOTE: an empty palette means 1:1 mapping
208 return true;
209 // See above: only certain entry values will result in a valid call to GetGreyPalette
210 if( nEntryCount == 2 || nEntryCount == 4 || nEntryCount == 16 || nEntryCount == 256 )
211 {
212 const BitmapPalette& rGreyPalette = Bitmap::GetGreyPalette( nEntryCount );
213 if( rGreyPalette == *this )
214 return true;
215 }
216
217 bool bRet = false;
218 // TODO: is it worth to compare the entries for the general case?
219 if (nEntryCount == 2)
220 {
221 const BitmapColor& rCol0(mpBitmapColor[0]);
222 const BitmapColor& rCol1(mpBitmapColor[1]);
223 bRet = rCol0.GetRed() == rCol0.GetGreen() && rCol0.GetRed() == rCol0.GetBlue() &&
224 rCol1.GetRed() == rCol1.GetGreen() && rCol1.GetRed() == rCol1.GetBlue();
225 }
226 return bRet;
227 }
228
229 Bitmap& Bitmap::operator=( const Bitmap& rBitmap )
230 {
231 if (this == &rBitmap)
232 return *this;
233
234 maPrefSize = rBitmap.maPrefSize;
235 maPrefMapMode = rBitmap.maPrefMapMode;
236
237 if ( rBitmap.mpImpBmp )
238 rBitmap.mpImpBmp->ImplIncRefCount();
239
240 ImplReleaseRef();
241 mpImpBmp = rBitmap.mpImpBmp;
242
243 return *this;
244 }
245
246 bool Bitmap::IsEqual( const Bitmap& rBmp ) const
247 {
248 return(IsSameInstance(rBmp) || // Includes both are nullptr
249 (rBmp.mpImpBmp && mpImpBmp && mpImpBmp->ImplIsEqual(*rBmp.mpImpBmp)));
250 }
251
252 void Bitmap::SetEmpty()
253 {
254 maPrefMapMode = MapMode();
255 maPrefSize = Size();
256
257 ImplReleaseRef();
258 mpImpBmp = NULL;
259 }
260
261 Size Bitmap::GetSizePixel() const
262 {
263 return( mpImpBmp ? mpImpBmp->ImplGetSize() : Size() );
264 }
265
266 sal_uInt16 Bitmap::GetBitCount() const
267 {
268 return( mpImpBmp ? mpImpBmp->ImplGetBitCount() : 0 );
269 }
270
271 bool Bitmap::HasGreyPalette() const
272 {
273 const sal_uInt16 nBitCount = GetBitCount();
274 bool bRet = nBitCount == 1;
275
276 BitmapInfoAccess* pIAcc = const_cast<Bitmap*>(this)->AcquireInfoAccess();
277
278 if( pIAcc )
279 {
280 bRet = pIAcc->HasPalette() && pIAcc->GetPalette().IsGreyPalette();
281 ReleaseAccess( pIAcc );
282 }
283
284 return bRet;
285 }
286
287 BitmapChecksum Bitmap::GetChecksum() const
288 {
289 BitmapChecksum nRet = 0;
290
291 if( mpImpBmp )
292 {
293 nRet = mpImpBmp->ImplGetChecksum();
294 }
295
296 return nRet;
297 }
298
299 void Bitmap::ImplReleaseRef()
300 {
301 if( mpImpBmp )
302 {
303 if( mpImpBmp->ImplGetRefCount() > 1UL )
304 mpImpBmp->ImplDecRefCount();
305 else
306 {
307 delete mpImpBmp;
308 mpImpBmp = NULL;
309 }
310 }
311 }
312
313 void Bitmap::ImplMakeUnique()
314 {
315 if( mpImpBmp && mpImpBmp->ImplGetRefCount() > 1UL )
316 {
317 ImpBitmap* pOldImpBmp = mpImpBmp;
318
319 pOldImpBmp->ImplDecRefCount();
320
321 mpImpBmp = new ImpBitmap;
322 mpImpBmp->ImplCreate( *pOldImpBmp );
323 }
324 }
325
326 void Bitmap::ImplAssignWithSize( const Bitmap& rBitmap )
327 {
328 const Size aOldSizePix( GetSizePixel() );
329 const Size aNewSizePix( rBitmap.GetSizePixel() );
330 const MapMode aOldMapMode( maPrefMapMode );
331 Size aNewPrefSize;
332
333 if( ( aOldSizePix != aNewSizePix ) && aOldSizePix.Width() && aOldSizePix.Height() )
334 {
335 aNewPrefSize.Width() = FRound( maPrefSize.Width() * aNewSizePix.Width() / aOldSizePix.Width() );
336 aNewPrefSize.Height() = FRound( maPrefSize.Height() * aNewSizePix.Height() / aOldSizePix.Height() );
337 }
338 else
339 aNewPrefSize = maPrefSize;
340
341 *this = rBitmap;
342
343 maPrefSize = aNewPrefSize;
344 maPrefMapMode = aOldMapMode;
345 }
346
347
348 void Bitmap::ImplSetImpBitmap( ImpBitmap* pImpBmp )
349 {
350 if( pImpBmp != mpImpBmp )
351 {
352 ImplReleaseRef();
353 mpImpBmp = pImpBmp;
354 }
355 }
356
357 BitmapInfoAccess* Bitmap::AcquireInfoAccess()
358 {
359 BitmapInfoAccess* pInfoAccess = new BitmapInfoAccess( *this );
360
361 if( !*pInfoAccess )
362 {
363 delete pInfoAccess;
364 pInfoAccess = NULL;
365 }
366
367 return pInfoAccess;
368 }
369
370 BitmapReadAccess* Bitmap::AcquireReadAccess()
371 {
372 BitmapReadAccess* pReadAccess = new BitmapReadAccess( *this );
373
374 if( !*pReadAccess )
375 {
376 delete pReadAccess;
377 pReadAccess = NULL;
378 }
379
380 return pReadAccess;
381 }
382
383 BitmapWriteAccess* Bitmap::AcquireWriteAccess()
384 {
385 BitmapWriteAccess* pWriteAccess = new BitmapWriteAccess( *this );
386
387 if( !*pWriteAccess )
388 {
389 delete pWriteAccess;
390 pWriteAccess = NULL;
391 }
392
393 return pWriteAccess;
394 }
395
396 void Bitmap::ReleaseAccess( BitmapInfoAccess* pBitmapAccess )
397 {
398 delete pBitmapAccess;
399 }
400
401 bool Bitmap::Erase(const Color& rFillColor)
402 {
403 if (IsEmpty())
404 return true;
405
406 Bitmap::ScopedWriteAccess pWriteAcc(*this);
407 bool bRet = false;
408
409 if (pWriteAcc)
410 {
411 const sal_uLong nFormat = pWriteAcc->GetScanlineFormat();
412 sal_uInt8 cIndex = 0;
413 bool bFast = false;
414
415 switch (nFormat)
416 {
417 case BMP_FORMAT_1BIT_MSB_PAL:
418 case BMP_FORMAT_1BIT_LSB_PAL:
419 {
420 cIndex = static_cast<sal_uInt8>(pWriteAcc->GetBestPaletteIndex(rFillColor));
421 cIndex = (cIndex ? 255 : 0);
422 bFast = true;
423 }
424 break;
425
426 case BMP_FORMAT_4BIT_MSN_PAL:
427 case BMP_FORMAT_4BIT_LSN_PAL:
428 {
429 cIndex = static_cast<sal_uInt8>(pWriteAcc->GetBestPaletteIndex(rFillColor));
430 cIndex = cIndex | ( cIndex << 4 );
431 bFast = true;
432 }
433 break;
434
435 case BMP_FORMAT_8BIT_PAL:
436 {
437 cIndex = static_cast<sal_uInt8>(pWriteAcc->GetBestPaletteIndex(rFillColor));
438 bFast = true;
439 }
440 break;
441
442 case BMP_FORMAT_24BIT_TC_BGR:
443 case BMP_FORMAT_24BIT_TC_RGB:
444 {
445 if (rFillColor.GetRed() == rFillColor.GetGreen() &&
446 rFillColor.GetRed() == rFillColor.GetBlue())
447 {
448 cIndex = rFillColor.GetRed();
449 bFast = true;
450 }
451 else
452 bFast = false;
453 }
454 break;
455
456 default:
457 bFast = false;
458 break;
459 }
460
461 if( bFast )
462 {
463 const sal_uLong nBufSize = pWriteAcc->GetScanlineSize() * pWriteAcc->Height();
464 memset( pWriteAcc->GetBuffer(), cIndex, nBufSize );
465 }
466 else
467 {
468 Point aTmpPoint;
469 const Rectangle aRect( aTmpPoint, Size( pWriteAcc->Width(), pWriteAcc->Height() ) );
470 pWriteAcc->SetFillColor( rFillColor );
471 pWriteAcc->FillRect( aRect );
472 }
473
474 bRet = true;
475 }
476
477 return bRet;
478 }
479
480 bool Bitmap::Invert()
481 {
482 BitmapWriteAccess* pAcc = AcquireWriteAccess();
483 bool bRet = false;
484
485 if( pAcc )
486 {
487 if( pAcc->HasPalette() )
488 {
489 BitmapPalette aBmpPal( pAcc->GetPalette() );
490 const sal_uInt16 nCount = aBmpPal.GetEntryCount();
491
492 for( sal_uInt16 i = 0; i < nCount; i++ )
493 aBmpPal[ i ].Invert();
494
495 pAcc->SetPalette( aBmpPal );
496 }
497 else
498 {
499 const long nWidth = pAcc->Width();
500 const long nHeight = pAcc->Height();
501
502 for( long nX = 0L; nX < nWidth; nX++ )
503 for( long nY = 0L; nY < nHeight; nY++ )
504 pAcc->SetPixel( nY, nX, pAcc->GetPixel( nY, nX ).Invert() );
505 }
506
507 mpImpBmp->ImplInvalidateChecksum();
508 ReleaseAccess( pAcc );
509 bRet = true;
510 }
511
512 return bRet;
513 }
514
515 bool Bitmap::Mirror( BmpMirrorFlags nMirrorFlags )
516 {
517 bool bHorz( nMirrorFlags & BmpMirrorFlags::Horizontal );
518 bool bVert( nMirrorFlags & BmpMirrorFlags::Vertical );
519 bool bRet = false;
520
521 if( bHorz && !bVert )
522 {
523 BitmapWriteAccess* pAcc = AcquireWriteAccess();
524
525 if( pAcc )
526 {
527 const long nWidth = pAcc->Width();
528 const long nHeight = pAcc->Height();
529 const long nWidth1 = nWidth - 1L;
530 const long nWidth_2 = nWidth >> 1L;
531
532 for( long nY = 0L; nY < nHeight; nY++ )
533 {
534 for( long nX = 0L, nOther = nWidth1; nX < nWidth_2; nX++, nOther-- )
535 {
536 const BitmapColor aTemp( pAcc->GetPixel( nY, nX ) );
537
538 pAcc->SetPixel( nY, nX, pAcc->GetPixel( nY, nOther ) );
539 pAcc->SetPixel( nY, nOther, aTemp );
540 }
541 }
542
543 ReleaseAccess( pAcc );
544 bRet = true;
545 }
546 }
547 else if( bVert && !bHorz )
548 {
549 BitmapWriteAccess* pAcc = AcquireWriteAccess();
550
551 if( pAcc )
552 {
553 const long nScanSize = pAcc->GetScanlineSize();
554 boost::scoped_array<sal_uInt8> pBuffer(new sal_uInt8[ nScanSize ]);
555 const long nHeight = pAcc->Height();
556 const long nHeight1 = nHeight - 1L;
557 const long nHeight_2 = nHeight >> 1L;
558
559 for( long nY = 0L, nOther = nHeight1; nY < nHeight_2; nY++, nOther-- )
560 {
561 memcpy( pBuffer.get(), pAcc->GetScanline( nY ), nScanSize );
562 memcpy( pAcc->GetScanline( nY ), pAcc->GetScanline( nOther ), nScanSize );
563 memcpy( pAcc->GetScanline( nOther ), pBuffer.get(), nScanSize );
564 }
565
566 ReleaseAccess( pAcc );
567 bRet = true;
568 }
569 }
570 else if( bHorz && bVert )
571 {
572 BitmapWriteAccess* pAcc = AcquireWriteAccess();
573
574 if( pAcc )
575 {
576 const long nWidth = pAcc->Width();
577 const long nWidth1 = nWidth - 1L;
578 const long nHeight = pAcc->Height();
579 long nHeight_2 = nHeight >> 1;
580
581 for( long nY = 0L, nOtherY = nHeight - 1L; nY < nHeight_2; nY++, nOtherY-- )
582 {
583 for( long nX = 0L, nOtherX = nWidth1; nX < nWidth; nX++, nOtherX-- )
584 {
585 const BitmapColor aTemp( pAcc->GetPixel( nY, nX ) );
586
587 pAcc->SetPixel( nY, nX, pAcc->GetPixel( nOtherY, nOtherX ) );
588 pAcc->SetPixel( nOtherY, nOtherX, aTemp );
589 }
590 }
591
592 // ggf. noch mittlere Zeile horizontal spiegeln
593 if( nHeight & 1 )
594 {
595 for( long nX = 0L, nOtherX = nWidth1, nWidth_2 = nWidth >> 1; nX < nWidth_2; nX++, nOtherX-- )
596 {
597 const BitmapColor aTemp( pAcc->GetPixel( nHeight_2, nX ) );
598 pAcc->SetPixel( nHeight_2, nX, pAcc->GetPixel( nHeight_2, nOtherX ) );
599 pAcc->SetPixel( nHeight_2, nOtherX, aTemp );
600 }
601 }
602
603 ReleaseAccess( pAcc );
604 bRet = true;
605 }
606 }
607 else
608 bRet = true;
609
610 return bRet;
611 }
612
613 bool Bitmap::Rotate( long nAngle10, const Color& rFillColor )
614 {
615 bool bRet = false;
616
617 nAngle10 %= 3600L;
618 nAngle10 = ( nAngle10 < 0L ) ? ( 3599L + nAngle10 ) : nAngle10;
619
620 if( !nAngle10 )
621 bRet = true;
622 else if( 1800L == nAngle10 )
623 bRet = Mirror( BmpMirrorFlags::Horizontal | BmpMirrorFlags::Vertical );
624 else
625 {
626 BitmapReadAccess* pReadAcc = AcquireReadAccess();
627 Bitmap aRotatedBmp;
628
629 if( pReadAcc )
630 {
631 const Size aSizePix( GetSizePixel() );
632
633 if( ( 900L == nAngle10 ) || ( 2700L == nAngle10 ) )
634 {
635 const Size aNewSizePix( aSizePix.Height(), aSizePix.Width() );
636 Bitmap aNewBmp( aNewSizePix, GetBitCount(), &pReadAcc->GetPalette() );
637 BitmapWriteAccess* pWriteAcc = aNewBmp.AcquireWriteAccess();
638
639 if( pWriteAcc )
640 {
641 const long nWidth = aSizePix.Width();
642 const long nWidth1 = nWidth - 1L;
643 const long nHeight = aSizePix.Height();
644 const long nHeight1 = nHeight - 1L;
645 const long nNewWidth = aNewSizePix.Width();
646 const long nNewHeight = aNewSizePix.Height();
647
648 if( 900L == nAngle10 )
649 {
650 for( long nY = 0L, nOtherX = nWidth1; nY < nNewHeight; nY++, nOtherX-- )
651 for( long nX = 0L, nOtherY = 0L; nX < nNewWidth; nX++ )
652 pWriteAcc->SetPixel( nY, nX, pReadAcc->GetPixel( nOtherY++, nOtherX ) );
653 }
654 else if( 2700L == nAngle10 )
655 {
656 for( long nY = 0L, nOtherX = 0L; nY < nNewHeight; nY++, nOtherX++ )
657 for( long nX = 0L, nOtherY = nHeight1; nX < nNewWidth; nX++ )
658 pWriteAcc->SetPixel( nY, nX, pReadAcc->GetPixel( nOtherY--, nOtherX ) );
659 }
660
661 ReleaseAccess( pWriteAcc );
662 }
663
664 aRotatedBmp = aNewBmp;
665 }
666 else
667 {
668 Point aTmpPoint;
669 Rectangle aTmpRectangle( aTmpPoint, aSizePix );
670 Polygon aPoly( aTmpRectangle );
671 aPoly.Rotate( aTmpPoint, (sal_uInt16) nAngle10 );
672
673 Rectangle aNewBound( aPoly.GetBoundRect() );
674 const Size aNewSizePix( aNewBound.GetSize() );
675 Bitmap aNewBmp( aNewSizePix, GetBitCount(), &pReadAcc->GetPalette() );
676 BitmapWriteAccess* pWriteAcc = aNewBmp.AcquireWriteAccess();
677
678 if( pWriteAcc )
679 {
680 const BitmapColor aFillColor( pWriteAcc->GetBestMatchingColor( rFillColor ) );
681 const double fCosAngle = cos( nAngle10 * F_PI1800 );
682 const double fSinAngle = sin( nAngle10 * F_PI1800 );
683 const double fXMin = aNewBound.Left();
684 const double fYMin = aNewBound.Top();
685 const long nWidth = aSizePix.Width();
686 const long nHeight = aSizePix.Height();
687 const long nNewWidth = aNewSizePix.Width();
688 const long nNewHeight = aNewSizePix.Height();
689 long nX;
690 long nY;
691 long nRotX;
692 long nRotY;
693 boost::scoped_array<long> pCosX(new long[ nNewWidth ]);
694 boost::scoped_array<long> pSinX(new long[ nNewWidth ]);
695 boost::scoped_array<long> pCosY(new long[ nNewHeight ]);
696 boost::scoped_array<long> pSinY(new long[ nNewHeight ]);
697
698 for ( nX = 0; nX < nNewWidth; nX++ )
699 {
700 const double fTmp = ( fXMin + nX ) * 64.;
701
702 pCosX[ nX ] = FRound( fCosAngle * fTmp );
703 pSinX[ nX ] = FRound( fSinAngle * fTmp );
704 }
705
706 for ( nY = 0; nY < nNewHeight; nY++ )
707 {
708 const double fTmp = ( fYMin + nY ) * 64.;
709
710 pCosY[ nY ] = FRound( fCosAngle * fTmp );
711 pSinY[ nY ] = FRound( fSinAngle * fTmp );
712 }
713
714 for( nY = 0L; nY < nNewHeight; nY++ )
715 {
716 long nSinY = pSinY[ nY ];
717 long nCosY = pCosY[ nY ];
718
719 for( nX = 0L; nX < nNewWidth; nX++ )
720 {
721 nRotX = ( pCosX[ nX ] - nSinY ) >> 6;
722 nRotY = ( pSinX[ nX ] + nCosY ) >> 6;
723
724 if ( ( nRotX > -1L ) && ( nRotX < nWidth ) && ( nRotY > -1L ) && ( nRotY < nHeight ) )
725 pWriteAcc->SetPixel( nY, nX, pReadAcc->GetPixel( nRotY, nRotX ) );
726 else
727 pWriteAcc->SetPixel( nY, nX, aFillColor );
728 }
729 }
730
731 ReleaseAccess( pWriteAcc );
732 }
733
734 aRotatedBmp = aNewBmp;
735 }
736
737 ReleaseAccess( pReadAcc );
738 }
739
740 if( ( bRet = !!aRotatedBmp ) )
741 ImplAssignWithSize( aRotatedBmp );
742 }
743
744 return bRet;
745 };
746
747 bool Bitmap::Crop( const Rectangle& rRectPixel )
748 {
749 const Size aSizePix( GetSizePixel() );
750 Rectangle aRect( rRectPixel );
751 bool bRet = false;
752
753 aRect.Intersection( Rectangle( Point(), aSizePix ) );
754
755 if( !aRect.IsEmpty() && aSizePix != aRect.GetSize())
756 {
757 BitmapReadAccess* pReadAcc = AcquireReadAccess();
758
759 if( pReadAcc )
760 {
761 Point aTmpPoint;
762 const Rectangle aNewRect( aTmpPoint, aRect.GetSize() );
763 Bitmap aNewBmp( aNewRect.GetSize(), GetBitCount(), &pReadAcc->GetPalette() );
764 BitmapWriteAccess* pWriteAcc = aNewBmp.AcquireWriteAccess();
765
766 if( pWriteAcc )
767 {
768 const long nOldX = aRect.Left();
769 const long nOldY = aRect.Top();
770 const long nNewWidth = aNewRect.GetWidth();
771 const long nNewHeight = aNewRect.GetHeight();
772
773 for( long nY = 0, nY2 = nOldY; nY < nNewHeight; nY++, nY2++ )
774 for( long nX = 0, nX2 = nOldX; nX < nNewWidth; nX++, nX2++ )
775 pWriteAcc->SetPixel( nY, nX, pReadAcc->GetPixel( nY2, nX2 ) );
776
777 ReleaseAccess( pWriteAcc );
778 bRet = true;
779 }
780
781 ReleaseAccess( pReadAcc );
782
783 if( bRet )
784 ImplAssignWithSize( aNewBmp );
785 }
786 }
787
788 return bRet;
789 };
790
791 bool Bitmap::CopyPixel( const Rectangle& rRectDst,
792 const Rectangle& rRectSrc, const Bitmap* pBmpSrc )
793 {
794 const Size aSizePix( GetSizePixel() );
795 Rectangle aRectDst( rRectDst );
796 bool bRet = false;
797
798 aRectDst.Intersection( Rectangle( Point(), aSizePix ) );
799
800 if( !aRectDst.IsEmpty() )
801 {
802 if( pBmpSrc && ( *pBmpSrc != *this ) )
803 {
804 Bitmap* pSrc = const_cast<Bitmap*>(pBmpSrc);
805 const Size aCopySizePix( pSrc->GetSizePixel() );
806 Rectangle aRectSrc( rRectSrc );
807 const sal_uInt16 nSrcBitCount = pBmpSrc->GetBitCount();
808 const sal_uInt16 nDstBitCount = GetBitCount();
809
810 if( nSrcBitCount > nDstBitCount )
811 {
812 long nNextIndex = 0L;
813
814 if( ( nSrcBitCount == 24 ) && ( nDstBitCount < 24 ) )
815 Convert( BMP_CONVERSION_24BIT );
816 else if( ( nSrcBitCount == 8 ) && ( nDstBitCount < 8 ) )
817 {
818 Convert( BMP_CONVERSION_8BIT_COLORS );
819 nNextIndex = 16;
820 }
821 else if( ( nSrcBitCount == 4 ) && ( nDstBitCount < 4 ) )
822 {
823 Convert( BMP_CONVERSION_4BIT_COLORS );
824 nNextIndex = 2;
825 }
826
827 if( nNextIndex )
828 {
829 BitmapReadAccess* pSrcAcc = pSrc->AcquireReadAccess();
830 BitmapWriteAccess* pDstAcc = AcquireWriteAccess();
831
832 if( pSrcAcc && pDstAcc )
833 {
834 const long nSrcCount = pDstAcc->GetPaletteEntryCount();
835 const long nDstCount = 1 << nDstBitCount;
836
837 for( long i = 0L; ( i < nSrcCount ) && ( nNextIndex < nSrcCount ); i++ )
838 {
839 const BitmapColor& rSrcCol = pSrcAcc->GetPaletteColor( (sal_uInt16) i );
840
841 bool bFound = false;
842
843 for( long j = 0L; j < nDstCount; j++ )
844 {
845 if( rSrcCol == pDstAcc->GetPaletteColor( (sal_uInt16) j ) )
846 {
847 bFound = true;
848 break;
849 }
850 }
851
852 if( !bFound )
853 pDstAcc->SetPaletteColor( (sal_uInt16) nNextIndex++, rSrcCol );
854 }
855 }
856
857 if( pSrcAcc )
858 ReleaseAccess( pSrcAcc );
859
860 if( pDstAcc )
861 ReleaseAccess( pDstAcc );
862 }
863 }
864
865 aRectSrc.Intersection( Rectangle( Point(), aCopySizePix ) );
866
867 if( !aRectSrc.IsEmpty() )
868 {
869 BitmapReadAccess* pReadAcc = pSrc->AcquireReadAccess();
870
871 if( pReadAcc )
872 {
873 BitmapWriteAccess* pWriteAcc = AcquireWriteAccess();
874
875 if( pWriteAcc )
876 {
877 const long nWidth = std::min( aRectSrc.GetWidth(), aRectDst.GetWidth() );
878 const long nHeight = std::min( aRectSrc.GetHeight(), aRectDst.GetHeight() );
879 const long nSrcEndX = aRectSrc.Left() + nWidth;
880 const long nSrcEndY = aRectSrc.Top() + nHeight;
881 long nDstY = aRectDst.Top();
882
883 if( pReadAcc->HasPalette() && pWriteAcc->HasPalette() )
884 {
885 const sal_uInt16 nCount = pReadAcc->GetPaletteEntryCount();
886 boost::scoped_array<sal_uInt8> pMap(new sal_uInt8[ nCount ]);
887
888 // Create index map for the color table, as the bitmap should be copied
889 // retaining it's color information relatively well
890 for( sal_uInt16 i = 0; i < nCount; i++ )
891 pMap[ i ] = (sal_uInt8) pWriteAcc->GetBestPaletteIndex( pReadAcc->GetPaletteColor( i ) );
892
893 for( long nSrcY = aRectSrc.Top(); nSrcY < nSrcEndY; nSrcY++, nDstY++ )
894 for( long nSrcX = aRectSrc.Left(), nDstX = aRectDst.Left(); nSrcX < nSrcEndX; nSrcX++, nDstX++ )
895 pWriteAcc->SetPixelIndex( nDstY, nDstX, pMap[ pReadAcc->GetPixelIndex( nSrcY, nSrcX ) ] );
896 }
897 else if( pReadAcc->HasPalette() )
898 {
899 for( long nSrcY = aRectSrc.Top(); nSrcY < nSrcEndY; nSrcY++, nDstY++ )
900 for( long nSrcX = aRectSrc.Left(), nDstX = aRectDst.Left(); nSrcX < nSrcEndX; nSrcX++, nDstX++ )
901 pWriteAcc->SetPixel( nDstY, nDstX, pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nSrcY, nSrcX ) ) );
902 }
903 else
904 for( long nSrcY = aRectSrc.Top(); nSrcY < nSrcEndY; nSrcY++, nDstY++ )
905 for( long nSrcX = aRectSrc.Left(), nDstX = aRectDst.Left(); nSrcX < nSrcEndX; nSrcX++, nDstX++ )
906 pWriteAcc->SetPixel( nDstY, nDstX, pReadAcc->GetPixel( nSrcY, nSrcX ) );
907
908 ReleaseAccess( pWriteAcc );
909 bRet = ( nWidth > 0L ) && ( nHeight > 0L );
910 }
911
912 ReleaseAccess( pReadAcc );
913 }
914 }
915 }
916 else
917 {
918 Rectangle aRectSrc( rRectSrc );
919
920 aRectSrc.Intersection( Rectangle( Point(), aSizePix ) );
921
922 if( !aRectSrc.IsEmpty() && ( aRectSrc != aRectDst ) )
923 {
924 BitmapWriteAccess* pWriteAcc = AcquireWriteAccess();
925
926 if( pWriteAcc )
927 {
928 const long nWidth = std::min( aRectSrc.GetWidth(), aRectDst.GetWidth() );
929 const long nHeight = std::min( aRectSrc.GetHeight(), aRectDst.GetHeight() );
930 const long nSrcX = aRectSrc.Left();
931 const long nSrcY = aRectSrc.Top();
932 const long nSrcEndX1 = nSrcX + nWidth - 1L;
933 const long nSrcEndY1 = nSrcY + nHeight - 1L;
934 const long nDstX = aRectDst.Left();
935 const long nDstY = aRectDst.Top();
936 const long nDstEndX1 = nDstX + nWidth - 1L;
937 const long nDstEndY1 = nDstY + nHeight - 1L;
938
939 if( ( nDstX <= nSrcX ) && ( nDstY <= nSrcY ) )
940 {
941 for( long nY = nSrcY, nYN = nDstY; nY <= nSrcEndY1; nY++, nYN++ )
942 for( long nX = nSrcX, nXN = nDstX; nX <= nSrcEndX1; nX++, nXN++ )
943 pWriteAcc->SetPixel( nYN, nXN, pWriteAcc->GetPixel( nY, nX ) );
944 }
945 else if( ( nDstX <= nSrcX ) && ( nDstY >= nSrcY ) )
946 {
947 for( long nY = nSrcEndY1, nYN = nDstEndY1; nY >= nSrcY; nY--, nYN-- )
948 for( long nX = nSrcX, nXN = nDstX; nX <= nSrcEndX1; nX++, nXN++ )
949 pWriteAcc->SetPixel( nYN, nXN, pWriteAcc->GetPixel( nY, nX ) );
950 }
951 else if( ( nDstX >= nSrcX ) && ( nDstY <= nSrcY ) )
952 {
953 for( long nY = nSrcY, nYN = nDstY; nY <= nSrcEndY1; nY++, nYN++ )
954 for( long nX = nSrcEndX1, nXN = nDstEndX1; nX >= nSrcX; nX--, nXN-- )
955 pWriteAcc->SetPixel( nYN, nXN, pWriteAcc->GetPixel( nY, nX ) );
956 }
957 else
958 {
959 for( long nY = nSrcEndY1, nYN = nDstEndY1; nY >= nSrcY; nY--, nYN-- )
960 for( long nX = nSrcEndX1, nXN = nDstEndX1; nX >= nSrcX; nX--, nXN-- )
961 pWriteAcc->SetPixel( nYN, nXN, pWriteAcc->GetPixel( nY, nX ) );
962 }
963
964 ReleaseAccess( pWriteAcc );
965 bRet = true;
966 }
967 }
968 }
969 }
970
971 return bRet;
972 }
973
974 bool Bitmap::CopyPixel_AlphaOptimized( const Rectangle& rRectDst, const Rectangle& rRectSrc,
975 const Bitmap* pBmpSrc )
976 {
977 // Note: this code is copied from Bitmap::CopyPixel but avoids any palette lookups
978 // This optimization is possible because the palettes of AlphaMasks are always identical (8bit GreyPalette, see ctor)
979 const Size aSizePix( GetSizePixel() );
980 Rectangle aRectDst( rRectDst );
981 bool bRet = false;
982
983 aRectDst.Intersection( Rectangle( Point(), aSizePix ) );
984
985 if( !aRectDst.IsEmpty() )
986 {
987 if( pBmpSrc && ( *pBmpSrc != *this ) )
988 {
989 Bitmap* pSrc = const_cast<Bitmap*>(pBmpSrc);
990 const Size aCopySizePix( pSrc->GetSizePixel() );
991 Rectangle aRectSrc( rRectSrc );
992
993 aRectSrc.Intersection( Rectangle( Point(), aCopySizePix ) );
994
995 if( !aRectSrc.IsEmpty() )
996 {
997 BitmapReadAccess* pReadAcc = pSrc->AcquireReadAccess();
998
999 if( pReadAcc )
1000 {
1001 BitmapWriteAccess* pWriteAcc = AcquireWriteAccess();
1002
1003 if( pWriteAcc )
1004 {
1005 const long nWidth = std::min( aRectSrc.GetWidth(), aRectDst.GetWidth() );
1006 const long nHeight = std::min( aRectSrc.GetHeight(), aRectDst.GetHeight() );
1007 const long nSrcEndX = aRectSrc.Left() + nWidth;
1008 const long nSrcEndY = aRectSrc.Top() + nHeight;
1009 long nDstY = aRectDst.Top();
1010
1011 for( long nSrcY = aRectSrc.Top(); nSrcY < nSrcEndY; nSrcY++, nDstY++ )
1012 for( long nSrcX = aRectSrc.Left(), nDstX = aRectDst.Left(); nSrcX < nSrcEndX; nSrcX++, nDstX++ )
1013 pWriteAcc->SetPixel( nDstY, nDstX, pReadAcc->GetPixel( nSrcY, nSrcX ) );
1014
1015 ReleaseAccess( pWriteAcc );
1016 bRet = ( nWidth > 0L ) && ( nHeight > 0L );
1017 }
1018
1019 ReleaseAccess( pReadAcc );
1020 }
1021 }
1022 }
1023 else
1024 {
1025 Rectangle aRectSrc( rRectSrc );
1026
1027 aRectSrc.Intersection( Rectangle( Point(), aSizePix ) );
1028
1029 if( !aRectSrc.IsEmpty() && ( aRectSrc != aRectDst ) )
1030 {
1031 BitmapWriteAccess* pWriteAcc = AcquireWriteAccess();
1032
1033 if( pWriteAcc )
1034 {
1035 const long nWidth = std::min( aRectSrc.GetWidth(), aRectDst.GetWidth() );
1036 const long nHeight = std::min( aRectSrc.GetHeight(), aRectDst.GetHeight() );
1037 const long nSrcX = aRectSrc.Left();
1038 const long nSrcY = aRectSrc.Top();
1039 const long nSrcEndX1 = nSrcX + nWidth - 1L;
1040 const long nSrcEndY1 = nSrcY + nHeight - 1L;
1041 const long nDstX = aRectDst.Left();
1042 const long nDstY = aRectDst.Top();
1043 const long nDstEndX1 = nDstX + nWidth - 1L;
1044 const long nDstEndY1 = nDstY + nHeight - 1L;
1045
1046 if( ( nDstX <= nSrcX ) && ( nDstY <= nSrcY ) )
1047 {
1048 for( long nY = nSrcY, nYN = nDstY; nY <= nSrcEndY1; nY++, nYN++ )
1049 for( long nX = nSrcX, nXN = nDstX; nX <= nSrcEndX1; nX++, nXN++ )
1050 pWriteAcc->SetPixel( nYN, nXN, pWriteAcc->GetPixel( nY, nX ) );
1051 }
1052 else if( ( nDstX <= nSrcX ) && ( nDstY >= nSrcY ) )
1053 {
1054 for( long nY = nSrcEndY1, nYN = nDstEndY1; nY >= nSrcY; nY--, nYN-- )
1055 for( long nX = nSrcX, nXN = nDstX; nX <= nSrcEndX1; nX++, nXN++ )
1056 pWriteAcc->SetPixel( nYN, nXN, pWriteAcc->GetPixel( nY, nX ) );
1057 }
1058 else if( ( nDstX >= nSrcX ) && ( nDstY <= nSrcY ) )
1059 {
1060 for( long nY = nSrcY, nYN = nDstY; nY <= nSrcEndY1; nY++, nYN++ )
1061 for( long nX = nSrcEndX1, nXN = nDstEndX1; nX >= nSrcX; nX--, nXN-- )
1062 pWriteAcc->SetPixel( nYN, nXN, pWriteAcc->GetPixel( nY, nX ) );
1063 }
1064 else
1065 {
1066 for( long nY = nSrcEndY1, nYN = nDstEndY1; nY >= nSrcY; nY--, nYN-- )
1067 for( long nX = nSrcEndX1, nXN = nDstEndX1; nX >= nSrcX; nX--, nXN-- )
1068 pWriteAcc->SetPixel( nYN, nXN, pWriteAcc->GetPixel( nY, nX ) );
1069 }
1070
1071 ReleaseAccess( pWriteAcc );
1072 bRet = true;
1073 }
1074 }
1075 }
1076 }
1077
1078 return bRet;
1079
1080 }
1081
1082 bool Bitmap::Expand( sal_uLong nDX, sal_uLong nDY, const Color* pInitColor )
1083 {
1084 bool bRet = false;
1085
1086 if( nDX || nDY )
1087 {
1088 const Size aSizePixel( GetSizePixel() );
1089 const long nWidth = aSizePixel.Width();
1090 const long nHeight = aSizePixel.Height();
1091 const Size aNewSize( nWidth + nDX, nHeight + nDY );
1092 BitmapReadAccess* pReadAcc = AcquireReadAccess();
1093
1094 if( pReadAcc )
1095 {
1096 BitmapPalette aBmpPal( pReadAcc->GetPalette() );
1097 Bitmap aNewBmp( aNewSize, GetBitCount(), &aBmpPal );
1098 BitmapWriteAccess* pWriteAcc = aNewBmp.AcquireWriteAccess();
1099
1100 if( pWriteAcc )
1101 {
1102 BitmapColor aColor;
1103 const long nNewX = nWidth;
1104 const long nNewY = nHeight;
1105 const long nNewWidth = pWriteAcc->Width();
1106 const long nNewHeight = pWriteAcc->Height();
1107 long nX;
1108 long nY;
1109
1110 if( pInitColor )
1111 aColor = pWriteAcc->GetBestMatchingColor( *pInitColor );
1112
1113 for( nY = 0L; nY < nHeight; nY++ )
1114 {
1115 pWriteAcc->CopyScanline( nY, *pReadAcc );
1116
1117 if( pInitColor && nDX )
1118 for( nX = nNewX; nX < nNewWidth; nX++ )
1119 pWriteAcc->SetPixel( nY, nX, aColor );
1120 }
1121
1122 if( pInitColor && nDY )
1123 for( nY = nNewY; nY < nNewHeight; nY++ )
1124 for( nX = 0; nX < nNewWidth; nX++ )
1125 pWriteAcc->SetPixel( nY, nX, aColor );
1126
1127 ReleaseAccess( pWriteAcc );
1128 bRet = true;
1129 }
1130
1131 ReleaseAccess( pReadAcc );
1132
1133 if( bRet )
1134 ImplAssignWithSize( aNewBmp );
1135 }
1136 }
1137
1138 return bRet;
1139 }
1140
1141 Bitmap Bitmap::CreateMask( const Color& rTransColor, sal_uLong nTol ) const
1142 {
1143 Bitmap aNewBmp( GetSizePixel(), 1 );
1144 BitmapWriteAccess* pWriteAcc = aNewBmp.AcquireWriteAccess();
1145 bool bRet = false;
1146
1147 if( pWriteAcc )
1148 {
1149 BitmapReadAccess* pReadAcc = const_cast<Bitmap*>(this)->AcquireReadAccess();
1150
1151 if( pReadAcc )
1152 {
1153 const long nWidth = pReadAcc->Width();
1154 const long nHeight = pReadAcc->Height();
1155 const BitmapColor aBlack( pWriteAcc->GetBestMatchingColor( Color( COL_BLACK ) ) );
1156 const BitmapColor aWhite( pWriteAcc->GetBestMatchingColor( Color( COL_WHITE ) ) );
1157
1158 if( !nTol )
1159 {
1160 const BitmapColor aTest( pReadAcc->GetBestMatchingColor( rTransColor ) );
1161 long nX, nY;
1162
1163 if( pReadAcc->GetScanlineFormat() == BMP_FORMAT_4BIT_MSN_PAL ||
1164 pReadAcc->GetScanlineFormat() == BMP_FORMAT_4BIT_LSN_PAL )
1165 {
1166 // optimized for 4Bit-MSN/LSN source palette
1167 const sal_uInt8 cTest = aTest.GetIndex();
1168 const long nShiftInit = ( ( pReadAcc->GetScanlineFormat() == BMP_FORMAT_4BIT_MSN_PAL ) ? 4 : 0 );
1169
1170 if( pWriteAcc->GetScanlineFormat() == BMP_FORMAT_1BIT_MSB_PAL &&
1171 aWhite.GetIndex() == 1 )
1172 {
1173 // optimized for 1Bit-MSB destination palette
1174 for( nY = 0L; nY < nHeight; nY++ )
1175 {
1176 Scanline pSrc = pReadAcc->GetScanline( nY );
1177 Scanline pDst = pWriteAcc->GetScanline( nY );
1178 long nShift = 0;
1179 for( nX = 0L, nShift = nShiftInit; nX < nWidth; nX++, nShift ^= 4 )
1180 {
1181 if( cTest == ( ( pSrc[ nX >> 1 ] >> nShift ) & 0x0f ) )
1182 pDst[ nX >> 3 ] |= 1 << ( 7 - ( nX & 7 ) );
1183 else
1184 pDst[ nX >> 3 ] &= ~( 1 << ( 7 - ( nX & 7 ) ) );
1185 }
1186 }
1187 }
1188 else
1189 {
1190 for( nY = 0L; nY < nHeight; nY++ )
1191 {
1192 Scanline pSrc = pReadAcc->GetScanline( nY );
1193 long nShift = 0;
1194 for( nX = 0L, nShift = nShiftInit; nX < nWidth; nX++, nShift ^= 4 )
1195 {
1196 if( cTest == ( ( pSrc[ nX >> 1 ] >> nShift ) & 0x0f ) )
1197 pWriteAcc->SetPixel( nY, nX, aWhite );
1198 else
1199 pWriteAcc->SetPixel( nY, nX, aBlack );
1200 }
1201 }
1202 }
1203 }
1204 else if( pReadAcc->GetScanlineFormat() == BMP_FORMAT_8BIT_PAL )
1205 {
1206 // optimized for 8Bit source palette
1207 const sal_uInt8 cTest = aTest.GetIndex();
1208
1209 if( pWriteAcc->GetScanlineFormat() == BMP_FORMAT_1BIT_MSB_PAL &&
1210 aWhite.GetIndex() == 1 )
1211 {
1212 // optimized for 1Bit-MSB destination palette
1213 for( nY = 0L; nY < nHeight; nY++ )
1214 {
1215 Scanline pSrc = pReadAcc->GetScanline( nY );
1216 Scanline pDst = pWriteAcc->GetScanline( nY );
1217 for( nX = 0L; nX < nWidth; nX++ )
1218 {
1219 if( cTest == pSrc[ nX ] )
1220 pDst[ nX >> 3 ] |= 1 << ( 7 - ( nX & 7 ) );
1221 else
1222 pDst[ nX >> 3 ] &= ~( 1 << ( 7 - ( nX & 7 ) ) );
1223 }
1224 }
1225 }
1226 else
1227 {
1228 for( nY = 0L; nY < nHeight; nY++ )
1229 {
1230 Scanline pSrc = pReadAcc->GetScanline( nY );
1231 for( nX = 0L; nX < nWidth; nX++ )
1232 {
1233 if( cTest == pSrc[ nX ] )
1234 pWriteAcc->SetPixel( nY, nX, aWhite );
1235 else
1236 pWriteAcc->SetPixel( nY, nX, aBlack );
1237 }
1238 }
1239 }
1240 }
1241 else
1242 {
1243 // not optimized
1244 for( nY = 0L; nY < nHeight; nY++ )
1245 {
1246 for( nX = 0L; nX < nWidth; nX++ )
1247 {
1248 if( aTest == pReadAcc->GetPixel( nY, nX ) )
1249 pWriteAcc->SetPixel( nY, nX, aWhite );
1250 else
1251 pWriteAcc->SetPixel( nY, nX, aBlack );
1252 }
1253 }
1254 }
1255 }
1256 else
1257 {
1258 BitmapColor aCol;
1259 long nR, nG, nB;
1260 const long nMinR = MinMax( (long) rTransColor.GetRed() - nTol, 0, 255 );
1261 const long nMaxR = MinMax( (long) rTransColor.GetRed() + nTol, 0, 255 );
1262 const long nMinG = MinMax( (long) rTransColor.GetGreen() - nTol, 0, 255 );
1263 const long nMaxG = MinMax( (long) rTransColor.GetGreen() + nTol, 0, 255 );
1264 const long nMinB = MinMax( (long) rTransColor.GetBlue() - nTol, 0, 255 );
1265 const long nMaxB = MinMax( (long) rTransColor.GetBlue() + nTol, 0, 255 );
1266
1267 if( pReadAcc->HasPalette() )
1268 {
1269 for( long nY = 0L; nY < nHeight; nY++ )
1270 {
1271 for( long nX = 0L; nX < nWidth; nX++ )
1272 {
1273 aCol = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, nX ) );
1274 nR = aCol.GetRed();
1275 nG = aCol.GetGreen();
1276 nB = aCol.GetBlue();
1277
1278 if( nMinR <= nR && nMaxR >= nR &&
1279 nMinG <= nG && nMaxG >= nG &&
1280 nMinB <= nB && nMaxB >= nB )
1281 {
1282 pWriteAcc->SetPixel( nY, nX, aWhite );
1283 }
1284 else
1285 pWriteAcc->SetPixel( nY, nX, aBlack );
1286 }
1287 }
1288 }
1289 else
1290 {
1291 for( long nY = 0L; nY < nHeight; nY++ )
1292 {
1293 for( long nX = 0L; nX < nWidth; nX++ )
1294 {
1295 aCol = pReadAcc->GetPixel( nY, nX );
1296 nR = aCol.GetRed();
1297 nG = aCol.GetGreen();
1298 nB = aCol.GetBlue();
1299
1300 if( nMinR <= nR && nMaxR >= nR &&
1301 nMinG <= nG && nMaxG >= nG &&
1302 nMinB <= nB && nMaxB >= nB )
1303 {
1304 pWriteAcc->SetPixel( nY, nX, aWhite );
1305 }
1306 else
1307 pWriteAcc->SetPixel( nY, nX, aBlack );
1308 }
1309 }
1310 }
1311 }
1312
1313 ReleaseAccess( pReadAcc );
1314 bRet = true;
1315 }
1316
1317 ReleaseAccess( pWriteAcc );
1318 }
1319
1320 if( bRet )
1321 {
1322 aNewBmp.maPrefSize = maPrefSize;
1323 aNewBmp.maPrefMapMode = maPrefMapMode;
1324 }
1325 else
1326 aNewBmp = Bitmap();
1327
1328 return aNewBmp;
1329 }
1330
1331 vcl::Region Bitmap::CreateRegion( const Color& rColor, const Rectangle& rRect ) const
1332 {
1333 vcl::Region aRegion;
1334 Rectangle aRect( rRect );
1335 BitmapReadAccess* pReadAcc = const_cast<Bitmap*>(this)->AcquireReadAccess();
1336
1337 aRect.Intersection( Rectangle( Point(), GetSizePixel() ) );
1338 aRect.Justify();
1339
1340 if( pReadAcc )
1341 {
1342 //Rectangle aSubRect;
1343 const long nLeft = aRect.Left();
1344 const long nTop = aRect.Top();
1345 const long nRight = aRect.Right();
1346 const long nBottom = aRect.Bottom();
1347 const BitmapColor aMatch( pReadAcc->GetBestMatchingColor( rColor ) );
1348
1349 //RectangleVector aRectangles;
1350 //aRegion.ImplBeginAddRect();
1351 std::vector< long > aLine;
1352 long nYStart(nTop);
1353 long nY(nTop);
1354
1355 for( ; nY <= nBottom; nY++ )
1356 {
1357 //aSubRect.Top() = aSubRect.Bottom() = nY;
1358 std::vector< long > aNewLine;
1359 long nX(nLeft);
1360
1361 for( ; nX <= nRight; )
1362 {
1363 while( ( nX <= nRight ) && ( aMatch != pReadAcc->GetPixel( nY, nX ) ) )
1364 nX++;
1365
1366 if( nX <= nRight )
1367 {
1368 aNewLine.push_back(nX);
1369 //aSubRect.Left() = nX;
1370
1371 while( ( nX <= nRight ) && ( aMatch == pReadAcc->GetPixel( nY, nX ) ) )
1372 nX++;
1373
1374 //aSubRect.Right() = nX - 1L;
1375 aNewLine.push_back(nX - 1);
1376
1377 //aRegion.ImplAddRect( aSubRect );
1378 //aRectangles.push_back(aSubRect);
1379 //aRegion.Union(aSubRect);
1380 }
1381 }
1382
1383 if(aNewLine != aLine)
1384 {
1385 // need to write aLine, it's different from the next line
1386 if(aLine.size())
1387 {
1388 Rectangle aSubRect;
1389
1390 // enter y values and proceed ystart
1391 aSubRect.Top() = nYStart;
1392 aSubRect.Bottom() = nY ? nY - 1 : 0;
1393
1394 for(sal_uInt32 a(0); a < aLine.size();)
1395 {
1396 aSubRect.Left() = aLine[a++];
1397 aSubRect.Right() = aLine[a++];
1398 aRegion.Union(aSubRect);
1399 }
1400 }
1401
1402 // copy line as new line
1403 aLine = aNewLine;
1404 nYStart = nY;
1405 }
1406 }
1407
1408 // write last line if used
1409 if(aLine.size())
1410 {
1411 Rectangle aSubRect;
1412
1413 // enter y values
1414 aSubRect.Top() = nYStart;
1415 aSubRect.Bottom() = nY ? nY - 1 : 0;
1416
1417 for(sal_uInt32 a(0); a < aLine.size();)
1418 {
1419 aSubRect.Left() = aLine[a++];
1420 aSubRect.Right() = aLine[a++];
1421 aRegion.Union(aSubRect);
1422 }
1423 }
1424
1425 //aRegion.ImplEndAddRect();
1426 //aRegion.SetRegionRectangles(aRectangles);
1427
1428 ReleaseAccess( pReadAcc );
1429 }
1430 else
1431 aRegion = aRect;
1432
1433 return aRegion;
1434 }
1435
1436 bool Bitmap::Replace( const Bitmap& rMask, const Color& rReplaceColor )
1437 {
1438 BitmapReadAccess* pMaskAcc = ( (Bitmap&) rMask ).AcquireReadAccess();
1439 BitmapWriteAccess* pAcc = AcquireWriteAccess();
1440 bool bRet = false;
1441
1442 if( pMaskAcc && pAcc )
1443 {
1444 const long nWidth = std::min( pMaskAcc->Width(), pAcc->Width() );
1445 const long nHeight = std::min( pMaskAcc->Height(), pAcc->Height() );
1446 const BitmapColor aMaskWhite( pMaskAcc->GetBestMatchingColor( Color( COL_WHITE ) ) );
1447 BitmapColor aReplace;
1448
1449 if( pAcc->HasPalette() )
1450 {
1451 const sal_uInt16 nActColors = pAcc->GetPaletteEntryCount();
1452 const sal_uInt16 nMaxColors = 1 << pAcc->GetBitCount();
1453
1454 // default to the nearest color
1455 aReplace = pAcc->GetBestMatchingColor( rReplaceColor );
1456
1457 // for paletted images without a matching palette entry
1458 // look for an unused palette entry (NOTE: expensive!)
1459 if( pAcc->GetPaletteColor( aReplace.GetIndex() ) != BitmapColor( rReplaceColor ) )
1460 {
1461 // if the palette has empty entries use the last one
1462 if( nActColors < nMaxColors )
1463 {
1464 pAcc->SetPaletteEntryCount( nActColors + 1 );
1465 pAcc->SetPaletteColor( nActColors, rReplaceColor );
1466 aReplace = BitmapColor( (sal_uInt8) nActColors );
1467 }
1468 else
1469 {
1470 boost::scoped_array<bool> pFlags(new bool[ nMaxColors ]);
1471
1472 // Set all entries to false
1473 std::fill( pFlags.get(), pFlags.get()+nMaxColors, false );
1474
1475 for( long nY = 0L; nY < nHeight; nY++ )
1476 for( long nX = 0L; nX < nWidth; nX++ )
1477 pFlags[ pAcc->GetPixelIndex( nY, nX ) ] = true;
1478
1479 for( sal_uInt16 i = 0UL; i < nMaxColors; i++ )
1480 {
1481 // Hurray, we do have an unsused entry
1482 if( !pFlags[ i ] )
1483 {
1484 pAcc->SetPaletteColor( (sal_uInt16) i, rReplaceColor );
1485 aReplace = BitmapColor( (sal_uInt8) i );
1486 }
1487 }
1488 }
1489 }
1490 }
1491 else
1492 aReplace = rReplaceColor;
1493
1494 for( long nY = 0L; nY < nHeight; nY++ )
1495 for( long nX = 0L; nX < nWidth; nX++ )
1496 if( pMaskAcc->GetPixel( nY, nX ) == aMaskWhite )
1497 pAcc->SetPixel( nY, nX, aReplace );
1498
1499 bRet = true;
1500 }
1501
1502 ReleaseAccess( pMaskAcc );
1503 ReleaseAccess( pAcc );
1504
1505 return bRet;
1506 }
1507
1508 bool Bitmap::Replace( const AlphaMask& rAlpha, const Color& rMergeColor )
1509 {
1510 Bitmap aNewBmp( GetSizePixel(), 24 );
1511 BitmapReadAccess* pAcc = AcquireReadAccess();
1512 BitmapReadAccess* pAlphaAcc = ( (AlphaMask&) rAlpha ).AcquireReadAccess();
1513 BitmapWriteAccess* pNewAcc = aNewBmp.AcquireWriteAccess();
1514 bool bRet = false;
1515
1516 if( pAcc && pAlphaAcc && pNewAcc )
1517 {
1518 BitmapColor aCol;
1519 const long nWidth = std::min( pAlphaAcc->Width(), pAcc->Width() );
1520 const long nHeight = std::min( pAlphaAcc->Height(), pAcc->Height() );
1521
1522 for( long nY = 0L; nY < nHeight; nY++ )
1523 {
1524 for( long nX = 0L; nX < nWidth; nX++ )
1525 {
1526 aCol = pAcc->GetColor( nY, nX );
1527 pNewAcc->SetPixel( nY, nX, aCol.Merge( rMergeColor, 255 - pAlphaAcc->GetPixelIndex( nY, nX ) ) );
1528 }
1529 }
1530
1531 bRet = true;
1532 }
1533
1534 ReleaseAccess( pAcc );
1535 ReleaseAccess( pAlphaAcc );
1536 ReleaseAccess( pNewAcc );
1537
1538 if( bRet )
1539 {
1540 const MapMode aMap( maPrefMapMode );
1541 const Size aSize( maPrefSize );
1542
1543 *this = aNewBmp;
1544
1545 maPrefMapMode = aMap;
1546 maPrefSize = aSize;
1547 }
1548
1549 return bRet;
1550 }
1551
1552 bool Bitmap::Replace( const Color& rSearchColor, const Color& rReplaceColor, sal_uLong nTol )
1553 {
1554 if( mpImpBmp )
1555 {
1556 // implementation specific replace
1557 ImpBitmap* pImpBmp = new ImpBitmap;
1558
1559 if( pImpBmp->ImplCreate( *mpImpBmp ) && pImpBmp->ImplReplace( rSearchColor, rReplaceColor, nTol ) )
1560 {
1561 ImplSetImpBitmap( pImpBmp );
1562 maPrefMapMode = MapMode( MAP_PIXEL );
1563 maPrefSize = pImpBmp->ImplGetSize();
1564 return true;
1565 }
1566 else
1567 {
1568 delete pImpBmp;
1569 }
1570 }
1571
1572 // Bitmaps with 1 bit color depth can cause problems
1573 // if they have other entries than black/white in their palette
1574 if( 1 == GetBitCount() )
1575 Convert( BMP_CONVERSION_4BIT_COLORS );
1576
1577 BitmapWriteAccess* pAcc = AcquireWriteAccess();
1578 bool bRet = false;
1579
1580 if( pAcc )
1581 {
1582 const long nMinR = MinMax( (long) rSearchColor.GetRed() - nTol, 0, 255 );
1583 const long nMaxR = MinMax( (long) rSearchColor.GetRed() + nTol, 0, 255 );
1584 const long nMinG = MinMax( (long) rSearchColor.GetGreen() - nTol, 0, 255 );
1585 const long nMaxG = MinMax( (long) rSearchColor.GetGreen() + nTol, 0, 255 );
1586 const long nMinB = MinMax( (long) rSearchColor.GetBlue() - nTol, 0, 255 );
1587 const long nMaxB = MinMax( (long) rSearchColor.GetBlue() + nTol, 0, 255 );
1588
1589 if( pAcc->HasPalette() )
1590 {
1591 for( sal_uInt16 i = 0, nPalCount = pAcc->GetPaletteEntryCount(); i < nPalCount; i++ )
1592 {
1593 const BitmapColor& rCol = pAcc->GetPaletteColor( i );
1594
1595 if( nMinR <= rCol.GetRed() && nMaxR >= rCol.GetRed() &&
1596 nMinG <= rCol.GetGreen() && nMaxG >= rCol.GetGreen() &&
1597 nMinB <= rCol.GetBlue() && nMaxB >= rCol.GetBlue() )
1598 {
1599 pAcc->SetPaletteColor( i, rReplaceColor );
1600 }
1601 }
1602 }
1603 else
1604 {
1605 BitmapColor aCol;
1606 const BitmapColor aReplace( pAcc->GetBestMatchingColor( rReplaceColor ) );
1607
1608 for( long nY = 0L, nHeight = pAcc->Height(); nY < nHeight; nY++ )
1609 {
1610 for( long nX = 0L, nWidth = pAcc->Width(); nX < nWidth; nX++ )
1611 {
1612 aCol = pAcc->GetPixel( nY, nX );
1613
1614 if( nMinR <= aCol.GetRed() && nMaxR >= aCol.GetRed() &&
1615 nMinG <= aCol.GetGreen() && nMaxG >= aCol.GetGreen() &&
1616 nMinB <= aCol.GetBlue() && nMaxB >= aCol.GetBlue() )
1617 {
1618 pAcc->SetPixel( nY, nX, aReplace );
1619 }
1620 }
1621 }
1622 }
1623
1624 ReleaseAccess( pAcc );
1625 bRet = true;
1626 }
1627
1628 return bRet;
1629 }
1630
1631 bool Bitmap::Replace( const Color* pSearchColors, const Color* pReplaceColors,
1632 sal_uLong nColorCount, sal_uLong* _pTols )
1633 {
1634 // Bitmaps with 1 bit color depth can cause problems
1635 // if they have other entries than black/white in their palette
1636 if( 1 == GetBitCount() )
1637 Convert( BMP_CONVERSION_4BIT_COLORS );
1638
1639 BitmapWriteAccess* pAcc = AcquireWriteAccess();
1640 bool bRet = false;
1641
1642 if( pAcc )
1643 {
1644 boost::scoped_array<long> pMinR(new long[ nColorCount ]);
1645 boost::scoped_array<long> pMaxR(new long[ nColorCount ]);
1646 boost::scoped_array<long> pMinG(new long[ nColorCount ]);
1647 boost::scoped_array<long> pMaxG(new long[ nColorCount ]);
1648 boost::scoped_array<long> pMinB(new long[ nColorCount ]);
1649 boost::scoped_array<long> pMaxB(new long[ nColorCount ]);
1650 long* pTols;
1651 sal_uLong i;
1652
1653 if( !_pTols )
1654 {
1655 pTols = new long[ nColorCount ];
1656 memset( pTols, 0, nColorCount * sizeof( long ) );
1657 }
1658 else
1659 pTols = reinterpret_cast<long*>(_pTols);
1660
1661 for( i = 0UL; i < nColorCount; i++ )
1662 {
1663 const Color& rCol = pSearchColors[ i ];
1664 const long nTol = pTols[ i ];
1665
1666 pMinR[ i ] = MinMax( (long) rCol.GetRed() - nTol, 0, 255 );
1667 pMaxR[ i ] = MinMax( (long) rCol.GetRed() + nTol, 0, 255 );
1668 pMinG[ i ] = MinMax( (long) rCol.GetGreen() - nTol, 0, 255 );
1669 pMaxG[ i ] = MinMax( (long) rCol.GetGreen() + nTol, 0, 255 );
1670 pMinB[ i ] = MinMax( (long) rCol.GetBlue() - nTol, 0, 255 );
1671 pMaxB[ i ] = MinMax( (long) rCol.GetBlue() + nTol, 0, 255 );
1672 }
1673
1674 if( pAcc->HasPalette() )
1675 {
1676 for( sal_uInt16 nEntry = 0, nPalCount = pAcc->GetPaletteEntryCount(); nEntry < nPalCount; nEntry++ )
1677 {
1678 const BitmapColor& rCol = pAcc->GetPaletteColor( nEntry );
1679
1680 for( i = 0UL; i < nColorCount; i++ )
1681 {
1682 if( pMinR[ i ] <= rCol.GetRed() && pMaxR[ i ] >= rCol.GetRed() &&
1683 pMinG[ i ] <= rCol.GetGreen() && pMaxG[ i ] >= rCol.GetGreen() &&
1684 pMinB[ i ] <= rCol.GetBlue() && pMaxB[ i ] >= rCol.GetBlue() )
1685 {
1686 pAcc->SetPaletteColor( (sal_uInt16)nEntry, pReplaceColors[ i ] );
1687 break;
1688 }
1689 }
1690 }
1691 }
1692 else
1693 {
1694 BitmapColor aCol;
1695 boost::scoped_array<BitmapColor> pReplaces(new BitmapColor[ nColorCount ]);
1696
1697 for( i = 0UL; i < nColorCount; i++ )
1698 pReplaces[ i ] = pAcc->GetBestMatchingColor( pReplaceColors[ i ] );
1699
1700 for( long nY = 0L, nHeight = pAcc->Height(); nY < nHeight; nY++ )
1701 {
1702 for( long nX = 0L, nWidth = pAcc->Width(); nX < nWidth; nX++ )
1703 {
1704 aCol = pAcc->GetPixel( nY, nX );
1705
1706 for( i = 0UL; i < nColorCount; i++ )
1707 {
1708 if( pMinR[ i ] <= aCol.GetRed() && pMaxR[ i ] >= aCol.GetRed() &&
1709 pMinG[ i ] <= aCol.GetGreen() && pMaxG[ i ] >= aCol.GetGreen() &&
1710 pMinB[ i ] <= aCol.GetBlue() && pMaxB[ i ] >= aCol.GetBlue() )
1711 {
1712 pAcc->SetPixel( nY, nX, pReplaces[ i ] );
1713 break;
1714 }
1715 }
1716 }
1717 }
1718 }
1719
1720 if( !_pTols )
1721 delete[] pTols;
1722
1723 ReleaseAccess( pAcc );
1724 bRet = true;
1725 }
1726
1727 return bRet;
1728 }
1729
1730 Bitmap Bitmap::CreateDisplayBitmap( OutputDevice* pDisplay )
1731 {
1732 Bitmap aDispBmp( *this );
1733
1734 SalGraphics* pDispGraphics = pDisplay->GetGraphics();
1735
1736 if( mpImpBmp && pDispGraphics )
1737 {
1738 ImpBitmap* pImpDispBmp = new ImpBitmap;
1739
1740 if( pImpDispBmp->ImplCreate( *mpImpBmp, pDispGraphics ) )
1741 aDispBmp.ImplSetImpBitmap( pImpDispBmp );
1742 else
1743 delete pImpDispBmp;
1744 }
1745
1746 return aDispBmp;
1747 }
1748
1749 bool Bitmap::CombineSimple( const Bitmap& rMask, BmpCombine eCombine )
1750 {
1751 BitmapReadAccess* pMaskAcc = ( (Bitmap&) rMask ).AcquireReadAccess();
1752 BitmapWriteAccess* pAcc = AcquireWriteAccess();
1753 bool bRet = false;
1754
1755 if( pMaskAcc && pAcc )
1756 {
1757 const long nWidth = std::min( pMaskAcc->Width(), pAcc->Width() );
1758 const long nHeight = std::min( pMaskAcc->Height(), pAcc->Height() );
1759 const Color aColBlack( COL_BLACK );
1760 BitmapColor aPixel;
1761 BitmapColor aMaskPixel;
1762 const BitmapColor aWhite( pAcc->GetBestMatchingColor( Color( COL_WHITE ) ) );
1763 const BitmapColor aBlack( pAcc->GetBestMatchingColor( aColBlack ) );
1764 const BitmapColor aMaskBlack( pMaskAcc->GetBestMatchingColor( aColBlack ) );
1765
1766 switch( eCombine )
1767 {
1768 case( BMP_COMBINE_COPY ):
1769 {
1770 for( long nY = 0L; nY < nHeight; nY++ ) for( long nX = 0L; nX < nWidth; nX++ )
1771 {
1772 if( pMaskAcc->GetPixel( nY, nX ) == aMaskBlack )
1773 pAcc->SetPixel( nY, nX, aBlack );
1774 else
1775 pAcc->SetPixel( nY, nX, aWhite );
1776 }
1777 }
1778 break;
1779
1780 case( BMP_COMBINE_INVERT ):
1781 {
1782 for( long nY = 0L; nY < nHeight; nY++ ) for( long nX = 0L; nX < nWidth; nX++ )
1783 {
1784 if( pAcc->GetPixel( nY, nX ) == aBlack )
1785 pAcc->SetPixel( nY, nX, aWhite );
1786 else
1787 pAcc->SetPixel( nY, nX, aBlack );
1788 }
1789 }
1790 break;
1791
1792 case( BMP_COMBINE_AND ):
1793 {
1794 for( long nY = 0L; nY < nHeight; nY++ ) for( long nX = 0L; nX < nWidth; nX++ )
1795 {
1796 if( pMaskAcc->GetPixel( nY, nX ) != aMaskBlack && pAcc->GetPixel( nY, nX ) != aBlack )
1797 pAcc->SetPixel( nY, nX, aWhite );
1798 else
1799 pAcc->SetPixel( nY, nX, aBlack );
1800 }
1801 }
1802 break;
1803
1804 case( BMP_COMBINE_NAND ):
1805 {
1806 for( long nY = 0L; nY < nHeight; nY++ ) for( long nX = 0L; nX < nWidth; nX++ )
1807 {
1808 if( pMaskAcc->GetPixel( nY, nX ) != aMaskBlack && pAcc->GetPixel( nY, nX ) != aBlack )
1809 pAcc->SetPixel( nY, nX, aBlack );
1810 else
1811 pAcc->SetPixel( nY, nX, aWhite );
1812 }
1813 }
1814 break;
1815
1816 case( BMP_COMBINE_OR ):
1817 {
1818 for( long nY = 0L; nY < nHeight; nY++ ) for( long nX = 0L; nX < nWidth; nX++ )
1819 {
1820 if( pMaskAcc->GetPixel( nY, nX ) != aMaskBlack || pAcc->GetPixel( nY, nX ) != aBlack )
1821 pAcc->SetPixel( nY, nX, aWhite );
1822 else
1823 pAcc->SetPixel( nY, nX, aBlack );
1824 }
1825 }
1826 break;
1827
1828 case( BMP_COMBINE_NOR ):
1829 {
1830 for( long nY = 0L; nY < nHeight; nY++ ) for( long nX = 0L; nX < nWidth; nX++ )
1831 {
1832 if( pMaskAcc->GetPixel( nY, nX ) != aMaskBlack || pAcc->GetPixel( nY, nX ) != aBlack )
1833 pAcc->SetPixel( nY, nX, aBlack );
1834 else
1835 pAcc->SetPixel( nY, nX, aWhite );
1836 }
1837 }
1838 break;
1839
1840 case( BMP_COMBINE_XOR ):
1841 {
1842 for( long nY = 0L; nY < nHeight; nY++ ) for( long nX = 0L; nX < nWidth; nX++ )
1843 {
1844 aPixel = pAcc->GetPixel( nY, nX );
1845 aMaskPixel = pMaskAcc->GetPixel( nY, nX );
1846
1847 if( ( aMaskPixel != aMaskBlack && aPixel == aBlack ) ||
1848 ( aMaskPixel == aMaskBlack && aPixel != aBlack ) )
1849 {
1850 pAcc->SetPixel( nY, nX, aWhite );
1851 }
1852 else
1853 pAcc->SetPixel( nY, nX, aBlack );
1854 }
1855 }
1856 break;
1857
1858 case( BMP_COMBINE_NXOR ):
1859 {
1860 for( long nY = 0L; nY < nHeight; nY++ ) for( long nX = 0L; nX < nWidth; nX++ )
1861 {
1862 aPixel = pAcc->GetPixel( nY, nX );
1863 aMaskPixel = pMaskAcc->GetPixel( nY, nX );
1864
1865 if( ( aMaskPixel != aMaskBlack && aPixel == aBlack ) ||
1866 ( aMaskPixel == aMaskBlack && aPixel != aBlack ) )
1867 {
1868 pAcc->SetPixel( nY, nX, aBlack );
1869 }
1870 else
1871 pAcc->SetPixel( nY, nX, aWhite );
1872 }
1873 }
1874 break;
1875 }
1876
1877 bRet = true;
1878 }
1879
1880 ReleaseAccess( pMaskAcc );
1881 ReleaseAccess( pAcc );
1882
1883 return bRet;
1884 }
1885
1886 // TODO: Have a look at OutputDevice::ImplDrawAlpha() for some
1887 // optimizations. Might even consolidate the code here and there.
1888 bool Bitmap::Blend( const AlphaMask& rAlpha, const Color& rBackgroundColor )
1889 {
1890 // Convert to a truecolor bitmap, if we're a paletted one. There's
1891 // room for tradeoff decision here, maybe later for an overload (or a flag)
1892 if( GetBitCount() <= 8 )
1893 Convert( BMP_CONVERSION_24BIT );
1894
1895 BitmapReadAccess* pAlphaAcc = const_cast<AlphaMask&>(rAlpha).AcquireReadAccess();
1896 BitmapWriteAccess* pAcc = AcquireWriteAccess();
1897 bool bRet = false;
1898
1899 if( pAlphaAcc && pAcc )
1900 {
1901 const long nWidth = std::min( pAlphaAcc->Width(), pAcc->Width() );
1902 const long nHeight = std::min( pAlphaAcc->Height(), pAcc->Height() );
1903
1904 for( long nY = 0L; nY < nHeight; ++nY )
1905 for( long nX = 0L; nX < nWidth; ++nX )
1906 pAcc->SetPixel( nY, nX,
1907 pAcc->GetPixel( nY, nX ).Merge( rBackgroundColor,
1908 255 - pAlphaAcc->GetPixelIndex( nY, nX ) ) );
1909
1910 bRet = true;
1911 }
1912
1913 ReleaseAccess( pAlphaAcc );
1914 ReleaseAccess( pAcc );
1915
1916 return bRet;
1917 }
1918
1919 bool Bitmap::MakeMono( sal_uInt8 cThreshold )
1920 {
1921 return ImplMakeMono( cThreshold );
1922 }
1923
1924 bool Bitmap::GetSystemData( BitmapSystemData& rData ) const
1925 {
1926 bool bRet = false;
1927 if( mpImpBmp )
1928 {
1929 SalBitmap* pSalBitmap = mpImpBmp->ImplGetSalBitmap();
1930 if( pSalBitmap )
1931 bRet = pSalBitmap->GetSystemData( rData );
1932 }
1933
1934 return bRet;
1935 }
1936
1937 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE